summaryrefslogtreecommitdiff
path: root/src/parser.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/parser.c')
-rw-r--r--src/parser.c1901
1 files changed, 1901 insertions, 0 deletions
diff --git a/src/parser.c b/src/parser.c
new file mode 100644
index 00000000..47b77fb0
--- /dev/null
+++ b/src/parser.c
@@ -0,0 +1,1901 @@
+#if defined (__cplusplus) || defined (c_plusplus)
+#include <c_varieties.h>
+#ifdef __EXTERN_C__
+ EXTERN_FUNCTION ( extern int yylex, ());
+#else
+ extern int yylex();
+#endif
+ extern void yyerror(char *);
+ extern int yyparse();
+#endif
+
+#include <malloc.h>
+
+# line 2 "lua.stx"
+
+char *rcs_luastx = "$Id: lua.stx,v 3.17 1995/01/13 22:11:12 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"
+
+/* 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 */
+
+static Word localvar[STACKGAP]; /* 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 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 (Byte *b)
+{
+ CodeCode code;
+ code.b = b;
+ 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 < STACKGAP-1)
+ fields[nfields++] = name;
+ else
+ lua_error ("too many fields in a constructor");
+}
+
+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_nlocalvar (int n)
+{
+ if (MAX_TEMPS+nlocalvar+MAXVAR+n < STACKGAP)
+ nlocalvar += n;
+ else
+ lua_error ("too many local variables");
+}
+
+static void incr_nvarbuffer (void)
+{
+ if (nvarbuffer < MAXVAR-1)
+ nvarbuffer++;
+ 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 init_function (TreeNode *func)
+{
+ if (funcCode == NULL) /* first function */
+ {
+ funcCode = newvector(CODE_BLOCK, Byte);
+ maxcode = CODE_BLOCK;
+ }
+ pc=0; basepc=funcCode; maxcurr=maxcode;
+ nlocalvar=0;
+ if (lua_debug)
+ {
+ code_byte(SETFUNCTION);
+ code_code((Byte *)luaI_strdup(lua_file[lua_nfile-1]));
+ code_word(luaI_findconstant(func));
+ }
+}
+
+static void codereturn (void)
+{
+ if (lua_debug) code_byte(RESET);
+ if (nlocalvar == 0)
+ code_byte(RETCODE0);
+ else
+ {
+ code_byte(RETCODE);
+ code_byte(nlocalvar);
+ }
+}
+
+static void codedebugline (void)
+{
+ if (lua_debug)
+ {
+ code_byte(SETLINE);
+ code_word(lua_linenumber);
+ }
+}
+
+static void adjust_mult_assign (int vars, int exps, int temps)
+{
+ if (exps < 0)
+ {
+ int r = vars - (-exps-1);
+ if (r >= 0)
+ code_byte(r);
+ else
+ {
+ code_byte(0);
+ lua_codeadjust(temps);
+ }
+ }
+ else if (vars != exps)
+ lua_codeadjust(temps);
+}
+
+static void lua_codestore (int i)
+{
+ if (varbuffer[i] > 0) /* global var */
+ {
+ 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);
+ }
+ }
+}
+
+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));
+}
+
+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_filename());
+ lua_error (msg);
+}
+
+
+/*
+** Parse LUA code.
+*/
+void lua_parse (Byte **code)
+{
+ initcode = code;
+ *initcode = newvector(CODE_BLOCK, Byte);
+ maincode = 0;
+ maxmain = CODE_BLOCK;
+ if (yyparse ()) lua_error("parse error");
+ (*initcode)[maincode++] = RETCODE0;
+#if LISTING
+{ static void PrintCode (Byte *c, Byte *end);
+ PrintCode(*initcode,*initcode+maincode); }
+#endif
+}
+
+
+
+# line 365 "lua.stx"
+typedef union
+{
+ int vInt;
+ float vFloat;
+ char *pChar;
+ Word vWord;
+ Long vLong;
+ Byte *pByte;
+ TreeNode *pNode;
+} YYSTYPE;
+# define WRONGTOKEN 257
+# define NIL 258
+# define IF 259
+# define THEN 260
+# define ELSE 261
+# define ELSEIF 262
+# define WHILE 263
+# define DO 264
+# define REPEAT 265
+# define UNTIL 266
+# define END 267
+# define RETURN 268
+# define LOCAL 269
+# define FUNCTION 270
+# define NUMBER 271
+# define STRING 272
+# define NAME 273
+# define DEBUG 274
+# define AND 275
+# define OR 276
+# define EQ 277
+# define NE 278
+# define LE 279
+# define GE 280
+# define CONC 281
+# define UNARY 282
+# define NOT 283
+#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 737 "lua.stx"
+
+
+#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.b);
+ }
+ 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 SETFUNCTION:
+ {
+ CodeCode c1;
+ CodeWord c2;
+ int n = p-code;
+ p++;
+ get_code(c1,p);
+ get_word(c2,p);
+ printf ("%d SETFUNCTION %s %d\n", n, (char *)c1.b, c2.w);
+ }
+ break;
+ case SETLINE:
+ {
+ CodeWord c;
+ int n = p-code;
+ p++;
+ get_word(c,p);
+ printf ("%d SETLINE %d\n", n, c.w);
+ }
+ break;
+
+ case RESET: printf ("%d RESET\n", (p++)-code); break;
+ default: printf ("%d Cannot happen: code %d\n", (p++)-code, *(p-1)); break;
+ }
+ }
+}
+#endif
+
+int yyexca[] ={
+-1, 1,
+ 0, -1,
+ -2, 2,
+-1, 20,
+ 61, 91,
+ 44, 91,
+ -2, 97,
+-1, 32,
+ 40, 66,
+ 123, 66,
+ -2, 53,
+-1, 47,
+ 123, 63,
+ -2, 70,
+-1, 74,
+ 125, 79,
+ -2, 63,
+-1, 79,
+ 275, 37,
+ 276, 37,
+ 277, 37,
+ 278, 37,
+ 62, 37,
+ 60, 37,
+ 279, 37,
+ 280, 37,
+ 281, 37,
+ 43, 37,
+ 45, 37,
+ 42, 37,
+ 47, 37,
+ 94, 37,
+ -2, 72,
+-1, 80,
+ 91, 97,
+ 46, 97,
+ -2, 92,
+-1, 118,
+ 261, 33,
+ 262, 33,
+ 266, 33,
+ 267, 33,
+ -2, 16,
+-1, 133,
+ 125, 85,
+ -2, 63,
+-1, 158,
+ 123, 63,
+ -2, 70,
+-1, 159,
+ 275, 37,
+ 276, 37,
+ 277, 37,
+ 278, 37,
+ 62, 37,
+ 60, 37,
+ 279, 37,
+ 280, 37,
+ 281, 37,
+ 43, 37,
+ 45, 37,
+ 42, 37,
+ 47, 37,
+ 94, 37,
+ -2, 74,
+ };
+# define YYNPROD 103
+# define YYLAST 351
+int yyact[]={
+
+ 64, 62, 6, 63, 152, 65, 7, 64, 62, 145,
+ 63, 120, 65, 92, 64, 62, 89, 63, 57, 65,
+ 58, 64, 62, 87, 63, 57, 65, 58, 64, 62,
+ 24, 63, 57, 65, 58, 64, 62, 54, 63, 57,
+ 65, 58, 45, 10, 29, 142, 57, 171, 58, 30,
+ 29, 123, 66, 167, 14, 30, 160, 117, 15, 66,
+ 16, 162, 163, 173, 19, 131, 66, 138, 24, 28,
+ 112, 114, 130, 66, 74, 71, 8, 64, 66, 52,
+ 66, 86, 65, 51, 161, 83, 51, 66, 43, 136,
+ 27, 12, 64, 62, 26, 63, 133, 65, 49, 70,
+ 135, 119, 84, 125, 124, 42, 72, 122, 109, 32,
+ 53, 132, 79, 73, 85, 39, 75, 79, 47, 23,
+ 149, 91, 143, 31, 78, 20, 88, 38, 50, 66,
+ 11, 50, 95, 96, 97, 98, 99, 100, 101, 102,
+ 103, 104, 105, 106, 66, 48, 36, 129, 128, 158,
+ 113, 141, 94, 81, 79, 77, 18, 41, 40, 80,
+ 139, 13, 9, 118, 90, 93, 121, 25, 5, 4,
+ 3, 2, 22, 126, 111, 76, 82, 44, 134, 110,
+ 21, 46, 17, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 140, 0, 0, 0, 0,
+ 0, 0, 0, 0, 147, 148, 0, 151, 0, 150,
+ 0, 0, 153, 159, 0, 156, 0, 0, 0, 0,
+ 164, 107, 108, 0, 0, 0, 0, 0, 79, 116,
+ 170, 169, 55, 68, 69, 56, 59, 60, 61, 67,
+ 68, 69, 56, 59, 60, 61, 67, 68, 69, 56,
+ 59, 60, 61, 67, 68, 69, 56, 59, 60, 61,
+ 67, 177, 35, 56, 59, 60, 61, 67, 35, 137,
+ 127, 157, 0, 166, 67, 33, 34, 24, 0, 0,
+ 146, 33, 34, 115, 0, 0, 0, 37, 0, 0,
+ 0, 155, 0, 37, 0, 0, 0, 172, 0, 0,
+ 144, 0, 0, 0, 0, 0, 0, 165, 0, 0,
+ 0, 0, 0, 154, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 174, 0, 176, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 168, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 175 };
+int yypact[]={
+
+ -1000, -268, -1000, -1000, -1000, -1000, -230, -1000, 32, -205,
+ 36, -1000, -1000, -1000, 4, -1000, -1000, 44, -1000, -231,
+ -1000, 78, -1000, 40, -1000, 70, -236, -28, -1000, 4,
+ 4, -1000, 40, -1000, -1000, -1000, -1000, 4, -49, -1000,
+ 4, -1000, 4, -243, 41, -1000, -1000, 4, -1000, -250,
+ 4, -257, -1000, -260, -1000, -1000, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, -1000, -1000,
+ 67, -21, -16, -16, 10, -35, -209, -1000, 57, -1000,
+ -1000, 37, -1000, -262, 4, 66, 57, -1000, -42, -1000,
+ 63, 59, -1000, 70, -1000, -7, -7, -7, -7, -7,
+ -7, 35, 35, -16, -16, -16, 50, -1000, -1000, -1000,
+ -53, 52, 56, -21, -1000, 28, -1000, -1000, -223, -1000,
+ -1000, 57, -1000, -1000, -1000, -264, -1000, -1000, 4, 4,
+ -1000, -1000, -1000, 4, -1000, -269, 4, -1000, -1000, 4,
+ 32, -1000, -1000, 4, -211, -1000, -200, -14, -14, -269,
+ -21, -1000, 28, -21, -1000, -1000, -21, -1000, 4, -1000,
+ -1000, -214, -1000, -1000, 56, -220, 32, -1000, -1000, -197,
+ -1000, -1000, -1000, -1000, -1000, -1000, -200, -1000 };
+int yypgo[]={
+
+ 0, 183, 152, 69, 114, 81, 182, 181, 180, 179,
+ 177, 176, 70, 174, 115, 172, 79, 171, 76, 130,
+ 170, 169, 168, 167, 165, 164, 175, 163, 162, 161,
+ 67, 160, 75, 84, 158, 157, 146, 155, 151, 149,
+ 123, 109, 148, 147, 127, 122, 121, 65, 120, 71 };
+int yyr1[]={
+
+ 0, 1, 17, 1, 1, 1, 1, 23, 20, 24,
+ 21, 16, 27, 27, 19, 19, 28, 18, 31, 30,
+ 29, 34, 29, 35, 29, 29, 29, 29, 33, 33,
+ 33, 37, 26, 38, 39, 38, 2, 32, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 42,
+ 3, 43, 3, 44, 40, 36, 8, 8, 7, 7,
+ 4, 4, 5, 45, 5, 25, 25, 46, 46, 9,
+ 9, 9, 48, 9, 47, 47, 12, 12, 49, 13,
+ 13, 6, 6, 14, 14, 14, 15, 41, 10, 10,
+ 11, 11, 22 };
+int yyr2[]={
+
+ 0, 0, 1, 9, 4, 4, 4, 1, 9, 1,
+ 13, 11, 0, 6, 0, 2, 1, 4, 1, 4,
+ 17, 1, 17, 1, 13, 7, 3, 7, 0, 4,
+ 15, 1, 7, 0, 1, 9, 1, 3, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 5, 3, 3, 3, 3, 3, 3, 5, 1,
+ 11, 1, 11, 1, 9, 5, 3, 7, 7, 3,
+ 1, 3, 3, 1, 9, 1, 3, 3, 7, 1,
+ 5, 5, 1, 11, 0, 2, 3, 7, 7, 3,
+ 7, 3, 7, 3, 9, 7, 3, 3, 3, 7,
+ 1, 5, 3 };
+int yychk[]={
+
+ -1000, -1, -17, -20, -21, -22, 270, 274, -18, -28,
+ 273, -19, 59, -29, 259, 263, 265, -6, -36, 269,
+ -14, -8, -15, -41, 273, -23, 58, -32, -3, 40,
+ 45, -40, -41, 271, 272, 258, -36, 283, -44, -14,
+ -34, -35, 61, 44, -10, 273, -7, 40, -40, 58,
+ 91, 46, -16, 40, 273, 260, 277, 60, 62, 278,
+ 279, 280, 43, 45, 42, 47, 94, 281, 275, 276,
+ -3, -32, -32, -32, 123, -32, -26, -37, -5, -3,
+ -14, -41, -11, 44, 61, -4, -5, 273, -32, 273,
+ -25, -46, 273, -24, -2, -32, -32, -32, -32, -32,
+ -32, -32, -32, -32, -32, -32, -32, -2, -2, 41,
+ -9, -13, -12, -32, -49, 273, 264, 266, -27, 44,
+ 273, -5, 41, 93, 41, 44, -16, -26, -42, -43,
+ 125, -47, 59, 44, -47, 44, 61, -2, -30, -31,
+ -18, -38, 268, -45, -26, 273, -2, -32, -32, -48,
+ -32, -49, 273, -32, -26, -2, -32, -19, -39, -3,
+ 267, -33, 261, 262, -12, -2, -4, 267, -26, -30,
+ -47, 267, -19, 260, -2, -26, -2, -33 };
+int yydef[]={
+
+ 1, -2, 16, 4, 5, 6, 0, 102, 14, 0,
+ 7, 3, 15, 17, 63, 21, 23, 0, 26, 0,
+ -2, 63, 93, 66, 96, 0, 0, 0, 37, 63,
+ 63, 52, -2, 54, 55, 56, 57, 63, 0, 97,
+ 63, 31, 63, 0, 100, 98, 65, -2, 69, 0,
+ 63, 0, 8, 75, 9, 36, 63, 63, 63, 63,
+ 63, 63, 63, 63, 63, 63, 63, 63, 36, 36,
+ 37, 0, 51, 58, -2, 0, 0, 12, 25, -2,
+ -2, 0, 27, 0, 63, 0, 71, 67, 0, 95,
+ 0, 76, 77, 0, 31, 39, 40, 41, 42, 43,
+ 44, 45, 46, 47, 48, 49, 50, 59, 61, 38,
+ 0, 84, 84, 89, 86, 96, 36, 18, -2, 73,
+ 99, 101, 68, 94, 31, 0, 10, 36, 63, 63,
+ 64, 80, 82, -2, 81, 85, 63, 31, 36, 63,
+ 14, 32, 34, 63, 0, 78, 28, 60, 62, 0,
+ 90, 87, 0, 88, 36, 24, 19, 13, -2, -2,
+ 11, 0, 31, 18, 84, 0, 14, 20, 29, 0,
+ 83, 22, 35, 36, 31, 36, 28, 30 };
+typedef struct { char *t_name; int t_val; } yytoktype;
+#ifndef YYDEBUG
+# define YYDEBUG 0 /* don't allow debugging */
+#endif
+
+#if YYDEBUG
+
+yytoktype yytoks[] =
+{
+ "WRONGTOKEN", 257,
+ "NIL", 258,
+ "IF", 259,
+ "THEN", 260,
+ "ELSE", 261,
+ "ELSEIF", 262,
+ "WHILE", 263,
+ "DO", 264,
+ "REPEAT", 265,
+ "UNTIL", 266,
+ "END", 267,
+ "RETURN", 268,
+ "LOCAL", 269,
+ "FUNCTION", 270,
+ "NUMBER", 271,
+ "STRING", 272,
+ "NAME", 273,
+ "DEBUG", 274,
+ "AND", 275,
+ "OR", 276,
+ "EQ", 277,
+ "NE", 278,
+ ">", 62,
+ "<", 60,
+ "LE", 279,
+ "GE", 280,
+ "CONC", 281,
+ "+", 43,
+ "-", 45,
+ "*", 42,
+ "/", 47,
+ "UNARY", 282,
+ "NOT", 283,
+ "^", 94,
+ "-unknown-", -1 /* ends search */
+};
+
+char * yyreds[] =
+{
+ "-no such reduction-",
+ "functionlist : /* empty */",
+ "functionlist : functionlist",
+ "functionlist : functionlist stat sc",
+ "functionlist : functionlist function",
+ "functionlist : functionlist method",
+ "functionlist : functionlist setdebug",
+ "function : FUNCTION NAME",
+ "function : FUNCTION NAME body",
+ "method : FUNCTION NAME ':' NAME",
+ "method : FUNCTION NAME ':' NAME body",
+ "body : '(' parlist ')' block END",
+ "statlist : /* empty */",
+ "statlist : statlist stat sc",
+ "sc : /* empty */",
+ "sc : ';'",
+ "stat : /* empty */",
+ "stat : stat1",
+ "cond : /* empty */",
+ "cond : expr1",
+ "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 cond PrepJump",
+ "stat1 : varlist1 '=' exprlist1",
+ "stat1 : functioncall",
+ "stat1 : LOCAL localdeclist decinit",
+ "elsepart : /* empty */",
+ "elsepart : ELSE block",
+ "elsepart : ELSEIF cond THEN PrepJump block PrepJump elsepart",
+ "block : /* empty */",
+ "block : statlist ret",
+ "ret : /* empty */",
+ "ret : RETURN",
+ "ret : RETURN exprlist sc",
+ "PrepJump : /* empty */",
+ "expr1 : expr",
+ "expr : '(' expr ')'",
+ "expr : expr1 EQ 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 '^' expr1",
+ "expr : expr1 CONC expr1",
+ "expr : '-' expr1",
+ "expr : table",
+ "expr : varexp",
+ "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",
+ "table : /* empty */",
+ "table : '{' fieldlist '}'",
+ "functioncall : funcvalue funcParams",
+ "funcvalue : varexp",
+ "funcvalue : varexp ':' NAME",
+ "funcParams : '(' exprlist ')'",
+ "funcParams : table",
+ "exprlist : /* empty */",
+ "exprlist : exprlist1",
+ "exprlist1 : expr",
+ "exprlist1 : exprlist1 ','",
+ "exprlist1 : exprlist1 ',' expr",
+ "parlist : /* empty */",
+ "parlist : parlist1",
+ "parlist1 : NAME",
+ "parlist1 : parlist1 ',' NAME",
+ "fieldlist : /* empty */",
+ "fieldlist : lfieldlist1 lastcomma",
+ "fieldlist : ffieldlist1 lastcomma",
+ "fieldlist : lfieldlist1 ';'",
+ "fieldlist : lfieldlist1 ';' ffieldlist1 lastcomma",
+ "lastcomma : /* empty */",
+ "lastcomma : ','",
+ "ffieldlist1 : ffield",
+ "ffieldlist1 : ffieldlist1 ',' ffield",
+ "ffield : NAME '=' expr1",
+ "lfieldlist1 : expr1",
+ "lfieldlist1 : lfieldlist1 ',' expr1",
+ "varlist1 : var",
+ "varlist1 : varlist1 ',' var",
+ "var : singlevar",
+ "var : varexp '[' expr1 ']'",
+ "var : varexp '.' NAME",
+ "singlevar : NAME",
+ "varexp : var",
+ "localdeclist : NAME",
+ "localdeclist : localdeclist ',' NAME",
+ "decinit : /* empty */",
+ "decinit : '=' exprlist1",
+ "setdebug : DEBUG",
+};
+#endif /* YYDEBUG */
+#line 1 "/usr/lang/SC1.0/yaccpar"
+/* @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10 */
+
+/*
+** Skeleton parser driver for yacc output
+*/
+/*
+ @(#)RELEASE SC1.0 C++ 2.1 1Mar1991
+*/
+
+/*
+** yacc user known macros and defines
+*/
+#define YYERROR goto yyerrlab
+#define YYACCEPT return(0)
+#define YYABORT 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)
+#define YYCOPY(to, from, type) \
+ (type *) memcpy(to, (char *) from, yynewmax * sizeof(type))
+#ifndef YYDEBUG
+# define YYDEBUG 1 /* make debugging available */
+#endif
+
+
+/*
+** extern declarations for C++ - check your own code for correctness
+** if you have function redefined error messages here.
+*/
+
+#ifdef __cplusplus
+EXTERN_FUNCTION ( extern int printf, (const char*, DOTDOTDOT) );
+EXTERN_FUNCTION ( extern void *memcpy, (void *, const void *, int) );
+#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 yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; /* value stack */
+static int yy_yys[YYMAXDEPTH], *yys = yy_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) */
+
+#if defined(__cplusplus) || defined(__STDC__) || defined(lint)
+static int __yaccpar_lint_hack__ = 0;
+ /* if you change the value from 0 to
+ something else, make sure you know
+ what to do with yyerrlab reference.
+ This is a hack - to make sure C++ and
+ lint are happy with the 4.1 yacc code. */
+#endif
+
+int yynerrs; /* number of errors */
+
+int yyerrflag; /* error recovery flag */
+int yychar; /* current input token number */
+static unsigned yymaxdepth = YYMAXDEPTH;
+
+
+/*
+** yyparse - return 0 if worked, 1 if syntax error not recovered from
+*/
+int
+yyparse()
+{
+ register YYSTYPE *yypvt = (YYSTYPE*)0 ; /* top of value stack for
+$vars */
+
+ /*
+ ** Initialize externals - yyparse may be called more than once
+ */
+ yypv = &yyv[-1];
+ yyps = &yys[-1];
+ yystate = 0;
+ yytmp = 0;
+ yynerrs = 0;
+ yyerrflag = 0;
+ yychar = -1;
+
+#if defined(__cplusplus) || defined(__STDC__) || defined(lint)
+/*
+ Note that the following can never be executed but simply to please
+ lint and C++
+ */
+ switch (__yaccpar_lint_hack__)
+ {
+ case 1: goto yyerrlab;
+ case 2: goto yynewstate;
+ }
+#endif
+
+ {
+ 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 */
+
+ goto yystack;
+
+ /*
+ ** 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);
+ int yynewmax;
+
+ yynewmax = yymaxdepth + YYMAXDEPTH;
+ if (yymaxdepth == YYMAXDEPTH) /* first time growth */
+ {
+ YYSTYPE *newyyv = (YYSTYPE*)malloc(yynewmax*sizeof(YYSTYPE));
+ int *newyys = (int*)malloc(yynewmax*sizeof(int));
+ if (newyys != 0 && newyyv != 0)
+ {
+ yys = YYCOPY(newyys, yys, int);
+ yyv = YYCOPY(newyyv, yyv, YYSTYPE);
+ }
+ else
+ yynewmax = 0; /* failed */
+ }
+ else /* not first time */
+ {
+ yyv = (YYSTYPE*)realloc((char*)yyv,
+ yynewmax * sizeof(YYSTYPE));
+ yys = (int*)realloc((char*)yys,
+ yynewmax * sizeof(int));
+ if (yys == 0 || yyv == 0)
+ yynewmax = 0; /* failed */
+ }
+ if (yynewmax <= yymaxdepth) /* tables not expanded */
+ {
+ yyerror( "yacc stack overflow" );
+ YYABORT;
+ }
+ yymaxdepth = yynewmax;
+
+ 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 411 "lua.stx"
+{
+ pc=maincode; basepc=*initcode; maxcurr=maxmain;
+ nlocalvar=0;
+ } break;
+case 3:
+# line 416 "lua.stx"
+{
+ maincode=pc; *initcode=basepc; maxmain=maxcurr;
+ } break;
+case 7:
+# line 425 "lua.stx"
+{
+ init_function(yypvt[-0].pNode);
+ } break;
+case 8:
+# line 429 "lua.stx"
+{
+ Word func = luaI_findsymbol(yypvt[-2].pNode);
+ s_tag(func) = LUA_T_FUNCTION;
+ s_bvalue(func) = yypvt[-0].pByte;
+ } break;
+case 9:
+# line 437 "lua.stx"
+{
+ init_function(yypvt[-0].pNode);
+ localvar[nlocalvar]=luaI_findsymbolbyname("self");
+ add_nlocalvar(1);
+ } break;
+case 10:
+# line 443 "lua.stx"
+{
+ /* assign function to table field */
+ pc=maincode; basepc=*initcode; maxcurr=maxmain;
+ nlocalvar=0;
+ lua_pushvar(luaI_findsymbol(yypvt[-4].pNode)+1);
+ code_byte(PUSHSTRING);
+ code_word(luaI_findconstant(yypvt[-2].pNode));
+ code_byte(PUSHFUNCTION);
+ code_code(yypvt[-0].pByte);
+ code_byte(STOREINDEXED0);
+ maincode=pc; *initcode=basepc; maxmain=maxcurr;
+ } break;
+case 11:
+# line 458 "lua.stx"
+{
+ codereturn();
+ yyval.pByte = newvector(pc, Byte);
+ memcpy(yyval.pByte, basepc, pc*sizeof(Byte));
+ funcCode = basepc; maxcode=maxcurr;
+#if LISTING
+ PrintCode(funcCode,funcCode+pc);
+#endif
+ } break;
+case 16:
+# line 475 "lua.stx"
+{ codedebugline(); } break;
+case 18:
+# line 477 "lua.stx"
+{ codedebugline(); } break;
+case 20:
+# line 480 "lua.stx"
+{ codeIf(yypvt[-4].vLong, yypvt[-2].vLong); } break;
+case 21:
+# line 482 "lua.stx"
+{yyval.vLong=pc;} break;
+case 22:
+# line 483 "lua.stx"
+{
+ basepc[yypvt[-3].vLong] = IFFJMP;
+ code_word_at(basepc+yypvt[-3].vLong+1, pc - (yypvt[-3].vLong + sizeof(Word)+1));
+ basepc[yypvt[-1].vLong] = UPJMP;
+ code_word_at(basepc+yypvt[-1].vLong+1, pc - (yypvt[-6].vLong));
+ } break;
+case 23:
+# line 490 "lua.stx"
+{yyval.vLong=pc;} break;
+case 24:
+# line 491 "lua.stx"
+{
+ basepc[yypvt[-0].vLong] = IFFUPJMP;
+ code_word_at(basepc+yypvt[-0].vLong+1, pc - (yypvt[-4].vLong));
+ } break;
+case 25:
+# line 497 "lua.stx"
+{
+ {
+ int i;
+ adjust_mult_assign(nvarbuffer, yypvt[-0].vInt, 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 26:
+# line 507 "lua.stx"
+{ code_byte(0); } break;
+case 27:
+# line 509 "lua.stx"
+{ add_nlocalvar(yypvt[-1].vInt);
+ adjust_mult_assign(yypvt[-1].vInt, yypvt[-0].vInt, 0);
+ } break;
+case 30:
+# line 517 "lua.stx"
+{ codeIf(yypvt[-3].vLong, yypvt[-1].vLong); } break;
+case 31:
+# line 520 "lua.stx"
+{yyval.vInt = nlocalvar;} break;
+case 32:
+# line 521 "lua.stx"
+{
+ if (nlocalvar != yypvt[-2].vInt)
+ {
+ nlocalvar = yypvt[-2].vInt;
+ lua_codeadjust (0);
+ }
+ } break;
+case 34:
+# line 531 "lua.stx"
+{ codedebugline(); } break;
+case 35:
+# line 532 "lua.stx"
+{
+ if (yypvt[-1].vInt < 0) code_byte(MULT_RET);
+ codereturn();
+ } break;
+case 36:
+# line 539 "lua.stx"
+{
+ yyval.vLong = pc;
+ code_byte(0); /* open space */
+ code_word (0);
+ } break;
+case 37:
+# line 545 "lua.stx"
+{ if (yypvt[-0].vInt == 0) code_byte(1); } break;
+case 38:
+# line 548 "lua.stx"
+{ yyval.vInt = yypvt[-1].vInt; } break;
+case 39:
+# line 549 "lua.stx"
+{ code_byte(EQOP); yyval.vInt = 1; } break;
+case 40:
+# line 550 "lua.stx"
+{ code_byte(LTOP); yyval.vInt = 1; } break;
+case 41:
+# line 551 "lua.stx"
+{ code_byte(GTOP); yyval.vInt = 1; } break;
+case 42:
+# line 552 "lua.stx"
+{ code_byte(EQOP); code_byte(NOTOP); yyval.vInt = 1; } break;
+case 43:
+# line 553 "lua.stx"
+{ code_byte(LEOP); yyval.vInt = 1; } break;
+case 44:
+# line 554 "lua.stx"
+{ code_byte(GEOP); yyval.vInt = 1; } break;
+case 45:
+# line 555 "lua.stx"
+{ code_byte(ADDOP); yyval.vInt = 1; } break;
+case 46:
+# line 556 "lua.stx"
+{ code_byte(SUBOP); yyval.vInt = 1; } break;
+case 47:
+# line 557 "lua.stx"
+{ code_byte(MULTOP); yyval.vInt = 1; } break;
+case 48:
+# line 558 "lua.stx"
+{ code_byte(DIVOP); yyval.vInt = 1; } break;
+case 49:
+# line 559 "lua.stx"
+{ code_byte(POWOP); yyval.vInt = 1; } break;
+case 50:
+# line 560 "lua.stx"
+{ code_byte(CONCOP); yyval.vInt = 1; } break;
+case 51:
+# line 561 "lua.stx"
+{ code_byte(MINUSOP); yyval.vInt = 1;} break;
+case 52:
+# line 562 "lua.stx"
+{ yyval.vInt = 1; } break;
+case 53:
+# line 563 "lua.stx"
+{ yyval.vInt = 1;} break;
+case 54:
+# line 564 "lua.stx"
+{ code_number(yypvt[-0].vFloat); yyval.vInt = 1; } break;
+case 55:
+# line 566 "lua.stx"
+{
+ code_byte(PUSHSTRING);
+ code_word(yypvt[-0].vWord);
+ yyval.vInt = 1;
+ } break;
+case 56:
+# line 571 "lua.stx"
+{code_byte(PUSHNIL); yyval.vInt = 1; } break;
+case 57:
+# line 572 "lua.stx"
+{ yyval.vInt = 0; } break;
+case 58:
+# line 573 "lua.stx"
+{ code_byte(NOTOP); yyval.vInt = 1;} break;
+case 59:
+# line 574 "lua.stx"
+{code_byte(POP); } break;
+case 60:
+# line 575 "lua.stx"
+{
+ basepc[yypvt[-2].vLong] = ONFJMP;
+ code_word_at(basepc+yypvt[-2].vLong+1, pc - (yypvt[-2].vLong + sizeof(Word)+1));
+ yyval.vInt = 1;
+ } break;
+case 61:
+# line 580 "lua.stx"
+{code_byte(POP); } break;
+case 62:
+# line 581 "lua.stx"
+{
+ basepc[yypvt[-2].vLong] = ONTJMP;
+ code_word_at(basepc+yypvt[-2].vLong+1, pc - (yypvt[-2].vLong + sizeof(Word)+1));
+ yyval.vInt = 1;
+ } break;
+case 63:
+# line 589 "lua.stx"
+{
+ code_byte(CREATEARRAY);
+ yyval.vLong = pc; code_word(0);
+ } break;
+case 64:
+# line 594 "lua.stx"
+{
+ code_word_at(basepc+yypvt[-3].vLong, yypvt[-1].vInt);
+ } break;
+case 65:
+# line 600 "lua.stx"
+{ code_byte(CALLFUNC); code_byte(yypvt[-1].vInt+yypvt[-0].vInt); } break;
+case 66:
+# line 603 "lua.stx"
+{ yyval.vInt = 0; } break;
+case 67:
+# line 605 "lua.stx"
+{
+ code_byte(PUSHSELF);
+ code_word(luaI_findconstant(yypvt[-0].pNode));
+ yyval.vInt = 1;
+ } break;
+case 68:
+# line 613 "lua.stx"
+{ if (yypvt[-1].vInt<0) { code_byte(1); yyval.vInt = -yypvt[-1].vInt; } else yyval.vInt = yypvt[-1].vInt; } break;
+case 69:
+# line 614 "lua.stx"
+{ yyval.vInt = 1; } break;
+case 70:
+# line 617 "lua.stx"
+{ yyval.vInt = 0; } break;
+case 71:
+# line 618 "lua.stx"
+{ yyval.vInt = yypvt[-0].vInt; } break;
+case 72:
+# line 621 "lua.stx"
+{ if (yypvt[-0].vInt == 0) yyval.vInt = -1; else yyval.vInt = 1; } break;
+case 73:
+# line 622 "lua.stx"
+{ if (yypvt[-1].vInt < 0) code_byte(1); } break;
+case 74:
+# line 623 "lua.stx"
+{
+ int r = yypvt[-3].vInt < 0 ? -yypvt[-3].vInt : yypvt[-3].vInt;
+ yyval.vInt = (yypvt[-0].vInt == 0) ? -(r+1) : r+1;
+ } break;
+case 75:
+# line 629 "lua.stx"
+{ lua_codeadjust(0); } break;
+case 76:
+# line 630 "lua.stx"
+{ lua_codeadjust(0); } break;
+case 77:
+# line 634 "lua.stx"
+{
+ localvar[nlocalvar]=luaI_findsymbol(yypvt[-0].pNode);
+ add_nlocalvar(1);
+ } break;
+case 78:
+# line 639 "lua.stx"
+{
+ localvar[nlocalvar]=luaI_findsymbol(yypvt[-0].pNode);
+ add_nlocalvar(1);
+ } break;
+case 79:
+# line 645 "lua.stx"
+{ yyval.vInt = 0; } break;
+case 80:
+# line 647 "lua.stx"
+{ yyval.vInt = yypvt[-1].vInt; flush_list(yypvt[-1].vInt/FIELDS_PER_FLUSH, yypvt[-1].vInt%FIELDS_PER_FLUSH); } break;
+case 81:
+# line 649 "lua.stx"
+{ yyval.vInt = yypvt[-1].vInt; flush_record(yypvt[-1].vInt%FIELDS_PER_FLUSH); } break;
+case 82:
+# line 651 "lua.stx"
+{ flush_list(yypvt[-1].vInt/FIELDS_PER_FLUSH, yypvt[-1].vInt%FIELDS_PER_FLUSH); } break;
+case 83:
+# line 653 "lua.stx"
+{ yyval.vInt = yypvt[-4].vInt+yypvt[-1].vInt; flush_record(yypvt[-1].vInt%FIELDS_PER_FLUSH); } break;
+case 86:
+# line 660 "lua.stx"
+{yyval.vInt=1;} break;
+case 87:
+# line 662 "lua.stx"
+{
+ yyval.vInt=yypvt[-2].vInt+1;
+ if (yyval.vInt%FIELDS_PER_FLUSH == 0) flush_record(FIELDS_PER_FLUSH);
+ } break;
+case 88:
+# line 669 "lua.stx"
+{
+ push_field(luaI_findconstant(yypvt[-2].pNode));
+ } break;
+case 89:
+# line 674 "lua.stx"
+{yyval.vInt=1;} break;
+case 90:
+# line 676 "lua.stx"
+{
+ yyval.vInt=yypvt[-2].vInt+1;
+ if (yyval.vInt%FIELDS_PER_FLUSH == 0)
+ flush_list(yyval.vInt/FIELDS_PER_FLUSH - 1, FIELDS_PER_FLUSH);
+ } break;
+case 91:
+# line 684 "lua.stx"
+{
+ nvarbuffer = 0;
+ varbuffer[nvarbuffer] = yypvt[-0].vLong; incr_nvarbuffer();
+ yyval.vInt = (yypvt[-0].vLong == 0) ? 1 : 0;
+ } break;
+case 92:
+# line 690 "lua.stx"
+{
+ varbuffer[nvarbuffer] = yypvt[-0].vLong; incr_nvarbuffer();
+ yyval.vInt = (yypvt[-0].vLong == 0) ? yypvt[-2].vInt + 1 : yypvt[-2].vInt;
+ } break;
+case 93:
+# line 696 "lua.stx"
+{ yyval.vLong = yypvt[-0].vLong; } break;
+case 94:
+# line 698 "lua.stx"
+{
+ yyval.vLong = 0; /* indexed variable */
+ } break;
+case 95:
+# line 702 "lua.stx"
+{
+ code_byte(PUSHSTRING);
+ code_word(luaI_findconstant(yypvt[-0].pNode));
+ yyval.vLong = 0; /* indexed variable */
+ } break;
+case 96:
+# line 710 "lua.stx"
+{
+ Word s = luaI_findsymbol(yypvt[-0].pNode);
+ int local = lua_localname (s);
+ if (local == -1) /* global var */
+ yyval.vLong = s + 1; /* return positive value */
+ else
+ yyval.vLong = -(local+1); /* return negative value */
+ } break;
+case 97:
+# line 720 "lua.stx"
+{ lua_pushvar(yypvt[-0].vLong); } break;
+case 98:
+# line 723 "lua.stx"
+{localvar[nlocalvar]=luaI_findsymbol(yypvt[-0].pNode); yyval.vInt = 1;} break;
+case 99:
+# line 725 "lua.stx"
+{
+ localvar[nlocalvar+yypvt[-2].vInt]=luaI_findsymbol(yypvt[-0].pNode);
+ yyval.vInt = yypvt[-2].vInt+1;
+ } break;
+case 100:
+# line 731 "lua.stx"
+{ yyval.vInt = 0; } break;
+case 101:
+# line 732 "lua.stx"
+{ yyval.vInt = yypvt[-0].vInt; } break;
+case 102:
+# line 735 "lua.stx"
+{lua_debug = yypvt[-0].vInt;} break;
+ }
+ goto yystack; /* reset registers in driver code */
+}
View Lorry Controller Status