mirror of
https://github.com/lua/lua
synced 2024-11-21 20:31:22 +03:00
LUA YACC syntax and semantics
This commit is contained in:
Waldemar Celes
parent
4478f0ce92
commit
93683d530d
771
lua.stx
Normal file
771
lua.stx
Normal file
@ -0,0 +1,771 @@
|
||||
%{
|
||||
|
||||
char *rcs_luastx = "$Id: $";
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "opcode.h"
|
||||
#include "hash.h"
|
||||
#include "inout.h"
|
||||
#include "table.h"
|
||||
#include "lua.h"
|
||||
|
||||
#ifndef ALIGNMENT
|
||||
#define ALIGNMENT (sizeof(void *))
|
||||
#endif
|
||||
|
||||
#ifndef MAXCODE
|
||||
#define MAXCODE 1024
|
||||
#endif
|
||||
static long buffer[MAXCODE];
|
||||
static Byte *code = (Byte *)buffer;
|
||||
static long mainbuffer[MAXCODE];
|
||||
static Byte *maincode = (Byte *)mainbuffer;
|
||||
static Byte *basepc;
|
||||
static Byte *pc;
|
||||
|
||||
#define MAXVAR 32
|
||||
static long varbuffer[MAXVAR];
|
||||
static Byte nvarbuffer=0; /* number of variables at a list */
|
||||
|
||||
static Word localvar[STACKGAP];
|
||||
static Byte nlocalvar=0; /* number of local variables */
|
||||
static int ntemp; /* number of temporary var into stack */
|
||||
static int err; /* flag to indicate error */
|
||||
|
||||
/* Internal functions */
|
||||
#define align(n) align_n(sizeof(n))
|
||||
|
||||
static void code_byte (Byte c)
|
||||
{
|
||||
if (pc-basepc>MAXCODE-1)
|
||||
{
|
||||
lua_error ("code buffer overflow");
|
||||
err = 1;
|
||||
}
|
||||
*pc++ = c;
|
||||
}
|
||||
|
||||
static void code_word (Word n)
|
||||
{
|
||||
if (pc-basepc>MAXCODE-sizeof(Word))
|
||||
{
|
||||
lua_error ("code buffer overflow");
|
||||
err = 1;
|
||||
}
|
||||
*((Word *)pc) = n;
|
||||
pc += sizeof(Word);
|
||||
}
|
||||
|
||||
static void code_float (float n)
|
||||
{
|
||||
if (pc-basepc>MAXCODE-sizeof(float))
|
||||
{
|
||||
lua_error ("code buffer overflow");
|
||||
err = 1;
|
||||
}
|
||||
*((float *)pc) = n;
|
||||
pc += sizeof(float);
|
||||
}
|
||||
|
||||
static void incr_ntemp (void)
|
||||
{
|
||||
if (ntemp+nlocalvar+MAXVAR+1 < STACKGAP)
|
||||
ntemp++;
|
||||
else
|
||||
{
|
||||
lua_error ("stack overflow");
|
||||
err = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void add_nlocalvar (int n)
|
||||
{
|
||||
if (ntemp+nlocalvar+MAXVAR+n < STACKGAP)
|
||||
nlocalvar += n;
|
||||
else
|
||||
{
|
||||
lua_error ("too many local variables or expression too complicate");
|
||||
err = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void incr_nvarbuffer (void)
|
||||
{
|
||||
if (nvarbuffer < MAXVAR-1)
|
||||
nvarbuffer++;
|
||||
else
|
||||
{
|
||||
lua_error ("variable buffer overflow");
|
||||
err = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void align_n (unsigned size)
|
||||
{
|
||||
if (size > ALIGNMENT) size = ALIGNMENT;
|
||||
while (((pc+1-code)%size) != 0) /* +1 to include BYTECODE */
|
||||
code_byte (NOP);
|
||||
}
|
||||
|
||||
static void code_number (float f)
|
||||
{ int i = f;
|
||||
if (f == i) /* f has an integer value */
|
||||
{
|
||||
if (i <= 2) code_byte(PUSH0 + i);
|
||||
else if (i <= 255)
|
||||
{
|
||||
code_byte(PUSHBYTE);
|
||||
code_byte(i);
|
||||
}
|
||||
else
|
||||
{
|
||||
align(Word);
|
||||
code_byte(PUSHWORD);
|
||||
code_word(i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
align(float);
|
||||
code_byte(PUSHFLOAT);
|
||||
code_float(f);
|
||||
}
|
||||
incr_ntemp();
|
||||
}
|
||||
|
||||
%}
|
||||
|
||||
|
||||
%union
|
||||
{
|
||||
int vInt;
|
||||
long vLong;
|
||||
float vFloat;
|
||||
Word vWord;
|
||||
Byte *pByte;
|
||||
}
|
||||
|
||||
%start functionlist
|
||||
|
||||
%token NIL
|
||||
%token IF THEN ELSE ELSEIF WHILE DO REPEAT UNTIL END
|
||||
%token RETURN
|
||||
%token LOCAL
|
||||
%token <vFloat> NUMBER
|
||||
%token <vWord> FUNCTION NAME STRING
|
||||
%token <vInt> DEBUG
|
||||
|
||||
%type <pByte> PrepJump
|
||||
%type <vInt> expr, exprlist, exprlist1, varlist1, typeconstructor
|
||||
%type <vInt> fieldlist, localdeclist
|
||||
%type <vInt> ffieldlist, ffieldlist1
|
||||
%type <vInt> lfieldlist, lfieldlist1
|
||||
%type <vLong> var, objectname
|
||||
|
||||
|
||||
%left AND OR
|
||||
%left '=' NE '>' '<' LE GE
|
||||
%left CONC
|
||||
%left '+' '-'
|
||||
%left '*' '/'
|
||||
%left UNARY NOT
|
||||
|
||||
|
||||
%% /* beginning of rules section */
|
||||
|
||||
|
||||
functionlist : /* empty */
|
||||
| functionlist {pc=basepc=maincode; nlocalvar=0;} stat sc {maincode=pc;}
|
||||
| functionlist function
|
||||
| functionlist setdebug
|
||||
;
|
||||
|
||||
function : FUNCTION NAME {pc=basepc=code; nlocalvar=0;} '(' parlist ')'
|
||||
{
|
||||
if (lua_debug)
|
||||
{
|
||||
align(Word);
|
||||
code_byte(SETFUNCTION);
|
||||
code_word($1);
|
||||
code_word($2);
|
||||
}
|
||||
lua_codeadjust (0);
|
||||
}
|
||||
block
|
||||
END
|
||||
{
|
||||
if (lua_debug) code_byte(RESET);
|
||||
code_byte(RETCODE); code_byte(nlocalvar);
|
||||
s_tag($2) = T_FUNCTION;
|
||||
s_bvalue($2) = calloc (pc-code, sizeof(Byte));
|
||||
memcpy (s_bvalue($2), code, (pc-code)*sizeof(Byte));
|
||||
}
|
||||
;
|
||||
|
||||
statlist : /* empty */
|
||||
| statlist stat sc
|
||||
;
|
||||
|
||||
stat : {
|
||||
ntemp = 0;
|
||||
if (lua_debug)
|
||||
{
|
||||
align(Word); code_byte(SETLINE); code_word(lua_linenumber);
|
||||
}
|
||||
}
|
||||
stat1
|
||||
|
||||
sc : /* empty */ | ';' ;
|
||||
|
||||
|
||||
stat1 : IF expr1 THEN PrepJump block PrepJump elsepart END
|
||||
{
|
||||
{
|
||||
Byte *elseinit = $6 + sizeof(Word)+1;
|
||||
if (pc - elseinit == 0) /* no else */
|
||||
{
|
||||
pc -= sizeof(Word)+1;
|
||||
/* if (*(pc-1) == NOP) --pc; */
|
||||
elseinit = pc;
|
||||
}
|
||||
else
|
||||
{
|
||||
*($6) = JMP;
|
||||
*((Word *)($6+1)) = pc - elseinit;
|
||||
}
|
||||
*($4) = IFFJMP;
|
||||
*((Word *)($4+1)) = elseinit - ($4 + sizeof(Word)+1);
|
||||
}
|
||||
}
|
||||
|
||||
| WHILE {$<pByte>$ = pc;} expr1 DO PrepJump block PrepJump END
|
||||
|
||||
{
|
||||
*($5) = IFFJMP;
|
||||
*((Word *)($5+1)) = pc - ($5 + sizeof(Word)+1);
|
||||
|
||||
*($7) = UPJMP;
|
||||
*((Word *)($7+1)) = pc - $<pByte>2;
|
||||
}
|
||||
|
||||
| REPEAT {$<pByte>$ = pc;} block UNTIL expr1 PrepJump
|
||||
|
||||
{
|
||||
*($6) = IFFUPJMP;
|
||||
*((Word *)($6+1)) = pc - $<pByte>2;
|
||||
}
|
||||
|
||||
|
||||
| varlist1 '=' exprlist1
|
||||
{
|
||||
{
|
||||
int i;
|
||||
if ($3 == 0 || nvarbuffer != ntemp - $1 * 2)
|
||||
lua_codeadjust ($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 { lua_codeadjust (0); }
|
||||
| typeconstructor { lua_codeadjust (0); }
|
||||
| LOCAL localdeclist decinit { add_nlocalvar($2); lua_codeadjust (0); }
|
||||
;
|
||||
|
||||
elsepart : /* empty */
|
||||
| ELSE block
|
||||
| ELSEIF expr1 THEN PrepJump block PrepJump elsepart
|
||||
{
|
||||
{
|
||||
Byte *elseinit = $6 + sizeof(Word)+1;
|
||||
if (pc - elseinit == 0) /* no else */
|
||||
{
|
||||
pc -= sizeof(Word)+1;
|
||||
/* if (*(pc-1) == NOP) --pc; */
|
||||
elseinit = pc;
|
||||
}
|
||||
else
|
||||
{
|
||||
*($6) = JMP;
|
||||
*((Word *)($6+1)) = pc - elseinit;
|
||||
}
|
||||
*($4) = IFFJMP;
|
||||
*((Word *)($4+1)) = elseinit - ($4 + sizeof(Word)+1);
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
block : {$<vInt>$ = nlocalvar;} statlist {ntemp = 0;} ret
|
||||
{
|
||||
if (nlocalvar != $<vInt>1)
|
||||
{
|
||||
nlocalvar = $<vInt>1;
|
||||
lua_codeadjust (0);
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
ret : /* empty */
|
||||
| { if (lua_debug){align(Word);code_byte(SETLINE);code_word(lua_linenumber);}}
|
||||
RETURN exprlist sc
|
||||
{
|
||||
if (lua_debug) code_byte(RESET);
|
||||
code_byte(RETCODE); code_byte(nlocalvar);
|
||||
}
|
||||
;
|
||||
|
||||
PrepJump : /* empty */
|
||||
{
|
||||
align(Word);
|
||||
$$ = pc;
|
||||
code_byte(0); /* open space */
|
||||
code_word (0);
|
||||
}
|
||||
|
||||
expr1 : expr { if ($1 == 0) {lua_codeadjust (ntemp+1); incr_ntemp();}}
|
||||
;
|
||||
|
||||
expr : '(' expr ')' { $$ = $2; }
|
||||
| expr1 '=' expr1 { code_byte(EQOP); $$ = 1; ntemp--;}
|
||||
| expr1 '<' expr1 { code_byte(LTOP); $$ = 1; ntemp--;}
|
||||
| expr1 '>' expr1 { code_byte(LEOP); code_byte(NOTOP); $$ = 1; ntemp--;}
|
||||
| expr1 NE expr1 { code_byte(EQOP); code_byte(NOTOP); $$ = 1; ntemp--;}
|
||||
| expr1 LE expr1 { code_byte(LEOP); $$ = 1; ntemp--;}
|
||||
| expr1 GE expr1 { code_byte(LTOP); code_byte(NOTOP); $$ = 1; ntemp--;}
|
||||
| expr1 '+' expr1 { code_byte(ADDOP); $$ = 1; ntemp--;}
|
||||
| expr1 '-' expr1 { code_byte(SUBOP); $$ = 1; ntemp--;}
|
||||
| expr1 '*' expr1 { code_byte(MULTOP); $$ = 1; ntemp--;}
|
||||
| expr1 '/' expr1 { code_byte(DIVOP); $$ = 1; ntemp--;}
|
||||
| expr1 CONC expr1 { code_byte(CONCOP); $$ = 1; ntemp--;}
|
||||
| '+' expr1 %prec UNARY { $$ = 1; }
|
||||
| '-' expr1 %prec UNARY { code_byte(MINUSOP); $$ = 1;}
|
||||
| typeconstructor { $$ = $1; }
|
||||
| '@' '(' dimension ')'
|
||||
{
|
||||
code_byte(CREATEARRAY);
|
||||
$$ = 1;
|
||||
}
|
||||
| var { lua_pushvar ($1); $$ = 1;}
|
||||
| NUMBER { code_number($1); $$ = 1; }
|
||||
| STRING
|
||||
{
|
||||
align(Word);
|
||||
code_byte(PUSHSTRING);
|
||||
code_word($1);
|
||||
$$ = 1;
|
||||
incr_ntemp();
|
||||
}
|
||||
| NIL {code_byte(PUSHNIL); $$ = 1; incr_ntemp();}
|
||||
| functioncall
|
||||
{
|
||||
$$ = 0;
|
||||
if (lua_debug)
|
||||
{
|
||||
align(Word); code_byte(SETLINE); code_word(lua_linenumber);
|
||||
}
|
||||
}
|
||||
| NOT expr1 { code_byte(NOTOP); $$ = 1;}
|
||||
| expr1 AND PrepJump {code_byte(POP); ntemp--;} expr1
|
||||
{
|
||||
*($3) = ONFJMP;
|
||||
*((Word *)($3+1)) = pc - ($3 + sizeof(Word)+1);
|
||||
$$ = 1;
|
||||
}
|
||||
| expr1 OR PrepJump {code_byte(POP); ntemp--;} expr1
|
||||
{
|
||||
*($3) = ONTJMP;
|
||||
*((Word *)($3+1)) = pc - ($3 + sizeof(Word)+1);
|
||||
$$ = 1;
|
||||
}
|
||||
;
|
||||
|
||||
typeconstructor: '@'
|
||||
{
|
||||
code_byte(PUSHBYTE);
|
||||
$<pByte>$ = pc; code_byte(0);
|
||||
incr_ntemp();
|
||||
code_byte(CREATEARRAY);
|
||||
}
|
||||
objectname fieldlist
|
||||
{
|
||||
*($<pByte>2) = $4;
|
||||
if ($3 < 0) /* there is no function to be called */
|
||||
{
|
||||
$$ = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
lua_pushvar ($3+1);
|
||||
code_byte(PUSHMARK);
|
||||
incr_ntemp();
|
||||
code_byte(PUSHOBJECT);
|
||||
incr_ntemp();
|
||||
code_byte(CALLFUNC);
|
||||
ntemp -= 4;
|
||||
$$ = 0;
|
||||
if (lua_debug)
|
||||
{
|
||||
align(Word); code_byte(SETLINE); code_word(lua_linenumber);
|
||||
}
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
dimension : /* empty */ { code_byte(PUSHNIL); incr_ntemp();}
|
||||
| expr1
|
||||
;
|
||||
|
||||
functioncall : functionvalue {code_byte(PUSHMARK); $<vInt>$ = ntemp; incr_ntemp();}
|
||||
'(' exprlist ')' { code_byte(CALLFUNC); ntemp = $<vInt>2-1;}
|
||||
|
||||
functionvalue : var {lua_pushvar ($1); }
|
||||
;
|
||||
|
||||
exprlist : /* empty */ { $$ = 1; }
|
||||
| exprlist1 { $$ = $1; }
|
||||
;
|
||||
|
||||
exprlist1 : expr { $$ = $1; }
|
||||
| exprlist1 ',' {if (!$1){lua_codeadjust (ntemp+1); incr_ntemp();}}
|
||||
expr {$$ = $4;}
|
||||
;
|
||||
|
||||
parlist : /* empty */
|
||||
| parlist1
|
||||
;
|
||||
|
||||
parlist1 : NAME {localvar[nlocalvar]=$1; add_nlocalvar(1);}
|
||||
| parlist1 ',' NAME {localvar[nlocalvar]=$3; add_nlocalvar(1);}
|
||||
;
|
||||
|
||||
objectname : /* empty */ {$$=-1;}
|
||||
| NAME {$$=$1;}
|
||||
;
|
||||
|
||||
fieldlist : '{' ffieldlist '}' { $$ = $2; }
|
||||
| '[' lfieldlist ']' { $$ = $2; }
|
||||
;
|
||||
|
||||
ffieldlist : /* empty */ { $$ = 0; }
|
||||
| ffieldlist1 { $$ = $1; }
|
||||
;
|
||||
|
||||
ffieldlist1 : ffield {$$=1;}
|
||||
| ffieldlist1 ',' ffield {$$=$1+1;}
|
||||
;
|
||||
|
||||
ffield : NAME
|
||||
{
|
||||
align(Word);
|
||||
code_byte(PUSHSTRING);
|
||||
code_word(lua_findconstant (s_name($1)));
|
||||
incr_ntemp();
|
||||
}
|
||||
'=' expr1
|
||||
{
|
||||
code_byte(STOREFIELD);
|
||||
ntemp-=2;
|
||||
}
|
||||
;
|
||||
|
||||
lfieldlist : /* empty */ { $$ = 0; }
|
||||
| lfieldlist1 { $$ = $1; }
|
||||
;
|
||||
|
||||
lfieldlist1 : { code_number(1); } lfield {$$=1;}
|
||||
| lfieldlist1 ',' { code_number($1+1); } lfield
|
||||
{$$=$1+1;}
|
||||
;
|
||||
|
||||
lfield : expr1
|
||||
{
|
||||
code_byte(STOREFIELD);
|
||||
ntemp-=2;
|
||||
}
|
||||
;
|
||||
|
||||
varlist1 : var
|
||||
{
|
||||
nvarbuffer = 0;
|
||||
varbuffer[nvarbuffer] = $1; incr_nvarbuffer();
|
||||
$$ = ($1 == 0) ? 1 : 0;
|
||||
}
|
||||
| varlist1 ',' var
|
||||
{
|
||||
varbuffer[nvarbuffer] = $3; incr_nvarbuffer();
|
||||
$$ = ($3 == 0) ? $1 + 1 : $1;
|
||||
}
|
||||
;
|
||||
|
||||
var : NAME
|
||||
{
|
||||
int local = lua_localname ($1);
|
||||
if (local == -1) /* global var */
|
||||
$$ = $1 + 1; /* return positive value */
|
||||
else
|
||||
$$ = -(local+1); /* return negative value */
|
||||
}
|
||||
|
||||
| var {lua_pushvar ($1);} '[' expr1 ']'
|
||||
{
|
||||
$$ = 0; /* indexed variable */
|
||||
}
|
||||
| var {lua_pushvar ($1);} '.' NAME
|
||||
{
|
||||
align(Word);
|
||||
code_byte(PUSHSTRING);
|
||||
code_word(lua_findconstant (s_name($4))); incr_ntemp();
|
||||
$$ = 0; /* indexed variable */
|
||||
}
|
||||
;
|
||||
|
||||
localdeclist : NAME {localvar[nlocalvar]=$1; $$ = 1;}
|
||||
| localdeclist ',' NAME {localvar[nlocalvar+$1]=$3; $$ = $1+1;}
|
||||
;
|
||||
|
||||
decinit : /* empty */
|
||||
| '=' exprlist1
|
||||
;
|
||||
|
||||
setdebug : DEBUG {lua_debug = $1;}
|
||||
|
||||
%%
|
||||
|
||||
/*
|
||||
** 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 */
|
||||
{
|
||||
align(Word);
|
||||
code_byte(PUSHGLOBAL);
|
||||
code_word(number-1);
|
||||
incr_ntemp();
|
||||
}
|
||||
else if (number < 0) /* local var */
|
||||
{
|
||||
number = (-number) - 1;
|
||||
if (number < 10) code_byte(PUSHLOCAL0 + number);
|
||||
else
|
||||
{
|
||||
code_byte(PUSHLOCAL);
|
||||
code_byte(number);
|
||||
}
|
||||
incr_ntemp();
|
||||
}
|
||||
else
|
||||
{
|
||||
code_byte(PUSHINDEXED);
|
||||
ntemp--;
|
||||
}
|
||||
}
|
||||
|
||||
static void lua_codeadjust (int n)
|
||||
{
|
||||
code_byte(ADJUST);
|
||||
code_byte(n + nlocalvar);
|
||||
}
|
||||
|
||||
static void lua_codestore (int i)
|
||||
{
|
||||
if (varbuffer[i] > 0) /* global var */
|
||||
{
|
||||
align(Word);
|
||||
code_byte(STOREGLOBAL);
|
||||
code_word(varbuffer[i]-1);
|
||||
}
|
||||
else if (varbuffer[i] < 0) /* local var */
|
||||
{
|
||||
int number = (-varbuffer[i]) - 1;
|
||||
if (number < 10) code_byte(STORELOCAL0 + number);
|
||||
else
|
||||
{
|
||||
code_byte(STORELOCAL);
|
||||
code_byte(number);
|
||||
}
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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_filename());
|
||||
lua_error (msg);
|
||||
err = 1;
|
||||
}
|
||||
|
||||
int yywrap (void)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Parse LUA code and execute global statement.
|
||||
** Return 0 on success or 1 on error.
|
||||
*/
|
||||
int lua_parse (void)
|
||||
{
|
||||
Byte *initcode = maincode;
|
||||
err = 0;
|
||||
if (yyparse () || (err==1)) return 1;
|
||||
*maincode++ = HALT;
|
||||
if (lua_execute (initcode)) return 1;
|
||||
maincode = initcode;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
static void PrintCode (void)
|
||||
{
|
||||
Byte *p = code;
|
||||
printf ("\n\nCODE\n");
|
||||
while (p != pc)
|
||||
{
|
||||
switch ((OpCode)*p)
|
||||
{
|
||||
case NOP: printf ("%d NOP\n", (p++)-code); break;
|
||||
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:
|
||||
printf ("%d PUSHWORD %d\n", p-code, *((Word *)(p+1)));
|
||||
p += 1 + sizeof(Word);
|
||||
break;
|
||||
case PUSHFLOAT:
|
||||
printf ("%d PUSHFLOAT %f\n", p-code, *((float *)(p+1)));
|
||||
p += 1 + sizeof(float);
|
||||
break;
|
||||
case PUSHSTRING:
|
||||
printf ("%d PUSHSTRING %d\n", p-code, *((Word *)(p+1)));
|
||||
p += 1 + sizeof(Word);
|
||||
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:
|
||||
printf ("%d PUSHGLOBAL %d\n", p-code, *((Word *)(p+1)));
|
||||
p += 1 + sizeof(Word);
|
||||
break;
|
||||
case PUSHINDEXED: printf ("%d PUSHINDEXED\n", (p++)-code); break;
|
||||
case PUSHMARK: printf ("%d PUSHMARK\n", (p++)-code); break;
|
||||
case PUSHOBJECT: printf ("%d PUSHOBJECT\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 STORELOCAK %d\n", p-code, *(++p));
|
||||
p++;
|
||||
break;
|
||||
case STOREGLOBAL:
|
||||
printf ("%d STOREGLOBAL %d\n", p-code, *((Word *)(p+1)));
|
||||
p += 1 + sizeof(Word);
|
||||
break;
|
||||
case STOREINDEXED0: printf ("%d STOREINDEXED0\n", (p++)-code); break;
|
||||
case STOREINDEXED: printf ("%d STOREINDEXED %d\n", p-code, *(++p));
|
||||
p++;
|
||||
break;
|
||||
case STOREFIELD: printf ("%d STOREFIELD\n", (p++)-code); break;
|
||||
case ADJUST:
|
||||
printf ("%d ADJUST %d\n", p-code, *(++p));
|
||||
p++;
|
||||
break;
|
||||
case CREATEARRAY: printf ("%d CREATEARRAY\n", (p++)-code); 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 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:
|
||||
printf ("%d ONTJMP %d\n", p-code, *((Word *)(p+1)));
|
||||
p += sizeof(Word) + 1;
|
||||
break;
|
||||
case ONFJMP:
|
||||
printf ("%d ONFJMP %d\n", p-code, *((Word *)(p+1)));
|
||||
p += sizeof(Word) + 1;
|
||||
break;
|
||||
case JMP:
|
||||
printf ("%d JMP %d\n", p-code, *((Word *)(p+1)));
|
||||
p += sizeof(Word) + 1;
|
||||
break;
|
||||
case UPJMP:
|
||||
printf ("%d UPJMP %d\n", p-code, *((Word *)(p+1)));
|
||||
p += sizeof(Word) + 1;
|
||||
break;
|
||||
case IFFJMP:
|
||||
printf ("%d IFFJMP %d\n", p-code, *((Word *)(p+1)));
|
||||
p += sizeof(Word) + 1;
|
||||
break;
|
||||
case IFFUPJMP:
|
||||
printf ("%d IFFUPJMP %d\n", p-code, *((Word *)(p+1)));
|
||||
p += sizeof(Word) + 1;
|
||||
break;
|
||||
case POP: printf ("%d POP\n", (p++)-code); break;
|
||||
case CALLFUNC: printf ("%d CALLFUNC\n", (p++)-code); break;
|
||||
case RETCODE:
|
||||
printf ("%d RETCODE %d\n", p-code, *(++p));
|
||||
p++;
|
||||
break;
|
||||
default: printf ("%d Cannot happen\n", (p++)-code); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
35
y_tab.h
35
y_tab.h
@ -1,35 +0,0 @@
|
||||
|
||||
typedef union
|
||||
{
|
||||
int vInt;
|
||||
long vLong;
|
||||
float vFloat;
|
||||
Word vWord;
|
||||
Byte *pByte;
|
||||
} YYSTYPE;
|
||||
extern YYSTYPE yylval;
|
||||
# define NIL 257
|
||||
# define IF 258
|
||||
# define THEN 259
|
||||
# define ELSE 260
|
||||
# define ELSEIF 261
|
||||
# define WHILE 262
|
||||
# define DO 263
|
||||
# define REPEAT 264
|
||||
# define UNTIL 265
|
||||
# define END 266
|
||||
# define RETURN 267
|
||||
# define LOCAL 268
|
||||
# define NUMBER 269
|
||||
# define FUNCTION 270
|
||||
# define NAME 271
|
||||
# define STRING 272
|
||||
# define DEBUG 273
|
||||
# define NOT 274
|
||||
# define AND 275
|
||||
# define OR 276
|
||||
# define NE 277
|
||||
# define LE 278
|
||||
# define GE 279
|
||||
# define CONC 280
|
||||
# define UNARY 281
|
||||
Loading…
Reference in New Issue
Block a user