summaryrefslogtreecommitdiff
path: root/apps/interpreters/bas/token.l
diff options
context:
space:
mode:
Diffstat (limited to 'apps/interpreters/bas/token.l')
-rw-r--r--apps/interpreters/bas/token.l1943
1 files changed, 1943 insertions, 0 deletions
diff --git a/apps/interpreters/bas/token.l b/apps/interpreters/bas/token.l
new file mode 100644
index 000000000..54179765a
--- /dev/null
+++ b/apps/interpreters/bas/token.l
@@ -0,0 +1,1943 @@
+/* Tokens and token sequence arrays. */
+%{
+/* #includes */ /*{{{C}}}*//*{{{*/
+#include "config.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "auto.h"
+#include "token.h"
+#include "statement.h"
+
+#ifdef DMALLOC
+#include "dmalloc.h"
+#endif
+/*}}}*/
+
+static int matchdata;
+static int backslash_colon;
+static int uppercase;
+int yylex(void);
+static struct Token *cur;
+
+static void string(const char *text) /*{{{*/
+{
+ if (cur)
+ {
+ const char *t;
+ char *q;
+ size_t l;
+
+ for (t=text+1,l=0; *(t+1); ++t,++l)
+ {
+ if (*t=='"') ++t;
+ }
+ cur->u.string=malloc(sizeof(struct String));
+ String_size(String_new(cur->u.string),l);
+ for (t=text+1,q=cur->u.string->character; *(t+1); ++t,++q)
+ {
+ *q=*t;
+ if (*t=='"') ++t;
+ }
+ }
+}
+/*}}}*/
+static void string2(void) /*{{{*/
+{
+ if (cur)
+ {
+ char *t,*q;
+ size_t l;
+
+ for (t=yytext+1,l=0; *t; ++t,++l)
+ {
+ if (*t=='"') ++t;
+ }
+ cur->u.string=malloc(sizeof(struct String));
+ String_size(String_new(cur->u.string),l);
+ for (t=yytext+1,q=cur->u.string->character; *t; ++t,++q)
+ {
+ *q=*t;
+ if (*t=='"') ++t;
+ }
+ }
+}
+/*}}}*/
+%}
+ /* flex options and definitions */ /*{{{*/
+%option noyywrap
+%option nounput
+%x DATAINPUT ELSEIF IMAGEFMT
+REAL ([0-9]+("!"|"#"))|([0-9]+\.[0-9]*(e("+"|"-")?[0-9]+)?("!"|"#")?)|([0-9]*\.[0-9]+(e("+"|"-")?[0-9]+)?("!"|"#")?|([0-9]+e("+"|"-")?[0-9]+("!"|"#")?))
+INTEGER [0-9]+%?
+HEXINTEGER &H[0-9A-F]+
+OCTINTEGER &O[0-7]+
+IDENTIFIER ("fn"[ \t]+)?[A-Z][A-Z_0-9\.]*("$"|"%"|"#")?
+STRING \"([^"]|\"\")*\"
+STRING2 \"([^"]|\"\")*$
+REM rem([^0-9A-Z_\.\n][^\n]*)?
+QUOTE ("'"|"!")[^\n]*
+ENDIF end[ \t]*if
+ENDPROC end[ \t]*proc
+ENDSELECT end[ \t]*select
+DOUNTIL do[ \t]+until
+DOWHILE do[ \t]+while
+EXITDO exit[ \t]+do
+EXITFOR exit[ \t]+for
+LINEINPUT (line[ \t]+input)|linput
+LOOPUNTIL loop[ \t]+until
+DATAITEM [^ \t\n,:][^,:\n]*
+ONERROR on[ \t]+error
+ONERROROFF on[ \t]+error[ \t]+off
+ONERRORGOTO0 on[ \t]+error[ \t]+goto[ \t]+0
+SELECTCASE select[ \t]+case
+ /*}}}*/
+%%
+ /* flex rules */ /*{{{*/
+ if (matchdata) BEGIN(DATAINPUT);
+
+"#" return T_CHANNEL;
+{REAL} {
+ int overflow;
+ double d;
+
+ d=Value_vald(yytext,(char**)0,&overflow);
+ if (overflow)
+ {
+ if (cur) cur->u.junk=yytext[0];
+ yyless(1);
+ return T_JUNK;
+ }
+ if (cur) cur->u.real=d;
+ return T_REAL;
+ }
+{INTEGER} {
+ int overflow;
+ long int n;
+
+ n=Value_vali(yytext,(char**)0,&overflow);
+ if (overflow)
+ {
+ double d;
+
+ d=Value_vald(yytext,(char**)0,&overflow);
+ if (overflow)
+ {
+ if (cur) cur->u.junk=yytext[0];
+ yyless(1);
+ return T_JUNK;
+ }
+ if (cur) cur->u.real=d;
+ return T_REAL;
+ }
+ if (cur) cur->u.integer=n;
+ return T_INTEGER;
+ }
+{HEXINTEGER} {
+ int overflow;
+ long int n;
+
+ n=Value_vali(yytext,(char**)0,&overflow);
+ if (overflow)
+ {
+ if (cur) cur->u.junk=yytext[0];
+ yyless(1);
+ return T_JUNK;
+ }
+ if (cur) cur->u.hexinteger=n;
+ return T_HEXINTEGER;
+ }
+{OCTINTEGER} {
+ int overflow;
+ long int n;
+
+ n=Value_vali(yytext,(char**)0,&overflow);
+ if (overflow)
+ {
+ if (cur) cur->u.junk=yytext[0];
+ yyless(1);
+ return T_JUNK;
+ }
+ if (cur) cur->u.octinteger=n;
+ return T_OCTINTEGER;
+ }
+{STRING} string(yytext); return T_STRING;
+{STRING2} string2(); return T_STRING;
+"("|"[" return T_OP;
+")"|"]" return T_CP;
+"*" return T_MULT;
+"+" return T_PLUS;
+"-" return T_MINUS;
+"," return T_COMMA;
+"/" return T_DIV;
+"\\" {
+ if (backslash_colon)
+ {
+ if (cur) cur->statement=stmt_COLON_EOL;
+ return T_COLON;
+ }
+ return T_IDIV;
+ }
+":" {
+ if (cur)
+ {
+ cur->statement=stmt_COLON_EOL;
+ }
+ return T_COLON;
+ }
+";" return T_SEMICOLON;
+"<" return T_LT;
+"<=" return T_LE;
+"=<" return T_LE;
+"<>"|"><" return T_NE;
+"=" {
+ if (cur)
+ {
+ cur->statement=stmt_EQ_FNRETURN_FNEND;
+ }
+ return T_EQ;
+ }
+">" return T_GT;
+">=" return T_GE;
+"=>" return T_GE;
+"^" return T_POW;
+"access"[ \t]+"read" return T_ACCESS_READ;
+"access"[ \t]+"read"[ \t]+"write" return T_ACCESS_READ_WRITE;
+"access"[ \t]+"write" return T_ACCESS_WRITE;
+"and" return T_AND;
+"as" return T_AS;
+"call" {
+ if (cur)
+ {
+ cur->statement=stmt_CALL;
+ }
+ return T_CALL;
+ }
+"case"[ \t]+"else" {
+ if (cur)
+ {
+ cur->statement=stmt_CASE;
+ cur->u.casevalue=malloc(sizeof(struct Casevalue));
+ }
+ return T_CASEELSE;
+ }
+"case" {
+ if (cur)
+ {
+ cur->statement=stmt_CASE;
+ cur->u.casevalue=malloc(sizeof(struct Casevalue));
+ }
+ return T_CASEVALUE;
+ }
+"chdir" {
+ if (cur)
+ {
+ cur->statement=stmt_CHDIR_MKDIR;
+ }
+ return T_CHDIR;
+ }
+"clear" {
+ if (cur)
+ {
+ cur->statement=stmt_CLEAR;
+ }
+ return T_CLEAR;
+ }
+"close" {
+ if (cur)
+ {
+ cur->statement=stmt_CLOSE;
+ }
+ return T_CLOSE;
+ }
+"close"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_CLOSE;
+ }
+ return T_CLOSE;
+ }
+"cls"|"home" {
+ if (cur)
+ {
+ cur->statement=stmt_CLS;
+ }
+ return T_CLS;
+ }
+"color" {
+ if (cur)
+ {
+ cur->statement=stmt_COLOR;
+ }
+ return T_COLOR;
+ }
+"con" return T_CON;
+"copy" {
+ if (cur)
+ {
+ cur->statement=stmt_COPY_RENAME;
+ }
+ return T_COPY;
+ }
+"data"|"d." {
+ BEGIN(DATAINPUT);
+ if (cur)
+ {
+ cur->statement=stmt_DATA;
+ }
+ return T_DATA;
+ }
+<DATAINPUT>{STRING} string(yytext); return T_STRING;
+<DATAINPUT>{STRING2} string2(); return T_STRING;
+<DATAINPUT>"," return T_COMMA;
+<DATAINPUT>{DATAITEM} {
+ if (cur) cur->u.datainput=strcpy(malloc(strlen(yytext)+1),yytext);
+ return T_DATAINPUT;
+ }
+<DATAINPUT>[ \t]+
+<DATAINPUT>\n BEGIN(INITIAL);
+<DATAINPUT>: BEGIN(INITIAL); return T_COLON;
+"dec" {
+ if (cur)
+ {
+ cur->statement=stmt_DEC_INC;
+ }
+ return T_DEC;
+ }
+"defdbl" {
+ if (cur)
+ {
+ cur->statement=stmt_DEFINT_DEFDBL_DEFSTR;
+ }
+ return T_DEFDBL;
+ }
+"defint" {
+ if (cur)
+ {
+ cur->statement=stmt_DEFINT_DEFDBL_DEFSTR;
+ }
+ return T_DEFINT;
+ }
+"defstr" {
+ if (cur)
+ {
+ cur->statement=stmt_DEFINT_DEFDBL_DEFSTR;
+ }
+ return T_DEFSTR;
+ }
+"def"/[ \t]+fn[ \t]*[A-Z_0-9\.] {
+ if (cur)
+ {
+ cur->statement=stmt_DEFFN_DEFPROC_FUNCTION_SUB;
+ cur->u.localSyms=(struct Symbol*)0;
+ }
+ return T_DEFFN;
+ }
+"def"/[ \t]+proc[A-Z_0-9\.] {
+ if (cur)
+ {
+ cur->statement=stmt_DEFFN_DEFPROC_FUNCTION_SUB;
+ cur->u.localSyms=(struct Symbol*)0;
+ }
+ return T_DEFPROC;
+ }
+"delete" {
+ if (cur)
+ {
+ cur->statement=stmt_DELETE;
+ }
+ return T_DELETE;
+ }
+"dim" {
+ if (cur)
+ {
+ cur->statement=stmt_DIM;
+ }
+ return T_DIM;
+ }
+"display" {
+ if (cur)
+ {
+ cur->statement=stmt_DISPLAY;
+ }
+ return T_DISPLAY;
+ }
+"do" {
+ if (cur)
+ {
+ cur->statement=stmt_DO;
+ }
+ return T_DO;
+ }
+{DOUNTIL} {
+ if (cur)
+ {
+ cur->statement=stmt_DOcondition;
+ }
+ return T_DOUNTIL;
+ }
+{DOWHILE} {
+ if (cur)
+ {
+ cur->statement=stmt_DOcondition;
+ }
+ return T_DOWHILE;
+ }
+"edit" {
+ if (cur)
+ {
+ cur->statement=stmt_EDIT;
+ }
+ return T_EDIT;
+ }
+"else"|"el." {
+ if (cur)
+ {
+ cur->statement=stmt_ELSE_ELSEIFELSE;
+ }
+ return T_ELSE;
+ }
+"else"/"if" {
+ BEGIN(ELSEIF);
+ if (cur)
+ {
+ cur->statement=stmt_ELSE_ELSEIFELSE;
+ }
+ return T_ELSEIFELSE;
+ }
+<ELSEIF>"if" {
+ BEGIN(INITIAL);
+ if (cur)
+ {
+ cur->statement=stmt_IF_ELSEIFIF;
+ }
+ return T_ELSEIFIF;
+ }
+end[ \t]+function {
+ if (cur)
+ {
+ cur->statement=stmt_ENDFN;
+ }
+ return T_ENDFN;
+ }
+{ENDIF} {
+ if (cur)
+ {
+ cur->statement=stmt_ENDIF;
+ }
+ return T_ENDIF;
+ }
+{ENDPROC} {
+ if (cur)
+ {
+ cur->statement=stmt_ENDPROC_SUBEND;
+ }
+ return T_ENDPROC;
+ }
+{ENDSELECT} {
+ if (cur)
+ {
+ cur->statement=stmt_ENDSELECT;
+ }
+ return T_ENDSELECT;
+ }
+"end"[ \t]*"sub" {
+ if (cur)
+ {
+ cur->statement=stmt_ENDPROC_SUBEND;
+ }
+ return T_SUBEND;
+ }
+"end" {
+ if (cur)
+ {
+ cur->statement=stmt_END;
+ }
+ return T_END;
+ }
+"environ" {
+ if (cur)
+ {
+ cur->statement=stmt_ENVIRON;
+ }
+ return T_ENVIRON;
+ }
+"erase" {
+ if (cur)
+ {
+ cur->statement=stmt_ERASE;
+ }
+ return T_ERASE;
+ }
+"eqv" return T_EQV;
+{EXITDO} {
+ if (cur)
+ {
+ cur->statement=stmt_EXITDO;
+ }
+ return T_EXITDO;
+ }
+{EXITFOR} {
+ if (cur)
+ {
+ cur->statement=stmt_EXITFOR;
+ }
+ return T_EXITFOR;
+ }
+"exit"[ \t]+"function" {
+ if (cur)
+ {
+ cur->statement=stmt_FNEXIT;
+ }
+ return T_FNEXIT;
+ }
+"exit"[ \t]+"sub" {
+ if (cur)
+ {
+ cur->statement=stmt_SUBEXIT;
+ }
+ return T_SUBEXIT;
+ }
+"field" {
+ if (cur)
+ {
+ cur->statement=stmt_FIELD;
+ }
+ return T_FIELD;
+ }
+"field"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_FIELD;
+ }
+ return T_FIELD;
+ }
+"fnend" {
+ if (cur)
+ {
+ cur->statement=stmt_EQ_FNRETURN_FNEND;
+ }
+ return T_FNEND;
+ }
+"fnreturn" {
+ if (cur)
+ {
+ cur->statement=stmt_EQ_FNRETURN_FNEND;
+ }
+ return T_FNRETURN;
+ }
+"for" {
+ if (cur)
+ {
+ cur->statement=stmt_FOR;
+ }
+ return T_FOR;
+ }
+"for"[ \t]+"input" return T_FOR_INPUT;
+"for"[ \t]+"output" return T_FOR_OUTPUT;
+"for"[ \t]+"append" return T_FOR_APPEND;
+"for"[ \t]+"random" return T_FOR_RANDOM;
+"for"[ \t]+"binary" return T_FOR_BINARY;
+"function" {
+ if (cur)
+ {
+ cur->statement=stmt_DEFFN_DEFPROC_FUNCTION_SUB;
+ cur->u.localSyms=(struct Symbol*)0;
+ }
+ return T_FUNCTION;
+ }
+"get" {
+ if (cur)
+ {
+ cur->statement=stmt_GET_PUT;
+ }
+ return T_GET;
+ }
+"get"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_GET_PUT;
+ }
+ return T_GET;
+ }
+"go"[ \t]*"sub" {
+ if (cur)
+ {
+ cur->statement=stmt_GOSUB;
+ }
+ return T_GOSUB;
+ }
+"go"[ \t]*"to" {
+ if (cur)
+ {
+ cur->statement=stmt_RESUME_GOTO;
+ }
+ return T_GOTO;
+ }
+"idn" return T_IDN;
+"if" {
+ if (cur)
+ {
+ cur->statement=stmt_IF_ELSEIFIF;
+ }
+ return T_IF;
+ }
+"image"[ \t]*/[^"\n \t] {
+ BEGIN(IMAGEFMT);
+ if (cur)
+ {
+ cur->statement=stmt_IMAGE;
+ }
+ return T_IMAGE;
+ }
+<IMAGEFMT>.*$ {
+ BEGIN(INITIAL);
+ if (cur)
+ {
+ size_t l;
+
+ l=strlen(yytext);
+ cur->u.string=malloc(sizeof(struct String));
+ String_size(String_new(cur->u.string),l);
+ memcpy(cur->u.string->character,yytext,l);
+ }
+ return T_STRING;
+ }
+"image" {
+ if (cur)
+ {
+ cur->statement=stmt_IMAGE;
+ }
+ return T_IMAGE;
+ }
+"imp" return T_IMP;
+"inc" {
+ if (cur)
+ {
+ cur->statement=stmt_DEC_INC;
+ }
+ return T_INC;
+ }
+"input" {
+ if (cur)
+ {
+ cur->statement=stmt_INPUT;
+ }
+ return T_INPUT;
+ }
+"input"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_INPUT;
+ }
+ return T_INPUT;
+ }
+"inv" return T_INV;
+"is" return T_IS;
+"kill" {
+ if (cur)
+ {
+ cur->statement=stmt_KILL;
+ }
+ return T_KILL;
+ }
+"let" {
+ if (cur)
+ {
+ cur->statement=stmt_LET;
+ }
+ return T_LET;
+ }
+"list" {
+ if (cur)
+ {
+ cur->statement=stmt_LIST_LLIST;
+ }
+ return T_LIST;
+ }
+"llist" {
+ if (cur)
+ {
+ cur->statement=stmt_LIST_LLIST;
+ }
+ return T_LLIST;
+ }
+"load" {
+ if (cur)
+ {
+ cur->statement=stmt_LOAD;
+ }
+ return T_LOAD;
+ }
+"local" {
+ if (cur)
+ {
+ cur->statement=stmt_LOCAL;
+ }
+ return T_LOCAL;
+ }
+"locate" {
+ if (cur)
+ {
+ cur->statement=stmt_LOCATE;
+ }
+ return T_LOCATE;
+ }
+"lock" {
+ if (cur)
+ {
+ cur->statement=stmt_LOCK_UNLOCK;
+ }
+ return T_LOCK;
+ }
+"lock"[ \t]+"read" return T_LOCK_READ;
+"lock"[ \t]+"write" return T_LOCK_WRITE;
+"loop" {
+ if (cur)
+ {
+ cur->statement=stmt_LOOP;
+ }
+ return T_LOOP;
+ }
+{LOOPUNTIL} {
+ if (cur)
+ {
+ cur->statement=stmt_LOOPUNTIL;
+ }
+ return T_LOOPUNTIL;
+ }
+"lprint" {
+ if (cur)
+ {
+ cur->statement=stmt_PRINT_LPRINT;
+ }
+ return T_LPRINT;
+ }
+"lset" {
+ if (cur)
+ {
+ cur->statement=stmt_LSET_RSET;
+ }
+ return T_LSET;
+ }
+"mat"[ \t]+"input" {
+ if (cur)
+ {
+ cur->statement=stmt_MATINPUT;
+ }
+ return T_MATINPUT;
+ }
+"mat"[ \t]+"print" {
+ if (cur)
+ {
+ cur->statement=stmt_MATPRINT;
+ }
+ return T_MATPRINT;
+ }
+"mat"[ \t]+"read" {
+ if (cur)
+ {
+ cur->statement=stmt_MATREAD;
+ }
+ return T_MATREAD;
+ }
+"mat"[ \t]+"redim" {
+ if (cur)
+ {
+ cur->statement=stmt_MATREDIM;
+ }
+ return T_MATREDIM;
+ }
+"mat"[ \t]+"write" {
+ if (cur)
+ {
+ cur->statement=stmt_MATWRITE;
+ }
+ return T_MATWRITE;
+ }
+"mat" {
+ if (cur)
+ {
+ cur->statement=stmt_MAT;
+ }
+ return T_MAT;
+ }
+"mkdir" {
+ if (cur)
+ {
+ cur->statement=stmt_CHDIR_MKDIR;
+ }
+ return T_MKDIR;
+ }
+"mod" return T_MOD;
+"new" {
+ if (cur)
+ {
+ cur->statement=stmt_NEW;
+ }
+ return T_NEW;
+ }
+"name" {
+ if (cur)
+ {
+ cur->statement=stmt_NAME;
+ }
+ return T_NAME;
+ }
+"next" {
+ if (cur)
+ {
+ cur->statement=stmt_NEXT;
+ cur->u.next=malloc(sizeof(struct Next));
+ }
+ return T_NEXT;
+ }
+"not" return T_NOT;
+{ONERROROFF} {
+ if (cur)
+ {
+ cur->statement=stmt_ONERROROFF;
+ }
+ return T_ONERROROFF;
+ }
+{ONERRORGOTO0} {
+ if (cur)
+ {
+ cur->statement=stmt_ONERRORGOTO0;
+ }
+ return T_ONERRORGOTO0;
+ }
+{ONERROR} {
+ if (cur)
+ {
+ cur->statement=stmt_ONERROR;
+ }
+ return T_ONERROR;
+ }
+"on" {
+ if (cur)
+ {
+ cur->statement=stmt_ON;
+ cur->u.on.pcLength=1;
+ cur->u.on.pc=(struct Pc*)0;
+ }
+ return T_ON;
+ }
+"open" {
+ if (cur)
+ {
+ cur->statement=stmt_OPEN;
+ }
+ return T_OPEN;
+ }
+"option"[ \t]+"base" {
+ if (cur)
+ {
+ cur->statement=stmt_OPTIONBASE;
+ }
+ return T_OPTIONBASE;
+ }
+"option"[ \t]+"run" {
+ if (cur)
+ {
+ cur->statement=stmt_OPTIONRUN;
+ }
+ return T_OPTIONRUN;
+ }
+"option"[ \t]+"stop" {
+ if (cur)
+ {
+ cur->statement=stmt_OPTIONSTOP;
+ }
+ return T_OPTIONSTOP;
+ }
+"or" return T_OR;
+"out" {
+ if (cur)
+ {
+ cur->statement=stmt_OUT_POKE;
+ }
+ return T_OUT;
+ }
+"print"|"p."|"?" {
+ if (cur)
+ {
+ cur->statement=stmt_PRINT_LPRINT;
+ }
+ return T_PRINT;
+ }
+("print"|"p."|"?")/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_PRINT_LPRINT;
+ }
+ return T_PRINT;
+ }
+"poke" {
+ if (cur)
+ {
+ cur->statement=stmt_OUT_POKE;
+ }
+ return T_POKE;
+ }
+"put" {
+ if (cur)
+ {
+ cur->statement=stmt_GET_PUT;
+ }
+ return T_PUT;
+ }
+"put"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_GET_PUT;
+ }
+ return T_PUT;
+ }
+"randomize" {
+ if (cur)
+ {
+ cur->statement=stmt_RANDOMIZE;
+ }
+ return T_RANDOMIZE;
+ }
+"read" {
+ if (cur)
+ {
+ cur->statement=stmt_READ;
+ }
+ return T_READ;
+ }
+"renum"|"ren." {
+ if (cur)
+ {
+ cur->statement=stmt_RENUM;
+ }
+ return T_RENUM;
+ }
+"repeat"|"rep." {
+ if (cur)
+ {
+ cur->statement=stmt_REPEAT;
+ }
+ return T_REPEAT;
+ }
+"restore"|"res." {
+ if (cur)
+ {
+ cur->statement=stmt_RESTORE;
+ }
+ return T_RESTORE;
+ }
+"resume" {
+ if (cur)
+ {
+ cur->statement=stmt_RESUME_GOTO;
+ }
+ return T_RESUME;
+ }
+"return"|"r." {
+ if (cur)
+ {
+ cur->statement=stmt_RETURN;
+ }
+ return T_RETURN;
+ }
+"rset" {
+ if (cur)
+ {
+ cur->statement=stmt_LSET_RSET;
+ }
+ return T_RSET;
+ }
+"run" {
+ if (cur)
+ {
+ cur->statement=stmt_RUN;
+ }
+ return T_RUN;
+ }
+"save" {
+ if (cur)
+ {
+ cur->statement=stmt_SAVE;
+ }
+ return T_SAVE;
+ }
+{SELECTCASE} {
+ if (cur)
+ {
+ cur->statement=stmt_SELECTCASE;
+ cur->u.selectcase=malloc(sizeof(struct Selectcase));
+ }
+ return T_SELECTCASE;
+ }
+"shared" return T_SHARED;
+"shell" {
+ if (cur)
+ {
+ cur->statement=stmt_SHELL;
+ }
+ return T_SHELL;
+ }
+"sleep" {
+ if (cur)
+ {
+ cur->statement=stmt_SLEEP;
+ }
+ return T_SLEEP;
+ }
+"spc" return T_SPC;
+"step" return T_STEP;
+"stop" {
+ if (cur)
+ {
+ cur->statement=stmt_STOP;
+ }
+ return T_STOP;
+ }
+"sub"[ \t]*"end" {
+ if (cur)
+ {
+ cur->statement=stmt_ENDPROC_SUBEND;
+ }
+ return T_SUBEND;
+ }
+"sub"[ \t]*"exit" {
+ if (cur)
+ {
+ cur->statement=stmt_SUBEXIT;
+ }
+ return T_SUBEXIT;
+ }
+"sub" {
+ if (cur)
+ {
+ cur->statement=stmt_DEFFN_DEFPROC_FUNCTION_SUB;
+ cur->u.localSyms=(struct Symbol*)0;
+ }
+ return T_SUB;
+ }
+"swap" {
+ if (cur)
+ {
+ cur->statement=stmt_SWAP;
+ }
+ return T_SWAP;
+ }
+"system"|"bye" {
+ if (cur)
+ {
+ cur->statement=stmt_SYSTEM;
+ }
+ return T_SYSTEM;
+ }
+"then"|"th." return T_THEN;
+"tab" return T_TAB;
+"to" return T_TO;
+"trn" return T_TRN;
+"troff" {
+ if (cur)
+ {
+ cur->statement=stmt_TROFF;
+ }
+ return T_TROFF;
+ }
+"tron" {
+ if (cur)
+ {
+ cur->statement=stmt_TRON;
+ }
+ return T_TRON;
+ }
+"truncate" {
+ if (cur)
+ {
+ cur->statement=stmt_TRUNCATE;
+ }
+ return T_TRUNCATE;
+ }
+"unlock" {
+ if (cur)
+ {
+ cur->statement=stmt_LOCK_UNLOCK;
+ }
+ return T_UNLOCK;
+ }
+"unnum" {
+ if (cur)
+ {
+ cur->statement=stmt_UNNUM;
+ }
+ return T_UNNUM;
+ }
+"until" {
+ if (cur)
+ {
+ cur->statement=stmt_UNTIL;
+ }
+ return T_UNTIL;
+ }
+"using" return T_USING;
+"wait" {
+ if (cur)
+ {
+ cur->statement=stmt_WAIT;
+ }
+ return T_WAIT;
+ }
+"wend" {
+ if (cur)
+ {
+ cur->statement=stmt_WEND;
+ cur->u.whilepc=malloc(sizeof(struct Pc));
+ }
+ return T_WEND;
+ }
+"while" {
+ if (cur)
+ {
+ cur->statement=stmt_WHILE;
+ cur->u.afterwend=malloc(sizeof(struct Pc));
+ }
+ return T_WHILE;
+ }
+"width" {
+ if (cur)
+ {
+ cur->statement=stmt_WIDTH;
+ }
+ return T_WIDTH;
+ }
+"width"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_WIDTH;
+ }
+ return T_WIDTH;
+ }
+"write" {
+ if (cur)
+ {
+ cur->statement=stmt_WRITE;
+ }
+ return T_WRITE;
+ }
+"write"/"#" {
+ if (cur)
+ {
+ cur->statement=stmt_WRITE;
+ }
+ return T_WRITE;
+ }
+"xor" return T_XOR;
+"xref" {
+ if (cur)
+ {
+ cur->statement=stmt_XREF;
+ }
+ return T_XREF;
+ }
+"zer" return T_ZER;
+"zone" {
+ if (cur)
+ {
+ cur->statement=stmt_ZONE;
+ }
+ return T_ZONE;
+ }
+{REM} {
+ if (cur)
+ {
+ cur->statement=stmt_QUOTE_REM;
+ cur->u.rem=strcpy(malloc(strlen(yytext+3)+1),yytext+3);
+ }
+ return T_REM;
+ }
+"rename" {
+ if (cur)
+ {
+ cur->statement=stmt_COPY_RENAME;
+ }
+ return T_RENAME;
+ }
+{QUOTE} {
+ if (cur)
+ {
+ cur->statement=stmt_QUOTE_REM;
+ strcpy(cur->u.rem=malloc(strlen(yytext+1)+1),yytext+1);
+ }
+ return T_QUOTE;
+ }
+{LINEINPUT} {
+ if (cur)
+ {
+ cur->statement=stmt_LINEINPUT;
+ }
+ return T_LINEINPUT;
+ }
+{IDENTIFIER} {
+ if (cur)
+ {
+ size_t len;
+ char *s;
+ int fn;
+
+ cur->statement=stmt_IDENTIFIER;
+ if (tolower(yytext[0])=='f' && tolower(yytext[1])=='n')
+ {
+ for (len=2,s=&yytext[2]; *s==' ' || *s=='\t'; ++s);
+ fn=1;
+ }
+ else
+ {
+ len=0;
+ s=yytext;
+ fn=0;
+ }
+ len+=strlen(s);
+ cur->u.identifier=malloc(offsetof(struct Identifier,name)+len+1);
+ if (fn)
+ {
+ memcpy(cur->u.identifier->name,yytext,2);
+ strcpy(cur->u.identifier->name+2,s);
+ }
+ else
+ {
+ strcpy(cur->u.identifier->name,s);
+ }
+ switch (yytext[yyleng-1])
+ {
+ case '$': cur->u.identifier->defaultType=V_STRING; break;
+ case '%': cur->u.identifier->defaultType=V_INTEGER; break;
+ default: cur->u.identifier->defaultType=V_REAL; break;
+ }
+ }
+ return T_IDENTIFIER;
+ }
+[ \t\n]+
+. {
+ if (cur) cur->u.junk=yytext[0];
+ return T_JUNK;
+ }
+ /*}}}*/
+%%
+
+int Token_property[T_LASTTOKEN];
+
+struct Token *Token_newCode(const char *ln) /*{{{*/
+{
+ int l,lasttok,thistok,addNumber=0,sawif;
+ struct Token *result;
+ YY_BUFFER_STATE buf;
+
+ cur=(struct Token*)0;
+ buf=yy_scan_string(ln);
+ /* determine number of tokens */ /*{{{*/
+ matchdata=sawif=0;
+ for (lasttok=T_EOL,l=1; (thistok=yylex()); ++l)
+ {
+ if (l==1 && thistok!=T_INTEGER) { addNumber=1; ++l; }
+ if ((lasttok==T_THEN || lasttok==T_ELSE) && thistok==T_INTEGER) ++l;
+ if (thistok==T_IF) sawif=1;
+ if (thistok==T_THEN) sawif=0;
+ if (thistok==T_GOTO && sawif) ++l;
+ lasttok=thistok;
+ }
+ if (l==1) { addNumber=1; ++l; }
+ /*}}}*/
+ yy_delete_buffer(buf);
+ cur=result=malloc(sizeof(struct Token)*l);
+ if (addNumber)
+ {
+ cur->type=T_UNNUMBERED;
+ ++cur;
+ }
+ buf=yy_scan_string(ln);
+ lasttok=T_EOL;
+ matchdata=sawif=0;
+ while (cur->statement=NULL,(cur->type=yylex()))
+ {
+ if (cur->type==T_IF) sawif=1;
+ if (cur->type==T_THEN) sawif=0;
+ if (cur->type==T_GOTO && sawif)
+ {
+ sawif=0;
+ *(cur+1)=*cur;
+ cur->type=T_THEN;
+ lasttok=T_GOTO;
+ cur+=2;
+ }
+ else if ((lasttok==T_THEN || lasttok==T_ELSE) && cur->type==T_INTEGER)
+ {
+ *(cur+1)=*cur;
+ cur->type=T_GOTO;
+ cur->statement=stmt_RESUME_GOTO;
+ lasttok=T_INTEGER;
+ cur+=2;
+ }
+ else
+ {
+ lasttok=cur->type;
+ ++cur;
+ }
+ }
+ cur->type=T_EOL;
+ cur->statement=stmt_COLON_EOL;
+ yy_delete_buffer(buf);
+ return result;
+}
+/*}}}*/
+struct Token *Token_newData(const char *ln) /*{{{*/
+{
+ int l;
+ struct Token *result;
+ YY_BUFFER_STATE buf;
+
+ cur=(struct Token*)0;
+ buf=yy_scan_string(ln);
+ matchdata=1;
+ for (l=1; yylex(); ++l);
+ yy_delete_buffer(buf);
+ cur=result=malloc(sizeof(struct Token)*l);
+ buf=yy_scan_string(ln);
+ matchdata=1;
+ while (cur->statement=NULL,(cur->type=yylex())) ++cur;
+ cur->type=T_EOL;
+ cur->statement=stmt_COLON_EOL;
+ yy_delete_buffer(buf);
+ return result;
+}
+/*}}}*/
+void Token_destroy(struct Token *token) /*{{{*/
+{
+ struct Token *r=token;
+
+ do
+ {
+ switch (r->type)
+ {
+ case T_ACCESS_READ: break;
+ case T_ACCESS_WRITE: break;
+ case T_AND: break;
+ case T_AS: break;
+ case T_CALL: break;
+ case T_CASEELSE:
+ case T_CASEVALUE: free(r->u.casevalue); break;
+ case T_CHANNEL: break;
+ case T_CHDIR: break;
+ case T_CLEAR: break;
+ case T_CLOSE: break;
+ case T_CLS: break;
+ case T_COLON: break;
+ case T_COLOR: break;
+ case T_COMMA: break;
+ case T_CON: break;
+ case T_COPY: break;
+ case T_CP: break;
+ case T_DATA: break;
+ case T_DATAINPUT: free(r->u.datainput); break;
+ case T_DEC: break;
+ case T_DEFFN: break;
+ case T_DEFDBL: break;
+ case T_DEFINT: break;
+ case T_DEFPROC: break;
+ case T_DEFSTR: break;
+ case T_DELETE: break;
+ case T_DIM: break;
+ case T_DISPLAY: break;
+ case T_DIV: break;
+ case T_DO: break;
+ case T_DOUNTIL: break;
+ case T_DOWHILE: break;
+ case T_EDIT: break;
+ case T_ELSE: break;
+ case T_ELSEIFELSE: break;
+ case T_ELSEIFIF: break;
+ case T_END: break;
+ case T_ENDFN: break;
+ case T_ENDIF: break;
+ case T_ENDPROC: break;
+ case T_ENDSELECT: break;
+ case T_ENVIRON: break;
+ case T_EOL: break;
+ case T_EQ: break;
+ case T_EQV: break;
+ case T_ERASE: break;
+ case T_EXITDO: break;
+ case T_EXITFOR: break;
+ case T_FIELD: break;
+ case T_FNEND: break;
+ case T_FNEXIT: break;
+ case T_FNRETURN: break;
+ case T_FOR: break;
+ case T_FOR_INPUT: break;
+ case T_FOR_OUTPUT: break;
+ case T_FOR_APPEND: break;
+ case T_FOR_RANDOM: break;
+ case T_FOR_BINARY: break;
+ case T_FUNCTION: break;
+ case T_GE: break;
+ case T_GET: break;
+ case T_GOSUB: break;
+ case T_GOTO: break;
+ case T_GT: break;
+ case T_HEXINTEGER: break;
+ case T_OCTINTEGER: break;
+ case T_IDENTIFIER: free(r->u.identifier); break;
+ case T_IDIV: break;
+ case T_IDN: break;
+ case T_IF: break;
+ case T_IMAGE: break;
+ case T_IMP: break;
+ case T_INC: break;
+ case T_INPUT: break;
+ case T_INTEGER: break;
+ case T_INV: break;
+ case T_IS: break;
+ case T_JUNK: break;
+ case T_KILL: break;
+ case T_LE: break;
+ case T_LET: break;
+ case T_LINEINPUT: break;
+ case T_LIST: break;
+ case T_LLIST: break;
+ case T_LOAD: break;
+ case T_LOCAL: break;
+ case T_LOCATE: break;
+ case T_LOCK: break;
+ case T_LOCK_READ: break;
+ case T_LOCK_WRITE: break;
+ case T_LOOP: break;
+ case T_LOOPUNTIL: break;
+ case T_LPRINT: break;
+ case T_LSET: break;
+ case T_LT: break;
+ case T_MAT: break;
+ case T_MATINPUT: break;
+ case T_MATPRINT: break;
+ case T_MATREAD: break;
+ case T_MATREDIM: break;
+ case T_MATWRITE: break;
+ case T_MINUS: break;
+ case T_MKDIR: break;
+ case T_MOD: break;
+ case T_MULT: break;
+ case T_NAME: break;
+ case T_NE: break;
+ case T_NEW: break;
+ case T_NEXT: free(r->u.next); break;
+ case T_NOT: break;
+ case T_ON: if (r->u.on.pc) free(r->u.on.pc); break;
+ case T_ONERROR: break;
+ case T_ONERRORGOTO0: break;
+ case T_ONERROROFF: break;
+ case T_OP: break;
+ case T_OPEN: break;
+ case T_OPTIONBASE: break;
+ case T_OPTIONRUN: break;
+ case T_OPTIONSTOP: break;
+ case T_OR: break;
+ case T_OUT: break;
+ case T_PLUS: break;
+ case T_POKE: break;
+ case T_POW: break;
+ case T_PRINT: break;
+ case T_PUT: break;
+ case T_QUOTE: free(r->u.rem); break;
+ case T_RANDOMIZE: break;
+ case T_READ: break;
+ case T_REAL: break;
+ case T_REM: free(r->u.rem); break;
+ case T_RENAME: break;
+ case T_RENUM: break;
+ case T_REPEAT: break;
+ case T_RESTORE: break;
+ case T_RESUME: break;
+ case T_RETURN: break;
+ case T_RSET: break;
+ case T_RUN: break;
+ case T_SAVE: break;
+ case T_SELECTCASE: free(r->u.selectcase); break;
+ case T_SEMICOLON: break;
+ case T_SHARED: break;
+ case T_SHELL: break;
+ case T_SLEEP: break;
+ case T_SPC: break;
+ case T_STEP: break;
+ case T_STOP: break;
+ case T_STRING: String_destroy(r->u.string); free(r->u.string); break;
+ case T_SUB: break;
+ case T_SUBEND: break;
+ case T_SUBEXIT: break;
+ case T_SWAP: break;
+ case T_SYSTEM: break;
+ case T_TAB: break;
+ case T_THEN: break;
+ case T_TO: break;
+ case T_TRN: break;
+ case T_TROFF: break;
+ case T_TRON: break;
+ case T_TRUNCATE: break;
+ case T_UNLOCK: break;
+ case T_UNNUM: break;
+ case T_UNNUMBERED: break;
+ case T_UNTIL: break;
+ case T_USING: break;
+ case T_WAIT: break;
+ case T_WEND: free(r->u.whilepc); break;
+ case T_WHILE: free(r->u.afterwend); break;
+ case T_WIDTH: break;
+ case T_WRITE: break;
+ case T_XOR: break;
+ case T_XREF: break;
+ case T_ZER: break;
+ case T_ZONE: break;
+ default: assert(0);
+ }
+ } while ((r++)->type!=T_EOL);
+ free(token);
+}
+/*}}}*/
+struct String *Token_toString(struct Token *token, struct Token *spaceto, struct String *s, int *indent, int width) /*{{{*/
+{
+ int ns=0,infn=0;
+ int thisindent=0,thisnotindent=0,nextindent=0;
+ size_t oldlength=s->length;
+ struct Token *t;
+ static struct
+ {
+ const char *text;
+ char space;
+ } table[]=
+ {
+ /* 0 */ {(const char*)0,-1},
+ /* T_ACCESS_READ */ {"access read",1},
+ /* T_ACCESS_READ_WRITE */ {"access read write",1},
+ /* T_ACCESS_WRITE */ {"access write",1},
+ /* T_AND */ {"and",1},
+ /* T_AS */ {"as",1},
+ /* T_CALL */ {"call",1},
+ /* T_CASEELSE */ {"case else",1},
+ /* T_CASEVALUE */ {"case",1},
+ /* T_CHANNEL */ {"#",0},
+ /* T_CHDIR */ {"chdir",1},
+ /* T_CLEAR */ {"clear",1},
+ /* T_CLOSE */ {"close",1},
+ /* T_CLS */ {"cls",1},
+ /* T_COLON */ {":",1},
+ /* T_COLOR */ {"color",1},
+ /* T_COMMA */ {",",0},
+ /* T_CON */ {"con",0},
+ /* T_COPY */ {"copy",1},
+ /* T_CP */ {")",0},
+ /* T_DATA */ {"data",1},
+ /* T_DATAINPUT */ {(const char*)0,0},
+ /* T_DEC */ {"dec",1},
+ /* T_DEFDBL */ {"defdbl",1},
+ /* T_DEFFN */ {"def",1},
+ /* T_DEFINT */ {"defint",1},
+ /* T_DEFPROC */ {"def",1},
+ /* T_DEFSTR */ {"defstr",1},
+ /* T_DELETE */ {"delete",1},
+ /* T_DIM */ {"dim",1},
+ /* T_DISPLAY */ {"display",1},
+ /* T_DIV */ {"/",0},
+ /* T_DO */ {"do",1},
+ /* T_DOUNTIL */ {"do until",1},
+ /* T_DOWHILE */ {"do while",1},
+ /* T_EDIT */ {"edit",1},
+ /* T_ELSE */ {"else",1},
+ /* T_ELSEIFELSE */ {"elseif",1},
+ /* T_ELSEIFIF */ {(const char*)0,0},
+ /* T_END */ {"end",1},
+ /* T_ENDFN */ {"end function",1},
+ /* T_ENDIF */ {"end if",1},
+ /* T_ENDPROC */ {"end proc",1},
+ /* T_ENDSELECT */ {"end select",1},
+ /* T_ENVIRON */ {"environ",1},
+ /* T_EOL */ {"\n",0},
+ /* T_EQ */ {"=",0},
+ /* T_EQV */ {"eqv",0},
+ /* T_ERASE */ {"erase",1},
+ /* T_EXITDO */ {"exit do",1},
+ /* T_EXITFOR */ {"exit for",1},
+ /* T_FIELD */ {"field",1},
+ /* T_FNEND */ {"fnend",1},
+ /* T_FNEXIT */ {"exit function",1},
+ /* T_FNRETURN */ {"fnreturn",1},
+ /* T_FOR */ {"for",1},
+ /* T_FOR_INPUT */ {"for input",1},
+ /* T_FOR_OUTPUT */ {"for output",1},
+ /* T_FOR_APPEND */ {"for append",1},
+ /* T_FOR_RANDOM */ {"for random",1},
+ /* T_FOR_BINARY */ {"for binary",1},
+ /* T_FUNCTION */ {"function",1},
+ /* T_GE */ {">=",0},
+ /* T_GET */ {"get",1},
+ /* T_GOSUB */ {"gosub",1},
+ /* T_GOTO */ {"goto",1},
+ /* T_GT */ {">",0},
+ /* T_HEXINTEGER */ {(const char*)0,0},
+ /* T_OCTINTEGER */ {(const char*)0,0},
+ /* T_IDENTIFIER */ {(const char*)0,0},
+ /* T_IDIV */ {"\\",0},
+ /* T_IDN */ {"idn",0},
+ /* T_IF */ {"if",1},
+ /* T_IMAGE */ {"image",1},
+ /* T_IMP */ {"imp",0},
+ /* T_INC */ {"inc",1},
+ /* T_INPUT */ {"input",1},
+ /* T_INTEGER */ {(const char*)0,0},
+ /* T_INV */ {"inv",0},
+ /* T_IS */ {"is",1},
+ /* T_JUNK */ {(const char*)0,0},
+ /* T_KILL */ {"kill",1},
+ /* T_LE */ {"<=",0},
+ /* T_LET */ {"let",1},
+ /* T_LINEINPUT */ {"line input",1},
+ /* T_LIST */ {"list",1},
+ /* T_LLIST */ {"llist",1},
+ /* T_LOAD */ {"load",1},
+ /* T_LOCAL */ {"local",1},
+ /* T_LOCATE */ {"locate",1},
+ /* T_LOCK */ {"lock",1},
+ /* T_LOCK_READ */ {"lock read",1},
+ /* T_LOCK_WRITE */ {"lock write",1},
+ /* T_LOOP */ {"loop",1},
+ /* T_LOOPUNTIL */ {"loop until",1},
+ /* T_LPRINT */ {"lprint",1},
+ /* T_LSET */ {"lset",1},
+ /* T_LT */ {"<",0},
+ /* T_MAT */ {"mat",1},
+ /* T_MATINPUT */ {"mat input",1},
+ /* T_MATPRINT */ {"mat print",1},
+ /* T_MATREAD */ {"mat read",1},
+ /* T_MATREDIM */ {"mat redim",1},
+ /* T_MATWRITE */ {"mat write",1},
+ /* T_MINUS */ {"-",0},
+ /* T_MKDIR */ {"mkdir",1},
+ /* T_MOD */ {"mod",0},
+ /* T_MULT */ {"*",0},
+ /* T_NAME */ {"name",1},
+ /* T_NE */ {"<>",0},
+ /* T_NEW */ {"new",1},
+ /* T_NEXT */ {"next",1},
+ /* T_NOT */ {"not",0},
+ /* T_ON */ {"on",1},
+ /* T_ONERROR */ {"on error",1},
+ /* T_ONERRORGOTO0 */ {"on error goto 0",1},
+ /* T_ONERROROFF */ {"on error off",1},
+ /* T_OP */ {"(",0},
+ /* T_OPEN */ {"open",1},
+ /* T_OPTIONBASE */ {"option base",1},
+ /* T_OPTIONRUN */ {"option run",1},
+ /* T_OPTIONSTOP */ {"option stop",1},
+ /* T_OR */ {"or",1},
+ /* T_OUT */ {"out",1},
+ /* T_PLUS */ {"+",0},
+ /* T_POKE */ {"poke",1},
+ /* T_POW */ {"^",0},
+ /* T_PRINT */ {"print",1},
+ /* T_PUT */ {"put",1},
+ /* T_QUOTE */ {(const char*)0,1},
+ /* T_RANDOMIZE */ {"randomize",1},
+ /* T_READ */ {"read",1},
+ /* T_REAL */ {(const char*)0,0},
+ /* T_REM */ {(const char*)0,1},
+ /* T_RENAME */ {"rename",1},
+ /* T_RENUM */ {"renum",1},
+ /* T_REPEAT */ {"repeat",1},
+ /* T_RESTORE */ {"restore",1},
+ /* T_RESUME */ {"resume",1},
+ /* T_RETURN */ {"return",1},
+ /* T_RSET */ {"rset",1},
+ /* T_RUN */ {"run",1},
+ /* T_SAVE */ {"save",1},
+ /* T_SELECTCASE */ {"select case",1},
+ /* T_SEMICOLON */ {";",0},
+ /* T_SHARED */ {"shared",1},
+ /* T_SHELL */ {"shell",1},
+ /* T_SLEEP */ {"sleep",1},
+ /* T_SPC */ {"spc",0},
+ /* T_STEP */ {"step",1},
+ /* T_STOP */ {"stop",1},
+ /* T_STRING */ {(const char*)0,0},
+ /* T_SUB */ {"sub",1},
+ /* T_SUBEND */ {"subend",1},
+ /* T_SUBEXIT */ {"subexit",1},
+ /* T_SWAP */ {"swap",1},
+ /* T_SYSTEM */ {"system",1},
+ /* T_TAB */ {"tab",0},
+ /* T_THEN */ {"then",1},
+ /* T_TO */ {"to",1},
+ /* T_TRN */ {"trn",0},
+ /* T_TROFF */ {"troff",1},
+ /* T_TRON */ {"tron",1},
+ /* T_TRUNCATE */ {"truncate",1},
+ /* T_UNLOCK */ {"unlock",1},
+ /* T_UNNUM */ {"unnum",1},
+ /* T_UNNUMBERED */ {"",0},
+ /* T_UNTIL */ {"until",1},
+ /* T_USING */ {"using",0},
+ /* T_WAIT */ {"wait",1},
+ /* T_WEND */ {"wend",1},
+ /* T_WHILE */ {"while",1},
+ /* T_WIDTH */ {"width",1},
+ /* T_WRITE */ {"write",1},
+ /* T_XOR */ {"xor",0},
+ /* T_XREF */ {"xref",0},
+ /* T_ZER */ {"zer",0},
+ /* T_ZONE */ {"zone",1},
+ };
+
+ /* precompute indentation */ /*{{{*/
+ if (indent) thisindent=nextindent=*indent;
+ t=token;
+ do
+ {
+ switch (t->type)
+ {
+ case T_CASEELSE:
+ case T_CASEVALUE:
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ break;
+ }
+ case T_DEFFN:
+ case T_FUNCTION:
+ {
+ struct Token *cp;
+
+ for (cp=t; cp->type!=T_EOL && cp->type!=T_CP; ++cp);
+ if ((cp+1)->type!=T_EQ)
+ {
+ ++thisnotindent;
+ ++nextindent;
+ }
+ infn=1;
+ break;
+ }
+ case T_COLON: infn=0; break;
+ case T_DEFPROC:
+ case T_DO:
+ case T_DOUNTIL:
+ case T_DOWHILE:
+ case T_REPEAT:
+ case T_SUB:
+ case T_WHILE: ++thisnotindent; ++nextindent; break;
+ case T_FOR:
+ {
+ if ((t>token && ((t-1)->type==T_COLON || (t-1)->type==T_INTEGER || (t-1)->type==T_UNNUMBERED)))
+ {
+ ++thisnotindent; ++nextindent;
+ }
+ break;
+ }
+ case T_SELECTCASE: thisnotindent+=2; nextindent+=2; break;
+ case T_EQ:
+ {
+ if (infn || (t>token && ((t-1)->type==T_COLON || (t-1)->type==T_INTEGER || (t-1)->type==T_UNNUMBERED)))
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ if (nextindent) --nextindent;
+ }
+ infn=0;
+ break;
+ }
+ case T_ENDFN:
+ case T_FNEND:
+ case T_ENDIF:
+ case T_ENDPROC:
+ case T_SUBEND:
+ case T_LOOP:
+ case T_LOOPUNTIL:
+ case T_UNTIL:
+ case T_WEND:
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ if (nextindent) --nextindent;
+ break;
+ }
+ case T_ENDSELECT:
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ if (nextindent) --nextindent;
+ if (nextindent) --nextindent;
+ break;
+ }
+ case T_NEXT:
+ {
+ ++t;
+ while (1)
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ if (nextindent) --nextindent;
+ if (t->type==T_IDENTIFIER)
+ {
+ ++t;
+ if (t->type==T_OP)
+ {
+ int par=0;
+
+ do
+ {
+ if (t->type==T_OP) ++par;
+ else if (t->type==T_CP) --par;
+ if (t->type!=T_EOL) ++t;
+ else break;
+ } while (par);
+ }
+ if (t->type==T_COMMA) ++t;
+ else break;
+ }
+ else break;
+ }
+ break;
+ }
+ case T_THEN: if ((t+1)->type==T_EOL) { ++thisnotindent; ++nextindent; } break;
+ case T_ELSE:
+ {
+ if (t==token+1)
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ }
+ break;
+ }
+ case T_ELSEIFELSE:
+ {
+ if (t==token+1)
+ {
+ if (thisnotindent) --thisnotindent; else if (thisindent) --thisindent;
+ }
+ if (nextindent) --nextindent;
+ break;
+ }
+ default: break;
+ }
+ } while (t++->type!=T_EOL);
+ /*}}}*/
+ if (width>=0) /* whole line */
+ {
+ if (width) /* nicely formatted listing */
+ {
+ assert (token->type==T_UNNUMBERED || token->type==T_INTEGER);
+ if (token->type==T_INTEGER) String_appendPrintf(s,"%*ld ",width,token->u.integer);
+ else String_appendPrintf(s,"%*s ",width,"");
+ }
+ else assert (token->type==T_UNNUMBERED);
+ ++token;
+ }
+ while (thisindent--) String_appendPrintf(s," ");
+ do
+ {
+ if (s->length>oldlength && token->type!=T_EOL)
+ {
+ const char *keyword;
+
+ if ((keyword=table[token->type].text)==(const char*)0) keyword="X";
+ if (ns && s->character[s->length-1]!=' ')
+ {
+ String_appendPrintf(s," ");
+ }
+ else if (isalnum((int)(s->character[s->length-1])) && isalnum((int)*keyword))
+ {
+ String_appendPrintf(s," ");
+ }
+ else if (s->character[s->length-1]!=' ' && table[token->type].space)
+ {
+ String_appendChar(s,' ');
+ }
+ }
+ if (spaceto && token==spaceto) break;
+ switch (token->type)
+ {
+ case T_DATAINPUT: String_appendChars(s,token->u.datainput); break;
+ case T_ELSEIFIF: break;
+ case T_IDENTIFIER: String_appendChars(s,token->u.identifier->name); break;
+ case T_INTEGER: String_appendPrintf(s,"%ld",token->u.integer); break;
+ case T_HEXINTEGER: String_appendPrintf(s,"&h%lx",token->u.hexinteger); break;
+ case T_OCTINTEGER: String_appendPrintf(s,"&o%lo",token->u.octinteger); break;
+ case T_JUNK: String_appendChar(s,token->u.junk); break;
+ case T_REAL:
+ {
+ String_appendPrintf(s,"%.*g",DBL_DIG,token->u.real);
+ if ((token->u.real<((double)LONG_MIN)) || (token->u.real>((double)LONG_MAX))) String_appendChar(s,'!');
+ break;
+ }
+ case T_REM: String_appendPrintf(s,"%s%s",uppercase?"REM":"rem",token->u.rem); break;
+ case T_QUOTE: String_appendPrintf(s,"'%s",token->u.rem); break;
+ case T_STRING: /*{{{*/
+ {
+ size_t l=token->u.string->length;
+ char *data=token->u.string->character;
+
+ String_appendPrintf(s,"\"");
+ while (l--)
+ {
+ if (*data=='"') String_appendPrintf(s,"\"");
+ String_appendPrintf(s,"%c",*data);
+ ++data;
+ }
+ String_appendPrintf(s,"\"");
+ break;
+ }
+ /*}}}*/
+ default:
+ {
+ if (uppercase)
+ {
+ struct String u;
+
+ String_new(&u);
+ String_appendChars(&u,table[token->type].text);
+ String_ucase(&u);
+ String_appendString(s,&u);
+ String_destroy(&u);
+ }
+ else String_appendChars(s,table[token->type].text);
+ }
+ }
+ ns=table[token->type].space;
+ } while (token++->type!=T_EOL);
+ if (indent) *indent=nextindent;
+ if (spaceto && s->length>oldlength) memset(s->character+oldlength,' ',s->length-oldlength);
+ return s;
+}
+/*}}}*/
+void Token_init(int b_c, int uc) /*{{{*/
+{
+#define PROPERTY(t,assoc,unary_priority,binary_priority,is_unary,is_binary) \
+ Token_property[t]=(assoc<<8)|(unary_priority<<5)|(binary_priority<<2)|(is_unary<<1)|is_binary
+
+ backslash_colon=b_c;
+ uppercase=uc;
+ PROPERTY(T_POW, 1,0,7,0,1);
+ PROPERTY(T_MULT, 0,0,5,0,1);
+ PROPERTY(T_DIV, 0,0,5,0,1);
+ PROPERTY(T_IDIV, 0,0,5,0,1);
+ PROPERTY(T_MOD, 0,0,5,0,1);
+ PROPERTY(T_PLUS, 0,6,4,1,1);
+ PROPERTY(T_MINUS,0,6,4,1,1);
+ PROPERTY(T_LT, 0,0,3,0,1);
+ PROPERTY(T_LE, 0,0,3,0,1);
+ PROPERTY(T_EQ, 0,0,3,0,1);
+ PROPERTY(T_GE, 0,0,3,0,1);
+ PROPERTY(T_GT, 0,0,3,0,1);
+ PROPERTY(T_NE, 0,0,3,0,1);
+ PROPERTY(T_NOT, 0,2,0,1,0);
+ PROPERTY(T_AND, 0,0,1,0,1);
+ PROPERTY(T_OR, 0,0,0,0,1);
+ PROPERTY(T_XOR, 0,0,0,0,1);
+ PROPERTY(T_EQV, 0,0,0,0,1);
+ PROPERTY(T_IMP, 0,0,0,0,1);
+}
+/*}}}*/
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-03 00:39:41 +0000