plan9-archive/lua

HISTORY+1−1

@@ -1,4 +1,4 @@
1	This is Lua 5.0.	1	This is Lua 5.1 (work).
2		2
3	* Changes from version 4.0 to 5.0	3	* Changes from version 4.0 to 5.0
4	-------------------------------	4	-------------------------------

INSTALL+11−11

-This is Lua 5.0.
+This is Lua 5.1 (work).
 * Installation
   ------------
 	1. Read "config" and edit it to suit your platform and needs.
 	   We strongly recommend that you enable support for dynamic loading,
 	   if your platform allows it.
-	2. Do "make".
+	2. Do the same for include/luaconf.h.
-	3. If you want to install Lua in an "official" place in your system,
+	3. Do "make".
+	4. If you want to install Lua in an "official" place in your system,
 	   then do "make install". The official place and the way to install
 	   files are defined in "config". You may have to be root to do this.
   /usr/local/lib may not be a place that is checked for shared libraries.
   In Linux, the places checked are in /etc/ld.so.conf. Try also "man ld.so".
-  Building shared libraries in other systems is similar but details differ;
+  Building shared libraries on other systems is similar but details differ;
   you may need to fix a few details in the top-level Makefile.
 * Installation on Windows and other systems
   -----------------------------------------
-  The instructions for building Lua on other systems machine depend on the
+  The instructions for building Lua on other systems depend on the particular
-  particular compiler you are using. The simplest way is to create a folder
+  compiler you are using. The simplest way is to create a folder with all .c
-  with all .c and .h files, and then create projects for the core library,
+  and .h files, and then create projects for the core library, the standard
-  the standard library, the interpreter, and the compiler, as follows:
+  library, the interpreter, and the compiler, as follows:
   core lib:	lapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c
                 lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c
 		ltable.c ltm.c lundump.c lvm.c lzio.c
-  standard lib:	lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c ltablib.c
+  standard lib:	lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c
-                lstrlib.c loadlib.c
+  		ltablib.c lstrlib.c loadlib.c
   interpreter:	core lib, standard lib, lua.c
   compiler:	core lib, lauxlib.c luac.c print.c
-		and also lopcodes.c (with LUA_OPNAMES defined) from core.
   Of course, to use Lua as a library, you'll have to know how to create
   and use libraries with your compiler.

MANIFEST+114−0

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

RCS+0−1

@@ -1 +0,0 @@
1	../RCS

README+1−1

@@ -1,4 +1,4 @@
1	This is Lua 5.0.	1	This is Lua 5.1 (work).
2	See HISTORY for a summary of changes since the last released version.	2	See HISTORY for a summary of changes since the last released version.
3		3
4	* What is Lua?	4	* What is Lua?

build+6−3

-# If you don't want to use make, run this script.
+#!/bin/sh
-# But make sure you read config to see what can be customized.
+#
+# If you don't want to use make, run this script to build Lua.
+# Read config and include/luaconf.h to see what can be customized.
 # Easiest way to build bin/lua:
 # cc -O2 -o bin/lua -Iinclude -Isrc src/*.c src/lib/*.c src/lua/*.c -lm -ldl
+# bin/lua test/hello.lua
 # Easiest way to build Lua libraries and executables:
 echo -n 'luac... '
 cd ../luac
-cc -O2 -o ../../bin/luac -I../../include -I.. *.c -DLUA_OPNAMES ../lopcodes.c ../../lib/*.a
+cc -O2 -o ../../bin/luac -I../../include -I.. *.c ../../lib/*.a
 echo 'done'

config+5−48

@@ -1,14 +1,10 @@
1	# configuration file for making Lua 5.0	1	# configuration file for making Lua 5.1 (work)
2	# see INSTALL for installation instructions	2	# see INSTALL for installation instructions
3		3
4	# These are default values. Skip this section and see the explanations below.	4	# These are default values. Skip this section and see the explanations below.
5		5
6	LOADLIB=	6	LOADLIB=
7	DLLIB=	7	DLLIB=
8	NUMBER=
9	POPEN=
10	TMPNAM=
11	DEGREES=
12	USERCONF=	8	USERCONF=
13		9
14	# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================	10	# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
@@ -42,50 +38,11 @@ USERCONF= · 27 unmodified lines
42		38
43	# --------------------------------------------------------------- Lua libraries	39	# --------------------------------------------------------------- Lua libraries
44		40
45	# The Lua IO library (src/lib/liolib.c) has support for pipes using popen and	41	# See include/luaconf.h.
46	# pclose. This support is enabled by default on POSIX systems.
47	# If your system is not POSIX but has popen and pclose, define USE_POPEN=1.
48	# If you don't want to support pipes, define USE_POPEN=0.
49	#
50	#POPEN= -DUSE_POPEN=1
51	#POPEN= -DUSE_POPEN=0
52	#
53	# The form below will probably work on (some) Windows systems.
54	#
55	#POPEN= -DUSE_POPEN=1 -Dpopen=_popen -Dpclose=_pclose
56
57	# The Lua OS library (src/lib/liolib.c) exports an interface to the C function
58	# tmpnam, which gcc now thinks is `dangerous'. So, support for tmpnam is
59	# disabled by default when compiling with gcc.
60	# If you still want to use tmpnam, define USE_TMPNAME=1. If you don't want to
61	# use tmpnam even if you're not compiling with gcc, define USE_TMPNAME=0.
62	#
63	#TMPNAM= -DUSE_TMPNAME=1
64	#TMPNAM= -DUSE_TMPNAME=0
65
66	# The Lua math library (src/lib/lmathlib.c) now operates in radians, unlike
67	# previous versions of Lua, which used degrees. To use degrees instead of
68	# radians, define USE_DEGREES.
69	#
70	#DEGREES= -DUSE_DEGREES
71		42
72	# ------------------------------------------------------------------ Lua core	43	# ------------------------------------------------------------------ Lua core
73		44
74	# Lua uses double for numbers. To change this, uncomment and edit the following	45	# See include/luaconf.h.
75	# line, changing USE_XXX to one of USE_DOUBLE, USE_FLOAT, USE_LONG, USE_INT.
76	#
77	#NUMBER= -DLUA_USER_H='"../etc/luser_number.h"' -DUSE_XXX
78
79	# When compiling Lua with gcc on a Pentium machine, using a fast rounding
80	# method for the conversion of doubles to ints can give around 20% speed
81	# improvement. To use this rounding method, uncomment the following line.
82	#NUMBER= -DLUA_USER_H='"../etc/luser_number.h"' -DUSE_FASTROUND
83
84	# For partial compatibility with old upvalue syntax, define LUA_COMPATUPSYNTAX.
85	# For partial compatibility with old upvalue behavior in C functions, define
86	# LUA_COMPATUPVALUES. Add these definitions to MYCFLAGS.
87	#
88	# -DLUA_COMPATUPSYNTAX -DLUA_COMPATUPVALUES
89		46
90	# ------------------------------------------------------------- Lua interpreter	47	# ------------------------------------------------------------- Lua interpreter
91		48
@@ -165,14 +122,14 @@ INSTALL_DATA= cp · 73 unmodified lines
165		122
166	# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========	123	# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
167		124
168	V= 5.0	125	V= 5.1
169		126
170	BIN= $(LUA)/bin	127	BIN= $(LUA)/bin
171	INC= $(LUA)/include	128	INC= $(LUA)/include
172	LIB= $(LUA)/lib	129	LIB= $(LUA)/lib
173		130
174	INCS= -I$(INC) $(EXTRA_INCS)	131	INCS= -I$(INC) $(EXTRA_INCS)
175	DEFS= $(NUMBER) $(EXTRA_DEFS)	132	DEFS= $(EXTRA_DEFS)
176		133
177	CFLAGS= $(MYCFLAGS) $(WARN) $(INCS) $(DEFS)	134	CFLAGS= $(MYCFLAGS) $(WARN) $(INCS) $(DEFS)
178		135

configure+0−9

@@ -1,9 +0,0 @@
1	#!/bin/sh
2
3	# Lua does not use GNU autoconf; just edit ./config if needed to suit your
4	# platform and then run make.
5
6	# This shows the parameters currently set in ./config:
7	make echo
8
9	# If you want config as a Lua program, run "make lecho".

etc/Makefile+8−11

 include $(LUA)/config
-LIBLUA=$(LIB)/liblua.a
+ALL= min noparser luab 1
-ALL= bin2c min noparser luab
 all:
 	@echo 'choose a target:' $(ALL)
-bin2c:	bin2c.c
-	$(CC) $(CFLAGS) -o $@ $@.c
 min:	min.c $(LIBLUA)
-	$(CC) $(CFLAGS) -o $@ $@.c -L$(LIB) -llua
+	$(CC) $(CFLAGS) -o $@ $@.c -L$(LIB) -llua -llualib
 noparser: noparser.c
 	$(CC) $(CFLAGS) -I$(LUA)/src -o $@.o -c $@.c
-luab:	noparser $(LIBLUA)
+luab:	noparser
-	$(CC) -o $@ noparser.o $(LUA)/src/lua/lua.o -L$(LIB) -llua -llualib $(EXTRA_LIBS)
+	$(CC) -o $@ noparser.o $(LUA)/src/lua/lua.o -L$(LIB) -llua -llualib $(EXTRA_LIBS) $(DLLIB)
 	$(BIN)/luac $(LUA)/test/hello.lua
 	$@ luac.out
 	-$@ -e'a=1'
+1:
+	$(CC) $(CFLAGS) -I../src -I../src/lib -I../src/lua all.c $(EXTRA_LIBS) $(DLLIB)
+	./a.out $(LUA)/test/hello.lua
 flat:
 	cd ..; mkdir flat; mv include/*.h src/*.[ch] src/*/*.[ch] flat
-$(LIBLUA):
-	cd ../src; $(MAKE)
 clean:
 	rm -f $(ALL) a.out core *.o luac.out

etc/RCS+0−1

@@ -1 +0,0 @@
1	../RCS

etc/README+4−0

 This directory contains some useful files and code.
 Unlike the code in ../src, everything here is in the public domain.
+all.c
+	Full Lua interpreter in a single file.
+	Do "make 1".
 lua.ico
 	A Lua icon for Windows (and web sites, as favicon.ico).
 	Drawn by hand by Markus Gritsch <gritsch@iue.tuwien.ac.at>.

etc/all.c+41−0

@@ -0,0 +1,41 @@
	1	/*
	2	* all.c -- Lua core, libraries and interpreter in a single file
	3	*/
	4
	5	#define LUA_CORE
	6	#define LUA_LIB
	7	#define lua_c
	8
	9	#include "lapi.c"
	10	#include "lcode.c"
	11	#include "ldebug.c"
	12	#include "ldo.c"
	13	#include "ldump.c"
	14	#include "lfunc.c"
	15	#include "lgc.c"
	16	#include "llex.c"
	17	#include "lmem.c"
	18	#include "lobject.c"
	19	#include "lopcodes.c"
	20	#include "lparser.c"
	21	#include "lstate.c"
	22	#include "lstring.c"
	23	#include "ltable.c"
	24	#include "ltm.c"
	25	#include "lundump.c"
	26	#include "lvm.c"
	27	#include "lzio.c"
	28
	29	#include "lauxlib.c"
	30	#include "lbaselib.c"
	31	#include "ldblib.c"
	32	#include "liolib.c"
	33	#include "linit.c"
	34	#include "lmathlib.c"
	35	#include "loadlib.c"
	36	#define pushresult pushresult2
	37	#include "loslib.c"
	38	#include "lstrlib.c"
	39	#include "ltablib.c"
	40
	41	#include "lua.c"

etc/min.c+28−18

 /*
 * min.c -- a minimal Lua interpreter
-* only dynamic loading is enabled -- all libraries must be dynamically loaded
+* loads stdin only with minimal error handling.
-* no interaction, only batch execution
+* no interaction, and no standard library, only a "print" function.
 */
 #include <stdio.h>
 #include "lua.h"
-#include "lualib.h"
 #include "lauxlib.h"
-static int run(lua_State *L)
+static int print(lua_State *L)
 {
- char **argv=lua_touserdata(L,1);
+ int n=lua_gettop(L);
- lua_register(L,"error",lua_error);
+ int i;
- luaopen_loadlib(L);
+ for (i=1; i<=n; i++)
- while (*++argv)
  {
-  if (luaL_loadfile(L,*argv)) lua_error(L); else lua_call(L,0,0);
+  if (i>1) printf("\t");
+  if (lua_isstring(L,i))
+   printf("%s",lua_tostring(L,i));
+  else if (lua_isnil(L,i))
+   printf("%s","nil");
+  else if (lua_isboolean(L,i))
+   printf("%s",lua_toboolean(L,i) ? "true" : "false");
+  else
+   printf("%s:%p",lua_typename(L,lua_type(L,i)),lua_topointer(L,i));
  }
+ printf("\n");
  return 0;
 }
-#define report(s) fprintf(stderr,"%s\n",s)
+static const char *getF(lua_State *L, void *ud, size_t *size)
+{
+ FILE *f=(FILE *)ud;
+ static char buff[512];
+ if (feof(f)) return NULL;
+ *size=fread(buff,1,sizeof(buff),f);
+ return (*size>0) ? buff : NULL;
+}
-int main(int argc, char *argv[])
+int main(void)
 {
  lua_State *L=lua_open();
- if (L==NULL)
+ lua_register(L,"print",print);
- {
+ if (lua_load(L,getF,stdin,"=stdin") || lua_pcall(L,0,0,0))
-  report("not enough memory for state");
+  fprintf(stderr,"%s\n",lua_tostring(L,-1));
-  return 1;
- }
- if (lua_cpcall(L,run,argv)) report(lua_tostring(L,-1));
- lua_close(L);
  return 0;
 }

etc/noparser.c+3−0

 * load the parsing modules. To try it, do "make luab".
 */
+#define LUA_CORE
 #include "llex.h"
 #include "lparser.h"
 #include "lzio.h"
 /*
 * If you also want to avoid the dump module, ldump.o, enable the code below.
 */
+#define NODUMP
 #ifdef NODUMP
 #include "lundump.h"

include/Makefile+1−1

@@ -4,7 +4,7 @@ LUA= .. · 3 unmodified lines
4		4
5	include $(LUA)/config	5	include $(LUA)/config
6		6
7	SRCS= lua.h lualib.h lauxlib.h	7	SRCS= lua.h lualib.h lauxlib.h luaconf.h
8		8
9	all:	9	all:
10		10

include/RCS+0−1

@@ -1 +0,0 @@
1	../RCS

include/lauxlib.h+17−16

 /*
-** $Id: lauxlib.h,v 1.63 2004/03/13 13:32:09 roberto Exp $
+** $Id: lauxlib.h,v 1.70 2004/07/09 18:23:17 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 #include "lua.h"
-#ifndef LUALIB_API
+/* extra error code for `luaL_load' */
-#define LUALIB_API	LUA_API
+#define LUA_ERRFILE     (LUA_ERRERR+1)
-#endif
 typedef struct luaL_reg {
 LUALIB_API int luaL_findstring (const char *st, const char *const lst[]);
+LUALIB_API const char *luaL_searchpath (lua_State *L, const char *name,
+                                                      const char *path);
 LUALIB_API int luaL_ref (lua_State *L, int t);
 LUALIB_API void luaL_unref (lua_State *L, int t, int ref);
 #define luaL_checklong(L,n)	((long)luaL_checkinteger(L, n))
 #define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, n,d))
+#define luaL_typename(L,i)	lua_typename(L,lua_type(L,(i)))
 /*
 ** {======================================================
 */
-#ifndef LUAL_BUFFERSIZE
-#define LUAL_BUFFERSIZE	  BUFSIZ
-#endif
 typedef struct luaL_Buffer {
   char *p;			/* current position in buffer */
 /* }====================================================== */
+/* compatibility with ref system */
-/*
+/* pre-defined references */
-** Compatibility macros and functions
+#define LUA_NOREF       (-2)
-*/
+#define LUA_REFNIL      (-1)
+#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
+#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
-LUALIB_API int   lua_dofile (lua_State *L, const char *filename);
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, ref)
-LUALIB_API int   lua_dostring (lua_State *L, const char *str);
-LUALIB_API int   lua_dobuffer (lua_State *L, const char *buff, size_t sz,
-                               const char *n);
 #endif

include/lua.h+13−56

 /*
-** $Id: lua.h,v 1.187 2004/03/09 17:34:35 roberto Exp $
+** $Id: lua.h,v 1.192 2004/06/04 15:30:53 roberto Exp $
 ** Lua - An Extensible Extension Language
 ** Tecgraf: Computer Graphics Technology Group, PUC-Rio, Brazil
 ** http://www.lua.org	mailto:info@lua.org
 #include <stddef.h>
-#define LUA_VERSION	"Lua 5.1 (work)"
+#include "luaconf.h"
+#define LUA_VERSION	"Lua 5.1 (work1)"
 #define LUA_COPYRIGHT	"Copyright (C) 1994-2004 Tecgraf, PUC-Rio"
 #define LUA_AUTHORS 	"R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
 #define lua_upvalueindex(i)	(LUA_GLOBALSINDEX-(i))
-/* error codes for `lua_load' and `lua_pcall' */
+/* error codes for `lua_pcall' */
 #define LUA_ERRRUN	1
-#define LUA_ERRFILE	2
+#define LUA_ERRSYNTAX	2
-#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	3
-#define LUA_ERRMEM	4
+#define LUA_ERRERR	4
-#define LUA_ERRERR	5
 typedef struct lua_State lua_State;
 /* type of numbers in Lua */
-#ifndef LUA_NUMBER
-typedef double lua_Number;
-#else
 typedef LUA_NUMBER lua_Number;
-#endif
 /* type for integer functions */
-#ifndef LUA_INTEGER
-typedef long lua_Integer;
-#else
 typedef LUA_INTEGER lua_Integer;
-#endif
-/* mark for all API functions */
-#ifndef LUA_API
-#define LUA_API		extern
-#endif
 /*
 ** state manipulation
 LUA_API lua_Integer     lua_tointeger (lua_State *L, int idx);
 LUA_API int             lua_toboolean (lua_State *L, int idx);
 LUA_API const char     *lua_tostring (lua_State *L, int idx);
-LUA_API size_t          lua_strlen (lua_State *L, int idx);
+LUA_API size_t          lua_objsize (lua_State *L, int idx);
 LUA_API lua_CFunction   lua_tocfunction (lua_State *L, int idx);
 LUA_API void	       *lua_touserdata (lua_State *L, int idx);
 LUA_API lua_State      *lua_tothread (lua_State *L, int idx);
 #define LUA_GCRESTART	1
 #define LUA_GCCOLLECT	2
 #define LUA_GCCOUNT	3
+#define LUA_GCSTEP	4
 LUA_API int lua_gc (lua_State *L, int what, int data);
 ** ===============================================================
 */
-#define lua_boxpointer(L,u) \
-	(*(void **)(lua_newuserdata(L, sizeof(void *))) = (u))
-#define lua_unboxpointer(L,i)	(*(void **)(lua_touserdata(L, i)))
 #define lua_pop(L,n)		lua_settop(L, -(n)-1)
 #define lua_newtable(L)		lua_createtable(L, 0, 0)
 #define lua_pushcfunction(L,f)	lua_pushcclosure(L, f, 0)
+#define lua_strlen(L,i)		lua_objsize(L,i)
 #define lua_isfunction(L,n)	(lua_type(L,n) == LUA_TFUNCTION)
 #define lua_istable(L,n)	(lua_type(L,n) == LUA_TTABLE)
 #define lua_islightuserdata(L,n)	(lua_type(L,n) == LUA_TLIGHTUSERDATA)
 #define lua_getgccount(L)	lua_gc(L, LUA_GCCOUNT, 0)
-/* compatibility with ref system */
-/* pre-defined references */
-#define LUA_NOREF	(-2)
-#define LUA_REFNIL	(-1)
-#define lua_ref(L,lock)	((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
-      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
-#define lua_unref(L,ref)	luaL_unref(L, LUA_REGISTRYINDEX, (ref))
-#define lua_getref(L,ref)	lua_rawgeti(L, LUA_REGISTRYINDEX, ref)
-/*
-** {======================================================================
-** useful definitions for Lua kernel and libraries
-** =======================================================================
-*/
-/* formats for Lua numbers */
-#ifndef LUA_NUMBER_SCAN
-#define LUA_NUMBER_SCAN		"%lf"
-#endif
-#ifndef LUA_NUMBER_FMT
-#define LUA_NUMBER_FMT		"%.14g"
-#endif
-/* }====================================================================== */
 /*
 ** {======================================================================
 ** Debug API

include/luaconf.h+312−0

@@ -0,0 +1,312 @@
	1	/*
	2	** $Id: luaconf.h,v 1.11 2004/08/30 18:35:14 roberto Exp $
	3	** Configuration file for Lua
	4	** See Copyright Notice in lua.h
	5	*/
	6
	7
	8	#ifndef lconfig_h
	9	#define lconfig_h
	10
	11	#include <limits.h>
	12	#include <stddef.h>
	13
	14
	15	/*
	16	** {======================================================
	17	** Index (search for keyword to find corresponding entry)
	18	** =======================================================
	19	*/
	20
	21
	22	/* }====================================================== */
	23
	24
	25
	26
	27	/*
	28	** {======================================================
	29	** Generic configuration
	30	** =======================================================
	31	*/
	32
	33	/* default path */
	34	#define LUA_PATH_DEFAULT "?;?.lua"
	35
	36
	37	/* type of numbers in Lua */
	38	#define LUA_NUMBER double
	39
	40	/* formats for Lua numbers */
	41	#define LUA_NUMBER_SCAN "%lf"
	42	#define LUA_NUMBER_FMT "%.14g"
	43
	44
	45	/* type for integer functions */
	46	#define LUA_INTEGER long
	47
	48
	49	/* mark for all API functions */
	50	#define LUA_API extern
	51
	52	/* mark for auxlib functions */
	53	#define LUALIB_API extern
	54
	55	/* buffer size used by lauxlib buffer system */
	56	#define LUAL_BUFFERSIZE BUFSIZ
	57
	58
	59	/* first index for arrays */
	60	#define LUA_FIRSTINDEX 1
	61
	62	/* assertions in Lua (mainly for internal debugging) */
	63	#define lua_assert(c) /* empty */
	64
	65	/* }====================================================== */
	66
	67
	68
	69	/*
	70	** {======================================================
	71	** Stand-alone configuration
	72	** =======================================================
	73	*/
	74
	75	#ifdef lua_c
	76
	77	/* definition of `isatty' */
	78	#ifdef _POSIX_C_SOURCE
	79	#include <unistd.h>
	80	#define stdin_is_tty() isatty(0)
	81	#else
	82	#define stdin_is_tty() 1 /* assume stdin is a tty */
	83	#endif
	84
	85
	86	#define PROMPT "> "
	87	#define PROMPT2 ">> "
	88	#define PROGNAME "lua"
	89
	90
	91	/*
	92	** this macro allows you to open other libraries when starting the
	93	** stand-alone interpreter
	94	*/
	95	#define lua_userinit(L) luaopen_stdlibs(L)
	96	/*
	97	** #define lua_userinit(L) { int luaopen_mylibs(lua_State *L); \
	98	** luaopen_stdlibs(L); luaopen_mylibs(L); }
	99	*/
	100
	101
	102
	103	/*
	104	** this macro can be used by some `history' system to save lines
	105	** read in manual input
	106	*/
	107	#define lua_saveline(L,line) /* empty */
	108
	109
	110
	111	#endif
	112
	113	/* }====================================================== */
	114
	115
	116
	117	/*
	118	** {======================================================
	119	** Core configuration
	120	** =======================================================
	121	*/
	122
	123	#ifdef LUA_CORE
	124
	125	/* LUA-C API assertions */
	126	#define api_check(L, o) /* empty */
	127
	128
	129	/* an unsigned integer with at least 32 bits */
	130	#define LUA_UINT32 unsigned long
	131
	132	/* a signed integer with at least 32 bits */
	133	#define LUA_INT32 long
	134	#define LUA_MAXINT32 LONG_MAX
	135
	136
	137	/* maximum depth for calls (unsigned short) */
	138	#define LUA_MAXCALLS 4096
	139
	140	/*
	141	** maximum depth for C calls (unsigned short): Not too big, or may
	142	** overflow the C stack...
	143	*/
	144	#define LUA_MAXCCALLS 200
	145
	146
	147	/* maximum size for the virtual stack of a C function */
	148	#define MAXCSTACK 2048
	149
	150
	151	/*
	152	** maximum number of syntactical nested non-terminals: Not too big,
	153	** or may overflow the C stack...
	154	*/
	155	#define LUA_MAXPARSERLEVEL 200
	156
	157
	158	/* maximum number of variables declared in a function */
	159	#define MAXVARS 200 /* <MAXSTACK */
	160
	161
	162	/* maximum number of upvalues per function */
	163	#define MAXUPVALUES 32 /* <MAXSTACK */
	164
	165
	166	/* maximum size of expressions for optimizing `while' code */
	167	#define MAXEXPWHILE 100
	168
	169
	170	/* function to convert a lua_Number to int (with any rounding method) */
	171	#if defined(__GNUC__) && defined(__i386)
	172	#define lua_number2int(i,d) __asm__ ("fistpl %0":"=m"(i):"t"(d):"st")
	173	#elif 0
	174	/* on machines compliant with C99, you can try `lrint' */
	175	#include <math.h>
	176	#define lua_number2int(i,d) ((i)=lrint(d))
	177	#else
	178	#define lua_number2int(i,d) ((i)=(int)(d))
	179	#endif
	180
	181	/* function to convert a lua_Number to lua_Integer (with any rounding method) */
	182	#define lua_number2integer(i,n) lua_number2int(i,n)
	183
	184
	185	/* function to convert a lua_Number to a string */
	186	#include <stdio.h>
	187	#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
	188
	189	/* function to convert a string to a lua_Number */
	190	#define lua_str2number(s,p) strtod((s), (p))
	191
	192
	193
	194	/* result of a `usual argument conversion' over lua_Number */
	195	#define LUA_UACNUMBER double
	196
	197
	198	/* number of bits in an `int' */
	199	/* avoid overflows in comparison */
	200	#if INT_MAX-20 < 32760
	201	#define LUA_BITSINT 16
	202	#elif INT_MAX > 2147483640L
	203	/* machine has at least 32 bits */
	204	#define LUA_BITSINT 32
	205	#else
	206	#error "you must define LUA_BITSINT with number of bits in an integer"
	207	#endif
	208
	209
	210	/* type to ensure maximum alignment */
	211	#define LUSER_ALIGNMENT_T union { double u; void *s; long l; }
	212
	213
	214	/* exception handling */
	215	#ifndef __cplusplus
	216	/* default handling with long jumps */
	217	#include <setjmp.h>
	218	#define L_THROW(c) longjmp((c)->b, 1)
	219	#define L_TRY(c,a) if (setjmp((c)->b) == 0) { a }
	220	#define l_jmpbuf jmp_buf
	221
	222	#else
	223	/* C++ exceptions */
	224	#define L_THROW(c) throw(c)
	225	#define L_TRY(c,a) try { a } catch(...) \
	226	{ if ((c)->status == 0) (c)->status = -1; }
	227	#define l_jmpbuf int /* dummy variable */
	228	#endif
	229
	230
	231
	232	/*
	233	** macros for thread synchronization inside Lua core machine:
	234	** all accesses to the global state and to global objects are synchronized.
	235	** Because threads can read the stack of other threads
	236	** (when running garbage collection),
	237	** a thread must also synchronize any write-access to its own stack.
	238	** Unsynchronized accesses are allowed only when reading its own stack,
	239	** or when reading immutable fields from global objects
	240	** (such as string values and udata values).
	241	*/
	242	#define lua_lock(L) ((void) 0)
	243	#define lua_unlock(L) ((void) 0)
	244
	245	/*
	246	** this macro allows a thread switch in appropriate places in the Lua
	247	** core
	248	*/
	249	#define lua_threadyield(L) {lua_unlock(L); lua_lock(L);}
	250
	251
	252
	253	/* allows user-specific initialization on new threads */
	254	#define lua_userstateopen(l) /* empty */
	255
	256
	257	#endif
	258
	259	/* }====================================================== */
	260
	261
	262
	263	/*
	264	** {======================================================
	265	** Library configuration
	266	** =======================================================
	267	*/
	268
	269	#ifdef LUA_LIB
	270
	271
	272
	273	/* `assert' options */
	274
	275	/* environment variable that holds the search path for packages */
	276	#define LUA_PATH "LUA_PATH"
	277
	278	/* separator of templates in a path */
	279	#define LUA_PATH_SEP ';'
	280
	281	/* wild char in each template */
	282	#define LUA_PATH_MARK "?"
	283
	284
	285	/* maximum number of captures in pattern-matching */
	286	#define MAX_CAPTURES 32 /* arbitrary limit */
	287
	288
	289	/*
	290	** by default, gcc does not get `tmpname'
	291	*/
	292	#ifdef __GNUC__
	293	#define USE_TMPNAME 0
	294	#else
	295	#define USE_TMPNAME 1
	296	#endif
	297
	298
	299
	300	#endif
	301
	302	/* }====================================================== */
	303
	304
	305
	306
	307	/* Local configuration */
	308
	309	#undef USE_TMPNAME
	310	#define USE_TMPNAME 1
	311
	312	#endif

include/lualib.h+8−17

 /*
-** $Id: lualib.h,v 1.28 2003/03/18 12:24:26 roberto Exp $
+** $Id: lualib.h,v 1.32 2004/07/09 15:47:48 roberto Exp $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
 #include "lua.h"
-#ifndef LUALIB_API
+/* Key to file-handle type */
-#define LUALIB_API	LUA_API
+#define LUA_FILEHANDLE		"FILE*"
-#endif
 #define LUA_COLIBNAME	"coroutine"
 LUALIB_API int luaopen_table (lua_State *L);
 #define LUA_IOLIBNAME	"io"
-#define LUA_OSLIBNAME	"os"
 LUALIB_API int luaopen_io (lua_State *L);
+#define LUA_OSLIBNAME	"os"
+LUALIB_API int luaopen_os (lua_State *L);
 #define LUA_STRLIBNAME	"string"
 LUALIB_API int luaopen_string (lua_State *L);
 LUALIB_API int luaopen_loadlib (lua_State *L);
-/* to help testing the libraries */
+/* open all previous libraries */
-#ifndef lua_assert
+LUALIB_API int luaopen_stdlibs (lua_State *L);
-#define lua_assert(c)		/* empty */
-#endif
-/* compatibility code */
-#define lua_baselibopen	luaopen_base
-#define lua_tablibopen	luaopen_table
-#define lua_iolibopen	luaopen_io
-#define lua_strlibopen	luaopen_string
-#define lua_mathlibopen	luaopen_math
-#define lua_dblibopen	luaopen_debug
 #endif

src/RCS+0−1

@@ -1 +0,0 @@
1	../RCS

src/README+2−2

@@ -1,5 +1,5 @@
1	This is the Lua core.	1	This is the Lua core.
2		2
3	The standard Lua library are in lib/.	3	The standard Lua library are in lib/.
4	A sample interpreter is in lua/.	4	The standalone interpreter is in lua/.
5	A standalone compiler is in luac/.	5	The standalone compiler is in luac/.

src/lapi.c+55−33

 /*
-** $Id: lapi.c,v 2.5 2004/03/23 17:07:34 roberto Exp $
+** $Id: lapi.c,v 2.18 2004/08/30 13:44:44 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lapi_c
+#define LUA_CORE
 #include "lua.h"
 #include "lvm.h"
-/* function to convert a lua_Number to lua_Integer (with any rounding method) */
-#ifndef lua_number2integer
-#define lua_number2integer(i,n)     ((i)=(lua_Integer)(n))
-#endif
 const char lua_ident[] =
   "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
-#ifndef api_check
-#define api_check(L, o)		lua_assert(o)
-#endif
 #define api_checknelems(L, n)	api_check(L, (n) <= (L->top - L->base))
 #define api_checkvalidindex(L, i)	api_check(L, (i) != &luaO_nilobject)
 static TValue *luaA_index (lua_State *L, int idx) {
   if (idx > 0) {
     TValue *o = L->base + (idx - 1);
-    api_check(L, idx <= L->stack_last - L->base);
+    api_check(L, idx <= L->ci->top - L->base);
     if (o >= L->top) return cast(TValue *, &luaO_nilobject);
     else return o;
   }
 LUA_API int lua_checkstack (lua_State *L, int size) {
   int res;
   lua_lock(L);
-  if ((L->top - L->base + size) > LUA_MAXCSTACK)
+  if ((L->top - L->base + size) > MAXCSTACK)
     res = 0;  /* stack overflow */
   else {
     luaD_checkstack(L, size);
 }
-LUA_API size_t lua_strlen (lua_State *L, int idx) {
+LUA_API size_t lua_objsize (lua_State *L, int idx) {
   StkId o = luaA_index(L, idx);
   if (ttisstring(o))
     return tsvalue(o)->len;
+  else if (ttisuserdata(o))
+    return uvalue(o)->len;
   else {
     size_t l;
     lua_lock(L);  /* `luaV_tostring' may create a new string */
   lua_lock(L);
   t = luaA_index(L, idx);
   api_checkvalidindex(L, t);
-  luaV_gettable(L, t, L->top - 1, L->top - 1);
+  luaV_gettable(L, t, L->top - 1, L->top - 1, NULL);
   lua_unlock(L);
 }
   t = luaA_index(L, idx);
   api_checkvalidindex(L, t);
   setsvalue(L, &key, luaS_new(L, k));
-  luaV_gettable(L, t, &key, L->top);
+  luaV_gettable(L, t, &key, L->top, NULL);
   api_incr_top(L);
   lua_unlock(L);
 }
   api_checknelems(L, 2);
   t = luaA_index(L, idx);
   api_checkvalidindex(L, t);
-  luaV_settable(L, t, L->top - 2, L->top - 1);
+  luaV_settable(L, t, L->top - 2, L->top - 1, NULL);
   L->top -= 2;  /* pop index and value */
   lua_unlock(L);
 }
   t = luaA_index(L, idx);
   api_checkvalidindex(L, t);
   setsvalue(L, &key, luaS_new(L, k));
-  luaV_settable(L, t, &key, L->top - 1);
+  luaV_settable(L, t, &key, L->top - 1, NULL);
   L->top--;  /* pop value */
   lua_unlock(L);
 }
   t = luaA_index(L, idx);
   api_check(L, ttistable(t));
   setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
-  luaC_barrier(L, hvalue(t), L->top-1);
+  luaC_barriert(L, hvalue(t), L->top-1);
   L->top -= 2;
   lua_unlock(L);
 }
   o = luaA_index(L, idx);
   api_check(L, ttistable(o));
   setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
-  luaC_barrier(L, hvalue(o), L->top-1);
+  luaC_barriert(L, hvalue(o), L->top-1);
   L->top--;
   lua_unlock(L);
 }
   api_checknelems(L, 1);
   o = luaA_index(L, idx);
   api_checkvalidindex(L, o);
-  L->top--;
+  api_check(L, ttistable(L->top - 1));
-  api_check(L, ttistable(L->top));
   if (isLfunction(o)) {
     res = 1;
-    clvalue(o)->l.g = *(L->top);
+    clvalue(o)->l.g = *(L->top - 1);
+    luaC_objbarrier(L, clvalue(o), hvalue(L->top - 1));
   }
+  L->top--;
   lua_unlock(L);
   return res;
 }
 ** `load' and `call' functions (run Lua code)
 */
+#define adjustresults(L,nres) \
+    { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }
+#define checkresults(L,na,nr) \
+     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))
 LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
   StkId func;
   lua_lock(L);
   api_checknelems(L, nargs+1);
+  checkresults(L, nargs, nresults);
   func = L->top - (nargs+1);
   luaD_call(L, func, nresults);
+  adjustresults(L, nresults);
   lua_unlock(L);
 }
   int status;
   ptrdiff_t func;
   lua_lock(L);
+  api_checknelems(L, nargs+1);
+  checkresults(L, nargs, nresults);
   if (errfunc == 0)
     func = 0;
   else {
   c.func = L->top - (nargs+1);  /* function to be called */
   c.nresults = nresults;
   status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
+  adjustresults(L, nresults);
   lua_unlock(L);
   return status;
 }
 */
 LUA_API int lua_gc (lua_State *L, int what, int data) {
-  global_State *g = G(L);
+  int res = 0;
+  global_State *g;
+  lua_lock(L);
+  g = G(L);
   switch (what) {
     case LUA_GCSTOP: {
       g->GCthreshold = MAXLMEM;
-      return 0;
+      break;
     }
     case LUA_GCRESTART: {
-      g->GCthreshold = g->nblocks;
+      g->GCthreshold = g->totalbytes;
-      return 0;
+      break;
     }
     case LUA_GCCOLLECT: {
-      lua_lock(L);
       luaC_fullgc(L);
-      lua_unlock(L);
+      break;
-      return 0;
     }
     case LUA_GCCOUNT: {
       /* GC values are expressed in Kbytes: #bytes/2^10 */
-      return cast(int, g->nblocks >> 10);
+      res = cast(int, g->totalbytes >> 10);
+      break;
+    }
+    case LUA_GCSTEP: {
+      lu_mem a = (cast(lu_mem, data) << 10);
+      if (a <= g->totalbytes)
+        g->GCthreshold = g->totalbytes - a;
+      else
+        g->GCthreshold = 0;
+      luaC_step(L);
+      break;
     }
-    default: return -1;  /* invalid option */
+    default: res = -1;  /* invalid option */
   }
+  lua_unlock(L);
+  return res;
 }
   if (!ttisfunction(fi)) return NULL;
   f = clvalue(fi);
   if (f->c.isC) {
-    if (n > f->c.nupvalues) return NULL;
+    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
     *val = &f->c.upvalue[n-1];
     return "";
   }
   else {
     Proto *p = f->l.p;
-    if (n > p->sizeupvalues) return NULL;
+    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
     *val = f->l.upvals[n-1]->v;
     return getstr(p->upvalues[n-1]);
   }

src/lcode.c+28−13

 /*
-** $Id: lcode.c,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: lcode.c,v 2.6 2004/08/24 20:09:11 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 #include <stdlib.h>
 #define lcode_c
+#define LUA_CORE
 #include "lua.h"
 static void freereg (FuncState *fs, int reg) {
-  if (reg >= fs->nactvar && reg < MAXSTACK) {
+  if (!ISK(reg) && reg >= fs->nactvar) {
     fs->freereg--;
     lua_assert(reg == fs->freereg);
   }
                     MAXARG_Bx, "constant table overflow");
     while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
     setobj(L, &f->k[fs->nk], v);
-    luaC_barrier(L, f, v);
+    luaC_barriert(L, f, v);
     return fs->nk++;
   }
 }
 }
-void luaK_setcallreturns (FuncState *fs, expdesc *e, int nresults) {
+void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
   if (e->k == VCALL) {  /* expression is an open function call? */
     SETARG_C(getcode(fs, e), nresults+1);
-    if (nresults == 1) {  /* `regular' expression? */
+  }
-      e->k = VNONRELOC;
+  else if (e->k == VVARARG) {
-      e->info = GETARG_A(getcode(fs, e));
+    SETARG_B(getcode(fs, e), nresults+1);
-    }
+    SETARG_A(getcode(fs, e), fs->freereg);
+    luaK_reserveregs(fs, 1);
+  }
+}
+void luaK_setoneret (FuncState *fs, expdesc *e) {
+  if (e->k == VCALL) {  /* expression is an open function call? */
+    e->k = VNONRELOC;
+    e->info = GETARG_A(getcode(fs, e));
+  }
+  else if (e->k == VVARARG) {
+    SETARG_B(getcode(fs, e), 2);
+    e->k = VRELOCABLE;  /* can relocate its simple result */
   }
 }
       e->k = VRELOCABLE;
       break;
     }
+    case VVARARG:
     case VCALL: {
-      luaK_setcallreturns(fs, e, 1);
+      luaK_setoneret(fs, e);
       break;
     }
     default: break;  /* there is one value available (somewhere) */
   luaK_exp2val(fs, e);
   switch (e->k) {
     case VNIL: {
-      if (fs->nk + MAXSTACK <= MAXARG_C) {  /* constant fit in argC? */
+      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
         e->info = nil_constant(fs);
         e->k = VK;
-        return e->info + MAXSTACK;
+        return RKASK(e->info);
       }
       else break;
     }
     case VK: {
-      if (e->info + MAXSTACK <= MAXARG_C)  /* constant fit in argC? */
+      if (e->info <= MAXINDEXRK)  /* constant fit in argC? */
-        return e->info + MAXSTACK;
+        return RKASK(e->info);
       else break;
     }
     default: break;

src/lcode.h+5−2

 /*
-** $Id: lcode.h,v 1.38 2002/12/11 12:34:22 roberto Exp $
+** $Id: lcode.h,v 1.39 2004/05/31 18:51:50 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
+#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
 int luaK_code (FuncState *fs, Instruction i, int line);
 int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
 int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
 void luaK_goiftrue (FuncState *fs, expdesc *e);
 void luaK_goiffalse (FuncState *fs, expdesc *e);
 void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
-void luaK_setcallreturns (FuncState *fs, expdesc *var, int nresults);
+void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
+void luaK_setoneret (FuncState *fs, expdesc *e);
 int luaK_jump (FuncState *fs);
 void luaK_patchlist (FuncState *fs, int list, int target);
 void luaK_patchtohere (FuncState *fs, int list);

src/ldebug.c+24−15

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldebug.c,v 2.3 2004/03/23 13:10:16 roberto Exp $	2	** $Id: ldebug.c,v 2.8 2004/09/01 13:47:31 roberto Exp $
3	** Debug Interface	3	** Debug Interface
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -11,6 +11,7 @@ · 5 unmodified lines
11		11
12		12
13	#define ldebug_c	13	#define ldebug_c
		14	#define LUA_CORE
14		15
15	#include "lua.h"	16	#include "lua.h"
16		17
@@ -34,7 +35,7 @@ static const char getfuncname (CallInfo ci, const char **name); · 17 unmodified lines
34		35
35	static int currentpc (CallInfo *ci) {	36	static int currentpc (CallInfo *ci) {
36	if (!isLua(ci)) return -1; /* function is not a Lua function? */	37	if (!isLua(ci)) return -1; /* function is not a Lua function? */
37	return pcRel(ci->u.l.savedpc, ci_func(ci)->l.p);	38	return pcRel(ci->savedpc, ci_func(ci)->l.p);
38	}	39	}
39		40
40		41
@@ -85,7 +86,7 @@ LUA_API int lua_getstack (lua_State L, int level, lua_Debug ar) { · 44 unmodified lines
85	for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {	86	for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
86	level--;	87	level--;
87	if (f_isLua(ci)) /* Lua function? */	88	if (f_isLua(ci)) /* Lua function? */
88	level -= ci->u.l.tailcalls; /* skip lost tail calls */	89	level -= ci->tailcalls; /* skip lost tail calls */
89	}	90	}
90	if (level > 0 \|\| ci == L->base_ci) status = 0; /* there is no such level */	91	if (level > 0 \|\| ci == L->base_ci) status = 0; /* there is no such level */
91	else if (level < 0) { /* level is of a lost tail call */	92	else if (level < 0) { /* level is of a lost tail call */
@@ -220,8 +221,8 @@ LUA_API int lua_getinfo (lua_State L, const char what, lua_Debug *ar) { · 128 unmodified lines
220	}	221	}
221	else if (ar->i_ci != 0) { /* no tail call? */	222	else if (ar->i_ci != 0) { /* no tail call? */
222	CallInfo *ci = L->base_ci + ar->i_ci;	223	CallInfo *ci = L->base_ci + ar->i_ci;
223	lua_assert(ttisfunction(ci->base - 1));	224	lua_assert(ttisfunction(ci->func));
224	status = auxgetinfo(L, what, ar, ci->base - 1, ci);	225	status = auxgetinfo(L, what, ar, ci->func, ci);
225	}	226	}
226	else	227	else
227	info_tailcall(L, ar);	228	info_tailcall(L, ar);
@@ -254,8 +255,9 @@ static int precheck (const Proto *pt) { · 26 unmodified lines
254	}	255	}
255		256
256		257
257	static int checkopenop (const Proto *pt, int pc) {	258	#define checkopenop(pt,pc) luaG_checkopenop((pt)->code[(pc)+1])
258	Instruction i = pt->code[pc+1];	259
		260	int luaG_checkopenop (Instruction i) {
259	switch (GET_OPCODE(i)) {	261	switch (GET_OPCODE(i)) {
260	case OP_CALL:	262	case OP_CALL:
261	case OP_TAILCALL:	263	case OP_TAILCALL:
@@ -274,8 +276,8 @@ static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) { · 12 unmodified lines
274	case OpArgN: check(r == 0); break;	276	case OpArgN: check(r == 0); break;
275	case OpArgU: break;	277	case OpArgU: break;
276	case OpArgR: checkreg(pt, r); break;	278	case OpArgR: checkreg(pt, r); break;
277	case OpArgK:	279	case OpArgK:
278	check(r < pt->maxstacksize \|\| (r >= MAXSTACK && r-MAXSTACK < pt->sizek));	280	check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
279	break;	281	break;
280	}	282	}
281	return 1;	283	return 1;
@@ -355,7 +357,7 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) { · 73 unmodified lines
355	}	357	}
356	case OP_TFORLOOP: {	358	case OP_TFORLOOP: {
357	checkreg(pt, a+5); /* space for control variables */	359	checkreg(pt, a+5); /* space for control variables */
358	if (reg >= a) last = pc; /* affect all registers above base */	360	if (reg >= a+3) last = pc; /* affect all regs above its call base */
359	break;	361	break;
360	}	362	}
361	case OP_TFORPREP:	363	case OP_TFORPREP:
@@ -404,6 +406,13 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) { · 42 unmodified lines
404	}	406	}
405	break;	407	break;
406	}	408	}
		409	case OP_VARARG: {
		410	check(pt->is_vararg & NEWSTYLEVARARG);
		411	b--;
		412	if (b == LUA_MULTRET) check(checkopenop(pt, pc));
		413	checkreg(pt, a+b-1);
		414	break;
		415	}
407	default: break;	416	default: break;
408	}	417	}
409	}	418	}
@@ -423,9 +432,8 @@ int luaG_checkcode (const Proto *pt) { · 13 unmodified lines
423		432
424		433
425	static const char kname (Proto p, int c) {	434	static const char kname (Proto p, int c) {
426	c = c - MAXSTACK;	435	if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))
427	if (c >= 0 && ttisstring(&p->k[c]))	436	return svalue(&p->k[INDEXK(c)]);
428	return svalue(&p->k[c]);
429	else	437	else
430	return "?";	438	return "?";
431	}	439	}
@@ -479,11 +487,12 @@ static const char getobjname (CallInfo ci, int stackpos, const char **name) { · 47 unmodified lines
479		487
480	static const char getfuncname (CallInfo ci, const char **name) {	488	static const char getfuncname (CallInfo ci, const char **name) {
481	Instruction i;	489	Instruction i;
482	if ((isLua(ci) && ci->u.l.tailcalls > 0) \|\| !isLua(ci - 1))	490	if ((isLua(ci) && ci->tailcalls > 0) \|\| !isLua(ci - 1))
483	return NULL; /* calling function is not Lua (or is unknown) */	491	return NULL; /* calling function is not Lua (or is unknown) */
484	ci--; /* calling function */	492	ci--; /* calling function */
485	i = ci_func(ci)->l.p->code[currentpc(ci)];	493	i = ci_func(ci)->l.p->code[currentpc(ci)];
486	if (GET_OPCODE(i) == OP_CALL \|\| GET_OPCODE(i) == OP_TAILCALL)	494	if (GET_OPCODE(i) == OP_CALL \|\| GET_OPCODE(i) == OP_TAILCALL \|\|
		495	GET_OPCODE(i) == OP_TFORLOOP)
487	return getobjname(ci, GETARG_A(i), name);	496	return getobjname(ci, GETARG_A(i), name);
488	else	497	else
489	return NULL; /* no useful name can be found */	498	return NULL; /* no useful name can be found */

src/ldebug.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldebug.h,v 2.1 2003/12/10 12:13:36 roberto Exp $	2	** $Id: ldebug.h,v 2.2 2004/06/02 19:07:55 roberto Exp $
3	** Auxiliary functions from Debug Interface module	3	** Auxiliary functions from Debug Interface module
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -25,6 +25,6 @@ int luaG_ordererror (lua_State L, const TValue p1, const TValue *p2); · 19 unmodified lines
25	void luaG_runerror (lua_State L, const char fmt, ...);	25	void luaG_runerror (lua_State L, const char fmt, ...);
26	void luaG_errormsg (lua_State *L);	26	void luaG_errormsg (lua_State *L);
27	int luaG_checkcode (const Proto *pt);	27	int luaG_checkcode (const Proto *pt);
28		28	int luaG_checkopenop (Instruction i);
29		29
30	#endif	30	#endif

src/ldo.c+68−56

 /*
-** $Id: ldo.c,v 2.2 2004/03/23 17:02:58 roberto Exp $
+** $Id: ldo.c,v 2.7 2004/06/02 19:07:55 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
-#include <setjmp.h>
 #include <stdlib.h>
 #include <string.h>
 #define ldo_c
+#define LUA_CORE
 #include "lua.h"
 /*
 ** {======================================================
-** Error-recovery functions (based on long jumps)
+** Error-recovery functions
 ** =======================================================
 */
-#ifndef LUA_USEEXCEPTIONS
-#define L_THROW(c)	longjmp((c)->b, 1)
-#define L_TRY(c,a)	if (setjmp((c)->b) == 0) { a }
-#else
-#define L_THROW(c)	throw(c)
-#define L_TRY(c,a)	try { a } catch(...) \
-				{ if ((c)->status == 0) (c)->status = -1; }
-#endif
 /* chain list of long jump buffers */
 struct lua_longjmp {
   struct lua_longjmp *previous;
-  jmp_buf b;
+  l_jmpbuf b;
   volatile int status;  /* error code */
 };
   for (ci = L->base_ci; ci <= L->ci; ci++) {
     ci->top = (ci->top - oldstack) + L->stack;
     ci->base = (ci->base - oldstack) + L->stack;
+    ci->func = (ci->func - oldstack) + L->stack;
   }
   L->base = L->ci->base;
 }
 }
-static void adjust_varargs (lua_State *L, int nfixargs, StkId base) {
+static StkId adjust_varargs (lua_State *L, int nfixargs, int actual,
+                             int style) {
   int i;
-  Table *htab;
+  Table *htab = NULL;
-  int actual = L->top - base;  /* actual number of arguments */
+  StkId base, fixed;
   if (actual < nfixargs) {
-    luaD_checkstack(L, nfixargs - actual);
     for (; actual < nfixargs; ++actual)
       setnilvalue(L->top++);
   }
-  actual -= nfixargs;  /* number of extra arguments */
+  if (style != NEWSTYLEVARARG) {  /* compatibility with old-style vararg */
-  htab = luaH_new(L, actual, 1);  /* create `arg' table */
+    int nvar = actual - nfixargs;  /* number of extra arguments */
-  for (i=0; i<actual; i++)  /* put extra arguments into `arg' table */
+    htab = luaH_new(L, nvar, 1);  /* create `arg' table */
-    setobj2n(L, luaH_setnum(L, htab, i+1), L->top - actual + i);
+    for (i=0; i<nvar; i++)  /* put extra arguments into `arg' table */
-  /* store counter in field `n' */
+      setobj2n(L, luaH_setnum(L, htab, i+LUA_FIRSTINDEX), L->top - nvar + i);
-  setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")),
+    /* store counter in field `n' */
-                                 cast(lua_Number, actual));
+    setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")),
-  L->top -= actual;  /* remove extra elements from the stack */
+                                   cast(lua_Number, nvar));
-  sethvalue(L, L->top, htab);
+  }
-  lua_assert(iswhite(obj2gco(htab)));
+  /* move fixed parameters to final position */
-  incr_top(L);
+  fixed = L->top - actual;  /* first fixed argument */
+  base = L->top;  /* final position of first argument */
+  for (i=0; i<nfixargs; i++) {
+    setobjs2s(L, L->top++, fixed+i);
+    setnilvalue(fixed+i);
+  }
+  /* add `arg' parameter */
+  if (htab) {
+    sethvalue(L, L->top++, htab);
+    lua_assert(iswhite(obj2gco(htab)));
+  }
+  return base;
 }
 }
-StkId luaD_precall (lua_State *L, StkId func) {
+int luaD_precall (lua_State *L, StkId func, int nresults) {
   LClosure *cl;
-  ptrdiff_t funcr = savestack(L, func);
+  ptrdiff_t funcr;
   if (!ttisfunction(func)) /* `func' is not a function? */
     func = tryfuncTM(L, func);  /* check the `function' tag method */
+  funcr = savestack(L, func);
   if (L->ci + 1 == L->end_ci) luaD_growCI(L);
   else condhardstacktests(luaD_reallocCI(L, L->size_ci));
   cl = &clvalue(func)->l;
   if (!cl->isC) {  /* Lua function? prepare its call */
     CallInfo *ci;
-    StkId st;
+    StkId st, base;
     Proto *p = cl->p;
-    if (p->is_vararg)  /* varargs? */
-      adjust_varargs(L, p->numparams, func+1);
     luaD_checkstack(L, p->maxstacksize);
+    func = restorestack(L, funcr);
+    if (p->is_vararg) {  /* varargs? */
+      int nargs = L->top - func - 1;
+      base = adjust_varargs(L, p->numparams, nargs, p->is_vararg);
+    }
+    else
+      base = func + 1;
     ci = ++L->ci;  /* now `enter' new function */
-    L->base = L->ci->base = restorestack(L, funcr) + 1;
+    ci->func = func;
+    L->base = ci->base = base;
     ci->top = L->base + p->maxstacksize;
-    ci->u.l.savedpc = p->code;  /* starting point */
+    ci->savedpc = p->code;  /* starting point */
-    ci->u.l.tailcalls = 0;
+    ci->tailcalls = 0;
+    ci->nresults = nresults;
     for (st = L->top; st < ci->top; st++)
       setnilvalue(st);
     L->top = ci->top;
-    return NULL;
+    return PCRLUA;
   }
   else {  /* if is a C function, call it */
     CallInfo *ci;
     int n;
     luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
     ci = ++L->ci;  /* now `enter' new function */
-    L->base = L->ci->base = restorestack(L, funcr) + 1;
+    ci->func = restorestack(L, funcr);
+    L->base = ci->base = ci->func + 1;
     ci->top = L->top + LUA_MINSTACK;
     if (L->hookmask & LUA_MASKCALL)
       luaD_callhook(L, LUA_HOOKCALL, -1);
     lua_unlock(L);
     n = (*curr_func(L)->c.f)(L);  /* do the actual call */
     lua_lock(L);
-    return L->top - n;
+    if (n >= 0) {  /* no yielding? */
+      luaD_poscall(L, nresults, L->top - n);
+      return PCRC;
+    }
+    else {
+      ci->nresults = nresults;
+      return PCRYIELD;
+    }
   }
 }
   ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */
   luaD_callhook(L, LUA_HOOKRET, -1);
   if (f_isLua(L->ci)) {  /* Lua function? */
-    while (L->ci->u.l.tailcalls--)  /* call hook for eventual tail calls */
+    while (L->ci->tailcalls--)  /* call hook for eventual tail calls */
       luaD_callhook(L, LUA_HOOKTAILRET, -1);
   }
   return restorestack(L, fr);
   StkId res;
   if (L->hookmask & LUA_MASKRET)
     firstResult = callrethooks(L, firstResult);
-  res = L->base - 1;  /* res == final position of 1st result */
+  res = L->ci->func;  /* res == final position of 1st result */
   L->ci--;
   L->base = L->ci->base;  /* restore base */
   /* move results to correct place */
 ** function position.
 */
 void luaD_call (lua_State *L, StkId func, int nResults) {
-  StkId firstResult;
   if (++L->nCcalls >= LUA_MAXCCALLS) {
     if (L->nCcalls == LUA_MAXCCALLS)
       luaG_runerror(L, "C stack overflow");
     else if (L->nCcalls >= (LUA_MAXCCALLS + (LUA_MAXCCALLS>>3)))
       luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
   }
-  firstResult = luaD_precall(L, func);
+  if (luaD_precall(L, func, nResults) == PCRLUA) {  /* is a Lua function? */
-  if (firstResult == NULL)  /* is a Lua function? */
+    StkId firstResult = luaV_execute(L, 1);  /* call it */
-    firstResult = luaV_execute(L, 1);  /* call it */
+    luaD_poscall(L, nResults, firstResult);
-  luaD_poscall(L, nResults, firstResult);
+  }
   L->nCcalls--;
   luaC_checkGC(L);
 }
   CallInfo *ci = L->ci;
   if (!L->isSuspended) {
     lua_assert(ci == L->base_ci && nargs < L->top - L->base);
-    luaD_precall(L, L->top - (nargs + 1));  /* start coroutine */
+    luaD_precall(L, L->top - (nargs + 1), LUA_MULTRET);  /* start coroutine */
   }
   else {  /* resuming from previous yield */
     if (!f_isLua(ci)) {  /* `common' yield? */
       /* finish interrupted execution of `OP_CALL' */
-      int nresults;
+      int nresults = ci->nresults;
-      lua_assert(GET_OPCODE(*((ci-1)->u.l.savedpc - 1)) == OP_CALL ||
+      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
-                 GET_OPCODE(*((ci-1)->u.l.savedpc - 1)) == OP_TAILCALL);
+                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
-      nresults = GETARG_C(*((ci-1)->u.l.savedpc - 1)) - 1;
       luaD_poscall(L, nresults, L->top - nargs);  /* complete it */
       if (nresults >= 0) L->top = L->ci->top;
     }  /* else yielded inside a hook: just continue its execution */

src/ldo.h+8−2

 /*
-** $Id: ldo.h,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: ldo.h,v 2.2 2004/05/14 19:25:09 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
 #define restoreci(L,n)		((CallInfo *)((char *)L->base_ci + (n)))
+/* results from luaD_precall */
+#define PCRLUA		0	/* initiated a call to a Lua function */
+#define PCRC		1	/* did a call to a C function */
+#define PCRYIELD	2	/* C funtion yielded */
 /* type of protected functions, to be ran by `runprotected' */
 typedef void (*Pfunc) (lua_State *L, void *ud);
 void luaD_resetprotection (lua_State *L);
 int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
 void luaD_callhook (lua_State *L, int event, int line);
-StkId luaD_precall (lua_State *L, StkId func);
+int luaD_precall (lua_State *L, StkId func, int nresults);
 void luaD_call (lua_State *L, StkId func, int nResults);
 int luaD_pcall (lua_State *L, Pfunc func, void *u,
                 ptrdiff_t oldtop, ptrdiff_t ef);

src/ldump.c+18−12

 /*
-** $Id: ldump.c,v 1.6 2004/03/24 00:25:08 lhf Exp $
+** $Id: ldump.c,v 1.8 2004/09/01 21:22:34 lhf Exp $
-** save bytecodes
+** save pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #include <stddef.h>
 #define ldump_c
+#define LUA_CORE
 #include "lua.h"
 typedef struct {
  lua_State* L;
- lua_Chunkwriter write;
+ lua_Chunkwriter writer;
  void* data;
  int strip;
+ int status;
 } DumpState;
 static void DumpBlock(const void* b, size_t size, DumpState* D)
 {
- lua_unlock(D->L);
+ if (D->status==0)
- (*D->write)(D->L,b,size,D->data);
+ {
- lua_lock(D->L);
+  lua_unlock(D->L);
+  D->status=(*D->writer)(D->L,b,size,D->data);
+  lua_lock(D->L);
+ }
 }
 static void DumpByte(int y, DumpState* D)
  DumpBlock(&x,sizeof(x),D);
 }
-static void DumpString(TString* s, DumpState* D)
+static void DumpString(const TString* s, DumpState* D)
 {
  if (s==NULL || getstr(s)==NULL)
   DumpSize(0,D);
 }
 /*
-** dump function as precompiled chunk
+** dump Lua function as precompiled chunk
 */
-int luaU_dump (lua_State* L, const Proto* Main, lua_Chunkwriter w, void* data, int strip)
+int luaU_dump (lua_State* L, const Proto* f, lua_Chunkwriter w, void* data, int strip)
 {
  DumpState D;
  D.L=L;
- D.write=w;
+ D.writer=w;
  D.data=data;
  D.strip=strip;
+ D.status=0;
  DumpHeader(&D);
- DumpFunction(Main,NULL,&D);
+ DumpFunction(f,NULL,&D);
- return 1;
+ return D.status;
 }

src/lfunc.c+2−1

 /*
-** $Id: lfunc.c,v 2.3 2004/03/15 21:04:33 roberto Exp $
+** $Id: lfunc.c,v 2.4 2004/04/30 20:13:38 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
 #include <stddef.h>
 #define lfunc_c
+#define LUA_CORE
 #include "lua.h"

src/lgc.c+173−137

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lgc.c,v 2.6 2004/03/23 12:57:12 roberto Exp $	2	** $Id: lgc.c,v 2.10 2004/08/30 13:44:44 roberto Exp $
3	** Garbage Collector	3	** Garbage Collector
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -7,6 +7,7 @@ · 1 unmodified line
7	#include <string.h>	7	#include <string.h>
8		8
9	#define lgc_c	9	#define lgc_c
		10	#define LUA_CORE
10		11
11	#include "lua.h"	12	#include "lua.h"
12		13
@@ -22,10 +23,11 @@ · 9 unmodified lines
22	#include "ltm.h"	23	#include "ltm.h"
23		24
24		25
25	#define GCSTEPSIZE (40*sizeof(TValue))	26	#define GCSTEPSIZE 1000
26	#define GCFREECOST (sizeof(TValue)/2)	27	#define STEPMUL 2
27	#define GCSWEEPCOST sizeof(TValue)	28	#define GCSWEEPMAX 10
28	#define GCFINALIZECOST (10*sizeof(TValue))	29	#define GCSWEEPCOST 30
		30	#define GCFINALIZECOST 100
29		31
30		32
31	#define FIXEDMASK bitmask(FIXEDBIT)	33	#define FIXEDMASK bitmask(FIXEDBIT)
@@ -266,60 +268,61 @@ static void traversestack (global_State g, lua_State l) { · 234 unmodified lines
266		268
267		269
268	/*	270	/*
269	** traverse a given `quantity' of gray objects,	271	** traverse one gray object, turning it to black.
270	** turning them to black. Returns extra `quantity' traversed.	272	** Returns `quantity' traversed.
271	*/	273	*/
272	static l_mem propagatemarks (global_State *g, l_mem lim) {	274	static l_mem propagatemark (global_State *g) {
273	GCObject *o;	275	GCObject *o = g->gray;
274	while ((o = g->gray) != NULL) {	276	lua_assert(isgray(o));
275	lua_assert(isgray(o));	277	gray2black(o);
276	gray2black(o);	278	switch (o->gch.tt) {
277	switch (o->gch.tt) {	279	case LUA_TTABLE: {
278	case LUA_TTABLE: {	280	Table *h = gco2h(o);
279	Table *h = gco2h(o);	281	g->gray = h->gclist;
280	g->gray = h->gclist;	282	if (traversetable(g, h)) /* table is weak? */
281	if (traversetable(g, h)) /* table is weak? */	283	black2gray(o); /* keep it gray */
282	black2gray(o); /* keep it gray */	284	return sizeof(Table) + sizeof(TValue) * h->sizearray +
283	lim -= sizeof(Table) + sizeof(TValue) * h->sizearray +	285	sizeof(Node) * sizenode(h);
284	sizeof(Node) * sizenode(h);	286	break;
285	break;	287	}
286	}	288	case LUA_TFUNCTION: {
287	case LUA_TFUNCTION: {	289	Closure *cl = gco2cl(o);
288	Closure *cl = gco2cl(o);	290	g->gray = cl->c.gclist;
289	g->gray = cl->c.gclist;	291	traverseclosure(g, cl);
290	traverseclosure(g, cl);	292	return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
291	lim -= (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :	293	sizeLclosure(cl->l.nupvalues);
292	sizeLclosure(cl->l.nupvalues);	294	break;
293	break;	295	}
294	}	296	case LUA_TTHREAD: {
295	case LUA_TTHREAD: {	297	lua_State *th = gco2th(o);
296	lua_State *th = gco2th(o);	298	g->gray = th->gclist;
297	g->gray = th->gclist;	299	th->gclist = g->grayagain;
298	th->gclist = g->grayagain;	300	g->grayagain = o;
299	g->grayagain = o;	301	black2gray(o);
300	black2gray(o);	302	traversestack(g, th);
301	traversestack(g, th);	303	return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
302	lim -= sizeof(lua_State) + sizeof(TValue) * th->stacksize +	304	sizeof(CallInfo) * th->size_ci;
303	sizeof(CallInfo) * th->size_ci;	305	break;
304	break;	306	}
305	}	307	case LUA_TPROTO: {
306	case LUA_TPROTO: {	308	Proto *p = gco2p(o);
307	Proto *p = gco2p(o);	309	g->gray = p->gclist;
308	g->gray = p->gclist;	310	traverseproto(g, p);
309	traverseproto(g, p);	311	return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
310	lim -= sizeof(Proto) + sizeof(Instruction) * p->sizecode +	312	sizeof(Proto ) p->sizep +
311	sizeof(Proto ) p->sizep +	313	sizeof(TValue) * p->sizek +
312	sizeof(TValue) * p->sizek +	314	sizeof(int) * p->sizelineinfo +
313	sizeof(int) * p->sizelineinfo +	315	sizeof(LocVar) * p->sizelocvars +
314	sizeof(LocVar) * p->sizelocvars +	316	sizeof(TString ) p->sizeupvalues;
315	sizeof(TString ) p->sizeupvalues;	317	break;
316	break;
317	}
318	default: lua_assert(0);
319	}	318	}
320	if (lim <= 0) return lim;	319	default: lua_assert(0); return 0;
321	}	320	}
322	return lim;	321	}
		322
		323
		324	static void propagateall (global_State *g) {
		325	while (g->gray) propagatemark(g);
323	}	326	}
324		327
325		328
@@ -381,6 +384,7 @@ static void freeobj (lua_State L, GCObject o) { · 55 unmodified lines
381	break;	384	break;
382	}	385	}
383	case LUA_TSTRING: {	386	case LUA_TSTRING: {
		387	G(L)->strt.nuse--;
384	luaM_free(L, o, sizestring(gco2ts(o)->len));	388	luaM_free(L, o, sizestring(gco2ts(o)->len));
385	break;	389	break;
386	}	390	}
@@ -393,59 +397,45 @@ static void freeobj (lua_State L, GCObject o) { · 6 unmodified lines
393	}	397	}
394		398
395		399
396	static l_mem sweepwholelist (lua_State L, GCObject *p, int keepfixed,	400
397	lu_int32 *count);	401	#define sweepwholelist(L,p) sweeplist(L,p,LUA_MAXINT32)
398		402
399		403
400	static GCObject *sweeplist (lua_State L, GCObject **p, int keepfixed,	404	static GCObject *sweeplist (lua_State L, GCObject **p, lu_int32 count) {
401	l_mem plim, lu_int32 count) {
402	GCObject *curr;	405	GCObject *curr;
403	global_State *g = G(L);	406	global_State *g = G(L);
404	l_mem lim = *plim;	407	int whitebit = otherwhite(g);
405	int deadmask = otherwhite(g);	408	int deadmask = whitebit \| FIXEDMASK;
406	if (keepfixed) deadmask \|= FIXEDMASK;	409	int generational = g->gcgenerational;
407	while ((curr = *p) != NULL) {	410	while ((curr = *p) != NULL && count-- > 0) {
408	if (((curr->gch.marked ^ FIXEDMASK) & deadmask) != deadmask) {	411	if ((curr->gch.marked ^ whitebit) & deadmask) {
409	makewhite(g, curr);	412	lua_assert(!isdead(g, curr) \|\| testbit(curr->gch.marked, FIXEDBIT));
		413	if (!generational \|\| isdead(g, curr))
		414	makewhite(g, curr);
410	if (curr->gch.tt == LUA_TTHREAD)	415	if (curr->gch.tt == LUA_TTHREAD)
411	lim -= sweepwholelist(L, &gco2th(curr)->openupval, keepfixed, count);	416	sweepwholelist(L, &gco2th(curr)->openupval);
412	p = &curr->gch.next;	417	p = &curr->gch.next;
413	lim -= GCSWEEPCOST;
414	}	418	}
415	else {	419	else {
416	lua_assert(iswhite(curr));	420	lua_assert(isdead(g, curr));
417	*p = curr->gch.next;	421	*p = curr->gch.next;
418	if (curr == g->rootgc) /* is the first element of the list? */	422	if (curr == g->rootgc) /* is the first element of the list? */
419	g->rootgc = curr->gch.next; /* adjust first */	423	g->rootgc = curr->gch.next; /* adjust first */
420	freeobj(L, curr);	424	freeobj(L, curr);
421	lim -= GCFREECOST;
422	if (count) (*count)--;
423	}	425	}
424	if (lim <= 0) break;
425	}	426	}
426	*plim = lim;
427	return p;	427	return p;
428	}	428	}
429		429
430		430
431	static l_mem sweepwholelist (lua_State L, GCObject *p, int keepfixed,
432	lu_int32 *count) {
433	l_mem lim = MAXLMEM;
434	/* empty lists are quite common here, so avoid useless calls */
435	if (*p) sweeplist(L, p, keepfixed, &lim, count);
436	return MAXLMEM - lim;
437	}
438
439		431
440	static l_mem sweepstrings (lua_State *L, int keepfixed, l_mem lim) {	432	static void freelist (lua_State L, GCObject *p) {
441	int i;	433	while (*p) {
442	global_State *g = G(L);	434	GCObject curr = p;
443	for (i = g->sweepstrgc; i < g->strt.size; i++) { /* for each list */	435	p = (p)->gch.next;
444	lim -= sweepwholelist(L, &G(L)->strt.hash[i], keepfixed, &g->strt.nuse);	436	if (curr != obj2gco(L))
445	if (lim <= 0) break;	437	freeobj(L, curr);
446	}	438	}
447	g->sweepstrgc = i+1;
448	return lim;
449	}	439	}
450		440
451		441
@@ -494,19 +484,12 @@ void luaC_callGCTM (lua_State *L) { · 42 unmodified lines
494	}	484	}
495		485
496		486
497	void luaC_sweepall (lua_State *L) {	487	void luaC_freeall (lua_State *L) {
498	global_State *g = G(L);	488	global_State *g = G(L);
499	l_mem dummy = MAXLMEM;	489	int i;
500	/* finish (occasional) current sweep */	490	freelist(L, &g->rootgc);
501	sweepstrings(L, 0, MAXLMEM);	491	for (i = 0; i < g->strt.size; i++) /* free all string lists */
502	sweeplist(L, &g->rootgc, 0, &dummy, NULL);	492	freelist(L, &G(L)->strt.hash[i]);
503	/* do a whole new sweep */
504	markobject(g, g->mainthread); /* cannot collect main thread */
505	g->currentwhite = otherwhite(g);
506	g->sweepgc = &g->rootgc;
507	g->sweepstrgc = 0;
508	sweepstrings(L, 0, MAXLMEM);
509	sweeplist(L, &g->rootgc, 0, &dummy, NULL);
510	}	493	}
511		494
512		495
@@ -530,8 +513,10 @@ static void remarkupvals (global_State *g) { · 17 unmodified lines
530	if (iswhite(o)) {	513	if (iswhite(o)) {
531	GCObject *curr;	514	GCObject *curr;
532	for (curr = gco2th(o)->openupval; curr != NULL; curr = curr->gch.next) {	515	for (curr = gco2th(o)->openupval; curr != NULL; curr = curr->gch.next) {
533	if (isgray(curr))	516	if (isgray(curr)) {
534	markvalue(g, gco2uv(curr)->v);	517	UpVal *uv = gco2uv(curr);
		518	markvalue(g, uv->v);
		519	}
535	}	520	}
536	}	521	}
537	}	522	}
@@ -540,6 +525,7 @@ static void remarkupvals (global_State *g) { · 2 unmodified lines
540		525
541	static void atomic (lua_State *L) {	526	static void atomic (lua_State *L) {
542	global_State *g = G(L);	527	global_State *g = G(L);
		528	int aux;
543	lua_assert(g->gray == NULL);	529	lua_assert(g->gray == NULL);
544	/* remark occasional upvalues of (maybe) dead threads */	530	/* remark occasional upvalues of (maybe) dead threads */
545	remarkupvals(g);	531	remarkupvals(g);
@@ -548,90 +534,130 @@ static void atomic (lua_State *L) { · 2 unmodified lines
548	g->weak = NULL;	534	g->weak = NULL;
549	lua_assert(!iswhite(obj2gco(g->mainthread)));	535	lua_assert(!iswhite(obj2gco(g->mainthread)));
550	markobject(g, L); /* mark running thread */	536	markobject(g, L); /* mark running thread */
551	propagatemarks(g, MAXLMEM);	537	propagateall(g);
552	/* remark gray again */	538	/* remark gray again */
553	g->gray = g->grayagain;	539	g->gray = g->grayagain;
554	g->grayagain = NULL;	540	g->grayagain = NULL;
555	propagatemarks(g, MAXLMEM);	541	propagateall(g);
556	luaC_separateudata(L, 0); /* separate userdata to be preserved */	542	luaC_separateudata(L, 0); /* separate userdata to be preserved */
557	marktmu(g); /* mark `preserved' userdata */	543	marktmu(g); /* mark `preserved' userdata */
558	propagatemarks(g, MAXLMEM); /* remark, to propagate `preserveness' */	544	propagateall(g); /* remark, to propagate `preserveness' */
559	cleartable(g->weak); /* remove collected objects from weak tables */	545	cleartable(g->weak); /* remove collected objects from weak tables */
560	/* flip current white */	546	/* flip current white */
561	g->currentwhite = otherwhite(g);	547	g->currentwhite = otherwhite(g);
		548	g->sweepstrgc = 0;
		549	g->sweepgc = &g->rootgc;
562	g->gcstate = GCSsweepstring;	550	g->gcstate = GCSsweepstring;
		551	aux = g->gcgenerational;
		552	g->gcgenerational = (g->estimate <= 4*g->prevestimate/2);
		553	if (!aux) /* last collection was full? */
		554	g->prevestimate = g->estimate; /* keep estimate of last full collection */
		555	g->estimate = g->totalbytes; /* first estimate */
563	}	556	}
564		557
565		558
566	static l_mem singlestep (lua_State *L, l_mem lim) {	559	static l_mem singlestep (lua_State *L) {
567	global_State *g = G(L);	560	global_State *g = G(L);
		561	/lua_checkmemory(L);/
568	switch (g->gcstate) {	562	switch (g->gcstate) {
		563	case GCSpause: {
		564	/* start a new collection */
		565	if (g->gcgenerational)
		566	atomic(L);
		567	else
		568	markroot(L);
		569	return 0;
		570	}
569	case GCSpropagate: {	571	case GCSpropagate: {
570	if (g->gray)	572	if (g->gray)
571	lim = propagatemarks(g, lim);	573	return propagatemark(g);
572	else { /* no more `gray' objects */	574	else { /* no more `gray' objects */
573	atomic(L); /* finish mark phase */	575	atomic(L); /* finish mark phase */
574	lim = 0;	576	return 0;
575	}	577	}
576	break;
577	}	578	}
578	case GCSsweepstring: {	579	case GCSsweepstring: {
579	lim = sweepstrings(L, 1, lim);	580	lu_mem old = g->totalbytes;
580	if (g->sweepstrgc >= g->strt.size) { /* nothing more to sweep? */	581	sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
581	g->sweepstrgc = 0;	582	if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */
582	g->gcstate = GCSsweep; /* end sweep-string phase */	583	g->gcstate = GCSsweep; /* end sweep-string phase */
583	}	584	g->estimate -= old - g->totalbytes;
584	break;	585	return GCSWEEPCOST;
585	}	586	}
586	case GCSsweep: {	587	case GCSsweep: {
587	g->sweepgc = sweeplist(L, g->sweepgc, 1, &lim, NULL);	588	lu_mem old = g->totalbytes;
		589	g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
588	if (g->sweepgc == NULL) { / nothing more to sweep? */	590	if (g->sweepgc == NULL) { / nothing more to sweep? */
589	checkSizes(L);	591	checkSizes(L);
590	g->sweepgc = &g->rootgc;
591	g->gcstate = GCSfinalize; /* end sweep phase */	592	g->gcstate = GCSfinalize; /* end sweep phase */
592	}	593	}
593	break;	594	g->estimate -= old - g->totalbytes;
		595	return GCSWEEPMAX*GCSWEEPCOST;
594	}	596	}
595	case GCSfinalize: {	597	case GCSfinalize: {
596	if (g->tmudata) {	598	if (g->tmudata) {
597	GCTM(L);	599	GCTM(L);
598	lim -= GCFINALIZECOST;	600	return GCFINALIZECOST;
599	}	601	}
600	else { /* no more `udata' to finalize */	602	else {
601	markroot(L); /* may restart collection */	603	g->gcstate = GCSpause; /* end collection */
602	lim = 0;	604	return 0;
603	}	605	}
604	break;
605	}	606	}
606	default: lua_assert(0);	607	default: lua_assert(0); return 0;
607	}	608	}
608	return lim;
609	}	609	}
610		610
611		611
612	void luaC_step (lua_State *L) {	612	void luaC_step (lua_State *L) {
613	global_State *g = G(L);	613	global_State *g = G(L);
614	l_mem lim = (g->nblocks - (g->GCthreshold - GCSTEPSIZE)) * 2;	614	l_mem lim = (g->totalbytes - (g->GCthreshold - GCSTEPSIZE)) * STEPMUL;
		615	/printf("step(%c): ", g->gcgenerational?'g':' ');/
615	do {	616	do {
616	lim = singlestep(L, lim);	617	/printf("%c", "_pswf"[g->gcstate]);/
617	if (g->gcstate == GCSfinalize && g->tmudata == NULL)	618	lim -= singlestep(L);
618	break; /* do not start new collection */	619	if (g->gcstate == GCSpause)
		620	break;
619	} while (lim > 0);	621	} while (lim > 0);
620	g->GCthreshold = g->nblocks + GCSTEPSIZE - lim/2;	622	/printf("\n");/
621	lua_assert((long)g->nblocks + (long)GCSTEPSIZE >= lim/2);	623	if (g->gcstate != GCSpause)
		624	g->GCthreshold = g->totalbytes + GCSTEPSIZE; /* - lim/STEPMUL; */
		625	else {
		626	/printf("---\n");/
		627	lua_assert(g->totalbytes >= g->estimate);
		628	g->GCthreshold = 2*g->estimate;
		629	if (g->GCthreshold < g->totalbytes + GCSTEPSIZE)
		630	g->GCthreshold = g->totalbytes + GCSTEPSIZE;
		631	}
622	}	632	}
623		633
624		634
625	void luaC_fullgc (lua_State *L) {	635	void luaC_fullgc (lua_State *L) {
626	global_State *g = G(L);	636	global_State *g = G(L);
		637	if (g->gcstate <= GCSpropagate \|\| g->gcgenerational) {
		638	g->gcgenerational = 0;
		639	/* reset sweep marks to sweep all elements (returning them to white) */
		640	g->sweepstrgc = 0;
		641	g->sweepgc = &g->rootgc;
		642	/* reset other collector lists */
		643	g->gray = NULL;
		644	g->grayagain = NULL;
		645	g->weak = NULL;
		646	g->gcstate = GCSsweepstring;
		647	}
		648	/* finish any pending sweep phase */
627	while (g->gcstate != GCSfinalize) {	649	while (g->gcstate != GCSfinalize) {
628	singlestep(L, MAXLMEM);	650	lua_assert(g->gcstate == GCSsweepstring \|\| g->gcstate == GCSsweep);
		651	singlestep(L);
629	}	652	}
630	markroot(L);	653	markroot(L);
		654	lua_assert(!g->gcgenerational);
631	while (g->gcstate != GCSfinalize) {	655	while (g->gcstate != GCSfinalize) {
632	singlestep(L, MAXLMEM);	656	singlestep(L);
		657	g->gcgenerational = 0; /* keep it in this mode */
633	}	658	}
634	g->GCthreshold = g->nblocks + GCSTEPSIZE;	659	lua_assert(g->estimate == g->totalbytes);
		660	g->GCthreshold = 2*g->estimate;
635	luaC_callGCTM(L); /* call finalizers */	661	luaC_callGCTM(L); /* call finalizers */
636	}	662	}
637		663
@@ -639,7 +665,7 @@ void luaC_fullgc (lua_State *L) { · 1 unmodified line
639	void luaC_barrierf (lua_State L, GCObject o, GCObject *v) {	665	void luaC_barrierf (lua_State L, GCObject o, GCObject *v) {
640	global_State *g = G(L);	666	global_State *g = G(L);
641	lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));	667	lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
642	lua_assert(g->gcstate != GCSfinalize);	668	lua_assert(g->gcgenerational \|\| g->gcstate != GCSfinalize);
643	if (g->gcstate != GCSpropagate) /* sweeping phases? */	669	if (g->gcstate != GCSpropagate) /* sweeping phases? */
644	black2gray(o); /* just mark as gray to avoid other barriers */	670	black2gray(o); /* just mark as gray to avoid other barriers */
645	else /* breaking invariant! */	671	else /* breaking invariant! */
@@ -647,6 +673,16 @@ void luaC_barrierf (lua_State L, GCObject o, GCObject *v) { · 1 unmodified line
647	}	673	}
648		674
649		675
		676	void luaC_barrierback (lua_State L, GCObject o, GCObject *v) {
		677	global_State *g = G(L);
		678	lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
		679	lua_assert(g->gcgenerational \|\| g->gcstate != GCSfinalize);
		680	black2gray(o); /* make table gray (again) */
		681	gco2h(o)->gclist = g->grayagain;
		682	g->grayagain = o;
		683	}
		684
		685
650	void luaC_link (lua_State L, GCObject o, lu_byte tt) {	686	void luaC_link (lua_State L, GCObject o, lu_byte tt) {
651	global_State *g = G(L);	687	global_State *g = G(L);
652	o->gch.next = g->rootgc;	688	o->gch.next = g->rootgc;
@@ -662,13 +698,13 @@ void luaC_linkupval (lua_State L, UpVal uv) { · 9 unmodified lines
662	o->gch.next = g->rootgc; /* link upvalue into `rootgc' list */	698	o->gch.next = g->rootgc; /* link upvalue into `rootgc' list */
663	g->rootgc = o;	699	g->rootgc = o;
664	if (isgray(o)) {	700	if (isgray(o)) {
665	if (g->gcstate == GCSpropagate) {	701	if (g->gcstate == GCSpropagate \|\| g->gcgenerational) {
666	gray2black(o); /* closed upvalues need barrier */	702	gray2black(o); /* closed upvalues need barrier */
667	luaC_barrier(L, uv, uv->v);	703	luaC_barrier(L, uv, uv->v);
668	}	704	}
669	else { /* sweep phase: sweep it (turning it into white) */	705	else { /* sweep phase: sweep it (turning it into white) */
670	makewhite(g, o);	706	makewhite(g, o);
671	lua_assert(g->gcstate != GCSfinalize);	707	lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
672	}	708	}
673	}	709	}
674	}	710	}

src/lgc.h+19−13

 /*
-** $Id: lgc.h,v 2.5 2004/03/15 21:04:33 roberto Exp $
+** $Id: lgc.h,v 2.8 2004/08/30 13:44:44 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 /*
 ** Possible states of the Garbage Collector
 */
-#define GCSpropagate	0
+#define GCSpause	0
-#define GCSsweepstring	1
+#define GCSpropagate	1
-#define GCSsweep	2
+#define GCSsweepstring	2
-#define GCSfinalize	3
+#define GCSsweep	3
+#define GCSfinalize	4
 /*
 /*
 ** Layout for bit use in `marked' field:
-** bit 0 - object is gray
+** bit 0 - object is white (type 0)
-** bit 1 - object is black
+** bit 1 - object is white (type 1)
-** bit 2 - For userdata: is finalized;
+** bit 2 - object is black
-           for tables: has weak keys
+** bit 3 - for userdata: has been finalized
-** bit 3 - for tables: has weak values
+** bit 3 - for tables: has weak keys
-** bit 4 - object is fixed (should not be collected)
+** bit 4 - for tables: has weak values
+** bit 5 - object is fixed (should not be collected)
 */
 #define WHITE0BIT	0
 #define luaC_white(g)	cast(lu_byte, (g)->currentwhite)
-#define luaC_checkGC(L) { if (G(L)->nblocks >= G(L)->GCthreshold) \
+#define luaC_checkGC(L) { if (G(L)->totalbytes >= G(L)->GCthreshold) \
 	luaC_step(L); }
 #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
 	luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
+#define luaC_barriert(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
+	luaC_barrierback(L,obj2gco(p),gcvalue(v)); }
 #define luaC_objbarrier(L,p,o)  \
 	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
 		luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
 size_t luaC_separateudata (lua_State *L, int all);
 void luaC_callGCTM (lua_State *L);
-void luaC_sweepall (lua_State *L);
+void luaC_freeall (lua_State *L);
 void luaC_step (lua_State *L);
 void luaC_fullgc (lua_State *L);
 void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
 void luaC_linkupval (lua_State *L, UpVal *uv);
 void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
+void luaC_barrierback (lua_State *L, GCObject *o, GCObject *v);
 #endif

src/lib/Makefile+2−2

@@ -6,8 +6,8 @@ include $(LUA)/config · 5 unmodified lines
6		6
7	EXTRA_DEFS= $(POPEN) $(TMPNAM) $(DEGREES) $(LOADLIB)	7	EXTRA_DEFS= $(POPEN) $(TMPNAM) $(DEGREES) $(LOADLIB)
8		8
9	OBJS= lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o ltablib.o lstrlib.o loadlib.o	9	OBJS= lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o lstrlib.o loadlib.o linit.o
10	SRCS= lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c ltablib.c lstrlib.c loadlib.c	10	SRCS= lauxlib.c lbaselib.c ldblib.c liolib.c lmathlib.c loslib.c ltablib.c lstrlib.c loadlib.c linit.c
11		11
12	T= $(LIB)/liblualib.a	12	T= $(LIB)/liblualib.a
13		13

src/lib/RCS+0−1

@@ -1 +0,0 @@
1	../RCS

src/lib/lauxlib.c+96−63

 /*
-** $Id: lauxlib.c,v 1.110 2004/03/23 16:38:43 roberto Exp $
+** $Id: lauxlib.c,v 1.123 2004/08/30 18:35:14 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 */
 #define lauxlib_c
+#define LUA_LIB
 #include "lua.h"
 LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
   const char *msg = lua_pushfstring(L, "%s expected, got %s",
-                                    tname, lua_typename(L, lua_type(L,narg)));
+                                    tname, luaL_typename(L, narg));
   return luaL_argerror(L, narg, msg);
 }
     if (lua_isnil(L, -1)) {  /* no? */
       lua_pop(L, 1);
       lua_newtable(L);  /* create it */
+      if (lua_getmetatable(L, LUA_GLOBALSINDEX))
+        lua_setmetatable(L, -2);  /* share metatable with global table */
       lua_pushvalue(L, -1);
       /* register it with given name */
       lua_setglobal(L, libname);
 }
-void luaL_setn (lua_State *L, int t, int n) {
+LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
   t = abs_index(L, t);
   getsizes(L);
   lua_pushvalue(L, t);
 }
-int luaL_getn (lua_State *L, int t) {
+/* find an `n' such that t[n] ~= nil and t[n+1] == nil */
+static int countn (lua_State *L, int t) {
+  int i = LUA_FIRSTINDEX - 1;
+  int j = 2;
+  /* find `i' such that i <= n < i*2 (= j) */
+  for (;;) {
+    lua_rawgeti(L, t, j);
+    if (lua_isnil(L, -1)) break;
+    lua_pop(L, 1);
+    i = j;
+    j = i*2;
+  }
+  lua_pop(L, 1);
+  /* i <= n < j; do a binary search */
+  while (i < j-1) {
+    int m = (i+j)/2;
+    lua_rawgeti(L, t, m);
+    if (lua_isnil(L, -1)) j = m;
+    else i = m;
+    lua_pop(L, 1);
+  }
+  return i - LUA_FIRSTINDEX + 1;
+}
+LUALIB_API int luaL_getn (lua_State *L, int t) {
   int n;
   t = abs_index(L, t);
   getsizes(L);  /* try sizes[t] */
   if ((n = checkint(L, 2)) >= 0) return n;
   lua_getfield(L, t, "n");  /* else try t.n */
   if ((n = checkint(L, 1)) >= 0) return n;
-  for (n = 1; ; n++) {  /* else must count elements */
+  return countn(L, t);
-    lua_rawgeti(L, t, n);
-    if (lua_isnil(L, -1)) break;
-    lua_pop(L, 1);
-  }
-  lua_pop(L, 1);
-  return n - 1;
 }
 /* }====================================================== */
+static const char *pushnexttemplate (lua_State *L, const char *path) {
+  const char *l;
+  if (*path == '\0') return NULL;  /* no more templates */
+  if (*path == LUA_PATH_SEP) path++;  /* skip separator */
+  l = strchr(path, LUA_PATH_SEP);  /* find next separator */
+  if (l == NULL) l = path+strlen(path);
+  lua_pushlstring(L, path, l - path);  /* template */
+  return l;
+}
+static const char *luaL_gsub (lua_State *L, const char *s,
+                              const char *p, const char *r) {
+  const char *wild;
+  int l = strlen(p);
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  while ((wild = strstr(s, p)) != NULL) {
+    luaL_addlstring(&b, s, wild - s);  /* push prefix */
+    luaL_addstring(&b, r);  /* push replacement in place of pattern */
+    s = wild + l;  /* continue after `p' */
+  }
+  luaL_addstring(&b, s);  /* push last suffix (`n' already includes this) */
+  luaL_pushresult(&b);
+  return lua_tostring(L, -1);
+}
+LUALIB_API const char *luaL_searchpath (lua_State *L, const char *name,
+                                                      const char *path) {
+  FILE *f;
+  const char *p = path;
+  for (;;) {
+    const char *fname;
+    if ((p = pushnexttemplate(L, p)) == NULL) {
+      lua_pushfstring(L, "no readable `%s' in path `%s'", name, path);
+      return NULL;
+    }
+    fname = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
+    lua_remove(L, -2);  /* remove path template */
+    f = fopen(fname, "r");  /* try to read it */
+    if (f) {
+      fclose(f);
+      return fname;
+    }
+    lua_pop(L, 1);  /* remove file name */
+  }
+}
 /*
 ** {======================================================
 }
-static int errfile (lua_State *L, int fnameindex) {
+static int errfile (lua_State *L, const char *what, int fnameindex) {
+  const char *serr = strerror(errno);
   const char *filename = lua_tostring(L, fnameindex) + 1;
-  lua_pushfstring(L, "cannot read %s: %s", filename, strerror(errno));
+  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
   lua_remove(L, fnameindex);
   return LUA_ERRFILE;
 }
   else {
     lua_pushfstring(L, "@%s", filename);
     lf.f = fopen(filename, "r");
-    if (lf.f == NULL) return errfile(L, fnameindex);  /* unable to open file */
+    if (lf.f == NULL) return errfile(L, "open", fnameindex);
   }
   c = getc(lf.f);
   if (c == '#') {  /* Unix exec. file? */
   if (c == LUA_SIGNATURE[0] && lf.f != stdin) {  /* binary file? */
     fclose(lf.f);
     lf.f = fopen(filename, "rb");  /* reopen in binary mode */
-    if (lf.f == NULL) return errfile(L, fnameindex); /* unable to reopen file */
+    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
     /* skip eventual `#!...' */
    while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
     lf.extraline = 0;
   if (lf.f != stdin) fclose(lf.f);  /* close file (even in case of errors) */
   if (readstatus) {
     lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
-    return errfile(L, fnameindex);
+    return errfile(L, "read", fnameindex);
   }
   lua_remove(L, fnameindex);
   return status;
   return lua_load(L, getS, &ls, name);
 }
 /* }====================================================== */
 }
-LUALIB_API lua_State *luaL_newstate (void) {
+static int panic (lua_State *L) {
-  return lua_newstate(l_alloc, NULL);
+  fprintf(stderr, "PANIC: unprotected error during Lua-API call\n");
-}
+  return 0;
-/*
-** {======================================================
-** compatibility code
-** =======================================================
-*/
-static void callalert (lua_State *L, int status) {
-  if (status != 0) {
-    lua_getglobal(L, "_ALERT");
-    if (lua_isfunction(L, -1)) {
-      lua_insert(L, -2);
-      lua_call(L, 1, 0);
-    }
-    else {  /* no _ALERT function; print it on stderr */
-      fprintf(stderr, "%s\n", lua_tostring(L, -2));
-      lua_pop(L, 2);  /* remove error message and _ALERT */
-    }
-  }
 }
-static int aux_do (lua_State *L, int status) {
+LUALIB_API lua_State *luaL_newstate (void) {
-  if (status == 0) {  /* parse OK? */
+  lua_State *L = lua_newstate(l_alloc, NULL);
-    status = lua_pcall(L, 0, LUA_MULTRET, 0);  /* call main */
+  lua_atpanic(L, &panic);
-  }
+  return L;
-  callalert(L, status);
-  return status;
-}
-LUALIB_API int lua_dofile (lua_State *L, const char *filename) {
-  return aux_do(L, luaL_loadfile(L, filename));
-}
-LUALIB_API int lua_dobuffer (lua_State *L, const char *buff, size_t size,
-                          const char *name) {
-  return aux_do(L, luaL_loadbuffer(L, buff, size, name));
-}
-LUALIB_API int lua_dostring (lua_State *L, const char *str) {
-  return lua_dobuffer(L, str, strlen(str), str);
 }
-/* }====================================================== */

src/lib/lbaselib.c+120−176

 /*
-** $Id: lbaselib.c,v 1.140 2004/03/09 17:34:35 roberto Exp $
+** $Id: lbaselib.c,v 1.156 2004/08/30 18:35:14 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lbaselib_c
+#define LUA_LIB
 #include "lua.h"
 }
-static int aux_getfenv (lua_State *L) {
-  lua_getfenv(L, -1);
-  lua_pushliteral(L, "__fenv");
-  lua_rawget(L, -2);
-  return !lua_isnil(L, -1);
-}
 static int luaB_getfenv (lua_State *L) {
   getfunc(L);
-  if (!aux_getfenv(L))  /* __fenv not defined? */
+  lua_getfenv(L, -1);
-    lua_pop(L, 1);  /* remove it, to return real environment */
   return 1;
 }
 static int luaB_setfenv (lua_State *L) {
   luaL_checktype(L, 2, LUA_TTABLE);
   getfunc(L);
-  if (aux_getfenv(L))  /* __fenv defined? */
-    luaL_error(L, "`setfenv' cannot change a protected environment");
-  else
-    lua_pop(L, 2);  /* remove __fenv and real environment table */
   lua_pushvalue(L, 2);
-  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0)
+  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
     lua_replace(L, LUA_GLOBALSINDEX);
+    return 0;
+  }
   else if (lua_setfenv(L, -2) == 0)
     luaL_error(L, "`setfenv' cannot change environment of given function");
-  return 0;
+  return 1;
 }
 static int luaB_collectgarbage (lua_State *L) {
   static const char *const opts[] = {"stop", "restart", "collect", "count",
-                                     NULL};
+                                     "step", NULL};
   static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART,
-                                LUA_GCCOLLECT, LUA_GCCOUNT};
+                                LUA_GCCOLLECT, LUA_GCCOUNT, LUA_GCSTEP};
-  int o;
+  int o = luaL_findstring(luaL_optstring(L, 1, "collect"), opts);
-  int ex;
+  int ex = luaL_optint(L, 2, 0);
-#if 1
-  if (lua_isnumber(L, 1)) {
-    int v = lua_tointeger(L, 1);
-    lua_settop(L, 0);
-    if (v == 0) lua_pushstring(L, "collect");
-    else if (v >= 10000) lua_pushstring(L, "stop");
-    else lua_pushstring(L, "restart");
-  }
-#endif
-  o = luaL_findstring(luaL_optstring(L, 1, "collect"), opts);
-  ex = luaL_optint(L, 2, 0);
   luaL_argcheck(L, o >= 0, 1, "invalid option");
   lua_pushinteger(L, lua_gc(L, optsnum[o], ex));
   return 1;
 static int luaB_type (lua_State *L) {
   luaL_checkany(L, 1);
-  lua_pushstring(L, lua_typename(L, lua_type(L, 1)));
+  lua_pushstring(L, luaL_typename(L, 1));
   return 1;
 }
 static int luaB_pairs (lua_State *L) {
   luaL_checktype(L, 1, LUA_TTABLE);
-  lua_getglobal(L, "next");  /* return generator, */
+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
   lua_pushvalue(L, 1);  /* state, */
   lua_pushnil(L);  /* and initial value */
   return 3;
 }
+static int ipairsaux (lua_State *L) {
+  int i = luaL_checkint(L, 2);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  i++;  /* next value */
+  lua_pushinteger(L, i);
+  lua_rawgeti(L, 1, i);
+  return (lua_isnil(L, -1)) ? 0 : 2;
+}
 static int luaB_ipairs (lua_State *L) {
-  int i = (int)lua_tointeger(L, 2);
   luaL_checktype(L, 1, LUA_TTABLE);
-  if (i == 0 && lua_isnone(L, 2)) {  /* `for' start? */
+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
-    lua_getglobal(L, "ipairs");  /* return generator, */
+  lua_pushvalue(L, 1);  /* state, */
-    lua_pushvalue(L, 1);  /* state, */
+  lua_pushinteger(L, LUA_FIRSTINDEX - 1);  /* and initial value */
-    lua_pushinteger(L, 0);  /* and initial value */
+  return 3;
-    return 3;
-  }
-  else {  /* `for' step */
-    i++;  /* next value */
-    lua_pushinteger(L, i);
-    lua_rawgeti(L, 1, i);
-    return (lua_isnil(L, -1)) ? 0 : 2;
-  }
 }
 static int luaB_loadfile (lua_State *L) {
   const char *fname = luaL_optstring(L, 1, NULL);
-  return load_aux(L, luaL_loadfile(L, fname));
+  const char *path = luaL_optstring(L, 2, NULL);
+  int status;
+  if (path == NULL)
+    status = luaL_loadfile(L, fname);
+  else {
+    fname = luaL_searchpath(L, fname, path);
+    status = (fname) ? luaL_loadfile(L, fname) : 1;
+  }
+  return load_aux(L, status);
 }
   luaL_checkany(L, 1);
   if (!lua_toboolean(L, 1))
     return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
-  lua_settop(L, 1);
+  return lua_gettop(L);
-  return 1;
 }
 static int luaB_unpack (lua_State *L) {
-  int n, i;
+  int i = luaL_optint(L, 2, LUA_FIRSTINDEX);
+  int e = luaL_optint(L, 3, -1);
+  int n;
   luaL_checktype(L, 1, LUA_TTABLE);
-  n = luaL_getn(L, 1);
+  if (e == -1)
+    e = luaL_getn(L, 1) + LUA_FIRSTINDEX - 1;
+  n = e - i + 1;  /* number of elements */
+  if (n <= 0) return 0;  /* empty range */
   luaL_checkstack(L, n, "table too big to unpack");
-  for (i=1; i<=n; i++)  /* push arg[1...n] */
+  for (; i<=e; i++)  /* push arg[i...e] */
     lua_rawgeti(L, 1, i);
   return n;
 }
+static int luaB_select (lua_State *L) {
+  int n = lua_gettop(L);
+  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
+    lua_pushinteger(L, n-1);
+    return 1;
+  }
+  else {
+    int i = luaL_checkint(L, 1);
+    if (i <= 0) i = 1;
+    else if (i >= n) i = n;
+    return n - i;
+  }
+}
 static int luaB_pcall (lua_State *L) {
   int status;
   luaL_checkany(L, 1);
 static int luaB_tostring (lua_State *L) {
-  char buff[4*sizeof(void *) + 2];  /* enough space for a `%p' */
-  const char *tn = "";
-  const void *p = NULL;
   luaL_checkany(L, 1);
   if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
     return 1;  /* use its value */
   switch (lua_type(L, 1)) {
     case LUA_TNUMBER:
       lua_pushstring(L, lua_tostring(L, 1));
-      return 1;
+      break;
     case LUA_TSTRING:
       lua_pushvalue(L, 1);
-      return 1;
+      break;
     case LUA_TBOOLEAN:
       lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
-      return 1;
+      break;
     case LUA_TNIL:
       lua_pushliteral(L, "nil");
-      return 1;
+      break;
     case LUA_TTABLE:
-      p = lua_topointer(L, 1);
+      lua_pushfstring(L, "table: %p", lua_topointer(L, 1));
-      tn = "table";
       break;
     case LUA_TFUNCTION:
-      p = lua_topointer(L, 1);
+      lua_pushfstring(L, "function: %p", lua_topointer(L, 1));
-      tn = "function";
       break;
     case LUA_TUSERDATA:
     case LUA_TLIGHTUSERDATA:
-      p = lua_touserdata(L, 1);
+      lua_pushfstring(L, "userdata: %p", lua_topointer(L, 1));
-      tn = "userdata";
       break;
     case LUA_TTHREAD:
-      p = lua_tothread(L, 1);
+      lua_pushfstring(L, "thread: %p", lua_topointer(L, 1));
-      tn = "thread";
       break;
   }
-  sprintf(buff, "%p", p);
-  lua_pushfstring(L, "%s: %s", tn, buff);
   return 1;
 }
 */
-/* name of global that holds table with loaded packages */
-#define REQTAB		"_LOADED"
-/* name of global that holds the search path for packages */
-#define LUA_PATH	"LUA_PATH"
-#ifndef LUA_PATH_SEP
-#define LUA_PATH_SEP	';'
-#endif
-#ifndef LUA_PATH_MARK
-#define LUA_PATH_MARK	'?'
-#endif
-#ifndef LUA_PATH_DEFAULT
-#define LUA_PATH_DEFAULT	"?;?.lua"
-#endif
 static const char *getpath (lua_State *L) {
-  const char *path;
+  /* try first `LUA_PATH' for compatibility */
-  lua_getglobal(L, LUA_PATH);  /* try global variable */
+  lua_getfield(L, LUA_GLOBALSINDEX, "LUA_PATH");
-  path = lua_tostring(L, -1);
+  if (!lua_isstring(L, -1)) {
-  lua_pop(L, 1);
+    lua_pop(L, 1);
-  if (path) return path;
+    lua_getfield(L, LUA_GLOBALSINDEX, "_PATH");
-  path = getenv(LUA_PATH);  /* else try environment variable */
-  if (path) return path;
-  return LUA_PATH_DEFAULT;  /* else use default */
-}
-static const char *pushnextpath (lua_State *L, const char *path) {
-  const char *l;
-  if (*path == '\0') return NULL;  /* no more paths */
-  if (*path == LUA_PATH_SEP) path++;  /* skip separator */
-  l = strchr(path, LUA_PATH_SEP);  /* find next separator */
-  if (l == NULL) l = path+strlen(path);
-  lua_pushlstring(L, path, l - path);  /* directory name */
-  return l;
-}
-static void pushcomposename (lua_State *L) {
-  const char *path = lua_tostring(L, -1);
-  const char *wild;
-  int n = 1;
-  while ((wild = strchr(path, LUA_PATH_MARK)) != NULL) {
-    /* is there stack space for prefix, name, and eventual last suffix? */
-    luaL_checkstack(L, 3, "too many marks in a path component");
-    lua_pushlstring(L, path, wild - path);  /* push prefix */
-    lua_pushvalue(L, 1);  /* push package name (in place of MARK) */
-    path = wild + 1;  /* continue after MARK */
-    n += 2;
   }
-  lua_pushstring(L, path);  /* push last suffix (`n' already includes this) */
+  if (!lua_isstring(L, -1))
-  lua_concat(L, n);
+    luaL_error(L, "global _PATH must be a string");
+  return lua_tostring(L, -1);
 }
 static int luaB_require (lua_State *L) {
-  const char *path;
+  const char *name = luaL_checkstring(L, 1);
-  int status = LUA_ERRFILE;  /* not found (yet) */
+  const char *fname;
-  luaL_checkstring(L, 1);
+  lua_getfield(L, lua_upvalueindex(1), name);
-  lua_settop(L, 1);
-  lua_getglobal(L, REQTAB);
-  if (!lua_istable(L, 2)) return luaL_error(L, "`" REQTAB "' is not a table");
-  path = getpath(L);
-  lua_pushvalue(L, 1);  /* check package's name in book-keeping table */
-  lua_rawget(L, 2);
   if (lua_toboolean(L, -1))  /* is it there? */
     return 1;  /* package is already loaded; return its result */
-  else {  /* must load it */
+  /* else must load it; first mark it as loaded */
-    while (status == LUA_ERRFILE) {
+  lua_pushboolean(L, 1);
-      lua_settop(L, 3);  /* reset stack position */
+  lua_setfield(L, lua_upvalueindex(1), name);  /* _LOADED[name] = true */
-      if ((path = pushnextpath(L, path)) == NULL) break;
+  fname = luaL_searchpath(L, name, getpath(L));
-      pushcomposename(L);
+  if (fname == NULL || luaL_loadfile(L, fname) != 0)
-      status = luaL_loadfile(L, lua_tostring(L, -1));  /* try to load it */
+    return luaL_error(L, "error loading package `%s' (%s)", name,
-    }
+                         lua_tostring(L, -1));
-  }
+  lua_pushvalue(L, 1);  /* pass name as argument to module */
-  switch (status) {
+  lua_call(L, 1, 1);  /* run loaded module */
-    case 0: {
+  if (!lua_isnil(L, -1))  /* nil return? */
-      lua_getglobal(L, "_REQUIREDNAME");  /* save previous name */
+    lua_setfield(L, lua_upvalueindex(1), name);
-      lua_insert(L, -2);  /* put it below function */
+  lua_getfield(L, lua_upvalueindex(1), name);  /* return _LOADED[name] */
-      lua_pushvalue(L, 1);
+  return 1;
-      lua_setglobal(L, "_REQUIREDNAME");  /* set new name */
-      lua_call(L, 0, 1);  /* run loaded module */
-      lua_insert(L, -2);  /* put result below previous name */
-      lua_setglobal(L, "_REQUIREDNAME");  /* reset to previous name */
-      if (lua_isnil(L, -1)) {  /* no/nil return? */
-        lua_pushboolean(L, 1);
-        lua_replace(L, -2);  /* replace to true */
-      }
-      lua_pushvalue(L, 1);
-      lua_pushvalue(L, -2);
-      lua_rawset(L, 2);  /* mark it as loaded */
-      return 1;  /* return value */
-    }
-    case LUA_ERRFILE: {  /* file not found */
-      return luaL_error(L, "could not load package `%s' from path `%s'",
-                            lua_tostring(L, 1), getpath(L));
-    }
-    default: {
-      return luaL_error(L, "error loading package `%s' (%s)",
-                           lua_tostring(L, 1), lua_tostring(L, -1));
-    }
-  }
 }
 /* }====================================================== */
   {"getfenv", luaB_getfenv},
   {"setfenv", luaB_setfenv},
   {"next", luaB_next},
-  {"ipairs", luaB_ipairs},
-  {"pairs", luaB_pairs},
   {"print", luaB_print},
   {"tonumber", luaB_tonumber},
   {"tostring", luaB_tostring},
   {"type", luaB_type},
   {"assert", luaB_assert},
   {"unpack", luaB_unpack},
+  {"select", luaB_select},
   {"rawequal", luaB_rawequal},
   {"rawget", luaB_rawget},
   {"rawset", luaB_rawset},
   {"dofile", luaB_dofile},
   {"loadstring", luaB_loadstring},
   {"load", luaB_load},
-  {"require", luaB_require},
   {NULL, NULL}
 };
 /* }====================================================== */
+static void auxopen (lua_State *L, const char *name,
+                     lua_CFunction f, lua_CFunction u) {
+  lua_pushcfunction(L, u);
+  lua_pushcclosure(L, f, 1);
+  lua_setfield(L, -2, name);
+}
 static void base_open (lua_State *L) {
+  const char *path;
   lua_pushvalue(L, LUA_GLOBALSINDEX);
   luaL_openlib(L, NULL, base_funcs, 0);  /* open lib into global table */
   lua_pushliteral(L, LUA_VERSION);
-  lua_setfield(L, -2, "_VERSION");  /* set global _VERSION */
+  lua_setfield(L, LUA_GLOBALSINDEX, "_VERSION");  /* set global _VERSION */
+  /* `ipairs' and `pairs' need auxliliary functions as upvalues */
+  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
+  auxopen(L, "pairs", luaB_pairs, luaB_next);
   /* `newproxy' needs a weaktable as upvalue */
   lua_newtable(L);  /* new table `w' */
   lua_pushvalue(L, -1);  /* `w' will be its own metatable */
   lua_pushliteral(L, "kv");
   lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
   lua_pushcclosure(L, luaB_newproxy, 1);
-  lua_setfield(L, -2, "newproxy");  /* set global `newproxy' */
+  lua_setfield(L, LUA_GLOBALSINDEX, "newproxy");  /* set global `newproxy' */
-  lua_setfield(L, -1, "_G");  /* set global _G */
+  /* `require' needs a table to keep loaded chunks */
+  lua_newtable(L);
+  lua_pushvalue(L, -1);
+  lua_setglobal(L, "_LOADED");
+  lua_pushcclosure(L, luaB_require, 1);
+  lua_setfield(L, LUA_GLOBALSINDEX, "require");
+  /* set global _G */
+  lua_pushvalue(L, LUA_GLOBALSINDEX);
+  lua_setfield(L, LUA_GLOBALSINDEX, "_G");
+  /* set global _PATH */
+  path = getenv(LUA_PATH);
+  if (path == NULL) path = LUA_PATH_DEFAULT;
+  lua_pushstring(L, path);
+  lua_setfield(L, LUA_GLOBALSINDEX, "_PATH");
 }
 LUALIB_API int luaopen_base (lua_State *L) {
   base_open(L);
   luaL_openlib(L, LUA_COLIBNAME, co_funcs, 0);
-  lua_newtable(L);
-  lua_setglobal(L, REQTAB);
   return 2;
 }

src/lib/ldblib.c+16−17

 /*
-** $Id: ldblib.c,v 1.84 2003/11/05 11:59:14 roberto Exp $
+** $Id: ldblib.c,v 1.87 2004/08/13 18:02:36 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define ldblib_c
+#define LUA_LIB
 #include "lua.h"
     if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
         strcmp(buffer, "cont\n") == 0)
       return 0;
-    lua_dostring(L, buffer);
+    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=debug command") ||
+        lua_pcall(L, 0, 0, 0)) {
+      fputs(lua_tostring(L, -1), stderr);
+      fputs("\n", stderr);
+    }
     lua_settop(L, 0);  /* remove eventual returns */
   }
 }
     lua_pushfstring(L, "%s:", ar.short_src);
     if (ar.currentline > 0)
       lua_pushfstring(L, "%d:", ar.currentline);
-    switch (*ar.namewhat) {
+    if (*ar.namewhat != '\0')  /* is there a name? */
-      case 'g':  /* global */
-      case 'l':  /* local */
-      case 'f':  /* field */
-      case 'm':  /* method */
         lua_pushfstring(L, " in function `%s'", ar.name);
-        break;
+    else {
-      default: {
+      if (*ar.what == 'm')  /* main? */
-        if (*ar.what == 'm')  /* main? */
+        lua_pushfstring(L, " in main chunk");
-          lua_pushfstring(L, " in main chunk");
+      else if (*ar.what == 'C' || *ar.what == 't')
-        else if (*ar.what == 'C' || *ar.what == 't')
+        lua_pushliteral(L, " ?");  /* C function or tail call */
-          lua_pushliteral(L, " ?");  /* C function or tail call */
+      else
-        else
+        lua_pushfstring(L, " in function <%s:%d>",
-          lua_pushfstring(L, " in function <%s:%d>",
+                           ar.short_src, ar.linedefined);
-                             ar.short_src, ar.linedefined);
-      }
     }
     lua_concat(L, lua_gettop(L) - arg);
   }

src/lib/linit.c+38−0

@@ -0,0 +1,38 @@
	1	/*
	2	** $Id: linit.c,v 1.8 2004/07/09 15:47:48 roberto Exp $
	3	** Initialization of libraries for lua.c
	4	** See Copyright Notice in lua.h
	5	*/
	6
	7
	8	#define linit_c
	9	#define LUA_LIB
	10
	11	#include "lua.h"
	12
	13	#include "lualib.h"
	14	#include "lauxlib.h"
	15
	16
	17	static const luaL_reg lualibs[] = {
	18	{"", luaopen_base},
	19	{LUA_TABLIBNAME, luaopen_table},
	20	{LUA_IOLIBNAME, luaopen_io},
	21	{LUA_OSLIBNAME, luaopen_os},
	22	{LUA_STRLIBNAME, luaopen_string},
	23	{LUA_MATHLIBNAME, luaopen_math},
	24	{LUA_DBLIBNAME, luaopen_debug},
	25	{"", luaopen_loadlib},
	26	{NULL, NULL}
	27	};
	28
	29
	30	LUALIB_API int luaopen_stdlibs (lua_State *L) {
	31	const luaL_reg *lib = lualibs;
	32	for (; lib->func; lib++) {
	33	lib->func(L); /* open library */
	34	lua_settop(L, 0); /* discard any results */
	35	}
	36	return 0;
	37	}
	38

src/lib/liolib.c+69−309

@@ -1,18 +1,17 @@
1	/*	1	/*
2	** $Id: liolib.c,v 2.49 2003/10/10 13:29:28 roberto Exp $	2	** $Id: liolib.c,v 2.57 2004/08/13 19:52:13 roberto Exp $
3	** Standard I/O (and system) library	3	** Standard I/O (and system) library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
6		6
7		7
8	#include <errno.h>	8	#include <errno.h>
9	#include <locale.h>
10	#include <stdio.h>	9	#include <stdio.h>
11	#include <stdlib.h>	10	#include <stdlib.h>
12	#include <string.h>	11	#include <string.h>
13	#include <time.h>
14		12
15	#define liolib_c	13	#define liolib_c
		14	#define LUA_LIB
16		15
17	#include "lua.h"	16	#include "lua.h"
18		17
@@ -21,50 +20,13 @@ · 2 unmodified lines
21		20
22		21
23		22
24	/*
25	** by default, gcc does not get `tmpname'
26	*/
27	#ifndef USE_TMPNAME
28	#ifdef __GNUC__
29	#define USE_TMPNAME 0
30	#else
31	#define USE_TMPNAME 1
32	#endif
33	#endif
34
35
36	/*
37	** by default, posix systems get `popen'
38	*/
39	#ifndef USE_POPEN
40	#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 2
41	#define USE_POPEN 1
42	#else
43	#define USE_POPEN 0
44	#endif
45	#endif
46
47
48
49
50	/*
51	** {======================================================
52	** FILE Operations
53	** =======================================================
54	*/
55
56
57	#if !USE_POPEN
58	#define pclose(f) (-1)
59	#endif
60
61
62	#define FILEHANDLE "FILE*"
63
64	#define IO_INPUT 1	23	#define IO_INPUT 1
65	#define IO_OUTPUT 2	24	#define IO_OUTPUT 2
66		25
67		26
		27	static const char *const fnames[] = {"input", "output"};
		28
		29
68	static int pushresult (lua_State L, int i, const char filename) {	30	static int pushresult (lua_State L, int i, const char filename) {
69	if (i) {	31	if (i) {
70	lua_pushboolean(L, 1);	32	lua_pushboolean(L, 1);
@@ -82,15 +44,21 @@ static int pushresult (lua_State L, int i, const char filename) { · 11 unmodified lines
82	}	44	}
83		45
84		46
85	static FILE *topfile (lua_State L, int findex) {	47	static void fileerror (lua_State L, int arg, const char filename) {
86	FILE f = (FILE )luaL_checkudata(L, findex, FILEHANDLE);	48	lua_pushfstring(L, "%s: %s", filename, strerror(errno));
87	if (f == NULL) luaL_argerror(L, findex, "bad file");	49	luaL_argerror(L, arg, lua_tostring(L, -1));
		50	}
		51
		52
		53	static FILE *topfile (lua_State L) {
		54	FILE f = (FILE )luaL_checkudata(L, 1, LUA_FILEHANDLE);
		55	if (f == NULL) luaL_argerror(L, 1, "bad file");
88	return f;	56	return f;
89	}	57	}
90		58
91		59
92	static int io_type (lua_State *L) {	60	static int io_type (lua_State *L) {
93	FILE f = (FILE )luaL_checkudata(L, 1, FILEHANDLE);	61	FILE f = (FILE )luaL_checkudata(L, 1, LUA_FILEHANDLE);
94	if (f == NULL) lua_pushnil(L);	62	if (f == NULL) lua_pushnil(L);
95	else if (*f == NULL)	63	else if (*f == NULL)
96	lua_pushliteral(L, "closed file");	64	lua_pushliteral(L, "closed file");
@@ -100,8 +68,8 @@ static int io_type (lua_State *L) { · 3 unmodified lines
100	}	68	}
101		69
102		70
103	static FILE tofile (lua_State L, int findex) {	71	static FILE tofile (lua_State L) {
104	FILE **f = topfile(L, findex);	72	FILE **f = topfile(L);
105	if (*f == NULL)	73	if (*f == NULL)
106	luaL_error(L, "attempt to use a closed file");	74	luaL_error(L, "attempt to use a closed file");
107	return *f;	75	return *f;
@@ -117,18 +85,18 @@ static FILE tofile (lua_State L, int findex) { · 9 unmodified lines
117	static FILE *newfile (lua_State L) {	85	static FILE *newfile (lua_State L) {
118	FILE pf = (FILE )lua_newuserdata(L, sizeof(FILE *));	86	FILE pf = (FILE )lua_newuserdata(L, sizeof(FILE *));
119	pf = NULL; / file handle is currently `closed' */	87	pf = NULL; / file handle is currently `closed' */
120	luaL_getmetatable(L, FILEHANDLE);	88	luaL_getmetatable(L, LUA_FILEHANDLE);
121	lua_setmetatable(L, -2);	89	lua_setmetatable(L, -2);
122	return pf;	90	return pf;
123	}	91	}
124		92
125		93
126	static int aux_close (lua_State *L) {	94	static int aux_close (lua_State *L) {
127	FILE *f = tofile(L, 1);	95	FILE *f = tofile(L);
128	if (f == stdin \|\| f == stdout \|\| f == stderr)	96	if (f == stdin \|\| f == stdout \|\| f == stderr)
129	return 0; /* file cannot be closed */	97	return 0; /* file cannot be closed */
130	else {	98	else {
131	int ok = (pclose(f) != -1) \|\| (fclose(f) == 0);	99	int ok = (fclose(f) == 0);
132	if (ok)	100	if (ok)
133	(FILE )lua_touserdata(L, 1) = NULL; / mark file as closed */	101	(FILE )lua_touserdata(L, 1) = NULL; / mark file as closed */
134	return ok;	102	return ok;
@@ -144,7 +112,7 @@ static int io_close (lua_State *L) { · 9 unmodified lines
144		112
145		113
146	static int io_gc (lua_State *L) {	114	static int io_gc (lua_State *L) {
147	FILE **f = topfile(L, 1);	115	FILE **f = topfile(L);
148	if (f != NULL) / ignore closed files */	116	if (f != NULL) / ignore closed files */
149	aux_close(L);	117	aux_close(L);
150	return 0;	118	return 0;
@@ -152,13 +120,11 @@ static int io_gc (lua_State *L) { · 1 unmodified line
152		120
153		121
154	static int io_tostring (lua_State *L) {	122	static int io_tostring (lua_State *L) {
155	char buff[4sizeof(void ) + 2]; /* enough space for a `%p' */	123	FILE f = topfile(L);
156	FILE **f = topfile(L, 1);	124	if (f == NULL)
157	if (*f == NULL)	125	lua_pushstring(L, "file (closed)");
158	strcpy(buff, "closed");
159	else	126	else
160	sprintf(buff, "%p", lua_touserdata(L, 1));	127	lua_pushfstring(L, "file (%p)", f);
161	lua_pushfstring(L, "file (%s)", buff);
162	return 1;	128	return 1;
163	}	129	}
164		130
@@ -172,20 +138,6 @@ static int io_open (lua_State *L) { · 7 unmodified lines
172	}	138	}
173		139
174		140
175	static int io_popen (lua_State *L) {
176	#if !USE_POPEN
177	luaL_error(L, "`popen' not supported");
178	return 0;
179	#else
180	const char *filename = luaL_checkstring(L, 1);
181	const char *mode = luaL_optstring(L, 2, "r");
182	FILE **pf = newfile(L);
183	*pf = popen(filename, mode);
184	return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
185	#endif
186	}
187
188
189	static int io_tmpfile (lua_State *L) {	141	static int io_tmpfile (lua_State *L) {
190	FILE **pf = newfile(L);	142	FILE **pf = newfile(L);
191	*pf = tmpfile();	143	*pf = tmpfile();
@@ -193,9 +145,14 @@ static int io_tmpfile (lua_State *L) { · 1 unmodified line
193	}	145	}
194		146
195		147
196	static FILE getiofile (lua_State L, int f) {	148	static FILE getiofile (lua_State L, int findex) {
197	lua_rawgeti(L, lua_upvalueindex(1), f);	149	FILE *f;
198	return tofile(L, -1);	150	lua_rawgeti(L, lua_upvalueindex(1), findex);
		151	lua_assert(luaL_checkudata(L, -1, LUA_FILEHANDLE));
		152	f = (FILE *)lua_touserdata(L, -1);
		153	if (f == NULL)
		154	luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
		155	return f;
199	}	156	}
200		157
201		158
@@ -205,15 +162,14 @@ static int g_iofile (lua_State L, int f, const char mode) { · 3 unmodified lines
205	if (filename) {	162	if (filename) {
206	FILE **pf = newfile(L);	163	FILE **pf = newfile(L);
207	*pf = fopen(filename, mode);	164	*pf = fopen(filename, mode);
208	if (*pf == NULL) {	165	if (*pf == NULL)
209	lua_pushfstring(L, "%s: %s", filename, strerror(errno));	166	fileerror(L, 1, filename);
210	luaL_argerror(L, 1, lua_tostring(L, -1));
211	}
212	}	167	}
213	else {	168	else {
214	tofile(L, 1); /* check that it's a valid file handle */	169	tofile(L); /* check that it's a valid file handle */
215	lua_pushvalue(L, 1);	170	lua_pushvalue(L, 1);
216	}	171	}
		172	lua_assert(luaL_checkudata(L, -1, LUA_FILEHANDLE));
217	lua_rawseti(L, lua_upvalueindex(1), f);	173	lua_rawseti(L, lua_upvalueindex(1), f);
218	}	174	}
219	/* return current value */	175	/* return current value */
@@ -236,7 +192,7 @@ static int io_readline (lua_State *L); · 16 unmodified lines
236		192
237		193
238	static void aux_lines (lua_State *L, int idx, int close) {	194	static void aux_lines (lua_State *L, int idx, int close) {
239	lua_getfield(L, LUA_REGISTRYINDEX, FILEHANDLE);	195	lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
240	lua_pushvalue(L, idx);	196	lua_pushvalue(L, idx);
241	lua_pushboolean(L, close); /* close/not close file when finished */	197	lua_pushboolean(L, close); /* close/not close file when finished */
242	lua_pushcclosure(L, io_readline, 3);	198	lua_pushcclosure(L, io_readline, 3);
@@ -244,7 +200,7 @@ static void aux_lines (lua_State *L, int idx, int close) { · 1 unmodified line
244		200
245		201
246	static int f_lines (lua_State *L) {	202	static int f_lines (lua_State *L) {
247	tofile(L, 1); /* check that it's a valid file handle */	203	tofile(L); /* check that it's a valid file handle */
248	aux_lines(L, 1, 0);	204	aux_lines(L, 1, 0);
249	return 1;	205	return 1;
250	}	206	}
@@ -260,7 +216,8 @@ static int io_lines (lua_State *L) { · 9 unmodified lines
260	const char *filename = luaL_checkstring(L, 1);	216	const char *filename = luaL_checkstring(L, 1);
261	FILE **pf = newfile(L);	217	FILE **pf = newfile(L);
262	*pf = fopen(filename, "r");	218	*pf = fopen(filename, "r");
263	luaL_argcheck(L, *pf, 1, strerror(errno));	219	if (*pf == NULL)
		220	fileerror(L, 1, filename);
264	aux_lines(L, lua_gettop(L), 1);	221	aux_lines(L, lua_gettop(L), 1);
265	return 1;	222	return 1;
266	}	223	}
@@ -336,6 +293,7 @@ static int g_read (lua_State L, FILE f, int first) { · 69 unmodified lines
336	int nargs = lua_gettop(L) - 1;	293	int nargs = lua_gettop(L) - 1;
337	int success;	294	int success;
338	int n;	295	int n;
		296	clearerr(f);
339	if (nargs == 0) { /* no arguments? */	297	if (nargs == 0) { /* no arguments? */
340	success = read_line(L, f);	298	success = read_line(L, f);
341	n = first+1; /* to return 1 result */	299	n = first+1; /* to return 1 result */
@@ -370,6 +328,8 @@ static int g_read (lua_State L, FILE f, int first) { · 28 unmodified lines
370	}	328	}
371	}	329	}
372	}	330	}
		331	if (ferror(f))
		332	return pushresult(L, 0, NULL);
373	if (!success) {	333	if (!success) {
374	lua_pop(L, 1); /* remove last result */	334	lua_pop(L, 1); /* remove last result */
375	lua_pushnil(L); /* push nil instead */	335	lua_pushnil(L); /* push nil instead */
@@ -384,15 +344,19 @@ static int io_read (lua_State *L) { · 8 unmodified lines
384		344
385		345
386	static int f_read (lua_State *L) {	346	static int f_read (lua_State *L) {
387	return g_read(L, tofile(L, 1), 2);	347	return g_read(L, tofile(L), 2);
388	}	348	}
389		349
390		350
391	static int io_readline (lua_State *L) {	351	static int io_readline (lua_State *L) {
392	FILE f = (FILE **)lua_touserdata(L, lua_upvalueindex(2));	352	FILE f = (FILE **)lua_touserdata(L, lua_upvalueindex(2));
		353	int sucess;
393	if (f == NULL) /* file is already closed? */	354	if (f == NULL) /* file is already closed? */
394	luaL_error(L, "file is already closed");	355	luaL_error(L, "file is already closed");
395	if (read_line(L, f)) return 1;	356	sucess = read_line(L, f);
		357	if (ferror(f))
		358	luaL_error(L, "%s", strerror(errno));
		359	if (sucess) return 1;
396	else { /* EOF */	360	else { /* EOF */
397	if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */	361	if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */
398	lua_settop(L, 0);	362	lua_settop(L, 0);
@@ -431,14 +395,14 @@ static int io_write (lua_State *L) { · 32 unmodified lines
431		395
432		396
433	static int f_write (lua_State *L) {	397	static int f_write (lua_State *L) {
434	return g_write(L, tofile(L, 1), 2);	398	return g_write(L, tofile(L), 2);
435	}	399	}
436		400
437		401
438	static int f_seek (lua_State *L) {	402	static int f_seek (lua_State *L) {
439	static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};	403	static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
440	static const char *const modenames[] = {"set", "cur", "end", NULL};	404	static const char *const modenames[] = {"set", "cur", "end", NULL};
441	FILE *f = tofile(L, 1);	405	FILE *f = tofile(L);
442	int op = luaL_findstring(luaL_optstring(L, 2, "cur"), modenames);	406	int op = luaL_findstring(luaL_optstring(L, 2, "cur"), modenames);
443	lua_Integer offset = luaL_optinteger(L, 3, 0);	407	lua_Integer offset = luaL_optinteger(L, 3, 0);
444	luaL_argcheck(L, op != -1, 2, "invalid mode");	408	luaL_argcheck(L, op != -1, 2, "invalid mode");
@@ -455,7 +419,7 @@ static int f_seek (lua_State *L) { · 10 unmodified lines
455	static int f_setvbuf (lua_State *L) {	419	static int f_setvbuf (lua_State *L) {
456	static const int mode[] = {_IONBF, _IOFBF, _IOLBF};	420	static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
457	static const char *const modenames[] = {"no", "full", "line", NULL};	421	static const char *const modenames[] = {"no", "full", "line", NULL};
458	FILE *f = tofile(L, 1);	422	FILE *f = tofile(L);
459	int op = luaL_findstring(luaL_checkstring(L, 2), modenames);	423	int op = luaL_findstring(luaL_checkstring(L, 2), modenames);
460	luaL_argcheck(L, op != -1, 2, "invalid mode");	424	luaL_argcheck(L, op != -1, 2, "invalid mode");
461	return pushresult(L, setvbuf(f, NULL, mode[op], 0) == 0, NULL);	425	return pushresult(L, setvbuf(f, NULL, mode[op], 0) == 0, NULL);
@@ -469,7 +433,7 @@ static int io_flush (lua_State *L) { · 7 unmodified lines
469		433
470		434
471	static int f_flush (lua_State *L) {	435	static int f_flush (lua_State *L) {
472	return pushresult(L, fflush(tofile(L, 1)) == 0, NULL);	436	return pushresult(L, fflush(tofile(L)) == 0, NULL);
473	}	437	}
474		438
475		439
@@ -480,7 +444,6 @@ static const luaL_reg iolib[] = { · 4 unmodified lines
480	{"close", io_close},	444	{"close", io_close},
481	{"flush", io_flush},	445	{"flush", io_flush},
482	{"open", io_open},	446	{"open", io_open},
483	{"popen", io_popen},
484	{"read", io_read},	447	{"read", io_read},
485	{"tmpfile", io_tmpfile},	448	{"tmpfile", io_tmpfile},
486	{"type", io_type},	449	{"type", io_type},
@@ -504,239 +467,36 @@ static const luaL_reg flib[] = { · 17 unmodified lines
504		467
505		468
506	static void createmeta (lua_State *L) {	469	static void createmeta (lua_State *L) {
507	luaL_newmetatable(L, FILEHANDLE); /* create new metatable for file handles */	470	luaL_newmetatable(L, LUA_FILEHANDLE); /* create metatable for file handles */
508	/* create (and set) default files */
509	*newfile(L) = stdin;
510	lua_rawseti(L, -2, IO_INPUT);
511	*newfile(L) = stdout;
512	lua_rawseti(L, -2, IO_OUTPUT);
513	/* file methods */
514	lua_pushvalue(L, -1); /* push metatable */	471	lua_pushvalue(L, -1); /* push metatable */
515	lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */	472	lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */
516	luaL_openlib(L, NULL, flib, 0);	473	luaL_openlib(L, NULL, flib, 0); /* file methods */
517	}
518
519	/* }====================================================== */
520
521
522	/*
523	** {======================================================
524	** Other O.S. Operations
525	** =======================================================
526	*/
527
528	static int io_execute (lua_State *L) {
529	lua_pushinteger(L, system(luaL_checkstring(L, 1)));
530	return 1;
531	}
532
533
534	static int io_remove (lua_State *L) {
535	const char *filename = luaL_checkstring(L, 1);
536	return pushresult(L, remove(filename) == 0, filename);
537	}
538
539
540	static int io_rename (lua_State *L) {
541	const char *fromname = luaL_checkstring(L, 1);
542	const char *toname = luaL_checkstring(L, 2);
543	return pushresult(L, rename(fromname, toname) == 0, fromname);
544	}
545
546
547	static int io_tmpname (lua_State *L) {
548	#if !USE_TMPNAME
549	luaL_error(L, "`tmpname' not supported");
550	return 0;
551	#else
552	char buff[L_tmpnam];
553	if (tmpnam(buff) != buff)
554	return luaL_error(L, "unable to generate a unique filename in `tmpname'");
555	lua_pushstring(L, buff);
556	return 1;
557	#endif
558	}	474	}
559		475
560		476
561	static int io_getenv (lua_State *L) {	477	static void createupval (lua_State *L) {
562	lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */	478	lua_newtable(L);
563	return 1;	479	/* create (and set) default files */
564	}	480	*newfile(L) = stdin;
565		481	lua_rawseti(L, -2, IO_INPUT);
566		482	*newfile(L) = stdout;
567	static int io_clock (lua_State *L) {	483	lua_rawseti(L, -2, IO_OUTPUT);
568	lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
569	return 1;
570	}
571
572
573	/*
574	** {======================================================
575	** Time/Date operations
576	** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
577	** wday=%w+1, yday=%j, isdst=? }
578	** =======================================================
579	*/
580
581	static void setfield (lua_State L, const char key, int value) {
582	lua_pushstring(L, key);
583	lua_pushinteger(L, value);
584	lua_rawset(L, -3);
585	}
586
587	static void setboolfield (lua_State L, const char key, int value) {
588	lua_pushstring(L, key);
589	lua_pushboolean(L, value);
590	lua_rawset(L, -3);
591	}
592
593	static int getboolfield (lua_State L, const char key) {
594	int res;
595	lua_getfield(L, -1, key);
596	res = lua_toboolean(L, -1);
597	lua_pop(L, 1);
598	return res;
599	}
600
601
602	static int getfield (lua_State L, const char key, int d) {
603	int res;
604	lua_getfield(L, -1, key);
605	if (lua_isnumber(L, -1))
606	res = (int)lua_tointeger(L, -1);
607	else {
608	if (d < 0)
609	return luaL_error(L, "field `%s' missing in date table", key);
610	res = d;
611	}
612	lua_pop(L, 1);
613	return res;
614	}
615
616
617	static int io_date (lua_State *L) {
618	const char *s = luaL_optstring(L, 1, "%c");
619	lua_Number n = luaL_optnumber(L, 2, -1);
620	time_t t = (n == -1) ? time(NULL) : (time_t)n;
621	struct tm *stm;
622	if (s == '!') { / UTC? */
623	stm = gmtime(&t);
624	s++; /* skip `!' */
625	}
626	else
627	stm = localtime(&t);
628	if (stm == NULL) /* invalid date? */
629	lua_pushnil(L);
630	else if (strcmp(s, "*t") == 0) {
631	lua_createtable(L, 0, 9); /* 9 = number of fields */
632	setfield(L, "sec", stm->tm_sec);
633	setfield(L, "min", stm->tm_min);
634	setfield(L, "hour", stm->tm_hour);
635	setfield(L, "day", stm->tm_mday);
636	setfield(L, "month", stm->tm_mon+1);
637	setfield(L, "year", stm->tm_year+1900);
638	setfield(L, "wday", stm->tm_wday+1);
639	setfield(L, "yday", stm->tm_yday+1);
640	setboolfield(L, "isdst", stm->tm_isdst);
641	}
642	else {
643	char b[256];
644	if (strftime(b, sizeof(b), s, stm))
645	lua_pushstring(L, b);
646	else
647	return luaL_error(L, "`date' format too long");
648	}
649	return 1;
650	}
651
652
653	static int io_time (lua_State *L) {
654	if (lua_isnoneornil(L, 1)) /* called without args? */
655	lua_pushnumber(L, time(NULL)); /* return current time */
656	else {
657	time_t t;
658	struct tm ts;
659	luaL_checktype(L, 1, LUA_TTABLE);
660	lua_settop(L, 1); /* make sure table is at the top */
661	ts.tm_sec = getfield(L, "sec", 0);
662	ts.tm_min = getfield(L, "min", 0);
663	ts.tm_hour = getfield(L, "hour", 12);
664	ts.tm_mday = getfield(L, "day", -1);
665	ts.tm_mon = getfield(L, "month", -1) - 1;
666	ts.tm_year = getfield(L, "year", -1) - 1900;
667	ts.tm_isdst = getboolfield(L, "isdst");
668	t = mktime(&ts);
669	if (t == (time_t)(-1))
670	lua_pushnil(L);
671	else
672	lua_pushnumber(L, t);
673	}
674	return 1;
675	}
676
677
678	static int io_difftime (lua_State *L) {
679	lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
680	(time_t)(luaL_optnumber(L, 2, 0))));
681	return 1;
682	}
683
684	/* }====================================================== */
685
686
687	static int io_setloc (lua_State *L) {
688	static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
689	LC_NUMERIC, LC_TIME};
690	static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
691	"numeric", "time", NULL};
692	const char *l = lua_tostring(L, 1);
693	int op = luaL_findstring(luaL_optstring(L, 2, "all"), catnames);
694	luaL_argcheck(L, l \|\| lua_isnoneornil(L, 1), 1, "string expected");
695	luaL_argcheck(L, op != -1, 2, "invalid option");
696	lua_pushstring(L, setlocale(cat[op], l));
697	return 1;
698	}
699
700
701	static int io_exit (lua_State *L) {
702	exit(luaL_optint(L, 1, EXIT_SUCCESS));
703	return 0; /* to avoid warnings */
704	}	484	}
705		485
706	static const luaL_reg syslib[] = {
707	{"clock", io_clock},
708	{"date", io_date},
709	{"difftime", io_difftime},
710	{"execute", io_execute},
711	{"exit", io_exit},
712	{"getenv", io_getenv},
713	{"remove", io_remove},
714	{"rename", io_rename},
715	{"setlocale", io_setloc},
716	{"time", io_time},
717	{"tmpname", io_tmpname},
718	{NULL, NULL}
719	};
720
721	/* }====================================================== */
722
723		486
724		487
725	LUALIB_API int luaopen_io (lua_State *L) {	488	LUALIB_API int luaopen_io (lua_State *L) {
726	luaL_openlib(L, LUA_OSLIBNAME, syslib, 0);
727	createmeta(L);	489	createmeta(L);
		490	createupval(L);
728	lua_pushvalue(L, -1);	491	lua_pushvalue(L, -1);
729	luaL_openlib(L, LUA_IOLIBNAME, iolib, 1);	492	luaL_openlib(L, LUA_IOLIBNAME, iolib, 1);
730	/* put predefined file handles into `io' table */	493	/* put predefined file handles into `io' table */
731	lua_pushliteral(L, "stdin");	494	lua_rawgeti(L, -2, IO_INPUT); /* get current input from metatable */
732	lua_rawgeti(L, 2, IO_INPUT);	495	lua_setfield(L, -2, "stdin"); /* io.stdin = metatable[IO_INPUT] */
733	lua_rawset(L, 3);	496	lua_rawgeti(L, -2, IO_OUTPUT); /* get current output from metatable */
734	lua_pushliteral(L, "stdout");	497	lua_setfield(L, -2, "stdout"); /* io.stdout = metatable[IO_OUTPUT] */
735	lua_rawgeti(L, 2, IO_OUTPUT);
736	lua_rawset(L, 3);
737	lua_pushliteral(L, "stderr");
738	*newfile(L) = stderr;	498	*newfile(L) = stderr;
739	lua_rawset(L, 3);	499	lua_setfield(L, -2, "stderr"); /* io.stderr = newfile(stderr) */
740	return 1;	500	return 1;
741	}	501	}
742		502

src/lib/lmathlib.c+9−21

 /*
-** $Id: lmathlib.c,v 1.59 2003/11/05 11:59:14 roberto Exp $
+** $Id: lmathlib.c,v 1.61 2004/05/10 18:11:32 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 #include <math.h>
 #define lmathlib_c
+#define LUA_LIB
 #include "lua.h"
-/*
-** If you want Lua to operate in degrees (instead of radians),
-** define USE_DEGREES
-*/
-#ifdef USE_DEGREES
-#define FROMRAD(a)	((a)/RADIANS_PER_DEGREE)
-#define TORAD(a)	((a)*RADIANS_PER_DEGREE)
-#else
-#define FROMRAD(a)	(a)
-#define TORAD(a)	(a)
-#endif
 static int math_abs (lua_State *L) {
   lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_sin (lua_State *L) {
-  lua_pushnumber(L, sin(TORAD(luaL_checknumber(L, 1))));
+  lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_cos (lua_State *L) {
-  lua_pushnumber(L, cos(TORAD(luaL_checknumber(L, 1))));
+  lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_tan (lua_State *L) {
-  lua_pushnumber(L, tan(TORAD(luaL_checknumber(L, 1))));
+  lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_asin (lua_State *L) {
-  lua_pushnumber(L, FROMRAD(asin(luaL_checknumber(L, 1))));
+  lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_acos (lua_State *L) {
-  lua_pushnumber(L, FROMRAD(acos(luaL_checknumber(L, 1))));
+  lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_atan (lua_State *L) {
-  lua_pushnumber(L, FROMRAD(atan(luaL_checknumber(L, 1))));
+  lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_atan2 (lua_State *L) {
-  lua_pushnumber(L, FROMRAD(atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2))));
+  lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
   return 1;
 }

src/lib/loadlib.c+4−1

 /*
-** $Id: loadlib.c,v 1.5 2003/05/14 21:01:53 roberto Exp $
+** $Id: loadlib.c,v 1.6 2004/04/30 20:13:38 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 *
 *
 */
+#define loadlib_c
+#define LUA_LIB
 #include "lua.h"
 #include "lauxlib.h"
 #include "lualib.h"

src/lib/loslib.c+241−0

@@ -0,0 +1,241 @@
	1	/*
	2	** $Id: loslib.c,v 1.2 2004/08/05 19:30:37 roberto Exp $
	3	** Standard Operating System library
	4	** See Copyright Notice in lua.h
	5	*/
	6
	7
	8	#include <errno.h>
	9	#include <locale.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#include <time.h>
	13
	14	#define loslib_c
	15	#define LUA_LIB
	16
	17	#include "lua.h"
	18
	19	#include "lauxlib.h"
	20	#include "lualib.h"
	21
	22
	23	static int pushresult (lua_State L, int i, const char filename) {
	24	if (i) {
	25	lua_pushboolean(L, 1);
	26	return 1;
	27	}
	28	else {
	29	lua_pushnil(L);
	30	if (filename)
	31	lua_pushfstring(L, "%s: %s", filename, strerror(errno));
	32	else
	33	lua_pushfstring(L, "%s", strerror(errno));
	34	lua_pushinteger(L, errno);
	35	return 3;
	36	}
	37	}
	38
	39
	40	static int io_execute (lua_State *L) {
	41	lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
	42	return 1;
	43	}
	44
	45
	46	static int io_remove (lua_State *L) {
	47	const char *filename = luaL_checkstring(L, 1);
	48	return pushresult(L, remove(filename) == 0, filename);
	49	}
	50
	51
	52	static int io_rename (lua_State *L) {
	53	const char *fromname = luaL_checkstring(L, 1);
	54	const char *toname = luaL_checkstring(L, 2);
	55	return pushresult(L, rename(fromname, toname) == 0, fromname);
	56	}
	57
	58
	59	static int io_tmpname (lua_State *L) {
	60	#if !USE_TMPNAME
	61	luaL_error(L, "`tmpname' not supported");
	62	return 0;
	63	#else
	64	char buff[L_tmpnam];
	65	if (tmpnam(buff) != buff)
	66	return luaL_error(L, "unable to generate a unique filename in `tmpname'");
	67	lua_pushstring(L, buff);
	68	return 1;
	69	#endif
	70	}
	71
	72
	73	static int io_getenv (lua_State *L) {
	74	lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */
	75	return 1;
	76	}
	77
	78
	79	static int io_clock (lua_State *L) {
	80	lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
	81	return 1;
	82	}
	83
	84
	85	/*
	86	** {======================================================
	87	** Time/Date operations
	88	** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
	89	** wday=%w+1, yday=%j, isdst=? }
	90	** =======================================================
	91	*/
	92
	93	static void setfield (lua_State L, const char key, int value) {
	94	lua_pushstring(L, key);
	95	lua_pushinteger(L, value);
	96	lua_rawset(L, -3);
	97	}
	98
	99	static void setboolfield (lua_State L, const char key, int value) {
	100	lua_pushstring(L, key);
	101	lua_pushboolean(L, value);
	102	lua_rawset(L, -3);
	103	}
	104
	105	static int getboolfield (lua_State L, const char key) {
	106	int res;
	107	lua_getfield(L, -1, key);
	108	res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
	109	lua_pop(L, 1);
	110	return res;
	111	}
	112
	113
	114	static int getfield (lua_State L, const char key, int d) {
	115	int res;
	116	lua_getfield(L, -1, key);
	117	if (lua_isnumber(L, -1))
	118	res = (int)lua_tointeger(L, -1);
	119	else {
	120	if (d < 0)
	121	return luaL_error(L, "field `%s' missing in date table", key);
	122	res = d;
	123	}
	124	lua_pop(L, 1);
	125	return res;
	126	}
	127
	128
	129	static int io_date (lua_State *L) {
	130	const char *s = luaL_optstring(L, 1, "%c");
	131	lua_Number n = luaL_optnumber(L, 2, -1);
	132	time_t t = (n == -1) ? time(NULL) : (time_t)n;
	133	struct tm *stm;
	134	if (s == '!') { / UTC? */
	135	stm = gmtime(&t);
	136	s++; /* skip `!' */
	137	}
	138	else
	139	stm = localtime(&t);
	140	if (stm == NULL) /* invalid date? */
	141	lua_pushnil(L);
	142	else if (strcmp(s, "*t") == 0) {
	143	lua_createtable(L, 0, 9); /* 9 = number of fields */
	144	setfield(L, "sec", stm->tm_sec);
	145	setfield(L, "min", stm->tm_min);
	146	setfield(L, "hour", stm->tm_hour);
	147	setfield(L, "day", stm->tm_mday);
	148	setfield(L, "month", stm->tm_mon+1);
	149	setfield(L, "year", stm->tm_year+1900);
	150	setfield(L, "wday", stm->tm_wday+1);
	151	setfield(L, "yday", stm->tm_yday+1);
	152	setboolfield(L, "isdst", stm->tm_isdst);
	153	}
	154	else {
	155	char b[256];
	156	if (strftime(b, sizeof(b), s, stm))
	157	lua_pushstring(L, b);
	158	else
	159	return luaL_error(L, "`date' format too long");
	160	}
	161	return 1;
	162	}
	163
	164
	165	static int io_time (lua_State *L) {
	166	time_t t;
	167	if (lua_isnoneornil(L, 1)) /* called without args? */
	168	t = time(NULL); /* get current time */
	169	else {
	170	struct tm ts;
	171	luaL_checktype(L, 1, LUA_TTABLE);
	172	lua_settop(L, 1); /* make sure table is at the top */
	173	ts.tm_sec = getfield(L, "sec", 0);
	174	ts.tm_min = getfield(L, "min", 0);
	175	ts.tm_hour = getfield(L, "hour", 12);
	176	ts.tm_mday = getfield(L, "day", -1);
	177	ts.tm_mon = getfield(L, "month", -1) - 1;
	178	ts.tm_year = getfield(L, "year", -1) - 1900;
	179	ts.tm_isdst = getboolfield(L, "isdst");
	180	t = mktime(&ts);
	181	}
	182	if (t == (time_t)(-1))
	183	lua_pushnil(L);
	184	else
	185	lua_pushnumber(L, t);
	186	return 1;
	187	}
	188
	189
	190	static int io_difftime (lua_State *L) {
	191	lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
	192	(time_t)(luaL_optnumber(L, 2, 0))));
	193	return 1;
	194	}
	195
	196	/* }====================================================== */
	197
	198
	199	static int io_setloc (lua_State *L) {
	200	static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
	201	LC_NUMERIC, LC_TIME};
	202	static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
	203	"numeric", "time", NULL};
	204	const char *l = lua_tostring(L, 1);
	205	int op = luaL_findstring(luaL_optstring(L, 2, "all"), catnames);
	206	luaL_argcheck(L, l \|\| lua_isnoneornil(L, 1), 1, "string expected");
	207	luaL_argcheck(L, op != -1, 2, "invalid option");
	208	lua_pushstring(L, setlocale(cat[op], l));
	209	return 1;
	210	}
	211
	212
	213	static int io_exit (lua_State *L) {
	214	exit(luaL_optint(L, 1, EXIT_SUCCESS));
	215	return 0; /* to avoid warnings */
	216	}
	217
	218	static const luaL_reg syslib[] = {
	219	{"clock", io_clock},
	220	{"date", io_date},
	221	{"difftime", io_difftime},
	222	{"execute", io_execute},
	223	{"exit", io_exit},
	224	{"getenv", io_getenv},
	225	{"remove", io_remove},
	226	{"rename", io_rename},
	227	{"setlocale", io_setloc},
	228	{"time", io_time},
	229	{"tmpname", io_tmpname},
	230	{NULL, NULL}
	231	};
	232
	233	/* }====================================================== */
	234
	235
	236
	237	LUALIB_API int luaopen_os (lua_State *L) {
	238	luaL_openlib(L, LUA_OSLIBNAME, syslib, 0);
	239	return 1;
	240	}
	241

src/lib/lstrlib.c+16−14

 /*
-** $Id: lstrlib.c,v 1.101 2004/01/02 11:54:14 roberto Exp $
+** $Id: lstrlib.c,v 1.106 2004/08/09 13:30:33 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lstrlib_c
+#define LUA_LIB
 #include "lua.h"
 /* macro to `unsign' a character */
-#ifndef uchar
 #define uchar(c)        ((unsigned char)(c))
-#endif
 typedef lua_Integer sint32;	/* a signed version for size_t */
 static int str_byte (lua_State *L) {
   size_t l;
   const char *s = luaL_checklstring(L, 1, &l);
-  sint32 pos = posrelat(luaL_optinteger(L, 2, 1), l);
+  sint32 posi = posrelat(luaL_optinteger(L, 2, 1), l);
-  if (pos <= 0 || (size_t)(pos) > l)  /* index out of range? */
+  sint32 pose = posrelat(luaL_optinteger(L, 3, posi), l);
-    return 0;  /* no answer */
+  int n, i;
-  lua_pushinteger(L, uchar(s[pos-1]));
+  if (posi <= 0) posi = 1;
-  return 1;
+  if ((size_t)pose > l) pose = l;
+  if (posi > pose) return 0;  /* empty interval; return no values */
+  n = pose -  posi + 1;
+  luaL_checkstack(L, n, "string slice too long");
+  for (i=0; i<n; i++)
+    lua_pushinteger(L, uchar(s[posi+i-1]));
+  return n;
 }
 static int writer (lua_State *L, const void* b, size_t size, void* B) {
   (void)L;
   luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
-  return 1;
+  return 0;
 }
 static int str_dump (lua_State *L) {
   luaL_Buffer b;
   luaL_checktype(L, 1, LUA_TFUNCTION);
+  lua_settop(L, 1);
   luaL_buffinit(L,&b);
-  if (!lua_dump(L, writer, &b))
+  if (lua_dump(L, writer, &b) != 0)
     luaL_error(L, "unable to dump given function");
   luaL_pushresult(&b);
   return 1;
 ** =======================================================
 */
-#ifndef MAX_CAPTURES
-#define MAX_CAPTURES 32  /* arbitrary limit */
-#endif
 #define CAP_UNFINISHED	(-1)
 #define CAP_POSITION	(-2)

src/lib/ltablib.c+25−22

 /*
-** $Id: ltablib.c,v 1.22 2003/10/07 20:13:41 roberto Exp $
+** $Id: ltablib.c,v 1.26 2004/06/15 13:37:21 roberto Exp $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
 #include <stddef.h>
 #define ltablib_c
+#define LUA_LIB
 #include "lua.h"
   int i;
   int n = aux_getn(L, 1);
   luaL_checktype(L, 2, LUA_TFUNCTION);
-  for (i=1; i<=n; i++) {
+  for (i=LUA_FIRSTINDEX; i < n+LUA_FIRSTINDEX; i++) {
     lua_pushvalue(L, 2);  /* function */
     lua_pushinteger(L, i);  /* 1st argument */
     lua_rawgeti(L, 1, i);  /* 2nd argument */
 static int luaB_setn (lua_State *L) {
   luaL_checktype(L, 1, LUA_TTABLE);
   luaL_setn(L, 1, luaL_checkint(L, 2));
-  return 0;
+  lua_pushvalue(L, 1);
+  return 1;
 }
 static int luaB_tinsert (lua_State *L) {
   int v = lua_gettop(L);  /* number of arguments */
-  int n = aux_getn(L, 1) + 1;
+  int e = aux_getn(L, 1) + LUA_FIRSTINDEX;  /* first empty element */
   int pos;  /* where to insert new element */
   if (v == 2)  /* called with only 2 arguments */
-    pos = n;  /* insert new element at the end */
+    pos = e;  /* insert new element at the end */
   else {
     pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
-    if (pos > n) n = pos;  /* `grow' array if necessary */
+    if (pos > e) e = pos;  /* `grow' array if necessary */
     v = 3;  /* function may be called with more than 3 args */
   }
-  luaL_setn(L, 1, n);  /* new size */
+  luaL_setn(L, 1, e - LUA_FIRSTINDEX + 1);  /* new size */
-  while (--n >= pos) {  /* move up elements */
+  while (--e >= pos) {  /* move up elements */
-    lua_rawgeti(L, 1, n);
+    lua_rawgeti(L, 1, e);
-    lua_rawseti(L, 1, n+1);  /* t[n+1] = t[n] */
+    lua_rawseti(L, 1, e+1);  /* t[e+1] = t[e] */
   }
   lua_pushvalue(L, v);
   lua_rawseti(L, 1, pos);  /* t[pos] = v */
 static int luaB_tremove (lua_State *L) {
-  int n = aux_getn(L, 1);
+  int e = aux_getn(L, 1) + LUA_FIRSTINDEX - 1;
-  int pos = luaL_optint(L, 2, n);
+  int pos = luaL_optint(L, 2, e);
-  if (n <= 0) return 0;  /* table is `empty' */
+  if (e < LUA_FIRSTINDEX) return 0;  /* table is `empty' */
-  luaL_setn(L, 1, n-1);  /* t.n = n-1 */
+  luaL_setn(L, 1, e - LUA_FIRSTINDEX);  /* t.n = n-1 */
   lua_rawgeti(L, 1, pos);  /* result = t[pos] */
-  for ( ;pos<n; pos++) {
+  for ( ;pos<e; pos++) {
     lua_rawgeti(L, 1, pos+1);
     lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
   }
   lua_pushnil(L);
-  lua_rawseti(L, 1, n);  /* t[n] = nil */
+  lua_rawseti(L, 1, e);  /* t[e] = nil */
   return 1;
 }
   luaL_Buffer b;
   size_t lsep;
   const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  int i = luaL_optint(L, 3, 1);
+  int i = luaL_optint(L, 3, LUA_FIRSTINDEX);
-  int n = luaL_optint(L, 4, 0);
+  int last = luaL_optint(L, 4, -2);
   luaL_checktype(L, 1, LUA_TTABLE);
-  if (n == 0) n = luaL_getn(L, 1);
+  if (last == -2)
+    last = luaL_getn(L, 1) + LUA_FIRSTINDEX - 1;
   luaL_buffinit(L, &b);
-  for (; i <= n; i++) {
+  for (; i <= last; i++) {
     lua_rawgeti(L, 1, i);
     luaL_argcheck(L, lua_isstring(L, -1), 1, "table contains non-strings");
     luaL_addvalue(&b);
-    if (i != n)
+    if (i != last)
       luaL_addlstring(&b, sep, lsep);
   }
   luaL_pushresult(&b);
   if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
     luaL_checktype(L, 2, LUA_TFUNCTION);
   lua_settop(L, 2);  /* make sure there is two arguments */
-  auxsort(L, 1, n);
+  auxsort(L, LUA_FIRSTINDEX, n + LUA_FIRSTINDEX - 1);
   return 0;
 }

src/llex.c+2−1

 /*
-** $Id: llex.c,v 2.2 2004/03/12 19:53:56 roberto Exp $
+** $Id: llex.c,v 2.3 2004/04/30 20:13:38 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define llex_c
+#define LUA_CORE
 #include "lua.h"

src/llimits.h+2−95

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llimits.h,v 1.57 2003/12/01 16:33:30 roberto Exp $	2	** $Id: llimits.h,v 1.59 2004/06/23 15:57:29 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	*/
@@ -15,48 +15,9 @@ · 9 unmodified lines
15	#include "lua.h"	15	#include "lua.h"
16		16
17		17
18	/*
19	** try to find number of bits in an integer
20	*/
21	#ifndef BITS_INT
22	/* avoid overflows in comparison */
23	#if INT_MAX-20 < 32760
24	#define BITS_INT 16
25	#elif INT_MAX > 2147483640L
26	/* machine has at least 32 bits */
27	#define BITS_INT 32
28	#else
29	#error "you must define BITS_INT with number of bits in an integer"
30	#endif
31	#endif
32
33
34	/*
35	** the following types define integer types for values that may not
36	** fit in a `small int' (16 bits), but may waste space in a
37	** `large long' (64 bits). The current definitions should work in
38	** any machine, but may not be optimal.
39	*/
40
41
42	/*
43	** an unsigned integer with at least 32 bits
44	*/
45	#ifndef LUA_UINT32
46	#define LUA_UINT32 unsigned long
47	#endif
48		18
49	typedef LUA_UINT32 lu_int32;	19	typedef LUA_UINT32 lu_int32;
50		20
51
52	/*
53	** a signed integer with at least 32 bits
54	*/
55	#ifndef LUA_INT32
56	#define LUA_INT32 long
57	#define LUA_MAXINT32 LONG_MAX
58	#endif
59
60	typedef LUA_INT32 l_int32;	21	typedef LUA_INT32 l_int32;
61		22
62		23
@@ -95,24 +56,11 @@ typedef unsigned char lu_byte; · 32 unmodified lines
95		56
96		57
97	/* type to ensure maximum alignment */	58	/* type to ensure maximum alignment */
98	#ifndef LUSER_ALIGNMENT_T
99	typedef union { double u; void *s; long l; } L_Umaxalign;
100	#else
101	typedef LUSER_ALIGNMENT_T L_Umaxalign;	59	typedef LUSER_ALIGNMENT_T L_Umaxalign;
102	#endif
103		60
104		61
105	/* result of `usual argument conversion' over lua_Number */	62	/* result of a `usual argument conversion' over lua_Number */
106	#ifndef LUA_UACNUMBER
107	typedef double l_uacNumber;
108	#else
109	typedef LUA_UACNUMBER l_uacNumber;	63	typedef LUA_UACNUMBER l_uacNumber;
110	#endif
111
112
113	#ifndef lua_assert
114	#define lua_assert(c) /* empty */
115	#endif
116		64
117		65
118	#ifndef check_exp	66	#ifndef check_exp
@@ -138,43 +86,11 @@ typedef LUA_UACNUMBER l_uacNumber; · 19 unmodified lines
138	typedef lu_int32 Instruction;	86	typedef lu_int32 Instruction;
139		87
140		88
141	/* maximum depth for calls (unsigned short) */
142	#ifndef LUA_MAXCALLS
143	#define LUA_MAXCALLS 4096
144	#endif
145
146
147	/*
148	** maximum depth for C calls (unsigned short): Not too big, or may
149	** overflow the C stack...
150	*/
151
152	#ifndef LUA_MAXCCALLS
153	#define LUA_MAXCCALLS 200
154	#endif
155
156
157	/* maximum size for the virtual stack of a C function */
158	#ifndef LUA_MAXCSTACK
159	#define LUA_MAXCSTACK 2048
160	#endif
161
162		89
163	/* maximum stack for a Lua function */	90	/* maximum stack for a Lua function */
164	#define MAXSTACK 250	91	#define MAXSTACK 250
165		92
166		93
167	/* maximum number of variables declared in a function */
168	#ifndef MAXVARS
169	#define MAXVARS 200 /* <MAXSTACK */
170	#endif
171
172
173	/* maximum number of upvalues per function */
174	#ifndef MAXUPVALUES
175	#define MAXUPVALUES 32 /* <MAXSTACK */
176	#endif
177
178		94
179	/* minimum size for the string table (must be power of 2) */	95	/* minimum size for the string table (must be power of 2) */
180	#ifndef MINSTRTABSIZE	96	#ifndef MINSTRTABSIZE
@@ -188,13 +104,4 @@ typedef lu_int32 Instruction; · 7 unmodified lines
188	#endif	104	#endif
189		105
190		106
191	/*
192	** maximum number of syntactical nested non-terminals: Not too big,
193	** or may overflow the C stack...
194	*/
195	#ifndef LUA_MAXPARSERLEVEL
196	#define LUA_MAXPARSERLEVEL 200
197	#endif
198
199
200	#endif	107	#endif

src/lmem.c+3−3

 /*
-** $Id: lmem.c,v 1.63 2003/11/27 18:18:37 roberto Exp $
+** $Id: lmem.c,v 1.65 2004/08/30 13:44:44 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
 #include <stddef.h>
 #define lmem_c
+#define LUA_CORE
 #include "lua.h"
   if (block == NULL && nsize > 0)
     luaD_throw(L, LUA_ERRMEM);
   lua_assert((nsize == 0) == (block == NULL));
-  g->nblocks -= osize;
+  g->totalbytes = (g->totalbytes - osize) + nsize;
-  g->nblocks += nsize;
   return block;
 }

src/lobject.c+18−12

 /*
-** $Id: lobject.c,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: lobject.c,v 2.4 2004/07/09 16:01:38 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lobject_c
+#define LUA_CORE
 #include "lua.h"
 #include "lvm.h"
-/* function to convert a string to a lua_Number */
-#ifndef lua_str2number
-#define lua_str2number(s,p)     strtod((s), (p))
-#endif
 const TValue luaO_nilobject = {LUA_TNIL, {NULL}};
 }
-/* this function handles only `%d', `%c', %f, and `%s' formats */
+/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
 const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
   int n = 1;
   pushstr(L, "");
     setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
     incr_top(L);
     switch (*(e+1)) {
-      case 's':
+      case 's': {
         pushstr(L, va_arg(argp, char *));
         break;
+      }
       case 'c': {
         char buff[2];
         buff[0] = cast(char, va_arg(argp, int));
         pushstr(L, buff);
         break;
       }
-      case 'd':
+      case 'd': {
         setnvalue(L->top, cast(lua_Number, va_arg(argp, int)));
         incr_top(L);
         break;
-      case 'f':
+      }
+      case 'f': {
         setnvalue(L->top, cast(lua_Number, va_arg(argp, l_uacNumber)));
         incr_top(L);
         break;
-      case '%':
+      }
+      case 'p': {
+        char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
+        sprintf(buff, "%p", va_arg(argp, void *));
+        pushstr(L, buff);
+        break;
+      }
+      case '%': {
         pushstr(L, "%");
         break;
+      }
       default: {
         char buff[3];
         buff[0] = '%';
       strcat(out, source);
     }
     else {  /* out = [string "string"] */
-      int len = strcspn(source, "\n");  /* stop at first newline */
+      int len = strcspn(source, "\n\r");  /* stop at first newline */
       bufflen -= sizeof(" [string \"...\"] ");
       if (len > bufflen) len = bufflen;
       strcpy(out, "[string \"");

src/lobject.h+5−1

 /*
-** $Id: lobject.h,v 2.4 2004/03/15 21:04:33 roberto Exp $
+** $Id: lobject.h,v 2.5 2004/05/31 18:51:50 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
 } Proto;
+/* mask for new-style vararg */
+#define NEWSTYLEVARARG		2
 typedef struct LocVar {
   TString *varname;
   int startpc;  /* first point where variable is active */

src/lopcodes.c+5−5

 /*
-** $Id: lopcodes.c,v 1.25 2003/05/14 21:09:53 roberto Exp $
+** $Id: lopcodes.c,v 1.28 2004/07/16 13:15:32 roberto Exp $
 ** See Copyright Notice in lua.h
 */
 #define lopcodes_c
+#define LUA_CORE
 #include "lua.h"
 /* ORDER OP */
-#ifdef LUA_OPNAMES
 const char *const luaP_opnames[NUM_OPCODES] = {
   "MOVE",
   "LOADK",
   "SETLIST",
   "SETLISTO",
   "CLOSE",
-  "CLOSURE"
+  "CLOSURE",
+  "VARARG"
 };
-#endif
 #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
  ,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+41−17

 /*
-** $Id: lopcodes.h,v 1.106 2003/05/15 19:46:03 roberto Exp $
+** $Id: lopcodes.h,v 1.111 2004/08/04 20:18:13 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 #define SIZE_OP		6
-#define POS_C		SIZE_OP
+#define POS_OP		0
+#define POS_A		(POS_OP + SIZE_OP)
+#define POS_C		(POS_A + SIZE_A)
 #define POS_B		(POS_C + SIZE_C)
 #define POS_Bx		POS_C
-#define POS_A		(POS_B + SIZE_B)
 /*
 ** limits for opcode arguments.
 ** we use (signed) int to manipulate most arguments,
-** so they must fit in BITS_INT-1 bits (-1 for sign)
+** so they must fit in LUA_BITSINT-1 bits (-1 for sign)
 */
-#if SIZE_Bx < BITS_INT-1
+#if SIZE_Bx < LUA_BITSINT-1
 #define MAXARG_Bx        ((1<<SIZE_Bx)-1)
 #define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
 #else
 ** the following macros help to manipulate instructions
 */
-#define GET_OPCODE(i)	(cast(OpCode, (i)&MASK1(SIZE_OP,0)))
+#define GET_OPCODE(i)	(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
-#define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,0)) | cast(Instruction, o)))
+#define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
+		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
-#define GETARG_A(i)	(cast(int, (i)>>POS_A))
+#define GETARG_A(i)	(cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
 #define SETARG_A(i,u)	((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
 		((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
 #define SETARG_sBx(i,b)	SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
-#define CREATE_ABC(o,a,b,c)	(cast(Instruction, o) \
+#define CREATE_ABC(o,a,b,c)	((cast(Instruction, o)<<POS_OP) \
 			| (cast(Instruction, a)<<POS_A) \
 			| (cast(Instruction, b)<<POS_B) \
 			| (cast(Instruction, c)<<POS_C))
-#define CREATE_ABx(o,a,bc)	(cast(Instruction, o) \
+#define CREATE_ABx(o,a,bc)	((cast(Instruction, o)<<POS_OP) \
 			| (cast(Instruction, a)<<POS_A) \
 			| (cast(Instruction, bc)<<POS_Bx))
+/*
+** Macros to operate RK indices
+*/
+/* this bit 1 means constant (0 means register) */
+#define BITRK		(1 << (SIZE_B - 1))
+/* test whether value is a constant */
+#define ISK(x)		((x) & BITRK)
+/* gets the index of the constant */
+#define INDEXK(r)	((int)(r) & ~BITRK)
+#define MAXINDEXRK	(BITRK - 1)
+/* code a constant index as a RK value */
+#define RKASK(x)	((x) | BITRK)
 /*
 /*
 ** R(x) - register
 ** Kst(x) - constant (in constant table)
-** RK(x) == if x < MAXSTACK then R(x) else Kst(x-MAXSTACK)
+** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
 */
 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))	*/
+OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))	*/
+OP_VARARG/*	A B	R(A), R(A+1), ..., R(A+B-1) = vararg		*/
 } OpCode;
-#define NUM_OPCODES	(cast(int, OP_CLOSURE+1))
+#define NUM_OPCODES	(cast(int, OP_VARARG+1))
 /*===========================================================================
   Notes:
-  (1) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
+  (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
       and can be 0: OP_CALL then sets `top' to last_result+1, so
       next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
-  (2) In OP_RETURN, if (B == 0) then return up to `top'
+  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
+      set top (like in OP_CALL).
+  (*) In OP_RETURN, if (B == 0) then return up to `top'
-  (3) For comparisons, B specifies what conditions the test should accept.
+  (*) For comparisons, B specifies what conditions the test should accept.
-  (4) All `skips' (pc++) assume that next instruction is a jump
+  (*) All `skips' (pc++) assume that next instruction is a jump
 ===========================================================================*/

src/lparser.c+33−35

 /*
-** $Id: lparser.c,v 2.2 2004/03/12 19:53:56 roberto Exp $
+** $Id: lparser.c,v 2.5 2004/05/31 18:51:50 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lparser_c
+#define LUA_CORE
 #include "lua.h"
+#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
 #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)
 static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
   FuncState *fs = ls->fs;
   int extra = nvars - nexps;
-  if (e->k == VCALL) {
+  if (hasmultret(e->k)) {
     extra++;  /* includes call itself */
-    if (extra <= 0) extra = 0;
+    if (extra < 0) extra = 0;
-    else luaK_reserveregs(fs, extra-1);
+    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
-    luaK_setcallreturns(fs, e, extra);  /* call provides the difference */
+    if (extra > 1) luaK_reserveregs(fs, extra-1);
   }
   else {
     if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
   lexstate.nestlevel = 0;
   luaX_setinput(L, &lexstate, z, luaS_new(L, name));
   open_func(&lexstate, &funcstate);
+  funcstate.f->is_vararg = NEWSTYLEVARARG;
   next(&lexstate);  /* read first token */
   chunk(&lexstate);
   check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected");
 static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
   if (cc->tostore == 0) return;
-  if (cc->v.k == VCALL) {
+  if (hasmultret(cc->v.k)) {
-    luaK_setcallreturns(fs, &cc->v, LUA_MULTRET);
+    luaK_setmultret(fs, &cc->v);
     luaK_codeABx(fs, OP_SETLISTO, cc->t->info, cc->na-1);
+    cc->na--;  /* do not count last expression (unknown number of elements) */
   }
   else {
     if (cc->v.k != VVOID)
   if (ls->t.token != ')') {  /* is `parlist' not empty? */
     do {
       switch (ls->t.token) {
-        case TK_NAME: {  /* param -> NAME [ `=' `...' ] */
+        case TK_NAME: {  /* param -> NAME */
           new_localvar(ls, str_checkname(ls), nparams++);
-          if (testnext(ls, '=')) {
-            check(ls, TK_DOTS);
-            f->is_vararg = 1;
-          }
           break;
         }
         case TK_DOTS: {  /* param -> `...' */
         args.k = VVOID;
       else {
         explist1(ls, &args);
-        luaK_setcallreturns(fs, &args, LUA_MULTRET);
+        luaK_setmultret(fs, &args);
       }
       check_match(ls, ')', '(', line);
       break;
   }
   lua_assert(f->k == VNONRELOC);
   base = f->info;  /* base register for call */
-  if (args.k == VCALL)
+  if (hasmultret(args.k))
     nparams = LUA_MULTRET;  /* open call */
   else {
     if (args.k != VVOID)
   switch (ls->t.token) {
     case TK_NUMBER: {
       init_exp(v, VK, luaK_numberK(ls->fs, ls->t.seminfo.r));
-      next(ls);  /* must use `seminfo' before `next' */
       break;
     }
     case TK_STRING: {
       codestring(ls, v, ls->t.seminfo.ts);
-      next(ls);  /* must use `seminfo' before `next' */
       break;
     }
     case TK_NIL: {
       init_exp(v, VNIL, 0);
-      next(ls);
       break;
     }
     case TK_TRUE: {
       init_exp(v, VTRUE, 0);
-      next(ls);
       break;
     }
     case TK_FALSE: {
       init_exp(v, VFALSE, 0);
-      next(ls);
+      break;
+    }
+    case TK_DOTS: {  /* vararg */
+      FuncState *fs = ls->fs;
+      check_condition(ls, fs->f->is_vararg,
+                      "cannot use `...' outside a vararg function");
+      fs->f->is_vararg = NEWSTYLEVARARG;
+      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
       break;
     }
     case '{': {  /* constructor */
       constructor(ls, v);
-      break;
+      return;
     }
     case TK_FUNCTION: {
       next(ls);
       body(ls, v, 0, ls->linenumber);
-      break;
+      return;
     }
     default: {
       primaryexp(ls, v);
-      break;
+      return;
     }
   }
+  next(ls);
 }
         ls->fs->freereg -= nexps - nvars;  /* remove extra values */
     }
     else {
-      luaK_setcallreturns(ls->fs, &e, 1);  /* close last expression */
+      luaK_setoneret(ls->fs, &e);  /* close last expression */
       luaK_storevar(ls->fs, &lh->v, &e);
       return;  /* avoid default */
     }
 ** after its body (and thus avoiding one jump in the loop).
 */
-/*
-** maximum size of expressions for optimizing `while' code
-*/
-#ifndef MAXEXPWHILE
-#define MAXEXPWHILE	100
-#endif
 /*
 ** the call `luaK_goiffalse' may grow the size of an expression by
   FuncState *fs = ls->fs;
   struct LHS_assign v;
   primaryexp(ls, &v.v);
-  if (v.v.k == VCALL) {  /* stat -> func */
+  if (v.v.k == VCALL)  /* stat -> func */
-    luaK_setcallreturns(fs, &v.v, 0);  /* call statement uses no results */
+    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
-  }
   else {  /* stat -> assignment */
     v.prev = NULL;
     assignment(ls, &v, 1);
     first = nret = 0;  /* return no values */
   else {
     nret = explist1(ls, &e);  /* optional return values */
-    if (e.k == VCALL) {
+    if (hasmultret(e.k)) {
-      luaK_setcallreturns(fs, &e, LUA_MULTRET);
+      luaK_setmultret(fs, &e);
-      if (nret == 1) {  /* tail call? */
+      if (e.k == VCALL && nret == 1) {  /* tail call? */
         SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
         lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
       }

src/lparser.h+3−2

 /*
-** $Id: lparser.h,v 1.50 2003/08/25 19:51:54 roberto Exp $
+** $Id: lparser.h,v 1.51 2004/05/31 18:51:50 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
   VJMP,		/* info = instruction pc */
   VRELOCABLE,	/* info = instruction pc */
   VNONRELOC,	/* info = result register */
-  VCALL		/* info = result register */
+  VCALL,	/* info = instruction pc */
+  VVARARG	/* info = instruction pc */
 } expkind;
 typedef struct expdesc {

src/lstate.c+22−10

 /*
-** $Id: lstate.c,v 2.5 2004/03/23 12:57:12 roberto Exp $
+** $Id: lstate.c,v 2.12 2004/08/30 13:44:44 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 #include <stddef.h>
 #define lstate_c
+#define LUA_CORE
 #include "lua.h"
   L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
   L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
   L1->ci = L1->base_ci;
+  L1->ci->func = L1->top;
   setnilvalue(L1->top++);  /* `function' entry for this `ci' */
   L1->base = L1->ci->base = L1->top;
   L1->ci->top = L1->top + LUA_MINSTACK;
 */
 static void f_luaopen (lua_State *L, void *ud) {
   Udata *u;  /* head of udata list */
+  global_State *g = G(L);
   UNUSED(ud);
   u = cast(Udata *, luaM_malloc(L, sizeudata(0)));
   u->uv.len = 0;
   u->uv.metatable = NULL;
-  G(L)->firstudata = obj2gco(u);
+  g->firstudata = obj2gco(u);
   luaC_link(L, obj2gco(u), LUA_TUSERDATA);
   setbit(u->uv.marked, FIXEDBIT);
   setbit(L->marked, FIXEDBIT);
   stack_init(L, L);  /* init stack */
   sethvalue(L, gt(L), luaH_new(L, 0, 4));  /* table of globals */
+  hvalue(gt(L))->metatable = luaH_new(L, 0, 0);  /* globals metatable */
   sethvalue(L, registry(L), luaH_new(L, 4, 4));  /* registry */
   luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
   luaT_init(L);
   luaX_init(L);
   luaS_fix(luaS_newliteral(L, MEMERRMSG));
-  G(L)->GCthreshold = 4*G(L)->nblocks;
+  g->GCthreshold = 4*g->totalbytes;
+  g->prevestimate = g->estimate = g->totalbytes;
 }
 static void close_state (lua_State *L) {
   global_State *g = G(L);
   luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_sweepall(L);  /* collect all elements */
+  luaC_freeall(L);  /* collect all objects */
-  lua_assert(g->rootgc == obj2gco(L));
+  lua_assert(g->rootgc == NULL);
-  luaS_freeall(L);
+  lua_assert(g->strt.nuse == 0);
+  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
   luaZ_freebuffer(L, &g->buff);
   freestack(L, L);
-  lua_assert(g->nblocks == sizeof(LG));
+  lua_assert(g->totalbytes == sizeof(LG));
   (*g->realloc)(g->ud, fromstate(L), state_size(LG), 0);
 }
   preinit_state(L1, G(L));
   stack_init(L1, L);  /* init stack */
   setobj2n(L, gt(L1), gt(L));  /* share table of globals */
+  L1->hookmask = L->hookmask;
+  L1->basehookcount = L->basehookcount;
+  L1->hook = L->hook;
+  resethookcount(L1);
   lua_assert(iswhite(obj2gco(L1)));
   return L1;
 }
   setnilvalue(registry(L));
   luaZ_initbuffer(L, &g->buff);
   g->panic = NULL;
-  g->gcstate = GCSfinalize;
+  g->gcstate = GCSpause;
+  g->gcgenerational = 0;
   g->rootgc = obj2gco(L);
   g->sweepstrgc = 0;
   g->sweepgc = &g->rootgc;
   setnilvalue(gkey(g->dummynode));
   setnilvalue(gval(g->dummynode));
   g->dummynode->next = NULL;
-  g->nblocks = sizeof(LG);
+  g->totalbytes = sizeof(LG);
   if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
     /* memory allocation error: free partial state */
     close_state(L);
     L = NULL;
   }
-  lua_userstateopen(L);
+  else
+    lua_userstateopen(L);
   return L;
 }

src/lstate.h+15−41

 /*
-** $Id: lstate.h,v 2.2 2004/03/23 17:02:58 roberto Exp $
+** $Id: lstate.h,v 2.7 2004/08/30 13:44:44 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 #include "lzio.h"
-/*
-** macros for thread synchronization inside Lua core machine:
-** all accesses to the global state and to global objects are synchronized.
-** Because threads can read the stack of other threads
-** (when running garbage collection),
-** a thread must also synchronize any write-access to its own stack.
-** Unsynchronized accesses are allowed only when reading its own stack,
-** or when reading immutable fields from global objects
-** (such as string values and udata values).
-*/
-#ifndef lua_lock
-#define lua_lock(L)	((void) 0)
-#endif
-#ifndef lua_unlock
-#define lua_unlock(L)	((void) 0)
-#endif
-#ifndef lua_userstateopen
-#define lua_userstateopen(l)
-#endif
 struct lua_longjmp;  /* defined in ldo.c */
 ** informations about a call
 */
 typedef struct CallInfo {
-  StkId base;  /* base for called function */
+  StkId base;  /* base for this function */
+  StkId func;  /* function index in the stack */
   StkId	top;  /* top for this function */
-  union {
+  int nresults;  /* expected number of results from this function */
-    struct {  /* for Lua functions */
+  const Instruction *savedpc;
-      const Instruction *savedpc;
+  int tailcalls;  /* number of tail calls lost under this entry */
-      int tailcalls;  /* number of tail calls lost under this entry */
-    } l;
-    struct {  /* for C functions */
-      int dummy;  /* just to avoid an empty struct */
-    } c;
-  } u;
 } CallInfo;
-#define curr_func(L)	(clvalue(L->base - 1))
+#define curr_func(L)	(clvalue(L->ci->func))
-#define ci_func(ci)	(clvalue((ci)->base - 1))
+#define ci_func(ci)	(clvalue((ci)->func))
 #define f_isLua(ci)	(!ci_func(ci)->c.isC)
-#define isLua(ci)	(ttisfunction((ci)->base - 1) && f_isLua(ci))
+#define isLua(ci)	(ttisfunction((ci)->func) && f_isLua(ci))
 /*
   stringtable strt;  /* hash table for strings */
   lua_Alloc realloc;  /* function to reallocate memory */
   void *ud;         /* auxiliary data to `realloc' */
-  int currentwhite;
+  lu_byte currentwhite;
+  lu_byte gcstate;  /* state of garbage collector */
+  lu_byte gcgenerational;
   GCObject *rootgc;  /* list of all collectable objects */
   GCObject *firstudata;   /* udata go to the end of `rootgc' */
   GCObject **sweepgc;  /* position of sweep in `rootgc' */
   GCObject *grayagain;  /* list of objects to be traversed atomically */
   GCObject *weak;  /* list of weak tables (to be cleared) */
   GCObject *tmudata;  /* list of userdata to be GC */
-  int gcstate;  /* state of garbage collector */
   Mbuffer buff;  /* temporary buffer for string concatentation */
   lu_mem GCthreshold;
-  lu_mem nblocks;  /* number of `bytes' currently allocated */
+  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 */
   lua_CFunction panic;  /* to be called in unprotected errors */
   TValue _registry;
   struct lua_State *mainthread;

src/lstring.c+4−8

 /*
-** $Id: lstring.c,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: lstring.c,v 2.3 2004/08/24 20:12:06 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lstring_c
+#define LUA_CORE
 #include "lua.h"
-void luaS_freeall (lua_State *L) {
-  lua_assert(G(L)->strt.nuse==0);
-  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
-}
 void luaS_resize (lua_State *L, int newsize) {
   GCObject **newhash;
   stringtable *tb;
   int i;
-  if (G(L)->sweepstrgc > 0) return;  /* cannot resize during GC traverse */
+  if (G(L)->gcstate == GCSsweepstring)
+    return;  /* cannot resize during GC traverse */
   newhash = luaM_newvector(L, newsize, GCObject *);
   tb = &G(L)->strt;
   for (i=0; i<newsize; i++) newhash[i] = NULL;

src/lstring.h+1−2

 /*
-** $Id: lstring.h,v 1.38 2003/11/17 19:50:05 roberto Exp $
+** $Id: lstring.h,v 1.39 2004/08/24 20:12:06 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 void luaS_resize (lua_State *L, int newsize);
 Udata *luaS_newudata (lua_State *L, size_t s);
-void luaS_freeall (lua_State *L);
 TString *luaS_newlstr (lua_State *L, const char *str, size_t l);

src/ltable.c+16−47

 /*
-** $Id: ltable.c,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: ltable.c,v 2.5 2004/08/31 17:57:33 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define ltable_c
+#define LUA_CORE
 #include "lua.h"
 /*
 ** max size of array part is 2^MAXBITS
 */
-#if BITS_INT > 26
+#if LUA_BITSINT > 26
 #define MAXBITS		24
 #else
-#define MAXBITS		(BITS_INT-2)
+#define MAXBITS		(LUA_BITSINT-2)
 #endif
 #define MAXASIZE	(1 << MAXBITS)
-/* function to convert a lua_Number to int (with any rounding method) */
-#ifndef lua_number2int
-#define lua_number2int(i,n)	((i)=(int)(n))
-#endif
 #define hashpow2(t,n)      (gnode(t, lmod((n), sizenode(t))))
 }
-static void resize (lua_State *L, Table *t, int nasize, int nhsize) {
+void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize) {
   int i;
   int oldasize = t->sizearray;
   int oldhsize = t->lsizenode;
 static void rehash (lua_State *L, Table *t) {
   int nasize, nhsize;
   numuse(t, &nasize, &nhsize);  /* compute new sizes for array and hash parts */
-  resize(L, t, nasize, luaO_log2(nhsize)+1);
+  luaH_resize(L, t, nasize, luaO_log2(nhsize)+1);
 }
 }
-#if 0
-/*
-** try to remove an element from a hash table; cannot move any element
-** (because gc can call `remove' during a table traversal)
-*/
-void luaH_remove (Table *t, Node *e) {
-  Node *mp = luaH_mainposition(t, gkey(e));
-  if (e != mp) {  /* element not in its main position? */
-    while (mp->next != e) mp = mp->next;  /* find previous */
-    mp->next = e->next;  /* remove `e' from its list */
-  }
-  else {
-    if (e->next != NULL) ??
-  }
-  lua_assert(ttisnil(gval(node)));
-  setnilvalue(gkey(e));  /* clear node `e' */
-  e->next = NULL;
-}
-#endif
 /*
 ** inserts a new key into a hash table; first, check whether key's main
     }
   }
   setobj2t(L, gkey(mp), key);
-  luaC_barrier(L, t, key);
+  luaC_barriert(L, t, key);
   lua_assert(ttisnil(gval(mp)));
   for (;;) {  /* correct `firstfree' */
     if (ttisnil(gkey(t->firstfree)))
 }
-/*
-** generic search function
-*/
-static const TValue *luaH_getany (Table *t, const TValue *key) {
-  if (!ttisnil(key)) {
-    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 */
-      else n = n->next;
-    } while (n);
-  }
-  return &luaO_nilobject;
-}
 /*
 ** search function for integers
 */
 */
 const TValue *luaH_get (Table *t, const TValue *key) {
   switch (ttype(key)) {
+    case LUA_TNIL: return &luaO_nilobject;
     case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
     case LUA_TNUMBER: {
       int k;
         return luaH_getnum(t, k);  /* use specialized version */
       /* else go through */
     }
-    default: return luaH_getany(t, key);
+    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 */
+        else n = n->next;
+      } while (n);
+      return &luaO_nilobject;
+    }
   }
 }

src/ltable.h+2−1

 /*
-** $Id: ltable.h,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: ltable.h,v 2.2 2004/03/26 14:02:41 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 const TValue *luaH_get (Table *t, const TValue *key);
 TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
 Table *luaH_new (lua_State *L, int narray, int lnhash);
+void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize);
 void luaH_free (lua_State *L, Table *t);
 int luaH_next (lua_State *L, Table *t, StkId key);

src/ltests.c+0−852

@@ -1,852 +0,0 @@
1	/*
2	** $Id: ltests.c,v 1.158 2003/04/07 14:35:00 roberto Exp $
3	** Internal Module for Debugging of the Lua Implementation
4	** See Copyright Notice in lua.h
5	*/
6
7
8	#include <ctype.h>
9	#include <limits.h>
10	#include <stdio.h>
11	#include <stdlib.h>
12	#include <string.h>
13
14	#define ltests_c
15
16	#include "lua.h"
17
18	#include "lapi.h"
19	#include "lauxlib.h"
20	#include "lcode.h"
21	#include "ldebug.h"
22	#include "ldo.h"
23	#include "lfunc.h"
24	#include "lmem.h"
25	#include "lopcodes.h"
26	#include "lstate.h"
27	#include "lstring.h"
28	#include "ltable.h"
29	#include "lualib.h"
30
31
32
33	/*
34	** The whole module only makes sense with LUA_DEBUG on
35	*/
36	#ifdef LUA_DEBUG
37
38
39	#define lua_pushintegral(L,i) lua_pushnumber(L, cast(lua_Number, (i)))
40
41
42	static lua_State *lua_state = NULL;
43
44	int islocked = 0;
45
46
47	#define func_at(L,k) (L->ci->base+(k) - 1)
48
49
50	static void setnameval (lua_State L, const char name, int val) {
51	lua_pushstring(L, name);
52	lua_pushintegral(L, val);
53	lua_settable(L, -3);
54	}
55
56
57	/*
58	** {======================================================================
59	** Controlled version for realloc.
60	** =======================================================================
61	*/
62
63	#define MARK 0x55 /* 01010101 (a nice pattern) */
64
65	#ifndef EXTERNMEMCHECK
66	/* full memory check */
67	#define HEADER (sizeof(L_Umaxalign)) /* ensures maximum alignment for HEADER */
68	#define MARKSIZE 16 /* size of marks after each block */
69	#define blockhead(b) (cast(char *, b) - HEADER)
70	#define setsize(newblock, size) (cast(size_t , newblock) = size)
71	#define checkblocksize(b, size) (size == (cast(size_t , blockhead(b))))
72	#define fillmem(mem,size) memset(mem, -MARK, size)
73	#else
74	/* external memory check: don't do it twice */
75	#define HEADER 0
76	#define MARKSIZE 0
77	#define blockhead(b) (b)
78	#define setsize(newblock, size) /* empty */
79	#define checkblocksize(b,size) (1)
80	#define fillmem(mem,size) /* empty */
81	#endif
82
83	unsigned long memdebug_numblocks = 0;
84	unsigned long memdebug_total = 0;
85	unsigned long memdebug_maxmem = 0;
86	unsigned long memdebug_memlimit = ULONG_MAX;
87
88
89	static void checkblock (void block, size_t size) {
90	void *b = blockhead(block);
91	int i;
92	for (i=0;i<MARKSIZE;i++)
93	lua_assert((cast(char , b)+HEADER+size+i) == MARK+i); /* corrupted block? */
94	return b;
95	}
96
97
98	static void freeblock (void *block, size_t size) {
99	if (block) {
100	lua_assert(checkblocksize(block, size));
101	block = checkblock(block, size);
102	fillmem(block, size+HEADER+MARKSIZE); /* erase block */
103	free(block); /* free original block */
104	memdebug_numblocks--;
105	memdebug_total -= size;
106	}
107	}
108
109
110	void debug_realloc (void block, size_t oldsize, size_t size) {
111	lua_assert(oldsize == 0 \|\| checkblocksize(block, oldsize));
112	/* ISO does not specify what realloc(NULL, 0) does */
113	lua_assert(block != NULL \|\| size > 0);
114	if (size == 0) {
115	freeblock(block, oldsize);
116	return NULL;
117	}
118	else if (size > oldsize && memdebug_total+size-oldsize > memdebug_memlimit)
119	return NULL; /* to test memory allocation errors */
120	else {
121	void *newblock;
122	int i;
123	size_t realsize = HEADER+size+MARKSIZE;
124	size_t commonsize = (oldsize < size) ? oldsize : size;
125	if (realsize < size) return NULL; /* overflow! */
126	newblock = malloc(realsize); /* alloc a new block */
127	if (newblock == NULL) return NULL;
128	if (block) {
129	memcpy(cast(char *, newblock)+HEADER, block, commonsize);
130	freeblock(block, oldsize); /* erase (and check) old copy */
131	}
132	/* initialize new part of the block with something `weird' */
133	fillmem(cast(char *, newblock)+HEADER+commonsize, size-commonsize);
134	memdebug_total += size;
135	if (memdebug_total > memdebug_maxmem)
136	memdebug_maxmem = memdebug_total;
137	memdebug_numblocks++;
138	setsize(newblock, size);
139	for (i=0;i<MARKSIZE;i++)
140	(cast(char , newblock)+HEADER+size+i) = cast(char, MARK+i);
141	return cast(char *, newblock)+HEADER;
142	}
143	}
144
145
146	/* }====================================================================== */
147
148
149
150	/*
151	** {======================================================
152	** Disassembler
153	** =======================================================
154	*/
155
156
157	static char buildop (Proto p, int pc, char *buff) {
158	Instruction i = p->code[pc];
159	OpCode o = GET_OPCODE(i);
160	const char *name = luaP_opnames[o];
161	int line = getline(p, pc);
162	sprintf(buff, "(%4d) %4d - ", line, pc);
163	switch (getOpMode(o)) {
164	case iABC:
165	sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name,
166	GETARG_A(i), GETARG_B(i), GETARG_C(i));
167	break;
168	case iABx:
169	sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i));
170	break;
171	case iAsBx:
172	sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i));
173	break;
174	}
175	return buff;
176	}
177
178
179	#if 0
180	void luaI_printcode (Proto *pt, int size) {
181	int pc;
182	for (pc=0; pc<size; pc++) {
183	char buff[100];
184	printf("%s\n", buildop(pt, pc, buff));
185	}
186	printf("-------\n");
187	}
188	#endif
189
190
191	static int listcode (lua_State *L) {
192	int pc;
193	Proto *p;
194	luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
195	1, "Lua function expected");
196	p = clvalue(func_at(L, 1))->l.p;
197	lua_newtable(L);
198	setnameval(L, "maxstack", p->maxstacksize);
199	setnameval(L, "numparams", p->numparams);
200	for (pc=0; pc<p->sizecode; pc++) {
201	char buff[100];
202	lua_pushintegral(L, pc+1);
203	lua_pushstring(L, buildop(p, pc, buff));
204	lua_settable(L, -3);
205	}
206	return 1;
207	}
208
209
210	static int listk (lua_State *L) {
211	Proto *p;
212	int i;
213	luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
214	1, "Lua function expected");
215	p = clvalue(func_at(L, 1))->l.p;
216	lua_newtable(L);
217	for (i=0; i<p->sizek; i++) {
218	lua_pushintegral(L, i+1);
219	luaA_pushobject(L, p->k+i);
220	lua_settable(L, -3);
221	}
222	return 1;
223	}
224
225
226	static int listlocals (lua_State *L) {
227	Proto *p;
228	int pc = luaL_checkint(L, 2) - 1;
229	int i = 0;
230	const char *name;
231	luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
232	1, "Lua function expected");
233	p = clvalue(func_at(L, 1))->l.p;
234	while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
235	lua_pushstring(L, name);
236	return i-1;
237	}
238
239	/* }====================================================== */
240
241
242
243
244	static int get_limits (lua_State *L) {
245	lua_newtable(L);
246	setnameval(L, "BITS_INT", BITS_INT);
247	setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
248	setnameval(L, "MAXVARS", MAXVARS);
249	setnameval(L, "MAXPARAMS", MAXPARAMS);
250	setnameval(L, "MAXSTACK", MAXSTACK);
251	setnameval(L, "MAXUPVALUES", MAXUPVALUES);
252	return 1;
253	}
254
255
256	static int mem_query (lua_State *L) {
257	if (lua_isnone(L, 1)) {
258	lua_pushintegral(L, memdebug_total);
259	lua_pushintegral(L, memdebug_numblocks);
260	lua_pushintegral(L, memdebug_maxmem);
261	return 3;
262	}
263	else {
264	memdebug_memlimit = luaL_checkint(L, 1);
265	return 0;
266	}
267	}
268
269
270	static int hash_query (lua_State *L) {
271	if (lua_isnone(L, 2)) {
272	luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected");
273	lua_pushintegral(L, tsvalue(func_at(L, 1))->tsv.hash);
274	}
275	else {
276	TObject *o = func_at(L, 1);
277	Table *t;
278	luaL_checktype(L, 2, LUA_TTABLE);
279	t = hvalue(func_at(L, 2));
280	lua_pushintegral(L, luaH_mainposition(t, o) - t->node);
281	}
282	return 1;
283	}
284
285
286	static int stacklevel (lua_State *L) {
287	unsigned long a = 0;
288	lua_pushintegral(L, (int)(L->top - L->stack));
289	lua_pushintegral(L, (int)(L->stack_last - L->stack));
290	lua_pushintegral(L, (int)(L->ci - L->base_ci));
291	lua_pushintegral(L, (int)(L->end_ci - L->base_ci));
292	lua_pushintegral(L, (unsigned long)&a);
293	return 5;
294	}
295
296
297	static int table_query (lua_State *L) {
298	const Table *t;
299	int i = luaL_optint(L, 2, -1);
300	luaL_checktype(L, 1, LUA_TTABLE);
301	t = hvalue(func_at(L, 1));
302	if (i == -1) {
303	lua_pushintegral(L, t->sizearray);
304	lua_pushintegral(L, sizenode(t));
305	lua_pushintegral(L, t->firstfree - t->node);
306	}
307	else if (i < t->sizearray) {
308	lua_pushintegral(L, i);
309	luaA_pushobject(L, &t->array[i]);
310	lua_pushnil(L);
311	}
312	else if ((i -= t->sizearray) < sizenode(t)) {
313	if (!ttisnil(gval(gnode(t, i))) \|\|
314	ttisnil(gkey(gnode(t, i))) \|\|
315	ttisnumber(gkey(gnode(t, i)))) {
316	luaA_pushobject(L, gkey(gnode(t, i)));
317	}
318	else
319	lua_pushstring(L, "<undef>");
320	luaA_pushobject(L, gval(gnode(t, i)));
321	if (t->node[i].next)
322	lua_pushintegral(L, t->node[i].next - t->node);
323	else
324	lua_pushnil(L);
325	}
326	return 3;
327	}
328
329
330	static int string_query (lua_State *L) {
331	stringtable *tb = &G(L)->strt;
332	int s = luaL_optint(L, 2, 0) - 1;
333	if (s==-1) {
334	lua_pushintegral(L ,tb->nuse);
335	lua_pushintegral(L ,tb->size);
336	return 2;
337	}
338	else if (s < tb->size) {
339	GCObject *ts;
340	int n = 0;
341	for (ts = tb->hash[s]; ts; ts = ts->gch.next) {
342	setsvalue2s(L->top, gcotots(ts));
343	incr_top(L);
344	n++;
345	}
346	return n;
347	}
348	return 0;
349	}
350
351
352	static int tref (lua_State *L) {
353	int level = lua_gettop(L);
354	int lock = luaL_optint(L, 2, 1);
355	luaL_checkany(L, 1);
356	lua_pushvalue(L, 1);
357	lua_pushintegral(L, lua_ref(L, lock));
358	assert(lua_gettop(L) == level+1); /* +1 for result */
359	return 1;
360	}
361
362	static int getref (lua_State *L) {
363	int level = lua_gettop(L);
364	lua_getref(L, luaL_checkint(L, 1));
365	assert(lua_gettop(L) == level+1);
366	return 1;
367	}
368
369	static int unref (lua_State *L) {
370	int level = lua_gettop(L);
371	lua_unref(L, luaL_checkint(L, 1));
372	assert(lua_gettop(L) == level);
373	return 0;
374	}
375
376	static int metatable (lua_State *L) {
377	luaL_checkany(L, 1);
378	if (lua_isnone(L, 2)) {
379	if (lua_getmetatable(L, 1) == 0)
380	lua_pushnil(L);
381	}
382	else {
383	lua_settop(L, 2);
384	luaL_checktype(L, 2, LUA_TTABLE);
385	lua_setmetatable(L, 1);
386	}
387	return 1;
388	}
389
390
391	static int upvalue (lua_State *L) {
392	int n = luaL_checkint(L, 2);
393	luaL_checktype(L, 1, LUA_TFUNCTION);
394	if (lua_isnone(L, 3)) {
395	const char *name = lua_getupvalue(L, 1, n);
396	if (name == NULL) return 0;
397	lua_pushstring(L, name);
398	return 2;
399	}
400	else {
401	const char *name = lua_setupvalue(L, 1, n);
402	lua_pushstring(L, name);
403	return 1;
404	}
405	}
406
407
408	static int newuserdata (lua_State *L) {
409	size_t size = luaL_checkint(L, 1);
410	char p = cast(char , lua_newuserdata(L, size));
411	while (size--) *p++ = '\0';
412	return 1;
413	}
414
415
416	static int pushuserdata (lua_State *L) {
417	lua_pushlightuserdata(L, cast(void *, luaL_checkint(L, 1)));
418	return 1;
419	}
420
421
422	static int udataval (lua_State *L) {
423	lua_pushintegral(L, cast(int, lua_touserdata(L, 1)));
424	return 1;
425	}
426
427
428	static int doonnewstack (lua_State *L) {
429	lua_State *L1 = lua_newthread(L);
430	size_t l;
431	const char *s = luaL_checklstring(L, 1, &l);
432	int status = luaL_loadbuffer(L1, s, l, s);
433	if (status == 0)
434	status = lua_pcall(L1, 0, 0, 0);
435	lua_pushintegral(L, status);
436	return 1;
437	}
438
439
440	static int s2d (lua_State *L) {
441	lua_pushnumber(L, cast(const double , luaL_checkstring(L, 1)));
442	return 1;
443	}
444
445	static int d2s (lua_State *L) {
446	double d = luaL_checknumber(L, 1);
447	lua_pushlstring(L, cast(char *, &d), sizeof(d));
448	return 1;
449	}
450
451
452	static int newstate (lua_State *L) {
453	lua_State *L1 = lua_open();
454	if (L1) {
455	lua_userstateopen(L1); /* init lock */
456	lua_pushintegral(L, (unsigned long)L1);
457	}
458	else
459	lua_pushnil(L);
460	return 1;
461	}
462
463
464	static int loadlib (lua_State *L) {
465	static const luaL_reg libs[] = {
466	{"mathlibopen", luaopen_math},
467	{"strlibopen", luaopen_string},
468	{"iolibopen", luaopen_io},
469	{"tablibopen", luaopen_table},
470	{"dblibopen", luaopen_debug},
471	{"baselibopen", luaopen_base},
472	{NULL, NULL}
473	};
474	lua_State L1 = cast(lua_State ,
475	cast(unsigned long, luaL_checknumber(L, 1)));
476	lua_pushvalue(L1, LUA_GLOBALSINDEX);
477	luaL_openlib(L1, NULL, libs, 0);
478	return 0;
479	}
480
481	static int closestate (lua_State *L) {
482	lua_State L1 = cast(lua_State , cast(unsigned long, luaL_checknumber(L, 1)));
483	lua_close(L1);
484	lua_unlock(L); /* close cannot unlock that */
485	return 0;
486	}
487
488	static int doremote (lua_State *L) {
489	lua_State L1 = cast(lua_State ,cast(unsigned long,luaL_checknumber(L, 1)));
490	size_t lcode;
491	const char *code = luaL_checklstring(L, 2, &lcode);
492	int status;
493	lua_settop(L1, 0);
494	status = luaL_loadbuffer(L1, code, lcode, code);
495	if (status == 0)
496	status = lua_pcall(L1, 0, LUA_MULTRET, 0);
497	if (status != 0) {
498	lua_pushnil(L);
499	lua_pushintegral(L, status);
500	lua_pushstring(L, lua_tostring(L1, -1));
501	return 3;
502	}
503	else {
504	int i = 0;
505	while (!lua_isnone(L1, ++i))
506	lua_pushstring(L, lua_tostring(L1, i));
507	lua_pop(L1, i-1);
508	return i-1;
509	}
510	}
511
512
513	static int log2_aux (lua_State *L) {
514	lua_pushintegral(L, luaO_log2(luaL_checkint(L, 1)));
515	return 1;
516	}
517
518	static int int2fb_aux (lua_State *L) {
519	int b = luaO_int2fb(luaL_checkint(L, 1));
520	lua_pushintegral(L, b);
521	lua_pushintegral(L, fb2int(b));
522	return 2;
523	}
524
525
526	static int test_do (lua_State *L) {
527	const char *p = luaL_checkstring(L, 1);
528	if (*p == '@')
529	lua_dofile(L, p+1);
530	else
531	lua_dostring(L, p);
532	return lua_gettop(L);
533	}
534
535
536
537	/*
538	** {======================================================
539	** function to test the API with C. It interprets a kind of assembler
540	** language with calls to the API, so the test can be driven by Lua code
541	** =======================================================
542	*/
543
544	static const char *const delimits = " \t\n,;";
545
546	static void skip (const char **pc) {
547	while (pc != '\0' && strchr(delimits, pc)) (*pc)++;
548	}
549
550	static int getnum_aux (lua_State L, const char *pc) {
551	int res = 0;
552	int sig = 1;
553	skip(pc);
554	if (**pc == '.') {
555	res = cast(int, lua_tonumber(L, -1));
556	lua_pop(L, 1);
557	(*pc)++;
558	return res;
559	}
560	else if (**pc == '-') {
561	sig = -1;
562	(*pc)++;
563	}
564	while (isdigit(cast(int, *pc))) res = res10 + ((pc)++) - '0';
565	return sig*res;
566	}
567
568	static const char getname_aux (char buff, const char **pc) {
569	int i = 0;
570	skip(pc);
571	while (pc != '\0' && !strchr(delimits, pc))
572	buff[i++] = (pc)++;
573	buff[i] = '\0';
574	return buff;
575	}
576
577
578	#define EQ(s1) (strcmp(s1, inst) == 0)
579
580	#define getnum (getnum_aux(L, &pc))
581	#define getname (getname_aux(buff, &pc))
582
583
584	static int testC (lua_State *L) {
585	char buff[30];
586	const char *pc = luaL_checkstring(L, 1);
587	for (;;) {
588	const char *inst = getname;
589	if EQ("") return 0;
590	else if EQ("isnumber") {
591	lua_pushintegral(L, lua_isnumber(L, getnum));
592	}
593	else if EQ("isstring") {
594	lua_pushintegral(L, lua_isstring(L, getnum));
595	}
596	else if EQ("istable") {
597	lua_pushintegral(L, lua_istable(L, getnum));
598	}
599	else if EQ("iscfunction") {
600	lua_pushintegral(L, lua_iscfunction(L, getnum));
601	}
602	else if EQ("isfunction") {
603	lua_pushintegral(L, lua_isfunction(L, getnum));
604	}
605	else if EQ("isuserdata") {
606	lua_pushintegral(L, lua_isuserdata(L, getnum));
607	}
608	else if EQ("isudataval") {
609	lua_pushintegral(L, lua_islightuserdata(L, getnum));
610	}
611	else if EQ("isnil") {
612	lua_pushintegral(L, lua_isnil(L, getnum));
613	}
614	else if EQ("isnull") {
615	lua_pushintegral(L, lua_isnone(L, getnum));
616	}
617	else if EQ("tonumber") {
618	lua_pushnumber(L, lua_tonumber(L, getnum));
619	}
620	else if EQ("tostring") {
621	const char *s = lua_tostring(L, getnum);
622	lua_pushstring(L, s);
623	}
624	else if EQ("strlen") {
625	lua_pushintegral(L, lua_strlen(L, getnum));
626	}
627	else if EQ("tocfunction") {
628	lua_pushcfunction(L, lua_tocfunction(L, getnum));
629	}
630	else if EQ("return") {
631	return getnum;
632	}
633	else if EQ("gettop") {
634	lua_pushintegral(L, lua_gettop(L));
635	}
636	else if EQ("settop") {
637	lua_settop(L, getnum);
638	}
639	else if EQ("pop") {
640	lua_pop(L, getnum);
641	}
642	else if EQ("pushnum") {
643	lua_pushintegral(L, getnum);
644	}
645	else if EQ("pushnil") {
646	lua_pushnil(L);
647	}
648	else if EQ("pushbool") {
649	lua_pushboolean(L, getnum);
650	}
651	else if EQ("tobool") {
652	lua_pushintegral(L, lua_toboolean(L, getnum));
653	}
654	else if EQ("pushvalue") {
655	lua_pushvalue(L, getnum);
656	}
657	else if EQ("pushcclosure") {
658	lua_pushcclosure(L, testC, getnum);
659	}
660	else if EQ("pushupvalues") {
661	lua_pushupvalues(L);
662	}
663	else if EQ("remove") {
664	lua_remove(L, getnum);
665	}
666	else if EQ("insert") {
667	lua_insert(L, getnum);
668	}
669	else if EQ("replace") {
670	lua_replace(L, getnum);
671	}
672	else if EQ("gettable") {
673	lua_gettable(L, getnum);
674	}
675	else if EQ("settable") {
676	lua_settable(L, getnum);
677	}
678	else if EQ("next") {
679	lua_next(L, -2);
680	}
681	else if EQ("concat") {
682	lua_concat(L, getnum);
683	}
684	else if EQ("lessthan") {
685	int a = getnum;
686	lua_pushboolean(L, lua_lessthan(L, a, getnum));
687	}
688	else if EQ("equal") {
689	int a = getnum;
690	lua_pushboolean(L, lua_equal(L, a, getnum));
691	}
692	else if EQ("rawcall") {
693	int narg = getnum;
694	int nres = getnum;
695	lua_call(L, narg, nres);
696	}
697	else if EQ("call") {
698	int narg = getnum;
699	int nres = getnum;
700	lua_pcall(L, narg, nres, 0);
701	}
702	else if EQ("loadstring") {
703	size_t sl;
704	const char *s = luaL_checklstring(L, getnum, &sl);
705	luaL_loadbuffer(L, s, sl, s);
706	}
707	else if EQ("loadfile") {
708	luaL_loadfile(L, luaL_checkstring(L, getnum));
709	}
710	else if EQ("setmetatable") {
711	lua_setmetatable(L, getnum);
712	}
713	else if EQ("getmetatable") {
714	if (lua_getmetatable(L, getnum) == 0)
715	lua_pushnil(L);
716	}
717	else if EQ("type") {
718	lua_pushstring(L, lua_typename(L, lua_type(L, getnum)));
719	}
720	else if EQ("getn") {
721	int i = getnum;
722	lua_pushintegral(L, luaL_getn(L, i));
723	}
724	else if EQ("setn") {
725	int i = getnum;
726	int n = cast(int, lua_tonumber(L, -1));
727	luaL_setn(L, i, n);
728	lua_pop(L, 1);
729	}
730	else luaL_error(L, "unknown instruction %s", buff);
731	}
732	return 0;
733	}
734
735	/* }====================================================== */
736
737
738	/*
739	** {======================================================
740	** tests for yield inside hooks
741	** =======================================================
742	*/
743
744	static void yieldf (lua_State L, lua_Debug ar) {
745	lua_yield(L, 0);
746	}
747
748	static int setyhook (lua_State *L) {
749	if (lua_isnoneornil(L, 1))
750	lua_sethook(L, NULL, 0, 0); /* turn off hooks */
751	else {
752	const char *smask = luaL_checkstring(L, 1);
753	int count = luaL_optint(L, 2, 0);
754	int mask = 0;
755	if (strchr(smask, 'l')) mask \|= LUA_MASKLINE;
756	if (count > 0) mask \|= LUA_MASKCOUNT;
757	lua_sethook(L, yieldf, mask, count);
758	}
759	return 0;
760	}
761
762
763	static int coresume (lua_State *L) {
764	int status;
765	lua_State *co = lua_tothread(L, 1);
766	luaL_argcheck(L, co, 1, "coroutine expected");
767	status = lua_resume(co, 0);
768	if (status != 0) {
769	lua_pushboolean(L, 0);
770	lua_insert(L, -2);
771	return 2; /* return false + error message */
772	}
773	else {
774	lua_pushboolean(L, 1);
775	return 1;
776	}
777	}
778
779	/* }====================================================== */
780
781
782
783	static const struct luaL_reg tests_funcs[] = {
784	{"hash", hash_query},
785	{"limits", get_limits},
786	{"listcode", listcode},
787	{"listk", listk},
788	{"listlocals", listlocals},
789	{"loadlib", loadlib},
790	{"stacklevel", stacklevel},
791	{"querystr", string_query},
792	{"querytab", table_query},
793	{"doit", test_do},
794	{"testC", testC},
795	{"ref", tref},
796	{"getref", getref},
797	{"unref", unref},
798	{"d2s", d2s},
799	{"s2d", s2d},
800	{"metatable", metatable},
801	{"upvalue", upvalue},
802	{"newuserdata", newuserdata},
803	{"pushuserdata", pushuserdata},
804	{"udataval", udataval},
805	{"doonnewstack", doonnewstack},
806	{"newstate", newstate},
807	{"closestate", closestate},
808	{"doremote", doremote},
809	{"log2", log2_aux},
810	{"int2fb", int2fb_aux},
811	{"totalmem", mem_query},
812	{"resume", coresume},
813	{"setyhook", setyhook},
814	{NULL, NULL}
815	};
816
817
818	static void fim (void) {
819	if (!islocked)
820	lua_close(lua_state);
821	lua_assert(memdebug_numblocks == 0);
822	lua_assert(memdebug_total == 0);
823	}
824
825
826	static int l_panic (lua_State *L) {
827	UNUSED(L);
828	fprintf(stderr, "unable to recover; exiting\n");
829	return 0;
830	}
831
832
833	int luaB_opentests (lua_State *L) {
834	lua_atpanic(L, l_panic);
835	lua_userstateopen(L); /* init lock */
836	lua_state = L; /* keep first state to be opened */
837	luaL_openlib(L, "T", tests_funcs, 0);
838	atexit(fim);
839	return 0;
840	}
841
842
843	#undef main
844	int main (int argc, char *argv[]) {
845	char *limit = getenv("MEMLIMIT");
846	if (limit)
847	memdebug_memlimit = strtoul(limit, NULL, 10);
848	l_main(argc, argv);
849	return 0;
850	}
851
852	#endif

src/ltm.c+2−1

 /*
-** $Id: ltm.c,v 2.2 2004/02/16 19:09:52 roberto Exp $
+** $Id: ltm.c,v 2.3 2004/04/30 20:13:38 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define ltm_c
+#define LUA_CORE
 #include "lua.h"

src/lua/RCS+0−1

@@ -1 +0,0 @@
1	../RCS

src/lua/README+2−2

@@ -1,4 +1,4 @@
1	This is lua, a sample Lua interpreter.	1	This is lua, the stand-alone Lua interpreter.
2	It can be used as a batch interpreter and also interactively.	2	It can be used as a batch interpreter and also interactively.
3	There are man pages for it in both nroff and html in ../../doc.	3	There are man pages for it in both nroff and html in ../../doc.
4		4
@@ -10,7 +10,7 @@ Usage: lua [options] [script [args]]. Available options are: · 5 unmodified lines
10	-v show version information	10	-v show version information
11	-- stop handling options	11	-- stop handling options
12		12
13	This interpreter is suitable for using Lua as a standalone language; it loads	13	This interpreter is suitable for using Lua as a stand-alone language; it loads
14	all standard libraries. For a minimal interpreter, see ../../etc/min.c.	14	all standard libraries. For a minimal interpreter, see ../../etc/min.c.
15		15
16	If your application simply exports new functions to Lua (which is common),	16	If your application simply exports new functions to Lua (which is common),

src/lua/lua.c+101−146

 /*
-** $Id: lua.c,v 1.124 2003/10/23 18:06:22 roberto Exp $
+** $Id: lua.c,v 1.132 2004/08/30 18:35:14 roberto Exp $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
 #endif
-/*
-** definition of `isatty'
-*/
-#ifdef _POSIX_C_SOURCE
-#include <unistd.h>
-#define stdin_is_tty()	isatty(0)
-#else
-#define stdin_is_tty()	1  /* assume stdin is a tty */
-#endif
-#ifndef PROMPT
-#define PROMPT		"> "
-#endif
-#ifndef PROMPT2
-#define PROMPT2		">> "
-#endif
-#ifndef PROGNAME
-#define PROGNAME	"lua"
-#endif
-#ifndef lua_userinit
-#define lua_userinit(L)		openstdlibs(L)
-#endif
-#ifndef LUA_EXTRALIBS
-#define LUA_EXTRALIBS	/* empty */
-#endif
-static lua_State *L = NULL;
+static lua_State *globalL = NULL;
 static const char *progname = PROGNAME;
-static const luaL_reg lualibs[] = {
+static void lstop (lua_State *L, lua_Debug *ar) {
-  {"base", luaopen_base},
-  {"table", luaopen_table},
-  {"io", luaopen_io},
-  {"string", luaopen_string},
-  {"math", luaopen_math},
-  {"debug", luaopen_debug},
-  {"loadlib", luaopen_loadlib},
-  /* add your libraries here */
-  LUA_EXTRALIBS
-  {NULL, NULL}
-};
-static void lstop (lua_State *l, lua_Debug *ar) {
   (void)ar;  /* unused arg. */
-  lua_sethook(l, NULL, 0, 0);
+  lua_sethook(L, NULL, 0, 0);
-  luaL_error(l, "interrupted!");
+  luaL_error(L, "interrupted!");
 }
 static void laction (int i) {
   signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
                               terminate process (default action) */
-  lua_sethook(L, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
+  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
 }
 }
-static int report (int status) {
+static int report (lua_State *L, int status) {
   if (status && !lua_isnil(L, -1)) {
     const char *msg = lua_tostring(L, -1);
     if (msg == NULL) msg = "(error object is not a string)";
 }
-static int lcall (int narg, int clear) {
+static int docall (lua_State *L, int narg, int clear) {
   int status;
   int base = lua_gettop(L) - narg;  /* function index */
   lua_pushliteral(L, "_TRACEBACK");
 }
-static void getargs (char *argv[], int n) {
+static int getargs (lua_State *L, char *argv[], int n) {
-  int i;
+  int i, narg;
+  for (i=n+1; argv[i]; i++) {
+    luaL_checkstack(L, 1, "too many arguments to script");
+    lua_pushstring(L, argv[i]);
+  }
+  narg = i-(n+1);  /* number of arguments to the script (not to `lua.c') */
   lua_newtable(L);
   for (i=0; argv[i]; i++) {
-    lua_pushnumber(L, i - n);
     lua_pushstring(L, argv[i]);
-    lua_rawset(L, -3);
+    lua_rawseti(L, -2, i - n);
   }
+  return narg;
 }
-static int docall (int status) {
+static int dofile (lua_State *L, const char *name) {
-  if (status == 0) status = lcall(0, 1);
+  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
-  return report(status);
+  return report(L, status);
-}
-static int file_input (const char *name) {
-  return docall(luaL_loadfile(L, name));
 }
-static int dostring (const char *s, const char *name) {
+static int dostring (lua_State *L, const char *s, const char *name) {
-  return docall(luaL_loadbuffer(L, s, strlen(s), name));
+  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
+  return report(L, status);
 }
-static int load_file (const char *name) {
+static int dolibrary (lua_State *L, const char *name) {
-  lua_pushliteral(L, "require");
+  lua_getfield(L, LUA_GLOBALSINDEX, "_PATH");
-  lua_rawget(L, LUA_GLOBALSINDEX);
+  if (!lua_isstring(L, -1)) {
-  if (!lua_isfunction(L, -1)) {  /* no `require' defined? */
+    l_message(progname, "global _PATH must be a string");
-    lua_pop(L, 1);
+    return 1;
-    return file_input(name);
-  }
-  else {
-    lua_pushstring(L, name);
-    return report(lcall(1, 1));
   }
+  name = luaL_searchpath(L, name, lua_tostring(L, -1));
+  if (name == NULL) return report(L, 1);
+  else  return dofile(L, name);
 }
-/*
-** this macro can be used by some `history' system to save lines
-** read in manual input
-*/
-#ifndef lua_saveline
-#define lua_saveline(L,line)	/* empty */
-#endif
 /*
 ** this macro defines a function to show the prompt and reads the
 #endif
-static int readline (lua_State *l, const char *prompt) {
+static int readline (lua_State *L, const char *prompt) {
   static char buffer[MAXINPUT];
   if (prompt) {
     fputs(prompt, stdout);
   if (fgets(buffer, sizeof(buffer), stdin) == NULL)
     return 0;  /* read fails */
   else {
-    lua_pushstring(l, buffer);
+    lua_pushstring(L, buffer);
     return 1;
   }
 }
 #endif
-static const char *get_prompt (int firstline) {
+static const char *get_prompt (lua_State *L, int firstline) {
   const char *p = NULL;
   lua_pushstring(L, firstline ? "_PROMPT" : "_PROMPT2");
   lua_rawget(L, LUA_GLOBALSINDEX);
 }
-static int incomplete (int status) {
+static int incomplete (lua_State *L, int status) {
   if (status == LUA_ERRSYNTAX &&
          strstr(lua_tostring(L, -1), "near `<eof>'") != NULL) {
     lua_pop(L, 1);
 }
-static int load_string (void) {
+static int loadline (lua_State *L) {
   int status;
   lua_settop(L, 0);
-  if (lua_readline(L, get_prompt(1)) == 0)  /* no input? */
+  if (lua_readline(L, get_prompt(L, 1)) == 0)  /* no input? */
     return -1;
   if (lua_tostring(L, -1)[0] == '=') {  /* line starts with `=' ? */
     lua_pushfstring(L, "return %s", lua_tostring(L, -1)+1);/* `=' -> `return' */
   }
   for (;;) {  /* repeat until gets a complete line */
     status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
-    if (!incomplete(status)) break;  /* cannot try to add lines? */
+    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
-    if (lua_readline(L, get_prompt(0)) == 0)  /* no more input? */
+    if (lua_readline(L, get_prompt(L, 0)) == 0)  /* no more input? */
       return -1;
     lua_concat(L, lua_gettop(L));  /* join lines */
   }
 }
-static void manual_input (void) {
+static void dotty (lua_State *L) {
   int status;
   const char *oldprogname = progname;
   progname = NULL;
-  while ((status = load_string()) != -1) {
+  print_version();
-    if (status == 0) status = lcall(0, 0);
+  while ((status = loadline(L)) != -1) {
-    report(status);
+    if (status == 0) status = docall(L, 0, 0);
+    report(L, status);
     if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
       lua_getglobal(L, "print");
       lua_insert(L, 1);
 }
-static int handle_argv (char *argv[], int *interactive) {
+static int checkvar (lua_State *L) {
-  if (argv[1] == NULL) {  /* no more arguments? */
+  const char *name = lua_tostring(L, 2);
-    if (stdin_is_tty()) {
+  if (name)
-      print_version();
+    luaL_error(L, "attempt to access undefined variable `%s'", name);
-      manual_input();
+  return 0;
-    }
+}
+#define clearinteractive(i)	(*i &= 2)
+static int handle_argv (lua_State *L, char *argv[], int *interactive) {
+  if (argv[1] == NULL) {  /* no arguments? */
+    *interactive = 0;
+    if (stdin_is_tty())
+      dotty(L);
     else
-      file_input(NULL);  /* executes stdin as a file */
+      dofile(L, NULL);  /* executes stdin as a file */
   }
   else {  /* other arguments; loop over them */
     int i;
           goto endloop;  /* stop handling arguments */
         }
         case '\0': {
-          file_input(NULL);  /* executes stdin as a file */
+          clearinteractive(interactive);
+          dofile(L, NULL);  /* executes stdin as a file */
           break;
         }
         case 'i': {
-          *interactive = 1;
+          *interactive = 2;  /* force interactive mode after arguments */
           break;
         }
         case 'v': {
+          clearinteractive(interactive);
           print_version();
           break;
         }
+        case 'w': {
+          if (lua_getmetatable(L, LUA_GLOBALSINDEX)) {
+            lua_pushcfunction(L, checkvar);
+            lua_setfield(L, -2, "__index");
+          }
+          break;
+        }
         case 'e': {
           const char *chunk = argv[i] + 2;
+          clearinteractive(interactive);
           if (*chunk == '\0') chunk = argv[++i];
           if (chunk == NULL) {
             print_usage();
             return 1;
           }
-          if (dostring(chunk, "=<command line>") != 0)
+          if (dostring(L, chunk, "=<command line>") != 0)
             return 1;
           break;
         }
             print_usage();
             return 1;
           }
-          if (load_file(filename))
+          if (dolibrary(L, filename))
             return 1;  /* stop if file fails */
           break;
         }
-        case 'c': {
-          l_message(progname, "option `-c' is deprecated");
-          break;
-        }
-        case 's': {
-          l_message(progname, "option `-s' is deprecated");
-          break;
-        }
         default: {
+          clearinteractive(interactive);
           print_usage();
           return 1;
         }
     } endloop:
     if (argv[i] != NULL) {
       const char *filename = argv[i];
-      getargs(argv, i);  /* collect arguments */
+      int narg = getargs(L, argv, i);  /* collect arguments */
+      int status;
       lua_setglobal(L, "arg");
-      return file_input(filename);  /* stop scanning arguments */
+      clearinteractive(interactive);
+      status = luaL_loadfile(L, filename);
+      lua_insert(L, -(narg+1));
+      if (status == 0)
+        status = docall(L, narg, 0);
+      else
+        lua_pop(L, narg);
+      return report(L, status);
     }
   }
   return 0;
 }
-static void openstdlibs (lua_State *l) {
+static int handle_luainit (lua_State *L) {
-  const luaL_reg *lib = lualibs;
-  for (; lib->func; lib++) {
-    lib->func(l);  /* open library */
-    lua_settop(l, 0);  /* discard any results */
-  }
-}
-static int handle_luainit (void) {
   const char *init = getenv("LUA_INIT");
   if (init == NULL) return 0;  /* status OK */
   else if (init[0] == '@')
-    return file_input(init+1);
+    return dofile(L, init+1);
   else
-    return dostring(init, "=LUA_INIT");
+    return dostring(L, init, "=LUA_INIT");
 }
 };
-static int pmain (lua_State *l) {
+static int pmain (lua_State *L) {
-  struct Smain *s = (struct Smain *)lua_touserdata(l, 1);
+  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
   int status;
-  int interactive = 0;
+  int interactive = 1;
   if (s->argv[0] && s->argv[0][0]) progname = s->argv[0];
-  L = l;
+  globalL = L;
-  lua_userinit(l);  /* open libraries */
+  lua_userinit(L);  /* open libraries */
-  status = handle_luainit();
+  status = handle_luainit(L);
   if (status == 0) {
-    status = handle_argv(s->argv, &interactive);
+    status = handle_argv(L, s->argv, &interactive);
-    if (status == 0 && interactive) manual_input();
+    if (status == 0 && interactive) dotty(L);
   }
   s->status = status;
   return 0;
 int main (int argc, char *argv[]) {
   int status;
   struct Smain s;
-  lua_State *l = lua_open();  /* create state */
+  lua_State *L = lua_open();  /* create state */
-  if (l == NULL) {
+  if (L == NULL) {
     l_message(argv[0], "cannot create state: not enough memory");
     return EXIT_FAILURE;
   }
   s.argc = argc;
   s.argv = argv;
-  status = lua_cpcall(l, &pmain, &s);
+  status = lua_cpcall(L, &pmain, &s);
-  report(status);
+  report(L, status);
-  lua_close(l);
+  lua_close(L);
   return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
 }

src/luac/Makefile+1−5

 include $(LUA)/config
 INCS= -I$(INC) -I.. $(EXTRA_INCS)
-OBJS= luac.o print.o lopcodes.o
+OBJS= luac.o print.o
 SRCS= luac.c print.c
 T= $(BIN)/luac
 $T:	$(OBJS) $(LIB)/liblua.a ../lib/lauxlib.o
 	$(CC) -o $@ $(MYLDFLAGS) $(OBJS) ../lib/lauxlib.o -L$(LIB) -llua $(EXTRA_LIBS)
-# print.c needs opcode names from lopcodes.c
-lopcodes.o:	../lopcodes.c ../lopcodes.h
-	$(CC) -o $@ -c $(CFLAGS) -DLUA_OPNAMES ../lopcodes.c
 $(LIB)/liblua.a:
 	cd ..; $(MAKE)

src/luac/RCS+0−1

@@ -1 +0,0 @@
1	../RCS

src/luac/README+1−1

@@ -1,7 +1,7 @@
1	This is luac, the Lua compiler.	1	This is luac, the Lua compiler.
2	There are man pages for it in both nroff and html in ../../doc.	2	There are man pages for it in both nroff and html in ../../doc.
3		3
4	luac translates Lua programs into binary files that can be loaded latter.	4	luac translates Lua programs into binary files that can be loaded later.
5	The main advantages of pre-compiling chunks are: faster loading, protecting	5	The main advantages of pre-compiling chunks are: faster loading, protecting
6	source code from user changes, and off-line syntax error detection.	6	source code from user changes, and off-line syntax error detection.
7	luac can also be used to learn about the Lua virtual machine.	7	luac can also be used to learn about the Lua virtual machine.

src/luac/luac.c+44−31

 /*
-** $Id: luac.c,v 1.47 2004/03/24 00:25:08 lhf Exp $
+** $Id: luac.c,v 1.49 2004/09/01 21:22:34 lhf Exp $
 ** Lua compiler (saves bytecodes to files; also list bytecodes)
 ** See Copyright Notice in lua.h
 */
 #include <stdlib.h>
 #include <string.h>
+#define luac_c
+#define LUA_CORE
 #include "lua.h"
 #include "lauxlib.h"
 static void cannot(const char* what)
 {
- fprintf(stderr,"%s: cannot %s output file %s: %s\n",
+ fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
-	progname,what,output,strerror(errno));
  exit(EXIT_FAILURE);
 }
    break;
   }
   else if (IS("-"))			/* end of options; use stdin */
-   return i;
+   break;
   else if (IS("-l"))			/* list */
-   listing=1;
+   ++listing;
   else if (IS("-o"))			/* output file */
   {
    output=argv[++i];
    if (output==NULL || *output==0) usage("`-o' needs argument");
+   if (IS("-")) output=NULL;
   }
   else if (IS("-p"))			/* parse only */
    dumping=0;
  return i;
 }
-static Proto* toproto(lua_State* L, int i)
+#define toproto(L,i) (clvalue(L->top+(i))->l.p)
-{
- const Closure* c=(const Closure*)lua_topointer(L,i);
- return c->l.p;
-}
 static Proto* combine(lua_State* L, int n)
 {
   return toproto(L,-1);
  else
  {
-  int i,pc=0;
+  int i,pc;
   Proto* f=luaF_newproto(L);
   setptvalue2s(L,L->top,f); incr_top(L);
   f->source=luaS_newliteral(L,"=(" PROGNAME ")");
   f->maxstacksize=1;
+  pc=2*n+1;
+  f->code=luaM_newvector(L,pc,Instruction);
+  f->sizecode=pc;
   f->p=luaM_newvector(L,n,Proto*);
   f->sizep=n;
-  f->sizecode=2*n+1;
+  pc=0;
-  f->code=luaM_newvector(L,f->sizecode,Instruction);
   for (i=0; i<n; i++)
   {
-   f->p[i]=toproto(L,i-n);
+   f->p[i]=toproto(L,i-n-1);
    f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
    f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
   }
 static int writer(lua_State* L, const void* p, size_t size, void* u)
 {
  UNUSED(L);
- return fwrite(p,size,1,(FILE*)u)==1;
+ return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
 }
-static int panic(lua_State *L)
+void unprint(lua_State* L, const char* name);
-{
- UNUSED(L);
- fatal("not enough memory!");
- return 0;
-}
-int main(int argc, char* argv[])
+struct Smain {
+  int argc;
+  char **argv;
+};
+static int pmain(lua_State *L)
 {
- lua_State* L;
+ struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
+ int argc=s->argc;
+ char **argv=s->argv;
  Proto* f;
- int i=doargs(argc,argv);
+ int i;
- argc-=i; argv+=i;
- if (argc<=0) usage("no input files given");
- L=lua_open();
- if (L==NULL) fatal("not enough memory for state");
- lua_atpanic(L,panic);
  if (!lua_checkstack(L,argc)) fatal("too many input files");
  for (i=0; i<argc; i++)
  {
   if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
  }
  f=combine(L,argc);
- if (listing) luaU_print(f);
+ if (listing) luaU_print(f,listing>1);
  if (dumping)
  {
-  FILE* D=fopen(output,"wb");
+  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
   if (D==NULL) cannot("open");
   lua_lock(L);
   luaU_dump(L,f,writer,D,stripping);
   if (ferror(D)) cannot("write");
   if (fclose(D)) cannot("close");
  }
+ return 0;
+}
+int main(int argc, char* argv[])
+{
+ lua_State* L;
+ struct Smain s;
+ int i=doargs(argc,argv);
+ argc-=i; argv+=i;
+ if (argc<=0) usage("no input files given");
+ L=lua_open();
+ if (L==NULL) fatal("not enough memory for state");
+ s.argc=argc;
+ s.argv=argv;
+ if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
  lua_close(L);
  return EXIT_SUCCESS;
 }

src/luac/print.c+21−31

 /*
-** $Id: print.c,v 1.46 2004/03/24 00:25:08 lhf Exp $
+** $Id: print.c,v 1.48 2004/09/01 21:22:34 lhf Exp $
 ** print bytecodes
 ** See Copyright Notice in lua.h
 */
+#include <ctype.h>
 #include <stdio.h>
-#if 1
+#define LUA_CORE
-#define DEBUG_PRINT
-#endif
-#ifndef LUA_OPNAMES
-#define LUA_OPNAMES
-#endif
 #include "ldebug.h"
 #include "lobject.h"
    case '\r': printf("\\r"); break;
    case '\t': printf("\\t"); break;
    case '\v': printf("\\v"); break;
-   default: putchar(*s); break;
+   default:   printf(isprint(*s) ? "%c" : "\\%03d",*s);
   }
  }
  putchar('"');
   {
    case iABC:
     printf("%d",a);
-    if (getBMode(o)!=OpArgN)
+    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b);
-    { if (b>=MAXSTACK) printf(" #%d",b-MAXSTACK); else printf(" %d",b); }
+    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c);
-    if (getCMode(o)!=OpArgN)
-    { if (c>=MAXSTACK) printf(" #%d",c-MAXSTACK); else printf(" %d",c); }
     break;
    case iABx:
-    if (getBMode(o)==OpArgK) printf("%d #%d",a,bx); else printf("%d %d",a,bx);
+    if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx);
     break;
    case iAsBx:
     if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx);
     break;
    case OP_GETTABLE:
    case OP_SELF:
-    if (c>=MAXSTACK) { printf("\t; "); PrintConstant(f,c-MAXSTACK); }
+    if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
     break;
    case OP_SETTABLE:
    case OP_ADD:
    case OP_EQ:
    case OP_LT:
    case OP_LE:
-    if (b>=MAXSTACK || c>=MAXSTACK)
+    if (ISK(b) || ISK(c))
     {
      printf("\t; ");
-     if (b>=MAXSTACK) PrintConstant(f,b-MAXSTACK); else printf("-");
+     if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
      printf(" ");
-     if (c>=MAXSTACK) PrintConstant(f,c-MAXSTACK); else printf("-");
+     if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
     }
     break;
    case OP_JMP:
   return "(string)";
 }
-#define IsMain(f)	(f->lineDefined==0)
 #define SS(x)	(x==1)?"":"s"
 #define S(x)	x,SS(x)
 static void PrintHeader(const Proto* f)
 {
  printf("\n%s <%s:%d> (%d instruction%s, %d bytes at %p)\n",
- 	IsMain(f)?"main":"function",Source(f),f->lineDefined,
+ 	(f->lineDefined==0)?"main":"function",Source(f),f->lineDefined,
 	S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));
  printf("%d%s param%s, %d stack%s, %d upvalue%s, ",
 	f->numparams,f->is_vararg?"+":"",SS(f->numparams),S(f->maxstacksize),
 	S(f->sizelocvars),S(f->sizek),S(f->sizep));
 }
-#ifdef DEBUG_PRINT
 static void PrintConstants(const Proto* f)
 {
  int i,n=f->sizek;
  printf("constants (%d) for %p:\n",n,VOID(f));
  for (i=0; i<n; i++)
  {
-  printf("\t%d\t",i);
+  printf("\t%d\t",i+1);
   PrintConstant(f,i);
   printf("\n");
  }
   printf("\t%d\t%s\n",i,getstr(f->upvalues[i]));
  }
 }
-#endif
-void luaU_print(const Proto* f)
+void luaU_print(const Proto* f, int full)
 {
  int i,n=f->sizep;
  PrintHeader(f);
  PrintCode(f);
-#ifdef DEBUG_PRINT
+ if (full)
- PrintConstants(f);
+ {
- PrintLocals(f);
+  PrintConstants(f);
- PrintUpvalues(f);
+  PrintLocals(f);
-#endif
+  PrintUpvalues(f);
- for (i=0; i<n; i++) luaU_print(f->p[i]);
+ }
+ for (i=0; i<n; i++) luaU_print(f->p[i],full);
 }

src/lundump.c+7−6

 /*
-** $Id: lundump.c,v 1.51 2004/03/24 00:25:08 lhf Exp $
+** $Id: lundump.c,v 1.53 2004/09/01 21:22:34 lhf Exp $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #include <stddef.h>
 #define lundump_c
+#define LUA_CORE
 #include "lua.h"
 /*
 ** load precompiled chunk
 */
-Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* s)
+Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
 {
  LoadState S;
- if (*s=='@' || *s=='=')
+ if (*name=='@' || *name=='=')
-  S.name=s+1;
+  S.name=name+1;
- else if (*s==LUA_SIGNATURE[0])
+ else if (*name==LUA_SIGNATURE[0])
   S.name="binary string";
  else
-  S.name=s;
+  S.name=name;
  S.L=L;
  S.Z=Z;
  S.b=buff;

src/lundump.h+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lundump.h,v 1.32 2003/12/09 19:22:19 lhf Exp $	2	** $Id: lundump.h,v 1.33 2004/06/09 21:03:53 lhf Exp $
3	** load pre-compiled Lua chunks	3	** load pre-compiled Lua chunks
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -17,10 +17,10 @@ Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char *name); · 11 unmodified lines
17	int luaU_endianness (void);	17	int luaU_endianness (void);
18		18
19	/* dump one chunk; from ldump.c */	19	/* dump one chunk; from ldump.c */
20	int luaU_dump (lua_State* L, const Proto* Main, lua_Chunkwriter w, void* data, int strip);	20	int luaU_dump (lua_State* L, const Proto* f, lua_Chunkwriter w, void* data, int strip);
21		21
22	/* print one chunk; from print.c */	22	/* print one chunk; from print.c */
23	void luaU_print (const Proto* Main);	23	void luaU_print (const Proto* f, int full);
24		24
25	/* definitions for headers of binary files */	25	/* definitions for headers of binary files */
26	#define VERSION 0x51 /* last format change was in 5.1 */	26	#define VERSION 0x51 /* last format change was in 5.1 */

src/lvm.c+166−138

 /*
-** $Id: lvm.c,v 2.2 2004/03/16 12:31:40 roberto Exp $
+** $Id: lvm.c,v 2.13 2004/08/12 14:19:51 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 #include <stdlib.h>
 #include <string.h>
-/* needed only when `lua_number2str' uses `sprintf' */
-#include <stdio.h>
 #define lvm_c
+#define LUA_CORE
 #include "lua.h"
-/* function to convert a lua_Number to a string */
-#ifndef lua_number2str
-#define lua_number2str(s,n)     sprintf((s), LUA_NUMBER_FMT, (n))
-#endif
 /* limit for table tag-method chains (to avoid loops) */
 #define MAXTAGLOOP	100
 static void traceexec (lua_State *L, const Instruction *pc) {
   lu_byte mask = L->hookmask;
   CallInfo *ci = L->ci;
-  const Instruction *oldpc = ci->u.l.savedpc;
+  const Instruction *oldpc = ci->savedpc;
-  ci->u.l.savedpc = pc;
+  ci->savedpc = pc;
   if (mask > LUA_MASKLINE) {  /* instruction-hook set? */
     if (L->hookcount == 0) {
       resethookcount(L);
 }
-void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
+StkId luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val,
+                     const Instruction *pc) {
   int loop;
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
     const TValue *tm;
       if (!ttisnil(res) ||  /* result is no nil? */
           (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
         setobj2s(L, val, res);
-        return;
+        return L->base;
       }
       /* else will try the tag method */
     }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
+    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))) {
+      L->ci->savedpc = pc;
       luaG_typeerror(L, t, "index");
+    }
     if (ttisfunction(tm)) {
+      L->ci->savedpc = pc;
       prepTMcall(L, tm, t, key);
       callTMres(L, val);
-      return;
+      return L->base;
     }
     t = tm;  /* else repeat with `tm' */
   }
+  L->ci->savedpc = pc;
   luaG_runerror(L, "loop in gettable");
+  return NULL;  /* to avoid warnings */
 }
-void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
+StkId luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val,
+                     const Instruction *pc) {
   int loop;
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
     const TValue *tm;
       if (!ttisnil(oldval) ||  /* result is no nil? */
           (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
         setobj2t(L, oldval, val);
-        luaC_barrier(L, h, val);
+        luaC_barriert(L, h, val);
-        return;
+        return L->base;
       }
       /* else will try the tag method */
     }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
+    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) {
+      L->ci->savedpc = pc;
       luaG_typeerror(L, t, "index");
+    }
     if (ttisfunction(tm)) {
+      L->ci->savedpc = pc;
       prepTMcall(L, tm, t, key);
       setobj2s(L, L->top+3, val);  /* 3th argument */
       callTM(L);
-      return;
+      return L->base;
     }
     t = tm;  /* else repeat with `tm' */
   }
+  L->ci->savedpc = pc;
   luaG_runerror(L, "loop in settable");
+  return NULL;  /* to avoid warnings */
 }
       char *buffer;
       int i;
       while (n < total && tostring(L, top-n-1)) {  /* collect total length */
-        tl += tsvalue(top-n-1)->len;
+        size_t l = tsvalue(top-n-1)->len;
+        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
+        tl += l;
         n++;
       }
-      if (tl > MAX_SIZET) luaG_runerror(L, "string size overflow");
       buffer = luaZ_openspace(L, &G(L)->buff, tl);
       tl = 0;
       for (i=n; i>0; i--) {  /* concat all strings */
                     const TValue *rc, TMS op, const Instruction *pc) {
   TValue tempb, tempc;
   const TValue *b, *c;
-  L->ci->u.l.savedpc = pc;
+  L->ci->savedpc = pc;
   if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
       (c = luaV_tonumber(rc, &tempc)) != NULL) {
     switch (op) {
 #define RB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
 #define RC(i)	check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
 #define RKB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
-	(GETARG_B(i) < MAXSTACK) ? base+GETARG_B(i) : k+GETARG_B(i)-MAXSTACK)
+	ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
 #define RKC(i)	check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
-	(GETARG_C(i) < MAXSTACK) ? base+GETARG_C(i) : k+GETARG_C(i)-MAXSTACK)
+	ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
 #define KBx(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
-#define dojump(pc, i)	((pc) += (i))
+#define dojump(L,pc,i)	{(pc) += (i); lua_threadyield(L);}
 StkId luaV_execute (lua_State *L, int nexeccalls) {
   if (L->hookmask & LUA_MASKCALL)
     luaD_callhook(L, LUA_HOOKCALL, -1);
  retentry:  /* entry point when returning to old functions */
-  pc = L->ci->u.l.savedpc;
+  pc = L->ci->savedpc;
+  cl = &clvalue(L->ci->func)->l;
   base = L->base;
-  cl = &clvalue(base - 1)->l;
   k = cl->p->k;
   /* main loop of interpreter */
   for (;;) {
         (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
       traceexec(L, pc);  /***/
       if (L->isSuspended) {  /* did hook yield? */
-        L->ci->u.l.savedpc = pc - 1;
+        L->ci->savedpc = pc - 1;
         return NULL;
       }
       base = L->base;
     /* warning!! several calls may realloc the stack and invalidate `ra' */
     ra = RA(i);
     lua_assert(base == L->ci->base && base == L->base);
-    lua_assert(L->top <= L->stack + L->stacksize && L->top >= base);
+    lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
-    lua_assert(L->top == L->ci->top ||
+    lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
-         GET_OPCODE(i) == OP_CALL ||   GET_OPCODE(i) == OP_TAILCALL ||
-         GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO);
     switch (GET_OPCODE(i)) {
       case OP_MOVE: {
         setobjs2s(L, ra, RB(i));
-        break;
+        continue;
       }
       case OP_LOADK: {
         setobj2s(L, ra, KBx(i));
-        break;
+        continue;
       }
       case OP_LOADBOOL: {
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
-        break;
+        continue;
       }
       case OP_LOADNIL: {
         TValue *rb = RB(i);
         do {
           setnilvalue(rb--);
         } while (rb >= ra);
-        break;
+        continue;
       }
       case OP_GETUPVAL: {
         int b = GETARG_B(i);
         setobj2s(L, ra, cl->upvals[b]->v);
-        break;
+        continue;
       }
       case OP_GETGLOBAL: {
         TValue *rb = KBx(i);
         lua_assert(ttisstring(rb) && ttistable(&cl->g));
-        L->ci->u.l.savedpc = pc;
+        base = luaV_gettable(L, &cl->g, rb, ra, pc);  /***/
-        luaV_gettable(L, &cl->g, rb, ra);  /***/
+        continue;
-        base = L->base;
-        break;
       }
       case OP_GETTABLE: {
-        L->ci->u.l.savedpc = pc;
+        base = luaV_gettable(L, RB(i), RKC(i), ra, pc);  /***/
-        luaV_gettable(L, RB(i), RKC(i), ra);  /***/
+        continue;
-        base = L->base;
-        break;
       }
       case OP_SETGLOBAL: {
         lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g));
-        L->ci->u.l.savedpc = pc;
+        base = luaV_settable(L, &cl->g, KBx(i), ra, pc);  /***/
-        luaV_settable(L, &cl->g, KBx(i), ra);  /***/
+        continue;
-        base = L->base;
-        break;
       }
       case OP_SETUPVAL: {
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
         luaC_barrier(L, uv, ra);
-        break;
+        continue;
       }
       case OP_SETTABLE: {
-        L->ci->u.l.savedpc = pc;
+        base = luaV_settable(L, ra, RKB(i), RKC(i), pc);  /***/
-        luaV_settable(L, ra, RKB(i), RKC(i));  /***/
+        continue;
-        base = L->base;
-        break;
       }
       case OP_NEWTABLE: {
         int b = GETARG_B(i);
         b = fb2int(b);
         sethvalue(L, ra, luaH_new(L, b, GETARG_C(i)));
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         luaC_checkGC(L);  /***/
         base = L->base;
-        break;
+        continue;
       }
       case OP_SELF: {
         StkId rb = RB(i);
         setobjs2s(L, ra+1, rb);
-        L->ci->u.l.savedpc = pc;
+        base = luaV_gettable(L, rb, RKC(i), ra, pc);  /***/
-        luaV_gettable(L, rb, RKC(i), ra);  /***/
+        continue;
-        base = L->base;
-        break;
       }
       case OP_ADD: {
         TValue *rb = RKB(i);
         }
         else
           base = Arith(L, ra, rb, rc, TM_ADD, pc);  /***/
-        break;
+        continue;
       }
       case OP_SUB: {
         TValue *rb = RKB(i);
         }
         else
           base = Arith(L, ra, rb, rc, TM_SUB, pc);  /***/
-        break;
+        continue;
       }
       case OP_MUL: {
         TValue *rb = RKB(i);
         }
         else
           base = Arith(L, ra, rb, rc, TM_MUL, pc);  /***/
-        break;
+        continue;
       }
       case OP_DIV: {
         TValue *rb = RKB(i);
         }
         else
           base = Arith(L, ra, rb, rc, TM_DIV, pc);  /***/
-        break;
+        continue;
       }
       case OP_POW: {
         base = Arith(L, ra, RKB(i), RKC(i), TM_POW, pc);  /***/
-        break;
+        continue;
       }
       case OP_UNM: {
         const TValue *rb = RB(i);
         }
         else {
           setnilvalue(&temp);
-          L->ci->u.l.savedpc = pc;
+          L->ci->savedpc = pc;
           if (!call_binTM(L, RB(i), &temp, ra, TM_UNM))  /***/
             luaG_aritherror(L, RB(i), &temp);
           base = L->base;
         }
-        break;
+        continue;
       }
       case OP_NOT: {
         int res = l_isfalse(RB(i));  /* next assignment may change this value */
         setbvalue(ra, res);
-        break;
+        continue;
       }
       case OP_CONCAT: {
         int b = GETARG_B(i);
         int c = GETARG_C(i);
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         luaV_concat(L, c-b+1, c);  /* may change `base' (and `ra') */  /***/
         luaC_checkGC(L);  /***/
         base = L->base;
         setobjs2s(L, RA(i), base+b);
-        break;
+        continue;
       }
       case OP_JMP: {
-        dojump(pc, GETARG_sBx(i));
+        dojump(L, pc, GETARG_sBx(i));
-        break;
+        continue;
       }
       case OP_EQ: {
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         if (equalobj(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;  /***/
-        else dojump(pc, GETARG_sBx(*pc) + 1);
+        else dojump(L, pc, GETARG_sBx(*pc) + 1);
         base = L->base;
-        break;
+        continue;
       }
       case OP_LT: {
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;  /***/
-        else dojump(pc, GETARG_sBx(*pc) + 1);
+        else dojump(L, pc, GETARG_sBx(*pc) + 1);
         base = L->base;
-        break;
+        continue;
       }
       case OP_LE: {
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;  /***/
-        else dojump(pc, GETARG_sBx(*pc) + 1);
+        else dojump(L, pc, GETARG_sBx(*pc) + 1);
         base = L->base;
-        break;
+        continue;
       }
       case OP_TEST: {
         TValue *rb = RB(i);
         if (l_isfalse(rb) == GETARG_C(i)) pc++;
         else {
           setobjs2s(L, ra, rb);
-          dojump(pc, GETARG_sBx(*pc) + 1);
+          dojump(L, pc, GETARG_sBx(*pc) + 1);
         }
-        break;
+        continue;
       }
-      case OP_CALL:
+      case OP_CALL: {  /***/
-      case OP_TAILCALL: {  /***/
+        int pcr;
-        StkId firstResult;
         int b = GETARG_B(i);
+        int nresults = GETARG_C(i) - 1;
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
-        firstResult = luaD_precall(L, ra);
+        pcr = luaD_precall(L, ra, nresults);
-        if (firstResult) {
+        if (pcr == PCRLUA) {
-          int nresults = GETARG_C(i) - 1;
+          nexeccalls++;
-          if (firstResult > L->top) {  /* yield? */
+          goto callentry;  /* restart luaV_execute over new Lua function */
-            (L->ci - 1)->u.l.savedpc = pc;
+        }
-            return NULL;
+        else if (pcr == PCRC) {
-          }
           /* it was a C function (`precall' called it); adjust results */
-          luaD_poscall(L, nresults, firstResult);
           if (nresults >= 0) L->top = L->ci->top;
+          base = L->base;
+          continue;
         }
-        else {  /* it is a Lua function */
+        else {
-          if (GET_OPCODE(i) == OP_CALL)  /* regular call? */
+          lua_assert(pcr == PCRYIELD);
-            nexeccalls++;
+          return NULL;
-          else {  /* tail call: put new frame in place of previous one */
+        }
-            int aux;
+      }
-            base = (L->ci - 1)->base;  /* `luaD_precall' may change the stack */
+      case OP_TAILCALL: {  /***/
-            ra = RA(i);
+        int pcr;
-            if (L->openupval) luaF_close(L, base);
+        int b = GETARG_B(i);
-            for (aux = 0; ra+aux < L->top; aux++)  /* move frame down */
+        if (b != 0) L->top = ra+b;  /* else previous instruction set top */
-              setobjs2s(L, base+aux-1, ra+aux);
+        L->ci->savedpc = pc;
-            (L->ci - 1)->top = L->top = base+aux;  /* correct top */
+        lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
-            (L->ci - 1)->u.l.savedpc = L->ci->u.l.savedpc;
+        pcr = luaD_precall(L, ra, LUA_MULTRET);
-            (L->ci - 1)->u.l.tailcalls++;  /* one more call lost */
+        if (pcr == PCRLUA) {
-            L->ci--;  /* remove new frame */
+          /* tail call: put new frame in place of previous one */
-            L->base = L->ci->base;
+          CallInfo *ci = L->ci - 1;  /* previous frame */
-          }
+          int aux;
+          StkId func = ci->func;
+          StkId pfunc = (ci+1)->func;  /* previous function index */
+          base = ci->base = ci->func + ((ci+1)->base - pfunc);
+          L->base = base;
+          if (L->openupval) luaF_close(L, base);
+          for (aux = 0; pfunc+aux < L->top; aux++)  /* move frame down */
+            setobjs2s(L, func+aux, pfunc+aux);
+          ci->top = L->top = func+aux;  /* correct top */
+          lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
+          ci->savedpc = L->ci->savedpc;
+          ci->tailcalls++;  /* one more call lost */
+          L->ci--;  /* remove new frame */
           goto callentry;
         }
-        base = L->base;
+        else if (pcr == PCRC) {
-        break;
+          /* it was a C function (`precall' called it) */
+          base = L->base;
+          continue;
+        }
+        else {
+          lua_assert(pcr == PCRYIELD);
+          return NULL;
+        }
       }
       case OP_RETURN: {
         CallInfo *ci = L->ci - 1;  /* previous function frame */
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b-1;
         if (L->openupval) luaF_close(L, base);
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         if (--nexeccalls == 0)  /* was previous function running `here'? */
           return ra;  /* no: return */
         else {  /* yes: continue its execution */
-          int nresults;
+          int nresults = (ci+1)->nresults;
           lua_assert(isLua(ci));
-          lua_assert(GET_OPCODE(*(ci->u.l.savedpc - 1)) == OP_CALL);
+          lua_assert(GET_OPCODE(*(ci->savedpc - 1)) == OP_CALL);
-          nresults = GETARG_C(*(ci->u.l.savedpc - 1)) - 1;
           luaD_poscall(L, nresults, ra);
           if (nresults >= 0) L->top = L->ci->top;
           goto retentry;
         lua_Number idx = nvalue(ra) + step;  /* increment index */
         lua_Number limit = nvalue(ra+1);
         if (step > 0 ? idx <= limit : idx >= limit) {
-          dojump(pc, GETARG_sBx(i));  /* jump back */
+          dojump(L, pc, GETARG_sBx(i));  /* jump back */
           setnvalue(ra, idx);  /* update internal index... */
           setnvalue(ra+3, idx);  /* ...and external index */
         }
-        break;
+        continue;
       }
       case OP_FORPREP: {  /***/
         const TValue *init = ra;
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         if (!tonumber(init, ra))
           luaG_runerror(L, "`for' initial value must be a number");
         else if (!tonumber(plimit, ra+1))
         else if (!tonumber(pstep, ra+2))
           luaG_runerror(L, "`for' step must be a number");
         setnvalue(ra, nvalue(ra) - nvalue(pstep));
-        dojump(pc, GETARG_sBx(i));
+        dojump(L, pc, GETARG_sBx(i));
-        break;
+        continue;
       }
       case OP_TFORLOOP: {
         StkId cb = ra + 3;  /* call base */
         setobjs2s(L, cb+1, ra+1);
         setobjs2s(L, cb, ra);
         L->top = cb+3;  /* func. + 2 args (state and index) */
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         luaD_call(L, cb, GETARG_C(i));  /***/
         L->top = L->ci->top;
         base = L->base;
           pc++;  /* skip jump (break loop) */
         else {
           setobjs2s(L, cb-1, cb);  /* save control variable */
-          dojump(pc, GETARG_sBx(*pc) + 1);  /* jump back */
+          dojump(L, pc, GETARG_sBx(*pc) + 1);  /* jump back */
         }
-        break;
+        continue;
       }
       case OP_TFORPREP: {  /* for compatibility only */
         if (ttistable(ra)) {
           setobjs2s(L, ra+1, ra);
           setobj2s(L, ra, luaH_getstr(hvalue(gt(L)), luaS_new(L, "next")));
         }
-        dojump(pc, GETARG_sBx(i));
+        dojump(L, pc, GETARG_sBx(i));
-        break;
+        continue;
       }
       case OP_SETLIST:
       case OP_SETLISTO: {
-        int bc;
+        int bc = GETARG_Bx(i);
-        int n;
+        int n, last;
         Table *h;
         runtime_check(L, ttistable(ra));
         h = hvalue(ra);
-        bc = GETARG_Bx(i);
         if (GET_OPCODE(i) == OP_SETLIST)
           n = (bc&(LFIELDS_PER_FLUSH-1)) + 1;
         else {
           L->top = L->ci->top;
         }
         bc &= ~(LFIELDS_PER_FLUSH-1);  /* bc = bc - bc%FPF */
+        last = bc + 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--) {
           TValue *val = ra+n;
-          setobj2t(L, luaH_setnum(L, h, bc+n), val);
+          setobj2t(L, luaH_setnum(L, h, last--), val);
-          luaC_barrier(L, h, val);
+          luaC_barriert(L, h, val);
         }
-        break;
+        continue;
       }
       case OP_CLOSE: {
         luaF_close(L, ra);
-        break;
+        continue;
       }
       case OP_CLOSURE: {
         Proto *p;
           }
         }
         setclvalue(L, ra, ncl);
-        L->ci->u.l.savedpc = pc;
+        L->ci->savedpc = pc;
         luaC_checkGC(L);  /***/
         base = L->base;
-        break;
+        continue;
+      }
+      case OP_VARARG: {
+        int b = GETARG_B(i) - 1;
+        int j;
+        CallInfo *ci = L->ci;
+        int n = ci->base - ci->func - cl->p->numparams - 1;
+        if (b == LUA_MULTRET) {
+          b = n;
+          L->top = ra + n;
+        }
+        for (j=0; j<b && j<n; j++)
+          setobjs2s(L, ra+j, ci->base - n + j);
+        for (; j<b; j++)
+          setnilvalue(ra+j);
+        continue;
       }
     }
   }

src/lvm.h+5−3

 /*
-** $Id: lvm.h,v 2.1 2003/12/10 12:13:36 roberto Exp $
+** $Id: lvm.h,v 2.2 2004/05/14 19:25:09 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
 const TValue *luaV_tonumber (const TValue *obj, TValue *n);
 int luaV_tostring (lua_State *L, StkId obj);
-void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val);
+StkId luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val,
-void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val);
+                     const Instruction *pc);
+StkId luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val,
+                     const Instruction *pc);
 StkId luaV_execute (lua_State *L, int nexeccalls);
 void luaV_concat (lua_State *L, int total, int last);

src/lzio.c+2−1

 /*
-** $Id: lzio.c,v 1.28 2003/11/18 10:44:53 roberto Exp $
+** $Id: lzio.c,v 1.29 2004/04/30 20:13:38 roberto Exp $
 ** a generic input stream interface
 ** See Copyright Notice in lua.h
 */
 #include <string.h>
 #define lzio_c
+#define LUA_CORE
 #include "lua.h"