Lua 1.1

Lua Team committed 32 years ago

Commit 6a0a9ef1 parent 8fa4b5556 files · +6975 −3402Browse files

Showing the changes to src (16 of 56 files). Show all

Unified · Split

16 files

src/Makefile +24 −0
src/hash.c +347 −0
src/hash.h +32 −0
src/inout.c +177 −0
src/inout.h +21 −0
src/lex.c +238 −0
src/opcode.c +1021 −0
src/opcode.h +164 −0
src/table.c +337 −0
src/table.h +42 −0
src/y.tab.c +1811 −0
src/y.tab.h +37 −0
src/yacc/Makefile +27 −0
src/yacc/exscript +3 −0
src/yacc/lua.lex +85 −0
src/yacc/lua.stx +953 −0

@@ -0,0 +1,24 @@
	1	# makefile for lua
	2
	3	LIB= $(LUA)/lib
	4	INC= $(LUA)/include
	5
	6	CC= gcc
	7	CFLAGS= -g -Wall -O2 -I$(INC) $(DEFS)
	8	DEFS= -DMAXCODE=64000 -DMAXCONSTANT=1024 -DMAXSYMBOL=1024 -DMAXARRAY=1024
	9
	10	OBJS= hash.o inout.o lex.o opcode.o table.o y.tab.o
	11	SLIB= $(LIB)/liblua.a
	12	DLIB= $(LIB)/liblua.so.1.1
	13
	14	libs: $(SLIB) $(DLIB)
	15
	16	$(SLIB): $(OBJS)
	17	ar ruvl $@ $(OBJS)
	18	ranlib $(SLIB)
	19
	20	$(DLIB): $(OBJS)
	21	ld -o $@ $(OBJS)
	22
	23	clean:
	24	rm -f $(OBJS) $(SLIB) $(DLIB)

src/hash.c+347−0

@@ -0,0 +1,347 @@
	1	/*
	2	** hash.c
	3	** hash manager for lua
	4	** Luiz Henrique de Figueiredo - 17 Aug 90
	5	*/
	6
	7	char *rcs_hash="$Id: hash.c,v 2.1 1994/04/20 22:07:57 celes Exp $";
	8
	9	#include <string.h>
	10	#include <stdlib.h>
	11
	12	#include "mm.h"
	13
	14	#include "opcode.h"
	15	#include "hash.h"
	16	#include "inout.h"
	17	#include "table.h"
	18	#include "lua.h"
	19
	20	#define streq(s1,s2) (strcmp(s1,s2)==0)
	21	#define strneq(s1,s2) (strcmp(s1,s2)!=0)
	22
	23	#define new(s) ((s *)malloc(sizeof(s)))
	24	#define newvector(n,s) ((s *)calloc(n,sizeof(s)))
	25
	26	#define nhash(t) ((t)->nhash)
	27	#define nodelist(t) ((t)->list)
	28	#define list(t,i) ((t)->list[i])
	29	#define markarray(t) ((t)->mark)
	30	#define ref_tag(n) (tag(&(n)->ref))
	31	#define ref_nvalue(n) (nvalue(&(n)->ref))
	32	#define ref_svalue(n) (svalue(&(n)->ref))
	33
	34	#ifndef ARRAYBLOCK
	35	#define ARRAYBLOCK 50
	36	#endif
	37
	38	typedef struct ArrayList
	39	{
	40	Hash *array;
	41	struct ArrayList *next;
	42	} ArrayList;
	43
	44	static ArrayList *listhead = NULL;
	45
	46	static int head (Hash t, Object ref) /* hash function */
	47	{
	48	if (tag(ref) == T_NUMBER) return (((int)nvalue(ref))%nhash(t));
	49	else if (tag(ref) == T_STRING)
	50	{
	51	int h;
	52	char *name = svalue(ref);
	53	for (h=0; name!=0; name++) / interpret name as binary number */
	54	{
	55	h <<= 8;
	56	h += (unsigned char) name; / avoid sign extension */
	57	h %= nhash(t); /* make it a valid index */
	58	}
	59	return h;
	60	}
	61	else
	62	{
	63	lua_reportbug ("unexpected type to index table");
	64	return -1;
	65	}
	66	}
	67
	68	static Node present(Hash t, Object *ref, int h)
	69	{
	70	Node n=NULL, p;
	71	if (tag(ref) == T_NUMBER)
	72	{
	73	for (p=NULL,n=list(t,h); n!=NULL; p=n, n=n->next)
	74	if (ref_tag(n) == T_NUMBER && nvalue(ref) == ref_nvalue(n)) break;
	75	}
	76	else if (tag(ref) == T_STRING)
	77	{
	78	for (p=NULL,n=list(t,h); n!=NULL; p=n, n=n->next)
	79	if (ref_tag(n) == T_STRING && streq(svalue(ref),ref_svalue(n))) break;
	80	}
	81	if (n==NULL) /* name not present */
	82	return NULL;
	83	#if 0
	84	if (p!=NULL) /* name present but not first */
	85	{
	86	p->next=n->next; /* move-to-front self-organization */
	87	n->next=list(t,h);
	88	list(t,h)=n;
	89	}
	90	#endif
	91	return n;
	92	}
	93
	94	static void freelist (Node *n)
	95	{
	96	while (n)
	97	{
	98	Node *next = n->next;
	99	free (n);
	100	n = next;
	101	}
	102	}
	103
	104	/*
	105	** Create a new hash. Return the hash pointer or NULL on error.
	106	*/
	107	static Hash *hashcreate (unsigned int nhash)
	108	{
	109	Hash *t = new (Hash);
	110	if (t == NULL)
	111	{
	112	lua_error ("not enough memory");
	113	return NULL;
	114	}
	115	nhash(t) = nhash;
	116	markarray(t) = 0;
	117	nodelist(t) = newvector (nhash, Node*);
	118	if (nodelist(t) == NULL)
	119	{
	120	lua_error ("not enough memory");
	121	return NULL;
	122	}
	123	return t;
	124	}
	125
	126	/*
	127	** Delete a hash
	128	*/
	129	static void hashdelete (Hash *h)
	130	{
	131	int i;
	132	for (i=0; i<nhash(h); i++)
	133	freelist (list(h,i));
	134	free (nodelist(h));
	135	free(h);
	136	}
	137
	138
	139	/*
	140	** Mark a hash and check its elements
	141	*/
	142	void lua_hashmark (Hash *h)
	143	{
	144	if (markarray(h) == 0)
	145	{
	146	int i;
	147	markarray(h) = 1;
	148	for (i=0; i<nhash(h); i++)
	149	{
	150	Node *n;
	151	for (n = list(h,i); n != NULL; n = n->next)
	152	{
	153	lua_markobject(&n->ref);
	154	lua_markobject(&n->val);
	155	}
	156	}
	157	}
	158	}
	159
	160	/*
	161	** Garbage collection to arrays
	162	** Delete all unmarked arrays.
	163	*/
	164	void lua_hashcollector (void)
	165	{
	166	ArrayList curr = listhead, prev = NULL;
	167	while (curr != NULL)
	168	{
	169	ArrayList *next = curr->next;
	170	if (markarray(curr->array) != 1)
	171	{
	172	if (prev == NULL) listhead = next;
	173	else prev->next = next;
	174	hashdelete(curr->array);
	175	free(curr);
	176	}
	177	else
	178	{
	179	markarray(curr->array) = 0;
	180	prev = curr;
	181	}
	182	curr = next;
	183	}
	184	}
	185
	186
	187	/*
	188	** Create a new array
	189	** This function insert the new array at array list. It also
	190	** execute garbage collection if the number of array created
	191	** exceed a pre-defined range.
	192	*/
	193	Hash *lua_createarray (int nhash)
	194	{
	195	ArrayList *new = new(ArrayList);
	196	if (new == NULL)
	197	{
	198	lua_error ("not enough memory");
	199	return NULL;
	200	}
	201	new->array = hashcreate(nhash);
	202	if (new->array == NULL)
	203	{
	204	lua_error ("not enough memory");
	205	return NULL;
	206	}
	207
	208	if (lua_nentity == lua_block)
	209	lua_pack();
	210
	211	lua_nentity++;
	212	new->next = listhead;
	213	listhead = new;
	214	return new->array;
	215	}
	216
	217
	218	/*
	219	** If the hash node is present, return its pointer, otherwise create a new
	220	** node for the given reference and also return its pointer.
	221	** On error, return NULL.
	222	*/
	223	Object lua_hashdefine (Hash t, Object *ref)
	224	{
	225	int h;
	226	Node *n;
	227	h = head (t, ref);
	228	if (h < 0) return NULL;
	229
	230	n = present(t, ref, h);
	231	if (n == NULL)
	232	{
	233	n = new(Node);
	234	if (n == NULL)
	235	{
	236	lua_error ("not enough memory");
	237	return NULL;
	238	}
	239	n->ref = *ref;
	240	tag(&n->val) = T_NIL;
	241	n->next = list(t,h); /* link node to head of list */
	242	list(t,h) = n;
	243	}
	244	return (&n->val);
	245	}
	246
	247
	248	/*
	249	** Internal function to manipulate arrays.
	250	** Given an array object and a reference value, return the next element
	251	** in the hash.
	252	** This function pushs the element value and its reference to the stack.
	253	*/
	254	static void firstnode (Hash *a, int h)
	255	{
	256	if (h < nhash(a))
	257	{
	258	int i;
	259	for (i=h; i<nhash(a); i++)
	260	{
	261	if (list(a,i) != NULL)
	262	{
	263	if (tag(&list(a,i)->val) != T_NIL)
	264	{
	265	lua_pushobject (&list(a,i)->ref);
	266	lua_pushobject (&list(a,i)->val);
	267	return;
	268	}
	269	else
	270	{
	271	Node *next = list(a,i)->next;
	272	while (next != NULL && tag(&next->val) == T_NIL) next = next->next;
	273	if (next != NULL)
	274	{
	275	lua_pushobject (&next->ref);
	276	lua_pushobject (&next->val);
	277	return;
	278	}
	279	}
	280	}
	281	}
	282	}
	283	lua_pushnil();
	284	lua_pushnil();
	285	}
	286	void lua_next (void)
	287	{
	288	Hash *a;
	289	Object *o = lua_getparam (1);
	290	Object *r = lua_getparam (2);
	291	if (o == NULL \|\| r == NULL)
	292	{ lua_error ("too few arguments to function `next'"); return; }
	293	if (lua_getparam (3) != NULL)
	294	{ lua_error ("too many arguments to function `next'"); return; }
	295	if (tag(o) != T_ARRAY)
	296	{ lua_error ("first argument of function `next' is not a table"); return; }
	297	a = avalue(o);
	298	if (tag(r) == T_NIL)
	299	{
	300	firstnode (a, 0);
	301	return;
	302	}
	303	else
	304	{
	305	int h = head (a, r);
	306	if (h >= 0)
	307	{
	308	Node *n = list(a,h);
	309	while (n)
	310	{
	311	if (memcmp(&n->ref,r,sizeof(Object)) == 0)
	312	{
	313	if (n->next == NULL)
	314	{
	315	firstnode (a, h+1);
	316	return;
	317	}
	318	else if (tag(&n->next->val) != T_NIL)
	319	{
	320	lua_pushobject (&n->next->ref);
	321	lua_pushobject (&n->next->val);
	322	return;
	323	}
	324	else
	325	{
	326	Node *next = n->next->next;
	327	while (next != NULL && tag(&next->val) == T_NIL) next = next->next;
	328	if (next == NULL)
	329	{
	330	firstnode (a, h+1);
	331	return;
	332	}
	333	else
	334	{
	335	lua_pushobject (&next->ref);
	336	lua_pushobject (&next->val);
	337	}
	338	return;
	339	}
	340	}
	341	n = n->next;
	342	}
	343	if (n == NULL)
	344	lua_error ("error in function 'next': reference not found");
	345	}
	346	}
	347	}

src/hash.h+32−0

@@ -0,0 +1,32 @@
	1	/*
	2	** hash.h
	3	** hash manager for lua
	4	** Luiz Henrique de Figueiredo - 17 Aug 90
	5	** $Id: hash.h,v 2.1 1994/04/20 22:07:57 celes Exp $
	6	*/
	7
	8	#ifndef hash_h
	9	#define hash_h
	10
	11	typedef struct node
	12	{
	13	Object ref;
	14	Object val;
	15	struct node *next;
	16	} Node;
	17
	18	typedef struct Hash
	19	{
	20	char mark;
	21	unsigned int nhash;
	22	Node **list;
	23	} Hash;
	24
	25
	26	Hash *lua_createarray (int nhash);
	27	void lua_hashmark (Hash *h);
	28	void lua_hashcollector (void);
	29	Object lua_hashdefine (Hash t, Object *ref);
	30	void lua_next (void);
	31
	32	#endif

src/inout.c+177−0

@@ -0,0 +1,177 @@
	1	/*
	2	** inout.c
	3	** Provide function to realise the input/output function and debugger
	4	** facilities.
	5	*/
	6
	7	char *rcs_inout="$Id: inout.c,v 1.2 1993/12/22 21:15:16 roberto Exp $";
	8
	9	#include <stdio.h>
	10	#include <string.h>
	11
	12	#include "opcode.h"
	13	#include "hash.h"
	14	#include "inout.h"
	15	#include "table.h"
	16
	17	/* Exported variables */
	18	int lua_linenumber;
	19	int lua_debug;
	20	int lua_debugline;
	21
	22	/* Internal variables */
	23	#ifndef MAXFUNCSTACK
	24	#define MAXFUNCSTACK 32
	25	#endif
	26	static struct { int file; int function; } funcstack[MAXFUNCSTACK];
	27	static int nfuncstack=0;
	28
	29	static FILE *fp;
	30	static char *st;
	31	static void (usererror) (char s);
	32
	33	/*
	34	** Function to set user function to handle errors.
	35	*/
	36	void lua_errorfunction (void (fn) (char s))
	37	{
	38	usererror = fn;
	39	}
	40
	41	/*
	42	** Function to get the next character from the input file
	43	*/
	44	static int fileinput (void)
	45	{
	46	int c = fgetc (fp);
	47	return (c == EOF ? 0 : c);
	48	}
	49
	50	/*
	51	** Function to get the next character from the input string
	52	*/
	53	static int stringinput (void)
	54	{
	55	st++;
	56	return (*(st-1));
	57	}
	58
	59	/*
	60	** Function to open a file to be input unit.
	61	** Return 0 on success or 1 on error.
	62	*/
	63	int lua_openfile (char *fn)
	64	{
	65	lua_linenumber = 1;
	66	lua_setinput (fileinput);
	67	fp = fopen (fn, "r");
	68	if (fp == NULL) return 1;
	69	if (lua_addfile (fn)) return 1;
	70	return 0;
	71	}
	72
	73	/*
	74	** Function to close an opened file
	75	*/
	76	void lua_closefile (void)
	77	{
	78	if (fp != NULL)
	79	{
	80	lua_delfile();
	81	fclose (fp);
	82	fp = NULL;
	83	}
	84	}
	85
	86	/*
	87	** Function to open a string to be input unit
	88	*/
	89	int lua_openstring (char *s)
	90	{
	91	lua_linenumber = 1;
	92	lua_setinput (stringinput);
	93	st = s;
	94	{
	95	char sn[64];
	96	sprintf (sn, "String: %10.10s...", s);
	97	if (lua_addfile (sn)) return 1;
	98	}
	99	return 0;
	100	}
	101
	102	/*
	103	** Function to close an opened string
	104	*/
	105	void lua_closestring (void)
	106	{
	107	lua_delfile();
	108	}
	109
	110	/*
	111	** Call user function to handle error messages, if registred. Or report error
	112	** using standard function (fprintf).
	113	*/
	114	void lua_error (char *s)
	115	{
	116	if (usererror != NULL) usererror (s);
	117	else fprintf (stderr, "lua: %s\n", s);
	118	}
	119
	120	/*
	121	** Called to execute SETFUNCTION opcode, this function pushs a function into
	122	** function stack. Return 0 on success or 1 on error.
	123	*/
	124	int lua_pushfunction (int file, int function)
	125	{
	126	if (nfuncstack >= MAXFUNCSTACK-1)
	127	{
	128	lua_error ("function stack overflow");
	129	return 1;
	130	}
	131	funcstack[nfuncstack].file = file;
	132	funcstack[nfuncstack].function = function;
	133	nfuncstack++;
	134	return 0;
	135	}
	136
	137	/*
	138	** Called to execute RESET opcode, this function pops a function from
	139	** function stack.
	140	*/
	141	void lua_popfunction (void)
	142	{
	143	nfuncstack--;
	144	}
	145
	146	/*
	147	** Report bug building a message and sending it to lua_error function.
	148	*/
	149	void lua_reportbug (char *s)
	150	{
	151	char msg[1024];
	152	strcpy (msg, s);
	153	if (lua_debugline != 0)
	154	{
	155	int i;
	156	if (nfuncstack > 0)
	157	{
	158	sprintf (strchr(msg,0),
	159	"\n\tin statement begining at line %d in function \"%s\" of file \"%s\"",
	160	lua_debugline, s_name(funcstack[nfuncstack-1].function),
	161	lua_file[funcstack[nfuncstack-1].file]);
	162	sprintf (strchr(msg,0), "\n\tactive stack\n");
	163	for (i=nfuncstack-1; i>=0; i--)
	164	sprintf (strchr(msg,0), "\t-> function \"%s\" of file \"%s\"\n",
	165	s_name(funcstack[i].function),
	166	lua_file[funcstack[i].file]);
	167	}
	168	else
	169	{
	170	sprintf (strchr(msg,0),
	171	"\n\tin statement begining at line %d of file \"%s\"",
	172	lua_debugline, lua_filename());
	173	}
	174	}
	175	lua_error (msg);
	176	}
	177

src/inout.h+21−0

@@ -0,0 +1,21 @@
	1	/*
	2	** $Id: inout.h,v 1.1 1993/12/17 18:41:19 celes Exp $
	3	*/
	4
	5
	6	#ifndef inout_h
	7	#define inout_h
	8
	9	extern int lua_linenumber;
	10	extern int lua_debug;
	11	extern int lua_debugline;
	12
	13	int lua_openfile (char *fn);
	14	void lua_closefile (void);
	15	int lua_openstring (char *s);
	16	void lua_closestring (void);
	17	int lua_pushfunction (int file, int function);
	18	void lua_popfunction (void);
	19	void lua_reportbug (char *s);
	20
	21	#endif

src/lex.c+238−0

@@ -0,0 +1,238 @@
	1	char *rcs_lex = "$Id: lex.c,v 2.1 1994/04/15 19:00:28 celes Exp $";
	2	/*$Log: lex.c,v $
	3	* Revision 2.1 1994/04/15 19:00:28 celes
	4	* Retirar chamada da funcao lua_findsymbol associada a cada
	5	* token NAME. A decisao de chamar lua_findsymbol ou lua_findconstant
	6	* fica a cargo do modulo "lua.stx".
	7	*
	8	* Revision 1.3 1993/12/28 16:42:29 roberto
	9	* "include"s de string.h e stdlib.h para evitar warnings
	10	*
	11	* Revision 1.2 1993/12/22 21:39:15 celes
	12	* Tratamento do token $debug e $nodebug
	13	*
	14	* Revision 1.1 1993/12/22 21:15:16 roberto
	15	* Initial revision
	16	**/
	17
	18	#include <ctype.h>
	19	#include <math.h>
	20	#include <stdlib.h>
	21	#include <string.h>
	22
	23	#include "opcode.h"
	24	#include "hash.h"
	25	#include "inout.h"
	26	#include "table.h"
	27	#include "y.tab.h"
	28
	29	#define next() { current = input(); }
	30	#define save(x) { *yytextLast++ = (x); }
	31	#define save_and_next() { save(current); next(); }
	32
	33	static int current;
	34	static char yytext[256];
	35	static char *yytextLast;
	36
	37	static Input input;
	38
	39	void lua_setinput (Input fn)
	40	{
	41	current = ' ';
	42	input = fn;
	43	}
	44
	45	char *lua_lasttext (void)
	46	{
	47	*yytextLast = 0;
	48	return yytext;
	49	}
	50
	51
	52	static struct
	53	{
	54	char *name;
	55	int token;
	56	} reserved [] = {
	57	{"and", AND},
	58	{"do", DO},
	59	{"else", ELSE},
	60	{"elseif", ELSEIF},
	61	{"end", END},
	62	{"function", FUNCTION},
	63	{"if", IF},
	64	{"local", LOCAL},
	65	{"nil", NIL},
	66	{"not", NOT},
	67	{"or", OR},
	68	{"repeat", REPEAT},
	69	{"return", RETURN},
	70	{"then", THEN},
	71	{"until", UNTIL},
	72	{"while", WHILE} };
	73
	74	#define RESERVEDSIZE (sizeof(reserved)/sizeof(reserved[0]))
	75
	76
	77	int findReserved (char *name)
	78	{
	79	int l = 0;
	80	int h = RESERVEDSIZE - 1;
	81	while (l <= h)
	82	{
	83	int m = (l+h)/2;
	84	int comp = strcmp(name, reserved[m].name);
	85	if (comp < 0)
	86	h = m-1;
	87	else if (comp == 0)
	88	return reserved[m].token;
	89	else
	90	l = m+1;
	91	}
	92	return 0;
	93	}
	94
	95
	96	int yylex ()
	97	{
	98	while (1)
	99	{
	100	yytextLast = yytext;
	101	switch (current)
	102	{
	103	case '\n': lua_linenumber++;
	104	case ' ':
	105	case '\t':
	106	next();
	107	continue;
	108
	109	case '$':
	110	next();
	111	while (isalnum(current) \|\| current == '_')
	112	save_and_next();
	113	*yytextLast = 0;
	114	if (strcmp(yytext, "debug") == 0)
	115	{
	116	yylval.vInt = 1;
	117	return DEBUG;
	118	}
	119	else if (strcmp(yytext, "nodebug") == 0)
	120	{
	121	yylval.vInt = 0;
	122	return DEBUG;
	123	}
	124	return WRONGTOKEN;
	125
	126	case '-':
	127	save_and_next();
	128	if (current != '-') return '-';
	129	do { next(); } while (current != '\n' && current != 0);
	130	continue;
	131
	132	case '<':
	133	save_and_next();
	134	if (current != '=') return '<';
	135	else { save_and_next(); return LE; }
	136
	137	case '>':
	138	save_and_next();
	139	if (current != '=') return '>';
	140	else { save_and_next(); return GE; }
	141
	142	case '~':
	143	save_and_next();
	144	if (current != '=') return '~';
	145	else { save_and_next(); return NE; }
	146
	147	case '"':
	148	case '\'':
	149	{
	150	int del = current;
	151	next(); /* skip the delimiter */
	152	while (current != del)
	153	{
	154	switch (current)
	155	{
	156	case 0:
	157	case '\n':
	158	return WRONGTOKEN;
	159	case '\\':
	160	next(); /* do not save the '\' */
	161	switch (current)
	162	{
	163	case 'n': save('\n'); next(); break;
	164	case 't': save('\t'); next(); break;
	165	case 'r': save('\r'); next(); break;
	166	default : save('\\'); break;
	167	}
	168	break;
	169	default:
	170	save_and_next();
	171	}
	172	}
	173	next(); /* skip the delimiter */
	174	*yytextLast = 0;
	175	yylval.vWord = lua_findconstant (yytext);
	176	return STRING;
	177	}
	178
	179	case 'a': case 'b': case 'c': case 'd': case 'e':
	180	case 'f': case 'g': case 'h': case 'i': case 'j':
	181	case 'k': case 'l': case 'm': case 'n': case 'o':
	182	case 'p': case 'q': case 'r': case 's': case 't':
	183	case 'u': case 'v': case 'w': case 'x': case 'y':
	184	case 'z':
	185	case 'A': case 'B': case 'C': case 'D': case 'E':
	186	case 'F': case 'G': case 'H': case 'I': case 'J':
	187	case 'K': case 'L': case 'M': case 'N': case 'O':
	188	case 'P': case 'Q': case 'R': case 'S': case 'T':
	189	case 'U': case 'V': case 'W': case 'X': case 'Y':
	190	case 'Z':
	191	case '_':
	192	{
	193	int res;
	194	do { save_and_next(); } while (isalnum(current) \|\| current == '_');
	195	*yytextLast = 0;
	196	res = findReserved(yytext);
	197	if (res) return res;
	198	yylval.pChar = yytext;
	199	return NAME;
	200	}
	201
	202	case '.':
	203	save_and_next();
	204	if (current == '.')
	205	{
	206	save_and_next();
	207	return CONC;
	208	}
	209	else if (!isdigit(current)) return '.';
	210	/* current is a digit: goes through to number */
	211	goto fraction;
	212
	213	case '0': case '1': case '2': case '3': case '4':
	214	case '5': case '6': case '7': case '8': case '9':
	215
	216	do { save_and_next(); } while (isdigit(current));
	217	if (current == '.') save_and_next();
	218	fraction: while (isdigit(current)) save_and_next();
	219	if (current == 'e' \|\| current == 'E')
	220	{
	221	save_and_next();
	222	if (current == '+' \|\| current == '-') save_and_next();
	223	if (!isdigit(current)) return WRONGTOKEN;
	224	do { save_and_next(); } while (isdigit(current));
	225	}
	226	*yytextLast = 0;
	227	yylval.vFloat = atof(yytext);
	228	return NUMBER;
	229
	230	default: /* also end of file */
	231	{
	232	save_and_next();
	233	return *yytext;
	234	}
	235	}
	236	}
	237	}
	238

src/opcode.c+1021−0

@@ -0,0 +1,1021 @@
	1	/*
	2	** opcode.c
	3	** TecCGraf - PUC-Rio
	4	*/
	5
	6	char *rcs_opcode="$Id: opcode.c,v 2.1 1994/04/20 22:07:57 celes Exp $";
	7
	8	#include <stdio.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11
	12	/* stdlib.h does not have this in SunOS */
	13	extern double strtod(const char , char *);
	14
	15	#include "mm.h"
	16
	17	#include "opcode.h"
	18	#include "hash.h"
	19	#include "inout.h"
	20	#include "table.h"
	21	#include "lua.h"
	22
	23	#define tonumber(o) ((tag(o) != T_NUMBER) && (lua_tonumber(o) != 0))
	24	#define tostring(o) ((tag(o) != T_STRING) && (lua_tostring(o) != 0))
	25
	26	#ifndef MAXSTACK
	27	#define MAXSTACK 256
	28	#endif
	29	static Object stack[MAXSTACK] = {{T_MARK, {NULL}}};
	30	static Object top=stack+1, base=stack+1;
	31
	32
	33	/*
	34	** Concatenate two given string, creating a mark space at the beginning.
	35	** Return the new string pointer.
	36	*/
	37	static char lua_strconc (char l, char *r)
	38	{
	39	char *s = calloc (strlen(l)+strlen(r)+2, sizeof(char));
	40	if (s == NULL)
	41	{
	42	lua_error ("not enough memory");
	43	return NULL;
	44	}
	45	s++ = 0; / create mark space */
	46	return strcat(strcpy(s,l),r);
	47	}
	48
	49	/*
	50	** Duplicate a string, creating a mark space at the beginning.
	51	** Return the new string pointer.
	52	*/
	53	char lua_strdup (char l)
	54	{
	55	char *s = calloc (strlen(l)+2, sizeof(char));
	56	if (s == NULL)
	57	{
	58	lua_error ("not enough memory");
	59	return NULL;
	60	}
	61	s++ = 0; / create mark space */
	62	return strcpy(s,l);
	63	}
	64
	65	/*
	66	** Convert, if possible, to a number tag.
	67	** Return 0 in success or not 0 on error.
	68	*/
	69	static int lua_tonumber (Object *obj)
	70	{
	71	char *ptr;
	72	if (tag(obj) != T_STRING)
	73	{
	74	lua_reportbug ("unexpected type at conversion to number");
	75	return 1;
	76	}
	77	nvalue(obj) = strtod(svalue(obj), &ptr);
	78	if (*ptr)
	79	{
	80	lua_reportbug ("string to number convertion failed");
	81	return 2;
	82	}
	83	tag(obj) = T_NUMBER;
	84	return 0;
	85	}
	86
	87	/*
	88	** Test if is possible to convert an object to a number one.
	89	** If possible, return the converted object, otherwise return nil object.
	90	*/
	91	static Object lua_convtonumber (Object obj)
	92	{
	93	static Object cvt;
	94
	95	if (tag(obj) == T_NUMBER)
	96	{
	97	cvt = *obj;
	98	return &cvt;
	99	}
	100
	101	tag(&cvt) = T_NIL;
	102	if (tag(obj) == T_STRING)
	103	{
	104	char *ptr;
	105	nvalue(&cvt) = strtod(svalue(obj), &ptr);
	106	if (*ptr == 0)
	107	tag(&cvt) = T_NUMBER;
	108	}
	109	return &cvt;
	110	}
	111
	112
	113
	114	/*
	115	** Convert, if possible, to a string tag
	116	** Return 0 in success or not 0 on error.
	117	*/
	118	static int lua_tostring (Object *obj)
	119	{
	120	static char s[256];
	121	if (tag(obj) != T_NUMBER)
	122	{
	123	lua_reportbug ("unexpected type at conversion to string");
	124	return 1;
	125	}
	126	if ((int) nvalue(obj) == nvalue(obj))
	127	sprintf (s, "%d", (int) nvalue(obj));
	128	else
	129	sprintf (s, "%g", nvalue(obj));
	130	svalue(obj) = lua_createstring(lua_strdup(s));
	131	if (svalue(obj) == NULL)
	132	return 1;
	133	tag(obj) = T_STRING;
	134	return 0;
	135	}
	136
	137
	138	/*
	139	** Execute the given opcode. Return 0 in success or 1 on error.
	140	*/
	141	int lua_execute (Byte *pc)
	142	{
	143	Object *oldbase = base;
	144	base = top;
	145	while (1)
	146	{
	147	OpCode opcode;
	148	switch (opcode = (OpCode)*pc++)
	149	{
	150	case PUSHNIL: tag(top++) = T_NIL; break;
	151
	152	case PUSH0: tag(top) = T_NUMBER; nvalue(top++) = 0; break;
	153	case PUSH1: tag(top) = T_NUMBER; nvalue(top++) = 1; break;
	154	case PUSH2: tag(top) = T_NUMBER; nvalue(top++) = 2; break;
	155
	156	case PUSHBYTE: tag(top) = T_NUMBER; nvalue(top++) = *pc++; break;
	157
	158	case PUSHWORD:
	159	{
	160	CodeWord code;
	161	get_word(code,pc);
	162	tag(top) = T_NUMBER; nvalue(top++) = code.w;
	163	}
	164	break;
	165
	166	case PUSHFLOAT:
	167	{
	168	CodeFloat code;
	169	get_float(code,pc);
	170	tag(top) = T_NUMBER; nvalue(top++) = code.f;
	171	}
	172	break;
	173
	174	case PUSHSTRING:
	175	{
	176	CodeWord code;
	177	get_word(code,pc);
	178	tag(top) = T_STRING; svalue(top++) = lua_constant[code.w];
	179	}
	180	break;
	181
	182	case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2:
	183	case PUSHLOCAL3: case PUSHLOCAL4: case PUSHLOCAL5:
	184	case PUSHLOCAL6: case PUSHLOCAL7: case PUSHLOCAL8:
	185	case PUSHLOCAL9: top++ = (base + (int)(opcode-PUSHLOCAL0)); break;
	186
	187	case PUSHLOCAL: top++ = (base + (*pc++)); break;
	188
	189	case PUSHGLOBAL:
	190	{
	191	CodeWord code;
	192	get_word(code,pc);
	193	*top++ = s_object(code.w);
	194	}
	195	break;
	196
	197	case PUSHINDEXED:
	198	--top;
	199	if (tag(top-1) != T_ARRAY)
	200	{
	201	lua_reportbug ("indexed expression not a table");
	202	return 1;
	203	}
	204	{
	205	Object *h = lua_hashdefine (avalue(top-1), top);
	206	if (h == NULL) return 1;
	207	(top-1) = h;
	208	}
	209	break;
	210
	211	case PUSHMARK: tag(top++) = T_MARK; break;
	212
	213	case PUSHOBJECT: top = (top-3); top++; break;
	214
	215	case STORELOCAL0: case STORELOCAL1: case STORELOCAL2:
	216	case STORELOCAL3: case STORELOCAL4: case STORELOCAL5:
	217	case STORELOCAL6: case STORELOCAL7: case STORELOCAL8:
	218	case STORELOCAL9: (base + (int)(opcode-STORELOCAL0)) = (--top); break;
	219
	220	case STORELOCAL: (base + (pc++)) = *(--top); break;
	221
	222	case STOREGLOBAL:
	223	{
	224	CodeWord code;
	225	get_word(code,pc);
	226	s_object(code.w) = *(--top);
	227	}
	228	break;
	229
	230	case STOREINDEXED0:
	231	if (tag(top-3) != T_ARRAY)
	232	{
	233	lua_reportbug ("indexed expression not a table");
	234	return 1;
	235	}
	236	{
	237	Object *h = lua_hashdefine (avalue(top-3), top-2);
	238	if (h == NULL) return 1;
	239	h = (top-1);
	240	}
	241	top -= 3;
	242	break;
	243
	244	case STOREINDEXED:
	245	{
	246	int n = *pc++;
	247	if (tag(top-3-n) != T_ARRAY)
	248	{
	249	lua_reportbug ("indexed expression not a table");
	250	return 1;
	251	}
	252	{
	253	Object *h = lua_hashdefine (avalue(top-3-n), top-2-n);
	254	if (h == NULL) return 1;
	255	h = (top-1);
	256	}
	257	top--;
	258	}
	259	break;
	260
	261	case STORELIST0:
	262	case STORELIST:
	263	{
	264	int m, n;
	265	Object *arr;
	266	if (opcode == STORELIST0) m = 0;
	267	else m = (pc++) FIELDS_PER_FLUSH;
	268	n = *(pc++);
	269	arr = top-n-1;
	270	if (tag(arr) != T_ARRAY)
	271	{
	272	lua_reportbug ("internal error - table expected");
	273	return 1;
	274	}
	275	while (n)
	276	{
	277	tag(top) = T_NUMBER; nvalue(top) = n+m;
	278	(lua_hashdefine (avalue(arr), top)) = (top-1);
	279	top--;
	280	n--;
	281	}
	282	}
	283	break;
	284
	285	case STORERECORD:
	286	{
	287	int n = *(pc++);
	288	Object *arr = top-n-1;
	289	if (tag(arr) != T_ARRAY)
	290	{
	291	lua_reportbug ("internal error - table expected");
	292	return 1;
	293	}
	294	while (n)
	295	{
	296	CodeWord code;
	297	get_word(code,pc);
	298	tag(top) = T_STRING; svalue(top) = lua_constant[code.w];
	299	(lua_hashdefine (avalue(arr), top)) = (top-1);
	300	top--;
	301	n--;
	302	}
	303	}
	304	break;
	305
	306	case ADJUST:
	307	{
	308	Object newtop = base + (pc++);
	309	while (top < newtop) tag(top++) = T_NIL;
	310	top = newtop; /* top could be bigger than newtop */
	311	}
	312	break;
	313
	314	case CREATEARRAY:
	315	if (tag(top-1) == T_NIL)
	316	nvalue(top-1) = 101;
	317	else
	318	{
	319	if (tonumber(top-1)) return 1;
	320	if (nvalue(top-1) <= 0) nvalue(top-1) = 101;
	321	}
	322	avalue(top-1) = lua_createarray(nvalue(top-1));
	323	if (avalue(top-1) == NULL)
	324	return 1;
	325	tag(top-1) = T_ARRAY;
	326	break;
	327
	328	case EQOP:
	329	{
	330	Object *l = top-2;
	331	Object *r = top-1;
	332	--top;
	333	if (tag(l) != tag(r))
	334	tag(top-1) = T_NIL;
	335	else
	336	{
	337	switch (tag(l))
	338	{
	339	case T_NIL: tag(top-1) = T_NUMBER; break;
	340	case T_NUMBER: tag(top-1) = (nvalue(l) == nvalue(r)) ? T_NUMBER : T_NIL; break;
	341	case T_ARRAY: tag(top-1) = (avalue(l) == avalue(r)) ? T_NUMBER : T_NIL; break;
	342	case T_FUNCTION: tag(top-1) = (bvalue(l) == bvalue(r)) ? T_NUMBER : T_NIL; break;
	343	case T_CFUNCTION: tag(top-1) = (fvalue(l) == fvalue(r)) ? T_NUMBER : T_NIL; break;
	344	case T_USERDATA: tag(top-1) = (uvalue(l) == uvalue(r)) ? T_NUMBER : T_NIL; break;
	345	case T_STRING: tag(top-1) = (strcmp (svalue(l), svalue(r)) == 0) ? T_NUMBER : T_NIL; break;
	346	case T_MARK: return 1;
	347	}
	348	}
	349	nvalue(top-1) = 1;
	350	}
	351	break;
	352
	353	case LTOP:
	354	{
	355	Object *l = top-2;
	356	Object *r = top-1;
	357	--top;
	358	if (tag(l) == T_NUMBER && tag(r) == T_NUMBER)
	359	tag(top-1) = (nvalue(l) < nvalue(r)) ? T_NUMBER : T_NIL;
	360	else
	361	{
	362	if (tostring(l) \|\| tostring(r))
	363	return 1;
	364	tag(top-1) = (strcmp (svalue(l), svalue(r)) < 0) ? T_NUMBER : T_NIL;
	365	}
	366	nvalue(top-1) = 1;
	367	}
	368	break;
	369
	370	case LEOP:
	371	{
	372	Object *l = top-2;
	373	Object *r = top-1;
	374	--top;
	375	if (tag(l) == T_NUMBER && tag(r) == T_NUMBER)
	376	tag(top-1) = (nvalue(l) <= nvalue(r)) ? T_NUMBER : T_NIL;
	377	else
	378	{
	379	if (tostring(l) \|\| tostring(r))
	380	return 1;
	381	tag(top-1) = (strcmp (svalue(l), svalue(r)) <= 0) ? T_NUMBER : T_NIL;
	382	}
	383	nvalue(top-1) = 1;
	384	}
	385	break;
	386
	387	case ADDOP:
	388	{
	389	Object *l = top-2;
	390	Object *r = top-1;
	391	if (tonumber(r) \|\| tonumber(l))
	392	return 1;
	393	nvalue(l) += nvalue(r);
	394	--top;
	395	}
	396	break;
	397
	398	case SUBOP:
	399	{
	400	Object *l = top-2;
	401	Object *r = top-1;
	402	if (tonumber(r) \|\| tonumber(l))
	403	return 1;
	404	nvalue(l) -= nvalue(r);
	405	--top;
	406	}
	407	break;
	408
	409	case MULTOP:
	410	{
	411	Object *l = top-2;
	412	Object *r = top-1;
	413	if (tonumber(r) \|\| tonumber(l))
	414	return 1;
	415	nvalue(l) *= nvalue(r);
	416	--top;
	417	}
	418	break;
	419
	420	case DIVOP:
	421	{
	422	Object *l = top-2;
	423	Object *r = top-1;
	424	if (tonumber(r) \|\| tonumber(l))
	425	return 1;
	426	nvalue(l) /= nvalue(r);
	427	--top;
	428	}
	429	break;
	430
	431	case CONCOP:
	432	{
	433	Object *l = top-2;
	434	Object *r = top-1;
	435	if (tostring(r) \|\| tostring(l))
	436	return 1;
	437	svalue(l) = lua_createstring (lua_strconc(svalue(l),svalue(r)));
	438	if (svalue(l) == NULL)
	439	return 1;
	440	--top;
	441	}
	442	break;
	443
	444	case MINUSOP:
	445	if (tonumber(top-1))
	446	return 1;
	447	nvalue(top-1) = - nvalue(top-1);
	448	break;
	449
	450	case NOTOP:
	451	tag(top-1) = tag(top-1) == T_NIL ? T_NUMBER : T_NIL;
	452	break;
	453
	454	case ONTJMP:
	455	{
	456	CodeWord code;
	457	get_word(code,pc);
	458	if (tag(top-1) != T_NIL) pc += code.w;
	459	}
	460	break;
	461
	462	case ONFJMP:
	463	{
	464	CodeWord code;
	465	get_word(code,pc);
	466	if (tag(top-1) == T_NIL) pc += code.w;
	467	}
	468	break;
	469
	470	case JMP:
	471	{
	472	CodeWord code;
	473	get_word(code,pc);
	474	pc += code.w;
	475	}
	476	break;
	477
	478	case UPJMP:
	479	{
	480	CodeWord code;
	481	get_word(code,pc);
	482	pc -= code.w;
	483	}
	484	break;
	485
	486	case IFFJMP:
	487	{
	488	CodeWord code;
	489	get_word(code,pc);
	490	top--;
	491	if (tag(top) == T_NIL) pc += code.w;
	492	}
	493	break;
	494
	495	case IFFUPJMP:
	496	{
	497	CodeWord code;
	498	get_word(code,pc);
	499	top--;
	500	if (tag(top) == T_NIL) pc -= code.w;
	501	}
	502	break;
	503
	504	case POP: --top; break;
	505
	506	case CALLFUNC:
	507	{
	508	Byte *newpc;
	509	Object *b = top-1;
	510	while (tag(b) != T_MARK) b--;
	511	if (tag(b-1) == T_FUNCTION)
	512	{
	513	lua_debugline = 0; /* always reset debug flag */
	514	newpc = bvalue(b-1);
	515	bvalue(b-1) = pc; /* store return code */
	516	nvalue(b) = (base-stack); /* store base value */
	517	base = b+1;
	518	pc = newpc;
	519	if (MAXSTACK-(base-stack) < STACKGAP)
	520	{
	521	lua_error ("stack overflow");
	522	return 1;
	523	}
	524	}
	525	else if (tag(b-1) == T_CFUNCTION)
	526	{
	527	int nparam;
	528	lua_debugline = 0; /* always reset debug flag */
	529	nvalue(b) = (base-stack); /* store base value */
	530	base = b+1;
	531	nparam = top-base; /* number of parameters */
	532	(fvalue(b-1))(); /* call C function */
	533
	534	/* shift returned values */
	535	{
	536	int i;
	537	int nretval = top - base - nparam;
	538	top = base - 2;
	539	base = stack + (int) nvalue(base-1);
	540	for (i=0; i<nretval; i++)
	541	{
	542	top = (top+nparam+2);
	543	++top;
	544	}
	545	}
	546	}
	547	else
	548	{
	549	lua_reportbug ("call expression not a function");
	550	return 1;
	551	}
	552	}
	553	break;
	554
	555	case RETCODE:
	556	{
	557	int i;
	558	int shift = *pc++;
	559	int nretval = top - base - shift;
	560	top = base - 2;
	561	pc = bvalue(base-2);
	562	base = stack + (int) nvalue(base-1);
	563	for (i=0; i<nretval; i++)
	564	{
	565	top = (top+shift+2);
	566	++top;
	567	}
	568	}
	569	break;
	570
	571	case HALT:
	572	base = oldbase;
	573	return 0; /* success */
	574
	575	case SETFUNCTION:
	576	{
	577	CodeWord file, func;
	578	get_word(file,pc);
	579	get_word(func,pc);
	580	if (lua_pushfunction (file.w, func.w))
	581	return 1;
	582	}
	583	break;
	584
	585	case SETLINE:
	586	{
	587	CodeWord code;
	588	get_word(code,pc);
	589	lua_debugline = code.w;
	590	}
	591	break;
	592
	593	case RESET:
	594	lua_popfunction ();
	595	break;
	596
	597	default:
	598	lua_error ("internal error - opcode didn't match");
	599	return 1;
	600	}
	601	}
	602	}
	603
	604
	605	/*
	606	** Traverse all objects on stack
	607	*/
	608	void lua_travstack (void (fn)(Object ))
	609	{
	610	Object *o;
	611	for (o = top-1; o >= stack; o--)
	612	fn (o);
	613	}
	614
	615	/*
	616	** Open file, generate opcode and execute global statement. Return 0 on
	617	** success or 1 on error.
	618	*/
	619	int lua_dofile (char *filename)
	620	{
	621	if (lua_openfile (filename)) return 1;
	622	if (lua_parse ()) { lua_closefile (); return 1; }
	623	lua_closefile ();
	624	return 0;
	625	}
	626
	627	/*
	628	** Generate opcode stored on string and execute global statement. Return 0 on
	629	** success or 1 on error.
	630	*/
	631	int lua_dostring (char *string)
	632	{
	633	if (lua_openstring (string)) return 1;
	634	if (lua_parse ()) return 1;
	635	lua_closestring();
	636	return 0;
	637	}
	638
	639	/*
	640	** Execute the given function. Return 0 on success or 1 on error.
	641	*/
	642	int lua_call (char *functionname, int nparam)
	643	{
	644	static Byte startcode[] = {CALLFUNC, HALT};
	645	int i;
	646	Object func = s_object(lua_findsymbol(functionname));
	647	if (tag(&func) != T_FUNCTION) return 1;
	648	for (i=1; i<=nparam; i++)
	649	(top-i+2) = (top-i);
	650	top += 2;
	651	tag(top-nparam-1) = T_MARK;
	652	*(top-nparam-2) = func;
	653	return (lua_execute (startcode));
	654	}
	655
	656	/*
	657	** Get a parameter, returning the object handle or NULL on error.
	658	** 'number' must be 1 to get the first parameter.
	659	*/
	660	Object *lua_getparam (int number)
	661	{
	662	if (number <= 0 \|\| number > top-base) return NULL;
	663	return (base+number-1);
	664	}
	665
	666	/*
	667	** Given an object handle, return its number value. On error, return 0.0.
	668	*/
	669	real lua_getnumber (Object *object)
	670	{
	671	if (object == NULL \|\| tag(object) == T_NIL) return 0.0;
	672	if (tonumber (object)) return 0.0;
	673	else return (nvalue(object));
	674	}
	675
	676	/*
	677	** Given an object handle, return its string pointer. On error, return NULL.
	678	*/
	679	char lua_getstring (Object object)
	680	{
	681	if (object == NULL \|\| tag(object) == T_NIL) return NULL;
	682	if (tostring (object)) return NULL;
	683	else return (svalue(object));
	684	}
	685
	686	/*
	687	** Given an object handle, return a copy of its string. On error, return NULL.
	688	*/
	689	char lua_copystring (Object object)
	690	{
	691	if (object == NULL \|\| tag(object) == T_NIL) return NULL;
	692	if (tostring (object)) return NULL;
	693	else return (strdup(svalue(object)));
	694	}
	695
	696	/*
	697	** Given an object handle, return its cfuntion pointer. On error, return NULL.
	698	*/
	699	lua_CFunction lua_getcfunction (Object *object)
	700	{
	701	if (object == NULL) return NULL;
	702	if (tag(object) != T_CFUNCTION) return NULL;
	703	else return (fvalue(object));
	704	}
	705
	706	/*
	707	** Given an object handle, return its user data. On error, return NULL.
	708	*/
	709	void lua_getuserdata (Object object)
	710	{
	711	if (object == NULL) return NULL;
	712	if (tag(object) != T_USERDATA) return NULL;
	713	else return (uvalue(object));
	714	}
	715
	716	/*
	717	** Given an object handle and a field name, return its field object.
	718	** On error, return NULL.
	719	*/
	720	Object lua_getfield (Object object, char *field)
	721	{
	722	if (object == NULL) return NULL;
	723	if (tag(object) != T_ARRAY)
	724	return NULL;
	725	else
	726	{
	727	Object ref;
	728	tag(&ref) = T_STRING;
	729	svalue(&ref) = lua_createstring(lua_strdup(field));
	730	return (lua_hashdefine(avalue(object), &ref));
	731	}
	732	}
	733
	734	/*
	735	** Given an object handle and an index, return its indexed object.
	736	** On error, return NULL.
	737	*/
	738	Object lua_getindexed (Object object, float index)
	739	{
	740	if (object == NULL) return NULL;
	741	if (tag(object) != T_ARRAY)
	742	return NULL;
	743	else
	744	{
	745	Object ref;
	746	tag(&ref) = T_NUMBER;
	747	nvalue(&ref) = index;
	748	return (lua_hashdefine(avalue(object), &ref));
	749	}
	750	}
	751
	752	/*
	753	** Get a global object. Return the object handle or NULL on error.
	754	*/
	755	Object lua_getglobal (char name)
	756	{
	757	int n = lua_findsymbol(name);
	758	if (n < 0) return NULL;
	759	return &s_object(n);
	760	}
	761
	762	/*
	763	** Pop and return an object
	764	*/
	765	Object *lua_pop (void)
	766	{
	767	if (top <= base) return NULL;
	768	top--;
	769	return top;
	770	}
	771
	772	/*
	773	** Push a nil object
	774	*/
	775	int lua_pushnil (void)
	776	{
	777	if ((top-stack) >= MAXSTACK-1)
	778	{
	779	lua_error ("stack overflow");
	780	return 1;
	781	}
	782	tag(top) = T_NIL;
	783	return 0;
	784	}
	785
	786	/*
	787	** Push an object (tag=number) to stack. Return 0 on success or 1 on error.
	788	*/
	789	int lua_pushnumber (real n)
	790	{
	791	if ((top-stack) >= MAXSTACK-1)
	792	{
	793	lua_error ("stack overflow");
	794	return 1;
	795	}
	796	tag(top) = T_NUMBER; nvalue(top++) = n;
	797	return 0;
	798	}
	799
	800	/*
	801	** Push an object (tag=string) to stack. Return 0 on success or 1 on error.
	802	*/
	803	int lua_pushstring (char *s)
	804	{
	805	if ((top-stack) >= MAXSTACK-1)
	806	{
	807	lua_error ("stack overflow");
	808	return 1;
	809	}
	810	tag(top) = T_STRING;
	811	svalue(top++) = lua_createstring(lua_strdup(s));
	812	return 0;
	813	}
	814
	815	/*
	816	** Push an object (tag=cfunction) to stack. Return 0 on success or 1 on error.
	817	*/
	818	int lua_pushcfunction (lua_CFunction fn)
	819	{
	820	if ((top-stack) >= MAXSTACK-1)
	821	{
	822	lua_error ("stack overflow");
	823	return 1;
	824	}
	825	tag(top) = T_CFUNCTION; fvalue(top++) = fn;
	826	return 0;
	827	}
	828
	829	/*
	830	** Push an object (tag=userdata) to stack. Return 0 on success or 1 on error.
	831	*/
	832	int lua_pushuserdata (void *u)
	833	{
	834	if ((top-stack) >= MAXSTACK-1)
	835	{
	836	lua_error ("stack overflow");
	837	return 1;
	838	}
	839	tag(top) = T_USERDATA; uvalue(top++) = u;
	840	return 0;
	841	}
	842
	843	/*
	844	** Push an object to stack.
	845	*/
	846	int lua_pushobject (Object *o)
	847	{
	848	if ((top-stack) >= MAXSTACK-1)
	849	{
	850	lua_error ("stack overflow");
	851	return 1;
	852	}
	853	top++ = o;
	854	return 0;
	855	}
	856
	857	/*
	858	** Store top of the stack at a global variable array field.
	859	** Return 1 on error, 0 on success.
	860	*/
	861	int lua_storeglobal (char *name)
	862	{
	863	int n = lua_findsymbol (name);
	864	if (n < 0) return 1;
	865	if (tag(top-1) == T_MARK) return 1;
	866	s_object(n) = *(--top);
	867	return 0;
	868	}
	869
	870	/*
	871	** Store top of the stack at an array field. Return 1 on error, 0 on success.
	872	*/
	873	int lua_storefield (lua_Object object, char *field)
	874	{
	875	if (tag(object) != T_ARRAY)
	876	return 1;
	877	else
	878	{
	879	Object ref, *h;
	880	tag(&ref) = T_STRING;
	881	svalue(&ref) = lua_createstring(lua_strdup(field));
	882	h = lua_hashdefine(avalue(object), &ref);
	883	if (h == NULL) return 1;
	884	if (tag(top-1) == T_MARK) return 1;
	885	h = (--top);
	886	}
	887	return 0;
	888	}
	889
	890
	891	/*
	892	** Store top of the stack at an array index. Return 1 on error, 0 on success.
	893	*/
	894	int lua_storeindexed (lua_Object object, float index)
	895	{
	896	if (tag(object) != T_ARRAY)
	897	return 1;
	898	else
	899	{
	900	Object ref, *h;
	901	tag(&ref) = T_NUMBER;
	902	nvalue(&ref) = index;
	903	h = lua_hashdefine(avalue(object), &ref);
	904	if (h == NULL) return 1;
	905	if (tag(top-1) == T_MARK) return 1;
	906	h = (--top);
	907	}
	908	return 0;
	909	}
	910
	911
	912	/*
	913	** Given an object handle, return if it is nil.
	914	*/
	915	int lua_isnil (Object *object)
	916	{
	917	return (object != NULL && tag(object) == T_NIL);
	918	}
	919
	920	/*
	921	** Given an object handle, return if it is a number one.
	922	*/
	923	int lua_isnumber (Object *object)
	924	{
	925	return (object != NULL && tag(object) == T_NUMBER);
	926	}
	927
	928	/*
	929	** Given an object handle, return if it is a string one.
	930	*/
	931	int lua_isstring (Object *object)
	932	{
	933	return (object != NULL && tag(object) == T_STRING);
	934	}
	935
	936	/*
	937	** Given an object handle, return if it is an array one.
	938	*/
	939	int lua_istable (Object *object)
	940	{
	941	return (object != NULL && tag(object) == T_ARRAY);
	942	}
	943
	944	/*
	945	** Given an object handle, return if it is a cfunction one.
	946	*/
	947	int lua_iscfunction (Object *object)
	948	{
	949	return (object != NULL && tag(object) == T_CFUNCTION);
	950	}
	951
	952	/*
	953	** Given an object handle, return if it is an user data one.
	954	*/
	955	int lua_isuserdata (Object *object)
	956	{
	957	return (object != NULL && tag(object) == T_USERDATA);
	958	}
	959
	960	/*
	961	** Internal function: return an object type.
	962	*/
	963	void lua_type (void)
	964	{
	965	Object *o = lua_getparam(1);
	966	lua_pushstring (lua_constant[tag(o)]);
	967	}
	968
	969	/*
	970	** Internal function: convert an object to a number
	971	*/
	972	void lua_obj2number (void)
	973	{
	974	Object *o = lua_getparam(1);
	975	lua_pushobject (lua_convtonumber(o));
	976	}
	977
	978	/*
	979	** Internal function: print object values
	980	*/
	981	void lua_print (void)
	982	{
	983	int i=1;
	984	void *obj;
	985	while ((obj=lua_getparam (i++)) != NULL)
	986	{
	987	if (lua_isnumber(obj)) printf("%g\n",lua_getnumber (obj));
	988	else if (lua_isstring(obj)) printf("%s\n",lua_getstring (obj));
	989	else if (lua_iscfunction(obj)) printf("cfunction: %p\n",lua_getcfunction (obj));
	990	else if (lua_isuserdata(obj)) printf("userdata: %p\n",lua_getuserdata (obj));
	991	else if (lua_istable(obj)) printf("table: %p\n",obj);
	992	else if (lua_isnil(obj)) printf("nil\n");
	993	else printf("invalid value to print\n");
	994	}
	995	}
	996
	997	/*
	998	** Internal function: do a file
	999	*/
	1000	void lua_internaldofile (void)
	1001	{
	1002	lua_Object obj = lua_getparam (1);
	1003	if (lua_isstring(obj) && !lua_dofile(lua_getstring(obj)))
	1004	lua_pushnumber(1);
	1005	else
	1006	lua_pushnil();
	1007	}
	1008
	1009	/*
	1010	** Internal function: do a string
	1011	*/
	1012	void lua_internaldostring (void)
	1013	{
	1014	lua_Object obj = lua_getparam (1);
	1015	if (lua_isstring(obj) && !lua_dostring(lua_getstring(obj)))
	1016	lua_pushnumber(1);
	1017	else
	1018	lua_pushnil();
	1019	}
	1020
	1021

src/opcode.h+164−0

@@ -0,0 +1,164 @@
	1	/*
	2	** TeCGraf - PUC-Rio
	3	** $Id: opcode.h,v 2.1 1994/04/20 22:07:57 celes Exp $
	4	*/
	5
	6	#ifndef opcode_h
	7	#define opcode_h
	8
	9	#ifndef STACKGAP
	10	#define STACKGAP 128
	11	#endif
	12
	13	#ifndef real
	14	#define real float
	15	#endif
	16
	17	#define FIELDS_PER_FLUSH 40
	18
	19	typedef unsigned char Byte;
	20
	21	typedef unsigned short Word;
	22
	23	typedef union
	24	{
	25	struct {char c1; char c2;} m;
	26	Word w;
	27	} CodeWord;
	28
	29	typedef union
	30	{
	31	struct {char c1; char c2; char c3; char c4;} m;
	32	float f;
	33	} CodeFloat;
	34
	35	typedef enum
	36	{
	37	PUSHNIL,
	38	PUSH0, PUSH1, PUSH2,
	39	PUSHBYTE,
	40	PUSHWORD,
	41	PUSHFLOAT,
	42	PUSHSTRING,
	43	PUSHLOCAL0, PUSHLOCAL1, PUSHLOCAL2, PUSHLOCAL3, PUSHLOCAL4,
	44	PUSHLOCAL5, PUSHLOCAL6, PUSHLOCAL7, PUSHLOCAL8, PUSHLOCAL9,
	45	PUSHLOCAL,
	46	PUSHGLOBAL,
	47	PUSHINDEXED,
	48	PUSHMARK,
	49	PUSHOBJECT,
	50	STORELOCAL0, STORELOCAL1, STORELOCAL2, STORELOCAL3, STORELOCAL4,
	51	STORELOCAL5, STORELOCAL6, STORELOCAL7, STORELOCAL8, STORELOCAL9,
	52	STORELOCAL,
	53	STOREGLOBAL,
	54	STOREINDEXED0,
	55	STOREINDEXED,
	56	STORELIST0,
	57	STORELIST,
	58	STORERECORD,
	59	ADJUST,
	60	CREATEARRAY,
	61	EQOP,
	62	LTOP,
	63	LEOP,
	64	ADDOP,
	65	SUBOP,
	66	MULTOP,
	67	DIVOP,
	68	CONCOP,
	69	MINUSOP,
	70	NOTOP,
	71	ONTJMP,
	72	ONFJMP,
	73	JMP,
	74	UPJMP,
	75	IFFJMP,
	76	IFFUPJMP,
	77	POP,
	78	CALLFUNC,
	79	RETCODE,
	80	HALT,
	81	SETFUNCTION,
	82	SETLINE,
	83	RESET
	84	} OpCode;
	85
	86	typedef enum
	87	{
	88	T_MARK,
	89	T_NIL,
	90	T_NUMBER,
	91	T_STRING,
	92	T_ARRAY,
	93	T_FUNCTION,
	94	T_CFUNCTION,
	95	T_USERDATA
	96	} Type;
	97
	98	typedef void (*Cfunction) (void);
	99	typedef int (*Input) (void);
	100
	101	typedef union
	102	{
	103	Cfunction f;
	104	real n;
	105	char *s;
	106	Byte *b;
	107	struct Hash *a;
	108	void *u;
	109	} Value;
	110
	111	typedef struct Object
	112	{
	113	Type tag;
	114	Value value;
	115	} Object;
	116
	117	typedef struct
	118	{
	119	char *name;
	120	Object object;
	121	} Symbol;
	122
	123	/* Macros to access structure members */
	124	#define tag(o) ((o)->tag)
	125	#define nvalue(o) ((o)->value.n)
	126	#define svalue(o) ((o)->value.s)
	127	#define bvalue(o) ((o)->value.b)
	128	#define avalue(o) ((o)->value.a)
	129	#define fvalue(o) ((o)->value.f)
	130	#define uvalue(o) ((o)->value.u)
	131
	132	/* Macros to access symbol table */
	133	#define s_name(i) (lua_table[i].name)
	134	#define s_object(i) (lua_table[i].object)
	135	#define s_tag(i) (tag(&s_object(i)))
	136	#define s_nvalue(i) (nvalue(&s_object(i)))
	137	#define s_svalue(i) (svalue(&s_object(i)))
	138	#define s_bvalue(i) (bvalue(&s_object(i)))
	139	#define s_avalue(i) (avalue(&s_object(i)))
	140	#define s_fvalue(i) (fvalue(&s_object(i)))
	141	#define s_uvalue(i) (uvalue(&s_object(i)))
	142
	143	#define get_word(code,pc) {code.m.c1 = pc++; code.m.c2 = pc++;}
	144	#define get_float(code,pc) {code.m.c1 = pc++; code.m.c2 = pc++;\
	145	code.m.c3 = pc++; code.m.c4 = pc++;}
	146
	147
	148
	149	/* Exported functions */
	150	int lua_execute (Byte *pc);
	151	void lua_markstack (void);
	152	char lua_strdup (char l);
	153
	154	void lua_setinput (Input fn); /* from "lex.c" module */
	155	char lua_lasttext (void); / from "lex.c" module */
	156	int lua_parse (void); /* from "lua.stx" module */
	157	void lua_type (void);
	158	void lua_obj2number (void);
	159	void lua_print (void);
	160	void lua_internaldofile (void);
	161	void lua_internaldostring (void);
	162	void lua_travstack (void (fn)(Object ));
	163
	164	#endif

src/table.c+337−0

@@ -0,0 +1,337 @@
	1	/*
	2	** table.c
	3	** Module to control static tables
	4	*/
	5
	6	char *rcs_table="$Id: table.c,v 2.1 1994/04/20 22:07:57 celes Exp $";
	7
	8	#include <stdlib.h>
	9	#include <string.h>
	10
	11	#include "mm.h"
	12
	13	#include "opcode.h"
	14	#include "hash.h"
	15	#include "inout.h"
	16	#include "table.h"
	17	#include "lua.h"
	18
	19	#define streq(s1,s2) (s1[0]==s2[0]&&strcmp(s1+1,s2+1)==0)
	20
	21	#ifndef MAXSYMBOL
	22	#define MAXSYMBOL 512
	23	#endif
	24	static Symbol tablebuffer[MAXSYMBOL] = {
	25	{"type",{T_CFUNCTION,{lua_type}}},
	26	{"tonumber",{T_CFUNCTION,{lua_obj2number}}},
	27	{"next",{T_CFUNCTION,{lua_next}}},
	28	{"nextvar",{T_CFUNCTION,{lua_nextvar}}},
	29	{"print",{T_CFUNCTION,{lua_print}}},
	30	{"dofile",{T_CFUNCTION,{lua_internaldofile}}},
	31	{"dostring",{T_CFUNCTION,{lua_internaldostring}}}
	32	};
	33	Symbol *lua_table=tablebuffer;
	34	Word lua_ntable=7;
	35
	36	struct List
	37	{
	38	Symbol *s;
	39	struct List *next;
	40	};
	41
	42	static struct List o6={ tablebuffer+6, 0};
	43	static struct List o5={ tablebuffer+5, &o6 };
	44	static struct List o4={ tablebuffer+4, &o5 };
	45	static struct List o3={ tablebuffer+3, &o4 };
	46	static struct List o2={ tablebuffer+2, &o3 };
	47	static struct List o1={ tablebuffer+1, &o2 };
	48	static struct List o0={ tablebuffer+0, &o1 };
	49	static struct List *searchlist=&o0;
	50
	51	#ifndef MAXCONSTANT
	52	#define MAXCONSTANT 256
	53	#endif
	54	/* pre-defined constants need garbage collection extra byte */
	55	static char tm[] = " mark";
	56	static char ti[] = " nil";
	57	static char tn[] = " number";
	58	static char ts[] = " string";
	59	static char tt[] = " table";
	60	static char tf[] = " function";
	61	static char tc[] = " cfunction";
	62	static char tu[] = " userdata";
	63	static char *constantbuffer[MAXCONSTANT] = {tm+1, ti+1,
	64	tn+1, ts+1,
	65	tt+1, tf+1,
	66	tc+1, tu+1
	67	};
	68	char **lua_constant = constantbuffer;
	69	Word lua_nconstant=T_USERDATA+1;
	70
	71	#ifndef MAXSTRING
	72	#define MAXSTRING 512
	73	#endif
	74	static char *stringbuffer[MAXSTRING];
	75	char **lua_string = stringbuffer;
	76	Word lua_nstring=0;
	77
	78	#define MAXFILE 20
	79	char *lua_file[MAXFILE];
	80	int lua_nfile;
	81
	82
	83	#define markstring(s) (*((s)-1))
	84
	85
	86	/* Variables to controll garbage collection */
	87	Word lua_block=10; /* to check when garbage collector will be called */
	88	Word lua_nentity; /* counter of new entities (strings and arrays) */
	89
	90
	91	/*
	92	** Given a name, search it at symbol table and return its index. If not
	93	** found, allocate at end of table, checking oveflow and return its index.
	94	** On error, return -1.
	95	*/
	96	int lua_findsymbol (char *s)
	97	{
	98	struct List l, p;
	99	for (p=NULL, l=searchlist; l!=NULL; p=l, l=l->next)
	100	if (streq(s,l->s->name))
	101	{
	102	if (p!=NULL)
	103	{
	104	p->next = l->next;
	105	l->next = searchlist;
	106	searchlist = l;
	107	}
	108	return (l->s-lua_table);
	109	}
	110
	111	if (lua_ntable >= MAXSYMBOL-1)
	112	{
	113	lua_error ("symbol table overflow");
	114	return -1;
	115	}
	116	s_name(lua_ntable) = strdup(s);
	117	if (s_name(lua_ntable) == NULL)
	118	{
	119	lua_error ("not enough memory");
	120	return -1;
	121	}
	122	s_tag(lua_ntable) = T_NIL;
	123	p = malloc(sizeof(*p));
	124	p->s = lua_table+lua_ntable;
	125	p->next = searchlist;
	126	searchlist = p;
	127
	128	return lua_ntable++;
	129	}
	130
	131	/*
	132	** Given a constant string, search it at constant table and return its index.
	133	** If not found, allocate at end of the table, checking oveflow and return
	134	** its index.
	135	**
	136	** For each allocation, the function allocate a extra char to be used to
	137	** mark used string (it's necessary to deal with constant and string
	138	** uniformily). The function store at the table the second position allocated,
	139	** that represents the beginning of the real string. On error, return -1.
	140	**
	141	*/
	142	int lua_findconstant (char *s)
	143	{
	144	int i;
	145	for (i=0; i<lua_nconstant; i++)
	146	if (streq(s,lua_constant[i]))
	147	return i;
	148	if (lua_nconstant >= MAXCONSTANT-1)
	149	{
	150	lua_error ("lua: constant string table overflow");
	151	return -1;
	152	}
	153	{
	154	char *c = calloc(strlen(s)+2,sizeof(char));
	155	c++; /* create mark space */
	156	lua_constant[lua_nconstant++] = strcpy(c,s);
	157	}
	158	return (lua_nconstant-1);
	159	}
	160
	161
	162	/*
	163	** Traverse symbol table objects
	164	*/
	165	void lua_travsymbol (void (fn)(Object ))
	166	{
	167	int i;
	168	for (i=0; i<lua_ntable; i++)
	169	fn(&s_object(i));
	170	}
	171
	172
	173	/*
	174	** Mark an object if it is a string or a unmarked array.
	175	*/
	176	void lua_markobject (Object *o)
	177	{
	178	if (tag(o) == T_STRING)
	179	markstring (svalue(o)) = 1;
	180	else if (tag(o) == T_ARRAY)
	181	lua_hashmark (avalue(o));
	182	}
	183
	184
	185	/*
	186	** Garbage collection.
	187	** Delete all unused strings and arrays.
	188	*/
	189	void lua_pack (void)
	190	{
	191	/* mark stack strings */
	192	lua_travstack(lua_markobject);
	193
	194	/* mark symbol table strings */
	195	lua_travsymbol(lua_markobject);
	196
	197	lua_stringcollector();
	198	lua_hashcollector();
	199
	200	lua_nentity = 0; /* reset counter */
	201	}
	202
	203	/*
	204	** Garbage collection to atrings.
	205	** Delete all unmarked strings
	206	*/
	207	void lua_stringcollector (void)
	208	{
	209	int i, j;
	210	for (i=j=0; i<lua_nstring; i++)
	211	if (markstring(lua_string[i]) == 1)
	212	{
	213	lua_string[j++] = lua_string[i];
	214	markstring(lua_string[i]) = 0;
	215	}
	216	else
	217	{
	218	free (lua_string[i]-1);
	219	}
	220	lua_nstring = j;
	221	}
	222
	223	/*
	224	** Allocate a new string at string table. The given string is already
	225	** allocated with mark space and the function puts it at the end of the
	226	** table, checking overflow, and returns its own pointer, or NULL on error.
	227	*/
	228	char lua_createstring (char s)
	229	{
	230	int i;
	231	if (s == NULL) return NULL;
	232
	233	for (i=0; i<lua_nstring; i++)
	234	if (streq(s,lua_string[i]))
	235	{
	236	free(s-1);
	237	return lua_string[i];
	238	}
	239
	240	if (lua_nentity == lua_block \|\| lua_nstring >= MAXSTRING-1)
	241	{
	242	lua_pack ();
	243	if (lua_nstring >= MAXSTRING-1)
	244	{
	245	lua_error ("string table overflow");
	246	return NULL;
	247	}
	248	}
	249	lua_string[lua_nstring++] = s;
	250	lua_nentity++;
	251	return s;
	252	}
	253
	254	/*
	255	** Add a file name at file table, checking overflow. This function also set
	256	** the external variable "lua_filename" with the function filename set.
	257	** Return 0 on success or 1 on error.
	258	*/
	259	int lua_addfile (char *fn)
	260	{
	261	if (lua_nfile >= MAXFILE-1)
	262	{
	263	lua_error ("too many files");
	264	return 1;
	265	}
	266	if ((lua_file[lua_nfile++] = strdup (fn)) == NULL)
	267	{
	268	lua_error ("not enough memory");
	269	return 1;
	270	}
	271	return 0;
	272	}
	273
	274	/*
	275	** Delete a file from file stack
	276	*/
	277	int lua_delfile (void)
	278	{
	279	lua_nfile--;
	280	return 1;
	281	}
	282
	283	/*
	284	** Return the last file name set.
	285	*/
	286	char *lua_filename (void)
	287	{
	288	return lua_file[lua_nfile-1];
	289	}
	290
	291	/*
	292	** Internal function: return next global variable
	293	*/
	294	void lua_nextvar (void)
	295	{
	296	int index;
	297	Object *o = lua_getparam (1);
	298	if (o == NULL)
	299	{ lua_error ("too few arguments to function `nextvar'"); return; }
	300	if (lua_getparam (2) != NULL)
	301	{ lua_error ("too many arguments to function `nextvar'"); return; }
	302	if (tag(o) == T_NIL)
	303	{
	304	index = 0;
	305	}
	306	else if (tag(o) != T_STRING)
	307	{
	308	lua_error ("incorrect argument to function `nextvar'");
	309	return;
	310	}
	311	else
	312	{
	313	for (index=0; index<lua_ntable; index++)
	314	if (streq(s_name(index),svalue(o))) break;
	315	if (index == lua_ntable)
	316	{
	317	lua_error ("name not found in function `nextvar'");
	318	return;
	319	}
	320	index++;
	321	while (index < lua_ntable && tag(&s_object(index)) == T_NIL) index++;
	322
	323	if (index == lua_ntable)
	324	{
	325	lua_pushnil();
	326	lua_pushnil();
	327	return;
	328	}
	329	}
	330	{
	331	Object name;
	332	tag(&name) = T_STRING;
	333	svalue(&name) = lua_createstring(lua_strdup(s_name(index)));
	334	if (lua_pushobject (&name)) return;
	335	if (lua_pushobject (&s_object(index))) return;
	336	}
	337	}

src/table.h+42−0

@@ -0,0 +1,42 @@
	1	/*
	2	** Module to control static tables
	3	** TeCGraf - PUC-Rio
	4	** $Id: table.h,v 2.1 1994/04/20 22:07:57 celes Exp $
	5	*/
	6
	7	#ifndef table_h
	8	#define table_h
	9
	10	extern Symbol *lua_table;
	11	extern Word lua_ntable;
	12
	13	extern char **lua_constant;
	14	extern Word lua_nconstant;
	15
	16	extern char **lua_string;
	17	extern Word lua_nstring;
	18
	19	extern Hash **lua_array;
	20	extern Word lua_narray;
	21
	22	extern char *lua_file[];
	23	extern int lua_nfile;
	24
	25	extern Word lua_block;
	26	extern Word lua_nentity;
	27
	28
	29
	30	int lua_findsymbol (char *s);
	31	int lua_findconstant (char *s);
	32	void lua_travsymbol (void (fn)(Object ));
	33	void lua_markobject (Object *o);
	34	void lua_pack (void);
	35	void lua_stringcollector (void);
	36	char lua_createstring (char s);
	37	int lua_addfile (char *fn);
	38	int lua_delfile (void);
	39	char *lua_filename (void);
	40	void lua_nextvar (void);
	41
	42	#endif

src/y.tab.c+1811−0

@@ -0,0 +1,1811 @@
	1
	2	# line 2 "lua.stx"
	3
	4	char *rcs_luastx = "$Id: lua.stx,v 2.4 1994/04/20 16:22:21 celes Exp $";
	5
	6	#include <stdio.h>
	7	#include <stdlib.h>
	8	#include <string.h>
	9
	10	#include "mm.h"
	11
	12	#include "opcode.h"
	13	#include "hash.h"
	14	#include "inout.h"
	15	#include "table.h"
	16	#include "lua.h"
	17
	18	#define LISTING 0
	19
	20	#ifndef GAPCODE
	21	#define GAPCODE 50
	22	#endif
	23	static Word maxcode;
	24	static Word maxmain;
	25	static Word maxcurr ;
	26	static Byte *code = NULL;
	27	static Byte *initcode;
	28	static Byte *basepc;
	29	static Word maincode;
	30	static Word pc;
	31
	32	#define MAXVAR 32
	33	static long varbuffer[MAXVAR]; /* variables in an assignment list;
	34	it's long to store negative Word values */
	35	static int nvarbuffer=0; /* number of variables at a list */
	36
	37	static Word localvar[STACKGAP]; /* store local variable names */
	38	static int nlocalvar=0; /* number of local variables */
	39
	40	#define MAXFIELDS FIELDS_PER_FLUSH*2
	41	static Word fields[MAXFIELDS]; /* fieldnames to be flushed */
	42	static int nfields=0;
	43	static int ntemp; /* number of temporary var into stack */
	44	static int err; /* flag to indicate error */
	45
	46	/* Internal functions */
	47
	48	static void code_byte (Byte c)
	49	{
	50	if (pc>maxcurr-2) /* 1 byte free to code HALT of main code */
	51	{
	52	maxcurr += GAPCODE;
	53	basepc = (Byte )realloc(basepc, maxcurrsizeof(Byte));
	54	if (basepc == NULL)
	55	{
	56	lua_error ("not enough memory");
	57	err = 1;
	58	}
	59	}
	60	basepc[pc++] = c;
	61	}
	62
	63	static void code_word (Word n)
	64	{
	65	CodeWord code;
	66	code.w = n;
	67	code_byte(code.m.c1);
	68	code_byte(code.m.c2);
	69	}
	70
	71	static void code_float (float n)
	72	{
	73	CodeFloat code;
	74	code.f = n;
	75	code_byte(code.m.c1);
	76	code_byte(code.m.c2);
	77	code_byte(code.m.c3);
	78	code_byte(code.m.c4);
	79	}
	80
	81	static void code_word_at (Byte *p, Word n)
	82	{
	83	CodeWord code;
	84	code.w = n;
	85	*p++ = code.m.c1;
	86	*p++ = code.m.c2;
	87	}
	88
	89	static void push_field (Word name)
	90	{
	91	if (nfields < STACKGAP-1)
	92	fields[nfields++] = name;
	93	else
	94	{
	95	lua_error ("too many fields in a constructor");
	96	err = 1;
	97	}
	98	}
	99
	100	static void flush_record (int n)
	101	{
	102	int i;
	103	if (n == 0) return;
	104	code_byte(STORERECORD);
	105	code_byte(n);
	106	for (i=0; i<n; i++)
	107	code_word(fields[--nfields]);
	108	ntemp -= n;
	109	}
	110
	111	static void flush_list (int m, int n)
	112	{
	113	if (n == 0) return;
	114	if (m == 0)
	115	code_byte(STORELIST0);
	116	else
	117	{
	118	code_byte(STORELIST);
	119	code_byte(m);
	120	}
	121	code_byte(n);
	122	ntemp-=n;
	123	}
	124
	125	static void incr_ntemp (void)
	126	{
	127	if (ntemp+nlocalvar+MAXVAR+1 < STACKGAP)
	128	ntemp++;
	129	else
	130	{
	131	lua_error ("stack overflow");
	132	err = 1;
	133	}
	134	}
	135
	136	static void add_nlocalvar (int n)
	137	{
	138	if (ntemp+nlocalvar+MAXVAR+n < STACKGAP)
	139	nlocalvar += n;
	140	else
	141	{
	142	lua_error ("too many local variables or expression too complicate");
	143	err = 1;
	144	}
	145	}
	146
	147	static void incr_nvarbuffer (void)
	148	{
	149	if (nvarbuffer < MAXVAR-1)
	150	nvarbuffer++;
	151	else
	152	{
	153	lua_error ("variable buffer overflow");
	154	err = 1;
	155	}
	156	}
	157
	158	static void code_number (float f)
	159	{ Word i = (Word)f;
	160	if (f == (float)i) /* f has an (short) integer value */
	161	{
	162	if (i <= 2) code_byte(PUSH0 + i);
	163	else if (i <= 255)
	164	{
	165	code_byte(PUSHBYTE);
	166	code_byte(i);
	167	}
	168	else
	169	{
	170	code_byte(PUSHWORD);
	171	code_word(i);
	172	}
	173	}
	174	else
	175	{
	176	code_byte(PUSHFLOAT);
	177	code_float(f);
	178	}
	179	incr_ntemp();
	180	}
	181
	182
	183	# line 184 "lua.stx"
	184	typedef union
	185	{
	186	int vInt;
	187	long vLong;
	188	float vFloat;
	189	char *pChar;
	190	Word vWord;
	191	Byte *pByte;
	192	} YYSTYPE;
	193	# define WRONGTOKEN 257
	194	# define NIL 258
	195	# define IF 259
	196	# define THEN 260
	197	# define ELSE 261
	198	# define ELSEIF 262
	199	# define WHILE 263
	200	# define DO 264
	201	# define REPEAT 265
	202	# define UNTIL 266
	203	# define END 267
	204	# define RETURN 268
	205	# define LOCAL 269
	206	# define NUMBER 270
	207	# define FUNCTION 271
	208	# define STRING 272
	209	# define NAME 273
	210	# define DEBUG 274
	211	# define AND 275
	212	# define OR 276
	213	# define NE 277
	214	# define LE 278
	215	# define GE 279
	216	# define CONC 280
	217	# define UNARY 281
	218	# define NOT 282
	219	#define yyclearin yychar = -1
	220	#define yyerrok yyerrflag = 0
	221	extern int yychar;
	222	extern int yyerrflag;
	223	#ifndef YYMAXDEPTH
	224	#define YYMAXDEPTH 150
	225	#endif
	226	YYSTYPE yylval, yyval;
	227	# define YYERRCODE 256
	228
	229	# line 622 "lua.stx"
	230
	231
	232	/*
	233	** Search a local name and if find return its index. If do not find return -1
	234	*/
	235	static int lua_localname (Word n)
	236	{
	237	int i;
	238	for (i=nlocalvar-1; i >= 0; i--)
	239	if (n == localvar[i]) return i; /* local var */
	240	return -1; /* global var */
	241	}
	242
	243	/*
	244	** Push a variable given a number. If number is positive, push global variable
	245	** indexed by (number -1). If negative, push local indexed by ABS(number)-1.
	246	** Otherwise, if zero, push indexed variable (record).
	247	*/
	248	static void lua_pushvar (long number)
	249	{
	250	if (number > 0) /* global var */
	251	{
	252	code_byte(PUSHGLOBAL);
	253	code_word(number-1);
	254	incr_ntemp();
	255	}
	256	else if (number < 0) /* local var */
	257	{
	258	number = (-number) - 1;
	259	if (number < 10) code_byte(PUSHLOCAL0 + number);
	260	else
	261	{
	262	code_byte(PUSHLOCAL);
	263	code_byte(number);
	264	}
	265	incr_ntemp();
	266	}
	267	else
	268	{
	269	code_byte(PUSHINDEXED);
	270	ntemp--;
	271	}
	272	}
	273
	274	static void lua_codeadjust (int n)
	275	{
	276	code_byte(ADJUST);
	277	code_byte(n + nlocalvar);
	278	}
	279
	280	static void lua_codestore (int i)
	281	{
	282	if (varbuffer[i] > 0) /* global var */
	283	{
	284	code_byte(STOREGLOBAL);
	285	code_word(varbuffer[i]-1);
	286	}
	287	else if (varbuffer[i] < 0) /* local var */
	288	{
	289	int number = (-varbuffer[i]) - 1;
	290	if (number < 10) code_byte(STORELOCAL0 + number);
	291	else
	292	{
	293	code_byte(STORELOCAL);
	294	code_byte(number);
	295	}
	296	}
	297	else /* indexed var */
	298	{
	299	int j;
	300	int upper=0; /* number of indexed variables upper */
	301	int param; /* number of itens until indexed expression */
	302	for (j=i+1; j <nvarbuffer; j++)
	303	if (varbuffer[j] == 0) upper++;
	304	param = upper*2 + i;
	305	if (param == 0)
	306	code_byte(STOREINDEXED0);
	307	else
	308	{
	309	code_byte(STOREINDEXED);
	310	code_byte(param);
	311	}
	312	}
	313	}
	314
	315	void yyerror (char *s)
	316	{
	317	static char msg[256];
	318	sprintf (msg,"%s near \"%s\" at line %d in file \"%s\"",
	319	s, lua_lasttext (), lua_linenumber, lua_filename());
	320	lua_error (msg);
	321	err = 1;
	322	}
	323
	324	int yywrap (void)
	325	{
	326	return 1;
	327	}
	328
	329
	330	/*
	331	** Parse LUA code and execute global statement.
	332	** Return 0 on success or 1 on error.
	333	*/
	334	int lua_parse (void)
	335	{
	336	Byte init = initcode = (Byte ) calloc(GAPCODE, sizeof(Byte));
	337	maincode = 0;
	338	maxmain = GAPCODE;
	339	if (init == NULL)
	340	{
	341	lua_error("not enough memory");
	342	return 1;
	343	}
	344	err = 0;
	345	if (yyparse () \|\| (err==1)) return 1;
	346	initcode[maincode++] = HALT;
	347	init = initcode;
	348	#if LISTING
	349	PrintCode(init,init+maincode);
	350	#endif
	351	if (lua_execute (init)) return 1;
	352	free(init);
	353	return 0;
	354	}
	355
	356
	357	#if LISTING
	358
	359	static void PrintCode (Byte code, Byte end)
	360	{
	361	Byte *p = code;
	362	printf ("\n\nCODE\n");
	363	while (p != end)
	364	{
	365	switch ((OpCode)*p)
	366	{
	367	case PUSHNIL: printf ("%d PUSHNIL\n", (p++)-code); break;
	368	case PUSH0: case PUSH1: case PUSH2:
	369	printf ("%d PUSH%c\n", p-code, *p-PUSH0+'0');
	370	p++;
	371	break;
	372	case PUSHBYTE:
	373	printf ("%d PUSHBYTE %d\n", p-code, *(++p));
	374	p++;
	375	break;
	376	case PUSHWORD:
	377	{
	378	CodeWord c;
	379	int n = p-code;
	380	p++;
	381	get_word(c,p);
	382	printf ("%d PUSHWORD %d\n", n, c.w);
	383	}
	384	break;
	385	case PUSHFLOAT:
	386	{
	387	CodeFloat c;
	388	int n = p-code;
	389	p++;
	390	get_float(c,p);
	391	printf ("%d PUSHFLOAT %f\n", n, c.f);
	392	}
	393	break;
	394	case PUSHSTRING:
	395	{
	396	CodeWord c;
	397	int n = p-code;
	398	p++;
	399	get_word(c,p);
	400	printf ("%d PUSHSTRING %d\n", n, c.w);
	401	}
	402	break;
	403	case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
	404	case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
	405	case PUSHLOCAL8: case PUSHLOCAL9:
	406	printf ("%d PUSHLOCAL%c\n", p-code, *p-PUSHLOCAL0+'0');
	407	p++;
	408	break;
	409	case PUSHLOCAL: printf ("%d PUSHLOCAL %d\n", p-code, *(++p));
	410	p++;
	411	break;
	412	case PUSHGLOBAL:
	413	{
	414	CodeWord c;
	415	int n = p-code;
	416	p++;
	417	get_word(c,p);
	418	printf ("%d PUSHGLOBAL %d\n", n, c.w);
	419	}
	420	break;
	421	case PUSHINDEXED: printf ("%d PUSHINDEXED\n", (p++)-code); break;
	422	case PUSHMARK: printf ("%d PUSHMARK\n", (p++)-code); break;
	423	case PUSHOBJECT: printf ("%d PUSHOBJECT\n", (p++)-code); break;
	424	case STORELOCAL0: case STORELOCAL1: case STORELOCAL2: case STORELOCAL3:
	425	case STORELOCAL4: case STORELOCAL5: case STORELOCAL6: case STORELOCAL7:
	426	case STORELOCAL8: case STORELOCAL9:
	427	printf ("%d STORELOCAL%c\n", p-code, *p-STORELOCAL0+'0');
	428	p++;
	429	break;
	430	case STORELOCAL:
	431	printf ("%d STORELOCAL %d\n", p-code, *(++p));
	432	p++;
	433	break;
	434	case STOREGLOBAL:
	435	{
	436	CodeWord c;
	437	int n = p-code;
	438	p++;
	439	get_word(c,p);
	440	printf ("%d STOREGLOBAL %d\n", n, c.w);
	441	}
	442	break;
	443	case STOREINDEXED0: printf ("%d STOREINDEXED0\n", (p++)-code); break;
	444	case STOREINDEXED: printf ("%d STOREINDEXED %d\n", p-code, *(++p));
	445	p++;
	446	break;
	447	case STORELIST0:
	448	printf("%d STORELIST0 %d\n", p-code, *(++p));
	449	p++;
	450	break;
	451	case STORELIST:
	452	printf("%d STORELIST %d %d\n", p-code, (p+1), (p+2));
	453	p+=3;
	454	break;
	455	case STORERECORD:
	456	printf("%d STORERECORD %d\n", p-code, *(++p));
	457	p += psizeof(Word) + 1;
	458	break;
	459	case ADJUST:
	460	printf ("%d ADJUST %d\n", p-code, *(++p));
	461	p++;
	462	break;
	463	case CREATEARRAY: printf ("%d CREATEARRAY\n", (p++)-code); break;
	464	case EQOP: printf ("%d EQOP\n", (p++)-code); break;
	465	case LTOP: printf ("%d LTOP\n", (p++)-code); break;
	466	case LEOP: printf ("%d LEOP\n", (p++)-code); break;
	467	case ADDOP: printf ("%d ADDOP\n", (p++)-code); break;
	468	case SUBOP: printf ("%d SUBOP\n", (p++)-code); break;
	469	case MULTOP: printf ("%d MULTOP\n", (p++)-code); break;
	470	case DIVOP: printf ("%d DIVOP\n", (p++)-code); break;
	471	case CONCOP: printf ("%d CONCOP\n", (p++)-code); break;
	472	case MINUSOP: printf ("%d MINUSOP\n", (p++)-code); break;
	473	case NOTOP: printf ("%d NOTOP\n", (p++)-code); break;
	474	case ONTJMP:
	475	{
	476	CodeWord c;
	477	int n = p-code;
	478	p++;
	479	get_word(c,p);
	480	printf ("%d ONTJMP %d\n", n, c.w);
	481	}
	482	break;
	483	case ONFJMP:
	484	{
	485	CodeWord c;
	486	int n = p-code;
	487	p++;
	488	get_word(c,p);
	489	printf ("%d ONFJMP %d\n", n, c.w);
	490	}
	491	break;
	492	case JMP:
	493	{
	494	CodeWord c;
	495	int n = p-code;
	496	p++;
	497	get_word(c,p);
	498	printf ("%d JMP %d\n", n, c.w);
	499	}
	500	break;
	501	case UPJMP:
	502	{
	503	CodeWord c;
	504	int n = p-code;
	505	p++;
	506	get_word(c,p);
	507	printf ("%d UPJMP %d\n", n, c.w);
	508	}
	509	break;
	510	case IFFJMP:
	511	{
	512	CodeWord c;
	513	int n = p-code;
	514	p++;
	515	get_word(c,p);
	516	printf ("%d IFFJMP %d\n", n, c.w);
	517	}
	518	break;
	519	case IFFUPJMP:
	520	{
	521	CodeWord c;
	522	int n = p-code;
	523	p++;
	524	get_word(c,p);
	525	printf ("%d IFFUPJMP %d\n", n, c.w);
	526	}
	527	break;
	528	case POP: printf ("%d POP\n", (p++)-code); break;
	529	case CALLFUNC: printf ("%d CALLFUNC\n", (p++)-code); break;
	530	case RETCODE:
	531	printf ("%d RETCODE %d\n", p-code, *(++p));
	532	p++;
	533	break;
	534	case HALT: printf ("%d HALT\n", (p++)-code); break;
	535	case SETFUNCTION:
	536	{
	537	CodeWord c1, c2;
	538	int n = p-code;
	539	p++;
	540	get_word(c1,p);
	541	get_word(c2,p);
	542	printf ("%d SETFUNCTION %d %d\n", n, c1.w, c2.w);
	543	}
	544	break;
	545	case SETLINE:
	546	{
	547	CodeWord c;
	548	int n = p-code;
	549	p++;
	550	get_word(c,p);
	551	printf ("%d SETLINE %d\n", n, c.w);
	552	}
	553	break;
	554
	555	case RESET: printf ("%d RESET\n", (p++)-code); break;
	556	default: printf ("%d Cannot happen: code %d\n", (p++)-code, *(p-1)); break;
	557	}
	558	}
	559	}
	560	#endif
	561
	562	int yyexca[] ={
	563	-1, 1,
	564	0, -1,
	565	-2, 2,
	566	-1, 20,
	567	40, 67,
	568	91, 94,
	569	46, 96,
	570	-2, 91,
	571	-1, 32,
	572	40, 67,
	573	91, 94,
	574	46, 96,
	575	-2, 51,
	576	-1, 73,
	577	275, 34,
	578	276, 34,
	579	61, 34,
	580	277, 34,
	581	62, 34,
	582	60, 34,
	583	278, 34,
	584	279, 34,
	585	280, 34,
	586	43, 34,
	587	45, 34,
	588	42, 34,
	589	47, 34,
	590	-2, 70,
	591	-1, 74,
	592	91, 94,
	593	46, 96,
	594	-2, 92,
	595	-1, 105,
	596	261, 28,
	597	262, 28,
	598	266, 28,
	599	267, 28,
	600	268, 28,
	601	-2, 11,
	602	-1, 125,
	603	268, 31,
	604	-2, 30,
	605	-1, 146,
	606	275, 34,
	607	276, 34,
	608	61, 34,
	609	277, 34,
	610	62, 34,
	611	60, 34,
	612	278, 34,
	613	279, 34,
	614	280, 34,
	615	43, 34,
	616	45, 34,
	617	42, 34,
	618	47, 34,
	619	-2, 72,
	620	};
	621	# define YYNPROD 103
	622	# define YYLAST 364
	623	int yyact[]={
	624
	625	58, 56, 22, 57, 132, 59, 58, 56, 137, 57,
	626	110, 59, 58, 56, 107, 57, 85, 59, 51, 50,
	627	52, 82, 23, 43, 51, 50, 52, 58, 56, 9,
	628	57, 157, 59, 58, 56, 165, 57, 5, 59, 162,
	629	6, 161, 104, 154, 155, 51, 50, 52, 64, 153,
	630	70, 51, 50, 52, 26, 58, 56, 127, 57, 10,
	631	59, 111, 25, 78, 27, 58, 56, 28, 57, 29,
	632	59, 131, 147, 51, 50, 52, 7, 65, 66, 115,
	633	150, 112, 63, 51, 50, 52, 68, 69, 31, 159,
	634	11, 79, 58, 76, 128, 73, 41, 59, 151, 87,
	635	88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	636	77, 114, 148, 40, 58, 56, 102, 57, 106, 59,
	637	117, 32, 72, 121, 116, 100, 80, 109, 67, 48,
	638	20, 36, 73, 30, 45, 73, 44, 118, 149, 84,
	639	17, 126, 18, 46, 21, 47, 120, 119, 101, 145,
	640	144, 125, 71, 123, 75, 39, 38, 12, 8, 108,
	641	105, 136, 83, 74, 135, 24, 4, 3, 139, 140,
	642	2, 81, 134, 141, 133, 130, 129, 42, 113, 16,
	643	1, 146, 124, 0, 143, 0, 0, 152, 0, 0,
	644	0, 86, 0, 0, 0, 0, 0, 13, 0, 0,
	645	160, 14, 0, 15, 164, 163, 0, 19, 167, 0,
	646	0, 23, 73, 0, 0, 0, 0, 0, 168, 166,
	647	158, 171, 173, 0, 0, 0, 169, 0, 0, 0,
	648	0, 0, 0, 61, 62, 53, 54, 55, 60, 61,
	649	62, 53, 54, 55, 60, 0, 0, 0, 0, 103,
	650	60, 49, 0, 98, 99, 0, 0, 0, 0, 0,
	651	61, 62, 53, 54, 55, 60, 61, 62, 53, 54,
	652	55, 60, 0, 0, 0, 0, 0, 0, 0, 0,
	653	0, 0, 35, 0, 0, 0, 0, 0, 61, 62,
	654	53, 54, 55, 60, 33, 122, 34, 23, 0, 0,
	655	53, 54, 55, 60, 0, 0, 37, 0, 0, 0,
	656	138, 0, 0, 0, 0, 142, 0, 0, 0, 0,
	657	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	658	0, 0, 0, 156, 0, 0, 0, 0, 0, 0,
	659	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	660	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	661	170, 0, 0, 172 };
	662	int yypact[]={
	663
	664	-1000, -234, -1000, -1000, -1000, -244, -1000, 31, -62, -1000,
	665	-1000, -1000, -1000, 24, -1000, -1000, 52, -1000, -1000, -250,
	666	-1000, -1000, -1000, -1000, 89, -9, -1000, 24, 24, 24,
	667	-1000, 88, -1000, -1000, -1000, -1000, -1000, 24, 24, -1000,
	668	24, -251, 49, -1000, -28, 45, 86, -252, -257, -1000,
	669	24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
	670	24, -1000, -1000, 84, 13, -1000, -1000, 24, -1000, -15,
	671	-224, -1000, 74, -1000, -1000, -1000, -259, 24, 24, -263,
	672	24, -12, -1000, 83, 76, -1000, -1000, -30, -30, -30,
	673	-30, -30, -30, 50, 50, -1000, -1000, 72, -1000, -1000,
	674	-1000, 82, 13, -1000, 24, -1000, -1000, -1000, 74, -36,
	675	-1000, 53, 74, -1000, -269, 24, -1000, -265, -1000, 24,
	676	24, -1000, -1000, 13, 31, -1000, 24, -1000, -1000, -53,
	677	68, -1000, -1000, -13, 54, 13, -1000, -1000, -218, 23,
	678	23, -1000, -1000, -1000, -1000, -237, -1000, -1000, -269, 28,
	679	-1000, 24, -226, -228, -1000, 24, -232, 24, -1000, 24,
	680	13, -1000, -1000, -1000, -42, -1000, 31, 13, -1000, -1000,
	681	-1000, -1000, -218, -1000 };
	682	int yypgo[]={
	683
	684	0, 180, 191, 54, 61, 81, 179, 133, 178, 177,
	685	176, 175, 174, 172, 121, 171, 170, 76, 59, 167,
	686	166, 165, 162, 161, 50, 160, 158, 157, 48, 49,
	687	156, 155, 131, 154, 152, 151, 150, 149, 148, 147,
	688	146, 145, 144, 143, 141, 139, 71, 138, 136, 134 };
	689	int yyr1[]={
	690
	691	0, 1, 16, 1, 1, 1, 21, 23, 19, 25,
	692	25, 26, 17, 18, 18, 27, 30, 27, 31, 27,
	693	27, 27, 27, 27, 29, 29, 29, 34, 35, 24,
	694	36, 37, 36, 2, 28, 3, 3, 3, 3, 3,
	695	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
	696	3, 3, 3, 3, 3, 3, 3, 39, 3, 40,
	697	3, 41, 7, 38, 38, 43, 32, 42, 4, 4,
	698	5, 44, 5, 22, 22, 45, 45, 15, 15, 8,
	699	8, 10, 10, 11, 11, 47, 46, 12, 12, 13,
	700	13, 6, 6, 14, 48, 14, 49, 14, 9, 9,
	701	33, 33, 20 };
	702	int yyr2[]={
	703
	704	0, 0, 1, 9, 4, 4, 1, 1, 19, 0,
	705	6, 1, 4, 0, 2, 17, 1, 17, 1, 13,
	706	7, 3, 3, 7, 0, 4, 15, 1, 1, 9,
	707	0, 1, 9, 1, 3, 7, 7, 7, 7, 7,
	708	7, 7, 7, 7, 7, 7, 7, 5, 5, 3,
	709	9, 3, 3, 3, 3, 3, 5, 1, 11, 1,
	710	11, 1, 9, 1, 2, 1, 11, 3, 1, 3,
	711	3, 1, 9, 0, 2, 3, 7, 1, 3, 7,
	712	7, 1, 3, 3, 7, 1, 9, 1, 3, 3,
	713	7, 3, 7, 3, 1, 11, 1, 9, 3, 7,
	714	0, 4, 3 };
	715	int yychk[]={
	716
	717	-1000, -1, -16, -19, -20, 271, 274, -17, -26, 273,
	718	-18, 59, -27, 259, 263, 265, -6, -32, -7, 269,
	719	-14, -42, 64, 273, -21, -28, -3, 40, 43, 45,
	720	-7, 64, -14, 270, 272, 258, -32, 282, -30, -31,
	721	61, 44, -9, 273, -48, -49, -43, -41, 40, 260,
	722	61, 60, 62, 277, 278, 279, 43, 45, 42, 47,
	723	280, 275, 276, -3, -28, -28, -28, 40, -28, -28,
	724	-24, -34, -5, -3, -14, -33, 44, 61, 91, 46,
	725	40, -15, 273, -22, -45, 273, -2, -28, -28, -28,
	726	-28, -28, -28, -28, -28, -28, -28, -28, -2, -2,
	727	41, -38, -28, 264, 266, -25, 44, 273, -5, -28,
	728	273, -4, -5, -8, 123, 91, 41, 44, -24, -39,
	729	-40, 41, -2, -28, -17, -35, -44, 93, 41, -10,
	730	-11, -46, 273, -12, -13, -28, -23, 273, -2, -28,
	731	-28, -24, -2, -18, -36, -37, -3, 125, 44, -47,
	732	93, 44, -24, -29, 261, 262, -2, 268, -46, 61,
	733	-28, 267, 267, -24, -28, 267, -4, -28, 260, -18,
	734	-2, -24, -2, -29 };
	735	int yydef[]={
	736
	737	1, -2, 11, 4, 5, 0, 102, 13, 0, 6,
	738	3, 14, 12, 0, 16, 18, 0, 21, 22, 0,
	739	-2, 65, 61, 93, 0, 0, 34, 0, 0, 0,
	740	49, 61, -2, 52, 53, 54, 55, 0, 0, 27,
	741	0, 0, 100, 98, 0, 0, 0, 77, 73, 33,
	742	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	743	0, 33, 33, 34, 0, 47, 48, 63, 56, 0,
	744	0, 9, 20, -2, -2, 23, 0, 0, 0, 0,
	745	68, 0, 78, 0, 74, 75, 27, 36, 37, 38,
	746	39, 40, 41, 42, 43, 44, 45, 46, 57, 59,
	747	35, 0, 64, 33, 0, -2, 71, 99, 101, 0,
	748	97, 0, 69, 62, 81, 87, 7, 0, 33, 0,
	749	0, 50, 27, 33, 13, -2, 0, 95, 66, 0,
	750	82, 83, 85, 0, 88, 89, 27, 76, 24, 58,
	751	60, 33, 19, 10, 29, 0, -2, 79, 0, 0,
	752	80, 0, 0, 0, 27, 0, 0, 68, 84, 0,
	753	90, 8, 15, 25, 0, 17, 13, 86, 33, 32,
	754	27, 33, 24, 26 };
	755	typedef struct { char *t_name; int t_val; } yytoktype;
	756	#ifndef YYDEBUG
	757	# define YYDEBUG 0 /* don't allow debugging */
	758	#endif
	759
	760	#if YYDEBUG
	761
	762	yytoktype yytoks[] =
	763	{
	764	"WRONGTOKEN", 257,
	765	"NIL", 258,
	766	"IF", 259,
	767	"THEN", 260,
	768	"ELSE", 261,
	769	"ELSEIF", 262,
	770	"WHILE", 263,
	771	"DO", 264,
	772	"REPEAT", 265,
	773	"UNTIL", 266,
	774	"END", 267,
	775	"RETURN", 268,
	776	"LOCAL", 269,
	777	"NUMBER", 270,
	778	"FUNCTION", 271,
	779	"STRING", 272,
	780	"NAME", 273,
	781	"DEBUG", 274,
	782	"AND", 275,
	783	"OR", 276,
	784	"=", 61,
	785	"NE", 277,
	786	">", 62,
	787	"<", 60,
	788	"LE", 278,
	789	"GE", 279,
	790	"CONC", 280,
	791	"+", 43,
	792	"-", 45,
	793	"*", 42,
	794	"/", 47,
	795	"UNARY", 281,
	796	"NOT", 282,
	797	"-unknown-", -1 /* ends search */
	798	};
	799
	800	char * yyreds[] =
	801	{
	802	"-no such reduction-",
	803	"functionlist : /* empty */",
	804	"functionlist : functionlist",
	805	"functionlist : functionlist stat sc",
	806	"functionlist : functionlist function",
	807	"functionlist : functionlist setdebug",
	808	"function : FUNCTION NAME",
	809	"function : FUNCTION NAME '(' parlist ')'",
	810	"function : FUNCTION NAME '(' parlist ')' block END",
	811	"statlist : /* empty */",
	812	"statlist : statlist stat sc",
	813	"stat : /* empty */",
	814	"stat : stat1",
	815	"sc : /* empty */",
	816	"sc : ';'",
	817	"stat1 : IF expr1 THEN PrepJump block PrepJump elsepart END",
	818	"stat1 : WHILE",
	819	"stat1 : WHILE expr1 DO PrepJump block PrepJump END",
	820	"stat1 : REPEAT",
	821	"stat1 : REPEAT block UNTIL expr1 PrepJump",
	822	"stat1 : varlist1 '=' exprlist1",
	823	"stat1 : functioncall",
	824	"stat1 : typeconstructor",
	825	"stat1 : LOCAL localdeclist decinit",
	826	"elsepart : /* empty */",
	827	"elsepart : ELSE block",
	828	"elsepart : ELSEIF expr1 THEN PrepJump block PrepJump elsepart",
	829	"block : /* empty */",
	830	"block : statlist",
	831	"block : statlist ret",
	832	"ret : /* empty */",
	833	"ret : /* empty */",
	834	"ret : RETURN exprlist sc",
	835	"PrepJump : /* empty */",
	836	"expr1 : expr",
	837	"expr : '(' expr ')'",
	838	"expr : expr1 '=' expr1",
	839	"expr : expr1 '<' expr1",
	840	"expr : expr1 '>' expr1",
	841	"expr : expr1 NE expr1",
	842	"expr : expr1 LE expr1",
	843	"expr : expr1 GE expr1",
	844	"expr : expr1 '+' expr1",
	845	"expr : expr1 '-' expr1",
	846	"expr : expr1 '*' expr1",
	847	"expr : expr1 '/' expr1",
	848	"expr : expr1 CONC expr1",
	849	"expr : '+' expr1",
	850	"expr : '-' expr1",
	851	"expr : typeconstructor",
	852	"expr : '@' '(' dimension ')'",
	853	"expr : var",
	854	"expr : NUMBER",
	855	"expr : STRING",
	856	"expr : NIL",
	857	"expr : functioncall",
	858	"expr : NOT expr1",
	859	"expr : expr1 AND PrepJump",
	860	"expr : expr1 AND PrepJump expr1",
	861	"expr : expr1 OR PrepJump",
	862	"expr : expr1 OR PrepJump expr1",
	863	"typeconstructor : '@'",
	864	"typeconstructor : '@' objectname fieldlist",
	865	"dimension : /* empty */",
	866	"dimension : expr1",
	867	"functioncall : functionvalue",
	868	"functioncall : functionvalue '(' exprlist ')'",
	869	"functionvalue : var",
	870	"exprlist : /* empty */",
	871	"exprlist : exprlist1",
	872	"exprlist1 : expr",
	873	"exprlist1 : exprlist1 ','",
	874	"exprlist1 : exprlist1 ',' expr",
	875	"parlist : /* empty */",
	876	"parlist : parlist1",
	877	"parlist1 : NAME",
	878	"parlist1 : parlist1 ',' NAME",
	879	"objectname : /* empty */",
	880	"objectname : NAME",
	881	"fieldlist : '{' ffieldlist '}'",
	882	"fieldlist : '[' lfieldlist ']'",
	883	"ffieldlist : /* empty */",
	884	"ffieldlist : ffieldlist1",
	885	"ffieldlist1 : ffield",
	886	"ffieldlist1 : ffieldlist1 ',' ffield",
	887	"ffield : NAME",
	888	"ffield : NAME '=' expr1",
	889	"lfieldlist : /* empty */",
	890	"lfieldlist : lfieldlist1",
	891	"lfieldlist1 : expr1",
	892	"lfieldlist1 : lfieldlist1 ',' expr1",
	893	"varlist1 : var",
	894	"varlist1 : varlist1 ',' var",
	895	"var : NAME",
	896	"var : var",
	897	"var : var '[' expr1 ']'",
	898	"var : var",
	899	"var : var '.' NAME",
	900	"localdeclist : NAME",
	901	"localdeclist : localdeclist ',' NAME",
	902	"decinit : /* empty */",
	903	"decinit : '=' exprlist1",
	904	"setdebug : DEBUG",
	905	};
	906	#endif /* YYDEBUG */
	907	#line 1 "/usr/lib/yaccpar"
	908	/* @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10 */
	909
	910	/*
	911	** Skeleton parser driver for yacc output
	912	*/
	913
	914	/*
	915	** yacc user known macros and defines
	916	*/
	917	#define YYERROR goto yyerrlab
	918	#define YYACCEPT { free(yys); free(yyv); return(0); }
	919	#define YYABORT { free(yys); free(yyv); return(1); }
	920	#define YYBACKUP( newtoken, newvalue )\
	921	{\
	922	if ( yychar >= 0 \|\| ( yyr2[ yytmp ] >> 1 ) != 1 )\
	923	{\
	924	yyerror( "syntax error - cannot backup" );\
	925	goto yyerrlab;\
	926	}\
	927	yychar = newtoken;\
	928	yystate = *yyps;\
	929	yylval = newvalue;\
	930	goto yynewstate;\
	931	}
	932	#define YYRECOVERING() (!!yyerrflag)
	933	#ifndef YYDEBUG
	934	# define YYDEBUG 1 /* make debugging available */
	935	#endif
	936
	937	/*
	938	** user known globals
	939	*/
	940	int yydebug; /* set to 1 to get debugging */
	941
	942	/*
	943	** driver internal defines
	944	*/
	945	#define YYFLAG (-1000)
	946
	947	/*
	948	** static variables used by the parser
	949	*/
	950	static YYSTYPE yyv; / value stack */
	951	static int yys; / state stack */
	952
	953	static YYSTYPE yypv; / top of value stack */
	954	static int yyps; / top of state stack */
	955
	956	static int yystate; /* current state */
	957	static int yytmp; /* extra var (lasts between blocks) */
	958
	959	int yynerrs; /* number of errors */
	960
	961	int yyerrflag; /* error recovery flag */
	962	int yychar; /* current input token number */
	963
	964
	965	/*
	966	** yyparse - return 0 if worked, 1 if syntax error not recovered from
	967	*/
	968	int
	969	yyparse()
	970	{
	971	register YYSTYPE yypvt; / top of value stack for $vars */
	972	unsigned yymaxdepth = YYMAXDEPTH;
	973
	974	/*
	975	** Initialize externals - yyparse may be called more than once
	976	*/
	977	yyv = (YYSTYPE)malloc(yymaxdepthsizeof(YYSTYPE));
	978	yys = (int)malloc(yymaxdepthsizeof(int));
	979	if (!yyv \|\| !yys)
	980	{
	981	yyerror( "out of memory" );
	982	return(1);
	983	}
	984	yypv = &yyv[-1];
	985	yyps = &yys[-1];
	986	yystate = 0;
	987	yytmp = 0;
	988	yynerrs = 0;
	989	yyerrflag = 0;
	990	yychar = -1;
	991
	992	goto yystack;
	993	{
	994	register YYSTYPE yy_pv; / top of value stack */
	995	register int yy_ps; / top of state stack */
	996	register int yy_state; /* current state */
	997	register int yy_n; /* internal state number info */
	998
	999	/*
	1000	** get globals into registers.
	1001	** branch to here only if YYBACKUP was called.
	1002	*/
	1003	yynewstate:
	1004	yy_pv = yypv;
	1005	yy_ps = yyps;
	1006	yy_state = yystate;
	1007	goto yy_newstate;
	1008
	1009	/*
	1010	** get globals into registers.
	1011	** either we just started, or we just finished a reduction
	1012	*/
	1013	yystack:
	1014	yy_pv = yypv;
	1015	yy_ps = yyps;
	1016	yy_state = yystate;
	1017
	1018	/*
	1019	** top of for (;;) loop while no reductions done
	1020	*/
	1021	yy_stack:
	1022	/*
	1023	** put a state and value onto the stacks
	1024	*/
	1025	#if YYDEBUG
	1026	/*
	1027	** if debugging, look up token value in list of value vs.
	1028	** name pairs. 0 and negative (-1) are special values.
	1029	** Note: linear search is used since time is not a real
	1030	** consideration while debugging.
	1031	*/
	1032	if ( yydebug )
	1033	{
	1034	register int yy_i;
	1035
	1036	(void)printf( "State %d, token ", yy_state );
	1037	if ( yychar == 0 )
	1038	(void)printf( "end-of-file\n" );
	1039	else if ( yychar < 0 )
	1040	(void)printf( "-none-\n" );
	1041	else
	1042	{
	1043	for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
	1044	yy_i++ )
	1045	{
	1046	if ( yytoks[yy_i].t_val == yychar )
	1047	break;
	1048	}
	1049	(void)printf( "%s\n", yytoks[yy_i].t_name );
	1050	}
	1051	}
	1052	#endif /* YYDEBUG */
	1053	if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */
	1054	{
	1055	/*
	1056	** reallocate and recover. Note that pointers
	1057	** have to be reset, or bad things will happen
	1058	*/
	1059	int yyps_index = (yy_ps - yys);
	1060	int yypv_index = (yy_pv - yyv);
	1061	int yypvt_index = (yypvt - yyv);
	1062	yymaxdepth += YYMAXDEPTH;
	1063	yyv = (YYSTYPE)realloc((char)yyv,
	1064	yymaxdepth * sizeof(YYSTYPE));
	1065	yys = (int)realloc((char)yys,
	1066	yymaxdepth * sizeof(int));
	1067	if (!yyv \|\| !yys)
	1068	{
	1069	yyerror( "yacc stack overflow" );
	1070	return(1);
	1071	}
	1072	yy_ps = yys + yyps_index;
	1073	yy_pv = yyv + yypv_index;
	1074	yypvt = yyv + yypvt_index;
	1075	}
	1076	*yy_ps = yy_state;
	1077	*++yy_pv = yyval;
	1078
	1079	/*
	1080	** we have a new state - find out what to do
	1081	*/
	1082	yy_newstate:
	1083	if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
	1084	goto yydefault; /* simple state */
	1085	#if YYDEBUG
	1086	/*
	1087	** if debugging, need to mark whether new token grabbed
	1088	*/
	1089	yytmp = yychar < 0;
	1090	#endif
	1091	if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
	1092	yychar = 0; /* reached EOF */
	1093	#if YYDEBUG
	1094	if ( yydebug && yytmp )
	1095	{
	1096	register int yy_i;
	1097
	1098	(void)printf( "Received token " );
	1099	if ( yychar == 0 )
	1100	(void)printf( "end-of-file\n" );
	1101	else if ( yychar < 0 )
	1102	(void)printf( "-none-\n" );
	1103	else
	1104	{
	1105	for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
	1106	yy_i++ )
	1107	{
	1108	if ( yytoks[yy_i].t_val == yychar )
	1109	break;
	1110	}
	1111	(void)printf( "%s\n", yytoks[yy_i].t_name );
	1112	}
	1113	}
	1114	#endif /* YYDEBUG */
	1115	if ( ( ( yy_n += yychar ) < 0 ) \|\| ( yy_n >= YYLAST ) )
	1116	goto yydefault;
	1117	if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /valid shift/
	1118	{
	1119	yychar = -1;
	1120	yyval = yylval;
	1121	yy_state = yy_n;
	1122	if ( yyerrflag > 0 )
	1123	yyerrflag--;
	1124	goto yy_stack;
	1125	}
	1126
	1127	yydefault:
	1128	if ( ( yy_n = yydef[ yy_state ] ) == -2 )
	1129	{
	1130	#if YYDEBUG
	1131	yytmp = yychar < 0;
	1132	#endif
	1133	if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
	1134	yychar = 0; /* reached EOF */
	1135	#if YYDEBUG
	1136	if ( yydebug && yytmp )
	1137	{
	1138	register int yy_i;
	1139
	1140	(void)printf( "Received token " );
	1141	if ( yychar == 0 )
	1142	(void)printf( "end-of-file\n" );
	1143	else if ( yychar < 0 )
	1144	(void)printf( "-none-\n" );
	1145	else
	1146	{
	1147	for ( yy_i = 0;
	1148	yytoks[yy_i].t_val >= 0;
	1149	yy_i++ )
	1150	{
	1151	if ( yytoks[yy_i].t_val
	1152	== yychar )
	1153	{
	1154	break;
	1155	}
	1156	}
	1157	(void)printf( "%s\n", yytoks[yy_i].t_name );
	1158	}
	1159	}
	1160	#endif /* YYDEBUG */
	1161	/*
	1162	** look through exception table
	1163	*/
	1164	{
	1165	register int *yyxi = yyexca;
	1166
	1167	while ( ( *yyxi != -1 ) \|\|
	1168	( yyxi[1] != yy_state ) )
	1169	{
	1170	yyxi += 2;
	1171	}
	1172	while ( ( *(yyxi += 2) >= 0 ) &&
	1173	( *yyxi != yychar ) )
	1174	;
	1175	if ( ( yy_n = yyxi[1] ) < 0 )
	1176	YYACCEPT;
	1177	}
	1178	}
	1179
	1180	/*
	1181	** check for syntax error
	1182	*/
	1183	if ( yy_n == 0 ) /* have an error */
	1184	{
	1185	/* no worry about speed here! */
	1186	switch ( yyerrflag )
	1187	{
	1188	case 0: /* new error */
	1189	yyerror( "syntax error" );
	1190	goto skip_init;
	1191	yyerrlab:
	1192	/*
	1193	** get globals into registers.
	1194	** we have a user generated syntax type error
	1195	*/
	1196	yy_pv = yypv;
	1197	yy_ps = yyps;
	1198	yy_state = yystate;
	1199	yynerrs++;
	1200	skip_init:
	1201	case 1:
	1202	case 2: /* incompletely recovered error */
	1203	/* try again... */
	1204	yyerrflag = 3;
	1205	/*
	1206	** find state where "error" is a legal
	1207	** shift action
	1208	*/
	1209	while ( yy_ps >= yys )
	1210	{
	1211	yy_n = yypact[ *yy_ps ] + YYERRCODE;
	1212	if ( yy_n >= 0 && yy_n < YYLAST &&
	1213	yychk[yyact[yy_n]] == YYERRCODE) {
	1214	/*
	1215	** simulate shift of "error"
	1216	*/
	1217	yy_state = yyact[ yy_n ];
	1218	goto yy_stack;
	1219	}
	1220	/*
	1221	** current state has no shift on
	1222	** "error", pop stack
	1223	*/
	1224	#if YYDEBUG
	1225	# define _POP_ "Error recovery pops state %d, uncovers state %d\n"
	1226	if ( yydebug )
	1227	(void)printf( _POP_, *yy_ps,
	1228	yy_ps[-1] );
	1229	# undef _POP_
	1230	#endif
	1231	yy_ps--;
	1232	yy_pv--;
	1233	}
	1234	/*
	1235	** there is no state on stack with "error" as
	1236	** a valid shift. give up.
	1237	*/
	1238	YYABORT;
	1239	case 3: /* no shift yet; eat a token */
	1240	#if YYDEBUG
	1241	/*
	1242	** if debugging, look up token in list of
	1243	** pairs. 0 and negative shouldn't occur,
	1244	** but since timing doesn't matter when
	1245	** debugging, it doesn't hurt to leave the
	1246	** tests here.
	1247	*/
	1248	if ( yydebug )
	1249	{
	1250	register int yy_i;
	1251
	1252	(void)printf( "Error recovery discards " );
	1253	if ( yychar == 0 )
	1254	(void)printf( "token end-of-file\n" );
	1255	else if ( yychar < 0 )
	1256	(void)printf( "token -none-\n" );
	1257	else
	1258	{
	1259	for ( yy_i = 0;
	1260	yytoks[yy_i].t_val >= 0;
	1261	yy_i++ )
	1262	{
	1263	if ( yytoks[yy_i].t_val
	1264	== yychar )
	1265	{
	1266	break;
	1267	}
	1268	}
	1269	(void)printf( "token %s\n",
	1270	yytoks[yy_i].t_name );
	1271	}
	1272	}
	1273	#endif /* YYDEBUG */
	1274	if ( yychar == 0 ) /* reached EOF. quit */
	1275	YYABORT;
	1276	yychar = -1;
	1277	goto yy_newstate;
	1278	}
	1279	}/* end if ( yy_n == 0 ) */
	1280	/*
	1281	** reduction by production yy_n
	1282	** put stack tops, etc. so things right after switch
	1283	*/
	1284	#if YYDEBUG
	1285	/*
	1286	** if debugging, print the string that is the user's
	1287	** specification of the reduction which is just about
	1288	** to be done.
	1289	*/
	1290	if ( yydebug )
	1291	(void)printf( "Reduce by (%d) \"%s\"\n",
	1292	yy_n, yyreds[ yy_n ] );
	1293	#endif
	1294	yytmp = yy_n; /* value to switch over */
	1295	yypvt = yy_pv; /* $vars top of value stack */
	1296	/*
	1297	** Look in goto table for next state
	1298	** Sorry about using yy_state here as temporary
	1299	** register variable, but why not, if it works...
	1300	** If yyr2[ yy_n ] doesn't have the low order bit
	1301	** set, then there is no action to be done for
	1302	** this reduction. So, no saving & unsaving of
	1303	** registers done. The only difference between the
	1304	** code just after the if and the body of the if is
	1305	** the goto yy_stack in the body. This way the test
	1306	** can be made before the choice of what to do is needed.
	1307	*/
	1308	{
	1309	/* length of production doubled with extra bit */
	1310	register int yy_len = yyr2[ yy_n ];
	1311
	1312	if ( !( yy_len & 01 ) )
	1313	{
	1314	yy_len >>= 1;
	1315	yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
	1316	yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
	1317	*( yy_ps -= yy_len ) + 1;
	1318	if ( yy_state >= YYLAST \|\|
	1319	yychk[ yy_state =
	1320	yyact[ yy_state ] ] != -yy_n )
	1321	{
	1322	yy_state = yyact[ yypgo[ yy_n ] ];
	1323	}
	1324	goto yy_stack;
	1325	}
	1326	yy_len >>= 1;
	1327	yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
	1328	yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
	1329	*( yy_ps -= yy_len ) + 1;
	1330	if ( yy_state >= YYLAST \|\|
	1331	yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
	1332	{
	1333	yy_state = yyact[ yypgo[ yy_n ] ];
	1334	}
	1335	}
	1336	/* save until reenter driver code */
	1337	yystate = yy_state;
	1338	yyps = yy_ps;
	1339	yypv = yy_pv;
	1340	}
	1341	/*
	1342	** code supplied by user is placed in this switch
	1343	*/
	1344	switch( yytmp )
	1345	{
	1346
	1347	case 2:
	1348	# line 227 "lua.stx"
	1349	{
	1350	pc=maincode; basepc=initcode; maxcurr=maxmain;
	1351	nlocalvar=0;
	1352	} break;
	1353	case 3:
	1354	# line 232 "lua.stx"
	1355	{
	1356	maincode=pc; initcode=basepc; maxmain=maxcurr;
	1357	} break;
	1358	case 6:
	1359	# line 240 "lua.stx"
	1360	{
	1361	if (code == NULL) /* first function */
	1362	{
	1363	code = (Byte *) calloc(GAPCODE, sizeof(Byte));
	1364	if (code == NULL)
	1365	{
	1366	lua_error("not enough memory");
	1367	err = 1;
	1368	}
	1369	maxcode = GAPCODE;
	1370	}
	1371	pc=0; basepc=code; maxcurr=maxcode;
	1372	nlocalvar=0;
	1373	yyval.vWord = lua_findsymbol(yypvt[-0].pChar);
	1374	} break;
	1375	case 7:
	1376	# line 256 "lua.stx"
	1377	{
	1378	if (lua_debug)
	1379	{
	1380	code_byte(SETFUNCTION);
	1381	code_word(lua_nfile-1);
	1382	code_word(yypvt[-3].vWord);
	1383	}
	1384	lua_codeadjust (0);
	1385	} break;
	1386	case 8:
	1387	# line 267 "lua.stx"
	1388	{
	1389	if (lua_debug) code_byte(RESET);
	1390	code_byte(RETCODE); code_byte(nlocalvar);
	1391	s_tag(yypvt[-6].vWord) = T_FUNCTION;
	1392	s_bvalue(yypvt[-6].vWord) = calloc (pc, sizeof(Byte));
	1393	if (s_bvalue(yypvt[-6].vWord) == NULL)
	1394	{
	1395	lua_error("not enough memory");
	1396	err = 1;
	1397	}
	1398	memcpy (s_bvalue(yypvt[-6].vWord), basepc, pc*sizeof(Byte));
	1399	code = basepc; maxcode=maxcurr;
	1400	#if LISTING
	1401	PrintCode(code,code+pc);
	1402	#endif
	1403	} break;
	1404	case 11:
	1405	# line 289 "lua.stx"
	1406	{
	1407	ntemp = 0;
	1408	if (lua_debug)
	1409	{
	1410	code_byte(SETLINE); code_word(lua_linenumber);
	1411	}
	1412	} break;
	1413	case 15:
	1414	# line 302 "lua.stx"
	1415	{
	1416	{
	1417	Word elseinit = yypvt[-2].vWord+sizeof(Word)+1;
	1418	if (pc - elseinit == 0) /* no else */
	1419	{
	1420	pc -= sizeof(Word)+1;
	1421	elseinit = pc;
	1422	}
	1423	else
	1424	{
	1425	basepc[yypvt[-2].vWord] = JMP;
	1426	code_word_at(basepc+yypvt[-2].vWord+1, pc - elseinit);
	1427	}
	1428	basepc[yypvt[-4].vWord] = IFFJMP;
	1429	code_word_at(basepc+yypvt[-4].vWord+1,elseinit-(yypvt[-4].vWord+sizeof(Word)+1));
	1430	}
	1431	} break;
	1432	case 16:
	1433	# line 320 "lua.stx"
	1434	{yyval.vWord=pc;} break;
	1435	case 17:
	1436	# line 322 "lua.stx"
	1437	{
	1438	basepc[yypvt[-3].vWord] = IFFJMP;
	1439	code_word_at(basepc+yypvt[-3].vWord+1, pc - (yypvt[-3].vWord + sizeof(Word)+1));
	1440
	1441	basepc[yypvt[-1].vWord] = UPJMP;
	1442	code_word_at(basepc+yypvt[-1].vWord+1, pc - (yypvt[-6].vWord));
	1443	} break;
	1444	case 18:
	1445	# line 330 "lua.stx"
	1446	{yyval.vWord=pc;} break;
	1447	case 19:
	1448	# line 332 "lua.stx"
	1449	{
	1450	basepc[yypvt[-0].vWord] = IFFUPJMP;
	1451	code_word_at(basepc+yypvt[-0].vWord+1, pc - (yypvt[-4].vWord));
	1452	} break;
	1453	case 20:
	1454	# line 339 "lua.stx"
	1455	{
	1456	{
	1457	int i;
	1458	if (yypvt[-0].vInt == 0 \|\| nvarbuffer != ntemp - yypvt[-2].vInt * 2)
	1459	lua_codeadjust (yypvt[-2].vInt * 2 + nvarbuffer);
	1460	for (i=nvarbuffer-1; i>=0; i--)
	1461	lua_codestore (i);
	1462	if (yypvt[-2].vInt > 1 \|\| (yypvt[-2].vInt == 1 && varbuffer[0] != 0))
	1463	lua_codeadjust (0);
	1464	}
	1465	} break;
	1466	case 21:
	1467	# line 350 "lua.stx"
	1468	{ lua_codeadjust (0); } break;
	1469	case 22:
	1470	# line 351 "lua.stx"
	1471	{ lua_codeadjust (0); } break;
	1472	case 23:
	1473	# line 352 "lua.stx"
	1474	{ add_nlocalvar(yypvt[-1].vInt); lua_codeadjust (0); } break;
	1475	case 26:
	1476	# line 358 "lua.stx"
	1477	{
	1478	{
	1479	Word elseinit = yypvt[-1].vWord+sizeof(Word)+1;
	1480	if (pc - elseinit == 0) /* no else */
	1481	{
	1482	pc -= sizeof(Word)+1;
	1483	elseinit = pc;
	1484	}
	1485	else
	1486	{
	1487	basepc[yypvt[-1].vWord] = JMP;
	1488	code_word_at(basepc+yypvt[-1].vWord+1, pc - elseinit);
	1489	}
	1490	basepc[yypvt[-3].vWord] = IFFJMP;
	1491	code_word_at(basepc+yypvt[-3].vWord+1, elseinit - (yypvt[-3].vWord + sizeof(Word)+1));
	1492	}
	1493	} break;
	1494	case 27:
	1495	# line 377 "lua.stx"
	1496	{yyval.vInt = nlocalvar;} break;
	1497	case 28:
	1498	# line 377 "lua.stx"
	1499	{ntemp = 0;} break;
	1500	case 29:
	1501	# line 378 "lua.stx"
	1502	{
	1503	if (nlocalvar != yypvt[-3].vInt)
	1504	{
	1505	nlocalvar = yypvt[-3].vInt;
	1506	lua_codeadjust (0);
	1507	}
	1508	} break;
	1509	case 31:
	1510	# line 388 "lua.stx"
	1511	{ if (lua_debug){code_byte(SETLINE);code_word(lua_linenumber);}} break;
	1512	case 32:
	1513	# line 390 "lua.stx"
	1514	{
	1515	if (lua_debug) code_byte(RESET);
	1516	code_byte(RETCODE); code_byte(nlocalvar);
	1517	} break;
	1518	case 33:
	1519	# line 397 "lua.stx"
	1520	{
	1521	yyval.vWord = pc;
	1522	code_byte(0); /* open space */
	1523	code_word (0);
	1524	} break;
	1525	case 34:
	1526	# line 403 "lua.stx"
	1527	{ if (yypvt[-0].vInt == 0) {lua_codeadjust (ntemp+1); incr_ntemp();}} break;
	1528	case 35:
	1529	# line 406 "lua.stx"
	1530	{ yyval.vInt = yypvt[-1].vInt; } break;
	1531	case 36:
	1532	# line 407 "lua.stx"
	1533	{ code_byte(EQOP); yyval.vInt = 1; ntemp--;} break;
	1534	case 37:
	1535	# line 408 "lua.stx"
	1536	{ code_byte(LTOP); yyval.vInt = 1; ntemp--;} break;
	1537	case 38:
	1538	# line 409 "lua.stx"
	1539	{ code_byte(LEOP); code_byte(NOTOP); yyval.vInt = 1; ntemp--;} break;
	1540	case 39:
	1541	# line 410 "lua.stx"
	1542	{ code_byte(EQOP); code_byte(NOTOP); yyval.vInt = 1; ntemp--;} break;
	1543	case 40:
	1544	# line 411 "lua.stx"
	1545	{ code_byte(LEOP); yyval.vInt = 1; ntemp--;} break;
	1546	case 41:
	1547	# line 412 "lua.stx"
	1548	{ code_byte(LTOP); code_byte(NOTOP); yyval.vInt = 1; ntemp--;} break;
	1549	case 42:
	1550	# line 413 "lua.stx"
	1551	{ code_byte(ADDOP); yyval.vInt = 1; ntemp--;} break;
	1552	case 43:
	1553	# line 414 "lua.stx"
	1554	{ code_byte(SUBOP); yyval.vInt = 1; ntemp--;} break;
	1555	case 44:
	1556	# line 415 "lua.stx"
	1557	{ code_byte(MULTOP); yyval.vInt = 1; ntemp--;} break;
	1558	case 45:
	1559	# line 416 "lua.stx"
	1560	{ code_byte(DIVOP); yyval.vInt = 1; ntemp--;} break;
	1561	case 46:
	1562	# line 417 "lua.stx"
	1563	{ code_byte(CONCOP); yyval.vInt = 1; ntemp--;} break;
	1564	case 47:
	1565	# line 418 "lua.stx"
	1566	{ yyval.vInt = 1; } break;
	1567	case 48:
	1568	# line 419 "lua.stx"
	1569	{ code_byte(MINUSOP); yyval.vInt = 1;} break;
	1570	case 49:
	1571	# line 420 "lua.stx"
	1572	{ yyval.vInt = yypvt[-0].vInt; } break;
	1573	case 50:
	1574	# line 422 "lua.stx"
	1575	{
	1576	code_byte(CREATEARRAY);
	1577	yyval.vInt = 1;
	1578	} break;
	1579	case 51:
	1580	# line 426 "lua.stx"
	1581	{ lua_pushvar (yypvt[-0].vLong); yyval.vInt = 1;} break;
	1582	case 52:
	1583	# line 427 "lua.stx"
	1584	{ code_number(yypvt[-0].vFloat); yyval.vInt = 1; } break;
	1585	case 53:
	1586	# line 429 "lua.stx"
	1587	{
	1588	code_byte(PUSHSTRING);
	1589	code_word(yypvt[-0].vWord);
	1590	yyval.vInt = 1;
	1591	incr_ntemp();
	1592	} break;
	1593	case 54:
	1594	# line 435 "lua.stx"
	1595	{code_byte(PUSHNIL); yyval.vInt = 1; incr_ntemp();} break;
	1596	case 55:
	1597	# line 437 "lua.stx"
	1598	{
	1599	yyval.vInt = 0;
	1600	if (lua_debug)
	1601	{
	1602	code_byte(SETLINE); code_word(lua_linenumber);
	1603	}
	1604	} break;
	1605	case 56:
	1606	# line 444 "lua.stx"
	1607	{ code_byte(NOTOP); yyval.vInt = 1;} break;
	1608	case 57:
	1609	# line 445 "lua.stx"
	1610	{code_byte(POP); ntemp--;} break;
	1611	case 58:
	1612	# line 446 "lua.stx"
	1613	{
	1614	basepc[yypvt[-2].vWord] = ONFJMP;
	1615	code_word_at(basepc+yypvt[-2].vWord+1, pc - (yypvt[-2].vWord + sizeof(Word)+1));
	1616	yyval.vInt = 1;
	1617	} break;
	1618	case 59:
	1619	# line 451 "lua.stx"
	1620	{code_byte(POP); ntemp--;} break;
	1621	case 60:
	1622	# line 452 "lua.stx"
	1623	{
	1624	basepc[yypvt[-2].vWord] = ONTJMP;
	1625	code_word_at(basepc+yypvt[-2].vWord+1, pc - (yypvt[-2].vWord + sizeof(Word)+1));
	1626	yyval.vInt = 1;
	1627	} break;
	1628	case 61:
	1629	# line 460 "lua.stx"
	1630	{
	1631	code_byte(PUSHBYTE);
	1632	yyval.vWord = pc; code_byte(0);
	1633	incr_ntemp();
	1634	code_byte(CREATEARRAY);
	1635	} break;
	1636	case 62:
	1637	# line 467 "lua.stx"
	1638	{
	1639	basepc[yypvt[-2].vWord] = yypvt[-0].vInt;
	1640	if (yypvt[-1].vLong < 0) /* there is no function to be called */
	1641	{
	1642	yyval.vInt = 1;
	1643	}
	1644	else
	1645	{
	1646	lua_pushvar (yypvt[-1].vLong+1);
	1647	code_byte(PUSHMARK);
	1648	incr_ntemp();
	1649	code_byte(PUSHOBJECT);
	1650	incr_ntemp();
	1651	code_byte(CALLFUNC);
	1652	ntemp -= 4;
	1653	yyval.vInt = 0;
	1654	if (lua_debug)
	1655	{
	1656	code_byte(SETLINE); code_word(lua_linenumber);
	1657	}
	1658	}
	1659	} break;
	1660	case 63:
	1661	# line 491 "lua.stx"
	1662	{ code_byte(PUSHNIL); incr_ntemp();} break;
	1663	case 65:
	1664	# line 495 "lua.stx"
	1665	{code_byte(PUSHMARK); yyval.vInt = ntemp; incr_ntemp();} break;
	1666	case 66:
	1667	# line 496 "lua.stx"
	1668	{ code_byte(CALLFUNC); ntemp = yypvt[-3].vInt-1;} break;
	1669	case 67:
	1670	# line 498 "lua.stx"
	1671	{lua_pushvar (yypvt[-0].vLong); } break;
	1672	case 68:
	1673	# line 501 "lua.stx"
	1674	{ yyval.vInt = 1; } break;
	1675	case 69:
	1676	# line 502 "lua.stx"
	1677	{ yyval.vInt = yypvt[-0].vInt; } break;
	1678	case 70:
	1679	# line 505 "lua.stx"
	1680	{ yyval.vInt = yypvt[-0].vInt; } break;
	1681	case 71:
	1682	# line 506 "lua.stx"
	1683	{if (!yypvt[-1].vInt){lua_codeadjust (ntemp+1); incr_ntemp();}} break;
	1684	case 72:
	1685	# line 507 "lua.stx"
	1686	{yyval.vInt = yypvt[-0].vInt;} break;
	1687	case 75:
	1688	# line 515 "lua.stx"
	1689	{
	1690	localvar[nlocalvar]=lua_findsymbol(yypvt[-0].pChar);
	1691	add_nlocalvar(1);
	1692	} break;
	1693	case 76:
	1694	# line 520 "lua.stx"
	1695	{
	1696	localvar[nlocalvar]=lua_findsymbol(yypvt[-0].pChar);
	1697	add_nlocalvar(1);
	1698	} break;
	1699	case 77:
	1700	# line 526 "lua.stx"
	1701	{yyval.vLong=-1;} break;
	1702	case 78:
	1703	# line 527 "lua.stx"
	1704	{yyval.vLong=lua_findsymbol(yypvt[-0].pChar);} break;
	1705	case 79:
	1706	# line 531 "lua.stx"
	1707	{
	1708	flush_record(yypvt[-1].vInt%FIELDS_PER_FLUSH);
	1709	yyval.vInt = yypvt[-1].vInt;
	1710	} break;
	1711	case 80:
	1712	# line 536 "lua.stx"
	1713	{
	1714	flush_list(yypvt[-1].vInt/FIELDS_PER_FLUSH, yypvt[-1].vInt%FIELDS_PER_FLUSH);
	1715	yyval.vInt = yypvt[-1].vInt;
	1716	} break;
	1717	case 81:
	1718	# line 542 "lua.stx"
	1719	{ yyval.vInt = 0; } break;
	1720	case 82:
	1721	# line 543 "lua.stx"
	1722	{ yyval.vInt = yypvt[-0].vInt; } break;
	1723	case 83:
	1724	# line 546 "lua.stx"
	1725	{yyval.vInt=1;} break;
	1726	case 84:
	1727	# line 548 "lua.stx"
	1728	{
	1729	yyval.vInt=yypvt[-2].vInt+1;
	1730	if (yyval.vInt%FIELDS_PER_FLUSH == 0) flush_record(FIELDS_PER_FLUSH);
	1731	} break;
	1732	case 85:
	1733	# line 554 "lua.stx"
	1734	{yyval.vWord = lua_findconstant(yypvt[-0].pChar);} break;
	1735	case 86:
	1736	# line 555 "lua.stx"
	1737	{
	1738	push_field(yypvt[-2].vWord);
	1739	} break;
	1740	case 87:
	1741	# line 560 "lua.stx"
	1742	{ yyval.vInt = 0; } break;
	1743	case 88:
	1744	# line 561 "lua.stx"
	1745	{ yyval.vInt = yypvt[-0].vInt; } break;
	1746	case 89:
	1747	# line 564 "lua.stx"
	1748	{yyval.vInt=1;} break;
	1749	case 90:
	1750	# line 566 "lua.stx"
	1751	{
	1752	yyval.vInt=yypvt[-2].vInt+1;
	1753	if (yyval.vInt%FIELDS_PER_FLUSH == 0)
	1754	flush_list(yyval.vInt/FIELDS_PER_FLUSH - 1, FIELDS_PER_FLUSH);
	1755	} break;
	1756	case 91:
	1757	# line 574 "lua.stx"
	1758	{
	1759	nvarbuffer = 0;
	1760	varbuffer[nvarbuffer] = yypvt[-0].vLong; incr_nvarbuffer();
	1761	yyval.vInt = (yypvt[-0].vLong == 0) ? 1 : 0;
	1762	} break;
	1763	case 92:
	1764	# line 580 "lua.stx"
	1765	{
	1766	varbuffer[nvarbuffer] = yypvt[-0].vLong; incr_nvarbuffer();
	1767	yyval.vInt = (yypvt[-0].vLong == 0) ? yypvt[-2].vInt + 1 : yypvt[-2].vInt;
	1768	} break;
	1769	case 93:
	1770	# line 587 "lua.stx"
	1771	{
	1772	Word s = lua_findsymbol(yypvt[-0].pChar);
	1773	int local = lua_localname (s);
	1774	if (local == -1) /* global var */
	1775	yyval.vLong = s + 1; /* return positive value */
	1776	else
	1777	yyval.vLong = -(local+1); /* return negative value */
	1778	} break;
	1779	case 94:
	1780	# line 596 "lua.stx"
	1781	{lua_pushvar (yypvt[-0].vLong);} break;
	1782	case 95:
	1783	# line 597 "lua.stx"
	1784	{
	1785	yyval.vLong = 0; /* indexed variable */
	1786	} break;
	1787	case 96:
	1788	# line 600 "lua.stx"
	1789	{lua_pushvar (yypvt[-0].vLong);} break;
	1790	case 97:
	1791	# line 601 "lua.stx"
	1792	{
	1793	code_byte(PUSHSTRING);
	1794	code_word(lua_findconstant(yypvt[-0].pChar)); incr_ntemp();
	1795	yyval.vLong = 0; /* indexed variable */
	1796	} break;
	1797	case 98:
	1798	# line 608 "lua.stx"
	1799	{localvar[nlocalvar]=lua_findsymbol(yypvt[-0].pChar); yyval.vInt = 1;} break;
	1800	case 99:
	1801	# line 610 "lua.stx"
	1802	{
	1803	localvar[nlocalvar+yypvt[-2].vInt]=lua_findsymbol(yypvt[-0].pChar);
	1804	yyval.vInt = yypvt[-2].vInt+1;
	1805	} break;
	1806	case 102:
	1807	# line 620 "lua.stx"
	1808	{lua_debug = yypvt[-0].vInt;} break;
	1809	}
	1810	goto yystack; /* reset registers in driver code */
	1811	}

src/y.tab.h+37−0

@@ -0,0 +1,37 @@
	1
	2	typedef union
	3	{
	4	int vInt;
	5	long vLong;
	6	float vFloat;
	7	char *pChar;
	8	Word vWord;
	9	Byte *pByte;
	10	} YYSTYPE;
	11	extern YYSTYPE yylval;
	12	# define WRONGTOKEN 257
	13	# define NIL 258
	14	# define IF 259
	15	# define THEN 260
	16	# define ELSE 261
	17	# define ELSEIF 262
	18	# define WHILE 263
	19	# define DO 264
	20	# define REPEAT 265
	21	# define UNTIL 266
	22	# define END 267
	23	# define RETURN 268
	24	# define LOCAL 269
	25	# define NUMBER 270
	26	# define FUNCTION 271
	27	# define STRING 272
	28	# define NAME 273
	29	# define DEBUG 274
	30	# define AND 275
	31	# define OR 276
	32	# define NE 277
	33	# define LE 278
	34	# define GE 279
	35	# define CONC 280
	36	# define UNARY 281
	37	# define NOT 282

src/yacc/Makefile+27−0

@@ -0,0 +1,27 @@
	1	# makefile for lua
	2
	3	LIB= $(LUA)/lib
	4	INC= $(LUA)/inc
	5
	6	CC= gcc
	7	CFLAGS= -g -Wall -O2 -I$(INC) $(DEFS)
	8	DEFS= -DMAXCODE=64000 -DMAXCONSTANT=1024 -DMAXSYMBOL=1024 -DMAXARRAY=1024
	9
	10	OBJS= hash.o inout.o lex.o opcode.o table.o y.tab.o
	11	SLIB= $(LIB)/lua.a
	12	DLIB= $(LIB)/liblua.so.1.1
	13
	14	libs: $(SLIB) $(DLIB)
	15
	16	$(SLIB): y.tab.c $(OBJS)
	17	ar ruvl $@ $(OBJS)
	18	ranlib $(SLIB)
	19
	20	$(DLIB): $(OBJS)
	21	ld -o $@ $(OBJS)
	22
	23	y.tab.c: lua.stx exscript
	24	yacc -d lua.stx ; ex y.tab.c <exscript
	25
	26	clean:
	27	rm -f $(OBJS) $(SLIB) $(DLIB)

src/yacc/exscript+3−0

@@ -0,0 +1,3 @@
	1	1d
	2	x
	3

src/yacc/lua.lex+85−0

@@ -0,0 +1,85 @@
	1	%{
	2
	3	char *rcs_lualex = "$Id: lua.lex,v 1.1 1993/12/17 18:53:41 celes Exp $";
	4
	5	#include <stdlib.h>
	6	#include <string.h>
	7
	8	#include "opcode.h"
	9	#include "hash.h"
	10	#include "inout.h"
	11	#include "table.h"
	12	#include "y.tab.h"
	13
	14	#undef input
	15	#undef unput
	16
	17	static Input input;
	18	static Unput unput;
	19
	20	void lua_setinput (Input fn)
	21	{
	22	input = fn;
	23	}
	24
	25	void lua_setunput (Unput fn)
	26	{
	27	unput = fn;
	28	}
	29
	30	char *lua_lasttext (void)
	31	{
	32	return yytext;
	33	}
	34
	35	%}
	36
	37
	38	%%
	39	[ \t]* ;
	40	^"$debug" {yylval.vInt = 1; return DEBUG;}
	41	^"$nodebug" {yylval.vInt = 0; return DEBUG;}
	42	\n lua_linenumber++;
	43	"--".* ;
	44	"local" return LOCAL;
	45	"if" return IF;
	46	"then" return THEN;
	47	"else" return ELSE;
	48	"elseif" return ELSEIF;
	49	"while" return WHILE;
	50	"do" return DO;
	51	"repeat" return REPEAT;
	52	"until" return UNTIL;
	53	"function" {
	54	yylval.vWord = lua_nfile-1;
	55	return FUNCTION;
	56	}
	57	"end" return END;
	58	"return" return RETURN;
	59	"local" return LOCAL;
	60	"nil" return NIL;
	61	"and" return AND;
	62	"or" return OR;
	63	"not" return NOT;
	64	"~=" return NE;
	65	"<=" return LE;
	66	">=" return GE;
	67	".." return CONC;
	68	\"[^\"]*\" \|
	69	\'[^\']*\' {
	70	yylval.vWord = lua_findenclosedconstant (yytext);
	71	return STRING;
	72	}
	73	[0-9]+("."[0-9]*)? \|
	74	([0-9]+)?"."[0-9]+ \|
	75	[0-9]+("."[0-9]*)?[dDeEgG][+-]?[0-9]+ \|
	76	([0-9]+)?"."[0-9]+[dDeEgG][+-]?[0-9]+ {
	77	yylval.vFloat = atof(yytext);
	78	return NUMBER;
	79	}
	80	[a-zA-Z_][a-zA-Z0-9_]* {
	81	yylval.vWord = lua_findsymbol (yytext);
	82	return NAME;
	83	}
	84	. return *yytext;
	85

src/yacc/lua.stx+953−0

@@ -0,0 +1,953 @@
	1	%{
	2
	3	char *rcs_luastx = "$Id: lua.stx,v 2.4 1994/04/20 16:22:21 celes Exp $";
	4
	5	#include <stdio.h>
	6	#include <stdlib.h>
	7	#include <string.h>
	8
	9	#include "mm.h"
	10
	11	#include "opcode.h"
	12	#include "hash.h"
	13	#include "inout.h"
	14	#include "table.h"
	15	#include "lua.h"
	16
	17	#define LISTING 0
	18
	19	#ifndef GAPCODE
	20	#define GAPCODE 50
	21	#endif
	22	static Word maxcode;
	23	static Word maxmain;
	24	static Word maxcurr ;
	25	static Byte *code = NULL;
	26	static Byte *initcode;
	27	static Byte *basepc;
	28	static Word maincode;
	29	static Word pc;
	30
	31	#define MAXVAR 32
	32	static long varbuffer[MAXVAR]; /* variables in an assignment list;
	33	it's long to store negative Word values */
	34	static int nvarbuffer=0; /* number of variables at a list */
	35
	36	static Word localvar[STACKGAP]; /* store local variable names */
	37	static int nlocalvar=0; /* number of local variables */
	38
	39	#define MAXFIELDS FIELDS_PER_FLUSH*2
	40	static Word fields[MAXFIELDS]; /* fieldnames to be flushed */
	41	static int nfields=0;
	42	static int ntemp; /* number of temporary var into stack */
	43	static int err; /* flag to indicate error */
	44
	45	/* Internal functions */
	46
	47	static void code_byte (Byte c)
	48	{
	49	if (pc>maxcurr-2) /* 1 byte free to code HALT of main code */
	50	{
	51	maxcurr += GAPCODE;
	52	basepc = (Byte )realloc(basepc, maxcurrsizeof(Byte));
	53	if (basepc == NULL)
	54	{
	55	lua_error ("not enough memory");
	56	err = 1;
	57	}
	58	}
	59	basepc[pc++] = c;
	60	}
	61
	62	static void code_word (Word n)
	63	{
	64	CodeWord code;
	65	code.w = n;
	66	code_byte(code.m.c1);
	67	code_byte(code.m.c2);
	68	}
	69
	70	static void code_float (float n)
	71	{
	72	CodeFloat code;
	73	code.f = n;
	74	code_byte(code.m.c1);
	75	code_byte(code.m.c2);
	76	code_byte(code.m.c3);
	77	code_byte(code.m.c4);
	78	}
	79
	80	static void code_word_at (Byte *p, Word n)
	81	{
	82	CodeWord code;
	83	code.w = n;
	84	*p++ = code.m.c1;
	85	*p++ = code.m.c2;
	86	}
	87
	88	static void push_field (Word name)
	89	{
	90	if (nfields < STACKGAP-1)
	91	fields[nfields++] = name;
	92	else
	93	{
	94	lua_error ("too many fields in a constructor");
	95	err = 1;
	96	}
	97	}
	98
	99	static void flush_record (int n)
	100	{
	101	int i;
	102	if (n == 0) return;
	103	code_byte(STORERECORD);
	104	code_byte(n);
	105	for (i=0; i<n; i++)
	106	code_word(fields[--nfields]);
	107	ntemp -= n;
	108	}
	109
	110	static void flush_list (int m, int n)
	111	{
	112	if (n == 0) return;
	113	if (m == 0)
	114	code_byte(STORELIST0);
	115	else
	116	{
	117	code_byte(STORELIST);
	118	code_byte(m);
	119	}
	120	code_byte(n);
	121	ntemp-=n;
	122	}
	123
	124	static void incr_ntemp (void)
	125	{
	126	if (ntemp+nlocalvar+MAXVAR+1 < STACKGAP)
	127	ntemp++;
	128	else
	129	{
	130	lua_error ("stack overflow");
	131	err = 1;
	132	}
	133	}
	134
	135	static void add_nlocalvar (int n)
	136	{
	137	if (ntemp+nlocalvar+MAXVAR+n < STACKGAP)
	138	nlocalvar += n;
	139	else
	140	{
	141	lua_error ("too many local variables or expression too complicate");
	142	err = 1;
	143	}
	144	}
	145
	146	static void incr_nvarbuffer (void)
	147	{
	148	if (nvarbuffer < MAXVAR-1)
	149	nvarbuffer++;
	150	else
	151	{
	152	lua_error ("variable buffer overflow");
	153	err = 1;
	154	}
	155	}
	156
	157	static void code_number (float f)
	158	{ Word i = (Word)f;
	159	if (f == (float)i) /* f has an (short) integer value */
	160	{
	161	if (i <= 2) code_byte(PUSH0 + i);
	162	else if (i <= 255)
	163	{
	164	code_byte(PUSHBYTE);
	165	code_byte(i);
	166	}
	167	else
	168	{
	169	code_byte(PUSHWORD);
	170	code_word(i);
	171	}
	172	}
	173	else
	174	{
	175	code_byte(PUSHFLOAT);
	176	code_float(f);
	177	}
	178	incr_ntemp();
	179	}
	180
	181	%}
	182
	183
	184	%union
	185	{
	186	int vInt;
	187	long vLong;
	188	float vFloat;
	189	char *pChar;
	190	Word vWord;
	191	Byte *pByte;
	192	}
	193
	194	%start functionlist
	195
	196	%token WRONGTOKEN
	197	%token NIL
	198	%token IF THEN ELSE ELSEIF WHILE DO REPEAT UNTIL END
	199	%token RETURN
	200	%token LOCAL
	201	%token <vFloat> NUMBER
	202	%token <vWord> FUNCTION STRING
	203	%token <pChar> NAME
	204	%token <vInt> DEBUG
	205
	206	%type <vWord> PrepJump
	207	%type <vInt> expr, exprlist, exprlist1, varlist1, typeconstructor
	208	%type <vInt> fieldlist, localdeclist
	209	%type <vInt> ffieldlist, ffieldlist1
	210	%type <vInt> lfieldlist, lfieldlist1
	211	%type <vLong> var, objectname
	212
	213
	214	%left AND OR
	215	%left '=' NE '>' '<' LE GE
	216	%left CONC
	217	%left '+' '-'
	218	%left '*' '/'
	219	%left UNARY NOT
	220
	221
	222	%% /* beginning of rules section */
	223
	224
	225	functionlist : /* empty */
	226	\| functionlist
	227	{
	228	pc=maincode; basepc=initcode; maxcurr=maxmain;
	229	nlocalvar=0;
	230	}
	231	stat sc
	232	{
	233	maincode=pc; initcode=basepc; maxmain=maxcurr;
	234	}
	235	\| functionlist function
	236	\| functionlist setdebug
	237	;
	238
	239	function : FUNCTION NAME
	240	{
	241	if (code == NULL) /* first function */
	242	{
	243	code = (Byte *) calloc(GAPCODE, sizeof(Byte));
	244	if (code == NULL)
	245	{
	246	lua_error("not enough memory");
	247	err = 1;
	248	}
	249	maxcode = GAPCODE;
	250	}
	251	pc=0; basepc=code; maxcurr=maxcode;
	252	nlocalvar=0;
	253	$<vWord>$ = lua_findsymbol($2);
	254	}
	255	'(' parlist ')'
	256	{
	257	if (lua_debug)
	258	{
	259	code_byte(SETFUNCTION);
	260	code_word(lua_nfile-1);
	261	code_word($<vWord>3);
	262	}
	263	lua_codeadjust (0);
	264	}
	265	block
	266	END
	267	{
	268	if (lua_debug) code_byte(RESET);
	269	code_byte(RETCODE); code_byte(nlocalvar);
	270	s_tag($<vWord>3) = T_FUNCTION;
	271	s_bvalue($<vWord>3) = calloc (pc, sizeof(Byte));
	272	if (s_bvalue($<vWord>3) == NULL)
	273	{
	274	lua_error("not enough memory");
	275	err = 1;
	276	}
	277	memcpy (s_bvalue($<vWord>3), basepc, pc*sizeof(Byte));
	278	code = basepc; maxcode=maxcurr;
	279	#if LISTING
	280	PrintCode(code,code+pc);
	281	#endif
	282	}
	283	;
	284
	285	statlist : /* empty */
	286	\| statlist stat sc
	287	;
	288
	289	stat : {
	290	ntemp = 0;
	291	if (lua_debug)
	292	{
	293	code_byte(SETLINE); code_word(lua_linenumber);
	294	}
	295	}
	296	stat1
	297
	298	sc : /* empty */ \| ';' ;
	299
	300
	301	stat1 : IF expr1 THEN PrepJump block PrepJump elsepart END
	302	{
	303	{
	304	Word elseinit = $6+sizeof(Word)+1;
	305	if (pc - elseinit == 0) /* no else */
	306	{
	307	pc -= sizeof(Word)+1;
	308	elseinit = pc;
	309	}
	310	else
	311	{
	312	basepc[$6] = JMP;
	313	code_word_at(basepc+$6+1, pc - elseinit);
	314	}
	315	basepc[$4] = IFFJMP;
	316	code_word_at(basepc+$4+1,elseinit-($4+sizeof(Word)+1));
	317	}
	318	}
	319
	320	\| WHILE {$<vWord>$=pc;} expr1 DO PrepJump block PrepJump END
	321
	322	{
	323	basepc[$5] = IFFJMP;
	324	code_word_at(basepc+$5+1, pc - ($5 + sizeof(Word)+1));
	325
	326	basepc[$7] = UPJMP;
	327	code_word_at(basepc+$7+1, pc - ($<vWord>2));
	328	}
	329
	330	\| REPEAT {$<vWord>$=pc;} block UNTIL expr1 PrepJump
	331
	332	{
	333	basepc[$6] = IFFUPJMP;
	334	code_word_at(basepc+$6+1, pc - ($<vWord>2));
	335	}
	336
	337
	338	\| varlist1 '=' exprlist1
	339	{
	340	{
	341	int i;
	342	if ($3 == 0 \|\| nvarbuffer != ntemp - $1 * 2)
	343	lua_codeadjust ($1 * 2 + nvarbuffer);
	344	for (i=nvarbuffer-1; i>=0; i--)
	345	lua_codestore (i);
	346	if ($1 > 1 \|\| ($1 == 1 && varbuffer[0] != 0))
	347	lua_codeadjust (0);
	348	}
	349	}
	350	\| functioncall { lua_codeadjust (0); }
	351	\| typeconstructor { lua_codeadjust (0); }
	352	\| LOCAL localdeclist decinit { add_nlocalvar($2); lua_codeadjust (0); }
	353	;
	354
	355	elsepart : /* empty */
	356	\| ELSE block
	357	\| ELSEIF expr1 THEN PrepJump block PrepJump elsepart
	358	{
	359	{
	360	Word elseinit = $6+sizeof(Word)+1;
	361	if (pc - elseinit == 0) /* no else */
	362	{
	363	pc -= sizeof(Word)+1;
	364	elseinit = pc;
	365	}
	366	else
	367	{
	368	basepc[$6] = JMP;
	369	code_word_at(basepc+$6+1, pc - elseinit);
	370	}
	371	basepc[$4] = IFFJMP;
	372	code_word_at(basepc+$4+1, elseinit - ($4 + sizeof(Word)+1));
	373	}
	374	}
	375	;
	376
	377	block : {$<vInt>$ = nlocalvar;} statlist {ntemp = 0;} ret
	378	{
	379	if (nlocalvar != $<vInt>1)
	380	{
	381	nlocalvar = $<vInt>1;
	382	lua_codeadjust (0);
	383	}
	384	}
	385	;
	386
	387	ret : /* empty */
	388	\| { if (lua_debug){code_byte(SETLINE);code_word(lua_linenumber);}}
	389	RETURN exprlist sc
	390	{
	391	if (lua_debug) code_byte(RESET);
	392	code_byte(RETCODE); code_byte(nlocalvar);
	393	}
	394	;
	395
	396	PrepJump : /* empty */
	397	{
	398	$$ = pc;
	399	code_byte(0); /* open space */
	400	code_word (0);
	401	}
	402
	403	expr1 : expr { if ($1 == 0) {lua_codeadjust (ntemp+1); incr_ntemp();}}
	404	;
	405
	406	expr : '(' expr ')' { $$ = $2; }
	407	\| expr1 '=' expr1 { code_byte(EQOP); $$ = 1; ntemp--;}
	408	\| expr1 '<' expr1 { code_byte(LTOP); $$ = 1; ntemp--;}
	409	\| expr1 '>' expr1 { code_byte(LEOP); code_byte(NOTOP); $$ = 1; ntemp--;}
	410	\| expr1 NE expr1 { code_byte(EQOP); code_byte(NOTOP); $$ = 1; ntemp--;}
	411	\| expr1 LE expr1 { code_byte(LEOP); $$ = 1; ntemp--;}
	412	\| expr1 GE expr1 { code_byte(LTOP); code_byte(NOTOP); $$ = 1; ntemp--;}
	413	\| expr1 '+' expr1 { code_byte(ADDOP); $$ = 1; ntemp--;}
	414	\| expr1 '-' expr1 { code_byte(SUBOP); $$ = 1; ntemp--;}
	415	\| expr1 '*' expr1 { code_byte(MULTOP); $$ = 1; ntemp--;}
	416	\| expr1 '/' expr1 { code_byte(DIVOP); $$ = 1; ntemp--;}
	417	\| expr1 CONC expr1 { code_byte(CONCOP); $$ = 1; ntemp--;}
	418	\| '+' expr1 %prec UNARY { $$ = 1; }
	419	\| '-' expr1 %prec UNARY { code_byte(MINUSOP); $$ = 1;}
	420	\| typeconstructor { $$ = $1; }
	421	\| '@' '(' dimension ')'
	422	{
	423	code_byte(CREATEARRAY);
	424	$$ = 1;
	425	}
	426	\| var { lua_pushvar ($1); $$ = 1;}
	427	\| NUMBER { code_number($1); $$ = 1; }
	428	\| STRING
	429	{
	430	code_byte(PUSHSTRING);
	431	code_word($1);
	432	$$ = 1;
	433	incr_ntemp();
	434	}
	435	\| NIL {code_byte(PUSHNIL); $$ = 1; incr_ntemp();}
	436	\| functioncall
	437	{
	438	$$ = 0;
	439	if (lua_debug)
	440	{
	441	code_byte(SETLINE); code_word(lua_linenumber);
	442	}
	443	}
	444	\| NOT expr1 { code_byte(NOTOP); $$ = 1;}
	445	\| expr1 AND PrepJump {code_byte(POP); ntemp--;} expr1
	446	{
	447	basepc[$3] = ONFJMP;
	448	code_word_at(basepc+$3+1, pc - ($3 + sizeof(Word)+1));
	449	$$ = 1;
	450	}
	451	\| expr1 OR PrepJump {code_byte(POP); ntemp--;} expr1
	452	{
	453	basepc[$3] = ONTJMP;
	454	code_word_at(basepc+$3+1, pc - ($3 + sizeof(Word)+1));
	455	$$ = 1;
	456	}
	457	;
	458
	459	typeconstructor: '@'
	460	{
	461	code_byte(PUSHBYTE);
	462	$<vWord>$ = pc; code_byte(0);
	463	incr_ntemp();
	464	code_byte(CREATEARRAY);
	465	}
	466	objectname fieldlist
	467	{
	468	basepc[$<vWord>2] = $4;
	469	if ($3 < 0) /* there is no function to be called */
	470	{
	471	$$ = 1;
	472	}
	473	else
	474	{
	475	lua_pushvar ($3+1);
	476	code_byte(PUSHMARK);
	477	incr_ntemp();
	478	code_byte(PUSHOBJECT);
	479	incr_ntemp();
	480	code_byte(CALLFUNC);
	481	ntemp -= 4;
	482	$$ = 0;
	483	if (lua_debug)
	484	{
	485	code_byte(SETLINE); code_word(lua_linenumber);
	486	}
	487	}
	488	}
	489	;
	490
	491	dimension : /* empty */ { code_byte(PUSHNIL); incr_ntemp();}
	492	\| expr1
	493	;
	494
	495	functioncall : functionvalue {code_byte(PUSHMARK); $<vInt>$ = ntemp; incr_ntemp();}
	496	'(' exprlist ')' { code_byte(CALLFUNC); ntemp = $<vInt>2-1;}
	497
	498	functionvalue : var {lua_pushvar ($1); }
	499	;
	500
	501	exprlist : /* empty */ { $$ = 1; }
	502	\| exprlist1 { $$ = $1; }
	503	;
	504
	505	exprlist1 : expr { $$ = $1; }
	506	\| exprlist1 ',' {if (!$1){lua_codeadjust (ntemp+1); incr_ntemp();}}
	507	expr {$$ = $4;}
	508	;
	509
	510	parlist : /* empty */
	511	\| parlist1
	512	;
	513
	514	parlist1 : NAME
	515	{
	516	localvar[nlocalvar]=lua_findsymbol($1);
	517	add_nlocalvar(1);
	518	}
	519	\| parlist1 ',' NAME
	520	{
	521	localvar[nlocalvar]=lua_findsymbol($3);
	522	add_nlocalvar(1);
	523	}
	524	;
	525
	526	objectname : /* empty */ {$$=-1;}
	527	\| NAME {$$=lua_findsymbol($1);}
	528	;
	529
	530	fieldlist : '{' ffieldlist '}'
	531	{
	532	flush_record($2%FIELDS_PER_FLUSH);
	533	$$ = $2;
	534	}
	535	\| '[' lfieldlist ']'
	536	{
	537	flush_list($2/FIELDS_PER_FLUSH, $2%FIELDS_PER_FLUSH);
	538	$$ = $2;
	539	}
	540	;
	541
	542	ffieldlist : /* empty */ { $$ = 0; }
	543	\| ffieldlist1 { $$ = $1; }
	544	;
	545
	546	ffieldlist1 : ffield {$$=1;}
	547	\| ffieldlist1 ',' ffield
	548	{
	549	$$=$1+1;
	550	if ($$%FIELDS_PER_FLUSH == 0) flush_record(FIELDS_PER_FLUSH);
	551	}
	552	;
	553
	554	ffield : NAME {$<vWord>$ = lua_findconstant($1);} '=' expr1
	555	{
	556	push_field($<vWord>2);
	557	}
	558	;
	559
	560	lfieldlist : /* empty */ { $$ = 0; }
	561	\| lfieldlist1 { $$ = $1; }
	562	;
	563
	564	lfieldlist1 : expr1 {$$=1;}
	565	\| lfieldlist1 ',' expr1
	566	{
	567	$$=$1+1;
	568	if ($$%FIELDS_PER_FLUSH == 0)
	569	flush_list($$/FIELDS_PER_FLUSH - 1, FIELDS_PER_FLUSH);
	570	}
	571	;
	572
	573	varlist1 : var
	574	{
	575	nvarbuffer = 0;
	576	varbuffer[nvarbuffer] = $1; incr_nvarbuffer();
	577	$$ = ($1 == 0) ? 1 : 0;
	578	}
	579	\| varlist1 ',' var
	580	{
	581	varbuffer[nvarbuffer] = $3; incr_nvarbuffer();
	582	$$ = ($3 == 0) ? $1 + 1 : $1;
	583	}
	584	;
	585
	586	var : NAME
	587	{
	588	Word s = lua_findsymbol($1);
	589	int local = lua_localname (s);
	590	if (local == -1) /* global var */
	591	$$ = s + 1; /* return positive value */
	592	else
	593	$$ = -(local+1); /* return negative value */
	594	}
	595
	596	\| var {lua_pushvar ($1);} '[' expr1 ']'
	597	{
	598	$$ = 0; /* indexed variable */
	599	}
	600	\| var {lua_pushvar ($1);} '.' NAME
	601	{
	602	code_byte(PUSHSTRING);
	603	code_word(lua_findconstant($4)); incr_ntemp();
	604	$$ = 0; /* indexed variable */
	605	}
	606	;
	607
	608	localdeclist : NAME {localvar[nlocalvar]=lua_findsymbol($1); $$ = 1;}
	609	\| localdeclist ',' NAME
	610	{
	611	localvar[nlocalvar+$1]=lua_findsymbol($3);
	612	$$ = $1+1;
	613	}
	614	;
	615
	616	decinit : /* empty */
	617	\| '=' exprlist1
	618	;
	619
	620	setdebug : DEBUG {lua_debug = $1;}
	621
	622	%%
	623
	624	/*
	625	** Search a local name and if find return its index. If do not find return -1
	626	*/
	627	static int lua_localname (Word n)
	628	{
	629	int i;
	630	for (i=nlocalvar-1; i >= 0; i--)
	631	if (n == localvar[i]) return i; /* local var */
	632	return -1; /* global var */
	633	}
	634
	635	/*
	636	** Push a variable given a number. If number is positive, push global variable
	637	** indexed by (number -1). If negative, push local indexed by ABS(number)-1.
	638	** Otherwise, if zero, push indexed variable (record).
	639	*/
	640	static void lua_pushvar (long number)
	641	{
	642	if (number > 0) /* global var */
	643	{
	644	code_byte(PUSHGLOBAL);
	645	code_word(number-1);
	646	incr_ntemp();
	647	}
	648	else if (number < 0) /* local var */
	649	{
	650	number = (-number) - 1;
	651	if (number < 10) code_byte(PUSHLOCAL0 + number);
	652	else
	653	{
	654	code_byte(PUSHLOCAL);
	655	code_byte(number);
	656	}
	657	incr_ntemp();
	658	}
	659	else
	660	{
	661	code_byte(PUSHINDEXED);
	662	ntemp--;
	663	}
	664	}
	665
	666	static void lua_codeadjust (int n)
	667	{
	668	code_byte(ADJUST);
	669	code_byte(n + nlocalvar);
	670	}
	671
	672	static void lua_codestore (int i)
	673	{
	674	if (varbuffer[i] > 0) /* global var */
	675	{
	676	code_byte(STOREGLOBAL);
	677	code_word(varbuffer[i]-1);
	678	}
	679	else if (varbuffer[i] < 0) /* local var */
	680	{
	681	int number = (-varbuffer[i]) - 1;
	682	if (number < 10) code_byte(STORELOCAL0 + number);
	683	else
	684	{
	685	code_byte(STORELOCAL);
	686	code_byte(number);
	687	}
	688	}
	689	else /* indexed var */
	690	{
	691	int j;
	692	int upper=0; /* number of indexed variables upper */
	693	int param; /* number of itens until indexed expression */
	694	for (j=i+1; j <nvarbuffer; j++)
	695	if (varbuffer[j] == 0) upper++;
	696	param = upper*2 + i;
	697	if (param == 0)
	698	code_byte(STOREINDEXED0);
	699	else
	700	{
	701	code_byte(STOREINDEXED);
	702	code_byte(param);
	703	}
	704	}
	705	}
	706
	707	void yyerror (char *s)
	708	{
	709	static char msg[256];
	710	sprintf (msg,"%s near \"%s\" at line %d in file \"%s\"",
	711	s, lua_lasttext (), lua_linenumber, lua_filename());
	712	lua_error (msg);
	713	err = 1;
	714	}
	715
	716	int yywrap (void)
	717	{
	718	return 1;
	719	}
	720
	721
	722	/*
	723	** Parse LUA code and execute global statement.
	724	** Return 0 on success or 1 on error.
	725	*/
	726	int lua_parse (void)
	727	{
	728	Byte init = initcode = (Byte ) calloc(GAPCODE, sizeof(Byte));
	729	maincode = 0;
	730	maxmain = GAPCODE;
	731	if (init == NULL)
	732	{
	733	lua_error("not enough memory");
	734	return 1;
	735	}
	736	err = 0;
	737	if (yyparse () \|\| (err==1)) return 1;
	738	initcode[maincode++] = HALT;
	739	init = initcode;
	740	#if LISTING
	741	PrintCode(init,init+maincode);
	742	#endif
	743	if (lua_execute (init)) return 1;
	744	free(init);
	745	return 0;
	746	}
	747
	748
	749	#if LISTING
	750
	751	static void PrintCode (Byte code, Byte end)
	752	{
	753	Byte *p = code;
	754	printf ("\n\nCODE\n");
	755	while (p != end)
	756	{
	757	switch ((OpCode)*p)
	758	{
	759	case PUSHNIL: printf ("%d PUSHNIL\n", (p++)-code); break;
	760	case PUSH0: case PUSH1: case PUSH2:
	761	printf ("%d PUSH%c\n", p-code, *p-PUSH0+'0');
	762	p++;
	763	break;
	764	case PUSHBYTE:
	765	printf ("%d PUSHBYTE %d\n", p-code, *(++p));
	766	p++;
	767	break;
	768	case PUSHWORD:
	769	{
	770	CodeWord c;
	771	int n = p-code;
	772	p++;
	773	get_word(c,p);
	774	printf ("%d PUSHWORD %d\n", n, c.w);
	775	}
	776	break;
	777	case PUSHFLOAT:
	778	{
	779	CodeFloat c;
	780	int n = p-code;
	781	p++;
	782	get_float(c,p);
	783	printf ("%d PUSHFLOAT %f\n", n, c.f);
	784	}
	785	break;
	786	case PUSHSTRING:
	787	{
	788	CodeWord c;
	789	int n = p-code;
	790	p++;
	791	get_word(c,p);
	792	printf ("%d PUSHSTRING %d\n", n, c.w);
	793	}
	794	break;
	795	case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
	796	case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
	797	case PUSHLOCAL8: case PUSHLOCAL9:
	798	printf ("%d PUSHLOCAL%c\n", p-code, *p-PUSHLOCAL0+'0');
	799	p++;
	800	break;
	801	case PUSHLOCAL: printf ("%d PUSHLOCAL %d\n", p-code, *(++p));
	802	p++;
	803	break;
	804	case PUSHGLOBAL:
	805	{
	806	CodeWord c;
	807	int n = p-code;
	808	p++;
	809	get_word(c,p);
	810	printf ("%d PUSHGLOBAL %d\n", n, c.w);
	811	}
	812	break;
	813	case PUSHINDEXED: printf ("%d PUSHINDEXED\n", (p++)-code); break;
	814	case PUSHMARK: printf ("%d PUSHMARK\n", (p++)-code); break;
	815	case PUSHOBJECT: printf ("%d PUSHOBJECT\n", (p++)-code); break;
	816	case STORELOCAL0: case STORELOCAL1: case STORELOCAL2: case STORELOCAL3:
	817	case STORELOCAL4: case STORELOCAL5: case STORELOCAL6: case STORELOCAL7:
	818	case STORELOCAL8: case STORELOCAL9:
	819	printf ("%d STORELOCAL%c\n", p-code, *p-STORELOCAL0+'0');
	820	p++;
	821	break;
	822	case STORELOCAL:
	823	printf ("%d STORELOCAL %d\n", p-code, *(++p));
	824	p++;
	825	break;
	826	case STOREGLOBAL:
	827	{
	828	CodeWord c;
	829	int n = p-code;
	830	p++;
	831	get_word(c,p);
	832	printf ("%d STOREGLOBAL %d\n", n, c.w);
	833	}
	834	break;
	835	case STOREINDEXED0: printf ("%d STOREINDEXED0\n", (p++)-code); break;
	836	case STOREINDEXED: printf ("%d STOREINDEXED %d\n", p-code, *(++p));
	837	p++;
	838	break;
	839	case STORELIST0:
	840	printf("%d STORELIST0 %d\n", p-code, *(++p));
	841	p++;
	842	break;
	843	case STORELIST:
	844	printf("%d STORELIST %d %d\n", p-code, (p+1), (p+2));
	845	p+=3;
	846	break;
	847	case STORERECORD:
	848	printf("%d STORERECORD %d\n", p-code, *(++p));
	849	p += psizeof(Word) + 1;
	850	break;
	851	case ADJUST:
	852	printf ("%d ADJUST %d\n", p-code, *(++p));
	853	p++;
	854	break;
	855	case CREATEARRAY: printf ("%d CREATEARRAY\n", (p++)-code); break;
	856	case EQOP: printf ("%d EQOP\n", (p++)-code); break;
	857	case LTOP: printf ("%d LTOP\n", (p++)-code); break;
	858	case LEOP: printf ("%d LEOP\n", (p++)-code); break;
	859	case ADDOP: printf ("%d ADDOP\n", (p++)-code); break;
	860	case SUBOP: printf ("%d SUBOP\n", (p++)-code); break;
	861	case MULTOP: printf ("%d MULTOP\n", (p++)-code); break;
	862	case DIVOP: printf ("%d DIVOP\n", (p++)-code); break;
	863	case CONCOP: printf ("%d CONCOP\n", (p++)-code); break;
	864	case MINUSOP: printf ("%d MINUSOP\n", (p++)-code); break;
	865	case NOTOP: printf ("%d NOTOP\n", (p++)-code); break;
	866	case ONTJMP:
	867	{
	868	CodeWord c;
	869	int n = p-code;
	870	p++;
	871	get_word(c,p);
	872	printf ("%d ONTJMP %d\n", n, c.w);
	873	}
	874	break;
	875	case ONFJMP:
	876	{
	877	CodeWord c;
	878	int n = p-code;
	879	p++;
	880	get_word(c,p);
	881	printf ("%d ONFJMP %d\n", n, c.w);
	882	}
	883	break;
	884	case JMP:
	885	{
	886	CodeWord c;
	887	int n = p-code;
	888	p++;
	889	get_word(c,p);
	890	printf ("%d JMP %d\n", n, c.w);
	891	}
	892	break;
	893	case UPJMP:
	894	{
	895	CodeWord c;
	896	int n = p-code;
	897	p++;
	898	get_word(c,p);
	899	printf ("%d UPJMP %d\n", n, c.w);
	900	}
	901	break;
	902	case IFFJMP:
	903	{
	904	CodeWord c;
	905	int n = p-code;
	906	p++;
	907	get_word(c,p);
	908	printf ("%d IFFJMP %d\n", n, c.w);
	909	}
	910	break;
	911	case IFFUPJMP:
	912	{
	913	CodeWord c;
	914	int n = p-code;
	915	p++;
	916	get_word(c,p);
	917	printf ("%d IFFUPJMP %d\n", n, c.w);
	918	}
	919	break;
	920	case POP: printf ("%d POP\n", (p++)-code); break;
	921	case CALLFUNC: printf ("%d CALLFUNC\n", (p++)-code); break;
	922	case RETCODE:
	923	printf ("%d RETCODE %d\n", p-code, *(++p));
	924	p++;
	925	break;
	926	case HALT: printf ("%d HALT\n", (p++)-code); break;
	927	case SETFUNCTION:
	928	{
	929	CodeWord c1, c2;
	930	int n = p-code;
	931	p++;
	932	get_word(c1,p);
	933	get_word(c2,p);
	934	printf ("%d SETFUNCTION %d %d\n", n, c1.w, c2.w);
	935	}
	936	break;
	937	case SETLINE:
	938	{
	939	CodeWord c;
	940	int n = p-code;
	941	p++;
	942	get_word(c,p);
	943	printf ("%d SETLINE %d\n", n, c.w);
	944	}
	945	break;
	946
	947	case RESET: printf ("%d RESET\n", (p++)-code); break;
	948	default: printf ("%d Cannot happen: code %d\n", (p++)-code, *(p-1)); break;
	949	}
	950	}
	951	}
	952	#endif
	953

Lua 1.1

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code