Lua 3.0

Lua Team committed 29 years ago

Commit 9bc113c1 parent 100a7f178 files · +6569 −11586Browse files

Showing the changes to src (33 of 78 files). Show all

Unified · Split

33 files

src/Makefile +12 −6
src/auxlib.c +81 −0
src/auxlib.h +30 −0
src/fallback.c +286 −109
src/fallback.h +50 −22
src/func.c +26 −16
src/func.h +3 −2
src/hash.c +147 −134
src/hash.h +17 −16
src/inout.c +278 −170
src/inout.h +8 −17
src/lex.c +174 −45
src/lex.h +3 −4
src/lua.stx +29 −34
src/luac/dump.c +11 −19
src/luac/luac.c +112 −27
src/luac/luac.h +6 −5
src/luac/print.c +213 −20
src/luac/print.h +6 −3
src/luamem.c +159 −0
src/luamem.h +3 −3
src/mem.c +0 −58
src/opcode.c +517 −369
src/opcode.h +46 −25
src/parser.c +344 −316
src/table.c +84 −96
src/table.h +6 −5
src/tree.c +92 −26
src/tree.h +14 −4
src/undump.c +71 −74
src/undump.h +11 −4
src/zio.c +79 −0
src/zio.h +48 −0

 include $(LUA)/config
-OBJS=	fallback.o\
+OBJS=	auxlib.o\
+	fallback.o\
 	func.o\
 	hash.o\
 	inout.o\
 	lex.o\
-	mem.o\
+	luamem.o\
 	opcode.o\
 	parser.o\
 	table.o\
 	tree.o\
-	undump.o
+	undump.o\
+	zio.o
-SRCS=	fallback.c\
+SRCS=	auxlib.c\
+	auxlib.h\
+	fallback.c\
 	fallback.h\
 	func.c\
 	func.h\
 	inout.h\
 	lex.c\
 	lex.h\
-	mem.c\
+	luamem.c\
-	mem.h\
+	luamem.h\
 	opcode.c\
 	opcode.h\
 	parser.c\
 	types.h\
 	undump.c\
 	undump.h\
+	zio.c\
+	zio.h\
 	lua.stx
 SLIB= $(LIB)/liblua.a

src/auxlib.c+81−0

@@ -0,0 +1,81 @@
	1	char *rcs_auxlib="$Id: auxlib.c,v 1.5 1997/04/14 15:30:03 roberto Exp $";
	2
	3	#include <stdio.h>
	4	#include <stdarg.h>
	5	#include <string.h>
	6
	7	#include "lua.h"
	8	#include "auxlib.h"
	9	#include "luadebug.h"
	10
	11
	12
	13	int luaI_findstring (char name, char list[])
	14	{
	15	int i;
	16	for (i=0; list[i]; i++)
	17	if (strcmp(list[i], name) == 0)
	18	return i;
	19	return -1; /* name not found */
	20	}
	21
	22
	23	void luaL_arg_check(int cond, int numarg, char *extramsg)
	24	{
	25	if (!cond) {
	26	char *funcname;
	27	lua_getobjname(lua_stackedfunction(0), &funcname);
	28	if (funcname == NULL)
	29	funcname = "???";
	30	if (extramsg == NULL)
	31	luaL_verror("bad argument #%d to function `%s'", numarg, funcname);
	32	else
	33	luaL_verror("bad argument #%d to function `%s' (%s)",
	34	numarg, funcname, extramsg);
	35	}
	36	}
	37
	38	char *luaL_check_string (int numArg)
	39	{
	40	lua_Object o = lua_getparam(numArg);
	41	luaL_arg_check(lua_isstring(o), numArg, "string expected");
	42	return lua_getstring(o);
	43	}
	44
	45	char luaL_opt_string (int numArg, char def)
	46	{
	47	return (lua_getparam(numArg) == LUA_NOOBJECT) ? def :
	48	luaL_check_string(numArg);
	49	}
	50
	51	double luaL_check_number (int numArg)
	52	{
	53	lua_Object o = lua_getparam(numArg);
	54	luaL_arg_check(lua_isnumber(o), numArg, "number expected");
	55	return lua_getnumber(o);
	56	}
	57
	58
	59	double luaL_opt_number (int numArg, double def)
	60	{
	61	return (lua_getparam(numArg) == LUA_NOOBJECT) ? def :
	62	luaL_check_number(numArg);
	63	}
	64
	65	void luaL_openlib (struct luaL_reg *l, int n)
	66	{
	67	int i;
	68	for (i=0; i<n; i++)
	69	lua_register(l[i].name, l[i].func);
	70	}
	71
	72
	73	void luaL_verror (char *fmt, ...)
	74	{
	75	char buff[1000];
	76	va_list argp;
	77	va_start(argp, fmt);
	78	vsprintf(buff, fmt, argp);
	79	va_end(argp);
	80	lua_error(buff);
	81	}

src/auxlib.h+30−0

@@ -0,0 +1,30 @@
	1	/*
	2	** $Id: auxlib.h,v 1.3 1997/04/07 14:48:53 roberto Exp $
	3	*/
	4
	5	#ifndef auxlib_h
	6	#define auxlib_h
	7
	8	#include "lua.h"
	9
	10	struct luaL_reg {
	11	char *name;
	12	lua_CFunction func;
	13	};
	14
	15	void luaL_openlib (struct luaL_reg *l, int n);
	16	void luaL_arg_check(int cond, int numarg, char *extramsg);
	17	char *luaL_check_string (int numArg);
	18	char luaL_opt_string (int numArg, char def);
	19	double luaL_check_number (int numArg);
	20	double luaL_opt_number (int numArg, double def);
	21	void luaL_verror (char *fmt, ...);
	22
	23
	24
	25	/* -- private part (only for Lua modules */
	26
	27	int luaI_findstring (char name, char list[]);
	28
	29
	30	#endif

src/fallback.c+286−109

@@ -3,130 +3,37 @@ · 2 unmodified lines
3	** TecCGraf - PUC-Rio	3	** TecCGraf - PUC-Rio
4	*/	4	*/
5		5
6	char *rcs_fallback="$Id: fallback.c,v 1.25 1996/04/25 14:10:00 roberto Exp $";	6	char *rcs_fallback="$Id: fallback.c,v 2.9 1997/06/23 18:27:53 roberto Exp $";
7		7
8	#include <stdio.h>	8	#include <stdio.h>
9	#include <string.h>	9	#include <string.h>
10		10
11	#include "mem.h"	11	#include "auxlib.h"
		12	#include "luamem.h"
12	#include "fallback.h"	13	#include "fallback.h"
13	#include "opcode.h"	14	#include "opcode.h"
14	#include "lua.h"	15	#include "lua.h"
15	#include "table.h"	16	#include "table.h"
		17	#include "tree.h"
		18	#include "hash.h"
16		19
17		20
18	static void errorFB (void);
19	static void indexFB (void);
20	static void gettableFB (void);
21	static void arithFB (void);
22	static void concatFB (void);
23	static void orderFB (void);
24	static void GDFB (void);
25	static void funcFB (void);
26		21
27		22	/* -------------------------------------------
28	/*
29	** Warning: This list must be in the same order as the #define's
30	*/
31	struct FB luaI_fallBacks[] = {
32	{"error", {LUA_T_CFUNCTION, {errorFB}}, 1, 0},
33	{"index", {LUA_T_CFUNCTION, {indexFB}}, 2, 1},
34	{"gettable", {LUA_T_CFUNCTION, {gettableFB}}, 2, 1},
35	{"arith", {LUA_T_CFUNCTION, {arithFB}}, 3, 1},
36	{"order", {LUA_T_CFUNCTION, {orderFB}}, 3, 1},
37	{"concat", {LUA_T_CFUNCTION, {concatFB}}, 2, 1},
38	{"settable", {LUA_T_CFUNCTION, {gettableFB}}, 3, 0},
39	{"gc", {LUA_T_CFUNCTION, {GDFB}}, 1, 0},
40	{"function", {LUA_T_CFUNCTION, {funcFB}}, -1, -1},
41	/* no fixed number of params or results */
42	{"getglobal", {LUA_T_CFUNCTION, {indexFB}}, 1, 1}
43	/* same default behavior of index FB */
44	};
45
46	#define N_FB (sizeof(luaI_fallBacks)/sizeof(struct FB))
47
48	void luaI_setfallback (void)
49	{
50	int i;
51	char *name = lua_getstring(lua_getparam(1));
52	lua_Object func = lua_getparam(2);
53	if (name == NULL \|\| !lua_isfunction(func))
54	lua_error("incorrect argument to function `setfallback'");
55	for (i=0; i<N_FB; i++)
56	{
57	if (strcmp(luaI_fallBacks[i].kind, name) == 0)
58	{
59	luaI_pushobject(&luaI_fallBacks[i].function);
60	luaI_fallBacks[i].function = *luaI_Address(func);
61	return;
62	}
63	}
64	/* name not found */
65	lua_error("incorrect argument to function `setfallback'");
66	}
67
68
69	static void errorFB (void)
70	{
71	lua_Object o = lua_getparam(1);
72	if (lua_isstring(o))
73	fprintf (stderr, "lua: %s\n", lua_getstring(o));
74	else
75	fprintf(stderr, "lua: unknown error\n");
76	}
77
78
79	static void indexFB (void)
80	{
81	lua_pushnil();
82	}
83
84
85	static void gettableFB (void)
86	{
87	lua_error("indexed expression not a table");
88	}
89
90
91	static void arithFB (void)
92	{
93	lua_error("unexpected type at conversion to number");
94	}
95
96	static void concatFB (void)
97	{
98	lua_error("unexpected type at conversion to string");
99	}
100
101
102	static void orderFB (void)
103	{
104	lua_error("unexpected type at comparison");
105	}
106
107	static void GDFB (void) { }
108
109	static void funcFB (void)
110	{
111	lua_error("call expression not a function");
112	}
113
114
115	/*
116	** Reference routines	23	** Reference routines
117	*/	24	*/
118		25
119	static struct ref {	26	static struct ref {
120	Object o;	27	TObject o;
121	enum {LOCK, HOLD, FREE, COLLECTED} status;	28	enum {LOCK, HOLD, FREE, COLLECTED} status;
122	} *refArray = NULL;	29	} *refArray = NULL;
123	static int refSize = 0;	30	static int refSize = 0;
124		31
125	int luaI_ref (Object *object, int lock)	32	int luaI_ref (TObject *object, int lock)
126	{	33	{
127	int i;	34	int i;
128	int oldSize;	35	int oldSize;
129	if (tag(object) == LUA_T_NIL)	36	if (ttype(object) == LUA_T_NIL)
130	return -1; /* special ref for nil */	37	return -1; /* special ref for nil */
131	for (i=0; i<refSize; i++)	38	for (i=0; i<refSize; i++)
132	if (refArray[i].status == FREE)	39	if (refArray[i].status == FREE)
@@ -151,9 +58,9 @@ void lua_unref (int ref) · 18 unmodified lines
151	}	58	}
152		59
153		60
154	Object *luaI_getref (int ref)	61	TObject *luaI_getref (int ref)
155	{	62	{
156	static Object nul = {LUA_T_NIL, {0}};	63	static TObject nul = {LUA_T_NIL, {0}};
157	if (ref == -1)	64	if (ref == -1)
158	return &nul;	65	return &nul;
159	if (ref >= 0 && ref < refSize &&	66	if (ref >= 0 && ref < refSize &&
@@ -164,7 +71,7 @@ Object *luaI_getref (int ref) · 4 unmodified lines
164	}	71	}
165		72
166		73
167	void luaI_travlock (int (fn)(Object ))	74	void luaI_travlock (int (fn)(TObject ))
168	{	75	{
169	int i;	76	int i;
170	for (i=0; i<refSize; i++)	77	for (i=0; i<refSize; i++)
@@ -181,11 +88,281 @@ void luaI_invalidaterefs (void) · 10 unmodified lines
181	refArray[i].status = COLLECTED;	88	refArray[i].status = COLLECTED;
182	}	89	}
183		90
184	char luaI_travfallbacks (int (fn)(Object *))	91
		92	/* -------------------------------------------
		93	* Internal Methods
		94	*/
		95
		96	char luaI_eventname[] = { / ORDER IM */
		97	"gettable", "settable", "index", "getglobal", "setglobal", "add",
		98	"sub", "mul", "div", "pow", "unm", "lt", "le", "gt", "ge",
		99	"concat", "gc", "function",
		100	NULL
		101	};
		102
		103
		104
		105	static int luaI_checkevent (char name, char list[])
		106	{
		107	int e = luaI_findstring(name, list);
		108	if (e < 0)
		109	luaL_verror("`%s' is not a valid event name", name);
		110	return e;
		111	}
		112
		113
		114	struct IM *luaI_IMtable = NULL;
		115
		116	static int IMtable_size = 0;
		117	static int last_tag = LUA_T_NIL; /* ORDER LUA_T */
		118
		119
		120	/* events in LUA_T_LINE are all allowed, since this is used as a
		121	* 'placeholder' for "default" fallbacks
		122	*/
		123	static char validevents[NUM_TYPES][IM_N] = { /* ORDER LUA_T, ORDER IM */
		124	{1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* LUA_T_USERDATA */
		125	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* LUA_T_LINE */
		126	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* LUA_T_CMARK */
		127	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, /* LUA_T_MARK */
		128	{1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0}, /* LUA_T_CFUNCTION */
		129	{1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0}, /* LUA_T_FUNCTION */
		130	{0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* LUA_T_ARRAY */
		131	{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, /* LUA_T_STRING */
		132	{1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1}, /* LUA_T_NUMBER */
		133	{1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} /* LUA_T_NIL */
		134	};
		135
		136	static int validevent (lua_Type t, int e)
		137	{ /* ORDER LUA_T */
		138	return (t < LUA_T_NIL) ? 1 : validevents[-t][e];
		139	}
		140
		141
		142	static void init_entry (int tag)
185	{	143	{
186	int i;	144	int i;
187	for (i=0; i<N_FB; i++)	145	for (i=0; i<IM_N; i++)
188	if (fn(&luaI_fallBacks[i].function))	146	ttype(luaI_getim(tag, i)) = LUA_T_NIL;
189	return luaI_fallBacks[i].kind;	147	}
		148
		149	void luaI_initfallbacks (void)
		150	{
		151	if (luaI_IMtable == NULL) {
		152	int i;
		153	IMtable_size = NUM_TYPES+10;
		154	luaI_IMtable = newvector(IMtable_size, struct IM);
		155	for (i=LUA_T_NIL; i<=LUA_T_USERDATA; i++)
		156	init_entry(i);
		157	}
		158	}
		159
		160	int lua_newtag (void)
		161	{
		162	--last_tag;
		163	if ((-last_tag) >= IMtable_size) {
		164	luaI_initfallbacks();
		165	IMtable_size = growvector(&luaI_IMtable, IMtable_size,
		166	struct IM, memEM, MAX_INT);
		167	}
		168	init_entry(last_tag);
		169	return last_tag;
		170	}
		171
		172
		173	static void checktag (int tag)
		174	{
		175	if (!(last_tag <= tag && tag <= 0))
		176	luaL_verror("%d is not a valid tag", tag);
		177	}
		178
		179	void luaI_realtag (int tag)
		180	{
		181	if (!(last_tag <= tag && tag < LUA_T_NIL))
		182	luaL_verror("tag %d is not result of `newtag'", tag);
		183	}
		184
		185
		186	void luaI_settag (int tag, TObject *o)
		187	{
		188	luaI_realtag(tag);
		189	switch (ttype(o)) {
		190	case LUA_T_ARRAY:
		191	o->value.a->htag = tag;
		192	break;
		193	case LUA_T_USERDATA:
		194	o->value.ts->tag = tag;
		195	break;
		196	default:
		197	luaL_verror("cannot change the tag of a %s", luaI_typenames[-ttype(o)]);
		198	}
		199	}
		200
		201
		202	int luaI_efectivetag (TObject *o)
		203	{
		204	lua_Type t = ttype(o);
		205	if (t == LUA_T_USERDATA) {
		206	int tag = o->value.ts->tag;
		207	return (tag >= 0) ? LUA_T_USERDATA : tag;
		208	}
		209	else if (t == LUA_T_ARRAY)
		210	return o->value.a->htag;
		211	else return t;
		212	}
		213
		214
		215	void luaI_gettagmethod (void)
		216	{
		217	int t = (int)luaL_check_number(1);
		218	int e = luaI_checkevent(luaL_check_string(2), luaI_eventname);
		219	checktag(t);
		220	if (validevent(t, e))
		221	luaI_pushobject(luaI_getim(t,e));
		222	}
		223
		224
		225	void luaI_settagmethod (void)
		226	{
		227	int t = (int)luaL_check_number(1);
		228	int e = luaI_checkevent(luaL_check_string(2), luaI_eventname);
		229	lua_Object func = lua_getparam(3);
		230	checktag(t);
		231	if (!validevent(t, e))
		232	luaL_verror("cannot change internal method `%s' for tag %d",
		233	luaI_eventname[e], t);
		234	luaL_arg_check(lua_isnil(func) \|\| lua_isfunction(func),
		235	3, "function expected");
		236	luaI_pushobject(luaI_getim(t,e));
		237	luaI_getim(t, e) = luaI_Address(func);
		238	}
		239
		240
		241	static void stderrorim (void)
		242	{
		243	lua_Object s = lua_getparam(1);
		244	if (lua_isstring(s))
		245	fprintf(stderr, "lua: %s\n", lua_getstring(s));
		246	}
		247
		248	static TObject errorim = {LUA_T_CFUNCTION, {stderrorim}};
		249
		250
		251	TObject *luaI_geterrorim (void)
		252	{
		253	return &errorim;
		254	}
		255
		256	void luaI_seterrormethod (void)
		257	{
		258	lua_Object func = lua_getparam(1);
		259	luaL_arg_check(lua_isnil(func) \|\| lua_isfunction(func),
		260	1, "function expected");
		261	luaI_pushobject(&errorim);
		262	errorim = *luaI_Address(func);
		263	}
		264
		265	char luaI_travfallbacks (int (fn)(TObject *))
		266	{
		267	int e;
		268	if (fn(&errorim))
		269	return "error";
		270	for (e=IM_GETTABLE; e<=IM_FUNCTION; e++) { /* ORDER IM */
		271	int t;
		272	for (t=0; t>=last_tag; t--)
		273	if (fn(luaI_getim(t,e)))
		274	return luaI_eventname[e];
		275	}
190	return NULL;	276	return NULL;
191	}	277	}
		278
		279
		280	/*
		281	* ===================================================================
		282	* compatibility with old fallback system
		283	*/
		284	#if LUA_COMPAT2_5
		285
		286	static void errorFB (void)
		287	{
		288	lua_Object o = lua_getparam(1);
		289	if (lua_isstring(o))
		290	fprintf (stderr, "lua: %s\n", lua_getstring(o));
		291	else
		292	fprintf(stderr, "lua: unknown error\n");
		293	}
		294
		295
		296	static void nilFB (void) { }
		297
		298
		299	static void typeFB (void)
		300	{
		301	lua_error("unexpected type");
		302	}
		303
		304
		305	static void fillvalids (IMS e, TObject *func)
		306	{
		307	int t;
		308	for (t=LUA_T_NIL; t<=LUA_T_USERDATA; t++)
		309	if (validevent(t, e))
		310	luaI_getim(t, e) = func;
		311	}
		312
		313
		314	void luaI_setfallback (void)
		315	{
		316	static char *oldnames [] = {"error", "getglobal", "arith", "order", NULL};
		317	TObject oldfunc;
		318	lua_CFunction replace;
		319	char *name = luaL_check_string(1);
		320	lua_Object func = lua_getparam(2);
		321	luaI_initfallbacks();
		322	luaL_arg_check(lua_isfunction(func), 2, "function expected");
		323	switch (luaI_findstring(name, oldnames)) {
		324	case 0: /* old error fallback */
		325	oldfunc = errorim;
		326	errorim = *luaI_Address(func);
		327	replace = errorFB;
		328	break;
		329	case 1: /* old getglobal fallback */
		330	oldfunc = *luaI_getim(LUA_T_NIL, IM_GETGLOBAL);
		331	luaI_getim(LUA_T_NIL, IM_GETGLOBAL) = luaI_Address(func);
		332	replace = nilFB;
		333	break;
		334	case 2: { /* old arith fallback */
		335	int i;
		336	oldfunc = *luaI_getim(LUA_T_NUMBER, IM_POW);
		337	for (i=IM_ADD; i<=IM_UNM; i++) /* ORDER IM */
		338	fillvalids(i, luaI_Address(func));
		339	replace = typeFB;
		340	break;
		341	}
		342	case 3: { /* old order fallback */
		343	int i;
		344	oldfunc = *luaI_getim(LUA_T_LINE, IM_LT);
		345	for (i=IM_LT; i<=IM_GE; i++) /* ORDER IM */
		346	fillvalids(i, luaI_Address(func));
		347	replace = typeFB;
		348	break;
		349	}
		350	default: {
		351	int e;
		352	if ((e = luaI_findstring(name, luaI_eventname)) >= 0) {
		353	oldfunc = *luaI_getim(LUA_T_LINE, e);
		354	fillvalids(e, luaI_Address(func));
		355	replace = (e == IM_GC \|\| e == IM_INDEX) ? nilFB : typeFB;
		356	}
		357	else {
		358	luaL_verror("`%s' is not a valid fallback name", name);
		359	replace = NULL; /* to avoid warnings */
		360	}
		361	}
		362	}
		363	if (oldfunc.ttype != LUA_T_NIL)
		364	luaI_pushobject(&oldfunc);
		365	else
		366	lua_pushcfunction(replace);
		367	}
		368	#endif

src/fallback.h+50−22

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: fallback.h,v 1.13 1996/04/25 14:10:00 roberto Exp $	2	** $Id: fallback.h,v 1.23 1997/04/24 22:59:57 roberto Exp $
3	*/	3	*/
4		4
5	#ifndef fallback_h	5	#ifndef fallback_h
@@ -8,30 +8,58 @@ · 2 unmodified lines
8	#include "lua.h"	8	#include "lua.h"
9	#include "opcode.h"	9	#include "opcode.h"
10		10
11	extern struct FB {	11	/*
12	char *kind;	12	* WARNING: if you change the order of this enumeration,
13	Object function;	13	* grep "ORDER IM"
14	int nParams;	14	*/
15	int nResults;	15	typedef enum {
16	} luaI_fallBacks[];	16	IM_GETTABLE = 0,
17		17	IM_SETTABLE,
18	#define FB_ERROR 0	18	IM_INDEX,
19	#define FB_INDEX 1	19	IM_GETGLOBAL,
20	#define FB_GETTABLE 2	20	IM_SETGLOBAL,
21	#define FB_ARITH 3	21	IM_ADD,
22	#define FB_ORDER 4	22	IM_SUB,
23	#define FB_CONCAT 5	23	IM_MUL,
24	#define FB_SETTABLE 6	24	IM_DIV,
25	#define FB_GC 7	25	IM_POW,
26	#define FB_FUNCTION 8	26	IM_UNM,
27	#define FB_GETGLOBAL 9	27	IM_LT,
		28	IM_LE,
		29	IM_GT,
		30	IM_GE,
		31	IM_CONCAT,
		32	IM_GC,
		33	IM_FUNCTION
		34	} IMS;
		35
		36	#define IM_N 18
		37
		38
		39	extern struct IM {
		40	TObject int_method[IM_N];
		41	} *luaI_IMtable;
		42
		43	extern char *luaI_eventname[];
		44
		45	#define luaI_getim(tag,event) (&luaI_IMtable[-(tag)].int_method[event])
		46	#define luaI_getimbyObj(o,e) (luaI_getim(luaI_efectivetag(o),(e)))
28		47
29	void luaI_setfallback (void);	48	void luaI_setfallback (void);
30	int luaI_ref (Object *object, int lock);	49	int luaI_ref (TObject *object, int lock);
31	Object *luaI_getref (int ref);	50	TObject *luaI_getref (int ref);
32	void luaI_travlock (int (fn)(Object ));	51	void luaI_travlock (int (fn)(TObject ));
33	void luaI_invalidaterefs (void);	52	void luaI_invalidaterefs (void);
34	char luaI_travfallbacks (int (fn)(Object *));	53	char luaI_travfallbacks (int (fn)(TObject *));
		54
		55	void luaI_settag (int tag, TObject *o);
		56	void luaI_realtag (int tag);
		57	TObject *luaI_geterrorim (void);
		58	int luaI_efectivetag (TObject *o);
		59	void luaI_settagmethod (void);
		60	void luaI_gettagmethod (void);
		61	void luaI_seterrormethod (void);
		62	void luaI_initfallbacks (void);
35		63
36	#endif	64	#endif
37		65

src/func.c+26−16

 #include "luadebug.h"
 #include "table.h"
-#include "mem.h"
+#include "luamem.h"
 #include "func.h"
 #include "opcode.h"
+#include "inout.h"
 static TFunc *function_root = NULL;
   f->size = 0;
   f->code = NULL;
   f->lineDefined = 0;
-  f->fileName = NULL;
+  f->fileName = lua_parsedfile;
   f->locvars = NULL;
 }
   luaI_free (f);
 }
+void luaI_funcfree (TFunc *l)
+{
+  while (l) {
+    TFunc *next = l->next;
+    luaI_freefunc(l);
+    l = next;
+  }
+}
 /*
 ** Garbage collection function.
-** This function traverse the function list freeing unindexed functions
 */
-Long luaI_funccollector (void)
+TFunc *luaI_funccollector (long *acum)
 {
   TFunc *curr = function_root;
   TFunc *prev = NULL;
-  Long counter = 0;
+  TFunc *frees = NULL;
-  while (curr)
+  long counter = 0;
-  {
+  while (curr) {
     TFunc *next = curr->next;
-    if (!curr->marked)
+    if (!curr->marked) {
-    {
       if (prev == NULL)
         function_root = next;
       else
         prev->next = next;
-      luaI_freefunc (curr);
+      curr->next = frees;
+      frees = curr;
       ++counter;
     }
-    else
+    else {
-    {
       curr->marked = 0;
       prev = curr;
     }
     curr = next;
   }
-  return counter;
+  *acum += counter;
+  return frees;
 }
 void lua_funcinfo (lua_Object func, char **filename, int *linedefined)
 {
-  Object *f = luaI_Address(func);
+  TObject *f = luaI_Address(func);
-  if (f->tag == LUA_T_MARK || f->tag == LUA_T_FUNCTION)
+  if (f->ttype == LUA_T_MARK || f->ttype == LUA_T_FUNCTION)
   {
     *filename = f->value.tf->fileName;
     *linedefined = f->value.tf->lineDefined;
   }
-  else if (f->tag == LUA_T_CMARK || f->tag == LUA_T_CFUNCTION)
+  else if (f->ttype == LUA_T_CMARK || f->ttype == LUA_T_CFUNCTION)
   {
     *filename = "(C)";
     *linedefined = -1;

src/func.h+3−2

 /*
-** $Id: func.h,v 1.8 1996/03/14 15:54:20 roberto Exp $
+** $Id: func.h,v 1.9 1997/05/14 18:38:29 roberto Exp $
 */
 #ifndef func_h
   LocVar        *locvars;
 } TFunc;
-Long luaI_funccollector (void);
+TFunc *luaI_funccollector (long *cont);
+void luaI_funcfree (TFunc *l);
 void luaI_insertfunction (TFunc *f);
 void luaI_initTFunc (TFunc *f);

src/hash.c+147−134

@@ -3,14 +3,15 @@ · 2 unmodified lines
3	** hash manager for lua	3	** hash manager for lua
4	*/	4	*/
5		5
6	char *rcs_hash="$Id: hash.c,v 2.32 1996/11/18 13:48:44 roberto Exp $";	6	char *rcs_hash="$Id: hash.c,v 2.43 1997/05/14 18:38:29 roberto Exp $";
7		7
8		8
9	#include "mem.h"	9	#include "luamem.h"
10	#include "opcode.h"	10	#include "opcode.h"
11	#include "hash.h"	11	#include "hash.h"
12	#include "table.h"	12	#include "table.h"
13	#include "lua.h"	13	#include "lua.h"
		14	#include "auxlib.h"
14		15
15		16
16	#define nhash(t) ((t)->nhash)	17	#define nhash(t) ((t)->nhash)
@@ -24,13 +25,15 @@ char *rcs_hash="$Id: hash.c,v 2.32 1996/11/18 13:48:44 roberto Exp $"; · 7 unmodified lines
24		25
25	#define REHASH_LIMIT 0.70 /* avoid more than this % full */	26	#define REHASH_LIMIT 0.70 /* avoid more than this % full */
26		27
		28	#define TagDefault LUA_T_ARRAY;
		29
27		30
28	static Hash *listhead = NULL;	31	static Hash *listhead = NULL;
29		32
30		33
31	/* hash dimensions values */	34	/* hash dimensions values */
32	static Long dimensions[] =	35	static Long dimensions[] =
33	{3L, 5L, 7L, 11L, 23L, 47L, 97L, 197L, 397L, 797L, 1597L, 3203L, 6421L,	36	{5L, 11L, 23L, 47L, 97L, 197L, 397L, 797L, 1597L, 3203L, 6421L,
34	12853L, 25717L, 51437L, 102811L, 205619L, 411233L, 822433L,	37	12853L, 25717L, 51437L, 102811L, 205619L, 411233L, 822433L,
35	1644817L, 3289613L, 6579211L, 13158023L, MAX_INT};	38	1644817L, 3289613L, 6579211L, 13158023L, MAX_INT};
36		39
@@ -46,16 +49,32 @@ int luaI_redimension (int nhash) · 9 unmodified lines
46	return 0; /* to avoid warnings */	49	return 0; /* to avoid warnings */
47	}	50	}
48		51
49	static int hashindex (Hash t, Object ref) /* hash function */	52
		53	int lua_equalObj (TObject t1, TObject t2)
		54	{
		55	if (ttype(t1) != ttype(t2)) return 0;
		56	switch (ttype(t1))
		57	{
		58	case LUA_T_NIL: return 1;
		59	case LUA_T_NUMBER: return nvalue(t1) == nvalue(t2);
		60	case LUA_T_STRING: case LUA_T_USERDATA: return svalue(t1) == svalue(t2);
		61	case LUA_T_ARRAY: return avalue(t1) == avalue(t2);
		62	case LUA_T_FUNCTION: return t1->value.tf == t2->value.tf;
		63	case LUA_T_CFUNCTION: return fvalue(t1) == fvalue(t2);
		64	default:
		65	lua_error("internal error in `lua_equalObj'");
		66	return 0; /* UNREACHEABLE */
		67	}
		68	}
		69
		70
		71	static long int hashindex (TObject *ref)
50	{	72	{
51	long int h;	73	long int h;
52	switch (tag(ref)) {	74	switch (ttype(ref)) {
53	case LUA_T_NIL:
54	lua_error ("unexpected type to index table");
55	h = 0; /* UNREACHEABLE */
56	case LUA_T_NUMBER:	75	case LUA_T_NUMBER:
57	h = (long int)nvalue(ref); break;	76	h = (long int)nvalue(ref); break;
58	case LUA_T_STRING:	77	case LUA_T_STRING: case LUA_T_USERDATA:
59	h = tsvalue(ref)->hash; break;	78	h = tsvalue(ref)->hash; break;
60	case LUA_T_FUNCTION:	79	case LUA_T_FUNCTION:
61	h = (IntPoint)ref->value.tf; break;	80	h = (IntPoint)ref->value.tf; break;
@@ -63,38 +82,29 @@ static int hashindex (Hash t, Object ref) /* hash function */ · 1 unmodified line
63	h = (IntPoint)fvalue(ref); break;	82	h = (IntPoint)fvalue(ref); break;
64	case LUA_T_ARRAY:	83	case LUA_T_ARRAY:
65	h = (IntPoint)avalue(ref); break;	84	h = (IntPoint)avalue(ref); break;
66	default: /* user data */	85	default:
67	h = (IntPoint)uvalue(ref); break;	86	lua_error ("unexpected type to index table");
		87	h = 0; /* UNREACHEABLE */
68	}	88	}
69	if (h < 0) h = -h;	89	if (h < 0) h = -h;
70	return h%nhash(t); /* make it a valid index */	90	return h;
71	}	91	}
72		92
73	int lua_equalObj (Object t1, Object t2)	93
		94	static int present (Hash t, TObject key)
74	{	95	{
75	if (tag(t1) != tag(t2)) return 0;	96	long int h = hashindex(key);
76	switch (tag(t1))	97	int tsize = nhash(t);
77	{	98	int h1 = h%tsize;
78	case LUA_T_NIL: return 1;	99	TObject *rf = ref(node(t, h1));
79	case LUA_T_NUMBER: return nvalue(t1) == nvalue(t2);	100	if (ttype(rf) != LUA_T_NIL && !lua_equalObj(key, rf)) {
80	case LUA_T_STRING: return svalue(t1) == svalue(t2);	101	int h2 = h%(tsize-2) + 1;
81	case LUA_T_ARRAY: return avalue(t1) == avalue(t2);	102	do {
82	case LUA_T_FUNCTION: return t1->value.tf == t2->value.tf;	103	h1 = (h1+h2)%tsize;
83	case LUA_T_CFUNCTION: return fvalue(t1) == fvalue(t2);	104	rf = ref(node(t, h1));
84	default: return uvalue(t1) == uvalue(t2);	105	} while (ttype(rf) != LUA_T_NIL && !lua_equalObj(key, rf));
85	}	106	}
86	}	107	return h1;
87
88	static int present (Hash t, Object ref)
89	{
90	int h = hashindex(t, ref);
91	while (tag(ref(node(t, h))) != LUA_T_NIL)
92	{
93	if (lua_equalObj(ref, ref(node(t, h))))
94	return h;
95	h = (h+1) % nhash(t);
96	}
97	return h;
98	}	108	}
99		109
100		110
@@ -106,7 +116,7 @@ static Node *hashnodecreate (int nhash) · 5 unmodified lines
106	int i;	116	int i;
107	Node *v = newvector (nhash, Node);	117	Node *v = newvector (nhash, Node);
108	for (i=0; i<nhash; i++)	118	for (i=0; i<nhash; i++)
109	tag(ref(&v[i])) = LUA_T_NIL;	119	ttype(ref(&v[i])) = LUA_T_NIL;
110	return v;	120	return v;
111	}	121	}
112		122
@@ -121,6 +131,7 @@ static Hash *hashcreate (int nhash) · 8 unmodified lines
121	nhash(t) = nhash;	131	nhash(t) = nhash;
122	nuse(t) = 0;	132	nuse(t) = 0;
123	markarray(t) = 0;	133	markarray(t) = 0;
		134	t->htag = TagDefault;
124	return t;	135	return t;
125	}	136	}
126		137
@@ -146,7 +157,7 @@ void lua_hashmark (Hash *h) · 19 unmodified lines
146	for (i=0; i<nhash(h); i++)	157	for (i=0; i<nhash(h); i++)
147	{	158	{
148	Node *n = node(h,i);	159	Node *n = node(h,i);
149	if (tag(ref(n)) != LUA_T_NIL)	160	if (ttype(ref(n)) != LUA_T_NIL)
150	{	161	{
151	lua_markobject(&n->ref);	162	lua_markobject(&n->ref);
152	lua_markobject(&n->val);	163	lua_markobject(&n->val);
@@ -156,49 +167,50 @@ void lua_hashmark (Hash *h) · 3 unmodified lines
156	}	167	}
157		168
158		169
159	static void call_fallbacks (void)	170	void luaI_hashcallIM (Hash *l)
160	{	171	{
161	Hash *curr_array;	172	TObject t;
162	Object t;	173	ttype(&t) = LUA_T_ARRAY;
163	tag(&t) = LUA_T_ARRAY;	174	for (; l; l=l->next) {
164	for (curr_array = listhead; curr_array; curr_array = curr_array->next)	175	avalue(&t) = l;
165	if (markarray(curr_array) != 1)	176	luaI_gcIM(&t);
166	{	177	}
167	avalue(&t) = curr_array;
168	luaI_gcFB(&t);
169	}
170	tag(&t) = LUA_T_NIL;
171	luaI_gcFB(&t); /* end of list */
172	}	178	}
173		179
174		180
175	/*	181	void luaI_hashfree (Hash *frees)
176	** Garbage collection to arrays
177	** Delete all unmarked arrays.
178	*/
179	Long lua_hashcollector (void)
180	{	182	{
181	Hash curr_array = listhead, prev = NULL;	183	while (frees) {
182	Long counter = 0;	184	Hash *next = frees->next;
183	call_fallbacks();	185	hashdelete(frees);
184	while (curr_array != NULL)	186	frees = next;
185	{
186	Hash *next = curr_array->next;
187	if (markarray(curr_array) != 1)
188	{
189	if (prev == NULL) listhead = next;
190	else prev->next = next;
191	hashdelete(curr_array);
192	++counter;
193	}	187	}
194	else	188	}
195	{	189
196	markarray(curr_array) = 0;	190
197	prev = curr_array;	191	Hash luaI_hashcollector (long acum)
		192	{
		193	Hash curr_array = listhead, prev = NULL, *frees = NULL;
		194	long counter = 0;
		195	while (curr_array != NULL) {
		196	Hash *next = curr_array->next;
		197	if (markarray(curr_array) != 1) {
		198	if (prev == NULL)
		199	listhead = next;
		200	else
		201	prev->next = next;
		202	curr_array->next = frees;
		203	frees = curr_array;
		204	++counter;
		205	}
		206	else {
		207	markarray(curr_array) = 0;
		208	prev = curr_array;
		209	}
		210	curr_array = next;
198	}	211	}
199	curr_array = next;	212	*acum += counter;
200	}	213	return frees;
201	return counter;
202	}	214	}
203		215
204		216
@@ -220,32 +232,45 @@ Hash *lua_createarray (int nhash) · 15 unmodified lines
220		232
221		233
222	/*	234	/*
223	** Re-hash	235	** Rehash:
		236	** Check if table has deleted slots. It it has, it does not need to
		237	** grow, since rehash will reuse them.
224	*/	238	*/
		239	static int emptyslots (Hash *t)
		240	{
		241	int i;
		242	for (i=nhash(t)-1; i>=0; i--) {
		243	Node *n = node(t, i);
		244	if (ttype(ref(n)) != LUA_T_NIL && ttype(val(n)) == LUA_T_NIL)
		245	return 1;
		246	}
		247	return 0;
		248	}
		249
225	static void rehash (Hash *t)	250	static void rehash (Hash *t)
226	{	251	{
227	int i;	252	int nold = nhash(t);
228	int nold = nhash(t);	253	Node *vold = nodevector(t);
229	Node *vold = nodevector(t);	254	int i;
230	nhash(t) = luaI_redimension(nhash(t));	255	if (!emptyslots(t))
231	nodevector(t) = hashnodecreate(nhash(t));	256	nhash(t) = luaI_redimension(nhash(t));
232	for (i=0; i<nold; i++)	257	nodevector(t) = hashnodecreate(nhash(t));
233	{	258	for (i=0; i<nold; i++) {
234	Node *n = vold+i;	259	Node *n = vold+i;
235	if (tag(ref(n)) != LUA_T_NIL && tag(val(n)) != LUA_T_NIL)	260	if (ttype(ref(n)) != LUA_T_NIL && ttype(val(n)) != LUA_T_NIL)
236	node(t, present(t, ref(n))) = n; /* copy old node to new hahs */	261	node(t, present(t, ref(n))) = n; /* copy old node to new hash */
237	}	262	}
238	luaI_free(vold);	263	luaI_free(vold);
239	}	264	}
240		265
241	/*	266	/*
242	** If the hash node is present, return its pointer, otherwise return	267	** If the hash node is present, return its pointer, otherwise return
243	** null.	268	** null.
244	*/	269	*/
245	Object lua_hashget (Hash t, Object *ref)	270	TObject lua_hashget (Hash t, TObject *ref)
246	{	271	{
247	int h = present(t, ref);	272	int h = present(t, ref);
248	if (tag(ref(node(t, h))) != LUA_T_NIL) return val(node(t, h));	273	if (ttype(ref(node(t, h))) != LUA_T_NIL) return val(node(t, h));
249	else return NULL;	274	else return NULL;
250	}	275	}
251		276
@@ -254,25 +279,19 @@ Object lua_hashget (Hash t, Object *ref) · 2 unmodified lines
254	** If the hash node is present, return its pointer, otherwise create a new	279	** If the hash node is present, return its pointer, otherwise create a new
255	** node for the given reference and also return its pointer.	280	** node for the given reference and also return its pointer.
256	*/	281	*/
257	Object lua_hashdefine (Hash t, Object *ref)	282	TObject lua_hashdefine (Hash t, TObject *ref)
258	{	283	{
259	int h;	284	Node *n = node(t, present(t, ref));
260	Node *n;	285	if (ttype(ref(n)) == LUA_T_NIL) {
261	h = present(t, ref);	286	nuse(t)++;
262	n = node(t, h);	287	if ((float)nuse(t) > (float)nhash(t)*REHASH_LIMIT) {
263	if (tag(ref(n)) == LUA_T_NIL)	288	rehash(t);
264	{	289	n = node(t, present(t, ref));
265	nuse(t)++;	290	}
266	if ((float)nuse(t) > (float)nhash(t)*REHASH_LIMIT)	291	ref(n) = ref;
267	{	292	ttype(val(n)) = LUA_T_NIL;
268	rehash(t);
269	h = present(t, ref);
270	n = node(t, h);
271	}	293	}
272	ref(n) = ref;	294	return (val(n));
273	tag(val(n)) = LUA_T_NIL;
274	}
275	return (val(n));
276	}	295	}
277		296
278		297
@@ -284,36 +303,30 @@ Object lua_hashdefine (Hash t, Object *ref) · 5 unmodified lines
284	*/	303	*/
285	static void hashnext (Hash *t, int i)	304	static void hashnext (Hash *t, int i)
286	{	305	{
287	if (i >= nhash(t))	306	Node *n;
288	return;	307	int tsize = nhash(t);
289	while (tag(ref(node(t,i))) == LUA_T_NIL \|\| tag(val(node(t,i))) == LUA_T_NIL)	308	if (i >= tsize)
290	{	309	return;
291	if (++i >= nhash(t))	310	n = node(t, i);
292	return;	311	while (ttype(ref(n)) == LUA_T_NIL \|\| ttype(val(n)) == LUA_T_NIL) {
293	}	312	if (++i >= tsize)
294	luaI_pushobject(ref(node(t,i)));	313	return;
295	luaI_pushobject(val(node(t,i)));	314	n = node(t, i);
		315	}
		316	luaI_pushobject(ref(node(t,i)));
		317	luaI_pushobject(val(node(t,i)));
296	}	318	}
297		319
298	void lua_next (void)	320	void lua_next (void)
299	{	321	{
300	Hash *t;	322	Hash *t;
301	lua_Object o = lua_getparam(1);	323	lua_Object o = lua_getparam(1);
302	lua_Object r = lua_getparam(2);	324	lua_Object r = lua_getparam(2);
303	if (o == LUA_NOOBJECT \|\| r == LUA_NOOBJECT)	325	luaL_arg_check(lua_istable(o), 1, "table expected");
304	lua_error ("too few arguments to function `next'");	326	luaL_arg_check(r != LUA_NOOBJECT, 2, "value expected");
305	if (lua_getparam(3) != LUA_NOOBJECT)	327	t = avalue(luaI_Address(o));
306	lua_error ("too many arguments to function `next'");	328	if (lua_isnil(r))
307	if (!lua_istable(o))	329	hashnext(t, 0);
308	lua_error ("first argument of function `next' is not a table");	330	else
309	t = avalue(luaI_Address(o));	331	hashnext(t, present(t, luaI_Address(r))+1);
310	if (lua_isnil(r))
311	{
312	hashnext(t, 0);
313	}
314	else
315	{
316	int h = present (t, luaI_Address(r));
317	hashnext(t, h+1);
318	}
319	}	332	}

src/hash.h+17−16

@@ -1,7 +1,7 @@
1	/*	1	/*
2	** hash.h	2	** hash.h
3	** hash manager for lua	3	** hash manager for lua
4	** $Id: hash.h,v 2.12 1996/05/06 14:30:27 roberto Exp $	4	** $Id: hash.h,v 2.16 1997/05/14 18:38:29 roberto Exp $
5	*/	5	*/
6		6
7	#ifndef hash_h	7	#ifndef hash_h
@@ -10,29 +10,30 @@ · 2 unmodified lines
10	#include "types.h"	10	#include "types.h"
11	#include "opcode.h"	11	#include "opcode.h"
12		12
13	typedef struct node	13	typedef struct node {
14	{	14	TObject ref;
15	Object ref;	15	TObject val;
16	Object val;
17	} Node;	16	} Node;
18		17
19	typedef struct Hash	18	typedef struct Hash {
20	{	19	struct Hash *next;
21	struct Hash *next;	20	Node *node;
22	Node *node;	21	int nhash;
23	int nhash;	22	int nuse;
24	int nuse;	23	int htag;
25	char mark;	24	char mark;
26	} Hash;	25	} Hash;
27		26
28		27
29	int lua_equalObj (Object t1, Object t2);	28	int lua_equalObj (TObject t1, TObject t2);
30	int luaI_redimension (int nhash);	29	int luaI_redimension (int nhash);
31	Hash *lua_createarray (int nhash);	30	Hash *lua_createarray (int nhash);
32	void lua_hashmark (Hash *h);	31	void lua_hashmark (Hash *h);
33	Long lua_hashcollector (void);	32	Hash luaI_hashcollector (long count);
34	Object lua_hashget (Hash t, Object *ref);	33	void luaI_hashcallIM (Hash *l);
35	Object lua_hashdefine (Hash t, Object *ref);	34	void luaI_hashfree (Hash *frees);
		35	TObject lua_hashget (Hash t, TObject *ref);
		36	TObject lua_hashdefine (Hash t, TObject *ref);
36	void lua_next (void);	37	void lua_next (void);
37		38
38	#endif	39	#endif

src/inout.c+278−170

@@ -5,18 +5,24 @@ · 4 unmodified lines
5	** Also provides some predefined lua functions.	5	** Also provides some predefined lua functions.
6	*/	6	*/
7		7
8	char *rcs_inout="$Id: inout.c,v 2.43 1996/09/25 12:57:22 roberto Exp $";	8	char *rcs_inout="$Id: inout.c,v 2.69 1997/06/27 22:38:49 roberto Exp $";
9		9
10	#include <stdio.h>	10	#include <stdio.h>
11	#include <string.h>	11	#include <string.h>
12		12
		13	#include "auxlib.h"
		14	#include "fallback.h"
		15	#include "hash.h"
		16	#include "inout.h"
13	#include "lex.h"	17	#include "lex.h"
		18	#include "lua.h"
		19	#include "luamem.h"
		20	#include "luamem.h"
14	#include "opcode.h"	21	#include "opcode.h"
15	#include "inout.h"
16	#include "table.h"	22	#include "table.h"
17	#include "tree.h"	23	#include "tree.h"
18	#include "lua.h"	24	#include "undump.h"
19	#include "mem.h"	25	#include "zio.h"
20		26
21		27
22	/* Exported variables */	28	/* Exported variables */
@@ -24,92 +30,93 @@ Word lua_linenumber; · 1 unmodified line
24	char *lua_parsedfile;	30	char *lua_parsedfile;
25		31
26		32
27	static FILE *fp;	33	char luaI_typenames[] = { / ORDER LUA_T */
28	static char *st;	34	"userdata", "line", "cmark", "mark", "function",
		35	"function", "table", "string", "number", "nil",
		36	NULL
		37	};
29		38
30	/*
31	** Function to get the next character from the input file
32	*/
33	static int fileinput (void)
34	{
35	int c = fgetc(fp);
36	return (c == EOF) ? 0 : c;
37	}
38		39
39	/*	40
40	** Function to get the next character from the input string	41	void luaI_setparsedfile (char *name)
41	*/
42	static int stringinput (void)
43	{	42	{
44	return *st++;	43	lua_parsedfile = luaI_createfixedstring(name)->str;
45	}	44	}
46		45
47	/*	46
48	** Function to open a file to be input unit.	47	int lua_doFILE (FILE *f, int bin)
49	** Return the file.
50	*/
51	FILE lua_openfile (char fn)
52	{	48	{
53	lua_setinput (fileinput);	49	ZIO z;
54	if (fn == NULL)	50	luaZ_Fopen(&z, f);
55	{	51	if (bin)
56	fp = stdin;	52	return luaI_undump(&z);
57	fn = "(stdin)";	53	else {
58	}	54	lua_setinput(&z);
59	else	55	return lua_domain();
60	fp = fopen (fn, "r");	56	}
61	if (fp == NULL)	57	}
62	return NULL;
63	lua_parsedfile = luaI_createfixedstring(fn)->str;
64	return fp;
65	}
66		58
67	/*	59
68	** Function to close an opened file	60	int lua_dofile (char *filename)
69	*/
70	void lua_closefile (void)
71	{	61	{
72	if (fp != NULL && fp != stdin)	62	int status;
73	{	63	int c;
74	fclose (fp);	64	FILE *f = (filename == NULL) ? stdin : fopen(filename, "r");
75	fp = NULL;	65	if (f == NULL)
76	}	66	return 2;
77	}	67	luaI_setparsedfile(filename?filename:"(stdin)");
		68	c = fgetc(f);
		69	ungetc(c, f);
		70	if (c == ID_CHUNK) {
		71	f = freopen(filename, "rb", f); /* set binary mode */
		72	status = lua_doFILE(f, 1);
		73	}
		74	else {
		75	if (c == '#')
		76	while ((c=fgetc(f)) != '\n') /* skip first line */;
		77	status = lua_doFILE(f, 0);
		78	}
		79	if (f != stdin)
		80	fclose(f);
		81	return status;
		82	}
		83
		84
78		85
79	/*
80	** Function to open a string to be input unit
81	*/
82	#define SIZE_PREF 20 /* size of string prefix to appear in error messages */	86	#define SIZE_PREF 20 /* size of string prefix to appear in error messages */
83	void lua_openstring (char *s)
84	{
85	char buff[SIZE_PREF+25];
86	lua_setinput(stringinput);
87	st = s;
88	strcpy(buff, "(dostring) >> ");
89	strncat(buff, s, SIZE_PREF);
90	if (strlen(s) > SIZE_PREF) strcat(buff, "...");
91	lua_parsedfile = luaI_createfixedstring(buff)->str;
92	}
93		87
94	/*	88
95	** Function to close an opened string	89	int lua_dobuffer (char *buff, int size)
96	*/
97	void lua_closestring (void)
98	{	90	{
		91	int status;
		92	ZIO z;
		93	luaI_setparsedfile("(buffer)");
		94	luaZ_mopen(&z, buff, size);
		95	status = luaI_undump(&z);
		96	return status;
99	}	97	}
100		98
101		99
102	static void check_arg (int cond, char *func)	100	int lua_dostring (char *str)
103	{	101	{
104	if (!cond)	102	int status;
105	{	103	char buff[SIZE_PREF+25];
106	char buff[100];	104	char *temp;
107	sprintf(buff, "incorrect argument to function `%s'", func);	105	ZIO z;
108	lua_error(buff);	106	if (str == NULL) return 1;
109	}	107	sprintf(buff, "(dostring) >> %.20s", str);
		108	temp = strchr(buff, '\n');
		109	if (temp) temp = 0; / end string after first line */
		110	luaI_setparsedfile(buff);
		111	luaZ_sopen(&z, str);
		112	lua_setinput(&z);
		113	status = lua_domain();
		114	return status;
110	}	115	}
111		116
112		117
		118
		119
113	static int passresults (void)	120	static int passresults (void)
114	{	121	{
115	int arg = 0;	122	int arg = 0;
@@ -118,30 +125,53 @@ static int passresults (void) · 2 unmodified lines
118	lua_pushobject(obj);	125	lua_pushobject(obj);
119	return arg-1;	126	return arg-1;
120	}	127	}
		128
		129
		130	static void packresults (void)
		131	{
		132	int arg = 0;
		133	lua_Object obj;
		134	lua_Object table = lua_createtable();
		135	while ((obj = lua_getresult(++arg)) != LUA_NOOBJECT) {
		136	lua_pushobject(table);
		137	lua_pushnumber(arg);
		138	lua_pushobject(obj);
		139	lua_rawsettable();
		140	}
		141	lua_pushobject(table);
		142	lua_pushstring("n");
		143	lua_pushnumber(arg-1);
		144	lua_rawsettable();
		145	lua_pushobject(table); /* final result */
		146	}
121		147
122	/*	148	/*
123	** Internal function: do a string	149	** Internal function: do a string
124	*/	150	*/
125	void lua_internaldostring (void)	151	static void lua_internaldostring (void)
126	{	152	{
127	lua_Object obj = lua_getparam (1);	153	lua_Object err = lua_getparam(2);
128	if (lua_isstring(obj) && lua_dostring(lua_getstring(obj)) == 0)	154	if (err != LUA_NOOBJECT) { /* set new error method */
		155	luaL_arg_check(lua_isnil(err) \|\| lua_isfunction(err), 2,
		156	"must be a valid error handler");
		157	lua_pushobject(err);
		158	err = lua_seterrormethod();
		159	}
		160	if (lua_dostring(luaL_check_string(1)) == 0)
129	if (passresults() == 0)	161	if (passresults() == 0)
130	lua_pushuserdata(NULL); /* at least one result to signal no errors */	162	lua_pushuserdata(NULL); /* at least one result to signal no errors */
		163	if (err != LUA_NOOBJECT) { /* restore old error method */
		164	lua_pushobject(err);
		165	lua_seterrormethod();
		166	}
131	}	167	}
132		168
133	/*	169	/*
134	** Internal function: do a file	170	** Internal function: do a file
135	*/	171	*/
136	void lua_internaldofile (void)	172	static void lua_internaldofile (void)
137	{	173	{
138	lua_Object obj = lua_getparam (1);	174	char *fname = luaL_opt_string(1, NULL);
139	char *fname = NULL;
140	if (lua_isstring(obj))
141	fname = lua_getstring(obj);
142	else if (obj != LUA_NOOBJECT)
143	lua_error("invalid argument to function `dofile'");
144	/* else fname = NULL */
145	if (lua_dofile(fname) == 0)	175	if (lua_dofile(fname) == 0)
146	if (passresults() == 0)	176	if (passresults() == 0)
147	lua_pushuserdata(NULL); /* at least one result to signal no errors */	177	lua_pushuserdata(NULL); /* at least one result to signal no errors */
@@ -150,36 +180,28 @@ void lua_internaldofile (void) · 2 unmodified lines
150		180
151	static char *tostring (lua_Object obj)	181	static char *tostring (lua_Object obj)
152	{	182	{
153	char *buff = luaI_buffer(20);	183	TObject *o = luaI_Address(obj);
154	if (lua_isstring(obj)) /* get strings and numbers */	184	switch (ttype(o)) {
155	return lua_getstring(obj);	185	case LUA_T_NUMBER: case LUA_T_STRING:
156	else switch(lua_type(obj))	186	return lua_getstring(obj);
157	{	187	case LUA_T_ARRAY: case LUA_T_FUNCTION:
158	case LUA_T_FUNCTION:	188	case LUA_T_CFUNCTION: case LUA_T_NIL:
159	sprintf(buff, "function: %p", (luaI_Address(obj))->value.tf);	189	return luaI_typenames[-ttype(o)];
160	break;	190	case LUA_T_USERDATA: {
161	case LUA_T_CFUNCTION:	191	char *buff = luaI_buffer(30);
162	sprintf(buff, "cfunction: %p", lua_getcfunction(obj));	192	sprintf(buff, "userdata: %p", o->value.ts->u.v);
163	break;	193	return buff;
164	case LUA_T_ARRAY:	194	}
165	sprintf(buff, "table: %p", avalue(luaI_Address(obj)));	195	default: return "<unknown object>";
166	break;
167	case LUA_T_NIL:
168	sprintf(buff, "nil");
169	break;
170	default:
171	sprintf(buff, "userdata: %p", lua_getuserdata(obj));
172	break;
173	}	196	}
174	return buff;
175	}	197	}
176		198
177	void luaI_tostring (void)	199	static void luaI_tostring (void)
178	{	200	{
179	lua_pushstring(tostring(lua_getparam(1)));	201	lua_pushstring(tostring(lua_getparam(1)));
180	}	202	}
181		203
182	void luaI_print (void)	204	static void luaI_print (void)
183	{	205	{
184	int i = 1;	206	int i = 1;
185	lua_Object obj;	207	lua_Object obj;
@@ -187,45 +209,18 @@ void luaI_print (void) · 1 unmodified line
187	printf("%s\n", tostring(obj));	209	printf("%s\n", tostring(obj));
188	}	210	}
189		211
190	/*	212	static void luaI_type (void)
191	** Internal function: return an object type.
192	*/
193	void luaI_type (void)
194	{	213	{
195	lua_Object o = lua_getparam(1);	214	lua_Object o = lua_getparam(1);
196	int t;	215	luaL_arg_check(o != LUA_NOOBJECT, 1, "no argument");
197	if (o == LUA_NOOBJECT)	216	lua_pushstring(luaI_typenames[-ttype(luaI_Address(o))]);
198	lua_error("no parameter to function 'type'");	217	lua_pushnumber(lua_tag(o));
199	t = lua_type(o);
200	switch (t)
201	{
202	case LUA_T_NIL :
203	lua_pushliteral("nil");
204	break;
205	case LUA_T_NUMBER :
206	lua_pushliteral("number");
207	break;
208	case LUA_T_STRING :
209	lua_pushliteral("string");
210	break;
211	case LUA_T_ARRAY :
212	lua_pushliteral("table");
213	break;
214	case LUA_T_FUNCTION :
215	case LUA_T_CFUNCTION :
216	lua_pushliteral("function");
217	break;
218	default :
219	lua_pushliteral("userdata");
220	break;
221	}
222	lua_pushnumber(t);
223	}	218	}
224		219
225	/*	220	/*
226	** Internal function: convert an object to a number	221	** Internal function: convert an object to a number
227	*/	222	*/
228	void lua_obj2number (void)	223	static void lua_obj2number (void)
229	{	224	{
230	lua_Object o = lua_getparam(1);	225	lua_Object o = lua_getparam(1);
231	if (lua_isnumber(o))	226	if (lua_isnumber(o))
@@ -233,68 +228,181 @@ void lua_obj2number (void) · 1 unmodified line
233	}	228	}
234		229
235		230
236	void luaI_error (void)	231	static void luaI_error (void)
237	{	232	{
238	char *s = lua_getstring(lua_getparam(1));	233	char *s = lua_getstring(lua_getparam(1));
239	if (s == NULL) s = "(no message)";	234	if (s == NULL) s = "(no message)";
240	lua_error(s);	235	lua_error(s);
241	}	236	}
242		237
243	void luaI_assert (void)	238	static void luaI_assert (void)
244	{	239	{
245	lua_Object p = lua_getparam(1);	240	lua_Object p = lua_getparam(1);
246	if (p == LUA_NOOBJECT \|\| lua_isnil(p))	241	if (p == LUA_NOOBJECT \|\| lua_isnil(p))
247	lua_error("assertion failed!");	242	lua_error("assertion failed!");
248	}	243	}
249		244
250	void luaI_setglobal (void)	245	static void luaI_setglobal (void)
		246	{
		247	lua_Object value = lua_getparam(2);
		248	luaL_arg_check(value != LUA_NOOBJECT, 2, NULL);
		249	lua_pushobject(value);
		250	lua_setglobal(luaL_check_string(1));
		251	lua_pushobject(value); /* return given value */
		252	}
		253
		254	static void luaI_rawsetglobal (void)
251	{	255	{
252	lua_Object name = lua_getparam(1);
253	lua_Object value = lua_getparam(2);	256	lua_Object value = lua_getparam(2);
254	check_arg(lua_isstring(name), "setglobal");	257	luaL_arg_check(value != LUA_NOOBJECT, 2, NULL);
255	lua_pushobject(value);	258	lua_pushobject(value);
256	lua_storeglobal(lua_getstring(name));	259	lua_rawsetglobal(luaL_check_string(1));
257	lua_pushobject(value); /* return given value */	260	lua_pushobject(value); /* return given value */
258	}	261	}
259		262
260	void luaI_getglobal (void)	263	static void luaI_getglobal (void)
261	{	264	{
262	lua_Object name = lua_getparam(1);	265	lua_pushobject(lua_getglobal(luaL_check_string(1)));
263	check_arg(lua_isstring(name), "getglobal");
264	lua_pushobject(lua_getglobal(lua_getstring(name)));
265	}	266	}
266		267
267	#define MAXPARAMS 256	268	static void luaI_rawgetglobal (void)
268	void luaI_call (void)	269	{
		270	lua_pushobject(lua_rawgetglobal(luaL_check_string(1)));
		271	}
		272
		273	static void luatag (void)
		274	{
		275	lua_pushnumber(lua_tag(lua_getparam(1)));
		276	}
		277
		278
		279	static int getnarg (lua_Object table)
		280	{
		281	lua_Object temp;
		282	/* temp = table.n */
		283	lua_pushobject(table); lua_pushstring("n"); temp = lua_gettable();
		284	return (lua_isnumber(temp) ? lua_getnumber(temp) : MAX_WORD);
		285	}
		286
		287	static void luaI_call (void)
269	{	288	{
270	lua_Object f = lua_getparam(1);	289	lua_Object f = lua_getparam(1);
271	lua_Object arg = lua_getparam(2);	290	lua_Object arg = lua_getparam(2);
272	lua_Object temp, params[MAXPARAMS];	291	int withtable = (strcmp(luaL_opt_string(3, ""), "pack") == 0);
273	int narg, i;	292	int narg, i;
274	check_arg(lua_istable(arg), "call");	293	luaL_arg_check(lua_isfunction(f), 1, "function expected");
275	check_arg(lua_isfunction(f), "call");	294	luaL_arg_check(lua_istable(arg), 2, "table expected");
276	/* narg = arg.n */	295	narg = getnarg(arg);
277	lua_pushobject(arg);	296	/* push arg[1...n] */
278	lua_pushstring("n");
279	temp = lua_getsubscript();
280	narg = lua_isnumber(temp) ? lua_getnumber(temp) : MAXPARAMS+1;
281	/* read arg[1...n] */
282	for (i=0; i<narg; i++) {	297	for (i=0; i<narg; i++) {
283	if (i>=MAXPARAMS)	298	lua_Object temp;
284	lua_error("argument list too long in function `call'");	299	/* temp = arg[i+1] */
285	lua_pushobject(arg);	300	lua_pushobject(arg); lua_pushnumber(i+1); temp = lua_gettable();
286	lua_pushnumber(i+1);	301	if (narg == MAX_WORD && lua_isnil(temp))
287	params[i] = lua_getsubscript();
288	if (narg == MAXPARAMS+1 && lua_isnil(params[i])) {
289	narg = i;
290	break;	302	break;
291	}	303	lua_pushobject(temp);
292	}	304	}
293	/* push parameters and do the call */
294	for (i=0; i<narg; i++)
295	lua_pushobject(params[i]);
296	if (lua_callfunction(f))	305	if (lua_callfunction(f))
297	lua_error(NULL);	306	lua_error(NULL);
		307	else if (withtable)
		308	packresults();
298	else	309	else
299	passresults();	310	passresults();
300	}	311	}
		312
		313	static void luaIl_settag (void)
		314	{
		315	lua_Object o = lua_getparam(1);
		316	luaL_arg_check(lua_istable(o), 1, "table expected");
		317	lua_pushobject(o);
		318	lua_settag(luaL_check_number(2));
		319	}
		320
		321	static void luaIl_newtag (void)
		322	{
		323	lua_pushnumber(lua_newtag());
		324	}
		325
		326	static void rawgettable (void)
		327	{
		328	lua_Object t = lua_getparam(1);
		329	lua_Object i = lua_getparam(2);
		330	luaL_arg_check(t != LUA_NOOBJECT, 1, NULL);
		331	luaL_arg_check(i != LUA_NOOBJECT, 2, NULL);
		332	lua_pushobject(t);
		333	lua_pushobject(i);
		334	lua_pushobject(lua_rawgettable());
		335	}
		336
		337	static void rawsettable (void)
		338	{
		339	lua_Object t = lua_getparam(1);
		340	lua_Object i = lua_getparam(2);
		341	lua_Object v = lua_getparam(3);
		342	luaL_arg_check(t != LUA_NOOBJECT && i != LUA_NOOBJECT && v != LUA_NOOBJECT,
		343	0, NULL);
		344	lua_pushobject(t);
		345	lua_pushobject(i);
		346	lua_pushobject(v);
		347	lua_rawsettable();
		348	}
		349
		350
		351	static void luaI_collectgarbage (void)
		352	{
		353	lua_pushnumber(lua_collectgarbage(luaL_opt_number(1, 0)));
		354	}
		355
		356
		357	/*
		358	** Internal functions
		359	*/
		360	static struct {
		361	char *name;
		362	lua_CFunction func;
		363	} int_funcs[] = {
		364	{"assert", luaI_assert},
		365	{"call", luaI_call},
		366	{"collectgarbage", luaI_collectgarbage},
		367	{"dofile", lua_internaldofile},
		368	{"dostring", lua_internaldostring},
		369	{"error", luaI_error},
		370	{"getglobal", luaI_getglobal},
		371	{"newtag", luaIl_newtag},
		372	{"next", lua_next},
		373	{"nextvar", luaI_nextvar},
		374	{"print", luaI_print},
		375	{"rawgetglobal", luaI_rawgetglobal},
		376	{"rawgettable", rawgettable},
		377	{"rawsetglobal", luaI_rawsetglobal},
		378	{"rawsettable", rawsettable},
		379	{"seterrormethod", luaI_seterrormethod},
		380	#if LUA_COMPAT2_5
		381	{"setfallback", luaI_setfallback},
		382	#endif
		383	{"setglobal", luaI_setglobal},
		384	{"settagmethod", luaI_settagmethod},
		385	{"gettagmethod", luaI_gettagmethod},
		386	{"settag", luaIl_settag},
		387	{"tonumber", lua_obj2number},
		388	{"tostring", luaI_tostring},
		389	{"tag", luatag},
		390	{"type", luaI_type}
		391	};
		392
		393	#define INTFUNCSIZE (sizeof(int_funcs)/sizeof(int_funcs[0]))
		394
		395
		396	void luaI_predefine (void)
		397	{
		398	int i;
		399	Word n;
		400	for (i=0; i<INTFUNCSIZE; i++) {
		401	n = luaI_findsymbolbyname(int_funcs[i].name);
		402	s_ttype(n) = LUA_T_CFUNCTION; s_fvalue(n) = int_funcs[i].func;
		403	}
		404	n = luaI_findsymbolbyname("_VERSION");
		405	s_ttype(n) = LUA_T_STRING; s_tsvalue(n) = lua_createstring(LUA_VERSION);
		406	}
		407
		408

src/inout.h+8−17

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: inout.h,v 1.16 1996/05/28 21:07:32 roberto Exp $	2	** $Id: inout.h,v 1.20 1997/06/19 18:04:34 roberto Exp $
3	*/	3	*/
4		4
5		5
@@ -14,21 +14,12 @@ extern Word lua_linenumber; · 8 unmodified lines
14	extern Word lua_debugline;	14	extern Word lua_debugline;
15	extern char *lua_parsedfile;	15	extern char *lua_parsedfile;
16		16
17	FILE lua_openfile (char fn);	17	void luaI_setparsedfile (char *name);
18	void lua_closefile (void);	18
19	void lua_openstring (char *s);	19	void luaI_predefine (void);
20	void lua_closestring (void);	20
21		21	int lua_dobuffer (char *buff, int size);
22	void lua_internaldofile (void);	22	int lua_doFILE (FILE *f, int bin);
23	void lua_internaldostring (void);	23
24	void luaI_tostring (void);
25	void luaI_print (void);
26	void luaI_type (void);
27	void lua_obj2number (void);
28	void luaI_error (void);
29	void luaI_assert (void);
30	void luaI_setglobal (void);
31	void luaI_getglobal (void);
32	void luaI_call (void);
33		24
34	#endif	25	#endif

src/lex.c+174−45

@@ -1,10 +1,11 @@
1	char *rcs_lex = "$Id: lex.c,v 2.39 1996/11/08 19:08:30 roberto Exp $";	1	char *rcs_lex = "$Id: lex.c,v 3.5 1997/06/16 16:50:22 roberto Exp $";
2		2
3		3
4	#include <ctype.h>	4	#include <ctype.h>
5	#include <string.h>	5	#include <string.h>
6		6
7	#include "mem.h"	7	#include "auxlib.h"
		8	#include "luamem.h"
8	#include "tree.h"	9	#include "tree.h"
9	#include "table.h"	10	#include "table.h"
10	#include "lex.h"	11	#include "lex.h"
@@ -12,33 +13,58 @@ char *rcs_lex = "$Id: lex.c,v 2.39 1996/11/08 19:08:30 roberto Exp $"; · 1 unmodified line
12	#include "luadebug.h"	13	#include "luadebug.h"
13	#include "parser.h"	14	#include "parser.h"
14		15
15	#define MINBUFF 260	16	#define MINBUFF 250
16		17
17	#define next() (current = input())	18	static int current; /* look ahead character */
		19	static ZIO *lex_z;
		20
		21
		22	#define next() (current = zgetc(lex_z))
18	#define save(x) (yytext[tokensize++] = (x))	23	#define save(x) (yytext[tokensize++] = (x))
19	#define save_and_next() (save(current), next())	24	#define save_and_next() (save(current), next())
20		25
21		26
22	static int current; /* look ahead character */	27	#define MAX_IFS 5
23	static Input input; /* input function */	28
		29	/* "ifstate" keeps the state of each nested $if the lexical is dealing with. */
		30
		31	static struct {
		32	int elsepart; /* true if its in the $else part */
		33	int condition; /* true if $if condition is true */
		34	int skip; /* true if part must be skiped */
		35	} ifstate[MAX_IFS];
		36
		37	static int iflevel; /* level of nested $if's */
24		38
25		39
26	void lua_setinput (Input fn)	40	void lua_setinput (ZIO *z)
27	{	41	{
28	current = '\n';	42	current = '\n';
29	lua_linenumber = 0;	43	lua_linenumber = 0;
30	input = fn;	44	iflevel = 0;
		45	ifstate[0].skip = 0;
		46	ifstate[0].elsepart = 1; /* to avoid a free $else */
		47	lex_z = z;
31	}	48	}
32		49
33	void luaI_syntaxerror (char *s)	50
		51	static void luaI_auxsyntaxerror (char *s)
		52	{
		53	luaL_verror("%s;\n> at line %d in file %s",
		54	s, lua_linenumber, lua_parsedfile);
		55	}
		56
		57	static void luaI_auxsynterrbf (char s, char token)
34	{	58	{
35	char msg[256];
36	char *token = luaI_buffer(1);
37	if (token[0] == 0)	59	if (token[0] == 0)
38	token = "<eof>";	60	token = "<eof>";
39	sprintf (msg,"%s;\n> last token read: \"%s\" at line %d in file %s",	61	luaL_verror("%s;\n> last token read: \"%s\" at line %d in file %s",
40	s, token, lua_linenumber, lua_parsedfile);	62	s, token, lua_linenumber, lua_parsedfile);
41	lua_error (msg);	63	}
		64
		65	void luaI_syntaxerror (char *s)
		66	{
		67	luaI_auxsynterrbf(s, luaI_buffer(1));
42	}	68	}
43		69
44		70
@@ -78,26 +104,122 @@ void luaI_addReserved (void) · 33 unmodified lines
78	}	104	}
79	}	105	}
80		106
81	static int inclinenumber (int pragma_allowed)	107
		108	/*
		109	** Pragma handling
		110	*/
		111
		112	#define PRAGMASIZE 20
		113
		114	static void skipspace (void)
		115	{
		116	while (current == ' ' \|\| current == '\t') next();
		117	}
		118
		119
		120	static int checkcond (char *buff)
		121	{
		122	static char *opts[] = {"nil", "1"};
		123	int i = luaI_findstring(buff, opts);
		124	if (i >= 0) return i;
		125	else if (isalpha((unsigned char)buff[0]) \|\| buff[0] == '_')
		126	return luaI_globaldefined(buff);
		127	else {
		128	luaI_auxsynterrbf("invalid $if condition", buff);
		129	return 0; /* to avoid warnings */
		130	}
		131	}
		132
		133
		134	static void readname (char *buff)
		135	{
		136	int i = 0;
		137	skipspace();
		138	while (isalnum((unsigned char)current) \|\| current == '_') {
		139	if (i >= PRAGMASIZE) {
		140	buff[PRAGMASIZE] = 0;
		141	luaI_auxsynterrbf("pragma too long", buff);
		142	}
		143	buff[i++] = current;
		144	next();
		145	}
		146	buff[i] = 0;
		147	}
		148
		149
		150	static void inclinenumber (void);
		151
		152
		153	static void ifskip (void)
		154	{
		155	while (ifstate[iflevel].skip) {
		156	if (current == '\n')
		157	inclinenumber();
		158	else if (current == EOZ)
		159	luaI_auxsyntaxerror("input ends inside a $if");
		160	else next();
		161	}
		162	}
		163
		164
		165	static void inclinenumber (void)
82	{	166	{
		167	static char *pragmas [] =
		168	{"debug", "nodebug", "endinput", "end", "ifnot", "if", "else", NULL};
		169	next(); /* skip '\n' */
83	++lua_linenumber;	170	++lua_linenumber;
84	if (pragma_allowed && current == '$') { /* is a pragma? */	171	if (current == '$') { /* is a pragma? */
85	char *buff = luaI_buffer(MINBUFF+1);	172	char buff[PRAGMASIZE+1];
86	int i = 0;	173	int ifnot = 0;
		174	int skip = ifstate[iflevel].skip;
87	next(); /* skip $ */	175	next(); /* skip $ */
88	while (isalnum(current)) {	176	readname(buff);
89	if (i >= MINBUFF) luaI_syntaxerror("pragma too long");	177	switch (luaI_findstring(buff, pragmas)) {
90	buff[i++] = current;	178	case 0: /* debug */
91	next();	179	if (!skip) lua_debug = 1;
		180	break;
		181	case 1: /* nodebug */
		182	if (!skip) lua_debug = 0;
		183	break;
		184	case 2: /* endinput */
		185	if (!skip) {
		186	current = EOZ;
		187	iflevel = 0; /* to allow $endinput inside a $if */
		188	}
		189	break;
		190	case 3: /* end */
		191	if (iflevel-- == 0)
		192	luaI_auxsyntaxerror("unmatched $endif");
		193	break;
		194	case 4: /* ifnot */
		195	ifnot = 1;
		196	/* go through */
		197	case 5: /* if */
		198	if (iflevel == MAX_IFS-1)
		199	luaI_auxsyntaxerror("too many nested `$ifs'");
		200	readname(buff);
		201	iflevel++;
		202	ifstate[iflevel].elsepart = 0;
		203	ifstate[iflevel].condition = checkcond(buff) ? !ifnot : ifnot;
		204	ifstate[iflevel].skip = skip \|\| !ifstate[iflevel].condition;
		205	break;
		206	case 6: /* else */
		207	if (ifstate[iflevel].elsepart)
		208	luaI_auxsyntaxerror("unmatched $else");
		209	ifstate[iflevel].elsepart = 1;
		210	ifstate[iflevel].skip =
		211	ifstate[iflevel-1].skip \|\| ifstate[iflevel].condition;
		212	break;
		213	default:
		214	luaI_auxsynterrbf("invalid pragma", buff);
92	}	215	}
93	buff[i] = 0;	216	skipspace();
94	if (strcmp(buff, "debug") == 0)	217	if (current == '\n') /* pragma must end with a '\n' ... */
95	lua_debug = 1;	218	inclinenumber();
96	else if (strcmp(buff, "nodebug") == 0)	219	else if (current != EOZ) /* or eof */
97	lua_debug = 0;	220	luaI_auxsyntaxerror("invalid pragma format");
98	else luaI_syntaxerror("invalid pragma");	221	ifskip();
99	}	222	}
100	return lua_linenumber;
101	}	223	}
102		224
103	static int read_long_string (char *yytext, int buffsize)	225	static int read_long_string (char *yytext, int buffsize)
@@ -110,7 +232,7 @@ static int read_long_string (char *yytext, int buffsize) · 6 unmodified lines
110	yytext = luaI_buffer(buffsize *= 2);	232	yytext = luaI_buffer(buffsize *= 2);
111	switch (current)	233	switch (current)
112	{	234	{
113	case 0:	235	case EOZ:
114	save(0);	236	save(0);
115	return WRONGTOKEN;	237	return WRONGTOKEN;
116	case '[':	238	case '[':
@@ -131,8 +253,8 @@ static int read_long_string (char *yytext, int buffsize) · 14 unmodified lines
131	}	253	}
132	continue;	254	continue;
133	case '\n':	255	case '\n':
134	save_and_next();	256	save('\n');
135	inclinenumber(0);	257	inclinenumber();
136	continue;	258	continue;
137	default:	259	default:
138	save_and_next();	260	save_and_next();
@@ -162,8 +284,8 @@ int luaY_lex (void) · 23 unmodified lines
162	switch (current)	284	switch (current)
163	{	285	{
164	case '\n':	286	case '\n':
165	next();	287	inclinenumber();
166	linelasttoken = inclinenumber(1);	288	linelasttoken = lua_linenumber;
167	continue;	289	continue;
168		290
169	case ' ': case '\t': case '\r': /* CR: to avoid problems with DOS */	291	case ' ': case '\t': case '\r': /* CR: to avoid problems with DOS */
@@ -173,7 +295,7 @@ int luaY_lex (void) · 3 unmodified lines
173	case '-':	295	case '-':
174	save_and_next();	296	save_and_next();
175	if (current != '-') return '-';	297	if (current != '-') return '-';
176	do { next(); } while (current != '\n' && current != 0);	298	do { next(); } while (current != '\n' && current != EOZ);
177	continue;	299	continue;
178		300
179	case '[':	301	case '[':
@@ -216,7 +338,7 @@ int luaY_lex (void) · 36 unmodified lines
216	yytext = luaI_buffer(buffsize *= 2);	338	yytext = luaI_buffer(buffsize *= 2);
217	switch (current)	339	switch (current)
218	{	340	{
219	case 0:	341	case EOZ:
220	case '\n':	342	case '\n':
221	save(0);	343	save(0);
222	return WRONGTOKEN;	344	return WRONGTOKEN;
@@ -227,7 +349,7 @@ int luaY_lex (void) · 4 unmodified lines
227	case 'n': save('\n'); next(); break;	349	case 'n': save('\n'); next(); break;
228	case 't': save('\t'); next(); break;	350	case 't': save('\t'); next(); break;
229	case 'r': save('\r'); next(); break;	351	case 'r': save('\r'); next(); break;
230	case '\n': save_and_next(); inclinenumber(0); break;	352	case '\n': save('\n'); inclinenumber(); break;
231	default : save_and_next(); break;	353	default : save_and_next(); break;
232	}	354	}
233	break;	355	break;
@@ -258,7 +380,9 @@ int luaY_lex (void) · 24 unmodified lines
258	case '_':	380	case '_':
259	{	381	{
260	TaggedString *ts;	382	TaggedString *ts;
261	do { save_and_next(); } while (isalnum(current) \|\| current == '_');	383	do {
		384	save_and_next();
		385	} while (isalnum((unsigned char)current) \|\| current == '_');
262	save(0);	386	save(0);
263	ts = lua_createstring(yytext);	387	ts = lua_createstring(yytext);
264	if (ts->marked > 2)	388	if (ts->marked > 2)
@@ -280,7 +404,7 @@ int luaY_lex (void) · 15 unmodified lines
280	}	404	}
281	else return CONC; /* .. */	405	else return CONC; /* .. */
282	}	406	}
283	else if (!isdigit(current)) return '.';	407	else if (!isdigit((unsigned char)current)) return '.';
284	/* current is a digit: goes through to number */	408	/* current is a digit: goes through to number */
285	a=0.0;	409	a=0.0;
286	goto fraction;	410	goto fraction;
@@ -291,7 +415,7 @@ int luaY_lex (void) · 4 unmodified lines
291	do {	415	do {
292	a=10.0*a+(current-'0');	416	a=10.0*a+(current-'0');
293	save_and_next();	417	save_and_next();
294	} while (isdigit(current));	418	} while (isdigit((unsigned char)current));
295	if (current == '.') {	419	if (current == '.') {
296	save_and_next();	420	save_and_next();
297	if (current == '.')	421	if (current == '.')
@@ -300,7 +424,7 @@ int luaY_lex (void) · 2 unmodified lines
300	}	424	}
301	fraction:	425	fraction:
302	{ double da=0.1;	426	{ double da=0.1;
303	while (isdigit(current))	427	while (isdigit((unsigned char)current))
304	{	428	{
305	a+=(current-'0')*da;	429	a+=(current-'0')*da;
306	da/=10.0;	430	da/=10.0;
@@ -314,11 +438,12 @@ int luaY_lex (void) · 7 unmodified lines
314	save_and_next();	438	save_and_next();
315	neg=(current=='-');	439	neg=(current=='-');
316	if (current == '+' \|\| current == '-') save_and_next();	440	if (current == '+' \|\| current == '-') save_and_next();
317	if (!isdigit(current)) { save(0); return WRONGTOKEN; }	441	if (!isdigit((unsigned char)current)) {
		442	save(0); return WRONGTOKEN; }
318	do {	443	do {
319	e=10.0*e+(current-'0');	444	e=10.0*e+(current-'0');
320	save_and_next();	445	save_and_next();
321	} while (isdigit(current));	446	} while (isdigit((unsigned char)current));
322	for (ea=neg?0.1:10.0; e>0; e>>=1)	447	for (ea=neg?0.1:10.0; e>0; e>>=1)
323	{	448	{
324	if (e & 1) a*=ea;	449	if (e & 1) a*=ea;
@@ -330,11 +455,15 @@ int luaY_lex (void) · 5 unmodified lines
330	return NUMBER;	455	return NUMBER;
331	}	456	}
332		457
333	default: /* also end of program (0) */	458	case EOZ:
334	{	459	save(0);
		460	if (iflevel > 0)
		461	luaI_syntaxerror("missing $endif");
		462	return 0;
		463
		464	default:
335	save_and_next();	465	save_and_next();
336	return yytext[0];	466	return yytext[0];
337	}
338	}	467	}
339	}	468	}
340	}	469	}

src/lex.h+3−4

 /*
 ** lex.h
 ** TecCGraf - PUC-Rio
-** $Id: lex.h,v 1.3 1996/11/08 12:49:35 roberto Exp $
+** $Id: lex.h,v 1.4 1997/06/16 16:50:22 roberto Exp $
 */
 #ifndef lex_h
 #define lex_h
+#include "zio.h"
-typedef int  (*Input) (void);
+void    lua_setinput   (ZIO *z);
-void    lua_setinput   (Input fn);
 void luaI_syntaxerror (char *s);
 int     luaY_lex (void);
 void luaI_addReserved (void);

src/lua.stx+29−34

 %{
-char *rcs_luastx = "$Id: lua.stx,v 3.41 1996/11/08 12:49:35 roberto Exp $";
+char *rcs_luastx = "$Id: lua.stx,v 3.47 1997/06/19 17:46:12 roberto Exp $";
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "luadebug.h"
-#include "mem.h"
+#include "luamem.h"
 #include "lex.h"
 #include "opcode.h"
 #include "hash.h"
 static int     nlocalvar=0;	     /* number of local variables */
 #define MAXFIELDS FIELDS_PER_FLUSH*2
-static Word    fields[MAXFIELDS];     /* fieldnames to be flushed */
-static int     nfields=0;
 int lua_debug = 0;
   memcpy(p, &w, sizeof(Word));
 }
-static void push_field (Word name)
-{
-  if (nfields < MAXFIELDS)
-    fields[nfields++] = name;
-  else
-   yyerror ("too many fields in nested constructors");
-}
 static void flush_record (int n)
 {
-  int i;
   if (n == 0) return;
-  code_byte(STORERECORD);
+  code_byte(STOREMAP);
   code_byte(n);
-  for (i=0; i<n; i++)
-    code_word(fields[--nfields]);
 }
 static void flush_list (int m, int n)
   yyerror ("variable buffer overflow");
 }
+static void code_string (Word w)
+{
+  code_byte(PUSHSTRING);
+  code_word(w);
+}
+static void code_constant (TaggedString *s)
+{
+  code_string(luaI_findconstant(s));
+}
 static void code_number (float f)
 {
-  Word i = (Word)f;
+  Word i;
-  if (f == (float)i)  /* f has an (short) integer value */
+  if (f >= 0 && f <= (float)MAX_WORD && (float)(i=(Word)f) == f) {
-  {
+   /* f has an (short) integer value */
    if (i <= 2) code_byte(PUSH0 + i);
    else if (i <= 255)
    {
 %% /* beginning of rules section */
-chunk	: chunklist ret
+chunk	: chunklist ret ;
 chunklist : /* empty */
 	  | chunklist stat sc
 funcname	: var { $$ =$1; init_func(); }
 		| varexp ':' NAME
 	{
-	  code_byte(PUSHSTRING);
+	  code_constant($3);
-	  code_word(luaI_findconstant($3));
 	  $$ = 0;  /* indexed variable */
 	  init_func();
 	  add_localvar(luaI_createfixedstring("self"));
           luaI_initTFunc($$);
 	  $$->size = pc;
 	  $$->code = newvector(pc, Byte);
-	  $$->fileName = lua_parsedfile;
 	  $$->lineDefined = $2;
 	  memcpy($$->code, basepc, pc*sizeof(Byte));
           if (lua_debug)
 	  lua_codeadjust (0);
 	}
        }
-       | functioncall
+       | functioncall {;}
        | LOCAL localdeclist decinit
 	{ nlocalvar += $2;
 	  adjust_mult_assign($2, $3, 0);
      |  NUMBER          { code_number($1); $$ = 0; }
      |  STRING
      {
-      code_byte(PUSHSTRING);
+       code_string($1);
-      code_word($1);
+       $$ = 0;
-      $$ = 0;
      }
      |	NIL		{code_byte(PUSHNIL); $$ = 0; }
      |  functioncall    { $$ = $1; }
 		}
 	   ;
-ffield      : NAME '=' expr1
+ffield      : ffieldkey '=' expr1
-	      {
-	       push_field(luaI_findconstant($1));
-	      }
            ;
+ffieldkey   : '[' expr1 ']'
+	    | NAME { code_constant($1); }
+	    ;
 lfieldlist  : /* empty */ { $$ = 0; }
 	    | lfieldlist1 lastcomma { $$ = $1; }
 	    ;
 	  }
 	  |	varexp '.' NAME
 	  {
-	   code_byte(PUSHSTRING);
+	    code_constant($3);
-	   code_word(luaI_findconstant($3));
+	    $$ = 0;		/* indexed variable */
-	   $$ = 0;		/* indexed variable */
 	  }
 	  ;

src/luac/dump.c+11−19

 ** thread and save bytecodes to file
 */
-char* rcs_dump="$Id: dump.c,v 1.17 1996/11/18 11:18:29 lhf Exp $";
+char* rcs_dump="$Id: dump.c,v 1.20 1997/06/19 14:56:04 lhf Exp $";
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "luac.h"
-static TFunc* lastF=NULL;		/* list of functions seen in code */
 static int SawVar(int i, int at)
 {
  int old=VarLoc(i);
  for (i=0; i<lua_nconstant; i++) StrLoc(i)=0;
  for (p=code; p!=end;)
  {
-	OpCode op=(OpCode)*p;
+	int op=*p;
 	int at=p-code+1;
 	switch (op)
 	{
 	case STORELIST0:
 	case ADJUST:
 	case RETCODE:
+	case VARARGS:
+	case STOREMAP:
 		p+=2;
 		break;
 	case PUSHWORD:
 	case PUSHFLOAT:
 		p+=5;			/* assumes sizeof(float)==4 */
 		break;
-	case PUSHSELF:
+	case PUSHFUNCTION:
+		p+=sizeof(TFunc*)+1;
+		break;
 	case PUSHSTRING:
+	case PUSHSELF:
 	{
 		Word w;
 		p++;
 		memcpy(p-2,&w,sizeof(w));
 		break;
 	}
-	case PUSHFUNCTION:
-	{
-		TFunc* tf;
-		p++;
-		get_code(tf,p);
-		tf->marked=at;
-		tf->next=NULL;		/* TODO: remove? */
-		lastF=lastF->next=tf;
-		break;
-	}
 	case PUSHGLOBAL:
 	case STOREGLOBAL:
 	{
 		}
 		break;
 	}
-	default:
+	default:			/* cannot happen */
-		fprintf(stderr,"luac: cannot happen:  opcode=%d",*p);
+		fprintf(stderr,"luac: bad opcode %d at %d\n",*p,(int)(p-code));
 		exit(1);
 		break;
 	}
  int n=strlen(s)+1;
  if ((Word)n != n)
  {
-  fprintf(stderr,"luac: string too long: \"%.32s...\"\n",s);
+  fprintf(stderr,"luac: string too long (%d bytes): \"%.32s...\"\n",n,s);
   exit(1);
  }
  DumpWord(n,D);
 void DumpFunction(TFunc* tf, FILE* D)
 {
- lastF=tf;
  ThreadCode(tf->code,tf->code+tf->size);
  fputc(ID_FUN,D);
  DumpSize(tf->size,D);

src/luac/luac.c+112−27

 /*
 ** luac.c
-** lua compiler (saves bytecodes to files)
+** lua compiler (saves bytecodes to files; also list binary files)
 */
-char* rcs_luac="$Id: luac.c,v 1.18 1996/11/16 20:14:23 lhf Exp $";
+char* rcs_luac="$Id: luac.c,v 1.23 1997/06/20 20:34:04 lhf Exp $";
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "luac.h"
+#include "lex.h"
+#include "zio.h"
 static void compile(char* filename);
+static void undump(char* filename);
 static int listing=0;			/* list bytecodes? */
 static int dumping=1;			/* dump bytecodes? */
+static int undumping=0;			/* undump bytecodes? */
 static FILE* D;				/* output file */
 static void usage(void)
 {
- fprintf(stderr,"usage: luac [-dlpv] [-o output] file ...\n");
+ fprintf(stderr,
- exit(0);
+ "usage: luac [-c | -u] [-d] [-l] [-p] [-q] [-v] [-o output] file ...\n"
+ " -c\tcompile (default)\n"
+ " -u\tundump\n"
+ " -d\tgenerate debugging information\n"
+ " -l\tlist (default for -u)\n"
+ " -o\toutput file for -c (default \"luac.out\")\n"
+ " -p\tparse only\n"
+ " -q\tquiet (default for -c)\n"
+ " -v\tshow version information\n"
+ );
+ exit(1);
 }
 #define	IS(s)	(strcmp(argv[i],s)==0)
    break;
   else if (IS("-"))			/* use stdin */
    break;
+  else if (IS("-c"))			/* compile (and dump) */
+  {
+   dumping=1;
+   undumping=0;
+  }
   else if (IS("-d"))			/* debug */
    lua_debug=1;
   else if (IS("-l"))			/* list */
    d=argv[++i];
   else if (IS("-p"))			/* parse only (for timing purposes) */
    dumping=0;
+  else if (IS("-q"))			/* quiet */
+   listing=0;
+  else if (IS("-u"))			/* undump */
+  {
+   dumping=0;
+   undumping=1;
+   listing=1;
+  }
   else if (IS("-v"))			/* show version */
    printf("%s  %s\n(written by %s)\n\n",LUA_VERSION,LUA_COPYRIGHT,LUA_AUTHORS);
   else					/* unknown option */
  --i;					/* fake new argv[0] */
  argc-=i;
  argv+=i;
- if (argc<2) usage();
+ if (dumping)
- for (i=1; i<argc; i++)
+ {
-  if (IS(d))
+  if (argc<2) usage();
+  for (i=1; i<argc; i++)		/* play safe with output file */
+   if (IS(d))
+   {
+    fprintf(stderr,"luac: will not overwrite input file \"%s\"\n",d);
+    exit(1);
+   }
+  D=fopen(d,"wb");			/* must open in binary mode */
+  if (D==NULL)
   {
-   fprintf(stderr,"luac: will not overwrite input file \"%s\"\n",d);
+   fprintf(stderr,"luac: cannot open ");
+   perror(d);
    exit(1);
   }
- D=(dumping) ? fopen(d,"wb") : stdout;	/* must open in binary mode */
+  for (i=1; i<argc; i++) compile(IS("-")? NULL : argv[i]);
- if (D==NULL)
+  fclose(D);
+ }
+ if (undumping)
  {
-  fprintf(stderr,"luac: cannot open ");
+  if (argc<2)
-  perror(d);
+   undump("luac.out");
-  exit(1);
+  else
+   for (i=1; i<argc; i++) undump(IS("-")? NULL : argv[i]);
  }
- for (i=1; i<argc; i++) compile(IS("-")? NULL : argv[i]);
- fclose(D);
  return 0;
 }
-static void do_dump(TFunc* tf)		/* only for tf==main */
+static void do_dump(TFunc* Main)
 {
- if (dumping) DumpHeader(D);
+ TFunc* tf;
- while (tf!=NULL)
+ LinkFunctions(Main);
+ if (listing)
+ {
+  for (tf=Main; tf!=NULL; tf=tf->next) PrintFunction(tf,Main);
+ }
+ if (dumping)
  {
-  TFunc* nf;
+  DumpHeader(D);
-  if (listing) PrintFunction(tf);
+  for (tf=Main; tf!=NULL; tf=tf->next) DumpFunction(tf,D);
-  if (dumping) DumpFunction(tf,D);
+ }
-  nf=tf->next;				/* list only built after first main */
+ for (tf=Main; tf!=NULL; )
+ {
+  TFunc* nf=tf->next;
   luaI_freefunc(tf);
   tf=nf;
  }
 }
-static void do_compile(void)
+static void do_compile(ZIO* z)
 {
  TFunc* tf=new(TFunc);
+ lua_setinput(z);
  luaI_initTFunc(tf);
- tf->fileName = lua_parsedfile;
+ tf->fileName=lua_parsedfile;
  lua_parse(tf);
  do_dump(tf);
 }
 static void compile(char* filename)
 {
- if (lua_openfile(filename)==NULL)
+ FILE* f= (filename==NULL) ? stdin : fopen(filename, "r");
+ if (f==NULL)
+ {
+  fprintf(stderr,"luac: cannot open ");
+  perror(filename);
+  exit(1);
+ }
+ else
+ {
+  ZIO z;
+  zFopen(&z,f);
+  luaI_setparsedfile(filename?filename:"(stdin)");
+  do_compile(&z);
+  fclose(f);
+ }
+}
+static void do_undump(ZIO* z)
+{
+ TFunc* Main;
+ while ((Main=luaI_undump1(z)))
+ {
+  if (listing)
+  {
+   TFunc* tf;
+   for (tf=Main; tf!=NULL; tf=tf->next)
+    PrintFunction(tf,Main);
+  }
+  luaI_freefunc(Main);			/* TODO: free others */
+ }
+}
+static void undump(char* filename)
+{
+ FILE* f= (filename==NULL) ? stdin : fopen(filename, "rb");
+ if (f==NULL)
  {
   fprintf(stderr,"luac: cannot open ");
   perror(filename);
   exit(1);
  }
- do_compile();
+ else
- lua_closefile();
+ {
+  ZIO z;
+  zFopen(&z,f);
+  do_undump(&z);
+  fclose(f);
+ }
 }

src/luac/luac.h+6−5

 /*
 ** luac.h
 ** definitions for luac compiler
-** $Id: luac.h,v 1.5 1996/03/08 21:41:47 lhf Exp $
+** $Id: luac.h,v 1.8 1997/06/19 17:32:08 lhf Exp $
 */
 #include "inout.h"
-#include "mem.h"
+#include "luamem.h"
 #include "opcode.h"
 #include "table.h"
 #include "undump.h"
 #define VarStr(i)	(lua_table[i].varname->str)
-#define VarLoc(i)	(lua_table[i].varname->varindex)
+#define VarLoc(i)	(lua_table[i].varname->u.s.varindex)
 #define StrStr(i)	(lua_constant[i]->str)
-#define StrLoc(i)	(lua_constant[i]->constindex)
+#define StrLoc(i)	(lua_constant[i]->u.s.constindex)
 extern Word lua_ntable;
 extern Word lua_nconstant;
 extern int lua_debug;
+void LinkFunctions(TFunc* tf);
+void PrintFunction(TFunc* tf, TFunc* Main);
 void DumpHeader(FILE* D);
 void DumpFunction(TFunc* tf, FILE* D);
-void PrintFunction(TFunc* tf);

src/luac/print.c+213−20

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	** print bytecodes	3	** print bytecodes
4	*/	4	*/
5		5
6	char* rcs_print="$Id: print.c,v 1.11 1996/11/18 11:24:16 lhf Exp $";	6	char* rcs_print="$Id: print.c,v 1.17 1997/06/25 17:07:28 lhf Exp $";
7		7
8	#include <stdio.h>	8	#include <stdio.h>
9	#include <stdlib.h>	9	#include <stdlib.h>
@@ -11,20 +11,134 @@ char* rcs_print="$Id: print.c,v 1.11 1996/11/18 11:24:16 lhf Exp $"; · 1 unmodified line
11	#include "luac.h"	11	#include "luac.h"
12	#include "print.h"	12	#include "print.h"
13		13
14	static LocVar* V=NULL;	14	void LinkFunctions(TFunc* m)
15
16	static char* LocStr(int i)
17	{	15	{
18	if (V==NULL) return ""; else return V[i].varname->str;	16	static TFunc* lastF; /* list of functions seen in code */
		17	Byte* code=m->code;
		18	Byte* end=code+m->size;
		19	Byte* p;
		20	if (IsMain(m)) lastF=m;
		21	for (p=code; p!=end;)
		22	{
		23	int op=*p;
		24	int at=p-code+1;
		25	switch (op)
		26	{
		27	case PUSHNIL:
		28	case PUSH0:
		29	case PUSH1:
		30	case PUSH2:
		31	case PUSHLOCAL0:
		32	case PUSHLOCAL1:
		33	case PUSHLOCAL2:
		34	case PUSHLOCAL3:
		35	case PUSHLOCAL4:
		36	case PUSHLOCAL5:
		37	case PUSHLOCAL6:
		38	case PUSHLOCAL7:
		39	case PUSHLOCAL8:
		40	case PUSHLOCAL9:
		41	case PUSHINDEXED:
		42	case STORELOCAL0:
		43	case STORELOCAL1:
		44	case STORELOCAL2:
		45	case STORELOCAL3:
		46	case STORELOCAL4:
		47	case STORELOCAL5:
		48	case STORELOCAL6:
		49	case STORELOCAL7:
		50	case STORELOCAL8:
		51	case STORELOCAL9:
		52	case STOREINDEXED0:
		53	case ADJUST0:
		54	case EQOP:
		55	case LTOP:
		56	case LEOP:
		57	case GTOP:
		58	case GEOP:
		59	case ADDOP:
		60	case SUBOP:
		61	case MULTOP:
		62	case DIVOP:
		63	case POWOP:
		64	case CONCOP:
		65	case MINUSOP:
		66	case NOTOP:
		67	case POP:
		68	case RETCODE0:
		69	p++;
		70	break;
		71	case PUSHBYTE:
		72	case PUSHLOCAL:
		73	case STORELOCAL:
		74	case STOREINDEXED:
		75	case STORELIST0:
		76	case ADJUST:
		77	case RETCODE:
		78	case VARARGS:
		79	case STOREMAP:
		80	p+=2;
		81	break;
		82	case PUSHWORD:
		83	case PUSHSTRING:
		84	case PUSHGLOBAL:
		85	case PUSHSELF:
		86	case STOREGLOBAL:
		87	case CREATEARRAY:
		88	case ONTJMP:
		89	case ONFJMP:
		90	case JMP:
		91	case UPJMP:
		92	case IFFJMP:
		93	case IFFUPJMP:
		94	case CALLFUNC:
		95	case SETLINE:
		96	case STORELIST:
		97	p+=3;
		98	break;
		99	case PUSHFLOAT:
		100	p+=5; /* assumes sizeof(float)==4 */
		101	break;
		102	case PUSHFUNCTION:
		103	{
		104	TFunc* tf;
		105	p++;
		106	get_code(tf,p);
		107	tf->marked=at;
		108	tf->next=NULL; /* TODO: remove? */
		109	lastF=lastF->next=tf;
		110	break;
		111	}
		112	case STORERECORD:
		113	{
		114	int n=*++p;
		115	p+=2*n+1;
		116	break;
		117	}
		118	default: /* cannot happen */
		119	fprintf(stderr,"luac: bad opcode %d at %d\n",*p,(int)(p-code));
		120	exit(1);
		121	break;
		122	}
		123	}
19	}	124	}
20		125
21	static void PrintCode(Byte* code, Byte* end)	126	#define LocStr(i) luaI_getlocalname(tf,i+1,line)
		127
		128	static void PrintCode(TFunc* tf)
22	{	129	{
		130	Byte* code=tf->code;
		131	Byte* end=code+tf->size;
23	Byte* p;	132	Byte* p;
		133	int line=0;
24	for (p=code; p!=end;)	134	for (p=code; p!=end;)
25	{	135	{
26	OpCode op=(OpCode)*p;	136	int op=*p;
27	if (op>SETLINE) op=SETLINE+1;	137	if (op>=NOPCODES)
		138	{
		139	fprintf(stderr,"luac: bad opcode %d at %d\n",op,(int)(p-code));
		140	exit(1);
		141	}
28	printf("%6d\t%s",(int)(p-code),OpCodeName[op]);	142	printf("%6d\t%s",(int)(p-code),OpCodeName[op]);
29	switch (op)	143	switch (op)
30	{	144	{
@@ -64,7 +178,7 @@ static void PrintCode(Byte* code, Byte* end) · 33 unmodified lines
64	case PUSHLOCAL9:	178	case PUSHLOCAL9:
65	{	179	{
66	int i=op-PUSHLOCAL0;	180	int i=op-PUSHLOCAL0;
67	printf("\t%d\t; %s",i,LocStr(i));	181	if (tf->locvars) printf("\t\t; %s",LocStr(i));
68	p++;	182	p++;
69	break;	183	break;
70	}	184	}
@@ -80,7 +194,7 @@ static void PrintCode(Byte* code, Byte* end) · 9 unmodified lines
80	case STORELOCAL9:	194	case STORELOCAL9:
81	{	195	{
82	int i=op-STORELOCAL0;	196	int i=op-STORELOCAL0;
83	printf("\t%d\t; %s",i,LocStr(i));	197	if (tf->locvars) printf("\t\t; %s",LocStr(i));
84	p++;	198	p++;
85	break;	199	break;
86	}	200	}
@@ -88,7 +202,7 @@ static void PrintCode(Byte* code, Byte* end) · 1 unmodified line
88	case STORELOCAL:	202	case STORELOCAL:
89	{	203	{
90	int i=*(p+1);	204	int i=*(p+1);
91	printf("\t%d\t; %s",i,LocStr(i));	205	if (tf->locvars) printf("\t%d\t; %s",i,LocStr(i));
92	p+=2;	206	p+=2;
93	break;	207	break;
94	}	208	}
@@ -97,23 +211,40 @@ static void PrintCode(Byte* code, Byte* end) · 2 unmodified lines
97	case STORELIST0:	211	case STORELIST0:
98	case ADJUST:	212	case ADJUST:
99	case RETCODE:	213	case RETCODE:
		214	case VARARGS:
		215	case STOREMAP:
100	printf("\t%d",*(p+1));	216	printf("\t%d",*(p+1));
101	p+=2;	217	p+=2;
102	break;	218	break;
103	case PUSHWORD:	219	case PUSHWORD:
104	case CREATEARRAY:	220	case CREATEARRAY:
		221	case SETLINE:
		222	{
		223	Word w;
		224	p++;
		225	get_word(w,p);
		226	printf("\t%d",w);
		227	if (op==SETLINE) line=w;
		228	break;
		229	}
105	case ONTJMP:	230	case ONTJMP:
106	case ONFJMP:	231	case ONFJMP:
107	case JMP:	232	case JMP:
108	case UPJMP:
109	case IFFJMP:	233	case IFFJMP:
		234	{ /* suggested by Norman Ramsey <nr@cs.virginia.edu> */
		235	Word w;
		236	p++;
		237	get_word(w,p);
		238	printf("\t%d\t\t; to %d",w,(int)(p-code)+w);
		239	break;
		240	}
		241	case UPJMP:
110	case IFFUPJMP:	242	case IFFUPJMP:
111	case SETLINE:	243	{ /* suggested by Norman Ramsey <nr@cs.virginia.edu> */
112	{
113	Word w;	244	Word w;
114	p++;	245	p++;
115	get_word(w,p);	246	get_word(w,p);
116	printf("\t%d",w);	247	printf("\t%d\t\t; to %d",w,(int)(p-code)-w);
117	break;	248	break;
118	}	249	}
119	case PUSHFLOAT:	250	case PUSHFLOAT:
@@ -170,7 +301,8 @@ static void PrintCode(Byte* code, Byte* end) · 50 unmodified lines
170	break;	301	break;
171	}	302	}
172	default:	303	default:
173	printf("\tcannot happen: opcode=%d",*p);	304	printf("\tcannot happen: opcode=%d\n",*p);
		305	fprintf(stderr,"luac: bad opcode %d at %d\n",op,(int)(p-code));
174	exit(1);	306	exit(1);
175	break;	307	break;
176	}	308	}
@@ -178,13 +310,74 @@ static void PrintCode(Byte* code, Byte* end) · 1 unmodified line
178	}	310	}
179	}	311	}
180		312
181	void PrintFunction(TFunc* tf)	313	#undef LocStr
		314
		315	static void PrintLocals(LocVar* v, int n)
182	{	316	{
		317	int i=0;
		318	if (v==NULL \|\| v->varname==NULL) return;
		319	if (n>0)
		320	{
		321	printf("parameters:");
		322	for (i=0; i<n; v++,i++) printf(" %s[%d@%d]",v->varname->str,i,v->line);
		323	printf("\n");
		324	}
		325	if (v->varname!=NULL)
		326	{
		327	printf("locals:");
		328	for (; v->line>=0; v++)
		329	{
		330	if (v->varname==NULL)
		331	#if 0
		332	printf(" %s[%d@%d]","*",--i,v->line);
		333	#else
		334	--i;
		335	#endif
		336	else
		337	printf(" %s[%d@%d]",v->varname->str,i++,v->line);
		338	}
		339	printf("\n");
		340	}
		341	}
		342
		343	void PrintFunction(TFunc* tf, TFunc* Main)
		344	{
		345	int n=0;
183	if (IsMain(tf))	346	if (IsMain(tf))
184	printf("\nmain of \"%s\" (%d bytes at %p)\n",tf->fileName,tf->size,tf);	347	printf("\nmain of \"%s\" (%d bytes at %p)\n",tf->fileName,tf->size,tf);
185	else	348	else
186	printf("\nfunction \"%s\":%d (%d bytes at %p); used at main+%d\n",	349	{
		350	Byte* p;
		351	p=tf->code; /* get number of parameters */
		352	while (*p==SETLINE) p+=3;
		353	if (*p==ADJUST) n=p[1];
		354	p=Main->code+tf->marked+sizeof(TFunc*);
		355	printf("\nfunction ");
		356	switch (p) / try to get name */
		357	{
		358	case STOREGLOBAL:
		359	{
		360	Word w;
		361	p++; get_word(w,p); printf("%s defined at ",VarStr(w));
		362	break;
		363	}
		364	case STOREINDEXED0: /* try method definition */
		365	{
		366	if (p[-11]==PUSHGLOBAL && p[-8]==PUSHSTRING)
		367	{
		368	Word w;
		369	Byte* op=p;
		370	int c=(tf->locvars && n>0 && strcmp(tf->locvars->varname->str,"self")==0)
		371	? ':' : '.';
		372	p=op-11; p++; get_word(w,p); printf("%s%c",VarStr(w),c);
		373	p=op-8; p++; get_word(w,p); printf("%s defined at ",StrStr(w));
		374	}
		375	break;
		376	}
		377	}
		378	printf("\"%s\":%d (%d bytes at %p); used at main+%d\n",
187	tf->fileName,tf->lineDefined,tf->size,tf,tf->marked);	379	tf->fileName,tf->lineDefined,tf->size,tf,tf->marked);
188	V=tf->locvars;	380	}
189	PrintCode(tf->code,tf->code+tf->size);	381	PrintLocals(tf->locvars,n);
		382	PrintCode(tf);
190	}	383	}

src/luac/print.h+6−3

 /*
 ** print.h
 ** opcode names
-** $Id: print.h,v 1.1 1996/02/23 19:04:13 lhf Exp $
+** $Id: print.h,v 1.3 1997/04/14 14:42:50 lhf Exp $
 */
-static char* OpCodeName[]={	/* attention: same order as enum in opcode.h */
+static char* OpCodeName[]={	/* ATTENTION: same order as enum in opcode.h */
  "PUSHNIL",
  "PUSH0",
  "PUSH1",
  "RETCODE0",
  "RETCODE",
  "SETLINE",
- ""
+ "VARARGS",
+ "STOREMAP"
 };
+#define NOPCODES	(sizeof(OpCodeName)/sizeof(OpCodeName[0]))

src/luamem.c+159−0

@@ -0,0 +1,159 @@
	1	/*
	2	** mem.c
	3	** TecCGraf - PUC-Rio
	4	*/
	5
	6	char *rcs_luamem = "$Id: luamem.c,v 1.16 1997/04/01 21:23:20 roberto Exp $";
	7
	8	#include <stdlib.h>
	9
	10	#include "luamem.h"
	11	#include "lua.h"
	12
	13
	14	#define DEBUG 0
	15
	16	#if !DEBUG
	17
	18	void luaI_free (void *block)
	19	{
	20	if (block)
	21	{
	22	((char )block) = -1; /* to catch errors */
	23	free(block);
	24	}
	25	}
	26
	27
	28	void luaI_realloc (void oldblock, unsigned long size)
	29	{
	30	void *block;
	31	size_t s = (size_t)size;
	32	if (s != size)
	33	lua_error("Allocation Error: Block too big");
	34	block = oldblock ? realloc(oldblock, s) : malloc(s);
	35	if (block == NULL)
	36	lua_error(memEM);
	37	return block;
	38	}
	39
	40
	41	int luaI_growvector (void **block, unsigned long nelems, int size,
	42	char *errormsg, unsigned long limit)
	43	{
	44	if (nelems >= limit)
	45	lua_error(errormsg);
	46	nelems = (nelems == 0) ? 20 : nelems*2;
	47	if (nelems > limit)
	48	nelems = limit;
	49	block = luaI_realloc(block, nelems*size);
	50	return (int)nelems;
	51	}
	52
	53
	54	void* luaI_buffer (unsigned long size)
	55	{
	56	static unsigned long buffsize = 0;
	57	static char* buffer = NULL;
	58	if (size > buffsize)
	59	buffer = luaI_realloc(buffer, buffsize=size);
	60	return buffer;
	61	}
	62
	63	#else
	64	/* DEBUG */
	65
	66	#include <stdio.h>
	67
	68	# define assert(ex) {if (!(ex)){(void)fprintf(stderr, \
	69	"Assertion failed: file \"%s\", line %d\n", __FILE__, __LINE__);exit(1);}}
	70
	71	#define MARK 55
	72
	73	static unsigned long numblocks = 0;
	74	static unsigned long totalmem = 0;
	75
	76
	77	static void message (void)
	78	{
	79	#define inrange(x,y) ((x) < (((y)3)/2) && (x) > (((y)2)/3))
	80	static int count = 0;
	81	static unsigned long lastnumblocks = 0;
	82	static unsigned long lasttotalmem = 0;
	83	if (!inrange(numblocks, lastnumblocks) \|\| !inrange(totalmem, lasttotalmem)
	84	\|\| count++ >= 5000)
	85	{
	86	fprintf(stderr,"blocks = %lu mem = %luK\n", numblocks, totalmem/1000);
	87	count = 0;
	88	lastnumblocks = numblocks;
	89	lasttotalmem = totalmem;
	90	}
	91	}
	92
	93
	94	void luaI_free (void *block)
	95	{
	96	if (block)
	97	{
	98	unsigned long b = (unsigned long )block - 1;
	99	unsigned long size = *b;
	100	assert((((char )b)+size+sizeof(unsigned long)) == MARK);
	101	numblocks--;
	102	totalmem -= size;
	103	free(b);
	104	message();
	105	}
	106	}
	107
	108
	109	void luaI_realloc (void oldblock, unsigned long size)
	110	{
	111	unsigned long *block;
	112	unsigned long realsize = sizeof(unsigned long)+size+sizeof(char);
	113	if (realsize != (size_t)realsize)
	114	lua_error("Allocation Error: Block too big");
	115	if (oldblock)
	116	{
	117	unsigned long b = (unsigned long )oldblock - 1;
	118	unsigned long oldsize = *b;
	119	assert((((char )b)+oldsize+sizeof(unsigned long)) == MARK);
	120	totalmem -= oldsize;
	121	numblocks--;
	122	block = (unsigned long *)realloc(b, realsize);
	123	}
	124	else
	125	block = (unsigned long *)malloc(realsize);
	126	if (block == NULL)
	127	lua_error("not enough memory");
	128	totalmem += size;
	129	numblocks++;
	130	*block = size;
	131	(((char )block)+size+sizeof(unsigned long)) = MARK;
	132	message();
	133	return block+1;
	134	}
	135
	136
	137	int luaI_growvector (void **block, unsigned long nelems, int size,
	138	char *errormsg, unsigned long limit)
	139	{
	140	if (nelems >= limit)
	141	lua_error(errormsg);
	142	nelems = (nelems == 0) ? 20 : nelems*2;
	143	if (nelems > limit)
	144	nelems = limit;
	145	block = luaI_realloc(block, nelems*size);
	146	return (int)nelems;
	147	}
	148
	149
	150	void* luaI_buffer (unsigned long size)
	151	{
	152	static unsigned long buffsize = 0;
	153	static char* buffer = NULL;
	154	if (size > buffsize)
	155	buffer = luaI_realloc(buffer, buffsize=size);
	156	return buffer;
	157	}
	158
	159	#endif

src/luamem.hrenamed from src/mem.h+3−3

@@ -1,11 +1,11 @@
1	/*	1	/*
2	** mem.c	2	** mem.c
3	** memory manager for lua	3	** memory manager for lua
4	** $Id: mem.h,v 1.8 1996/05/24 14:31:10 roberto Exp $	4	** $Id: luamem.h,v 1.9 1997/03/31 14:10:11 roberto Exp $
5	*/	5	*/
6		6
7	#ifndef mem_h	7	#ifndef luamem_h
8	#define mem_h	8	#define luamem_h
9		9
10	#ifndef NULL	10	#ifndef NULL
11	#define NULL 0	11	#define NULL 0

src/mem.c+0−58

@@ -1,58 +0,0 @@
1	/*
2	** mem.c
3	** TecCGraf - PUC-Rio
4	*/
5
6	char *rcs_mem = "$Id: mem.c,v 1.13 1996/05/24 14:31:10 roberto Exp $";
7
8	#include <stdlib.h>
9
10	#include "mem.h"
11	#include "lua.h"
12
13
14	void luaI_free (void *block)
15	{
16	if (block)
17	{
18	((int )block) = -1; /* to catch errors */
19	free(block);
20	}
21	}
22
23
24	void luaI_realloc (void oldblock, unsigned long size)
25	{
26	void *block;
27	size_t s = (size_t)size;
28	if (s != size)
29	lua_error("Allocation Error: Block too big");
30	block = oldblock ? realloc(oldblock, s) : malloc(s);
31	if (block == NULL)
32	lua_error(memEM);
33	return block;
34	}
35
36
37	int luaI_growvector (void **block, unsigned long nelems, int size,
38	char *errormsg, unsigned long limit)
39	{
40	if (nelems >= limit)
41	lua_error(errormsg);
42	nelems = (nelems == 0) ? 20 : nelems*2;
43	if (nelems > limit)
44	nelems = limit;
45	block = luaI_realloc(block, nelems*size);
46	return (int)nelems;
47	}
48
49
50	void* luaI_buffer (unsigned long size)
51	{
52	static unsigned long buffsize = 0;
53	static char* buffer = NULL;
54	if (size > buffsize)
55	buffer = luaI_realloc(buffer, buffsize=size);
56	return buffer;
57	}
58

src/opcode.c+517−369

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	** TecCGraf - PUC-Rio	3	** TecCGraf - PUC-Rio
4	*/	4	*/
5		5
6	char *rcs_opcode="$Id: opcode.c,v 3.77 1996/11/18 13:48:44 roberto Exp $";	6	char *rcs_opcode="$Id: opcode.c,v 4.15 1997/06/26 21:40:57 roberto Exp $";
7		7
8	#include <setjmp.h>	8	#include <setjmp.h>
9	#include <stdio.h>	9	#include <stdio.h>
@@ -11,17 +11,18 @@ char *rcs_opcode="$Id: opcode.c,v 3.77 1996/11/18 13:48:44 roberto Exp $"; · 1 unmodified line
11	#include <stdlib.h>	11	#include <stdlib.h>
12		12
13	#include "luadebug.h"	13	#include "luadebug.h"
14	#include "mem.h"	14	#include "luamem.h"
15	#include "opcode.h"	15	#include "opcode.h"
16	#include "hash.h"	16	#include "hash.h"
17	#include "inout.h"	17	#include "inout.h"
18	#include "table.h"	18	#include "table.h"
19	#include "lua.h"	19	#include "lua.h"
20	#include "fallback.h"	20	#include "fallback.h"
21	#include "undump.h"	21	#include "auxlib.h"
		22	#include "lex.h"
22		23
23	#define tonumber(o) ((tag(o) != LUA_T_NUMBER) && (lua_tonumber(o) != 0))	24	#define tonumber(o) ((ttype(o) != LUA_T_NUMBER) && (lua_tonumber(o) != 0))
24	#define tostring(o) ((tag(o) != LUA_T_STRING) && (lua_tostring(o) != 0))	25	#define tostring(o) ((ttype(o) != LUA_T_STRING) && (lua_tostring(o) != 0))
25		26
26		27
27	#define STACK_SIZE 128	28	#define STACK_SIZE 128
@@ -32,14 +33,14 @@ char *rcs_opcode="$Id: opcode.c,v 3.77 1996/11/18 13:48:44 roberto Exp $"; · 4 unmodified lines
32		33
33	typedef int StkId; /* index to stack elements */	34	typedef int StkId; /* index to stack elements */
34		35
35	static Object initial_stack;	36	static TObject initial_stack;
36		37
37	static Object *stackLimit = &initial_stack+1;	38	static TObject *stackLimit = &initial_stack+1;
38	static Object *stack = &initial_stack;	39	static TObject *stack = &initial_stack;
39	static Object *top = &initial_stack;	40	static TObject *top = &initial_stack;
40		41
41		42
42	/* macros to convert from lua_Object to (Object ) and back /	43	/* macros to convert from lua_Object to (TObject ) and back /
43		44
44	#define Address(lo) ((lo)+stack-1)	45	#define Address(lo) ((lo)+stack-1)
45	#define Ref(st) ((st)-stack+1)	46	#define Ref(st) ((st)-stack+1)
@@ -51,13 +52,13 @@ static Object *top = &initial_stack; · 5 unmodified lines
51	#define incr_top if (++top >= stackLimit) growstack()	52	#define incr_top if (++top >= stackLimit) growstack()
52		53
53	struct C_Lua_Stack {	54	struct C_Lua_Stack {
54	StkId base; /* when Lua calls C or C calls Lua, points to */	55	StkId base; /* when Lua calls C or C calls Lua, points to */
55	/* the first slot after the last parameter. */	56	/* the first slot after the last parameter. */
56	int num; /* when Lua calls C, has the number of parameters; */	57	StkId lua2C; /* points to first element of "array" lua2C */
57	/* when C calls Lua, has the number of results. */	58	int num; /* size of "array" lua2C */
58	};	59	};
59		60
60	static struct C_Lua_Stack CLS_current = {0, 0};	61	static struct C_Lua_Stack CLS_current = {0, 0, 0};
61		62
62	static jmp_buf errorJmp = NULL; / current error recover point */	63	static jmp_buf errorJmp = NULL; / current error recover point */
63		64
@@ -72,7 +73,7 @@ static void do_call (StkId base, int nResults); · 8 unmodified lines
72		73
73		74
74		75
75	Object *luaI_Address (lua_Object o)	76	TObject *luaI_Address (lua_Object o)
76	{	77	{
77	return Address(o);	78	return Address(o);
78	}	79	}
@@ -84,7 +85,7 @@ Object *luaI_Address (lua_Object o) · 5 unmodified lines
84	static void lua_initstack (void)	85	static void lua_initstack (void)
85	{	86	{
86	Long maxstack = STACK_SIZE;	87	Long maxstack = STACK_SIZE;
87	stack = newvector(maxstack, Object);	88	stack = newvector(maxstack, TObject);
88	stackLimit = stack+maxstack;	89	stackLimit = stack+maxstack;
89	top = stack;	90	top = stack;
90	*(top++) = initial_stack;	91	*(top++) = initial_stack;
@@ -105,7 +106,7 @@ static void growstack (void) · 14 unmodified lines
105	static int limit = STACK_LIMIT;	106	static int limit = STACK_LIMIT;
106	StkId t = top-stack;	107	StkId t = top-stack;
107	Long stacksize = stackLimit - stack;	108	Long stacksize = stackLimit - stack;
108	stacksize = growvector(&stack, stacksize, Object, stackEM, limit+100);	109	stacksize = growvector(&stack, stacksize, TObject, stackEM, limit+100);
109	stackLimit = stack+stacksize;	110	stackLimit = stack+stacksize;
110	top = stack + t;	111	top = stack + t;
111	if (stacksize >= limit)	112	if (stacksize >= limit)
@@ -134,16 +135,16 @@ static char lua_strconc (char l, char *r) · 22 unmodified lines
134	** Convert, if possible, to a number object.	135	** Convert, if possible, to a number object.
135	** Return 0 if success, not 0 if error.	136	** Return 0 if success, not 0 if error.
136	*/	137	*/
137	static int lua_tonumber (Object *obj)	138	static int lua_tonumber (TObject *obj)
138	{	139	{
139	float t;	140	float t;
140	char c;	141	char c;
141	if (tag(obj) != LUA_T_STRING)	142	if (ttype(obj) != LUA_T_STRING)
142	return 1;	143	return 1;
143	else if (sscanf(svalue(obj), "%f %c",&t, &c) == 1)	144	else if (sscanf(svalue(obj), "%f %c",&t, &c) == 1)
144	{	145	{
145	nvalue(obj) = t;	146	nvalue(obj) = t;
146	tag(obj) = LUA_T_NUMBER;	147	ttype(obj) = LUA_T_NUMBER;
147	return 0;	148	return 0;
148	}	149	}
149	else	150	else
@@ -152,39 +153,54 @@ static int lua_tonumber (Object *obj) · 2 unmodified lines
152		153
153		154
154	/*	155	/*
155	** Convert, if possible, to a string tag	156	** Convert, if possible, to a string ttype
156	** Return 0 in success or not 0 on error.	157	** Return 0 in success or not 0 on error.
157	*/	158	*/
158	static int lua_tostring (Object *obj)	159	static int lua_tostring (TObject *obj)
159	{	160	{
160	char s[256];	161	if (ttype(obj) != LUA_T_NUMBER)
161	if (tag(obj) != LUA_T_NUMBER)	162	return 1;
162	return 1;	163	else {
163	if ((int) nvalue(obj) == nvalue(obj))	164	char s[60];
164	sprintf (s, "%d", (int) nvalue(obj));	165	real f = nvalue(obj);
165	else	166	int i;
166	sprintf (s, "%g", nvalue(obj));	167	if ((real)(-MAX_INT) <= f && f <= (real)MAX_INT && (real)(i=(int)f) == f)
167	tsvalue(obj) = lua_createstring(s);	168	sprintf (s, "%d", i);
168	tag(obj) = LUA_T_STRING;	169	else
169	return 0;	170	sprintf (s, "%g", nvalue(obj));
		171	tsvalue(obj) = lua_createstring(s);
		172	ttype(obj) = LUA_T_STRING;
		173	return 0;
		174	}
170	}	175	}
171		176
172		177
173	/*	178	/*
174	** Adjust stack. Set top to the given value, pushing NILs if needed.	179	** Adjust stack. Set top to the given value, pushing NILs if needed.
175	*/	180	*/
176	static void adjust_top (StkId newtop)	181	static void adjust_top_aux (StkId newtop)
177	{	182	{
178	Object *nt;	183	TObject *nt;
179	lua_checkstack(stack+newtop);	184	lua_checkstack(stack+newtop);
180	nt = stack+newtop; /* warning: previous call may change stack */	185	nt = stack+newtop; /* warning: previous call may change stack */
181	while (top < nt) tag(top++) = LUA_T_NIL;	186	while (top < nt) ttype(top++) = LUA_T_NIL;
182	top = nt; /* top could be bigger than newtop */
183	}	187	}
184		188
		189
		190	#define adjust_top(newtop) { if (newtop <= top-stack) \
		191	top = stack+newtop; \
		192	else adjust_top_aux(newtop); }
		193
185	#define adjustC(nParams) adjust_top(CLS_current.base+nParams)	194	#define adjustC(nParams) adjust_top(CLS_current.base+nParams)
186		195
187		196
		197	static void checkCparams (int nParams)
		198	{
		199	if (top-stack < CLS_current.base+nParams)
		200	lua_error("API error - wrong number of arguments in C2lua stack");
		201	}
		202
		203
188	/*	204	/*
189	** Open a hole below "nelems" from the top.	205	** Open a hole below "nelems" from the top.
190	*/	206	*/
@@ -197,13 +213,37 @@ static void open_stack (int nelems) · 6 unmodified lines
197	}	213	}
198		214
199		215
		216	static lua_Object put_luaObject (TObject *o)
		217	{
		218	open_stack((top-stack)-CLS_current.base);
		219	stack[CLS_current.base++] = *o;
		220	return CLS_current.base; /* this is +1 real position (see Ref) */
		221	}
		222
		223
		224	static lua_Object put_luaObjectonTop (void)
		225	{
		226	open_stack((top-stack)-CLS_current.base);
		227	stack[CLS_current.base++] = *(--top);
		228	return CLS_current.base; /* this is +1 real position (see Ref) */
		229	}
		230
		231
		232	lua_Object lua_pop (void)
		233	{
		234	checkCparams(1);
		235	return put_luaObjectonTop();
		236	}
		237
		238
		239
200	/*	240	/*
201	** call Line hook	241	** call Line hook
202	*/	242	*/
203	static void lineHook (int line)	243	static void lineHook (int line)
204	{	244	{
205	struct C_Lua_Stack oldCLS = CLS_current;	245	struct C_Lua_Stack oldCLS = CLS_current;
206	StkId old_top = CLS_current.base = top-stack;	246	StkId old_top = CLS_current.lua2C = CLS_current.base = top-stack;
207	CLS_current.num = 0;	247	CLS_current.num = 0;
208	(*lua_linehook)(line);	248	(*lua_linehook)(line);
209	top = stack+old_top;	249	top = stack+old_top;
@@ -218,13 +258,13 @@ static void lineHook (int line) · 8 unmodified lines
218	static void callHook (StkId base, lua_Type type, int isreturn)	258	static void callHook (StkId base, lua_Type type, int isreturn)
219	{	259	{
220	struct C_Lua_Stack oldCLS = CLS_current;	260	struct C_Lua_Stack oldCLS = CLS_current;
221	StkId old_top = CLS_current.base = top-stack;	261	StkId old_top = CLS_current.lua2C = CLS_current.base = top-stack;
222	CLS_current.num = 0;	262	CLS_current.num = 0;
223	if (isreturn)	263	if (isreturn)
224	(*lua_callhook)(LUA_NOOBJECT, "(return)", 0);	264	(*lua_callhook)(LUA_NOOBJECT, "(return)", 0);
225	else	265	else
226	{	266	{
227	Object *f = stack+base-1;	267	TObject *f = stack+base-1;
228	if (type == LUA_T_MARK)	268	if (type == LUA_T_MARK)
229	(*lua_callhook)(Ref(f), f->value.tf->fileName, f->value.tf->lineDefined);	269	(*lua_callhook)(Ref(f), f->value.tf->fileName, f->value.tf->lineDefined);
230	else	270	else
@@ -246,6 +286,7 @@ static StkId callC (lua_CFunction func, StkId base) · 15 unmodified lines
246	StkId firstResult;	286	StkId firstResult;
247	CLS_current.num = (top-stack) - base;	287	CLS_current.num = (top-stack) - base;
248	/* incorporate parameters on the stack */	288	/* incorporate parameters on the stack */
		289	CLS_current.lua2C = base;
249	CLS_current.base = base+CLS_current.num; /* == top-stack */	290	CLS_current.base = base+CLS_current.num; /* == top-stack */
250	if (lua_callhook)	291	if (lua_callhook)
251	callHook(base, LUA_T_CMARK, 0);	292	callHook(base, LUA_T_CMARK, 0);
@@ -257,15 +298,11 @@ static StkId callC (lua_CFunction func, StkId base) · 5 unmodified lines
257	return firstResult;	298	return firstResult;
258	}	299	}
259		300
260	/*	301	static void callIM (TObject *f, int nParams, int nResults)
261	** Call the specified fallback, putting it on the stack below its arguments
262	*/
263	static void callFB (int fb)
264	{	302	{
265	int nParams = luaI_fallBacks[fb].nParams;
266	open_stack(nParams);	303	open_stack(nParams);
267	*(top-nParams-1) = luaI_fallBacks[fb].function;	304	(top-nParams-1) = f;
268	do_call((top-stack)-nParams, luaI_fallBacks[fb].nResults);	305	do_call((top-stack)-nParams, nResults);
269	}	306	}
270		307
271		308
@@ -278,28 +315,28 @@ static void callFB (int fb) · 6 unmodified lines
278	static void do_call (StkId base, int nResults)	315	static void do_call (StkId base, int nResults)
279	{	316	{
280	StkId firstResult;	317	StkId firstResult;
281	Object *func = stack+base-1;	318	TObject *func = stack+base-1;
282	int i;	319	int i;
283	if (tag(func) == LUA_T_CFUNCTION)	320	if (ttype(func) == LUA_T_CFUNCTION) {
284	{	321	ttype(func) = LUA_T_CMARK;
285	tag(func) = LUA_T_CMARK;
286	firstResult = callC(fvalue(func), base);	322	firstResult = callC(fvalue(func), base);
287	}	323	}
288	else if (tag(func) == LUA_T_FUNCTION)	324	else if (ttype(func) == LUA_T_FUNCTION) {
289	{	325	ttype(func) = LUA_T_MARK;
290	tag(func) = LUA_T_MARK;
291	firstResult = lua_execute(func->value.tf->code, base);	326	firstResult = lua_execute(func->value.tf->code, base);
292	}	327	}
293	else	328	else { /* func is not a function */
294	{ /* func is not a function */	329	/* Check the tag method for invalid functions */
295	/* Call the fallback for invalid functions */	330	TObject *im = luaI_getimbyObj(func, IM_FUNCTION);
		331	if (ttype(im) == LUA_T_NIL)
		332	lua_error("call expression not a function");
296	open_stack((top-stack)-(base-1));	333	open_stack((top-stack)-(base-1));
297	stack[base-1] = luaI_fallBacks[FB_FUNCTION].function;	334	stack[base-1] = *im;
298	do_call(base, nResults);	335	do_call(base, nResults);
299	return;	336	return;
300	}	337	}
301	/* adjust the number of results */	338	/* adjust the number of results */
302	if (nResults != MULT_RET && top - (stack+firstResult) != nResults)	339	if (nResults != MULT_RET)
303	adjust_top(firstResult+nResults);	340	adjust_top(firstResult+nResults);
304	/* move results to base-1 (to erase parameters and function) */	341	/* move results to base-1 (to erase parameters and function) */
305	base--;	342	base--;
@@ -316,58 +353,110 @@ static void do_call (StkId base, int nResults) · 10 unmodified lines
316	*/	353	*/
317	static void pushsubscript (void)	354	static void pushsubscript (void)
318	{	355	{
319	if (tag(top-2) != LUA_T_ARRAY)	356	TObject *im;
320	callFB(FB_GETTABLE);	357	if (ttype(top-2) != LUA_T_ARRAY) /* not a table, get "gettable" method */
321	else	358	im = luaI_getimbyObj(top-2, IM_GETTABLE);
322	{	359	else { /* object is a table... */
323	Object *h = lua_hashget(avalue(top-2), top-1);	360	int tg = (top-2)->value.a->htag;
324	if (h == NULL \|\| tag(h) == LUA_T_NIL)	361	im = luaI_getim(tg, IM_GETTABLE);
325	callFB(FB_INDEX);	362	if (ttype(im) == LUA_T_NIL) { /* and does not have a "gettable" method */
326	else	363	TObject *h = lua_hashget(avalue(top-2), top-1);
327	{	364	if (h != NULL && ttype(h) != LUA_T_NIL) {
328	--top;	365	--top;
329	(top-1) = h;	366	(top-1) = h;
		367	}
		368	else if (ttype(im=luaI_getim(tg, IM_INDEX)) != LUA_T_NIL)
		369	callIM(im, 2, 1);
		370	else {
		371	--top;
		372	ttype(top-1) = LUA_T_NIL;
		373	}
		374	return;
330	}	375	}
		376	/* else it has a "gettable" method, go through to next command */
		377	}
		378	/* object is not a table, or it has a "gettable" method */
		379	if (ttype(im) != LUA_T_NIL)
		380	callIM(im, 2, 1);
		381	else
		382	lua_error("indexed expression not a table");
		383	}
		384
		385
		386	lua_Object lua_rawgettable (void)
		387	{
		388	checkCparams(2);
		389	if (ttype(top-2) != LUA_T_ARRAY)
		390	lua_error("indexed expression not a table in raw gettable");
		391	else {
		392	TObject *h = lua_hashget(avalue(top-2), top-1);
		393	--top;
		394	if (h != NULL)
		395	(top-1) = h;
		396	else
		397	ttype(top-1) = LUA_T_NIL;
331	}	398	}
		399	return put_luaObjectonTop();
332	}	400	}
333		401
334		402
335	/*	403	/*
336	** Function to store indexed based on values at the top	404	** Function to store indexed based on values at the top
		405	** mode = 0: raw store (without internal methods)
		406	** mode = 1: normal store (with internal methods)
		407	** mode = 2: "deep stack" store (with internal methods)
337	*/	408	*/
338	static void storesubscript (void)	409	static void storesubscript (TObject *t, int mode)
339	{	410	{
340	if (tag(top-3) != LUA_T_ARRAY)	411	TObject *im = (mode == 0) ? NULL : luaI_getimbyObj(t, IM_SETTABLE);
341	callFB(FB_SETTABLE);	412	if (ttype(t) == LUA_T_ARRAY && (im == NULL \|\| ttype(im) == LUA_T_NIL)) {
342	else	413	TObject *h = lua_hashdefine(avalue(t), t+1);
343	{	414	h = (top-1);
344	Object *h = lua_hashdefine (avalue(top-3), top-2);	415	top -= (mode == 2) ? 1 : 3;
345	h = (top-1);	416	}
346	top -= 3;	417	else { /* object is not a table, and/or has a specific "settable" method */
347	}	418	if (im && ttype(im) != LUA_T_NIL) {
		419	if (mode == 2) {
		420	lua_checkstack(top+2);
		421	(top+1) = (top-1);
		422	(top) = (t+1);
		423	(top-1) = t;
		424	top += 2;
		425	}
		426	callIM(im, 3, 0);
		427	}
		428	else
		429	lua_error("indexed expression not a table");
		430	}
348	}	431	}
349		432
350		433
351	static void getglobal (Word n)	434	static void getglobal (Word n)
352	{	435	{
353	*top = lua_table[n].object;	436	TObject *value = &lua_table[n].object;
354	incr_top;	437	TObject *im = luaI_getimbyObj(value, IM_GETGLOBAL);
355	if (tag(top-1) == LUA_T_NIL)	438	if (ttype(im) == LUA_T_NIL) { /* default behavior */
356	{ /* must call getglobal fallback */	439	top = value;
357	tag(top-1) = LUA_T_STRING;	440	incr_top;
358	tsvalue(top-1) = lua_table[n].varname;
359	callFB(FB_GETGLOBAL);
360	}	441	}
		442	else {
		443	ttype(top) = LUA_T_STRING;
		444	tsvalue(top) = lua_table[n].varname;
		445	incr_top;
		446	top = value;
		447	incr_top;
		448	callIM(im, 2, 1);
		449	}
361	}	450	}
362		451
363	/*	452	/*
364	** Traverse all objects on stack	453	** Traverse all objects on stack
365	*/	454	*/
366	void lua_travstack (int (fn)(Object ))	455	void lua_travstack (int (fn)(TObject ))
367	{	456	{
368	Object *o;	457	StkId i;
369	for (o = top-1; o >= stack; o--)	458	for (i = (top-1)-stack; i>=0; i--)
370	fn (o);	459	fn (stack+i);
371	}	460	}
372		461
373		462
@@ -377,8 +466,11 @@ void lua_travstack (int (fn)(Object )) · 3 unmodified lines
377		466
378	static void lua_message (char *s)	467	static void lua_message (char *s)
379	{	468	{
380	lua_pushstring(s);	469	TObject *im = luaI_geterrorim();
381	callFB(FB_ERROR);	470	if (ttype(im) != LUA_T_NIL) {
		471	lua_pushstring(s);
		472	callIM(im, 1, 0);
		473	}
382	}	474	}
383		475
384	/*	476	/*
@@ -399,25 +491,25 @@ void lua_error (char *s) · 14 unmodified lines
399		491
400	lua_Function lua_stackedfunction (int level)	492	lua_Function lua_stackedfunction (int level)
401	{	493	{
402	Object *p = top;	494	StkId i;
403	while (--p >= stack)	495	for (i = (top-1)-stack; i>=0; i--)
404	if (p->tag == LUA_T_MARK \|\| p->tag == LUA_T_CMARK)	496	if (stack[i].ttype == LUA_T_MARK \|\| stack[i].ttype == LUA_T_CMARK)
405	if (level-- == 0)	497	if (level-- == 0)
406	return Ref(p);	498	return Ref(stack+i);
407	return LUA_NOOBJECT;	499	return LUA_NOOBJECT;
408	}	500	}
409		501
410		502
411	int lua_currentline (lua_Function func)	503	int lua_currentline (lua_Function func)
412	{	504	{
413	Object *f = Address(func);	505	TObject *f = Address(func);
414	return (f+1 < top && (f+1)->tag == LUA_T_LINE) ? (f+1)->value.i : -1;	506	return (f+1 < top && (f+1)->ttype == LUA_T_LINE) ? (f+1)->value.i : -1;
415	}	507	}
416		508
417		509
418	lua_Object lua_getlocal (lua_Function func, int local_number, char **name)	510	lua_Object lua_getlocal (lua_Function func, int local_number, char **name)
419	{	511	{
420	Object *f = luaI_Address(func);	512	TObject *f = luaI_Address(func);
421	*name = luaI_getlocalname(f->value.tf, local_number, lua_currentline(func));	513	*name = luaI_getlocalname(f->value.tf, local_number, lua_currentline(func));
422	if (*name)	514	if (*name)
423	{	515	{
@@ -431,9 +523,9 @@ lua_Object lua_getlocal (lua_Function func, int local_number, char **name) · 7 unmodified lines
431		523
432	int lua_setlocal (lua_Function func, int local_number)	524	int lua_setlocal (lua_Function func, int local_number)
433	{	525	{
434	Object *f = Address(func);	526	TObject *f = Address(func);
435	char *name = luaI_getlocalname(f->value.tf, local_number, lua_currentline(func));	527	char *name = luaI_getlocalname(f->value.tf, local_number, lua_currentline(func));
436	adjustC(1);	528	checkCparams(1);
437	--top;	529	--top;
438	if (name)	530	if (name)
439	{	531	{
@@ -446,6 +538,29 @@ int lua_setlocal (lua_Function func, int local_number) · 6 unmodified lines
446	return 0;	538	return 0;
447	}	539	}
448		540
		541	/*
		542	** Call the function at CLS_current.base, and incorporate results on
		543	** the Lua2C structure.
		544	*/
		545	static void do_callinc (int nResults)
		546	{
		547	StkId base = CLS_current.base;
		548	do_call(base+1, nResults);
		549	CLS_current.lua2C = base; /* position of the new results */
		550	CLS_current.num = (top-stack) - base; /* number of results */
		551	CLS_current.base = base + CLS_current.num; /* incorporate results on stack */
		552	}
		553
		554
		555	static void do_unprotectedrun (lua_CFunction f, int nParams, int nResults)
		556	{
		557	StkId base = (top-stack)-nParams;
		558	open_stack(nParams);
		559	stack[base].ttype = LUA_T_CFUNCTION;
		560	stack[base].value.f = f;
		561	do_call(base+1, nResults);
		562	}
		563
449		564
450	/*	565	/*
451	** Execute a protected call. Assumes that function is at CLS_current.base and	566	** Execute a protected call. Assumes that function is at CLS_current.base and
@@ -458,15 +573,11 @@ static int do_protectedrun (int nResults) · 6 unmodified lines
458	struct C_Lua_Stack oldCLS = CLS_current;	573	struct C_Lua_Stack oldCLS = CLS_current;
459	jmp_buf *oldErr = errorJmp;	574	jmp_buf *oldErr = errorJmp;
460	errorJmp = &myErrorJmp;	575	errorJmp = &myErrorJmp;
461	if (setjmp(myErrorJmp) == 0)	576	if (setjmp(myErrorJmp) == 0) {
462	{	577	do_callinc(nResults);
463	do_call(CLS_current.base+1, nResults);
464	CLS_current.num = (top-stack) - CLS_current.base; /* number of results */
465	CLS_current.base += CLS_current.num; /* incorporate results on the stack */
466	status = 0;	578	status = 0;
467	}	579	}
468	else	580	else { /* an error occurred: restore CLS_current and top */
469	{ /* an error occurred: restore CLS_current and top */
470	CLS_current = oldCLS;	581	CLS_current = oldCLS;
471	top = stack+CLS_current.base;	582	top = stack+CLS_current.base;
472	status = 1;	583	status = 1;
@@ -479,13 +590,14 @@ int luaI_dorun (TFunc *tf) · 6 unmodified lines
479	{	590	{
480	int status;	591	int status;
481	adjustC(1); /* one slot for the pseudo-function */	592	adjustC(1); /* one slot for the pseudo-function */
482	stack[CLS_current.base].tag = LUA_T_FUNCTION;	593	stack[CLS_current.base].ttype = LUA_T_FUNCTION;
483	stack[CLS_current.base].value.tf = tf;	594	stack[CLS_current.base].value.tf = tf;
484	status = do_protectedrun(MULT_RET);	595	status = do_protectedrun(MULT_RET);
485	return status;	596	return status;
486	}	597	}
487		598
488	static int do_protectedmain (void)	599
		600	int lua_domain (void)
489	{	601	{
490	TFunc tf;	602	TFunc tf;
491	int status;	603	int status;
@@ -493,23 +605,21 @@ static int do_protectedmain (void) · 1 unmodified line
493	jmp_buf *oldErr = errorJmp;	605	jmp_buf *oldErr = errorJmp;
494	errorJmp = &myErrorJmp;	606	errorJmp = &myErrorJmp;
495	luaI_initTFunc(&tf);	607	luaI_initTFunc(&tf);
496	tf.fileName = lua_parsedfile;	608	if (setjmp(myErrorJmp) == 0) {
497	if (setjmp(myErrorJmp) == 0)
498	{
499	lua_parse(&tf);	609	lua_parse(&tf);
500	status = luaI_dorun(&tf);	610	status = 0;
501	}	611	}
502	else	612	else {
503	{
504	status = 1;
505	adjustC(0); /* erase extra slot */	613	adjustC(0); /* erase extra slot */
		614	status = 1;
506	}	615	}
		616	if (status == 0)
		617	status = luaI_dorun(&tf);
507	errorJmp = oldErr;	618	errorJmp = oldErr;
508	luaI_free(tf.code);	619	luaI_free(tf.code);
509	return status;	620	return status;
510	}	621	}
511		622
512
513	/*	623	/*
514	** Execute the given lua function. Return 0 on success or 1 on error.	624	** Execute the given lua function. Return 0 on success or 1 on error.
515	*/	625	*/
@@ -526,71 +636,31 @@ int lua_callfunction (lua_Object function) · 10 unmodified lines
526	}	636	}
527		637
528		638
529	int lua_call (char *funcname)	639	lua_Object lua_gettagmethod (int tag, char *event)
530	{	640	{
531	Word n = luaI_findsymbolbyname(funcname);	641	lua_pushnumber(tag);
532	open_stack((top-stack)-CLS_current.base);	642	lua_pushstring(event);
533	stack[CLS_current.base] = s_object(n);	643	do_unprotectedrun(luaI_gettagmethod, 2, 1);
534	return do_protectedrun(MULT_RET);	644	return put_luaObjectonTop();
535	}	645	}
536		646
537		647	lua_Object lua_settagmethod (int tag, char *event)
538	/*
539	** Open file, generate opcode and execute global statement. Return 0 on
540	** success or non 0 on error.
541	*/
542	int lua_dofile (char *filename)
543	{	648	{
544	int status;	649	TObject newmethod;
545	int c;	650	checkCparams(1);
546	FILE *f = lua_openfile(filename);	651	newmethod = *(--top);
547	if (f == NULL)	652	lua_pushnumber(tag);
548	return 2;	653	lua_pushstring(event);
549	c = fgetc(f);	654	*top = newmethod; incr_top;
550	ungetc(c, f);	655	do_unprotectedrun(luaI_settagmethod, 3, 1);
551	if (c == ID_CHUNK) {	656	return put_luaObjectonTop();
552	f = freopen(filename, "rb", f); /* set binary mode */
553	status = luaI_undump(f);
554	}
555	else {
556	if (c == '#')
557	while ((c=fgetc(f)) != '\n') /* skip first line */;
558	status = do_protectedmain();
559	}
560	lua_closefile();
561	return status;
562	}	657	}
563		658
564	/*	659	lua_Object lua_seterrormethod (void)
565	** Generate opcode stored on string and execute global statement. Return 0 on
566	** success or non 0 on error.
567	*/
568	int lua_dostring (char *str)
569	{	660	{
570	int status;	661	checkCparams(1);
571	if (str == NULL)	662	do_unprotectedrun(luaI_seterrormethod, 1, 1);
572	return 1;	663	return put_luaObjectonTop();
573	lua_openstring(str);
574	status = do_protectedmain();
575	lua_closestring();
576	return status;
577	}
578
579
580	/*
581	** API: set a function as a fallback
582	*/
583	lua_Object lua_setfallback (char *name, lua_CFunction fallback)
584	{
585	adjustC(1); /* one slot for the pseudo-function */
586	stack[CLS_current.base].tag = LUA_T_CFUNCTION;
587	stack[CLS_current.base].value.f = luaI_setfallback;
588	lua_pushstring(name);
589	lua_pushcfunction(fallback);
590	if (do_protectedrun(1) == 0)
591	return (Ref(top-1));
592	else
593	return LUA_NOOBJECT;
594	}	664	}
595		665
596		666
@@ -598,12 +668,11 @@ lua_Object lua_setfallback (char *name, lua_CFunction fallback) · 1 unmodified line
598	** API: receives on the stack the table and the index.	668	** API: receives on the stack the table and the index.
599	** returns the value.	669	** returns the value.
600	*/	670	*/
601	lua_Object lua_getsubscript (void)	671	lua_Object lua_gettable (void)
602	{	672	{
603	adjustC(2);	673	checkCparams(2);
604	pushsubscript();	674	pushsubscript();
605	CLS_current.base++; /* incorporate object in the stack */	675	return put_luaObjectonTop();
606	return (Ref(top-1));
607	}	676	}
608		677
609		678
@@ -633,13 +702,25 @@ void lua_endblock (void) · 23 unmodified lines
633	adjustC(0);	702	adjustC(0);
634	}	703	}
635		704
		705	void lua_settag (int tag)
		706	{
		707	checkCparams(1);
		708	luaI_settag(tag, --top);
		709	}
		710
636	/*	711	/*
637	** API: receives on the stack the table, the index, and the new value.	712	** API: receives on the stack the table, the index, and the new value.
638	*/	713	*/
639	void lua_storesubscript (void)	714	void lua_settable (void)
640	{	715	{
641	adjustC(3);	716	checkCparams(3);
642	storesubscript();	717	storesubscript(top-3, 1);
		718	}
		719
		720	void lua_rawsettable (void)
		721	{
		722	checkCparams(3);
		723	storesubscript(top-3, 0);
643	}	724	}
644		725
645	/*	726	/*
@@ -647,40 +728,59 @@ void lua_storesubscript (void) · 1 unmodified line
647	*/	728	*/
648	lua_Object lua_createtable (void)	729	lua_Object lua_createtable (void)
649	{	730	{
650	adjustC(0);	731	TObject o;
651	avalue(top) = lua_createarray(0);	732	avalue(&o) = lua_createarray(0);
652	tag(top) = LUA_T_ARRAY;	733	ttype(&o) = LUA_T_ARRAY;
653	incr_top;	734	return put_luaObject(&o);
654	CLS_current.base++; /* incorporate object in the stack */
655	return Ref(top-1);
656	}	735	}
657		736
658	/*	737	/*
659	** Get a parameter, returning the object handle or LUA_NOOBJECT on error.	738	** Get a parameter, returning the object handle or LUA_NOOBJECT on error.
660	** 'number' must be 1 to get the first parameter.	739	** 'number' must be 1 to get the first parameter.
661	*/	740	*/
662	lua_Object lua_getparam (int number)	741	lua_Object lua_lua2C (int number)
		742	{
		743	if (number <= 0 \|\| number > CLS_current.num) return LUA_NOOBJECT;
		744	/* Ref(stack+(CLS_current.lua2C+number-1)) ==
		745	stack+(CLS_current.lua2C+number-1)-stack+1 == */
		746	return CLS_current.lua2C+number;
		747	}
		748
		749	int lua_isnil (lua_Object o)
		750	{
		751	return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_NIL);
		752	}
		753
		754	int lua_istable (lua_Object o)
		755	{
		756	return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_ARRAY);
		757	}
		758
		759	int lua_isuserdata (lua_Object o)
663	{	760	{
664	if (number <= 0 \|\| number > CLS_current.num) return LUA_NOOBJECT;	761	return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_USERDATA);
665	/* Ref(stack+(CLS_current.base-CLS_current.num+number-1)) ==
666	stack+(CLS_current.base-CLS_current.num+number-1)-stack+1 == */
667	return CLS_current.base-CLS_current.num+number;
668	}	762	}
669		763
670	int lua_isnumber (lua_Object object)	764	int lua_iscfunction (lua_Object o)
671	{	765	{
672	return (object != LUA_NOOBJECT) && (tonumber(Address(object)) == 0);	766	int t = lua_tag(o);
		767	return (t == LUA_T_CMARK) \|\| (t == LUA_T_CFUNCTION);
673	}	768	}
674		769
675	int lua_isstring (lua_Object object)	770	int lua_isnumber (lua_Object o)
676	{	771	{
677	int t = lua_type(object);	772	return (o!= LUA_NOOBJECT) && (tonumber(Address(o)) == 0);
		773	}
		774
		775	int lua_isstring (lua_Object o)
		776	{
		777	int t = lua_tag(o);
678	return (t == LUA_T_STRING) \|\| (t == LUA_T_NUMBER);	778	return (t == LUA_T_STRING) \|\| (t == LUA_T_NUMBER);
679	}	779	}
680		780
681	int lua_isfunction (lua_Object object)	781	int lua_isfunction (lua_Object o)
682	{	782	{
683	int t = lua_type(object);	783	int t = lua_tag(o);
684	return (t == LUA_T_FUNCTION) \|\| (t == LUA_T_CFUNCTION) \|\|	784	return (t == LUA_T_FUNCTION) \|\| (t == LUA_T_CFUNCTION) \|\|
685	(t == LUA_T_MARK) \|\| (t == LUA_T_CMARK);	785	(t == LUA_T_MARK) \|\| (t == LUA_T_CMARK);
686	}	786	}
@@ -700,57 +800,44 @@ real lua_getnumber (lua_Object object) · 13 unmodified lines
700	*/	800	*/
701	char *lua_getstring (lua_Object object)	801	char *lua_getstring (lua_Object object)
702	{	802	{
703	if (object == LUA_NOOBJECT) return NULL;	803	if (object == LUA_NOOBJECT \|\| tostring (Address(object)))
704	if (tostring (Address(object))) return NULL;	804	return NULL;
705	else return (svalue(Address(object)));	805	else return (svalue(Address(object)));
706	}	806	}
707		807
708	/*	808
709	** Given an object handle, return its cfuntion pointer. On error, return NULL.	809	void *lua_getuserdata (lua_Object object)
710	*/
711	lua_CFunction lua_getcfunction (lua_Object object)
712	{	810	{
713	if (object == LUA_NOOBJECT \|\| ((tag(Address(object)) != LUA_T_CFUNCTION) &&	811	if (object == LUA_NOOBJECT \|\| ttype(Address(object)) != LUA_T_USERDATA)
714	(tag(Address(object)) != LUA_T_CMARK)))	812	return NULL;
715	return NULL;	813	else return tsvalue(Address(object))->u.v;
716	else return (fvalue(Address(object)));
717	}	814	}
718		815
		816
719	/*	817	/*
720	** Given an object handle, return its user data. On error, return NULL.	818	** Given an object handle, return its cfuntion pointer. On error, return NULL.
721	*/	819	*/
722	void *lua_getuserdata (lua_Object object)	820	lua_CFunction lua_getcfunction (lua_Object object)
723	{	821	{
724	if (object == LUA_NOOBJECT \|\| tag(Address(object)) < LUA_T_USERDATA)	822	if (object == LUA_NOOBJECT \|\| ((ttype(Address(object)) != LUA_T_CFUNCTION) &&
		823	(ttype(Address(object)) != LUA_T_CMARK)))
725	return NULL;	824	return NULL;
726	else return (uvalue(Address(object)));	825	else return (fvalue(Address(object)));
727	}	826	}
728		827
729		828
730	lua_Object lua_getref (int ref)	829	lua_Object lua_getref (int ref)
731	{	830	{
732	Object *o = luaI_getref(ref);	831	TObject *o = luaI_getref(ref);
733	if (o == NULL)	832	if (o == NULL)
734	return LUA_NOOBJECT;	833	return LUA_NOOBJECT;
735	adjustC(0);	834	return put_luaObject(o);
736	luaI_pushobject(o);
737	CLS_current.base++; /* incorporate object in the stack */
738	return Ref(top-1);
739	}
740
741
742	void lua_pushref (int ref)
743	{
744	Object *o = luaI_getref(ref);
745	if (o == NULL)
746	lua_error("access to invalid (possibly garbage collected) reference");
747	luaI_pushobject(o);
748	}	835	}
749		836
750		837
751	int lua_ref (int lock)	838	int lua_ref (int lock)
752	{	839	{
753	adjustC(1);	840	checkCparams(1);
754	return luaI_ref(--top, lock);	841	return luaI_ref(--top, lock);
755	}	842	}
756		843
@@ -761,20 +848,50 @@ int lua_ref (int lock) · 4 unmodified lines
761	*/	848	*/
762	lua_Object lua_getglobal (char *name)	849	lua_Object lua_getglobal (char *name)
763	{	850	{
764	adjustC(0);	851	getglobal(luaI_findsymbolbyname(name));
765	getglobal(luaI_findsymbolbyname(name));	852	return put_luaObjectonTop();
766	CLS_current.base++; /* incorporate object in the stack */	853	}
767	return Ref(top-1);	854
		855
		856	lua_Object lua_rawgetglobal (char *name)
		857	{
		858	return put_luaObject(&lua_table[luaI_findsymbolbyname(name)].object);
768	}	859	}
769		860
		861
770	/*	862	/*
771	** Store top of the stack at a global variable array field.	863	** Store top of the stack at a global variable array field.
772	*/	864	*/
773	void lua_storeglobal (char *name)	865	static void setglobal (Word n)
		866	{
		867	TObject *oldvalue = &lua_table[n].object;
		868	TObject *im = luaI_getimbyObj(oldvalue, IM_SETGLOBAL);
		869	if (ttype(im) == LUA_T_NIL) /* default behavior */
		870	s_object(n) = *(--top);
		871	else {
		872	TObject newvalue = *(top-1);
		873	ttype(top-1) = LUA_T_STRING;
		874	tsvalue(top-1) = lua_table[n].varname;
		875	top = oldvalue;
		876	incr_top;
		877	*top = newvalue;
		878	incr_top;
		879	callIM(im, 3, 0);
		880	}
		881	}
		882
		883
		884	void lua_setglobal (char *name)
774	{	885	{
775	Word n = luaI_findsymbolbyname(name);	886	checkCparams(1);
776	adjustC(1);	887	setglobal(luaI_findsymbolbyname(name));
777	s_object(n) = *(--top);	888	}
		889
		890	void lua_rawsetglobal (char *name)
		891	{
		892	Word n = luaI_findsymbolbyname(name);
		893	checkCparams(1);
		894	s_object(n) = *(--top);
778	}	895	}
779		896
780	/*	897	/*
@@ -782,60 +899,59 @@ void lua_storeglobal (char *name) · 1 unmodified line
782	*/	899	*/
783	void lua_pushnil (void)	900	void lua_pushnil (void)
784	{	901	{
785	tag(top) = LUA_T_NIL;	902	ttype(top) = LUA_T_NIL;
786	incr_top;	903	incr_top;
787	}	904	}
788		905
789	/*	906	/*
790	** Push an object (tag=number) to stack.	907	** Push an object (ttype=number) to stack.
791	*/	908	*/
792	void lua_pushnumber (real n)	909	void lua_pushnumber (real n)
793	{	910	{
794	tag(top) = LUA_T_NUMBER; nvalue(top) = n;	911	ttype(top) = LUA_T_NUMBER; nvalue(top) = n;
795	incr_top;	912	incr_top;
796	}	913	}
797		914
798	/*	915	/*
799	** Push an object (tag=string) to stack.	916	** Push an object (ttype=string) to stack.
800	*/	917	*/
801	void lua_pushstring (char *s)	918	void lua_pushstring (char *s)
802	{	919	{
803	if (s == NULL)	920	if (s == NULL)
804	tag(top) = LUA_T_NIL;	921	ttype(top) = LUA_T_NIL;
805	else	922	else
806	{	923	{
807	tsvalue(top) = lua_createstring(s);	924	tsvalue(top) = lua_createstring(s);
808	tag(top) = LUA_T_STRING;	925	ttype(top) = LUA_T_STRING;
809	}	926	}
810	incr_top;	927	incr_top;
811	}	928	}
812	/*>>>>>>>>>#undef lua_pushliteral	929
813	void lua_pushliteral(char s) { lua_pushstring(s); }/
814		930
815	/*	931	/*
816	** Push an object (tag=cfunction) to stack.	932	** Push an object (ttype=cfunction) to stack.
817	*/	933	*/
818	void lua_pushcfunction (lua_CFunction fn)	934	void lua_pushcfunction (lua_CFunction fn)
819	{	935	{
820	tag(top) = LUA_T_CFUNCTION; fvalue(top) = fn;	936	ttype(top) = LUA_T_CFUNCTION; fvalue(top) = fn;
821	incr_top;	937	incr_top;
822	}	938	}
823		939
824	/*	940
825	** Push an object (tag=userdata) to stack.	941
826	*/
827	void lua_pushusertag (void *u, int tag)	942	void lua_pushusertag (void *u, int tag)
828	{	943	{
829	if (tag < LUA_T_USERDATA)	944	if (tag < 0 && tag != LUA_ANYTAG)
830	lua_error("invalid tag in `lua_pushusertag'");	945	luaI_realtag(tag); /* error if tag is not valid */
831	tag(top) = tag; uvalue(top) = u;	946	tsvalue(top) = luaI_createudata(u, tag);
832	incr_top;	947	ttype(top) = LUA_T_USERDATA;
		948	incr_top;
833	}	949	}
834		950
835	/*	951	/*
836	** Push an object on the stack.	952	** Push an object on the stack.
837	*/	953	*/
838	void luaI_pushobject (Object *o)	954	void luaI_pushobject (TObject *o)
839	{	955	{
840	top = o;	956	top = o;
841	incr_top;	957	incr_top;
@@ -847,78 +963,102 @@ void luaI_pushobject (Object *o) · 5 unmodified lines
847	void lua_pushobject (lua_Object o)	963	void lua_pushobject (lua_Object o)
848	{	964	{
849	if (o == LUA_NOOBJECT)	965	if (o == LUA_NOOBJECT)
850	lua_error("attempt to push a NOOBJECT");	966	lua_error("API error - attempt to push a NOOBJECT");
851	top = Address(o);	967	top = Address(o);
852	if (tag(top) == LUA_T_MARK) tag(top) = LUA_T_FUNCTION;	968	if (ttype(top) == LUA_T_MARK) ttype(top) = LUA_T_FUNCTION;
853	else if (tag(top) == LUA_T_CMARK) tag(top) = LUA_T_CFUNCTION;	969	else if (ttype(top) == LUA_T_CMARK) ttype(top) = LUA_T_CFUNCTION;
854	incr_top;	970	incr_top;
855	}	971	}
856		972
857	int lua_type (lua_Object o)	973	int lua_tag (lua_Object lo)
858	{	974	{
859	if (o == LUA_NOOBJECT)	975	if (lo == LUA_NOOBJECT) return LUA_T_NIL;
860	return LUA_T_NIL;	976	else {
861	else	977	TObject *o = Address(lo);
862	return tag(Address(o));	978	lua_Type t = ttype(o);
		979	if (t == LUA_T_USERDATA)
		980	return o->value.ts->tag;
		981	else if (t == LUA_T_ARRAY)
		982	return o->value.a->htag;
		983	else return t;
		984	}
863	}	985	}
864		986
865		987
866	void luaI_gcFB (Object *o)	988	void luaI_gcIM (TObject *o)
867	{	989	{
868	top = o;	990	TObject *im = luaI_getimbyObj(o, IM_GC);
869	incr_top;	991	if (ttype(im) != LUA_T_NIL) {
870	callFB(FB_GC);	992	top = o;
		993	incr_top;
		994	callIM(im, 1, 0);
		995	}
		996	}
		997
		998
		999	static void call_binTM (IMS event, char *msg)
		1000	{
		1001	TObject im = luaI_getimbyObj(top-2, event); / try first operand */
		1002	if (ttype(im) == LUA_T_NIL) {
		1003	im = luaI_getimbyObj(top-1, event); /* try second operand */
		1004	if (ttype(im) == LUA_T_NIL) {
		1005	im = luaI_getim(0, event); /* try a 'global' i.m. */
		1006	if (ttype(im) == LUA_T_NIL)
		1007	lua_error(msg);
		1008	}
		1009	}
		1010	lua_pushstring(luaI_eventname[event]);
		1011	callIM(im, 3, 1);
871	}	1012	}
872		1013
873		1014
874	static void call_arith (char *op)	1015	static void call_arith (IMS event)
875	{	1016	{
876	lua_pushstring(op);	1017	call_binTM(event, "unexpected type at arithmetic operation");
877	callFB(FB_ARITH);
878	}	1018	}
879		1019
880	static void comparison (lua_Type tag_less, lua_Type tag_equal,	1020
881	lua_Type tag_great, char *op)	1021	static void comparison (lua_Type ttype_less, lua_Type ttype_equal,
		1022	lua_Type ttype_great, IMS op)
882	{	1023	{
883	Object *l = top-2;	1024	TObject *l = top-2;
884	Object *r = top-1;	1025	TObject *r = top-1;
885	int result;	1026	int result;
886	if (tag(l) == LUA_T_NUMBER && tag(r) == LUA_T_NUMBER)	1027	if (ttype(l) == LUA_T_NUMBER && ttype(r) == LUA_T_NUMBER)
887	result = (nvalue(l) < nvalue(r)) ? -1 : (nvalue(l) == nvalue(r)) ? 0 : 1;	1028	result = (nvalue(l) < nvalue(r)) ? -1 : (nvalue(l) == nvalue(r)) ? 0 : 1;
888	else if (tostring(l) \|\| tostring(r))	1029	else if (ttype(l) == LUA_T_STRING && ttype(r) == LUA_T_STRING)
889	{	1030	result = strcmp(svalue(l), svalue(r));
890	lua_pushstring(op);	1031	else {
891	callFB(FB_ORDER);	1032	call_binTM(op, "unexpected type at comparison");
892	return;	1033	return;
893	}	1034	}
894	else
895	result = strcmp(svalue(l), svalue(r));
896	top--;	1035	top--;
897	nvalue(top-1) = 1;	1036	nvalue(top-1) = 1;
898	tag(top-1) = (result < 0) ? tag_less : (result == 0) ? tag_equal : tag_great;	1037	ttype(top-1) = (result < 0) ? ttype_less :
		1038	(result == 0) ? ttype_equal : ttype_great;
899	}	1039	}
900		1040
901		1041
902	static void adjust_varargs (StkId first_extra_arg)	1042	static void adjust_varargs (StkId first_extra_arg)
903	{	1043	{
904	Object arg;	1044	TObject arg;
905	Object *firstelem = stack+first_extra_arg;	1045	TObject *firstelem = stack+first_extra_arg;
906	int nvararg = top-firstelem;	1046	int nvararg = top-firstelem;
907	int i;	1047	int i;
908	if (nvararg < 0) nvararg = 0;	1048	if (nvararg < 0) nvararg = 0;
909	avalue(&arg) = lua_createarray(nvararg+1); /* +1 for field 'n' */	1049	avalue(&arg) = lua_createarray(nvararg+1); /* +1 for field 'n' */
910	tag(&arg) = LUA_T_ARRAY;	1050	ttype(&arg) = LUA_T_ARRAY;
911	for (i=0; i<nvararg; i++) {	1051	for (i=0; i<nvararg; i++) {
912	Object index;	1052	TObject index;
913	tag(&index) = LUA_T_NUMBER;	1053	ttype(&index) = LUA_T_NUMBER;
914	nvalue(&index) = i+1;	1054	nvalue(&index) = i+1;
915	(lua_hashdefine(avalue(&arg), &index)) = (firstelem+i);	1055	(lua_hashdefine(avalue(&arg), &index)) = (firstelem+i);
916	}	1056	}
917	/* store counter in field "n" */ {	1057	/* store counter in field "n" */ {
918	Object index, extra;	1058	TObject index, extra;
919	tag(&index) = LUA_T_STRING;	1059	ttype(&index) = LUA_T_STRING;
920	tsvalue(&index) = lua_createstring("n");	1060	tsvalue(&index) = lua_createstring("n");
921	tag(&extra) = LUA_T_NUMBER;	1061	ttype(&extra) = LUA_T_NUMBER;
922	nvalue(&extra) = nvararg;	1062	nvalue(&extra) = nvararg;
923	*(lua_hashdefine(avalue(&arg), &index)) = extra;	1063	*(lua_hashdefine(avalue(&arg), &index)) = extra;
924	}	1064	}
@@ -942,22 +1082,22 @@ static StkId lua_execute (Byte *pc, StkId base) · 17 unmodified lines
942	OpCode opcode;	1082	OpCode opcode;
943	switch (opcode = (OpCode)*pc++)	1083	switch (opcode = (OpCode)*pc++)
944	{	1084	{
945	case PUSHNIL: tag(top) = LUA_T_NIL; incr_top; break;	1085	case PUSHNIL: ttype(top) = LUA_T_NIL; incr_top; break;
946		1086
947	case PUSH0: case PUSH1: case PUSH2:	1087	case PUSH0: case PUSH1: case PUSH2:
948	tag(top) = LUA_T_NUMBER;	1088	ttype(top) = LUA_T_NUMBER;
949	nvalue(top) = opcode-PUSH0;	1089	nvalue(top) = opcode-PUSH0;
950	incr_top;	1090	incr_top;
951	break;	1091	break;
952		1092
953	case PUSHBYTE:	1093	case PUSHBYTE:
954	tag(top) = LUA_T_NUMBER; nvalue(top) = *pc++; incr_top; break;	1094	ttype(top) = LUA_T_NUMBER; nvalue(top) = *pc++; incr_top; break;
955		1095
956	case PUSHWORD:	1096	case PUSHWORD:
957	{	1097	{
958	Word w;	1098	Word w;
959	get_word(w,pc);	1099	get_word(w,pc);
960	tag(top) = LUA_T_NUMBER; nvalue(top) = w;	1100	ttype(top) = LUA_T_NUMBER; nvalue(top) = w;
961	incr_top;	1101	incr_top;
962	}	1102	}
963	break;	1103	break;
@@ -966,7 +1106,7 @@ static StkId lua_execute (Byte *pc, StkId base) · 2 unmodified lines
966	{	1106	{
967	real num;	1107	real num;
968	get_float(num,pc);	1108	get_float(num,pc);
969	tag(top) = LUA_T_NUMBER; nvalue(top) = num;	1109	ttype(top) = LUA_T_NUMBER; nvalue(top) = num;
970	incr_top;	1110	incr_top;
971	}	1111	}
972	break;	1112	break;
@@ -975,7 +1115,7 @@ static StkId lua_execute (Byte *pc, StkId base) · 2 unmodified lines
975	{	1115	{
976	Word w;	1116	Word w;
977	get_word(w,pc);	1117	get_word(w,pc);
978	tag(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];	1118	ttype(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];
979	incr_top;	1119	incr_top;
980	}	1120	}
981	break;	1121	break;
@@ -985,7 +1125,7 @@ static StkId lua_execute (Byte *pc, StkId base) · 3 unmodified lines
985	TFunc *f;	1125	TFunc *f;
986	get_code(f,pc);	1126	get_code(f,pc);
987	luaI_insertfunction(f); /* may take part in GC */	1127	luaI_insertfunction(f); /* may take part in GC */
988	top->tag = LUA_T_FUNCTION;	1128	top->ttype = LUA_T_FUNCTION;
989	top->value.tf = f;	1129	top->value.tf = f;
990	incr_top;	1130	incr_top;
991	}	1131	}
@@ -1013,10 +1153,10 @@ static StkId lua_execute (Byte *pc, StkId base) · 21 unmodified lines
1013		1153
1014	case PUSHSELF:	1154	case PUSHSELF:
1015	{	1155	{
1016	Object receiver = *(top-1);	1156	TObject receiver = *(top-1);
1017	Word w;	1157	Word w;
1018	get_word(w,pc);	1158	get_word(w,pc);
1019	tag(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];	1159	ttype(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];
1020	incr_top;	1160	incr_top;
1021	pushsubscript();	1161	pushsubscript();
1022	*top = receiver;	1162	*top = receiver;
@@ -1037,47 +1177,32 @@ static StkId lua_execute (Byte *pc, StkId base) · 14 unmodified lines
1037	{	1177	{
1038	Word w;	1178	Word w;
1039	get_word(w,pc);	1179	get_word(w,pc);
1040	s_object(w) = *(--top);	1180	setglobal(w);
1041	}	1181	}
1042	break;	1182	break;
1043		1183
1044	case STOREINDEXED0:	1184	case STOREINDEXED0:
1045	storesubscript();	1185	storesubscript(top-3, 1);
1046	break;	1186	break;
1047		1187
1048	case STOREINDEXED:	1188	case STOREINDEXED: {
1049	{	1189	int n = *pc++;
1050	int n = *pc++;	1190	storesubscript(top-3-n, 2);
1051	if (tag(top-3-n) != LUA_T_ARRAY)	1191	break;
1052	{
1053	lua_checkstack(top+2);
1054	(top+1) = (top-1);
1055	(top) = (top-2-n);
1056	(top-1) = (top-3-n);
1057	top += 2;
1058	callFB(FB_SETTABLE);
1059	}
1060	else
1061	{
1062	Object *h = lua_hashdefine (avalue(top-3-n), top-2-n);
1063	h = (top-1);
1064	top--;
1065	}
1066	}	1192	}
1067	break;
1068		1193
1069	case STORELIST0:	1194	case STORELIST0:
1070	case STORELIST:	1195	case STORELIST:
1071	{	1196	{
1072	int m, n;	1197	int m, n;
1073	Object *arr;	1198	TObject *arr;
1074	if (opcode == STORELIST0) m = 0;	1199	if (opcode == STORELIST0) m = 0;
1075	else m = (pc++) FIELDS_PER_FLUSH;	1200	else m = (pc++) FIELDS_PER_FLUSH;
1076	n = *(pc++);	1201	n = *(pc++);
1077	arr = top-n-1;	1202	arr = top-n-1;
1078	while (n)	1203	while (n)
1079	{	1204	{
1080	tag(top) = LUA_T_NUMBER; nvalue(top) = n+m;	1205	ttype(top) = LUA_T_NUMBER; nvalue(top) = n+m;
1081	(lua_hashdefine (avalue(arr), top)) = (top-1);	1206	(lua_hashdefine (avalue(arr), top)) = (top-1);
1082	top--;	1207	top--;
1083	n--;	1208	n--;
@@ -1085,15 +1210,15 @@ static StkId lua_execute (Byte *pc, StkId base) · 1 unmodified line
1085	}	1210	}
1086	break;	1211	break;
1087		1212
1088	case STORERECORD:	1213	case STORERECORD: /* opcode obsolete: supersed by STOREMAP */
1089	{	1214	{
1090	int n = *(pc++);	1215	int n = *(pc++);
1091	Object *arr = top-n-1;	1216	TObject *arr = top-n-1;
1092	while (n)	1217	while (n)
1093	{	1218	{
1094	Word w;	1219	Word w;
1095	get_word(w,pc);	1220	get_word(w,pc);
1096	tag(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];	1221	ttype(top) = LUA_T_STRING; tsvalue(top) = lua_constant[w];
1097	(lua_hashdefine (avalue(arr), top)) = (top-1);	1222	(lua_hashdefine (avalue(arr), top)) = (top-1);
1098	top--;	1223	top--;
1099	n--;	1224	n--;
@@ -1101,13 +1226,25 @@ static StkId lua_execute (Byte *pc, StkId base) · 1 unmodified line
1101	}	1226	}
1102	break;	1227	break;
1103		1228
		1229	case STOREMAP: {
		1230	int n = *(pc++);
		1231	TObject arr = top-(2n)-1;
		1232	while (n--) {
		1233	(lua_hashdefine (avalue(arr), top-2)) = (top-1);
		1234	top-=2;
		1235	}
		1236	}
		1237	break;
		1238
1104	case ADJUST0:	1239	case ADJUST0:
1105	adjust_top(base);	1240	adjust_top(base);
1106	break;	1241	break;
1107		1242
1108	case ADJUST:	1243	case ADJUST: {
1109	adjust_top(base + *(pc++));	1244	StkId newtop = base + *(pc++);
		1245	adjust_top(newtop);
1110	break;	1246	break;
		1247	}
1111		1248
1112	case VARARGS:	1249	case VARARGS:
1113	adjust_varargs(base + *(pc++));	1250	adjust_varargs(base + *(pc++));
@@ -1118,7 +1255,7 @@ static StkId lua_execute (Byte *pc, StkId base) · 4 unmodified lines
1118	Word size;	1255	Word size;
1119	get_word(size,pc);	1256	get_word(size,pc);
1120	avalue(top) = lua_createarray(size);	1257	avalue(top) = lua_createarray(size);
1121	tag(top) = LUA_T_ARRAY;	1258	ttype(top) = LUA_T_ARRAY;
1122	incr_top;	1259	incr_top;
1123	}	1260	}
1124	break;	1261	break;
@@ -1127,33 +1264,33 @@ static StkId lua_execute (Byte *pc, StkId base) · 2 unmodified lines
1127	{	1264	{
1128	int res = lua_equalObj(top-2, top-1);	1265	int res = lua_equalObj(top-2, top-1);
1129	--top;	1266	--top;
1130	tag(top-1) = res ? LUA_T_NUMBER : LUA_T_NIL;	1267	ttype(top-1) = res ? LUA_T_NUMBER : LUA_T_NIL;
1131	nvalue(top-1) = 1;	1268	nvalue(top-1) = 1;
1132	}	1269	}
1133	break;	1270	break;
1134		1271
1135	case LTOP:	1272	case LTOP:
1136	comparison(LUA_T_NUMBER, LUA_T_NIL, LUA_T_NIL, "lt");	1273	comparison(LUA_T_NUMBER, LUA_T_NIL, LUA_T_NIL, IM_LT);
1137	break;	1274	break;
1138		1275
1139	case LEOP:	1276	case LEOP:
1140	comparison(LUA_T_NUMBER, LUA_T_NUMBER, LUA_T_NIL, "le");	1277	comparison(LUA_T_NUMBER, LUA_T_NUMBER, LUA_T_NIL, IM_LE);
1141	break;	1278	break;
1142		1279
1143	case GTOP:	1280	case GTOP:
1144	comparison(LUA_T_NIL, LUA_T_NIL, LUA_T_NUMBER, "gt");	1281	comparison(LUA_T_NIL, LUA_T_NIL, LUA_T_NUMBER, IM_GT);
1145	break;	1282	break;
1146		1283
1147	case GEOP:	1284	case GEOP:
1148	comparison(LUA_T_NIL, LUA_T_NUMBER, LUA_T_NUMBER, "ge");	1285	comparison(LUA_T_NIL, LUA_T_NUMBER, LUA_T_NUMBER, IM_GE);
1149	break;	1286	break;
1150		1287
1151	case ADDOP:	1288	case ADDOP:
1152	{	1289	{
1153	Object *l = top-2;	1290	TObject *l = top-2;
1154	Object *r = top-1;	1291	TObject *r = top-1;
1155	if (tonumber(r) \|\| tonumber(l))	1292	if (tonumber(r) \|\| tonumber(l))
1156	call_arith("add");	1293	call_arith(IM_ADD);
1157	else	1294	else
1158	{	1295	{
1159	nvalue(l) += nvalue(r);	1296	nvalue(l) += nvalue(r);
@@ -1164,10 +1301,10 @@ static StkId lua_execute (Byte *pc, StkId base) · 4 unmodified lines
1164		1301
1165	case SUBOP:	1302	case SUBOP:
1166	{	1303	{
1167	Object *l = top-2;	1304	TObject *l = top-2;
1168	Object *r = top-1;	1305	TObject *r = top-1;
1169	if (tonumber(r) \|\| tonumber(l))	1306	if (tonumber(r) \|\| tonumber(l))
1170	call_arith("sub");	1307	call_arith(IM_SUB);
1171	else	1308	else
1172	{	1309	{
1173	nvalue(l) -= nvalue(r);	1310	nvalue(l) -= nvalue(r);
@@ -1178,10 +1315,10 @@ static StkId lua_execute (Byte *pc, StkId base) · 4 unmodified lines
1178		1315
1179	case MULTOP:	1316	case MULTOP:
1180	{	1317	{
1181	Object *l = top-2;	1318	TObject *l = top-2;
1182	Object *r = top-1;	1319	TObject *r = top-1;
1183	if (tonumber(r) \|\| tonumber(l))	1320	if (tonumber(r) \|\| tonumber(l))
1184	call_arith("mul");	1321	call_arith(IM_MUL);
1185	else	1322	else
1186	{	1323	{
1187	nvalue(l) *= nvalue(r);	1324	nvalue(l) *= nvalue(r);
@@ -1192,10 +1329,10 @@ static StkId lua_execute (Byte *pc, StkId base) · 4 unmodified lines
1192		1329
1193	case DIVOP:	1330	case DIVOP:
1194	{	1331	{
1195	Object *l = top-2;	1332	TObject *l = top-2;
1196	Object *r = top-1;	1333	TObject *r = top-1;
1197	if (tonumber(r) \|\| tonumber(l))	1334	if (tonumber(r) \|\| tonumber(l))
1198	call_arith("div");	1335	call_arith(IM_DIV);
1199	else	1336	else
1200	{	1337	{
1201	nvalue(l) /= nvalue(r);	1338	nvalue(l) /= nvalue(r);
@@ -1205,36 +1342,34 @@ static StkId lua_execute (Byte *pc, StkId base) · 3 unmodified lines
1205	break;	1342	break;
1206		1343
1207	case POWOP:	1344	case POWOP:
1208	call_arith("pow");	1345	call_arith(IM_POW);
1209	break;	1346	break;
1210		1347
1211	case CONCOP:	1348	case CONCOP: {
1212	{	1349	TObject *l = top-2;
1213	Object *l = top-2;	1350	TObject *r = top-1;
1214	Object *r = top-1;	1351	if (tostring(l) \|\| tostring(r))
1215	if (tostring(r) \|\| tostring(l))	1352	call_binTM(IM_CONCAT, "unexpected type for concatenation");
1216	callFB(FB_CONCAT);	1353	else {
1217	else	1354	tsvalue(l) = lua_createstring(lua_strconc(svalue(l),svalue(r)));
1218	{	1355	--top;
1219	tsvalue(l) = lua_createstring (lua_strconc(svalue(l),svalue(r)));	1356	}
1220	--top;
1221	}
1222	}	1357	}
1223	break;	1358	break;
1224		1359
1225	case MINUSOP:	1360	case MINUSOP:
1226	if (tonumber(top-1))	1361	if (tonumber(top-1))
1227	{	1362	{
1228	tag(top) = LUA_T_NIL;	1363	ttype(top) = LUA_T_NIL;
1229	incr_top;	1364	incr_top;
1230	call_arith("unm");	1365	call_arith(IM_UNM);
1231	}	1366	}
1232	else	1367	else
1233	nvalue(top-1) = - nvalue(top-1);	1368	nvalue(top-1) = - nvalue(top-1);
1234	break;	1369	break;
1235		1370
1236	case NOTOP:	1371	case NOTOP:
1237	tag(top-1) = (tag(top-1) == LUA_T_NIL) ? LUA_T_NUMBER : LUA_T_NIL;	1372	ttype(top-1) = (ttype(top-1) == LUA_T_NIL) ? LUA_T_NUMBER : LUA_T_NIL;
1238	nvalue(top-1) = 1;	1373	nvalue(top-1) = 1;
1239	break;	1374	break;
1240		1375
@@ -1242,15 +1377,15 @@ static StkId lua_execute (Byte *pc, StkId base) · 1 unmodified line
1242	{	1377	{
1243	Word w;	1378	Word w;
1244	get_word(w,pc);	1379	get_word(w,pc);
1245	if (tag(top-1) != LUA_T_NIL) pc += w;	1380	if (ttype(top-1) != LUA_T_NIL) pc += w;
1246	}	1381	}
1247	break;	1382	break;
1248		1383
1249	case ONFJMP:	1384	case ONFJMP:
1250	{	1385	{
1251	Word w;	1386	Word w;
1252	get_word(w,pc);	1387	get_word(w,pc);
1253	if (tag(top-1) == LUA_T_NIL) pc += w;	1388	if (ttype(top-1) == LUA_T_NIL) pc += w;
1254	}	1389	}
1255	break;	1390	break;
1256		1391
@@ -1275,7 +1410,7 @@ static StkId lua_execute (Byte *pc, StkId base) · 18 unmodified lines
1275	Word w;	1410	Word w;
1276	get_word(w,pc);	1411	get_word(w,pc);
1277	top--;	1412	top--;
1278	if (tag(top) == LUA_T_NIL) pc += w;	1413	if (ttype(top) == LUA_T_NIL) pc += w;
1279	}	1414	}
1280	break;	1415	break;
1281		1416
@@ -1284,7 +1419,7 @@ static StkId lua_execute (Byte *pc, StkId base) · 2 unmodified lines
1284	Word w;	1419	Word w;
1285	get_word(w,pc);	1420	get_word(w,pc);
1286	top--;	1421	top--;
1287	if (tag(top) == LUA_T_NIL) pc -= w;	1422	if (ttype(top) == LUA_T_NIL) pc -= w;
1288	}	1423	}
1289	break;	1424	break;
1290		1425
@@ -1309,12 +1444,12 @@ static StkId lua_execute (Byte *pc, StkId base) · 18 unmodified lines
1309	{	1444	{
1310	Word line;	1445	Word line;
1311	get_word(line,pc);	1446	get_word(line,pc);
1312	if ((stack+base-1)->tag != LUA_T_LINE)	1447	if ((stack+base-1)->ttype != LUA_T_LINE)
1313	{	1448	{
1314	/* open space for LINE value */	1449	/* open space for LINE value */
1315	open_stack((top-stack)-base);	1450	open_stack((top-stack)-base);
1316	base++;	1451	base++;
1317	(stack+base-1)->tag = LUA_T_LINE;	1452	(stack+base-1)->ttype = LUA_T_LINE;
1318	}	1453	}
1319	(stack+base-1)->value.i = line;	1454	(stack+base-1)->value.i = line;
1320	if (lua_linehook)	1455	if (lua_linehook)
@@ -1328,3 +1463,16 @@ static StkId lua_execute (Byte *pc, StkId base) · 7 unmodified lines
1328	}	1463	}
1329	}	1464	}
1330		1465
		1466
		1467	#if COMPAT2_5
		1468	/*
		1469	** API: set a function as a fallback
		1470	*/
		1471	lua_Object lua_setfallback (char *name, lua_CFunction fallback)
		1472	{
		1473	lua_pushstring(name);
		1474	lua_pushcfunction(fallback);
		1475	do_unprotectedrun(luaI_setfallback, 2, 1);
		1476	return put_luaObjectonTop();
		1477	}
		1478	#endif

src/opcode.h+46−25

@@ -1,6 +1,6 @@
1	/*	1	/*
2	** TeCGraf - PUC-Rio	2	** TeCGraf - PUC-Rio
3	** $Id: opcode.h,v 3.24 1996/11/01 12:46:59 roberto Exp $	3	** $Id: opcode.h,v 3.34 1997/06/16 16:50:22 roberto Exp $
4	*/	4	*/
5		5
6	#ifndef opcode_h	6	#ifndef opcode_h
@@ -14,6 +14,28 @@ · 7 unmodified lines
14		14
15	#define FIELDS_PER_FLUSH 40	15	#define FIELDS_PER_FLUSH 40
16		16
		17	/*
		18	* WARNING: if you change the order of this enumeration,
		19	* grep "ORDER LUA_T"
		20	*/
		21	typedef enum
		22	{
		23	LUA_T_NIL = -9,
		24	LUA_T_NUMBER = -8,
		25	LUA_T_STRING = -7,
		26	LUA_T_ARRAY = -6, /* array==table */
		27	LUA_T_FUNCTION = -5,
		28	LUA_T_CFUNCTION= -4,
		29	LUA_T_MARK = -3,
		30	LUA_T_CMARK = -2,
		31	LUA_T_LINE = -1,
		32	LUA_T_USERDATA = 0
		33	} lua_Type;
		34
		35	#define NUM_TYPES 10
		36
		37
		38	extern char *luaI_typenames[];
17		39
18	typedef enum {	40	typedef enum {
19	/* name parm before after side effect	41	/* name parm before after side effect
@@ -38,7 +60,7 @@ PUSHLOCAL6,/* - LOC[6] */ · 18 unmodified lines
38	PUSHLOCAL7,/* - LOC[7] */	60	PUSHLOCAL7,/* - LOC[7] */
39	PUSHLOCAL8,/* - LOC[8] */	61	PUSHLOCAL8,/* - LOC[8] */
40	PUSHLOCAL9,/* - LOC[9] */	62	PUSHLOCAL9,/* - LOC[9] */
41	PUSHLOCAL,/* w - LOC[w] */	63	PUSHLOCAL,/* b - LOC[b] */
42	PUSHGLOBAL,/* w - VAR[w] */	64	PUSHGLOBAL,/* w - VAR[w] */
43	PUSHINDEXED,/* i t t[i] */	65	PUSHINDEXED,/* i t t[i] */
44	PUSHSELF,/* w t t t[STR[w]] */	66	PUSHSELF,/* w t t t[STR[w]] */
@@ -52,14 +74,14 @@ STORELOCAL6,/* x - LOC[6]=x */ · 7 unmodified lines
52	STORELOCAL7,/* x - LOC[7]=x */	74	STORELOCAL7,/* x - LOC[7]=x */
53	STORELOCAL8,/* x - LOC[8]=x */	75	STORELOCAL8,/* x - LOC[8]=x */
54	STORELOCAL9,/* x - LOC[9]=x */	76	STORELOCAL9,/* x - LOC[9]=x */
55	STORELOCAL,/* w x - LOC[w]=x */	77	STORELOCAL,/* b x - LOC[b]=x */
56	STOREGLOBAL,/* w x - VAR[w]=x */	78	STOREGLOBAL,/* w x - VAR[w]=x */
57	STOREINDEXED0,/* v i t - t[i]=v */	79	STOREINDEXED0,/* v i t - t[i]=v */
58	STOREINDEXED,/* b v a_b...a_1 i t a_b...a_1 i t t[i]=v */	80	STOREINDEXED,/* b v a_b...a_1 i t a_b...a_1 i t t[i]=v */
59	STORELIST0,/* w v_w...v_1 t - t[i]=v_i */	81	STORELIST0,/* b v_b...v_1 t - t[i]=v_i */
60	STORELIST,/* w n v_w...v_1 t - t[i+nFPF]=v_i /	82	STORELIST,/* b c v_b...v_1 t - t[i+cFPF]=v_i /
61	STORERECORD,/* n	83	STORERECORD,/* b
62	w_n...w_1 v_n...v_1 t - t[STR[w_i]]=v_i */	84	w_b...w_1 v_b...v_1 t - t[STR[w_i]]=v_i */
63	ADJUST0,/* - - TOP=BASE */	85	ADJUST0,/* - - TOP=BASE */
64	ADJUST,/* b - - TOP=BASE+b */	86	ADJUST,/* b - - TOP=BASE+b */
65	CREATEARRAY,/* w - newarray(size = w) */	87	CREATEARRAY,/* w - newarray(size = w) */
@@ -76,19 +98,19 @@ POWOP,/* y x x^y */ · 10 unmodified lines
76	CONCOP,/* y x x..y */	98	CONCOP,/* y x x..y */
77	MINUSOP,/* x -x */	99	MINUSOP,/* x -x */
78	NOTOP,/* x (x==nil)? 1 : nil */	100	NOTOP,/* x (x==nil)? 1 : nil */
79	ONTJMP,/* w x - (x!=nil)? PC+=w */	101	ONTJMP,/* w x - (x!=nil)? PC+=w */
80	ONFJMP,/* w x - (x==nil)? PC+=w */	102	ONFJMP,/* w x - (x==nil)? PC+=w */
81	JMP,/* w - - PC+=w */	103	JMP,/* w - - PC+=w */
82	UPJMP,/* w - - PC-=w */	104	UPJMP,/* w - - PC-=w */
83	IFFJMP,/* w x - (x==nil)? PC+=w */	105	IFFJMP,/* w x - (x==nil)? PC+=w */
84	IFFUPJMP,/* w x - (x==nil)? PC-=w */	106	IFFUPJMP,/* w x - (x==nil)? PC-=w */
85	POP,/* x - */	107	POP,/* x - */
86	CALLFUNC,/* n m v_n...v_1 f r_m...r_1 f(v1,...,v_n) */	108	CALLFUNC,/* b c v_b...v_1 f r_c...r_1 f(v1,...,v_b) */
87	RETCODE0,	109	RETCODE0,
88	RETCODE,/* b - - */	110	RETCODE,/* b - - */
89	SETLINE,/* w - - LINE=w */	111	SETLINE,/* w - - LINE=w */
90	VARARGS/* b v_n...v_1 {v_1...v_n;n=n} */	112	VARARGS,/* b v_b...v_1 {v_1...v_b;n=b} */
91		113	STOREMAP/* b v_b k_b ...v_1 k_1 t - t[k_i]=v_i */
92	} OpCode;	114	} OpCode;
93		115
94		116
@@ -102,29 +124,27 @@ typedef union · 7 unmodified lines
102	TaggedString *ts;	124	TaggedString *ts;
103	TFunc *tf;	125	TFunc *tf;
104	struct Hash *a;	126	struct Hash *a;
105	void *u;
106	int i;	127	int i;
107	} Value;	128	} Value;
108		129
109	typedef struct Object	130	typedef struct TObject
110	{	131	{
111	lua_Type tag;	132	lua_Type ttype;
112	Value value;	133	Value value;
113	} Object;	134	} TObject;
114		135
115		136
116	/* Macros to access structure members */	137	/* Macros to access structure members */
117	#define tag(o) ((o)->tag)	138	#define ttype(o) ((o)->ttype)
118	#define nvalue(o) ((o)->value.n)	139	#define nvalue(o) ((o)->value.n)
119	#define svalue(o) ((o)->value.ts->str)	140	#define svalue(o) ((o)->value.ts->str)
120	#define tsvalue(o) ((o)->value.ts)	141	#define tsvalue(o) ((o)->value.ts)
121	#define avalue(o) ((o)->value.a)	142	#define avalue(o) ((o)->value.a)
122	#define fvalue(o) ((o)->value.f)	143	#define fvalue(o) ((o)->value.f)
123	#define uvalue(o) ((o)->value.u)
124		144
125	/* Macros to access symbol table */	145	/* Macros to access symbol table */
126	#define s_object(i) (lua_table[i].object)	146	#define s_object(i) (lua_table[i].object)
127	#define s_tag(i) (tag(&s_object(i)))	147	#define s_ttype(i) (ttype(&s_object(i)))
128	#define s_nvalue(i) (nvalue(&s_object(i)))	148	#define s_nvalue(i) (nvalue(&s_object(i)))
129	#define s_svalue(i) (svalue(&s_object(i)))	149	#define s_svalue(i) (svalue(&s_object(i)))
130	#define s_tsvalue(i) (tsvalue(&s_object(i)))	150	#define s_tsvalue(i) (tsvalue(&s_object(i)))
@@ -141,10 +161,11 @@ typedef struct Object · 10 unmodified lines
141	/* Exported functions */	161	/* Exported functions */
142	void lua_parse (TFunc tf); / from "lua.stx" module */	162	void lua_parse (TFunc tf); / from "lua.stx" module */
143	void luaI_codedebugline (int line); /* from "lua.stx" module */	163	void luaI_codedebugline (int line); /* from "lua.stx" module */
144	void lua_travstack (int (fn)(Object ));	164	void lua_travstack (int (fn)(TObject ));
145	Object *luaI_Address (lua_Object o);	165	TObject *luaI_Address (lua_Object o);
146	void luaI_pushobject (Object *o);	166	void luaI_pushobject (TObject *o);
147	void luaI_gcFB (Object *o);	167	void luaI_gcIM (TObject *o);
148	int luaI_dorun (TFunc *tf);	168	int luaI_dorun (TFunc *tf);
		169	int lua_domain (void);
149		170
150	#endif	171	#endif

src/parser.c+344−316

 #define YYPREFIX "luaY_"
 #line 2 "lua.stx"
-char *rcs_luastx = "$Id: parser.c,v 1.1 1996/11/21 16:11:40 lhf Exp $";
+char *rcs_luastx = "$Id: parser.c,v 1.1 1997/06/30 18:59:03 lhf Exp $";
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "luadebug.h"
-#include "mem.h"
+#include "luamem.h"
 #include "lex.h"
 #include "opcode.h"
 #include "hash.h"
 static int     nlocalvar=0;	     /* number of local variables */
 #define MAXFIELDS FIELDS_PER_FLUSH*2
-static Word    fields[MAXFIELDS];     /* fieldnames to be flushed */
-static int     nfields=0;
 int lua_debug = 0;
   memcpy(p, &w, sizeof(Word));
 }
-static void push_field (Word name)
-{
-  if (nfields < MAXFIELDS)
-    fields[nfields++] = name;
-  else
-   luaY_error ("too many fields in nested constructors");
-}
 static void flush_record (int n)
 {
-  int i;
   if (n == 0) return;
-  code_byte(STORERECORD);
+  code_byte(STOREMAP);
   code_byte(n);
-  for (i=0; i<n; i++)
-    code_word(fields[--nfields]);
 }
 static void flush_list (int m, int n)
   luaY_error ("variable buffer overflow");
 }
+static void code_string (Word w)
+{
+  code_byte(PUSHSTRING);
+  code_word(w);
+}
+static void code_constant (TaggedString *s)
+{
+  code_string(luaI_findconstant(s));
+}
 static void code_number (float f)
 {
-  Word i = (Word)f;
+  Word i;
-  if (f == (float)i)  /* f has an (short) integer value */
+  if (f >= 0 && f <= (float)MAX_WORD && (float)(i=(Word)f) == f) {
-  {
+   /* f has an (short) integer value */
    if (i <= 2) code_byte(PUSH0 + i);
    else if (i <= 255)
    {
 }
-#line 414 "lua.stx"
+#line 412 "lua.stx"
 typedef union
 {
  int   vInt;
  TFunc *pFunc;
  TaggedString *pTStr;
 } YYSTYPE;
-#line 433 "y.tab.c"
+#line 431 "y.tab.c"
 #define WRONGTOKEN 257
 #define NIL 258
 #define IF 259
    38,    5,   39,    5,   40,   37,    4,    8,    8,    7,
     7,    2,    2,    3,   41,    3,   17,   17,   18,   18,
    19,   19,   42,    9,    9,   14,   14,   43,   43,   12,
-   12,   13,   13,   44,   15,   15,   16,   16,    6,    6,
+   12,   13,   13,   44,   45,   45,   15,   15,   16,   16,
-   20,   20,   20,   21,   29,   10,   10,   11,   11,
+    6,    6,   20,   20,   20,   21,   29,   10,   10,   11,
+   11,
 };
 short luaY_len[] = {                                         2,
     2,    0,    3,    2,    3,    1,    3,    5,    0,    3,
     0,    5,    0,    5,    0,    4,    2,    1,    3,    3,
     1,    0,    1,    1,    0,    4,    0,    1,    1,    3,
     1,    1,    0,    3,    2,    0,    2,    0,    1,    0,
-    2,    1,    3,    3,    0,    2,    1,    3,    1,    3,
+    2,    1,    3,    3,    3,    1,    0,    2,    1,    3,
-    1,    4,    3,    1,    1,    1,    3,    0,    2,
+    1,    3,    1,    4,    3,    1,    1,    1,    3,    0,
+    2,
 };
 short luaY_defred[] = {                                      2,
-    0,    0,    0,   14,   16,    0,    0,    0,   94,   19,
+    0,    0,    0,   14,   16,    0,    0,    0,   96,   19,
-    0,    0,    0,   91,    1,    0,    4,    0,   48,   46,
+    0,    0,    0,   93,    1,    0,    4,    0,   48,   46,
-   47,    0,    0,    0,   49,   29,   95,    0,    0,   44,
+   47,    0,    0,    0,   49,   29,   97,    0,    0,   44,
-    0,    0,   24,    0,    0,    0,    0,   96,    0,    0,
+    0,    0,   24,    0,    0,    0,    0,   98,    0,    0,
     0,    0,    0,    0,    0,   57,   61,   12,    3,    0,
     0,    0,    0,    0,    0,   28,   28,   28,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    9,   27,   65,    0,    0,   20,    0,
-    5,    0,    0,    0,    0,    0,   59,    0,   93,   30,
+    5,    0,    0,    0,    0,    0,   59,    0,   95,   30,
    24,   51,   53,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,   73,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   73,
-    0,   82,   28,    0,    0,    0,    0,   97,   72,   71,
+    0,    0,   82,    0,   28,    0,    0,    0,    0,   99,
-    0,    0,   69,    7,   60,   92,   28,    0,    0,    0,
+   72,   71,    0,    0,   69,    7,   60,   94,   28,    0,
-   56,    0,   75,    0,    0,   86,   24,    0,   25,    0,
+    0,    0,   56,    0,   75,    0,    0,   88,    0,   24,
-    0,   24,    0,    0,    0,    0,    0,    0,   83,    0,
+    0,   25,    0,    0,   24,    0,    0,    0,    0,   85,
-   74,    0,   28,   17,   10,    0,   70,   24,    0,    0,
+   86,   83,    0,   74,    0,    0,   28,   17,   10,    0,
-   77,    0,    0,    8,   22,    0,   13,   81,   15,   28,
+   70,   24,    0,    0,   77,    0,    0,    8,   22,    0,
-   24,   28,    0,   23,
+   13,   81,   15,   28,   24,   28,    0,   23,
 };
 short luaY_dgoto[] = {                                       1,
-   91,   34,   35,   25,   26,   11,   46,   12,  107,   39,
+   91,   34,   35,   25,   26,   11,   46,   12,  108,   39,
-   79,  161,  108,  151,  109,  110,  121,  122,  123,   27,
+   79,  165,  109,  154,  110,  111,  123,  124,  125,   27,
    14,   41,   81,    2,   15,   16,   49,   17,   28,   73,
-  115,   37,  160,   32,   33,   74,   30,  128,  129,   31,
+  117,   37,  164,   32,   33,   74,   30,  130,  131,   31,
-  116,  134,  133,  112,
+  118,  136,  135,  113,  114,
 };
 short luaY_sindex[] = {                                      0,
-    0,  332,  -38,    0,    0,  -38, -239, -223,    0,    0,
+    0,  288,  -34,    0,    0,  -34, -238, -223,    0,    0,
-  -23,   17,    0,    0,    0,    3,    0,  137,    0,    0,
+   -6,   22,    0,    0,    0,   14,    0,  150,    0,    0,
-    0,  -38,  -38,  -38,    0,    0,    0,  137,  547,    0,
+    0,  -34,  -34,  -34,    0,    0,    0,  150,  547,    0,
-  -25,  -38,    0,    3,   45,    0,  212,    0,  -22,    0,
+  -46,  -34,    0,   14,   34,    0,  212,    0,   -5,    0,
-   52,  140,  -38, -223,  -38,    0,    0,    0,    0, -166,
+   39,  156,  -34, -223,  -34,    0,    0,    0,    0, -194,
-  -38, -154,   40,   40,  102,    0,    0,    0,  -38,  -38,
+  -34, -193,   -4,   -4,   48,    0,    0,    0,  -34,  -34,
-  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
+  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
-  -34,  481, -130,    0,    0,    0,  -38, -129,    0, -194,
+  -38,  481, -173,    0,    0,    0,  -34, -146,    0, -234,
-    0, -123,   45,    0,  -17,  103,    0,  753,    0,    0,
+    0, -138,   34,    0,  -15,   96,    0,  753,    0,    0,
-    0,    0,    0,  -30,  -30,  -30,  -30,  -30,  -30,   95,
+    0,    0,    0,  -30,  -30,  -30,  -30,  -30,  -30,  -20,
-   11,   11,   40,   40,   40,   97,   41,  123,    0,  124,
+  -12,  -12,   -4,   -4,   -4,    0,  -34,   16,   95,    0,
-  212,    0,    0,  -38,  -59,  -38,   45,    0,    0,    0,
+   98,  212,    0,   82,    0,  -34,  328,  -34,   34,    0,
-  128,  131,    0,    0,    0,    0,    0,  -38,  -38,  -38,
+    0,    0,  103,  101,    0,    0,    0,    0,    0,  -34,
-    0,  -97,    0,  120,  -38,    0,    0,  212,    0,    3,
+  -34, 1181,    0,  -91,    0,   92,  -34,    0,  -34,    0,
-    0,    0, -194, -183,  118,  118,  212,   97,    0,  -97,
+  212,    0,   14,    0,    0, -234, -233,  118,  118,    0,
-    0,  212,    0,    0,    0,  -85,    0,    0,  -38,  -82,
+    0,    0,  -91,    0,  212,  212,    0,    0,    0, -105,
-    0,  123,  -80,    0,    0, 1105,    0,    0,    0,    0,
+    0,    0,  -34, -103,    0,   95, -101,    0,    0, 1105,
-    0,    0, -183,    0,
+    0,    0,    0,    0,    0,    0, -233,    0,
 };
 short luaY_rindex[] = {                                      0,
-    0,  191,   69,    0,    0,  173,    0,    0,    0,    0,
+    0,  169,   52,    0,    0,  173,    0,    0,    0,    0,
-    0,   69,  150,    0,    0,  146,    0,  -36,    0,    0,
+    0,   52,  508,    0,    0,  146,    0,  -36,    0,    0,
-    0,   69,   69,   69,    0,    0,    0,    1,    0,    0,
+    0,   52,   52,   52,    0,    0,    0,    1,    0,    0,
-    0,   69,    0,   47,  461,  436,    0,    0,  197,  130,
+    0,   52,    0,   47,  461,  436,    0,    0,  197,   76,
-    0,    0,   69,    0,  -33,    0,    0,    0,    0,    0,
+    0,    0,   52,    0,  -32,    0,    0,    0,    0,    0,
-   69,    0,   24,   59, 1181,    0,    0,    0,   69,   69,
+   52,    0,   24,   59, 1195,    0,    0,    0,   52,   52,
-   69,   69,   69,   69,   69,   69,   69,   69,   69,   69,
+   52,   52,   52,   52,   52,   52,   52,   52,   52,   52,
-  -50,    0,    0,    0,    0,    0,   69,    0,    0,  152,
+  -27,    0,    0,    0,    0,    0,   52,    0,    0,  129,
-    0,    0,  311,  -21,    0,    0,    0,    0,    0,    0,
+    0,    0,  311,  142,    0,    0,    0,    0,    0,    0,
     0,    0,    0,  746,  776,  799,  821,  844,  866,  505,
-  383,  410,   88,  112,  359, 1174,    0,   74,    0,  -40,
+  383,  410,   88,  112,  359, 1174,   52,    0,   51,    0,
-  -26,    0,    0,   69, -230,   69,  921,    0,    0,    0,
+  -40,  -10,    0,    0,    0,   52, -153,   52,  921,    0,
-    0,  160,    0,    0,    0,    0,    0,   69,   69,   69,
+    0,    0,    0,  144,    0,    0,    0,    0,    0,   52,
-    0,   77,    0,   78,   -9,    0,    0,  939,    0,  289,
+   52,    0,    0,   62,    0,   64,  -26,    0,   52,    0,
-  474,    0,    0,  -60,  894, 1137,  -16,    0,    0,   89,
+  939,    0,  682,  474,    0,    0,  -77,  894, 1137,    0,
-    0,  -10,    0,    0,    0,    0,    0,    0,   69,    0,
+    0,    0,   66,    0,   13,  -18,    0,    0,    0,    0,
-    0,   74,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,   52,    0,    0,   51,    0,    0,    0,    0,
-    0,    0,  -60,    0,
+    0,    0,    0,    0,    0,    0,  -77,    0,
 };
 short luaY_gindex[] = {                                      0,
-  -31,  171,   85,   -2,   48,    0,    0,    0,    0,    0,
+   53,  147,  -23,    3,  134,    0,    0,    0,    0,    0,
-    0,    0,   67,    0,    0,    0,    0,    0,   75,    8,
+    0,    0,   40,    0,    0,    0,    0,    0,   49,    6,
-    0,    0,    0,    0,  104,  107,  -29,    0,   12,  -61,
+    0,    0,    0,    0,   81,   83,  -16,    0,    8,  -70,
-    0, 1260,   50,    0,    0,    0,  213,    0,    0,    0,
+    0, 1445,   27,    0,    0,    0,  187,    0,    0,    0,
-    0,    0, -107,   94,
+    0,    0, -108,   67,    0,
 };
-#define YYTABLESIZE 1462
+#define YYTABLESIZE 1608
-short luaY_table[] = {                                      10,
+short luaY_table[] = {                                     107,
-   45,   24,  136,   58,   75,   24,   22,   62,   85,   13,
+   45,   24,  138,   58,   10,   24,   22,   13,   62,   18,
-   22,   68,   66,   18,   67,   40,   69,   87,   78,   42,
+   22,   68,   66,   40,   67,   42,   69,   75,   78,   83,
-   44,   78,   90,   43,   95,   92,   93,   84,   52,  127,
+  129,   68,   66,   43,   67,   84,   69,  162,  163,   68,
-   26,   26,   87,   88,   38,   26,   26,   43,   77,   90,
+   52,   87,   79,   89,   69,   38,  121,   44,   78,  122,
-   58,   45,   45,   45,   45,   45,   11,   45,   88,   79,
+   58,   45,   45,   45,   45,   45,   11,   45,   89,   84,
-    9,   84,   68,   36,  168,   85,   45,   69,   50,   45,
+    9,   85,  107,  119,   43,   77,   90,  172,   50,   45,
-   45,   48,   45,   70,   43,   43,   43,   43,   43,   95,
+   45,   45,   45,   70,   43,   43,   43,   43,   43,  157,
-   43,   55,   55,   51,   85,  153,  119,  158,  159,  120,
+   43,   90,   48,   70,  160,   51,   71,   76,   80,   87,
-  156,  137,   43,   43,   78,   43,   58,   39,   76,   55,
+   89,   70,   43,   43,   78,   43,   58,   39,   90,   70,
-   36,   80,   36,   45,   45,  144,  165,   71,   87,   50,
+   55,  169,  116,   45,   45,   55,   55,   87,   79,   50,
-   50,   50,   50,   50,   70,   50,  154,   87,   84,  172,
+   50,   50,   50,   50,  176,   50,   84,   26,   26,   92,
-  155,   40,   10,   55,   88,   79,   43,   50,   50,   89,
+   93,   40,   26,   26,   89,    6,   43,   50,   50,   10,
-   50,  163,   13,   58,   36,   45,   18,   83,   39,   39,
+   50,   97,   13,   58,   18,   45,  159,  120,   39,   39,
-   39,   39,   39,   70,   39,  114,   68,   66,  171,   67,
+   39,   39,   39,   97,   39,  126,  127,   90,  134,   36,
-  173,   69,   90,  125,  118,   11,   39,   39,   43,   39,
+  133,  137,  139,  145,  146,   11,   39,   39,   43,   39,
-  124,   50,   40,   40,   40,   40,   40,  130,   40,   68,
+  153,   50,   40,   40,   40,   40,   40,   55,   40,   68,
-   66,  117,   67,  141,   69,  131,  132,  135,  142,    6,
+   66,  168,   67,  171,   69,  173,   97,  140,   26,   67,
-   40,   40,   62,   40,  143,   95,  148,   62,  150,   61,
+   40,   40,   62,   40,   55,   78,   36,   62,   36,   61,
-   39,  164,   52,   50,  167,   52,  169,   95,   70,   95,
+   39,  147,  151,   50,   68,   92,   79,   97,   76,   21,
-   26,   55,   67,   89,   50,   95,   98,   82,   78,    3,
+   80,   86,  166,  158,  161,   52,  100,  142,   47,  143,
-   68,   79,   76,    4,   40,    5,   21,   95,    6,    7,
+  152,   52,   92,  178,   40,    0,    0,   50,    0,  167,
-   89,   70,   39,   80,    9,   86,  162,  157,  139,   19,
+   36,   70,   39,   82,    0,    0,    0,    0,    0,   19,
-   95,  140,  174,   19,   47,  149,    0,   51,    0,    0,
+    0,    0,    0,   19,    0,    0,  175,    0,  177,    0,
-   51,   62,    0,   20,   21,    9,   40,   20,   21,  106,
+    0,   62,   97,   20,   21,  106,   40,   20,   21,    9,
-   95,    0,    0,    0,   23,    0,    0,    0,   23,    0,
+   51,    0,    0,    0,   23,    0,   51,    0,   23,    0,
-   65,    0,    0,   68,   66,   98,   67,    0,   69,   45,
+   65,  144,    0,   68,   66,  100,   67,    0,   69,   45,
    45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
-   45,   62,   95,   61,   45,   45,   45,   45,   45,   45,
+   45,   62,    0,   61,   45,   45,   45,   45,   45,   45,
    45,   45,   43,   43,   43,   43,   43,   43,   43,   43,
    43,   43,   43,   43,    0,   55,    0,   43,   43,   43,
    43,   43,   43,   43,   43,   70,    0,   11,   11,    0,
    41,    0,    0,   37,    0,   37,   37,   37,    0,    0,
     0,    0,    0,   62,   62,   64,    0,    0,   62,   62,
     0,   37,   37,    0,   37,    0,    0,    0,    0,    0,
-   38,   41,   38,   38,   38,   98,    0,   98,   98,   98,
+   38,   41,   38,   38,   38,  100,    0,  100,  100,  100,
-   63,   98,   98,   98,   98,   98,   98,    0,   38,   38,
+   63,  100,  100,  100,  100,  100,  100,    0,   38,   38,
-   98,   38,    0,   66,    0,   37,   64,   29,   29,   64,
+  100,   38,    0,   66,    0,   37,   64,   29,   29,   64,
    29,    0,   29,   41,    0,    0,   57,   58,   59,   60,
    63,   64,   65,    0,   64,   29,    0,   29,    0,    0,
     0,   63,   38,    0,   42,    0,    0,   37,    0,    0,
     0,    0,    0,    0,   66,   29,   29,   66,   29,   63,
    29,    0,   68,   66,    0,   67,    0,   69,    0,   29,
     0,    0,   66,   29,   38,   29,    0,    0,    0,    0,
-   62,    0,   61,    0,    0,   42,    0,   11,   42,   11,
+   62,    0,   61,    0,    0,   42,    3,   97,   42,    0,
-   11,   11,    0,   11,   11,   11,   11,   11,    0,    0,
+    4,   91,    5,   97,    0,    6,    7,    8,    0,    0,
-    0,    0,   11,   42,   42,    0,   42,   29,    0,   18,
+    0,    9,    0,   42,   42,   97,   42,   29,   91,   18,
     0,   18,   18,   18,   70,   18,   18,   18,   18,   18,
-   18,    0,    0,    0,   18,    0,    0,    0,   68,   66,
+   18,    0,    0,    0,   18,    0,    3,    0,   68,   66,
-    3,   67,    0,   69,    4,    0,    5,   42,    0,    6,
+    4,   67,    5,   69,    0,    6,    7,   42,   97,    0,
-    7,    8,    0,    0,    0,    9,   62,    0,   61,    0,
+    0,    9,    0,    0,    0,    0,   62,    0,   61,    0,
     0,    0,    0,    0,    0,    0,    0,   41,   41,   41,
    41,   41,   41,   41,   41,   41,   41,   41,   41,   42,
-    0,    0,   41,   41,   41,   41,   41,   41,   41,   41,
+   97,    0,   41,   41,   41,   41,   41,   41,   41,   41,
    70,   37,   37,   37,   37,   37,   37,   37,   37,   37,
    37,   37,   37,    0,    0,    0,   37,   37,   37,   37,
    37,   37,   37,   37,    0,    0,    0,    0,   38,   38,
    29,   29,   29,   29,   29,   29,   29,    0,    0,    0,
     0,   63,   63,    0,    0,    0,   63,   63,    0,    0,
     0,    0,   66,    0,   66,   66,   66,    0,   66,   66,
-   66,   66,   66,   66,  113,   31,    0,   66,   29,   29,
+   66,   66,   66,   66,  115,   31,    0,   66,   29,   29,
    29,   29,   29,   29,   29,   57,   58,   59,   60,   63,
    64,   65,    0,   42,   42,   42,   42,   42,   42,   42,
    42,   42,   42,   42,   42,   34,    0,    0,   42,   42,
     0,    0,   62,    0,   61,    0,   34,    0,    0,   34,
    32,   57,   58,   59,   60,   63,   64,   65,    0,    0,
     0,    0,    0,    0,   34,   34,    0,   34,   31,   33,
-    0,    0,   33,   35,    0,  126,   70,    0,    0,    0,
+    0,    0,   33,   35,    0,  128,   70,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,   33,   33,    0,
    33,   32,    0,    0,   32,   36,    0,    0,   34,    0,
    31,    0,    0,    0,    0,    0,    0,    0,    0,   32,
     0,   33,    0,   52,    0,    0,    0,    0,    0,    0,
    34,    0,   35,   35,    0,   35,   36,    0,    0,   36,
     0,    0,    0,   32,    0,    0,    0,    0,    0,    0,
-   99,    0,    0,   33,   36,   36,    0,   36,    0,    0,
+  101,    0,    0,   33,   36,   36,    0,   36,    0,    0,
     0,    0,    0,    0,   52,    0,   35,   52,   28,    0,
-    0,    0,    0,    0,    0,   32,    0,    0,    0,    0,
+   11,    0,   11,   11,   11,   32,   11,   11,   11,   11,
-    0,    0,   52,    0,    0,    0,    0,    0,   36,    0,
+   11,    0,   52,    0,    0,   11,    0,    0,   36,    0,
     0,    0,    0,    0,    0,    0,    0,    0,   35,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,   99,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,  101,
     0,    0,    0,    0,    0,    0,   52,    0,    0,    0,
    36,    0,    0,    0,    0,    0,    0,   28,    0,    0,
     0,    0,    0,    0,   31,   31,   31,   31,   31,   31,
    36,   36,   36,   36,   36,   36,   68,   66,    0,   67,
     0,   69,   52,   52,   52,   52,   52,   52,   52,   52,
    52,   52,   52,   52,   62,    0,   61,   52,   52,   52,
-    0,    0,    0,    0,    0,    0,    0,   54,    0,   99,
+    0,    0,    0,    0,    0,    0,    0,   54,    0,  101,
-   54,   99,   99,   99,    0,   99,   99,   99,   99,   99,
+   54,  101,  101,  101,    0,  101,  101,  101,  101,  101,
-   99,    0,    0,    0,   99,   54,    0,   28,   70,   28,
+  101,    0,    0,    0,  101,   54,    0,   28,   70,   28,
    28,   28,    0,   28,   28,   28,   28,   28,   28,    0,
-    0,    0,   28,   94,    0,   94,   94,   94,   94,   94,
+    0,    0,   28,   96,    0,   96,   96,   96,   96,   96,
-   94,    0,   29,   29,    0,   29,    0,   29,    0,   54,
+   96,    0,   68,   66,    0,   67,    0,   69,    0,   54,
-    0,   94,   94,   94,    0,   94,    0,    0,    0,    0,
+    0,   96,   96,   96,   86,   96,   29,   29,    0,   29,
-   29,    0,   29,    0,    0,    0,    0,    0,    0,    0,
+   62,   29,   61,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,   29,    0,   29,    0,    0,    0,
+    0,   54,    0,    0,   96,    0,    0,   96,    0,    0,
+    0,    0,    0,  150,   70,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,   29,    0,
+    0,    0,    0,    0,    0,    0,   96,    0,   96,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   54,   29,    0,   94,    0,    0,   94,    0,    0,
-    0,    0,    0,    0,   29,    0,    0,    0,    0,    0,
-    0,   53,   54,    0,    0,    0,    0,    0,    0,    0,
-    0,   72,    0,    0,    0,    0,   94,    0,   94,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   88,    0,    0,    0,    0,    0,    0,    0,   94,   95,
-   96,   97,   98,   99,  100,  101,  102,  103,  104,  105,
-  111,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  170,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  138,    0,    0,    0,    0,    0,   57,
+    0,    0,    0,    0,  174,    0,    0,    0,    0,    0,
-   58,   59,   60,   63,   64,   65,    0,  145,  146,  147,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   57,
-    0,    0,    0,    0,  152,   54,   54,   54,   54,   54,
+   58,   59,   60,   63,   64,   65,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   54,   54,   54,   54,   54,
    54,   54,   54,   54,   54,   54,   54,    0,    0,    0,
-   54,   54,   54,    0,    0,    0,    0,    0,  166,    0,
+   54,   54,   54,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   29,   96,   96,
+   96,   96,   96,   96,   96,   57,   58,   59,   60,   63,
+   64,   65,    0,    0,    0,    0,   53,   54,    0,   29,
+   29,   29,   29,   29,   29,   29,   72,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   88,    0,    0,    0,    0,
+    0,    0,    0,   94,   95,   96,   97,   98,   99,  100,
+  101,  102,  103,  104,  105,  112,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,   94,   94,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   94,   94,   94,   94,   94,   29,   29,   29,   29,   29,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   29,   29,
+    0,  132,    0,    0,    0,    0,    0,    0,    0,    0,
+  141,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,  148,  149,    0,    0,    0,    0,
+    0,  155,    0,  156,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  170,
 };
-short luaY_check[] = {                                       2,
+short luaY_check[] = {                                      91,
-    0,   40,  110,   40,   34,   40,   45,   41,   59,    2,
+    0,   40,  111,   40,    2,   40,   45,    2,   41,    2,
-   45,   42,   43,    2,   45,    8,   47,   44,   59,    8,
+   45,   42,   43,    8,   45,    8,   47,   34,   59,   43,
-   44,   44,   44,    0,   46,   57,   58,   44,   46,   91,
+   91,   42,   43,    0,   45,   44,   47,  261,  262,   42,
-  261,  262,   59,   44,  274,  266,  267,   61,   61,   61,
+   46,   59,   59,   44,   47,  274,  271,   44,   44,  274,
-   40,   41,   42,   43,   44,   45,    0,   47,   59,   59,
+   40,   41,   42,   43,   44,   45,    0,   47,   59,   44,
-  274,   44,   42,    6,  162,   44,   40,   47,    0,   59,
+  274,   44,   91,   77,   61,   61,   44,  166,    0,   59,
-   60,   59,   62,   94,   41,   42,   43,   44,   45,   91,
+   60,   40,   62,   94,   41,   42,   43,   44,   45,  140,
-   47,   24,  123,   91,  125,  137,  271,  261,  262,  274,
+   47,   59,   59,   94,  145,   91,  123,   44,   40,  274,
-  142,  113,   59,   60,  125,   62,  123,    0,   44,  123,
+  274,   94,   59,   60,  125,   62,  123,    0,   41,   94,
-   43,   40,   45,   93,   94,  127,  158,  123,  125,   41,
+  123,  162,  266,   93,   94,  123,  123,  125,  125,   41,
-   42,   43,   44,   45,   94,   47,  138,  274,  125,  171,
+   42,   43,   44,   45,  175,   47,  125,  261,  262,   57,
-  140,    0,  115,  123,  125,  125,   93,   59,   60,  274,
+   58,    0,  266,  267,  125,   40,   93,   59,   60,  117,
-   62,  153,  115,  123,   77,  125,  115,   43,   41,   42,
+   62,   46,  117,  123,  117,  125,  143,  274,   41,   42,
-   43,   44,   45,   94,   47,  266,   42,   43,  170,   45,
+   43,   44,   45,   58,   47,  274,   41,  125,   44,    6,
-  172,   47,   41,   41,  274,    0,   59,   60,  125,   62,
+  125,   44,   61,   41,   44,    0,   59,   60,  125,   62,
-  274,   93,   41,   42,   43,   44,   45,   61,   47,   42,
+   59,   93,   41,   42,   43,   44,   45,   24,   47,   42,
-   43,   77,   45,  116,   47,  125,   44,   44,   41,   40,
+   43,  267,   45,  267,   47,  267,   91,  115,    0,   41,
-   59,   60,    0,   62,   44,   46,  274,   60,   59,   62,
+   59,   60,    0,   62,  123,  125,   43,   60,   45,   62,
-   93,  267,   46,  125,  267,   46,  267,   58,   94,   40,
+   93,  129,  274,  125,   41,   44,  125,   46,  125,  267,
-    0,  123,   41,   44,   58,   46,    0,   58,  125,  259,
+  125,   45,  153,  141,  146,   46,    0,  117,   12,  117,
-   41,  125,  125,  263,   93,  265,  267,   58,  268,  269,
+  134,   46,   61,  177,   93,   -1,   -1,   58,   -1,  157,
-   61,   94,  125,  125,  274,   45,  150,  143,  115,  258,
+   77,   94,  125,   58,   -1,   -1,   -1,   -1,   -1,  258,
-   91,  115,  173,  258,   12,  132,   -1,   91,   -1,   -1,
+   -1,   -1,   -1,  258,   -1,   -1,  174,   -1,  176,   -1,
-   91,   59,   -1,  272,  273,  274,  125,  272,  273,  274,
+   -1,   59,   91,  272,  273,  274,  125,  272,  273,  274,
-   91,   -1,   -1,   -1,  283,   -1,   -1,   -1,  283,   -1,
+   91,   -1,   -1,   -1,  283,   -1,   91,   -1,  283,   -1,
-  281,   -1,   -1,   42,   43,   59,   45,   -1,   47,  259,
+  281,  118,   -1,   42,   43,   59,   45,   -1,   47,  259,
   260,  261,  262,  263,  264,  265,  266,  267,  268,  269,
-  270,   60,  123,   62,  274,  275,  276,  277,  278,  279,
+  270,   60,   -1,   62,  274,  275,  276,  277,  278,  279,
   280,  281,  259,  260,  261,  262,  263,  264,  265,  266,
   267,  268,  269,  270,   -1,  123,   -1,  274,  275,  276,
   277,  278,  279,  280,  281,   94,   -1,  261,  262,   -1,
    -1,   -1,   -1,   -1,   41,   42,   43,   44,   45,   59,
    47,   -1,   42,   43,   -1,   45,   -1,   47,   -1,   94,
    -1,   -1,   59,   60,  125,   62,   -1,   -1,   -1,   -1,
-   60,   -1,   62,   -1,   -1,   41,   -1,  259,   44,  261,
+   60,   -1,   62,   -1,   -1,   41,  259,   40,   44,   -1,
-  262,  263,   -1,  265,  266,  267,  268,  269,   -1,   -1,
+  263,   44,  265,   46,   -1,  268,  269,  270,   -1,   -1,
-   -1,   -1,  274,   59,   60,   -1,   62,   94,   -1,  259,
+   -1,  274,   -1,   59,   60,   58,   62,   94,   61,  259,
    -1,  261,  262,  263,   94,  265,  266,  267,  268,  269,
-  270,   -1,   -1,   -1,  274,   -1,   -1,   -1,   42,   43,
+  270,   -1,   -1,   -1,  274,   -1,  259,   -1,   42,   43,
-  259,   45,   -1,   47,  263,   -1,  265,   93,   -1,  268,
+  263,   45,  265,   47,   -1,  268,  269,   93,   91,   -1,
-  269,  270,   -1,   -1,   -1,  274,   60,   -1,   62,   -1,
+   -1,  274,   -1,   -1,   -1,   -1,   60,   -1,   62,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,  259,  260,  261,
   262,  263,  264,  265,  266,  267,  268,  269,  270,  125,
-   -1,   -1,  274,  275,  276,  277,  278,  279,  280,  281,
+  123,   -1,  274,  275,  276,  277,  278,  279,  280,  281,
    94,  259,  260,  261,  262,  263,  264,  265,  266,  267,
   268,  269,  270,   -1,   -1,   -1,  274,  275,  276,  277,
   278,  279,  280,  281,   -1,   -1,   -1,   -1,  259,  260,
    -1,   -1,   -1,   93,   -1,   -1,   -1,   -1,   -1,   -1,
     0,   -1,   -1,  125,   59,   60,   -1,   62,   -1,   -1,
    -1,   -1,   -1,   -1,   41,   -1,   93,   44,    0,   -1,
-   -1,   -1,   -1,   -1,   -1,  125,   -1,   -1,   -1,   -1,
+  259,   -1,  261,  262,  263,  125,  265,  266,  267,  268,
-   -1,   -1,   59,   -1,   -1,   -1,   -1,   -1,   93,   -1,
+  269,   -1,   59,   -1,   -1,  274,   -1,   -1,   93,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  125,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   59,
    -1,   -1,   -1,   -1,   -1,   -1,   93,   -1,   -1,   -1,
   262,  263,   -1,  265,  266,  267,  268,  269,  270,   -1,
    -1,   -1,  274,   40,   -1,   42,   43,   44,   45,   46,
    47,   -1,   42,   43,   -1,   45,   -1,   47,   -1,   93,
-   -1,   58,   59,   60,   -1,   62,   -1,   -1,   -1,   -1,
+   -1,   58,   59,   60,   61,   62,   42,   43,   -1,   45,
-   60,   -1,   62,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   60,   47,   62,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   60,   -1,   62,   -1,   -1,   -1,
+   -1,  125,   -1,   -1,   91,   -1,   -1,   94,   -1,   -1,
+   -1,   -1,   -1,   93,   94,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   94,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  123,   -1,  125,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  125,    3,   -1,   91,   -1,   -1,   94,   -1,   -1,
-   -1,   -1,   -1,   -1,   94,   -1,   -1,   -1,   -1,   -1,
-   -1,   22,   23,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   32,   -1,   -1,   -1,   -1,  123,   -1,  125,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   51,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   59,   60,
-   61,   62,   63,   64,   65,   66,   67,   68,   69,   70,
-   71,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,  260,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  114,   -1,   -1,   -1,   -1,   -1,  275,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  275,
-  276,  277,  278,  279,  280,  281,   -1,  128,  129,  130,
+  276,  277,  278,  279,  280,  281,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  135,  259,  260,  261,  262,  263,
+   -1,   -1,   -1,   -1,   -1,  259,  260,  261,  262,  263,
   264,  265,  266,  267,  268,  269,  270,   -1,   -1,   -1,
-  274,  275,  276,   -1,   -1,   -1,   -1,   -1,  159,   -1,
+  274,  275,  276,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  275,  276,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,    3,  275,  276,
   277,  278,  279,  280,  281,  275,  276,  277,  278,  279,
-  280,  281,
+  280,  281,   -1,   -1,   -1,   -1,   22,   23,   -1,  275,
+  276,  277,  278,  279,  280,  281,   32,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   51,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   59,   60,   61,   62,   63,   64,   65,
+   66,   67,   68,   69,   70,   71,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  107,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  116,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  130,  131,   -1,   -1,   -1,   -1,
+   -1,  137,   -1,  139,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  163,
 };
 #define YYFINAL 1
 #ifndef YYDEBUG
 "ffieldlist : ffieldlist1 lastcomma",
 "ffieldlist1 : ffield",
 "ffieldlist1 : ffieldlist1 ',' ffield",
-"ffield : NAME '=' expr1",
+"ffield : ffieldkey '=' expr1",
+"ffieldkey : '[' expr1 ']'",
+"ffieldkey : NAME",
 "lfieldlist :",
 "lfieldlist : lfieldlist1 lastcomma",
 "lfieldlist1 : expr1",
     switch (luaY_n)
     {
 case 5:
-#line 470 "lua.stx"
+#line 468 "lua.stx"
 {
 		code_byte(PUSHFUNCTION);
 		code_code(luaY_vsp[0].pFunc);
 	       }
 break;
 case 6:
-#line 477 "lua.stx"
+#line 475 "lua.stx"
 { luaY_val.vLong =luaY_vsp[0].vLong; init_func(); }
 break;
 case 7:
-#line 479 "lua.stx"
+#line 477 "lua.stx"
 {
-	  code_byte(PUSHSTRING);
+	  code_constant(luaY_vsp[0].pTStr);
-	  code_word(luaI_findconstant(luaY_vsp[0].pTStr));
 	  luaY_val.vLong = 0;  /* indexed variable */
 	  init_func();
 	  add_localvar(luaI_createfixedstring("self"));
 	}
 break;
 case 8:
-#line 489 "lua.stx"
+#line 486 "lua.stx"
 {
           codereturn();
 	  luaY_val.pFunc = new(TFunc);
           luaI_initTFunc(luaY_val.pFunc);
 	  luaY_val.pFunc->size = pc;
 	  luaY_val.pFunc->code = newvector(pc, Byte);
-	  luaY_val.pFunc->fileName = lua_parsedfile;
 	  luaY_val.pFunc->lineDefined = luaY_vsp[-3].vInt;
 	  memcpy(luaY_val.pFunc->code, basepc, pc*sizeof(Byte));
           if (lua_debug)
 	}
 break;
 case 13:
-#line 516 "lua.stx"
+#line 512 "lua.stx"
 { codeIf(luaY_vsp[-4].vLong, luaY_vsp[-2].vLong); }
 break;
 case 14:
-#line 518 "lua.stx"
+#line 514 "lua.stx"
 {luaY_val.vLong=pc;}
 break;
 case 15:
-#line 519 "lua.stx"
+#line 515 "lua.stx"
 {
         basepc[luaY_vsp[-3].vLong] = IFFJMP;
 	code_word_at(basepc+luaY_vsp[-3].vLong+1, pc - (luaY_vsp[-3].vLong + sizeof(Word)+1));
        }
 break;
 case 16:
-#line 526 "lua.stx"
+#line 522 "lua.stx"
 {luaY_val.vLong=pc;}
 break;
 case 17:
-#line 527 "lua.stx"
+#line 523 "lua.stx"
 {
         basepc[luaY_vsp[0].vLong] = IFFUPJMP;
 	code_word_at(basepc+luaY_vsp[0].vLong+1, pc - (luaY_vsp[-4].vLong));
        }
 break;
 case 18:
-#line 533 "lua.stx"
+#line 529 "lua.stx"
 {
         {
          int i;
 	}
        }
 break;
+case 19:
+#line 539 "lua.stx"
+{;}
+break;
 case 20:
-#line 545 "lua.stx"
+#line 541 "lua.stx"
 { nlocalvar += luaY_vsp[-1].vInt;
 	  adjust_mult_assign(luaY_vsp[-1].vInt, luaY_vsp[0].vInt, 0);
 	}
 break;
 case 23:
-#line 553 "lua.stx"
+#line 549 "lua.stx"
 { codeIf(luaY_vsp[-3].vLong, luaY_vsp[-1].vLong); }
 break;
 case 24:
-#line 556 "lua.stx"
+#line 552 "lua.stx"
 {luaY_val.vInt = nlocalvar;}
 break;
 case 25:
-#line 557 "lua.stx"
+#line 553 "lua.stx"
 {
 	  if (nlocalvar != luaY_vsp[-2].vInt)
 	  {
          }
 break;
 case 27:
-#line 572 "lua.stx"
+#line 568 "lua.stx"
 {
 	   adjust_functioncall(luaY_vsp[-1].vLong, MULT_RET);
            codereturn();
           }
 break;
 case 28:
-#line 579 "lua.stx"
+#line 575 "lua.stx"
 {
 	  luaY_val.vLong = pc;
 	  code_byte(0);		/* open space */
          }
 break;
 case 29:
-#line 586 "lua.stx"
+#line 582 "lua.stx"
 { adjust_functioncall(luaY_vsp[0].vLong, 1); }
 break;
 case 30:
-#line 589 "lua.stx"
+#line 585 "lua.stx"
 { luaY_val.vLong = luaY_vsp[-1].vLong; }
 break;
 case 31:
-#line 590 "lua.stx"
+#line 586 "lua.stx"
 { code_byte(EQOP);   luaY_val.vLong = 0; }
 break;
 case 32:
-#line 591 "lua.stx"
+#line 587 "lua.stx"
 { code_byte(LTOP);   luaY_val.vLong = 0; }
 break;
 case 33:
-#line 592 "lua.stx"
+#line 588 "lua.stx"
 { code_byte(GTOP);   luaY_val.vLong = 0; }
 break;
 case 34:
-#line 593 "lua.stx"
+#line 589 "lua.stx"
 { code_byte(EQOP); code_byte(NOTOP); luaY_val.vLong = 0; }
 break;
 case 35:
-#line 594 "lua.stx"
+#line 590 "lua.stx"
 { code_byte(LEOP);   luaY_val.vLong = 0; }
 break;
 case 36:
-#line 595 "lua.stx"
+#line 591 "lua.stx"
 { code_byte(GEOP);   luaY_val.vLong = 0; }
 break;
 case 37:
-#line 596 "lua.stx"
+#line 592 "lua.stx"
 { code_byte(ADDOP);  luaY_val.vLong = 0; }
 break;
 case 38:
-#line 597 "lua.stx"
+#line 593 "lua.stx"
 { code_byte(SUBOP);  luaY_val.vLong = 0; }
 break;
 case 39:
-#line 598 "lua.stx"
+#line 594 "lua.stx"
 { code_byte(MULTOP); luaY_val.vLong = 0; }
 break;
 case 40:
-#line 599 "lua.stx"
+#line 595 "lua.stx"
 { code_byte(DIVOP);  luaY_val.vLong = 0; }
 break;
 case 41:
-#line 600 "lua.stx"
+#line 596 "lua.stx"
 { code_byte(POWOP);  luaY_val.vLong = 0; }
 break;
 case 42:
-#line 601 "lua.stx"
+#line 597 "lua.stx"
 { code_byte(CONCOP);  luaY_val.vLong = 0; }
 break;
 case 43:
-#line 602 "lua.stx"
+#line 598 "lua.stx"
 { code_byte(MINUSOP); luaY_val.vLong = 0;}
 break;
 case 44:
-#line 603 "lua.stx"
+#line 599 "lua.stx"
 { luaY_val.vLong = 0; }
 break;
 case 45:
-#line 604 "lua.stx"
+#line 600 "lua.stx"
 { luaY_val.vLong = 0;}
 break;
 case 46:
-#line 605 "lua.stx"
+#line 601 "lua.stx"
 { code_number(luaY_vsp[0].vFloat); luaY_val.vLong = 0; }
 break;
 case 47:
-#line 607 "lua.stx"
+#line 603 "lua.stx"
 {
-      code_byte(PUSHSTRING);
+       code_string(luaY_vsp[0].vWord);
-      code_word(luaY_vsp[0].vWord);
+       luaY_val.vLong = 0;
-      luaY_val.vLong = 0;
      }
 break;
 case 48:
-#line 612 "lua.stx"
+#line 607 "lua.stx"
 {code_byte(PUSHNIL); luaY_val.vLong = 0; }
 break;
 case 49:
-#line 613 "lua.stx"
+#line 608 "lua.stx"
 { luaY_val.vLong = luaY_vsp[0].vLong; }
 break;
 case 50:
-#line 614 "lua.stx"
+#line 609 "lua.stx"
 { code_byte(NOTOP);  luaY_val.vLong = 0;}
 break;
 case 51:
-#line 615 "lua.stx"
+#line 610 "lua.stx"
 {code_byte(POP); }
 break;
 case 52:
-#line 616 "lua.stx"
+#line 611 "lua.stx"
 {
       basepc[luaY_vsp[-2].vLong] = ONFJMP;
       code_word_at(basepc+luaY_vsp[-2].vLong+1, pc - (luaY_vsp[-2].vLong + sizeof(Word)+1));
      }
 break;
 case 53:
-#line 621 "lua.stx"
+#line 616 "lua.stx"
 {code_byte(POP); }
 break;
 case 54:
-#line 622 "lua.stx"
+#line 617 "lua.stx"
 {
       basepc[luaY_vsp[-2].vLong] = ONTJMP;
       code_word_at(basepc+luaY_vsp[-2].vLong+1, pc - (luaY_vsp[-2].vLong + sizeof(Word)+1));
      }
 break;
 case 55:
-#line 630 "lua.stx"
+#line 625 "lua.stx"
 {
       code_byte(CREATEARRAY);
       luaY_val.vLong = pc; code_word(0);
      }
 break;
 case 56:
-#line 635 "lua.stx"
+#line 630 "lua.stx"
 {
       code_word_at(basepc+luaY_vsp[-3].vLong, luaY_vsp[-1].vInt);
      }
 break;
 case 57:
-#line 641 "lua.stx"
+#line 636 "lua.stx"
 {
 	  code_byte(CALLFUNC);
 	  code_byte(luaY_vsp[-1].vInt+luaY_vsp[0].vInt);
 	}
 break;
 case 58:
-#line 649 "lua.stx"
+#line 644 "lua.stx"
 { luaY_val.vInt = 0; }
 break;
 case 59:
-#line 651 "lua.stx"
+#line 646 "lua.stx"
 {
                code_byte(PUSHSELF);
 	       code_word(luaI_findconstant(luaY_vsp[0].pTStr));
 	     }
 break;
 case 60:
-#line 659 "lua.stx"
+#line 654 "lua.stx"
 { luaY_val.vInt = adjust_functioncall(luaY_vsp[-1].vLong, 1); }
 break;
 case 61:
-#line 660 "lua.stx"
+#line 655 "lua.stx"
 { luaY_val.vInt = 1; }
 break;
 case 62:
-#line 663 "lua.stx"
+#line 658 "lua.stx"
 { luaY_val.vLong = 0; }
 break;
 case 63:
-#line 664 "lua.stx"
+#line 659 "lua.stx"
 { luaY_val.vLong = luaY_vsp[0].vLong; }
 break;
 case 64:
-#line 667 "lua.stx"
+#line 662 "lua.stx"
 { if (luaY_vsp[0].vLong != 0) luaY_val.vLong = luaY_vsp[0].vLong; else luaY_val.vLong = -1; }
 break;
 case 65:
-#line 668 "lua.stx"
+#line 663 "lua.stx"
 { luaY_val.vLong = adjust_functioncall(luaY_vsp[-1].vLong, 1); }
 break;
 case 66:
-#line 669 "lua.stx"
+#line 664 "lua.stx"
 {
 	  if (luaY_vsp[0].vLong == 0) luaY_val.vLong = -(luaY_vsp[-1].vLong + 1);  /* -length */
 	  else
 	}
 break;
 case 67:
-#line 679 "lua.stx"
+#line 674 "lua.stx"
 { luaY_val.vInt = close_parlist(0); }
 break;
 case 68:
-#line 680 "lua.stx"
+#line 675 "lua.stx"
 { luaY_val.vInt = close_parlist(luaY_vsp[0].vInt); }
 break;
 case 69:
-#line 683 "lua.stx"
+#line 678 "lua.stx"
 { luaY_val.vInt = luaY_vsp[0].vInt; }
 break;
 case 70:
-#line 685 "lua.stx"
+#line 680 "lua.stx"
 {
 	  if (luaY_vsp[-2].vInt)
             lua_error("invalid parameter list");
 	}
 break;
 case 71:
-#line 692 "lua.stx"
+#line 687 "lua.stx"
 { add_localvar(luaY_vsp[0].pTStr); luaY_val.vInt = 0; }
 break;
 case 72:
-#line 693 "lua.stx"
+#line 688 "lua.stx"
 { luaY_val.vInt = 1; }
 break;
 case 73:
-#line 697 "lua.stx"
+#line 692 "lua.stx"
 { flush_list(luaY_vsp[0].vInt/FIELDS_PER_FLUSH, luaY_vsp[0].vInt%FIELDS_PER_FLUSH); }
 break;
 case 74:
-#line 699 "lua.stx"
+#line 694 "lua.stx"
 { luaY_val.vInt = luaY_vsp[-2].vInt+luaY_vsp[0].vInt; }
 break;
 case 75:
-#line 701 "lua.stx"
+#line 696 "lua.stx"
 { luaY_val.vInt = luaY_vsp[-1].vInt; flush_record(luaY_vsp[-1].vInt%FIELDS_PER_FLUSH); }
 break;
 case 76:
-#line 705 "lua.stx"
+#line 700 "lua.stx"
 { luaY_val.vInt = 0; }
 break;
 case 77:
-#line 707 "lua.stx"
+#line 702 "lua.stx"
 { luaY_val.vInt = luaY_vsp[0].vInt; flush_record(luaY_vsp[0].vInt%FIELDS_PER_FLUSH); }
 break;
 case 80:
-#line 714 "lua.stx"
+#line 709 "lua.stx"
 { luaY_val.vInt = 0; }
 break;
 case 81:
-#line 715 "lua.stx"
+#line 710 "lua.stx"
 { luaY_val.vInt = luaY_vsp[-1].vInt; }
 break;
 case 82:
-#line 718 "lua.stx"
+#line 713 "lua.stx"
 {luaY_val.vInt=1;}
 break;
 case 83:
-#line 720 "lua.stx"
+#line 715 "lua.stx"
 {
 		  luaY_val.vInt=luaY_vsp[-2].vInt+1;
 		  if (luaY_val.vInt%FIELDS_PER_FLUSH == 0) flush_record(FIELDS_PER_FLUSH);
 		}
 break;
-case 84:
+case 86:
-#line 727 "lua.stx"
+#line 725 "lua.stx"
-{
+{ code_constant(luaY_vsp[0].pTStr); }
-	       push_field(luaI_findconstant(luaY_vsp[-2].pTStr));
-	      }
 break;
-case 85:
+case 87:
-#line 732 "lua.stx"
+#line 728 "lua.stx"
 { luaY_val.vInt = 0; }
 break;
-case 86:
+case 88:
-#line 733 "lua.stx"
+#line 729 "lua.stx"
 { luaY_val.vInt = luaY_vsp[-1].vInt; }
 break;
-case 87:
+case 89:
-#line 736 "lua.stx"
+#line 732 "lua.stx"
 {luaY_val.vInt=1;}
 break;
-case 88:
+case 90:
-#line 738 "lua.stx"
+#line 734 "lua.stx"
 {
 		  luaY_val.vInt=luaY_vsp[-2].vInt+1;
 		  if (luaY_val.vInt%FIELDS_PER_FLUSH == 0)
 		    flush_list(luaY_val.vInt/FIELDS_PER_FLUSH - 1, FIELDS_PER_FLUSH);
 		}
 break;
-case 89:
+case 91:
-#line 746 "lua.stx"
+#line 742 "lua.stx"
 {
 	   nvarbuffer = 0;
 	   add_varbuffer(luaY_vsp[0].vLong);
 	   luaY_val.vInt = (luaY_vsp[0].vLong == 0) ? 1 : 0;
 	  }
 break;
-case 90:
+case 92:
-#line 752 "lua.stx"
+#line 748 "lua.stx"
 {
 	   add_varbuffer(luaY_vsp[0].vLong);
 	   luaY_val.vInt = (luaY_vsp[0].vLong == 0) ? luaY_vsp[-2].vInt + 1 : luaY_vsp[-2].vInt;
 	  }
 break;
-case 91:
+case 93:
-#line 758 "lua.stx"
+#line 754 "lua.stx"
 { luaY_val.vLong = luaY_vsp[0].vLong; }
 break;
-case 92:
+case 94:
-#line 760 "lua.stx"
+#line 756 "lua.stx"
 {
 	   luaY_val.vLong = 0;		/* indexed variable */
 	  }
 break;
-case 93:
+case 95:
-#line 764 "lua.stx"
+#line 760 "lua.stx"
 {
-	   code_byte(PUSHSTRING);
+	    code_constant(luaY_vsp[0].pTStr);
-	   code_word(luaI_findconstant(luaY_vsp[0].pTStr));
+	    luaY_val.vLong = 0;		/* indexed variable */
-	   luaY_val.vLong = 0;		/* indexed variable */
 	  }
 break;
-case 94:
+case 96:
-#line 772 "lua.stx"
+#line 767 "lua.stx"
 {
 	   int local = lua_localname(luaY_vsp[0].pTStr);
 	   if (local == -1)	/* global var */
 	    luaY_val.vLong = -(local+1);		/* return negative value */
 	  }
 break;
-case 95:
+case 97:
-#line 781 "lua.stx"
+#line 776 "lua.stx"
 { lua_pushvar(luaY_vsp[0].vLong); }
 break;
-case 96:
+case 98:
-#line 784 "lua.stx"
+#line 779 "lua.stx"
 {store_localvar(luaY_vsp[0].pTStr, 0); luaY_val.vInt = 1;}
 break;
-case 97:
+case 99:
-#line 786 "lua.stx"
+#line 781 "lua.stx"
 {
 	     store_localvar(luaY_vsp[0].pTStr, luaY_vsp[-2].vInt);
 	     luaY_val.vInt = luaY_vsp[-2].vInt+1;
 	    }
 break;
-case 98:
+case 100:
-#line 792 "lua.stx"
+#line 787 "lua.stx"
 { luaY_val.vInt = 0; }
 break;
-case 99:
+case 101:
-#line 793 "lua.stx"
+#line 788 "lua.stx"
 { luaY_val.vInt = luaY_vsp[0].vLong; }
 break;
-#line 1613 "y.tab.c"
+#line 1641 "y.tab.c"
     }
     luaY_ssp -= luaY_m;
     luaY_state = *luaY_ssp;

src/table.c+84−96

 ** Module to control static tables
 */
-char *rcs_table="$Id: table.c,v 2.58 1996/11/01 12:47:45 roberto Exp $";
+char *rcs_table="$Id: table.c,v 2.72 1997/06/17 18:09:31 roberto Exp $";
-#include "mem.h"
+#include "luamem.h"
+#include "auxlib.h"
+#include "func.h"
 #include "opcode.h"
 #include "tree.h"
 #include "hash.h"
 static Long lua_maxconstant = 0;
-#define GARBAGE_BLOCK 50
+#define GARBAGE_BLOCK 100
-static void lua_nextvar (void);
-/*
-** Internal functions
-*/
-static struct {
-  char *name;
-  lua_CFunction func;
-} int_funcs[] = {
-  {"assert", luaI_assert},
-  {"call", luaI_call},
-  {"dofile", lua_internaldofile},
-  {"dostring", lua_internaldostring},
-  {"error", luaI_error},
-  {"getglobal", luaI_getglobal},
-  {"next", lua_next},
-  {"nextvar", lua_nextvar},
-  {"print", luaI_print},
-  {"setfallback", luaI_setfallback},
-  {"setglobal", luaI_setglobal},
-  {"tonumber", lua_obj2number},
-  {"tostring", luaI_tostring},
-  {"type", luaI_type}
-};
-#define INTFUNCSIZE (sizeof(int_funcs)/sizeof(int_funcs[0]))
 void luaI_initsymbol (void)
 {
-  int i;
-  Word n;
   lua_maxsymbol = BUFFER_BLOCK;
   lua_table = newvector(lua_maxsymbol, Symbol);
-  for (i=0; i<INTFUNCSIZE; i++)
+  luaI_predefine();
-  {
-    n = luaI_findsymbolbyname(int_funcs[i].name);
-    s_tag(n) = LUA_T_CFUNCTION; s_fvalue(n) = int_funcs[i].func;
-  }
-  n = luaI_findsymbolbyname("_VERSION_");
-  s_tag(n) = LUA_T_STRING; s_tsvalue(n) = lua_createstring(LUA_VERSION);
 }
 */
 Word luaI_findsymbol (TaggedString *t)
 {
- if (t->varindex == NOT_USED)
+ if (t->u.s.varindex == NOT_USED)
  {
   if (lua_ntable == lua_maxsymbol)
     lua_maxsymbol = growvector(&lua_table, lua_maxsymbol, Symbol,
                       symbolEM, MAX_WORD);
-  t->varindex = lua_ntable;
+  t->u.s.varindex = lua_ntable;
   lua_table[lua_ntable].varname = t;
-  s_tag(lua_ntable) = LUA_T_NIL;
+  s_ttype(lua_ntable) = LUA_T_NIL;
   lua_ntable++;
  }
- return t->varindex;
+ return t->u.s.varindex;
 }
 */
 Word luaI_findconstant (TaggedString *t)
 {
- if (t->constindex == NOT_USED)
+ if (t->u.s.constindex == NOT_USED)
  {
   if (lua_nconstant == lua_maxconstant)
     lua_maxconstant = growvector(&lua_constant, lua_maxconstant, TaggedString *,
                         constantEM, MAX_WORD);
-  t->constindex = lua_nconstant;
+  t->u.s.constindex = lua_nconstant;
   lua_constant[lua_nconstant] = t;
   lua_nconstant++;
  }
- return t->constindex;
+ return t->u.s.constindex;
 }
 }
+int luaI_globaldefined (char *name)
+{
+  return ttype(&lua_table[luaI_findsymbolbyname(name)].object) != LUA_T_NIL;
+}
 /*
 ** Traverse symbol table objects
 */
-static char *lua_travsymbol (int (*fn)(Object *))
+static char *lua_travsymbol (int (*fn)(TObject *))
 {
  Word i;
  for (i=0; i<lua_ntable; i++)
 /*
 ** Mark an object if it is a string or a unmarked array.
 */
-int lua_markobject (Object *o)
+int lua_markobject (TObject *o)
 {/* if already marked, does not change mark value */
- if (tag(o) == LUA_T_STRING && !tsvalue(o)->marked)
+ if (ttype(o) == LUA_T_USERDATA ||
+     (ttype(o) == LUA_T_STRING && !tsvalue(o)->marked))
    tsvalue(o)->marked = 1;
- else if (tag(o) == LUA_T_ARRAY)
+ else if (ttype(o) == LUA_T_ARRAY)
    lua_hashmark (avalue(o));
- else if ((o->tag == LUA_T_FUNCTION || o->tag == LUA_T_MARK)
+ else if ((o->ttype == LUA_T_FUNCTION || o->ttype == LUA_T_MARK)
            && !o->value.tf->marked)
    o->value.tf->marked = 1;
  return 0;
 /*
 * returns 0 if the object is going to be (garbage) collected
 */
-int luaI_ismarked (Object *o)
+int luaI_ismarked (TObject *o)
 {
-  switch (o->tag)
+  switch (o->ttype)
   {
-   case LUA_T_STRING:
+   case LUA_T_STRING: case LUA_T_USERDATA:
      return o->value.ts->marked;
    case LUA_T_FUNCTION:
     return o->value.tf->marked;
 }
+static void call_nilIM (void)
+{ /* signals end of garbage collection */
+  TObject t;
+  ttype(&t) = LUA_T_NIL;
+  luaI_gcIM(&t);  /* end of list */
+}
 /*
 ** Garbage collection.
 ** Delete all unused strings and arrays.
 */
-Long luaI_collectgarbage (void)
+static long gc_block = GARBAGE_BLOCK;
+static long gc_nentity = 0;  /* total of strings, arrays, etc */
+static void markall (void)
 {
-  Long recovered = 0;
   lua_travstack(lua_markobject); /* mark stack objects */
   lua_travsymbol(lua_markobject); /* mark symbol table objects */
   luaI_travlock(lua_markobject); /* mark locked objects */
   luaI_travfallbacks(lua_markobject);  /* mark fallbacks */
+}
+long lua_collectgarbage (long limit)
+{
+  long recovered = 0;
+  Hash *freetable;
+  TaggedString *freestr;
+  TFunc *freefunc;
+  markall();
   luaI_invalidaterefs();
-  recovered += lua_strcollector();
+  freetable = luaI_hashcollector(&recovered);
-  recovered += lua_hashcollector();
+  freestr = luaI_strcollector(&recovered);
-  recovered += luaI_funccollector();
+  freefunc = luaI_funccollector(&recovered);
+  gc_nentity -= recovered;
+  gc_block = (limit == 0) ? 2*(gc_block-recovered) : gc_nentity+limit;
+  luaI_hashcallIM(freetable);
+  luaI_strcallIM(freestr);
+  call_nilIM();
+  luaI_hashfree(freetable);
+  luaI_strfree(freestr);
+  luaI_funcfree(freefunc);
   return recovered;
 }
 void lua_pack (void)
 {
-  static unsigned long block = GARBAGE_BLOCK;
+  if (++gc_nentity >= gc_block)
-  static unsigned long nentity = 0;  /* total of strings, arrays, etc */
+    lua_collectgarbage(0);
-  unsigned long recovered = 0;
-  if (nentity++ < block) return;
-  recovered = luaI_collectgarbage();
-  block = 2*(block-recovered);
-  nentity -= recovered;
 }
 /*
 ** Internal function: return next global variable
 */
-static void lua_nextvar (void)
+void luaI_nextvar (void)
 {
- Word next;
+  Word next;
- lua_Object o = lua_getparam(1);
+  if (lua_isnil(lua_getparam(1)))
- if (o == LUA_NOOBJECT)
+    next = 0;
-   lua_error("too few arguments to function `nextvar'");
+  else
- if (lua_getparam(2) != LUA_NOOBJECT)
+    next = luaI_findsymbolbyname(luaL_check_string(1)) + 1;
-   lua_error("too many arguments to function `nextvar'");
+  while (next < lua_ntable && s_ttype(next) == LUA_T_NIL)
- if (lua_isnil(o))
+    next++;
-   next = 0;
+  if (next < lua_ntable) {
- else if (!lua_isstring(o))
+    lua_pushstring(lua_table[next].varname->str);
- {
+    luaI_pushobject(&s_object(next));
-   lua_error("incorrect argument to function `nextvar'");
+  }
-   return;  /* to avoid warnings */
- }
- else
-   next = luaI_findsymbolbyname(lua_getstring(o)) + 1;
- while (next < lua_ntable && s_tag(next) == LUA_T_NIL) next++;
- if (next < lua_ntable)
- {
-  lua_pushstring(lua_table[next].varname->str);
-  luaI_pushobject(&s_object(next));
- }
 }
-static Object *functofind;
+static TObject *functofind;
-static int checkfunc (Object *o)
+static int checkfunc (TObject *o)
 {
-  if (o->tag == LUA_T_FUNCTION)
+  if (o->ttype == LUA_T_FUNCTION)
     return
-       ((functofind->tag == LUA_T_FUNCTION || functofind->tag == LUA_T_MARK)
+       ((functofind->ttype == LUA_T_FUNCTION || functofind->ttype == LUA_T_MARK)
             && (functofind->value.tf == o->value.tf));
-  if (o->tag == LUA_T_CFUNCTION)
+  if (o->ttype == LUA_T_CFUNCTION)
     return
-       ((functofind->tag == LUA_T_CFUNCTION || functofind->tag == LUA_T_CMARK)
+       ((functofind->ttype == LUA_T_CFUNCTION ||
-            && (functofind->value.f == o->value.f));
+         functofind->ttype == LUA_T_CMARK) &&
+         (functofind->value.f == o->value.f));
   return 0;
 }
 { /* try to find a name for given function */
   functofind = luaI_Address(o);
   if ((*name = luaI_travfallbacks(checkfunc)) != NULL)
-    return "fallback";
+    return "tag-method";
   else if ((*name = lua_travsymbol(checkfunc)) != NULL)
     return "global";
   else return "";

src/table.h+6−5

 /*
 ** Module to control static tables
 ** TeCGraf - PUC-Rio
-** $Id: table.h,v 2.21 1996/04/22 18:00:37 roberto Exp $
+** $Id: table.h,v 2.25 1997/05/26 14:42:36 roberto Exp $
 */
 #ifndef table_h
 typedef struct
 {
- Object  object;
+ TObject  object;
  TaggedString *varname;
 } Symbol;
 Word  luaI_findsymbol      (TaggedString *t);
 Word  luaI_findconstant    (TaggedString *t);
 Word  luaI_findconstantbyname (char *name);
+int luaI_globaldefined (char *name);
+void luaI_nextvar (void);
 TaggedString *luaI_createfixedstring  (char *str);
-int   lua_markobject      (Object *o);
+int   lua_markobject      (TObject *o);
-int luaI_ismarked (Object *o);
+int luaI_ismarked (TObject *o);
-Long luaI_collectgarbage (void);
 void  lua_pack            (void);

src/tree.c+92−26

@@ -3,17 +3,18 @@ · 2 unmodified lines
3	** TecCGraf - PUC-Rio	3	** TecCGraf - PUC-Rio
4	*/	4	*/
5		5
6	char *rcs_tree="$Id: tree.c,v 1.20 1996/03/14 15:56:26 roberto Exp $";	6	char *rcs_tree="$Id: tree.c,v 1.28 1997/06/11 14:24:40 roberto Exp $";
7		7
8		8
9	#include <string.h>	9	#include <string.h>
10		10
11	#include "mem.h"	11	#include "luamem.h"
12	#include "lua.h"	12	#include "lua.h"
13	#include "tree.h"	13	#include "tree.h"
14	#include "lex.h"	14	#include "lex.h"
15	#include "hash.h"	15	#include "hash.h"
16	#include "table.h"	16	#include "table.h"
		17	#include "fallback.h"
17		18
18		19
19	#define NUM_HASHS 64	20	#define NUM_HASHS 64
@@ -28,23 +29,43 @@ static int initialized = 0; · 8 unmodified lines
28		29
29	static stringtable string_root[NUM_HASHS];	30	static stringtable string_root[NUM_HASHS];
30		31
31	static TaggedString EMPTY = {NOT_USED, NOT_USED, 0, 2, {0}};	32	static TaggedString EMPTY = {LUA_T_STRING, NULL, {{NOT_USED, NOT_USED}},
		33	0, 2, {0}};
32		34
33		35
34	static unsigned long hash (char *str)	36	static unsigned long hash (char *s, int tag)
35	{	37	{
36	unsigned long h = 0;	38	unsigned long h;
37	while (*str)	39	if (tag != LUA_T_STRING)
38	h = ((h<<5)-h)^(unsigned char)*(str++);	40	h = (unsigned long)s;
		41	else {
		42	h = 0;
		43	while (*s)
		44	h = ((h<<5)-h)^(unsigned char)*(s++);
		45	}
39	return h;	46	return h;
40	}	47	}
41		48
		49
		50	static void luaI_inittree (void)
		51	{
		52	int i;
		53	for (i=0; i<NUM_HASHS; i++) {
		54	string_root[i].size = 0;
		55	string_root[i].nuse = 0;
		56	string_root[i].hash = NULL;
		57	}
		58	}
		59
		60
42	static void initialize (void)	61	static void initialize (void)
43	{	62	{
44	initialized = 1;	63	initialized = 1;
		64	luaI_inittree();
45	luaI_addReserved();	65	luaI_addReserved();
46	luaI_initsymbol();	66	luaI_initsymbol();
47	luaI_initconstant();	67	luaI_initconstant();
		68	luaI_initfallbacks();
48	}	69	}
49		70
50		71
@@ -58,8 +79,7 @@ static void grow (stringtable *tb) · 7 unmodified lines
58	/* rehash */	79	/* rehash */
59	tb->nuse = 0;	80	tb->nuse = 0;
60	for (i=0; i<tb->size; i++)	81	for (i=0; i<tb->size; i++)
61	if (tb->hash[i] != NULL && tb->hash[i] != &EMPTY)	82	if (tb->hash[i] != NULL && tb->hash[i] != &EMPTY) {
62	{
63	int h = tb->hash[i]->hash%newsize;	83	int h = tb->hash[i]->hash%newsize;
64	while (newhash[h])	84	while (newhash[h])
65	h = (h+1)%newsize;	85	h = (h+1)%newsize;
@@ -71,10 +91,30 @@ static void grow (stringtable *tb) · 5 unmodified lines
71	tb->hash = newhash;	91	tb->hash = newhash;
72	}	92	}
73		93
74	static TaggedString insert (char str, stringtable *tb)	94
		95	static TaggedString newone(char buff, int tag, unsigned long h)
		96	{
		97	TaggedString *ts;
		98	if (tag == LUA_T_STRING) {
		99	ts = (TaggedString *)luaI_malloc(sizeof(TaggedString)+strlen(buff));
		100	strcpy(ts->str, buff);
		101	ts->u.s.varindex = ts->u.s.constindex = NOT_USED;
		102	ts->tag = LUA_T_STRING;
		103	}
		104	else {
		105	ts = (TaggedString *)luaI_malloc(sizeof(TaggedString));
		106	ts->u.v = buff;
		107	ts->tag = tag == LUA_ANYTAG ? 0 : tag;
		108	}
		109	ts->marked = 0;
		110	ts->hash = h;
		111	return ts;
		112	}
		113
		114	static TaggedString insert (char buff, int tag, stringtable *tb)
75	{	115	{
76	TaggedString *ts;	116	TaggedString *ts;
77	unsigned long h = hash(str);	117	unsigned long h = hash(buff, tag);
78	int i;	118	int i;
79	int j = -1;	119	int j = -1;
80	if ((Long)tb->nuse3 >= (Long)tb->size2)	120	if ((Long)tb->nuse3 >= (Long)tb->size2)
@@ -84,12 +124,14 @@ static TaggedString insert (char str, stringtable *tb) · 3 unmodified lines
84	grow(tb);	124	grow(tb);
85	}	125	}
86	i = h%tb->size;	126	i = h%tb->size;
87	while (tb->hash[i])	127	while ((ts = tb->hash[i]) != NULL)
88	{	128	{
89	if (tb->hash[i] == &EMPTY)	129	if (ts == &EMPTY)
90	j = i;	130	j = i;
91	else if (strcmp(str, tb->hash[i]->str) == 0)	131	else if ((ts->tag == LUA_T_STRING) ?
92	return tb->hash[i];	132	(tag == LUA_T_STRING && (strcmp(buff, ts->str) == 0)) :
		133	((tag == ts->tag \|\| tag == LUA_ANYTAG) && buff == ts->u.v))
		134	return ts;
93	i = (i+1)%tb->size;	135	i = (i+1)%tb->size;
94	}	136	}
95	/* not found */	137	/* not found */
@@ -98,27 +140,49 @@ static TaggedString insert (char str, stringtable *tb) · 2 unmodified lines
98	i = j;	140	i = j;
99	else	141	else
100	tb->nuse++;	142	tb->nuse++;
101	ts = tb->hash[i] = (TaggedString *)luaI_malloc(sizeof(TaggedString)+strlen(str));	143	ts = tb->hash[i] = newone(buff, tag, h);
102	strcpy(ts->str, str);
103	ts->marked = 0;
104	ts->hash = h;
105	ts->varindex = ts->constindex = NOT_USED;
106	return ts;	144	return ts;
107	}	145	}
108		146
109	TaggedString lua_createstring (char str)	147	TaggedString luaI_createudata (void udata, int tag)
110	{	148	{
111	return insert(str, &string_root[(unsigned)str[0]%NUM_HASHS]);	149	return insert(udata, tag, &string_root[(unsigned)udata%NUM_HASHS]);
		150	}
		151
		152	TaggedString lua_createstring (char str)
		153	{
		154	return insert(str, LUA_T_STRING, &string_root[(unsigned)str[0]%NUM_HASHS]);
		155	}
		156
		157
		158	void luaI_strcallIM (TaggedString *l)
		159	{
		160	TObject o;
		161	ttype(&o) = LUA_T_USERDATA;
		162	for (; l; l=l->next) {
		163	tsvalue(&o) = l;
		164	luaI_gcIM(&o);
		165	}
		166	}
		167
		168
		169	void luaI_strfree (TaggedString *l)
		170	{
		171	while (l) {
		172	TaggedString *next = l->next;
		173	luaI_free(l);
		174	l = next;
		175	}
112	}	176	}
113		177
114		178
115	/*	179	/*
116	** Garbage collection function.	180	** Garbage collection function.
117	** This function traverse the string list freeing unindexed strings
118	*/	181	*/
119	Long lua_strcollector (void)	182	TaggedString luaI_strcollector (long acum)
120	{	183	{
121	Long counter = 0;	184	Long counter = 0;
		185	TaggedString *frees = NULL;
122	int i;	186	int i;
123	for (i=0; i<NUM_HASHS; i++)	187	for (i=0; i<NUM_HASHS; i++)
124	{	188	{
@@ -133,13 +197,15 @@ Long lua_strcollector (void) · 8 unmodified lines
133	t->marked = 0;	197	t->marked = 0;
134	else	198	else
135	{	199	{
136	luaI_free(t);	200	t->next = frees;
		201	frees = t;
137	tb->hash[j] = &EMPTY;	202	tb->hash[j] = &EMPTY;
138	counter++;	203	counter++;
139	}	204	}
140	}	205	}
141	}	206	}
142	}	207	}
143	return counter;	208	*acum += counter;
		209	return frees;
144	}	210	}
145		211

src/tree.h+14−4

 /*
 ** tree.h
 ** TecCGraf - PUC-Rio
-** $Id: tree.h,v 1.14 1996/02/26 17:07:49 roberto Exp $
+** $Id: tree.h,v 1.18 1997/06/09 17:28:14 roberto Exp $
 */
 #ifndef tree_h
 typedef struct TaggedString
 {
-  Word varindex;  /* != NOT_USED  if this is a symbol */
+  int tag;  /* if != LUA_T_STRING, this is a userdata */
-  Word constindex;  /* != NOT_USED  if this is a constant */
+  struct TaggedString *next;
+  union {
+    struct {
+      Word varindex;  /* != NOT_USED  if this is a symbol */
+      Word constindex;  /* != NOT_USED  if this is a constant */
+    } s;
+    void *v;  /* if this is a userdata, here is its value */
+  } u;
   unsigned long hash;  /* 0 if not initialized */
   int marked;   /* for garbage collection; never collect (nor change) if > 1 */
   char str[1];   /* \0 byte already reserved */
 TaggedString *lua_createstring (char *str);
-Long lua_strcollector (void);
+TaggedString *luaI_createudata (void *udata, int tag);
+TaggedString *luaI_strcollector (long *cont);
+void luaI_strfree (TaggedString *l);
+void luaI_strcallIM (TaggedString *l);
 #endif

src/undump.c+71−74

 ** load bytecodes from files
 */
-char* rcs_undump="$Id: undump.c,v 1.21 1996/11/18 11:18:29 lhf Exp $";
+char* rcs_undump="$Id: undump.c,v 1.24 1997/06/17 18:19:17 roberto Exp $";
 #include <stdio.h>
 #include <string.h>
+#include "auxlib.h"
 #include "opcode.h"
-#include "mem.h"
+#include "luamem.h"
 #include "table.h"
 #include "undump.h"
+#include "zio.h"
 static int swapword=0;
 static int swapfloat=0;
 static TFunc* Main=NULL;			/* functions in a chunk */
 static TFunc* lastF=NULL;
-static void warn(char* s)			/* TODO: remove */
-{
-#if 0
- fprintf(stderr,"undump: %s\n",s);
-#endif
-}
 static void FixCode(Byte* code, Byte* end)	/* swap words */
 {
  Byte* p;
  for (p=code; p!=end;)
  {
-	OpCode op=(OpCode)*p;
+	int op=*p;
 	switch (op)
 	{
 	case PUSHNIL:
 	case STORELIST0:
 	case ADJUST:
 	case RETCODE:
+	case VARARGS:
+	case STOREMAP:
 		p+=2;
 		break;
 	case STORELIST:
 		break;
 	}
 	default:
-		lua_error("corrupt binary file");
+		luaL_verror("corrupt binary file: bad opcode %d at %d\n",
+			op,(int)(p-code));
 		break;
 	}
  }
  }
 }
-static int LoadWord(FILE* D)
+static int LoadWord(ZIO* Z)
 {
  Word w;
- fread(&w,sizeof(w),1,D);
+ zread(Z,&w,sizeof(w));
  if (swapword)
  {
-  Byte* p=(Byte*)&w;				/* TODO: need union? */
+  Byte* p=(Byte*)&w;
   Byte t;
   t=p[0]; p[0]=p[1]; p[1]=t;
  }
  return w;
 }
-static int LoadSize(FILE* D)
+static int LoadSize(ZIO* Z)
 {
- Word hi=LoadWord(D);
+ Word hi=LoadWord(Z);
- Word lo=LoadWord(D);
+ Word lo=LoadWord(Z);
  int s=(hi<<16)|lo;
  if ((Word)s != s) lua_error("code too long");
  return s;
 }
-static void* LoadBlock(int size, FILE* D)
+static void* LoadBlock(int size, ZIO* Z)
 {
  void* b=luaI_malloc(size);
- fread(b,size,1,D);
+ zread(Z,b,size);
  return b;
 }
-static char* LoadString(FILE* D)
+static char* LoadString(ZIO* Z)
 {
- int size=LoadWord(D);
+ int size=LoadWord(Z);
  char *b=luaI_buffer(size);
- fread(b,size,1,D);
+ zread(Z,b,size);
  return b;
 }
-static char* LoadNewString(FILE* D)
+static char* LoadNewString(ZIO* Z)
 {
- return LoadBlock(LoadWord(D),D);
+ return LoadBlock(LoadWord(Z),Z);
 }
-static void LoadFunction(FILE* D)
+static void LoadFunction(ZIO* Z)
 {
  TFunc* tf=new(TFunc);
  tf->next=NULL;
  tf->locvars=NULL;
- tf->size=LoadSize(D);
+ tf->size=LoadSize(Z);
- tf->lineDefined=LoadWord(D);
+ tf->lineDefined=LoadWord(Z);
  if (IsMain(tf))				/* new main */
  {
-  tf->fileName=LoadNewString(D);
+  tf->fileName=LoadNewString(Z);
   Main=lastF=tf;
  }
  else						/* fix PUSHFUNCTION */
  {
-  tf->marked=LoadWord(D);
+  tf->marked=LoadWord(Z);
   tf->fileName=Main->fileName;
   memcpy(Main->code+tf->marked,&tf,sizeof(tf));
   lastF=lastF->next=tf;
  }
- tf->code=LoadBlock(tf->size,D);
+ tf->code=LoadBlock(tf->size,Z);
  if (swapword || swapfloat) FixCode(tf->code,tf->code+tf->size);
  while (1)					/* unthread */
  {
-  int c=getc(D);
+  int c=zgetc(Z);
   if (c==ID_VAR)				/* global var */
   {
-   int i=LoadWord(D);
+   int i=LoadWord(Z);
-   char* s=LoadString(D);
+   char* s=LoadString(Z);
    int v=luaI_findsymbolbyname(s);
    Unthread(tf->code,i,v);
   }
   else if (c==ID_STR)				/* constant string */
   {
-   int i=LoadWord(D);
+   int i=LoadWord(Z);
-   char* s=LoadString(D);
+   char* s=LoadString(Z);
    int v=luaI_findconstantbyname(s);
    Unthread(tf->code,i,v);
   }
   else
   {
-   ungetc(c,D);
+   zungetc(Z);
    break;
   }
  }
 }
-static void LoadSignature(FILE* D)
+static void LoadSignature(ZIO* Z)
 {
  char* s=SIGNATURE;
- while (*s!=0 && getc(D)==*s)
+ while (*s!=0 && zgetc(Z)==*s)
   ++s;
- if (*s!=0) lua_error("bad signature");
+ if (*s!=0) lua_error("cannot load binary file: bad signature");
 }
-static void LoadHeader(FILE* D)			/* TODO: error handling */
+static void LoadHeader(ZIO* Z)
 {
  Word w,tw=TEST_WORD;
  float f,tf=TEST_FLOAT;
  int version;
- LoadSignature(D);
+ LoadSignature(Z);
- version=getc(D);
+ version=zgetc(Z);
  if (version>0x23)				/* after 2.5 */
  {
-  int oldsizeofW=getc(D);
+  int oldsizeofW=zgetc(Z);
-  int oldsizeofF=getc(D);
+  int oldsizeofF=zgetc(Z);
-  int oldsizeofP=getc(D);
+  int oldsizeofP=zgetc(Z);
   if (oldsizeofW!=2)
-   lua_error("cannot load binary file created on machine with sizeof(Word)!=2");
+   luaL_verror(
+	"cannot load binary file created on machine with sizeof(Word)=%d; "
+	"expected 2",oldsizeofW);
   if (oldsizeofF!=4)
-   lua_error("cannot load binary file created on machine with sizeof(float)!=4. not an IEEE machine?");
+   luaL_verror(
-  if (oldsizeofP!=sizeof(TFunc*))		/* TODO: pack */
+	"cannot load binary file created on machine with sizeof(float)=%d; "
-   lua_error("cannot load binary file: different pointer sizes");
+	"expected 4\nnot an IEEE machine?",oldsizeofF);
+  if (oldsizeofP!=sizeof(TFunc*))		/* TODO: pack? */
+   luaL_verror(
+	"cannot load binary file created on machine with sizeof(TFunc*)=%d; "
+	"expected %d",oldsizeofP,(int)sizeof(TFunc*));
  }
- fread(&w,sizeof(w),1,D);			/* test word */
+ zread(Z,&w,sizeof(w));			/* test word */
  if (w!=tw)
  {
   swapword=1;
-  warn("different byte order");
  }
- fread(&f,sizeof(f),1,D);			/* test float */
+ zread(Z,&f,sizeof(f));			/* test float */
  if (f!=tf)
  {
-  Byte* p=(Byte*)&f;				/* TODO: need union? */
+  Byte* p=(Byte*)&f;
   Byte t;
   swapfloat=1;
   t=p[0]; p[0]=p[3]; p[3]=t;
   t=p[1]; p[1]=p[2]; p[2]=t;
   if (f!=tf)					/* TODO: try another perm? */
-   lua_error("different float representation");
+   lua_error("cannot load binary file: unknown float representation");
-  else
-   warn("different byte order in floats");
  }
 }
-static void LoadChunk(FILE* D)
+static void LoadChunk(ZIO* Z)
 {
- LoadHeader(D);
+ LoadHeader(Z);
  while (1)
  {
-  int c=getc(D);
+  int c=zgetc(Z);
-  if (c==ID_FUN) LoadFunction(D); else { ungetc(c,D); break; }
+  if (c==ID_FUN) LoadFunction(Z); else { zungetc(Z); break; }
  }
 }
 ** load one chunk from a file.
 ** return list of functions found, headed by main, or NULL at EOF.
 */
-TFunc* luaI_undump1(FILE* D)
+TFunc* luaI_undump1(ZIO* Z)
 {
- while (1)
+ int c=zgetc(Z);
+ if (c==ID_CHUNK)
  {
-  int c=getc(D);
+  LoadChunk(Z);
-  if (c==ID_CHUNK)
+  return Main;
-  {
-   LoadChunk(D);
-   return Main;
-  }
-  else if (c==EOF)
-   return NULL;
-  else
-   lua_error("not a lua binary file");
  }
+ else if (c!=EOZ)
+   lua_error("not a lua binary file");
+ return NULL;
 }
 /*
 ** load and run all chunks in a file
 */
-int luaI_undump(FILE* D)
+int luaI_undump(ZIO* Z)
 {
  TFunc* m;
- while ((m=luaI_undump1(D)))
+ while ((m=luaI_undump1(Z)))
  {
   int status=luaI_dorun(m);
   luaI_freefunc(m);

src/undump.h+11−4

@@ -1,10 +1,14 @@
1	/*	1	/*
2	** undump.h	2	** undump.h
3	** definitions for lua decompiler	3	** definitions for lua decompiler
4	** $Id: undump.h,v 1.3 1996/11/14 11:44:34 lhf Exp $	4	** $Id: undump.h,v 1.6 1997/06/17 18:19:17 roberto Exp $
5	*/	5	*/
6		6
		7	#ifndef undump_h
		8	#define undump_h
		9
7	#include "func.h"	10	#include "func.h"
		11	#include "zio.h"
8		12
9	#define IsMain(f) (f->lineDefined==0)	13	#define IsMain(f) (f->lineDefined==0)
10		14
@@ -15,9 +19,12 @@ · 4 unmodified lines
15	#define ID_VAR 'V'	19	#define ID_VAR 'V'
16	#define ID_STR 'S'	20	#define ID_STR 'S'
17	#define SIGNATURE "Lua"	21	#define SIGNATURE "Lua"
18	#define VERSION 0x25 /* 2.5 */	22	#define VERSION 0x25 /* last format change was in 2.5 */
19	#define TEST_WORD 0x1234 /* a word for testing byte ordering */	23	#define TEST_WORD 0x1234 /* a word for testing byte ordering */
20	#define TEST_FLOAT 0.123456789e-23 /* a float for testing representation */	24	#define TEST_FLOAT 0.123456789e-23 /* a float for testing representation */
21		25
22	TFunc* luaI_undump1(FILE* D); /* load one chunk */	26
23	int luaI_undump(FILE* D); /* load all chunks */	27	TFunc* luaI_undump1(ZIO* Z);
		28	int luaI_undump(ZIO* Z); /* load all chunks */
		29
		30	#endif

src/zio.c+79−0

@@ -0,0 +1,79 @@
	1	/*
	2	* zio.c
	3	* a generic input stream interface
	4	* $Id: zio.c,v 1.2 1997/06/20 19:25:54 roberto Exp $
	5	*/
	6
	7	#include <stdio.h>
	8	#include <stdlib.h>
	9	#include <string.h>
	10	#include "zio.h"
	11
	12
	13	/* ----------------------------------------------------- memory buffers --- */
	14
	15	static int zmfilbuf(ZIO* z)
	16	{
	17	return EOZ;
	18	}
	19
	20	ZIO* zmopen(ZIO* z, char* b, int size)
	21	{
	22	if (b==NULL) return NULL;
	23	z->n=size;
	24	z->p= (unsigned char *)b;
	25	z->filbuf=zmfilbuf;
	26	z->u=NULL;
	27	return z;
	28	}
	29
	30	/* ------------------------------------------------------------ strings --- */
	31
	32	ZIO* zsopen(ZIO* z, char* s)
	33	{
	34	if (s==NULL) return NULL;
	35	return zmopen(z,s,strlen(s));
	36	}
	37
	38	/* -------------------------------------------------------------- FILEs --- */
	39
	40	static int zffilbuf(ZIO* z)
	41	{
	42	int n=fread(z->buffer,1,ZBSIZE,z->u);
	43	if (n==0) return EOZ;
	44	z->n=n-1;
	45	z->p=z->buffer;
	46	return *(z->p++);
	47	}
	48
	49
	50	ZIO* zFopen(ZIO* z, FILE* f)
	51	{
	52	if (f==NULL) return NULL;
	53	z->n=0;
	54	z->p=z->buffer;
	55	z->filbuf=zffilbuf;
	56	z->u=f;
	57	return z;
	58	}
	59
	60
	61	/* --------------------------------------------------------------- read --- */
	62	int zread(ZIO z, void b, int n)
	63	{
	64	while (n) {
	65	int m;
	66	if (z->n == 0) {
	67	if (z->filbuf(z) == EOZ)
	68	return n; /* retorna quantos faltaram ler */
	69	zungetc(z); /* poe o resultado de filbuf no buffer */
	70	}
	71	m = (n <= z->n) ? n : z->n; /* minimo de n e z->n */
	72	memcpy(b, z->p, m);
	73	z->n -= m;
	74	z->p += m;
	75	b = (char *)b + m;
	76	n -= m;
	77	}
	78	return 0;
	79	}

src/zio.h+48−0

@@ -0,0 +1,48 @@
	1	/*
	2	* zio.h
	3	* a generic input stream interface
	4	* $Id: zio.h,v 1.5 1997/06/20 19:25:54 roberto Exp $
	5	*/
	6
	7	#ifndef zio_h
	8	#define zio_h
	9
	10	#include <stdio.h>
	11
	12
	13
	14	/* For Lua only */
	15	#define zFopen luaZ_Fopen
	16	#define zsopen luaZ_sopen
	17	#define zmopen luaZ_mopen
	18	#define zread luaZ_read
	19
	20	#define EOZ (-1) /* end of stream */
	21
	22	typedef struct zio ZIO;
	23
	24	ZIO* zFopen(ZIO* z, FILE* f); /* open FILEs */
	25	ZIO* zsopen(ZIO* z, char* s); /* string */
	26	ZIO* zmopen(ZIO* z, char* b, int size); /* memory */
	27
	28	int zread(ZIO* z, void* b, int n); /* read next n bytes */
	29
	30	#define zgetc(z) (--(z)->n>=0 ? ((int)*(z)->p++): (z)->filbuf(z))
	31	#define zungetc(z) (++(z)->n,--(z)->p)
	32
	33
	34
	35	/* --------- Private Part ------------------ */
	36
	37	#define ZBSIZE 256 /* buffer size */
	38
	39	struct zio {
	40	int n; /* bytes still unread */
	41	unsigned char* p; /* current position in buffer */
	42	int (filbuf)(ZIO z);
	43	void* u; /* additional data */
	44	unsigned char buffer[ZBSIZE]; /* buffer */
	45	};
	46
	47
	48	#endif