diff options
author | Lua Team <team@lua.org> | 1995-11-28 12:00:00 +0000 |
---|---|---|
committer | repogen <> | 1995-11-28 12:00:00 +0000 |
commit | 71754d2f6423fb9b6e87658e58bafc5470d53f65 (patch) | |
tree | c704e97b80e52a52d3152738941bb4c8ca676b97 /src/lua.stx | |
parent | a8b6ba0954edb9e0e669e1f451b9a8f145ce5166 (diff) | |
download | lua-github-71754d2f6423fb9b6e87658e58bafc5470d53f65.tar.gz |
Lua 2.22.2
Diffstat (limited to 'src/lua.stx')
-rw-r--r-- | src/lua.stx | 1014 |
1 files changed, 1014 insertions, 0 deletions
diff --git a/src/lua.stx b/src/lua.stx new file mode 100644 index 00000000..99e96179 --- /dev/null +++ b/src/lua.stx @@ -0,0 +1,1014 @@ +%{ + +char *rcs_luastx = "$Id: lua.stx,v 3.25 1995/10/26 17:02:50 roberto Exp $"; + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "mem.h" +#include "opcode.h" +#include "hash.h" +#include "inout.h" +#include "tree.h" +#include "table.h" +#include "lua.h" +#include "func.h" + +/* to avoid warnings generated by yacc */ +int yyparse (void); +#define malloc luaI_malloc +#define realloc luaI_realloc +#define free luaI_free + +#ifndef LISTING +#define LISTING 0 +#endif + +#ifndef CODE_BLOCK +#define CODE_BLOCK 256 +#endif +static int maxcode; +static int maxmain; +static Long maxcurr; /* to allow maxcurr *= 2 without overflow */ +static Byte *funcCode = NULL; +static Byte **initcode; +static Byte *basepc; +static int maincode; +static int pc; + + +#define MAXVAR 32 +static Long varbuffer[MAXVAR]; /* variables in an assignment list; + it's long to store negative Word values */ +static int nvarbuffer=0; /* number of variables at a list */ + +#define MAXLOCALS 32 +static Word localvar[MAXLOCALS]; /* store local variable names */ +static int nlocalvar=0; /* number of local variables */ + +#define MAXFIELDS FIELDS_PER_FLUSH*2 +static Word fields[MAXFIELDS]; /* fieldnames to be flushed */ +static int nfields=0; + + +/* Internal functions */ + +static void yyerror (char *s) +{ + static char msg[256]; + sprintf (msg,"%s near \"%s\" at line %d in file `%s'", + s, lua_lasttext (), lua_linenumber, lua_parsedfile); + lua_error (msg); +} + +static void code_byte (Byte c) +{ + if (pc>maxcurr-2) /* 1 byte free to code HALT of main code */ + { + if (maxcurr >= MAX_INT) + lua_error("code size overflow"); + maxcurr *= 2; + if (maxcurr >= MAX_INT) + maxcurr = MAX_INT; + basepc = growvector(basepc, maxcurr, Byte); + } + basepc[pc++] = c; +} + +static void code_word (Word n) +{ + CodeWord code; + code.w = n; + code_byte(code.m.c1); + code_byte(code.m.c2); +} + +static void code_float (float n) +{ + CodeFloat code; + code.f = n; + code_byte(code.m.c1); + code_byte(code.m.c2); + code_byte(code.m.c3); + code_byte(code.m.c4); +} + +static void code_code (TFunc *tf) +{ + CodeCode code; + code.tf = tf; + code_byte(code.m.c1); + code_byte(code.m.c2); + code_byte(code.m.c3); + code_byte(code.m.c4); +} + +static void code_word_at (Byte *p, Word n) +{ + CodeWord code; + code.w = n; + *p++ = code.m.c1; + *p++ = code.m.c2; +} + +static void push_field (Word name) +{ + if (nfields < MAXFIELDS) + fields[nfields++] = name; + else + lua_error ("too many fields in nested constructors"); +} + +static void flush_record (int n) +{ + int i; + if (n == 0) return; + code_byte(STORERECORD); + code_byte(n); + for (i=0; i<n; i++) + code_word(fields[--nfields]); +} + +static void flush_list (int m, int n) +{ + if (n == 0) return; + if (m == 0) + code_byte(STORELIST0); + else + if (m < 255) + { + code_byte(STORELIST); + code_byte(m); + } + else + lua_error ("list constructor too long"); + code_byte(n); +} + +static void add_localvar (Word name) +{ + if (nlocalvar < MAXLOCALS) + localvar[nlocalvar++] = name; + else + lua_error ("too many local variables"); +} + +static void store_localvar (Word name, int n) +{ + if (nlocalvar+n < MAXLOCALS) + localvar[nlocalvar+n] = name; + else + lua_error ("too many local variables"); +} + +static void add_varbuffer (Long var) +{ + if (nvarbuffer < MAXVAR) + varbuffer[nvarbuffer++] = var; + else + lua_error ("variable buffer overflow"); +} + +static void code_number (float f) +{ + Word i = (Word)f; + if (f == (float)i) /* f has an (short) integer value */ + { + if (i <= 2) code_byte(PUSH0 + i); + else if (i <= 255) + { + code_byte(PUSHBYTE); + code_byte(i); + } + else + { + code_byte(PUSHWORD); + code_word(i); + } + } + else + { + code_byte(PUSHFLOAT); + code_float(f); + } +} + +/* +** Search a local name and if find return its index. If do not find return -1 +*/ +static int lua_localname (Word n) +{ + int i; + for (i=nlocalvar-1; i >= 0; i--) + if (n == localvar[i]) return i; /* local var */ + return -1; /* global var */ +} + +/* +** Push a variable given a number. If number is positive, push global variable +** indexed by (number -1). If negative, push local indexed by ABS(number)-1. +** Otherwise, if zero, push indexed variable (record). +*/ +static void lua_pushvar (Long number) +{ + if (number > 0) /* global var */ + { + code_byte(PUSHGLOBAL); + code_word(number-1); + } + else if (number < 0) /* local var */ + { + number = (-number) - 1; + if (number < 10) code_byte(PUSHLOCAL0 + number); + else + { + code_byte(PUSHLOCAL); + code_byte(number); + } + } + else + { + code_byte(PUSHINDEXED); + } +} + +static void lua_codeadjust (int n) +{ + if (n+nlocalvar == 0) + code_byte(ADJUST0); + else + { + code_byte(ADJUST); + code_byte(n+nlocalvar); + } +} + +static void change2main (void) +{ + /* (re)store main values */ + pc=maincode; basepc=*initcode; maxcurr=maxmain; + nlocalvar=0; +} + +static void savemain (void) +{ + /* save main values */ + maincode=pc; *initcode=basepc; maxmain=maxcurr; +} + +static void init_func (void) +{ + if (funcCode == NULL) /* first function */ + { + funcCode = newvector(CODE_BLOCK, Byte); + maxcode = CODE_BLOCK; + } + savemain(); /* save main values */ + /* set func values */ + pc=0; basepc=funcCode; maxcurr=maxcode; + nlocalvar = 0; + luaI_codedebugline(lua_linenumber); +} + +static void codereturn (void) +{ + if (nlocalvar == 0) + code_byte(RETCODE0); + else + { + code_byte(RETCODE); + code_byte(nlocalvar); + } +} + +void luaI_codedebugline (int line) +{ + static int lastline = 0; + if (lua_debug && line != lastline) + { + code_byte(SETLINE); + code_word(line); + lastline = line; + } +} + +static int adjust_functioncall (Long exp, int i) +{ + if (exp <= 0) + return -exp; /* exp is -list length */ + else + { + int temp = basepc[exp]; + basepc[exp] = i; + return temp+i; + } +} + +static void adjust_mult_assign (int vars, Long exps, int temps) +{ + if (exps > 0) + { /* must correct function call */ + int diff = vars - basepc[exps]; + if (diff >= 0) + adjust_functioncall(exps, diff); + else + { + adjust_functioncall(exps, 0); + lua_codeadjust(temps); + } + } + else if (vars != -exps) + lua_codeadjust(temps); +} + +static void storesinglevar (Long v) +{ + if (v > 0) /* global var */ + { + code_byte(STOREGLOBAL); + code_word(v-1); + } + else if (v < 0) /* local var */ + { + int number = (-v) - 1; + if (number < 10) code_byte(STORELOCAL0 + number); + else + { + code_byte(STORELOCAL); + code_byte(number); + } + } + else + code_byte(STOREINDEXED0); +} + +static void lua_codestore (int i) +{ + if (varbuffer[i] != 0) /* global or local var */ + storesinglevar(varbuffer[i]); + else /* indexed var */ + { + int j; + int upper=0; /* number of indexed variables upper */ + int param; /* number of itens until indexed expression */ + for (j=i+1; j <nvarbuffer; j++) + if (varbuffer[j] == 0) upper++; + param = upper*2 + i; + if (param == 0) + code_byte(STOREINDEXED0); + else + { + code_byte(STOREINDEXED); + code_byte(param); + } + } +} + +static void codeIf (Long thenAdd, Long elseAdd) +{ + Long elseinit = elseAdd+sizeof(Word)+1; + if (pc == elseinit) /* no else */ + { + pc -= sizeof(Word)+1; + elseinit = pc; + } + else + { + basepc[elseAdd] = JMP; + code_word_at(basepc+elseAdd+1, pc-elseinit); + } + basepc[thenAdd] = IFFJMP; + code_word_at(basepc+thenAdd+1,elseinit-(thenAdd+sizeof(Word)+1)); +} + + +/* +** Parse LUA code. +*/ +void lua_parse (TFunc *tf) +{ + lua_debug = 0; + initcode = &(tf->code); + *initcode = newvector(CODE_BLOCK, Byte); + maincode = 0; + maxmain = CODE_BLOCK; + change2main(); + if (yyparse ()) lua_error("parse error"); + savemain(); + (*initcode)[maincode++] = RETCODE0; + tf->size = maincode; +#if LISTING +{ static void PrintCode (Byte *c, Byte *end); + PrintCode(*initcode,*initcode+maincode); } +#endif +} + + +%} + + +%union +{ + int vInt; + float vFloat; + char *pChar; + Word vWord; + Long vLong; + TFunc *pFunc; + TreeNode *pNode; +} + +%start functionlist + +%token WRONGTOKEN +%token NIL +%token IF THEN ELSE ELSEIF WHILE DO REPEAT UNTIL END +%token RETURN +%token LOCAL +%token FUNCTION +%token <vFloat> NUMBER +%token <vWord> STRING +%token <pNode> NAME +%token <vInt> DEBUG + +%type <vLong> PrepJump +%type <vLong> exprlist, exprlist1 /* if > 0, points to function return + counter (which has list length); if <= 0, -list lenght */ +%type <vLong> functioncall, expr /* if != 0, points to function return + counter */ +%type <vInt> varlist1, funcParams, funcvalue +%type <vInt> fieldlist, localdeclist, decinit +%type <vInt> ffieldlist, ffieldlist1, semicolonpart +%type <vInt> lfieldlist, lfieldlist1 +%type <vInt> parlist +%type <vLong> var, singlevar, funcname +%type <pFunc> body + +%left AND OR +%left EQ NE '>' '<' LE GE +%left CONC +%left '+' '-' +%left '*' '/' +%left UNARY NOT +%right '^' + + +%% /* beginning of rules section */ + + +functionlist : /* empty */ + | functionlist globalstat + | functionlist function + ; + +globalstat : stat sc + | setdebug + ; + +function : FUNCTION funcname body + { + code_byte(PUSHFUNCTION); + code_code($3); + storesinglevar($2); + } + ; + +funcname : var { $$ =$1; init_func(); } + | varexp ':' NAME + { + code_byte(PUSHSTRING); + code_word(luaI_findconstant($3)); + $$ = 0; /* indexed variable */ + init_func(); + add_localvar(luaI_findsymbolbyname("self")); + } + ; + +body : '(' parlist ')' block END + { + codereturn(); + $$ = new(TFunc); + $$->size = pc; + $$->code = newvector(pc, Byte); + $$->fileName = lua_parsedfile; + $$->lineDefined = $2; + memcpy($$->code, basepc, pc*sizeof(Byte)); + /* save func values */ + funcCode = basepc; maxcode=maxcurr; +#if LISTING + PrintCode(funcCode,funcCode+pc); +#endif + change2main(); /* change back to main code */ + } + ; + +statlist : /* empty */ + | statlist stat sc + ; + +sc : /* empty */ | ';' ; + +stat : IF expr1 THEN PrepJump block PrepJump elsepart END + { codeIf($4, $6); } + + | WHILE {$<vLong>$=pc;} expr1 DO PrepJump block PrepJump END + { + basepc[$5] = IFFJMP; + code_word_at(basepc+$5+1, pc - ($5 + sizeof(Word)+1)); + basepc[$7] = UPJMP; + code_word_at(basepc+$7+1, pc - ($<vLong>2)); + } + + | REPEAT {$<vLong>$=pc;} block UNTIL expr1 PrepJump + { + basepc[$6] = IFFUPJMP; + code_word_at(basepc+$6+1, pc - ($<vLong>2)); + } + + | varlist1 '=' exprlist1 + { + { + int i; + adjust_mult_assign(nvarbuffer, $3, $1 * 2 + nvarbuffer); + for (i=nvarbuffer-1; i>=0; i--) + lua_codestore (i); + if ($1 > 1 || ($1 == 1 && varbuffer[0] != 0)) + lua_codeadjust (0); + } + } + | functioncall + | LOCAL localdeclist decinit + { nlocalvar += $2; + adjust_mult_assign($2, $3, 0); + } + ; + +elsepart : /* empty */ + | ELSE block + | ELSEIF expr1 THEN PrepJump block PrepJump elsepart + { codeIf($4, $6); } + ; + +block : {$<vInt>$ = nlocalvar;} statlist ret + { + if (nlocalvar != $<vInt>1) + { + nlocalvar = $<vInt>1; + lua_codeadjust (0); + } + } + ; + +ret : /* empty */ + | RETURN exprlist sc + { + adjust_functioncall($2, MULT_RET); + codereturn(); + } + ; + +PrepJump : /* empty */ + { + $$ = pc; + code_byte(0); /* open space */ + code_word (0); + } + +expr1 : expr { adjust_functioncall($1, 1); } + ; + +expr : '(' expr ')' { $$ = $2; } + | expr1 EQ expr1 { code_byte(EQOP); $$ = 0; } + | expr1 '<' expr1 { code_byte(LTOP); $$ = 0; } + | expr1 '>' expr1 { code_byte(GTOP); $$ = 0; } + | expr1 NE expr1 { code_byte(EQOP); code_byte(NOTOP); $$ = 0; } + | expr1 LE expr1 { code_byte(LEOP); $$ = 0; } + | expr1 GE expr1 { code_byte(GEOP); $$ = 0; } + | expr1 '+' expr1 { code_byte(ADDOP); $$ = 0; } + | expr1 '-' expr1 { code_byte(SUBOP); $$ = 0; } + | expr1 '*' expr1 { code_byte(MULTOP); $$ = 0; } + | expr1 '/' expr1 { code_byte(DIVOP); $$ = 0; } + | expr1 '^' expr1 { code_byte(POWOP); $$ = 0; } + | expr1 CONC expr1 { code_byte(CONCOP); $$ = 0; } + | '-' expr1 %prec UNARY { code_byte(MINUSOP); $$ = 0;} + | table { $$ = 0; } + | varexp { $$ = 0;} + | NUMBER { code_number($1); $$ = 0; } + | STRING + { + code_byte(PUSHSTRING); + code_word($1); + $$ = 0; + } + | NIL {code_byte(PUSHNIL); $$ = 0; } + | functioncall { $$ = $1; } + | NOT expr1 { code_byte(NOTOP); $$ = 0;} + | expr1 AND PrepJump {code_byte(POP); } expr1 + { + basepc[$3] = ONFJMP; + code_word_at(basepc+$3+1, pc - ($3 + sizeof(Word)+1)); + $$ = 0; + } + | expr1 OR PrepJump {code_byte(POP); } expr1 + { + basepc[$3] = ONTJMP; + code_word_at(basepc+$3+1, pc - ($3 + sizeof(Word)+1)); + $$ = 0; + } + ; + +table : + { + code_byte(CREATEARRAY); + $<vLong>$ = pc; code_word(0); + } + '{' fieldlist '}' + { + code_word_at(basepc+$<vLong>1, $3); + } + ; + +functioncall : funcvalue funcParams + { + code_byte(CALLFUNC); + code_byte($1+$2); + $$ = pc; + code_byte(0); /* may be modified by other rules */ + } + ; + +funcvalue : varexp { $$ = 0; } + | varexp ':' NAME + { + code_byte(PUSHSELF); + code_word(luaI_findconstant($3)); + $$ = 1; + } + ; + +funcParams : '(' exprlist ')' + { $$ = adjust_functioncall($2, 1); } + | table { $$ = 1; } + ; + +exprlist : /* empty */ { $$ = 0; } + | exprlist1 { $$ = $1; } + ; + +exprlist1 : expr { if ($1 != 0) $$ = $1; else $$ = -1; } + | exprlist1 ',' { $<vLong>$ = adjust_functioncall($1, 1); } expr + { + if ($4 == 0) $$ = -($<vLong>3 + 1); /* -length */ + else + { + adjust_functioncall($4, $<vLong>3); + $$ = $4; + } + } + ; + +parlist : /* empty */ { lua_codeadjust(0); $$ = lua_linenumber; } + | parlist1 { lua_codeadjust(0); $$ = lua_linenumber; } + ; + +parlist1 : NAME + { + add_localvar(luaI_findsymbol($1)); + } + | parlist1 ',' NAME + { + add_localvar(luaI_findsymbol($3)); + } + ; + +fieldlist : lfieldlist + { flush_list($1/FIELDS_PER_FLUSH, $1%FIELDS_PER_FLUSH); } + semicolonpart + { $$ = $1+$3; } + | ffieldlist1 lastcomma + { $$ = $1; flush_record($1%FIELDS_PER_FLUSH); } + ; + +semicolonpart : /* empty */ + { $$ = 0; } + | ';' ffieldlist + { $$ = $2; flush_record($2%FIELDS_PER_FLUSH); } + ; + +lastcomma : /* empty */ + | ',' + ; + +ffieldlist : /* empty */ { $$ = 0; } + | ffieldlist1 lastcomma { $$ = $1; } + ; + +ffieldlist1 : ffield {$$=1;} + | ffieldlist1 ',' ffield + { + $$=$1+1; + if ($$%FIELDS_PER_FLUSH == 0) flush_record(FIELDS_PER_FLUSH); + } + ; + +ffield : NAME '=' expr1 + { + push_field(luaI_findconstant($1)); + } + ; + +lfieldlist : /* empty */ { $$ = 0; } + | lfieldlist1 lastcomma { $$ = $1; } + ; + +lfieldlist1 : expr1 {$$=1;} + | lfieldlist1 ',' expr1 + { + $$=$1+1; + if ($$%FIELDS_PER_FLUSH == 0) + flush_list($$/FIELDS_PER_FLUSH - 1, FIELDS_PER_FLUSH); + } + ; + +varlist1 : var + { + nvarbuffer = 0; + add_varbuffer($1); + $$ = ($1 == 0) ? 1 : 0; + } + | varlist1 ',' var + { + add_varbuffer($3); + $$ = ($3 == 0) ? $1 + 1 : $1; + } + ; + +var : singlevar { $$ = $1; } + | varexp '[' expr1 ']' + { + $$ = 0; /* indexed variable */ + } + | varexp '.' NAME + { + code_byte(PUSHSTRING); + code_word(luaI_findconstant($3)); + $$ = 0; /* indexed variable */ + } + ; + +singlevar : NAME + { + Word s = luaI_findsymbol($1); + int local = lua_localname (s); + if (local == -1) /* global var */ + $$ = s + 1; /* return positive value */ + else + $$ = -(local+1); /* return negative value */ + } + ; + +varexp : var { lua_pushvar($1); } + ; + +localdeclist : NAME {store_localvar(luaI_findsymbol($1), 0); $$ = 1;} + | localdeclist ',' NAME + { + store_localvar(luaI_findsymbol($3), $1); + $$ = $1+1; + } + ; + +decinit : /* empty */ { $$ = 0; } + | '=' exprlist1 { $$ = $2; } + ; + +setdebug : DEBUG { lua_debug = $1; } + ; + +%% + +#if LISTING + +static void PrintCode (Byte *code, Byte *end) +{ + Byte *p = code; + printf ("\n\nCODE\n"); + while (p != end) + { + switch ((OpCode)*p) + { + case PUSHNIL: printf ("%d PUSHNIL\n", (p++)-code); break; + case PUSH0: case PUSH1: case PUSH2: + printf ("%d PUSH%c\n", p-code, *p-PUSH0+'0'); + p++; + break; + case PUSHBYTE: + printf ("%d PUSHBYTE %d\n", p-code, *(++p)); + p++; + break; + case PUSHWORD: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d PUSHWORD %d\n", n, c.w); + } + break; + case PUSHFLOAT: + { + CodeFloat c; + int n = p-code; + p++; + get_float(c,p); + printf ("%d PUSHFLOAT %f\n", n, c.f); + } + break; + case PUSHSTRING: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d PUSHSTRING %d\n", n, c.w); + } + break; + case PUSHFUNCTION: + { + CodeCode c; + int n = p-code; + p++; + get_code(c,p); + printf ("%d PUSHFUNCTION %p\n", n, c.tf); + } + break; + + case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3: + case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7: + case PUSHLOCAL8: case PUSHLOCAL9: + printf ("%d PUSHLOCAL%c\n", p-code, *p-PUSHLOCAL0+'0'); + p++; + break; + case PUSHLOCAL: printf ("%d PUSHLOCAL %d\n", p-code, *(++p)); + p++; + break; + case PUSHGLOBAL: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d PUSHGLOBAL %d\n", n, c.w); + } + break; + case PUSHINDEXED: printf ("%d PUSHINDEXED\n", (p++)-code); break; + case STORELOCAL0: case STORELOCAL1: case STORELOCAL2: case STORELOCAL3: + case STORELOCAL4: case STORELOCAL5: case STORELOCAL6: case STORELOCAL7: + case STORELOCAL8: case STORELOCAL9: + printf ("%d STORELOCAL%c\n", p-code, *p-STORELOCAL0+'0'); + p++; + break; + case STORELOCAL: + printf ("%d STORELOCAL %d\n", p-code, *(++p)); + p++; + break; + case STOREGLOBAL: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d STOREGLOBAL %d\n", n, c.w); + } + break; + case PUSHSELF: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d PUSHSELF %d\n", n, c.w); + } + break; + case STOREINDEXED0: printf ("%d STOREINDEXED0\n", (p++)-code); break; + case STOREINDEXED: printf ("%d STOREINDEXED %d\n", p-code, *(++p)); + p++; + break; + case STORELIST0: + printf("%d STORELIST0 %d\n", p-code, *(++p)); + p++; + break; + case STORELIST: + printf("%d STORELIST %d %d\n", p-code, *(p+1), *(p+2)); + p+=3; + break; + case STORERECORD: + printf("%d STORERECORD %d\n", p-code, *(++p)); + p += *p*sizeof(Word) + 1; + break; + case ADJUST0: printf ("%d ADJUST0\n", (p++)-code); break; + case ADJUST: + printf ("%d ADJUST %d\n", p-code, *(++p)); + p++; + break; + case CREATEARRAY: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d CREATEARRAY %d\n", n, c.w); + break; + } + case EQOP: printf ("%d EQOP\n", (p++)-code); break; + case LTOP: printf ("%d LTOP\n", (p++)-code); break; + case LEOP: printf ("%d LEOP\n", (p++)-code); break; + case ADDOP: printf ("%d ADDOP\n", (p++)-code); break; + case SUBOP: printf ("%d SUBOP\n", (p++)-code); break; + case MULTOP: printf ("%d MULTOP\n", (p++)-code); break; + case DIVOP: printf ("%d DIVOP\n", (p++)-code); break; + case POWOP: printf ("%d POWOP\n", (p++)-code); break; + case CONCOP: printf ("%d CONCOP\n", (p++)-code); break; + case MINUSOP: printf ("%d MINUSOP\n", (p++)-code); break; + case NOTOP: printf ("%d NOTOP\n", (p++)-code); break; + case ONTJMP: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d ONTJMP %d\n", n, c.w); + } + break; + case ONFJMP: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d ONFJMP %d\n", n, c.w); + } + break; + case JMP: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d JMP %d\n", n, c.w); + } + break; + case UPJMP: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d UPJMP %d\n", n, c.w); + } + break; + case IFFJMP: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d IFFJMP %d\n", n, c.w); + } + break; + case IFFUPJMP: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d IFFUPJMP %d\n", n, c.w); + } + break; + case POP: printf ("%d POP\n", (p++)-code); break; + case CALLFUNC: + printf ("%d CALLFUNC %d %d\n", p-code, *(p+1), *(p+2)); + p+=3; + break; + case RETCODE0: printf ("%d RETCODE0\n", (p++)-code); break; + case RETCODE: + printf ("%d RETCODE %d\n", p-code, *(++p)); + p++; + break; + case SETLINE: + { + CodeWord c; + int n = p-code; + p++; + get_word(c,p); + printf ("%d SETLINE %d\n", n, c.w); + } + break; + + default: printf ("%d Cannot happen: code %d\n", (p++)-code, *(p-1)); break; + } + } +} +#endif + |