/*

*

* $Id: basic.h,v 1.13 2023/07/16 14:17:08 stefan Exp stefan $

*

* Stefan's basic interpreter

*

* Playing around with frugal programming. See the licence file on

* https://github.com/slviajero/tinybasic for copyright/left.

* (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)

*

* Author: Stefan Lenz, sl001@serverfabrik.de

*

* basic.h are the core defintions and function protypes

*

*/

/*

* if the PROGMEM macro is define we compile on the Arduino IDE

* we undef all hardware settings otherwise a little odd

*/

#ifdef ARDUINO_ARCH_MBED

#define PROGMEM

#endif

#ifdef PROGMEM

#define ARDUINOPROGMEM

#else

#undef ARDUINO

#undef ARDUINOSD

#undef ARDUINORF24

#undef ARDUINORTC

#undef ARDUINOEEPROM

#undef ARDUINOEEPROMI2C

#undef ARDUINOWIRE

#endif

/*

* MSDOS, Mac, Linux and Windows

*/

#ifndef ARDUINO

typedef unsigned char uint8_t;

#define PROGMEM

#include <stdio.h>

#include <stdlib.h>

#ifdef HASFLOAT

#include <math.h>

#include <float.h>

#endif

#include <time.h>

#include <sys/types.h>

#include <sys/timeb.h>

#ifndef MSDOS

#include <dirent.h>

#include <unistd.h>

#else

#include <dir.h>

#include <dos.h>

#endif

#ifdef MINGW

#include <windows.h>

#endif

#endif

#if defined(ARDUINO_ARCH_AVR)

/* the small memory model with shallow stacks and small buffers */

#define BUFSIZE 80

#define STACKSIZE 15

#define GOSUBDEPTH 4

#define FORDEPTH 4

#define LINECACHESIZE 4

#else

/* the for larger microcontrollers */

#ifdef ARDUINO

#define BUFSIZE 128

#define STACKSIZE 64

#define GOSUBDEPTH 8

#define FORDEPTH 8

#define LINECACHESIZE 16

#else

/* for real computers */

#define BUFSIZE 256

#define STACKSIZE 256

#define GOSUBDEPTH 64

#define FORDEPTH 64

#define LINECACHESIZE 64

#endif

#endif

/* on the real small systems we remove the linecache and set a fixed memory size*/

#ifdef ARDUINO_AVR_DUEMILANOVE

#undef LINECACHESIZE

#if MEMSIZE == 0

#define MEMSIZE 512

#endif

#endif

/* more duffers and vars */

#define SBUFSIZE 32

#define VARSIZE 26

/* default sizes of arrays and strings if they are not DIMed */

#define ARRAYSIZEDEF 10

#define STRSIZEDEF 32

/*

* the time intervall in ms needed for

* ESP8266 yields, network client loops

* and other timing related functions

*/

#define LONGYIELDINTERVAL 1000

#define YIELDINTERVAL 32

#define YIELDTIME 2

/* the default EEPROM dummy size */

#define EEPROMSIZE 1024

/* after run behaviour on POSIX systems, 1 to terminate if started

on the command line with a file argument, 0 to stay active and

show a BASIC prompt*/

#define TERMINATEAFTERRUN 1

/*

* The tokens for the BASIC keywords

*

* All single character operators are their own tokens

* ASCII values above 0x7f are used for tokens of keywords.

* EOL is a token

*/

#define EOL 0

#define NUMBER -127

#define LINENUMBER -126

#define STRING -125

#define VARIABLE -124

#define STRINGVAR -123

#define ARRAYVAR -122

/* multi character tokens - BASEKEYWORD (3) */

#define GREATEREQUAL -121

#define LESSEREQUAL -120

#define NOTEQUAL -119

/* this is the Palo Alto Language Set (19) */

#define TPRINT -118

#define TLET -117

#define TINPUT -116

#define TGOTO -115

#define TGOSUB -114

#define TRETURN -113

#define TIF -112

#define TFOR -111

#define TTO -110

#define TSTEP -109

#define TNEXT -108

#define TSTOP -107

#define TLIST -106

#define TNEW -105

#define TRUN -104

#define TABS -103

#define TRND -102

#define TSIZE -101

#define TREM -100

/* this is the Apple 1 language set in addition to Palo Alto (14) */

#define TNOT -99

#define TAND -98

#define TOR -97

#define TLEN -96

#define TSGN -95

#define TPEEK -94

#define TDIM -93

#define TCLR -92

#define THIMEM -91

#define TTAB -90

#define TTHEN -89

#define TEND -88

#define TPOKE -87

/* Stefan's tinybasic additions (14) */

#define TCONT -86

#define TSQR -85

#define TPOW -84

#define TMAP -83

#define TDUMP -82

#define TBREAK -81

#define TSAVE -80

#define TLOAD -79

#define TGET -78

#define TPUT -77

#define TSET -76

#define TCLS -75

#define TLOCATE -74

#define TELSE -73

/* Arduino functions (10) */

#define TPINM -72

#define TDWRITE -71

#define TDREAD -70

#define TAWRITE -69

#define TAREAD -68

#define TDELAY -67

#define TMILLIS -66

#define TTONE -65

#define TPULSE -64

#define TAZERO -63

#define TLED -62

/* the DOS functions (5) */

#define TCATALOG -61

#define TDELETE -60

#define TOPEN -59

#define TCLOSE -58

#define TFDISK -57

/* low level access of internal routines (2) */

#define TUSR -56

#define TCALL -55

/* mathematical functions (7) */

#define TSIN -54

#define TCOS -53

#define TTAN -52

#define TATAN -51

#define TLOG -50

#define TEXP -49

#define TINT -48

/* graphics - experimental - rudimentary (7) */

#define TCOLOR -47

#define TPLOT -46

#define TLINE -45

#define TCIRCLE -44

#define TRECT -43

#define TFCIRCLE -42

#define TFRECT -41

/* the Dartmouth extensions (6) */

#define TDATA -40

#define TREAD -39

#define TRESTORE -38

#define TDEF -37

#define TFN -36

#define TON -35

/* darkarts (3) */

#define TMALLOC -34

#define TFIND -33

#define TEVAL -32

/* iot extensions (9) */

#define TERROR -31

#define TAVAIL -30

#define TSTR -29

#define TINSTR -28

#define TVAL -27

#define TNETSTAT -26

#define TSENSOR -25

#define TWIRE -24

#define TSLEEP -23

/* events and interrupts */

#define TAFTER -22

#define TEVERY -21

#define TEVENT -20

/* experimental structured commands, currently partially implemented */

#define TWHILE -19

#define TWEND -18

#define TREPEAT -17

#define TUNTIL -16

#define TSWITCH -15

#define TCASE -14

#define TSWEND -13

#define TDO -12

#define TDEND -11

/* these are multibyte token extension, currently unused */

/* using them would allow over 1000 BASIC keywords */

#define TEXT1 -3

/* end of tokens */

/* constants used for some obscure purposes */

#define TBUFFER -2

/* UNKNOWN is not used in the current code, the

* lexer tokenizes everything blindly. There is a UNKNOWN hook

* in statement for a grammar aware lexer */

#define UNKNOWN -1

/* extension tokens can be in the range from -128 to -255

* one needs to set HASLONGTOKENS

*/

#undef HASLONGTOKEN

#define TTOKEN1 -128

/* the number of keywords, and the base index of the keywords

* the number is irrelevant but BASEKEYWORD is used */

#define NKEYWORDS 3+19+13+14+11+5+2+7+7+6+12+3+9

#define BASEKEYWORD -121

/*

* Interpreter states

* SRUN means running from a programm

* SINT means interactive mode

* SERUN means running directly from EEPROM

* (enum would be the right way of doing this.)

* BREAKCHAR is the character stopping the program on Ardunios

* BREAKPIN can be set, it is a pin that needs to go to low to stop a BASIC program

* This should be done in hardware*.h

* BREAKSIGNAL can also be set, should be done in hardware*.h

*/

#define SINT 0

#define SRUN 1

#define SERUN 2

#define BREAKCHAR '#'

/*

* Input and output channels

*/

#define OSERIAL 1

#define ODSP 2

#define OPRT 4

#define OWIRE 7

#define ORADIO 8

#define OMQTT 9

#define OFILE 16

#define ISERIAL 1

#define IKEYBOARD 2

#define ISERIAL1 4

#define IWIRE 7

#define IRADIO 8

#define IMQTT 9

#define IFILE 16

/*

* All BASIC keywords for the tokens

*/

const char sge[] PROGMEM = "=>";

const char sle[] PROGMEM = "<=";

const char sne[] PROGMEM = "<>";

/* Palo Alto language set */

const char sprint[] PROGMEM = "PRINT";

const char slet[] PROGMEM = "LET";

const char sinput[] PROGMEM = "INPUT";

const char sgoto[] PROGMEM = "GOTO";

const char sgosub[] PROGMEM = "GOSUB";

const char sreturn[] PROGMEM = "RETURN";

const char sif[] PROGMEM = "IF";

const char sfor[] PROGMEM = "FOR";

const char sto[] PROGMEM = "TO";

const char sstep[] PROGMEM = "STEP";

const char snext[] PROGMEM = "NEXT";

const char sstop[] PROGMEM = "STOP";

const char slist[] PROGMEM = "LIST";

const char snew[] PROGMEM = "NEW";

const char srun[] PROGMEM = "RUN";

const char sabs[] PROGMEM = "ABS";

const char srnd[] PROGMEM = "RND";

const char ssize[] PROGMEM = "SIZE";

const char srem[] PROGMEM = "REM";

/* Apple 1 language set */

#ifdef HASAPPLE1

const char snot[] PROGMEM = "NOT";

const char sand[] PROGMEM = "AND";

const char sor[] PROGMEM = "OR";

const char slen[] PROGMEM = "LEN";

const char ssgn[] PROGMEM = "SGN";

const char speek[] PROGMEM = "PEEK";

const char sdim[] PROGMEM = "DIM";

const char sclr[] PROGMEM = "CLR";

const char shimem[] PROGMEM = "HIMEM";

const char stab[] PROGMEM = "TAB";

const char sthen[] PROGMEM = "THEN";

const char sbend[] PROGMEM = "END";

const char spoke[] PROGMEM = "POKE";

#endif

/* Stefan's basic additions */

#ifdef HASSTEFANSEXT

const char scont[] PROGMEM = "CONT";

const char ssqr[] PROGMEM = "SQR";

const char spow[] PROGMEM = "POW";

const char smap[] PROGMEM = "MAP";

const char sdump[] PROGMEM = "DUMP";

const char sbreak[] PROGMEM = "BREAK";

#endif

/* LOAD and SAVE is always there */

const char ssave[] PROGMEM = "SAVE";

const char sload[] PROGMEM = "LOAD";

#ifdef HASSTEFANSEXT

const char sget[] PROGMEM = "GET";

const char sput[] PROGMEM = "PUT";

const char sset[] PROGMEM = "SET";

const char scls[] PROGMEM = "CLS";

const char slocate[] PROGMEM = "LOCATE";

const char selse[] PROGMEM = "ELSE";

#endif

/* Arduino functions */

#ifdef HASARDUINOIO

const char spinm[] PROGMEM = "PINM";

const char sdwrite[] PROGMEM = "DWRITE";

const char sdread[] PROGMEM = "DREAD";

const char sawrite[] PROGMEM = "AWRITE";

const char saread[] PROGMEM = "AREAD";

const char sdelay[] PROGMEM = "DELAY";

const char smillis[] PROGMEM = "MILLIS";

const char sazero[] PROGMEM = "AZERO";

const char sled[] PROGMEM = "LED";

#endif

#ifdef HASTONE

const char stone[] PROGMEM = "PLAY";

#endif

#ifdef HASPULSE

const char spulse[] PROGMEM = "PULSE";

#endif

/* DOS functions */

#ifdef HASFILEIO

const char scatalog[] PROGMEM = "CATALOG";

const char sdelete[] PROGMEM = "DELETE";

const char sfopen[] PROGMEM = "OPEN";

const char sfclose[] PROGMEM = "CLOSE";

const char sfdisk[] PROGMEM = "FDISK";

#endif

/* low level access functions */

#ifdef HASSTEFANSEXT

const char susr[] PROGMEM = "USR";

const char scall[] PROGMEM = "CALL";

#endif

/* mathematics */

#ifdef HASFLOAT

const char ssin[] PROGMEM = "SIN";

const char scos[] PROGMEM = "COS";

const char stan[] PROGMEM = "TAN";

const char satan[] PROGMEM = "ATAN";

const char slog[] PROGMEM = "LOG";

const char sexp[] PROGMEM = "EXP";

#endif

/* INT is always needed to make float/int programs compatible */

const char sint[] PROGMEM = "INT";

/* elemetars graphics */

#ifdef HASGRAPH

const char scolor[] PROGMEM = "COLOR";

const char splot[] PROGMEM = "PLOT";

const char sline[] PROGMEM = "LINE";

const char scircle[] PROGMEM = "CIRCLE";

const char srect[] PROGMEM = "RECT";

const char sfcircle[] PROGMEM = "FCIRCLE";

const char sfrect[] PROGMEM = "FRECT";

#endif

/* Dartmouth BASIC extensions */

#ifdef HASDARTMOUTH

const char sdata[] PROGMEM = "DATA";

const char sread[] PROGMEM = "READ";

const char srestore[] PROGMEM = "RESTORE";

const char sdef[] PROGMEM = "DEF";

const char sfn[] PROGMEM = "FN";

const char son[] PROGMEM = "ON";

#endif

/* The Darkarts commands unthinkable in Dartmouth */

#ifdef HASDARKARTS

const char smalloc[] PROGMEM = "MALLOC";

const char sfind[] PROGMEM = "FIND";

const char seval[] PROGMEM = "EVAL";

#endif

/* complex error handling */

#ifdef HASERRORHANDLING

const char serror[] PROGMEM = "ERROR";

#endif

/* iot extensions */

#ifdef HASIOT

const char savail[] PROGMEM = "AVAIL";

const char sstr[] PROGMEM = "STR";

const char sinstr[] PROGMEM = "INSTR";

const char sval[] PROGMEM = "VAL";

const char snetstat[] PROGMEM = "NETSTAT";

const char ssensor[] PROGMEM = "SENSOR";

const char swire[] PROGMEM = "WIRE";

const char ssleep[] PROGMEM = "SLEEP";

#endif

/* events and interrupts */

#ifdef HASTIMER

const char safter[] PROGMEM = "AFTER";

const char severy[] PROGMEM = "EVERY";

#endif

#ifdef HASEVENTS

const char sevent[] PROGMEM = "EVENT";

#endif

#ifdef HASSTRUCT

const char swhile[] PROGMEM = "WHILE";

const char swend[] PROGMEM = "WEND";

const char srepeat[] PROGMEM = "REPEAT";

const char suntil[] PROGMEM = "UNTIL";

const char sswitch[] PROGMEM = "SWITCH";

const char scase[] PROGMEM = "CASE";

const char sswend[] PROGMEM = "SWEND";

const char sdo[] PROGMEM = "DO";

const char sdend[] PROGMEM = "DEND";

#endif

/* zero terminated keyword storage */

const char* const keyword[] PROGMEM = {

sge, sle, sne, sprint, slet, sinput,

sgoto, sgosub, sreturn, sif, sfor, sto,

sstep, snext, sstop, slist, snew, srun,

sabs, srnd, ssize, srem,

#ifdef HASAPPLE1

snot, sand, sor, slen, ssgn, speek, sdim,

sclr, shimem, stab, sthen,

sbend, spoke,

#endif

#ifdef HASSTEFANSEXT

scont, ssqr, spow, smap, sdump, sbreak,

#endif

ssave, sload,

#ifdef HASSTEFANSEXT

sget, sput, sset, scls, slocate, selse,

#endif

#ifdef HASARDUINOIO

spinm, sdwrite, sdread, sawrite, saread,

sdelay, smillis, sazero, sled,

#endif

#ifdef HASTONE

stone,

#endif

#ifdef HASPULSE

spulse,

#endif

#ifdef HASFILEIO

scatalog, sdelete, sfopen, sfclose, sfdisk,

#endif

#ifdef HASSTEFANSEXT

susr, scall,

#endif

#ifdef HASFLOAT

ssin, scos, stan, satan, slog, sexp,

#endif

sint,

#ifdef HASGRAPH

scolor, splot, sline, scircle, srect,

sfcircle, sfrect,

#endif

#ifdef HASDARTMOUTH

sdata, sread, srestore, sdef, sfn, son,

#endif

#ifdef HASDARKARTS

smalloc, sfind, seval,

#endif

/* complex error handling */

#ifdef HASERRORHANDLING

serror,

#endif

#ifdef HASIOT

savail, sstr, sinstr, sval,

snetstat, ssensor, swire, ssleep,

#endif

#ifdef HASTIMER

safter, severy,

#endif

#ifdef HASEVENTS

sevent,

#endif

#ifdef HASSTRUCT

swhile, swend, srepeat, suntil, sswitch, scase, sswend,

sdo, sdend,

#endif

0

};

/* the zero terminated token dictonary needed for scalability */

const signed char tokens[] PROGMEM = {

GREATEREQUAL, LESSEREQUAL, NOTEQUAL, TPRINT, TLET,

TINPUT, TGOTO, TGOSUB, TRETURN, TIF, TFOR, TTO, TSTEP,

TNEXT, TSTOP, TLIST, TNEW, TRUN, TABS, TRND, TSIZE, TREM,

#ifdef HASAPPLE1

TNOT, TAND, TOR, TLEN, TSGN, TPEEK, TDIM, TCLR,

THIMEM, TTAB, TTHEN, TEND, TPOKE,

#endif

#ifdef HASSTEFANSEXT

TCONT, TSQR, TPOW, TMAP, TDUMP, TBREAK,

#endif

TSAVE, TLOAD,

#ifdef HASSTEFANSEXT

TGET, TPUT, TSET, TCLS, TLOCATE, TELSE,

#endif

#ifdef HASARDUINOIO

TPINM, TDWRITE, TDREAD, TAWRITE, TAREAD, TDELAY, TMILLIS,

TAZERO, TLED,

#endif

#ifdef HASTONE

TTONE,

#endif

#ifdef HASPULSE

TPULSE,

#endif

#ifdef HASFILEIO

TCATALOG, TDELETE, TOPEN, TCLOSE, TFDISK,

#endif

#ifdef HASSTEFANSEXT

TUSR, TCALL,

#endif

#ifdef HASFLOAT

TSIN, TCOS, TTAN, TATAN, TLOG, TEXP,

#endif

TINT,

#ifdef HASGRAPH

TCOLOR, TPLOT, TLINE, TCIRCLE, TRECT,

TFCIRCLE, TFRECT,

#endif

#ifdef HASDARTMOUTH

TDATA, TREAD, TRESTORE, TDEF, TFN, TON,

#endif

#ifdef HASDARKARTS

TMALLOC, TFIND, TEVAL,

#endif

#ifdef HASERRORHANDLING

TERROR,

#endif

#ifdef HASIOT

TAVAIL, TSTR, TINSTR, TVAL, TNETSTAT,

TSENSOR, TWIRE, TSLEEP,

#endif

#ifdef HASTIMER

TAFTER, TEVERY,

#endif

#ifdef HASEVENTS

TEVENT,

#endif

#ifdef HASSTRUCT

TWHILE, TWEND, TREPEAT, TUNTIL, TSWITCH, TCASE, TSWEND,

TDO, TDEND,

#endif

0

};

/*

* the message catalog

*/

#define MFILE 0

#define MPROMPT 1

#define MGREET 2

#define MLINE 3

#define MNUMBER 4

#define MVARIABLE 5

#define MARRAY 6

#define MSTRING 7

#define MSTRINGVAR 8

#define EGENERAL 9

#define EUNKNOWN 10

#define ENUMBER 11

#define EDIVIDE 12

#define ELINE 13

#define EOUTOFMEMORY 14

#define ESTACK 15

#define EORANGE 16

#define ESTRING 17

#define EVARIABLE 18

#define ELOOP 19

#define EFILE 20

#define EFUN 21

#define EARGS 22

#define EEEPROM 23

#define ESDCARD 24

const char mfile[] PROGMEM = "file.bas";

const char mprompt[] PROGMEM = "> ";

const char mgreet[] PROGMEM = "Stefan's Basic 1.4";

const char mline[] PROGMEM = "LINE";

const char mnumber[] PROGMEM = "NUMBER";

const char mvariable[] PROGMEM = "VARIABLE";

const char marray[] PROGMEM = "ARRAY";

const char mstring[] PROGMEM = "STRING";

const char mstringv[] PROGMEM = "STRINGVAR";

const char egeneral[] PROGMEM = "Error";

#ifdef HASERRORMSG

const char eunknown[] PROGMEM = "Syntax";

const char enumber[] PROGMEM = "Number";

const char edivide[] PROGMEM = "Div by 0";

const char eline[] PROGMEM = "Unknown Line";

const char emem[] PROGMEM = "Memory";

const char estack[] PROGMEM = "Stack";

const char erange[] PROGMEM = "Range";

const char estring[] PROGMEM = "String";

const char evariable[] PROGMEM = "Variable";

const char eloop[] PROGMEM = "Loop";

const char efile[] PROGMEM = "File";

const char efun[] PROGMEM = "Function";

const char eargs[] PROGMEM = "Args";

const char eeeprom[] PROGMEM = "EEPROM";

const char esdcard[] PROGMEM = "SD card";

#endif

const char* const message[] PROGMEM = {

mfile, mprompt, mgreet,

mline, mnumber, mvariable, marray,

mstring, mstringv,

egeneral

#ifdef HASERRORMSG

, eunknown, enumber, edivide, eline,

emem, estack, erange,

estring, evariable, eloop, efile, efun, eargs,

eeeprom, esdcard

#endif

};

/*

* code for variable numbers and addresses sizes

* the original code was 16 bit but can be extended here

* to arbitrary types

*

* number_t is the type for numerical work - either float or int

* wnumber_t is the type containing the largest printable integer,

* for float keep this int on 32 bit and long on 8 bit unless you

* want to use very long integers, like 64 or 128 bit types.

* address_t is an unsigned type adddressing memory, default 16bit

* mem_t is a SIGNED 8bit character type.

* index_t is a SIGNED minimum 16 bit integer type

*

* works with the tacit assumption that

* sizeof(number_t) >= sizeof(address_t)

* and that the entire memory is smaller than the positive

* part of number type (!!)

*

* we assume that float >= 4 bytes in the following

*

* maxnum: the maximum accurate(!) integer of a

* 32 bit float

* strindexsize: the index size of strings either

* 1 byte or 2 bytes - no other values supported

*/

#ifdef HASFLOAT

typedef float number_t;

const number_t maxnum=16777216;

typedef long wnumber_t;

#else

typedef int number_t;

typedef int wnumber_t;

const number_t maxnum=(number_t)~((number_t)1<<(sizeof(number_t)*8-1));

#endif

typedef unsigned short address_t; /* this type addresses memory */

const int numsize=sizeof(number_t);

const int addrsize=sizeof(address_t);

const int eheadersize=sizeof(address_t)+1;

const int strindexsize=2; /* default in the meantime, strings up to unsigned 16 bit length */

const address_t maxaddr=(address_t)(~0);

typedef signed char mem_t; /* a signed 8 bit type for the memory */

typedef int index_t; /* this type counts at least 16 bit */

#ifndef HASLONGTOKENS

typedef signed char token_t; /* the type of tokens, normally mem_t with a maximum of 127 commands and data types */

#else

typedef short token_t; /* token type extension, allows an extra of 127 commands and symbols */

#endif

/* this type maps numbers to bytes */

typedef struct {mem_t l; mem_t h;} twobytes_t;

typedef union { number_t i; address_t a; twobytes_t b; mem_t c[sizeof(number_t)]; } accu_t;

/* the memreader function type */

typedef mem_t (*memreader_t)(address_t);

/*

* system type identifiers

*/

#define SYSTYPE_UNKNOWN 0

#define SYSTYPE_AVR 1

#define SYSTYPE_ESP8266 2

#define SYSTYPE_ESP32 3

#define SYSTYPE_RP2040 4

#define SYSTYPE_SAM 5

#define SYSTYPE_XMC 6

#define SYSTYPE_SMT32 7

#define SYSTYPE_NRENESA 8

#define SYSTYPE_POSIX 32

#define SYSTYPE_MSDOS 33

#define SYSTYPE_MINGW 34

#define SYSTYPE_RASPPI 35

/*

* The basic interpreter is implemented as a stack machine

* with global variable for the interpreter state, the memory

* and the arithmetic during run time.

*/

/* the stack, all BASIC arithmetic is done here */

number_t stack[STACKSIZE];

address_t sp=0;

/* a small buffer to process string arguments, mostly used for Arduino PROGMEM */

char sbuffer[SBUFSIZE];

/* the input buffer, the lexer can tokenize this and run from it, bi is an index to this.

bi must be global as it is the program cursor in interactive mode */

char ibuffer[BUFSIZE] = "\0";

char *bi;

/* a static array of variables A-Z for the small systems that have no heap */

number_t vars[VARSIZE];

/* the BASIC working memory, either malloced or allocated as a global array */

#if MEMSIZE != 0

mem_t mem[MEMSIZE];

#else

mem_t* mem;

#endif

address_t himem, memsize;

/* the for stack - remembers the variable, indices, and optionally a type for stuctured BASIC */

struct forstackitem {mem_t varx; mem_t vary; address_t here; number_t to; number_t step;

#ifdef HASSTRUCT

mem_t type;

#endif

} forstack[FORDEPTH];

index_t forsp = 0;

/* the GOSUB stack remembers an address to jump to */

address_t gosubstack[GOSUBDEPTH];

index_t gosubsp = 0;

/* this variable stores the location in pushlocation() and poplocation(), used to rewind the program cursor */

address_t slocation;

/* arithmetic accumulators - used by many statements, y may be obsolete in future*/

number_t x, y;

/* the names of a variable and small integer accumulator */

mem_t xc, yc;

/* an address accumulator, used a lot in string operations */

address_t ax;

/* z is another accumulator used to convert numbers and addressed to bytes and vice versa */

/* this union is used to store larger objects into byte oriented memory */

accu_t z;

/* string index registers */

char *ir, *ir2;

/* the active token */

token_t token;

/* the curent error, can be a token, hance token type */

token_t er;

/* a trapable error */

mem_t ert;

/* the interpreter state, interactive, run or run from EEPROM */

mem_t st;

/* the current program location or "cursor" */

address_t here;

/* the topmost byte of a program in memory, beginning of free BASIC RAM */

address_t top;

/* the number of variables on the heap */

address_t nvars = 0;

/* used to format output with # */

mem_t form = 0;

/* counts the outputed characters on streams 0-3, used to emulate a real tab */

#ifdef HASMSTAB

mem_t charcount[3]; /* devices 1-4 support tabing */

mem_t reltab = 0;

#endif

/* the lower limit of the array is one by default, can be a variable */

#ifdef HASARRAYLIMIT

address_t arraylimit = 1;

#else

const address_t arraylimit = 1;

#endif

/* the number of arguments parsed from a command */

mem_t args;

/* the random number seed, this is unsigned hence address_t */

#ifndef HASFLOAT

address_t rd;

#else

unsigned long rd;

#endif

/* output and input channels, used to direct output to various devices */

mem_t id;

mem_t od;

/* default IO - not constant, can be changed at runtime through a user call */

mem_t idd = ISERIAL;

mem_t odd = OSERIAL;

/* the runtime debuglevel */

mem_t debuglevel = 0;

/* DATA pointer, where is the current READ statement */

#ifdef HASDARTMOUTH

address_t data = 0;

address_t datarc = 1;

#endif

/*

* process command line arguments in the POSIX world

* bnointafterrun is a flag to remember if called as command

* line argument, in this case we don't return to interactive

*/

#ifndef ARDUINO

int bargc;

char** bargv;

mem_t bnointafterrun = 0;

#endif

/*

* Yield counter, we count when we did yield the last time

* lastyield controlls the client loops of network functions

* like mqtt, scanned keyboard, and USB.

*

* lastlongyield controls longterm functions like DHCP lease

* renewal in Ethernet

*

* there variables are only needed if the platform has background

* tasks

*/

long lastyield=0;

long lastlongyield=0;

/* formaters lastouttoken and spaceafterkeyword to make a nice LIST */

mem_t lastouttoken;

mem_t spaceafterkeyword;

mem_t outliteral = 0;

mem_t lexliteral = 0;

/*

* the cache for the heap search - helps the string code

* the last found object on the heap is remembered. This is needed

* because the string code sometime searches the heap twice during the

* same operation.

*/

#ifdef HASAPPLE1

mem_t bfindc, bfindd, bfindt;

address_t bfinda, bfindz;

#endif

/*

* a variable for some string operations

*/

int vlength;

/* the timer code - very simple needs to to to a struct */

/* timer type */

typedef struct {

mem_t enabled;

unsigned long last;

unsigned long interval;

mem_t type;

address_t linenumber;

} btimer_t;

#ifdef HASTIMER

btimer_t after_timer = {0, 0, 0, 0, 0};

btimer_t every_timer = {0, 0, 0, 0, 0};

#endif

/* the event code */

#ifdef HASEVENTS

#define EVENTLISTSIZE 4

/* event type */

typedef struct {

mem_t enabled;

mem_t pin;

mem_t mode;

mem_t type;

address_t linenumber;

mem_t active;

} bevent_t;

/* the event list */

int nevents = 0;

int ievent = 0;

static mem_t events_enabled = 1;

static volatile bevent_t eventlist[EVENTLISTSIZE];

/* the extension of the GOSUB stack */

static mem_t gosubarg[GOSUBDEPTH];

/* handle the event list */

mem_t addevent(mem_t, mem_t, mem_t, address_t);

void deleteevent(mem_t);

volatile bevent_t* findevent(mem_t);

mem_t eventindex(mem_t);

#endif

#ifdef HASERRORHANDLING

/* the error handler type, very simple for now */

typedef struct {

mem_t type;

address_t linenumber;

} berrorh_t;

berrorh_t berrorh = {0 , 0};

mem_t erh = 0;

#endif

/* the string for real time clocks */

char rtcstring[20] = { 0 };

/* the units pulse operates on, in microseconds*/

short bpulseunit = 10;

/* only needed for POSIXNONBLOCKING */

mem_t breakcondition = 0;

/*

* Function prototypes, ordered by layers