plan9-archive/lua

INSTALL+1−1

@@ -32,7 +32,7 @@ This is Lua 5.1 (work). · 31 unmodified lines
32		32
33	* If you have problems (and solutions!)	33	* If you have problems (and solutions!)
34	-------------------------------------	34	-------------------------------------
35	If "make" fails, please let us know (lua@tecgraf.puc-rio.br).	35	If "make" fails, please let us know.
36	If you make changes to "config" or to the Makefiles, please send them to us.	36	If you make changes to "config" or to the Makefiles, please send them to us.
37		37
38	* Shared libraries	38	* Shared libraries

MANIFEST+114−113

@@ -1,114 +1,115 @@
1	MANIFEST contents of Lua 5.1 (work2) distribution on Mon Sep 20 21:28:06 BRT 2004	1	MANIFEST contents of Lua 5.1 (work3) distribution on Mon Dec 6 23:00:22 BRST 2004
2	lua-5.1-work2	2	lua-5.1-work3
3	lua-5.1-work2/COPYRIGHT	3	lua-5.1-work3/COPYRIGHT
4	lua-5.1-work2/HISTORY	4	lua-5.1-work3/HISTORY
5	lua-5.1-work2/INSTALL	5	lua-5.1-work3/INSTALL
6	lua-5.1-work2/MANIFEST	6	lua-5.1-work3/MANIFEST
7	lua-5.1-work2/Makefile	7	lua-5.1-work3/Makefile
8	lua-5.1-work2/README	8	lua-5.1-work3/README
9	lua-5.1-work2/bin	9	lua-5.1-work3/bin
10	lua-5.1-work2/build	10	lua-5.1-work3/build
11	lua-5.1-work2/config	11	lua-5.1-work3/config
12	lua-5.1-work2/etc	12	lua-5.1-work3/etc
13	lua-5.1-work2/etc/Makefile	13	lua-5.1-work3/etc/Makefile
14	lua-5.1-work2/etc/README	14	lua-5.1-work3/etc/README
15	lua-5.1-work2/etc/all.c	15	lua-5.1-work3/etc/all.c
16	lua-5.1-work2/etc/lua.ico	16	lua-5.1-work3/etc/lua.hpp
17	lua-5.1-work2/etc/min.c	17	lua-5.1-work3/etc/lua.ico
18	lua-5.1-work2/etc/noparser.c	18	lua-5.1-work3/etc/min.c
19	lua-5.1-work2/etc/saconfig.c	19	lua-5.1-work3/etc/noparser.c
20	lua-5.1-work2/include	20	lua-5.1-work3/etc/saconfig.c
21	lua-5.1-work2/include/Makefile	21	lua-5.1-work3/include
22	lua-5.1-work2/include/lauxlib.h	22	lua-5.1-work3/include/Makefile
23	lua-5.1-work2/include/lua.h	23	lua-5.1-work3/include/lauxlib.h
24	lua-5.1-work2/include/luaconf.h	24	lua-5.1-work3/include/lua.h
25	lua-5.1-work2/include/lualib.h	25	lua-5.1-work3/include/luaconf.h
26	lua-5.1-work2/lib	26	lua-5.1-work3/include/lualib.h
27	lua-5.1-work2/src	27	lua-5.1-work3/lib
28	lua-5.1-work2/src/Makefile	28	lua-5.1-work3/src
29	lua-5.1-work2/src/README	29	lua-5.1-work3/src/Makefile
30	lua-5.1-work2/src/lapi.c	30	lua-5.1-work3/src/README
31	lua-5.1-work2/src/lapi.h	31	lua-5.1-work3/src/lapi.c
32	lua-5.1-work2/src/lcode.c	32	lua-5.1-work3/src/lapi.h
33	lua-5.1-work2/src/lcode.h	33	lua-5.1-work3/src/lcode.c
34	lua-5.1-work2/src/ldebug.c	34	lua-5.1-work3/src/lcode.h
35	lua-5.1-work2/src/ldebug.h	35	lua-5.1-work3/src/ldebug.c
36	lua-5.1-work2/src/ldo.c	36	lua-5.1-work3/src/ldebug.h
37	lua-5.1-work2/src/ldo.h	37	lua-5.1-work3/src/ldo.c
38	lua-5.1-work2/src/ldump.c	38	lua-5.1-work3/src/ldo.h
39	lua-5.1-work2/src/lfunc.c	39	lua-5.1-work3/src/ldump.c
40	lua-5.1-work2/src/lfunc.h	40	lua-5.1-work3/src/lfunc.c
41	lua-5.1-work2/src/lgc.c	41	lua-5.1-work3/src/lfunc.h
42	lua-5.1-work2/src/lgc.h	42	lua-5.1-work3/src/lgc.c
43	lua-5.1-work2/src/lib	43	lua-5.1-work3/src/lgc.h
44	lua-5.1-work2/src/lib/Makefile	44	lua-5.1-work3/src/lib
45	lua-5.1-work2/src/lib/README	45	lua-5.1-work3/src/lib/Makefile
46	lua-5.1-work2/src/lib/lauxlib.c	46	lua-5.1-work3/src/lib/README
47	lua-5.1-work2/src/lib/lbaselib.c	47	lua-5.1-work3/src/lib/lauxlib.c
48	lua-5.1-work2/src/lib/ldblib.c	48	lua-5.1-work3/src/lib/lbaselib.c
49	lua-5.1-work2/src/lib/linit.c	49	lua-5.1-work3/src/lib/ldblib.c
50	lua-5.1-work2/src/lib/liolib.c	50	lua-5.1-work3/src/lib/linit.c
51	lua-5.1-work2/src/lib/lmathlib.c	51	lua-5.1-work3/src/lib/liolib.c
52	lua-5.1-work2/src/lib/loadlib.c	52	lua-5.1-work3/src/lib/lmathlib.c
53	lua-5.1-work2/src/lib/loslib.c	53	lua-5.1-work3/src/lib/loadlib.c
54	lua-5.1-work2/src/lib/lstrlib.c	54	lua-5.1-work3/src/lib/loslib.c
55	lua-5.1-work2/src/lib/ltablib.c	55	lua-5.1-work3/src/lib/lstrlib.c
56	lua-5.1-work2/src/llex.c	56	lua-5.1-work3/src/lib/ltablib.c
57	lua-5.1-work2/src/llex.h	57	lua-5.1-work3/src/llex.c
58	lua-5.1-work2/src/llimits.h	58	lua-5.1-work3/src/llex.h
59	lua-5.1-work2/src/lmem.c	59	lua-5.1-work3/src/llimits.h
60	lua-5.1-work2/src/lmem.h	60	lua-5.1-work3/src/lmem.c
61	lua-5.1-work2/src/lobject.c	61	lua-5.1-work3/src/lmem.h
62	lua-5.1-work2/src/lobject.h	62	lua-5.1-work3/src/lobject.c
63	lua-5.1-work2/src/lopcodes.c	63	lua-5.1-work3/src/lobject.h
64	lua-5.1-work2/src/lopcodes.h	64	lua-5.1-work3/src/lopcodes.c
65	lua-5.1-work2/src/lparser.c	65	lua-5.1-work3/src/lopcodes.h
66	lua-5.1-work2/src/lparser.h	66	lua-5.1-work3/src/lparser.c
67	lua-5.1-work2/src/lstate.c	67	lua-5.1-work3/src/lparser.h
68	lua-5.1-work2/src/lstate.h	68	lua-5.1-work3/src/lstate.c
69	lua-5.1-work2/src/lstring.c	69	lua-5.1-work3/src/lstate.h
70	lua-5.1-work2/src/lstring.h	70	lua-5.1-work3/src/lstring.c
71	lua-5.1-work2/src/ltable.c	71	lua-5.1-work3/src/lstring.h
72	lua-5.1-work2/src/ltable.h	72	lua-5.1-work3/src/ltable.c
73	lua-5.1-work2/src/ltm.c	73	lua-5.1-work3/src/ltable.h
74	lua-5.1-work2/src/ltm.h	74	lua-5.1-work3/src/ltm.c
75	lua-5.1-work2/src/lua	75	lua-5.1-work3/src/ltm.h
76	lua-5.1-work2/src/lua/Makefile	76	lua-5.1-work3/src/lua
77	lua-5.1-work2/src/lua/README	77	lua-5.1-work3/src/lua/Makefile
78	lua-5.1-work2/src/lua/lua.c	78	lua-5.1-work3/src/lua/README
79	lua-5.1-work2/src/luac	79	lua-5.1-work3/src/lua/lua.c
80	lua-5.1-work2/src/luac/Makefile	80	lua-5.1-work3/src/luac
81	lua-5.1-work2/src/luac/README	81	lua-5.1-work3/src/luac/Makefile
82	lua-5.1-work2/src/luac/luac.c	82	lua-5.1-work3/src/luac/README
83	lua-5.1-work2/src/luac/print.c	83	lua-5.1-work3/src/luac/luac.c
84	lua-5.1-work2/src/lundump.c	84	lua-5.1-work3/src/luac/print.c
85	lua-5.1-work2/src/lundump.h	85	lua-5.1-work3/src/lundump.c
86	lua-5.1-work2/src/lvm.c	86	lua-5.1-work3/src/lundump.h
87	lua-5.1-work2/src/lvm.h	87	lua-5.1-work3/src/lvm.c
88	lua-5.1-work2/src/lzio.c	88	lua-5.1-work3/src/lvm.h
89	lua-5.1-work2/src/lzio.h	89	lua-5.1-work3/src/lzio.c
90	lua-5.1-work2/test	90	lua-5.1-work3/src/lzio.h
91	lua-5.1-work2/test/README	91	lua-5.1-work3/test
92	lua-5.1-work2/test/bisect.lua	92	lua-5.1-work3/test/README
93	lua-5.1-work2/test/cf.lua	93	lua-5.1-work3/test/bisect.lua
94	lua-5.1-work2/test/echo.lua	94	lua-5.1-work3/test/cf.lua
95	lua-5.1-work2/test/env.lua	95	lua-5.1-work3/test/echo.lua
96	lua-5.1-work2/test/factorial.lua	96	lua-5.1-work3/test/env.lua
97	lua-5.1-work2/test/fib.lua	97	lua-5.1-work3/test/factorial.lua
98	lua-5.1-work2/test/fibfor.lua	98	lua-5.1-work3/test/fib.lua
99	lua-5.1-work2/test/globals.lua	99	lua-5.1-work3/test/fibfor.lua
100	lua-5.1-work2/test/hello.lua	100	lua-5.1-work3/test/globals.lua
101	lua-5.1-work2/test/life.lua	101	lua-5.1-work3/test/hello.lua
102	lua-5.1-work2/test/lua	102	lua-5.1-work3/test/life.lua
103	lua-5.1-work2/test/luac	103	lua-5.1-work3/test/lua
104	lua-5.1-work2/test/luac.lua	104	lua-5.1-work3/test/luac
105	lua-5.1-work2/test/printf.lua	105	lua-5.1-work3/test/luac.lua
106	lua-5.1-work2/test/readonly.lua	106	lua-5.1-work3/test/printf.lua
107	lua-5.1-work2/test/sieve.lua	107	lua-5.1-work3/test/readonly.lua
108	lua-5.1-work2/test/sort.lua	108	lua-5.1-work3/test/sieve.lua
109	lua-5.1-work2/test/table.lua	109	lua-5.1-work3/test/sort.lua
110	lua-5.1-work2/test/trace-calls.lua	110	lua-5.1-work3/test/table.lua
111	lua-5.1-work2/test/trace-globals.lua	111	lua-5.1-work3/test/trace-calls.lua
112	lua-5.1-work2/test/undefined.lua	112	lua-5.1-work3/test/trace-globals.lua
113	lua-5.1-work2/test/xd.lua	113	lua-5.1-work3/test/undefined.lua
		114	lua-5.1-work3/test/xd.lua
114	END OF MANIFEST	115	END OF MANIFEST

Makefile+2−25

@@ -14,8 +14,6 @@ all clean co klean: · 13 unmodified lines
14	cd src/luac; $(MAKE) $@	14	cd src/luac; $(MAKE) $@
15	cd src/lua; $(MAKE) $@	15	cd src/lua; $(MAKE) $@
16		16
17	clean klean: soclean
18
19	# in case they were not created during unpacking	17	# in case they were not created during unpacking
20	all: bin lib	18	all: bin lib
21		19
@@ -38,27 +36,6 @@ install: all strip · 16 unmodified lines
38	$(INSTALL_DATA) lib/*.a $(INSTALL_LIB)	36	$(INSTALL_DATA) lib/*.a $(INSTALL_LIB)
39	$(INSTALL_DATA) doc/*.1 $(INSTALL_MAN)	37	$(INSTALL_DATA) doc/*.1 $(INSTALL_MAN)
40		38
41	# shared libraries (for Linux)
42	so:
43	ld -o lib/liblua.so.$V -shared src/*.o
44	ld -o lib/liblualib.so.$V -shared src/lib/*.o
45	cd lib; ln -fs liblua.so.$V liblua.so; ln -fs liblualib.so.$V liblualib.so
46
47	# binaries using shared libraries
48	sobin:
49	rm -f bin/lua*
50	cd src/lua; $(MAKE)
51	cd src/luac; $(MAKE)
52
53	# install shared libraries
54	soinstall:
55	$(INSTALL_EXEC) lib/.so. $(INSTALL_LIB)
56	cd $(INSTALL_LIB); ln -fs liblua.so.$V liblua.so; ln -fs liblualib.so.$V liblualib.so
57
58	# clean shared libraries
59	soclean:
60	rm -f lib/.so bin/lua*
61
62	# echo config parameters	39	# echo config parameters
63	echo:	40	echo:
64	@echo ""	41	@echo ""
@@ -98,7 +75,7 @@ lecho: · 33 unmodified lines
98	@make echo \| grep = \| sed -e 's/= /= "/' -e 's/$$/"/' #-e 's/""/nil/'	75	@make echo \| grep = \| sed -e 's/= /= "/' -e 's/$$/"/' #-e 's/""/nil/'
99	@echo "-- EOF"	76	@echo "-- EOF"
100		77
101	# (end of Makefile)
102
103	newer:	78	newer:
104	@find . -newer MANIFEST -type f	79	@find . -newer MANIFEST -type f
		80
		81	# (end of Makefile)

README+3−2

 * Contacting the authors
   ----------------------
-  Send your comments, questions, and bug reports to lua@tecgraf.puc-rio.br.
+  Send your comments, questions, and bug reports to
+	lua-team AT tecgraf.puc-rio.br.
   For more information about the authors, see http://www.lua.org/authors.html .
-  For reporting bugs, try also the mailing list: lua-l@tecgraf.puc-rio.br.
+  For reporting bugs, try also the mailing list: lua@bazar2.conectiva.com.br .
   For more information about this list, including instructions on how to
   subscribe and access the archives, see http://www.lua.org/lua-l.html .

config+3−3

@@ -21,15 +21,15 @@ USERCONF= · 20 unmodified lines
21	# interface (e.g., Linux, Solaris, IRIX, BSD, AIX, HPUX, and probably others),	21	# interface (e.g., Linux, Solaris, IRIX, BSD, AIX, HPUX, and probably others),
22	# uncomment the next two lines. Also read the next paragraph.	22	# uncomment the next two lines. Also read the next paragraph.
23	#	23	#
24	#LOADLIB= -DUSE_DLOPEN=1	24	LOADLIB= -DUSE_DLOPEN=1
25	#DLLIB= -ldl	25	DLLIB= -ldl
26	#	26	#
27	# In Linux with gcc, you should also uncomment the next definition for	27	# In Linux with gcc, you should also uncomment the next definition for
28	# MYLDFLAGS, which passes -E (= -export-dynamic) to the linker. This option	28	# MYLDFLAGS, which passes -E (= -export-dynamic) to the linker. This option
29	# allows dynamic libraries to link back to the `lua' program, so that they do	29	# allows dynamic libraries to link back to the `lua' program, so that they do
30	# not need the Lua libraries. (Other systems may have an equivalent facility.)	30	# not need the Lua libraries. (Other systems may have an equivalent facility.)
31	#	31	#
32	#MYLDFLAGS= -Wl,-E	32	MYLDFLAGS= -Wl,-E
33	#	33	#
34	# On Windows systems. support for dynamic loading is enabled by default.	34	# On Windows systems. support for dynamic loading is enabled by default.
35	# To disable this support, uncomment the next line.	35	# To disable this support, uncomment the next line.

etc/all.c+0−1

@@ -33,7 +33,6 @@ · 32 unmodified lines
33	#include "linit.c"	33	#include "linit.c"
34	#include "lmathlib.c"	34	#include "lmathlib.c"
35	#include "loadlib.c"	35	#include "loadlib.c"
36	#define pushresult pushresult2
37	#include "loslib.c"	36	#include "loslib.c"
38	#include "lstrlib.c"	37	#include "lstrlib.c"
39	#include "ltablib.c"	38	#include "ltablib.c"

etc/lua.hpp+8−0

@@ -0,0 +1,8 @@
	1	// lua.hpp
	2	// Lua header files for C++
	3
	4	extern "C" {
	5	#include "lua.h"
	6	#include "lualib.h"
	7	#include "lauxlib.h"
	8	}

etc/min.c+1−0

@@ -43,5 +43,6 @@ int main(void) · 42 unmodified lines
43	lua_register(L,"print",print);	43	lua_register(L,"print",print);
44	if (lua_load(L,getF,stdin,"=stdin") \|\| lua_pcall(L,0,0,0))	44	if (lua_load(L,getF,stdin,"=stdin") \|\| lua_pcall(L,0,0,0))
45	fprintf(stderr,"%s\n",lua_tostring(L,-1));	45	fprintf(stderr,"%s\n",lua_tostring(L,-1));
		46	lua_close(L);
46	return 0;	47	return 0;
47	}	48	}

include/lauxlib.h+14−8

 /*
-** $Id: lauxlib.h,v 1.70 2004/07/09 18:23:17 roberto Exp $
+** $Id: lauxlib.h,v 1.73 2004/10/18 12:51:44 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 LUALIB_API lua_State *(luaL_newstate) (void);
+LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
+                                     const char *r);
+LUALIB_API const char *luaL_getfield (lua_State *L, int idx, const char *fname);
+LUALIB_API const char *luaL_setfield (lua_State *L, int idx, const char *fname);
 /*
 ** ===============================================================
 */
 #define luaL_argcheck(L, cond,numarg,extramsg)	\
-		((void)((cond) || luaL_argerror(L, numarg,extramsg)))
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
 #define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
 #define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
-#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, n))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
-#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, n,d))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
-#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, n))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, n,d))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
-#define luaL_typename(L,i)	lua_typename(L,lua_type(L,(i)))
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
 /*
 ** {======================================================
 #define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
-#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, ref)
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
 #endif

include/lua.h+26−20

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lua.h,v 1.193 2004/09/15 20:39:42 roberto Exp $	2	** $Id: lua.h,v 1.196 2004/12/06 17:53:42 roberto Exp $
3	** Lua - An Extensible Extension Language	3	** Lua - An Extensible Extension Language
4	** Tecgraf: Computer Graphics Technology Group, PUC-Rio, Brazil	4	** Tecgraf: Computer Graphics Technology Group, PUC-Rio, Brazil
5	** http://www.lua.org mailto:info@lua.org	5	** http://www.lua.org mailto:info@lua.org
@@ -17,7 +17,7 @@ · 11 unmodified lines
17	#include "luaconf.h"	17	#include "luaconf.h"
18		18
19		19
20	#define LUA_VERSION "Lua 5.1 (work2)"	20	#define LUA_VERSION "Lua 5.1 (work3)"
21	#define LUA_COPYRIGHT "Copyright (C) 1994-2004 Tecgraf, PUC-Rio"	21	#define LUA_COPYRIGHT "Copyright (C) 1994-2004 Tecgraf, PUC-Rio"
22	#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"	22	#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
23		23
@@ -81,6 +81,10 @@ typedef void * (lua_Alloc) (void ud, void *ptr, size_t osize, size_t nsize); · 57 unmodified lines
81	#define LUA_TTHREAD 8	81	#define LUA_TTHREAD 8
82		82
83		83
		84	/* first index for arrays */
		85	#define LUA_FIRSTINDEX 1
		86
		87
84	/* minimum Lua stack available to a C function */	88	/* minimum Lua stack available to a C function */
85	#define LUA_MINSTACK 20	89	#define LUA_MINSTACK 20
86		90
@@ -216,11 +220,13 @@ LUA_API int lua_threadstatus (lua_State *L); · 129 unmodified lines
216	** garbage-collection function and options	220	** garbage-collection function and options
217	*/	221	*/
218		222
219	#define LUA_GCSTOP 0	223	#define LUA_GCSTOP 0
220	#define LUA_GCRESTART 1	224	#define LUA_GCRESTART 1
221	#define LUA_GCCOLLECT 2	225	#define LUA_GCCOLLECT 2
222	#define LUA_GCCOUNT 3	226	#define LUA_GCCOUNT 3
223	#define LUA_GCSTEP 4	227	#define LUA_GCSTEP 4
		228	#define LUA_GCSETSTEPMUL 5
		229	#define LUA_GCSETINCMODE 6
224		230
225	LUA_API int lua_gc (lua_State *L, int what, int data);	231	LUA_API int lua_gc (lua_State *L, int what, int data);
226		232
@@ -251,26 +257,26 @@ LUA_API lua_Alloc lua_getallocf (lua_State L, void *ud); · 24 unmodified lines
251		257
252	#define lua_newtable(L) lua_createtable(L, 0, 0)	258	#define lua_newtable(L) lua_createtable(L, 0, 0)
253		259
254	#define lua_register(L,n,f) (lua_pushcfunction(L,f), lua_setglobal(L,n))	260	#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
255		261
256	#define lua_pushcfunction(L,f) lua_pushcclosure(L, f, 0)	262	#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
257		263
258	#define lua_strlen(L,i) lua_objsize(L,i)	264	#define lua_strlen(L,i) lua_objsize(L, (i))
259		265
260	#define lua_isfunction(L,n) (lua_type(L,n) == LUA_TFUNCTION)	266	#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
261	#define lua_istable(L,n) (lua_type(L,n) == LUA_TTABLE)	267	#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
262	#define lua_islightuserdata(L,n) (lua_type(L,n) == LUA_TLIGHTUSERDATA)	268	#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
263	#define lua_isnil(L,n) (lua_type(L,n) == LUA_TNIL)	269	#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
264	#define lua_isboolean(L,n) (lua_type(L,n) == LUA_TBOOLEAN)	270	#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
265	#define lua_isthread(L,n) (lua_type(L,n) == LUA_TTHREAD)	271	#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
266	#define lua_isnone(L,n) (lua_type(L,n) == LUA_TNONE)	272	#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
267	#define lua_isnoneornil(L, n) (lua_type(L,n) <= 0)	273	#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
268		274
269	#define lua_pushliteral(L, s) \	275	#define lua_pushliteral(L, s) \
270	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)	276	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
271		277
272	#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, s)	278	#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, (s))
273	#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, s)	279	#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, (s))
274		280
275		281
276		282

include/luaconf.h+77−33

 /*
-** $Id: luaconf.h,v 1.12 2004/09/10 17:30:46 roberto Exp $
+** $Id: luaconf.h,v 1.20 2004/12/06 17:53:42 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
 */
 /* default path */
-#define LUA_PATH_DEFAULT	"?;?.lua"
+#define LUA_PATH_DEFAULT \
+   "./?.lua;/usr/local/share/lua/5.0/?.lua;/usr/local/share/lua/5.0/?/init.lua"
+#define LUA_CPATH_DEFAULT \
+   "./?.so;/usr/local/lib/lua/5.0/?.so;/usr/local/lib/lua/5.0/lib?.so"
 /* type of numbers in Lua */
 #define LUA_NUMBER_FMT		"%.14g"
-/* type for integer functions */
+/*
-#define LUA_INTEGER	long
+** type for integer functions
+** on most machines, `ptrdiff_t' gives a reasonable size for integers
+*/
+#define LUA_INTEGER	ptrdiff_t
 /* mark for all API functions */
 #define LUAL_BUFFERSIZE   BUFSIZ
-/* first index for arrays */
-#define LUA_FIRSTINDEX		1
 /* assertions in Lua (mainly for internal debugging) */
 #define lua_assert(c)		((void)0)
 #ifdef LUA_CORE
 /* LUA-C API assertions */
-#define api_check(L, o)		lua_assert(o)
+#define api_check(L,o)		lua_assert(o)
-/* an unsigned integer with at least 32 bits */
+/* number of bits in an `int' */
-#define LUA_UINT32	unsigned long
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760
+#define LUA_BITSINT	16
+#elif INT_MAX > 2147483640L
+/* `int' has at least 32 bits */
+#define LUA_BITSINT	32
+#else
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif
-/* a signed integer with at least 32 bits */
+/*
+** L_UINT32: unsigned integer with at least 32 bits
+** L_INT32: signed integer with at least 32 bits
+** LU_MEM: an unsigned integer big enough to count the total memory used by Lua
+** L_MEM: a signed integer big enough to count the total memory used by Lua
+*/
+#if LUA_BITSINT >= 32
+#define LUA_UINT32	unsigned int
+#define LUA_INT32	int
+#define LUA_MAXINT32	INT_MAX
+#define LU_MEM		size_t
+#define L_MEM		ptrdiff_t
+#else
+/* 16-bit ints */
+#define LUA_UINT32	unsigned long
 #define LUA_INT32	long
 #define LUA_MAXINT32	LONG_MAX
+#define LU_MEM		LUA_UINT32
+#define L_MEM		ptrdiff_t
+#endif
 /* maximum depth for calls (unsigned short) */
-#define LUA_MAXCALLS	4096
+#define LUA_MAXCALLS	10000
 /*
 ** maximum depth for C calls (unsigned short): Not too big, or may
 /* maximum number of upvalues per function */
-#define MAXUPVALUES		32	/* <MAXSTACK */
+#define MAXUPVALUES		60	/* <MAXSTACK */
 /* maximum size of expressions for optimizing `while' code */
 /* function to convert a lua_Number to int (with any rounding method) */
 #if defined(__GNUC__) && defined(__i386)
 #define lua_number2int(i,d)	__asm__ ("fistpl %0":"=m"(i):"t"(d):"st")
-#elif 0
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199900L)
 /* on machines compliant with C99, you can try `lrint' */
 #include <math.h>
 #define lua_number2int(i,d)	((i)=lrint(d))
 #endif
 /* function to convert a lua_Number to lua_Integer (with any rounding method) */
-#define lua_number2integer(i,n)		lua_number2int(i,n)
+#define lua_number2integer(i,n)		lua_number2int((i), (n))
 /* function to convert a lua_Number to a string */
 #define LUA_UACNUMBER	double
-/* number of bits in an `int' */
-/* avoid overflows in comparison */
-#if INT_MAX-20 < 32760
-#define LUA_BITSINT	16
-#elif INT_MAX > 2147483640L
-/* machine has at least 32 bits */
-#define LUA_BITSINT	32
-#else
-#error "you must define LUA_BITSINT with number of bits in an integer"
-#endif
 /* type to ensure maximum alignment */
 #define LUSER_ALIGNMENT_T	union { double u; void *s; long l; }
 #ifndef __cplusplus
 /* default handling with long jumps */
 #include <setjmp.h>
-#define L_THROW(c)	longjmp((c)->b, 1)
+#define L_THROW(L,c)	longjmp((c)->b, 1)
-#define L_TRY(c,a)	if (setjmp((c)->b) == 0) { a }
+#define L_TRY(L,c,a)	if (setjmp((c)->b) == 0) { a }
 #define l_jmpbuf	jmp_buf
 #else
 /* C++ exceptions */
-#define L_THROW(c)	throw(c)
+#define L_THROW(L,c)	throw(c)
-#define L_TRY(c,a)	try { a } catch(...) \
+#define L_TRY(L,c,a)	try { a } catch(...) \
 	{ if ((c)->status == 0) (c)->status = -1; }
 #define l_jmpbuf	int  /* dummy variable */
 #endif
 /* allows user-specific initialization on new threads */
-#define lua_userstateopen(l)	/* empty */
+#define lua_userstateopen(L)	/* empty */
+/* initial GC parameters */
+#define STEPMUL		4
 #endif
 /* }====================================================== */
 /* `assert' options */
-/* environment variable that holds the search path for packages */
+/* environment variables that hold the search path for packages */
 #define LUA_PATH	"LUA_PATH"
+#define LUA_CPATH	"LUA_CPATH"
+/* prefix for open functions in C libraries */
+#if defined(__APPLE__) && defined(__MACH__)
+#define LUA_POF		"_luaopen_"
+#else
+#define LUA_POF		"luaopen_"
+#endif
+/* directory separator (for submodules) */
+#define LUA_DIRSEP	"/"
 /* separator of templates in a path */
 #define LUA_PATH_SEP	';'
 /*
 ** by default, gcc does not get `tmpname'
 */
 #ifdef __GNUC__
 #define USE_TMPNAME	0
 #else
 #endif
+/*
+** Configuration for loadlib
+*/
+#if defined(__linux) || defined(sun) || defined(sgi) || defined(BSD)
+#define USE_DLOPEN
+#elif defined(_WIN32)
+#define USE_DLL
+#elif defined(__APPLE__) && defined(__MACH__)
+#define USE_DYLD
+#endif
 #endif

src/lapi.c+52−42

 /*
-** $Id: lapi.c,v 2.19 2004/09/15 20:39:42 roberto Exp $
+** $Id: lapi.c,v 2.22 2004/12/06 17:53:42 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
-static TValue *luaA_index (lua_State *L, int idx) {
+static TValue *index2adr (lua_State *L, int idx) {
   if (idx > 0) {
     TValue *o = L->base + (idx - 1);
     api_check(L, idx <= L->ci->top - L->base);
 LUA_API void lua_remove (lua_State *L, int idx) {
   StkId p;
   lua_lock(L);
-  p = luaA_index(L, idx);
+  p = index2adr(L, idx);
   api_checkvalidindex(L, p);
   while (++p < L->top) setobjs2s(L, p-1, p);
   L->top--;
   StkId p;
   StkId q;
   lua_lock(L);
-  p = luaA_index(L, idx);
+  p = index2adr(L, idx);
   api_checkvalidindex(L, p);
   for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
   setobjs2s(L, p, L->top);
   StkId o;
   lua_lock(L);
   api_checknelems(L, 1);
-  o = luaA_index(L, idx);
+  o = index2adr(L, idx);
   api_checkvalidindex(L, o);
   setobj(L, o, L->top - 1);
   if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
 LUA_API void lua_pushvalue (lua_State *L, int idx) {
   lua_lock(L);
-  setobj2s(L, L->top, luaA_index(L, idx));
+  setobj2s(L, L->top, index2adr(L, idx));
   api_incr_top(L);
   lua_unlock(L);
 }
 LUA_API int lua_type (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   return (o == &luaO_nilobject) ? LUA_TNONE : ttype(o);
 }
 LUA_API int lua_iscfunction (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   return iscfunction(o);
 }
 LUA_API int lua_isnumber (lua_State *L, int idx) {
   TValue n;
-  const TValue *o = luaA_index(L, idx);
+  const TValue *o = index2adr(L, idx);
   return tonumber(o, &n);
 }
 LUA_API int lua_isuserdata (lua_State *L, int idx) {
-  const TValue *o = luaA_index(L, idx);
+  const TValue *o = index2adr(L, idx);
   return (ttisuserdata(o) || ttislightuserdata(o));
 }
 LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
-  StkId o1 = luaA_index(L, index1);
+  StkId o1 = index2adr(L, index1);
-  StkId o2 = luaA_index(L, index2);
+  StkId o2 = index2adr(L, index2);
   return (o1 == &luaO_nilobject || o2 == &luaO_nilobject) ? 0
          : luaO_rawequalObj(o1, o2);
 }
   StkId o1, o2;
   int i;
   lua_lock(L);  /* may call tag method */
-  o1 = luaA_index(L, index1);
+  o1 = index2adr(L, index1);
-  o2 = luaA_index(L, index2);
+  o2 = index2adr(L, index2);
   i = (o1 == &luaO_nilobject || o2 == &luaO_nilobject) ? 0
        : equalobj(L, o1, o2);
   lua_unlock(L);
   StkId o1, o2;
   int i;
   lua_lock(L);  /* may call tag method */
-  o1 = luaA_index(L, index1);
+  o1 = index2adr(L, index1);
-  o2 = luaA_index(L, index2);
+  o2 = index2adr(L, index2);
   i = (o1 == &luaO_nilobject || o2 == &luaO_nilobject) ? 0
        : luaV_lessthan(L, o1, o2);
   lua_unlock(L);
 LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
   TValue n;
-  const TValue *o = luaA_index(L, idx);
+  const TValue *o = index2adr(L, idx);
   if (tonumber(o, &n))
     return nvalue(o);
   else
 LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
   TValue n;
-  const TValue *o = luaA_index(L, idx);
+  const TValue *o = index2adr(L, idx);
   if (tonumber(o, &n)) {
     lua_Integer res;
     lua_number2integer(res, nvalue(o));
 LUA_API int lua_toboolean (lua_State *L, int idx) {
-  const TValue *o = luaA_index(L, idx);
+  const TValue *o = index2adr(L, idx);
   return !l_isfalse(o);
 }
 LUA_API const char *lua_tostring (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   if (ttisstring(o))
     return svalue(o);
   else {
 LUA_API size_t lua_objsize (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   if (ttisstring(o))
     return tsvalue(o)->len;
   else if (ttisuserdata(o))
 LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
 }
 LUA_API void *lua_touserdata (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   switch (ttype(o)) {
     case LUA_TUSERDATA: return (rawuvalue(o) + 1);
     case LUA_TLIGHTUSERDATA: return pvalue(o);
 LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   return (!ttisthread(o)) ? NULL : thvalue(o);
 }
 LUA_API const void *lua_topointer (lua_State *L, int idx) {
-  StkId o = luaA_index(L, idx);
+  StkId o = index2adr(L, idx);
   switch (ttype(o)) {
     case LUA_TTABLE: return hvalue(o);
     case LUA_TFUNCTION: return clvalue(o);
 LUA_API void lua_gettable (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_checkvalidindex(L, t);
   luaV_gettable(L, t, L->top - 1, L->top - 1, NULL);
   lua_unlock(L);
   StkId t;
   TValue key;
   lua_lock(L);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_checkvalidindex(L, t);
   setsvalue(L, &key, luaS_new(L, k));
   luaV_gettable(L, t, &key, L->top, NULL);
 LUA_API void lua_rawget (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_check(L, ttistable(t));
   setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
   lua_unlock(L);
 LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
   StkId o;
   lua_lock(L);
-  o = luaA_index(L, idx);
+  o = index2adr(L, idx);
   api_check(L, ttistable(o));
   setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
   api_incr_top(L);
   Table *mt = NULL;
   int res;
   lua_lock(L);
-  obj = luaA_index(L, objindex);
+  obj = index2adr(L, objindex);
   switch (ttype(obj)) {
     case LUA_TTABLE:
       mt = hvalue(obj)->metatable;
 LUA_API void lua_getfenv (lua_State *L, int idx) {
   StkId o;
   lua_lock(L);
-  o = luaA_index(L, idx);
+  o = index2adr(L, idx);
   api_checkvalidindex(L, o);
   setobj2s(L, L->top, isLfunction(o) ? &clvalue(o)->l.g : gt(L));
   api_incr_top(L);
   StkId t;
   lua_lock(L);
   api_checknelems(L, 2);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_checkvalidindex(L, t);
   luaV_settable(L, t, L->top - 2, L->top - 1, NULL);
   L->top -= 2;  /* pop index and value */
   TValue key;
   lua_lock(L);
   api_checknelems(L, 1);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_checkvalidindex(L, t);
   setsvalue(L, &key, luaS_new(L, k));
   luaV_settable(L, t, &key, L->top - 1, NULL);
   StkId t;
   lua_lock(L);
   api_checknelems(L, 2);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_check(L, ttistable(t));
   setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
   luaC_barriert(L, hvalue(t), L->top-1);
   StkId o;
   lua_lock(L);
   api_checknelems(L, 1);
-  o = luaA_index(L, idx);
+  o = index2adr(L, idx);
   api_check(L, ttistable(o));
   setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
   luaC_barriert(L, hvalue(o), L->top-1);
   int res = 1;
   lua_lock(L);
   api_checknelems(L, 1);
-  obj = luaA_index(L, objindex);
+  obj = index2adr(L, objindex);
   api_checkvalidindex(L, obj);
   if (ttisnil(L->top - 1))
     mt = NULL;
   int res = 0;
   lua_lock(L);
   api_checknelems(L, 1);
-  o = luaA_index(L, idx);
+  o = index2adr(L, idx);
   api_checkvalidindex(L, o);
   api_check(L, ttistable(L->top - 1));
   if (isLfunction(o)) {
   if (errfunc == 0)
     func = 0;
   else {
-    StkId o = luaA_index(L, errfunc);
+    StkId o = index2adr(L, errfunc);
     api_checkvalidindex(L, o);
     func = savestack(L, o);
   }
   g = G(L);
   switch (what) {
     case LUA_GCSTOP: {
-      g->GCthreshold = MAXLMEM;
+      g->GCthreshold = MAX_LUMEM;
       break;
     }
     case LUA_GCRESTART: {
       luaC_step(L);
       break;
     }
+    case LUA_GCSETSTEPMUL: {
+      res = g->stepmul;
+      g->stepmul = data;
+      break;
+    }
+    case LUA_GCSETINCMODE: {
+      res = g->incgc;
+      g->incgc = data;
+      break;
+    }
     default: res = -1;  /* invalid option */
   }
   lua_unlock(L);
   StkId t;
   int more;
   lua_lock(L);
-  t = luaA_index(L, idx);
+  t = index2adr(L, idx);
   api_check(L, ttistable(t));
   more = luaH_next(L, hvalue(t), L->top - 1);
   if (more) {
   const char *name;
   TValue *val;
   lua_lock(L);
-  name = aux_upvalue(L, luaA_index(L, funcindex), n, &val);
+  name = aux_upvalue(L, index2adr(L, funcindex), n, &val);
   if (name) {
     setobj2s(L, L->top, val);
     api_incr_top(L);
   TValue *val;
   StkId fi;
   lua_lock(L);
-  fi = luaA_index(L, funcindex);
+  fi = index2adr(L, funcindex);
   api_checknelems(L, 1);
   name = aux_upvalue(L, fi, n, &val);
   if (name) {

src/lcode.c+50−27

 /*
-** $Id: lcode.c,v 2.6 2004/08/24 20:09:11 roberto Exp $
+** $Id: lcode.c,v 2.8 2004/12/03 20:35:33 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 }
-static int luaK_condjump (FuncState *fs, OpCode op, int A, int B, int C) {
+static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
   luaK_codeABC(fs, op, A, B, C);
   return luaK_jump(fs);
 }
-static void luaK_fixjump (FuncState *fs, int pc, int dest) {
+static void fixjump (FuncState *fs, int pc, int dest) {
   Instruction *jmp = &fs->f->code[pc];
   int offset = dest-(pc+1);
   lua_assert(dest != NO_JUMP);
 }
-static int luaK_getjump (FuncState *fs, int pc) {
+static int getjump (FuncState *fs, int pc) {
   int offset = GETARG_sBx(fs->f->code[pc]);
   if (offset == NO_JUMP)  /* point to itself represents end of list */
     return NO_JUMP;  /* end of list */
 ** (or produce an inverted value)
 */
 static int need_value (FuncState *fs, int list, int cond) {
-  for (; list != NO_JUMP; list = luaK_getjump(fs, list)) {
+  for (; list != NO_JUMP; list = getjump(fs, list)) {
     Instruction i = *getjumpcontrol(fs, list);
     if (GET_OPCODE(i) != OP_TEST || GETARG_C(i) != cond) return 1;
   }
 }
-static void luaK_patchlistaux (FuncState *fs, int list,
+static void patchlistaux (FuncState *fs, int list,
           int ttarget, int treg, int ftarget, int freg, int dtarget) {
   while (list != NO_JUMP) {
-    int next = luaK_getjump(fs, list);
+    int next = getjump(fs, list);
     Instruction *i = getjumpcontrol(fs, list);
     if (GET_OPCODE(*i) != OP_TEST) {
       lua_assert(dtarget != NO_JUMP);
-      luaK_fixjump(fs, list, dtarget);  /* jump to default target */
+      fixjump(fs, list, dtarget);  /* jump to default target */
     }
     else {
       if (GETARG_C(*i)) {
         lua_assert(ttarget != NO_JUMP);
         patchtestreg(i, treg);
-        luaK_fixjump(fs, list, ttarget);
+        fixjump(fs, list, ttarget);
       }
       else {
         lua_assert(ftarget != NO_JUMP);
         patchtestreg(i, freg);
-        luaK_fixjump(fs, list, ftarget);
+        fixjump(fs, list, ftarget);
       }
     }
     list = next;
 }
-static void luaK_dischargejpc (FuncState *fs) {
+static void dischargejpc (FuncState *fs) {
-  luaK_patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc, NO_REG, fs->pc);
+  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc, NO_REG, fs->pc);
   fs->jpc = NO_JUMP;
 }
     luaK_patchtohere(fs, list);
   else {
     lua_assert(target < fs->pc);
-    luaK_patchlistaux(fs, list, target, NO_REG, target, NO_REG, target);
+    patchlistaux(fs, list, target, NO_REG, target, NO_REG, target);
   }
 }
   else {
     int list = *l1;
     int next;
-    while ((next = luaK_getjump(fs, list)) != NO_JUMP)  /* find last element */
+    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
       list = next;
-    luaK_fixjump(fs, list, l2);
+    fixjump(fs, list, l2);
   }
 }
 }
-static int nil_constant (FuncState *fs) {
+static int boolK (FuncState *fs, int b) {
+  TValue o;
+  setbvalue(&o, b);
+  return addk(fs, &o, &o);
+}
+static int nilK (FuncState *fs) {
   TValue k, v;
   setnilvalue(&v);
   /* cannot use nil as key; instead use table itself to represent nil */
 }
-static void luaK_exp2reg (FuncState *fs, expdesc *e, int reg) {
+static void exp2reg (FuncState *fs, expdesc *e, int reg) {
   discharge2reg(fs, e, reg);
   if (e->k == VJMP)
     luaK_concat(fs, &e->t, e->info);  /* put this jump in `t' list */
       luaK_patchtohere(fs, fj);
     }
     final = luaK_getlabel(fs);
-    luaK_patchlistaux(fs, e->f, p_f, NO_REG, final, reg, p_f);
+    patchlistaux(fs, e->f, p_f, NO_REG, final, reg, p_f);
-    luaK_patchlistaux(fs, e->t, final, reg, p_t, NO_REG, p_t);
+    patchlistaux(fs, e->t, final, reg, p_t, NO_REG, p_t);
   }
   e->f = e->t = NO_JUMP;
   e->info = reg;
   luaK_dischargevars(fs, e);
   freeexp(fs, e);
   luaK_reserveregs(fs, 1);
-  luaK_exp2reg(fs, e, fs->freereg - 1);
+  exp2reg(fs, e, fs->freereg - 1);
 }
   if (e->k == VNONRELOC) {
     if (!hasjumps(e)) return e->info;  /* exp is already in a register */
     if (e->info >= fs->nactvar) {  /* reg. is not a local? */
-      luaK_exp2reg(fs, e, e->info);  /* put value on it */
+      exp2reg(fs, e, e->info);  /* put value on it */
       return e->info;
     }
   }
 int luaK_exp2RK (FuncState *fs, expdesc *e) {
   luaK_exp2val(fs, e);
   switch (e->k) {
+    case VTRUE:
+    case VFALSE:
     case VNIL: {
       if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
-        e->info = nil_constant(fs);
+        e->info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE));
         e->k = VK;
         return RKASK(e->info);
       }
   switch (var->k) {
     case VLOCAL: {
       freeexp(fs, ex);
-      luaK_exp2reg(fs, ex, var->info);
+      exp2reg(fs, ex, var->info);
       return;
     }
     case VUPVAL: {
     Instruction ie = getcode(fs, e);
     if (GET_OPCODE(ie) == OP_NOT) {
       fs->pc--;  /* remove previous OP_NOT */
-      return luaK_condjump(fs, OP_TEST, NO_REG, GETARG_B(ie), !cond);
+      return condjump(fs, OP_TEST, NO_REG, GETARG_B(ie), !cond);
     }
     /* else go through */
   }
   discharge2anyreg(fs, e);
   freeexp(fs, e);
-  return luaK_condjump(fs, OP_TEST, NO_REG, e->info, cond);
+  return condjump(fs, OP_TEST, NO_REG, e->info, cond);
 }
       temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
     }
     else if (op == OPR_NE) cond = 0;
-    res->info = luaK_condjump(fs, ops[op - OPR_NE], cond, o1, o2);
+    res->info = condjump(fs, ops[op - OPR_NE], cond, o1, o2);
     res->k = VJMP;
   }
 }
 int luaK_code (FuncState *fs, Instruction i, int line) {
   Proto *f = fs->f;
-  luaK_dischargejpc(fs);  /* `pc' will change */
+  dischargejpc(fs);  /* `pc' will change */
   /* put new instruction in code array */
   luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                   MAX_INT, "code size overflow");
   return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
 }
+void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
+  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
+  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
+  lua_assert(tostore != 0);
+  if (c <= MAXARG_C)
+    luaK_codeABC(fs, OP_SETLIST, base, b, c);
+  else {
+    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
+    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
+  }
+  fs->freereg = base + 1;  /* free registers with list values */
+}

src/lcode.h+2−1

 /*
-** $Id: lcode.h,v 1.39 2004/05/31 18:51:50 roberto Exp $
+** $Id: lcode.h,v 1.40 2004/10/04 19:01:53 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
 void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
 void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
+void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
 #endif

src/ldebug.c+15−8

 /*
-** $Id: ldebug.c,v 2.8 2004/09/01 13:47:31 roberto Exp $
+** $Id: ldebug.c,v 2.11 2004/12/03 20:35:33 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
   switch (GET_OPCODE(i)) {
     case OP_CALL:
     case OP_TAILCALL:
-    case OP_RETURN: {
+    case OP_RETURN:
+    case OP_SETLIST: {
       check(GETARG_B(i) == 0);
       return 1;
     }
-    case OP_SETLISTO: return 1;
     default: return 0;  /* invalid instruction after an open call */
   }
 }
 }
-static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) {
+static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
   int pc;
   int last;  /* stores position of last instruction that changed `reg' */
   last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
         if (getBMode(op) == OpArgR) {
           int dest = pc+1+b;
           check(0 <= dest && dest < pt->sizecode);
+          if (dest > 0) {
+            /* cannot jump to a setlist count */
+            const Instruction d = pt->code[dest-1];
+            check(!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0));
+          }
         }
         break;
       }
         break;
       }
       case OP_TFORLOOP: {
-        checkreg(pt, a+5);  /* space for control variables */
+        check(c >= 1);  /* at least one result (control variable) */
+        checkreg(pt, a+3+c);  /* space for results */
         if (reg >= a+3) last = pc;  /* affect all regs above its call base */
         break;
       }
         break;
       }
       case OP_SETLIST: {
-        checkreg(pt, a + (b&(LFIELDS_PER_FLUSH-1)) + 1);
+        if (b > 0) checkreg(pt, a + b);
+        if (c == 0) pc++;
         break;
       }
       case OP_CLOSURE: {
 int luaG_checkcode (const Proto *pt) {
-  return (luaG_symbexec(pt, pt->sizecode, NO_REG) != 0);
+  return (symbexec(pt, pt->sizecode, NO_REG) != 0);
 }
     *name = luaF_getlocalname(p, stackpos+1, pc);
     if (*name)  /* is a local? */
       return "local";
-    i = luaG_symbexec(p, pc, stackpos);  /* try symbolic execution */
+    i = symbexec(p, pc, stackpos);  /* try symbolic execution */
     lua_assert(pc != -1);
     switch (GET_OPCODE(i)) {
       case OP_GETGLOBAL: {

src/ldo.c+5−7

 /*
-** $Id: ldo.c,v 2.10 2004/09/15 20:39:42 roberto Exp $
+** $Id: ldo.c,v 2.13 2004/12/03 20:35:33 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
 void luaD_throw (lua_State *L, int errcode) {
   if (L->errorJmp) {
     L->errorJmp->status = errcode;
-    L_THROW(L->errorJmp);
+    L_THROW(L, L->errorJmp);
   }
   else {
     if (G(L)->panic) G(L)->panic(L);
   lj.status = 0;
   lj.previous = L->errorJmp;  /* chain new error handler */
   L->errorJmp = &lj;
-  L_TRY(&lj,
+  L_TRY(L, &lj,
     (*f)(L, ud);
   );
   L->errorJmp = lj.previous;  /* restore old error handler */
 }
-static CallInfo *luaD_growCI (lua_State *L) {
+static CallInfo *growCI (lua_State *L) {
   if (L->size_ci > LUA_MAXCALLS)  /* overflow while handling overflow? */
     luaD_throw(L, LUA_ERRERR);
   else {
 #define inc_ci(L) \
-  ((L->ci == L->end_ci) ? luaD_growCI(L) : \
+  ((L->ci == L->end_ci) ? growCI(L) : \
    (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
 LUA_API int lua_resume (lua_State *L, int nargs) {
   int status;
-  lu_byte old_allowhooks;
   lua_lock(L);
   lua_assert(L->errfunc == 0 && L->nCcalls == 0);
   if (L->status != LUA_YIELD) {
     else if (L->ci != L->base_ci)
       return resume_error(L, "cannot resume non-suspended coroutine");
   }
-  old_allowhooks = L->allowhook;
   status = luaD_rawrunprotected(L, resume, &nargs);
   if (status != 0) {  /* error? */
     L->status = status;  /* mark thread as `dead' */

src/ldump.c+6−3

 /*
-** $Id: ldump.c,v 1.8 2004/09/01 21:22:34 lhf Exp $
+** $Id: ldump.c,v 1.9 2004/11/25 09:31:41 lhf Exp $
 ** save pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
   DumpByte(ttype(o),D);
   switch (ttype(o))
   {
+   case LUA_TNIL:
+	break;
+   case LUA_TBOOLEAN:
+	DumpByte(bvalue(o),D);
+	break;
    case LUA_TNUMBER:
 	DumpNumber(nvalue(o),D);
 	break;
    case LUA_TSTRING:
 	DumpString(rawtsvalue(o),D);
 	break;
-   case LUA_TNIL:
-	break;
    default:
 	lua_assert(0);			/* cannot happen */
 	break;

src/lfunc.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lfunc.c,v 2.4 2004/04/30 20:13:38 roberto Exp $	2	** $Id: lfunc.c,v 2.5 2004/11/24 19:20:21 roberto Exp $
3	** Auxiliary functions to manipulate prototypes and closures	3	** Auxiliary functions to manipulate prototypes and closures
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -75,7 +75,7 @@ void luaF_close (lua_State *L, StkId level) { · 69 unmodified lines
75	lua_assert(!isblack(o));	75	lua_assert(!isblack(o));
76	L->openupval = uv->next; /* remove from `open' list */	76	L->openupval = uv->next; /* remove from `open' list */
77	if (isdead(g, o))	77	if (isdead(g, o))
78	luaM_freelem(L, uv); /* free upvalue */	78	luaM_free(L, uv); /* free upvalue */
79	else {	79	else {
80	setobj(L, &uv->value, uv->v);	80	setobj(L, &uv->value, uv->v);
81	uv->v = &uv->value; /* now current value lives here */	81	uv->v = &uv->value; /* now current value lives here */
@@ -117,14 +117,14 @@ void luaF_freeproto (lua_State L, Proto f) { · 35 unmodified lines
117	luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);	117	luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
118	luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);	118	luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
119	luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);	119	luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
120	luaM_freelem(L, f);	120	luaM_free(L, f);
121	}	121	}
122		122
123		123
124	void luaF_freeclosure (lua_State L, Closure c) {	124	void luaF_freeclosure (lua_State L, Closure c) {
125	int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :	125	int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
126	sizeLclosure(c->l.nupvalues);	126	sizeLclosure(c->l.nupvalues);
127	luaM_free(L, c, size);	127	luaM_freemem(L, c, size);
128	}	128	}
129		129
130		130

src/lgc.c+25−25

 /*
-** $Id: lgc.c,v 2.12 2004/09/15 20:38:15 roberto Exp $
+** $Id: lgc.c,v 2.18 2004/12/06 17:53:42 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 #define GCSTEPSIZE	1000
-#define STEPMUL		2
 #define GCSWEEPMAX	10
 #define GCSWEEPCOST	30
 #define GCFINALIZECOST	100
 static void removeentry (Node *n) {
   setnilvalue(gval(n));  /* remove corresponding value ... */
   if (iscollectable(gkey(n)))
-    setttype(gkey(n), LUA_TNONE);  /* dead key; remove it */
+    setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
 }
       p = &curr->gch.next;
     }
     else {  /* must call its gc method */
-      deadmem += sizeudata(gco2u(curr)->len);
+      deadmem += sizeudata(gco2u(curr));
       markfinalized(gco2u(curr));
       *p = curr->gch.next;
       curr->gch.next = NULL;  /* link `curr' at the end of `collected' list */
   i = sizenode(h);
   while (i--) {
     Node *n = gnode(h, i);
+    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
     if (ttisnil(gval(n)))
       removeentry(n);  /* remove empty entries */
     else {
     while (i--) {
       Node *n = gnode(h, i);
       if (!ttisnil(gval(n)) &&  /* non-empty entry? */
-          (iscleared(gkey(n), 1) || iscleared(gval(n), 0)))
+          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0)))
         removeentry(n);  /* remove entry from table */
     }
     l = h->gclist;
   switch (o->gch.tt) {
     case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
     case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
-    case LUA_TUPVAL: luaM_freelem(L, gco2uv(o)); break;
+    case LUA_TUPVAL: luaM_free(L, gco2uv(o)); break;
     case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
     case LUA_TTHREAD: {
       lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
     }
     case LUA_TSTRING: {
       G(L)->strt.nuse--;
-      luaM_free(L, o, sizestring(gco2ts(o)->len));
+      luaM_freemem(L, o, sizestring(gco2ts(o)));
       break;
     }
     case LUA_TUSERDATA: {
-      luaM_free(L, o, sizeudata(gco2u(o)->len));
+      luaM_freemem(L, o, sizeudata(gco2u(o)));
       break;
     }
     default: lua_assert(0);
 static void atomic (lua_State *L) {
   global_State *g = G(L);
+  size_t udsize;  /* total size of userdata to be finalized */
   int aux;
   /* remark objects cautch by write barrier */
   propagateall(g);
   g->gray = g->grayagain;
   g->grayagain = NULL;
   propagateall(g);
-  luaC_separateudata(L, 0);  /* separate userdata to be preserved */
+  udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
   marktmu(g);  /* mark `preserved' userdata */
   propagateall(g);  /* remark, to propagate `preserveness' */
   cleartable(g->weak);  /* remove collected objects from weak tables */
   g->sweepgc = &g->rootgc;
   g->gcstate = GCSsweepstring;
   aux = g->gcgenerational;
-  g->gcgenerational = (g->estimate <= 4*g->prevestimate/2);
+  g->gcgenerational = g->incgc && (g->estimate/2 <= g->prevestimate);
   if (!aux)  /* last collection was full? */
     g->prevestimate = g->estimate;  /* keep estimate of last full collection */
-  g->estimate = g->totalbytes;  /* first estimate */
+  g->estimate = g->totalbytes - udsize;  /* first estimate */
 }
       sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
       if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
         g->gcstate = GCSsweep;  /* end sweep-string phase */
+      lua_assert(old >= g->totalbytes);
       g->estimate -= old - g->totalbytes;
       return GCSWEEPCOST;
     }
         checkSizes(L);
         g->gcstate = GCSfinalize;  /* end sweep phase */
       }
+      lua_assert(old >= g->totalbytes);
       g->estimate -= old - g->totalbytes;
       return GCSWEEPMAX*GCSWEEPCOST;
     }
     case GCSfinalize: {
       if (g->tmudata) {
+        g->GCthreshold += GCFINALIZECOST;  /* avoid GC steps inside method */
         GCTM(L);
+        g->GCthreshold -= GCFINALIZECOST;  /* correct threshold */
         return GCFINALIZECOST;
       }
       else {
 void luaC_step (lua_State *L) {
   global_State *g = G(L);
-  l_mem lim = (g->totalbytes - (g->GCthreshold - GCSTEPSIZE)) * STEPMUL;
+  l_mem lim = (g->totalbytes - (g->GCthreshold - GCSTEPSIZE)) * g->stepmul;
-/*printf("step(%c): ", g->gcgenerational?'g':' ');*/
   do {
-    /*printf("%c", "_pswf"[g->gcstate]);*/
     lim -= singlestep(L);
     if (g->gcstate == GCSpause)
       break;
-  } while (lim > 0);
+  } while (lim > 0 || !g->incgc);
-/*printf("\n");*/
+  if (g->incgc)
-  if (g->gcstate != GCSpause)
     g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/STEPMUL; */
   else {
-/*printf("---\n");*/
     lua_assert(g->totalbytes >= g->estimate);
+    lua_assert(g->gcstate == GCSpause);
     g->GCthreshold = 2*g->estimate;
-    if (g->GCthreshold < g->totalbytes + GCSTEPSIZE)
-      g->GCthreshold = g->totalbytes + GCSTEPSIZE;
   }
 }
   }
   markroot(L);
   lua_assert(!g->gcgenerational);
-  while (g->gcstate != GCSfinalize) {
+  while (g->gcstate != GCSpause) {
     singlestep(L);
     g->gcgenerational = 0;  /* keep it in this mode */
   }
-  lua_assert(g->estimate == g->totalbytes);
   g->GCthreshold = 2*g->estimate;
-  luaC_callGCTM(L);  /* call finalizers */
 }
 void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
   global_State *g = G(L);
   lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  lua_assert(g->gcgenerational || g->gcstate != GCSfinalize);
+  lua_assert(g->gcgenerational ||
+             (g->gcstate != GCSfinalize && g->gcstate != GCSpause));
   lua_assert(ttype(&o->gch) != LUA_TTABLE);
   /* must keep invariant? */
   if (g->gcstate == GCSpropagate || g->gcgenerational)
 void luaC_barrierback (lua_State *L, GCObject *o, GCObject *v) {
   global_State *g = G(L);
   lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  lua_assert(g->gcgenerational || g->gcstate != GCSfinalize);
+  lua_assert(g->gcgenerational ||
+             (g->gcstate != GCSfinalize && g->gcstate != GCSpause));
   black2gray(o);  /* make table gray (again) */
   gco2h(o)->gclist = g->grayagain;
   g->grayagain = o;

src/lib/lauxlib.c+68−10

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lauxlib.c,v 1.124 2004/09/03 13:17:14 roberto Exp $	2	** $Id: lauxlib.c,v 1.126 2004/09/29 21:03:14 roberto Exp $
3	** Auxiliary functions for building Lua libraries	3	** Auxiliary functions for building Lua libraries
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -239,16 +239,22 @@ LUALIB_API void luaL_openlib (lua_State L, const char libname, · 233 unmodified lines
239	const luaL_reg *l, int nup) {	239	const luaL_reg *l, int nup) {
240	if (libname) {	240	if (libname) {
241	/* check whether lib already exists */	241	/* check whether lib already exists */
242	lua_getglobal(L, libname);	242	luaL_getfield(L, LUA_GLOBALSINDEX, libname);
243	if (lua_isnil(L, -1)) { /* no? */	243	if (lua_isnil(L, -1)) { /* not found? */
244	lua_pop(L, 1);	244	lua_pop(L, 1); /* remove previous result */
245	lua_newtable(L); /* create it */	245	lua_newtable(L); /* create it */
246	if (lua_getmetatable(L, LUA_GLOBALSINDEX))	246	if (lua_getmetatable(L, LUA_GLOBALSINDEX))
247	lua_setmetatable(L, -2); /* share metatable with global table */	247	lua_setmetatable(L, -2); /* share metatable with global table */
248	lua_pushvalue(L, -1);
249	/* register it with given name */	248	/* register it with given name */
250	lua_setglobal(L, libname);	249	lua_pushvalue(L, -1);
		250	luaL_setfield(L, LUA_GLOBALSINDEX, libname);
251	}	251	}
		252	else if (!lua_istable(L, -1))
		253	luaL_error(L, "name conflict for library `%s'", libname);
		254	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
		255	lua_pushvalue(L, -2);
		256	lua_setfield(L, -2, libname); /* _LOADED[modname] = new table */
		257	lua_pop(L, 1); /* remove _LOADED table */
252	lua_insert(L, -(nup+1)); /* move library table to below upvalues */	258	lua_insert(L, -(nup+1)); /* move library table to below upvalues */
253	}	259	}
254	for (; l->name; l++) {	260	for (; l->name; l++) {
@@ -352,8 +358,8 @@ static const char pushnexttemplate (lua_State L, const char *path) { · 97 unmodified lines
352	}	358	}
353		359
354		360
355	static const char luaL_gsub (lua_State L, const char *s,	361	LUALIB_API const char luaL_gsub (lua_State L, const char s, const char p,
356	const char p, const char r) {	362	const char *r) {
357	const char *wild;	363	const char *wild;
358	int l = strlen(p);	364	int l = strlen(p);
359	luaL_Buffer b;	365	luaL_Buffer b;
@@ -381,16 +387,68 @@ LUALIB_API const char luaL_searchpath (lua_State L, const char *name, · 21 unmodified lines
381	}	387	}
382	fname = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);	388	fname = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
383	lua_remove(L, -2); /* remove path template */	389	lua_remove(L, -2); /* remove path template */
384	f = fopen(fname, "r"); /* try to read it */	390	f = fopen(fname, "r"); /* try to open it */
385	if (f) {	391	if (f) {
		392	int err;
		393	getc(f); /* try to read file */
		394	err = ferror(f);
386	fclose(f);	395	fclose(f);
387	return fname;	396	if (err == 0) /* open and read sucessful? */
		397	return fname; /* return that file name */
388	}	398	}
389	lua_pop(L, 1); /* remove file name */	399	lua_pop(L, 1); /* remove file name */
390	}	400	}
391	}	401	}
392		402
393		403
		404	LUALIB_API const char luaL_getfield (lua_State L, int idx,
		405	const char *fname) {
		406	const char *e;
		407	lua_pushvalue(L, idx);
		408	while ((e = strchr(fname, '.')) != NULL) {
		409	lua_pushlstring(L, fname, e - fname);
		410	lua_rawget(L, -2);
		411	lua_remove(L, -2); /* remove previous table */
		412	fname = e + 1;
		413	if (!lua_istable(L, -1)) return fname;
		414	}
		415	lua_pushstring(L, fname);
		416	lua_rawget(L, -2); /* get last field */
		417	lua_remove(L, -2); /* remove previous table */
		418	return NULL;
		419	}
		420
		421
		422	LUALIB_API const char luaL_setfield (lua_State L, int idx,
		423	const char *fname) {
		424	const char *e;
		425	lua_pushvalue(L, idx);
		426	while ((e = strchr(fname, '.')) != NULL) {
		427	lua_pushlstring(L, fname, e - fname);
		428	lua_rawget(L, -2);
		429	if (lua_isnil(L, -1)) { /* no such field? */
		430	lua_pop(L, 1); /* remove this nil */
		431	lua_newtable(L); /* create a new table for field */
		432	lua_pushlstring(L, fname, e - fname);
		433	lua_pushvalue(L, -2);
		434	lua_settable(L, -4); /* set new table into field */
		435	}
		436	lua_remove(L, -2); /* remove previous table */
		437	fname = e + 1;
		438	if (!lua_istable(L, -1)) {
		439	lua_pop(L, 2); /* remove table and value */
		440	return fname;
		441	}
		442	}
		443	lua_pushstring(L, fname);
		444	lua_pushvalue(L, -3); /* move value to the top */
		445	lua_rawset(L, -3); /* set last field */
		446	lua_pop(L, 2); /* remove value and table */
		447	return NULL;
		448	}
		449
		450
		451
394	/*	452	/*
395	** {======================================================	453	** {======================================================
396	** Generic Buffer manipulation	454	** Generic Buffer manipulation

src/lib/lbaselib.c+13−63

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lbaselib.c,v 1.158 2004/09/15 20:39:42 roberto Exp $	2	** $Id: lbaselib.c,v 1.161 2004/12/06 17:53:42 roberto Exp $
3	** Basic library	3	** Basic library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -181,10 +181,10 @@ static int luaB_gcinfo (lua_State *L) { · 175 unmodified lines
181		181
182		182
183	static int luaB_collectgarbage (lua_State *L) {	183	static int luaB_collectgarbage (lua_State *L) {
184	static const char *const opts[] = {"stop", "restart", "collect", "count",	184	static const char *const opts[] = {"stop", "restart", "collect",
185	"step", NULL};	185	"count", "step", "setstepmul", "setincmode", NULL};
186	static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART,	186	static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
187	LUA_GCCOLLECT, LUA_GCCOUNT, LUA_GCSTEP};	187	LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETSTEPMUL, LUA_GCSETINCMODE};
188	int o = luaL_findstring(luaL_optstring(L, 1, "collect"), opts);	188	int o = luaL_findstring(luaL_optstring(L, 1, "collect"), opts);
189	int ex = luaL_optint(L, 2, 0);	189	int ex = luaL_optint(L, 2, 0);
190	luaL_argcheck(L, o >= 0, 1, "invalid option");	190	luaL_argcheck(L, o >= 0, 1, "invalid option");
@@ -440,50 +440,6 @@ static int luaB_newproxy (lua_State *L) { · 249 unmodified lines
440	}	440	}
441		441
442		442
443	/*
444	** {======================================================
445	** `require' function
446	** =======================================================
447	*/
448
449
450	static const char getpath (lua_State L) {
451	/* try first `LUA_PATH' for compatibility */
452	lua_getfield(L, LUA_GLOBALSINDEX, "LUA_PATH");
453	if (!lua_isstring(L, -1)) {
454	lua_pop(L, 1);
455	lua_getfield(L, LUA_GLOBALSINDEX, "_PATH");
456	}
457	if (!lua_isstring(L, -1))
458	luaL_error(L, "global _PATH must be a string");
459	return lua_tostring(L, -1);
460	}
461
462
463	static int luaB_require (lua_State *L) {
464	const char *name = luaL_checkstring(L, 1);
465	const char *fname;
466	lua_getfield(L, lua_upvalueindex(1), name);
467	if (lua_toboolean(L, -1)) /* is it there? */
468	return 1; /* package is already loaded; return its result */
469	/* else must load it; first mark it as loaded */
470	lua_pushboolean(L, 1);
471	lua_setfield(L, lua_upvalueindex(1), name); /* _LOADED[name] = true */
472	fname = luaL_searchpath(L, name, getpath(L));
473	if (fname == NULL \|\| luaL_loadfile(L, fname) != 0)
474	return luaL_error(L, "error loading package `%s' (%s)", name,
475	lua_tostring(L, -1));
476	lua_pushvalue(L, 1); /* pass name as argument to module */
477	lua_call(L, 1, 1); /* run loaded module */
478	if (!lua_isnil(L, -1)) /* nil return? */
479	lua_setfield(L, lua_upvalueindex(1), name);
480	lua_getfield(L, lua_upvalueindex(1), name); /* return _LOADED[name] */
481	return 1;
482	}
483
484	/* }====================================================== */
485
486
487	static const luaL_reg base_funcs[] = {	443	static const luaL_reg base_funcs[] = {
488	{"error", luaB_error},	444	{"error", luaB_error},
489	{"getmetatable", luaB_getmetatable},	445	{"getmetatable", luaB_getmetatable},
@@ -656,11 +612,10 @@ static void auxopen (lua_State L, const char name, · 166 unmodified lines
656		612
657		613
658	static void base_open (lua_State *L) {	614	static void base_open (lua_State *L) {
659	const char *path;
660	lua_pushvalue(L, LUA_GLOBALSINDEX);	615	lua_pushvalue(L, LUA_GLOBALSINDEX);
661	luaL_openlib(L, NULL, base_funcs, 0); /* open lib into global table */	616	luaL_openlib(L, NULL, base_funcs, 0); /* open lib into global table */
662	lua_pushliteral(L, LUA_VERSION);	617	lua_pushliteral(L, LUA_VERSION);
663	lua_setfield(L, LUA_GLOBALSINDEX, "_VERSION"); /* set global _VERSION */	618	lua_setglobal(L, "_VERSION"); /* set global _VERSION */
664	/* `ipairs' and `pairs' need auxliliary functions as upvalues */	619	/* `ipairs' and `pairs' need auxliliary functions as upvalues */
665	auxopen(L, "ipairs", luaB_ipairs, ipairsaux);	620	auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
666	auxopen(L, "pairs", luaB_pairs, luaB_next);	621	auxopen(L, "pairs", luaB_pairs, luaB_next);
@@ -671,21 +626,16 @@ static void base_open (lua_State *L) { · 4 unmodified lines
671	lua_pushliteral(L, "kv");	626	lua_pushliteral(L, "kv");
672	lua_setfield(L, -2, "__mode"); /* metatable(w).__mode = "kv" */	627	lua_setfield(L, -2, "__mode"); /* metatable(w).__mode = "kv" */
673	lua_pushcclosure(L, luaB_newproxy, 1);	628	lua_pushcclosure(L, luaB_newproxy, 1);
674	lua_setfield(L, LUA_GLOBALSINDEX, "newproxy"); /* set global `newproxy' */	629	lua_setglobal(L, "newproxy"); /* set global `newproxy' */
675	/* `require' needs a table to keep loaded chunks */	630	/* create register._LOADED to track loaded modules */
		631	lua_newtable(L);
		632	lua_setfield(L, LUA_REGISTRYINDEX, "_LOADED");
		633	/* create register._PRELOAD to allow pre-loaded modules */
676	lua_newtable(L);	634	lua_newtable(L);
677	lua_pushvalue(L, -1);	635	lua_setfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
678	lua_setglobal(L, "_LOADED");
679	lua_pushcclosure(L, luaB_require, 1);
680	lua_setfield(L, LUA_GLOBALSINDEX, "require");
681	/* set global _G */	636	/* set global _G */
682	lua_pushvalue(L, LUA_GLOBALSINDEX);	637	lua_pushvalue(L, LUA_GLOBALSINDEX);
683	lua_setfield(L, LUA_GLOBALSINDEX, "_G");	638	lua_setglobal(L, "_G");
684	/* set global _PATH */
685	path = getenv(LUA_PATH);
686	if (path == NULL) path = LUA_PATH_DEFAULT;
687	lua_pushstring(L, path);
688	lua_setfield(L, LUA_GLOBALSINDEX, "_PATH");
689	}	639	}
690		640
691		641

src/lib/ldblib.c+5−4

 /*
-** $Id: ldblib.c,v 1.87 2004/08/13 18:02:36 roberto Exp $
+** $Id: ldblib.c,v 1.89 2004/11/17 12:02:41 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
     if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
         strcmp(buffer, "cont\n") == 0)
       return 0;
-    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=debug command") ||
+    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
         lua_pcall(L, 0, 0, 0)) {
       fputs(lua_tostring(L, -1), stderr);
       fputs("\n", stderr);
 #define LEVELS2	10	/* size of the second part of the stack */
 static int errorfb (lua_State *L) {
-  int level = 1;  /* skip level 0 (it's this function) */
+  int level = 0;
   int firstpart = 1;  /* still before eventual `...' */
   int arg;
   lua_State *L1 = getthread(L, &arg);
   lua_Debug ar;
+  if (L == L1) level++;  /* skip level 0 (it's this function) */
   if (lua_gettop(L) == arg)
     lua_pushliteral(L, "");
-  else if (!lua_isstring(L, arg+1)) return 1;  /* no string message */
+  else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */
   else lua_pushliteral(L, "\n");
   lua_pushliteral(L, "stack traceback:");
   while (lua_getstack(L1, level++, &ar)) {

src/lib/loadlib.c+319−78

@@ -1,31 +1,35 @@
1	/*	1	/*
2	** $Id: loadlib.c,v 1.6 2004/04/30 20:13:38 roberto Exp $	2	** $Id: loadlib.c,v 1.11 2004/11/19 15:52:12 roberto Exp $
3	** Dynamic library loader for Lua	3	** Dynamic library loader for Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*	5	*
6	* This Lua library exports a single function, called loadlib, which is	6	* This Lua library exports a single function, called loadlib, which
7	* called from Lua as loadlib(lib,init), where lib is the full name of the	7	* is called from Lua as loadlib(lib,init), where lib is the full
8	* library to be loaded (including the complete path) and init is the name	8	* name of the library to be loaded (including the complete path) and
9	* of a function to be called after the library is loaded. Typically, this	9	* init is the name of a function to be called after the library is
10	* function will register other functions, thus making the complete library	10	* loaded. Typically, this function will register other functions, thus
11	* available to Lua. The init function is not automatically called by	11	* making the complete library available to Lua. The init function is
12	* loadlib. Instead, loadlib returns the init function as a Lua function	12	* not automatically called by loadlib. Instead, loadlib returns the
13	* that the client can call when it thinks is appropriate. In the case of	13	* init function as a Lua function that the client can call when it
14	* errors, loadlib returns nil and two strings describing the error.	14	* thinks is appropriate. In the case of errors, loadlib returns nil and
15	* The first string is supplied by the operating system; it should be	15	* two strings describing the error. The first string is supplied by
16	* informative and useful for error messages. The second string is "open",	16	* the operating system; it should be informative and useful for error
17	* "init", or "absent" to identify the error and is meant to be used for	17	* messages. The second string is "open", "init", or "absent" to identify
18	* making decisions without having to look into the first string (whose	18	* the error and is meant to be used for making decisions without having
19	* format is system-dependent).	19	* to look into the first string (whose format is system-dependent).
20	*	20	* This module contains an implementation of loadlib for Unix systems
21	* This module contains an implementation of loadlib for Unix systems that	21	* that have dlfcn, an implementation for Darwin (Mac OS X), an
22	* have dlfcn, an implementation for Windows, and a stub for other systems.	22	* implementation for Windows, and a stub for other systems. See
23	* See the list at the end of this file for some links to available	23	* the list at the end of this file for some links to available
24	* implementations of dlfcn and interfaces to other native dynamic loaders	24	* implementations of dlfcn and interfaces to other native dynamic
25	* on top of which loadlib could be implemented.	25	* loaders on top of which loadlib could be implemented.
26	*
27	*/	26	*/
28		27
		28
		29	#include <stdlib.h>
		30	#include <string.h>
		31
		32
29	#define loadlib_c	33	#define loadlib_c
30	#define LUA_LIB	34	#define LUA_LIB
31		35
@@ -34,11 +38,14 @@ · 2 unmodified lines
34	#include "lualib.h"	38	#include "lualib.h"
35		39
36		40
37	#undef LOADLIB	41	#define ERR_OPEN 1
		42	#define ERR_FUNCTION 2
		43
		44
		45	static void registerlib (lua_State L, const void lib);
38		46
39		47
40	#ifdef USE_DLOPEN	48	#if defined(USE_DLOPEN)
41	#define LOADLIB
42	/*	49	/*
43	* This is an implementation of loadlib based on the dlfcn interface.	50	* This is an implementation of loadlib based on the dlfcn interface.
44	* The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,	51	* The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
@@ -48,53 +55,41 @@ · 3 unmodified lines
48		55
49	#include <dlfcn.h>	56	#include <dlfcn.h>
50		57
51	static int loadlib(lua_State *L)	58	#define freelib dlclose
		59
		60	static int loadlib(lua_State L, const char path, const char *init)
52	{	61	{
53	const char *path=luaL_checkstring(L,1);
54	const char *init=luaL_checkstring(L,2);
55	void *lib=dlopen(path,RTLD_NOW);	62	void *lib=dlopen(path,RTLD_NOW);
56	if (lib!=NULL)	63	if (lib!=NULL)
57	{	64	{
58	lua_CFunction f=(lua_CFunction) dlsym(lib,init);	65	lua_CFunction f=(lua_CFunction) dlsym(lib,init);
59	if (f!=NULL)	66	if (f!=NULL)
60	{	67	{
61	lua_pushlightuserdata(L,lib);	68	registerlib(L, lib);
62	lua_pushcclosure(L,f,1);	69	lua_pushcfunction(L,f);
63	return 1;	70	return 0;
64	}	71	}
65	}	72	}
66	/* else return appropriate error messages */	73	/* else return appropriate error message */
67	lua_pushnil(L);
68	lua_pushstring(L,dlerror());	74	lua_pushstring(L,dlerror());
69	lua_pushstring(L,(lib!=NULL) ? "init" : "open");	75	if (lib!=NULL) {
70	if (lib!=NULL) dlclose(lib);	76	dlclose(lib);
71	return 3;	77	return ERR_FUNCTION; /* error loading function */
		78	}
		79	else return ERR_OPEN; /* error loading library */
72	}	80	}
73		81
74	#endif
75
76
77
78	/*
79	** In Windows, default is to use dll; otherwise, default is not to use dll
80	*/
81	#ifndef USE_DLL
82	#ifdef _WIN32
83	#define USE_DLL 1
84	#else
85	#define USE_DLL 0
86	#endif
87	#endif
88		82
89		83
90	#if USE_DLL	84	#elif defined(USE_DLL)
91	#define LOADLIB
92	/*	85	/*
93	* This is an implementation of loadlib for Windows using native functions.	86	* This is an implementation of loadlib for Windows using native functions.
94	*/	87	*/
95		88
96	#include <windows.h>	89	#include <windows.h>
97		90
		91	#define freelib(lib) FreeLibrary((HINSTANCE)lib)
		92
98	static void pusherror(lua_State *L)	93	static void pusherror(lua_State *L)
99	{	94	{
100	int error=GetLastError();	95	int error=GetLastError();
@@ -106,61 +101,310 @@ static void pusherror(lua_State *L) · 5 unmodified lines
106	lua_pushfstring(L,"system error %d\n",error);	101	lua_pushfstring(L,"system error %d\n",error);
107	}	102	}
108		103
109	static int loadlib(lua_State *L)	104	static int loadlib(lua_State L, const char path, const char *init)
110	{	105	{
111	const char *path=luaL_checkstring(L,1);
112	const char *init=luaL_checkstring(L,2);
113	HINSTANCE lib=LoadLibrary(path);	106	HINSTANCE lib=LoadLibrary(path);
114	if (lib!=NULL)	107	if (lib!=NULL)
115	{	108	{
116	lua_CFunction f=(lua_CFunction) GetProcAddress(lib,init);	109	lua_CFunction f=(lua_CFunction) GetProcAddress(lib,init);
117	if (f!=NULL)	110	if (f!=NULL)
118	{	111	{
119	lua_pushlightuserdata(L,lib);	112	registerlib(L, lib);
120	lua_pushcclosure(L,f,1);	113	lua_pushcfunction(L,f);
121	return 1;	114	return 1;
122	}	115	}
123	}	116	}
124	lua_pushnil(L);
125	pusherror(L);	117	pusherror(L);
126	lua_pushstring(L,(lib!=NULL) ? "init" : "open");	118	if (lib!=NULL) {
127	if (lib!=NULL) FreeLibrary(lib);	119	FreeLibrary(lib);
128	return 3;	120	return ERR_OPEN;
		121	}
		122	else return ERR_FUNCTION;
129	}	123	}
130		124
131	#endif
132		125
133		126
		127	/* Native Mac OS X / Darwin Implementation */
		128	#elif defined(USE_DYLD)
		129
		130	#include <mach-o/dyld.h>
		131
		132
		133	/* Mach cannot unload images (?) */
		134	#define freelib(lib) ((void)lib)
		135
		136	static void pusherror (lua_State *L)
		137	{
		138	const char *err_str;
		139	const char *err_file;
		140	NSLinkEditErrors err;
		141	int err_num;
		142	NSLinkEditError(&err, &err_num, &err_file, &err_str);
		143	lua_pushstring(L, err_str);
		144	}
		145
		146	static int loadlib (lua_State L, const char path, const char *init) {
		147	const struct mach_header *lib;
		148	/* this would be a rare case, but prevents crashing if it happens */
		149	if(!_dyld_present()) {
		150	lua_pushstring(L,"dyld not present.");
		151	return ERR_OPEN;
		152	}
		153	lib = NSAddImage(path, NSADDIMAGE_OPTION_RETURN_ON_ERROR);
		154	if(lib != NULL) {
		155	NSSymbol init_sym = NSLookupSymbolInImage(lib, init,
		156	NSLOOKUPSYMBOLINIMAGE_OPTION_BIND \|
		157	NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR);
		158	if(init_sym != NULL) {
		159	lua_CFunction f = (lua_CFunction)NSAddressOfSymbol(init_sym);
		160	registerlib(L, lib);
		161	lua_pushcfunction(L,f);
		162	return 0;
		163	}
		164	}
		165	/* else an error ocurred */
		166	pusherror(L);
		167	/* Can't unload image */
		168	return (lib != NULL) ? ERR_FUNCTION : ERR_OPEN;
		169	}
		170
134		171
135	#ifndef LOADLIB
136	/* Fallback for other systems */
137		172
138	/*
139	** Those systems support dlopen, so they should have defined USE_DLOPEN.
140	** The default (no)implementation gives them a special error message.
141	*/
142	#if defined(linux) \|\| defined(sun) \|\| defined(sgi) \|\| defined(BSD) \|\| defined(_WIN32)
143	#define LOADLIB "`loadlib' not installed (check your Lua configuration)"
144	#else	173	#else
145	#define LOADLIB "`loadlib' not supported"	174	/* Fallback for other systems */
146	#endif	175
147		176
		177	#define freelib(lib) ((void)lib)
148		178
149	static int loadlib(lua_State *L)	179	static int loadlib(lua_State *L)
150	{	180	{
		181	registerlib(L, NULL); /* to avoid warnings */
151	lua_pushnil(L);	182	lua_pushnil(L);
152	lua_pushliteral(L,LOADLIB);	183	lua_pushliteral(L,"`loadlib' not supported");
153	lua_pushliteral(L,"absent");	184	lua_pushliteral(L,"absent");
154	return 3;	185	return 3;
155	}	186	}
		187
156	#endif	188	#endif
157		189
158	LUALIB_API int luaopen_loadlib (lua_State *L)	190
		191	/*
		192	** common code for all implementations: put a library into the registry
		193	** so that, when Lua closes its state, the library's __gc metamethod
		194	** will be called to unload the library.
		195	*/
		196	static void registerlib (lua_State L, const void lib)
		197	{
		198	const void plib = (const void )lua_newuserdata(L, sizeof(const void *));
		199	*plib = lib;
		200	luaL_getmetatable(L, "_LOADLIB");
		201	lua_setmetatable(L, -2);
		202	lua_pushboolean(L, 1);
		203	lua_settable(L, LUA_REGISTRYINDEX); /* registry[lib] = true */
		204	}
		205
		206	/*
		207	** __gc tag method: calls library's `freelib' function with the lib
		208	** handle
		209	*/
		210	static int gctm (lua_State *L)
159	{	211	{
160	lua_register(L,"loadlib",loadlib);	212	void lib = (void **)luaL_checkudata(L, 1, "_LOADLIB");
		213	freelib(lib);
161	return 0;	214	return 0;
162	}	215	}
163		216
		217
		218	static int loadlib1 (lua_State *L) {
		219	const char *path=luaL_checkstring(L,1);
		220	const char *init=luaL_checkstring(L,2);
		221	int res = loadlib(L,path,init);
		222	if (res == 0) /* no error? */
		223	return 1; /* function is at stack top */
		224	else { /* error */
		225	lua_pushnil(L);
		226	lua_insert(L,-2); /* insert nil before error message */
		227	lua_pushstring(L, (res==ERR_OPEN)?"open":"init");
		228	return 3;
		229	}
		230	}
		231
		232
		233
		234	/*
		235	** {======================================================
		236	** `require' and `module' functions
		237	** =======================================================
		238	*/
		239
		240
		241	static const char loadLua (lua_State L, const char fname, const char name) {
		242	const char *path;
		243	/* try first `LUA_PATH' for compatibility */
		244	lua_getglobal(L, "LUA_PATH");
		245	path = lua_tostring(L, -1);
		246	if (!path) {
		247	lua_pop(L, 1);
		248	luaL_getfield(L, LUA_GLOBALSINDEX, "package.path");
		249	path = lua_tostring(L, -1);
		250	}
		251	if (path == NULL)
		252	luaL_error(L, "`package.path' must be a string");
		253	fname = luaL_searchpath(L, fname, path);
		254	if (fname == NULL) return path; /* library not found in this path */
		255	if (luaL_loadfile(L, fname) != 0)
		256	luaL_error(L, "error loading package `%s' (%s)", name, lua_tostring(L, -1));
		257	return NULL; /* library loaded successfully */
		258	}
		259
		260
		261	static const char loadC (lua_State L, const char fname, const char name) {
		262	const char *path;
		263	const char *funcname;
		264	luaL_getfield(L, LUA_GLOBALSINDEX, "package.cpath");
		265	path = lua_tostring(L, -1);
		266	if (path == NULL)
		267	luaL_error(L, "global _CPATH must be a string");
		268	fname = luaL_searchpath(L, fname, path);
		269	if (fname == NULL) return path; /* library not found in this path */
		270	funcname = luaL_gsub(L, name, ".", "");
		271	funcname = lua_pushfstring(L, "%s%s", LUA_POF, funcname);
		272	if (loadlib(L, fname, funcname) != 0)
		273	luaL_error(L, "error loading package `%s' (%s)", name, lua_tostring(L, -1));
		274	return NULL; /* library loaded successfully */
		275	}
		276
		277
		278	static int ll_require (lua_State *L) {
		279	const char *name = luaL_checkstring(L, 1);
		280	lua_settop(L, 1);
		281	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
		282	lua_getfield(L, 2, name);
		283	if (lua_toboolean(L, -1)) /* is it there? */
		284	return 1; /* package is already loaded; return its result */
		285	/* else must load it; first mark it as loaded */
		286	lua_pushboolean(L, 1);
		287	lua_setfield(L, 2, name); /* _LOADED[name] = true */
		288	/* check whether it is preloaded */
		289	lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
		290	lua_getfield(L, -1, name);
		291	if (lua_isnil(L, -1)) { /* no preload function for that module? */
		292	const char *fname = luaL_gsub(L, name, ".", LUA_DIRSEP);
		293	const char cpath = loadC(L, fname, name); / try a C module */
		294	if (cpath) { /* not found? */
		295	const char path = loadLua(L, fname, name); / try a Lua module */
		296	if (path) { /* yet not found? */
		297	lua_pushnil(L);
		298	lua_setfield(L, 2, name); /* unmark _LOADED[name] */
		299	return luaL_error(L, "package `%s' not found\n"
		300	" cpath: %s\n path: %s",
		301	name, cpath, path);
		302	}
		303	}
		304	}
		305	lua_pushvalue(L, 1); /* pass name as argument to module */
		306	lua_call(L, 1, 1); /* run loaded module */
		307	if (!lua_isnil(L, -1)) /* non-nil return? */
		308	lua_setfield(L, 2, name); /* update _LOADED[name] with returned value */
		309	lua_getfield(L, 2, name); /* return _LOADED[name] */
		310	return 1;
		311	}
		312
		313
		314	static void setfenv (lua_State *L) {
		315	lua_Debug ar;
		316	lua_getstack(L, 1, &ar);
		317	lua_getinfo(L, "f", &ar);
		318	lua_pushvalue(L, -2);
		319	lua_setfenv(L, -2);
		320	}
		321
		322
		323	static int ll_module (lua_State *L) {
		324	const char *modname = luaL_checkstring(L, 1);
		325	const char *dot;
		326	lua_settop(L, 1);
		327	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
		328	/* try to find given table */
		329	luaL_getfield(L, LUA_GLOBALSINDEX, modname);
		330	if (lua_isnil(L, -1)) { /* not found? */
		331	lua_pop(L, 1); /* remove previous result */
		332	lua_newtable(L); /* create it */
		333	/* register it with given name */
		334	lua_pushvalue(L, -1);
		335	luaL_setfield(L, LUA_GLOBALSINDEX, modname);
		336	}
		337	else if (!lua_istable(L, -1))
		338	return luaL_error(L, "name conflict for module `%s'", modname);
		339	/* check whether table already has a _NAME field */
		340	lua_getfield(L, -1, "_NAME");
		341	if (!lua_isnil(L, -1)) /* is table an initialized module? */
		342	lua_pop(L, 1);
		343	else { /* no; initialize it */
		344	lua_pop(L, 1);
		345	lua_newtable(L); /* create new metatable */
		346	lua_pushvalue(L, LUA_GLOBALSINDEX);
		347	lua_setfield(L, -2, "__index"); /* mt.__index = _G */
		348	lua_setmetatable(L, -2);
		349	lua_pushstring(L, modname);
		350	lua_setfield(L, -2, "_NAME");
		351	dot = strrchr(modname, '.'); /* look for last dot in module name */
		352	if (dot == NULL) dot = modname;
		353	else dot++;
		354	/* set _PACKAGE as package name (full module name minus last part) */
		355	lua_pushlstring(L, modname, dot - modname);
		356	lua_setfield(L, -2, "_PACKAGE");
		357	}
		358	lua_pushvalue(L, -1);
		359	lua_setfield(L, 2, modname); /* _LOADED[modname] = new table */
		360	setfenv(L);
		361	return 0;
		362	}
		363
		364
		365	/* }====================================================== */
		366
		367
		368	static const luaL_reg ll_funcs[] = {
		369	{"loadlib", loadlib1},
		370	{"require", ll_require},
		371	{"module", ll_module},
		372	{NULL, NULL}
		373	};
		374
		375
		376
		377	LUALIB_API int luaopen_loadlib (lua_State *L) {
		378	const char *path;
		379	/* create new type _LOADLIB */
		380	luaL_newmetatable(L, "_LOADLIB");
		381	lua_pushcfunction(L, gctm);
		382	lua_setfield(L, -2, "__gc");
		383	/* create `package' table */
		384	lua_newtable(L);
		385	lua_pushvalue(L, -1);
		386	lua_setglobal(L, "package");
		387	/* set field `path' */
		388	path = getenv(LUA_PATH);
		389	if (path == NULL) path = LUA_PATH_DEFAULT;
		390	lua_pushstring(L, path);
		391	lua_setfield(L, -2, "path");
		392	/* set field `cpath' */
		393	path = getenv(LUA_CPATH);
		394	if (path == NULL) path = LUA_CPATH_DEFAULT;
		395	lua_pushstring(L, path);
		396	lua_setfield(L, -2, "cpath");
		397	/* set field `loaded' */
		398	lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
		399	lua_setfield(L, -2, "loaded");
		400	/* set field `preload' */
		401	lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
		402	lua_setfield(L, -2, "preload");
		403	lua_pushvalue(L, LUA_GLOBALSINDEX);
		404	luaL_openlib(L, NULL, ll_funcs, 0); /* open lib into global table */
		405	return 1;
		406	}
		407
164	/*	408	/*
165	* Here are some links to available implementations of dlfcn and	409	* Here are some links to available implementations of dlfcn and
166	* interfaces to other native dynamic loaders on top of which loadlib	410	* interfaces to other native dynamic loaders on top of which loadlib
@@ -179,9 +423,6 @@ LUALIB_API int luaopen_loadlib (lua_State *L) · 12 unmodified lines
179	* Macintosh, Windows	423	* Macintosh, Windows
180	* http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html	424	* http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html
181	*	425	*
182	* Mac OS X/Darwin
183	* http://www.opendarwin.org/projects/dlcompat/
184	*
185	* GLIB has wrapper code for BeOS, OS2, Unix and Windows	426	* GLIB has wrapper code for BeOS, OS2, Unix and Windows
186	* http://cvs.gnome.org/lxr/source/glib/gmodule/	427	* http://cvs.gnome.org/lxr/source/glib/gmodule/
187	*	428	*

src/lib/loslib.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: loslib.c,v 1.2 2004/08/05 19:30:37 roberto Exp $	2	** $Id: loslib.c,v 1.3 2004/10/08 18:57:16 roberto Exp $
3	** Standard Operating System library	3	** Standard Operating System library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -20,7 +20,7 @@ · 14 unmodified lines
20	#include "lualib.h"	20	#include "lualib.h"
21		21
22		22
23	static int pushresult (lua_State L, int i, const char filename) {	23	static int os_pushresult (lua_State L, int i, const char filename) {
24	if (i) {	24	if (i) {
25	lua_pushboolean(L, 1);	25	lua_pushboolean(L, 1);
26	return 1;	26	return 1;
@@ -45,14 +45,14 @@ static int io_execute (lua_State *L) { · 18 unmodified lines
45		45
46	static int io_remove (lua_State *L) {	46	static int io_remove (lua_State *L) {
47	const char *filename = luaL_checkstring(L, 1);	47	const char *filename = luaL_checkstring(L, 1);
48	return pushresult(L, remove(filename) == 0, filename);	48	return os_pushresult(L, remove(filename) == 0, filename);
49	}	49	}
50		50
51		51
52	static int io_rename (lua_State *L) {	52	static int io_rename (lua_State *L) {
53	const char *fromname = luaL_checkstring(L, 1);	53	const char *fromname = luaL_checkstring(L, 1);
54	const char *toname = luaL_checkstring(L, 2);	54	const char *toname = luaL_checkstring(L, 2);
55	return pushresult(L, rename(fromname, toname) == 0, fromname);	55	return os_pushresult(L, rename(fromname, toname) == 0, fromname);
56	}	56	}
57		57
58		58

src/lib/lstrlib.c+24−26

 /*
-** $Id: lstrlib.c,v 1.106 2004/08/09 13:30:33 roberto Exp $
+** $Id: lstrlib.c,v 1.109 2004/12/01 15:46:06 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
 #define uchar(c)        ((unsigned char)(c))
-typedef lua_Integer sint32;	/* a signed version for size_t */
 static int str_len (lua_State *L) {
   size_t l;
 }
-static sint32 posrelat (sint32 pos, size_t len) {
+static ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {
   /* relative string position: negative means back from end */
-  return (pos>=0) ? pos : (sint32)len+pos+1;
+  return (pos>=0) ? pos : (ptrdiff_t)len+pos+1;
 }
 static int str_sub (lua_State *L) {
   size_t l;
   const char *s = luaL_checklstring(L, 1, &l);
-  sint32 start = posrelat(luaL_checkinteger(L, 2), l);
+  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
-  sint32 end = posrelat(luaL_optinteger(L, 3, -1), l);
+  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
   if (start < 1) start = 1;
-  if (end > (sint32)l) end = (sint32)l;
+  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
   if (start <= end)
     lua_pushlstring(L, s+start-1, end-start+1);
   else lua_pushliteral(L, "");
 static int str_byte (lua_State *L) {
   size_t l;
   const char *s = luaL_checklstring(L, 1, &l);
-  sint32 posi = posrelat(luaL_optinteger(L, 2, 1), l);
+  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
-  sint32 pose = posrelat(luaL_optinteger(L, 3, posi), l);
+  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
   int n, i;
   if (posi <= 0) posi = 1;
   if ((size_t)pose > l) pose = l;
   int level;  /* total number of captures (finished or unfinished) */
   struct {
     const char *init;
-    sint32 len;
+    ptrdiff_t len;
   } capture[MAX_CAPTURES];
 } MatchState;
 }
-static const char *luaI_classend (MatchState *ms, const char *p) {
+static const char *classend (MatchState *ms, const char *p) {
   switch (*p++) {
     case ESC: {
       if (*p == '\0')
   while (++p < ec) {
     if (*p == ESC) {
       p++;
-      if (match_class(c, *p))
+      if (match_class(c, uchar(*p)))
         return sig;
     }
     else if ((*(p+1) == '-') && (p+2 < ec)) {
 }
-static int luaI_singlematch (int c, const char *p, const char *ep) {
+static int singlematch (int c, const char *p, const char *ep) {
   switch (*p) {
     case '.': return 1;  /* matches any char */
-    case ESC: return match_class(c, *(p+1));
+    case ESC: return match_class(c, uchar(*(p+1)));
     case '[': return matchbracketclass(c, p, ep-1);
     default:  return (uchar(*p) == c);
   }
 static const char *max_expand (MatchState *ms, const char *s,
                                  const char *p, const char *ep) {
-  sint32 i = 0;  /* counts maximum expand for item */
+  ptrdiff_t i = 0;  /* counts maximum expand for item */
-  while ((s+i)<ms->src_end && luaI_singlematch(uchar(*(s+i)), p, ep))
+  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
     i++;
   /* keeps trying to match with the maximum repetitions */
   while (i>=0) {
     const char *res = match(ms, s, ep+1);
     if (res != NULL)
       return res;
-    else if (s<ms->src_end && luaI_singlematch(uchar(*s), p, ep))
+    else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
       s++;  /* try with one more repetition */
     else return NULL;
   }
           p += 2;
           if (*p != '[')
             luaL_error(ms->L, "missing `[' after `%%f' in pattern");
-          ep = luaI_classend(ms, p);  /* points to what is next */
+          ep = classend(ms, p);  /* points to what is next */
           previous = (s == ms->src_init) ? '\0' : *(s-1);
           if (matchbracketclass(uchar(previous), p, ep-1) ||
              !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
         }
         default: {
           if (isdigit(uchar(*(p+1)))) {  /* capture results (%0-%9)? */
-            s = match_capture(ms, s, *(p+1));
+            s = match_capture(ms, s, uchar(*(p+1)));
             if (s == NULL) return NULL;
             p+=2; goto init;  /* else return match(ms, s, p+2) */
           }
       else goto dflt;
     }
     default: dflt: {  /* it is a pattern item */
-      const char *ep = luaI_classend(ms, p);  /* points to what is next */
+      const char *ep = classend(ms, p);  /* points to what is next */
-      int m = s<ms->src_end && luaI_singlematch(uchar(*s), p, ep);
+      int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
       switch (*ep) {
         case '?': {  /* optional */
           const char *res;
   size_t l1, l2;
   const char *s = luaL_checklstring(L, 1, &l1);
   const char *p = luaL_checklstring(L, 2, &l2);
-  sint32 init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;
+  ptrdiff_t init = posrelat(luaL_optinteger(L, 3, 1), l1) - 1;
   if (init < 0) init = 0;
-  else if ((size_t)(init) > l1) init = (sint32)l1;
+  else if ((size_t)(init) > l1) init = (ptrdiff_t)l1;
   if (lua_toboolean(L, 4) ||  /* explicit request? */
       strpbrk(p, SPECIALS) == NULL) {  /* or no special characters? */
     /* do a plain search */
 #define MAX_FORMAT	20
-static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) {
+static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
   size_t l;
   const char *s = luaL_checklstring(L, arg, &l);
   luaL_putchar(b, '"');
           break;
         }
         case 'q': {
-          luaI_addquoted(L, &b, arg);
+          addquoted(L, &b, arg);
           continue;  /* skip the `addsize' at the end */
         }
         case 's': {

src/llex.c+41−35

 /*
-** $Id: llex.c,v 2.3 2004/04/30 20:13:38 roberto Exp $
+** $Id: llex.c,v 2.9 2004/12/03 20:54:12 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 #define next(ls) (ls->current = zgetc(ls->z))
-#define save(ls,c)  { \
-  Mbuffer *b = ls->buff; \
-  if (b->n + 1 > b->buffsize) \
-    luaZ_resizebuffer(ls->L, b, ((b->buffsize*2) + LUA_MINBUFFER)); \
-  b->buffer[b->n++] = cast(char, c); }
 #define currIsNewline(ls)	(ls->current == '\n' || ls->current == '\r')
 /* ORDER RESERVED */
-static const char *const token2string [] = {
+const char *const luaX_tokens [] = {
     "and", "break", "do", "else", "elseif",
     "end", "false", "for", "function", "if",
     "in", "local", "nil", "not", "or", "repeat",
-    "return", "then", "true", "until", "while", "*name",
+    "return", "then", "true", "until", "while",
     "..", "...", "==", ">=", "<=", "~=",
-    "*number", "*string", "<eof>"
+    "<number>", "<name>", "<string>", "<eof>",
+    NULL
 };
+#define save_and_next(ls) (save(ls, ls->current), next(ls))
+static void save (LexState *ls, int c) {
+  Mbuffer *b = ls->buff;
+  if (b->n + 1 > b->buffsize) {
+    size_t newsize;
+    if (b->buffsize >= MAX_SIZET/2)
+      luaX_lexerror(ls, "lexical element too long", 0);
+    newsize = b->buffsize * 2;
+    luaZ_resizebuffer(ls->L, b, newsize);
+  }
+  b->buffer[b->n++] = cast(char, c);
+}
 void luaX_init (lua_State *L) {
   int i;
   for (i=0; i<NUM_RESERVED; i++) {
-    TString *ts = luaS_new(L, token2string[i]);
+    TString *ts = luaS_new(L, luaX_tokens[i]);
     luaS_fix(ts);  /* reserved words are never collected */
-    lua_assert(strlen(token2string[i])+1 <= TOKEN_LEN);
+    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
     ts->tsv.reserved = cast(lu_byte, i+1);  /* reserved word */
   }
 }
 const char *luaX_token2str (LexState *ls, int token) {
   if (token < FIRST_RESERVED) {
-    lua_assert(token == (unsigned char)token);
+    lua_assert(token == cast(unsigned char, token));
     return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
                               luaO_pushfstring(ls->L, "%c", token);
   }
   else
-    return token2string[token-FIRST_RESERVED];
+    return luaX_tokens[token-FIRST_RESERVED];
 }
   ls->linenumber = 1;
   ls->lastline = 1;
   ls->source = source;
+  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
   next(ls);  /* read first char */
 }
-static void save_and_next (LexState *ls) {
-  save(ls, ls->current);
-  next(ls);
-}
 /* LUA_NUMBER */
 static void read_numeral (LexState *ls, SemInfo *seminfo) {
 }
-static int skip_ast (LexState *ls) {
+static int skip_sep (LexState *ls) {
   int count = 0;
   int s = ls->current;
   lua_assert(s == '[' || s == ']');
   save_and_next(ls);
-  while (ls->current == '*') {
+  while (ls->current == '=') {
     save_and_next(ls);
     count++;
   }
 }
-static void read_long_string (LexState *ls, SemInfo *seminfo, int ast) {
+static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
   int cont = 0;
   save_and_next(ls);  /* skip 2nd `[' */
   if (currIsNewline(ls))  /* string starts with a newline? */
                                    "unfinished long comment", TK_EOS);
         break;  /* to avoid warnings */
       case '[':
-        if (skip_ast(ls) == ast) {
+        if (skip_sep(ls) == sep) {
           save_and_next(ls);  /* skip 2nd `[' */
           cont++;
         }
         continue;
       case ']':
-        if (skip_ast(ls) == ast) {
+        if (skip_sep(ls) == sep) {
           save_and_next(ls);  /* skip 2nd `]' */
           if (cont-- == 0) goto endloop;
         }
     }
   } endloop:
   if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + ast),
+    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
-                                     luaZ_bufflen(ls->buff) - 2*(2 + ast));
+                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
 }
         /* else is a comment */
         next(ls);
         if (ls->current == '[') {
-          int ast = skip_ast(ls);
+          int sep = skip_sep(ls);
-          luaZ_resetbuffer(ls->buff);  /* `skip_ast' may dirty the buffer */
+          luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
-          if (ast >= 0) {
+          if (sep >= 0) {
-            read_long_string(ls, NULL, ast);  /* long comment */
+            read_long_string(ls, NULL, sep);  /* long comment */
             luaZ_resetbuffer(ls->buff);
             continue;
           }
         continue;
       }
       case '[': {
-        int ast = skip_ast(ls);
+        int sep = skip_sep(ls);
-        if (ast >= 0) {
+        if (sep >= 0) {
-          read_long_string(ls, seminfo, ast);
+          read_long_string(ls, seminfo, sep);
           return TK_STRING;
         }
-        else if (ast == -1) return '[';
+        else if (sep == -1) return '[';
         else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
       }
       case '=': {

src/llex.h+7−3

 /*
-** $Id: llex.h,v 1.50 2004/03/12 19:53:56 roberto Exp $
+** $Id: llex.h,v 1.52 2004/12/03 20:54:12 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
   TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
   /* other terminal symbols */
-  TK_NAME, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
+  TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
-  TK_STRING, TK_EOS
+  TK_NAME, TK_STRING, TK_EOS
 };
 /* number of reserved words */
 #define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
+/* array with token `names' */
+extern const char *const luaX_tokens [];
 typedef union {
   lua_Number r;
   TString *ts;

src/llimits.h+6−17

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llimits.h,v 1.60 2004/09/10 17:30:46 roberto Exp $	2	** $Id: llimits.h,v 1.61 2004/11/24 18:55:56 roberto Exp $
3	** Limits, basic types, and some other `installation-dependent' definitions	3	** Limits, basic types, and some other `installation-dependent' definitions
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -18,22 +18,9 @@ · 12 unmodified lines
18		18
19	typedef LUA_UINT32 lu_int32;	19	typedef LUA_UINT32 lu_int32;
20		20
21	typedef LUA_INT32 l_int32;	21	typedef LU_MEM lu_mem;
22		22
23		23	typedef L_MEM l_mem;
24	/*
25	** an unsigned integer big enough to count the total memory used by Lua;
26	** it should be at least as large as `size_t'
27	*/
28	typedef lu_int32 lu_mem;
29
30
31	/*
32	** a signed integer big enough to count the total memory used by Lua;
33	** it should be at least as large as `size_t'
34	*/
35	typedef l_int32 l_mem;
36	#define MAXLMEM LUA_MAXINT32
37		24
38		25
39		26
@@ -43,6 +30,8 @@ typedef unsigned char lu_byte; · 3 unmodified lines
43		30
44	#define MAX_SIZET ((size_t)(~(size_t)0)-2)	31	#define MAX_SIZET ((size_t)(~(size_t)0)-2)
45		32
		33	#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2)
		34
46		35
47	#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */	36	#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */
48		37
@@ -51,7 +40,7 @@ typedef unsigned char lu_byte; · 2 unmodified lines
51	** this is for hashing only; there is no problem if the integer	40	** this is for hashing only; there is no problem if the integer
52	** cannot hold the whole pointer value	41	** cannot hold the whole pointer value
53	*/	42	*/
54	#define IntPoint(p) ((unsigned int)(p))	43	#define IntPoint(p) ((unsigned int)(lu_mem)(p))
55		44
56		45
57		46

src/lmem.c+14−11

 /*
-** $Id: lmem.c,v 1.65 2004/08/30 13:44:44 roberto Exp $
+** $Id: lmem.c,v 1.67 2004/12/01 15:46:18 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
 #define MINSIZEARRAY	4
-void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
+void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
-                    int limit, const char *errormsg) {
+                     int limit, const char *errormsg) {
   void *newblock;
   int newsize;
   if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit - MINSIZEARRAY)  /* try something smaller... */
+    if (*size >= limit)  /* cannot grow even a little? */
       luaG_runerror(L, errormsg);
-    newsize = limit;  /* still have at least MINSIZEARRAY free places */
+    newsize = limit;  /* still have at least one free place */
   }
   else {
     newsize = (*size)*2;
     if (newsize < MINSIZEARRAY)
       newsize = MINSIZEARRAY;  /* minimum size */
   }
-  newblock = luaM_realloc(L, block,
+  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
-                          cast(lu_mem, *size)*cast(lu_mem, size_elems),
-                          cast(lu_mem, newsize)*cast(lu_mem, size_elems));
   *size = newsize;  /* update only when everything else is OK */
   return newblock;
 }
+void *luaM_toobig (lua_State *L) {
+  luaG_runerror(L, "memory allocation error: block too big");
+  return NULL;  /* to avoid warnings */
+}
 /*
 ** generic allocation routine.
 */
-void *luaM_realloc (lua_State *L, void *block, lu_mem osize, lu_mem nsize) {
+void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
   global_State *g = G(L);
   lua_assert((osize == 0) == (block == NULL));
-  if (nsize >= MAX_SIZET)
-    luaG_runerror(L, "memory allocation error: block too big");
   block = (*g->realloc)(g->ud, block, osize, nsize);
   if (block == NULL && nsize > 0)
     luaD_throw(L, LUA_ERRMEM);

src/lmem.h+22−16

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lmem.h,v 1.26 2002/05/01 20:40:42 roberto Exp $	2	** $Id: lmem.h,v 1.29 2004/12/01 15:46:18 roberto Exp $
3	** Interface to Memory Manager	3	** Interface to Memory Manager
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -16,28 +16,34 @@ · 10 unmodified lines
16	#define MEMERRMSG "not enough memory"	16	#define MEMERRMSG "not enough memory"
17		17
18		18
19	void luaM_realloc (lua_State L, void *oldblock, lu_mem oldsize, lu_mem size);	19	void luaM_realloc_ (lua_State L, void *block, size_t oldsize, size_t size);
20		20
21	void luaM_growaux (lua_State L, void block, int size, int size_elem,	21	void luaM_toobig (lua_State L);
22	int limit, const char *errormsg);
23		22
24	#define luaM_free(L, b, s) luaM_realloc(L, (b), (s), 0)	23	#define luaM_reallocv(L,b,on,n,e) \
25	#define luaM_freelem(L, b) luaM_realloc(L, (b), sizeof(*(b)), 0)	24	((cast(unsigned int, (n)+1) <= MAX_SIZET/(e)) ? /* +1 to avoid warnings */ \
26	#define luaM_freearray(L, b, n, t) luaM_realloc(L, (b), \	25	luaM_realloc_(L, (b), (on)(e), (n)(e)) : \
27	cast(lu_mem, n)*cast(lu_mem, sizeof(t)), 0)	26	luaM_toobig(L))
28		27
29	#define luaM_malloc(L, t) luaM_realloc(L, NULL, 0, (t))	28
30	#define luaM_new(L, t) cast(t *, luaM_malloc(L, sizeof(t)))	29	void luaM_growaux_ (lua_State L, void block, int size, size_t size_elem,
31	#define luaM_newvector(L, n,t) cast(t *, luaM_malloc(L, \	30	int limit, const char *errormsg);
32	cast(lu_mem, n)*cast(lu_mem, sizeof(t))))	31
		32	#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)
		33	#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)
		34	#define luaM_freearray(L, b, n, t) luaM_reallocv(L, (b), n, 0, sizeof(t))
		35
		36	#define luaM_malloc(L,t) luaM_realloc_(L, NULL, 0, (t))
		37	#define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t)))
		38	#define luaM_newvector(L,n,t) \
		39	cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
33		40
34	#define luaM_growvector(L,v,nelems,size,t,limit,e) \	41	#define luaM_growvector(L,v,nelems,size,t,limit,e) \
35	if (((nelems)+1) > (size)) \	42	if ((nelems)+1 > (size)) \
36	((v)=cast(t *, luaM_growaux(L,v,&(size),sizeof(t),limit,e)))	43	((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
37		44
38	#define luaM_reallocvector(L, v,oldn,n,t) \	45	#define luaM_reallocvector(L, v,oldn,n,t) \
39	((v)=cast(t , luaM_realloc(L, v,cast(lu_mem, oldn)cast(lu_mem, sizeof(t)), \	46	((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
40	cast(lu_mem, n)*cast(lu_mem, sizeof(t)))))
41		47
42		48
43	#endif	49	#endif

src/lobject.c+16−7

 /*
-** $Id: lobject.c,v 2.4 2004/07/09 16:01:38 roberto Exp $
+** $Id: lobject.c,v 2.7 2004/11/24 19:16:03 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
-const TValue luaO_nilobject = {LUA_TNIL, {NULL}};
+const TValue luaO_nilobject = {{NULL}, LUA_TNIL};
 /*
 ** (mmmmmxxx), where the real value is (xxx) * 2^(mmmmm)
 */
 int luaO_int2fb (unsigned int x) {
-  int m = 0;  /* mantissa */
+  int e = 0;  /* expoent */
-  while (x >= (1<<3)) {
+  while (x >= 16) {
     x = (x+1) >> 1;
-    m++;
+    e++;
   }
-  return (m << 3) | cast(int, x);
+  if (x < 8) return x;
+  else return ((e+1) << 3) | (cast(int, x) - 8);
+}
+/* converts back */
+int luaO_fb2int (int x) {
+  int e = (x >> 3) & 31;
+  if (e == 0) return x;
+  else return ((x & 7)+8) << (e - 1);
 }
   char *endptr;
   lua_Number res = lua_str2number(s, &endptr);
   if (endptr == s) return 0;  /* no conversion */
-  while (isspace((unsigned char)(*endptr))) endptr++;
+  while (isspace(cast(unsigned char, *endptr))) endptr++;
   if (*endptr != '\0') return 0;  /* invalid trailing characters? */
   *result = res;
   return 1;

src/lobject.h+15−7

 /*
-** $Id: lobject.h,v 2.5 2004/05/31 18:51:50 roberto Exp $
+** $Id: lobject.h,v 2.8 2004/12/04 18:10:22 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
 */
 #define LUA_TPROTO	(NUM_TAGS+1)
 #define LUA_TUPVAL	(NUM_TAGS+2)
+#define LUA_TDEADKEY	(NUM_TAGS+3)
 /*
 /*
 ** Tagged Values
 */
+#define TValuefields	Value value; int tt
 typedef struct lua_TValue {
-  int tt;
+  TValuefields;
-  Value value;
 } TValue;
 #define setobj(L,obj1,obj2) \
   { const TValue *o2=(obj2); TValue *o1=(obj1); \
-    o1->tt=o2->tt; o1->value = o2->value; \
+    o1->value = o2->value; o1->tt=o2->tt; \
     checkliveness(G(L),o1); }
 ** Tables
 */
+typedef struct TKey {
+  TValuefields;
+  struct Node *next;  /* for chaining */
+} TKey;
 typedef struct Node {
-  TValue i_key;
   TValue i_val;
-  struct Node *next;  /* for chaining */
+  TKey i_key;
 } Node;
 int luaO_log2 (unsigned int x);
 int luaO_int2fb (unsigned int x);
-#define fb2int(x)	(((x) & 7) << ((x) >> 3))
+int luaO_fb2int (int x);
 int luaO_rawequalObj (const TValue *t1, const TValue *t2);
 int luaO_str2d (const char *s, lua_Number *result);

src/lopcodes.c+5−6

 /*
-** $Id: lopcodes.c,v 1.28 2004/07/16 13:15:32 roberto Exp $
+** $Id: lopcodes.c,v 1.30 2004/12/02 12:59:10 roberto Exp $
 ** See Copyright Notice in lua.h
 */
 /* ORDER OP */
-const char *const luaP_opnames[NUM_OPCODES] = {
+const char *const luaP_opnames[NUM_OPCODES+1] = {
   "MOVE",
   "LOADK",
   "LOADBOOL",
   "TFORLOOP",
   "TFORPREP",
   "SETLIST",
-  "SETLISTO",
   "CLOSE",
   "CLOSURE",
-  "VARARG"
+  "VARARG",
+  NULL
 };
  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
  ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TFORLOOP */
  ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_TFORPREP */
- ,opmode(0, 0, OpArgU, OpArgN, iABx)		/* OP_SETLIST */
+ ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
- ,opmode(0, 0, OpArgU, OpArgN, iABx)		/* OP_SETLISTO */
  ,opmode(0, 0, OpArgN, OpArgN, iABC)		/* OP_CLOSE */
  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */

src/lopcodes.h+10−8

 /*
-** $Id: lopcodes.h,v 1.111 2004/08/04 20:18:13 roberto Exp $
+** $Id: lopcodes.h,v 1.114 2004/12/02 12:59:10 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 OP_TFORPREP,/*	A sBx	if type(R(A)) == table then R(A+1):=R(A), R(A):=next;
 			pc+=sBx					*/
-OP_SETLIST,/*	A Bx	R(A)[Bx-Bx%FPF+i] := R(A+i), 1 <= i <= Bx%FPF+1	*/
+OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
-OP_SETLISTO,/*	A Bx							*/
 OP_CLOSE,/*	A 	close all variables in the stack up to (>=) R(A)*/
 OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))	*/
       next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
   (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
-      set top (like in OP_CALL).
+      set top (like in OP_CALL with C == 0).
   (*) In OP_RETURN, if (B == 0) then return up to `top'
-  (*) For comparisons, B specifies what conditions the test should accept.
+  (*) In OP_SETLIST, if (B == 0) then B = `top';
+      if (C == 0) then next `instruction' is real C
+  (*) For comparisons, A specifies what condition the test should accept
+      (true or false).
   (*) All `skips' (pc++) assume that next instruction is a jump
 ===========================================================================*/
 #define testTMode(m)	(luaP_opmodes[m] & (1 << 7))
-extern const char *const luaP_opnames[NUM_OPCODES];  /* opcode names */
+extern const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
 /* number of list items to accumulate before a SETLIST instruction */
-/* (must be a power of 2) */
+#define LFIELDS_PER_FLUSH	50
-#define LFIELDS_PER_FLUSH	32
 #endif

src/lparser.c+16−19

 /*
-** $Id: lparser.c,v 2.5 2004/05/31 18:51:50 roberto Exp $
+** $Id: lparser.c,v 2.10 2004/12/03 20:50:25 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 #define getlocvar(fs, i)	((fs)->f->locvars[(fs)->actvar[i]])
-#define luaY_checklimit(fs,v,l,m)	if ((v)>(l)) luaY_errorlimit(fs,l,m)
+#define luaY_checklimit(fs,v,l,m)	if ((v)>(l)) errorlimit(fs,l,m)
 #define enterlevel(ls) if (++(ls)->nestlevel > LUA_MAXPARSERLEVEL) \
 	luaX_lexerror(ls, "chunk has too many syntax levels", 0)
 }
-static void luaY_errorlimit (FuncState *fs, int limit, const char *what) {
+static void errorlimit (FuncState *fs, int limit, const char *what) {
   const char *msg = (fs->f->lineDefined == 0) ?
     luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
     luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
 static TString *str_checkname (LexState *ls) {
   TString *ts;
-  check_condition(ls, (ls->t.token == TK_NAME), "<name> expected");
+  if (ls->t.token != TK_NAME) error_expected(ls, TK_NAME);
   ts = ls->t.seminfo.ts;
   next(ls);
   return ts;
 }
-static int luaI_registerlocalvar (LexState *ls, TString *varname) {
+static int registerlocalvar (LexState *ls, TString *varname) {
   FuncState *fs = ls->fs;
   Proto *f = fs->f;
   int oldsize = f->sizelocvars;
 static void new_localvar (LexState *ls, TString *name, int n) {
   FuncState *fs = ls->fs;
   luaY_checklimit(fs, fs->nactvar+n+1, MAXVARS, "local variables");
-  fs->actvar[fs->nactvar+n] = cast(unsigned short,
+  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
-                                   luaI_registerlocalvar(ls, name));
 }
 /*============================================================*/
-static void luaY_field (LexState *ls, expdesc *v) {
+static void field (LexState *ls, expdesc *v) {
   /* field -> ['.' | ':'] NAME */
   FuncState *fs = ls->fs;
   expdesc key;
 }
-static void luaY_index (LexState *ls, expdesc *v) {
+static void yindex (LexState *ls, expdesc *v) {
   /* index -> '[' expr ']' */
   next(ls);  /* skip the '[' */
   expr(ls, v);
     checkname(ls, &key);
   }
   else  /* ls->t.token == '[' */
-    luaY_index(ls, &key);
+    yindex(ls, &key);
   check(ls, '=');
   luaK_exp2RK(fs, &key);
   expr(ls, &val);
   luaK_exp2nextreg(fs, &cc->v);
   cc->v.k = VVOID;
   if (cc->tostore == LFIELDS_PER_FLUSH) {
-    luaK_codeABx(fs, OP_SETLIST, cc->t->info, cc->na-1);  /* flush */
+    luaK_setlist(fs, cc->t->info, cc->na, cc->tostore);  /* flush */
     cc->tostore = 0;  /* no more items pending */
-    fs->freereg = cc->t->info + 1;  /* free registers */
   }
 }
   if (cc->tostore == 0) return;
   if (hasmultret(cc->v.k)) {
     luaK_setmultret(fs, &cc->v);
-    luaK_codeABx(fs, OP_SETLISTO, cc->t->info, cc->na-1);
+    luaK_setlist(fs, cc->t->info, cc->na, LUA_MULTRET);
     cc->na--;  /* do not count last expression (unknown number of elements) */
   }
   else {
     if (cc->v.k != VVOID)
       luaK_exp2nextreg(fs, &cc->v);
-    luaK_codeABx(fs, OP_SETLIST, cc->t->info, cc->na-1);
+    luaK_setlist(fs, cc->t->info, cc->na, cc->tostore);
   }
-  fs->freereg = cc->t->info + 1;  /* free registers */
 }
   for (;;) {
     switch (ls->t.token) {
       case '.': {  /* field */
-        luaY_field(ls, v);
+        field(ls, v);
         break;
       }
       case '[': {  /* `[' exp1 `]' */
         expdesc key;
         luaK_exp2anyreg(fs, v);
-        luaY_index(ls, &key);
+        yindex(ls, &key);
         luaK_indexed(fs, v, &key);
         break;
       }
   int needself = 0;
   singlevar(ls, v, 1);
   while (ls->t.token == '.')
-    luaY_field(ls, v);
+    field(ls, v);
   if (ls->t.token == ':') {
     needself = 1;
-    luaY_field(ls, v);
+    field(ls, v);
   }
   return needself;
 }

src/lstate.c+6−4

 /*
-** $Id: lstate.c,v 2.14 2004/09/15 20:39:42 roberto Exp $
+** $Id: lstate.c,v 2.18 2004/12/06 17:53:42 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
   Udata *u;  /* head of udata list */
   global_State *g = G(L);
   UNUSED(ud);
-  u = cast(Udata *, luaM_malloc(L, sizeudata(0)));
+  u = luaM_new(L, Udata);
   u->uv.len = 0;
   u->uv.metatable = NULL;
   g->firstudata = obj2gco(u);
   luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
   lua_assert(L1->openupval == NULL);
   freestack(L, L1);
-  luaM_free(L, fromstate(L1), state_size(lua_State));
+  luaM_freemem(L, fromstate(L1), state_size(lua_State));
 }
   g->tmudata = NULL;
   setnilvalue(gkey(g->dummynode));
   setnilvalue(gval(g->dummynode));
-  g->dummynode->next = NULL;
+  gnext(g->dummynode) = NULL;
   g->totalbytes = sizeof(LG);
+  g->stepmul = STEPMUL;
+  g->incgc = 1;
   if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
     /* memory allocation error: free partial state */
     close_state(L);

src/lstate.h+3−1

 /*
-** $Id: lstate.h,v 2.8 2004/09/15 20:39:42 roberto Exp $
+** $Id: lstate.h,v 2.9 2004/12/06 17:53:42 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
   lu_mem totalbytes;  /* number of bytes currently allocated */
   lu_mem estimate;  /* an estimate of number of bytes actually in use */
   lu_mem prevestimate;  /* previous estimate */
+  int stepmul;  /* relative `speed' of the GC */
+  int incgc;  /* 0 if GC is done non-incrementally */
   lua_CFunction panic;  /* to be called in unprotected errors */
   TValue _registry;
   struct lua_State *mainthread;

src/lstring.c+9−4

 /*
-** $Id: lstring.c,v 2.3 2004/08/24 20:12:06 roberto Exp $
+** $Id: lstring.c,v 2.5 2004/11/24 19:16:03 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 static TString *newlstr (lua_State *L, const char *str, size_t l,
                                        unsigned int h) {
-  TString *ts = cast(TString *, luaM_malloc(L, sizestring(l)));
+  TString *ts;
   stringtable *tb;
+  if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
+    luaM_toobig(L);
+  ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
   ts->tsv.len = l;
   ts->tsv.hash = h;
   ts->tsv.marked = luaC_white(G(L));
   size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
   size_t l1;
   for (l1=l; l1>=step; l1-=step)  /* compute hash */
-    h = h ^ ((h<<5)+(h>>2)+(unsigned char)(str[l1-1]));
+    h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
   for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
        o != NULL;
        o = o->gch.next) {
 Udata *luaS_newudata (lua_State *L, size_t s) {
   Udata *u;
-  u = cast(Udata *, luaM_malloc(L, sizeudata(s)));
+  if (s > MAX_SIZET - sizeof(Udata))
+    luaM_toobig(L);
+  u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
   u->uv.marked = luaC_white(G(L));  /* is not finalized */
   u->uv.tt = LUA_TUSERDATA;
   u->uv.len = s;

src/lstring.h+3−4

 /*
-** $Id: lstring.h,v 1.39 2004/08/24 20:12:06 roberto Exp $
+** $Id: lstring.h,v 1.40 2004/11/19 15:52:40 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #include "lstate.h"
-#define sizestring(l)	(cast(lu_mem, sizeof(union TString))+ \
+#define sizestring(s)	(sizeof(union TString)+((s)->len+1)*sizeof(char))
-                         (cast(lu_mem, l)+1)*sizeof(char))
-#define sizeudata(l)	(cast(lu_mem, sizeof(union Udata))+(l))
+#define sizeudata(u)	(sizeof(union Udata)+(u)->len)
 #define luaS_new(L, s)	(luaS_newlstr(L, s, strlen(s)))
 #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \

src/ltable.c+45−40

 /*
-** $Id: ltable.c,v 2.5 2004/08/31 17:57:33 roberto Exp $
+** $Id: ltable.c,v 2.12 2004/12/04 18:10:22 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 ** max size of array part is 2^MAXBITS
 */
 #if LUA_BITSINT > 26
-#define MAXBITS		24
+#define MAXBITS		26
 #else
 #define MAXBITS		(LUA_BITSINT-2)
 #endif
 ** returns the index for `key' if `key' is an appropriate key to live in
 ** the array part of the table, -1 otherwise.
 */
-static int arrayindex (const TValue *key, lua_Number lim) {
+static int arrayindex (const TValue *key) {
   if (ttisnumber(key)) {
     lua_Number n = nvalue(key);
     int k;
-    if (n <= 0 || n > lim) return -1;  /* out of range? */
     lua_number2int(k, n);
     if (cast(lua_Number, k) == nvalue(key))
       return k;
 /*
 ** returns the index of a `key' for table traversals. First goes all
 ** elements in the array part, then elements in the hash part. The
-** beginning and end of a traversal are signalled by -1.
+** beginning of a traversal is signalled by -1.
 */
-static int luaH_index (lua_State *L, Table *t, StkId key) {
+static int findindex (lua_State *L, Table *t, StkId key) {
   int i;
   if (ttisnil(key)) return -1;  /* first iteration */
-  i = arrayindex(key, t->sizearray);
+  i = arrayindex(key);
-  if (0 <= i) {  /* is `key' inside array part? */
+  if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
     return i-1;  /* yes; that's the index (corrected to C) */
-  }
   else {
-    const TValue *v = luaH_get(t, key);
+    Node *n = luaH_mainposition(t, key);
-    if (v == &luaO_nilobject)
+    do {  /* check whether `key' is somewhere in the chain */
-      luaG_runerror(L, "invalid key for `next'");
+      /* key may be dead already, but it is ok to use it in `next' */
-    i = cast(int, (cast(const lu_byte *, v) -
+      if (luaO_rawequalObj(key2tval(n), key) ||
-                   cast(const lu_byte *, gval(gnode(t, 0)))) / sizeof(Node));
+            (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
-    return i + t->sizearray;  /* hash elements are numbered after array ones */
+             gcvalue(gkey(n)) == gcvalue(key))) {
+        i = n - gnode(t, 0);  /* key index in hash table */
+        /* hash elements are numbered after array ones */
+        return i + t->sizearray;
+      }
+      else n = gnext(n);
+    } while (n);
+    luaG_runerror(L, "invalid key for `next'");  /* key not found */
+    return 0;  /* to avoid warnings */
   }
 }
 int luaH_next (lua_State *L, Table *t, StkId key) {
-  int i = luaH_index(L, t, key);  /* find original element */
+  int i = findindex(L, t, key);  /* find original element */
   for (i++; i < t->sizearray; i++) {  /* try first array part */
     if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
       setnvalue(key, cast(lua_Number, i+1));
   }
   for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */
     if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
-      setobj2s(L, key, gkey(gnode(t, i)));
+      setobj2s(L, key, key2tval(gnode(t, i)));
       setobj2s(L, key+1, gval(gnode(t, i)));
       return 1;
     }
   int nums[MAXBITS+1];
   int i, lg;
   int totaluse = 0;
-  lua_Number sizelimit;  /* an upper bound for the array size */
   /* count elements in array part */
   for (i=0, lg=0; lg<=MAXBITS; lg++) {  /* for each slice [2^(lg-1) to 2^lg) */
     int ttlg = twoto(lg);  /* 2^lg */
   *narray = totaluse;  /* all previous uses were in array part */
   /* count elements in hash part */
   i = sizenode(t);
-  /* array part cannot be larger than twice the maximum number of elements */
-  sizelimit = cast(lua_Number, totaluse + i) * 2;
-  if (sizelimit >= MAXASIZE) sizelimit = MAXASIZE;
   while (i--) {
     Node *n = &t->node[i];
     if (!ttisnil(gval(n))) {
-      int k = arrayindex(gkey(n), sizelimit);
+      int k = arrayindex(key2tval(n));
-      if (k >= 0) {  /* is `key' an appropriate array index? */
+      if (0 < k && k <= MAXASIZE) {  /* is `key' an appropriate array index? */
         nums[luaO_log2(k-1)+1]++;  /* count as such */
         (*narray)++;
       }
     t->node = G(L)->dummynode;  /* use common `dummynode' */
     lua_assert(ttisnil(gkey(t->node)));  /* assert invariants: */
     lua_assert(ttisnil(gval(t->node)));
-    lua_assert(t->node->next == NULL);  /* (`dummynode' must be empty) */
+    lua_assert(gnext(t->node) == NULL);  /* (`dummynode' must be empty) */
   }
   else {
     t->node = luaM_newvector(L, size, Node);
     for (i=0; i<size; i++) {
-      t->node[i].next = NULL;
+      gnext(&t->node[i]) = NULL;
       setnilvalue(gkey(gnode(t, i)));
       setnilvalue(gval(gnode(t, i)));
     }
     nold = temp;
     setnilvalue(gkey(G(L)->dummynode));  /* restate invariant */
     setnilvalue(gval(G(L)->dummynode));
-    lua_assert(G(L)->dummynode->next == NULL);
+    lua_assert(gnext(G(L)->dummynode) == NULL);
   }
   if (nasize > oldasize)  /* array part must grow? */
     setarrayvector(L, t, nasize);
   for (i = twoto(oldhsize) - 1; i >= 0; i--) {
     Node *old = nold+i;
     if (!ttisnil(gval(old)))
-      setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
+      setobjt2t(L, luaH_set(L, t, key2tval(old)), gval(old));
   }
   if (oldhsize)
     luaM_freearray(L, nold, twoto(oldhsize), Node);  /* free old array */
   if (t->lsizenode)
     luaM_freearray(L, t->node, sizenode(t), Node);
   luaM_freearray(L, t->array, t->sizearray, TValue);
-  luaM_freelem(L, t);
+  luaM_free(L, t);
 }
   TValue *val;
   Node *mp = luaH_mainposition(t, key);
   if (!ttisnil(gval(mp))) {  /* main position is not free? */
-    Node *othern = luaH_mainposition(t, gkey(mp));  /* `mp' of colliding node */
+    /* `mp' of colliding node */
+    Node *othern = luaH_mainposition(t, key2tval(mp));
     Node *n = t->firstfree;  /* get a free place */
     if (othern != mp) {  /* is colliding node out of its main position? */
       /* yes; move colliding node into free position */
-      while (othern->next != mp) othern = othern->next;  /* find previous */
+      while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */
-      othern->next = n;  /* redo the chain with `n' in place of `mp' */
+      gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */
       *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
-      mp->next = NULL;  /* now `mp' is free */
+      gnext(mp) = NULL;  /* now `mp' is free */
       setnilvalue(gval(mp));
     }
     else {  /* colliding node is in its own main position */
       /* new node will go into free position */
-      n->next = mp->next;  /* chain new position */
+      gnext(n) = gnext(mp);  /* chain new position */
-      mp->next = n;
+      gnext(mp) = n;
       mp = n;
     }
   }
-  setobj2t(L, gkey(mp), key);
+  gkey(mp)->value = key->value; gkey(mp)->tt = key->tt;
   luaC_barriert(L, t, key);
   lua_assert(ttisnil(gval(mp)));
   for (;;) {  /* correct `firstfree' */
 ** search function for integers
 */
 const TValue *luaH_getnum (Table *t, int key) {
-  if (1 <= key && key <= t->sizearray)
+  /* (1 <= key && key <= t->sizearray) */
+  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
     return &t->array[key-1];
   else {
     lua_Number nk = cast(lua_Number, key);
     do {  /* check whether `key' is somewhere in the chain */
       if (ttisnumber(gkey(n)) && nvalue(gkey(n)) == nk)
         return gval(n);  /* that's it */
-      else n = n->next;
+      else n = gnext(n);
     } while (n);
     return &luaO_nilobject;
   }
   do {  /* check whether `key' is somewhere in the chain */
     if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
       return gval(n);  /* that's it */
-    else n = n->next;
+    else n = gnext(n);
   } while (n);
   return &luaO_nilobject;
 }
     default: {
       Node *n = luaH_mainposition(t, key);
       do {  /* check whether `key' is somewhere in the chain */
-        if (luaO_rawequalObj(gkey(n), key)) return gval(n);  /* that's it */
+        if (luaO_rawequalObj(key2tval(n), key))
-        else n = n->next;
+          return gval(n);  /* that's it */
+        else n = gnext(n);
       } while (n);
       return &luaO_nilobject;
     }

src/ltable.h+4−1

 /*
-** $Id: ltable.h,v 2.2 2004/03/26 14:02:41 roberto Exp $
+** $Id: ltable.h,v 2.3 2004/10/06 18:34:16 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define gnode(t,i)	(&(t)->node[i])
 #define gkey(n)		(&(n)->i_key)
 #define gval(n)		(&(n)->i_val)
+#define gnext(n)	((n)->i_key.next)
+#define key2tval(n)	(cast(const TValue *, gkey(n)))
 const TValue *luaH_getnum (Table *t, int key);

src/lua/lua.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lua.c,v 1.132 2004/08/30 18:35:14 roberto Exp $	2	** $Id: lua.c,v 1.133 2004/11/18 19:53:49 roberto Exp $
3	** Lua stand-alone interpreter	3	** Lua stand-alone interpreter
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -127,9 +127,9 @@ static int dostring (lua_State L, const char s, const char *name) { · 121 unmodified lines
127		127
128		128
129	static int dolibrary (lua_State L, const char name) {	129	static int dolibrary (lua_State L, const char name) {
130	lua_getfield(L, LUA_GLOBALSINDEX, "_PATH");	130	luaL_getfield(L, LUA_GLOBALSINDEX, "package.path");
131	if (!lua_isstring(L, -1)) {	131	if (!lua_isstring(L, -1)) {
132	l_message(progname, "global _PATH must be a string");	132	l_message(progname, "`package.path' must be a string");
133	return 1;	133	return 1;
134	}	134	}
135	name = luaL_searchpath(L, name, lua_tostring(L, -1));	135	name = luaL_searchpath(L, name, lua_tostring(L, -1));
@@ -295,7 +295,7 @@ static int handle_argv (lua_State L, char argv[], int *interactive) { · 159 unmodified lines
295	print_usage();	295	print_usage();
296	return 1;	296	return 1;
297	}	297	}
298	if (dostring(L, chunk, "=<command line>") != 0)	298	if (dostring(L, chunk, "=(command line)") != 0)
299	return 1;	299	return 1;
300	break;	300	break;
301	}	301	}

src/luac/print.c+8−5

 /*
-** $Id: print.c,v 1.48 2004/09/01 21:22:34 lhf Exp $
+** $Id: print.c,v 1.49 2004/11/25 09:31:41 lhf Exp $
 ** print bytecodes
 ** See Copyright Notice in lua.h
 */
    case '\r': printf("\\r"); break;
    case '\t': printf("\\t"); break;
    case '\v': printf("\\v"); break;
-   default:   printf(isprint(*s) ? "%c" : "\\%03d",*s);
+   default:   printf(isprint((unsigned char)*s) ? "%c" : "\\%03d",*s);
   }
  }
  putchar('"');
  const TValue* o=&f->k[i];
  switch (ttype(o))
  {
+  case LUA_TNIL:
+	printf("nil");
+	break;
+  case LUA_TBOOLEAN:
+	printf(bvalue(o) ? "true" : "false");
+	break;
   case LUA_TNUMBER:
 	printf(LUA_NUMBER_FMT,nvalue(o));
 	break;
   case LUA_TSTRING:
 	PrintString(f,i);
 	break;
-  case LUA_TNIL:
-	printf("nil");
-	break;
   default:				/* cannot happen */
 	printf("? type=%d",ttype(o));
 	break;

src/lundump.c+10−11

 /*
-** $Id: lundump.c,v 1.53 2004/09/01 21:22:34 lhf Exp $
+** $Id: lundump.c,v 1.54 2004/11/25 09:31:41 lhf Exp $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
   int t=LoadByte(S);
   switch (t)
   {
+   case LUA_TNIL:
+   	setnilvalue(o);
+	break;
+   case LUA_TBOOLEAN:
+   	setbvalue(o,LoadByte(S));
+	break;
    case LUA_TNUMBER:
 	setnvalue(o,LoadNumber(S));
 	break;
    case LUA_TSTRING:
 	setsvalue2n(S->L,o,LoadString(S));
 	break;
-   case LUA_TNIL:
-   	setnilvalue(o);
-	break;
    default:
 	error(S,"bad constant type (%d)",t);
 	break;
  lua_Number x,tx=TEST_NUMBER;
  LoadSignature(S);
  version=LoadByte(S);
- if (version>VERSION)
+ if (version!=VERSION)
-  error(S,"bad version (read %d.%d; expected at %s %d.%d)",
+  error(S,"bad version (read %d.%d; expected %d.%d)",V(version),V(VERSION));
-	V(version),"most",V(VERSION));
- if (version<VERSION0)				/* check last major change */
-  error(S,"bad version (read %d.%d; expected at %s %d.%d)",
-	V(version),"least",V(VERSION0));
  S->swap=(luaU_endianness()!=LoadByte(S));	/* need to swap bytes? */
  TestSize(S,sizeof(int),"int");
  TestSize(S,sizeof(size_t),"size_t");
  TestSize(S,sizeof(Instruction),"instruction");
  TestSize(S,sizeof(lua_Number),"number");
  x=LoadNumber(S);
- if ((long)x!=(long)tx)		/* disregard errors in last bits of fraction */
+ if (x!=tx)
   error(S,"unknown number format");
 }

src/lundump.h+5−7

 /*
-** $Id: lundump.h,v 1.33 2004/06/09 21:03:53 lhf Exp $
+** $Id: lundump.h,v 1.34 2004/11/25 09:31:41 lhf Exp $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 /* print one chunk; from print.c */
 void luaU_print (const Proto* f, int full);
-/* definitions for headers of binary files */
+/* for header of binary files -- this is Lua 5.1 */
-#define	VERSION		0x51		/* last format change was in 5.1 */
+#define	VERSION		0x51
-#define	VERSION0	0x51		/* last major  change was in 5.1 */
-/* a multiple of PI for testing native format */
+/* for testing native format of lua_Numbers */
-/* multiplying by 1E7 gives non-trivial integer values */
+#define	TEST_NUMBER	((lua_Number)31415926.0)
-#define	TEST_NUMBER	((lua_Number)3.14159265358979323846E7)
 #endif

src/lvm.c+17−20

 /*
-** $Id: lvm.c,v 2.14 2004/09/15 20:39:42 roberto Exp $
+** $Id: lvm.c,v 2.18 2004/12/03 20:35:33 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 }
-static int luaV_strcmp (const TString *ls, const TString *rs) {
+static int l_strcmp (const TString *ls, const TString *rs) {
   const char *l = getstr(ls);
   size_t ll = ls->tsv.len;
   const char *r = getstr(rs);
   else if (ttisnumber(l))
     return nvalue(l) < nvalue(r);
   else if (ttisstring(l))
-    return luaV_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
+    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
   else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
     return res;
   return luaG_ordererror(L, l, r);
 }
-static int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
+static int lessequal (lua_State *L, const TValue *l, const TValue *r) {
   int res;
   if (ttype(l) != ttype(r))
     return luaG_ordererror(L, l, r);
   else if (ttisnumber(l))
     return nvalue(l) <= nvalue(r);
   else if (ttisstring(l))
-    return luaV_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
+    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
   else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */
     return res;
   else if ((res = call_orderTM(L, r, l, TM_LT)) != -1)  /* else try `lt' */
         luaG_concaterror(L, top-2, top-1);
     } else if (tsvalue(top-1)->len > 0) {  /* if len=0, do nothing */
       /* at least two string values; get as many as possible */
-      lu_mem tl = cast(lu_mem, tsvalue(top-1)->len) +
+      size_t tl = tsvalue(top-1)->len;
-                  cast(lu_mem, tsvalue(top-2)->len);
       char *buffer;
       int i;
-      while (n < total && tostring(L, top-n-1)) {  /* collect total length */
+      /* collect total length */
+      for (n = 1; n < total && tostring(L, top-n-1); n++) {
         size_t l = tsvalue(top-n-1)->len;
         if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
         tl += l;
-        n++;
       }
       buffer = luaZ_openspace(L, &G(L)->buff, tl);
       tl = 0;
       }
       case OP_NEWTABLE: {
         int b = GETARG_B(i);
-        b = fb2int(b);
+        b = luaO_fb2int(b);
         sethvalue(L, ra, luaH_new(L, b, GETARG_C(i)));
         L->ci->savedpc = pc;
         luaC_checkGC(L);  /***/
       }
       case OP_LE: {
         L->ci->savedpc = pc;
-        if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;  /***/
+        if (lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;  /***/
         else dojump(L, pc, GETARG_sBx(*pc) + 1);
         base = L->base;
         continue;
         dojump(L, pc, GETARG_sBx(i));
         continue;
       }
-      case OP_SETLIST:
+      case OP_SETLIST: {
-      case OP_SETLISTO: {
+        int n = GETARG_B(i);
-        int bc = GETARG_Bx(i);
+        int c = GETARG_C(i);
-        int n, last;
+        int last;
         Table *h;
         runtime_check(L, ttistable(ra));
         h = hvalue(ra);
-        if (GET_OPCODE(i) == OP_SETLIST)
+        if (n == 0) {
-          n = (bc&(LFIELDS_PER_FLUSH-1)) + 1;
-        else {
           n = L->top - ra - 1;
           L->top = L->ci->top;
         }
-        bc &= ~(LFIELDS_PER_FLUSH-1);  /* bc = bc - bc%FPF */
+        if (c == 0) c = cast(int, *pc++);
-        last = bc + n + LUA_FIRSTINDEX - 1;
+        last = ((c-1)*LFIELDS_PER_FLUSH) + n + LUA_FIRSTINDEX - 1;
         if (last > h->sizearray)  /* needs more space? */
           luaH_resize(L, h,  last, h->lsizenode);  /* pre-alloc it at once */
         for (; n > 0; n--) {

Lua 5.1-work3

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code