| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| #include "hardware.h"
|
| #include "runtime.h"
|
|
|
| |
| |
|
|
| #include "language.h"
|
| #include "basic.h"
|
|
|
|
|
| #if USELONGJUMP == 1
|
| #include "setjmp.h"
|
| #endif
|
|
|
|
|
|
|
| |
| |
| |
|
|
| const char sge[] PROGMEM = "=>";
|
| const char sle[] PROGMEM = "<=";
|
| const char sne[] PROGMEM = "<>";
|
|
|
| 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";
|
|
|
| #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
|
|
|
| #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
|
|
|
| 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
|
|
|
| #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
|
|
|
| #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
|
|
|
| #ifdef HASSTEFANSEXT
|
| const char susr[] PROGMEM = "USR";
|
| const char scall[] PROGMEM = "CALL";
|
| #endif
|
|
|
| #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
|
|
|
| const char sint[] PROGMEM = "INT";
|
|
|
| #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
|
|
|
| #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
|
|
|
| #ifdef HASDARKARTS
|
| const char smalloc[] PROGMEM = "MALLOC";
|
| const char sfind[] PROGMEM = "FIND";
|
| const char seval[] PROGMEM = "EVAL";
|
| #endif
|
|
|
| #ifdef HASERRORHANDLING
|
| const char serror[] PROGMEM = "ERROR";
|
| #endif
|
|
|
| #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
|
|
|
| #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
|
| #ifdef HASDARTMOUTH
|
| #ifdef HASMULTILINEFUNCTIONS
|
| const char sfend[] PROGMEM = "FEND";
|
| #endif
|
| #endif
|
| #ifdef HASMSSTRINGS
|
| const char sasc[] PROGMEM = "ASC";
|
| const char schr[] PROGMEM = "CHR";
|
| const char sright[] PROGMEM = "RIGHT";
|
| const char sleft[] PROGMEM = "LEFT";
|
| const char smid[] PROGMEM = "MID";
|
| const char sspc[] PROGMEM = "SPC";
|
| #endif
|
| #ifdef HASEDITOR
|
| const char sedit[] PROGMEM = "EDIT";
|
| #endif
|
|
|
|
|
|
|
| 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
|
|
|
| #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
|
| #ifdef HASDARTMOUTH
|
| #ifdef HASMULTILINEFUNCTIONS
|
| sfend,
|
| #endif
|
| #endif
|
| #ifdef HASMSSTRINGS
|
| sasc, schr, sright, sleft, smid, sspc,
|
| #endif
|
| #ifdef HASEDITOR
|
| sedit,
|
| #endif
|
| 0
|
| };
|
|
|
|
|
| const token_t 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
|
| #ifdef HASDARTMOUTH
|
| #ifdef HASMULTILINEFUNCTIONS
|
| TFEND,
|
| #endif
|
| #endif
|
| #ifdef HASMSSTRINGS
|
| TASC, TCHR, TRIGHT, TLEFT, TMID, TSPC,
|
| #endif
|
| #ifdef HASEDITOR
|
| TEDIT,
|
| #endif
|
| 0
|
| };
|
|
|
|
|
| const bworkfunction_t workfunctions[] PROGMEM = {
|
| 0, 0, 0, xprint, 0
|
| };
|
|
|
|
|
| const char mfile[] PROGMEM = "file.bas";
|
| const char mprompt[] PROGMEM = "> ";
|
| const char mgreet[] PROGMEM = "Stefan's Basic 2.0alpha";
|
| 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
|
| };
|
|
|
| |
| |
| |
| |
| |
|
|
| #ifdef HASFLOAT
|
| const number_t maxnum=16777216;
|
| #else
|
| const number_t maxnum=(number_t)~((number_t)1<<(sizeof(number_t)*8-1));
|
| #endif
|
| const int numsize=sizeof(number_t);
|
| const int addrsize=sizeof(address_t);
|
| const int eheadersize=sizeof(address_t)+1;
|
| const int strindexsize=sizeof(stringlength_t);
|
| const address_t maxaddr=(address_t)(~0);
|
|
|
| |
| |
| |
| |
|
|
|
|
|
|
|
|
| accu_t stack[STACKSIZE];
|
| address_t sp=0;
|
|
|
|
|
|
|
| char sbuffer[SBUFSIZE];
|
|
|
| |
|
|
| char ibuffer[BUFSIZE] = "\0";
|
| char *bi;
|
|
|
|
|
| #ifndef HASAPPLE1
|
| number_t vars[VARSIZE];
|
| #endif
|
|
|
|
|
| #if MEMSIZE != 0
|
| mem_t mem[MEMSIZE];
|
| #else
|
| mem_t* mem;
|
| #endif
|
| address_t himem, memsize;
|
|
|
|
|
| bloop_t loopstack[FORDEPTH];
|
| index_t loopsp = 0;
|
|
|
|
|
| address_t gosubstack[GOSUBDEPTH];
|
| index_t gosubsp = 0;
|
|
|
|
|
| number_t x, y;
|
|
|
|
|
| name_t name;
|
|
|
|
|
| address_t ax;
|
|
|
|
|
| string_t sr;
|
|
|
|
|
| token_t token;
|
|
|
|
|
| token_t er;
|
|
|
| #if USELONGJUMP == 1
|
| jmp_buf sthook;
|
| #endif
|
|
|
|
|
| mem_t ert;
|
|
|
|
|
| mem_t st;
|
|
|
|
|
| address_t here;
|
|
|
|
|
| address_t top;
|
|
|
|
|
| mem_t form = 0;
|
|
|
| |
| |
|
|
| #ifdef MSARRAYLIMITS
|
| mem_t msarraylimits = 1;
|
| address_t arraylimit = 0;
|
| #else
|
| mem_t msarraylimits = 0;
|
| address_t arraylimit = 1;
|
| #endif
|
|
|
|
|
|
|
|
|
| mem_t booleanmode = BOOLEANMODE;
|
|
|
|
|
| mem_t forceint = 0;
|
|
|
|
|
| stringlength_t defaultstrdim = STRSIZEDEF;
|
|
|
| |
| |
| |
|
|
| mem_t randombase = 0;
|
|
|
|
|
| #ifdef SUPPRESSSUBSTRINGS
|
| mem_t substringmode = 0;
|
| #else
|
| mem_t substringmode = 1;
|
| #endif
|
|
|
|
|
| mem_t reltab = 0;
|
|
|
|
|
| mem_t lowercasenames = 0;
|
|
|
|
|
| mem_t args;
|
|
|
|
|
| #ifndef HASFLOAT
|
| address_t rd;
|
| #else
|
| unsigned long rd;
|
| #endif
|
|
|
|
|
| mem_t debuglevel = 0;
|
|
|
|
|
| #ifdef HASDARTMOUTH
|
| address_t data = 0;
|
| address_t datarc = 1;
|
| #endif
|
|
|
| |
| |
| |
| |
|
|
| #ifdef HASARGS
|
| int bargc;
|
| char** bargv;
|
| mem_t bnointafterrun = 0;
|
| #endif
|
|
|
|
|
| mem_t lastouttoken;
|
| mem_t spaceafterkeyword;
|
| mem_t outliteral = 0;
|
| mem_t lexliteral = 0;
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| #ifdef HASAPPLE1
|
| heap_t bfind_object;
|
| #endif
|
|
|
| |
| |
| |
|
|
| address_t vlength;
|
|
|
|
|
|
|
| #ifdef HASTIMER
|
| btimer_t after_timer = {0, 0, 0, 0, 0};
|
| btimer_t every_timer = {0, 0, 0, 0, 0};
|
| #endif
|
|
|
|
|
| #ifdef HASEVENTS
|
|
|
| #define EVENTLISTSIZE 4
|
|
|
|
|
| int nevents = 0;
|
| int ievent = 0;
|
| mem_t events_enabled = 1;
|
| volatile bevent_t eventlist[EVENTLISTSIZE];
|
|
|
|
|
| mem_t gosubarg[GOSUBDEPTH];
|
| #endif
|
|
|
| #ifdef HASERRORHANDLING
|
|
|
| typedef struct {
|
| mem_t type;
|
| address_t linenumber;
|
| } berrorh_t;
|
|
|
| berrorh_t berrorh = {0 , 0};
|
| mem_t erh = 0;
|
| #endif
|
|
|
|
|
| char rtcstring[20] = { 0 };
|
|
|
|
|
| address_t bpulseunit = 10;
|
|
|
|
|
| mem_t breakcondition = 0;
|
|
|
|
|
| int fncontext = 0;
|
|
|
| |
| |
|
|
|
|
|
|
| void bmillis() {
|
| number_t m;
|
|
|
| m=(number_t) (millis()/(unsigned long)pop() % (unsigned long)maxnum);
|
| push(m);
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #if MEMSIZE == 0 && !(defined(SPIRAMINTERFACE))
|
| address_t ballocmem() {
|
|
|
|
|
| long m=freememorysize();
|
|
|
| |
|
|
| if (m < 16000) {
|
| #ifdef HASAPPLE1
|
| m-=64;
|
| #endif
|
| #ifdef USELONGJUMP
|
| m-=160;
|
| #endif
|
| #ifdef HASFLOAT
|
| m-=96;
|
| #endif
|
| #ifdef HASGRAPH
|
| m-=256;
|
| #endif
|
| }
|
|
|
|
|
| if (m<0) m=128;
|
|
|
|
|
| if (m>maxaddr) m=maxaddr;
|
|
|
|
|
| mem=(mem_t*)malloc(m);
|
| if (mem != 0) return m-1;
|
|
|
|
|
| mem=(mem_t*)malloc(128);
|
| if (mem != 0) return 128; else return 0;
|
|
|
| }
|
| #else
|
| address_t ballocmem(){ return MEMSIZE-1; };
|
| #endif
|
|
|
| |
| |
| |
| |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| void esave() {
|
| #ifndef EEPROMMEMINTERFACE
|
| address_t a=0;
|
|
|
|
|
| if (top+eheadersize < elength()) {
|
|
|
|
|
| eupdate(a++, 0);
|
|
|
|
|
| setaddress(a, eupdate, top);
|
| a+=addrsize;
|
|
|
|
|
| while (a < top+eheadersize){
|
| eupdate(a, memread2(a-eheadersize));
|
| a++;
|
| }
|
| eupdate(a++,0);
|
|
|
|
|
| eflush();
|
|
|
| } else {
|
| error(EOUTOFMEMORY);
|
| er=0;
|
| }
|
| #endif
|
| }
|
|
|
|
|
| void eload() {
|
| #ifndef EEPROMMEMINTERFACE
|
| address_t a=0;
|
|
|
|
|
| if (elength()>0 && (eread(a) == 0 || eread(a) == 1)) {
|
|
|
|
|
| a++;
|
| top=getaddress(a, eread);
|
| a+=addrsize;
|
|
|
|
|
| while (a < top+eheadersize){
|
| memwrite2(a-eheadersize, eread(a));
|
| a++;
|
| }
|
| } else {
|
|
|
| error(EEEPROM);
|
| }
|
| #endif
|
| }
|
|
|
|
|
| char autorun() {
|
|
|
|
|
| if (elength()>0 && eread(0) == 1) {
|
| top=getaddress(1, eread);
|
| st=SERUN;
|
| return 1;
|
| }
|
|
|
|
|
| #ifdef HASARGS
|
| if (bargc > 0 && ifileopen(bargv[1])) {
|
| xload(bargv[1]);
|
| st=SRUN;
|
| ifileclose();
|
| bnointafterrun=TERMINATEAFTERRUN;
|
| return 1;
|
| }
|
| #endif
|
|
|
|
|
| #if defined(FILESYSTEMDRIVER)
|
| if (ifileopen("autoexec.bas")) {
|
| xload("autoexec.bas");
|
| st=SRUN;
|
| ifileclose();
|
| return 1;
|
| }
|
| #endif
|
|
|
|
|
| return 0;
|
| }
|
|
|
| #ifdef HASAPPLE1
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| address_t bmalloc(name_t* name, address_t l) {
|
| address_t payloadsize;
|
| address_t heapheadersize = sizeof(name_t) + addrsize;
|
| address_t b=himem;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** bmalloc with token ");
|
| outnumber(name->token); outspc();
|
| outname(name); outspc();
|
| outnumber(l); outcr();
|
| }
|
|
|
| |
| |
|
|
| switch(name->token) {
|
| case VARIABLE:
|
| payloadsize=numsize;
|
|
|
| break;
|
| #ifndef HASMULTIDIM
|
| case ARRAYVAR:
|
| payloadsize=numsize*l;
|
| break;
|
| #else
|
| case ARRAYVAR:
|
| payloadsize=numsize*l+addrsize;
|
| break;
|
| #endif
|
| #ifdef HASDARTMOUTH
|
| case TFN: |
|
|
| payloadsize=addrsize+2+sizeof(name_t)*l;
|
| break;
|
| #endif
|
|
|
| default:
|
| payloadsize=l;
|
| }
|
|
|
|
|
| #ifndef EEPROMMEMINTERFACE
|
| if ((himem-top) < payloadsize+heapheadersize) { error(EOUTOFMEMORY); return 0;}
|
| #else
|
| if (himem-(elength()-eheadersize) < payloadsize+heapheadersize) { error(EOUTOFMEMORY); return 0;}
|
| #endif
|
|
|
|
|
|
|
| b-=payloadsize;
|
| bfind_object.address=b+1;
|
|
|
|
|
| if (name->token != VARIABLE) {
|
| b-=(addrsize-1);
|
| setaddress(b, memwrite2, payloadsize);
|
| if (DEBUG) {
|
| outsc("** bmalloc writes payloadsize "); outnumber(payloadsize);
|
| outsc(" at "); outnumber(b); outcr();
|
| }
|
| b--;
|
| }
|
|
|
|
|
| b=setname_heap(b, name);
|
|
|
|
|
| memwrite2(b--, name->token);
|
|
|
|
|
| if (b < top || er) { error(EOUTOFMEMORY); return 0; }
|
|
|
|
|
| bfind_object.name=*name;
|
| bfind_object.size=payloadsize;
|
|
|
|
|
| himem=b;
|
|
|
| if (DEBUG) {
|
| outsc("** bmalloc returns "); outnumber(bfind_object.address);
|
| outsc(" himem is "); outnumber(himem); outcr();
|
| }
|
|
|
|
|
| return bfind_object.address;
|
| }
|
|
|
| address_t bfind(name_t* name) {
|
| address_t b, b0;
|
| address_t i=0;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("*** bfind called for "); outname(name);
|
| outsc(" on heap with token "); outnumber(name->token);
|
| outsc(" himem is "); outnumber(himem); outcr();
|
| }
|
|
|
|
|
| if (himem == memsize) return 0; else b=himem+1;
|
|
|
|
|
| if (name->token == bfind_object.name.token && cmpname(name, &bfind_object.name)) {
|
| if (DEBUG) { outsc("*** bfind found in cache "); outname(name); outsc(" at "); outnumber(bfind_object.address); outcr(); }
|
| return bfind_object.address;
|
| }
|
|
|
|
|
| while (b <= memsize) {
|
|
|
|
|
| bfind_object.name.token=memread2(b++);
|
| b=getname(b, &bfind_object.name, memread2);
|
|
|
|
|
| if (bfind_object.name.token != VARIABLE) {
|
| bfind_object.size=getaddress(b, memread2);
|
| b+=addrsize;
|
| } else {
|
| bfind_object.size=numsize;
|
| }
|
|
|
|
|
| bfind_object.address=b;
|
|
|
|
|
| if (name->token == bfind_object.name.token && cmpname(name, &bfind_object.name)) {
|
| if (DEBUG) { outsc("*** bfind found "); outname(name); outsc(" at "); outnumber(bfind_object.address); outcr(); }
|
| return bfind_object.address;
|
| }
|
|
|
|
|
| b0=b;
|
| b+=bfind_object.size;
|
|
|
|
|
| if (b0 > b) {
|
| error(EVARIABLE);
|
| return 0;
|
| }
|
|
|
| }
|
|
|
|
|
|
|
| if (DEBUG) { outsc("bfind returns 0"); outcr(); }
|
|
|
| zeroheap(&bfind_object);
|
| return 0;
|
| }
|
|
|
|
|
| address_t bfree(name_t* name) {
|
| address_t b;
|
| address_t i;
|
|
|
| if (DEBUG) { outsc("*** bfree called for "); outname(name); outsc(" on heap with token "); outnumber(name->token); outcr(); }
|
|
|
|
|
| b=bfind(name);
|
|
|
|
|
| if (b == 0) return 0;
|
|
|
| if (DEBUG) { outsc("** bfree found "); outnumber(b); outcr(); }
|
|
|
|
|
| for (i=himem; i<=b+bfind_object.size-1; i++) memwrite2(i, 0);
|
|
|
|
|
| himem=b+bfind_object.size-1;
|
|
|
| if (DEBUG) { outsc("** bfree returns "); outnumber(himem); outcr(); }
|
|
|
|
|
| zeroheap(&bfind_object);
|
| return himem;
|
| }
|
|
|
|
|
| address_t blength(name_t* name) {
|
| if (bfind(name)) return bfind_object.size; else return 0;
|
| }
|
| #endif
|
|
|
|
|
| number_t getvar(name_t *name){
|
| address_t a;
|
|
|
| if (DEBUG) { outsc("* getvar "); outname(name); outspc(); outcr(); }
|
|
|
|
|
| if (name->c[0] == '@') {
|
| switch (name->c[1]) {
|
| case 'A':
|
| return availch();
|
| case 'S':
|
| return ert|ioer;
|
| case 'I':
|
| return id;
|
| case 'O':
|
| return od;
|
| case 'C':
|
| if (availch()) return inch(); else return 0;
|
| case 'E':
|
| return elength()/numsize;
|
| case 0:
|
| return (himem-top)/numsize;
|
| case 'R':
|
| return rd;
|
| case 'U':
|
| return getusrvar();
|
| #ifdef HASIOT
|
| case 'V':
|
| return vlength;
|
| #endif
|
| #if defined(DISPLAYDRIVER) || defined (GRAPHDISPLAYDRIVER)
|
| case 'X':
|
| return dspgetcursorx();
|
| case 'Y':
|
| return dspgetcursory();
|
| #endif
|
| }
|
| }
|
|
|
| #ifdef HASAPPLE1
|
|
|
| a=bfind(name);
|
| if (!USELONGJUMP && er) return 0;
|
|
|
|
|
| if (a == 0) {
|
| a=bmalloc(name, 0);
|
| if (!USELONGJUMP && er) return 0;
|
| }
|
|
|
|
|
| if (a == 0) {
|
| error(EVARIABLE);
|
| return 0;
|
| }
|
|
|
| return getnumber(a, memread2);
|
|
|
| #else
|
|
|
| if (name->c[0] >= 65 && name->c[0] <= 91 && name->c[1] == 0) return vars[name->c[0]-65];
|
|
|
|
|
| error(EVARIABLE);
|
| return 0;
|
| #endif
|
| }
|
|
|
|
|
| void setvar(name_t *name, number_t v){
|
| address_t a;
|
|
|
| if (DEBUG) { outsc("* setvar "); outname(name); outspc(); outnumber(v); outcr(); }
|
|
|
|
|
| if (name->c[0] == '@')
|
| switch (name->c[1]) {
|
| case 'S':
|
| ert=v;
|
| ioer=v;
|
| return;
|
| case 'I':
|
| id=v;
|
| return;
|
| case 'O':
|
| od=v;
|
| return;
|
| case 'C':
|
| outch(v);
|
| return;
|
| case 'R':
|
| rd=v;
|
| return;
|
| case 'U':
|
| setusrvar(v);
|
| return;
|
| #ifdef HASIOT
|
| case 'V':
|
| return;
|
| #endif
|
| #if defined(DISPLAYDRIVER) || defined(GRAPHDISPLAYDRIVER)
|
| case 'X':
|
| dspsetcursorx((int)v);
|
|
|
| #ifdef HASMSTAB
|
| if (od > 0 && od <= OPRT) charcount[od-1]=v;
|
| #endif
|
| return;
|
| case 'Y':
|
| dspsetcursory((int)v);
|
| return;
|
| #endif
|
| }
|
|
|
| #ifdef HASAPPLE1
|
|
|
| a=bfind(name);
|
|
|
|
|
| if (a == 0) {
|
| a=bmalloc(name, 0);
|
| if (!USELONGJUMP && er) return;
|
| }
|
|
|
|
|
| if (a == 0) {
|
| error(EVARIABLE);
|
| return;
|
| }
|
|
|
|
|
| setnumber(a, memwrite2, v);
|
| #else
|
|
|
| if (name->c[1] == 0 && name->c[0] >= 65 && name->c[0] <= 91) {
|
| vars[name->c[0]-65]=v;
|
| return;
|
| }
|
| error(EVARIABLE);
|
| #endif
|
| }
|
|
|
|
|
| void clrvars() {
|
|
|
|
|
| address_t i;
|
|
|
|
|
| #ifndef HASAPPLE1
|
| for (i=0; i<VARSIZE; i++) vars[i]=0;
|
| #endif
|
|
|
|
|
| for (i=himem; i<memsize; i++) memwrite2(i, 0);
|
|
|
|
|
| himem=memsize;
|
|
|
|
|
| #ifdef HASAPPLE1
|
| zeroheap(&bfind_object);
|
| #endif
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| number_t getnumber(address_t m, memreader_t f) {
|
| mem_t i;
|
| accu_t z;
|
|
|
| for (i=0; i<numsize; i++) z.c[i]=f(m++);
|
| return z.n;
|
| }
|
|
|
|
|
| address_t getaddress(address_t m, memreader_t f) {
|
| mem_t i;
|
| accu_t z;
|
|
|
| for (i=0; i<addrsize; i++) z.c[i]=f(m++);
|
| return z.a;
|
| }
|
|
|
|
|
| stringlength_t getstrlength(address_t m, memreader_t f) {
|
| mem_t i;
|
| accu_t z;
|
|
|
| z.a=0;
|
| for (i=0; i<strindexsize; i++) z.c[i]=f(m++);
|
| return z.a;
|
| }
|
|
|
|
|
| void setnumber(address_t m, memwriter_t f, number_t v){
|
| mem_t i;
|
| accu_t z;
|
|
|
| z.n=v;
|
| for (i=0; i<numsize; i++) f(m++, z.c[i]);
|
| }
|
|
|
|
|
| void setaddress(address_t m, memwriter_t f, address_t a){
|
| mem_t i;
|
| accu_t z;
|
|
|
| z.a=a;
|
| for (i=0; i<addrsize; i++) f(m++, z.c[i]);
|
| }
|
|
|
|
|
| void setstrlength(address_t m, memwriter_t f, stringlength_t s){
|
| mem_t i;
|
| accu_t z;
|
|
|
| z.s=s;
|
| for (i=0; i<strindexsize; i++) f(m++, z.c[i]);
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifndef HASLONGNAMES
|
|
|
|
|
| address_t setname_heap(address_t m, name_t* name) {
|
| memwrite2(m--, name->c[1]);
|
| memwrite2(m--, name->c[0]);
|
| return m;
|
| }
|
|
|
|
|
| address_t setname_pgm(address_t m, name_t* name) {
|
| memwrite2(m++, name->c[0]);
|
| memwrite2(m++, name->c[1]);
|
| return m;
|
| }
|
|
|
|
|
| address_t getname(address_t m, name_t* name, memreader_t f) {
|
| name->c[0]=f(m++);
|
| name->c[1]=f(m++);
|
| return m;
|
| }
|
|
|
|
|
| mem_t cmpname(name_t* a, name_t* b) {
|
| if (a->c[0] == b->c[0] && a->c[1] == b->c[1]) return 1; else return 0;
|
| }
|
|
|
|
|
| void zeroname(name_t* name) {
|
| name->c[0]=0;
|
| name->c[1]=0;
|
| name->token=0;
|
| }
|
|
|
| void zeroheap(heap_t* heap) {
|
| heap->address=0;
|
| heap->size=0;
|
| zeroname(&heap->name);
|
| }
|
|
|
|
|
| void outname(name_t* name) {
|
| outch(name->c[0]);
|
| if (name->c[1]) outch(name->c[1]);
|
| }
|
|
|
| #else
|
|
|
| address_t setname_heap(address_t m, name_t* name) {
|
| mem_t l;
|
| for(l=name->l; l>0; l--) memwrite2(m--, name->c[l-1]);
|
| memwrite2(m--, name->l);
|
| return m;
|
| }
|
|
|
|
|
| address_t setname_pgm(address_t m, name_t* name) {
|
| mem_t l;
|
| memwrite2(m++, name->l);
|
| for(l=0; l<name->l; l++) memwrite2(m++, name->c[l]);
|
| return m;
|
| }
|
|
|
|
|
| address_t getname(address_t m, name_t* name, memreader_t f) {
|
| mem_t l;
|
| name->l=f(m++);
|
|
|
| for(l=0; l<name->l; l++) name->c[l]=f(m++);
|
| for(; l<MAXNAME; l++) name->c[l]=0; |
|
|
| return m;
|
| }
|
|
|
|
|
| mem_t cmpname(name_t* a, name_t* b) {
|
| mem_t l;
|
| if (a->l != b->l) return 0;
|
| for(l=0; l<a->l; l++) if (a->c[l] != b->c[l]) return 0;
|
| return 1;
|
| }
|
|
|
|
|
| void zeroname(name_t* name) {
|
| mem_t l;
|
| name->l=0;
|
| for(l=0; l<MAXNAME; l++) name->c[l]=0;
|
| name->token=0;
|
| }
|
|
|
| void zeroheap(heap_t* heap) {
|
| heap->address=0;
|
| heap->size=0;
|
| zeroname(&heap->name);
|
| }
|
|
|
|
|
| void outname(name_t* name) {
|
| mem_t l;
|
| for(l=0; l<name->l; l++) outch(name->c[l]);
|
| }
|
| #endif
|
|
|
|
|
|
|
|
|
| address_t createarray(name_t* variable, address_t i, address_t j) {
|
| address_t a;
|
|
|
|
|
| if (msarraylimits) {
|
| i+=1;
|
| j+=1;
|
| }
|
|
|
|
|
|
|
| #ifdef HASAPPLE1
|
| if (DEBUG) {
|
| outsc("* create array "); outname(variable); outspc();
|
| outsc("* with name length "); outnumber(variable->l); outspc();
|
| outnumber(i); outspc(); outnumber(j); outcr();
|
| }
|
|
|
| #ifndef HASMULTIDIM
|
| return bmalloc(variable, i);
|
| #else
|
|
|
|
|
| a=bmalloc(variable, i*j);
|
|
|
|
|
| setaddress(a+i*j*numsize, memwrite2, j);
|
|
|
|
|
| return a;
|
| #endif
|
| #endif
|
| return 0;
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
|
|
| void array(lhsobject_t* object, mem_t getset, number_t* value) {
|
| address_t a;
|
| address_t h;
|
| address_t l=arraylimit;
|
| address_t dim=1;
|
|
|
| if (DEBUG) {
|
| outsc("* array2: accessing ");
|
| outname(&name); outspc(); outspc();
|
| outnumber(object->i); outspc();
|
| outnumber(object->j); outspc();
|
| outsc(" getset "); outch(getset); outcr();
|
| }
|
|
|
|
|
| if (object->name.c[0] == '@') {
|
| switch(object->name.c[1]) {
|
| case 'E':
|
| h=elength()/numsize;
|
| a=elength()-numsize*object->i;
|
| if (a < eheadersize) { error(EORANGE); return; }
|
| if (getset == 'g') *value=getnumber(a, eread);
|
| else if (getset == 's') setnumber(a, eupdate, *value);
|
| return;
|
| #if defined(DISPLAYDRIVER) && defined(DISPLAYCANSCROLL)
|
| case 'D':
|
| if (getset == 'g') *value=dspget(object->i-1);
|
| else if (getset == 's') dspset(object->i-1, *value);
|
| return;
|
| #endif
|
| #if defined(HASCLOCK)
|
| case 'T':
|
| if (getset == 'g') *value=rtcget(object->i);
|
| else if (getset == 's') rtcset(object->i, *value);
|
| return;
|
| #endif
|
| #if defined(ARDUINO) && defined(ARDUINOSENSORS)
|
| case 'S':
|
| if (getset == 'g') *value=sensorread(object->i, 0);
|
| return;
|
| #endif
|
| case 'U':
|
| if (getset == 'g') *value=getusrarray(object->i);
|
| else if (getset == 's') setusrarray(object->i, *value);
|
| return;
|
| case 0:
|
| h=(himem-top)/numsize;
|
| a=himem-numsize*(object->i+1)+1;
|
| if (object->i < 0 || a < top) { error(EORANGE); return; }
|
| if (getset == 'g') *value=getnumber(a, memread2);
|
| else if (getset == 's') setnumber(a, memwrite2, *value);
|
| return;
|
| case 'M':
|
| h=himem-top;
|
| a=himem-object->i;
|
| if (object->i < 0 || a < top) { error(EORANGE); return; }
|
| if (getset == 'g') *value=memread2(a);
|
| else if (getset == 's') memwrite2(a, *value);
|
| return;
|
| default:
|
| error(EVARIABLE);
|
| return;
|
| }
|
| } else {
|
|
|
| #ifdef HASAPPLE1
|
| object->name.token=ARRAYVAR;
|
| if (!(a=bfind(&object->name))) a=createarray(&object->name, ARRAYSIZEDEF, 1);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| #ifndef HASMULTIDIM
|
| h=bfind_object.size/numsize;
|
| #else
|
| h=(bfind_object.size-addrsize)/numsize;
|
| #endif
|
|
|
| if (DEBUG) {
|
| outsc("** in array dynamical base address "); outnumber(a);
|
| outsc(" and array element number"); outnumber(h);
|
| outcr();
|
| }
|
|
|
| #ifdef HASMULTIDIM
|
| dim=getaddress(a+bfind_object.size-2, memread2);
|
| if (DEBUG) {
|
| outsc("** in array, second dimension is "); outnumber(dim);
|
| outspc(); outnumber(a+bfind_object.size);
|
| outcr();
|
| }
|
| a=a+((object->i-l)*dim+(object->j-l))*numsize;
|
| #else
|
| a=a+(object->i-l)*numsize;
|
| #endif
|
| #else
|
| error(EVARIABLE);
|
| return;
|
| #endif
|
| }
|
|
|
|
|
| #ifdef HASMULTIDIM
|
| if ( (object->j < l) || (object->j >= dim+l) || (object->i < l) || (object->i >= h/dim+l)) { error(EORANGE); return; }
|
| #else
|
| if ( (object->i < l) || (object->i >= h+l) ) { error(EORANGE); return; }
|
| #endif
|
|
|
|
|
| if (getset == 'g') *value=getnumber(a, memread2);
|
| else if (getset == 's') setnumber(a, memwrite2, *value);
|
| }
|
|
|
|
|
| address_t createstring(name_t* variable, address_t i, address_t j) {
|
| #ifdef HASAPPLE1
|
| address_t a;
|
|
|
| if (DEBUG) { outsc("Create string "); outname(variable); outcr(); }
|
|
|
|
|
| if (msarraylimits) j+=1;
|
|
|
| #ifndef HASMULTIDIM
|
|
|
|
|
| a=bmalloc(variable, i+strindexsize);
|
| if (er != 0) return 0;
|
| return a;
|
| #else
|
| |
|
|
|
|
| a=bmalloc(variable, addrsize+j*(i+strindexsize));
|
| if (er != 0) return 0;
|
|
|
|
|
| setaddress(a+j*(i+strindexsize), memwrite2, j);
|
|
|
|
|
| return a;
|
| #endif
|
| if (er != 0) return 0;
|
| return a;
|
| #else
|
| return 0;
|
| #endif
|
| }
|
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifdef HASAPPLE1
|
|
|
|
|
|
|
| void storecstring(address_t ax, address_t s, char* b) {
|
| address_t k;
|
|
|
| for (k=0; k<s-strindexsize && b[k] != 0; k++) memwrite2(ax+k+strindexsize, b[k]);
|
| setstrlength(ax, memwrite2, k);
|
| }
|
|
|
|
|
| address_t cstringlength(char* c, address_t l) {
|
| address_t a;
|
|
|
| while(a < l && c[a] != 0) a++;
|
| return a;
|
| }
|
|
|
|
|
| void getstring(string_t* strp, name_t* name, address_t b, address_t j) {
|
| address_t k, zt;
|
| address_t ax;
|
|
|
|
|
| ax=0;
|
| strp->address=0;
|
| strp->ir=0;
|
| strp->length=0;
|
| strp->arraydim=1;
|
| strp->strdim=0;
|
|
|
| if (DEBUG) {
|
| outsc("* getstring from var "); outname(name); outspc();
|
| outnumber(b); outspc();
|
| outnumber(j); outcr();
|
| }
|
|
|
|
|
| if (name->c[0] == '@')
|
| switch(name->c[1]) {
|
| case 0:
|
| strp->ir=ibuffer+b;
|
| strp->length=ibuffer[0];
|
| strp->strdim=BUFSIZ-2;
|
| return;
|
| default:
|
| error(EVARIABLE);
|
| return;
|
| case 'U':
|
| makeusrstring();
|
| strp->ir=sbuffer+b;
|
| strp->length=sbuffer[0];
|
| return;
|
| #ifdef HASCLOCK
|
| case 'T':
|
| rtcmkstr();
|
| strp->ir=rtcstring+b;
|
| strp->length=rtcstring[0];
|
| return;
|
| #endif
|
|
|
| #ifdef HASARGS
|
| case 'A':
|
| if (bargc > 2) {
|
| strp->ir=bargv[2];
|
| strp->length=cstringlength(bargv[2], BUFSIZE);
|
| return;
|
| }
|
| return;
|
| #endif
|
| }
|
|
|
|
|
| if (!(ax=bfind(name))) ax=createstring(name, defaultstrdim, arraylimit);
|
|
|
| if (DEBUG) {
|
| outsc("** heap address "); outnumber(ax); outcr();
|
| if (ax) { outsc("** byte length of string memory segment "); outnumber(bfind_object.size); outcr(); }
|
| }
|
|
|
|
|
| if (!USELONGJUMP && er) return;
|
|
|
| #ifndef HASMULTIDIM
|
|
|
| strp->strdim=bfind_object.size-strindexsize;
|
|
|
|
|
| if ((b < 1) || (b > strp->strdim )) { error(EORANGE); return; }
|
|
|
| if (DEBUG) { outsc("** maximum string length "); outnumber(strp->strdim); outcr(); }
|
|
|
| |
|
|
| strp->length=getstrlength(ax, memread2);
|
|
|
|
|
| ax=ax+strindexsize+(b-1);
|
| #else
|
|
|
|
|
|
|
| strp->arraydim=getaddress(ax + bfind_object.size - addrsize, memread2);
|
|
|
|
|
| if ((j < arraylimit) || (j >= strp->arraydim + arraylimit )) { error(EORANGE); return; }
|
|
|
| if (DEBUG) { outsc("** string dimension "); outnumber(strp->arraydim); outcr(); }
|
|
|
|
|
| strp->strdim=(bfind_object.size - addrsize)/strp->arraydim-strindexsize;
|
|
|
|
|
| if ((b < 1) || (b > strp->strdim )) { error(EORANGE); return; }
|
|
|
| if (DEBUG) { outsc("** maximum string length "); outnumber(strp->strdim); outcr(); }
|
|
|
|
|
| ax=ax+(j-arraylimit)*(strp->strdim + strindexsize);
|
|
|
| if (DEBUG) { outsc("** string base address "); outnumber(ax); outcr(); }
|
|
|
|
|
| strp->length=getstrlength(ax, memread2);
|
|
|
|
|
| ax=ax+b-1+strindexsize;
|
|
|
| #endif
|
|
|
| if (DEBUG) { outsc("** payload address "); outnumber(ax); outcr(); }
|
|
|
|
|
| strp->address=ax;
|
|
|
| |
|
|
| #ifdef USEMEMINTERFACE
|
| strp->ir=0;
|
| #else
|
| strp->ir=(char *)&mem[ax];
|
| #endif
|
| }
|
|
|
|
|
|
|
|
|
| void setstringlength(name_t* name, address_t l, address_t j) {
|
| address_t a;
|
| stringlength_t stringdim;
|
|
|
| if (DEBUG) {
|
| outsc("** setstringlength ");
|
| outname(name);
|
| outspc(); outnumber(l); outspc(); outnumber(j);
|
| outcr();
|
| }
|
|
|
|
|
| if (name->c[0] == '@')
|
| switch(name->c[1]) {
|
| case 0:
|
| *ibuffer=l;
|
| return;
|
| case 'U':
|
|
|
| return;
|
| }
|
|
|
|
|
| a=bfind(name);
|
| if (!USELONGJUMP && er) return;
|
| if (a == 0) { error(EVARIABLE); return; }
|
|
|
|
|
| #ifndef HASMULTIDIM
|
| stringdim=bfind_object.size-strindexsize;
|
| #else
|
|
|
| stringdim=(bfind_object.size - addrsize)/(getaddress(a + bfind_object.size - addrsize, memread2)) - strindexsize;
|
| #endif
|
|
|
|
|
| a=a+(stringdim+strindexsize)*(j-arraylimit);
|
| if (DEBUG) { outsc("** setstringlength writing to "); outnumber(a); outsc(" value "); outnumber(l); outcr(); }
|
| setstrlength(a, memwrite2, l);
|
| }
|
|
|
|
|
| #ifdef HASCLOCK
|
| void rtcmkstr() {
|
| int cc = 1;
|
| int t;
|
|
|
|
|
| t=rtcget(2);
|
| rtcstring[cc++]=t/10+'0';
|
| rtcstring[cc++]=t%10+'0';
|
| rtcstring[cc++]=':';
|
|
|
|
|
| t=rtcget(1);
|
| rtcstring[cc++]=t/10+'0';
|
| rtcstring[cc++]=t%10+'0';
|
| rtcstring[cc++]=':';
|
|
|
|
|
| t=rtcget(0);
|
| rtcstring[cc++]=t/10+'0';
|
| rtcstring[cc++]=t%10+'0';
|
| rtcstring[cc++]='-';
|
|
|
|
|
| t=rtcget(4);
|
| if (t/10 > 0) rtcstring[cc++]=t/10+'0';
|
| rtcstring[cc++]=t%10+'0';
|
| rtcstring[cc++]='/';
|
|
|
|
|
| t=rtcget(5);
|
| if (t/10 > 0) rtcstring[cc++]=t/10+'0';
|
| rtcstring[cc++]=t%10+'0';
|
| rtcstring[cc++]='/';
|
|
|
|
|
| t=rtcget(6)%100;
|
| if (t/10 > 0) rtcstring[cc++]=t/10+'0';
|
| rtcstring[cc++]=t%10+'0';
|
| rtcstring[cc]=0;
|
|
|
|
|
| rtcstring[0]=cc-1;
|
| }
|
| #endif
|
| #endif
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| number_t getusrvar() { return 0; }
|
| void setusrvar(number_t v) {return; }
|
|
|
|
|
| number_t getusrarray(address_t i) {return 0;}
|
| void setusrarray(address_t i, number_t v) {return; }
|
|
|
|
|
| void makeusrstring() {
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| sbuffer[0]=0;
|
| }
|
|
|
|
|
| number_t usrfunction(address_t i, number_t v) { return 0; }
|
|
|
|
|
| void usrcall(address_t i) { return; }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| char* getkeyword(address_t i) {
|
|
|
| if (DEBUG) { outsc("** getkeyword from index "); outnumber(i); outcr(); }
|
|
|
| #ifndef ARDUINOPROGMEM
|
| return (char *) keyword[i];
|
| #else
|
| strcpy_P(sbuffer, (char*) pgm_read_ptr(&(keyword[i])));
|
| return sbuffer;
|
| #endif
|
| }
|
|
|
|
|
| char* getmessage(char i) {
|
| if (i >= sizeof(message) || i < 0) return 0;
|
| #ifndef ARDUINOPROGMEM
|
| return (char *) message[i];
|
| #else
|
| strcpy_P(sbuffer, (char*) pgm_read_ptr(&(message[i])));
|
| return sbuffer;
|
| #endif
|
| }
|
|
|
|
|
| token_t gettokenvalue(address_t i) {
|
| if (i >= sizeof(tokens)) return 0;
|
| #ifndef ARDUINOPROGMEM
|
| return tokens[i];
|
| #else
|
| #ifndef HASLONGTOKENS
|
| return (token_t) pgm_read_byte(&tokens[i]);
|
| #else
|
| return (token_t) pgm_read_word(&tokens[i]);
|
| #endif
|
| #endif
|
| }
|
|
|
|
|
| void printmessage(char i){
|
| #ifndef HASERRORMSG
|
| if (i > EGENERAL) return;
|
| #endif
|
| outsc((char *)getmessage(i));
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| void error(token_t e){
|
| address_t i;
|
|
|
|
|
| er=e;
|
|
|
|
|
| clearst();
|
| clrforstack();
|
| clrgosubstack();
|
|
|
|
|
| #ifdef HASTIMER
|
| resettimer(&after_timer);
|
| resettimer(&every_timer);
|
| #endif
|
|
|
|
|
| #ifdef HASERRORHANDLING
|
| #if !USELONGJUMP
|
| if (st != SINT && (berrorh.type == TGOTO || berrorh.type == TCONT)) return;
|
| #else
|
| if (st != SINT && (berrorh.type == TGOTO || berrorh.type == TCONT)) longjmp(sthook, er);
|
| #endif
|
| #endif
|
|
|
|
|
| iodefaults();
|
| form=0;
|
|
|
|
|
| if (st != SINT) {
|
| outnumber(myline(here));
|
| outch(':');
|
| outspc();
|
| }
|
|
|
|
|
| #ifdef HASERRORMSG
|
| if (e > 0)
|
| printmessage(e);
|
| else {
|
| for(i=0; gettokenvalue(i)!=0 && gettokenvalue(i)!=e; i++);
|
| outsc(getkeyword(i));
|
| }
|
| outspc();
|
| printmessage(EGENERAL);
|
| #else
|
| printmessage(EGENERAL);
|
| outspc();
|
| outnumber(er);
|
| #endif
|
| if (DEBUG) { outsc("** at "); outnumber(here); }
|
| outcr();
|
|
|
|
|
| fncontext=0;
|
|
|
|
|
| #if USELONGJUMP == 1
|
| longjmp(sthook, er);
|
| #endif
|
| }
|
|
|
| void reseterror() {
|
| er=0;
|
| here=0;
|
| st=SINT;
|
| }
|
|
|
| void debugtoken(){
|
| outsc("* ");
|
| if (debuglevel>2) { outnumber(here); outsc(" * "); }
|
|
|
| if (token == EOL) {
|
| outsc("EOL");
|
| return;
|
| }
|
|
|
| switch(token) {
|
| case LINENUMBER:
|
| printmessage(MLINE);
|
| break;
|
| case NUMBER:
|
| printmessage(MNUMBER);
|
| break;
|
| case VARIABLE:
|
| printmessage(MVARIABLE);
|
| break;
|
| case ARRAYVAR:
|
| printmessage(MARRAY);
|
| break;
|
| case STRING:
|
| printmessage(MSTRING);
|
| break;
|
| case STRINGVAR:
|
| printmessage(MSTRINGVAR);
|
| break;
|
| }
|
|
|
| outspc();
|
| outputtoken();
|
| }
|
|
|
| void bdebug(const char *c){
|
| outch('*');
|
| outspc();
|
| outsc(c);
|
| debugtoken();
|
| outcr();
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
| void push(number_t t){
|
|
|
| if (DEBUG) {
|
| outsc("** push sp= "); outnumber(sp); outcr();
|
| outsc("** push value= "); outnumber(t); outcr();
|
| }
|
|
|
|
|
| #ifdef HASFLOAT
|
| if (forceint) t=trunc(t);
|
| #endif
|
|
|
| if (sp == STACKSIZE)
|
| error(ESTACK);
|
| else
|
| stack[sp++].n=t;
|
| }
|
|
|
| number_t pop(){
|
|
|
| if (DEBUG) {
|
| outsc("** pop sp= "); outnumber(sp); outcr();
|
| outsc("** pop value= "); outnumber(stack[sp-1].n); outcr();
|
| }
|
|
|
| if (sp == 0) { error(ESTACK); return 0; }
|
|
|
| return stack[--sp].n;
|
| }
|
|
|
| void pushaddress2(address_t a) {
|
|
|
| if (DEBUG) {
|
| outsc("** push sp= "); outnumber(sp); outcr();
|
| outsc("** push value= "); outnumber(a); outcr();
|
| }
|
|
|
| if (sp == STACKSIZE)
|
| error(ESTACK);
|
| else
|
| stack[sp++].a=a;
|
| }
|
|
|
| address_t popaddress2() {
|
|
|
| if (DEBUG) {
|
| outsc("** pop sp= "); outnumber(sp); outcr();
|
| outsc("** pop value= "); outnumber(stack[sp-1].a); outcr();
|
| }
|
|
|
| if (sp == 0) { error(ESTACK); return 0; }
|
|
|
| return stack[--sp].a;
|
| }
|
|
|
| void pushinteger(index_t i) {
|
|
|
| if (DEBUG) {
|
| outsc("** push sp= "); outnumber(sp); outcr();
|
| outsc("** push value= "); outnumber(i); outcr();
|
| }
|
|
|
| if (sp == STACKSIZE)
|
| error(ESTACK);
|
| else
|
| stack[sp++].i=i;
|
| }
|
|
|
| index_t popinteger() {
|
|
|
| if (DEBUG) {
|
| outsc("** pop sp= "); outnumber(sp); outcr();
|
| outsc("** pop value= "); outnumber(stack[sp-1].i); outcr();
|
| }
|
|
|
| if (sp == 0) { error(ESTACK); return 0; }
|
|
|
| return stack[--sp].i;
|
| }
|
|
|
|
|
|
|
| address_t popaddress(){
|
| number_t tmp = 0;
|
|
|
| tmp=pop();
|
| if (tmp < 0) { error(EORANGE); return 0;}
|
| return (address_t) tmp;
|
| }
|
|
|
| void clearst(){
|
| sp=0;
|
| }
|
|
|
|
|
| address_t charsp;
|
|
|
| void pushchar(char ch) {}
|
|
|
| char popchar() { return 0; }
|
|
|
| |
| |
|
|
| void clrdata() {
|
| #ifdef HASDARTMOUTH
|
| data=0;
|
| #endif
|
| }
|
|
|
| |
| |
| |
| |
|
|
|
|
|
|
| void pushloop(name_t* name, token_t t, address_t here, number_t to, number_t step) {
|
| address_t i;
|
|
|
| if (DEBUG) {
|
| outsc("** loopsp and here in pushloopstack ");
|
| outnumber(loopsp); outspc(); outnumber(here); outcr();
|
| if (name != 0) { outsc("** loop name "); outname(name); outcr(); }
|
| else { outsc("** loop name is 0"); outcr(); }
|
| outsc("** loop token "); outnumber(t); outcr();
|
| outsc("** loop to "); outnumber(to); outcr();
|
| outsc("** loop step "); outnumber(step); outcr();
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| for(i=0; i<loopsp; i++) {
|
| if (loopstack[i].here == here) {
|
| loopsp=i;
|
| break;
|
| }
|
| }
|
|
|
|
|
| if (name != 0) {
|
| for(i=0; i<loopsp; i++) {
|
| if (cmpname(&loopstack[i].var, name)) {
|
| loopsp=i;
|
| break;
|
| }
|
| }
|
| }
|
|
|
|
|
| if (loopsp < FORDEPTH) {
|
| if (t == TWHILE || t == TREPEAT) {
|
| loopstack[loopsp].var.token=t;
|
| } else {
|
| if (name != 0) {
|
| loopstack[loopsp].var=*name;
|
| } else {
|
| loopstack[loopsp].var.c[0]=0;
|
| loopstack[loopsp].var.l=0;
|
| loopstack[loopsp].var.token=0;
|
| }
|
| }
|
| loopstack[loopsp].here=here;
|
| loopstack[loopsp].to=to;
|
| loopstack[loopsp].step=step;
|
| loopsp++;
|
| return;
|
| } else
|
| error(ELOOP);
|
| }
|
|
|
|
|
| bloop_t* activeloop() {
|
| if (loopsp>0) {
|
| return &loopstack[loopsp-1];
|
| } else {
|
| error(ELOOP);
|
| return 0;
|
| }
|
| }
|
|
|
| void droploop() {
|
| if (loopsp>0) {
|
| loopsp--;
|
| } else {
|
| error(ELOOP);
|
| return;
|
| }
|
| }
|
|
|
| void clrforstack() {
|
| loopsp=0;
|
| }
|
|
|
|
|
| void pushgosubstack(mem_t a){
|
| if (gosubsp < GOSUBDEPTH) {
|
| gosubstack[gosubsp]=here;
|
| #ifdef HASEVENTS
|
| gosubarg[gosubsp]=a;
|
| #endif
|
| gosubsp++;
|
| } else
|
| error(TGOSUB);
|
| }
|
|
|
| void popgosubstack(){
|
| if (gosubsp>0) {
|
| gosubsp--;
|
| } else {
|
| error(TRETURN);
|
| return;
|
| }
|
| here=gosubstack[gosubsp];
|
| }
|
|
|
| void dropgosubstack(){
|
| if (gosubsp>0) {
|
| gosubsp--;
|
| } else {
|
| error(TGOSUB);
|
| }
|
| }
|
|
|
| void clrgosubstack() {
|
| gosubsp=0;
|
| }
|
|
|
|
|
|
|
| void pushlocation(blocation_t* l) {
|
| if (st == SINT) l->location=bi-ibuffer;
|
| else l->location=here;
|
| l->token=token;
|
| }
|
|
|
| void poplocation(blocation_t* l) {
|
| if (st == SINT) bi=ibuffer+l->location;
|
| else here=l->location;
|
| token=l->token;
|
| }
|
|
|
|
|
|
|
|
|
| void outcr() {
|
| #ifdef HASSERIAL1
|
| if (sendcr) outch('\r');
|
| #endif
|
| outch('\n');
|
| }
|
|
|
|
|
| void outspc() {
|
| outch(' ');
|
| }
|
|
|
|
|
| void outsc(const char *c){ while (*c != 0) outch(*c++); }
|
|
|
| |
|
|
| void outscf(const char *c, index_t f){
|
| int i = 0;
|
|
|
| while (*c != 0) { outch(*c++); i++; }
|
| if (f > i) {
|
| f=f-i;
|
| while (f--) outspc();
|
| }
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
| address_t parsenumber(char *c, number_t *r) {
|
| address_t nd = 0;
|
|
|
| *r=0;
|
| while (*c >= '0' && *c <= '9' && *c != 0) {
|
| *r=*r*10+*c++-'0';
|
| nd++;
|
| if (nd == SBUFSIZE) break;
|
| }
|
| return nd;
|
| }
|
|
|
|
|
| #ifdef HASFLOAT
|
|
|
| address_t parsenumber2(char *c, number_t *r) {
|
| address_t nd = 0;
|
| index_t i;
|
| number_t fraction = 0;
|
| number_t exponent = 0;
|
| mem_t nexp = 0;
|
|
|
| *r=0;
|
|
|
|
|
| i=parsenumber(c, r);
|
| c+=i;
|
| nd+=i;
|
|
|
|
|
| if (*c == '.') {
|
| c++;
|
| nd++;
|
|
|
| i=parsenumber(c, &fraction);
|
| c+=i;
|
| nd+=i;
|
|
|
| if (i > 0) {
|
| while ((--i)>=0) fraction=fraction/10;
|
| *r+=fraction;
|
| }
|
| }
|
|
|
|
|
| if (*c == 'E' || *c == 'e') {
|
| c++;
|
| nd++;
|
| if (*c == '-') {c++; nd++; nexp=1;};
|
| i=parsenumber(c, &exponent);
|
| nd+=i;
|
| while ((--exponent)>=0) if (nexp) *r=*r/10; else *r=*r*10;
|
| }
|
|
|
| return nd;
|
| }
|
| #endif
|
|
|
| |
| |
| |
| |
|
|
| address_t writenumber(char *c, wnumber_t v){
|
| address_t nd = 0;
|
| index_t i,j;
|
| mem_t s = 1;
|
| char c1;
|
|
|
|
|
| if (v<0) s=-1;
|
|
|
|
|
| do {
|
| c[nd++]=(v%10)*s+'0';
|
| v=v/10;
|
| } while (v != 0);
|
|
|
|
|
| if (s < 0 ) c[nd]='-'; else nd--;
|
|
|
|
|
| i=0;
|
| j=nd;
|
| while (j>i) {
|
| c1=c[i];
|
| c[i]=c[j];
|
| c[j]=c1;
|
| i++;
|
| j--;
|
| }
|
|
|
| nd++;
|
| c[nd]=0;
|
| return nd;
|
| }
|
|
|
| #ifdef HASFLOAT
|
| |
| |
| |
|
|
| address_t tinydtostrf(number_t v, index_t p, char* c) {
|
| index_t i;
|
| address_t nd = 0;
|
| number_t f;
|
|
|
|
|
| if (forceint) {
|
| v=trunc(v);
|
| return writenumber(c, (int)v);
|
| }
|
|
|
|
|
| if (v<0) {
|
| v=fabs(v);
|
| c[nd++]='-';
|
| }
|
|
|
|
|
| nd+=writenumber(c+nd, (int)v);
|
| c[nd++]='.';
|
|
|
|
|
| f=fabs(v);
|
|
|
|
|
| for (i=p; i>0; i--) {
|
| f=f-floor(f);
|
| f=f*10;
|
| c[nd++]=(int)floor(f)+'0';
|
| }
|
|
|
|
|
| c[nd]=0;
|
| return nd;
|
| }
|
|
|
| address_t writenumber2(char *c, number_t vi) {
|
| index_t i;
|
| index_t nd;
|
| number_t f;
|
| index_t exponent = 0;
|
| mem_t eflag=0;
|
| const int p = 5;
|
|
|
| |
|
|
| f=floor(vi);
|
| if (f == vi && fabs(vi) < maxnum) return writenumber(c, vi);
|
|
|
| |
| |
| |
|
|
|
|
|
|
| if (!isfinite(vi)) {
|
| c[0]='*';
|
| c[1]=0;
|
| return 1;
|
| }
|
|
|
|
|
| f=vi;
|
| while (fabs(f)<1.0) { f=f*10; exponent--; }
|
| while (fabs(f)>=10.0-0.00001) { f=f/10; exponent++; }
|
|
|
|
|
|
|
| if (exponent > -2 && exponent < 7) {
|
| tinydtostrf(vi, 5, c);
|
| } else {
|
| tinydtostrf(f, 5, c);
|
| eflag=1;
|
| }
|
|
|
|
|
| for (i=0; (i < SBUFSIZE && c[i] !=0 ); i++);
|
| i--;
|
|
|
|
|
| while (c[i] == '0' && i>1) { i--; }
|
| i++;
|
|
|
|
|
| if (eflag && exponent != 0) {
|
| c[i++]='E';
|
| i+=writenumber(c+i, exponent);
|
| }
|
|
|
| c[i]=0;
|
| return i;
|
|
|
| }
|
| #endif
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| int innumber(number_t *r, char* buffer, address_t k) {
|
| address_t i = k;
|
| mem_t s = 1;
|
|
|
| #ifndef HASTINYBASICINPUT
|
|
|
| *r=0;
|
|
|
|
|
| while ((buffer[i] == ' ' || buffer[i] == '\t') && i <= (address_t) buffer[0]) i++;
|
|
|
|
|
| if (i > (address_t) buffer[0]) return 0;
|
|
|
|
|
| if (buffer[i] == '-') { s=-1; i++; }
|
|
|
|
|
| if (buffer[i] == BREAKCHAR) return -1;
|
|
|
|
|
| #ifndef HASFLOAT
|
| if (buffer[i] < '0' || buffer[i] > '9') return 0;
|
| i+=parsenumber(&buffer[i], r);
|
| #else
|
| if ((buffer[i] < '0' || buffer[i] > '9') && buffer[i] != '.') return 0;
|
| i+=parsenumber2(&buffer[i], r);
|
| #endif
|
|
|
|
|
| *r*=s;
|
| return i;
|
| #else
|
| char *b;
|
| token_t t;
|
|
|
|
|
| *r=0;
|
|
|
|
|
| b=bi;
|
| s=st;
|
| t=token;
|
|
|
|
|
| st=SINT;
|
| bi=buffer+k;
|
|
|
|
|
| if (*bi == BREAKCHAR) {
|
| return -1;
|
| }
|
|
|
|
|
| nexttoken();
|
| expression();
|
|
|
|
|
| i=bi-buffer-1;
|
| bi=b;
|
| st=s;
|
| token=t;
|
|
|
|
|
| if (er) {
|
| er=0;
|
| return 0;
|
| }
|
|
|
|
|
| *r=pop();
|
| return i;
|
| #endif
|
| }
|
|
|
|
|
| void outnumber(number_t n){
|
| address_t nd, i;
|
|
|
|
|
| #ifndef HASFLOAT
|
| nd=writenumber(sbuffer, n);
|
| #else
|
| nd=writenumber2(sbuffer, n);
|
| #endif
|
|
|
|
|
| if (form < 0) { i=nd; while(i < -form) {outspc(); i++;} }
|
|
|
|
|
| outs(sbuffer, nd);
|
|
|
|
|
| if (form > 0) { while (nd < form) {outspc(); nd++;} }
|
| }
|
|
|
| |
| |
| |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| void whitespaces(){
|
| while (*bi == ' ' || *bi == '\t') bi++;
|
| }
|
|
|
|
|
| char btoupper(char c) {
|
| if (c >= 'a' && c <= 'z') return c-32; else return c;
|
| }
|
|
|
|
|
| void nexttoken() {
|
| address_t k, l, i;
|
| char* ir;
|
| char quotechar;
|
|
|
|
|
| if (st == SRUN || st == SERUN) {
|
|
|
| fastticker();
|
|
|
| gettoken();
|
|
|
| if (debuglevel>1) { debugtoken(); outcr(); }
|
| return;
|
| }
|
|
|
|
|
| if (bi == ibuffer) bi++;
|
|
|
|
|
| if (lexliteral) {
|
| token=*bi;
|
| if (*bi != '\0') bi++; else lexliteral=0;
|
| return;
|
| }
|
|
|
|
|
| whitespaces();
|
|
|
|
|
| if (*bi == '\0') {
|
| token=EOL;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
|
|
| #ifndef HASFLOAT
|
| if (*bi <='9' && *bi >= '0') {
|
| bi+=parsenumber(bi, &x);
|
| #else
|
| if ((*bi <='9' && *bi >= '0') || *bi == '.') {
|
| bi+=parsenumber2(bi, &x);
|
| #endif
|
| token=NUMBER;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
|
|
| if (*bi == '"' || *bi == '\'') {
|
| quotechar=*bi;
|
| k=0;
|
| bi++;
|
| ir=bi;
|
| sr.ir=bi;
|
| while(*bi != quotechar && *bi !='\0') {
|
| k++;
|
| bi++;
|
| }
|
| bi++;
|
| token=STRING;
|
| sr.length=k;
|
| sr.address=0;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
| |
| |
| |
| |
|
|
| if (*bi == '=') {
|
| bi++;
|
| whitespaces();
|
| if (*bi == '>') {
|
| token=GREATEREQUAL;
|
| bi++;
|
| } else if (*bi == '<') {
|
| token=LESSEREQUAL;
|
| bi++;
|
| } else {
|
| token='=';
|
| }
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
| if (*bi == '>'){
|
| bi++;
|
| whitespaces();
|
| if (*bi == '=') {
|
| token=GREATEREQUAL;
|
| bi++;
|
| } else {
|
| token='>';
|
| }
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
| if (*bi == '<'){
|
| bi++;
|
| whitespaces();
|
| if (*bi == '=') {
|
| token=LESSEREQUAL;
|
| bi++;
|
| } else if (*bi == '>') {
|
| token=NOTEQUAL;
|
| bi++;
|
| } else {
|
| token='<';
|
| }
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
|
|
|
|
| l=0;
|
| ir=bi;
|
| while (-1) {
|
| if (*ir >= 'a' && *ir <= 'z') {
|
| if (!lowercasenames) *ir-=32;
|
| ir++;
|
| l++;
|
| } else if ((*ir >= '@' && *ir <= 'Z') || *ir == '_') {
|
| ir++;
|
| l++;
|
| } else {
|
| break;
|
| }
|
| }
|
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| k=0;
|
| while (gettokenvalue(k) != 0) {
|
| ir=getkeyword(k);
|
| i=0;
|
| while (*(ir+i) != 0) {
|
| if (*(ir+i) != btoupper(*(bi+i))) {
|
| k++;
|
| i=0;
|
| break;
|
| } else
|
| i++;
|
| }
|
| if (i == 0) continue;
|
| bi+=i;
|
| token=gettokenvalue(k);
|
| if (token == TREM) lexliteral=1;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifdef HASLONGNAMES
|
| if (l>0 && l<=MAXNAME) {
|
| token=VARIABLE;
|
| zeroname(&name);
|
| while (((*bi >= '0' && *bi <= '9') ||
|
| (*bi >= '@' && *bi <= 'Z') ||
|
| (*bi >= 'a' && *bi <= 'z') ||
|
| (*bi == '_') ) && name.l < MAXNAME && *bi != 0) {
|
| name.c[name.l]=*bi;
|
| bi++;
|
| name.l++;
|
| }
|
| if (*bi == '$') {
|
| token=STRINGVAR;
|
| bi++;
|
| }
|
| whitespaces();
|
| if (token == VARIABLE && *bi == '(' ) {
|
| token=ARRAYVAR;
|
| }
|
|
|
| name.token=token;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
| #else
|
| if (l == 1 || l == 2) {
|
| token=VARIABLE;
|
| name.l=0;
|
| name.c[0]=*bi;
|
| name.c[1]=0;
|
| bi++;
|
| if ((*bi >= '0' && *bi <= '9') || (*bi >= 'A' && *bi <= 'Z') || *bi == '_' ) {
|
| name.c[1]=*bi;
|
| bi++;
|
| }
|
| if (*bi == '$') {
|
| token=STRINGVAR;
|
| bi++;
|
| }
|
| whitespaces();
|
| if (token == VARIABLE && *bi == '(' ) {
|
| token=ARRAYVAR;
|
| }
|
|
|
| name.token=token;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
| #endif
|
|
|
|
|
| token=*bi;
|
| bi++;
|
| if (DEBUG) debugtoken();
|
| return;
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| |
| |
| |
| |
|
|
| char nomemory(number_t b){
|
| #ifndef EEPROMMEMINTERFACE
|
| if (top >= himem-b) return 1; else return 0;
|
| #else
|
| if (top >= elength()-eheadersize-b) return 1; else return 0;
|
| #endif
|
| }
|
|
|
|
|
| void storetoken() {
|
| int i;
|
|
|
| switch (token) {
|
| case LINENUMBER:
|
| if (nomemory(addrsize+1)) break;
|
| memwrite2(top++, token);
|
| setaddress(top, memwrite2, ax);
|
| top+=addrsize;
|
| return;
|
| case NUMBER:
|
| if (nomemory(numsize+1)) break;
|
| memwrite2(top++, token);
|
| setnumber(top, memwrite2, x);
|
| top+=numsize;
|
| return;
|
| case ARRAYVAR:
|
| case VARIABLE:
|
| case STRINGVAR:
|
| if (nomemory(sizeof(name_t))) break;
|
| memwrite2(top++, token);
|
| top=setname_pgm(top, &name);
|
| return;
|
| case STRING:
|
| i=sr.length;
|
| if (nomemory(i+2)) break;
|
| memwrite2(top++, token);
|
| memwrite2(top++, i);
|
| while (i > 0) { memwrite2(top++, *sr.ir++); i--; }
|
| return;
|
| default:
|
| if (token >= -127) {
|
| if (nomemory(1)) break;
|
| memwrite2(top++, token);
|
| } else {
|
| #ifdef HASLONGTOKENS
|
| if (nomemory(2)) break;
|
| memwrite2(top++, TEXT1);
|
| memwrite2(top++, token+255);
|
| #endif
|
| }
|
| return;
|
| }
|
| }
|
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifndef USEMEMINTERFACE
|
| mem_t memread(address_t a) {
|
| if (st != SERUN) {
|
| return mem[a];
|
| } else {
|
| return eread(a+eheadersize);
|
| }
|
| }
|
|
|
| mem_t memread2(address_t a) { return mem[a]; }
|
|
|
| void memwrite2(address_t a, mem_t c) { mem[a]=c; }
|
| #else
|
| #if defined(SPIRAMINTERFACE) || defined(SPIRAMSIMULATOR)
|
| mem_t memread(address_t a) {
|
| if (st != SERUN) {
|
| return spiram_robufferread(a);
|
| } else {
|
| return eread(a+eheadersize);
|
| }
|
| }
|
|
|
| mem_t memread2(address_t a) { return spiram_rwbufferread(a); }
|
|
|
| void memwrite2(address_t a, mem_t c) { spiram_rwbufferwrite(a, c); }
|
| #else
|
| #ifdef EEPROMMEMINTERFACE
|
| mem_t memread(address_t a) {
|
| if (a < elength()-eheadersize) return eread(a+eheadersize); else return mem[a-(elength()-eheadersize)];
|
| }
|
|
|
| mem_t memread2(address_t a) { return memread(a); }
|
|
|
| void memwrite2(address_t a, mem_t c) {
|
| if (a < elength()-eheadersize) eupdate(a+eheadersize, c); else mem[a-(elength()-eheadersize)]=c;
|
| }
|
| #endif
|
| #endif
|
| #endif
|
|
|
|
|
|
|
| void gettoken() {
|
| stringlength_t i;
|
|
|
| |
|
|
| if (here >= top) {
|
| token=EOL;
|
| return;
|
| }
|
|
|
|
|
| token=memread(here++);
|
| name.token=token;
|
|
|
|
|
| #ifdef HASLONGTOKENS
|
| if (token == TEXT1) {
|
| token=memread(here++)-255;
|
| }
|
| #endif
|
|
|
|
|
| switch (token) {
|
| case LINENUMBER:
|
| ax=getaddress(here, memread);
|
| here+=addrsize;
|
| break;
|
| case NUMBER:
|
| x=getnumber(here, memread);
|
| here+=numsize;
|
| break;
|
| case ARRAYVAR:
|
| case VARIABLE:
|
| case STRINGVAR:
|
| here=getname(here, &name, memread);
|
| name.token=token;
|
| break;
|
| case STRING:
|
| sr.length=(unsigned char)memread(here++);
|
|
|
| |
| |
| |
| |
|
|
| if (st == SERUN) {
|
| for(i=0; i<sr.length; i++) ibuffer[i]=memread(here+i);
|
| sr.ir=ibuffer;
|
| } else {
|
| #ifndef USEMEMINTERFACE
|
| sr.ir=(char*)&mem[here];
|
| #else
|
| sr.ir=0;
|
| #endif
|
| }
|
| sr.address=here;
|
| here+=sr.length;
|
| }
|
| }
|
|
|
|
|
| void firstline() {
|
| if (top == 0) {
|
| ax=0;
|
| return;
|
| }
|
| here=0;
|
| gettoken();
|
| }
|
|
|
|
|
| void nextline() {
|
| while (here < top) {
|
| gettoken();
|
| if (token == LINENUMBER) return;
|
| if (here >= top) {
|
| here=top;
|
| ax=0;
|
| return;
|
| }
|
| }
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
| #if defined(LINECACHESIZE) && LINECACHESIZE>0
|
| const unsigned char linecachedepth = LINECACHESIZE;
|
| typedef struct {address_t l; address_t h;} linecacheentry;
|
| linecacheentry linecache[LINECACHESIZE];
|
| unsigned char linecachehere = 0;
|
|
|
| void clrlinecache() {
|
| unsigned char i;
|
|
|
| for(i=0; i<linecachedepth; i++) linecache[i].l=linecache[i].h=0;
|
| linecachehere=0;
|
| }
|
|
|
| void addlinecache(address_t l, address_t h) {
|
| linecache[linecachehere].l=l;
|
| linecache[linecachehere].h=h;
|
| linecachehere=(linecachehere+1)%linecachedepth;
|
| }
|
|
|
| address_t findinlinecache(address_t l){
|
| unsigned char i;
|
|
|
| for(i=0; i<linecachedepth && linecache[i].l != 0; i++) {
|
| if (linecache[i].l == l) return linecache[i].h;
|
| }
|
| return 0;
|
| }
|
| #else
|
| void clrlinecache() {}
|
| void addlinecache(address_t l, address_t h) {}
|
| address_t findinlinecache(address_t l){ return 0; }
|
| #endif
|
|
|
|
|
| |
| |
| |
| |
|
|
| void findline(address_t l) {
|
| address_t a;
|
|
|
|
|
| if ((a=findinlinecache(l))) {
|
| here=a;
|
| token=LINENUMBER;
|
| ax=l;
|
| return;
|
| }
|
|
|
|
|
| here=0;
|
| while (here < top) {
|
| gettoken();
|
| if (token == LINENUMBER && ax == l ) {
|
|
|
| addlinecache(l, here);
|
| return;
|
| }
|
| }
|
| error(ELINE);
|
| }
|
|
|
|
|
| address_t myline(address_t h) {
|
| address_t l=0;
|
| address_t l1=0;
|
| address_t here2;
|
|
|
| here2=here;
|
| here=0;
|
| gettoken();
|
| while (here < top) {
|
| if (token == LINENUMBER) {
|
| l1=l;
|
| l=ax;
|
| }
|
| if (here >= h) break;
|
| gettoken();
|
| }
|
| here=here2;
|
| if (token == LINENUMBER)
|
| return l1;
|
| else
|
| return l;
|
| }
|
|
|
| |
| |
| |
|
|
| void moveblock(address_t b, address_t l, address_t d) {
|
| address_t i;
|
|
|
| if (d+l > himem) {
|
| error(EOUTOFMEMORY);
|
| return;
|
| }
|
| if (l<1) return;
|
|
|
| if (b < d) for (i=l; i>0; i--) memwrite2(d+i-1, memread2(b+i-1));
|
| else for (i=0; i<l; i++) memwrite2(d+i, memread2(b+i));
|
| }
|
|
|
|
|
| void zeroblock(address_t b, address_t l){
|
| address_t i;
|
|
|
| if (b+l > himem) { error(EOUTOFMEMORY); return; }
|
| if (l<1) return;
|
|
|
| for (i=0; i<l+1; i++) memwrite2(b+i, 0);
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifdef DEBUG
|
|
|
| void diag(){
|
| outsc("top, here, y and x\n");
|
| outnumber(top); outspc();
|
| outnumber(here); outspc();
|
| outcr();
|
| }
|
| #endif
|
|
|
| void storeline() {
|
| const index_t lnlength=addrsize+1;
|
| index_t linelength;
|
| number_t newline;
|
| address_t here2, here3;
|
| address_t t1, t2;
|
| address_t y;
|
|
|
|
|
| clrdata();
|
|
|
|
|
| clrlinecache();
|
|
|
| if (DEBUG) { outsc("storeline "); outnumber(ax); outsc(" : "); outsc(ibuffer); outcr(); }
|
|
|
| |
| |
| |
|
|
| t1=ax;
|
| here=top;
|
| newline=here;
|
| token=LINENUMBER;
|
| do {
|
| storetoken();
|
| if (er != 0 ) {
|
| top=newline;
|
| here=0;
|
| return;
|
| }
|
| nexttoken();
|
| } while (token != EOL);
|
|
|
| ax=t1;
|
| linelength=top-here;
|
|
|
| |
| |
|
|
| if (linelength == (lnlength)) {
|
| top-=(lnlength);
|
| findline(ax);
|
| if (er) return;
|
| y=here-lnlength;
|
| nextline();
|
| here-=lnlength;
|
| if (ax != 0) {
|
| moveblock(here, top-here, y);
|
| top=top-(here-y);
|
| } else {
|
| top=y;
|
| }
|
| return;
|
| }
|
|
|
| |
| |
| |
|
|
| else {
|
| y=ax;
|
| here2=here;
|
| here=lnlength;
|
| nextline();
|
|
|
| if (ax == 0) return;
|
|
|
| here=0;
|
| here2=0;
|
| while (here < top) {
|
| here3=here2;
|
| here2=here;
|
| nextline();
|
| if (ax > y) break;
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
| if (ax == 0) {
|
| here=here3-lnlength;
|
| gettoken();
|
| if (token == LINENUMBER && ax == y) {
|
| here2-=lnlength;
|
| here-=lnlength;
|
| moveblock(here2, linelength, here);
|
| top=here+linelength;
|
| }
|
| return;
|
| }
|
| here-=lnlength;
|
| t1=here;
|
| here=here2-lnlength;
|
| t2=here;
|
| gettoken();
|
| if (ax == y) {
|
| here2=t2;
|
| here=t1;
|
| y=here-here2;
|
| if (linelength == y) {
|
| moveblock(top-linelength, linelength, here2);
|
| top=top-linelength;
|
| } else if (linelength > y) {
|
| moveblock(here, top-here, here+linelength-y);
|
| here=here+linelength-y;
|
| top=top+linelength-y;
|
| moveblock(top-linelength, linelength, here2);
|
| top=top-linelength;
|
| } else {
|
| moveblock(top-linelength, linelength, here2);
|
| top=top-linelength;
|
| moveblock(here, top-here, here2+linelength);
|
| top=top-y+linelength;
|
| }
|
| } else {
|
| here=t1;
|
| moveblock(here, top-here, here+linelength);
|
| moveblock(top, linelength, here);
|
| }
|
| }
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| char termsymbol() {
|
| return (token == LINENUMBER || token == ':' || token == EOL || token == TELSE);
|
| }
|
|
|
|
|
| char expect(token_t t, mem_t e) {
|
| nexttoken();
|
| if (token != t) {error(e); return 0; } else return 1;
|
| }
|
|
|
|
|
| char expectexpr() {
|
| nexttoken();
|
| expression();
|
| if (er != 0) return 0; else return 1;
|
| }
|
|
|
|
|
| void parsearguments() {
|
| short argsl;
|
|
|
|
|
| argsl=0;
|
|
|
|
|
| if (!termsymbol()) {
|
|
|
|
|
| do {
|
| expression();
|
| if (er != 0) break;
|
| argsl++;
|
| if (token == ',') nexttoken(); else break;
|
| } while (1);
|
| }
|
|
|
|
|
| args=argsl;
|
| }
|
|
|
|
|
|
|
| void parsenarguments(char n) {
|
| parsearguments();
|
| if (args != n) error(EARGS);
|
| }
|
|
|
| |
|
|
| void parsesubscripts() {
|
| blocation_t l;
|
|
|
| args=0;
|
|
|
| if (DEBUG) {
|
| outsc("** in parsesubscripts "); outcr();
|
| bdebug("token ");
|
| }
|
|
|
|
|
| pushlocation(&l);
|
|
|
| |
|
|
| nexttoken();
|
|
|
|
|
| if (token != '(') {
|
| poplocation(&l);
|
| return;
|
| }
|
| nexttoken();
|
|
|
|
|
| #ifdef HASMULTIDIM
|
| if (token == ')') {
|
| args=-1;
|
| return;
|
| }
|
| #endif
|
|
|
|
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (token != ')') { error(EARGS); return; }
|
|
|
|
|
| }
|
|
|
| |
| |
|
|
|
|
| void parsefunction(void (*f)(), short ae){
|
| parsesubscripts();
|
| if (!USELONGJUMP && er) return;
|
| if (args == ae) f(); else error(EARGS);
|
| }
|
|
|
|
|
| void parseoperator(void (*f)()) {
|
| mem_t u=1;
|
|
|
| nexttoken();
|
|
|
| if (token == '-') {
|
| u=-1;
|
| nexttoken();
|
| }
|
|
|
| f();
|
| if (er !=0 ) return;
|
| y=pop();
|
| if (u == -1) y=-y;
|
| x=pop();
|
| }
|
|
|
| |
| |
|
|
| void xabs(){
|
| number_t x;
|
|
|
| if ((x=pop())<0) { x=-x; }
|
| push(x);
|
| }
|
|
|
| |
| |
|
|
| void xsgn(){
|
| number_t x;
|
|
|
| x=pop();
|
| if (x>0) x=1;
|
| if (x<0) x=-1;
|
| push(x);
|
| }
|
|
|
| |
| |
| |
|
|
| void xpeek(){
|
| number_t a;
|
|
|
|
|
| a=pop();
|
|
|
|
|
| if (a >= 0 && a<=memsize)
|
| push(memread2(a));
|
| else if (a < 0 && -a <= elength())
|
| push(eread(-a-1));
|
| else {
|
| error(EORANGE);
|
| return;
|
| }
|
| }
|
|
|
| |
| |
| |
|
|
| void xmap() {
|
| long v, in_min, in_max, out_min, out_max;
|
|
|
| out_max=pop();
|
| out_min=pop();
|
| in_max=pop();
|
| in_min=pop();
|
| v=pop();
|
| push((v - in_min) * (out_max - out_min) / (in_max - in_min) + out_min);
|
| }
|
|
|
| |
| |
| |
|
|
|
|
| void xrnd() {
|
| number_t r;
|
| mem_t base = randombase;
|
|
|
|
|
| r=pop();
|
|
|
|
|
| if (randombase < 0) {
|
| base=0;
|
| if (r < 0) {
|
| rd=-r;
|
| r=1;
|
| } else if (r == 0) {
|
| r=1;
|
| goto pushresult;
|
| } else {
|
| r=1;
|
| }
|
| }
|
|
|
|
|
| #ifndef HASFLOAT
|
|
|
| rd = (31421*rd + 6927) & 0xffff;
|
| #else
|
|
|
| rd = (110351245*rd + 12345) & 0x7fffffff;
|
| #endif
|
|
|
| pushresult:
|
|
|
|
|
| #ifndef HASFLOAT
|
| if (r>=0)
|
| push((unsigned long)rd*r/0x10000+base);
|
| else
|
| push((unsigned long)rd*r/0x10000+1-base);
|
| #else
|
| if (r>=0)
|
| push(rd*r/0x80000000+base);
|
| else
|
| push(rd*r/0x80000000+1-base);
|
| #endif
|
| }
|
|
|
|
|
| #ifndef HASFLOAT
|
| |
| |
| |
|
|
| void sqr(){
|
| number_t t,r;
|
| number_t l=0;
|
|
|
| r=pop();
|
| t=r;
|
| while (t > 0) {
|
| t>>=1;
|
| l++;
|
| }
|
| l=l/2;
|
| t=1;
|
| t<<=l;
|
| do {
|
| l=t;
|
| t=(t+r/t)/2;
|
| } while (abs(t-l)>1);
|
| push(t);
|
| }
|
| #else
|
| void sqr(){
|
| push(sqrt(pop()));
|
| }
|
| #endif
|
|
|
| |
| |
|
|
|
|
|
|
| void xpow(){
|
| number_t n;
|
| number_t a;
|
|
|
| n=pop();
|
| a=pop();
|
| push(bpow(a, n));
|
| }
|
|
|
|
|
| number_t bpow(number_t x, number_t y) {
|
| #ifdef HASFLOAT
|
| return pow(x, y);
|
| #else
|
| number_t r;
|
| address_t i;
|
|
|
| r=1;
|
| if (y>=0) for(i=0; i<y; i++) r*=x;
|
| else r=0;
|
| return r;
|
| #endif
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| void parsestringvar(string_t* strp, lhsobject_t* lhs) {
|
| #ifdef HASAPPLE1
|
| blocation_t l;
|
| address_t temp;
|
|
|
|
|
| lhs->name=name;
|
| lhs->i=1;
|
| lhs->j=arraylimit;
|
| lhs->i2=0;
|
| lhs->ps=1;
|
|
|
|
|
|
|
|
|
|
|
| pushlocation(&l);
|
|
|
|
|
| parsesubscripts();
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (DEBUG) { outsc("** in parsestringvar "); outnumber(args); outsc(" arguments \n"); }
|
|
|
|
|
| if (args == 0) {
|
|
|
| poplocation(&l);
|
| } else if (!substringmode) {
|
|
|
| if (args == 1) lhs->j=pop(); else { error(EORANGE); return; }
|
| } else {
|
|
|
| lhs->ps=0;
|
|
|
| if (args == 2) { lhs->i2=popaddress(); args--; }
|
| if (!USELONGJUMP && er) return;
|
| if (args == 1) { lhs->i=popaddress(); }
|
| if (!USELONGJUMP && er) return;
|
| if (args == -1) {}
|
|
|
| pushlocation(&l);
|
| nexttoken();
|
| if (token == '(') {
|
|
|
| nexttoken();
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| if (token != ')') { error(EUNKNOWN); return; }
|
| lhs->j=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| } else
|
| poplocation(&l);
|
| }
|
|
|
|
|
| if (!strp) return;
|
|
|
|
|
| getstring(strp, &lhs->name, lhs->i, lhs->j);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (!lhs->i2) lhs->i2=strp->length;
|
|
|
| if (DEBUG) {
|
| outsc("** in parsestringvar lower is "); outnumber(lhs->i); outcr();
|
| outsc("** in parsestringvar upper is "); outnumber(lhs->i2); outcr();
|
| outsc("** in parsestringvar array_index is "); outnumber(lhs->j); outcr();
|
| }
|
|
|
|
|
| if (lhs->i2-lhs->i+1 > 0) strp->length=lhs->i2-lhs->i+1; else strp->length=0;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** in parsestringvar, length ");
|
| outnumber(strp->length);
|
| outsc(" from "); outnumber(lhs->i); outspc(); outnumber(lhs->i2);
|
| outcr();
|
| }
|
|
|
|
|
| name=lhs->name;
|
| #else
|
| return;
|
| #endif
|
| }
|
|
|
|
|
| |
| |
| |
| |
|
|
|
|
| char stringvalue(string_t* strp) {
|
| address_t k, l;
|
| address_t i;
|
| token_t t;
|
| mem_t args=1;
|
|
|
| lhsobject_t lhs;
|
|
|
| if (DEBUG) outsc("** entering stringvalue \n");
|
|
|
|
|
| strp->address=0;
|
| strp->arraydim=0;
|
| strp->length=0;
|
| strp->strdim=0;
|
| strp->ir=0;
|
|
|
| switch(token) {
|
| case STRING:
|
|
|
| strp->ir=sr.ir;
|
| strp->length=sr.length;
|
| strp->address=sr.address;
|
| break;
|
| #ifdef HASAPPLE1
|
| case STRINGVAR:
|
| parsestringvar(strp, &lhs);
|
| break;
|
| case TSTR:
|
| nexttoken();
|
| if (token == '$') nexttoken();
|
| if (token != '(') { error(EARGS); return 0; }
|
| nexttoken();
|
| expression();
|
| if (er != 0) return 0;
|
| #ifdef HASFLOAT
|
| strp->length=writenumber2(sbuffer, pop());
|
| #else
|
| strp->length=writenumber(sbuffer, pop());
|
| #endif
|
| strp->ir=sbuffer;
|
| if (er != 0) return 0;
|
| if (token != ')') {error(EARGS); return 0; }
|
| break;
|
| #ifdef HASMSSTRINGS
|
| case TCHR:
|
| nexttoken();
|
| if (token == '$') nexttoken();
|
| if (token != '(') { error(EARGS); return 0; }
|
| nexttoken();
|
| expression();
|
| if (er != 0) return 0;
|
| *sbuffer=pop();
|
| strp->ir=sbuffer;
|
| strp->length=1;
|
| if (token != ')') {error(EARGS); return 0; }
|
| break;
|
| case TRIGHT:
|
| case TMID:
|
| case TLEFT:
|
| t=token;
|
| nexttoken();
|
| if (token == '$') nexttoken();
|
| if (token != '(') { error(EARGS); return 0; }
|
| nexttoken();
|
| if (token != STRINGVAR) { error(EARGS); return 0; }
|
| parsestringvar(strp, &lhs);
|
| if (er != 0) return 0;
|
| k=strp->length;
|
| nexttoken();
|
| if (token != ',') { error(EARGS); return 0; }
|
| nexttoken();
|
| expression();
|
| if (er != 0) return 0;
|
|
|
| switch (t) {
|
| case TRIGHT:
|
| l=popaddress();
|
| if (k < l) l=k;
|
| if (strp->address) strp->address=strp->address+(k-l);
|
| if (strp->ir) strp->ir=strp->ir+(k-l);
|
| break;
|
| case TLEFT:
|
| l=popaddress();
|
| if (k < l) l=k;
|
| break;
|
| case TMID:
|
| if (token == ',') {
|
| nexttoken();
|
| expression();
|
| if (er != 0) return 0;
|
| args++;
|
| }
|
| if (args == 1) {
|
| i=popaddress();
|
| l=0;
|
| if (i <= k) l=k-i+1;
|
| } else {
|
| l=popaddress();
|
| if (er != 0) return 0;
|
| i=popaddress();
|
| }
|
| if (k < i+l) l=k-i+1;
|
| if (l < 0) l=0;
|
| if (strp->address != 0) strp->address=strp->address+i-1;
|
| if (strp->ir) strp->ir=strp->ir+i-1;;
|
| break;
|
| }
|
| strp->length=l;
|
|
|
| if (token != ')') {error(EARGS); return 0; }
|
| break;
|
| #endif
|
| #endif
|
| default:
|
| return 0;
|
| }
|
| return 1;
|
| }
|
|
|
|
|
| |
| |
| |
| |
| |
|
|
|
|
| void streval(){
|
| token_t t;
|
| address_t k;
|
| string_t s1, s2;
|
| char* ir;
|
| address_t a;
|
| blocation_t l;
|
|
|
|
|
| if (!stringvalue(&s1)) { error(EUNKNOWN); return; }
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (DEBUG) { outsc("** in streval first string"); outcr(); }
|
|
|
|
|
| pushlocation(&l);
|
| t=token;
|
|
|
|
|
| nexttoken();
|
| if (token != '=' && token != NOTEQUAL) {
|
|
|
|
|
| poplocation(&l);
|
| token=t;
|
|
|
|
|
| if (s1.length == 0) push(0); else {
|
| if (s1.ir) push(s1.ir[0]);
|
| else if (s1.address) push(memread2(s1.address));
|
| else error(EGENERAL);
|
| }
|
|
|
| return;
|
| }
|
|
|
|
|
| t=token;
|
|
|
|
|
| nexttoken();
|
|
|
| if (DEBUG) {
|
| outsc("** in streval second string"); outcr();
|
| debugtoken(); outcr();
|
| }
|
|
|
|
|
| if (!stringvalue(&s2)){ error(EUNKNOWN); return; }
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (DEBUG) { outsc("** in streval result: "); outnumber(x); outcr(); }
|
|
|
|
|
| if (s2.length != s1.length) goto neq;
|
|
|
|
|
| #ifdef USEMEMINTERFACE
|
| if (s1.ir && s2.ir)
|
| for (k=0; k < s1.length; k++) { if (s1.ir[k] != s2.ir[k]) goto neq; }
|
| else if (s1.address && s2.address)
|
| for (k=0; k < s1.length; k++) { if (memread2(s1.address+k) != memread2(s2.address+k)) goto neq; }
|
| else {
|
| if (s1.address) { a=s1.address; ir=s2.ir; } else { a=s2.address; ir=s1.ir; }
|
| for (k=0; k < s1.length; k++) { if (memread2(a+k) != ir[k] ) goto neq; }
|
| }
|
| #else
|
| for (k=0; k < s1.length; k++) if (s1.ir[k] != s2.ir[k]) goto neq;
|
| #endif
|
|
|
|
|
| if (t == '=') push(booleanmode); else push(0);
|
| return;
|
| neq:
|
| if (t == '=') push(0); else push(booleanmode);
|
| return;
|
| }
|
|
|
|
|
| #ifdef HASFLOAT
|
| |
| |
| |
| |
| |
|
|
| void xsin() { push(sin(pop())); }
|
| void xcos() { push(cos(pop())); }
|
| void xtan() { push(tan(pop())); }
|
| void xatan() { push(atan(pop())); }
|
| void xlog() { push(log(pop())); }
|
| void xexp() { push(exp(pop())); }
|
| void xint() { push(floor(pop())); }
|
| #else
|
| void xint() {}
|
| #endif
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| void factorarray() {
|
| lhsobject_t object;
|
| number_t v;
|
|
|
|
|
| object.name=name;
|
|
|
|
|
| parsesubscripts();
|
| if (er != 0 ) return;
|
|
|
| switch(args) {
|
| case 1:
|
| object.i=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| object.j=arraylimit;
|
| break;
|
| #ifdef HASMULTIDIM
|
| case 2:
|
| object.j=popaddress();
|
| object.i=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| break;
|
| #endif
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
| array(&object, 'g', &v);
|
| push(v);
|
| }
|
|
|
|
|
| void factorlen() {
|
| #ifdef HASAPPLE1
|
| address_t a;
|
| string_t s;
|
| name_t n;
|
| lhsobject_t lhs;
|
|
|
| nexttoken();
|
| if ( token != '(') { error(EARGS); return; }
|
|
|
| nexttoken();
|
| switch(token) {
|
| case STRING:
|
| push(sr.length);
|
| nexttoken();
|
| break;
|
| case STRINGVAR:
|
| parsestringvar(&s, &lhs);
|
| push(s.length);
|
| nexttoken();
|
| break;
|
| #ifdef HASMSSTRINGS
|
| case TRIGHT:
|
| case TLEFT:
|
| case TMID:
|
| case TCHR:
|
| #endif
|
| case TSTR:
|
| error(EARGS);
|
| return;
|
| default:
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| n.token=TBUFFER;
|
| a=pop();
|
| n.c[0]=a%256;
|
| n.c[1]=a/256;
|
| push(blength(&n));
|
| }
|
|
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (token != ')') { error(EARGS); return; }
|
| #else
|
| push(0);
|
| #endif
|
| }
|
|
|
|
|
| void factorval() {
|
| index_t y;
|
| number_t x;
|
| string_t s;
|
| address_t a;
|
| char *ir;
|
|
|
| nexttoken();
|
| if (token != '(') { error(EARGS); return; }
|
|
|
| nexttoken();
|
| if (!stringvalue(&s)) { error(EUNKNOWN); return; }
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| vlength=0;
|
|
|
|
|
| #ifdef USEMEMINTERFACE
|
| if (!s.ir) getstringtobuffer(&s, spistrbuf1, SPIRAMSBSIZE);
|
| #endif
|
|
|
|
|
| stringtobuffer(sbuffer, &s);
|
| ir=sbuffer;
|
|
|
|
|
| while(*ir==' ' || *ir=='\t') { ir++; vlength++; }
|
|
|
|
|
| if(*ir=='-') { y=-1; ir++; vlength++; } else y=1;
|
|
|
| x=0;
|
| #ifdef HASFLOAT
|
| if ((a=parsenumber2(ir, &x)) > 0) {vlength+=a; ert=0; } else {vlength=0; ert=1;};
|
| #else
|
| if ((a=parsenumber(ir, &x)) > 0) {vlength+=a; ert=0; } else {vlength=0; ert=1;};
|
| #endif
|
| push(x*y);
|
|
|
| nexttoken();
|
| if (token != ')') { error(EARGS); return; }
|
| }
|
|
|
|
|
| #ifndef HASFULLINSTR
|
|
|
| void factorinstr() {
|
| char ch;
|
| address_t a;
|
| string_t s;
|
|
|
| nexttoken();
|
| if (token != '(') { error(EARGS); return; }
|
|
|
| nexttoken();
|
| if (!stringvalue(&s)) { error(EUNKNOWN); return; }
|
| if (!USELONGJUMP && er) return;
|
| nexttoken();
|
|
|
| if (token != ',') { error(EARGS); return; }
|
|
|
| nexttoken();
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
|
|
| ch=pop();
|
| if (s.address) {
|
| for (a=1; a<=s.length; a++) {if (memread2(s.address+a-1) == ch) break; }
|
| } else {
|
| for (a=1; a<=s.length; a++) {if (s.ir[a-1] == ch) break; }
|
| }
|
| if (a > s.length) a=0;
|
| push(a);
|
|
|
| if (token != ')') { error(EARGS); return; }
|
| }
|
| #else
|
|
|
| void factorinstr() {
|
| char ch;
|
| address_t a=1;
|
| address_t i=1;
|
| string_t search;
|
| string_t s;
|
|
|
| nexttoken();
|
| if (token != '(') { error(EARGS); return; }
|
| nexttoken();
|
|
|
|
|
| if(!stringvalue(&s)) { error(EUNKNOWN); return; }
|
| if (!USELONGJUMP && er) return;
|
| nexttoken();
|
|
|
| if (token != ',') { error(EARGS); return; }
|
| nexttoken();
|
|
|
|
|
| if (!stringvalue(&search)) { error(EUNKNOWN); return; }
|
| if (!USELONGJUMP && er) return;
|
| nexttoken();
|
|
|
|
|
| if (token == ',') {
|
| nexttoken();
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
|
|
| a=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| }
|
|
|
| if (token != ')') {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
|
|
|
|
| if (search.length == 0 || search.length+a > s.length || a == 0) {
|
| push(0);
|
| return;
|
| }
|
|
|
|
|
| while(i<=search.length) {
|
|
|
|
|
| if (search.address) {
|
| ch=memread2(search.address+i-1);
|
| } else {
|
| ch=search.ir[i-1];
|
| }
|
|
|
|
|
| if (s.address) {
|
| for (; a<=s.length; a++) {if (memread2(s.address+a-1) == ch) break; }
|
| } else {
|
| for (; a<=s.length; a++) {if ( s.ir[a-1] == ch ) break; }
|
| }
|
|
|
|
|
| if (a > s.length) {
|
| a=0;
|
| break;
|
| }
|
|
|
|
|
| i+=1;
|
|
|
| }
|
|
|
|
|
| if (i <= search.length) {
|
| a=0;
|
| } else {
|
| a=a-search.length+1;
|
| }
|
|
|
|
|
| push(a);
|
| }
|
| #endif
|
|
|
|
|
| void factornetstat() {
|
| address_t x=0;
|
|
|
| if (netconnected()) x=1;
|
| if (mqttstate() == 0) x+=2;
|
| push(x);
|
| }
|
|
|
|
|
| void factorasc() {
|
| #ifdef HASAPPLE1
|
| string_t s;
|
| lhsobject_t lhs;
|
|
|
| nexttoken();
|
| if ( token != '(') { error(EARGS); return; }
|
|
|
| nexttoken();
|
| switch(token) {
|
| case STRING:
|
| if (sr.ir) push(sr.ir[0]); else push(memread2(sr.address));
|
| nexttoken();
|
| break;
|
| case STRINGVAR:
|
| parsestringvar(&s, &lhs);
|
| if (s.length > 0) {
|
| if (s.ir) push(s.ir[0]); else push(memread2(s.address));
|
| } else
|
| push(0);
|
| nexttoken();
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
|
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (token != ')') { error(EARGS); return; }
|
| #else
|
| push(0);
|
| #endif
|
| }
|
|
|
| void factor(){
|
| if (DEBUG) bdebug("factor\n");
|
| switch (token) {
|
| case NUMBER:
|
| push(x);
|
| break;
|
| case VARIABLE:
|
| push(getvar(&name));
|
| break;
|
| case ARRAYVAR:
|
| factorarray();
|
| break;
|
| case '(':
|
| nexttoken();
|
| expression();
|
| if (er != 0 ) return;
|
| if (token != ')') { error(EARGS); return; }
|
| break;
|
|
|
| case TABS:
|
| parsefunction(xabs, 1);
|
| break;
|
| case TRND:
|
| parsefunction(xrnd, 1);
|
| break;
|
| case TSIZE:
|
| push(himem-top);
|
| break;
|
|
|
| #ifdef HASAPPLE1
|
| case TSGN:
|
| parsefunction(xsgn, 1);
|
| break;
|
| case TPEEK:
|
| parsefunction(xpeek, 1);
|
| break;
|
| case TLEN:
|
| factorlen();
|
| break;
|
| #ifdef HASIOT
|
| case TAVAIL:
|
| parsefunction(xavail, 1);
|
| break;
|
| case TOPEN:
|
| parsefunction(xfopen, 1);
|
| break;
|
| case TSENSOR:
|
| parsefunction(xfsensor, 2);
|
| break;
|
| case TVAL:
|
| factorval();
|
| break;
|
| case TINSTR:
|
| factorinstr();
|
| break;
|
| case TWIRE:
|
| parsefunction(xfwire, 1);
|
| break;
|
| #endif
|
| #ifdef HASERRORHANDLING
|
| case TERROR:
|
| push(erh);
|
| break;
|
| #endif
|
| case THIMEM:
|
| push(himem);
|
| break;
|
|
|
| case STRING:
|
| case STRINGVAR:
|
| #ifdef HASIOT
|
| case TSTR:
|
| #endif
|
| #ifdef HASMSSTRINGS
|
| case TLEFT:
|
| case TRIGHT:
|
| case TMID:
|
| case TCHR:
|
| #endif
|
| streval();
|
| if (er != 0 ) return;
|
| break;
|
| #endif
|
|
|
| #ifdef HASSTEFANSEXT
|
| case TSQR:
|
| parsefunction(sqr, 1);
|
| break;
|
| case TMAP:
|
| parsefunction(xmap, 5);
|
| break;
|
| case TUSR:
|
| parsefunction(xusr, 2);
|
| break;
|
| case TPOW:
|
| parsefunction(xpow, 2);
|
| break;
|
| #endif
|
|
|
| #ifdef HASARDUINOIO
|
| case TAREAD:
|
| parsefunction(xaread, 1);
|
| break;
|
| case TDREAD:
|
| parsefunction(xdread, 1);
|
| break;
|
| case TMILLIS:
|
| parsefunction(bmillis, 1);
|
| break;
|
| #ifdef HASPULSE
|
| case TPULSE:
|
| parsefunction(bpulsein, 3);
|
| break;
|
| #endif
|
| case TAZERO:
|
| #if defined(ARDUINO) && defined(A0)
|
| push(A0);
|
| #else
|
| push(0);
|
| #endif
|
| break;
|
| case TLED:
|
| #ifdef LED_BUILTIN
|
| push(LED_BUILTIN);
|
| #else
|
| push(0);
|
| #endif
|
| break;
|
| #endif
|
|
|
| #ifdef HASFLOAT
|
| case TSIN:
|
| parsefunction(xsin, 1);
|
| break;
|
| case TCOS:
|
| parsefunction(xcos, 1);
|
| break;
|
| case TTAN:
|
| parsefunction(xtan, 1);
|
| break;
|
| case TATAN:
|
| parsefunction(xatan, 1);
|
| break;
|
| case TLOG:
|
| parsefunction(xlog, 1);
|
| break;
|
| case TEXP:
|
| parsefunction(xexp, 1);
|
| break;
|
| #endif
|
|
|
| case TINT:
|
| parsefunction(xint, 1);
|
| break;
|
| #ifdef HASDARTMOUTH
|
| case TFN:
|
| xfn(0);
|
| break;
|
|
|
| case TDATA:
|
| push(datarc);
|
| break;
|
| #endif
|
| #ifdef HASDARKARTS
|
| case TMALLOC:
|
| parsefunction(xmalloc, 2);
|
| break;
|
| case TFIND:
|
| xfind();
|
| break;
|
| #endif
|
| #ifdef HASIOT
|
| case TNETSTAT:
|
| factornetstat();
|
| break;
|
| #endif
|
| #ifdef HASMSSTRINGS
|
| case TASC:
|
| factorasc();
|
| break;
|
| #endif
|
|
|
| default:
|
| error(EUNKNOWN);
|
| return;
|
| }
|
| }
|
|
|
|
|
| #ifdef POWERRIGHTTOLEFT
|
|
|
| void power() {
|
| if (DEBUG) bdebug("power\n");
|
| factor();
|
| if (!USELONGJUMP && er) return;
|
|
|
| nexttoken();
|
| if (DEBUG) bdebug("in power\n");
|
| if (token == '^'){
|
| parseoperator(power);
|
| if (!USELONGJUMP && er) return;
|
| push(bpow(x,y));
|
| }
|
| if (DEBUG) bdebug("leaving power\n");
|
| }
|
| #else
|
|
|
| void power() {
|
| if (DEBUG) bdebug("power\n");
|
| factor();
|
| if (!USELONGJUMP && er) return;
|
|
|
| nextpower:
|
| nexttoken();
|
| if (DEBUG) bdebug("in power\n");
|
| if (token == '^'){
|
| parseoperator(factor);
|
| push(bpow(x,y));
|
| goto nextpower;
|
| }
|
| if (DEBUG) bdebug("leaving power\n");
|
| }
|
| #endif
|
|
|
| |
| |
|
|
| void term(){
|
| if (DEBUG) bdebug("term\n");
|
| power();
|
| if (!USELONGJUMP && er) return;
|
|
|
| nextfactor:
|
| if (DEBUG) bdebug("in term\n");
|
| if (token == '*'){
|
| parseoperator(power);
|
| if (!USELONGJUMP && er) return;
|
| push(x*y);
|
| goto nextfactor;
|
| } else if (token == '/'){
|
| parseoperator(power);
|
| if (!USELONGJUMP && er) return;
|
| if (y != 0)
|
| #ifndef HASFLOAT
|
| push(x/y);
|
| #else
|
| if (forceint) push((int)x/(int)y); else push(x/y);
|
| #endif
|
| else {
|
| error(EDIVIDE);
|
| return;
|
| }
|
| goto nextfactor;
|
| } else if (token == '%') {
|
| parseoperator(power);
|
| if (!USELONGJUMP && er) return;
|
| if (y != 0)
|
| #ifndef HASFLOAT
|
| push(x%y);
|
| #else
|
| push((int)x%(int)y);
|
| #endif
|
| else {
|
| error(EDIVIDE);
|
| return;
|
| }
|
| goto nextfactor;
|
| }
|
| if (DEBUG) bdebug("leaving term\n");
|
| }
|
|
|
|
|
| void addexpression(){
|
| if (DEBUG) bdebug("addexp\n");
|
| if (token != '+' && token != '-') {
|
| term();
|
| if (!USELONGJUMP && er) return;
|
| } else {
|
| push(0);
|
| }
|
|
|
| nextterm:
|
| if (token == '+' ) {
|
| parseoperator(term);
|
| if (!USELONGJUMP && er) return;
|
| push(x+y);
|
| goto nextterm;
|
| } else if (token == '-'){
|
| parseoperator(term);
|
| if (!USELONGJUMP && er) return;
|
| push(x-y);
|
| goto nextterm;
|
| }
|
| }
|
|
|
|
|
| void compexpression() {
|
| if (DEBUG) bdebug("compexp\n");
|
| addexpression();
|
| if (!USELONGJUMP && er) return;
|
| switch (token){
|
| case '=':
|
| parseoperator(compexpression);
|
| if (!USELONGJUMP && er) return;
|
| push(x == y ? booleanmode : 0);
|
| break;
|
| case NOTEQUAL:
|
| parseoperator(compexpression);
|
| if (!USELONGJUMP && er) return;
|
| push(x != y ? booleanmode : 0);
|
| break;
|
| case '>':
|
| parseoperator(compexpression);
|
| if (!USELONGJUMP && er) return;
|
| push(x > y ? booleanmode : 0);
|
| break;
|
| case '<':
|
| parseoperator(compexpression);
|
| if (!USELONGJUMP && er) return;
|
| push(x < y ? booleanmode : 0);
|
| break;
|
| case LESSEREQUAL:
|
| parseoperator(compexpression);
|
| if (!USELONGJUMP && er) return;
|
| push(x <= y ? booleanmode : 0);
|
| break;
|
| case GREATEREQUAL:
|
| parseoperator(compexpression);
|
| if (!USELONGJUMP && er) return;
|
| push(x >= y ? booleanmode : 0);
|
| break;
|
| }
|
| }
|
|
|
| #ifdef HASAPPLE1
|
|
|
| void notexpression() {
|
| if (DEBUG) bdebug("notexp\n");
|
| if (token == TNOT) {
|
| nexttoken();
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| if (booleanmode == -1) push(~(short)pop());
|
| else if (pop() == 0) push(1); else push(0);
|
| } else
|
| compexpression();
|
| }
|
|
|
|
|
| void andexpression() {
|
| if (DEBUG) bdebug("andexp\n");
|
| notexpression();
|
| if (!USELONGJUMP && er) return;
|
| if (token == TAND) {
|
| parseoperator(expression);
|
| if (!USELONGJUMP && er) return;
|
| push((short)x & (short)y);
|
| }
|
| }
|
|
|
|
|
| void expression(){
|
| if (DEBUG) bdebug("exp\n");
|
| andexpression();
|
| if (!USELONGJUMP && er) return;
|
| if (token == TOR) {
|
| parseoperator(expression);
|
| if (!USELONGJUMP && er) return;
|
| push((short)x | (short)y);
|
| }
|
| }
|
| #else
|
|
|
|
|
| void expression(){
|
| if (DEBUG) bdebug("exp\n");
|
| compexpression();
|
| if (!USELONGJUMP && er) return;
|
| if (token == TOR) {
|
| parseoperator(expression);
|
| if (!USELONGJUMP && er) return;
|
| push((short)x | (short)y);
|
| }
|
| }
|
| #endif
|
|
|
| |
| |
| |
| |
| |
| |
|
|
|
|
| |
| |
| |
|
|
| void xprint(){
|
| char semicolon = 0;
|
| char oldod;
|
| char modifier = 0;
|
| string_t s;
|
| stringlength_t i;
|
|
|
| form=0;
|
| oldod=od;
|
| nexttoken();
|
|
|
| processsymbol:
|
|
|
| if (termsymbol()) {
|
| if (!semicolon) outcr();
|
| od=oldod;
|
| form=0;
|
| return;
|
| }
|
| semicolon=0;
|
|
|
|
|
| if (stringvalue(&s)) {
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| #ifdef USEMEMINTERFACE
|
| if (!s.ir) getstringtobuffer(&s, spistrbuf1, SPIRAMSBSIZE);
|
| #endif
|
| outs(s.ir, s.length);
|
|
|
| nexttoken();
|
| goto separators;
|
| }
|
|
|
|
|
| #ifdef HASMSSTRINGS
|
| if (token == TTAB || token == TSPC) {
|
| xtab();
|
| goto separators;
|
| }
|
| #endif
|
|
|
|
|
| if (token == '#' || token == '&') {
|
| modifier=token;
|
| nexttoken();
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
|
|
| switch(modifier) {
|
| case '#':
|
| form=pop();
|
| break;
|
| case '&':
|
| od=pop();
|
| break;
|
| }
|
| goto separators;
|
| }
|
|
|
| if (token != ',' && token != ';') {
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| outnumber(pop());
|
| }
|
|
|
|
|
| separators:
|
| if (termsymbol()) goto processsymbol;
|
|
|
| switch (token) {
|
| case ',':
|
| if (!modifier) outspc();
|
| case ';':
|
| semicolon=1;
|
| nexttoken();
|
| break;
|
| }
|
| modifier=0;
|
|
|
| goto processsymbol;
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| void lefthandside(lhsobject_t* lhs) {
|
|
|
|
|
| address_t temp;
|
|
|
| if (DEBUG) {
|
| outsc("assigning to variable ");
|
| outname(&lhs->name); outspc();
|
| outsc(" type "); outnumber(lhs->name.token);
|
| outcr();
|
| }
|
|
|
|
|
| lhs->i=1;
|
| lhs->i2=0;
|
| lhs->j=arraylimit;
|
| lhs->ps=1;
|
|
|
|
|
| switch (lhs->name.token) {
|
| case VARIABLE:
|
| nexttoken();
|
| break;
|
| case ARRAYVAR:
|
| parsesubscripts();
|
| if (!USELONGJUMP && er) return;
|
| switch(args) {
|
| case 1:
|
| lhs->i=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| lhs->j=arraylimit;
|
| break;
|
| case 2:
|
| lhs->j=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| lhs->i=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
| nexttoken();
|
| break;
|
| #ifdef HASAPPLE1
|
| case STRINGVAR:
|
| parsestringvar(0, lhs);
|
| nexttoken();
|
| break;
|
| #else
|
|
|
| #endif
|
| default:
|
| error(EUNKNOWN);
|
| return;
|
| }
|
|
|
| if (DEBUG) {
|
| outsc("** in assignment lefthandside with (i,j,ps,i2) ");
|
| outnumber(lhs->i); outspc();
|
| outnumber(lhs->j); outspc();
|
| outnumber(lhs->ps); outspc();
|
| outnumber(lhs->i2); outcr();
|
| outsc(" token is "); outputtoken();
|
| outsc(" at "); outnumber(here); outcr();
|
| }
|
| }
|
|
|
|
|
| void assignnumber2(lhsobject_t* lhs, number_t x) {
|
| string_t sr;
|
|
|
|
|
| switch (lhs->name.token) {
|
| case VARIABLE:
|
| setvar(&lhs->name, x);
|
| break;
|
| case ARRAYVAR:
|
| array(lhs, 's', &x);
|
| break;
|
| #ifdef HASAPPLE1
|
| case STRINGVAR:
|
|
|
|
|
| getstring(&sr, &lhs->name, lhs->i, lhs->j);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (sr.ir) sr.ir[0]=x; else if (sr.address) memwrite2(ax, x); else error(EUNKNOWN);
|
|
|
|
|
| if (lhs->ps)
|
| setstringlength(&lhs->name, 1, lhs->j);
|
| else
|
| if (sr.length < lhs->i && lhs->i <= sr.strdim)
|
| setstringlength(&lhs->name, lhs->i, lhs->j);
|
| break;
|
| #endif
|
| }
|
| }
|
|
|
| |
| |
|
|
| void assignment() {
|
| address_t newlength, copybytes;
|
| mem_t s;
|
| index_t k;
|
| char tmpchar;
|
| string_t sr, sl;
|
|
|
|
|
| lhsobject_t lhs;
|
|
|
|
|
| lhs.name=name;
|
|
|
| lefthandside(&lhs);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (token != '=') { error(EUNKNOWN); return; }
|
| nexttoken();
|
|
|
|
|
| switch (lhs.name.token) {
|
|
|
| case VARIABLE:
|
| case ARRAYVAR:
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| assignnumber2(&lhs, pop());
|
| break;
|
| #ifdef HASAPPLE1
|
|
|
| case STRINGVAR:
|
| nextstring:
|
|
|
|
|
| s=stringvalue(&sr);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (!s) {
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| tmpchar=pop();
|
| sr.length=1;
|
| sr.ir=&tmpchar;
|
| } else
|
| nexttoken();
|
|
|
| if (DEBUG) { outsc("* assigment stringcode at "); outnumber(here); outcr(); }
|
|
|
| |
|
|
|
|
|
|
|
|
|
|
| getstring(&sl, &lhs.name, lhs.i, lhs.j);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("* assigment stringcode "); outname(&lhs.name); outcr();
|
| outsc("** assignment source string length "); outnumber(sr.length); outcr();
|
| outsc("** assignment dest string length "); outnumber(sl.length); outcr();
|
| outsc("** assignment dest string dimension "); outnumber(sl.strdim); outcr();
|
| }
|
|
|
|
|
| if ((lhs.i2 == 0) && ((lhs.i+sr.length-1)>sl.strdim)) { error(EORANGE); return; };
|
|
|
|
|
| if ((lhs.i2 != 0) && lhs.i2>sl.strdim) { error(EORANGE); return; };
|
|
|
|
|
| if (lhs.i2 > 0) copybytes=((lhs.i2-lhs.i+1) > sr.length) ? sr.length : (lhs.i2-lhs.i+1);
|
| else copybytes=sr.length;
|
|
|
| if (DEBUG) { outsc("** assignment copybytes "); outnumber(copybytes); outcr(); }
|
|
|
|
|
| assignstring(&sl, &sr, copybytes);
|
|
|
| |
| |
| |
| |
|
|
| if (lhs.i2 == 0) {
|
| newlength = lhs.i+sr.length-1;
|
| } else {
|
| if (lhs.i+copybytes > sl.length) newlength=lhs.i+copybytes-1;
|
| else newlength=sl.length;
|
| }
|
|
|
| setstringlength(&lhs.name, newlength, lhs.j);
|
| |
| |
| |
| |
|
|
| addstring:
|
| if (token == '+') {
|
| lhs.i=lhs.i+copybytes;
|
| nexttoken();
|
| goto nextstring;
|
| }
|
| break;
|
| #endif
|
| }
|
| }
|
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
|
|
| void assignstring(string_t* sl, string_t* sr, stringlength_t copybytes) {
|
| stringlength_t k;
|
|
|
| |
|
|
|
|
| #ifdef USEMEMINTERFACE
|
|
|
| if (sl->address) {
|
|
|
|
|
|
|
| if (sr->address) {
|
| if (sr->address > sl->address)
|
| for (k=0; k<copybytes; k++) memwrite2(sl->address+k, memread2(sr->address+k));
|
| else
|
| for (k=1; k<=copybytes; k++) memwrite2(sl->address+copybytes-k, memread2(sr->address+copybytes-k));
|
| } else {
|
|
|
|
|
|
|
| for (k=0; k<copybytes; k++) memwrite2(sl->address+k, sr->ir[k]);
|
|
|
| }
|
| } else {
|
|
|
|
|
| error(EUNKNOWN);
|
| }
|
| #else
|
|
|
|
|
|
|
| if (sr->ir && sl->ir) {
|
| if (sr->ir > sl->ir)
|
| for (k=0; k<copybytes; k++) sl->ir[k]=sr->ir[k];
|
| else
|
| for (k=1; k<=copybytes; k++) sl->ir[copybytes-k]=sr->ir[copybytes-k];
|
| } else {
|
| error(EUNKNOWN);
|
| }
|
|
|
| #endif
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| void showprompt() {
|
| outsc("? ");
|
| }
|
|
|
| |
| |
|
|
| void xinput() {
|
|
|
| mem_t oldid = id;
|
| mem_t prompt = 1;
|
| number_t xv;
|
|
|
|
|
| lhsobject_t lhs;
|
|
|
| address_t maxlen, newlength;
|
| int k=0;
|
| string_t s;
|
| char* buffer;
|
| address_t bufsize;
|
|
|
|
|
|
|
| if (st == SRUN || st == SERUN) {
|
| buffer=ibuffer;
|
| bufsize=BUFSIZE;
|
| } else {
|
| buffer=sbuffer;
|
| bufsize=SBUFSIZE;
|
| }
|
|
|
|
|
| nexttoken();
|
|
|
|
|
| if (token == '&') {
|
| if(!expectexpr()) return;
|
| oldid=id;
|
| id=pop();
|
| if (id != ISERIAL || id !=IKEYBOARD) prompt=0;
|
| if (token != ',') {
|
| error(EUNKNOWN);
|
| return;
|
| } else
|
| nexttoken();
|
| }
|
|
|
| |
|
|
| if (token == '#') {
|
| if(!expectexpr()) return;
|
| form=pop();
|
| if (token != ',') {
|
| error(EUNKNOWN);
|
| return;
|
| } else
|
| nexttoken();
|
| }
|
|
|
|
|
| nextstring:
|
| if (token == STRING && id != IFILE) {
|
| prompt=0;
|
| #ifdef USEMEMINTERFACE
|
| if (!sr.ir) getstringtobuffer(&sr, spistrbuf1, SPIRAMSBSIZE);
|
| #endif
|
| outs(sr.ir, sr.length);
|
| nexttoken();
|
| }
|
|
|
|
|
| nextvariable:
|
| if (token == VARIABLE || token == ARRAYVAR || token == STRINGVAR) {
|
|
|
|
|
| lhs.name=name;
|
|
|
| lefthandside(&lhs);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| switch (lhs.name.token) {
|
| case VARIABLE:
|
| case ARRAYVAR:
|
| again:
|
|
|
| if (k == 0 || (address_t) buffer[0] < k) {
|
| if (prompt) showprompt();
|
| (void) ins(buffer, bufsize);
|
| k=1;
|
| }
|
|
|
|
|
| k=innumber(&xv, buffer, k);
|
|
|
|
|
| if (k == -1) {
|
| st=SINT;
|
| token=EOL;
|
| goto resetinput;
|
| }
|
|
|
|
|
| if (k == 0) {
|
| if (id == ISERIAL || id == IKEYBOARD) {
|
| printmessage(ENUMBER);
|
| outspc();
|
| printmessage(EGENERAL);
|
| outcr();
|
| xv=0;
|
| k=0;
|
| goto again;
|
| } else {
|
| ert=1;
|
| xv=0;
|
| goto resetinput;
|
| }
|
| }
|
|
|
|
|
| assignnumber2(&lhs, xv);
|
|
|
|
|
| while (k < (address_t) buffer[0] && buffer[k] != 0) {
|
| if (buffer[k] == ',') {
|
| k++;
|
| break;
|
| }
|
| k++;
|
| }
|
| break;
|
| #ifdef HASAPPLE1
|
| case STRINGVAR:
|
|
|
| getstring(&s, &lhs.name, lhs.i, lhs.j);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (lhs.i2 == 0) {
|
| maxlen=s.strdim-lhs.i+1;
|
| } else {
|
| maxlen=lhs.i2-lhs.i+1;
|
| if (maxlen > s.strdim) maxlen=s.strdim-lhs.i+1;
|
| }
|
|
|
| |
|
|
| if (form != 0 && form < maxlen) maxlen=form;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** input stringcode at "); outnumber(here); outcr();
|
| outsc("** input stringcode "); outname(&lhs.name); outcr();
|
| outsc("** input stringcode maximum length "); outnumber(maxlen); outcr();
|
| }
|
|
|
|
|
| if (prompt) showprompt();
|
| #ifndef USEMEMINTERFACE
|
| newlength=ins(s.ir-1, maxlen);
|
| #else
|
| newlength=ins(spistrbuf1, maxlen);
|
|
|
|
|
| if (newlength > 0) {
|
| if (s.ir) {
|
| for (k=0; k<newlength; k++) s.ir[k]=spistrbuf1[k+1];
|
| } else {
|
| for (k=0; k<newlength; k++) memwrite2(s.address+k, spistrbuf1[k+1]);
|
| }
|
| }
|
| #endif
|
|
|
|
|
|
|
|
|
|
|
|
|
| newlength = lhs.i+newlength-1;
|
| setstringlength(&lhs.name, newlength, lhs.j);
|
| break;
|
| #endif
|
| }
|
| }
|
|
|
|
|
| if (token == ',' || token == ';') {
|
| nexttoken();
|
| goto nextstring;
|
| }
|
|
|
|
|
| if (!termsymbol()) {
|
| error(EUNKNOWN);
|
| }
|
|
|
| resetinput:
|
| id=oldid;
|
| form=0;
|
| }
|
|
|
| |
| |
| |
| |
|
|
| void xgoto() {
|
| token_t t=token;
|
| number_t x;
|
|
|
| if (!expectexpr()) return;
|
| if (t == TGOSUB) pushgosubstack(0);
|
| if (!USELONGJUMP && er) return;
|
|
|
| x=pop();
|
|
|
| if (DEBUG) { outsc("** goto/gosub evaluated line number "); outnumber(x); outcr(); }
|
| findline((address_t) x);
|
| if (!USELONGJUMP && er) return;
|
| if (DEBUG) { outsc("** goto/gosub branches to "); outnumber(here); outcr(); }
|
|
|
| |
|
|
| if (st == SINT) st=SRUN;
|
| }
|
|
|
| |
| |
|
|
| void xreturn(){
|
| popgosubstack();
|
| if (DEBUG) { outsc("** restored location "); outnumber(here); outcr(); }
|
| if (!USELONGJUMP && er) return;
|
| nexttoken();
|
| #ifdef HASEVENTS
|
|
|
| if (gosubarg[gosubsp] == TEVENT) events_enabled=1;
|
| #endif
|
| }
|
|
|
| |
| |
|
|
| void xif() {
|
| mem_t nl=0;
|
|
|
| if (!expectexpr()) return;
|
| x=pop();
|
| if (DEBUG) { outsc("** in if, condition "); outnumber(x); outcr(); }
|
|
|
|
|
| if (token == LINENUMBER) nexttoken();
|
|
|
|
|
| if (x == 0) {
|
| #ifndef HASSTRUCT
|
|
|
| while(token != LINENUMBER && token != EOL && token != TELSE) nexttoken();
|
| #else
|
|
|
|
|
| if (token == TTHEN) nexttoken();
|
| if (token == LINENUMBER) { nexttoken(); nl=1; }
|
|
|
|
|
| if (token == TDO) {
|
| nexttoken();
|
| findbraket(TDO, TDEND);
|
| nexttoken();
|
| goto processelse;
|
| }
|
|
|
|
|
| if (!nl) while(token != LINENUMBER && token != EOL && token != TELSE) nexttoken();
|
|
|
| processelse:
|
| #endif
|
|
|
| |
|
|
|
|
| #ifdef HASSTEFANSEXT
|
|
|
| if (token == LINENUMBER) nexttoken();
|
|
|
|
|
| if (token == TELSE) {
|
| nexttoken();
|
| if (token == NUMBER) {
|
| findline((address_t) x);
|
| return;
|
| }
|
| }
|
| #endif
|
| }
|
|
|
|
|
| #ifdef HASAPPLE1
|
|
|
| if (token == TTHEN) {
|
| nexttoken();
|
| if (token == NUMBER) {
|
| findline((address_t) x);
|
| }
|
| }
|
| #endif
|
| }
|
|
|
| |
|
|
| #ifdef HASSTEFANSEXT
|
| void xelse() {
|
| mem_t nl=0;
|
|
|
| #ifndef HASSTRUCT
|
|
|
| while(token != LINENUMBER && token != EOL) nexttoken();
|
| #else
|
| nexttoken();
|
|
|
| if (token == LINENUMBER) {
|
| nexttoken();
|
| nl=1;
|
| }
|
|
|
|
|
| if (token == TDO) {
|
| nexttoken();
|
| findbraket(TDO, TDEND);
|
| }
|
|
|
|
|
| if (!nl) while(token != LINENUMBER && token != EOL) nexttoken();
|
|
|
| #endif
|
| }
|
| #endif
|
|
|
| |
| |
| |
| |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| void findbraket(token_t bra, token_t ket){
|
| address_t fnc = 0;
|
|
|
| while (1) {
|
|
|
| if (DEBUG) {
|
| outsc("** skpping braket ");
|
| outputtoken(); outspc();
|
| outnumber(here); outspc();
|
| outnumber(fnc); outcr();
|
| }
|
|
|
| if (token == ket) {
|
| if (fnc == 0) return; else fnc--;
|
| }
|
|
|
| if (token == bra) fnc++;
|
|
|
|
|
| if (token == EOL) {
|
| error(bra);
|
| return;
|
| }
|
| nexttoken();
|
| }
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| void xfor(){
|
| name_t variable;
|
| number_t begin=1;
|
| number_t to=maxnum;
|
| number_t step=1;
|
|
|
|
|
| if (!expect(VARIABLE, EUNKNOWN)) return;
|
| variable=name;
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| nexttoken();
|
| if (token == '=') {
|
| if (!expectexpr()) return;
|
| begin=pop();
|
| setvar(&variable, begin);
|
| }
|
|
|
| if (token == TTO) {
|
| if (!expectexpr()) return;
|
| to=pop();
|
| }
|
|
|
| if (token == TSTEP) {
|
| if (!expectexpr()) return;
|
| step=pop();
|
| }
|
|
|
| if (!termsymbol()) {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
|
|
|
|
| if (st == SINT) here=bi-ibuffer;
|
|
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** for loop with parameters var begin end step: ");
|
| outname(&variable);
|
| outspc(); outnumber(begin);
|
| outspc(); outnumber(to);
|
| outspc(); outnumber(step);
|
| outcr();
|
| outsc("** for loop target location "); outnumber(here); outcr();
|
| }
|
|
|
| pushloop(&variable, TFOR, here, to, step);
|
| if (!USELONGJUMP && er) return;
|
|
|
| |
| |
| |
|
|
| if ((step > 0 && getvar(&variable) > to) || (step < 0 && getvar(&variable) < to)) {
|
| droploop();
|
| findbraket(TFOR, TNEXT);
|
| nexttoken();
|
| if (token == VARIABLE) nexttoken();
|
| }
|
| }
|
|
|
| |
| |
|
|
| #ifdef HASSTRUCT
|
| void xbreak(){
|
|
|
| bloop_t* loop;
|
|
|
|
|
| loop=activeloop();
|
| if (!USELONGJUMP && er) return;
|
| switch (loop->var.token) {
|
| case TWHILE:
|
| findbraket(TWHILE, TWEND);
|
| nexttoken();
|
| break;
|
| case TREPEAT:
|
| findbraket(TREPEAT, TUNTIL);
|
| while (!termsymbol()) nexttoken();
|
| break;
|
| default:
|
| findbraket(TFOR, TNEXT);
|
| nexttoken();
|
| if (token == VARIABLE) nexttoken();
|
| break;
|
| }
|
| droploop();
|
| }
|
| #else
|
| void xbreak(){
|
|
|
| droploop();
|
| if (!USELONGJUMP && er) return;
|
| findbraket(TFOR, TNEXT);
|
| nexttoken();
|
| if (token == VARIABLE) nexttoken();
|
| }
|
| #endif
|
|
|
| |
| |
| |
|
|
| #ifdef HASSTRUCT
|
| void xcont() {
|
|
|
| bloop_t* loop;
|
|
|
|
|
| loop=activeloop();
|
| if (!USELONGJUMP && er) return;
|
| switch (loop->var.token) {
|
| case TWHILE:
|
| findbraket(TWHILE, TWEND);
|
| break;
|
| case TREPEAT:
|
| findbraket(TREPEAT, TUNTIL);
|
| break;
|
| default:
|
| findbraket(TFOR, TNEXT);
|
| break;
|
| }
|
| }
|
| #else
|
| void xcont() {
|
| findbraket(TFOR, TNEXT);
|
| }
|
| #endif
|
|
|
| |
| |
| |
| |
| |
|
|
|
|
|
|
|
|
| void xnext(){
|
| name_t variable;
|
| name_t* forname;
|
| token_t t;
|
| address_t h;
|
| number_t value;
|
|
|
|
|
| bloop_t* loop;
|
|
|
|
|
| nexttoken();
|
|
|
|
|
| if (token == VARIABLE) {
|
| if (DEBUG) { outsc("** variable argument "); outname(&name); outcr(); }
|
| variable=name;
|
| nexttoken();
|
| if (!termsymbol()) {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
| } else {
|
| variable.c[0]=0;
|
| }
|
|
|
|
|
|
|
| loop=activeloop();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| #ifdef HASSTRUCT
|
| if (loop->var.token == TWHILE || loop->var.token == TREPEAT) { error(ELOOP); return; }
|
|
|
| #endif
|
|
|
| |
|
|
| if (variable.c[0] != 0) {
|
| |
| |
| |
| |
| |
| |
| |
|
|
| while(!cmpname(&variable, &loop->var)) {
|
| droploop();
|
| if (!USELONGJUMP && er) return;
|
| loop=activeloop();
|
| if (!USELONGJUMP && er) return;
|
| }
|
| }
|
|
|
|
|
| value=getvar(&loop->var)+loop->step;
|
| setvar(&loop->var, value);
|
|
|
| if (DEBUG) {
|
| outsc("** next loop variable "); outname(&loop->var); outspc();
|
| outsc(" value "); outnumber(value); outcr();
|
| }
|
|
|
|
|
| if ((loop->step == 0) || (loop->step > 0 && value <= loop->to) || (loop->step < 0 && value >= loop->to)) {
|
|
|
| here=loop->here;
|
|
|
| if (st == SINT) bi=ibuffer+here;
|
| } else {
|
| |
|
|
| droploop();
|
| }
|
| nexttoken();
|
| if (DEBUG) { outsc("** after next found token "); debugtoken(); }
|
| }
|
|
|
| |
| |
| |
| |
|
|
| void outputtoken() {
|
| address_t i;
|
|
|
| if (token == EOL) return;
|
|
|
| if (token == LINENUMBER) outliteral=0;
|
|
|
| if (token == TREM) outliteral=1;
|
|
|
| if (spaceafterkeyword) {
|
| if (token != '(' &&
|
| token != LINENUMBER &&
|
| token !=':' &&
|
| token !='$') outspc();
|
| spaceafterkeyword=0;
|
| }
|
|
|
| switch (token) {
|
| case NUMBER:
|
| outnumber(x);
|
| break;
|
| case LINENUMBER:
|
| outnumber(ax);
|
| outspc();
|
| break;
|
| case ARRAYVAR:
|
| case STRINGVAR:
|
| case VARIABLE:
|
| if (lastouttoken == NUMBER) outspc();
|
| outname(&name);
|
| if (token == STRINGVAR) outch('$');
|
| break;
|
| case STRING:
|
| outch('"');
|
| #ifdef USEMEMINTERFACE
|
| if (!sr.ir) getstringtobuffer(&sr, spistrbuf1, SPIRAMSBSIZE);
|
| #endif
|
| outs(sr.ir, sr.length);
|
| outch('"');
|
| break;
|
| default:
|
| if ( (token < 32 && token >= BASEKEYWORD) || token < -127) {
|
| if ((token == TTHEN ||
|
| token == TELSE ||
|
| token == TTO ||
|
| token == TSTEP ||
|
| token == TGOTO ||
|
| token == TGOSUB ||
|
| token == TOR ||
|
| token == TAND) && lastouttoken != LINENUMBER) outspc();
|
| else
|
| if (lastouttoken == NUMBER || lastouttoken == VARIABLE) outspc();
|
|
|
| for(i=0; gettokenvalue(i)!=0 && gettokenvalue(i)!=token; i++);
|
| outsc(getkeyword(i));
|
| if (token != GREATEREQUAL &&
|
| token != NOTEQUAL &&
|
| token != LESSEREQUAL &&
|
| token != TREM &&
|
| token != TFN) spaceafterkeyword=1;
|
| break;
|
| }
|
| if (token >= 32) {
|
| outch(token);
|
| if (token == ':' && !outliteral) outspc();
|
| break;
|
| }
|
| outch(token); outspc(); outnumber(token);
|
| }
|
|
|
| lastouttoken=token;
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
|
|
| void listlines(address_t b, address_t e) {
|
| mem_t oflag=0;
|
|
|
|
|
| lastouttoken=0;
|
| spaceafterkeyword=0;
|
|
|
|
|
| if ( top != 0 ) {
|
| here=0;
|
| gettoken();
|
| while (here < top) {
|
| if (token == LINENUMBER && ax >= b) oflag=1;
|
| if (token == LINENUMBER && ax > e) oflag=0;
|
| if (oflag) outputtoken();
|
| gettoken();
|
| if (token == LINENUMBER && oflag) {
|
| outcr();
|
| |
|
|
| if (dspactive() && dspwaitonscroll() == 27) break;
|
| }
|
| }
|
| if (here == top && oflag) outputtoken();
|
| if (e == maxaddr || b != e) outcr();
|
| }
|
|
|
| }
|
|
|
| void xlist(){
|
| number_t b, e;
|
|
|
|
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| switch (args) {
|
| case 0:
|
| b=0;
|
| e=maxaddr;
|
| break;
|
| case 1:
|
| b=pop();
|
| e=b;
|
| break;
|
| case 2:
|
| e=pop();
|
| b=pop();
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
|
|
|
|
| listlines(b, e);
|
|
|
|
|
| nexttoken();
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| void xedit(){
|
| mem_t ood = od;
|
| address_t line;
|
| address_t l;
|
| int i, k, j;
|
| char ch;
|
|
|
|
|
| if (st != SINT) { error(EUNKNOWN); return; }
|
|
|
|
|
| if(!expectexpr()) { error(EARGS); return; }
|
|
|
|
|
| line=pop();
|
| undo:
|
| ibuffer[0]=0;
|
| ibuffer[1]=0;
|
| od=0;
|
| listlines(line, line);
|
| if (ibuffer[0] == 0) {
|
| outnumber(line);
|
| outspc();
|
| }
|
| od=ood;
|
|
|
|
|
| l=1;
|
|
|
|
|
| while (-1) {
|
|
|
|
|
| for(i=1; i<=(unsigned char)ibuffer[0]; i++) outch(ibuffer[i]);
|
| outcr();
|
| for(i=0; i<l-1; i++) outspc();
|
| outch('^');
|
| outcr();
|
|
|
|
|
| i=ins(sbuffer, SBUFSIZE);
|
| for (k=1; k<=i; k++) {
|
| ch=sbuffer[k];
|
| switch (ch) {
|
| case 'q':
|
| goto done;
|
| case 'Q':
|
| goto endnosave;
|
| break;
|
| case 'X':
|
| ibuffer[0]=(char)l;
|
| ibuffer[l]=0;
|
| break;
|
| case 'j':
|
| if (l > 1) l--;
|
| break;
|
| case 'k':
|
| if (l<(unsigned char)ibuffer[0]) l++;
|
| break;
|
| case 'x':
|
| if ((unsigned char)ibuffer[0]>0) {
|
| for (j=l; j<(unsigned char)ibuffer[0]; j++) ibuffer[j]=ibuffer[j+1];
|
| ibuffer[j]=0;
|
| ibuffer[0]=(unsigned char)ibuffer[0]-1;
|
| }
|
| if ((unsigned char)ibuffer[0]<l) l=(unsigned char)ibuffer[0];
|
| break;
|
| case 's':
|
| if (k<i) {
|
| k++;
|
| ibuffer[l]=sbuffer[k];
|
| }
|
| break;
|
| case 'a':
|
| l=(unsigned char)ibuffer[0]+1;
|
| case 'i':
|
| if (i-k+(unsigned char)ibuffer[0] < BUFSIZ) {
|
| for (j=i-k+(unsigned char)ibuffer[0]; j>=l; j--) {
|
| ibuffer[j+i-k]=ibuffer[j];
|
| if (j<=l+i-k) ibuffer[j]=sbuffer[k+1+(j-l)];
|
| }
|
| }
|
| ibuffer[0]=(unsigned char)ibuffer[0]+i-k;
|
| k=i;
|
| break;
|
| case '^':
|
| l=1;
|
| break;
|
| case '$':
|
| l=(unsigned char)ibuffer[0]+1;
|
| break;
|
| case 'h':
|
| if (l > 1) {
|
| for (j=l-1; j<(unsigned char)ibuffer[0]; j++) ibuffer[j]=ibuffer[j+1];
|
| ibuffer[j]=0;
|
| ibuffer[0]=(unsigned char)ibuffer[0]-1;
|
| l--;
|
| }
|
| break;
|
| case 'u':
|
| goto undo;
|
| break;
|
| case ':':
|
| if (l <= (unsigned char)ibuffer[0]) {
|
| while (l <= (unsigned char)ibuffer[0] && ibuffer[l] != ':') l++;
|
| if (l <= (unsigned char)ibuffer[0]) l++;
|
| }
|
| break;
|
| default:
|
| break;
|
| }
|
| }
|
| }
|
|
|
|
|
| done:
|
| bi=ibuffer;
|
| st=SINT;
|
| nexttoken();
|
| if (token == NUMBER) {
|
| ax=x;
|
| storeline();
|
| }
|
|
|
|
|
| endnosave:
|
| ibuffer[0]=0;
|
| ibuffer[1]=0;
|
| bi=ibuffer+1;
|
| nexttoken();
|
| }
|
|
|
| |
| |
|
|
| void xrun(){
|
| if (token == TCONT) {
|
| st=SRUN;
|
| nexttoken();
|
| } else {
|
| nexttoken();
|
| parsearguments();
|
| if (er != 0 ) return;
|
| if (args > 1) { error(EARGS); return; }
|
| if (args == 0) {
|
| here=0;
|
| } else {
|
| findline(pop());
|
| }
|
| if (!USELONGJUMP && er) return;
|
| if (st == SINT) st=SRUN;
|
|
|
|
|
| clrvars();
|
| clrgosubstack();
|
| clrforstack();
|
| clrdata();
|
| clrlinecache();
|
| ert=0;
|
| ioer=0;
|
| fncontext=0;
|
| #ifdef HASEVENTS
|
| resettimer(&every_timer);
|
| resettimer(&after_timer);
|
| events_enabled=1;
|
| #endif
|
|
|
| nexttoken();
|
| }
|
|
|
| |
|
|
| statement();
|
| st=SINT;
|
|
|
| eflush();
|
|
|
|
|
| #ifdef HASARGS
|
| if (bnointafterrun) restartsystem();
|
| #endif
|
| }
|
|
|
| |
| |
| |
| |
| |
|
|
| void resetbasicstate() {
|
|
|
| if (DEBUG) { outsc("** BASIC state reset \n"); }
|
|
|
|
|
| clearst();
|
| clrgosubstack();
|
| clrforstack();
|
| clrdata();
|
| clrvars();
|
| clrlinecache();
|
|
|
|
|
| reseterror();
|
|
|
|
|
| here=0;
|
|
|
|
|
| fncontext=0;
|
|
|
|
|
| st=SINT;
|
|
|
|
|
| #ifdef HASTIMER
|
| resettimer(&after_timer);
|
| resettimer(&every_timer);
|
| #endif
|
|
|
| }
|
|
|
| void xnew(){
|
|
|
|
|
| resetbasicstate();
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** clearing memory ");
|
| outnumber(memsize);
|
| outsc(" bytes \n");
|
| }
|
|
|
|
|
| himem=memsize;
|
| zeroblock(0, memsize);
|
| top=0;
|
|
|
| if (DEBUG) outsc("** clearing EEPROM state \n ");
|
|
|
| #ifdef EEPROMMEMINTERFACE
|
| eupdate(0, 0);
|
| setaddress(1, eupdate, top);
|
| #endif
|
| }
|
|
|
| |
| |
|
|
| void xrem() {
|
| if (debuglevel == -1) outsc("REM: ");
|
| while (token != LINENUMBER && token != EOL && here <= top)
|
| {
|
| nexttoken();
|
| if (debuglevel == -1) {
|
| if (token != LINENUMBER) outputtoken(); else outcr();
|
| }
|
| }
|
| }
|
|
|
| |
| |
| |
|
|
|
|
| |
| |
|
|
| void xclr() {
|
|
|
| #ifdef HASDARKARTS
|
| name_t variable;
|
|
|
| nexttoken();
|
|
|
| if (termsymbol()) {
|
| clrvars();
|
| clrgosubstack();
|
| clrforstack();
|
| clrdata();
|
| clrlinecache();
|
| ert=0;
|
| ioer=0;
|
| } else {
|
| variable=name;
|
| switch (variable.token) {
|
| case VARIABLE:
|
| if (variable.c[0] == '@') { return; }
|
| break;
|
| case ARRAYVAR:
|
| nexttoken();
|
| if (token != '(') { error(EVARIABLE); return; }
|
| nexttoken();
|
| if (token != ')') { error(EVARIABLE); return; }
|
| break;
|
| case STRINGVAR:
|
| if (variable.c[0] == '@') { error(EVARIABLE); return; }
|
| break;
|
| case TGOSUB:
|
| clrgosubstack();
|
| goto next;
|
| case TFOR:
|
| clrforstack();
|
| goto next;
|
| case TEVERY:
|
| resettimer(&every_timer);
|
| goto next;
|
| case TAFTER:
|
| resettimer(&after_timer);
|
| goto next;
|
| default:
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| ax=pop();
|
| variable.c[0]=ax%256;
|
| variable.c[1]=ax/256;
|
| variable.token=TBUFFER;
|
| }
|
|
|
|
|
| ax=bfree(&variable);
|
| if (ax == 0) {
|
| if (variable.token != TBUFFER) { error(EVARIABLE); return; }
|
| else ert=1;
|
| }
|
| }
|
| #else
|
| clrvars();
|
| clrgosubstack();
|
| clrforstack();
|
| clrdata();
|
| clrlinecache();
|
| ert=0;
|
| ioer=0;
|
| #endif
|
|
|
| next:
|
| nexttoken();
|
| }
|
|
|
| #ifdef HASAPPLE1
|
| |
| |
|
|
| void xdim(){
|
| name_t variable;
|
| address_t x;
|
| address_t y=1;
|
|
|
|
|
| nexttoken();
|
|
|
| nextvariable:
|
| if (token == ARRAYVAR || token == STRINGVAR ){
|
|
|
|
|
| variable=name;
|
|
|
| if (DEBUG) {
|
| outsc("** in xdim "); outname(&variable); outspc(); outnumber(variable.token);
|
| outspc(); outname(&name); outspc(); outnumber(name.token); outcr();
|
| }
|
|
|
|
|
| parsesubscripts();
|
| if (!USELONGJUMP && er) return;
|
|
|
| #ifndef HASMULTIDIM
|
| if (args != 1) {error(EARGS); return; }
|
| x=popaddress();
|
| #else
|
| if (args != 1 && args != 2) {error(EARGS); return; }
|
| if (args == 2) y=popaddress();
|
| x=popaddress();
|
| #endif
|
|
|
|
|
| if (x<1 || y<1) {error(EORANGE); return; }
|
|
|
|
|
| if (variable.token == STRINGVAR) {
|
| if ((x>255) && (strindexsize==1)) {error(EORANGE); return; }
|
| #ifdef SPIRAMSBSIZE
|
| if (x>SPIRAMSBSIZE-1) {error(EORANGE); return; }
|
| #endif
|
| |
| |
| |
|
|
| if (!substringmode)
|
| if (args == 1) {
|
| y=x;
|
| x=defaultstrdim;
|
| }
|
|
|
| (void) createstring(&variable, x, y);
|
| } else {
|
| (void) createarray(&variable, x, y);
|
| }
|
| if (!USELONGJUMP && er) return;
|
|
|
| } else if (token == VARIABLE) {
|
| (void) bmalloc(&name, 0);
|
| } else {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
|
|
| nexttoken();
|
| if (token == ',') {
|
| nexttoken();
|
| goto nextvariable;
|
| }
|
|
|
| nexttoken();
|
| }
|
|
|
|
|
| |
| |
| |
| |
|
|
| void xpoke(){
|
| number_t a, v;
|
|
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
|
|
| v=pop();
|
| a=pop();
|
|
|
|
|
| if (a >= 0 && a<=memsize)
|
| memwrite2(a, v);
|
| else if (a < 0 && a >= -elength())
|
| eupdate(-a-1, v);
|
| else {
|
| error(EORANGE);
|
| }
|
| }
|
|
|
| |
| |
| |
|
|
| void xtab(){
|
| address_t a;
|
| token_t t = token;
|
|
|
|
|
| nexttoken();
|
| if (token == '(') nexttoken();
|
| parsenarguments(1);
|
| if (!USELONGJUMP && er) return;
|
| if (token == ')') nexttoken();
|
|
|
| a=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| #ifdef HASMSTAB
|
| if (t != TSPC && reltab && od <= OPRT && od > 0) {
|
| if (charcount[od-1] >= a) a=0; else a=a-charcount[od-1]-1;
|
| }
|
| #endif
|
| while (a-- > 0) outspc();
|
| }
|
| #endif
|
|
|
| |
| |
|
|
|
|
| void xlocate() {
|
| address_t cx, cy;
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
|
|
| cy=popaddress();
|
| cx=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (cx > 0 && cy > 0 && cx < 224 && cy < 224) {
|
| outch(27); outch('Y');
|
| outch(31+(unsigned int) cy);
|
| outch(31+(unsigned int) cx);
|
| }
|
|
|
|
|
| #ifdef HASMSTAB
|
| if (od > 0 && od <= OPRT) charcount[od-1]=cx;
|
| #endif
|
|
|
| }
|
|
|
| |
| |
| |
| |
|
|
|
|
| |
| |
|
|
| void xdump() {
|
| address_t a, x;
|
| char eflag = 0;
|
|
|
| nexttoken();
|
| if (token == '!') { eflag=1; nexttoken(); }
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
| switch (args) {
|
| case 0:
|
| x=0;
|
| a=memsize;
|
| break;
|
| case 1:
|
| x=pop();
|
| a=memsize;
|
| break;
|
| case 2:
|
| a=pop();
|
| x=pop();
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
|
|
| form=6;
|
| if (a>x) dumpmem((a-x)/8+1, x, eflag);
|
| form=0;
|
| }
|
|
|
| |
| |
|
|
| void dumpmem(address_t r, address_t b, char eflag) {
|
| address_t j, i;
|
| address_t k;
|
| mem_t c;
|
| address_t end;
|
|
|
| k=b;
|
| i=r;
|
| if (eflag) end=elength(); else end=memsize;
|
| while (i>0) {
|
| outnumber(k); outspc();
|
| for (j=0; j<8; j++) {
|
| if (eflag) c=eread(k); else c=memread(k);
|
| k++;
|
| outnumber(c); outspc();
|
| if (k > end) break;
|
| }
|
| outcr();
|
| i--;
|
| if (k > end) break;
|
| }
|
| if (eflag) {
|
| outsc("elength: "); outnumber(elength()); outcr();
|
| } else {
|
| outsc("top: "); outnumber(top); outcr();
|
| outsc("himem: "); outnumber(himem); outcr();
|
| }
|
| }
|
|
|
| |
| |
| |
|
|
| void stringtobuffer(char *buffer, string_t* s) {
|
| index_t i = s->length;
|
|
|
| if (i >= SBUFSIZE) i=SBUFSIZE-1;
|
| buffer[i--]=0;
|
| while (i >= 0) { buffer[i]=s->ir[i]; i--; }
|
| }
|
|
|
|
|
| void getstringtobuffer(string_t* strp, char *buffer, stringlength_t maxlen) {
|
| stringlength_t i;
|
|
|
| for (i=0; i<strp->length && i<maxlen; i++) buffer[i]=memread2(strp->address+i);
|
| strp->ir=buffer;
|
| }
|
|
|
|
|
| void getfilename(char *buffer, char d) {
|
| index_t s;
|
| char *sbuffer;
|
| string_t sr;
|
|
|
|
|
| s=stringvalue(&sr);
|
| if (!USELONGJUMP && er) return;
|
| if (DEBUG) {outsc("** in getfilename2 stringvalue delivered "); outnumber(s); outcr(); }
|
|
|
| if (s) {
|
| if (DEBUG) {outsc("** in getfilename2 copying string of length "); outnumber(x); outcr(); }
|
| #ifdef USEMEMINTERFACE
|
| if (!sr.ir) getstringtobuffer(&sr, spistrbuf1, SPIRAMSBSIZE);
|
| #endif
|
| stringtobuffer(buffer, &sr);
|
| if (DEBUG) {outsc("** in getfilename2 stringvalue string "); outsc(buffer); outcr(); }
|
| nexttoken();
|
| } else if (termsymbol()) {
|
| if (d) {
|
| sbuffer=getmessage(MFILE);
|
| s=0;
|
| while ((sbuffer[s] != 0) && (s < SBUFSIZE-1)) { buffer[s]=sbuffer[s]; s++; }
|
| buffer[s]=0;
|
| x=s;
|
| } else {
|
| buffer[0]=0;
|
| x=0;
|
| }
|
| nexttoken();
|
| } else {
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| buffer[0]=pop();
|
| buffer[1]=0;
|
| }
|
| }
|
|
|
| |
| |
| |
| |
|
|
| char* getfilename2(char d) {
|
| mem_t s;
|
| string_t sr;
|
|
|
|
|
| if (termsymbol()) {
|
| if (d) return getmessage(MFILE);
|
| else return 0;
|
| }
|
|
|
|
|
| s=stringvalue(&sr);
|
| if (!USELONGJUMP && er) return 0;
|
| if (s) {
|
| #ifdef USEMEMINTERFACE
|
| if (!sr.ir) getstringtobuffer(&sr, sbuffer, SBUFSIZE);
|
| #endif
|
| nexttoken();
|
| for (s=0; s<sr.length && s<SBUFSIZE-1; s++) sbuffer[s]=sr.ir[s];
|
| sbuffer[s]=0;
|
| return sbuffer;
|
| } else {
|
| expression();
|
| if (!USELONGJUMP && er) return 0;
|
| sbuffer[0]=pop();
|
| sbuffer[1]=0;
|
| return sbuffer;
|
| }
|
| }
|
|
|
| #if defined(FILESYSTEMDRIVER)
|
| |
| |
|
|
| void xsave() {
|
|
|
| char *filename;
|
| address_t here2;
|
| token_t t;
|
|
|
| nexttoken();
|
|
|
| filename=getfilename2(1);
|
| if (!USELONGJUMP && er) return;
|
| t=token;
|
|
|
| if (filename[0] == '!') {
|
| esave();
|
| } else {
|
| if (DEBUG) { outsc("** Opening the file "); outsc(filename); outcr(); };
|
|
|
| if (!ofileopen(filename, "w")) {
|
| error(EFILE);
|
| return;
|
| }
|
|
|
|
|
| push(od);
|
| od=OFILE;
|
|
|
|
|
| ert=0;
|
| here2=here;
|
| here=0;
|
| gettoken();
|
| while (here < top) {
|
| outputtoken();
|
| if (ert) break;
|
| gettoken();
|
| if (token == LINENUMBER) outcr();
|
| }
|
| if (here == top) outputtoken();
|
| outcr();
|
|
|
|
|
| here=here2;
|
|
|
|
|
| od=pop();
|
|
|
|
|
| ofileclose();
|
|
|
|
|
| if (ert) { printmessage(EGENERAL); outcr(); ert=0; }
|
| }
|
|
|
|
|
| token=t;
|
| }
|
|
|
| |
| |
| |
| |
|
|
| void xload(const char* f) {
|
|
|
| char* filename;
|
| char ch;
|
| address_t here2;
|
| mem_t chain = 0;
|
|
|
| if (f == 0) {
|
| nexttoken();
|
| filename=getfilename2(1);
|
| if (!USELONGJUMP && er) return;
|
| } else {
|
| filename=(char*)f;
|
| }
|
|
|
| if (filename[0] == '!') {
|
| eload();
|
| } else {
|
|
|
| |
| |
| |
|
|
| if (st == SRUN) {
|
| chain=1;
|
| st=SINT;
|
| top=0;
|
| clrgosubstack();
|
| clrforstack();
|
| clrdata();
|
| }
|
|
|
| if (!f)
|
| if (!ifileopen(filename)) { error(EFILE); return; }
|
|
|
| bi=ibuffer+1;
|
| while (fileavailable()) {
|
| ch=fileread();
|
|
|
| if (ch == '\n' || ch == '\r' || cheof(ch)) {
|
| *bi=0;
|
| bi=ibuffer+1;
|
| if (*bi != '#') {
|
| nexttoken();
|
| if (token == NUMBER) {
|
| ax=x;
|
| storeline();
|
| }
|
| if (er != 0 ) break;
|
| bi=ibuffer+1;
|
| }
|
| } else {
|
| *bi++=ch;
|
| }
|
|
|
| if ((bi-ibuffer) > BUFSIZE) {
|
| error(EOUTOFMEMORY);
|
| break;
|
| }
|
| }
|
| ifileclose();
|
|
|
| #ifdef EEPROMMEMINTERFACE
|
| setaddress(1, eupdate, top);
|
| #endif
|
|
|
|
|
| if (chain) {
|
| st=SRUN;
|
| here=0;
|
| nexttoken();
|
| }
|
| }
|
| }
|
| #else
|
| |
| |
|
|
| void xsave() {
|
| esave();
|
| nexttoken();
|
| }
|
| |
| |
|
|
| void xload(const char* f) {
|
| eload();
|
| nexttoken();
|
| }
|
| #endif
|
|
|
| |
| |
|
|
| void xget(){
|
|
|
|
|
| lhsobject_t lhs;
|
|
|
| mem_t oid=id;
|
| char ch;
|
|
|
| nexttoken();
|
|
|
|
|
| if (token == '&') {
|
|
|
| if (!expectexpr()) return;
|
| id=pop();
|
| if (token != ',') {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
| nexttoken();
|
| }
|
|
|
|
|
| lhs.name=name;
|
|
|
| lefthandside(&lhs);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (availch()) ch=inch(); else ch=0;
|
|
|
|
|
| assignnumber2(&lhs, ch);
|
|
|
|
|
| #ifdef HASAPPLE1
|
| if (lhs.name.token == STRINGVAR && ch == 0 && lhs.ps) setstringlength(&lhs.name, 0, arraylimit);
|
| #endif
|
|
|
|
|
| id=oid;
|
| }
|
|
|
| |
| |
|
|
| void xput(){
|
| mem_t ood=od;
|
| index_t i;
|
|
|
| nexttoken();
|
|
|
|
|
| if (token == '&') {
|
|
|
| if(!expectexpr()) return;
|
| od=pop();
|
| if (token != ',') {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
| nexttoken();
|
| }
|
|
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
| for (i=args-1; i>=0; i--) sbuffer[i]=pop();
|
| outs(sbuffer, args);
|
|
|
| od=ood;
|
| }
|
|
|
|
|
| void setpersonality(index_t p) {
|
| #ifdef HASAPPLE1
|
| switch(p) {
|
|
|
| case 'm':
|
| case 'M':
|
| msarraylimits=1;
|
| arraylimit=0;
|
| substringmode=0;
|
| booleanmode=-1;
|
| randombase=-1;
|
| reltab=1;
|
| break;
|
|
|
| case 'a':
|
| case 'A':
|
| msarraylimits=0;
|
| arraylimit=1;
|
| substringmode=1;
|
| booleanmode=1;
|
| randombase=0;
|
| reltab=0;
|
| break;
|
|
|
| case 'p':
|
| case 'P':
|
| msarraylimits=0;
|
| arraylimit=0;
|
| substringmode=1;
|
| booleanmode=1;
|
| forceint=1;
|
| randombase=1;
|
| reltab=0;
|
| break;
|
| }
|
| #endif
|
| }
|
|
|
| |
| |
| |
| |
|
|
| void xset(){
|
| address_t function;
|
| index_t argument;
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
|
|
| argument=pop();
|
| function=pop();
|
| switch (function) {
|
|
|
| case 0:
|
| debuglevel=argument;
|
| break;
|
|
|
| case 1:
|
| eupdate(0, argument);
|
| break;
|
|
|
| case 2:
|
| switch (argument) {
|
| case 0:
|
| od=OSERIAL;
|
| break;
|
| case 1:
|
| od=ODSP;
|
| break;
|
| }
|
| break;
|
|
|
| case 3:
|
| switch (argument) {
|
| case 0:
|
| od=(odd=OSERIAL);
|
| break;
|
| case 1:
|
| od=(odd=ODSP);
|
| break;
|
| }
|
| break;
|
|
|
| case 4:
|
| switch (argument) {
|
| case 0:
|
| id=ISERIAL;
|
| break;
|
| case 1:
|
| id=IKEYBOARD;
|
| break;
|
| }
|
| break;
|
|
|
| case 5:
|
| switch (argument) {
|
| case 0:
|
| idd=(id=ISERIAL);
|
| break;
|
| case 1:
|
| idd=(id=IKEYBOARD);
|
| break;
|
| }
|
| break;
|
| #ifdef HASSERIAL1
|
|
|
| case 6:
|
| sendcr=(char)argument;
|
| break;
|
|
|
| case 7:
|
| blockmode=argument;
|
| break;
|
|
|
| case 8:
|
| prtset(argument);
|
| break;
|
| #endif
|
|
|
| #ifdef HASRF24
|
| case 9:
|
| radioset(argument);
|
| break;
|
| #endif
|
|
|
| #ifdef DISPLAYDRIVER
|
| case 10:
|
| dspsetupdatemode(argument);
|
| break;
|
| #endif
|
|
|
| #ifdef HASMSTAB
|
| case 11:
|
| reltab=argument;
|
| break;
|
| #endif
|
|
|
| #ifdef HASAPPLE1
|
| case 12:
|
| if (argument>=0) arraylimit=argument; else error(EORANGE);
|
| break;
|
| #endif
|
|
|
| #ifdef HASKEYPAD
|
| case 13:
|
| kbdrepeat=argument;
|
| break;
|
| #endif
|
|
|
| #ifdef HASPULSE
|
| case 14:
|
| bpulseunit=argument;
|
| break;
|
| #endif
|
|
|
| #ifdef POSIXVT52TOANSI
|
| case 15:
|
| vt52active=argument;
|
| break;
|
| #endif
|
|
|
| #ifdef HASAPPLE1
|
| case 16:
|
| if (argument>0) defaultstrdim=argument; else error(EORANGE);
|
| break;
|
| #endif
|
|
|
| case 17:
|
| if (argument==-1 || argument==1) booleanmode=argument; else error(EORANGE);
|
| break;
|
|
|
| case 18:
|
| forceint=(argument != 0);
|
| break;
|
|
|
| case 19:
|
| randombase=argument;
|
| break;
|
|
|
| #ifdef HASAPPLE1
|
| case 20:
|
| substringmode=(argument != 0);
|
| break;
|
| #endif
|
|
|
| #ifdef HASAPPLE1
|
| case 21:
|
| msarraylimits=(argument != 0);
|
| break;
|
| #endif
|
|
|
| case 22:
|
| setpersonality(argument);
|
| break;
|
| #ifdef HASAPPLE1
|
| case 23:
|
| lowercasenames=(argument != 0);
|
| break;
|
| #endif
|
| }
|
| }
|
|
|
| |
| |
|
|
| void xnetstat(){
|
| #if defined(HASMQTT)
|
|
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
| switch (args) {
|
| case 0:
|
| if (netconnected()) outsc("Network connected \n"); else outsc("Network not connected \n");
|
| outsc("MQTT state "); outnumber(mqttstate()); outcr();
|
| outsc("MQTT out topic "); outsc(mqtt_otopic); outcr();
|
| outsc("MQTT inp topic "); outsc(mqtt_itopic); outcr();
|
| outsc("MQTT name "); outsc(mqttname); outcr();
|
| break;
|
| case 1:
|
| ax=pop();
|
| switch (ax) {
|
| case 0:
|
| netstop();
|
| break;
|
| case 1:
|
| netbegin();
|
| break;
|
| case 2:
|
| if (!mqttreconnect()) ert=1;
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
| #endif
|
| nexttoken();
|
| }
|
|
|
| |
| |
| |
|
|
|
|
| |
| |
| |
|
|
|
|
| void xaread(){
|
| push(aread(popaddress()));
|
| }
|
|
|
| void xdread(){
|
| push(dread(popaddress()));
|
| }
|
|
|
| |
| |
|
|
| void xdwrite(){
|
| address_t x,y;
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
| x=popaddress();
|
| y=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| dwrite(y, x);
|
| }
|
|
|
| |
| |
|
|
| void xawrite(){
|
| address_t x,y;
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
| x=popaddress();
|
| if (x > 255) error(EORANGE);
|
| y=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| awrite(y, x);
|
| }
|
|
|
| |
| |
|
|
| void xpinm(){
|
| address_t x,y;
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
| x=popaddress();
|
| if (x > 1) error(EORANGE);
|
| y=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| pinm(y, x);
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
|
|
| void xdelay(){
|
| nexttoken();
|
| parsenarguments(1);
|
| if (!USELONGJUMP && er) return;
|
| bdelay(pop());
|
| }
|
|
|
|
|
| #ifdef HASTONE
|
|
|
| void xtone(){
|
| address_t d = 0;
|
| address_t v = 100;
|
| address_t f, p;
|
|
|
|
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
| if (args > 4 || args < 2) { error(EARGS); return; }
|
|
|
|
|
| if (args == 4) v=popaddress();
|
| if (args >= 3) d=popaddress();
|
| f=popaddress();
|
| p=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
| playtone(p, f, d, v);
|
| }
|
| #endif
|
|
|
|
|
| #ifdef HASPULSE
|
| void xpulse(){
|
| address_t pin, duration;
|
| address_t val = 1;
|
| address_t interval = 0;
|
| address_t repetition = 1;
|
|
|
|
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
| if (args>5 || args<2) { error(EARGS); return; }
|
|
|
|
|
| if (args == 5) { interval=popaddress(); repetition=popaddress(); }
|
| if (args == 4) { error(EARGS); return; }
|
| if (args > 2) val=popaddress();
|
| duration=popaddress();
|
| pin=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| pulseout(bpulseunit, pin, duration, val, repetition, interval);
|
| }
|
|
|
|
|
| void bpulsein() {
|
| address_t x,y;
|
| unsigned long t, pt;
|
|
|
| t=((unsigned long) popaddress())*1000;
|
| y=popaddress();
|
| x=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
| push(pulsein(x, y, t)/bpulseunit);
|
| }
|
| #endif
|
|
|
|
|
| #ifdef HASGRAPH
|
| |
| |
|
|
| void xcolor() {
|
| int r, g, b;
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
| switch(args) {
|
| case 1:
|
| vgacolor(pop());
|
| break;
|
| case 3:
|
| b=pop();
|
| g=pop();
|
| r=pop();
|
| rgbcolor(r, g, b);
|
| break;
|
| default:
|
| error(EARGS);
|
| break;
|
| }
|
| }
|
|
|
| |
| |
|
|
| void xplot() {
|
| int x0, y0;
|
|
|
| nexttoken();
|
| parsenarguments(2);
|
| if (!USELONGJUMP && er) return;
|
| y0=pop();
|
| x0=pop();
|
| plot(x0, y0);
|
| }
|
|
|
| |
| |
|
|
| void xline() {
|
| int x0, y0, x1, y1;
|
|
|
| nexttoken();
|
| parsenarguments(4);
|
| if (!USELONGJUMP && er) return;
|
| y1=pop();
|
| x1=pop();
|
| y0=pop();
|
| x0=pop();
|
| line(x0, y0, x1, y1);
|
| }
|
|
|
| void xrect() {
|
| int x0, y0, x1, y1;
|
|
|
| nexttoken();
|
| parsenarguments(4);
|
| if (!USELONGJUMP && er) return;
|
| y1=pop();
|
| x1=pop();
|
| y0=pop();
|
| x0=pop();
|
| rect(x0, y0, x1, y1);
|
| }
|
|
|
| void xcircle() {
|
| int x0, y0, r;
|
|
|
| nexttoken();
|
| parsenarguments(3);
|
| if (!USELONGJUMP && er) return;
|
| r=pop();
|
| y0=pop();
|
| x0=pop();
|
| circle(x0, y0, r);
|
| }
|
|
|
| void xfrect() {
|
| int x0, y0, x1, y1;
|
|
|
| nexttoken();
|
| parsenarguments(4);
|
| if (!USELONGJUMP && er) return;
|
| y1=pop();
|
| x1=pop();
|
| y0=pop();
|
| x0=pop();
|
| frect(x0, y0, x1, y1);
|
| }
|
|
|
| void xfcircle() {
|
| int x0, y0, r;
|
|
|
| nexttoken();
|
| parsenarguments(3);
|
| if (!USELONGJUMP && er) return;
|
| r=pop();
|
| y0=pop();
|
| x0=pop();
|
| fcircle(x0, y0, r);
|
| }
|
| #endif
|
|
|
| #ifdef HASDARKARTS
|
| |
| |
|
|
| void xmalloc() {
|
| address_t s;
|
| address_t a;
|
| name_t name;
|
|
|
|
|
| s=popaddress();
|
| a=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| name.token=TBUFFER;
|
| name.l=2;
|
| name.c[0]=a%256;
|
| name.c[1]=a/256;
|
|
|
|
|
| push(bmalloc(&name, s));
|
| }
|
|
|
| |
| |
| |
|
|
|
|
| void xfind() {
|
| address_t a;
|
| address_t n;
|
|
|
|
|
| if (!expect('(', EUNKNOWN)) return;
|
|
|
|
|
| nexttoken();
|
| if (token == TFN) {
|
| nexttoken();
|
| name.token=TFN;
|
| }
|
| a=bfind(&name);
|
|
|
|
|
| switch (token) {
|
| case ARRAYVAR:
|
| case TFN:
|
| if (!expect('(', EUNKNOWN)) return;
|
| if (!expect(')', EUNKNOWN)) return;
|
| case VARIABLE:
|
| case STRINGVAR:
|
| nexttoken();
|
| break;
|
| default:
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| n=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| name.token=TBUFFER;
|
| name.l=2;
|
| name.c[0]=n%256;
|
| name.c[1]=n/256;
|
| a=bfind(&name);
|
| }
|
|
|
|
|
| if (token != ')') { error(EUNKNOWN); return; }
|
|
|
| push(a);
|
| }
|
|
|
| |
| |
| |
| |
|
|
| void xeval(){
|
| address_t i, l;
|
| address_t mline, line;
|
| string_t s;
|
|
|
|
|
| if (!expectexpr()) return;
|
| line=popaddress();
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (token != ',') { error(EUNKNOWN); return; }
|
|
|
|
|
| nexttoken();
|
| if (!stringvalue(&s)) { error(EARGS); return; }
|
|
|
| |
|
|
| l=s.length;
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (l>BUFSIZE-1) {error(EORANGE); return; }
|
|
|
| #ifdef USEMEMINTERFACE
|
| if (!s.ir) getstringtobuffer(&s, spistrbuf1, SPIRAMSBSIZE);
|
| #endif
|
|
|
| for (i=0; i<l; i++) ibuffer[i+1]=s.ir[i];
|
| ibuffer[l+1]=0;
|
| if (DEBUG) {outsc("** Preparing to store line "); outnumber(line); outspc(); outsc(ibuffer+1); outcr(); }
|
|
|
|
|
| if (st != SINT) {
|
| mline=myline(here);
|
| if (DEBUG) {outsc("** myline is "); outnumber(mline); outcr(); }
|
| }
|
|
|
|
|
| ax=line;
|
| push(st); st=SINT;
|
| bi=ibuffer;
|
| storeline();
|
| st=pop();
|
|
|
|
|
| if (st != SINT) {
|
| findline(mline);
|
| nextline();
|
| }
|
| }
|
| #endif
|
|
|
|
|
| #ifdef HASIOT
|
|
|
| |
| |
|
|
| void xavail() {
|
| mem_t oid=id;
|
|
|
| id=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| push(availch());
|
| id=oid;
|
| }
|
|
|
| |
| |
|
|
| void xfsensor() {
|
| address_t s, a;
|
|
|
| a=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| s=popaddress();
|
| if (!USELONGJUMP && er) return;
|
| push(sensorread(s, a));
|
| }
|
|
|
|
|
| |
| |
| |
|
|
|
|
| void xsleep() {
|
| nexttoken();
|
| parsenarguments(1);
|
| if (!USELONGJUMP && er) return;
|
| activatesleep(pop());
|
| }
|
|
|
| |
| |
|
|
|
|
| void xwire() {
|
| short port, data1, data2;
|
|
|
| nexttoken();
|
| #if defined(HASWIRE) || defined(HASSIMPLEWIRE)
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (args == 3) {
|
| data2=pop();
|
| data1=pop();
|
| port=pop();
|
| wirewriteword(port, data1, data2);
|
| } else if (args == 2) {
|
| data1=pop();
|
| port=pop();
|
| wirewritebyte(port, data1);
|
| } else {
|
| error(EARGS);
|
| return;
|
| }
|
| #endif
|
| }
|
|
|
| void xfwire() {
|
| #if defined(HASWIRE) || defined(HASSIMPLEWIRE)
|
| push(wirereadbyte(pop()));
|
| #else
|
| #endif
|
| }
|
|
|
| #endif
|
|
|
| |
| |
|
|
| #ifdef HASERRORHANDLING
|
| void xerror() {
|
| berrorh.type=0;
|
| erh=0;
|
| nexttoken();
|
| switch (token) {
|
| case TGOTO:
|
| if (!expectexpr()) return;
|
| berrorh.type=TGOTO;
|
| berrorh.linenumber=pop();
|
| break;
|
| case TCONT:
|
| berrorh.type=TCONT;
|
| case TSTOP:
|
| nexttoken();
|
| break;
|
| default:
|
| error(EARGS);
|
| return;
|
| }
|
| }
|
| #endif
|
|
|
| |
| |
|
|
| #ifdef HASTIMER
|
| void resettimer(btimer_t* t) {
|
| t->enabled=0;
|
| t->interval=0;
|
| t->last=0;
|
| t->type=0;
|
| t->linenumber=0;
|
| }
|
|
|
| void xtimer() {
|
| token_t t;
|
| btimer_t* timer;
|
|
|
|
|
| if (token == TEVERY) timer=&every_timer; else timer=&after_timer;
|
|
|
|
|
| if (!expectexpr()) return;
|
|
|
| |
|
|
| switch(token) {
|
| case TGOSUB:
|
| case TGOTO:
|
| t=token;
|
| if (!expectexpr()) return;
|
| timer->last=millis();
|
| timer->type=t;
|
| timer->linenumber=pop();
|
| timer->interval=pop();
|
| timer->enabled=1;
|
| break;
|
| default:
|
| if (termsymbol()) {
|
| x=pop();
|
| if (x == 0)
|
| timer->enabled=0;
|
| else {
|
| if (timer->linenumber) {
|
| timer->enabled=1;
|
| timer->interval=x;
|
| timer->last=millis();
|
| } else
|
| error(EARGS);
|
| }
|
| } else
|
| error(EUNKNOWN);
|
| return;
|
| }
|
| }
|
| #endif
|
|
|
| #ifdef HASEVENTS
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| void bintroutine0() {
|
| eventlist[0].active=1;
|
| detachinterrupt(eventlist[0].pin);
|
| }
|
| void bintroutine1() {
|
| eventlist[1].active=1;
|
| detachinterrupt(eventlist[1].pin);
|
| }
|
| void bintroutine2() {
|
| eventlist[2].active=1;
|
| detachinterrupt(eventlist[2].pin);
|
| }
|
| void bintroutine3() {
|
| eventlist[3].active=1;
|
| detachinterrupt(eventlist[3].pin);
|
| }
|
|
|
| mem_t eventindex(mem_t pin) {
|
| mem_t i;
|
|
|
| for(i=0; i<EVENTLISTSIZE; i++ ) if (eventlist[i].pin == pin) return i;
|
| return -1;
|
| }
|
|
|
| mem_t enableevent(mem_t pin){
|
| mem_t inter;
|
| mem_t i;
|
|
|
|
|
| if ((i=eventindex(pin))<0) return 0;
|
|
|
|
|
| inter=pintointerrupt(eventlist[i].pin);
|
| if (inter < 0) return 0;
|
|
|
|
|
| switch(i) {
|
| case 0:
|
| attachinterrupt(inter, bintroutine0, eventlist[i].mode);
|
| break;
|
| case 1:
|
| attachinterrupt(inter, bintroutine1, eventlist[i].mode);
|
| break;
|
| case 2:
|
| attachinterrupt(inter, bintroutine2, eventlist[i].mode);
|
| break;
|
| case 3:
|
| attachinterrupt(inter, bintroutine3, eventlist[i].mode);
|
| break;
|
| default:
|
| return 0;
|
| }
|
|
|
|
|
| eventlist[i].enabled=1;
|
| return 1;
|
| }
|
|
|
|
|
| void disableevent(mem_t pin) {
|
| detachinterrupt(pin);
|
| }
|
|
|
|
|
| void initevents() {
|
| mem_t i;
|
|
|
| for(i=0; i<EVENTLISTSIZE; i++) eventlist[i].pin=-1;
|
| }
|
|
|
|
|
| void xevent() {
|
| mem_t pin, mode;
|
| mem_t type=0;
|
| address_t line=0;
|
|
|
|
|
| nexttoken();
|
|
|
|
|
| if (termsymbol()) {
|
| for (ax=0; ax<EVENTLISTSIZE; ax++) {
|
| if (eventlist[ax].pin >= 0) {
|
| outnumber(eventlist[ax].pin); outspc();
|
| outnumber(eventlist[ax].mode); outspc();
|
| outnumber(eventlist[ax].type); outspc();
|
| outnumber(eventlist[ax].linenumber); outspc();
|
| outcr();
|
| }
|
| }
|
| outnumber(nevents); outcr();
|
| nexttoken();
|
| return;
|
| }
|
|
|
|
|
| if (token == TSTOP) {
|
| events_enabled=0;
|
| nexttoken();
|
| return;
|
| }
|
|
|
| if (token == TCONT) {
|
| events_enabled=1;
|
| nexttoken();
|
| return;
|
| }
|
|
|
|
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
|
|
| switch(args) {
|
| case 2:
|
| mode=pop();
|
| if (mode > 3) {
|
| error(EARGS);
|
| return;
|
| }
|
| case 1:
|
| pin=pop();
|
| break;
|
| default:
|
| error(EARGS);
|
| }
|
|
|
|
|
| if (token == TGOTO || token == TGOSUB) {
|
| type=token;
|
|
|
|
|
| if (!expectexpr()) return;
|
| line=pop();
|
| }
|
|
|
|
|
|
|
| if (type) {
|
| if (!addevent(pin, mode, type, line)) {
|
| error(EARGS);
|
| return;
|
| }
|
| } else {
|
| disableevent(pin);
|
| deleteevent(pin);
|
| return;
|
| }
|
|
|
|
|
| if (!enableevent(pin)) {
|
| deleteevent(pin);
|
| error(EARGS);
|
| return;
|
| }
|
| }
|
|
|
|
|
| mem_t addevent(mem_t pin, mem_t mode, mem_t type, address_t linenumber) {
|
| int i;
|
|
|
|
|
| for (i=0; i<EVENTLISTSIZE; i++)
|
| if (pin == eventlist[i].pin) goto slotfound;
|
|
|
|
|
| if (nevents >= EVENTLISTSIZE) return 0;
|
| for (i=0; i<EVENTLISTSIZE; i++)
|
| if (eventlist[i].pin == -1) goto slotfound;
|
|
|
|
|
| return 0;
|
|
|
|
|
| slotfound:
|
| eventlist[i].enabled=0;
|
| eventlist[i].pin=pin;
|
| eventlist[i].mode=mode;
|
| eventlist[i].type=type;
|
| eventlist[i].linenumber=linenumber;
|
| eventlist[i].active=0;
|
| nevents++;
|
| return 1;
|
| }
|
|
|
| void deleteevent(mem_t pin) {
|
| int i;
|
|
|
|
|
| i=eventindex(pin);
|
|
|
| if (i >= 0) {
|
| eventlist[i].enabled=0;
|
| eventlist[i].pin=-1;
|
| eventlist[i].mode=0;
|
| eventlist[i].type=0;
|
| eventlist[i].linenumber=0;
|
| eventlist[i].active=0;
|
| nevents--;
|
| }
|
| }
|
| #endif
|
|
|
| |
| |
|
|
|
|
|
|
| char streq(const char *s, char *m){
|
| short i=0;
|
|
|
| while (m[i]!=0 && s[i]!=0 && i < SBUFSIZE){
|
| if (s[i] != m[i]) return 0;
|
| i++;
|
| }
|
| return 1;
|
| }
|
|
|
| |
| |
|
|
| void xcatalog() {
|
| #if defined(FILESYSTEMDRIVER)
|
| char filename[SBUFSIZE];
|
| const char *name;
|
|
|
| nexttoken();
|
| getfilename(filename, 0);
|
| if (!USELONGJUMP && er) return;
|
|
|
| rootopen();
|
| while (rootnextfile()) {
|
| if (rootisfile()) {
|
| name=rootfilename();
|
| if (*name != '_' && *name !='.' && streq(name, filename)){
|
| outscf(name, 14); outspc();
|
| if (rootfilesize()>0) outnumber(rootfilesize());
|
| outcr();
|
| if (dspwaitonscroll() == 27) break;
|
| }
|
| }
|
| rootfileclose();
|
| }
|
| rootclose();
|
| #else
|
| nexttoken();
|
| #endif
|
| }
|
|
|
| |
| |
|
|
| void xdelete() {
|
| #if defined(FILESYSTEMDRIVER)
|
| char filename[SBUFSIZE];
|
|
|
| nexttoken();
|
| getfilename(filename, 0);
|
| if (!USELONGJUMP && er) return;
|
|
|
| removefile(filename);
|
| #else
|
| nexttoken();
|
| #endif
|
| }
|
|
|
| |
| |
|
|
| void xopen() {
|
| #if defined(FILESYSTEMDRIVER) || defined(HASRF24) || defined(HASMQTT) || defined(HASWIRE) || defined(HASSERIAL1)
|
| char stream = IFILE;
|
| char* filename;
|
| int mode;
|
|
|
|
|
| nexttoken();
|
| if (token == '&') {
|
| if (!expectexpr()) return;
|
| stream=pop();
|
| if (token != ',') {error(EUNKNOWN); return; }
|
| nexttoken();
|
| }
|
|
|
|
|
|
|
| filename = getfilename2(0);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| args=0;
|
| if (token == ',') {
|
| nexttoken();
|
| parsearguments();
|
| }
|
|
|
|
|
| if (args == 0 ) {
|
| mode=0;
|
| } else if (args == 1) {
|
| mode=pop();
|
| } else {
|
| error(EARGS);
|
| return;
|
| }
|
|
|
|
|
| switch(stream) {
|
| #ifdef HASSERIAL1
|
| case ISERIAL1:
|
| prtclose();
|
| if (mode == 0) mode=9600;
|
| if (prtopen(filename, mode)) ert=0; else ert=1;
|
| break;
|
| #endif
|
| #ifdef FILESYSTEMDRIVER
|
| case IFILE:
|
| switch (mode) {
|
| case 1:
|
| ofileclose();
|
| if (ofileopen(filename, "w")) ert=0; else ert=1;
|
| break;
|
| case 2:
|
| ofileclose();
|
| if (ofileopen(filename, "a")) ert=0; else ert=1;
|
| break;
|
| default:
|
| case 0:
|
| ifileclose();
|
| if (ifileopen(filename)) ert=0; else ert=1;
|
| break;
|
| }
|
| break;
|
| #endif
|
| #ifdef HASRF24
|
| case IRADIO:
|
| if (mode == 0) {
|
| iradioopen(filename);
|
| } else if (mode == 1) {
|
| oradioopen(filename);
|
| }
|
| break;
|
| #endif
|
| #if defined(HASWIRE)
|
| case IWIRE:
|
| wireopen(filename[0], mode);
|
| break;
|
| #endif
|
| #ifdef HASMQTT
|
| case IMQTT:
|
| if (mode == 0) {
|
| mqttsubscribe(filename);
|
| } else if (mode == 1) {
|
| mqttsettopic(filename);
|
| }
|
| break;
|
| #endif
|
| default:
|
| error(EORANGE);
|
| return;
|
| }
|
| #endif
|
| nexttoken();
|
| }
|
|
|
| |
| |
|
|
| void xfopen() {
|
| address_t stream = popaddress();
|
| if (stream == 9) push(mqttstate()); else push(0);
|
| }
|
|
|
| |
| |
|
|
| void xclose() {
|
| #if defined(FILESYSTEMDRIVER) || defined(HASRF24) || defined(HASMQTT) || defined(HASWIRE)
|
| char stream = IFILE;
|
| char mode;
|
|
|
| nexttoken();
|
| if (token == '&') {
|
| if (!expectexpr()) return;
|
| stream=pop();
|
| if (token != ',' && ! termsymbol()) {error(EUNKNOWN); return; }
|
| nexttoken();
|
| }
|
|
|
| parsearguments();
|
| if (args == 0) {
|
| mode=0;
|
| } else if (args == 1) {
|
| mode=pop();
|
| } else {
|
| error(EARGS);
|
| return;
|
| }
|
|
|
|
|
| switch(stream) {
|
| case IFILE:
|
| if (mode == 1 || mode == 2) ofileclose(); else if (mode == 0) ifileclose();
|
| break;
|
| }
|
| #endif
|
| nexttoken();
|
| }
|
|
|
| |
| |
|
|
| void xfdisk() {
|
| #if defined(FILESYSTEMDRIVER)
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
| if (args > 1) error(EORANGE);
|
| if (args == 0) push(0);
|
| outsc("Format disk (y/N)?");
|
| (void) consins(sbuffer, SBUFSIZE);
|
| if (sbuffer[1] == 'y') formatdisk(pop());
|
| if (fsstat(1) > 0) outsc("ok\n"); else outsc("fail\n");
|
| #endif
|
| nexttoken();
|
| }
|
|
|
| #ifdef HASSTEFANSEXT
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| void xusr() {
|
| address_t fn;
|
| number_t v;
|
| int arg;
|
| address_t a;
|
|
|
| v=pop();
|
| arg=(int)v;
|
| fn=pop();
|
| switch(fn) {
|
|
|
| case 0:
|
| switch(arg) {
|
| case 0:
|
| push(bsystype);
|
| break;
|
| case 1:
|
| a=0;
|
| #ifdef HASAPPLE1
|
| a|=1;
|
| #endif
|
| #ifdef HASARDUINOIO
|
| a|=2;
|
| #endif
|
| #ifdef HASFILEIO
|
| a|=4;
|
| #endif
|
| #ifdef HASDARTMOUTH
|
| a|=8;
|
| #endif
|
| #ifdef HASGRAPH
|
| a|=16;
|
| #endif
|
| #ifdef HASDARKARTS
|
| a|=32;
|
| #endif
|
| #ifdef HASIOT
|
| a|=64;
|
| #endif
|
| push(a); break;
|
| case 2:
|
| push(0); break;
|
|
|
| #ifdef HASFLOAT
|
| case 3: push(-1); break;
|
| #else
|
| case 3: push(0); break;
|
| #endif
|
| case 4: push(numsize); break;
|
| case 5: push(maxnum); break;
|
| case 6: push(addrsize); break;
|
| case 7: push(maxaddr); break;
|
| case 8: push(strindexsize); break;
|
| case 9: push(memsize+1); break;
|
| case 10: push(elength()); break;
|
| case 11: push(GOSUBDEPTH); break;
|
| case 12: push(FORDEPTH); break;
|
| case 13: push(STACKSIZE); break;
|
| case 14: push(BUFSIZE); break;
|
| case 15: push(SBUFSIZE); break;
|
| case 16: push(ARRAYSIZEDEF); break;
|
| case 17: push(defaultstrdim); break;
|
|
|
| case 24: push(top); break;
|
| case 25: push(here); break;
|
| case 26: push(himem); break;
|
| case 27: push(0); break;
|
| case 28: push(freeRam()); break;
|
| case 29: push(gosubsp); break;
|
| case 30: push(loopsp); break;
|
| case 31: push(0); break;
|
| case 32: push(sp); break;
|
| #ifdef HASDARTMOUTH
|
| case 33: push(data); break;
|
| #else
|
| case 33: push(0); break;
|
| #endif
|
| case 34: push(0); break;
|
| #ifdef FASTTICKERPROFILE
|
| case 35: push(avgfasttick); break;
|
| #endif
|
|
|
| case 48: push(id); break;
|
| case 49: push(idd); break;
|
| case 50: push(od); break;
|
| case 51: push(odd); break;
|
| default: push(0);
|
| }
|
| break;
|
|
|
| case 1:
|
| push(serialstat(arg));
|
| break;
|
|
|
| case 2:
|
| #if defined(DISPLAYDRIVER) || defined(GRAPHDISPLAYDRIVER)
|
| push(dspstat(arg));
|
| #elif defined(ARDUINOVGA)
|
| push(vgastat(arg));
|
| #else
|
| push(0);
|
| #endif
|
| break;
|
|
|
| #ifdef HASSERIAL1
|
| case 4:
|
| push(prtstat(arg));
|
| break;
|
| #endif
|
|
|
| #if defined(HASWIRE)
|
| case 7:
|
| push(wirestat(arg));
|
| break;
|
| #endif
|
|
|
| #ifdef HASRF24
|
| case 8:
|
| push(radiostat(arg));
|
| break;
|
| #endif
|
|
|
| #ifdef HASMQTT
|
| case 9:
|
| push(mqttstat(arg));
|
| break;
|
| #endif
|
|
|
| #ifdef FILESYSTEMDRIVER
|
| case 16:
|
| push(fsstat(arg));
|
| break;
|
| #endif
|
| case 32:
|
|
|
|
|
| default:
|
| if (fn>31) push(usrfunction(fn, v)); else push(0);
|
| }
|
| }
|
| #endif
|
|
|
| |
| |
|
|
| void xcall() {
|
| int r;
|
|
|
| if (!expectexpr()) return;
|
| r=pop();
|
| switch(r) {
|
| case 0:
|
|
|
| eflush();
|
| ofileclose();
|
| #if defined(POSIXFRAMEBUFFER)
|
| vgaend();
|
| #endif
|
| restartsystem();
|
| break;
|
|
|
| case 1:
|
| fsbegin();
|
| break;
|
|
|
| default:
|
|
|
| if (r > 31) usrcall(r); else { error(EORANGE); return; }
|
| nexttoken();
|
| return;
|
| }
|
| }
|
|
|
|
|
| #ifdef HASDARTMOUTH
|
| |
| |
|
|
| void xdata() {
|
| while (!termsymbol()) nexttoken();
|
| }
|
|
|
| |
| |
|
|
| void nextdatarecord() {
|
| address_t h;
|
| mem_t s=1;
|
|
|
|
|
| h=here;
|
|
|
|
|
| if (data == 0) {
|
| here=0;
|
| while (here<top && token!=TDATA) gettoken();
|
| data=here;
|
| datarc=1;
|
| }
|
|
|
| processdata:
|
| |
| |
| |
| |
| |
| |
|
|
| if (data == top) {
|
| token=NUMBER;
|
| x=0;
|
| ert=1;
|
| here=h;
|
| return;
|
| }
|
|
|
|
|
| here=data;
|
| gettoken();
|
| if (token == '-') {s=-1; gettoken();}
|
| if (token == NUMBER || token == STRING) goto enddatarecord;
|
| if (token == ',') {
|
| gettoken();
|
| if (token == '-') {s=-1; gettoken();}
|
| if (token != NUMBER && token != STRING) {
|
| error(EUNKNOWN);
|
| here=h;
|
| return;
|
| }
|
| goto enddatarecord;
|
| }
|
|
|
| if (termsymbol()) {
|
| while (here<top && token!=TDATA) gettoken();
|
| data=here;
|
| goto processdata;
|
| }
|
|
|
| if (DEBUG) { outsc("** error in nextdata after termsymbol "); outnumber(data); outcr(); }
|
| error(EUNKNOWN);
|
|
|
| enddatarecord:
|
| if (token == NUMBER && s == -1) { x=-x; s=1; }
|
| data=here;
|
| datarc++;
|
| here=h;
|
|
|
| if (DEBUG) {
|
| outsc("** leaving nextdata with data and here ");
|
| outnumber(data); outspc();
|
| outnumber(here); outcr();
|
| }
|
| }
|
|
|
| |
| |
|
|
| void xread(){
|
| token_t t0;
|
|
|
| lhsobject_t lhs;
|
|
|
| mem_t datat;
|
| address_t lendest, lensource, newlength;
|
| int k;
|
| string_t s;
|
|
|
|
|
| nextdata:
|
|
|
| nexttoken();
|
|
|
|
|
| lhs.name=name;
|
|
|
| lefthandside(&lhs);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** read lefthandside ");
|
| outname(&lhs.name);
|
| outsc(" at here ");
|
| outnumber(here);
|
| outsc(" and data pointer ");
|
| outnumber(data);
|
| outcr();
|
| }
|
|
|
|
|
|
|
| if (!termsymbol() && token != ',') { error(EUNKNOWN); return; }
|
|
|
|
|
| t0=token;
|
|
|
|
|
| nextdatarecord();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| switch (token) {
|
| case NUMBER:
|
|
|
| assignnumber2(&lhs, x);
|
| break;
|
| case STRING:
|
| if (lhs.name.token != STRINGVAR) {
|
|
|
| if (sr.address) assignnumber2(&lhs, memread2(sr.address));
|
| else assignnumber2(&lhs, *sr.ir);
|
| } else {
|
|
|
|
|
| getstring(&s, &lhs.name, lhs.i, lhs.j);
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| lendest=s.length;
|
|
|
| if (DEBUG) {
|
| outsc("* read stringcode "); outname(&lhs.name); outcr();
|
| outsc("** read source string length "); outnumber(sr.length); outcr();
|
| outsc("** read dest string length "); outnumber(s.length); outcr();
|
| outsc("** read dest string dimension "); outnumber(s.strdim); outcr();
|
| }
|
|
|
|
|
| if ((lhs.i+sr.length-1) > s.strdim) { error(EORANGE); return; }
|
|
|
|
|
| assignstring(&s, &sr, sr.length);
|
|
|
|
|
| newlength = lhs.i+sr.length-1;
|
| setstringlength(&lhs.name, newlength, lhs.j);
|
|
|
| }
|
| break;
|
| default:
|
| error(EUNKNOWN);
|
| return;
|
| }
|
|
|
|
|
| if (t0 == ',') goto nextdata;
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** leaving xread with "); outnumber(token); outcr();
|
| outsc("** at here "); outnumber(here); outcr();
|
| outsc("** and data pointer "); outnumber(data); outcr();
|
| }
|
|
|
|
|
| token=t0;
|
| }
|
|
|
| |
| |
|
|
| void xrestore(){
|
| short rec;
|
|
|
| nexttoken();
|
|
|
|
|
| if (termsymbol()) {
|
| data=0;
|
| datarc=1;
|
| return;
|
| }
|
|
|
|
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| rec=pop();
|
|
|
|
|
| if (rec < datarc) {
|
| data=0;
|
| datarc=1;
|
| }
|
|
|
|
|
| while (datarc < rec && data < top) nextdatarecord();
|
|
|
|
|
| nexttoken();
|
| }
|
|
|
| |
| |
| |
|
|
| void xdef(){
|
| address_t a;
|
|
|
| name_t function;
|
| name_t variable;
|
|
|
|
|
| if (!expect(TFN, EUNKNOWN)) return;
|
|
|
|
|
| if (!expect(ARRAYVAR, EUNKNOWN)) return;
|
|
|
| function=name;
|
| function.token=TFN;
|
|
|
|
|
| if (!expect('(', EUNKNOWN)) return;
|
| nexttoken();
|
| if (token == ')') {
|
| zeroname(&variable);
|
| } else if (token == VARIABLE) {
|
| variable=name;
|
| nexttoken();
|
| } else {
|
| error(EUNKNOWN);
|
| return;
|
| }
|
| if (token != ')') { error(EUNKNOWN); return; }
|
|
|
|
|
| nexttoken();
|
|
|
|
|
| if (DEBUG) {
|
| outsc("** DEF FN with function ");
|
| outname(&function);
|
| outsc(" and argument ");
|
| outname(&variable);
|
| outsc(" at here ");
|
| outnumber(here);
|
| outsc(" and token is ");
|
| outnumber(token);
|
| outcr();
|
| }
|
|
|
|
|
| if ((a=bfind(&function))==0) a=bmalloc(&function, 1);
|
| if (DEBUG) {outsc("** found function structure at "); outnumber(a); outcr(); }
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (a == 0) { error(EVARIABLE); return; }
|
|
|
|
|
|
|
|
|
| setaddress(a, memwrite2, here);
|
| a=a+addrsize;
|
|
|
|
|
| if (token == '=')
|
| memwrite2(a++, VARIABLE);
|
| else
|
| memwrite2(a++, 0);
|
|
|
|
|
| memwrite2(a++, 1);
|
|
|
|
|
| memwrite2(a++, variable.token);
|
| setname_pgm(a, &variable);
|
| a=a+sizeof(name_t)-1;
|
|
|
|
|
| if (token == '=') {
|
| while (!termsymbol()) nexttoken();
|
| } else {
|
| #if defined(HASMULTILINEFUNCTIONS)
|
| while (token != TFEND) {
|
| nexttoken();
|
| if (token == TDEF || token == EOL) { error(EFUN); return; }
|
| }
|
| nexttoken();
|
| #else
|
| error(EFUN);
|
| return;
|
| #endif
|
| }
|
| }
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| void xfn(mem_t m) {
|
| address_t a;
|
| address_t h1, h2;
|
| name_t variable;
|
| token_t type;
|
|
|
|
|
| if (!expect(ARRAYVAR, EUNKNOWN)) return;
|
| name.token=TFN;
|
| a=bfind(&name);
|
| if (a == 0) {error(EUNKNOWN); return; }
|
|
|
| if (DEBUG) { outsc("** in xfn found function "); outname(&name); outsc(" at "); outnumber(a); outcr(); }
|
|
|
|
|
| if (!expect('(', EUNKNOWN)) return;
|
| nexttoken();
|
|
|
|
|
| if (token == ')') {
|
| push(0);
|
| } else {
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| }
|
| if (token != ')') {error(EUNKNOWN); return; }
|
|
|
|
|
| h1=getaddress(a, memread2);
|
| a=a+addrsize;
|
|
|
| if (DEBUG) { outsc("** found function address "); outnumber(h1); outcr(); }
|
|
|
|
|
| type=memread2(a++);
|
|
|
| if (DEBUG) { outsc("** found function type "); outnumber(type); outcr(); }
|
|
|
|
|
| a++;
|
|
|
|
|
|
|
| variable.token=memread2(a++);
|
| (void) getname(a, &variable, memread2);
|
| a=a+sizeof(name_t)-1;
|
|
|
| if (DEBUG) { outsc("** found function variable "); outname(&variable); outcr(); }
|
|
|
|
|
| if (variable.c[0]) {
|
| if (!bmalloc(&variable, 0)) { error(EVARIABLE); return; }
|
| setvar(&variable, pop());
|
| }
|
|
|
|
|
| h2=here;
|
| here=h1;
|
|
|
|
|
| if (type == VARIABLE) {
|
| if (DEBUG) {outsc("** evaluating expression at "); outnumber(here); outcr(); }
|
| if (!expectexpr()) return;
|
| } else {
|
| #ifdef HASMULTILINEFUNCTIONS
|
|
|
|
|
|
|
| if (DEBUG) {outsc("** starting a new interpreter instance "); outcr();}
|
|
|
| nexttoken();
|
| fncontext++;
|
| if (fncontext > FNLIMIT) { error(EFUN); return; }
|
| statement();
|
| if (!USELONGJUMP && er) return;
|
| if (fncontext > 0) fncontext--; else error(EFUN);
|
| #else
|
| error(EFUN);
|
| return;
|
| #endif
|
| }
|
|
|
|
|
| here=h2;
|
| (void) bfree(&variable);
|
|
|
| |
|
|
| if (m == 1) {
|
| pop();
|
| nexttoken();
|
| }
|
| }
|
|
|
| |
| |
|
|
|
|
| void xon(){
|
| number_t cr, tmp;
|
| int ci;
|
| token_t t;
|
| int line = 0;
|
|
|
| |
|
|
|
|
| nexttoken();
|
| switch(token) {
|
| #ifdef HASERRORHANDLING
|
| case TERROR:
|
| xerror();
|
| return;
|
| #endif
|
| #ifdef HASEVENTS
|
| case TEVENT:
|
| xevent();
|
| return;
|
| #endif
|
| default:
|
| expression();
|
| if (!USELONGJUMP && er) return;
|
| }
|
|
|
|
|
| cr=pop();
|
| if (DEBUG) { outsc("** in on condition found "); outnumber(cr); outcr(); }
|
|
|
|
|
| if (token != TGOSUB && token != TGOTO) { error(EUNKNOWN); return; }
|
|
|
|
|
| t=token;
|
|
|
|
|
| nexttoken();
|
| parsearguments();
|
| if (!USELONGJUMP && er) return;
|
| if (args == 0) { error(EARGS); return; }
|
|
|
|
|
| if (cr > args && cr <= 0) ci=0; else ci=(int)cr;
|
|
|
| |
| |
| |
| |
| |
|
|
| while (args) {
|
| tmp=pop();
|
| if (args == ci) {
|
| if (tmp < 0) er=ELINE;
|
| line=tmp;
|
| }
|
| args--;
|
| }
|
| if (!USELONGJUMP && er) return;
|
|
|
| if (DEBUG) { outsc("** in on found line as target "); outnumber(line); outcr(); }
|
|
|
|
|
| if (line == 0) {
|
| nexttoken();
|
| return;
|
| }
|
|
|
|
|
| if (t == TGOSUB) pushgosubstack(0);
|
| if (!USELONGJUMP && er) return;
|
|
|
| findline(line);
|
| if (!USELONGJUMP && er) return;
|
|
|
| |
|
|
| if (st == SINT) st=SRUN;
|
|
|
| }
|
| #endif
|
|
|
|
|
|
|
| #ifdef HASSTRUCT
|
| void xwhile() {
|
|
|
|
|
| if (DEBUG) { outsc("** in while "); outnumber(here); outspc(); outnumber(token); outcr(); }
|
|
|
|
|
| if (st == SINT) here=bi-ibuffer;
|
|
|
|
|
| pushloop(0, TWHILE, here, 0, 0);
|
|
|
|
|
| if (!expectexpr()) return;
|
|
|
|
|
| if (!pop()) {
|
| droploop();
|
| if (st == SINT) bi=ibuffer+here;
|
| nexttoken();
|
| findbraket(TWHILE, TWEND);
|
| nexttoken();
|
| }
|
| }
|
|
|
| void xwend() {
|
| blocation_t l;
|
| bloop_t* loop;
|
|
|
|
|
| pushlocation(&l);
|
|
|
|
|
| loop = activeloop();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (loop->var.token != TWHILE ) { error(TWEND); return; }
|
|
|
|
|
| if (st == SINT) bi=ibuffer+loop->here; else here=loop->here;
|
|
|
|
|
| if (!expectexpr()) return;
|
|
|
|
|
| if (!pop()) {
|
| droploop();
|
| poplocation(&l);
|
| nexttoken();
|
| }
|
| }
|
|
|
| void xrepeat() {
|
|
|
| if (DEBUG) { outsc("** in repeat "); outnumber(here); outspc(); outnumber(token); outcr(); }
|
|
|
|
|
| if (st == SINT) here=bi-ibuffer;
|
|
|
|
|
|
|
| pushloop(0, TREPEAT, here, 0, 0);
|
|
|
|
|
| nexttoken();
|
| }
|
|
|
| void xuntil() {
|
| blocation_t l;
|
| bloop_t* loop;
|
|
|
|
|
| if (!expectexpr()) return;
|
|
|
|
|
| pushlocation(&l);
|
|
|
|
|
|
|
| loop = activeloop();
|
| if (!USELONGJUMP && er) return;
|
|
|
|
|
| if (!pop()) {
|
|
|
|
|
| if (loop->var.token != TREPEAT) {
|
| error(TUNTIL);
|
| return;
|
| }
|
|
|
|
|
| if (st == SINT) bi=ibuffer+loop->here; else here=loop->here;
|
|
|
| } else {
|
|
|
|
|
| droploop();
|
| poplocation(&l);
|
| }
|
|
|
| nexttoken();
|
| }
|
|
|
| void xswitch() {
|
| number_t r;
|
| mem_t match = 0;
|
| mem_t swcount = 0;
|
| blocation_t l;
|
|
|
|
|
| if (!expectexpr()) return;
|
| r=pop();
|
|
|
|
|
| pushlocation(&l);
|
|
|
|
|
| while (token != EOL) {
|
| if (token == TSWEND) break;
|
|
|
| if (token == TSWITCH) {
|
|
|
| if (DEBUG) { outsc("** in SWITCH - nesting found "); outcr(); }
|
|
|
| nexttoken();
|
| findbraket(TSWITCH, TSWEND);
|
|
|
| if (DEBUG) { outsc("** in SWITCH SWEND found at "); outnumber(here); outcr(); }
|
|
|
| if (!USELONGJUMP && er) return;
|
| }
|
|
|
| if (token == TCASE) {
|
|
|
|
|
| nexttoken();
|
| parsearguments();
|
|
|
| if (DEBUG) { outsc("** in CASE found "); outnumber(args); outsc(" arguments"); outcr(); }
|
|
|
| if (!USELONGJUMP && er) return;
|
| if (args == 0) {
|
| error(TCASE);
|
| return;
|
| }
|
| while (args > 0) {
|
| if (pop() == r) match=1;
|
| args--;
|
| }
|
|
|
| if (match) {
|
| return;
|
| }
|
| }
|
| nexttoken();
|
| }
|
|
|
|
|
| poplocation(&l);
|
| }
|
|
|
|
|
| void xcase() {
|
| while (token != EOL) {
|
| nexttoken();
|
| if (token == TSWEND) break;
|
|
|
| |
| |
| |
| |
| |
|
|
| }
|
| }
|
| #endif
|
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| void statement(){
|
| mem_t xc;
|
|
|
| if (DEBUG) bdebug("statement \n");
|
|
|
|
|
|
|
|
|
| #if USELONGJUMP == 1
|
| if (fncontext == 0) if (setjmp(sthook)) goto errorhandler;
|
| #endif
|
|
|
|
|
| while (token != EOL) {
|
| #ifdef HASSTEFANSEXT
|
|
|
| if (debuglevel == 1) { debugtoken(); outcr(); }
|
| #endif
|
| switch(token){
|
| case ':':
|
| case LINENUMBER:
|
| nexttoken();
|
| break;
|
|
|
| case TPRINT:
|
| xprint();
|
| break;
|
| case TLET:
|
| nexttoken();
|
| if ((token != ARRAYVAR) && (token != STRINGVAR) && (token != VARIABLE)) {
|
| error(EUNKNOWN);
|
| break;
|
| }
|
| case STRINGVAR:
|
| case ARRAYVAR:
|
| case VARIABLE:
|
| assignment();
|
| break;
|
| case TINPUT:
|
| xinput();
|
| break;
|
| case TRETURN:
|
| #ifndef HASMULTILINEFUNCTIONS
|
| xreturn();
|
| #else
|
| if (fncontext > 0) {
|
| nexttoken();
|
| if (termsymbol()) { push(0); }
|
| else expression();
|
| return;
|
| } else
|
| xreturn();
|
| #endif
|
| break;
|
| #ifndef HASMULTILINEFUNCTIONS
|
| case TGOSUB:
|
| case TGOTO:
|
| xgoto();
|
| break;
|
| #else
|
| case TGOSUB:
|
| if (fncontext > 0) { error(EFUN); return; }
|
| case TGOTO:
|
| xgoto();
|
| break;
|
| #endif
|
| case TIF:
|
| xif();
|
| break;
|
| case TFOR:
|
| xfor();
|
| break;
|
| case TNEXT:
|
| xnext();
|
| break;
|
| case TBREAK:
|
| xbreak();
|
| break;
|
| case TSTOP:
|
| case TEND:
|
| *ibuffer=0;
|
| st=SINT;
|
| eflush();
|
| ofileclose();
|
| nexttoken();
|
| if (token == TSTOP) {
|
| restartsystem();
|
| }
|
| *ibuffer=0;
|
| st=SINT;
|
| return;
|
| case TLIST:
|
| xlist();
|
| break;
|
| case TNEW:
|
| xnew();
|
| return;
|
| case TCONT:
|
| if (st==SRUN || st==SERUN) {
|
| xcont();
|
| break;
|
| }
|
| case TRUN:
|
| xrun();
|
| return;
|
| case TREM:
|
| xrem();
|
| break;
|
|
|
| #ifdef HASAPPLE1
|
| case TDIM:
|
| xdim();
|
| break;
|
| case TCLR:
|
| xclr();
|
| break;
|
| case TTAB:
|
| case TSPC:
|
| xtab();
|
| break;
|
| case TPOKE:
|
| xpoke();
|
| break;
|
| #endif
|
|
|
| case TSAVE:
|
| xsave();
|
| break;
|
| case TLOAD:
|
| xload(0);
|
| if (st == SINT) return;
|
| else break;
|
| #ifdef HASSTEFANSEXT
|
| case TDUMP:
|
| xdump();
|
| break;
|
| case TGET:
|
| xget();
|
| break;
|
| case TPUT:
|
| xput();
|
| break;
|
| case TSET:
|
| xset();
|
| break;
|
| case TNETSTAT:
|
| xnetstat();
|
| break;
|
| case TCLS:
|
| ax=od;
|
|
|
| #if defined(DISPLAYDRIVER) || defined(GRAPHDISPLAYDRIVER)
|
| od=ODSP;
|
| #endif
|
| outch(12);
|
| od=ax;
|
| nexttoken();
|
| break;
|
| case TLOCATE:
|
| xlocate();
|
| break;
|
|
|
| case TCALL:
|
| xcall();
|
| break;
|
| #endif
|
|
|
| #ifdef HASARDUINOIO
|
| case TDWRITE:
|
| xdwrite();
|
| break;
|
| case TAWRITE:
|
| xawrite();
|
| break;
|
| case TPINM:
|
| xpinm();
|
| break;
|
| case TDELAY:
|
| xdelay();
|
| break;
|
| #ifdef HASTONE
|
| case TTONE:
|
| xtone();
|
| break;
|
| #endif
|
| #ifdef HASPULSE
|
| case TPULSE:
|
| xpulse();
|
| break;
|
| #endif
|
| #endif
|
|
|
| #ifdef HASFILEIO
|
| case TCATALOG:
|
| xcatalog();
|
| break;
|
| case TDELETE:
|
| xdelete();
|
| break;
|
| case TOPEN:
|
| xopen();
|
| break;
|
| case TCLOSE:
|
| xclose();
|
| break;
|
| case TFDISK:
|
| xfdisk();
|
| break;
|
| #endif
|
|
|
| #ifdef HASGRAPH
|
| case TCOLOR:
|
| xcolor();
|
| break;
|
| case TPLOT:
|
| xplot();
|
| break;
|
| case TLINE:
|
| xline();
|
| break;
|
| case TRECT:
|
| xrect();
|
| break;
|
| case TCIRCLE:
|
| xcircle();
|
| break;
|
| case TFRECT:
|
| xfrect();
|
| break;
|
| case TFCIRCLE:
|
| xfcircle();
|
| break;
|
| #endif
|
| #ifdef HASDARTMOUTH
|
| case TDATA:
|
| xdata();
|
| break;
|
| case TREAD:
|
| xread();
|
| break;
|
| case TRESTORE:
|
| xrestore();
|
| break;
|
| case TDEF:
|
| xdef();
|
| break;
|
| case TON:
|
| xon();
|
| break;
|
| #ifdef HASMULTILINEFUNCTIONS
|
| case TFN:
|
| xfn(1);
|
| break;
|
| case TFEND:
|
|
|
|
|
| if (fncontext == 0) { error(EFUN); return; }
|
| else { push(0); return; }
|
| break;
|
| #endif
|
| #endif
|
| #ifdef HASSTEFANSEXT
|
| case TELSE:
|
| xelse();
|
| break;
|
| #endif
|
| #ifdef HASDARKARTS
|
| case TEVAL:
|
| xeval();
|
| break;
|
| #endif
|
| #ifdef HASERRORHANDLING
|
| case TERROR:
|
| xerror();
|
| break;
|
| #endif
|
| #ifdef HASIOT
|
| case TSLEEP:
|
| xsleep();
|
| break;
|
| case TWIRE:
|
| xwire();
|
| break;
|
| #endif
|
| #ifdef HASTIMER
|
| case TAFTER:
|
| case TEVERY:
|
| xtimer();
|
| break;
|
| #endif
|
| #ifdef HASEVENTS
|
| case TEVENT:
|
| xevent();
|
| break;
|
| #endif
|
| #ifdef HASSTRUCT
|
| case TWHILE:
|
| xwhile();
|
| break;
|
| case TWEND:
|
| xwend();
|
| break;
|
| case TREPEAT:
|
| xrepeat();
|
| break;
|
| case TUNTIL:
|
| xuntil();
|
| break;
|
| case TSWITCH:
|
| xswitch();
|
| break;
|
| case TCASE:
|
| xcase();
|
| break;
|
| case TSWEND:
|
| case TDO:
|
| case TDEND:
|
| nexttoken();
|
| break;
|
| #endif
|
| #ifdef HASEDITOR
|
| case TEDIT:
|
| xedit();
|
| break;
|
| #endif
|
| default:
|
|
|
| error(EUNKNOWN);
|
| goto errorhandler;
|
| }
|
|
|
|
|
| |
| |
| |
| |
| |
|
|
| #if defined(BREAKCHAR)
|
| #ifndef POSIXNONBLOCKING
|
| if (checkch() == BREAKCHAR) {
|
| st=SINT;
|
| if (od == 1) serialflush(); else xc=inch();
|
| return;
|
| }
|
| #else
|
| if (breakcondition) {
|
| breakcondition=0;
|
| st=SINT;
|
| if (od == 1) serialflush(); else xc=inch();
|
| return;
|
| }
|
| #endif
|
| #endif
|
|
|
|
|
| #if defined(BREAKPIN)
|
| if (getbreakpin() == 0) {
|
| st=SINT;
|
| return;
|
| };
|
| #endif
|
|
|
|
|
| #if defined(POSIXSIGNALS)
|
| if (breaksignal) {
|
| st=SINT;
|
| breaksignal=0;
|
| serialflush();
|
| outcr();
|
| return;
|
| }
|
| #endif
|
|
|
| |
|
|
| byield();
|
|
|
|
|
| errorhandler:
|
| #ifdef HASERRORHANDLING
|
| if (er) {
|
| if (st != SINT) {
|
| erh=er;
|
| er=0;
|
| switch(berrorh.type) {
|
| case TCONT:
|
| while(!termsymbol()) nexttoken();
|
| break;
|
| case TGOTO:
|
| findline(berrorh.linenumber);
|
| berrorh.type=0;
|
| berrorh.linenumber=0;
|
| if (er) return;
|
| break;
|
| case 0:
|
| return;
|
| default:
|
| nexttoken();
|
| }
|
| } else
|
| return;
|
| }
|
| #else
|
|
|
| if (er) return;
|
| #endif
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifdef HASTIMER
|
| if ((token == LINENUMBER || token == ':' || token == TNEXT) && (st == SERUN || st == SRUN)) {
|
|
|
| if (after_timer.enabled && fncontext == 0) {
|
| if (millis() > after_timer.last + after_timer.interval) {
|
| after_timer.enabled=0;
|
| if (after_timer.type == TGOSUB) {
|
| if (token == TNEXT || token == ':') here--;
|
| if (token == LINENUMBER) here-=(1+sizeof(address_t));
|
| pushgosubstack(0);
|
| }
|
| findline(after_timer.linenumber);
|
| if (er) return;
|
| }
|
| }
|
|
|
| if (every_timer.enabled && fncontext == 0) {
|
| if (millis() > every_timer.last + every_timer.interval) {
|
| every_timer.last=millis();
|
| if (every_timer.type == TGOSUB) {
|
| if (token == TNEXT || token == ':') here--;
|
| if (token == LINENUMBER) here-=(1+sizeof(address_t));
|
| pushgosubstack(0);
|
| if (er) return;
|
| }
|
| findline(every_timer.linenumber);
|
| if (er) return;
|
| }
|
| }
|
| }
|
| #endif
|
|
|
|
|
| #ifdef HASEVENTS
|
| if ((token == LINENUMBER || token == ':' || token == TNEXT) && (st == SERUN || st == SRUN)) {
|
|
|
| if (events_enabled && fncontext == 0) {
|
| for (ax=0; ax<EVENTLISTSIZE; ax++) {
|
| if (eventlist[ievent].pin && eventlist[ievent].enabled && eventlist[ievent].active) {
|
| if (eventlist[ievent].type == TGOSUB) {
|
| if (token == TNEXT || token == ':') here--;
|
| if (token == LINENUMBER) here-=(1+sizeof(address_t));
|
| pushgosubstack(TEVENT);
|
| if (er) return;
|
| }
|
| findline(eventlist[ievent].linenumber);
|
| if (er) return;
|
| eventlist[ievent].active=0;
|
| enableevent(eventlist[ievent].pin);
|
| events_enabled=0;
|
| break;
|
| }
|
| ievent=(ievent+1)%EVENTLISTSIZE;
|
| }
|
| }
|
| }
|
| #endif
|
| }
|
| }
|
|
|
| |
| |
|
|
| void setup() {
|
|
|
|
|
| timeinit();
|
|
|
|
|
| #ifdef HASEVENTS
|
| initevents();
|
| #endif
|
|
|
|
|
| ioinit();
|
| #ifdef FILESYSTEMDRIVER
|
|
|
| #endif
|
|
|
|
|
| bsetup();
|
|
|
| |
|
|
| #if (defined(SPIRAMINTERFACE) || defined(SPIRAMSIMULATOR)) && MEMSIZE == 0
|
| himem=memsize=spirambegin();
|
| #else
|
| #if defined(EEPROMMEMINTERFACE)
|
| |
| |
| |
|
|
| himem=memsize=ballocmem()+(elength()-eheadersize);
|
| #else
|
| himem=memsize=ballocmem();
|
| #endif
|
| #endif
|
|
|
| #ifndef EEPROMMEMINTERFACE
|
| if (DEBUG) { outsc("** on startup, memsize is "); outnumber(memsize); outcr(); }
|
|
|
|
|
| xnew();
|
|
|
| if (DEBUG) { outsc("** on startup, ran xnew "); outcr(); }
|
| #else
|
|
|
| if (eread(0) == 0 || eread(0) == 1) {
|
| top=getaddress(1, eread);
|
| resetbasicstate();
|
| for (address_t a=elength(); a<memsize; a++) memwrite2(a, 0);
|
| } else {
|
| eupdate(0, 0);
|
| setaddress(1, eupdate, 0);
|
| xnew();
|
| }
|
| #endif
|
|
|
| |
|
|
| if (!autorun()) {
|
| printmessage(MGREET); outspc();
|
| printmessage(EOUTOFMEMORY); outspc();
|
| if (memsize < maxnum) outnumber(memsize+1); else { outnumber(memsize/1024+1); outch('k'); }
|
| outspc();
|
| outnumber(elength()); outcr();
|
| }
|
|
|
|
|
| breakpinbegin();
|
| }
|
|
|
| |
| |
|
|
| void loop() {
|
|
|
| |
| |
| |
| |
|
|
| if (st == SERUN) {
|
| xrun();
|
|
|
| #ifndef EEPROMMEMINTERFACE
|
| top=0;
|
| #endif
|
| st=SINT;
|
| } else if (st == SRUN) {
|
| here=0;
|
| xrun();
|
| st=SINT;
|
| }
|
|
|
|
|
| iodefaults();
|
| form=0;
|
|
|
|
|
| printmessage(MPROMPT);
|
| (void) ins(ibuffer, BUFSIZE-2);
|
|
|
|
|
| bi=ibuffer;
|
| nexttoken();
|
|
|
|
|
| if (token == NUMBER) {
|
| ax=x;
|
| storeline();
|
|
|
|
|
| #ifdef EEPROMMEMINTERFACE
|
| setaddress(1, eupdate, top);
|
| #endif
|
| } else {
|
|
|
| statement();
|
| st=SINT;
|
| }
|
|
|
|
|
| if (er) reseterror();
|
|
|
| }
|
|
|
|
|
| #ifndef ARDUINO
|
| int main(int argc, char* argv[]){
|
|
|
|
|
| #ifdef HASARGS
|
| bargc=argc;
|
| bargv=argv;
|
| #endif
|
|
|
|
|
| setup();
|
| while (1)
|
| loop();
|
| }
|
| #endif
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| void bsetup() {
|
|
|
|
|
| }
|
|
|
| void bloop() {
|
|
|
|
|
| }
|
|
|
