diff options
Diffstat (limited to 'y_tab.c')
| -rw-r--r-- | y_tab.c | 1639 |
1 files changed, 1639 insertions, 0 deletions
diff --git a/y_tab.c b/y_tab.c new file mode 100644 index 00000000..d34d2147 --- /dev/null +++ b/y_tab.c @@ -0,0 +1,1639 @@ +# line 2 "lua.stx" + +#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 incr_nlocalvar (void) +{ + if (ntemp+nlocalvar+MAXVAR+1 < STACKGAP) + nlocalvar++; + 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(); +} + + +# line 140 "lua.stx" +typedef union +{ + int vInt; + long vLong; + float vFloat; + Word vWord; + Byte *pByte; +} YYSTYPE; +# 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 +#define yyclearin yychar = -1 +#define yyerrok yyerrflag = 0 +extern int yychar; +extern int yyerrflag; +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 150 +#endif +YYSTYPE yylval, yyval; +# define YYERRCODE 256 + +# line 530 "lua.stx" + + +/* +** 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 + +int yyexca[] ={ +-1, 1, + 0, -1, + -2, 2, +-1, 19, + 40, 65, + 91, 95, + 46, 97, + -2, 92, +-1, 29, + 40, 65, + 91, 95, + 46, 97, + -2, 51, +-1, 70, + 275, 33, + 276, 33, + 61, 33, + 277, 33, + 62, 33, + 60, 33, + 278, 33, + 279, 33, + 280, 33, + 43, 33, + 45, 33, + 42, 33, + 47, 33, + -2, 68, +-1, 71, + 91, 95, + 46, 97, + -2, 93, +-1, 102, + 260, 27, + 261, 27, + 265, 27, + 266, 27, + 267, 27, + -2, 11, +-1, 117, + 93, 85, + -2, 87, +-1, 122, + 267, 30, + -2, 29, +-1, 145, + 275, 33, + 276, 33, + 61, 33, + 277, 33, + 62, 33, + 60, 33, + 278, 33, + 279, 33, + 280, 33, + 43, 33, + 45, 33, + 42, 33, + 47, 33, + -2, 70, + }; +# define YYNPROD 105 +# define YYLAST 318 +int yyact[]={ + + 54, 52, 136, 53, 13, 55, 54, 52, 14, 53, + 15, 55, 5, 166, 18, 6, 129, 21, 47, 46, + 48, 107, 104, 97, 47, 46, 48, 54, 52, 80, + 53, 21, 55, 54, 52, 40, 53, 9, 55, 54, + 52, 158, 53, 160, 55, 47, 46, 48, 159, 101, + 81, 47, 46, 48, 10, 54, 52, 126, 53, 67, + 55, 54, 52, 60, 53, 155, 55, 148, 149, 135, + 147, 108, 150, 47, 46, 48, 73, 23, 75, 47, + 46, 48, 7, 25, 38, 153, 26, 164, 27, 117, + 61, 62, 74, 11, 76, 54, 24, 127, 65, 66, + 55, 37, 154, 151, 103, 111, 72, 28, 93, 94, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 116, 59, 77, 54, 52, 118, 53, 99, 55, + 110, 95, 64, 44, 70, 109, 29, 33, 105, 106, + 42, 112, 41, 165, 139, 19, 17, 152, 79, 123, + 43, 119, 20, 114, 113, 98, 63, 144, 143, 122, + 68, 39, 36, 130, 35, 120, 12, 8, 102, 125, + 128, 141, 78, 69, 70, 71, 142, 131, 132, 140, + 22, 124, 4, 3, 2, 121, 96, 138, 146, 137, + 134, 157, 133, 115, 16, 1, 0, 0, 0, 0, + 0, 0, 0, 156, 0, 0, 0, 0, 161, 0, + 0, 0, 0, 162, 0, 0, 0, 168, 0, 172, + 145, 163, 171, 0, 174, 0, 0, 0, 169, 156, + 167, 170, 173, 57, 58, 49, 50, 51, 56, 57, + 58, 49, 50, 51, 56, 175, 0, 0, 100, 0, + 45, 0, 0, 0, 0, 70, 0, 0, 0, 0, + 57, 58, 49, 50, 51, 56, 57, 58, 49, 50, + 51, 56, 0, 0, 0, 0, 0, 56, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 57, 58, + 49, 50, 51, 56, 0, 0, 49, 50, 51, 56, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 30, 0, 21, 31, 0, 34 }; +int yypact[]={ + + -1000, -258, -1000, -1000, -1000, -234, -1000, 34, -254, -1000, + -1000, -1000, -1000, 43, -1000, -1000, 40, -1000, -236, -1000, + -1000, -1000, 93, -9, -1000, 43, 43, 43, 92, -1000, + -1000, -1000, -1000, -1000, 43, 43, -1000, 43, -240, 62, + 31, -13, 48, 83, -242, -1000, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, -1000, -1000, 90, + 13, -1000, -1000, -248, 43, 19, -15, -216, -1000, 60, + -1000, -1000, -249, -1000, -1000, 43, -250, 43, 89, 61, + -1000, -1000, -3, -3, -3, -3, -3, -3, 53, 53, + -1000, -1000, 82, -1000, -1000, -1000, -2, -1000, 85, 13, + -1000, 43, -1000, -1000, 31, 43, -36, -1000, 56, 60, + -1000, -255, -1000, 43, 43, -1000, -269, -1000, -1000, -1000, + 13, 34, -1000, 43, -1000, 13, -1000, -1000, -1000, -1000, + -193, 19, 19, -53, 59, -1000, -1000, -8, 58, 43, + -1000, -1000, -1000, -1000, -226, -1000, -218, -223, -1000, 43, + -1000, -269, 26, -1000, -1000, -1000, 13, -253, 43, -1000, + -1000, -1000, -42, -1000, 43, 43, -1000, 34, -1000, 13, + -1000, -1000, -1000, -1000, -193, -1000 }; +int yypgo[]={ + + 0, 195, 50, 96, 71, 135, 194, 193, 192, 190, + 189, 187, 136, 186, 184, 82, 54, 183, 182, 180, + 172, 170, 59, 168, 167, 166, 63, 70, 164, 162, + 137, 161, 160, 159, 158, 157, 156, 155, 154, 153, + 152, 150, 149, 148, 69, 147, 144, 65, 143, 142, + 140, 76, 138 }; +int yyr1[]={ + + 0, 1, 14, 1, 1, 1, 19, 21, 17, 23, + 23, 24, 15, 16, 16, 25, 28, 25, 29, 25, + 25, 25, 25, 27, 27, 27, 32, 33, 22, 34, + 35, 34, 2, 26, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 36, 3, + 3, 3, 3, 3, 3, 3, 3, 38, 3, 39, + 3, 37, 37, 41, 30, 40, 4, 4, 5, 42, + 5, 20, 20, 43, 43, 13, 13, 7, 7, 8, + 8, 9, 9, 45, 44, 10, 10, 46, 11, 48, + 11, 47, 6, 6, 12, 49, 12, 50, 12, 31, + 31, 51, 52, 51, 18 }; +int yyr2[]={ + + 0, 0, 1, 9, 4, 4, 1, 1, 19, 0, + 6, 1, 4, 0, 2, 17, 1, 17, 1, 13, + 7, 3, 4, 0, 4, 15, 1, 1, 9, 0, + 1, 9, 1, 3, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 5, 5, 1, 9, + 9, 3, 3, 3, 3, 3, 5, 1, 11, 1, + 11, 1, 2, 1, 11, 3, 1, 3, 3, 1, + 9, 0, 2, 3, 7, 1, 3, 7, 7, 1, + 3, 3, 7, 1, 9, 1, 3, 1, 5, 1, + 9, 3, 3, 7, 3, 1, 11, 1, 9, 5, + 9, 1, 1, 6, 3 }; +int yychk[]={ + + -1000, -1, -14, -17, -18, 270, 273, -15, -24, 271, + -16, 59, -25, 258, 262, 264, -6, -30, 268, -12, + -40, 271, -19, -26, -3, 40, 43, 45, 64, -12, + 269, 272, 257, -30, 274, -28, -29, 61, 44, -31, + 271, -49, -50, -41, 40, 259, 61, 60, 62, 277, + 278, 279, 43, 45, 42, 47, 280, 275, 276, -3, + -26, -26, -26, -36, 40, -26, -26, -22, -32, -5, + -3, -12, 44, -51, 61, 91, 46, 40, -20, -43, + 271, -2, -26, -26, -26, -26, -26, -26, -26, -26, + -26, -26, -26, -2, -2, 41, -13, 271, -37, -26, + 263, 265, -23, 44, 271, -52, -26, 271, -4, -5, + 41, 44, -22, -38, -39, -7, 123, 91, 41, -2, + -26, -15, -33, -42, -51, -26, 93, 41, -21, 271, + -2, -26, -26, -8, -9, -44, 271, -10, -11, -46, + -22, -2, -16, -34, -35, -3, -22, -27, 260, 261, + 125, 44, -45, 93, 44, -47, -26, -2, 267, 266, + 266, -22, -26, -44, 61, -48, 266, -4, 259, -26, + -47, -16, -2, -22, -2, -27 }; +int yydef[]={ + + 1, -2, 11, 4, 5, 0, 104, 13, 0, 6, + 3, 14, 12, 0, 16, 18, 0, 21, 0, -2, + 63, 94, 0, 0, 33, 0, 0, 0, 48, -2, + 52, 53, 54, 55, 0, 0, 26, 0, 0, 22, + 101, 0, 0, 0, 71, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 32, 32, 33, + 0, 46, 47, 75, 61, 56, 0, 0, 9, 20, + -2, -2, 0, 99, 102, 0, 0, 66, 0, 72, + 73, 26, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 57, 59, 34, 0, 76, 0, 62, + 32, 0, -2, 69, 101, 0, 0, 98, 0, 67, + 7, 0, 32, 0, 0, 49, 79, -2, 50, 26, + 32, 13, -2, 0, 100, 103, 96, 64, 26, 74, + 23, 58, 60, 0, 80, 81, 83, 0, 86, 0, + 32, 19, 10, 28, 0, -2, 0, 0, 26, 0, + 77, 0, 0, 78, 89, 88, 91, 0, 66, 8, + 15, 24, 0, 82, 0, 0, 17, 13, 32, 84, + 90, 31, 26, 32, 23, 25 }; +typedef struct { char *t_name; int t_val; } yytoktype; +#ifndef YYDEBUG +# define YYDEBUG 0 /* don't allow debugging */ +#endif + +#if YYDEBUG + +yytoktype yytoks[] = +{ + "NIL", 257, + "IF", 258, + "THEN", 259, + "ELSE", 260, + "ELSEIF", 261, + "WHILE", 262, + "DO", 263, + "REPEAT", 264, + "UNTIL", 265, + "END", 266, + "RETURN", 267, + "LOCAL", 268, + "NUMBER", 269, + "FUNCTION", 270, + "NAME", 271, + "STRING", 272, + "DEBUG", 273, + "NOT", 274, + "AND", 275, + "OR", 276, + "=", 61, + "NE", 277, + ">", 62, + "<", 60, + "LE", 278, + "GE", 279, + "CONC", 280, + "+", 43, + "-", 45, + "*", 42, + "/", 47, + "%", 37, + "UNARY", 281, + "-unknown-", -1 /* ends search */ +}; + +char * yyreds[] = +{ + "-no such reduction-", + "functionlist : /* empty */", + "functionlist : functionlist", + "functionlist : functionlist stat sc", + "functionlist : functionlist function", + "functionlist : functionlist setdebug", + "function : FUNCTION NAME", + "function : FUNCTION NAME '(' parlist ')'", + "function : FUNCTION NAME '(' parlist ')' block END", + "statlist : /* empty */", + "statlist : statlist stat sc", + "stat : /* empty */", + "stat : stat1", + "sc : /* empty */", + "sc : ';'", + "stat1 : IF expr1 THEN PrepJump block PrepJump elsepart END", + "stat1 : WHILE", + "stat1 : WHILE expr1 DO PrepJump block PrepJump END", + "stat1 : REPEAT", + "stat1 : REPEAT block UNTIL expr1 PrepJump", + "stat1 : varlist1 '=' exprlist1", + "stat1 : functioncall", + "stat1 : LOCAL declist", + "elsepart : /* empty */", + "elsepart : ELSE block", + "elsepart : ELSEIF expr1 THEN PrepJump block PrepJump elsepart", + "block : /* empty */", + "block : statlist", + "block : statlist ret", + "ret : /* empty */", + "ret : /* empty */", + "ret : RETURN exprlist sc", + "PrepJump : /* empty */", + "expr1 : expr", + "expr : '(' expr ')'", + "expr : expr1 '=' expr1", + "expr : expr1 '<' expr1", + "expr : expr1 '>' expr1", + "expr : expr1 NE expr1", + "expr : expr1 LE expr1", + "expr : expr1 GE expr1", + "expr : expr1 '+' expr1", + "expr : expr1 '-' expr1", + "expr : expr1 '*' expr1", + "expr : expr1 '/' expr1", + "expr : expr1 CONC expr1", + "expr : '+' expr1", + "expr : '-' expr1", + "expr : '@'", + "expr : '@' objectname fieldlist", + "expr : '@' '(' dimension ')'", + "expr : var", + "expr : NUMBER", + "expr : STRING", + "expr : NIL", + "expr : functioncall", + "expr : NOT expr1", + "expr : expr1 AND PrepJump", + "expr : expr1 AND PrepJump expr1", + "expr : expr1 OR PrepJump", + "expr : expr1 OR PrepJump expr1", + "dimension : /* empty */", + "dimension : expr1", + "functioncall : functionvalue", + "functioncall : functionvalue '(' exprlist ')'", + "functionvalue : var", + "exprlist : /* empty */", + "exprlist : exprlist1", + "exprlist1 : expr", + "exprlist1 : exprlist1 ','", + "exprlist1 : exprlist1 ',' expr", + "parlist : /* empty */", + "parlist : parlist1", + "parlist1 : NAME", + "parlist1 : parlist1 ',' NAME", + "objectname : /* empty */", + "objectname : NAME", + "fieldlist : '{' ffieldlist '}'", + "fieldlist : '[' lfieldlist ']'", + "ffieldlist : /* empty */", + "ffieldlist : ffieldlist1", + "ffieldlist1 : ffield", + "ffieldlist1 : ffieldlist1 ',' ffield", + "ffield : NAME", + "ffield : NAME '=' expr1", + "lfieldlist : /* empty */", + "lfieldlist : lfieldlist1", + "lfieldlist1 : /* empty */", + "lfieldlist1 : lfield", + "lfieldlist1 : lfieldlist1 ','", + "lfieldlist1 : lfieldlist1 ',' lfield", + "lfield : expr1", + "varlist1 : var", + "varlist1 : varlist1 ',' var", + "var : NAME", + "var : var", + "var : var '[' expr1 ']'", + "var : var", + "var : var '.' NAME", + "declist : NAME init", + "declist : declist ',' NAME init", + "init : /* empty */", + "init : '='", + "init : '=' expr1", + "setdebug : DEBUG", +}; +#endif /* YYDEBUG */ +#line 1 "/usr/lib/yaccpar" +/* @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10 */ + +/* +** Skeleton parser driver for yacc output +*/ + +/* +** yacc user known macros and defines +*/ +#define YYERROR goto yyerrlab +#define YYACCEPT { free(yys); free(yyv); return(0); } +#define YYABORT { free(yys); free(yyv); return(1); } +#define YYBACKUP( newtoken, newvalue )\ +{\ + if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ + {\ + yyerror( "syntax error - cannot backup" );\ + goto yyerrlab;\ + }\ + yychar = newtoken;\ + yystate = *yyps;\ + yylval = newvalue;\ + goto yynewstate;\ +} +#define YYRECOVERING() (!!yyerrflag) +#ifndef YYDEBUG +# define YYDEBUG 1 /* make debugging available */ +#endif + +/* +** user known globals +*/ +int yydebug; /* set to 1 to get debugging */ + +/* +** driver internal defines +*/ +#define YYFLAG (-1000) + +/* +** static variables used by the parser +*/ +static YYSTYPE *yyv; /* value stack */ +static int *yys; /* state stack */ + +static YYSTYPE *yypv; /* top of value stack */ +static int *yyps; /* top of state stack */ + +static int yystate; /* current state */ +static int yytmp; /* extra var (lasts between blocks) */ + +int yynerrs; /* number of errors */ + +int yyerrflag; /* error recovery flag */ +int yychar; /* current input token number */ + + +/* +** yyparse - return 0 if worked, 1 if syntax error not recovered from +*/ +int +yyparse() +{ + register YYSTYPE *yypvt; /* top of value stack for $vars */ + unsigned yymaxdepth = YYMAXDEPTH; + + /* + ** Initialize externals - yyparse may be called more than once + */ + yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE)); + yys = (int*)malloc(yymaxdepth*sizeof(int)); + if (!yyv || !yys) + { + yyerror( "out of memory" ); + return(1); + } + yypv = &yyv[-1]; + yyps = &yys[-1]; + yystate = 0; + yytmp = 0; + yynerrs = 0; + yyerrflag = 0; + yychar = -1; + + goto yystack; + { + register YYSTYPE *yy_pv; /* top of value stack */ + register int *yy_ps; /* top of state stack */ + register int yy_state; /* current state */ + register int yy_n; /* internal state number info */ + + /* + ** get globals into registers. + ** branch to here only if YYBACKUP was called. + */ + yynewstate: + yy_pv = yypv; + yy_ps = yyps; + yy_state = yystate; + goto yy_newstate; + + /* + ** get globals into registers. + ** either we just started, or we just finished a reduction + */ + yystack: + yy_pv = yypv; + yy_ps = yyps; + yy_state = yystate; + + /* + ** top of for (;;) loop while no reductions done + */ + yy_stack: + /* + ** put a state and value onto the stacks + */ +#if YYDEBUG + /* + ** if debugging, look up token value in list of value vs. + ** name pairs. 0 and negative (-1) are special values. + ** Note: linear search is used since time is not a real + ** consideration while debugging. + */ + if ( yydebug ) + { + register int yy_i; + + (void)printf( "State %d, token ", yy_state ); + if ( yychar == 0 ) + (void)printf( "end-of-file\n" ); + else if ( yychar < 0 ) + (void)printf( "-none-\n" ); + else + { + for ( yy_i = 0; yytoks[yy_i].t_val >= 0; + yy_i++ ) + { + if ( yytoks[yy_i].t_val == yychar ) + break; + } + (void)printf( "%s\n", yytoks[yy_i].t_name ); + } + } +#endif /* YYDEBUG */ + if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ + { + /* + ** reallocate and recover. Note that pointers + ** have to be reset, or bad things will happen + */ + int yyps_index = (yy_ps - yys); + int yypv_index = (yy_pv - yyv); + int yypvt_index = (yypvt - yyv); + yymaxdepth += YYMAXDEPTH; + yyv = (YYSTYPE*)realloc((char*)yyv, + yymaxdepth * sizeof(YYSTYPE)); + yys = (int*)realloc((char*)yys, + yymaxdepth * sizeof(int)); + if (!yyv || !yys) + { + yyerror( "yacc stack overflow" ); + return(1); + } + yy_ps = yys + yyps_index; + yy_pv = yyv + yypv_index; + yypvt = yyv + yypvt_index; + } + *yy_ps = yy_state; + *++yy_pv = yyval; + + /* + ** we have a new state - find out what to do + */ + yy_newstate: + if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) + goto yydefault; /* simple state */ +#if YYDEBUG + /* + ** if debugging, need to mark whether new token grabbed + */ + yytmp = yychar < 0; +#endif + if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) + yychar = 0; /* reached EOF */ +#if YYDEBUG + if ( yydebug && yytmp ) + { + register int yy_i; + + (void)printf( "Received token " ); + if ( yychar == 0 ) + (void)printf( "end-of-file\n" ); + else if ( yychar < 0 ) + (void)printf( "-none-\n" ); + else + { + for ( yy_i = 0; yytoks[yy_i].t_val >= 0; + yy_i++ ) + { + if ( yytoks[yy_i].t_val == yychar ) + break; + } + (void)printf( "%s\n", yytoks[yy_i].t_name ); + } + } +#endif /* YYDEBUG */ + if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) + goto yydefault; + if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ + { + yychar = -1; + yyval = yylval; + yy_state = yy_n; + if ( yyerrflag > 0 ) + yyerrflag--; + goto yy_stack; + } + + yydefault: + if ( ( yy_n = yydef[ yy_state ] ) == -2 ) + { +#if YYDEBUG + yytmp = yychar < 0; +#endif + if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) + yychar = 0; /* reached EOF */ +#if YYDEBUG + if ( yydebug && yytmp ) + { + register int yy_i; + + (void)printf( "Received token " ); + if ( yychar == 0 ) + (void)printf( "end-of-file\n" ); + else if ( yychar < 0 ) + (void)printf( "-none-\n" ); + else + { + for ( yy_i = 0; + yytoks[yy_i].t_val >= 0; + yy_i++ ) + { + if ( yytoks[yy_i].t_val + == yychar ) + { + break; + } + } + (void)printf( "%s\n", yytoks[yy_i].t_name ); + } + } +#endif /* YYDEBUG */ + /* + ** look through exception table + */ + { + register int *yyxi = yyexca; + + while ( ( *yyxi != -1 ) || + ( yyxi[1] != yy_state ) ) + { + yyxi += 2; + } + while ( ( *(yyxi += 2) >= 0 ) && + ( *yyxi != yychar ) ) + ; + if ( ( yy_n = yyxi[1] ) < 0 ) + YYACCEPT; + } + } + + /* + ** check for syntax error + */ + if ( yy_n == 0 ) /* have an error */ + { + /* no worry about speed here! */ + switch ( yyerrflag ) + { + case 0: /* new error */ + yyerror( "syntax error" ); + goto skip_init; + yyerrlab: + /* + ** get globals into registers. + ** we have a user generated syntax type error + */ + yy_pv = yypv; + yy_ps = yyps; + yy_state = yystate; + yynerrs++; + skip_init: + case 1: + case 2: /* incompletely recovered error */ + /* try again... */ + yyerrflag = 3; + /* + ** find state where "error" is a legal + ** shift action + */ + while ( yy_ps >= yys ) + { + yy_n = yypact[ *yy_ps ] + YYERRCODE; + if ( yy_n >= 0 && yy_n < YYLAST && + yychk[yyact[yy_n]] == YYERRCODE) { + /* + ** simulate shift of "error" + */ + yy_state = yyact[ yy_n ]; + goto yy_stack; + } + /* + ** current state has no shift on + ** "error", pop stack + */ +#if YYDEBUG +# define _POP_ "Error recovery pops state %d, uncovers state %d\n" + if ( yydebug ) + (void)printf( _POP_, *yy_ps, + yy_ps[-1] ); +# undef _POP_ +#endif + yy_ps--; + yy_pv--; + } + /* + ** there is no state on stack with "error" as + ** a valid shift. give up. + */ + YYABORT; + case 3: /* no shift yet; eat a token */ +#if YYDEBUG + /* + ** if debugging, look up token in list of + ** pairs. 0 and negative shouldn't occur, + ** but since timing doesn't matter when + ** debugging, it doesn't hurt to leave the + ** tests here. + */ + if ( yydebug ) + { + register int yy_i; + + (void)printf( "Error recovery discards " ); + if ( yychar == 0 ) + (void)printf( "token end-of-file\n" ); + else if ( yychar < 0 ) + (void)printf( "token -none-\n" ); + else + { + for ( yy_i = 0; + yytoks[yy_i].t_val >= 0; + yy_i++ ) + { + if ( yytoks[yy_i].t_val + == yychar ) + { + break; + } + } + (void)printf( "token %s\n", + yytoks[yy_i].t_name ); + } + } +#endif /* YYDEBUG */ + if ( yychar == 0 ) /* reached EOF. quit */ + YYABORT; + yychar = -1; + goto yy_newstate; + } + }/* end if ( yy_n == 0 ) */ + /* + ** reduction by production yy_n + ** put stack tops, etc. so things right after switch + */ +#if YYDEBUG + /* + ** if debugging, print the string that is the user's + ** specification of the reduction which is just about + ** to be done. + */ + if ( yydebug ) + (void)printf( "Reduce by (%d) \"%s\"\n", + yy_n, yyreds[ yy_n ] ); +#endif + yytmp = yy_n; /* value to switch over */ + yypvt = yy_pv; /* $vars top of value stack */ + /* + ** Look in goto table for next state + ** Sorry about using yy_state here as temporary + ** register variable, but why not, if it works... + ** If yyr2[ yy_n ] doesn't have the low order bit + ** set, then there is no action to be done for + ** this reduction. So, no saving & unsaving of + ** registers done. The only difference between the + ** code just after the if and the body of the if is + ** the goto yy_stack in the body. This way the test + ** can be made before the choice of what to do is needed. + */ + { + /* length of production doubled with extra bit */ + register int yy_len = yyr2[ yy_n ]; + + if ( !( yy_len & 01 ) ) + { + yy_len >>= 1; + yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ + yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + + *( yy_ps -= yy_len ) + 1; + if ( yy_state >= YYLAST || + yychk[ yy_state = + yyact[ yy_state ] ] != -yy_n ) + { + yy_state = yyact[ yypgo[ yy_n ] ]; + } + goto yy_stack; + } + yy_len >>= 1; + yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ + yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + + *( yy_ps -= yy_len ) + 1; + if ( yy_state >= YYLAST || + yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) + { + yy_state = yyact[ yypgo[ yy_n ] ]; + } + } + /* save until reenter driver code */ + yystate = yy_state; + yyps = yy_ps; + yypv = yy_pv; + } + /* + ** code supplied by user is placed in this switch + */ + switch( yytmp ) + { + +case 2: +# line 179 "lua.stx" +{pc=basepc=maincode; nlocalvar=0;} break; +case 3: +# line 179 "lua.stx" +{maincode=pc;} break; +case 6: +# line 184 "lua.stx" +{pc=basepc=code; nlocalvar=0;} break; +case 7: +# line 185 "lua.stx" +{ + if (lua_debug) + { + align(Word); + code_byte(SETFUNCTION); + code_word(yypvt[-5].vWord); + code_word(yypvt[-4].vWord); + } + lua_codeadjust (0); + } break; +case 8: +# line 197 "lua.stx" +{ + if (lua_debug) code_byte(RESET); + code_byte(RETCODE); code_byte(nlocalvar); + s_tag(yypvt[-7].vWord) = T_FUNCTION; + s_bvalue(yypvt[-7].vWord) = calloc (pc-code, sizeof(Byte)); + memcpy (s_bvalue(yypvt[-7].vWord), code, (pc-code)*sizeof(Byte)); + } break; +case 11: +# line 210 "lua.stx" +{ + ntemp = 0; + if (lua_debug) + { + align(Word); code_byte(SETLINE); code_word(lua_linenumber); + } + } break; +case 15: +# line 223 "lua.stx" +{ + { + Byte *elseinit = yypvt[-2].pByte + sizeof(Word)+1; + if (pc - elseinit == 0) /* no else */ + { + pc -= sizeof(Word)+1; + /* if (*(pc-1) == NOP) --pc; */ + elseinit = pc; + } + else + { + *(yypvt[-2].pByte) = JMP; + *((Word *)(yypvt[-2].pByte+1)) = pc - elseinit; + } + *(yypvt[-4].pByte) = IFFJMP; + *((Word *)(yypvt[-4].pByte+1)) = elseinit - (yypvt[-4].pByte + sizeof(Word)+1); + } + } break; +case 16: +# line 242 "lua.stx" +{yyval.pByte = pc;} break; +case 17: +# line 244 "lua.stx" +{ + *(yypvt[-3].pByte) = IFFJMP; + *((Word *)(yypvt[-3].pByte+1)) = pc - (yypvt[-3].pByte + sizeof(Word)+1); + + *(yypvt[-1].pByte) = UPJMP; + *((Word *)(yypvt[-1].pByte+1)) = pc - yypvt[-6].pByte; + } break; +case 18: +# line 252 "lua.stx" +{yyval.pByte = pc;} break; +case 19: +# line 254 "lua.stx" +{ + *(yypvt[-0].pByte) = IFFUPJMP; + *((Word *)(yypvt[-0].pByte+1)) = pc - yypvt[-4].pByte; + } break; +case 20: +# line 261 "lua.stx" +{ + { + int i; + if (yypvt[-0].vInt == 0 || nvarbuffer != ntemp - yypvt[-2].vInt * 2) + lua_codeadjust (yypvt[-2].vInt * 2 + nvarbuffer); + for (i=nvarbuffer-1; i>=0; i--) + lua_codestore (i); + if (yypvt[-2].vInt > 1 || (yypvt[-2].vInt == 1 && varbuffer[0] != 0)) + lua_codeadjust (0); + } + } break; +case 21: +# line 272 "lua.stx" +{ lua_codeadjust (0); } break; +case 25: +# line 279 "lua.stx" +{ + { + Byte *elseinit = yypvt[-1].pByte + sizeof(Word)+1; + if (pc - elseinit == 0) /* no else */ + { + pc -= sizeof(Word)+1; + /* if (*(pc-1) == NOP) --pc; */ + elseinit = pc; + } + else + { + *(yypvt[-1].pByte) = JMP; + *((Word *)(yypvt[-1].pByte+1)) = pc - elseinit; + } + *(yypvt[-3].pByte) = IFFJMP; + *((Word *)(yypvt[-3].pByte+1)) = elseinit - (yypvt[-3].pByte + sizeof(Word)+1); + } + } break; +case 26: +# line 299 "lua.stx" +{yyval.vInt = nlocalvar;} break; +case 27: +# line 299 "lua.stx" +{ntemp = 0;} break; +case 28: +# line 300 "lua.stx" +{ + if (nlocalvar != yypvt[-3].vInt) + { + nlocalvar = yypvt[-3].vInt; + lua_codeadjust (0); + } + } break; +case 30: +# line 310 "lua.stx" +{ if (lua_debug){align(Word);code_byte(SETLINE);code_word(lua_linenumber);}} break; +case 31: +# line 312 "lua.stx" +{ + if (lua_debug) code_byte(RESET); + code_byte(RETCODE); code_byte(nlocalvar); + } break; +case 32: +# line 319 "lua.stx" +{ + align(Word); + yyval.pByte = pc; + code_byte(0); /* open space */ + code_word (0); + } break; +case 33: +# line 326 "lua.stx" +{ if (yypvt[-0].vInt == 0) {lua_codeadjust (ntemp+1); incr_ntemp();}} break; +case 34: +# line 329 "lua.stx" +{ yyval.vInt = yypvt[-1].vInt; } break; +case 35: +# line 330 "lua.stx" +{ code_byte(EQOP); yyval.vInt = 1; ntemp--;} break; +case 36: +# line 331 "lua.stx" +{ code_byte(LTOP); yyval.vInt = 1; ntemp--;} break; +case 37: +# line 332 "lua.stx" +{ code_byte(LEOP); code_byte(NOTOP); yyval.vInt = 1; ntemp--;} break; +case 38: +# line 333 "lua.stx" +{ code_byte(EQOP); code_byte(NOTOP); yyval.vInt = 1; ntemp--;} break; +case 39: +# line 334 "lua.stx" +{ code_byte(LEOP); yyval.vInt = 1; ntemp--;} break; +case 40: +# line 335 "lua.stx" +{ code_byte(LTOP); code_byte(NOTOP); yyval.vInt = 1; ntemp--;} break; +case 41: +# line 336 "lua.stx" +{ code_byte(ADDOP); yyval.vInt = 1; ntemp--;} break; +case 42: +# line 337 "lua.stx" +{ code_byte(SUBOP); yyval.vInt = 1; ntemp--;} break; +case 43: +# line 338 "lua.stx" +{ code_byte(MULTOP); yyval.vInt = 1; ntemp--;} break; +case 44: +# line 339 "lua.stx" +{ code_byte(DIVOP); yyval.vInt = 1; ntemp--;} break; +case 45: +# line 340 "lua.stx" +{ code_byte(CONCOP); yyval.vInt = 1; ntemp--;} break; +case 46: +# line 341 "lua.stx" +{ yyval.vInt = 1; } break; +case 47: +# line 342 "lua.stx" +{ code_byte(MINUSOP); yyval.vInt = 1;} break; +case 48: +# line 344 "lua.stx" +{ + code_byte(PUSHBYTE); + yyval.pByte = pc; code_byte(0); + incr_ntemp(); + code_byte(CREATEARRAY); + } break; +case 49: +# line 351 "lua.stx" +{ + *(yypvt[-2].pByte) = yypvt[-0].vInt; + if (yypvt[-1].vLong < 0) /* there is no function to be called */ + { + yyval.vInt = 1; + } + else + { + lua_pushvar (yypvt[-1].vLong+1); + code_byte(PUSHMARK); + incr_ntemp(); + code_byte(PUSHOBJECT); + incr_ntemp(); + code_byte(CALLFUNC); + ntemp -= 4; + yyval.vInt = 0; + if (lua_debug) + { + align(Word); code_byte(SETLINE); code_word(lua_linenumber); + } + } + } break; +case 50: +# line 374 "lua.stx" +{ + code_byte(CREATEARRAY); + yyval.vInt = 1; + } break; +case 51: +# line 378 "lua.stx" +{ lua_pushvar (yypvt[-0].vLong); yyval.vInt = 1;} break; +case 52: +# line 379 "lua.stx" +{ code_number(yypvt[-0].vFloat); yyval.vInt = 1; } break; +case 53: +# line 381 "lua.stx" +{ + align(Word); + code_byte(PUSHSTRING); + code_word(yypvt[-0].vWord); + yyval.vInt = 1; + incr_ntemp(); + } break; +case 54: +# line 388 "lua.stx" +{code_byte(PUSHNIL); yyval.vInt = 1; incr_ntemp();} break; +case 55: +# line 390 "lua.stx" +{ + yyval.vInt = 0; + if (lua_debug) + { + align(Word); code_byte(SETLINE); code_word(lua_linenumber); + } + } break; +case 56: +# line 397 "lua.stx" +{ code_byte(NOTOP); yyval.vInt = 1;} break; +case 57: +# line 398 "lua.stx" +{code_byte(POP); ntemp--;} break; +case 58: +# line 399 "lua.stx" +{ + *(yypvt[-2].pByte) = ONFJMP; + *((Word *)(yypvt[-2].pByte+1)) = pc - (yypvt[-2].pByte + sizeof(Word)+1); + yyval.vInt = 1; + } break; +case 59: +# line 404 "lua.stx" +{code_byte(POP); ntemp--;} break; +case 60: +# line 405 "lua.stx" +{ + *(yypvt[-2].pByte) = ONTJMP; + *((Word *)(yypvt[-2].pByte+1)) = pc - (yypvt[-2].pByte + sizeof(Word)+1); + yyval.vInt = 1; + } break; +case 61: +# line 412 "lua.stx" +{ code_byte(PUSHNIL); incr_ntemp();} break; +case 63: +# line 416 "lua.stx" +{code_byte(PUSHMARK); yyval.vInt = ntemp; incr_ntemp();} break; +case 64: +# line 417 "lua.stx" +{ code_byte(CALLFUNC); ntemp = yypvt[-3].vInt-1;} break; +case 65: +# line 419 "lua.stx" +{lua_pushvar (yypvt[-0].vLong); } break; +case 66: +# line 422 "lua.stx" +{ yyval.vInt = 1; } break; +case 67: +# line 423 "lua.stx" +{ yyval.vInt = yypvt[-0].vInt; } break; +case 68: +# line 426 "lua.stx" +{ yyval.vInt = yypvt[-0].vInt; } break; +case 69: +# line 427 "lua.stx" +{if (!yypvt[-1].vInt){lua_codeadjust (ntemp+1); incr_ntemp();}} break; +case 70: +# line 428 "lua.stx" +{yyval.vInt = yypvt[-0].vInt;} break; +case 73: +# line 435 "lua.stx" +{localvar[nlocalvar]=yypvt[-0].vWord; incr_nlocalvar();} break; +case 74: +# line 436 "lua.stx" +{localvar[nlocalvar]=yypvt[-0].vWord; incr_nlocalvar();} break; +case 75: +# line 439 "lua.stx" +{yyval.vLong=-1;} break; +case 76: +# line 440 "lua.stx" +{yyval.vLong=yypvt[-0].vWord;} break; +case 77: +# line 443 "lua.stx" +{ yyval.vInt = yypvt[-1].vInt; } break; +case 78: +# line 444 "lua.stx" +{ yyval.vInt = yypvt[-1].vInt; } break; +case 79: +# line 447 "lua.stx" +{ yyval.vInt = 0; } break; +case 80: +# line 448 "lua.stx" +{ yyval.vInt = yypvt[-0].vInt; } break; +case 81: +# line 451 "lua.stx" +{yyval.vInt=1;} break; +case 82: +# line 452 "lua.stx" +{yyval.vInt=yypvt[-2].vInt+1;} break; +case 83: +# line 456 "lua.stx" +{ + align(Word); + code_byte(PUSHSTRING); + code_word(lua_findconstant (s_name(yypvt[-0].vWord))); + incr_ntemp(); + } break; +case 84: +# line 463 "lua.stx" +{ + code_byte(STOREFIELD); + ntemp-=2; + } break; +case 85: +# line 469 "lua.stx" +{ yyval.vInt = 0; } break; +case 86: +# line 470 "lua.stx" +{ yyval.vInt = yypvt[-0].vInt; } break; +case 87: +# line 473 "lua.stx" +{ code_number(1); } break; +case 88: +# line 473 "lua.stx" +{yyval.vInt=1;} break; +case 89: +# line 474 "lua.stx" +{ code_number(yypvt[-1].vInt+1); } break; +case 90: +# line 475 "lua.stx" +{yyval.vInt=yypvt[-3].vInt+1;} break; +case 91: +# line 479 "lua.stx" +{ + code_byte(STOREFIELD); + ntemp-=2; + } break; +case 92: +# line 486 "lua.stx" +{ + nvarbuffer = 0; + varbuffer[nvarbuffer] = yypvt[-0].vLong; incr_nvarbuffer(); + yyval.vInt = (yypvt[-0].vLong == 0) ? 1 : 0; + } break; +case 93: +# line 492 "lua.stx" +{ + varbuffer[nvarbuffer] = yypvt[-0].vLong; incr_nvarbuffer(); + yyval.vInt = (yypvt[-0].vLong == 0) ? yypvt[-2].vInt + 1 : yypvt[-2].vInt; + } break; +case 94: +# line 499 "lua.stx" +{ + int local = lua_localname (yypvt[-0].vWord); + if (local == -1) /* global var */ + yyval.vLong = yypvt[-0].vWord + 1; /* return positive value */ + else + yyval.vLong = -(local+1); /* return negative value */ + } break; +case 95: +# line 507 "lua.stx" +{lua_pushvar (yypvt[-0].vLong);} break; +case 96: +# line 508 "lua.stx" +{ + yyval.vLong = 0; /* indexed variable */ + } break; +case 97: +# line 511 "lua.stx" +{lua_pushvar (yypvt[-0].vLong);} break; +case 98: +# line 512 "lua.stx" +{ + align(Word); + code_byte(PUSHSTRING); + code_word(lua_findconstant (s_name(yypvt[-0].vWord))); incr_ntemp(); + yyval.vLong = 0; /* indexed variable */ + } break; +case 99: +# line 520 "lua.stx" +{localvar[nlocalvar]=yypvt[-1].vWord; incr_nlocalvar();} break; +case 100: +# line 521 "lua.stx" +{localvar[nlocalvar]=yypvt[-1].vWord; incr_nlocalvar();} break; +case 101: +# line 524 "lua.stx" +{ code_byte(PUSHNIL); } break; +case 102: +# line 525 "lua.stx" +{ntemp = 0;} break; +case 104: +# line 528 "lua.stx" +{lua_debug = yypvt[-0].vInt;} break; + } + goto yystack; /* reset registers in driver code */ +} |