Lua 5.2.0-rc1

Lua Team committed 14 years ago

Commit d74d0e51 parent 8203bab51 files · +1861 −1136Browse files

Unified · Split

51 files

Makefile +2 −2
README +1 −1
doc/alert.png +0 −0
doc/contents.html +9 −11
doc/lua.1 +116 −0
doc/lua.css +2 −3
doc/luac.1 +118 −0
doc/manual.css +5 −2
doc/manual.html +588 −438
doc/readme.html +61 −49
src/Makefile +1 −0
src/lapi.c +88 −37
src/lauxlib.c +31 −10
src/lauxlib.h +31 −2
src/lbaselib.c +45 −35
src/lcode.c +12 −10
src/lcode.h +2 −1
src/lcorolib.c +2 −2
src/lctype.c +4 −1
src/lctype.h +2 −2
src/ldblib.c +4 −7
src/ldebug.c +104 −96
src/ldebug.h +10 −10
src/ldo.c +17 −17
src/ldo.h +2 −2
src/ldump.c +3 −3
src/lgc.c +96 −46
src/lgc.h +1 −5
src/liolib.c +74 −30
src/llex.c +40 −47
src/llimits.h +16 −4
src/lmem.c +2 −2
src/loadlib.c +71 −33
src/lobject.c +6 −4
src/lobject.h +46 −22
src/lopcodes.h +2 −2
src/lparser.c +90 −70
src/lparser.h +6 −7
src/lstate.c +5 −8
src/lstate.h +2 −4
src/lstrlib.c +15 −6
src/ltable.c +25 −36
src/ltable.h +5 −3
src/ltablib.c +2 −2
src/lua.c +39 −12
src/lua.h +7 −10
src/luac.c +3 −4
src/luaconf.h +16 −11
src/lvm.c +29 −20
src/lzio.c +2 −2
src/lzio.h +2 −6

@@ -62,13 +62,13 @@ install: dummy · 61 unmodified lines
62	cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)	62	cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
63	cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)	63	cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
64	cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)	64	cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
65	#cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)	65	cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
66		66
67	uninstall:	67	uninstall:
68	cd src && cd $(INSTALL_BIN) && $(RM) $(TO_BIN)	68	cd src && cd $(INSTALL_BIN) && $(RM) $(TO_BIN)
69	cd src && cd $(INSTALL_INC) && $(RM) $(TO_INC)	69	cd src && cd $(INSTALL_INC) && $(RM) $(TO_INC)
70	cd src && cd $(INSTALL_LIB) && $(RM) $(TO_LIB)	70	cd src && cd $(INSTALL_LIB) && $(RM) $(TO_LIB)
71	#cd doc && cd $(INSTALL_MAN) && $(RM) $(TO_MAN)	71	cd doc && cd $(INSTALL_MAN) && $(RM) $(TO_MAN)
72		72
73	local:	73	local:
74	$(MAKE) install INSTALL_TOP=../install	74	$(MAKE) install INSTALL_TOP=../install

README+1−1

@@ -1,5 +1,5 @@
1		1
2	This is Lua 5.2 (beta), released on 05 Jul 2011.	2	This is Lua 5.2, released on 24 Nov 2011.
3		3
4	For installation instructions, license details, and	4	For installation instructions, license details, and
5	further information about Lua, see doc/readme.html.	5	further information about Lua, see doc/readme.html.

doc/alert.png+0−0

Binary file not shown.

doc/contents.html+9−11

 Lua 5.2 Reference Manual
 </H1>
-<P>
-<IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
-<EM>This is a beta version of Lua 5.2.
-Some details may change in the final version.</EM>
 <P>
 The reference manual is the official definition of the Lua language.
 For a complete introduction to Lua programming, see the book
 <UL>
 <LI><A HREF="manual.html#4.1">4.1 &ndash; The Stack</A>
 <LI><A HREF="manual.html#4.2">4.2 &ndash; Stack Size</A>
-<LI><A HREF="manual.html#4.3">4.3 &ndash; Pseudo-Indices</A>
+<LI><A HREF="manual.html#4.3">4.3 &ndash; Valid and Acceptable Indices</A>
 <LI><A HREF="manual.html#4.4">4.4 &ndash; C Closures</A>
 <LI><A HREF="manual.html#4.5">4.5 &ndash; Registry</A>
 <LI><A HREF="manual.html#4.6">4.6 &ndash; Error Handling in C</A>
 <A HREF="manual.html#pdf-error">error</A><BR>
 <A HREF="manual.html#pdf-getmetatable">getmetatable</A><BR>
 <A HREF="manual.html#pdf-ipairs">ipairs</A><BR>
-<A HREF="manual.html#pdf-load">load</A><BR>
 <A HREF="manual.html#pdf-loadfile">loadfile</A><BR>
+<A HREF="manual.html#pdf-load">load</A><BR>
 <A HREF="manual.html#pdf-next">next</A><BR>
 <A HREF="manual.html#pdf-pairs">pairs</A><BR>
 <A HREF="manual.html#pdf-pcall">pcall</A><BR>
 <A HREF="manual.html#lua_rawlen">lua_rawlen</A><BR>
 <A HREF="manual.html#lua_rawset">lua_rawset</A><BR>
 <A HREF="manual.html#lua_rawseti">lua_rawseti</A><BR>
+<A HREF="manual.html#lua_rawgetp">lua_rawgetp</A><BR>
+<A HREF="manual.html#lua_rawsetp">lua_rawsetp</A><BR>
 <A HREF="manual.html#lua_register">lua_register</A><BR>
 <A HREF="manual.html#lua_remove">lua_remove</A><BR>
 <A HREF="manual.html#lua_replace">lua_replace</A><BR>
 <A HREF="manual.html#luaL_buffinitsize">luaL_buffinitsize</A><BR>
 <A HREF="manual.html#luaL_callmeta">luaL_callmeta</A><BR>
 <A HREF="manual.html#luaL_checkany">luaL_checkany</A><BR>
-<A HREF="manual.html#luaL_checkint">luaL_checkint</A><BR>
 <A HREF="manual.html#luaL_checkinteger">luaL_checkinteger</A><BR>
+<A HREF="manual.html#luaL_checkint">luaL_checkint</A><BR>
 <A HREF="manual.html#luaL_checklong">luaL_checklong</A><BR>
 <A HREF="manual.html#luaL_checklstring">luaL_checklstring</A><BR>
 <A HREF="manual.html#luaL_checknumber">luaL_checknumber</A><BR>
 <A HREF="manual.html#luaL_len">luaL_len</A><BR>
 <A HREF="manual.html#luaL_loadbuffer">luaL_loadbuffer</A><BR>
 <A HREF="manual.html#luaL_loadfile">luaL_loadfile</A><BR>
+<A HREF="manual.html#luaL_loadfilex">luaL_loadfilex</A><BR>
 <A HREF="manual.html#luaL_loadstring">luaL_loadstring</A><BR>
 <A HREF="manual.html#luaL_newlib">luaL_newlib</A><BR>
 <A HREF="manual.html#luaL_newlibtable">luaL_newlibtable</A><BR>
 <A HREF="manual.html#luaL_newmetatable">luaL_newmetatable</A><BR>
 <A HREF="manual.html#luaL_newstate">luaL_newstate</A><BR>
 <A HREF="manual.html#luaL_openlibs">luaL_openlibs</A><BR>
-<A HREF="manual.html#luaL_optint">luaL_optint</A><BR>
 <A HREF="manual.html#luaL_optinteger">luaL_optinteger</A><BR>
+<A HREF="manual.html#luaL_optint">luaL_optint</A><BR>
 <A HREF="manual.html#luaL_optlong">luaL_optlong</A><BR>
 <A HREF="manual.html#luaL_optlstring">luaL_optlstring</A><BR>
 <A HREF="manual.html#luaL_optnumber">luaL_optnumber</A><BR>
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Tue Jun 28 14:53:13 BRT 2011
+Wed Nov 23 16:14:28 BRST 2011
 </SMALL>
 <!--
-Last change: revised for Lua 5.2.0 (beta)
+Last change: revised for Lua 5.2.0
 -->
 </BODY>

doc/lua.1+116−0

@@ -0,0 +1,116 @@
	1	.\" $Id: lua.man,v 1.13 2011/11/16 17:16:53 lhf Exp $
	2	.TH LUA 1 "$Date: 2011/11/16 17:16:53 $"
	3	.SH NAME
	4	lua \- Lua interpreter
	5	.SH SYNOPSIS
	6	.B lua
	7	[
	8	.I options
	9	]
	10	[
	11	.I script
	12	[
	13	.I args
	14	]
	15	]
	16	.SH DESCRIPTION
	17	.B lua
	18	is the standalone Lua interpreter.
	19	It loads and executes Lua programs,
	20	either in textual source form or
	21	in precompiled binary form.
	22	(Precompiled binaries are output by
	23	.BR luac ,
	24	the Lua compiler.)
	25	.B lua
	26	can be used as a batch interpreter and also interactively.
	27	.LP
	28	The given
	29	.I options
	30	are handled in order and then
	31	the Lua program in file
	32	.I script
	33	is loaded and executed.
	34	The given
	35	.I args
	36	are available to
	37	.I script
	38	as strings in a global table named
	39	.BR arg .
	40	If no options or arguments are given,
	41	then
	42	.B "\-v \-i"
	43	is assumed when the standard input is a terminal;
	44	otherwise,
	45	.B "\-"
	46	is assumed.
	47	.LP
	48	In interactive mode,
	49	.B lua
	50	prompts the user,
	51	reads lines from the standard input,
	52	and executes them as they are read.
	53	If a line does not contain a complete statement,
	54	then a secondary prompt is displayed and
	55	lines are read until a complete statement is formed or
	56	a syntax error is found.
	57	If a line starts with
	58	.BR '=' ,
	59	then
	60	.B lua
	61	evaluates and displays
	62	the values of the expressions in the remainder of the line.
	63	.LP
	64	At the very start,
	65	before even handling the command line,
	66	.B lua
	67	checks the contents of the environment variables
	68	.B LUA_INIT_5_2
	69	or
	70	.BR LUA_INIT ,
	71	in that order.
	72	If the contents is of the form
	73	.RI '@ filename ',
	74	then
	75	.I filename
	76	is executed.
	77	Otherwise, the string is assumed to be a Lua statement and is executed.
	78	.SH OPTIONS
	79	.TP
	80	.BI \-e " stat"
	81	execute statement
	82	.IR stat .
	83	.TP
	84	.B \-i
	85	enter interactive mode after executing
	86	.IR script .
	87	.TP
	88	.BI \-l " name"
	89	execute the equivalent of
	90	.IB name =require(' name ')
	91	before executing
	92	.IR script .
	93	.TP
	94	.B \-v
	95	show version information.
	96	.TP
	97	.B \-E
	98	ignore environment variables.
	99	.TP
	100	.B \-\-
	101	stop handling options.
	102	.TP
	103	.B \-
	104	stop handling options and execute the standard input as a file.
	105	.SH "SEE ALSO"
	106	.BR luac (1)
	107	.br
	108	The documentation at lua.org,
	109	especially section 7 of the reference manual.
	110	.SH DIAGNOSTICS
	111	Error messages should be self explanatory.
	112	.SH AUTHORS
	113	R. Ierusalimschy,
	114	L. H. de Figueiredo,
	115	W. Celes
	116	.\" EOF

doc/lua.css+2−3

 body {
 	color: #000000 ;
 	background-color: #FFFFFF ;
-	font-family: sans-serif ;
 	font-family: Helvetica, Arial, sans-serif ;
 	text-align: justify ;
 	margin-right: 20px ;
 	padding-top: 0.4em ;
 	padding-bottom: 0.4em ;
 	padding-left: 20px ;
+	padding-right: 20px ;
 	margin-left: -20px ;
 	background-color: #E0E0FF ;
 }
 h3 {
-	padding-left: 8px ;
+	padding-left: 0.5em ;
 	border-left: solid #E0E0FF 1em ;
 }
 	-moz-border-radius: 2em ;
 	background-image: url('images/search.png') ;
 	background-repeat: no-repeat;
-	background-position: left center ;
 	background-position: 4px center ;
 	padding-left: 20px ;
 	height: 2em ;

doc/luac.1+118−0

@@ -0,0 +1,118 @@
	1	.\" $Id: luac.man,v 1.29 2011/11/16 13:53:40 lhf Exp $
	2	.TH LUAC 1 "$Date: 2011/11/16 13:53:40 $"
	3	.SH NAME
	4	luac \- Lua compiler
	5	.SH SYNOPSIS
	6	.B luac
	7	[
	8	.I options
	9	] [
	10	.I filenames
	11	]
	12	.SH DESCRIPTION
	13	.B luac
	14	is the Lua compiler.
	15	It translates programs written in the Lua programming language
	16	into binary files containing precompiled chunks
	17	that can be later loaded and executed.
	18	.LP
	19	The main advantages of precompiling chunks are:
	20	faster loading,
	21	protecting source code from accidental user changes,
	22	and
	23	off-line syntax checking.
	24	Precompiling does not imply faster execution
	25	because in Lua chunks are always compiled into bytecodes before being executed.
	26	.B luac
	27	simply allows those bytecodes to be saved in a file for later execution.
	28	Precompiled chunks are not necessarily smaller than the corresponding source.
	29	The main goal in precompiling is faster loading.
	30	.LP
	31	In the command line,
	32	you can mix
	33	text files containing Lua source and
	34	binary files containing precompiled chunks.
	35	.B luac
	36	produces a single output file containing the combined bytecodes
	37	for all files given.
	38	Executing the combined file is equivalent to executing the given files.
	39	By default,
	40	the output file is named
	41	.BR luac.out ,
	42	but you can change this with the
	43	.B \-o
	44	option.
	45	.LP
	46	Precompiled chunks are
	47	.I not
	48	portable across different architectures.
	49	Moreover,
	50	the internal format of precompiled chunks
	51	is likely to change when a new version of Lua is released.
	52	Make sure you save the source files of all Lua programs that you precompile.
	53	.LP
	54	.SH OPTIONS
	55	.TP
	56	.B \-l
	57	produce a listing of the compiled bytecode for Lua's virtual machine.
	58	Listing bytecodes is useful to learn about Lua's virtual machine.
	59	If no files are given, then
	60	.B luac
	61	loads
	62	.B luac.out
	63	and lists its contents.
	64	Use
	65	.B \-l \-l
	66	for a full listing.
	67	.TP
	68	.BI \-o " file"
	69	output to
	70	.IR file ,
	71	instead of the default
	72	.BR luac.out .
	73	(You can use
	74	.B "'\-'"
	75	for standard output,
	76	but not on platforms that open standard output in text mode.)
	77	The output file may be one of the given files because
	78	all files are loaded before the output file is written.
	79	Be careful not to overwrite precious files.
	80	.TP
	81	.B \-p
	82	load files but do not generate any output file.
	83	Used mainly for syntax checking and for testing precompiled chunks:
	84	corrupted files will probably generate errors when loaded.
	85	If no files are given, then
	86	.B luac
	87	loads
	88	.B luac.out
	89	and tests its contents.
	90	No messages are displayed if the file loads without errors.
	91	.TP
	92	.B \-s
	93	strip debug information before writing the output file.
	94	This saves some space in very large chunks,
	95	but if errors occur when running a stripped chunk,
	96	then the error messages may not contain the full information they usually do.
	97	In particular,
	98	line numbers and names of local variables are lost.
	99	.TP
	100	.B \-v
	101	show version information.
	102	.TP
	103	.B \-\-
	104	stop handling options.
	105	.TP
	106	.B \-
	107	stop handling options and process standard input.
	108	.SH "SEE ALSO"
	109	.BR lua (1)
	110	.br
	111	The documentation at lua.org.
	112	.SH DIAGNOSTICS
	113	Error messages should be self explanatory.
	114	.SH AUTHORS
	115	R. Ierusalimschy,
	116	L. H. de Figueiredo,
	117	W. Celes
	118	.\" EOF

doc/manual.css+5−2

 	font-family: inherit ;
 }
-pre {
+pre, code {
-	font-size: 105% ;
+	font-size: 12pt ;
 }
 span.apii {
 	float: right ;
 	font-family: inherit ;
+	font-style: normal ;
+	font-size: small ;
+	color: gray ;
 }
 p+h1, ul+h1 {

doc/manual.html+588−438

@@ -16,11 +16,6 @@ · 15 unmodified lines
16	Lua 5.2 Reference Manual	16	Lua 5.2 Reference Manual
17	</h1>	17	</h1>
18		18
19	<IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
20	<EM>This is a beta version of Lua 5.2.
21	Some details may change in the final version.</EM>
22	<P>
23
24	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes	19	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
25	<p>	20	<p>
26	<small>	21	<small>
@@ -38,7 +33,7 @@ Freely available under the terms of the · 11 unmodified lines
38	<!-- ====================================================================== -->	33	<!-- ====================================================================== -->
39	<p>	34	<p>
40		35
41	<!-- $Id: manual.of,v 1.86 2011/07/08 20:00:45 roberto Exp $ -->	36	<!-- $Id: manual.of,v 1.88 2011/11/24 13:23:53 roberto Exp $ -->
42		37
43		38
44		39
@@ -51,8 +46,8 @@ general procedural programming with data description · 6 unmodified lines
51	facilities.	46	facilities.
52	It also offers good support for object-oriented programming,	47	It also offers good support for object-oriented programming,
53	functional programming, and data-driven programming.	48	functional programming, and data-driven programming.
54	Lua is intended to be used as a powerful, light-weight	49	Lua is intended to be used as a powerful, lightweight,
55	scripting language for any program that needs one.	50	embeddable scripting language for any program that needs one.
56	Lua is implemented as a library, written in <em>clean C</em>,	51	Lua is implemented as a library, written in <em>clean C</em>,
57	the common subset of Standard C and C++.	52	the common subset of Standard C and C++.
58		53
@@ -86,14 +81,14 @@ this document is dry in places. · 27 unmodified lines
86	For a discussion of the decisions behind the design of Lua,	81	For a discussion of the decisions behind the design of Lua,
87	see the technical papers available at Lua's web site.	82	see the technical papers available at Lua's web site.
88	For a detailed introduction to programming in Lua,	83	For a detailed introduction to programming in Lua,
89	see Roberto's book, <em>Programming in Lua</em> (second edition).	84	see Roberto's book, <em>Programming in Lua</em>.
90		85
91		86
92		87
93	<h1>2 – <a name="2">Basic Concepts</a></h1>	88	<h1>2 – <a name="2">Basic Concepts</a></h1>
94		89
95	<p>	90	<p>
96	This section describes some basic concepts of the language.	91	This section describes the basic concepts of the language.
97		92
98		93
99		94
@@ -148,11 +143,14 @@ functions written in C · 48 unmodified lines
148	<p>	143	<p>
149	The type <em>userdata</em> is provided to allow arbitrary C data to	144	The type <em>userdata</em> is provided to allow arbitrary C data to
150	be stored in Lua variables.	145	be stored in Lua variables.
151	This type corresponds to a block of raw memory	146	A userdata value is a pointer to a block of raw memory.
152	and has no pre-defined operations in Lua,	147	There are two kinds of userdata:
		148	full userdata, where the block of memory is managed by Lua,
		149	and light userdata, where the block of memory is managed by the host.
		150	Userdata has no predefined operations in Lua,
153	except assignment and identity test.	151	except assignment and identity test.
154	However, by using <em>metatables</em>,	152	By using <em>metatables</em>,
155	the programmer can define operations for userdata values	153	the programmer can define operations for full userdata values
156	(see <a href="#2.4">§2.4</a>).	154	(see <a href="#2.4">§2.4</a>).
157	Userdata values cannot be created or modified in Lua,	155	Userdata values cannot be created or modified in Lua,
158	only through the C API.	156	only through the C API.
@@ -200,7 +198,7 @@ which is called the length of the sequence (see <a href="#3.4.6">§3.4.6</a> · 41 unmodified lines
200		198
201	<p>	199	<p>
202	Like indices,	200	Like indices,
203	the value of a table field can be of any type.	201	the values of table fields can be of any type.
204	In particular,	202	In particular,
205	because functions are first-class values,	203	because functions are first-class values,
206	table fields can contain functions.	204	table fields can contain functions.
@@ -227,7 +225,7 @@ these operations do not imply any kind of copy. · 20 unmodified lines
227		225
228	<p>	226	<p>
229	The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type	227	The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
230	of a given value.	228	of a given value (see <a href="#6.1">§6.1</a>).
231		229
232		230
233		231
@@ -239,8 +237,8 @@ of a given value. · 5 unmodified lines
239	As will be discussed in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,	237	As will be discussed in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,
240	any reference to a global name <code>var</code> is syntactically translated	238	any reference to a global name <code>var</code> is syntactically translated
241	to <code>_ENV.var</code>.	239	to <code>_ENV.var</code>.
242	Moreover, every chunk is compiled in the scope of an external	240	Moreover, every chunk is compiled in the scope of
243	variable called <code>_ENV</code> (see <a href="#3.3.2">§3.3.2</a>),	241	an external local variable called <code>_ENV</code> (see <a href="#3.3.2">§3.3.2</a>),
244	so <code>_ENV</code> itself is never a global name in a chunk.	242	so <code>_ENV</code> itself is never a global name in a chunk.
245		243
246		244
@@ -252,12 +250,11 @@ In particular, · 5 unmodified lines
252	you can define new variables and parameters with that name.	250	you can define new variables and parameters with that name.
253	Each reference to a global name uses the <code>_ENV</code> that is	251	Each reference to a global name uses the <code>_ENV</code> that is
254	visible at that point in the program,	252	visible at that point in the program,
255	following the usual visibility rules of Lua.	253	following the usual visibility rules of Lua (see <a href="#3.5">§3.5</a>).
256		254
257		255
258	<p>	256	<p>
259	Any table used as the value of <code>_ENV</code> is usually called	257	Any table used as the value of <code>_ENV</code> is called an <em>environment</em>.
260	an <em>environment</em>.
261		258
262		259
263	<p>	260	<p>
@@ -268,13 +265,14 @@ In Lua, the variable <a href="#pdf-_G"><code>_G</code></a> is initialized with t · 4 unmodified lines
268		265
269	<p>	266	<p>
270	When Lua compiles a chunk,	267	When Lua compiles a chunk,
271	it initializes the value of its <code>_ENV</code> variable	268	it initializes the value of its <code>_ENV</code> upvalue
272	with the global environment (see <a href="#pdf-load"><code>load</code></a>).	269	with the global environment (see <a href="#pdf-load"><code>load</code></a>).
273	Therefore, by default,	270	Therefore, by default,
274	global variables in Lua code refer to entries in the global environment.	271	global variables in Lua code refer to entries in the global environment.
275	Moreover, all standard libraries are loaded in the global environment,	272	Moreover, all standard libraries are loaded in the global environment
276	and several functions there operate on that environment.	273	and several functions there operate on that environment.
277	You can use <a href="#pdf-load"><code>load</code></a> to load a chunk with a different environment.	274	You can use <a href="#pdf-load"><code>load</code></a> (or <a href="#pdf-loadfile"><code>loadfile</code></a>)
		275	to load a chunk with a different environment.
278	(In C, you have to load the chunk and then change the value	276	(In C, you have to load the chunk and then change the value
279	of its first upvalue.)	277	of its first upvalue.)
280		278
@@ -325,7 +323,7 @@ any value for the error object. · 44 unmodified lines
325		323
326	<p>	324	<p>
327	When you use <a href="#pdf-xpcall"><code>xpcall</code></a> or <a href="#lua_pcall"><code>lua_pcall</code></a>,	325	When you use <a href="#pdf-xpcall"><code>xpcall</code></a> or <a href="#lua_pcall"><code>lua_pcall</code></a>,
328	you may give an <em>message handler</em>	326	you may give a <em>message handler</em>
329	to be called in case of errors.	327	to be called in case of errors.
330	This function is called with the original error message	328	This function is called with the original error message
331	and returns a new error message.	329	and returns a new error message.
@@ -389,8 +387,8 @@ but the string library sets a metatable for the string type (see <a href="#6.4"> · 57 unmodified lines
389	<p>	387	<p>
390	A metatable controls how an object behaves in arithmetic operations,	388	A metatable controls how an object behaves in arithmetic operations,
391	order comparisons, concatenation, length operation, and indexing.	389	order comparisons, concatenation, length operation, and indexing.
392	A metatable also can define a function to be called when a userdata	390	A metatable also can define a function to be called
393	is garbage collected.	391	when a userdata or a table is garbage collected.
394	When Lua performs one of these operations over a value,	392	When Lua performs one of these operations over a value,
395	it checks whether this value has a metatable with the corresponding event.	393	it checks whether this value has a metatable with the corresponding event.
396	If so, the value associated with that key (the metamethod)	394	If so, the value associated with that key (the metamethod)
@@ -427,8 +425,8 @@ This should be read as · 30 unmodified lines
427	rawget(getmetatable(obj) or {}, event)	425	rawget(getmetatable(obj) or {}, event)
428	</pre><p>	426	</pre><p>
429		427
430	That is, the access to a metamethod does not invoke other metamethods,	428	This means that the access to a metamethod does not invoke other metamethods,
431	and the access to objects with no metatables does not fail	429	and access to objects with no metatables does not fail
432	(it simply results in <b>nil</b>).	430	(it simply results in <b>nil</b>).
433		431
434		432
@@ -590,13 +588,17 @@ The function <code>getequalhandler</code> defines how Lua chooses a metamethod · 155 unmodified lines
590	for equality.	588	for equality.
591	A metamethod is selected only when both values	589	A metamethod is selected only when both values
592	being compared have the same type	590	being compared have the same type
593	and the same metamethod for the selected operation.	591	and the same metamethod for the selected operation,
		592	and the values are either tables or full userdata.
594		593
595	<pre>	594	<pre>
596	function getequalhandler (op1, op2, event)	595	function getequalhandler (op1, op2)
597	if type(op1) ~= type(op2) then return nil end	596	if type(op1) ~= type(op2) or
598	local mm1 = metatable(op1)[event]	597	(type(op1) ~= "table" and type(op1) ~= "userdata") then
599	local mm2 = metatable(op2)[event]	598	return nil -- different values
		599	end
		600	local mm1 = metatable(op1).__eq
		601	local mm2 = metatable(op2).__eq
600	if mm1 == mm2 then return mm1 else return nil end	602	if mm1 == mm2 then return mm1 else return nil end
601	end	603	end
602	</pre><p>	604	</pre><p>
@@ -604,21 +606,19 @@ The "eq" event is defined as follows: · 1 unmodified line
604		606
605	<pre>	607	<pre>
606	function eq_event (op1, op2)	608	function eq_event (op1, op2)
607	if type(op1) ~= type(op2) then -- different types?
608	return false -- different values
609	end
610	if op1 == op2 then -- primitive equal?	609	if op1 == op2 then -- primitive equal?
611	return true -- values are equal	610	return true -- values are equal
612	end	611	end
613	-- try metamethod	612	-- try metamethod
614	local h = getequalhandler(op1, op2, "__eq")	613	local h = getequalhandler(op1, op2)
615	if h then	614	if h then
616	return (h(op1, op2))	615	return not not h(op1, op2)
617	else	616	else
618	return false	617	return false
619	end	618	end
620	end	619	end
621	</pre><p>	620	</pre><p>
		621	Note that the result is always a boolean.
622	</li>	622	</li>
623		623
624	<li><b>"lt": </b>	624	<li><b>"lt": </b>
@@ -634,13 +634,14 @@ the <code><</code> operation. · 9 unmodified lines
634	else	634	else
635	local h = getbinhandler(op1, op2, "__lt")	635	local h = getbinhandler(op1, op2, "__lt")
636	if h then	636	if h then
637	return (h(op1, op2))	637	return not not h(op1, op2)
638	else	638	else
639	error(···)	639	error(···)
640	end	640	end
641	end	641	end
642	end	642	end
643	</pre><p>	643	</pre><p>
		644	Note that the result is always a boolean.
644	</li>	645	</li>
645		646
646	<li><b>"le": </b>	647	<li><b>"le": </b>
@@ -656,7 +657,7 @@ the <code><=</code> operation. · 9 unmodified lines
656	else	657	else
657	local h = getbinhandler(op1, op2, "__le")	658	local h = getbinhandler(op1, op2, "__le")
658	if h then	659	if h then
659	return (h(op1, op2))	660	return not not h(op1, op2)
660	else	661	else
661	h = getbinhandler(op1, op2, "__lt")	662	h = getbinhandler(op1, op2, "__lt")
662	if h then	663	if h then
@@ -671,6 +672,11 @@ the <code><=</code> operation. · 8 unmodified lines
671	Note that, in the absence of a "le" metamethod,	672	Note that, in the absence of a "le" metamethod,
672	Lua tries the "lt", assuming that <code>a <= b</code> is	673	Lua tries the "lt", assuming that <code>a <= b</code> is
673	equivalent to <code>not (b < a)</code>.	674	equivalent to <code>not (b < a)</code>.
		675
		676
		677	<p>
		678	As with the other comparison operators,
		679	the result is always a boolean.
674	</li>	680	</li>
675		681
676	<li><b>"index": </b>	682	<li><b>"index": </b>
@@ -770,7 +776,7 @@ Lua manages memory automatically by running · 93 unmodified lines
770	a <em>garbage collector</em> to collect all <em>dead objects</em>	776	a <em>garbage collector</em> to collect all <em>dead objects</em>
771	(that is, objects that are no longer accessible from Lua).	777	(that is, objects that are no longer accessible from Lua).
772	All memory used by Lua is subject to automatic management:	778	All memory used by Lua is subject to automatic management:
773	tables, userdata, functions, threads, strings, etc.	779	strings, tables, userdata, functions, threads, internal structures, etc.
774		780
775		781
776	<p>	782	<p>
@@ -819,10 +825,25 @@ memory usage. · 42 unmodified lines
819	<p>	825	<p>
820	You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C	826	You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
821	or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.	827	or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
822	With these functions you can also control	828	You can also use these functions to control
823	the collector directly (e.g., stop and restart it).	829	the collector directly (e.g., stop and restart it).
824		830
825		831
		832	<p>
		833	As an experimental feature in Lua 5.2,
		834	you can change the collector's operation mode
		835	from incremental to <em>generational</em>.
		836	A <em>generational collector</em> assumes that most objects die young,
		837	and therefore it traverses only young (recently created) objects.
		838	This behavior can reduce the time used by the collector,
		839	but also increases memory usage (as old dead objects may accumulate).
		840	To mitigate this second problem,
		841	from time to time the generational collector performs a full collection.
		842	Remember that this is an experimental feature;
		843	you are welcome to try it,
		844	but check your gains.
		845
		846
826		847
827	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>	848	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>
828		849
@@ -879,11 +900,17 @@ the execution of the regular code. · 50 unmodified lines
879		900
880		901
881	<p>	902	<p>
882	Because the object being collected must still be used by the finalizer	903	Because the object being collected must still be used by the finalizer,
883	and even <em>resurrected</em>	904	it (and other objects accessible only through it)
884	(e.g., stored by the finalizer in a global variable),	905	must be <em>resurrected</em> by Lua.
885	the object memory is freed only when it becomes completely inaccessible	906	Usually, this resurrection is transient,
886	(that is, in the next garbage-collection cycle unless it was resurrected).	907	and the object memory is freed in the next garbage-collection cycle.
		908	However, if the finalizer stores the object in some global place
		909	(e.g., a global variable),
		910	then there is a permanent resurrection.
		911	In any case,
		912	the object memory is freed only when it becomes completely inaccessible;
		913	its finalizer will never be called twice.
887		914
888		915
889		916
@@ -927,32 +954,42 @@ the pair is removed. · 37 unmodified lines
927		954
928		955
929	<p>	956	<p>
930	After you use a table as a metatable,	957	Any change in the weakness of a table may take effect only
931	you should not change the value of its <code>__mode</code> field.	958	at the next collect cycle.
932	Otherwise, the weak behavior of the tables controlled by this	959	In particular, if you change the weakness to a stronger mode,
933	metatable is undefined.	960	Lua may still collect some items from that table
		961	before the change takes effect.
934		962
935		963
936	<p>	964	<p>
937	Only objects that have an explicit construction	965	Only objects that have an explicit construction
938	can be removed from weak tables.	966	are removed from weak tables.
939	Values, such as numbers and booleans,	967	Values, such as numbers and light C functions,
940	are not subject to garbage collection,	968	are not subject to garbage collection,
941	and therefore are not removed from weak tables	969	and therefore are not removed from weak tables
942	(unless its associated value is collected).	970	(unless its associated value is collected).
943	Lua treats strings and light C functions as non-object values.	971	Although strings are subject to garbage collection,
		972	they do not have an explicit construction,
		973	and therefore are not removed from weak tables.
944		974
945		975
946	<p>	976	<p>
947	Objects marked for finalization have a special behavior in weak tables.	977	Resurrected objects
948	When a marked object is a value in a weak table,	978	(that is, objects being finalized
949	it is removed from the table before running its finalizer.	979	and objects accessible only through objects being finalized)
950	However, when it is a key,	980	have a special behavior in weak tables.
951	it is removed from the table only after running its finalizer.	981	They are removed from weak values before running their finalizers,
		982	but are removed from weak keys only in the next collection
		983	after running their finalizers, when such objects are actually freed.
952	This behavior allows the finalizer to access properties	984	This behavior allows the finalizer to access properties
953	associated with the object through weak tables.	985	associated with the object through weak tables.
954		986
955		987
		988	<p>
		989	If a weak table is among the resurrected objects in a collection cycle,
		990	it may not be properly cleared until the next cycle.
		991
		992
956		993
957		994
958		995
@@ -1060,7 +1097,6 @@ When you run it, it produces the following output: · 101 unmodified lines
1060	<pre>	1097	<pre>
1061	co-body 1 10	1098	co-body 1 10
1062	foo 2	1099	foo 2
1063
1064	main true 4	1100	main true 4
1065	co-body r	1101	co-body r
1066	main true 11 -9	1102	main true 11 -9
@@ -1090,7 +1126,7 @@ and what their combinations mean. · 23 unmodified lines
1090		1126
1091		1127
1092	<p>	1128	<p>
1093	The language constructs will be explained using the usual extended BNF notation,	1129	Language constructs will be explained using the usual extended BNF notation,
1094	in which	1130	in which
1095	{<em>a</em>} means 0 or more <em>a</em>'s, and	1131	{<em>a</em>} means 0 or more <em>a</em>'s, and
1096	[<em>a</em>] means an optional <em>a</em>.	1132	[<em>a</em>] means an optional <em>a</em>.
@@ -1176,7 +1212,7 @@ into the string contents. · 79 unmodified lines
1176		1212
1177		1213
1178	<p>	1214	<p>
1179	A character in a literal string can also be specified by its numerical value.	1215	A byte in a literal string can also be specified by its numerical value.
1180	This can be done with the escape sequence <code>\x<em>XX</em></code>,	1216	This can be done with the escape sequence <code>\x<em>XX</em></code>,
1181	where <em>XX</em> is a sequence of exactly two hexadecimal digits,	1217	where <em>XX</em> is a sequence of exactly two hexadecimal digits,
1182	or with the escape sequence <code>\<em>ddd</em></code>,	1218	or with the escape sequence <code>\<em>ddd</em></code>,
@@ -1407,13 +1443,13 @@ even if it does not use that variable. · 224 unmodified lines
1407	<p>	1443	<p>
1408	A chunk can be stored in a file or in a string inside the host program.	1444	A chunk can be stored in a file or in a string inside the host program.
1409	To execute a chunk,	1445	To execute a chunk,
1410	Lua first pre-compiles the chunk into instructions for a virtual machine,	1446	Lua first precompiles the chunk into instructions for a virtual machine,
1411	and then it executes the compiled code	1447	and then it executes the compiled code
1412	with an interpreter for the virtual machine.	1448	with an interpreter for the virtual machine.
1413		1449
1414		1450
1415	<p>	1451	<p>
1416	Chunks can also be pre-compiled into binary form;	1452	Chunks can also be precompiled into binary form;
1417	see program <code>luac</code> for details.	1453	see program <code>luac</code> for details.
1418	Programs in source and compiled forms are interchangeable;	1454	Programs in source and compiled forms are interchangeable;
1419	Lua automatically detects the file type and acts accordingly.	1455	Lua automatically detects the file type and acts accordingly.
@@ -1555,7 +1591,7 @@ enter into the scope of a local variable. · 135 unmodified lines
1555		1591
1556		1592
1557	<p>	1593	<p>
1558	Both labels and empty statements are called <em>void statements</em>,	1594	Labels and empty statements are called <em>void statements</em>,
1559	as they perform no actions.	1595	as they perform no actions.
1560		1596
1561		1597
@@ -1806,14 +1842,13 @@ and the unary <em>length operator</em> (see <a href="#3.4.6">§3.4.6</a>). · 244 unmodified lines
1806		1842
1807	<p>	1843	<p>
1808	Both function calls and vararg expressions can result in multiple values.	1844	Both function calls and vararg expressions can result in multiple values.
1809	If an expression is used as a statement	1845	If a function call is used as a statement (see <a href="#3.3.6">§3.3.6</a>),
1810	(only possible for function calls (see <a href="#3.3.6">§3.3.6</a>)),
1811	then its return list is adjusted to zero elements,	1846	then its return list is adjusted to zero elements,
1812	thus discarding all returned values.	1847	thus discarding all returned values.
1813	If an expression is used as the last (or the only) element	1848	If an expression is used as the last (or the only) element
1814	of a list of expressions,	1849	of a list of expressions,
1815	then no adjustment is made	1850	then no adjustment is made
1816	(unless the call is enclosed in parentheses).	1851	(unless the expression is enclosed in parentheses).
1817	In all other contexts,	1852	In all other contexts,
1818	Lua adjusts the result list to one element,	1853	Lua adjusts the result list to one element,
1819	discarding all values except the first one.	1854	discarding all values except the first one.
@@ -1881,8 +1916,7 @@ Lua provides automatic conversion between · 61 unmodified lines
1881	string and number values at run time.	1916	string and number values at run time.
1882	Any arithmetic operation applied to a string tries to convert	1917	Any arithmetic operation applied to a string tries to convert
1883	this string to a number, following the rules of the Lua lexer.	1918	this string to a number, following the rules of the Lua lexer.
1884	(The string may have leading and trailing spaces,	1919	(The string may have leading and trailing spaces and a sign.)
1885	plus an optional sign.)
1886	Conversely, whenever a number is used where a string is expected,	1920	Conversely, whenever a number is used where a string is expected,
1887	the number is converted to a string, in a reasonable format.	1921	the number is converted to a string, in a reasonable format.
1888	For complete control over how numbers are converted to strings,	1922	For complete control over how numbers are converted to strings,
@@ -2254,8 +2288,8 @@ contains references to <code>f</code>.) · 365 unmodified lines
2254	<p>	2288	<p>
2255	A function definition is an executable expression,	2289	A function definition is an executable expression,
2256	whose value has type <em>function</em>.	2290	whose value has type <em>function</em>.
2257	When Lua pre-compiles a chunk,	2291	When Lua precompiles a chunk,
2258	all its function bodies are pre-compiled too.	2292	all its function bodies are precompiled too.
2259	Then, whenever Lua executes the function definition,	2293	Then, whenever Lua executes the function definition,
2260	the function is <em>instantiated</em> (or <em>closed</em>).	2294	the function is <em>instantiated</em> (or <em>closed</em>).
2261	This function instance (or <em>closure</em>)	2295	This function instance (or <em>closure</em>)
@@ -2272,9 +2306,9 @@ initialized with the argument values: · 10 unmodified lines
2272	When a function is called,	2306	When a function is called,
2273	the list of arguments is adjusted to	2307	the list of arguments is adjusted to
2274	the length of the list of parameters,	2308	the length of the list of parameters,
2275	unless the function is a variadic or <em>vararg function</em>,	2309	unless the function is a <em>vararg function</em>,
2276	which is	2310	which is indicated by three dots ('<code>...</code>')
2277	indicated by three dots ('<code>...</code>') at the end of its parameter list.	2311	at the end of its parameter list.
2278	A vararg function does not adjust its argument list;	2312	A vararg function does not adjust its argument list;
2279	instead, it collects all extra arguments and supplies them	2313	instead, it collects all extra arguments and supplies them
2280	to the function through a <em>vararg expression</em>,	2314	to the function through a <em>vararg expression</em>,
@@ -2425,7 +2459,8 @@ are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>. · 144 unmodified lines
2425	<p>	2459	<p>
2426	Even when we use the term "function",	2460	Even when we use the term "function",
2427	any facility in the API may be provided as a macro instead.	2461	any facility in the API may be provided as a macro instead.
2428	All such macros use each of their arguments exactly once	2462	Except where stated otherwise,
		2463	all such macros use each of their arguments exactly once
2429	(except for the first argument, which is always a Lua state),	2464	(except for the first argument, which is always a Lua state),
2430	and so do not generate any hidden side-effects.	2465	and so do not generate any hidden side-effects.
2431		2466
@@ -2434,8 +2469,7 @@ and so do not generate any hidden side-effects. · 2 unmodified lines
2434	As in most C libraries,	2469	As in most C libraries,
2435	the Lua API functions do not check their arguments for validity or consistency.	2470	the Lua API functions do not check their arguments for validity or consistency.
2436	However, you can change this behavior by compiling Lua	2471	However, you can change this behavior by compiling Lua
2437	with a proper definition for the macro <a name="pdf-luai_apicheck"><code>luai_apicheck</code></a>,	2472	with the macro <a name="pdf-LUA_USE_APICHECK"><code>LUA_USE_APICHECK</code></a> defined.
2438	in file <code>luaconf.h</code>.
2439		2473
2440		2474
2441		2475
@@ -2472,10 +2506,6 @@ index <em>n</em> represents the last element; · 30 unmodified lines
2472	index -1 also represents the last element	2506	index -1 also represents the last element
2473	(that is, the element at the top)	2507	(that is, the element at the top)
2474	and index <em>-n</em> represents the first element.	2508	and index <em>-n</em> represents the first element.
2475	We say that an index is <em>valid</em>
2476	if it lies between 1 and the stack top
2477	(that is, if <code>1 ≤ abs(index) ≤ top</code>).
2478
2479		2509
2480		2510
2481		2511
@@ -2494,7 +2524,7 @@ to ensure that the stack has extra slots when pushing new elements. · 12 unmodified lines
2494		2524
2495	<p>	2525	<p>
2496	Whenever Lua calls C,	2526	Whenever Lua calls C,
2497	it ensures that at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> stack positions are available.	2527	it ensures that the stack has at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> extra slots.
2498	<code>LUA_MINSTACK</code> is defined as 20,	2528	<code>LUA_MINSTACK</code> is defined as 20,
2499	so that usually you do not have to worry about stack space	2529	so that usually you do not have to worry about stack space
2500	unless your code has loops pushing elements onto the stack.	2530	unless your code has loops pushing elements onto the stack.
@@ -2509,33 +2539,66 @@ So, before pushing anything in the stack after such a call · 8 unmodified lines
2509	you should use <a href="#lua_checkstack"><code>lua_checkstack</code></a>.	2539	you should use <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
2510		2540
2511		2541
		2542
		2543
		2544
		2545	<h2>4.3 – <a name="4.3">Valid and Acceptable Indices</a></h2>
		2546
2512	<p>	2547	<p>
2513	Most query functions accept as indices any value inside the	2548	Any function in the API that receives stack indices
2514	available stack space, that is, indices up to the maximum stack size	2549	works only with <em>valid indices</em> or <em>acceptable indices</em>.
2515	that you have set through <a href="#lua_checkstack"><code>lua_checkstack</code></a>.	2550
2516	Such indices are called <em>acceptable indices</em>.	2551
2517	More formally, we define an <em>acceptable index</em>	2552	<p>
		2553	A <em>valid index</em> is an index that refers to a
		2554	valid position within the stack, that is,
		2555	it lies between 1 and the stack top
		2556	(<code>1 ≤ abs(index) ≤ top</code>).
		2557
		2558	Usually, functions that need a specific stack position
		2559	(e.g., <a href="#lua_remove"><code>lua_remove</code></a>) require valid indices.
		2560
		2561
		2562	<p>
		2563	Functions that do not need a specific stack position,
		2564	but only a value in the stack (e.g., query functions),
		2565	can be called with acceptable indices.
		2566	An <em>acceptable index</em> refers to a position within
		2567	the space allocated for the stack,
		2568	that is, indices up to the stack size.
		2569	More formally, we define an acceptable index
2518	as follows:	2570	as follows:
2519		2571
2520	<pre>	2572	<pre>
2521	(index < 0 && abs(index) <= top) \|\|	2573	(index < 0 && abs(index) <= top) \|\|
2522	(index > 0 && index <= stackspace)	2574	(index > 0 && index <= stack size)
2523	</pre><p>	2575	</pre><p>
2524	Note that 0 is never an acceptable index.	2576	(Note that 0 is never an acceptable index.)
		2577	When a function is called,
		2578	its stack size is <code>top + LUA_MINSTACK</code>.
		2579	You can change its stack size through function <a href="#lua_checkstack"><code>lua_checkstack</code></a>.
2525		2580
2526		2581
		2582	<p>
		2583	Acceptable indices serve to avoid extra tests
		2584	against the stack top when querying the stack.
		2585	For instance, a C function can query its third argument
		2586	without the need to first check whether there is a third argument,
		2587	that is, without the need to check whether 3 is a valid index.
2527		2588
2528		2589
		2590	<p>
		2591	For functions that can be called with acceptable indices,
		2592	any non-valid index is treated as if it
		2593	contains a value of a virtual type <a name="pdf-LUA_TNONE"><code>LUA_TNONE</code></a>.
2529		2594
2530	<h2>4.3 – <a name="4.3">Pseudo-Indices</a></h2>
2531		2595
2532	<p>	2596	<p>
2533	Unless otherwise noted,	2597	Unless otherwise noted,
2534	any function that accepts valid indices also accepts <em>pseudo-indices</em>,	2598	any function that accepts valid indices also accepts <em>pseudo-indices</em>,
2535	which represent some Lua values that are accessible to C code	2599	which represent some Lua values that are accessible to C code
2536	but which are not in the stack.	2600	but which are not in the stack.
2537	Pseudo-indices are used to access	2601	Pseudo-indices are used to access the registry
2538	the registry
2539	and the upvalues of a C function (see <a href="#4.4">§4.4</a>).	2602	and the upvalues of a C function (see <a href="#4.4">§4.4</a>).
2540		2603
2541		2604
@@ -2547,10 +2610,10 @@ and the upvalues of a C function (see <a href="#4.4">§4.4</a>). · 5 unmodified lines
2547	<p>	2610	<p>
2548	When a C function is created,	2611	When a C function is created,
2549	it is possible to associate some values with it,	2612	it is possible to associate some values with it,
2550	thus creating a <em>C closure</em>;	2613	thus creating a <em>C closure</em>
		2614	(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>);
2551	these values are called <em>upvalues</em> and are	2615	these values are called <em>upvalues</em> and are
2552	accessible to the function whenever it is called	2616	accessible to the function whenever it is called.
2553	(see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>).
2554		2617
2555		2618
2556	<p>	2619	<p>
@@ -2573,12 +2636,13 @@ produces an acceptable (but invalid) index. · 16 unmodified lines
2573		2636
2574	<p>	2637	<p>
2575	Lua provides a <em>registry</em>,	2638	Lua provides a <em>registry</em>,
2576	a pre-defined table that can be used by any C code to	2639	a predefined table that can be used by any C code to
2577	store whatever Lua value it needs to store.	2640	store whatever Lua values it needs to store.
2578	This table is always located at pseudo-index	2641	The registry table is always located at pseudo-index
2579	<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>.	2642	<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>.
2580	Any C library can store data into this table,	2643	Any C library can store data into this table,
2581	but it should take care to choose keys different from those used	2644	but it should take care to choose keys
		2645	that are different from those used
2582	by other libraries, to avoid collisions.	2646	by other libraries, to avoid collisions.
2583	Typically, you should use as key a string containing your library name,	2647	Typically, you should use as key a string containing your library name,
2584	or a light userdata with the address of a C object in your code,	2648	or a light userdata with the address of a C object in your code,
@@ -2610,7 +2674,6 @@ the main thread of the state. · 25 unmodified lines
2610		2674
2611	<li><b><a name="pdf-LUA_RIDX_GLOBALS"><code>LUA_RIDX_GLOBALS</code></a>: </b> At this index the registry has	2675	<li><b><a name="pdf-LUA_RIDX_GLOBALS"><code>LUA_RIDX_GLOBALS</code></a>: </b> At this index the registry has
2612	the global environment.	2676	the global environment.
2613	This is the C equivalent to the <a href="#pdf-_G"><code>_G</code></a> global variable.
2614	</li>	2677	</li>
2615	</ul>	2678	</ul>
2616		2679
@@ -2629,8 +2692,8 @@ and runtime errors) · 12 unmodified lines
2629	it <em>raises</em> an error;	2692	it <em>raises</em> an error;
2630	that is, it does a long jump.	2693	that is, it does a long jump.
2631	A <em>protected environment</em> uses <code>setjmp</code>	2694	A <em>protected environment</em> uses <code>setjmp</code>
2632	to set a recover point;	2695	to set a recovery point;
2633	any error jumps to the most recent active recover point.	2696	any error jumps to the most recent active recovery point.
2634		2697
2635		2698
2636	<p>	2699	<p>
@@ -2639,7 +2702,8 @@ Lua calls a <em>panic function</em> (see <a href="#lua_atpanic"><code>lua_atpani · 2 unmodified lines
2639	and then calls <code>abort</code>,	2702	and then calls <code>abort</code>,
2640	thus exiting the host application.	2703	thus exiting the host application.
2641	Your panic function can avoid this exit by	2704	Your panic function can avoid this exit by
2642	never returning (e.g., doing a long jump).	2705	never returning
		2706	(e.g., doing a long jump to your own recovery point outside Lua).
2643		2707
2644		2708
2645	<p>	2709	<p>
@@ -2677,8 +2741,7 @@ All those functions receive a <em>continuation function</em> · 31 unmodified lines
2677		2741
2678		2742
2679	<p>	2743	<p>
2680	To explain continuations,	2744	We need to set some terminology to explain continuations.
2681	let us set some terminology.
2682	We have a C function called from Lua which we will call	2745	We have a C function called from Lua which we will call
2683	the <em>original function</em>.	2746	the <em>original function</em>.
2684	This original function then calls one of those three functions in the C API,	2747	This original function then calls one of those three functions in the C API,
@@ -2704,7 +2767,7 @@ of the original function. · 19 unmodified lines
2704		2767
2705		2768
2706	<p>	2769	<p>
2707	Lua treats the continuation function as if it was the original function.	2770	Lua treats the continuation function as if it were the original function.
2708	The continuation function receives the same Lua stack	2771	The continuation function receives the same Lua stack
2709	from the original function,	2772	from the original function,
2710	in the same state it would be if the callee function had returned.	2773	in the same state it would be if the callee function had returned.
@@ -2712,7 +2775,7 @@ in the same state it would be if the callee function had returned. · 1 unmodified line
2712	after a <a href="#lua_callk"><code>lua_callk</code></a> the function and its arguments are	2775	after a <a href="#lua_callk"><code>lua_callk</code></a> the function and its arguments are
2713	removed from the stack and replaced by the results from the call.)	2776	removed from the stack and replaced by the results from the call.)
2714	It also has the same upvalues.	2777	It also has the same upvalues.
2715	Whatever it returns is handled by Lua as if it was the return	2778	Whatever it returns is handled by Lua as if it were the return
2716	of the original function.	2779	of the original function.
2717		2780
2718		2781
@@ -2749,15 +2812,14 @@ by looking only at its arguments · 30 unmodified lines
2749	The third field, <code>x</code>,	2812	The third field, <code>x</code>,
2750	tells whether the function may throw errors:	2813	tells whether the function may throw errors:
2751	'<code>-</code>' means the function never throws any error;	2814	'<code>-</code>' means the function never throws any error;
2752	'<code>m</code>' means the function may throw an error	2815	'<code>m</code>' means the function may throw only memory allocation errors;
2753	only due to not enough memory;
2754	'<code>e</code>' means the function may throw other kinds of errors;	2816	'<code>e</code>' means the function may throw other kinds of errors;
2755	'<code>v</code>' means the function may throw an error on purpose.	2817	'<code>v</code>' means the function may throw an error on purpose.
2756		2818
2757		2819
2758		2820
2759	<hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p>	2821	<hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p>
2760	<span class="apii">[-0, +0, <em>-</em>]</span>	2822	<span class="apii">[-0, +0, –]</span>
2761	<pre>int lua_absindex (lua_State *L, int idx);</pre>	2823	<pre>int lua_absindex (lua_State *L, int idx);</pre>
2762		2824
2763	<p>	2825	<p>
@@ -2795,7 +2857,7 @@ that is, the size given when it was allocated or reallocated. · 31 unmodified lines
2795		2857
2796	<p>	2858	<p>
2797	When <code>ptr</code> is <code>NULL</code>,	2859	When <code>ptr</code> is <code>NULL</code>,
2798	<code>osize</code> codes the kind of object that Lua is allocating.	2860	<code>osize</code> encodes the kind of object that Lua is allocating.
2799	<code>osize</code> is any of	2861	<code>osize</code> is any of
2800	<a href="#pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, <a href="#pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, <a href="#pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,	2862	<a href="#pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, <a href="#pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, <a href="#pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
2801	<a href="#pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, or <a href="#pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a> when (and only when)	2863	<a href="#pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, or <a href="#pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a> when (and only when)
@@ -2818,7 +2880,7 @@ and return <code>NULL</code>. · 16 unmodified lines
2818	When <code>nsize</code> is not zero,	2880	When <code>nsize</code> is not zero,
2819	the allocator should behave like <code>realloc</code>.	2881	the allocator should behave like <code>realloc</code>.
2820	The allocator returns <code>NULL</code>	2882	The allocator returns <code>NULL</code>
2821	if and only if it cannot fill the request.	2883	if and only if it cannot fulfill the request.
2822	Lua assumes that the allocator never fails when	2884	Lua assumes that the allocator never fails when
2823	<code>osize >= nsize</code>.	2885	<code>osize >= nsize</code>.
2824		2886
@@ -2843,8 +2905,8 @@ Note that Standard C ensures · 18 unmodified lines
2843	that <code>free(NULL)</code> has no effect and that	2905	that <code>free(NULL)</code> has no effect and that
2844	<code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.	2906	<code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.
2845	This code assumes that <code>realloc</code> does not fail when shrinking a block.	2907	This code assumes that <code>realloc</code> does not fail when shrinking a block.
2846	Standard C does not ensure this behavior,	2908	(Although Standard C does not ensure this behavior,
2847	but it seems a safe assumption.	2909	it seems to be a safe assumption.)
2848		2910
2849		2911
2850		2912
@@ -2883,7 +2945,7 @@ The value of <code>op</code> must be one of the following constants: · 32 unmodified lines
2883		2945
2884		2946
2885	<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>	2947	<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
2886	<span class="apii">[-0, +0, <em>-</em>]</span>	2948	<span class="apii">[-0, +0, –]</span>
2887	<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>	2949	<pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>
2888		2950
2889	<p>	2951	<p>
@@ -2901,7 +2963,7 @@ In particular, the error message is at the top of the stack. · 11 unmodified lines
2901		2963
2902		2964
2903	<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>	2965	<hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
2904	<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>	2966	<span class="apii">[-(nargs+1), +nresults, <em>e</em>]</span>
2905	<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>	2967	<pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>
2906		2968
2907	<p>	2969	<p>
@@ -3025,12 +3087,12 @@ of numerical arguments and returns their average and sum: · 117 unmodified lines
3025		3087
3026		3088
3027	<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>	3089	<hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
3028	<span class="apii">[-0, +0, <em>-</em>]</span>	3090	<span class="apii">[-0, +0, –]</span>
3029	<pre>int lua_checkstack (lua_State *L, int extra);</pre>	3091	<pre>int lua_checkstack (lua_State *L, int extra);</pre>
3030		3092
3031	<p>	3093	<p>
3032	Ensures that there are at least <code>extra</code> free stack slots in the stack.	3094	Ensures that there are at least <code>extra</code> free stack slots in the stack.
3033	It returns false if it cannot grant the request,	3095	It returns false if it cannot fulfill the request,
3034	because it would cause the stack to be larger than a fixed maximum size	3096	because it would cause the stack to be larger than a fixed maximum size
3035	(typically at least a few thousand elements) or	3097	(typically at least a few thousand elements) or
3036	because it cannot allocate memory for the new stack size.	3098	because it cannot allocate memory for the new stack size.
@@ -3043,7 +3105,7 @@ it is left unchanged. · 6 unmodified lines
3043		3105
3044		3106
3045	<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>	3107	<hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
3046	<span class="apii">[-0, +0, <em>-</em>]</span>	3108	<span class="apii">[-0, +0, –]</span>
3047	<pre>void lua_close (lua_State *L);</pre>	3109	<pre>void lua_close (lua_State *L);</pre>
3048		3110
3049	<p>	3111	<p>
@@ -3052,10 +3114,9 @@ Destroys all objects in the given Lua state · 2 unmodified lines
3052	and frees all dynamic memory used by this state.	3114	and frees all dynamic memory used by this state.
3053	On several platforms, you may not need to call this function,	3115	On several platforms, you may not need to call this function,
3054	because all resources are naturally released when the host program ends.	3116	because all resources are naturally released when the host program ends.
3055	On the other hand, long-running programs,	3117	On the other hand, long-running programs that create multiple states,
3056	such as a daemon or a web server,	3118	such as daemons or web servers,
3057	might need to release states as soon as they are not needed,	3119	might need to close states as soon as they are not needed.
3058	to avoid growing too large.
3059		3120
3060		3121
3061		3122
@@ -3066,6 +3127,7 @@ to avoid growing too large. · 4 unmodified lines
3066	<pre>int lua_compare (lua_State *L, int index1, int index2, int op);</pre>	3127	<pre>int lua_compare (lua_State *L, int index1, int index2, int op);</pre>
3067		3128
3068	<p>	3129	<p>
		3130	Compares two Lua values.
3069	Returns 1 if the value at acceptable index <code>index1</code> satisfies <code>op</code>	3131	Returns 1 if the value at acceptable index <code>index1</code> satisfies <code>op</code>
3070	when compared with the value at acceptable index <code>index2</code>,	3132	when compared with the value at acceptable index <code>index2</code>,
3071	following the semantics of the corresponding Lua operator	3133	following the semantics of the corresponding Lua operator
@@ -3106,7 +3168,7 @@ Concatenation is performed following the usual semantics of Lua · 34 unmodified lines
3106		3168
3107		3169
3108	<hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p>	3170	<hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p>
3109	<span class="apii">[-0, +0, <em>-</em>]</span>	3171	<span class="apii">[-0, +0, –]</span>
3110	<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>	3172	<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>
3111		3173
3112	<p>	3174	<p>
@@ -3176,7 +3238,7 @@ Generates a Lua error. · 63 unmodified lines
3176	The error message (which can actually be a Lua value of any type)	3238	The error message (which can actually be a Lua value of any type)
3177	must be on the stack top.	3239	must be on the stack top.
3178	This function does a long jump,	3240	This function does a long jump,
3179	and therefore never returns.	3241	and therefore never returns
3180	(see <a href="#luaL_error"><code>luaL_error</code></a>).	3242	(see <a href="#luaL_error"><code>luaL_error</code></a>).
3181		3243
3182		3244
@@ -3245,10 +3307,20 @@ returns a boolean that tells whether the collector is running · 62 unmodified lines
3245	(i.e., not stopped).	3307	(i.e., not stopped).
3246	</li>	3308	</li>
3247		3309
		3310	<li><b><code>LUA_GCGEN</code>: </b>
		3311	changes the collector to generational mode
		3312	(see <a href="#2.5">§2.5</a>).
		3313	</li>
		3314
		3315	<li><b><code>LUA_GCINC</code>: </b>
		3316	changes the collector to incremental mode.
		3317	This is the default mode.
		3318	</li>
		3319
3248	</ul>	3320	</ul>
3249		3321
3250	<p>	3322	<p>
3251	For more details about some options,	3323	For more details about these options,
3252	see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.	3324	see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.
3253		3325
3254		3326
@@ -3256,7 +3328,7 @@ see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>. · 1 unmodified line
3256		3328
3257		3329
3258	<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>	3330	<hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
3259	<span class="apii">[-0, +0, <em>-</em>]</span>	3331	<span class="apii">[-0, +0, –]</span>
3260	<pre>lua_Alloc lua_getallocf (lua_State L, void *ud);</pre>	3332	<pre>lua_Alloc lua_getallocf (lua_State L, void *ud);</pre>
3261		3333
3262	<p>	3334	<p>
@@ -3269,7 +3341,7 @@ opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>. · 6 unmodified lines
3269		3341
3270		3342
3271	<hr><h3><a name="lua_getctx"><code>lua_getctx</code></a></h3><p>	3343	<hr><h3><a name="lua_getctx"><code>lua_getctx</code></a></h3><p>
3272	<span class="apii">[-0, +0, <em>-</em>]</span>	3344	<span class="apii">[-0, +0, –]</span>
3273	<pre>int lua_getctx (lua_State L, int ctx);</pre>	3345	<pre>int lua_getctx (lua_State L, int ctx);</pre>
3274		3346
3275	<p>	3347	<p>
@@ -3293,7 +3365,7 @@ When the callee is <a href="#lua_pcallk"><code>lua_pcallk</code></a>, · 17 unmodified lines
3293	Lua may also call its continuation function	3365	Lua may also call its continuation function
3294	to handle errors during the call.	3366	to handle errors during the call.
3295	That is, upon an error in the function called by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,	3367	That is, upon an error in the function called by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
3296	Lua may not return <a href="#lua_pcallk"><code>lua_pcallk</code></a>	3368	Lua may not return to the original function
3297	but instead may call the continuation function.	3369	but instead may call the continuation function.
3298	In that case, a call to <a href="#lua_getctx"><code>lua_getctx</code></a> will return the error code	3370	In that case, a call to <a href="#lua_getctx"><code>lua_getctx</code></a> will return the error code
3299	(the value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>);	3371	(the value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>);
@@ -3324,21 +3396,19 @@ for the "index" event (see <a href="#2.4">§2.4</a>). · 24 unmodified lines
3324		3396
3325	<p>	3397	<p>
3326	Pushes onto the stack the value of the global <code>name</code>.	3398	Pushes onto the stack the value of the global <code>name</code>.
3327	It is defined as a macro.
3328		3399
3329		3400
3330		3401
3331		3402
3332		3403
3333	<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>	3404	<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
3334	<span class="apii">[-0, +(0\|1), <em>-</em>]</span>	3405	<span class="apii">[-0, +(0\|1), –]</span>
3335	<pre>int lua_getmetatable (lua_State *L, int index);</pre>	3406	<pre>int lua_getmetatable (lua_State *L, int index);</pre>
3336		3407
3337	<p>	3408	<p>
3338	Pushes onto the stack the metatable of the value at the given	3409	Pushes onto the stack the metatable of the value at the given
3339	acceptable index.	3410	acceptable index.
3340	If the index is not valid,	3411	If the value does not have a metatable,
3341	or if the value does not have a metatable,
3342	the function returns 0 and pushes nothing on the stack.	3412	the function returns 0 and pushes nothing on the stack.
3343		3413
3344		3414
@@ -3366,7 +3436,7 @@ for the "index" event (see <a href="#2.4">§2.4</a>). · 21 unmodified lines
3366		3436
3367		3437
3368	<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>	3438	<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
3369	<span class="apii">[-0, +0, <em>-</em>]</span>	3439	<span class="apii">[-0, +0, –]</span>
3370	<pre>int lua_gettop (lua_State *L);</pre>	3440	<pre>int lua_gettop (lua_State *L);</pre>
3371		3441
3372	<p>	3442	<p>
@@ -3380,7 +3450,7 @@ this result is equal to the number of elements in the stack · 7 unmodified lines
3380		3450
3381		3451
3382	<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>	3452	<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>
3383	<span class="apii">[-0, +1, <em>-</em>]</span>	3453	<span class="apii">[-0, +1, –]</span>
3384	<pre>void lua_getuservalue (lua_State *L, int index);</pre>	3454	<pre>void lua_getuservalue (lua_State *L, int index);</pre>
3385		3455
3386	<p>	3456	<p>
@@ -3393,7 +3463,7 @@ This Lua value must be a table or <b>nil</b>. · 6 unmodified lines
3393		3463
3394		3464
3395	<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>	3465	<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
3396	<span class="apii">[-1, +1, <em>-</em>]</span>	3466	<span class="apii">[-1, +1, –]</span>
3397	<pre>void lua_insert (lua_State *L, int index);</pre>	3467	<pre>void lua_insert (lua_State *L, int index);</pre>
3398		3468
3399	<p>	3469	<p>
@@ -3423,11 +3493,11 @@ which is usually the largest signed integral type the machine handles · 23 unmodified lines
3423		3493
3424		3494
3425	<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>	3495	<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
3426	<span class="apii">[-0, +0, <em>-</em>]</span>	3496	<span class="apii">[-0, +0, –]</span>
3427	<pre>int lua_isboolean (lua_State *L, int index);</pre>	3497	<pre>int lua_isboolean (lua_State *L, int index);</pre>
3428		3498
3429	<p>	3499	<p>
3430	Returns 1 if the value at the given acceptable index has type boolean,	3500	Returns 1 if the value at the given acceptable index is a boolean,
3431	and 0 otherwise.	3501	and 0 otherwise.
3432		3502
3433		3503
@@ -3435,7 +3505,7 @@ and 0 otherwise. · 1 unmodified line
3435		3505
3436		3506
3437	<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>	3507	<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
3438	<span class="apii">[-0, +0, <em>-</em>]</span>	3508	<span class="apii">[-0, +0, –]</span>
3439	<pre>int lua_iscfunction (lua_State *L, int index);</pre>	3509	<pre>int lua_iscfunction (lua_State *L, int index);</pre>
3440		3510
3441	<p>	3511	<p>
@@ -3447,7 +3517,7 @@ and 0 otherwise. · 5 unmodified lines
3447		3517
3448		3518
3449	<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>	3519	<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
3450	<span class="apii">[-0, +0, <em>-</em>]</span>	3520	<span class="apii">[-0, +0, –]</span>
3451	<pre>int lua_isfunction (lua_State *L, int index);</pre>	3521	<pre>int lua_isfunction (lua_State *L, int index);</pre>
3452		3522
3453	<p>	3523	<p>
@@ -3459,7 +3529,7 @@ Returns 1 if the value at the given acceptable index is a function · 5 unmodified lines
3459		3529
3460		3530
3461	<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>	3531	<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
3462	<span class="apii">[-0, +0, <em>-</em>]</span>	3532	<span class="apii">[-0, +0, –]</span>
3463	<pre>int lua_islightuserdata (lua_State *L, int index);</pre>	3533	<pre>int lua_islightuserdata (lua_State *L, int index);</pre>
3464		3534
3465	<p>	3535	<p>
@@ -3471,7 +3541,7 @@ and 0 otherwise. · 5 unmodified lines
3471		3541
3472		3542
3473	<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>	3543	<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
3474	<span class="apii">[-0, +0, <em>-</em>]</span>	3544	<span class="apii">[-0, +0, –]</span>
3475	<pre>int lua_isnil (lua_State *L, int index);</pre>	3545	<pre>int lua_isnil (lua_State *L, int index);</pre>
3476		3546
3477	<p>	3547	<p>
@@ -3483,7 +3553,7 @@ and 0 otherwise. · 5 unmodified lines
3483		3553
3484		3554
3485	<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>	3555	<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
3486	<span class="apii">[-0, +0, <em>-</em>]</span>	3556	<span class="apii">[-0, +0, –]</span>
3487	<pre>int lua_isnone (lua_State *L, int index);</pre>	3557	<pre>int lua_isnone (lua_State *L, int index);</pre>
3488		3558
3489	<p>	3559	<p>
@@ -3496,7 +3566,7 @@ and 0 otherwise. · 6 unmodified lines
3496		3566
3497		3567
3498	<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>	3568	<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
3499	<span class="apii">[-0, +0, <em>-</em>]</span>	3569	<span class="apii">[-0, +0, –]</span>
3500	<pre>int lua_isnoneornil (lua_State *L, int index);</pre>	3570	<pre>int lua_isnoneornil (lua_State *L, int index);</pre>
3501		3571
3502	<p>	3572	<p>
@@ -3510,7 +3580,7 @@ and 0 otherwise. · 7 unmodified lines
3510		3580
3511		3581
3512	<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>	3582	<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
3513	<span class="apii">[-0, +0, <em>-</em>]</span>	3583	<span class="apii">[-0, +0, –]</span>
3514	<pre>int lua_isnumber (lua_State *L, int index);</pre>	3584	<pre>int lua_isnumber (lua_State *L, int index);</pre>
3515		3585
3516	<p>	3586	<p>
@@ -3523,7 +3593,7 @@ and 0 otherwise. · 6 unmodified lines
3523		3593
3524		3594
3525	<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>	3595	<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
3526	<span class="apii">[-0, +0, <em>-</em>]</span>	3596	<span class="apii">[-0, +0, –]</span>
3527	<pre>int lua_isstring (lua_State *L, int index);</pre>	3597	<pre>int lua_isstring (lua_State *L, int index);</pre>
3528		3598
3529	<p>	3599	<p>
@@ -3536,7 +3606,7 @@ and 0 otherwise. · 6 unmodified lines
3536		3606
3537		3607
3538	<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>	3608	<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
3539	<span class="apii">[-0, +0, <em>-</em>]</span>	3609	<span class="apii">[-0, +0, –]</span>
3540	<pre>int lua_istable (lua_State *L, int index);</pre>	3610	<pre>int lua_istable (lua_State *L, int index);</pre>
3541		3611
3542	<p>	3612	<p>
@@ -3548,7 +3618,7 @@ and 0 otherwise. · 5 unmodified lines
3548		3618
3549		3619
3550	<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>	3620	<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
3551	<span class="apii">[-0, +0, <em>-</em>]</span>	3621	<span class="apii">[-0, +0, –]</span>
3552	<pre>int lua_isthread (lua_State *L, int index);</pre>	3622	<pre>int lua_isthread (lua_State *L, int index);</pre>
3553		3623
3554	<p>	3624	<p>
@@ -3560,7 +3630,7 @@ and 0 otherwise. · 5 unmodified lines
3560		3630
3561		3631
3562	<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>	3632	<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
3563	<span class="apii">[-0, +0, <em>-</em>]</span>	3633	<span class="apii">[-0, +0, –]</span>
3564	<pre>int lua_isuserdata (lua_State *L, int index);</pre>	3634	<pre>int lua_isuserdata (lua_State *L, int index);</pre>
3565		3635
3566	<p>	3636	<p>
@@ -3585,7 +3655,7 @@ The result is pushed on the stack. · 18 unmodified lines
3585		3655
3586		3656
3587	<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>	3657	<hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
3588	<span class="apii">[-0, +1, <em>-</em>]</span>	3658	<span class="apii">[-0, +1, –]</span>
3589	<pre>int lua_load (lua_State *L,	3659	<pre>int lua_load (lua_State *L,
3590	lua_Reader reader,	3660	lua_Reader reader,
3591	void *data,	3661	void *data,
@@ -3601,13 +3671,13 @@ The return values of <a href="#lua_load"><code>lua_load</code></a> are: · 9 unmodified lines
3601		3671
3602	<ul>	3672	<ul>
3603		3673
3604	<li><b><a href="#pdf-LUA_OK"><code>LUA_OK</code></a> (0): </b> no errors;</li>	3674	<li><b><a href="#pdf-LUA_OK"><code>LUA_OK</code></a>: </b> no errors;</li>
3605		3675
3606	<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>: </b>	3676	<li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>: </b>
3607	syntax error during pre-compilation;</li>	3677	syntax error during precompilation;</li>
3608		3678
3609	<li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>	3679	<li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
3610	memory allocation error.</li>	3680	memory allocation error;</li>
3611		3681
3612	<li><b><a href="#pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>	3682	<li><b><a href="#pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
3613	error while running a <code>__gc</code> metamethod.	3683	error while running a <code>__gc</code> metamethod.
@@ -3623,7 +3693,7 @@ it does not run it. · 9 unmodified lines
3623		3693
3624		3694
3625	<p>	3695	<p>
3626	<a href="#lua_load"><code>lua_load</code></a> automatically detects whether the chunk is text or binary,	3696	<a href="#lua_load"><code>lua_load</code></a> automatically detects whether the chunk is text or binary
3627	and loads it accordingly (see program <code>luac</code>).	3697	and loads it accordingly (see program <code>luac</code>).
3628		3698
3629		3699
@@ -3642,25 +3712,25 @@ which is used for error messages and in debug information (see <a href="#4.9">&s · 12 unmodified lines
3642	If the resulting function has one upvalue,	3712	If the resulting function has one upvalue,
3643	this upvalue is set to the value of the global environment	3713	this upvalue is set to the value of the global environment
3644	stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.5">§4.5</a>).	3714	stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.5">§4.5</a>).
3645	(When loading main chunks,	3715	When loading main chunks,
3646	this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).)	3716	this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).
3647		3717
3648		3718
3649		3719
3650		3720
3651		3721
3652	<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>	3722	<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p>
3653	<span class="apii">[-0, +0, <em>-</em>]</span>	3723	<span class="apii">[-0, +0, –]</span>
3654	<pre>lua_State lua_newstate (lua_Alloc f, void ud);</pre>	3724	<pre>lua_State lua_newstate (lua_Alloc f, void ud);</pre>
3655		3725
3656	<p>	3726	<p>
3657	Creates a new thread running in a new, independent state.	3727	Creates a new thread running in a new, independent state.
3658	Returns <code>NULL</code> if cannot create the thread/state	3728	Returns <code>NULL</code> if cannot create the thread or the state
3659	(due to lack of memory).	3729	(due to lack of memory).
3660	The argument <code>f</code> is the allocator function;	3730	The argument <code>f</code> is the allocator function;
3661	Lua does all memory allocation for this state through this function.	3731	Lua does all memory allocation for this state through this function.
3662	The second argument, <code>ud</code>, is an opaque pointer that Lua	3732	The second argument, <code>ud</code>, is an opaque pointer that Lua
3663	simply passes to the allocator in every call.	3733	passes to the allocator in every call.
3664		3734
3665		3735
3666		3736
@@ -3686,7 +3756,7 @@ It is equivalent to <code>lua_createtable(L, 0, 0)</code>. · 19 unmodified lines
3686	Creates a new thread, pushes it on the stack,	3756	Creates a new thread, pushes it on the stack,
3687	and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.	3757	and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread.
3688	The new thread returned by this function shares with the original thread	3758	The new thread returned by this function shares with the original thread
3689	all global objects (such as tables),	3759	its global environment,
3690	but has an independent execution stack.	3760	but has an independent execution stack.
3691		3761
3692		3762
@@ -3707,15 +3777,7 @@ like any Lua object. · 14 unmodified lines
3707	This function allocates a new block of memory with the given size,	3777	This function allocates a new block of memory with the given size,
3708	pushes onto the stack a new full userdata with the block address,	3778	pushes onto the stack a new full userdata with the block address,
3709	and returns this address.	3779	and returns this address.
3710		3780	The host program can freely use this memory.
3711
3712	<p>
3713	Userdata represent C values in Lua.
3714	A <em>full userdata</em> represents a block of memory.
3715	It is an object (like a table):
3716	you must create it, it can have its own metatable,
3717	and you can detect when it is being collected.
3718	A full userdata is only equal to itself (under raw equality).
3719		3781
3720		3782
3721		3783
@@ -3780,7 +3842,7 @@ Lua to operate with another type for numbers (e.g., float or long). · 58 unmodified lines
3780		3842
3781		3843
3782	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>	3844	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
3783	<span class="apii">[-(nargs + 1), +(nresults\|1), <em>-</em>]</span>	3845	<span class="apii">[-(nargs + 1), +(nresults\|1), –]</span>
3784	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>	3846	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>
3785		3847
3786	<p>	3848	<p>
@@ -3855,9 +3917,13 @@ It is generated by the garbage collector.) · 68 unmodified lines
3855		3917
3856		3918
3857	<hr><h3><a name="lua_pcallk"><code>lua_pcallk</code></a></h3><p>	3919	<hr><h3><a name="lua_pcallk"><code>lua_pcallk</code></a></h3><p>
3858	<span class="apii">[-(nargs + 1), +(nresults\|1), <em>-</em>]</span>	3920	<span class="apii">[-(nargs + 1), +(nresults\|1), –]</span>
3859	<pre>int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,	3921	<pre>int lua_pcallk (lua_State *L,
3860	int ctx, lua_CFunction k);</pre>	3922	int nargs,
		3923	int nresults,
		3924	int errfunc,
		3925	int ctx,
		3926	lua_CFunction k);</pre>
3861		3927
3862	<p>	3928	<p>
3863	This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,	3929	This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,
@@ -3868,7 +3934,7 @@ but allows the called function to yield (see <a href="#4.7">§4.7</a>). · 4 unmodified lines
3868		3934
3869		3935
3870	<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>	3936	<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p>
3871	<span class="apii">[-n, +0, <em>-</em>]</span>	3937	<span class="apii">[-n, +0, –]</span>
3872	<pre>void lua_pop (lua_State *L, int n);</pre>	3938	<pre>void lua_pop (lua_State *L, int n);</pre>
3873		3939
3874	<p>	3940	<p>
@@ -3879,7 +3945,7 @@ Pops <code>n</code> elements from the stack. · 4 unmodified lines
3879		3945
3880		3946
3881	<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>	3947	<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p>
3882	<span class="apii">[-0, +1, <em>-</em>]</span>	3948	<span class="apii">[-0, +1, –]</span>
3883	<pre>void lua_pushboolean (lua_State *L, int b);</pre>	3949	<pre>void lua_pushboolean (lua_State *L, int b);</pre>
3884		3950
3885	<p>	3951	<p>
@@ -3920,14 +3986,14 @@ The maximum value for <code>n</code> is 255. · 34 unmodified lines
3920	When <code>n</code> is zero,	3986	When <code>n</code> is zero,
3921	this function creates a <em>light C function</em>,	3987	this function creates a <em>light C function</em>,
3922	which is just a pointer to the C function.	3988	which is just a pointer to the C function.
3923	In that case, it cannot throw a memory error.	3989	In that case, it never throws a memory error.
3924		3990
3925		3991
3926		3992
3927		3993
3928		3994
3929	<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>	3995	<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p>
3930	<span class="apii">[-0, +1, <em>-</em>]</span>	3996	<span class="apii">[-0, +1, –]</span>
3931	<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>	3997	<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre>
3932		3998
3933	<p>	3999	<p>
@@ -3948,7 +4014,9 @@ and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code>< · 14 unmodified lines
3948		4014
3949	<pre>	4015	<pre>
3950	#define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)	4016	#define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)
3951	</pre>	4017	</pre><p>
		4018	Note that <code>f</code> is used twice.
		4019
3952		4020
3953		4021
3954		4022
@@ -3980,7 +4048,7 @@ The conversion specifiers can only be · 25 unmodified lines
3980	'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),	4048	'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
3981	'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),	4049	'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),
3982	'<code>%d</code>' (inserts an <code>int</code>), and	4050	'<code>%d</code>' (inserts an <code>int</code>), and
3983	'<code>%c</code>' (inserts an <code>int</code> as a character).	4051	'<code>%c</code>' (inserts an <code>int</code> as a byte).
3984	</li>	4052	</li>
3985		4053
3986	</ul>	4054	</ul>
@@ -3989,7 +4057,7 @@ The conversion specifiers can only be · 2 unmodified lines
3989		4057
3990		4058
3991	<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>	4059	<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p>
3992	<span class="apii">[-0, +1, <em>-</em>]</span>	4060	<span class="apii">[-0, +1, –]</span>
3993	<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>	4061	<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre>
3994		4062
3995	<p>	4063	<p>
@@ -4000,7 +4068,7 @@ Pushes a number with value <code>n</code> onto the stack. · 4 unmodified lines
4000		4068
4001		4069
4002	<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>	4070	<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p>
4003	<span class="apii">[-0, +1, <em>-</em>]</span>	4071	<span class="apii">[-0, +1, –]</span>
4004	<pre>void lua_pushlightuserdata (lua_State L, void p);</pre>	4072	<pre>void lua_pushlightuserdata (lua_State L, void p);</pre>
4005		4073
4006	<p>	4074	<p>
@@ -4027,7 +4095,7 @@ light userdata with the same C address. · 20 unmodified lines
4027	<p>	4095	<p>
4028	This macro is equivalent to <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>,	4096	This macro is equivalent to <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>,
4029	but can be used only when <code>s</code> is a literal string.	4097	but can be used only when <code>s</code> is a literal string.
4030	In these cases, it automatically provides the string length.	4098	It automatically provides the string length.
4031		4099
4032		4100
4033		4101
@@ -4055,7 +4123,7 @@ Returns a pointer to the internal copy of the string. · 21 unmodified lines
4055		4123
4056		4124
4057	<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>	4125	<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p>
4058	<span class="apii">[-0, +1, <em>-</em>]</span>	4126	<span class="apii">[-0, +1, –]</span>
4059	<pre>void lua_pushnil (lua_State *L);</pre>	4127	<pre>void lua_pushnil (lua_State *L);</pre>
4060		4128
4061	<p>	4129	<p>
@@ -4066,7 +4134,7 @@ Pushes a nil value onto the stack. · 4 unmodified lines
4066		4134
4067		4135
4068	<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>	4136	<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p>
4069	<span class="apii">[-0, +1, <em>-</em>]</span>	4137	<span class="apii">[-0, +1, –]</span>
4070	<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>	4138	<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
4071		4139
4072	<p>	4140	<p>
@@ -4100,7 +4168,7 @@ If <code>s</code> is <code>NULL</code>, pushes <b>nil</b> and returns <code>NULL · 27 unmodified lines
4100		4168
4101		4169
4102	<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>	4170	<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p>
4103	<span class="apii">[-0, +1, <em>-</em>]</span>	4171	<span class="apii">[-0, +1, –]</span>
4104	<pre>int lua_pushthread (lua_State *L);</pre>	4172	<pre>int lua_pushthread (lua_State *L);</pre>
4105		4173
4106	<p>	4174	<p>
@@ -4112,7 +4180,7 @@ Returns 1 if this thread is the main thread of its state. · 5 unmodified lines
4112		4180
4113		4181
4114	<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>	4182	<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
4115	<span class="apii">[-0, +1, <em>-</em>]</span>	4183	<span class="apii">[-0, +1, –]</span>
4116	<pre>void lua_pushvalue (lua_State *L, int index);</pre>	4184	<pre>void lua_pushvalue (lua_State *L, int index);</pre>
4117		4185
4118	<p>	4186	<p>
@@ -4138,7 +4206,7 @@ instead of a variable number of arguments. · 19 unmodified lines
4138		4206
4139		4207
4140	<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>	4208	<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p>
4141	<span class="apii">[-0, +0, <em>-</em>]</span>	4209	<span class="apii">[-0, +0, –]</span>
4142	<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>	4210	<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre>
4143		4211
4144	<p>	4212	<p>
@@ -4153,7 +4221,7 @@ Also returns 0 if any of the indices are non valid. · 8 unmodified lines
4153		4221
4154		4222
4155	<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>	4223	<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
4156	<span class="apii">[-1, +1, <em>-</em>]</span>	4224	<span class="apii">[-1, +1, –]</span>
4157	<pre>void lua_rawget (lua_State *L, int index);</pre>	4225	<pre>void lua_rawget (lua_State *L, int index);</pre>
4158		4226
4159	<p>	4227	<p>
@@ -4165,7 +4233,7 @@ Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw · 5 unmodified lines
4165		4233
4166		4234
4167	<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>	4235	<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
4168	<span class="apii">[-0, +1, <em>-</em>]</span>	4236	<span class="apii">[-0, +1, –]</span>
4169	<pre>void lua_rawgeti (lua_State *L, int index, int n);</pre>	4237	<pre>void lua_rawgeti (lua_State *L, int index, int n);</pre>
4170		4238
4171	<p>	4239	<p>
@@ -4178,8 +4246,23 @@ that is, it does not invoke metamethods. · 6 unmodified lines
4178		4246
4179		4247
4180		4248
		4249	<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p>
		4250	<span class="apii">[-0, +1, –]</span>
		4251	<pre>void lua_rawgetp (lua_State L, int index, const void p);</pre>
		4252
		4253	<p>
		4254	Pushes onto the stack the value <code>t[k]</code>,
		4255	where <code>t</code> is the table at the given valid index and
		4256	<code>k</code> is the pointer <code>p</code> represented as a light userdata.
		4257	The access is raw;
		4258	that is, it does not invoke metamethods.
		4259
		4260
		4261
		4262
		4263
4181	<hr><h3><a name="lua_rawlen"><code>lua_rawlen</code></a></h3><p>	4264	<hr><h3><a name="lua_rawlen"><code>lua_rawlen</code></a></h3><p>
4182	<span class="apii">[-0, +0, <em>-</em>]</span>	4265	<span class="apii">[-0, +0, –]</span>
4183	<pre>size_t lua_rawlen (lua_State *L, int index);</pre>	4266	<pre>size_t lua_rawlen (lua_State *L, int index);</pre>
4184		4267
4185	<p>	4268	<p>
@@ -4226,6 +4309,26 @@ that is, it does not invoke metamethods. · 40 unmodified lines
4226		4309
4227		4310
4228		4311
		4312	<hr><h3><a name="lua_rawsetp"><code>lua_rawsetp</code></a></h3><p>
		4313	<span class="apii">[-1, +0, <em>m</em>]</span>
		4314	<pre>void lua_rawsetp (lua_State L, int index, const void p);</pre>
		4315
		4316	<p>
		4317	Does the equivalent of <code>t[k] = v</code>,
		4318	where <code>t</code> is the table at the given valid index,
		4319	<code>k</code> is the pointer <code>p</code> represented as a light userdata,
		4320	and <code>v</code> is the value at the top of the stack.
		4321
		4322
		4323	<p>
		4324	This function pops the value from the stack.
		4325	The assignment is raw;
		4326	that is, it does not invoke metamethods.
		4327
		4328
		4329
		4330
		4331
4229	<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>	4332	<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3>
4230	<pre>typedef const char * (lua_Reader) (lua_State L,	4333	<pre>typedef const char * (lua_Reader) (lua_State L,
4231	void *data,	4334	void *data,
@@ -4250,9 +4353,7 @@ The reader function may return pieces of any size greater than zero. · 18 unmodified lines
4250		4353
4251	<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>	4354	<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p>
4252	<span class="apii">[-0, +0, <em>e</em>]</span>	4355	<span class="apii">[-0, +0, <em>e</em>]</span>
4253	<pre>void lua_register (lua_State *L,	4356	<pre>void lua_register (lua_State L, const char name, lua_CFunction f);</pre>
4254	const char *name,
4255	lua_CFunction f);</pre>
4256		4357
4257	<p>	4358	<p>
4258	Sets the C function <code>f</code> as the new value of global <code>name</code>.	4359	Sets the C function <code>f</code> as the new value of global <code>name</code>.
@@ -4267,7 +4368,7 @@ It is defined as a macro: · 8 unmodified lines
4267		4368
4268		4369
4269	<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>	4370	<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p>
4270	<span class="apii">[-1, +0, <em>-</em>]</span>	4371	<span class="apii">[-1, +0, –]</span>
4271	<pre>void lua_remove (lua_State *L, int index);</pre>	4372	<pre>void lua_remove (lua_State *L, int index);</pre>
4272		4373
4273	<p>	4374	<p>
@@ -4281,7 +4382,7 @@ because a pseudo-index is not an actual stack position. · 7 unmodified lines
4281		4382
4282		4383
4283	<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>	4384	<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p>
4284	<span class="apii">[-1, +0, <em>-</em>]</span>	4385	<span class="apii">[-1, +0, –]</span>
4285	<pre>void lua_replace (lua_State *L, int index);</pre>	4386	<pre>void lua_replace (lua_State *L, int index);</pre>
4286		4387
4287	<p>	4388	<p>
@@ -4295,8 +4396,8 @@ and then pops the top element. · 7 unmodified lines
4295		4396
4296		4397
4297	<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>	4398	<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p>
4298	<span class="apii">[-?, +?, <em>-</em>]</span>	4399	<span class="apii">[-?, +?, –]</span>
4299	<pre>int lua_resume (lua_State *L, int narg);</pre>	4400	<pre>int lua_resume (lua_State L, lua_State from, int narg);</pre>
4300		4401
4301	<p>	4402	<p>
4302	Starts and resumes a coroutine in a given thread.	4403	Starts and resumes a coroutine in a given thread.
@@ -4330,11 +4431,17 @@ be passed as results from <code>yield</code>, · 27 unmodified lines
4330	and then call <a href="#lua_resume"><code>lua_resume</code></a>.	4431	and then call <a href="#lua_resume"><code>lua_resume</code></a>.
4331		4432
4332		4433
		4434	<p>
		4435	The parameter <code>from</code> represents the coroutine that is resuming <code>L</code>.
		4436	If there is no such coroutine,
		4437	this parameter can be <code>NULL</code>.
		4438
		4439
4333		4440
4334		4441
4335		4442
4336	<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>	4443	<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
4337	<span class="apii">[-0, +0, <em>-</em>]</span>	4444	<span class="apii">[-0, +0, –]</span>
4338	<pre>void lua_setallocf (lua_State L, lua_Alloc f, void ud);</pre>	4445	<pre>void lua_setallocf (lua_State L, lua_Alloc f, void ud);</pre>
4339		4446
4340	<p>	4447	<p>
@@ -4371,14 +4478,13 @@ for the "newindex" event (see <a href="#2.4">§2.4</a>). · 30 unmodified lines
4371	<p>	4478	<p>
4372	Pops a value from the stack and	4479	Pops a value from the stack and
4373	sets it as the new value of global <code>name</code>.	4480	sets it as the new value of global <code>name</code>.
4374	It is defined as a macro.
4375		4481
4376		4482
4377		4483
4378		4484
4379		4485
4380	<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>	4486	<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
4381	<span class="apii">[-1, +0, <em>-</em>]</span>	4487	<span class="apii">[-1, +0, –]</span>
4382	<pre>void lua_setmetatable (lua_State *L, int index);</pre>	4488	<pre>void lua_setmetatable (lua_State *L, int index);</pre>
4383		4489
4384	<p>	4490	<p>
@@ -4411,7 +4517,7 @@ for the "newindex" event (see <a href="#2.4">§2.4</a>). · 26 unmodified lines
4411		4517
4412		4518
4413	<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>	4519	<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p>
4414	<span class="apii">[-?, +?, <em>-</em>]</span>	4520	<span class="apii">[-?, +?, –]</span>
4415	<pre>void lua_settop (lua_State *L, int index);</pre>	4521	<pre>void lua_settop (lua_State *L, int index);</pre>
4416		4522
4417	<p>	4523	<p>
@@ -4426,7 +4532,7 @@ If <code>index</code> is 0, then all stack elements are removed. · 8 unmodified lines
4426		4532
4427		4533
4428	<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p>	4534	<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p>
4429	<span class="apii">[-1, +0, <em>-</em>]</span>	4535	<span class="apii">[-1, +0, –]</span>
4430	<pre>void lua_setuservalue (lua_State *L, int index);</pre>	4536	<pre>void lua_setuservalue (lua_State *L, int index);</pre>
4431		4537
4432	<p>	4538	<p>
@@ -4457,7 +4563,7 @@ which creates a Lua state from scratch. · 24 unmodified lines
4457		4563
4458		4564
4459	<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>	4565	<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p>
4460	<span class="apii">[-0, +0, <em>-</em>]</span>	4566	<span class="apii">[-0, +0, –]</span>
4461	<pre>int lua_status (lua_State *L);</pre>	4567	<pre>int lua_status (lua_State *L);</pre>
4462		4568
4463	<p>	4569	<p>
@@ -4482,7 +4588,7 @@ You can resume threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> · 18 unmodified lines
4482		4588
4483		4589
4484	<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>	4590	<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p>
4485	<span class="apii">[-0, +0, <em>-</em>]</span>	4591	<span class="apii">[-0, +0, –]</span>
4486	<pre>int lua_toboolean (lua_State *L, int index);</pre>	4592	<pre>int lua_toboolean (lua_State *L, int index);</pre>
4487		4593
4488	<p>	4594	<p>
@@ -4501,7 +4607,7 @@ use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's · 12 unmodified lines
4501		4607
4502		4608
4503	<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>	4609	<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p>
4504	<span class="apii">[-0, +0, <em>-</em>]</span>	4610	<span class="apii">[-0, +0, –]</span>
4505	<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>	4611	<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre>
4506		4612
4507	<p>	4613	<p>
@@ -4514,18 +4620,18 @@ otherwise, returns <code>NULL</code>. · 6 unmodified lines
4514		4620
4515		4621
4516	<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>	4622	<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p>
4517	<span class="apii">[-0, +0, <em>-</em>]</span>	4623	<span class="apii">[-0, +0, –]</span>
4518	<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>	4624	<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre>
4519		4625
4520	<p>	4626	<p>
4521	A macro equivalent to <code>lua_tointegerx(L, index, NULL)</code>.	4627	Equivalent to <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
4522		4628
4523		4629
4524		4630
4525		4631
4526		4632
4527	<hr><h3><a name="lua_tointegerx"><code>lua_tointegerx</code></a></h3><p>	4633	<hr><h3><a name="lua_tointegerx"><code>lua_tointegerx</code></a></h3><p>
4528	<span class="apii">[-0, +0, <em>-</em>]</span>	4634	<span class="apii">[-0, +0, –]</span>
4529	<pre>lua_Integer lua_tointegerx (lua_State L, int index, int isnum);</pre>	4635	<pre>lua_Integer lua_tointegerx (lua_State L, int index, int isnum);</pre>
4530		4636
4531	<p>	4637	<p>
@@ -4533,7 +4639,7 @@ Converts the Lua value at the given acceptable index · 1 unmodified line
4533	to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.	4639	to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
4534	The Lua value must be a number or a string convertible to a number	4640	The Lua value must be a number or a string convertible to a number
4535	(see <a href="#3.4.2">§3.4.2</a>);	4641	(see <a href="#3.4.2">§3.4.2</a>);
4536	otherwise, <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> returns 0.	4642	otherwise, <code>lua_tointegerx</code> returns 0.
4537		4643
4538		4644
4539	<p>	4645	<p>
@@ -4542,7 +4648,7 @@ it is truncated in some non-specified way. · 2 unmodified lines
4542		4648
4543		4649
4544	<p>	4650	<p>
4545	If <code>isnum</code> is different from <code>NULL</code>,	4651	If <code>isnum</code> is not <code>NULL</code>,
4546	its referent is assigned a boolean value that	4652	its referent is assigned a boolean value that
4547	indicates whether the operation succeeded.	4653	indicates whether the operation succeeded.
4548		4654
@@ -4561,20 +4667,20 @@ it also sets <code>*len</code> with the string length. · 12 unmodified lines
4561	The Lua value must be a string or a number;	4667	The Lua value must be a string or a number;
4562	otherwise, the function returns <code>NULL</code>.	4668	otherwise, the function returns <code>NULL</code>.
4563	If the value is a number,	4669	If the value is a number,
4564	then <a href="#lua_tolstring"><code>lua_tolstring</code></a> also	4670	then <code>lua_tolstring</code> also
4565	<em>changes the actual value in the stack to a string</em>.	4671	<em>changes the actual value in the stack to a string</em>.
4566	(This change confuses <a href="#lua_next"><code>lua_next</code></a>	4672	(This change confuses <a href="#lua_next"><code>lua_next</code></a>
4567	when <a href="#lua_tolstring"><code>lua_tolstring</code></a> is applied to keys during a table traversal.)	4673	when <code>lua_tolstring</code> is applied to keys during a table traversal.)
4568		4674
4569		4675
4570	<p>	4676	<p>
4571	<a href="#lua_tolstring"><code>lua_tolstring</code></a> returns a fully aligned pointer	4677	<code>lua_tolstring</code> returns a fully aligned pointer
4572	to a string inside the Lua state.	4678	to a string inside the Lua state.
4573	This string always has a zero ('<code>\0</code>')	4679	This string always has a zero ('<code>\0</code>')
4574	after its last character (as in C),	4680	after its last character (as in C),
4575	but can contain other zeros in its body.	4681	but can contain other zeros in its body.
4576	Because Lua has garbage collection,	4682	Because Lua has garbage collection,
4577	there is no guarantee that the pointer returned by <a href="#lua_tolstring"><code>lua_tolstring</code></a>	4683	there is no guarantee that the pointer returned by <code>lua_tolstring</code>
4578	will be valid after the corresponding value is removed from the stack.	4684	will be valid after the corresponding value is removed from the stack.
4579		4685
4580		4686
@@ -4582,18 +4688,18 @@ will be valid after the corresponding value is removed from the stack. · 1 unmodified line
4582		4688
4583		4689
4584	<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>	4690	<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p>
4585	<span class="apii">[-0, +0, <em>-</em>]</span>	4691	<span class="apii">[-0, +0, –]</span>
4586	<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>	4692	<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre>
4587		4693
4588	<p>	4694	<p>
4589	A macro equivalent to <code>lua_tonumberx(L, index, NULL)</code>.	4695	Equivalent to <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
4590		4696
4591		4697
4592		4698
4593		4699
4594		4700
4595	<hr><h3><a name="lua_tonumberx"><code>lua_tonumberx</code></a></h3><p>	4701	<hr><h3><a name="lua_tonumberx"><code>lua_tonumberx</code></a></h3><p>
4596	<span class="apii">[-0, +0, <em>-</em>]</span>	4702	<span class="apii">[-0, +0, –]</span>
4597	<pre>lua_Number lua_tonumberx (lua_State L, int index, int isnum);</pre>	4703	<pre>lua_Number lua_tonumberx (lua_State L, int index, int isnum);</pre>
4598		4704
4599	<p>	4705	<p>
@@ -4605,7 +4711,7 @@ otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns  · 5 unmodified lines
4605		4711
4606		4712
4607	<p>	4713	<p>
4608	If <code>isnum</code> is different from <code>NULL</code>,	4714	If <code>isnum</code> is not <code>NULL</code>,
4609	its referent is assigned a boolean value that	4715	its referent is assigned a boolean value that
4610	indicates whether the operation succeeded.	4716	indicates whether the operation succeeded.
4611		4717
@@ -4614,14 +4720,14 @@ indicates whether the operation succeeded. · 2 unmodified lines
4614		4720
4615		4721
4616	<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>	4722	<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p>
4617	<span class="apii">[-0, +0, <em>-</em>]</span>	4723	<span class="apii">[-0, +0, –]</span>
4618	<pre>const void lua_topointer (lua_State L, int index);</pre>	4724	<pre>const void lua_topointer (lua_State L, int index);</pre>
4619		4725
4620	<p>	4726	<p>
4621	Converts the value at the given acceptable index to a generic	4727	Converts the value at the given acceptable index to a generic
4622	C pointer (<code>void*</code>).	4728	C pointer (<code>void*</code>).
4623	The value can be a userdata, a table, a thread, or a function;	4729	The value can be a userdata, a table, a thread, or a function;
4624	otherwise, <a href="#lua_topointer"><code>lua_topointer</code></a> returns <code>NULL</code>.	4730	otherwise, <code>lua_topointer</code> returns <code>NULL</code>.
4625	Different objects will give different pointers.	4731	Different objects will give different pointers.
4626	There is no way to convert the pointer back to its original value.	4732	There is no way to convert the pointer back to its original value.
4627		4733
@@ -4645,7 +4751,7 @@ Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code · 17 unmodified lines
4645		4751
4646		4752
4647	<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>	4753	<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p>
4648	<span class="apii">[-0, +0, <em>-</em>]</span>	4754	<span class="apii">[-0, +0, –]</span>
4649	<pre>lua_State lua_tothread (lua_State L, int index);</pre>	4755	<pre>lua_State lua_tothread (lua_State L, int index);</pre>
4650		4756
4651	<p>	4757	<p>
@@ -4659,18 +4765,18 @@ otherwise, the function returns <code>NULL</code>. · 7 unmodified lines
4659		4765
4660		4766
4661	<hr><h3><a name="lua_tounsigned"><code>lua_tounsigned</code></a></h3><p>	4767	<hr><h3><a name="lua_tounsigned"><code>lua_tounsigned</code></a></h3><p>
4662	<span class="apii">[-0, +0, <em>-</em>]</span>	4768	<span class="apii">[-0, +0, –]</span>
4663	<pre>lua_Unsigned lua_tounsigned (lua_State *L, int index);</pre>	4769	<pre>lua_Unsigned lua_tounsigned (lua_State *L, int index);</pre>
4664		4770
4665	<p>	4771	<p>
4666	A macro equivalent to <code>lua_tounsignedx(L, index, NULL)</code>.	4772	Equivalent to <a href="#lua_tounsignedx"><code>lua_tounsignedx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
4667		4773
4668		4774
4669		4775
4670		4776
4671		4777
4672	<hr><h3><a name="lua_tounsignedx"><code>lua_tounsignedx</code></a></h3><p>	4778	<hr><h3><a name="lua_tounsignedx"><code>lua_tounsignedx</code></a></h3><p>
4673	<span class="apii">[-0, +0, <em>-</em>]</span>	4779	<span class="apii">[-0, +0, –]</span>
4674	<pre>lua_Unsigned lua_tounsignedx (lua_State L, int index, int isnum);</pre>	4780	<pre>lua_Unsigned lua_tounsignedx (lua_State L, int index, int isnum);</pre>
4675		4781
4676	<p>	4782	<p>
@@ -4678,7 +4784,7 @@ Converts the Lua value at the given acceptable index · 1 unmodified line
4678	to the unsigned integral type <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.	4784	to the unsigned integral type <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
4679	The Lua value must be a number or a string convertible to a number	4785	The Lua value must be a number or a string convertible to a number
4680	(see <a href="#3.4.2">§3.4.2</a>);	4786	(see <a href="#3.4.2">§3.4.2</a>);
4681	otherwise, <a href="#lua_tounsignedx"><code>lua_tounsignedx</code></a> returns 0.	4787	otherwise, <code>lua_tounsignedx</code> returns 0.
4682		4788
4683		4789
4684	<p>	4790	<p>
@@ -4690,7 +4796,7 @@ one more than the maximum representable value. · 5 unmodified lines
4690		4796
4691		4797
4692	<p>	4798	<p>
4693	If <code>isnum</code> is different from <code>NULL</code>,	4799	If <code>isnum</code> is not <code>NULL</code>,
4694	its referent is assigned a boolean value that	4800	its referent is assigned a boolean value that
4695	indicates whether the operation succeeded.	4801	indicates whether the operation succeeded.
4696		4802
@@ -4699,7 +4805,7 @@ indicates whether the operation succeeded. · 2 unmodified lines
4699		4805
4700		4806
4701	<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>	4807	<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
4702	<span class="apii">[-0, +0, <em>-</em>]</span>	4808	<span class="apii">[-0, +0, –]</span>
4703	<pre>void lua_touserdata (lua_State L, int index);</pre>	4809	<pre>void lua_touserdata (lua_State L, int index);</pre>
4704		4810
4705	<p>	4811	<p>
@@ -4714,13 +4820,12 @@ Otherwise, returns <code>NULL</code>. · 8 unmodified lines
4714		4820
4715		4821
4716	<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>	4822	<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p>
4717	<span class="apii">[-0, +0, <em>-</em>]</span>	4823	<span class="apii">[-0, +0, –]</span>
4718	<pre>int lua_type (lua_State *L, int index);</pre>	4824	<pre>int lua_type (lua_State *L, int index);</pre>
4719		4825
4720	<p>	4826	<p>
4721	Returns the type of the value in the given acceptable index,	4827	Returns the type of the value in the given acceptable index,
4722	or <code>LUA_TNONE</code> for a non-valid index	4828	or <code>LUA_TNONE</code> for a non-valid index.
4723	(that is, an index to an "empty" stack position).
4724	The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants	4829	The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants
4725	defined in <code>lua.h</code>:	4830	defined in <code>lua.h</code>:
4726	<a name="pdf-LUA_TNIL"><code>LUA_TNIL</code></a>,	4831	<a name="pdf-LUA_TNIL"><code>LUA_TNIL</code></a>,
@@ -4739,7 +4844,7 @@ and · 12 unmodified lines
4739		4844
4740		4845
4741	<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>	4846	<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p>
4742	<span class="apii">[-0, +0, <em>-</em>]</span>	4847	<span class="apii">[-0, +0, –]</span>
4743	<pre>const char lua_typename (lua_State L, int tp);</pre>	4848	<pre>const char lua_typename (lua_State L, int tp);</pre>
4744		4849
4745	<p>	4850	<p>
@@ -4807,11 +4912,11 @@ calling the writer again. · 61 unmodified lines
4807		4912
4808		4913
4809	<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>	4914	<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p>
4810	<span class="apii">[-?, +?, <em>-</em>]</span>	4915	<span class="apii">[-?, +?, –]</span>
4811	<pre>void lua_xmove (lua_State from, lua_State to, int n);</pre>	4916	<pre>void lua_xmove (lua_State from, lua_State to, int n);</pre>
4812		4917
4813	<p>	4918	<p>
4814	Exchange values between different threads of the same global state.	4919	Exchange values between different threads of the same state.
4815		4920
4816		4921
4817	<p>	4922	<p>
@@ -4823,7 +4928,7 @@ and pushes them onto the stack <code>to</code>. · 5 unmodified lines
4823		4928
4824		4929
4825	<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>	4930	<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
4826	<span class="apii">[-?, +?, <em>-</em>]</span>	4931	<span class="apii">[-?, +?, –]</span>
4827	<pre>int lua_yield (lua_State *L, int nresults);</pre>	4932	<pre>int lua_yield (lua_State *L, int nresults);</pre>
4828		4933
4829	<p>	4934	<p>
@@ -4838,7 +4943,7 @@ the function calling <code>lua_yield</code>. · 8 unmodified lines
4838		4943
4839		4944
4840	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>	4945	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>
4841	<span class="apii">[-?, +?, <em>-</em>]</span>	4946	<span class="apii">[-?, +?, –]</span>
4842	<pre>int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k);</pre>	4947	<pre>int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k);</pre>
4843		4948
4844	<p>	4949	<p>
@@ -4850,7 +4955,7 @@ This function should only be called as the · 5 unmodified lines
4850	return expression of a C function, as follows:	4955	return expression of a C function, as follows:
4851		4956
4852	<pre>	4957	<pre>
4853	return lua_yield (L, nresults, i, k);	4958	return lua_yieldk (L, n, i, k);
4854	</pre><p>	4959	</pre><p>
4855	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,	4960	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,
4856	the running coroutine suspends its execution,	4961	the running coroutine suspends its execution,
@@ -4928,7 +5033,7 @@ If <code>source</code> starts with a '<code>@</code>', · 71 unmodified lines
4928	it means that the function was defined in a file where	5033	it means that the function was defined in a file where
4929	the file name follows the '<code>@</code>'.	5034	the file name follows the '<code>@</code>'.
4930	If <code>source</code> starts with a '<code>=</code>',	5035	If <code>source</code> starts with a '<code>=</code>',
4931	the rest of it should describe the source in a user-dependent manner.	5036	the remainder of its contents describe the source in a user-dependent manner.
4932	Otherwise,	5037	Otherwise,
4933	the function was defined in a string where	5038	the function was defined in a string where
4934	<code>source</code> is that string.	5039	<code>source</code> is that string.
@@ -4994,7 +5099,7 @@ the number of fixed parameters of the function · 59 unmodified lines
4994	</li>	5099	</li>
4995		5100
4996	<li><b><code>isvararg</code>: </b>	5101	<li><b><code>isvararg</code>: </b>
4997	whether the function is a vararg function	5102	true if the function is a vararg function
4998	(always true for C functions).	5103	(always true for C functions).
4999	</li>	5104	</li>
5000		5105
@@ -5004,7 +5109,7 @@ whether the function is a vararg function · 3 unmodified lines
5004		5109
5005		5110
5006	<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>	5111	<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p>
5007	<span class="apii">[-0, +0, <em>-</em>]</span>	5112	<span class="apii">[-0, +0, –]</span>
5008	<pre>lua_Hook lua_gethook (lua_State *L);</pre>	5113	<pre>lua_Hook lua_gethook (lua_State *L);</pre>
5009		5114
5010	<p>	5115	<p>
@@ -5015,7 +5120,7 @@ Returns the current hook function. · 4 unmodified lines
5015		5120
5016		5121
5017	<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>	5122	<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p>
5018	<span class="apii">[-0, +0, <em>-</em>]</span>	5123	<span class="apii">[-0, +0, –]</span>
5019	<pre>int lua_gethookcount (lua_State *L);</pre>	5124	<pre>int lua_gethookcount (lua_State *L);</pre>
5020		5125
5021	<p>	5126	<p>
@@ -5026,7 +5131,7 @@ Returns the current hook count. · 4 unmodified lines
5026		5131
5027		5132
5028	<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>	5133	<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p>
5029	<span class="apii">[-0, +0, <em>-</em>]</span>	5134	<span class="apii">[-0, +0, –]</span>
5030	<pre>int lua_gethookmask (lua_State *L);</pre>	5135	<pre>int lua_gethookmask (lua_State *L);</pre>
5031		5136
5032	<p>	5137	<p>
@@ -5115,7 +5220,7 @@ This function returns 0 on error · 82 unmodified lines
5115		5220
5116		5221
5117	<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>	5222	<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p>
5118	<span class="apii">[-0, +(0\|1), <em>-</em>]</span>	5223	<span class="apii">[-0, +(0\|1), –]</span>
5119	<pre>const char lua_getlocal (lua_State L, lua_Debug *ar, int n);</pre>	5224	<pre>const char lua_getlocal (lua_State L, lua_Debug *ar, int n);</pre>
5120		5225
5121	<p>	5226	<p>
@@ -5156,7 +5261,7 @@ the number of active local variables. · 34 unmodified lines
5156		5261
5157		5262
5158	<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>	5263	<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p>
5159	<span class="apii">[-0, +0, <em>-</em>]</span>	5264	<span class="apii">[-0, +0, –]</span>
5160	<pre>int lua_getstack (lua_State L, int level, lua_Debug ar);</pre>	5265	<pre>int lua_getstack (lua_State L, int level, lua_Debug ar);</pre>
5161		5266
5162	<p>	5267	<p>
@@ -5179,7 +5284,7 @@ it returns 0. · 16 unmodified lines
5179		5284
5180		5285
5181	<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>	5286	<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p>
5182	<span class="apii">[-0, +(0\|1), <em>-</em>]</span>	5287	<span class="apii">[-0, +(0\|1), –]</span>
5183	<pre>const char lua_getupvalue (lua_State L, int funcindex, int n);</pre>	5288	<pre>const char lua_getupvalue (lua_State L, int funcindex, int n);</pre>
5184		5289
5185	<p>	5290	<p>
@@ -5241,7 +5346,7 @@ this execution occurs without any calls to hooks. · 55 unmodified lines
5241		5346
5242		5347
5243	<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>	5348	<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
5244	<span class="apii">[-0, +0, <em>-</em>]</span>	5349	<span class="apii">[-0, +0, –]</span>
5245	<pre>int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>	5350	<pre>int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
5246		5351
5247	<p>	5352	<p>
@@ -5294,7 +5399,7 @@ A hook is disabled by setting <code>mask</code> to zero. · 46 unmodified lines
5294		5399
5295		5400
5296	<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>	5401	<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p>
5297	<span class="apii">[-(0\|1), +0, <em>-</em>]</span>	5402	<span class="apii">[-(0\|1), +0, –]</span>
5298	<pre>const char lua_setlocal (lua_State L, lua_Debug *ar, int n);</pre>	5403	<pre>const char lua_setlocal (lua_State L, lua_Debug *ar, int n);</pre>
5299		5404
5300	<p>	5405	<p>
@@ -5316,7 +5421,7 @@ the number of active local variables. · 15 unmodified lines
5316		5421
5317		5422
5318	<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>	5423	<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p>
5319	<span class="apii">[-(0\|1), +0, <em>-</em>]</span>	5424	<span class="apii">[-(0\|1), +0, –]</span>
5320	<pre>const char lua_setupvalue (lua_State L, int funcindex, int n);</pre>	5425	<pre>const char lua_setupvalue (lua_State L, int funcindex, int n);</pre>
5321		5426
5322	<p>	5427	<p>
@@ -5337,7 +5442,7 @@ when the index is greater than the number of upvalues. · 14 unmodified lines
5337		5442
5338		5443
5339	<hr><h3><a name="lua_upvalueid"><code>lua_upvalueid</code></a></h3><p>	5444	<hr><h3><a name="lua_upvalueid"><code>lua_upvalueid</code></a></h3><p>
5340	<span class="apii">[-0, +0, <em>-</em>]</span>	5445	<span class="apii">[-0, +0, –]</span>
5341	<pre>void lua_upvalueid (lua_State L, int funcindex, int n);</pre>	5446	<pre>void lua_upvalueid (lua_State L, int funcindex, int n);</pre>
5342		5447
5343	<p>	5448	<p>
@@ -5386,7 +5491,7 @@ common tasks. · 42 unmodified lines
5386		5491
5387		5492
5388	<p>	5493	<p>
5389	All functions from the auxiliary library	5494	All functions and types from the auxiliary library
5390	are defined in header file <code>lauxlib.h</code> and	5495	are defined in header file <code>lauxlib.h</code> and
5391	have a prefix <code>luaL_</code>.	5496	have a prefix <code>luaL_</code>.
5392		5497
@@ -5395,6 +5500,8 @@ have a prefix <code>luaL_</code>. · 2 unmodified lines
5395	All functions in the auxiliary library are built on	5500	All functions in the auxiliary library are built on
5396	top of the basic API,	5501	top of the basic API,
5397	and so they provide nothing that cannot be done with that API.	5502	and so they provide nothing that cannot be done with that API.
		5503	Nevertheless, the use of the auxiliary library ensures
		5504	more consistency to your code.
5398		5505
5399		5506
5400	<p>	5507	<p>
@@ -5432,7 +5539,7 @@ in alphabetical order. · 31 unmodified lines
5432	<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>	5539	<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre>
5433		5540
5434	<p>	5541	<p>
5435	Adds the character <code>c</code> to the buffer <code>B</code>	5542	Adds the byte <code>c</code> to the buffer <code>B</code>
5436	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).	5543	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
5437		5544
5438		5545
@@ -5474,7 +5581,7 @@ buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>). · 35 unmodified lines
5474	Adds the zero-terminated string pointed to by <code>s</code>	5581	Adds the zero-terminated string pointed to by <code>s</code>
5475	to the buffer <code>B</code>	5582	to the buffer <code>B</code>
5476	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).	5583	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
5477	The string should not contain embedded zeros.	5584	The string cannot contain embedded zeros.
5478		5585
5479		5586
5480		5587
@@ -5509,12 +5616,8 @@ which is the value to be added to the buffer. · 28 unmodified lines
5509		5616
5510	<p>	5617	<p>
5511	Checks whether <code>cond</code> is true.	5618	Checks whether <code>cond</code> is true.
5512	If not, raises an error with the following message,	5619	If not, raises an error with a standard message.
5513	where <code>func</code> is retrieved from the call stack:
5514		5620
5515	<pre>
5516	bad argument #<narg> to <func> (<extramsg>)
5517	</pre>
5518		5621
5519		5622
5520		5623
@@ -5524,12 +5627,9 @@ where <code>func</code> is retrieved from the call stack: · 3 unmodified lines
5524	<pre>int luaL_argerror (lua_State L, int narg, const char extramsg);</pre>	5627	<pre>int luaL_argerror (lua_State L, int narg, const char extramsg);</pre>
5525		5628
5526	<p>	5629	<p>
5527	Raises an error with the following message,	5630	Raises an error with a standard message
5528	where <code>func</code> is retrieved from the call stack:	5631	that includes <code>extramsg</code> as a comment.
5529		5632
5530	<pre>
5531	bad argument #<narg> to <func> (<extramsg>)
5532	</pre>
5533		5633
5534	<p>	5634	<p>
5535	This function never returns,	5635	This function never returns,
@@ -5553,17 +5653,17 @@ Its pattern of use is as follows: · 17 unmodified lines
5553		5653
5554	<ul>	5654	<ul>
5555		5655
5556	<li>First you declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>	5656	<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
5557		5657
5558	<li>Then you initialize it with a call <code>luaL_buffinit(L, &b)</code>.</li>	5658	<li>Then initialize it with a call <code>luaL_buffinit(L, &b)</code>.</li>
5559		5659
5560	<li>	5660	<li>
5561	Then you add string pieces to the buffer calling any of	5661	Then add string pieces to the buffer calling any of
5562	the <code>luaL_add*</code> functions.	5662	the <code>luaL_add*</code> functions.
5563	</li>	5663	</li>
5564		5664
5565	<li>	5665	<li>
5566	You finish by calling <code>luaL_pushresult(&b)</code>.	5666	Finish by calling <code>luaL_pushresult(&b)</code>.
5567	This call leaves the final string on the top of the stack.	5667	This call leaves the final string on the top of the stack.
5568	</li>	5668	</li>
5569		5669
@@ -5575,15 +5675,15 @@ you can use the buffer like this: · 5 unmodified lines
5575		5675
5576	<ul>	5676	<ul>
5577		5677
5578	<li>First you declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>	5678	<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li>
5579		5679
5580	<li>Then you initialize it and preallocate a space of	5680	<li>Then initialize it and preallocate a space of
5581	size <code>sz</code> with a call <code>luaL_buffinitsize(L, &b, sz)</code>.</li>	5681	size <code>sz</code> with a call <code>luaL_buffinitsize(L, &b, sz)</code>.</li>
5582		5682
5583	<li>Then you copy the string into that space.</li>	5683	<li>Then copy the string into that space.</li>
5584		5684
5585	<li>	5685	<li>
5586	You finish by calling <code>luaL_pushresult(&b, sz)</code>,	5686	Finish by calling <code>luaL_pushresult(&b, sz)</code>,
5587	where <code>sz</code> is the total size of the resulting string	5687	where <code>sz</code> is the total size of the resulting string
5588	copied into that space.	5688	copied into that space.
5589	</li>	5689	</li>
@@ -5611,7 +5711,7 @@ plus the final string on its top. · 21 unmodified lines
5611		5711
5612		5712
5613	<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>	5713	<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>
5614	<span class="apii">[-0, +0, <em>-</em>]</span>	5714	<span class="apii">[-0, +0, –]</span>
5615	<pre>void luaL_buffinit (lua_State L, luaL_Buffer B);</pre>	5715	<pre>void luaL_buffinit (lua_State L, luaL_Buffer B);</pre>
5616		5716
5617	<p>	5717	<p>
@@ -5647,7 +5747,7 @@ Calls a metamethod. · 29 unmodified lines
5647	<p>	5747	<p>
5648	If the object at index <code>obj</code> has a metatable and this	5748	If the object at index <code>obj</code> has a metatable and this
5649	metatable has a field <code>e</code>,	5749	metatable has a field <code>e</code>,
5650	this function calls this field and passes the object as its only argument.	5750	this function calls this field passing the object as its only argument.
5651	In this case this function returns true and pushes onto the	5751	In this case this function returns true and pushes onto the
5652	stack the value returned by the call.	5752	stack the value returned by the call.
5653	If there is no metatable or no metamethod,	5753	If there is no metatable or no metamethod,
@@ -5755,7 +5855,7 @@ if the string cannot be found. · 101 unmodified lines
5755	<p>	5855	<p>
5756	If <code>def</code> is not <code>NULL</code>,	5856	If <code>def</code> is not <code>NULL</code>,
5757	the function uses <code>def</code> as a default value when	5857	the function uses <code>def</code> as a default value when
5758	there is no argument <code>narg</code> or if this argument is <b>nil</b>.	5858	there is no argument <code>narg</code> or when this argument is <b>nil</b>.
5759		5859
5760		5860
5761	<p>	5861	<p>
@@ -5836,7 +5936,7 @@ and returns this number cast to a <a href="#lua_Unsigned"><code>lua_Unsigned</co · 74 unmodified lines
5836		5936
5837		5937
5838	<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>	5938	<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>
5839	<span class="apii">[-0, +0, <em>-</em>]</span>	5939	<span class="apii">[-0, +0, –]</span>
5840	<pre>void luaL_checkversion (lua_State *L);</pre>	5940	<pre>void luaL_checkversion (lua_State *L);</pre>
5841		5941
5842	<p>	5942	<p>
@@ -5870,7 +5970,7 @@ or true in case of errors. · 27 unmodified lines
5870		5970
5871		5971
5872	<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>	5972	<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p>
5873	<span class="apii">[-0, +?, <em>-</em>]</span>	5973	<span class="apii">[-0, +?, –]</span>
5874	<pre>int luaL_dostring (lua_State L, const char str);</pre>	5974	<pre>int luaL_dostring (lua_State L, const char str);</pre>
5875		5975
5876	<p>	5976	<p>
@@ -5952,7 +6052,7 @@ returns false and pushes nothing. · 75 unmodified lines
5952		6052
5953		6053
5954	<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>	6054	<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p>
5955	<span class="apii">[-0, +1, <em>-</em>]</span>	6055	<span class="apii">[-0, +1, –]</span>
5956	<pre>void luaL_getmetatable (lua_State L, const char tname);</pre>	6056	<pre>void luaL_getmetatable (lua_State L, const char tname);</pre>
5957		6057
5958	<p>	6058	<p>
@@ -6012,7 +6112,7 @@ Raises an error if the result of the operation is not a number. · 53 unmodified lines
6012		6112
6013		6113
6014	<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>	6114	<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p>
6015	<span class="apii">[-0, +1, <em>-</em>]</span>	6115	<span class="apii">[-0, +1, –]</span>
6016	<pre>int luaL_loadbuffer (lua_State *L,	6116	<pre>int luaL_loadbuffer (lua_State *L,
6017	const char *buff,	6117	const char *buff,
6018	size_t sz,	6118	size_t sz,
@@ -6035,7 +6135,16 @@ used for debug information and error messages. · 16 unmodified lines
6035		6135
6036	<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>	6136	<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p>
6037	<span class="apii">[-0, +1, <em>m</em>]</span>	6137	<span class="apii">[-0, +1, <em>m</em>]</span>
6038	<pre>int luaL_loadfile (lua_State L, const char filename);</pre>	6138	<pre>int luaL_loadfile (lua_State L, const char filename);</pre><p>
		6139	Equivalent to <a href="#luaL_loadfilex"><code>luaL_loadfilex</code></a> with <code>mode</code> equal to <code>NULL</code>.
		6140
		6141
		6142
		6143
		6144	<hr><h3><a name="luaL_loadfilex"><code>luaL_loadfilex</code></a></h3><p>
		6145	<span class="apii">[-0, +1, <em>m</em>]</span>
		6146	<pre>int luaL_loadfilex (lua_State L, const char filename,
		6147	const char *mode);</pre>
6039		6148
6040	<p>	6149	<p>
6041	Loads a file as a Lua chunk.	6150	Loads a file as a Lua chunk.
@@ -6046,10 +6155,16 @@ then it loads from the standard input. · 4 unmodified lines
6046	The first line in the file is ignored if it starts with a <code>#</code>.	6155	The first line in the file is ignored if it starts with a <code>#</code>.
6047		6156
6048		6157
		6158	<p>
		6159	The string <code>mode</code> works as in function <a href="#pdf-load"><code>load</code></a>,
		6160	with the addition that
		6161	a <code>NULL</code> value is equivalent to the string "<code>bt</code>".
		6162
		6163
6049	<p>	6164	<p>
6050	This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>,	6165	This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>,
6051	but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>	6166	but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a>
6052	if it cannot open/read the file.	6167	if it cannot open/read the file or the file has a wrong mode.
6053		6168
6054		6169
6055	<p>	6170	<p>
@@ -6061,7 +6176,7 @@ it does not run it. · 5 unmodified lines
6061		6176
6062		6177
6063	<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>	6178	<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p>
6064	<span class="apii">[-0, +1, <em>-</em>]</span>	6179	<span class="apii">[-0, +1, –]</span>
6065	<pre>int luaL_loadstring (lua_State L, const char s);</pre>	6180	<pre>int luaL_loadstring (lua_State L, const char s);</pre>
6066		6181
6067	<p>	6182	<p>
@@ -6141,7 +6256,7 @@ with <code>tname</code> in the registry. · 73 unmodified lines
6141		6256
6142		6257
6143	<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>	6258	<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p>
6144	<span class="apii">[-0, +0, <em>-</em>]</span>	6259	<span class="apii">[-0, +0, –]</span>
6145	<pre>lua_State *luaL_newstate (void);</pre>	6260	<pre>lua_State *luaL_newstate (void);</pre>
6146		6261
6147	<p>	6262	<p>
@@ -6434,7 +6549,7 @@ These values are popped from the stack after the registration. · 286 unmodified lines
6434		6549
6435		6550
6436	<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p>	6551	<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p>
6437	<span class="apii">[-0, +0, <em>-</em>]</span>	6552	<span class="apii">[-0, +0, –]</span>
6438	<pre>void luaL_setmetatable (lua_State L, const char tname);</pre>	6553	<pre>void luaL_setmetatable (lua_State L, const char tname);</pre>
6439		6554
6440	<p>	6555	<p>
@@ -6499,7 +6614,7 @@ to start the traceback. · 58 unmodified lines
6499		6614
6500		6615
6501	<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>	6616	<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p>
6502	<span class="apii">[-0, +0, <em>-</em>]</span>	6617	<span class="apii">[-0, +0, –]</span>
6503	<pre>const char luaL_typename (lua_State L, int index);</pre>	6618	<pre>const char luaL_typename (lua_State L, int index);</pre>
6504		6619
6505	<p>	6620	<p>
@@ -6510,7 +6625,7 @@ Returns the name of the type of the value at the given index. · 4 unmodified lines
6510		6625
6511		6626
6512	<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>	6627	<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
6513	<span class="apii">[-0, +0, <em>-</em>]</span>	6628	<span class="apii">[-0, +0, –]</span>
6514	<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>	6629	<pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
6515		6630
6516	<p>	6631	<p>
@@ -6575,28 +6690,28 @@ Currently, Lua has the following standard libraries: · 58 unmodified lines
6575		6690
6576	<ul>	6691	<ul>
6577		6692
6578	<li>basic library;</li>	6693	<li>basic library (<a href="#6.1">§6.1</a>);</li>
6579		6694
6580	<li>package library;</li>	6695	<li>coroutine library (<a href="#6.2">§6.2</a>);</li>
6581		6696
6582	<li>coroutine library;</li>	6697	<li>package library (<a href="#6.3">§6.3</a>);</li>
6583		6698
6584	<li>string manipulation;</li>	6699	<li>string manipulation (<a href="#6.4">§6.4</a>);</li>
6585		6700
6586	<li>table manipulation;</li>	6701	<li>table manipulation (<a href="#6.5">§6.5</a>);</li>
6587		6702
6588	<li>mathematical functions (sin, log, etc.);</li>	6703	<li>mathematical functions (<a href="#6.6">§6.6</a>) (sin, log, etc.);</li>
6589		6704
6590	<li>bitwise operations;</li>	6705	<li>bitwise operations (<a href="#6.7">§6.7</a>);</li>
6591		6706
6592	<li>input and output;</li>	6707	<li>input and output (<a href="#6.8">§6.8</a>);</li>
6593		6708
6594	<li>operating system facilities;</li>	6709	<li>operating system facilities (<a href="#6.9">§6.9</a>);</li>
6595		6710
6596	<li>debug facilities.</li>	6711	<li>debug facilities (<a href="#6.10">§6.10</a>).</li>
6597		6712
6598	</ul><p>	6713	</ul><p>
6599	Except for the basic and package libraries,	6714	Except for the basic and the package libraries,
6600	each library provides all its functions as fields of a global table	6715	each library provides all its functions as fields of a global table
6601	or as methods of its objects.	6716	or as methods of its objects.
6602		6717
@@ -6627,7 +6742,7 @@ e.g., by using <a href="#lua_call"><code>lua_call</code></a>. · 24 unmodified lines
6627	<h2>6.1 – <a name="6.1">Basic Functions</a></h2>	6742	<h2>6.1 – <a name="6.1">Basic Functions</a></h2>
6628		6743
6629	<p>	6744	<p>
6630	The basic library provides some core functions to Lua.	6745	The basic library provides core functions to Lua.
6631	If you do not include this library in your application,	6746	If you do not include this library in your application,
6632	you should check carefully whether you need to provide	6747	you should check carefully whether you need to provide
6633	implementations for some of its facilities.	6748	implementations for some of its facilities.
@@ -6660,13 +6775,13 @@ This is the default option. · 26 unmodified lines
6660	</li>	6775	</li>
6661		6776
6662	<li><b>"<code>stop</code>": </b>	6777	<li><b>"<code>stop</code>": </b>
6663	stops automatic invocation of the garbage collector.	6778	stops automatic execution of the garbage collector.
6664	The collector will run only when explcitly invoked,	6779	The collector will run only when explicitly invoked,
6665	until a call to restart it.	6780	until a call to restart it.
6666	</li>	6781	</li>
6667		6782
6668	<li><b>"<code>restart</code>": </b>	6783	<li><b>"<code>restart</code>": </b>
6669	restarts automatic invocation the garbage collector.	6784	restarts automatic execution of the garbage collector.
6670	</li>	6785	</li>
6671		6786
6672	<li><b>"<code>count</code>": </b>	6787	<li><b>"<code>count</code>": </b>
@@ -6709,6 +6824,16 @@ returns a boolean that tells whether the collector is running · 36 unmodified lines
6709	(i.e., not stopped).	6824	(i.e., not stopped).
6710	</li>	6825	</li>
6711		6826
		6827	<li><b>"<code>generational</code>": </b>
		6828	changes the collector to generational mode.
		6829	This is an experimental feature (see <a href="#2.5">§2.5</a>).
		6830	</li>
		6831
		6832	<li><b>"<code>incremental</code>": </b>
		6833	changes the collector to incremental mode.
		6834	This is the default mode.
		6835	</li>
		6836
6712	</ul>	6837	</ul>
6713		6838
6714		6839
@@ -6789,7 +6914,7 @@ so that the construction · 74 unmodified lines
6789	<pre>	6914	<pre>
6790	for i,v in ipairs(t) do <em>body</em> end	6915	for i,v in ipairs(t) do <em>body</em> end
6791	</pre><p>	6916	</pre><p>
6792	will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), ···,	6917	will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), ...,
6793	up to the first integer key absent from the table.	6918	up to the first integer key absent from the table.
6794		6919
6795		6920
@@ -6823,8 +6948,8 @@ If the resulting function has upvalues, · 27 unmodified lines
6823	the first upvalue is set to the value of the	6948	the first upvalue is set to the value of the
6824	global environment or to <code>env</code>,	6949	global environment or to <code>env</code>,
6825	if that parameter is given.	6950	if that parameter is given.
6826	(When loading main chunks,	6951	When loading main chunks,
6827	the first upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).)	6952	the first upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).
6828		6953
6829		6954
6830	<p>	6955	<p>
@@ -6832,21 +6957,22 @@ the first upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">&se · 1 unmodified line
6832	and debug information (see <a href="#4.9">§4.9</a>).	6957	and debug information (see <a href="#4.9">§4.9</a>).
6833	When absent,	6958	When absent,
6834	it defaults to <code>ld</code>, if <code>ld</code> is a string,	6959	it defaults to <code>ld</code>, if <code>ld</code> is a string,
6835	or to "<code>=(load)</code>".	6960	or to "<code>=(load)</code>" otherwise.
6836		6961
6837		6962
6838	<p>	6963	<p>
6839	The string <code>mode</code> controls whether the chunk can be text or binary	6964	The string <code>mode</code> controls whether the chunk can be text or binary
6840	(that is, a precompiled chunk).	6965	(that is, a precompiled chunk).
6841	A letter '<code>t</code>' in <code>mode</code> allows a text chunk;	6966	It may be the string "<code>b</code>" (only binary chunks),
6842	a letter '<code>b</code>' allows a binary chunk.	6967	"<code>t</code>" (only text chunks),
		6968	or "<code>bt</code>" (both binary and text).
6843	The default is "<code>bt</code>".	6969	The default is "<code>bt</code>".
6844		6970
6845		6971
6846		6972
6847		6973
6848	<p>	6974	<p>
6849	<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename])</code></a></h3>	6975	<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename [, mode [, env]]])</code></a></h3>
6850		6976
6851		6977
6852	<p>	6978	<p>
@@ -6945,13 +7071,14 @@ In case of any error, <code>pcall</code> returns <b>false</b> plus the error mes · 92 unmodified lines
6945		7071
6946	<p>	7072	<p>
6947	<hr><h3><a name="pdf-print"><code>print (···)</code></a></h3>	7073	<hr><h3><a name="pdf-print"><code>print (···)</code></a></h3>
6948	Receives any number of arguments,	7074	Receives any number of arguments
6949	and prints their values to <code>stdout</code>,	7075	and prints their values to <code>stdout</code>,
6950	using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert them to strings.	7076	using the <a href="#pdf-tostring"><code>tostring</code></a> function to convert each argument to a string.
6951	<code>print</code> is not intended for formatted output,	7077	<code>print</code> is not intended for formatted output,
6952	but only as a quick way to show a value,	7078	but only as a quick way to show a value,
6953	typically for debugging.	7079	for instance for debugging.
6954	For formatted output, use <a href="#pdf-string.format"><code>string.format</code></a>.	7080	For complete control over the output,
		7081	use <a href="#pdf-string.format"><code>string.format</code></a> and <a href="#pdf-io.write"><code>io.write</code></a>.
6955		7082
6956		7083
6957		7084
@@ -6990,7 +7117,7 @@ Returns an integer number. · 32 unmodified lines
6990	Sets the real value of <code>table[index]</code> to <code>value</code>,	7117	Sets the real value of <code>table[index]</code> to <code>value</code>,
6991	without invoking any metamethod.	7118	without invoking any metamethod.
6992	<code>table</code> must be a table,	7119	<code>table</code> must be a table,
6993	<code>index</code> any value different from <b>nil</b>,	7120	<code>index</code> any value different from <b>nil</b> and NaN,
6994	and <code>value</code> any Lua value.	7121	and <code>value</code> any Lua value.
6995		7122
6996		7123
@@ -7035,37 +7162,43 @@ This function returns <code>table</code>. · 38 unmodified lines
7035		7162
7036	<p>	7163	<p>
7037	<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>	7164	<hr><h3><a name="pdf-tonumber"><code>tonumber (e [, base])</code></a></h3>
7038	Tries to convert its argument to a number.	7165
7039	If the argument is already a number or a string convertible	7166
7040	to a number, then <code>tonumber</code> returns this number;	7167	<p>
		7168	When called with no <code>base</code>,
		7169	<code>tonumber</code> tries to convert its argument to a number.
		7170	If the argument is already a number or
		7171	a string convertible to a number (see <a href="#3.4.2">§3.4.2</a>),
		7172	then <code>tonumber</code> returns this number;
7041	otherwise, it returns <b>nil</b>.	7173	otherwise, it returns <b>nil</b>.
7042		7174
7043		7175
7044	<p>	7176	<p>
7045	An optional argument specifies the base to interpret the numeral.	7177	When called with <code>base</code>,
		7178	then <code>e</code> should be a string to be interpreted as
		7179	an integer numeral in that base.
7046	The base may be any integer between 2 and 36, inclusive.	7180	The base may be any integer between 2 and 36, inclusive.
7047	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)	7181	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)
7048	represents 10, '<code>B</code>' represents 11, and so forth,	7182	represents 10, '<code>B</code>' represents 11, and so forth,
7049	with '<code>Z</code>' representing 35.	7183	with '<code>Z</code>' representing 35.
7050	In base 10 (the default),	7184	If the string <code>e</code> is not a valid numeral in the given base,
7051	the numeral is converted following the coercion rules (see <a href="#3.4.2">§3.4.2</a>).	7185	the function returns <b>nil</b>.
7052	In other bases, only integers are accepted.
7053		7186
7054		7187
7055		7188
7056		7189
7057	<p>	7190	<p>
7058	<hr><h3><a name="pdf-tostring"><code>tostring (e)</code></a></h3>	7191	<hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3>
7059	Receives an argument of any type and	7192	Receives a value of any type and
7060	converts it to a string in a reasonable format.	7193	converts it to a string in a reasonable format.
7061	For complete control of how numbers are converted,	7194	(For complete control of how numbers are converted,
7062	use <a href="#pdf-string.format"><code>string.format</code></a>.	7195	use <a href="#pdf-string.format"><code>string.format</code></a>.)
7063		7196
7064		7197
7065	<p>	7198	<p>
7066	If the metatable of <code>e</code> has a <code>"__tostring"</code> field,	7199	If the metatable of <code>v</code> has a <code>"__tostring"</code> field,
7067	then <code>tostring</code> calls the corresponding value	7200	then <code>tostring</code> calls the corresponding value
7068	with <code>e</code> as argument,	7201	with <code>v</code> as argument,
7069	and uses the result of the call as its result.	7202	and uses the result of the call as its result.
7070		7203
7071		7204
@@ -7139,11 +7272,11 @@ an object with type <code>"thread"</code>. · 67 unmodified lines
7139	Starts or continues the execution of coroutine <code>co</code>.	7272	Starts or continues the execution of coroutine <code>co</code>.
7140	The first time you resume a coroutine,	7273	The first time you resume a coroutine,
7141	it starts running its body.	7274	it starts running its body.
7142	The values <code>val1</code>, ··· are passed	7275	The values <code>val1</code>, ... are passed
7143	as the arguments to the body function.	7276	as the arguments to the body function.
7144	If the coroutine has yielded,	7277	If the coroutine has yielded,
7145	<code>resume</code> restarts it;	7278	<code>resume</code> restarts it;
7146	the values <code>val1</code>, ··· are passed	7279	the values <code>val1</code>, ... are passed
7147	as the results from the yield.	7280	as the results from the yield.
7148		7281
7149		7282
@@ -7280,7 +7413,7 @@ final value of <code>package.loaded[modname]</code>. · 130 unmodified lines
7280	<p>	7413	<p>
7281	If there is any error loading or running the module,	7414	If there is any error loading or running the module,
7282	or if it cannot find any loader for the module,	7415	or if it cannot find any loader for the module,
7283	then <code>require</code> signals an error.	7416	then <code>require</code> raises an error.
7284		7417
7285		7418
7286		7419
@@ -7309,8 +7442,8 @@ Default is '<code>?</code>'.</li> · 22 unmodified lines
7309	is replaced by the executable's directory.	7442	is replaced by the executable's directory.
7310	Default is '<code>!</code>'.</li>	7443	Default is '<code>!</code>'.</li>
7311		7444
7312	<li>The fifth line is a mark to ignore all before it when building the	7445	<li>The fifth line is a mark to ignore all text before it
7313	<code>luaopen_</code> function name.	7446	when building the <code>luaopen_</code> function name.
7314	Default is '<code>-</code>'.</li>	7447	Default is '<code>-</code>'.</li>
7315		7448
7316	</ul>	7449	</ul>
@@ -7372,7 +7505,7 @@ available to other dynamically linked libraries. · 55 unmodified lines
7372	Otherwise,	7505	Otherwise,
7373	it looks for a function <code>funcname</code> inside the library	7506	it looks for a function <code>funcname</code> inside the library
7374	and returns this function as a C function.	7507	and returns this function as a C function.
7375	(So, <code>funcname</code> must follow the protocol (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>)).	7508	(So, <code>funcname</code> must follow the prototype <a href="#lua_CFunction"><code>lua_CFunction</code></a>).
7376		7509
7377		7510
7378	<p>	7511	<p>
@@ -7409,7 +7542,7 @@ At start-up, Lua initializes this variable with · 30 unmodified lines
7409	the value of the environment variable <a name="pdf-LUA_PATH_5_2"><code>LUA_PATH_5_2</code></a> or	7542	the value of the environment variable <a name="pdf-LUA_PATH_5_2"><code>LUA_PATH_5_2</code></a> or
7410	the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or	7543	the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
7411	with a default path defined in <code>luaconf.h</code>,	7544	with a default path defined in <code>luaconf.h</code>,
7412	if the environment variable is not defined.	7545	if those environment variables are not defined.
7413	Any "<code>;;</code>" in the value of the environment variable	7546	Any "<code>;;</code>" in the value of the environment variable
7414	is replaced by the default path.	7547	is replaced by the default path.
7415		7548
@@ -7511,7 +7644,7 @@ with each submodule keeping its original open function. · 95 unmodified lines
7511		7644
7512		7645
7513	<p>	7646	<p>
7514	All searchers except the first (preload) return as the extra value	7647	All searchers except the first one (preload) return as the extra value
7515	the file name where the module was found,	7648	the file name where the module was found,
7516	as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.	7649	as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
7517	The first searcher returns no extra value.	7650	The first searcher returns no extra value.
@@ -7520,7 +7653,7 @@ The first searcher returns no extra value. · 2 unmodified lines
7520		7653
7521		7654
7522	<p>	7655	<p>
7523	<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep])</code></a></h3>	7656	<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep [, rep]])</code></a></h3>
7524		7657
7525		7658
7526	<p>	7659	<p>
@@ -7528,17 +7661,16 @@ Searches for the given <code>name</code> in the given <code>path</code>. · 1 unmodified line
7528		7661
7529		7662
7530	<p>	7663	<p>
7531	A path is string containing a sequence of	7664	A path is a string containing a sequence of
7532	<em>templates</em> separated by semicolons.	7665	<em>templates</em> separated by semicolons.
7533	For each template,	7666	For each template,
7534	the function changes each interrogation	7667	the function replaces each interrogation mark (if any)
7535	mark in the template by a copy of <code>name</code>	7668	in the template with a copy of <code>name</code>
7536	wherein all occurrences of <code>sep</code>	7669	wherein all occurrences of <code>sep</code>
7537	(a dot, by default)	7670	(a dot, by default)
7538	were replaced by the system's directory separator,	7671	were replaced by <code>rep</code>
		7672	(the system's directory separator, by default),
7539	and then tries to open the resulting file name.	7673	and then tries to open the resulting file name.
7540	If <code>sep</code> is the empty string,
7541	the replacement is not done.
7542		7674
7543		7675
7544	<p>	7676	<p>
@@ -7583,7 +7715,7 @@ The string library provides all its functions inside the table · 38 unmodified lines
7583	It also sets a metatable for strings	7715	It also sets a metatable for strings
7584	where the <code>__index</code> field points to the <code>string</code> table.	7716	where the <code>__index</code> field points to the <code>string</code> table.
7585	Therefore, you can use the string functions in object-oriented style.	7717	Therefore, you can use the string functions in object-oriented style.
7586	For instance, <code>string.byte(s, i)</code>	7718	For instance, <code>string.byte(s,i)</code>
7587	can be written as <code>s:byte(i)</code>.	7719	can be written as <code>s:byte(i)</code>.
7588		7720
7589		7721
@@ -7594,13 +7726,15 @@ The string library assumes one-byte character encodings. · 4 unmodified lines
7594	<p>	7726	<p>
7595	<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>	7727	<hr><h3><a name="pdf-string.byte"><code>string.byte (s [, i [, j]])</code></a></h3>
7596	Returns the internal numerical codes of the characters <code>s[i]</code>,	7728	Returns the internal numerical codes of the characters <code>s[i]</code>,
7597	<code>s[i+1]</code>, ···, <code>s[j]</code>.	7729	<code>s[i+1]</code>, ..., <code>s[j]</code>.
7598	The default value for <code>i</code> is 1;	7730	The default value for <code>i</code> is 1;
7599	the default value for <code>j</code> is <code>i</code>.	7731	the default value for <code>j</code> is <code>i</code>.
		7732	These indices are corrected
		7733	following the same rules of function <a href="#pdf-string.sub"><code>string.sub</code></a>.
7600		7734
7601		7735
7602	<p>	7736	<p>
7603	Note that numerical codes are not necessarily portable across platforms.	7737	Numerical codes are not necessarily portable across platforms.
7604		7738
7605		7739
7606		7740
@@ -7614,7 +7748,7 @@ to its corresponding argument. · 7 unmodified lines
7614		7748
7615		7749
7616	<p>	7750	<p>
7617	Note that numerical codes are not necessarily portable across platforms.	7751	Numerical codes are not necessarily portable across platforms.
7618		7752
7619		7753
7620		7754
@@ -7709,7 +7843,7 @@ it is converted to one following the same rules of <a href="#pdf-tostring"><code · 88 unmodified lines
7709	<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>	7843	<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>
7710	Returns an iterator function that,	7844	Returns an iterator function that,
7711	each time it is called,	7845	each time it is called,
7712	returns the next captures from <code>pattern</code> over string <code>s</code>.	7846	returns the next captures from <code>pattern</code> over the string <code>s</code>.
7713	If <code>pattern</code> specifies no captures,	7847	If <code>pattern</code> specifies no captures,
7714	then the whole match is produced in each call.	7848	then the whole match is produced in each call.
7715		7849
@@ -7737,7 +7871,7 @@ given string into a table: · 21 unmodified lines
7737	</pre>	7871	</pre>
7738		7872
7739	<p>	7873	<p>
7740	For this function, a '<code>^</code>' at the start of a pattern does not	7874	For this function, a caret '<code>^</code>' at the start of a pattern does not
7741	work as an anchor, as this would prevent the iteration.	7875	work as an anchor, as this would prevent the iteration.
7742		7876
7743		7877
@@ -7884,6 +8018,17 @@ and <code>string.sub(s, -i)</code> returns a suffix of <code>s</code> · 140 unmodified lines
7884	with length <code>i</code>.	8018	with length <code>i</code>.
7885		8019
7886		8020
		8021	<p>
		8022	If, after the translation of negative indices,
		8023	<code>i</code> is less than zero,
		8024	it is corrected to zero.
		8025	If <code>j</code> is greater than the string length,
		8026	it is corrected to that length.
		8027	If, after these corrections,
		8028	<code>i</code> is greater than <code>j</code>,
		8029	the function returns the empty string.
		8030
		8031
7887		8032
7888		8033
7889	<p>	8034	<p>
@@ -8050,7 +8195,7 @@ they were the character '<code>\0</code>'. · 160 unmodified lines
8050		8195
8051	<h4>Pattern:</h4><p>	8196	<h4>Pattern:</h4><p>
8052	A <em>pattern</em> is a sequence of pattern items.	8197	A <em>pattern</em> is a sequence of pattern items.
8053	A '<code>^</code>' at the beginning of a pattern anchors the match at the	8198	A caret '<code>^</code>' at the beginning of a pattern anchors the match at the
8054	beginning of the subject string.	8199	beginning of the subject string.
8055	A '<code>$</code>' at the end of a pattern anchors the match at the	8200	A '<code>$</code>' at the end of a pattern anchors the match at the
8056	end of the subject string.	8201	end of the subject string.
@@ -8589,7 +8734,7 @@ result in zero or <code>0xFFFFFFFF</code> (all original bits are shifted out). · 532 unmodified lines
8589		8734
8590		8735
8591	<p>	8736	<p>
8592	Returns the bitwise and of its operands.	8737	Returns the bitwise <em>and</em> of its operands.
8593		8738
8594		8739
8595		8740
@@ -8614,7 +8759,7 @@ the following identity holds: · 18 unmodified lines
8614		8759
8615		8760
8616	<p>	8761	<p>
8617	Returns the bitwise or of its operands.	8762	Returns the bitwise <em>or</em> of its operands.
8618		8763
8619		8764
8620		8765
@@ -8625,7 +8770,7 @@ Returns the bitwise or of its operands. · 4 unmodified lines
8625		8770
8626	<p>	8771	<p>
8627	Returns a boolean signaling	8772	Returns a boolean signaling
8628	whether the bitwise and of its operands is different from zero.	8773	whether the bitwise <em>and</em> of its operands is different from zero.
8629		8774
8630		8775
8631		8776
@@ -8635,7 +8780,7 @@ whether the bitwise and of its operands is different from zero. · 3 unmodified lines
8635		8780
8636		8781
8637	<p>	8782	<p>
8638	Returns the bitwise exclusive or of its operands.	8783	Returns the bitwise <em>exclusive or</em> of its operands.
8639		8784
8640		8785
8641		8786
@@ -8845,7 +8990,7 @@ instead of returning an error code. · 203 unmodified lines
8845		8990
8846		8991
8847	<p>	8992	<p>
8848	<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename] ···)</code></a></h3>	8993	<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename ···])</code></a></h3>
8849		8994
8850		8995
8851	<p>	8996	<p>
@@ -8863,6 +9008,11 @@ that is, it iterates over the lines of the default input file. · 11 unmodified lines
8863	In this case it does not close the file when the loop ends.	9008	In this case it does not close the file when the loop ends.
8864		9009
8865		9010
		9011	<p>
		9012	In case of errors this function raises the error,
		9013	instead of returning an error code.
		9014
		9015
8866		9016
8867		9017
8868	<p>	9018	<p>
@@ -9007,15 +9157,20 @@ each time it is called, · 138 unmodified lines
9007	reads the file according to the given formats.	9157	reads the file according to the given formats.
9008	When no format is given,	9158	When no format is given,
9009	uses "*l" as a default.	9159	uses "*l" as a default.
9010	Therefore, the construction	9160	As an example, the construction
9011		9161
9012	<pre>	9162	<pre>
9013	for c in file:lines(1) do <em>body</em> end	9163	for c in file:lines(1) do <em>body</em> end
9014	</pre><p>	9164	</pre><p>
9015	will iterate over all characters of the file,	9165	will iterate over all characters of the file,
9016	starting at the current position.	9166	starting at the current position.
9017	(Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file	9167	Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
9018	when the loop ends.)	9168	when the loop ends.
		9169
		9170
		9171	<p>
		9172	In case of errors this function raises the error,
		9173	instead of returning an error code.
9019		9174
9020		9175
9021		9176
@@ -9062,7 +9217,7 @@ returning <b>nil</b> on end of file. · 40 unmodified lines
9062	</li>	9217	</li>
9063		9218
9064	<li><b><em>number</em>: </b>	9219	<li><b><em>number</em>: </b>
9065	reads a string with up to this number of characters,	9220	reads a string with up to this number of bytes,
9066	returning <b>nil</b> on end of file.	9221	returning <b>nil</b> on end of file.
9067	If number is zero,	9222	If number is zero,
9068	it reads nothing and returns an empty string,	9223	it reads nothing and returns an empty string,
@@ -9088,9 +9243,9 @@ specified by the string <code>whence</code>, as follows: · 19 unmodified lines
9088	<li><b>"<code>cur</code>": </b> base is current position;</li>	9243	<li><b>"<code>cur</code>": </b> base is current position;</li>
9089	<li><b>"<code>end</code>": </b> base is end of file;</li>	9244	<li><b>"<code>end</code>": </b> base is end of file;</li>
9090	</ul><p>	9245	</ul><p>
9091	In case of success, function <code>seek</code> returns the final file position,	9246	In case of success, <code>seek</code> returns the final file position,
9092	measured in bytes from the beginning of the file.	9247	measured in bytes from the beginning of the file.
9093	If this function fails, it returns <b>nil</b>,	9248	If <code>seek</code> fails, it returns <b>nil</b>,
9094	plus a string describing the error.	9249	plus a string describing the error.
9095		9250
9096		9251
@@ -9123,8 +9278,8 @@ no buffering; the result of any output operation appears immediately. · 26 unmodified lines
9123		9278
9124	<li><b>"<code>full</code>": </b>	9279	<li><b>"<code>full</code>": </b>
9125	full buffering; output operation is performed only	9280	full buffering; output operation is performed only
9126	when the buffer is full (or when you explicitly <code>flush</code> the file	9281	when the buffer is full or when
9127	(see <a href="#pdf-io.flush"><code>io.flush</code></a>)).	9282	you explicitly <code>flush</code> the file (see <a href="#pdf-io.flush"><code>io.flush</code></a>).
9128	</li>	9283	</li>
9129		9284
9130	<li><b>"<code>line</code>": </b>	9285	<li><b>"<code>line</code>": </b>
@@ -9146,11 +9301,8 @@ The default is an appropriate size. · 15 unmodified lines
9146		9301
9147		9302
9148	<p>	9303	<p>
9149	Writes the value of each of its arguments to	9304	Writes the value of each of its arguments to <code>file</code>.
9150	the <code>file</code>.
9151	The arguments must be strings or numbers.	9305	The arguments must be strings or numbers.
9152	To write other values,
9153	use <a href="#pdf-tostring"><code>tostring</code></a> or <a href="#pdf-string.format"><code>string.format</code></a> before <code>write</code>.
9154		9306
9155		9307
9156	<p>	9308	<p>
@@ -9202,8 +9354,8 @@ then the date is formatted in Coordinated Universal Time. · 45 unmodified lines
9202	After this optional character,	9354	After this optional character,
9203	if <code>format</code> is the string "<code>*t</code>",	9355	if <code>format</code> is the string "<code>*t</code>",
9204	then <code>date</code> returns a table with the following fields:	9356	then <code>date</code> returns a table with the following fields:
9205	<code>year</code> (four digits), <code>month</code> (1--12), <code>day</code> (1--31),	9357	<code>year</code> (four digits), <code>month</code> (1–12), <code>day</code> (1–31),
9206	<code>hour</code> (0--23), <code>min</code> (0--59), <code>sec</code> (0--61),	9358	<code>hour</code> (0–23), <code>min</code> (0–59), <code>sec</code> (0–61),
9207	<code>wday</code> (weekday, Sunday is 1),	9359	<code>wday</code> (weekday, Sunday is 1),
9208	<code>yday</code> (day of the year),	9360	<code>yday</code> (day of the year),
9209	and <code>isdst</code> (daylight saving flag, a boolean).	9361	and <code>isdst</code> (daylight saving flag, a boolean).
@@ -9314,7 +9466,7 @@ or <b>nil</b> if the variable is not defined. · 104 unmodified lines
9314	Deletes the file (or empty directory, on POSIX systems)	9466	Deletes the file (or empty directory, on POSIX systems)
9315	with the given name.	9467	with the given name.
9316	If this function fails, it returns <b>nil</b>,	9468	If this function fails, it returns <b>nil</b>,
9317	plus a string describing the error.	9469	plus a string describing the error and the error code.
9318		9470
9319		9471
9320		9472
@@ -9326,7 +9478,7 @@ plus a string describing the error. · 5 unmodified lines
9326	<p>	9478	<p>
9327	Renames file or directory named <code>oldname</code> to <code>newname</code>.	9479	Renames file or directory named <code>oldname</code> to <code>newname</code>.
9328	If this function fails, it returns <b>nil</b>,	9480	If this function fails, it returns <b>nil</b>,
9329	plus a string describing the error.	9481	plus a string describing the error and the error code.
9330		9482
9331		9483
9332		9484
@@ -9337,7 +9489,7 @@ plus a string describing the error. · 4 unmodified lines
9337		9489
9338	<p>	9490	<p>
9339	Sets the current locale of the program.	9491	Sets the current locale of the program.
9340	<code>locale</code> is a string specifying a locale;	9492	<code>locale</code> is a system-dependent string specifying a locale;
9341	<code>category</code> is an optional string describing which category to change:	9493	<code>category</code> is an optional string describing which category to change:
9342	<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,	9494	<code>"all"</code>, <code>"collate"</code>, <code>"ctype"</code>,
9343	<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;	9495	<code>"monetary"</code>, <code>"numeric"</code>, or <code>"time"</code>;
@@ -9369,8 +9521,12 @@ for the given category. · 25 unmodified lines
9369	Returns the current time when called without arguments,	9521	Returns the current time when called without arguments,
9370	or a time representing the date and time specified by the given table.	9522	or a time representing the date and time specified by the given table.
9371	This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,	9523	This table must have fields <code>year</code>, <code>month</code>, and <code>day</code>,
9372	and may have fields <code>hour</code>, <code>min</code>, <code>sec</code>, and <code>isdst</code>	9524	and may have fields
9373	(for a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function).	9525	<code>hour</code> (default is 12),
		9526	<code>min</code> (default is 0),
		9527	<code>sec</code> (default is 0),
		9528	and <code>isdst</code> (default is <b>nil</b>).
		9529	For a description of these fields, see the <a href="#pdf-os.date"><code>os.date</code></a> function.
9374		9530
9375		9531
9376	<p>	9532	<p>
@@ -9380,7 +9536,7 @@ this number counts the number · 3 unmodified lines
9380	of seconds since some given start time (the "epoch").	9536	of seconds since some given start time (the "epoch").
9381	In other systems, the meaning is not specified,	9537	In other systems, the meaning is not specified,
9382	and the number returned by <code>time</code> can be used only as an argument to	9538	and the number returned by <code>time</code> can be used only as an argument to
9383	<code>date</code> and <code>difftime</code>.	9539	<a href="#pdf-os.date"><code>os.date</code></a> and <a href="#pdf-os.difftime"><code>os.difftime</code></a>.
9384		9540
9385		9541
9386		9542
@@ -9421,9 +9577,9 @@ which automatically removes the file when the program ends. · 34 unmodified lines
9421		9577
9422	<p>	9578	<p>
9423	This library provides	9579	This library provides
9424	the functionality of the debug interface to Lua programs.	9580	the functionality of the debug interface (<a href="#4.9">§4.9</a>) to Lua programs.
9425	You should exert care when using this library.	9581	You should exert care when using this library.
9426	Several of these functions	9582	Several of its functions
9427	violate basic assumptions about Lua code	9583	violate basic assumptions about Lua code
9428	(e.g., that variables local to a function	9584	(e.g., that variables local to a function
9429	cannot be accessed from outside;	9585	cannot be accessed from outside;
@@ -9458,7 +9614,7 @@ so that the caller continues its execution. · 28 unmodified lines
9458		9614
9459	<p>	9615	<p>
9460	Note that commands for <code>debug.debug</code> are not lexically nested	9616	Note that commands for <code>debug.debug</code> are not lexically nested
9461	within any function, and so have no direct access to local variables.	9617	within any function and so have no direct access to local variables.
9462		9618
9463		9619
9464		9620
@@ -9477,20 +9633,20 @@ and the current hook count · 12 unmodified lines
9477		9633
9478		9634
9479	<p>	9635	<p>
9480	<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] function [, what])</code></a></h3>	9636	<hr><h3><a name="pdf-debug.getinfo"><code>debug.getinfo ([thread,] f [, what])</code></a></h3>
9481		9637
9482		9638
9483	<p>	9639	<p>
9484	Returns a table with information about a function.	9640	Returns a table with information about a function.
9485	You can give the function directly,	9641	You can give the function directly
9486	or you can give a number as the value of <code>function</code>,	9642	or you can give a number as the value of <code>f</code>,
9487	which means the function running at level <code>function</code> of the call stack	9643	which means the function running at level <code>f</code> of the call stack
9488	of the given thread:	9644	of the given thread:
9489	level 0 is the current function (<code>getinfo</code> itself);	9645	level 0 is the current function (<code>getinfo</code> itself);
9490	level 1 is the function that called <code>getinfo</code>	9646	level 1 is the function that called <code>getinfo</code>
9491	(except for tail calls, which do not count on the stack);	9647	(except for tail calls, which do not count on the stack);
9492	and so on.	9648	and so on.
9493	If <code>function</code> is a number larger than the number of active functions,	9649	If <code>f</code> is a number larger than the number of active functions,
9494	then <code>getinfo</code> returns <b>nil</b>.	9650	then <code>getinfo</code> returns <b>nil</b>.
9495		9651
9496		9652
@@ -9554,11 +9710,11 @@ In that case, <code>getlocal</code> returns only the name of function parameters · 57 unmodified lines
9554		9710
9555		9711
9556	<p>	9712	<p>
9557	<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (object)</code></a></h3>	9713	<hr><h3><a name="pdf-debug.getmetatable"><code>debug.getmetatable (value)</code></a></h3>
9558		9714
9559		9715
9560	<p>	9716	<p>
9561	Returns the metatable of the given <code>object</code>	9717	Returns the metatable of the given <code>value</code>
9562	or <b>nil</b> if it does not have a metatable.	9718	or <b>nil</b> if it does not have a metatable.
9563		9719
9564		9720
@@ -9575,12 +9731,12 @@ Returns the registry table (see <a href="#4.5">§4.5</a>). · 10 unmodified lines
9575		9731
9576		9732
9577	<p>	9733	<p>
9578	<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (func, up)</code></a></h3>	9734	<hr><h3><a name="pdf-debug.getupvalue"><code>debug.getupvalue (f, up)</code></a></h3>
9579		9735
9580		9736
9581	<p>	9737	<p>
9582	This function returns the name and the value of the upvalue	9738	This function returns the name and the value of the upvalue
9583	with index <code>up</code> of the function <code>func</code>.	9739	with index <code>up</code> of the function <code>f</code>.
9584	The function returns <b>nil</b> if there is no upvalue with the given index.	9740	The function returns <b>nil</b> if there is no upvalue with the given index.
9585		9741
9586		9742
@@ -9662,24 +9818,24 @@ variable indices and names. · 75 unmodified lines
9662		9818
9663		9819
9664	<p>	9820	<p>
9665	<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (object, table)</code></a></h3>	9821	<hr><h3><a name="pdf-debug.setmetatable"><code>debug.setmetatable (value, table)</code></a></h3>
9666		9822
9667		9823
9668	<p>	9824	<p>
9669	Sets the metatable for the given <code>object</code> to the given <code>table</code>	9825	Sets the metatable for the given <code>value</code> to the given <code>table</code>
9670	(which can be <b>nil</b>).	9826	(which can be <b>nil</b>).
9671	Returns <code>object</code>.	9827	Returns <code>value</code>.
9672		9828
9673		9829
9674		9830
9675		9831
9676	<p>	9832	<p>
9677	<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (func, up, value)</code></a></h3>	9833	<hr><h3><a name="pdf-debug.setupvalue"><code>debug.setupvalue (f, up, value)</code></a></h3>
9678		9834
9679		9835
9680	<p>	9836	<p>
9681	This function assigns the value <code>value</code> to the upvalue	9837	This function assigns the value <code>value</code> to the upvalue
9682	with index <code>up</code> of the function <code>func</code>.	9838	with index <code>up</code> of the function <code>f</code>.
9683	The function returns <b>nil</b> if there is no upvalue	9839	The function returns <b>nil</b> if there is no upvalue
9684	with the given index.	9840	with the given index.
9685	Otherwise, it returns the name of the upvalue.	9841	Otherwise, it returns the name of the upvalue.
@@ -9723,7 +9879,7 @@ to start the traceback · 37 unmodified lines
9723		9879
9724		9880
9725	<p>	9881	<p>
9726	<hr><h3><a name="pdf-debug.upvalueid"><code>debug.upvalueid (function, n)</code></a></h3>	9882	<hr><h3><a name="pdf-debug.upvalueid"><code>debug.upvalueid (f, n)</code></a></h3>
9727		9883
9728		9884
9729	<p>	9885	<p>
@@ -9743,12 +9899,12 @@ will return identical ids for those upvalue indices. · 13 unmodified lines
9743		9899
9744		9900
9745	<p>	9901	<p>
9746	<hr><h3><a name="pdf-debug.upvaluejoin"><code>debug.upvaluejoin (func1, n1, func2, n2)</code></a></h3>	9902	<hr><h3><a name="pdf-debug.upvaluejoin"><code>debug.upvaluejoin (f1, n1, f2, n2)</code></a></h3>
9747		9903
9748		9904
9749	<p>	9905	<p>
9750	Make the <code>n1</code>-th upvalue of the Lua closure <code>func1</code>	9906	Make the <code>n1</code>-th upvalue of the Lua closure <code>f1</code>
9751	refer to the <code>n2</code>-th upvalue of the Lua closure <code>func2</code>.	9907	refer to the <code>n2</code>-th upvalue of the Lua closure <code>f2</code>.
9752		9908
9753		9909
9754		9910
@@ -9779,6 +9935,7 @@ The options are: · 24 unmodified lines
9779	<li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em>;</li>	9935	<li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em>;</li>
9780	<li><b><code>-i</code>: </b> enters interactive mode after running <em>script</em>;</li>	9936	<li><b><code>-i</code>: </b> enters interactive mode after running <em>script</em>;</li>
9781	<li><b><code>-v</code>: </b> prints version information;</li>	9937	<li><b><code>-v</code>: </b> prints version information;</li>
		9938	<li><b><code>-E</code>: </b> ignores environment variables;</li>
9782	<li><b><code>--</code>: </b> stops handling options;</li>	9939	<li><b><code>--</code>: </b> stops handling options;</li>
9783	<li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li>	9940	<li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li>
9784	</ul><p>	9941	</ul><p>
@@ -9791,24 +9948,34 @@ and as <code>lua -</code> otherwise. · 6 unmodified lines
9791		9948
9792		9949
9793	<p>	9950	<p>
9794	Before running any argument,	9951	When called without option <code>-E</code>,
9795	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_2"><code>LUA_INIT_5_2</code></a>	9952	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_2"><code>LUA_INIT_5_2</code></a>
9796	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if it is not defined).	9953	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if it is not defined)
9797	If its format is <code>@<em>filename</em></code>,	9954	before running any argument.
		9955	If the variable content has the format <code>@<em>filename</em></code>,
9798	then <code>lua</code> executes the file.	9956	then <code>lua</code> executes the file.
9799	Otherwise, <code>lua</code> executes the string itself.	9957	Otherwise, <code>lua</code> executes the string itself.
9800		9958
9801		9959
9802	<p>	9960	<p>
9803	All options are handled in order, except <code>-i</code>.	9961	When called with option <code>-E</code>,
		9962	besides ignoring <code>LUA_INIT</code>,
		9963	the interpreter also resets the values of
		9964	<a href="#pdf-package.path"><code>package.path</code></a> and <a href="#pdf-package.cpath"><code>package.cpath</code></a>
		9965	with the default paths defined in <code>luaconf.h</code>,
		9966	in effect ignoring the values of <code>LUA_PATH</code> and <code>LUA_CPATH</code>.
		9967
		9968
		9969	<p>
		9970	All options are handled in order, except <code>-i</code> and <code>-E</code>.
9804	For instance, an invocation like	9971	For instance, an invocation like
9805		9972
9806	<pre>	9973	<pre>
9807	$ lua -e'a=1' -e 'print(a)' script.lua	9974	$ lua -e'a=1' -e 'print(a)' script.lua
9808	</pre><p>	9975	</pre><p>
9809	will first set <code>a</code> to 1, then print the value of <code>a</code> (which is '<code>1</code>'),	9976	will first set <code>a</code> to 1, then print the value of <code>a</code>,
9810	and finally run the file <code>script.lua</code> with no arguments.	9977	and finally run the file <code>script.lua</code> with no arguments.
9811	(Here <code>$</code> is the shell prompt. Your prompt can be different.)	9978	(Here <code>$</code> is the shell prompt. Your prompt may be different.)
9812		9979
9813		9980
9814	<p>	9981	<p>
@@ -9835,7 +10002,7 @@ then creates a table · 20 unmodified lines
9835	[1] = "t1", [2] = "t2" }	10002	[1] = "t1", [2] = "t2" }
9836	</pre><p>	10003	</pre><p>
9837	and finally runs the file <code>b.lua</code>.	10004	and finally runs the file <code>b.lua</code>.
9838	The script is called with <code>arg[1]</code>, <code>arg[2]</code>, ···	10005	The script is called with <code>arg[1]</code>, <code>arg[2]</code>, ...
9839	as arguments;	10006	as arguments;
9840	it can also access these arguments with the vararg expression '<code>...</code>'.	10007	it can also access these arguments with the vararg expression '<code>...</code>'.
9841		10008
@@ -9862,29 +10029,8 @@ the interpreter does not report the error. · 20 unmodified lines
9862	When finishing normally,	10029	When finishing normally,
9863	the interpreter closes its main Lua state	10030	the interpreter closes its main Lua state
9864	(see <a href="#lua_close"><code>lua_close</code></a>).	10031	(see <a href="#lua_close"><code>lua_close</code></a>).
9865	The script can avoid this step by terminating	10032	The script can avoid this step by
9866	through <a href="#pdf-os.exit"><code>os.exit</code></a>.	10033	calling <a href="#pdf-os.exit"><code>os.exit</code></a> to terminate.
9867
9868
9869	<p>
9870	If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,
9871	then its value is used as the prompt.
9872	Similarly, if the global variable <a name="pdf-_PROMPT2"><code>_PROMPT2</code></a> contains a string,
9873	its value is used as the secondary prompt
9874	(issued during incomplete statements).
9875	Therefore, both prompts can be changed directly on the command line
9876	or in any Lua programs by assigning to <code>_PROMPT</code>.
9877	See the next example:
9878
9879	<pre>
9880	$ lua -e"_PROMPT='myprompt> '" -i
9881	</pre><p>
9882	(The outer pair of quotes is for the shell,
9883	the inner pair is for Lua.)
9884	Note the use of <code>-i</code> to enter interactive mode;
9885	otherwise,
9886	the program would just end silently
9887	right after the assignment to <code>_PROMPT</code>.
9888		10034
9889		10035
9890	<p>	10036	<p>
@@ -9900,7 +10046,7 @@ as in · 9 unmodified lines
9900	#!/usr/local/bin/lua	10046	#!/usr/local/bin/lua
9901	</pre><p>	10047	</pre><p>
9902	(Of course,	10048	(Of course,
9903	the location of the Lua interpreter can be different in your machine.	10049	the location of the Lua interpreter may be different in your machine.
9904	If <code>lua</code> is in your <code>PATH</code>,	10050	If <code>lua</code> is in your <code>PATH</code>,
9905	then	10051	then
9906		10052
@@ -9914,9 +10060,9 @@ is a more portable solution.) · 7 unmodified lines
9914	<h1>8 – <a name="8">Incompatibilities with the Previous Version</a></h1>	10060	<h1>8 – <a name="8">Incompatibilities with the Previous Version</a></h1>
9915		10061
9916	<p>	10062	<p>
9917	Here we list the incompatibilities that you can find when moving a program	10063	Here we list the incompatibilities that you may find when moving a program
9918	from Lua 5.1 to Lua 5.2.	10064	from Lua 5.1 to Lua 5.2.
9919	You can avoid some incompatibilities compiling Lua with	10065	You can avoid some incompatibilities by compiling Lua with
9920	appropriate options (see file <code>luaconf.h</code>).	10066	appropriate options (see file <code>luaconf.h</code>).
9921	However,	10067	However,
9922	all these compatibility options will be removed in the next version of Lua.	10068	all these compatibility options will be removed in the next version of Lua.
@@ -9934,7 +10080,7 @@ use the variable <code>_ENV</code> or the function <a href="#pdf-load"><code>loa · 11 unmodified lines
9934		10080
9935		10081
9936	<p>	10082	<p>
9937	C functions do not have environments any more.	10083	C functions no longer have environments.
9938	Use an upvalue with a shared table if you need to keep	10084	Use an upvalue with a shared table if you need to keep
9939	shared state among several C functions.	10085	shared state among several C functions.
9940	(You may use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> to open a C library	10086	(You may use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> to open a C library
@@ -9964,8 +10110,8 @@ Weak tables with weak keys now perform like <em>ephemeron tables</em>. · 23 unmodified lines
9964	<li>	10110	<li>
9965	The event <em>tail return</em> in debug hooks was removed.	10111	The event <em>tail return</em> in debug hooks was removed.
9966	Instead, tail calls generate a special new event,	10112	Instead, tail calls generate a special new event,
9967	<em>tail call</em>, so that the debugger can know there will	10113	<em>tail call</em>, so that the debugger can know that
9968	not be a corresponding return event.	10114	there will not be a corresponding return event.
9969	</li>	10115	</li>
9970		10116
9971	<li>	10117	<li>
@@ -9985,8 +10131,8 @@ observable difference to the new function. · 13 unmodified lines
9985		10131
9986	<li>	10132	<li>
9987	Function <code>module</code> is deprecated.	10133	Function <code>module</code> is deprecated.
9988	Modules are not expected to set global variables anymore,	10134	It is easy to set up a module with regular Lua code.
9989	and it is easy to set up a module with regular Lua code.	10135	Modules are not expected to set global variables.
9990	</li>	10136	</li>
9991		10137
9992	<li>	10138	<li>
@@ -10036,12 +10182,17 @@ So, all functions that load code · 43 unmodified lines
10036	(<a href="#pdf-load"><code>load</code></a> and <a href="#pdf-loadfile"><code>loadfile</code></a>)	10182	(<a href="#pdf-load"><code>load</code></a> and <a href="#pdf-loadfile"><code>loadfile</code></a>)
10037	are potentially insecure when loading untrusted binary data.	10183	are potentially insecure when loading untrusted binary data.
10038	(Actually, those functions were already insecure because	10184	(Actually, those functions were already insecure because
10039	of bugs in the verification algorithm.)	10185	of flaws in the verification algorithm.)
10040	When in doubt,	10186	When in doubt,
10041	use the <code>mode</code> argument in function <a href="#pdf-load"><code>load</code></a>	10187	use the <code>mode</code> argument in function <a href="#pdf-load"><code>load</code></a>
10042	to restrict it to loading textual chunks.	10188	to restrict it to loading textual chunks.
10043	</li>	10189	</li>
10044		10190
		10191	<li>
		10192	The standard paths in the official distribution may
		10193	change between versions.
		10194	</li>
		10195
10045	</ul>	10196	</ul>
10046		10197
10047		10198
@@ -10060,13 +10211,12 @@ You must get the global environment from the registry · 12 unmodified lines
10060	Pseudoindex <code>LUA_ENVIRONINDEX</code>	10211	Pseudoindex <code>LUA_ENVIRONINDEX</code>
10061	and functions <code>lua_getfenv</code>/<code>lua_setfenv</code>	10212	and functions <code>lua_getfenv</code>/<code>lua_setfenv</code>
10062	were removed,	10213	were removed,
10063	as C functions do not have environments any more.	10214	as C functions no longer have environments.
10064	</li>	10215	</li>
10065		10216
10066	<li>	10217	<li>
10067	Function <code>luaL_register</code> is deprecated.	10218	Function <code>luaL_register</code> is deprecated.
10068	Use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> so that your module does not	10219	Use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> so that your module does not create globals.
10069	create globals anymore.
10070	(Modules are not expected to set global variables anymore.)	10220	(Modules are not expected to set global variables anymore.)
10071	</li>	10221	</li>
10072		10222
@@ -10081,7 +10231,7 @@ the block is new. · 8 unmodified lines
10081		10231
10082	<li>	10232	<li>
10083	Finalizers (<code>__gc</code> metamethods) for userdata are called in the	10233	Finalizers (<code>__gc</code> metamethods) for userdata are called in the
10084	reverse order that they were marked,	10234	reverse order that they were marked for finalization,
10085	not that they were created (see <a href="#2.5.1">§2.5.1</a>).	10235	not that they were created (see <a href="#2.5.1">§2.5.1</a>).
10086	(Most userdata are marked immediately after they are created.)	10236	(Most userdata are marked immediately after they are created.)
10087	Moreover,	10237	Moreover,
@@ -10202,10 +10352,10 @@ Here is the complete syntax of Lua in extended BNF. · 114 unmodified lines
10202	<HR>	10352	<HR>
10203	<SMALL CLASS="footer">	10353	<SMALL CLASS="footer">
10204	Last update:	10354	Last update:
10205	Fri Jul 8 17:11:02 BRT 2011	10355	Thu Nov 24 11:54:31 BRST 2011
10206	</SMALL>	10356	</SMALL>
10207	<!--	10357	<!--
10208	Last change: revised for Lua 5.2.0 (beta)	10358	Last change: revised for Lua 5.2.0
10209	-->	10359	-->
10210		10360
10211	</body></html>	10361	</body></html>

doc/readme.html+61−49

@@ -6,18 +6,21 @@ · 5 unmodified lines
6	<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">	6	<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
7	<STYLE TYPE="text/css">	7	<STYLE TYPE="text/css">
8	blockquote, .display {	8	blockquote, .display {
9	color: black ;
10	padding: 8px ;
11	border: solid #a0a0a0 2px ;	9	border: solid #a0a0a0 2px ;
12	xbackground-color: #EFEFFF ;	10	padding: 1em ;
13	margin-left: 0px ;	11	margin: 0px ;
		12	}
		13
		14	.display {
		15	word-spacing: 0.25em ;
		16	}
		17
		18	dl.display dd {
		19	padding-bottom: 0.2em ;
14	}	20	}
15		21
16	tt, kbd, code {	22	tt, kbd, code {
17	font-size: 120% ;	23	font-size: 12pt ;
18	xcolor: black ;
19	xpadding: 4px ;
20	xbackground-color: #E0E0E0 ;
21	}	24	}
22	</STYLE>	25	</STYLE>
23	</HEAD>	26	</HEAD>
@@ -27,14 +30,9 @@ tt, kbd, code { · 3 unmodified lines
27	<HR>	30	<HR>
28	<H1>	31	<H1>
29	<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>	32	<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
30	Welcome to Lua 5.2 (beta)	33	Welcome to Lua 5.2
31	</H1>	34	</H1>
32		35
33	<P>
34	<IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
35	<EM>This is a beta version of Lua 5.2.
36	Some details may change in the final version.</EM>
37
38	<P>	36	<P>
39	<A HREF="#about">about</A>	37	<A HREF="#about">about</A>
40	·	38	·
@@ -86,7 +84,7 @@ form. · 45 unmodified lines
86	You need to build it before using it.	84	You need to build it before using it.
87	Building Lua should be straightforward	85	Building Lua should be straightforward
88	because	86	because
89	Lua is implemented in pure ANSI C, and compiles unmodified in all known	87	Lua is implemented in pure ANSI C and compiles unmodified in all known
90	platforms that have an ANSI C compiler.	88	platforms that have an ANSI C compiler.
91	Lua also compiles unmodified as C++.	89	Lua also compiles unmodified as C++.
92	The instructions given below for building Lua are for Unix-like platforms.	90	The instructions given below for building Lua are for Unix-like platforms.
@@ -120,15 +118,16 @@ Here are the details. · 27 unmodified lines
120	<OL>	118	<OL>
121	<LI>	119	<LI>
122	Open a terminal window and move to	120	Open a terminal window and move to
123	the top-level directory, which is named lua-5.2.0.	121	the top-level directory, which is named <TT>lua-5.2.0</TT>.
124	The Makefile there controls both the build process and the installation process.	122	The Makefile there controls both the build process and the installation process.
125	<P>	123	<P>
126	<LI>	124	<LI>
127	Do "<KBD>make</KBD>" and see if your platform is listed.	125	Do "<KBD>make</KBD>" and see if your platform is listed.
128	The platforms currently supported are:	126	The platforms currently supported are:
129	<BLOCKQUOTE>	127	<P>
130	aix ansi bsd freebsd generic linux macosx mingw posix solaris	128	<P CLASS="display">
131	</BLOCKQUOTE>	129	aix ansi bsd freebsd generic linux macosx mingw posix solaris
		130	</P>
132	<P>	131	<P>
133	If your platform is listed, just do "<KBD>make xxx</KBD>", where xxx	132	If your platform is listed, just do "<KBD>make xxx</KBD>", where xxx
134	is your platform name.	133	is your platform name.
@@ -138,7 +137,7 @@ The Makefile there controls both the build process and the installation process. · 3 unmodified lines
138	<P>	137	<P>
139	<LI>	138	<LI>
140	The compilation takes only a few moments	139	The compilation takes only a few moments
141	and produces three files in the src directory:	140	and produces three files in the <TT>src</TT> directory:
142	lua (the interpreter),	141	lua (the interpreter),
143	luac (the compiler),	142	luac (the compiler),
144	and liblua.a (the library).	143	and liblua.a (the library).
@@ -147,12 +146,15 @@ and liblua.a (the library). · 2 unmodified lines
147	To check that Lua has been built correctly, do "<KBD>make test</KBD>"	146	To check that Lua has been built correctly, do "<KBD>make test</KBD>"
148	after building Lua. This will run the interpreter and print its version string.	147	after building Lua. This will run the interpreter and print its version string.
149	</OL>	148	</OL>
		149	<P>
		150	If you're running Linux and get compilation errors,
		151	make sure you have installed the <TT>readline</TT> development package.
150		152
151	<H3>Installing Lua</H3>	153	<H3>Installing Lua</H3>
152	<P>	154	<P>
153	Once you have built Lua, you may want to install it in an official	155	Once you have built Lua, you may want to install it in an official
154	place in your system. In this case, do "<KBD>make install</KBD>". The official	156	place in your system. In this case, do "<KBD>make install</KBD>". The official
155	place and the way to install files are defined in Makefile. You'll	157	place and the way to install files are defined in the Makefile. You'll
156	probably need the right permissions to install files.	158	probably need the right permissions to install files.
157		159
158	<P>	160	<P>
@@ -198,9 +200,9 @@ and liblua.a (the library). · 39 unmodified lines
198	<P>	200	<P>
199	Three kinds of things can be customized by editing a file:	201	Three kinds of things can be customized by editing a file:
200	<UL>	202	<UL>
201	<LI> Where and how to install Lua — edit Makefile.	203	<LI> Where and how to install Lua — edit <TT>Makefile</TT>.
202	<LI> How to build Lua — edit src/Makefile.	204	<LI> How to build Lua — edit <TT>src/Makefile</TT>.
203	<LI> Lua features — edit src/luaconf.h.	205	<LI> Lua features — edit <TT>src/luaconf.h</TT>.
204	</UL>	206	</UL>
205		207
206	<P>	208	<P>
@@ -211,13 +213,13 @@ and liblua.a (the library). · 4 unmodified lines
211		213
212	<P>	214	<P>
213	On the other hand, if you need to customize some Lua features, you'll need	215	On the other hand, if you need to customize some Lua features, you'll need
214	to edit src/luaconf.h before building and installing Lua.	216	to edit <TT>src/luaconf.h</TT> before building and installing Lua.
215	The edited file will be the one installed, and	217	The edited file will be the one installed, and
216	it will be used by any Lua clients that you build, to ensure consistency.	218	it will be used by any Lua clients that you build, to ensure consistency.
217	Further customization is available to experts by editing the Lua sources.	219	Further customization is available to experts by editing the Lua sources.
218		220
219	<P>	221	<P>
220	We strongly recommend that you enable dynamic loading in src/luaconf.h.	222	We strongly recommend that you enable dynamic loading in <TT>src/luaconf.h</TT>.
221	This is done automatically for all platforms listed above that have	223	This is done automatically for all platforms listed above that have
222	this feature and also for Windows.	224	this feature and also for Windows.
223		225
@@ -238,7 +240,6 @@ lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c ltable.c · 14 unmodified lines
238	ltm.c lundump.c lvm.c lzio.c	240	ltm.c lundump.c lvm.c lzio.c
239	lauxlib.c lbaselib.c lbitlib.c lcorolib.c ldblib.c liolib.c	241	lauxlib.c lbaselib.c lbitlib.c lcorolib.c ldblib.c liolib.c
240	lmathlib.c loslib.c lstrlib.c ltablib.c loadlib.c linit.c	242	lmathlib.c loslib.c lstrlib.c ltablib.c loadlib.c linit.c
241
242	<DT>	243	<DT>
243	interpreter:	244	interpreter:
244	<DD>	245	<DD>
@@ -257,11 +258,11 @@ compiler: · 12 unmodified lines
257	those dynamic libraries — but <EM>don't</EM> link the Lua library	258	those dynamic libraries — but <EM>don't</EM> link the Lua library
258	into each dynamic library. For Unix, we recommend that the Lua library	259	into each dynamic library. For Unix, we recommend that the Lua library
259	be linked statically into the host program and its symbols exported for	260	be linked statically into the host program and its symbols exported for
260	dynamic linking; src/Makefile does this for the Lua interpreter.	261	dynamic linking; <TT>src/Makefile</TT> does this for the Lua interpreter.
261	For Windows, we recommend that the Lua library be a DLL.	262	For Windows, we recommend that the Lua library be a DLL.
262		263
263	<P>	264	<P>
264	As mentioned above, you may edit src/luaconf.h to customize	265	As mentioned above, you may edit <TT>src/luaconf.h</TT> to customize
265	some features before building Lua.	266	some features before building Lua.
266		267
267	<H2><A NAME="changes">Changes since Lua 5.1</A></H2>	268	<H2><A NAME="changes">Changes since Lua 5.1</A></H2>
@@ -290,7 +291,7 @@ Here are the other changes introduced in Lua 5.2: · 22 unmodified lines
290	<UL>	291	<UL>
291	<LI> no more fenv for threads or functions	292	<LI> no more fenv for threads or functions
292	<LI> tables honor the <CODE>__len</CODE> metamethod	293	<LI> tables honor the <CODE>__len</CODE> metamethod
293	<LI> hex and <CODE>\*</CODE> escapes in strings	294	<LI> hex and <CODE>\z</CODE> escapes in strings
294	<LI> support for hexadecimal floats	295	<LI> support for hexadecimal floats
295	<LI> order metamethods work for different types	296	<LI> order metamethods work for different types
296	<LI> no more verification of opcode consistency	297	<LI> no more verification of opcode consistency
@@ -302,8 +303,8 @@ Here are the other changes introduced in Lua 5.2: · 5 unmodified lines
302	<H3>Libraries</H3>	303	<H3>Libraries</H3>
303	<UL>	304	<UL>
304	<LI> arguments for function called through <CODE>xpcall</CODE>	305	<LI> arguments for function called through <CODE>xpcall</CODE>
305	<LI> optional 'mode' argument to load (to control binary x text)	306	<LI> optional 'mode' argument to load and loadfile (to control binary x text)
306	<LI> optional 'env' argument to load (environment for loaded chunk)	307	<LI> optional 'env' argument to load and loadfile (environment for loaded chunk)
307	<LI> <CODE>loadlib</CODE> may load libraries with global names (RTLD_GLOBAL)	308	<LI> <CODE>loadlib</CODE> may load libraries with global names (RTLD_GLOBAL)
308	<LI> new function <CODE>package.searchpath</CODE>	309	<LI> new function <CODE>package.searchpath</CODE>
309	<LI> modules receive their paths when loaded	310	<LI> modules receive their paths when loaded
@@ -324,15 +325,23 @@ Here are the other changes introduced in Lua 5.2: · 14 unmodified lines
324	<H3>C API</H3>	325	<H3>C API</H3>
325	<UL>	326	<UL>
326	<LI> main thread predefined in the registry	327	<LI> main thread predefined in the registry
327	<LI> new constants <CODE>LUA_OK</CODE> and <CODE>LUA_ERRGCMM</CODE>	328	<LI> new functions
328	<LI> new <CODE>lua_compare</CODE>, <CODE>lua_arith</CODE>, and <CODE>lua_len</CODE>	329	<CODE>lua_absindex</CODE>,
329	<LI> new <CODE>lua_version</CODE> and <CODE>luaL_checkversion</CODE>	330	<CODE>lua_arith</CODE>,
		331	<CODE>lua_compare</CODE>,
		332	<CODE>lua_copy</CODE>,
		333	<CODE>lua_len</CODE>,
		334	<CODE>lua_rawgetp</CODE>,
		335	<CODE>lua_rawsetp</CODE>,
		336	<CODE>lua_upvalueid</CODE>,
		337	<CODE>lua_upvaluejoin</CODE>,
		338	<CODE>lua_version</CODE>.
		339	<LI> new functions
		340	<CODE>luaL_checkversion</CODE>,
		341	<CODE>luaL_setmetatable</CODE>,
		342	<CODE>luaL_testudata</CODE>,
		343	<CODE>luaL_tolstring</CODE>.
330	<LI> <CODE>lua_pushstring</CODE> and <CODE>pushlstring</CODE> return string	344	<LI> <CODE>lua_pushstring</CODE> and <CODE>pushlstring</CODE> return string
331	<LI> new <CODE>luaL_testudata</CODE> and <CODE>luaL_setmetatable</CODE>
332	<LI> new <CODE>luaL_tolstring</CODE>
333	<LI> new <CODE>lua_copy</CODE>
334	<LI> new <CODE>lua_absindex</CODE>
335	<LI> new <CODE>lua_upvalueid</CODE> and <CODE>lua_upvaluejoin</CODE>
336	<LI> <CODE>nparams</CODE> and <CODE>isvararg</CODE> available in debug API	345	<LI> <CODE>nparams</CODE> and <CODE>isvararg</CODE> available in debug API
337	<LI> new <CODE>lua_Unsigned</CODE>	346	<LI> new <CODE>lua_Unsigned</CODE>
338	</UL>	347	</UL>
@@ -340,15 +349,17 @@ Here are the other changes introduced in Lua 5.2: · 1 unmodified line
340	<H3>Implementation</H3>	349	<H3>Implementation</H3>
341	<UL>	350	<UL>
342	<LI> max constants per function raised to 2<SUP>26</SUP>	351	<LI> max constants per function raised to 2<SUP>26</SUP>
		352	<LI> generational mode for garbage collection (experimental)
		353	<LI> NaN trick (experimental)
343	<LI> internal (immutable) version of ctypes	354	<LI> internal (immutable) version of ctypes
344	<LI> simpler implementation for string buffers	355	<LI> simpler implementation for string buffers
345	<LI> udata with finalizers are kept in a separated list for the GC
346	<LI> <CODE>CallInfo</CODE> stack now is a linked list
347	<LI> parser uses much less C-stack space (no more auto arrays)	356	<LI> parser uses much less C-stack space (no more auto arrays)
348	<LI> new hash for floats	357	</UL>
349	<LI> handling of non-string error messages in the standalone interpreter	358
350	<LI> generational mode for garbage collection (experimental)	359	<H3>Lua standalone interpreter</H3>
351	<LI> NaN trick (experimental)	360	<UL>
		361	<LI> new <CODE>-E</CODE> option to avoid environment variables
		362	<LI> handling of non-string error messages
352	</UL>	363	</UL>
353		364
354	<H2><A NAME="license">License</A></H2>	365	<H2><A NAME="license">License</A></H2>
@@ -369,7 +380,7 @@ then you should give us credit by including the appropriate copyright notice som · 14 unmodified lines
369	For details, see	380	For details, see
370	<A HREF="http://www.lua.org/license.html">this</A>.	381	<A HREF="http://www.lua.org/license.html">this</A>.
371		382
372	<BLOCKQUOTE>	383	<BLOCKQUOTE STYLE="padding-bottom: 0em">
373	Copyright © 1994–2011 Lua.org, PUC-Rio.	384	Copyright © 1994–2011 Lua.org, PUC-Rio.
374		385
375	<P>	386	<P>
@@ -393,14 +404,15 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, · 17 unmodified lines
393	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN	404	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
394	THE SOFTWARE.	405	THE SOFTWARE.
395	</BLOCKQUOTE>	406	</BLOCKQUOTE>
		407	<P>
396		408
397	<HR>	409	<HR>
398	<SMALL CLASS="footer">	410	<SMALL CLASS="footer">
399	Last update:	411	Last update:
400	Fri Jun 24 11:30:57 BRT 2011	412	Wed Nov 23 16:17:22 BRST 2011
401	</SMALL>	413	</SMALL>
402	<!--	414	<!--
403	Last change: revised for Lua 5.2.0 (beta)	415	Last change: revised for Lua 5.2.0
404	-->	416	-->
405		417
406	</BODY>	418	</BODY>

src/Makefile+1−0

@@ -112,6 +112,7 @@ mingw: · 111 unmodified lines
112	$(MAKE) "LUA_A=lua52.dll" "LUA_T=lua.exe" \	112	$(MAKE) "LUA_A=lua52.dll" "LUA_T=lua.exe" \
113	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \	113	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
114	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe	114	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
		115	$(MAKE) "LUAC_T=luac.exe" luac.exe
115		116
116	posix:	117	posix:
117	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"	118	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"

src/lapi.c+88−37

 /*
-** $Id: lapi.c,v 2.149 2011/06/13 14:13:06 roberto Exp $
+** $Id: lapi.c,v 2.157 2011/11/16 18:51:36 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
   "$LuaAuthors: " LUA_AUTHORS " $";
+/* value at a non-valid index */
+#define NONVALIDVALUE		cast(TValue *, luaO_nilobject)
-#define api_checkvalidindex(L, i)	api_check(L, (i) != luaO_nilobject, \
+/* corresponding test */
-					  "invalid index")
+#define isvalid(o)	((o) != luaO_nilobject)
+#define api_checkvalidindex(L, i)  api_check(L, isvalid(i), "invalid index")
 static TValue *index2addr (lua_State *L, int idx) {
   if (idx > 0) {
     TValue *o = ci->func + idx;
     api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
-    if (o >= L->top) return cast(TValue *, luaO_nilobject);
+    if (o >= L->top) return NONVALIDVALUE;
     else return o;
   }
   else if (idx > LUA_REGISTRYINDEX) {
     idx = LUA_REGISTRYINDEX - idx;
     api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");
     if (ttislcf(ci->func))  /* light C function? */
-      return cast(TValue *, luaO_nilobject);  /* it has no upvalues */
+      return NONVALIDVALUE;  /* it has no upvalues */
     else {
       CClosure *func = clCvalue(ci->func);
-      return (idx <= func->nupvalues)
+      return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : NONVALIDVALUE;
-             ? &func->upvalue[idx-1]
-             : cast(TValue *, luaO_nilobject);
     }
   }
 }
 LUA_API int lua_type (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
-  return (o == luaO_nilobject) ? LUA_TNONE : ttypenv(o);
+  return (isvalid(o) ? ttypenv(o) : LUA_TNONE);
 }
 LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
   StkId o1 = index2addr(L, index1);
   StkId o2 = index2addr(L, index2);
-  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
+  return (isvalid(o1) && isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0;
-         : luaV_rawequalobj(o1, o2);
 }
 LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {
   StkId o1, o2;
-  int i;
+  int i = 0;
   lua_lock(L);  /* may call tag method */
   o1 = index2addr(L, index1);
   o2 = index2addr(L, index2);
-  if (o1 == luaO_nilobject || o2 == luaO_nilobject)
+  if (isvalid(o1) && isvalid(o2)) {
-    i = 0;
+    switch (op) {
-  else switch (op) {
+      case LUA_OPEQ: i = equalobj(L, o1, o2); break;
-    case LUA_OPEQ: i = equalobj(L, o1, o2); break;
+      case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
-    case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
+      case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
-    case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
+      default: api_check(L, 0, "invalid option");
-    default: api_check(L, 0, "invalid option"); i = 0;
+    }
   }
   lua_unlock(L);
   return i;
 */
+LUA_API void lua_getglobal (lua_State *L, const char *var) {
+  Table *reg = hvalue(&G(L)->l_registry);
+  const TValue *gt;  /* global table */
+  lua_lock(L);
+  gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
+  setsvalue2s(L, L->top++, luaS_new(L, var));
+  luaV_gettable(L, gt, L->top - 1, L->top - 1);
+  lua_unlock(L);
+}
 LUA_API void lua_gettable (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
 LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
-  StkId o;
+  StkId t;
   lua_lock(L);
-  o = index2addr(L, idx);
+  t = index2addr(L, idx);
-  api_check(L, ttistable(o), "table expected");
+  api_check(L, ttistable(t), "table expected");
-  setobj2s(L, L->top, luaH_getint(hvalue(o), n));
+  setobj2s(L, L->top, luaH_getint(hvalue(t), n));
+  api_incr_top(L);
+  lua_unlock(L);
+}
+LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) {
+  StkId t;
+  TValue k;
+  lua_lock(L);
+  t = index2addr(L, idx);
+  api_check(L, ttistable(t), "table expected");
+  setpvalue(&k, cast(void *, p));
+  setobj2s(L, L->top, luaH_get(hvalue(t), &k));
   api_incr_top(L);
   lua_unlock(L);
 }
 */
+LUA_API void lua_setglobal (lua_State *L, const char *var) {
+  Table *reg = hvalue(&G(L)->l_registry);
+  const TValue *gt;  /* global table */
+  lua_lock(L);
+  api_checknelems(L, 1);
+  gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
+  setsvalue2s(L, L->top++, luaS_new(L, var));
+  luaV_settable(L, gt, L->top - 1, L->top - 2);
+  L->top -= 2;  /* pop value and key */
+  lua_unlock(L);
+}
 LUA_API void lua_settable (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   api_check(L, ttistable(t), "table expected");
   setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
+  invalidateTMcache(hvalue(t));
   luaC_barrierback(L, gcvalue(t), L->top-1);
   L->top -= 2;
   lua_unlock(L);
 LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
-  StkId o;
+  StkId t;
   lua_lock(L);
   api_checknelems(L, 1);
-  o = index2addr(L, idx);
+  t = index2addr(L, idx);
-  api_check(L, ttistable(o), "table expected");
+  api_check(L, ttistable(t), "table expected");
-  setobj2t(L, luaH_setint(L, hvalue(o), n), L->top-1);
+  luaH_setint(L, hvalue(t), n, L->top - 1);
-  luaC_barrierback(L, gcvalue(o), L->top-1);
+  luaC_barrierback(L, gcvalue(t), L->top-1);
+  L->top--;
+  lua_unlock(L);
+}
+LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
+  StkId t;
+  TValue k;
+  lua_lock(L);
+  api_checknelems(L, 1);
+  t = index2addr(L, idx);
+  api_check(L, ttistable(t), "table expected");
+  setpvalue(&k, cast(void *, p));
+  setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1);
+  luaC_barrierback(L, gcvalue(t), L->top - 1);
   L->top--;
   lua_unlock(L);
 }
 static const char *aux_upvalue (StkId fi, int n, TValue **val,
                                 GCObject **owner) {
   switch (ttype(fi)) {
     }
     case LUA_TLCL: {  /* Lua closure */
       LClosure *f = clLvalue(fi);
-      const char *name;
+      TString *name;
       Proto *p = f->p;
       if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
       *val = f->upvals[n-1]->v;
       if (owner) *owner = obj2gco(f->upvals[n - 1]);
-      name = getstr(p->upvalues[n-1].name);
+      name = p->upvalues[n-1].name;
-      if (name == NULL)  /* no debug information? */
+      return (name == NULL) ? "" : getstr(name);
-        name = "";
-      return name;
     }
     default: return NULL;  /* not a closure */
   }
 LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
   const char *name;
-  TValue *val;
+  TValue *val = NULL;  /* initialized to avoid warnings */
   lua_lock(L);
   name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL);
   if (name) {
 LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
   const char *name;
-  TValue *val;
+  TValue *val = NULL;  /* initialized to avoid warnings */
-  GCObject *owner;
+  GCObject *owner = NULL;  /* initialized to avoid warnings */
   StkId fi;
   lua_lock(L);
   fi = index2addr(L, funcindex);

src/lauxlib.c+31−10

 /*
-** $Id: lauxlib.c,v 1.233 2011/06/16 14:11:04 roberto Exp $
+** $Id: lauxlib.c,v 1.236 2011/11/14 17:10:24 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 ** return 1 + string at top if find a good name.
 */
 static int findfield (lua_State *L, int objidx, int level) {
-  int found = 0;
   if (level == 0 || !lua_istable(L, -1))
     return 0;  /* not found */
   lua_pushnil(L);  /* start 'next' loop */
-  while (!found && lua_next(L, -2)) {  /* for each pair in table */
+  while (lua_next(L, -2)) {  /* for each pair in table */
     if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
       if (lua_rawequal(L, objidx, -1)) {  /* found object? */
         lua_pop(L, 1);  /* remove value (but keep name) */
     lua_pushfstring(L, "function " LUA_QS, ar->name);
   else if (*ar->what == 'm')  /* main? */
       lua_pushfstring(L, "main chunk");
-  else if (*ar->what == 'C' || *ar->what == 't') {
+  else if (*ar->what == 'C') {
     if (pushglobalfuncname(L, ar)) {
       lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
       lua_remove(L, -2);  /* remove name */
 LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
-  if (!lua_checkstack(L, space)) {
+  /* keep some extra space to run error routines, if needed */
+  const int extra = LUA_MINSTACK;
+  if (!lua_checkstack(L, space + extra)) {
     if (msg)
       luaL_error(L, "stack overflow (%s)", msg);
     else
 }
+static int checkmode (lua_State *L, const char *mode, const char *x) {
+  if (mode && strchr(mode, x[0]) == NULL) {
+    lua_pushfstring(L,
+       "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode);
+    return LUA_ERRFILE;
+  }
+  else return LUA_OK;
+}
 static int skipBOM (LoadF *lf) {
   const char *p = "\xEF\xBB\xBF";  /* Utf8 BOM mark */
   int c;
 }
-LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
+LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
+                                             const char *mode) {
   LoadF lf;
   int status, readstatus;
   int c;
   }
   if (skipcomment(&lf, &c))  /* read initial portion */
     lf.buff[lf.n++] = '\n';  /* add line to correct line numbers */
-  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
+  if (c == LUA_SIGNATURE[0]) {  /* binary file? */
-    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
+    if ((status = checkmode(L, mode, "binary")) != LUA_OK)
-    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
+      goto closefile;
-    skipcomment(&lf, &c);  /* re-read initial portion */
+    if (filename) {
+      lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
+      if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
+      skipcomment(&lf, &c);  /* re-read initial portion */
+    }
+  }
+  else {  /* text file */
+    if ((status = checkmode(L, mode, "text")) != LUA_OK)
+      goto closefile;
   }
   if (c != EOF)
     lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */
   status = lua_load(L, getF, &lf, lua_tostring(L, -1));
+ closefile:
   readstatus = ferror(lf.f);
   if (filename) fclose(lf.f);  /* close file (even in case of errors) */
   if (readstatus) {

src/lauxlib.h+31−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lauxlib.h,v 1.117 2011/06/16 14:10:12 roberto Exp $	2	** $Id: lauxlib.h,v 1.119 2011/11/14 17:10:24 roberto Exp $
3	** Auxiliary functions for building Lua libraries	3	** Auxiliary functions for building Lua libraries
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -72,7 +72,11 @@ LUALIB_API int (luaL_execresult) (lua_State *L, int stat); · 66 unmodified lines
72	LUALIB_API int (luaL_ref) (lua_State *L, int t);	72	LUALIB_API int (luaL_ref) (lua_State *L, int t);
73	LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);	73	LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
74		74
75	LUALIB_API int (luaL_loadfile) (lua_State L, const char filename);	75	LUALIB_API int (luaL_loadfilex) (lua_State L, const char filename,
		76	const char *mode);
		77
		78	#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
		79
76	LUALIB_API int (luaL_loadbuffer) (lua_State L, const char buff, size_t sz,	80	LUALIB_API int (luaL_loadbuffer) (lua_State L, const char buff, size_t sz,
77	const char *name);	81	const char *name);
78	LUALIB_API int (luaL_loadstring) (lua_State L, const char s);	82	LUALIB_API int (luaL_loadstring) (lua_State L, const char s);
@@ -163,6 +167,31 @@ LUALIB_API char (luaL_buffinitsize) (lua_State L, luaL_Buffer *B, size_t sz); · 84 unmodified lines
163	/* }====================================================== */	167	/* }====================================================== */
164		168
165		169
		170
		171	/*
		172	** {======================================================
		173	** File handles for IO library
		174	** =======================================================
		175	*/
		176
		177	/*
		178	** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
		179	** initial structure 'luaL_Stream' (it may contain other fields
		180	** after that initial structure).
		181	*/
		182
		183	#define LUA_FILEHANDLE "FILE*"
		184
		185
		186	typedef struct luaL_Stream {
		187	FILE f; / stream (NULL for incompletely created streams) */
		188	lua_CFunction closef; /* to close stream (NULL for closed streams) */
		189	} luaL_Stream;
		190
		191	/* }====================================================== */
		192
		193
		194
166	/* compatibility with old module system */	195	/* compatibility with old module system */
167	#if defined(LUA_COMPAT_MODULE)	196	#if defined(LUA_COMPAT_MODULE)
168		197

src/lbaselib.c+45−35

 /*
-** $Id: lbaselib.c,v 1.264 2011/07/05 12:49:35 roberto Exp $
+** $Id: lbaselib.c,v 1.270 2011/11/23 17:29:04 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 #define SPACECHARS	" \f\n\r\t\v"
 static int luaB_tonumber (lua_State *L) {
-  int base = luaL_optint(L, 2, 10);
+  if (lua_isnoneornil(L, 2)) {  /* standard conversion */
-  luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
+    int isnum;
-  if (base == 10) {  /* standard conversion */
+    lua_Number n = lua_tonumberx(L, 1, &isnum);
-    luaL_checkany(L, 1);
+    if (isnum) {
-    if (lua_isnumber(L, 1)) {
+      lua_pushnumber(L, n);
-      lua_pushnumber(L, lua_tonumber(L, 1));
       return 1;
-    }  /* else not a number */
+    }  /* else not a number; must be something */
+    luaL_checkany(L, 1);
   }
   else {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     const char *e = s + l;  /* end point for 's' */
+    int base = luaL_checkint(L, 2);
     int neg = 0;
+    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
     s += strspn(s, SPACECHARS);  /* skip initial spaces */
     if (*s == '-') { s++; neg = 1; }  /* handle signal */
     else if (*s == '+') s++;
 static int luaB_collectgarbage (lua_State *L) {
   static const char *const opts[] = {"stop", "restart", "collect",
     "count", "step", "setpause", "setstepmul",
-    "setmajorinc", "isrunning", "gen", "inc", NULL};
+    "setmajorinc", "isrunning", "generational", "incremental", NULL};
   static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
     LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
     LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
 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 *mode = luaL_optstring(L, 2, NULL);
+  int env = !lua_isnone(L, 3);  /* 'env' parameter? */
+  int status = luaL_loadfilex(L, fname, mode);
+  if (status == LUA_OK && env) {  /* 'env' parameter? */
+    lua_pushvalue(L, 3);
+    lua_setupvalue(L, -2, 1);  /* set it as 1st upvalue of loaded chunk */
+  }
+  return load_aux(L, status);
 }
 typedef struct {
-char c;
   const char *mode;
 } loaddata;
 ** pushed on the stack) in case of errors.
 */
 static const char *checkrights (lua_State *L, const char *mode, const char *s) {
-  if (strchr(mode, 'b') == NULL && *s == LUA_SIGNATURE[0])
+  const char *x = (*s == LUA_SIGNATURE[0]) ? "binary" : "text";
-    return lua_pushstring(L, "attempt to load a binary chunk");
+  if (strchr(mode, x[0]) == NULL)
-  if (strchr(mode, 't') == NULL && *s != LUA_SIGNATURE[0])
+    return lua_pushfstring(L,
-    return lua_pushstring(L, "attempt to load a text chunk");
+       "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode);
-  return NULL;  /* chunk in allowed format */
+  else return NULL;
 }
 }
-static int pcallcont (lua_State *L) {
+static int finishpcall (lua_State *L, int status) {
-  int errfunc = 0;  /* =0 to avoid warnings */
+  if (!lua_checkstack(L, 1)) {  /* no space for extra boolean? */
-  int status = lua_getctx(L, &errfunc);
+    lua_settop(L, 0);  /* create space for return values */
-  lua_assert(status != LUA_OK);
+    lua_pushboolean(L, 0);
-  lua_pushboolean(L, (status == LUA_YIELD));  /* first result (status) */
+    lua_pushstring(L, "stack overflow");
-  if (errfunc)  /* came from xpcall? */
+    return 2;  /* return false, msg */
-    lua_replace(L, 1);  /* put first result in place of error function */
+  }
-  else  /* came from pcall */
+  lua_pushboolean(L, status);  /* first result (status) */
-    lua_insert(L, 1);  /* open space for first result */
+  lua_replace(L, 1);  /* put first result in first slot */
   return lua_gettop(L);
 }
+static int pcallcont (lua_State *L) {
+  int status = lua_getctx(L, NULL);
+  return finishpcall(L, (status == LUA_YIELD));
+}
 static int luaB_pcall (lua_State *L) {
   int status;
   luaL_checkany(L, 1);
-  status = lua_pcallk(L, lua_gettop(L) - 1, LUA_MULTRET, 0, 0, pcallcont);
+  lua_pushnil(L);
-  luaL_checkstack(L, 1, NULL);
+  lua_insert(L, 1);  /* create space for status result */
-  lua_pushboolean(L, (status == LUA_OK));
+  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont);
-  lua_insert(L, 1);
+  return finishpcall(L, (status == LUA_OK));
-  return lua_gettop(L);  /* return status + all results */
 }
   lua_pushvalue(L, 1);  /* exchange function... */
   lua_copy(L, 2, 1);  /* ...and error handler */
   lua_replace(L, 2);
-  status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 1, pcallcont);
+  status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont);
-  luaL_checkstack(L, 1, NULL);
+  return finishpcall(L, (status == LUA_OK));
-  lua_pushboolean(L, (status == LUA_OK));
-  lua_replace(L, 1);
-  return lua_gettop(L);  /* return status + all results */
 }

src/lcode.c+12−10

 /*
-** $Id: lcode.c,v 2.56 2011/05/31 18:27:56 roberto Exp $
+** $Id: lcode.c,v 2.60 2011/08/30 16:26:41 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
       int pl = pfrom + GETARG_B(*previous);
       if ((pfrom <= from && from <= pl + 1) ||
           (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
         if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */
         if (pl > l) l = pl;  /* l = max(l, pl) */
         SETARG_A(*previous, from);
         SETARG_B(*previous, l - from);
         return;
   Proto *f = fs->f;
   dischargejpc(fs);  /* `pc' will change */
   /* put new instruction in code array */
-  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
+  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
                   MAX_INT, "opcodes");
   f->code[fs->pc] = i;
   /* save corresponding line information */
-  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
+  luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                   MAX_INT, "opcodes");
   f->lineinfo[fs->pc] = fs->ls->lastline;
   return fs->pc++;
 static int addk (FuncState *fs, TValue *key, TValue *v) {
-  lua_State *L = fs->L;
+  lua_State *L = fs->ls->L;
   TValue *idx = luaH_set(L, fs->h, key);
   Proto *f = fs->f;
   int k, oldsize;
   /* constant not found; create a new entry */
   oldsize = f->sizek;
   k = fs->nk;
+  /* numerical value does not need GC barrier;
+     table has no metatable, so it does not need to invalidate cache */
   setnvalue(idx, cast_num(k));
   luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
   while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
 int luaK_stringK (FuncState *fs, TString *s) {
   TValue o;
-  setsvalue(fs->L, &o, s);
+  setsvalue(fs->ls->L, &o, s);
   return addk(fs, &o, &o);
 }
 int luaK_numberK (FuncState *fs, lua_Number r) {
   int n;
-  lua_State *L = fs->L;
+  lua_State *L = fs->ls->L;
   TValue o;
   setnvalue(&o, r);
   if (r == 0 || luai_numisnan(NULL, r)) {  /* handle -0 and NaN */
   TValue k, v;
   setnilvalue(&v);
   /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->L, &k, fs->h);
+  sethvalue(fs->ls->L, &k, fs->h);
   return addk(fs, &k, &v);
 }
 }
-static void luaK_goiffalse (FuncState *fs, expdesc *e) {
+void luaK_goiffalse (FuncState *fs, expdesc *e) {
   int pc;  /* pc of last jump */
   luaK_dischargevars(fs, e);
   switch (e->k) {

src/lcode.h+2−1

 /*
-** $Id: lcode.h,v 1.57 2011/04/07 18:14:12 roberto Exp $
+** $Id: lcode.h,v 1.58 2011/08/30 16:26:41 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
 LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
 LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
 LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
 LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
 LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);

src/lcorolib.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lcorolib.c,v 1.2 2010/07/02 11:38:13 roberto Exp $	2	** $Id: lcorolib.c,v 1.3 2011/08/23 17:24:34 roberto Exp $
3	** Coroutine Library	3	** Coroutine Library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -28,7 +28,7 @@ static int auxresume (lua_State L, lua_State co, int narg) { · 22 unmodified lines
28	return -1; /* error flag */	28	return -1; /* error flag */
29	}	29	}
30	lua_xmove(L, co, narg);	30	lua_xmove(L, co, narg);
31	status = lua_resume(co, narg);	31	status = lua_resume(co, L, narg);
32	if (status == LUA_OK \|\| status == LUA_YIELD) {	32	if (status == LUA_OK \|\| status == LUA_YIELD) {
33	int nres = lua_gettop(co);	33	int nres = lua_gettop(co);
34	if (!lua_checkstack(L, nres + 1)) {	34	if (!lua_checkstack(L, nres + 1)) {

src/lctype.c+4−1

 /*
-** $Id: lctype.c,v 1.10 2011/06/24 12:25:33 roberto Exp $
+** $Id: lctype.c,v 1.11 2011/10/03 16:19:23 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
+#define lctype_c
+#define LUA_CORE
 #include "lctype.h"
 #if !LUA_USE_CTYPE	/* { */

src/lctype.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lctype.h,v 1.11 2011/06/27 18:22:46 roberto Exp $	2	** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp $
3	** 'ctype' functions for Lua	3	** 'ctype' functions for Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -11,7 +11,7 @@ · 5 unmodified lines
11		11
12		12
13	/*	13	/*
14	** WARNING: the functions defined here do not necessarily correspond	14	** WARNING: the functions defined here do not necessarily correspond
15	** to the similar functions in the standard C ctype.h. They are	15	** to the similar functions in the standard C ctype.h. They are
16	** optimized for the specific needs of Lua	16	** optimized for the specific needs of Lua
17	*/	17	*/

src/ldblib.c+4−7

 /*
-** $Id: ldblib.c,v 1.130 2011/04/08 19:17:36 roberto Exp $
+** $Id: ldblib.c,v 1.131 2011/10/24 14:54:05 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
   static const char *const hooknames[] =
     {"call", "return", "line", "count", "tail call"};
   gethooktable(L);
-  lua_pushlightuserdata(L, L);
+  lua_rawgetp(L, -1, L);
-  lua_rawget(L, -2);
   if (lua_isfunction(L, -1)) {
     lua_pushstring(L, hooknames[(int)ar->event]);
     if (ar->currentline >= 0)
     func = hookf; mask = makemask(smask, count);
   }
   gethooktable(L);
-  lua_pushlightuserdata(L, L1);
   lua_pushvalue(L, arg+1);
-  lua_rawset(L, -3);  /* set new hook */
+  lua_rawsetp(L, -2, L1);  /* set new hook */
   lua_pop(L, 1);  /* remove hook table */
   lua_sethook(L1, func, mask, count);  /* set hooks */
   return 0;
     lua_pushliteral(L, "external hook");
   else {
     gethooktable(L);
-    lua_pushlightuserdata(L, L1);
+    lua_rawgetp(L, -1, L1);   /* get hook */
-    lua_rawget(L, -2);   /* get hook */
     lua_remove(L, -2);  /* remove hook table */
   }
   lua_pushstring(L, unmakemask(mask, buff));

src/ldebug.c+104−96

 /*
-** $Id: ldebug.c,v 2.82 2011/06/02 19:31:40 roberto Exp $
+** $Id: ldebug.c,v 2.87 2011/10/07 20:45:19 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
 }
+static const char *upvalname (Proto *p, int uv) {
+  TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
+  if (s == NULL) return "?";
+  else return getstr(s);
+}
 static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
   int nparams = clLvalue(ci->func)->p->numparams;
   if (n >= ci->u.l.base - ci->func - nparams)
   }
   else {
     int i;
+    TValue v;
     int *lineinfo = f->l.p->lineinfo;
-    Table *t = luaH_new(L);
+    Table *t = luaH_new(L);  /* new table to store active lines */
-    sethvalue(L, L->top, t);
+    sethvalue(L, L->top, t);  /* push it on stack */
     incr_top(L);
-    for (i=0; i<f->l.p->sizelineinfo; i++)
+    setbvalue(&v, 1);  /* boolean 'true' to be the value of all indices */
-      setbvalue(luaH_setint(L, t, lineinfo[i]), 1);
+    for (i = 0; i < f->l.p->sizelineinfo; i++)  /* for all lines with code */
+      luaH_setint(L, t, lineinfo[i], &v);  /* table[line] = true */
   }
 }
         break;
       }
       case 'n': {
-        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
+        /* calling function is a known Lua function? */
+        if (ci && !(ci->callstatus & CIST_TAIL) && isLua(ci->previous))
+          ar->namewhat = getfuncname(L, ci->previous, &ar->name);
+        else
+          ar->namewhat = NULL;
         if (ar->namewhat == NULL) {
           ar->namewhat = "";  /* not found */
           ar->name = NULL;
 ** =======================================================
 */
-static const char *getobjname (lua_State *L, CallInfo *ci, int reg,
+static const char *getobjname (Proto *p, int lastpc, int reg,
                                const char **name);
 /*
 ** find a "name" for the RK value 'c'
 */
-static void kname (lua_State *L, CallInfo *ci, int c, int oreg,
+static void kname (Proto *p, int pc, int c, const char **name) {
-                   const char *what, const char **name) {
   if (ISK(c)) {  /* is 'c' a constant? */
-    TValue *kvalue = &ci_func(ci)->p->k[INDEXK(c)];
+    TValue *kvalue = &p->k[INDEXK(c)];
     if (ttisstring(kvalue)) {  /* literal constant? */
       *name = svalue(kvalue);  /* it is its own name */
       return;
     /* else no reasonable name found */
   }
   else {  /* 'c' is a register */
-    if (c != oreg)  /* not the original register? */
+    const char *what = getobjname(p, pc, c, name); /* search for 'c' */
-      what = getobjname(L, ci, c, name); /* search for 'c' */
     if (what && *what == 'c') {  /* found a constant name? */
       return;  /* 'name' already filled */
     }
 }
-static const char *getobjname (lua_State *L, CallInfo *ci, int reg,
+/*
-                               const char **name) {
+** try to find last instruction before 'lastpc' that modified register 'reg'
-  Proto *p = ci_func(ci)->p;
+*/
-  const char *what = NULL;
+static int findsetreg (Proto *p, int lastpc, int reg) {
-  int lastpc = currentpc(ci);
   int pc;
-  *name = luaF_getlocalname(p, reg + 1, lastpc);
+  int setreg = -1;  /* keep last instruction that changed 'reg' */
-  if (*name)  /* is a local? */
-    return "local";
-  /* else try symbolic execution */
   for (pc = 0; pc < lastpc; pc++) {
     Instruction i = p->code[pc];
     OpCode op = GET_OPCODE(i);
     int a = GETARG_A(i);
     switch (op) {
-      case OP_MOVE: {
-        if (reg == a) {
-          int b = GETARG_B(i);  /* move from 'b' to 'a' */
-          if (b < a)
-            what = getobjname(L, ci, b, name);  /* get name for 'b' */
-          else what = NULL;
-        }
-        break;
-      }
-      case OP_GETTABUP:
-      case OP_GETTABLE: {
-        if (reg == a) {
-          int k = GETARG_C(i);  /* key index */
-          int t = GETARG_B(i);
-          const char *vn = (op == OP_GETTABLE)  /* name of indexed variable */
-                           ? luaF_getlocalname(p, t + 1, pc)
-                           : getstr(p->upvalues[t].name);
-          kname(L, ci, k, a, what, name);
-          what = (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
-        }
-        break;
-      }
-      case OP_GETUPVAL: {
-        if (reg == a) {
-          int u = GETARG_B(i);  /* upvalue index */
-          TString *tn = p->upvalues[u].name;
-          *name = tn ? getstr(tn) : "?";
-          what = "upvalue";
-        }
-        break;
-      }
-      case OP_LOADK:
-      case OP_LOADKX: {
-        if (reg == a) {
-          int b = (op == OP_LOADK) ? GETARG_Bx(i)
-                                   : GETARG_Ax(p->code[pc + 1]);
-          if (ttisstring(&p->k[b])) {
-            what = "constant";
-            *name = svalue(&p->k[b]);
-          }
-        }
-        break;
-      }
       case OP_LOADNIL: {
         int b = GETARG_B(i);
         if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */
-          what = NULL;
+          setreg = pc;
-        break;
-      }
-      case OP_SELF: {
-        if (reg == a) {
-          int k = GETARG_C(i);  /* key index */
-          kname(L, ci, k, a, what, name);
-          what = "method";
-        }
         break;
       }
       case OP_TFORCALL: {
-        if (reg >= a + 2) what = NULL;  /* affect all regs above its base */
+        if (reg >= a + 2) setreg = pc;  /* affect all regs above its base */
         break;
       }
       case OP_CALL:
       case OP_TAILCALL: {
-        if (reg >= a) what = NULL;  /* affect all registers above base */
+        if (reg >= a) setreg = pc;  /* affect all registers above base */
         break;
       }
       case OP_JMP: {
         break;
       }
       case OP_TEST: {
-        if (reg == a) what = NULL;  /* jumped code can change 'a' */
+        if (reg == a) setreg = pc;  /* jumped code can change 'a' */
         break;
       }
       default:
-        if (testAMode(op) && reg == a) what = NULL;
+        if (testAMode(op) && reg == a)  /* any instruction that set A */
+          setreg = pc;
         break;
     }
   }
-  return what;
+  return setreg;
+}
+static const char *getobjname (Proto *p, int lastpc, int reg,
+                               const char **name) {
+  int pc;
+  *name = luaF_getlocalname(p, reg + 1, lastpc);
+  if (*name)  /* is a local? */
+    return "local";
+  /* else try symbolic execution */
+  pc = findsetreg(p, lastpc, reg);
+  if (pc != -1) {  /* could find instruction? */
+    Instruction i = p->code[pc];
+    OpCode op = GET_OPCODE(i);
+    switch (op) {
+      case OP_MOVE: {
+        int b = GETARG_B(i);  /* move from 'b' to 'a' */
+        if (b < GETARG_A(i))
+          return getobjname(p, pc, b, name);  /* get name for 'b' */
+        break;
+      }
+      case OP_GETTABUP:
+      case OP_GETTABLE: {
+        int k = GETARG_C(i);  /* key index */
+        int t = GETARG_B(i);  /* table index */
+        const char *vn = (op == OP_GETTABLE)  /* name of indexed variable */
+                         ? luaF_getlocalname(p, t + 1, pc)
+                         : upvalname(p, t);
+        kname(p, pc, k, name);
+        return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
+      }
+      case OP_GETUPVAL: {
+        *name = upvalname(p, GETARG_B(i));
+        return "upvalue";
+      }
+      case OP_LOADK:
+      case OP_LOADKX: {
+        int b = (op == OP_LOADK) ? GETARG_Bx(i)
+                                 : GETARG_Ax(p->code[pc + 1]);
+        if (ttisstring(&p->k[b])) {
+          *name = svalue(&p->k[b]);
+          return "constant";
+        }
+        break;
+      }
+      case OP_SELF: {
+        int k = GETARG_C(i);  /* key index */
+        kname(p, pc, k, name);
+        return "method";
+      }
+      default: break;  /* go through to return NULL */
+    }
+  }
+  return NULL;  /* could not find reasonable name */
 }
 static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
   TMS tm;
-  Instruction i;
+  Proto *p = ci_func(ci)->p;  /* calling function */
-  if ((ci->callstatus & CIST_TAIL) || !isLua(ci->previous))
+  int pc = currentpc(ci);  /* calling instruction index */
-    return NULL;  /* calling function is not Lua (or is unknown) */
+  Instruction i = p->code[pc];  /* calling instruction */
-  ci = ci->previous;  /* calling function */
-  i = ci_func(ci)->p->code[currentpc(ci)];
-  if (GET_OPCODE(i) == OP_EXTRAARG)  /* extra argument? */
-    i = ci_func(ci)->p->code[currentpc(ci) - 1];  /* get 'real' instruction */
   switch (GET_OPCODE(i)) {
     case OP_CALL:
-    case OP_TAILCALL:
+    case OP_TAILCALL:  /* get function name */
-      return getobjname(L, ci, GETARG_A(i), name);
+      return getobjname(p, pc, GETARG_A(i), name);
-    case OP_TFORCALL: {
+    case OP_TFORCALL: {  /* for iterator */
       *name = "for iterator";
        return "for iterator";
     }
+    /* all other instructions can call only through metamethods */
     case OP_SELF:
     case OP_GETTABUP:
     case OP_GETTABLE: tm = TM_INDEX; break;
 static const char *getupvalname (CallInfo *ci, const TValue *o,
-                               const char **name) {
+                                 const char **name) {
   LClosure *c = ci_func(ci);
   int i;
   for (i = 0; i < c->nupvalues; i++) {
     if (c->upvals[i]->v == o) {
-      *name = getstr(c->p->upvalues[i].name);
+      *name = upvalname(c->p, i);
       return "upvalue";
     }
   }
   if (isLua(ci)) {
     kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */
     if (!kind && isinstack(ci, o))  /* no? try a register */
-      kind = getobjname(L, ci, cast_int(o - ci->u.l.base), &name);
+      kind = getobjname(ci_func(ci)->p, currentpc(ci),
+                        cast_int(o - ci->u.l.base), &name);
   }
   if (kind)
     luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
 }
-void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
+l_noret luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
   TValue temp;
   if (luaV_tonumber(p1, &temp) == NULL)
     p2 = p1;  /* first operand is wrong */
 }
-int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
+l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
   const char *t1 = objtypename(p1);
   const char *t2 = objtypename(p2);
   if (t1 == t2)
     luaG_runerror(L, "attempt to compare two %s values", t1);
   else
     luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
-  return 0;
 }
 }
-void luaG_errormsg (lua_State *L) {
+l_noret luaG_errormsg (lua_State *L) {
   if (L->errfunc != 0) {  /* is there an error handling function? */
     StkId errfunc = restorestack(L, L->errfunc);
     if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
 }
-void luaG_runerror (lua_State *L, const char *fmt, ...) {
+l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
   va_list argp;
   va_start(argp, fmt);
   addinfo(L, luaO_pushvfstring(L, fmt, argp));

src/ldebug.h+10−10

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldebug.h,v 2.6 2011/06/02 19:31:40 roberto Exp $	2	** $Id: ldebug.h,v 2.7 2011/10/07 20:45:19 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	*/
@@ -21,14 +21,14 @@ · 15 unmodified lines
21	#define ci_func(ci) (clLvalue((ci)->func))	21	#define ci_func(ci) (clLvalue((ci)->func))
22		22
23		23
24	LUAI_FUNC void luaG_typeerror (lua_State L, const TValue o,	24	LUAI_FUNC l_noret luaG_typeerror (lua_State L, const TValue o,
25	const char *opname);	25	const char *opname);
26	LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);	26	LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2);
27	LUAI_FUNC void luaG_aritherror (lua_State L, const TValue p1,	27	LUAI_FUNC l_noret luaG_aritherror (lua_State L, const TValue p1,
28	const TValue *p2);	28	const TValue *p2);
29	LUAI_FUNC int luaG_ordererror (lua_State L, const TValue p1,	29	LUAI_FUNC l_noret luaG_ordererror (lua_State L, const TValue p1,
30	const TValue *p2);	30	const TValue *p2);
31	LUAI_FUNC void luaG_runerror (lua_State L, const char fmt, ...);	31	LUAI_FUNC l_noret luaG_runerror (lua_State L, const char fmt, ...);
32	LUAI_FUNC void luaG_errormsg (lua_State *L);	32	LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
33		33
34	#endif	34	#endif

src/ldo.c+17−17

 /*
-** $Id: ldo.c,v 2.98 2011/06/28 15:42:04 roberto Exp $
+** $Id: ldo.c,v 2.101 2011/10/07 20:45:19 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
 }
-void luaD_throw (lua_State *L, int errcode) {
+l_noret luaD_throw (lua_State *L, int errcode) {
   if (L->errorJmp) {  /* thread has an error handler? */
     L->errorJmp->status = errcode;  /* set status */
     LUAI_THROW(L, L->errorJmp);  /* jump to it */
 int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
-  unsigned short oldnCcalls = G(L)->nCcalls;
+  unsigned short oldnCcalls = L->nCcalls;
   struct lua_longjmp lj;
   lj.status = LUA_OK;
   lj.previous = L->errorJmp;  /* chain new error handler */
     (*f)(L, ud);
   );
   L->errorJmp = lj.previous;  /* restore old error handler */
-  G(L)->nCcalls = oldnCcalls;
+  L->nCcalls = oldnCcalls;
   return lj.status;
 }
     }
     default: {  /* not a function */
       func = tryfuncTM(L, func);  /* retry with 'function' tag method */
-      return luaD_precall(L, func, nresults);
+      return luaD_precall(L, func, nresults);  /* now it must be a function */
     }
   }
 }
 ** function position.
 */
 void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) {
-  global_State *g = G(L);
+  if (++L->nCcalls >= LUAI_MAXCCALLS) {
-  if (++g->nCcalls >= LUAI_MAXCCALLS) {
+    if (L->nCcalls == LUAI_MAXCCALLS)
-    if (g->nCcalls == LUAI_MAXCCALLS)
       luaG_runerror(L, "C stack overflow");
-    else if (g->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
+    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
       luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
   }
   if (!allowyield) L->nny++;
   if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
     luaV_execute(L);  /* call it */
   if (!allowyield) L->nny--;
-  g->nCcalls--;
+  L->nCcalls--;
   luaC_checkGC(L);
 }
   lua_assert(ci->u.c.k != NULL);  /* must have a continuation */
   lua_assert(L->nny == 0);
   /* finish 'luaD_call' */
-  G(L)->nCcalls--;
+  L->nCcalls--;
   /* finish 'lua_callk' */
   adjustresults(L, ci->nresults);
   /* call continuation function */
 ** coroutine itself. (Such errors should not be handled by any coroutine
 ** error handler and should not kill the coroutine.)
 */
-static void resume_error (lua_State *L, const char *msg, StkId firstArg) {
+static l_noret resume_error (lua_State *L, const char *msg, StkId firstArg) {
   L->top = firstArg;  /* remove args from the stack */
   setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
   incr_top(L);
 static void resume (lua_State *L, void *ud) {
   StkId firstArg = cast(StkId, ud);
   CallInfo *ci = L->ci;
-  if (G(L)->nCcalls >= LUAI_MAXCCALLS)
+  if (L->nCcalls >= LUAI_MAXCCALLS)
     resume_error(L, "C stack overflow", firstArg);
   if (L->status == LUA_OK) {  /* may be starting a coroutine */
     if (ci != &L->base_ci)  /* not in base level? */
         api_checknelems(L, n);
         firstArg = L->top - n;  /* yield results come from continuation */
       }
-      G(L)->nCcalls--;  /* finish 'luaD_call' */
+      L->nCcalls--;  /* finish 'luaD_call' */
       luaD_poscall(L, firstArg);  /* finish 'luaD_precall' */
     }
     unroll(L, NULL);
 }
-LUA_API int lua_resume (lua_State *L, int nargs) {
+LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
   int status;
   lua_lock(L);
   luai_userstateresume(L, nargs);
-  ++G(L)->nCcalls;  /* count resume */
+  L->nCcalls = (from) ? from->nCcalls + 1 : 1;
   L->nny = 0;  /* allow yields */
   api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
   status = luaD_rawrunprotected(L, resume, L->top - nargs);
     lua_assert(status == L->status);
   }
   L->nny = 1;  /* do not allow yields */
-  --G(L)->nCcalls;
+  L->nCcalls--;
+  lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
   lua_unlock(L);
   return status;
 }

src/ldo.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldo.h,v 2.18 2009/12/17 12:28:57 roberto Exp $	2	** $Id: ldo.h,v 2.19 2011/10/07 20:45:19 roberto Exp $
3	** Stack and Call structure of Lua	3	** Stack and Call structure of Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -38,7 +38,7 @@ LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize); · 32 unmodified lines
38	LUAI_FUNC void luaD_growstack (lua_State *L, int n);	38	LUAI_FUNC void luaD_growstack (lua_State *L, int n);
39	LUAI_FUNC void luaD_shrinkstack (lua_State *L);	39	LUAI_FUNC void luaD_shrinkstack (lua_State *L);
40		40
41	LUAI_FUNC void luaD_throw (lua_State *L, int errcode);	41	LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
42	LUAI_FUNC int luaD_rawrunprotected (lua_State L, Pfunc f, void ud);	42	LUAI_FUNC int luaD_rawrunprotected (lua_State L, Pfunc f, void ud);
43		43
44	#endif	44	#endif

src/ldump.c+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldump.c,v 1.18 2011/05/06 13:35:17 lhf Exp $	2	** $Id: ldump.c,v 1.19 2011/11/23 17:48:18 lhf Exp $
3	** save precompiled Lua chunks	3	** save precompiled Lua chunks
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -111,8 +111,8 @@ static void DumpUpvalues(const Proto* f, DumpState* D) · 105 unmodified lines
111	DumpInt(n,D);	111	DumpInt(n,D);
112	for (i=0; i<n; i++)	112	for (i=0; i<n; i++)
113	{	113	{
114	DumpChar(f->upvalues[i].instack, D);	114	DumpChar(f->upvalues[i].instack,D);
115	DumpChar(f->upvalues[i].idx, D);	115	DumpChar(f->upvalues[i].idx,D);
116	}	116	}
117	}	117	}
118		118

src/lgc.c+96−46

 /*
-** $Id: lgc.c,v 2.109 2011/05/05 19:42:25 roberto Exp $
+** $Id: lgc.c,v 2.114 2011/10/03 17:54:25 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 /*
-** mark a table entry as dead (therefore removing it from the table)
+** if key is not marked, mark its entry as dead (therefore removing it
+** from the table)
 */
 static void removeentry (Node *n) {
   lua_assert(ttisnil(gval(n)));
-  if (iscollectable(gkey(n)))
+  if (valiswhite(gkey(n)))
-    setdeadvalue(gkey(n));  /* dead key; remove it */
+    setdeadvalue(gkey(n));  /* unused and unmarked key; remove it */
 }
 ** other objects: if really collected, cannot keep them; for objects
 ** being finalized, keep them in keys, but not in values
 */
-static int iscleared (const TValue *o, int iskey) {
+static int iscleared (const TValue *o) {
   if (!iscollectable(o)) return 0;
   else if (ttisstring(o)) {
     stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
     return 0;
   }
-  else return iswhite(gcvalue(o)) || (!iskey && isfinalized(gcvalue(o)));
+  else return iswhite(gcvalue(o));
 }
 */
 void luaC_barrierback_ (lua_State *L, GCObject *o) {
   global_State *g = G(L);
-  lua_assert(isblack(o) && !isdead(g, o));
+  lua_assert(isblack(o) && !isdead(g, o) && gch(o)->tt == LUA_TTABLE);
   black2gray(o);  /* make object gray (again) */
   gco2t(o)->gclist = g->grayagain;
   g->grayagain = o;
 static void traverseweakvalue (global_State *g, Table *h) {
   Node *n, *limit = gnode(h, sizenode(h));
+  /* if there is array part, assume it may have white values (do not
+     traverse it just to check) */
+  int hasclears = (h->sizearray > 0);
   for (n = gnode(h, 0); n < limit; n++) {
     checkdeadkey(n);
     if (ttisnil(gval(n)))  /* entry is empty? */
     else {
       lua_assert(!ttisnil(gkey(n)));
       markvalue(g, gkey(n));  /* mark key */
+      if (!hasclears && iscleared(gval(n)))  /* is there a white value? */
+        hasclears = 1;  /* table will have to be cleared */
     }
   }
-  linktable(h, &g->weak);  /* link into appropriate list */
+  if (hasclears)
+    linktable(h, &g->weak);  /* has to be cleared later */
+  else  /* no white values */
+    linktable(h, &g->grayagain);  /* no need to clean */
 }
 static int traverseephemeron (global_State *g, Table *h) {
   int marked = 0;  /* true if an object is marked in this traversal */
-  int hasclears = 0;  /* true if table has unmarked pairs */
+  int hasclears = 0;  /* true if table has white keys */
+  int prop = 0;  /* true if table has entry "white-key -> white-value" */
   Node *n, *limit = gnode(h, sizenode(h));
   int i;
   /* traverse array part (numeric keys are 'strong') */
     checkdeadkey(n);
     if (ttisnil(gval(n)))  /* entry is empty? */
       removeentry(n);  /* remove it */
+    else if (iscleared(gkey(n))) {  /* key is not marked (yet)? */
+      hasclears = 1;  /* table must be cleared */
+      if (valiswhite(gval(n)))  /* value not marked yet? */
+        prop = 1;  /* must propagate again */
+    }
     else if (valiswhite(gval(n))) {  /* value not marked yet? */
-      if (iscleared(gkey(n), 1))  /* key is not marked (yet)? */
+      marked = 1;
-        hasclears = 1;  /* may have to propagate mark from key to value */
+      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
-      else {  /* key is marked, so mark value */
-        marked = 1;  /* value was not marked */
-        reallymarkobject(g, gcvalue(gval(n)));
-      }
     }
   }
-  if (hasclears)  /* does table have unmarked pairs? */
+  if (prop)
-    linktable(h, &g->ephemeron);  /* will have to propagate again */
+    linktable(h, &g->ephemeron);  /* have to propagate again */
-  else  /* nothing to propagate */
+  else if (hasclears)  /* does table have white keys? */
-    linktable(h, &g->weak);  /* avoid convergence phase  */
+    linktable(h, &g->allweak);  /* may have to clean white keys */
+  else  /* no white keys */
+    linktable(h, &g->grayagain);  /* no need to clean */
   return marked;
 }
 }
-static void traverselistofgrays (global_State *g, GCObject **l) {
+static void propagatelist (global_State *g, GCObject *l) {
   lua_assert(g->gray == NULL);  /* no grays left */
-  g->gray = *l;  /* now 'l' is new gray list */
+  g->gray = l;
-  *l = NULL;
+  propagateall(g);  /* traverse all elements from 'l' */
-  propagateall(g);
+}
+/*
+** retraverse all gray lists. Because tables may be reinserted in other
+** lists when traversed, traverse the original lists to avoid traversing
+** twice the same table (which is not wrong, but inefficient)
+*/
+static void retraversegrays (global_State *g) {
+  GCObject *weak = g->weak;  /* save original lists */
+  GCObject *grayagain = g->grayagain;
+  GCObject *ephemeron = g->ephemeron;
+  g->weak = g->grayagain = g->ephemeron = NULL;
+  propagateall(g);  /* traverse main gray list */
+  propagatelist(g, grayagain);
+  propagatelist(g, weak);
+  propagatelist(g, ephemeron);
 }
 /*
-** clear collected entries from all weaktables in list 'l'
+** clear entries with unmarked keys from all weaktables in list 'l' up
+** to element 'f'
+*/
+static void clearkeys (GCObject *l, GCObject *f) {
+  for (; l != f; l = gco2t(l)->gclist) {
+    Table *h = gco2t(l);
+    Node *n, *limit = gnode(h, sizenode(h));
+    for (n = gnode(h, 0); n < limit; n++) {
+      if (!ttisnil(gval(n)) && (iscleared(gkey(n)))) {
+        setnilvalue(gval(n));  /* remove value ... */
+        removeentry(n);  /* and remove entry from table */
+      }
+    }
+  }
+}
+/*
+** clear entries with unmarked values from all weaktables in list 'l' up
+** to element 'f'
 */
-static void cleartable (GCObject *l) {
+static void clearvalues (GCObject *l, GCObject *f) {
-  for (; l != NULL; l = gco2t(l)->gclist) {
+  for (; l != f; l = gco2t(l)->gclist) {
     Table *h = gco2t(l);
     Node *n, *limit = gnode(h, sizenode(h));
     int i;
     for (i = 0; i < h->sizearray; i++) {
       TValue *o = &h->array[i];
-      if (iscleared(o, 0))  /* value was collected? */
+      if (iscleared(o))  /* value was collected? */
         setnilvalue(o);  /* remove value */
     }
     for (n = gnode(h, 0); n < limit; n++) {
-      if (!ttisnil(gval(n)) &&  /* non-empty entry? */
+      if (!ttisnil(gval(n)) && iscleared(gval(n))) {
-          (iscleared(gkey(n), 1) || iscleared(gval(n), 0))) {
         setnilvalue(gval(n));  /* remove value ... */
         removeentry(n);  /* and remove entry from table */
       }
 /*
-** move all unreachable objects that need finalization from list 'finobj'
+** move all unreachable objects (or 'all' objects) that need
-** to list 'tobefnz'
+** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
 */
-void luaC_separateudata (lua_State *L, int all) {
+static void separatetobefnz (lua_State *L, int all) {
   global_State *g = G(L);
   GCObject **p = &g->finobj;
   GCObject *curr;
 void luaC_freeallobjects (lua_State *L) {
   global_State *g = G(L);
   int i;
+  separatetobefnz(L, 1);  /* separate all objects with finalizers */
+  lua_assert(g->finobj == NULL);
   callallpendingfinalizers(L, 0);
-  /* following "white" makes all objects look dead */
+  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
-  g->currentwhite = WHITEBITS;
   g->gckind = KGC_NORMAL;
-  sweepwholelist(L, &g->finobj);
+  sweepwholelist(L, &g->finobj);  /* finalizers can create objs. in 'finobj' */
-  lua_assert(g->finobj == NULL);
   sweepwholelist(L, &g->allgc);
-  lua_assert(g->allgc == NULL);
   for (i = 0; i < g->strt.size; i++)  /* free all string lists */
     sweepwholelist(L, &g->strt.hash[i]);
   lua_assert(g->strt.nuse == 0);
 static void atomic (lua_State *L) {
   global_State *g = G(L);
+  GCObject *origweak, *origall;
   lua_assert(!iswhite(obj2gco(g->mainthread)));
   markobject(g, L);  /* mark running thread */
   /* registry and global metatables may be changed by API */
   /* remark occasional upvalues of (maybe) dead threads */
   remarkupvals(g);
   /* traverse objects caught by write barrier and by 'remarkupvals' */
-  propagateall(g);
+  retraversegrays(g);
-  traverselistofgrays(g, &g->weak);  /* remark weak tables */
-  traverselistofgrays(g, &g->ephemeron);  /* remark ephemeron tables */
-  traverselistofgrays(g, &g->grayagain);  /* remark gray again */
   convergeephemerons(g);
   /* at this point, all strongly accessible objects are marked. */
-  luaC_separateudata(L, 0);  /* separate userdata to be finalized */
+  /* clear values from weak tables, before checking finalizers */
+  clearvalues(g->weak, NULL);
+  clearvalues(g->allweak, NULL);
+  origweak = g->weak; origall = g->allweak;
+  separatetobefnz(L, 0);  /* separate objects to be finalized */
   markbeingfnz(g);  /* mark userdata that will be finalized */
   propagateall(g);  /* remark, to propagate `preserveness' */
   convergeephemerons(g);
-  /* remove collected objects from weak tables */
+  /* at this point, all resurrected objects are marked. */
-  cleartable(g->weak);
+  /* remove dead objects from weak tables */
-  cleartable(g->ephemeron);
+  clearkeys(g->ephemeron, NULL);  /* clear keys from all ephemeron tables */
-  cleartable(g->allweak);
+  clearkeys(g->allweak, NULL);  /* clear keys from all allweak tables */
+  /* clear values from resurrected weak tables */
+  clearvalues(g->weak, origweak);
+  clearvalues(g->allweak, origall);
   g->sweepstrgc = 0;  /* prepare to sweep strings */
   g->gcstate = GCSsweepstring;
   g->currentwhite = cast_byte(otherwhite(g));  /* flip current white */

src/lgc.h+1−5

 /*
-** $Id: lgc.h,v 2.50 2011/01/26 16:30:02 roberto Exp $
+** $Id: lgc.h,v 2.52 2011/10/03 17:54:25 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 #define l_setbit(x,b)		setbits(x, bitmask(b))
 #define resetbit(x,b)		resetbits(x, bitmask(b))
 #define testbit(x,b)		testbits(x, bitmask(b))
-#define set2bits(x,b1,b2)	setbits(x, (bit2mask(b1, b2)))
-#define reset2bits(x,b1,b2)	resetbits(x, (bit2mask(b1, b2)))
 /* Layout for bit use in `marked' field: */
 #define luaC_barrierproto(L,p,c) \
    { if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); }
-LUAI_FUNC void luaC_separateudata (lua_State *L, int all);
 LUAI_FUNC void luaC_freeallobjects (lua_State *L);
 LUAI_FUNC void luaC_step (lua_State *L);
 LUAI_FUNC void luaC_forcestep (lua_State *L);

src/liolib.c+74−30

 /*
-** $Id: liolib.c,v 2.101 2011/06/27 19:42:31 roberto Exp $
+** $Id: liolib.c,v 2.107 2011/11/14 16:55:35 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
+/*
+** POSIX idiosyncrasy!
+** This definition must come before the inclusion of 'stdio.h'; it
+** should not affect non-POSIX systems
+*/
+#if !defined(_FILE_OFFSET_BITS)
+#define _FILE_OFFSET_BITS 64
+#endif
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 /*
-** lua_popen spawns a new process connected to the current one through
+** {======================================================
-** the file streams.
+** lua_popen spawns a new process connected to the current
+** one through the file streams.
+** =======================================================
 */
 #if !defined(lua_popen)	/* { */
 #if defined(LUA_USE_POPEN)	/* { */
 #endif			/* } */
+/* }====================================================== */
+/*
+** {======================================================
+** lua_fseek/lua_ftell: configuration for longer offsets
+** =======================================================
+*/
+#if !defined(lua_fseek)	/* { */
+#if defined(LUA_USE_POSIX)
+#define l_fseek(f,o,w)		fseeko(f,o,w)
+#define l_ftell(f)		ftello(f)
+#define l_seeknum		off_t
+#elif defined(LUA_WIN)
+#define l_fseek(f,o,w)		_fseeki64(f,o,w)
+#define l_ftell(f)		_ftelli64(f)
+#define l_seeknum		__int64
+#else
+#define l_fseek(f,o,w)		fseek(f,o,w)
+#define l_ftell(f)		ftell(f)
+#define l_seeknum		long
+#endif
+#endif			/* } */
+/* }====================================================== */
 #define IO_PREFIX	"_IO_"
 #define IO_INPUT	(IO_PREFIX "input")
 #define IO_OUTPUT	(IO_PREFIX "output")
-typedef struct LStream {
+typedef luaL_Stream LStream;
-  FILE *f;  /* stream */
-  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
-} LStream;
-static void fileerror (lua_State *L, int arg, const char *filename) {
-  lua_pushfstring(L, "%s: %s", filename, strerror(errno));
-  luaL_argerror(L, arg, lua_tostring(L, -1));
-}
 #define tolstream(L)	((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
 }
+static void opencheck (lua_State *L, const char *fname, const char *mode) {
+  LStream *p = newfile(L);
+  p->f = fopen(fname, mode);
+  if (p->f == NULL)
+    luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno));
+}
 static int io_open (lua_State *L) {
   const char *filename = luaL_checkstring(L, 1);
   const char *mode = luaL_optstring(L, 2, "r");
        (mode[i] != '+' || ++i) &&  /* skip if char is '+' */
        (mode[i] != 'b' || ++i) &&  /* skip if char is 'b' */
        (mode[i] == '\0')))
-    return luaL_error(L, "invalid mode " LUA_QL("%s")
+    return luaL_error(L, "invalid mode " LUA_QS
                          " (should match " LUA_QL("[rwa]%%+?b?") ")", mode);
   p->f = fopen(filename, mode);
   return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 static int g_iofile (lua_State *L, const char *f, const char *mode) {
   if (!lua_isnoneornil(L, 1)) {
     const char *filename = lua_tostring(L, 1);
-    if (filename) {
+    if (filename)
-      LStream *p = newfile(L);
+      opencheck(L, filename, mode);
-      p->f = fopen(filename, mode);
-      if (p->f == NULL)
-        fileerror(L, 1, filename);
-    }
     else {
       tofile(L);  /* check that it's a valid file handle */
       lua_pushvalue(L, 1);
   }
   else {  /* open a new file */
     const char *filename = luaL_checkstring(L, 1);
-    LStream *p = newfile(L);
+    opencheck(L, filename, "r");
-    p->f = fopen(filename, "r");
-    if (p->f == NULL)
-      fileerror(L, 1, filename);
     lua_replace(L, 1);  /* put file at index 1 */
     toclose = 1;  /* close it after iteration */
   }
   if (!lua_isnil(L, -n))  /* read at least one value? */
     return n;  /* return them */
   else {  /* first result is nil: EOF or error */
-    if (!lua_isnil(L, -1))  /* is there error information? */
+    if (n > 1) {  /* is there error information? */
-      return luaL_error(L, "%s", lua_tostring(L, -1));  /* error */
+      /* 2nd result is error message */
-    /* else EOF */
+      return luaL_error(L, "%s", lua_tostring(L, -n + 1));
+    }
     if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
       lua_settop(L, 0);
       lua_pushvalue(L, lua_upvalueindex(1));
   static const char *const modenames[] = {"set", "cur", "end", NULL};
   FILE *f = tofile(L);
   int op = luaL_checkoption(L, 2, "cur", modenames);
-  long offset = luaL_optlong(L, 3, 0);
+  lua_Number p3 = luaL_optnumber(L, 3, 0);
-  op = fseek(f, offset, mode[op]);
+  l_seeknum offset = (l_seeknum)p3;
+  luaL_argcheck(L, (lua_Number)offset == p3, 3,
+                  "not an integer in proper range");
+  op = l_fseek(f, offset, mode[op]);
   if (op)
     return luaL_fileresult(L, 0, NULL);  /* error */
   else {
-    lua_pushinteger(L, ftell(f));
+    lua_pushnumber(L, (lua_Number)l_ftell(f));
     return 1;
   }
 }

src/llex.c+40−47

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llex.c,v 2.53 2011/07/08 20:01:38 roberto Exp $	2	** $Id: llex.c,v 2.58 2011/08/15 19:41:58 roberto Exp $
3	** Lexical Analyzer	3	** Lexical Analyzer
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -126,8 +126,10 @@ TString luaX_newstring (LexState ls, const char *str, size_t l) { · 120 unmodified lines
126	TValue o; / entry for `str' */	126	TValue o; / entry for `str' */
127	TString ts = luaS_newlstr(L, str, l); / create new string */	127	TString ts = luaS_newlstr(L, str, l); / create new string */
128	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */	128	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */
129	o = luaH_setstr(L, ls->fs->h, ts);	129	o = luaH_set(L, ls->fs->h, L->top - 1);
130	if (ttisnil(o)) {	130	if (ttisnil(o)) { /* not in use yet? (see 'addK') */
		131	/* boolean value does not need GC barrier;
		132	table has no metatable, so it does not need to invalidate cache */
131	setbvalue(o, 1); /* t[string] = true */	133	setbvalue(o, 1); /* t[string] = true */
132	luaC_checkGC(L);	134	luaC_checkGC(L);
133	}	135	}
@@ -297,39 +299,29 @@ static void escerror (LexState ls, int c, int n, const char *msg) { · 163 unmodified lines
297		299
298		300
299	static int readhexaesc (LexState *ls) {	301	static int readhexaesc (LexState *ls) {
300	int c[3]; /* keep input for error message */	302	int c[3], i; /* keep input for error message */
301	int i = 2; /* at least 'x?' will go to error message */	303	int r = 0; /* result accumulator */
302	c[0] = 'x';	304	c[0] = 'x'; /* for error message */
303	c[1] = next(ls); /* first hexa digit */	305	for (i = 1; i < 3; i++) { /* read two hexa digits */
304	if (lisxdigit(c[1])) {	306	c[i] = next(ls);
305	c[i++] = next(ls); /* second hexa digit */	307	if (!lisxdigit(c[i]))
306	if (lisxdigit(c[2]))	308	escerror(ls, c, i + 1, "hexadecimal digit expected");
307	return (luaO_hexavalue(c[1]) << 4) + luaO_hexavalue(c[2]);	309	r = (r << 4) + luaO_hexavalue(c[i]);
308	/* else go through to error */
309	}	310	}
310	escerror(ls, c, i, "hexadecimal digit expected");	311	return r;
311	return 0; /* to avoid warnings */
312	}	312	}
313		313
314		314
315	static int readdecesc (LexState *ls) {	315	static int readdecesc (LexState *ls) {
316	int c[3], r;	316	int c[3], i;
317	int i = 2; /* at least two chars will be read */	317	int r = 0; /* result accumulator */
318	c[0] = ls->current; /* first char must be a digit */	318	for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */
319	c[1] = next(ls); /* read second char */	319	c[i] = ls->current;
320	r = c[0] - '0'; /* partial result */	320	r = 10*r + c[i] - '0';
321	if (lisdigit(c[1])) {	321	next(ls);
322	c[i++] = next(ls); /* read third char */
323	r = 10r + c[1] - '0'; / update result */
324	if (lisdigit(c[2])) {
325	r = 10r + c[2] - '0'; / update result */
326	if (r > UCHAR_MAX)
327	escerror(ls, c, i, "decimal escape too large");
328	return r;
329	}
330	}	322	}
331	/* else, has read one character that was not a digit */	323	if (r > UCHAR_MAX)
332	zungetc(ls->z); /* return it to input stream */	324	escerror(ls, c, i, "decimal escape too large");
333	return r;	325	return r;
334	}	326	}
335		327
@@ -349,37 +341,38 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 13 unmodified lines
349	int c; /* final character to be saved */	341	int c; /* final character to be saved */
350	next(ls); /* do not save the `\' */	342	next(ls); /* do not save the `\' */
351	switch (ls->current) {	343	switch (ls->current) {
352	case 'a': c = '\a'; break;	344	case 'a': c = '\a'; goto read_save;
353	case 'b': c = '\b'; break;	345	case 'b': c = '\b'; goto read_save;
354	case 'f': c = '\f'; break;	346	case 'f': c = '\f'; goto read_save;
355	case 'n': c = '\n'; break;	347	case 'n': c = '\n'; goto read_save;
356	case 'r': c = '\r'; break;	348	case 'r': c = '\r'; goto read_save;
357	case 't': c = '\t'; break;	349	case 't': c = '\t'; goto read_save;
358	case 'v': c = '\v'; break;	350	case 'v': c = '\v'; goto read_save;
359	case 'x': c = readhexaesc(ls); break;	351	case 'x': c = readhexaesc(ls); goto read_save;
360	case '\n':	352	case '\n': case '\r':
361	case '\r': save(ls, '\n'); inclinenumber(ls); continue;	353	inclinenumber(ls); c = '\n'; goto only_save;
362	case '\\': case '\"': case '\'': c = ls->current; break;	354	case '\\': case '\"': case '\'':
363	case EOZ: continue; /* will raise an error next loop */	355	c = ls->current; goto read_save;
		356	case EOZ: goto no_save; /* will raise an error next loop */
364	case 'z': { /* zap following span of spaces */	357	case 'z': { /* zap following span of spaces */
365	next(ls); /* skip the 'z' */	358	next(ls); /* skip the 'z' */
366	while (lisspace(ls->current)) {	359	while (lisspace(ls->current)) {
367	if (currIsNewline(ls)) inclinenumber(ls);	360	if (currIsNewline(ls)) inclinenumber(ls);
368	else next(ls);	361	else next(ls);
369	}	362	}
370	continue; /* do not save 'c' */	363	goto no_save;
371	}	364	}
372	default: {	365	default: {
373	if (!lisdigit(ls->current))	366	if (!lisdigit(ls->current))
374	escerror(ls, &ls->current, 1, "invalid escape sequence");	367	escerror(ls, &ls->current, 1, "invalid escape sequence");
375	/* digital escape \ddd */	368	/* digital escape \ddd */
376	c = readdecesc(ls);	369	c = readdecesc(ls);
377	break;	370	goto only_save;
378	}	371	}
379	}	372	}
380	next(ls);	373	read_save: next(ls); /* read next character */
381	save(ls, c);	374	only_save: save(ls, c); /* save 'c' */
382	break;	375	no_save: break;
383	}	376	}
384	default:	377	default:
385	save_and_next(ls);	378	save_and_next(ls);

src/llimits.h+16−4

 /*
-** $Id: llimits.h,v 1.90 2011/07/02 15:57:25 roberto Exp $
+** $Id: llimits.h,v 1.93 2011/10/07 20:45:19 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 #define MAX_SIZET	((size_t)(~(size_t)0)-2)
 #define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
-#define MIN_LMEM	((l_mem)~((~(lu_mem)0)>>1))
 #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
 /* to avoid problems with conditions too long */
 #define lua_longassert(c)	{ if (!(c)) lua_assert(0); }
 #else
-#define lua_assert(c)		/* empty */
+#define lua_assert(c)		((void)0)
 #define check_exp(c,e)		(e)
-#define lua_longassert(c)	/* empty */
+#define lua_longassert(c)	((void)0)
 #endif
 /*
 #define cast_uchar(i)	cast(unsigned char, (i))
+/*
+** non-return type
+*/
+#if defined(__GNUC__)
+#define l_noret		void __attribute__((noreturn))
+#elif defined(_MSC_VER)
+#define l_noret		void __declspec(noreturn)
+#else
+#define l_noret		void
+#endif
 /*
 ** maximum depth for nested C calls and syntactical nested non-terminals
 ** in a program. (Value must fit in an unsigned short int.)

src/lmem.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lmem.c,v 1.81 2010/12/20 19:40:07 roberto Exp $	2	** $Id: lmem.c,v 1.82 2011/09/20 19:25:23 roberto Exp $
3	** Interface to Memory Manager	3	** Interface to Memory Manager
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -106,7 +106,7 @@ void luaM_realloc_ (lua_State L, void *block, size_t osize, size_t nsize) { · 100 unmodified lines
106	if ((total % 200) == 0) {	106	if ((total % 200) == 0) {
107	if (f == NULL) f = fopen(TRACEMEM, "w");	107	if (f == NULL) f = fopen(TRACEMEM, "w");
108	fprintf(f, "%lu %u %d %d\n", total,	108	fprintf(f, "%lu %u %d %d\n", total,
109	g->totalbytes, g->GCdebt, g->gcstate * 1000);	109	gettotalbytes(g), g->GCdebt, g->gcstate * 10000);
110	}	110	}
111	}	111	}
112	#endif	112	#endif

src/loadlib.c+71−33

 /*
-** $Id: loadlib.c,v 1.100 2011/07/05 12:49:35 roberto Exp $
+** $Id: loadlib.c,v 1.104 2011/11/10 11:42:58 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
 */
+/*
+** if needed, includes windows header before everything else
+*/
+#if defined(LUA_DL_DLL)
+#include <windows.h>
+#endif
 #include <stdlib.h>
 #include <string.h>
 #endif
+/*
+** LUA_CSUBSEP is the character that replaces dots in submodule names
+** when searching for a C loader.
+** LUA_LSUBSEP is the character that replaces dots in submodule names
+** when searching for a Lua loader.
+*/
+#if !defined(LUA_CSUBSEP)
+#define LUA_CSUBSEP		LUA_DIRSEP
+#endif
+#if !defined(LUA_LSUBSEP)
+#define LUA_LSUBSEP		LUA_DIRSEP
+#endif
 /* prefix for open functions in C libraries */
 #define LUA_POF		"luaopen_"
 ** =======================================================================
 */
-#include <windows.h>
 #undef setprogdir
 /*
 static const char *searchpath (lua_State *L, const char *name,
                                              const char *path,
-                                             const char *sep) {
+                                             const char *sep,
+                                             const char *dirsep) {
+  luaL_Buffer msg;  /* to build error message */
+  luaL_buffinit(L, &msg);
   if (*sep != '\0')  /* non-empty separator? */
-    name = luaL_gsub(L, name, sep, LUA_DIRSEP);  /* replace it by proper one */
+    name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */
-  lua_pushliteral(L, "");  /* error accumulator */
   while ((path = pushnexttemplate(L, path)) != NULL) {
     const char *filename = luaL_gsub(L, lua_tostring(L, -1),
                                      LUA_PATH_MARK, name);
       return filename;  /* return that file name */
     lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
     lua_remove(L, -2);  /* remove file name */
-    lua_concat(L, 2);  /* add entry to possible error message */
+    luaL_addvalue(&msg);  /* concatenate error msg. entry */
   }
+  luaL_pushresult(&msg);  /* create error message */
   return NULL;  /* not found */
 }
 static int ll_searchpath (lua_State *L) {
   const char *f = searchpath(L, luaL_checkstring(L, 1),
                                 luaL_checkstring(L, 2),
-                                luaL_optstring(L, 3, "."));
+                                luaL_optstring(L, 3, "."),
+                                luaL_optstring(L, 4, LUA_DIRSEP));
   if (f != NULL) return 1;
   else {  /* error message is on top of the stack */
     lua_pushnil(L);
 static const char *findfile (lua_State *L, const char *name,
-                                           const char *pname) {
+                                           const char *pname,
+                                           const char *dirsep) {
   const char *path;
   lua_getfield(L, lua_upvalueindex(1), pname);
   path = lua_tostring(L, -1);
   if (path == NULL)
     luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
-  return searchpath(L, name, path, ".");
+  return searchpath(L, name, path, ".", dirsep);
 }
 static int searcher_Lua (lua_State *L) {
   const char *filename;
   const char *name = luaL_checkstring(L, 1);
-  filename = findfile(L, name, "path");
+  filename = findfile(L, name, "path", LUA_LSUBSEP);
   if (filename == NULL) return 1;  /* module not found in this path */
   return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
 }
 static int searcher_C (lua_State *L) {
   const char *name = luaL_checkstring(L, 1);
-  const char *filename = findfile(L, name, "cpath");
+  const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
   if (filename == NULL) return 1;  /* module not found in this path */
   return checkload(L, (loadfunc(L, filename, name) == 0), filename);
 }
   int stat;
   if (p == NULL) return 0;  /* is root */
   lua_pushlstring(L, name, p - name);
-  filename = findfile(L, lua_tostring(L, -1), "cpath");
+  filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
   if (filename == NULL) return 1;  /* root not found */
   if ((stat = loadfunc(L, filename, name)) != 0) {
     if (stat != ERRFUNC)
 }
-static int ll_require (lua_State *L) {
+static void findloader (lua_State *L, const char *name) {
-  const char *name = luaL_checkstring(L, 1);
   int i;
-  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
+  luaL_Buffer msg;  /* to build error message */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+  luaL_buffinit(L, &msg);
-  lua_getfield(L, 2, name);
+  lua_getfield(L, lua_upvalueindex(1), "searchers");  /* will be at index 3 */
-  if (lua_toboolean(L, -1))  /* is it there? */
+  if (!lua_istable(L, 3))
-    return 1;  /* package is already loaded */
-  /* else must load it; iterate over available seachers to find a loader */
-  lua_getfield(L, lua_upvalueindex(1), "searchers");
-  if (!lua_istable(L, -1))
     luaL_error(L, LUA_QL("package.searchers") " must be a table");
-  lua_pushliteral(L, "");  /* error message accumulator */
+  /*  iterate over available seachers to find a loader */
-  for (i=1; ; i++) {
+  for (i = 1; ; i++) {
-    lua_rawgeti(L, -2, i);  /* get a seacher */
+    lua_rawgeti(L, 3, i);  /* get a seacher */
-    if (lua_isnil(L, -1))  /* no more searchers? */
+    if (lua_isnil(L, -1)) {  /* no more searchers? */
+      lua_pop(L, 1);  /* remove nil */
+      luaL_pushresult(&msg);  /* create error message */
       luaL_error(L, "module " LUA_QS " not found:%s",
-                    name, lua_tostring(L, -2));
+                    name, lua_tostring(L, -1));
+    }
     lua_pushstring(L, name);
     lua_call(L, 1, 2);  /* call it */
     if (lua_isfunction(L, -2))  /* did it find a loader? */
-      break;  /* module loader found */
+      return;  /* module loader found */
     else if (lua_isstring(L, -2)) {  /* searcher returned error message? */
       lua_pop(L, 1);  /* remove extra return */
-      lua_concat(L, 2);  /* accumulate error message */
+      luaL_addvalue(&msg);  /* concatenate error message */
     }
     else
       lua_pop(L, 2);  /* remove both returns */
   }
+}
+static int ll_require (lua_State *L) {
+  const char *name = luaL_checkstring(L, 1);
+  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
+  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+  lua_getfield(L, 2, name);  /* _LOADED[name] */
+  if (lua_toboolean(L, -1))  /* is it there? */
+    return 1;  /* package is already loaded */
+  /* else must load package */
+  lua_pop(L, 1);  /* remove 'getfield' result */
+  findloader(L, name);
   lua_pushstring(L, name);  /* pass name as argument to module loader */
   lua_insert(L, -2);  /* name is 1st argument (before search data) */
   lua_call(L, 2, 1);  /* run loader to load module */
 static void dooptions (lua_State *L, int n) {
   int i;
   for (i = 2; i <= n; i++) {
-    lua_pushvalue(L, i);  /* get option (a function) */
+    if (lua_isfunction(L, i)) {  /* avoid 'calling' extra info. */
-    lua_pushvalue(L, -2);  /* module */
+      lua_pushvalue(L, i);  /* get option (a function) */
-    lua_call(L, 1, 0);
+      lua_pushvalue(L, -2);  /* module */
+      lua_call(L, 1, 0);
+    }
   }
 }

src/lobject.c+6−4

 /*
-** $Id: lobject.c,v 2.52 2011/06/24 12:25:02 roberto Exp $
+** $Id: lobject.c,v 2.53 2011/07/27 12:13:08 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
 static lua_Number readhexa (const char **s, lua_Number r, int *count) {
-  while (lisxdigit(cast_uchar(**s))) {  /* read integer part */
+  for (; lisxdigit(cast_uchar(**s)); (*s)++) {  /* read integer part */
-    r = (r * 16.0) + cast_num(luaO_hexavalue(cast_uchar(*(*s)++)));
+    r = (r * 16.0) + cast_num(luaO_hexavalue(cast_uchar(**s)));
     (*count)++;
   }
   return r;
 int luaO_str2d (const char *s, size_t len, lua_Number *result) {
   char *endptr;
-  if (strpbrk(s, "xX"))  /* hexa? */
+  if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
+    return 0;
+  else if (strpbrk(s, "xX"))  /* hexa? */
     *result = lua_strx2number(s, &endptr);
   else
     *result = lua_str2number(s, &endptr);

src/lobject.h+46−22

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lobject.h,v 2.61 2011/07/04 20:29:02 roberto Exp $	2	** $Id: lobject.h,v 2.64 2011/10/31 17:48:22 roberto Exp $
3	** Type definitions for Lua objects	3	** Type definitions for Lua objects
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -132,7 +132,7 @@ typedef struct lua_TValue TValue; · 126 unmodified lines
132	#define ttislcf(o) checktag((o), LUA_TLCF)	132	#define ttislcf(o) checktag((o), LUA_TLCF)
133	#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA))	133	#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA))
134	#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD))	134	#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD))
135	#define ttisdeadkey(o) checktag((o), ctb(LUA_TDEADKEY))	135	#define ttisdeadkey(o) checktag((o), LUA_TDEADKEY)
136		136
137	#define ttisequal(o1,o2) (rttype(o1) == rttype(o2))	137	#define ttisequal(o1,o2) (rttype(o1) == rttype(o2))
138		138
@@ -151,6 +151,8 @@ typedef struct lua_TValue TValue; · 12 unmodified lines
151	#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h)	151	#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h)
152	#define bvalue(o) check_exp(ttisboolean(o), val_(o).b)	152	#define bvalue(o) check_exp(ttisboolean(o), val_(o).b)
153	#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th)	153	#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th)
		154	/* a dead value may get the 'gc' field, but cannot access its contents */
		155	#define deadvalue(o) check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
154		156
155	#define l_isfalse(o) (ttisnil(o) \|\| (ttisboolean(o) && bvalue(o) == 0))	157	#define l_isfalse(o) (ttisnil(o) \|\| (ttisboolean(o) && bvalue(o) == 0))
156		158
@@ -224,7 +226,7 @@ typedef struct lua_TValue TValue; · 67 unmodified lines
224	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TPROTO)); \	226	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TPROTO)); \
225	checkliveness(G(L),io); }	227	checkliveness(G(L),io); }
226		228
227	#define setdeadvalue(obj) settt_(obj, ctb(LUA_TDEADKEY))	229	#define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY)
228		230
229		231
230		232
@@ -262,51 +264,73 @@ typedef struct lua_TValue TValue; · 31 unmodified lines
262	** =======================================================	264	** =======================================================
263	*/	265	*/
264		266
265	#if defined(LUA_NANTRICKLE) \|\| defined(LUA_NANTRICKBE)	267	#if defined(LUA_NANTRICK) \
		268	\|\| defined(LUA_NANTRICK_LE) \
		269	\|\| defined(LUA_NANTRICK_BE)
266		270
267	/*	271	/*
268	** numbers are represented in the 'd_' field. All other values have the	272	** numbers are represented in the 'd_' field. All other values have the
269	** value (NNMARK \| tag) in 'tt_'. A number with such pattern would be	273	** value (NNMARK \| tag) in 'tt__'. A number with such pattern would be
270	** a "signaled NaN", which is never generated by regular operations by	274	** a "signaled NaN", which is never generated by regular operations by
271	** the CPU (nor by 'strtod')	275	** the CPU (nor by 'strtod')
272	*/	276	*/
273	#if !defined(NNMARK)	277	#if !defined(NNMARK)
274	#define NNMARK 0x7FF7A500	278	#define NNMARK 0x7FF7A500
		279	#define NNMASK 0x7FFFFF00
275	#endif	280	#endif
276		281
277	#undef TValuefields	282	#undef TValuefields
278	#undef NILCONSTANT	283	#undef NILCONSTANT
279	#if defined(LUA_NANTRICKLE)	284
		285	#if defined(LUA_NANTRICK_LE)
		286
280	/* little endian */	287	/* little endian */
281	#define TValuefields \	288	#define TValuefields \
282	union { struct { Value v_; int tt_; } i; double d_; } u	289	union { struct { Value v__; int tt__; } i; double d__; } u
283	#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}}	290	#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}}
284	#else	291	/* field-access macros */
		292	#define v_(o) ((o)->u.i.v__)
		293	#define d_(o) ((o)->u.d__)
		294	#define tt_(o) ((o)->u.i.tt__)
		295
		296	#elif defined(LUA_NANTRICK_BE)
		297
285	/* big endian */	298	/* big endian */
286	#define TValuefields \	299	#define TValuefields \
287	union { struct { int tt_; Value v_; } i; double d_; } u	300	union { struct { int tt__; Value v__; } i; double d__; } u
288	#define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}}	301	#define NILCONSTANT {{tag2tt(LUA_TNIL), {NULL}}}
		302	/* field-access macros */
		303	#define v_(o) ((o)->u.i.v__)
		304	#define d_(o) ((o)->u.d__)
		305	#define tt_(o) ((o)->u.i.tt__)
		306
		307	#elif !defined(TValuefields)
		308	#error option 'LUA_NANTRICK' needs declaration for 'TValuefields'
		309
289	#endif	310	#endif
290		311
		312
		313	/* correspondence with standard representation */
		314	#undef val_
		315	#define val_(o) v_(o)
		316	#undef num_
		317	#define num_(o) d_(o)
		318
		319
291	#undef numfield	320	#undef numfield
292	#define numfield /* no such field; numbers are the entire struct */	321	#define numfield /* no such field; numbers are the entire struct */
293		322
294	/* basic check to distinguish numbers from non-numbers */	323	/* basic check to distinguish numbers from non-numbers */
295	#undef ttisnumber	324	#undef ttisnumber
296	#define ttisnumber(o) (((o)->u.i.tt_ & 0x7fffff00) != NNMARK)	325	#define ttisnumber(o) ((tt_(o) & NNMASK) != NNMARK)
297		326
298	#define tag2tt(t) (NNMARK \| (t))	327	#define tag2tt(t) (NNMARK \| (t))
299		328
300	#undef val_
301	#define val_(o) ((o)->u.i.v_)
302	#undef num_
303	#define num_(o) ((o)->u.d_)
304
305	#undef rttype	329	#undef rttype
306	#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : (o)->u.i.tt_ & 0xff)	330	#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff)
307		331
308	#undef settt_	332	#undef settt_
309	#define settt_(o,t) ((o)->u.i.tt_=tag2tt(t))	333	#define settt_(o,t) (tt_(o) = tag2tt(t))
310		334
311	#undef setnvalue	335	#undef setnvalue
312	#define setnvalue(obj,x) \	336	#define setnvalue(obj,x) \
@@ -324,11 +348,11 @@ typedef struct lua_TValue TValue; · 11 unmodified lines
324	*/	348	*/
325		349
326	#undef checktag	350	#undef checktag
327	#define checktag(o,t) ((o)->u.i.tt_ == tag2tt(t))	351	#define checktag(o,t) (tt_(o) == tag2tt(t))
328		352
329	#undef ttisequal	353	#undef ttisequal
330	#define ttisequal(o1,o2) \	354	#define ttisequal(o1,o2) \
331	(ttisnumber(o1) ? ttisnumber(o2) : ((o1)->u.i.tt_ == (o2)->u.i.tt_))	355	(ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))
332		356
333		357
334		358
@@ -435,11 +459,11 @@ typedef struct Proto { · 100 unmodified lines
435	TValue k; / constants used by the function */	459	TValue k; / constants used by the function */
436	Instruction *code;	460	Instruction *code;
437	struct Proto *p; / functions defined inside the function */	461	struct Proto *p; / functions defined inside the function */
438	int lineinfo; / map from opcodes to source lines */	462	int lineinfo; / map from opcodes to source lines (debug information) */
439	LocVar locvars; / information about local variables */	463	LocVar locvars; / information about local variables (debug information) */
440	Upvaldesc upvalues; / upvalue information */	464	Upvaldesc upvalues; / upvalue information */
441	union Closure cache; / last created closure with this prototype */	465	union Closure cache; / last created closure with this prototype */
442	TString *source;	466	TString source; / used for debug information */
443	int sizeupvalues; /* size of 'upvalues' */	467	int sizeupvalues; /* size of 'upvalues' */
444	int sizek; /* size of `k' */	468	int sizek; /* size of `k' */
445	int sizecode;	469	int sizecode;

src/lopcodes.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lopcodes.h,v 1.141 2011/04/19 16:22:13 roberto Exp $	2	** $Id: lopcodes.h,v 1.142 2011/07/15 12:50:29 roberto Exp $
3	** Opcodes for Lua virtual machine	3	** Opcodes for Lua virtual machine
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -196,7 +196,7 @@ OP_LEN,/* A B R(A) := length of R(B) */ · 190 unmodified lines
196		196
197	OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */	197	OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
198		198
199	OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A) + 1 */	199	OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A) + 1 */
200	OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */	200	OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */
201	OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */	201	OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */
202	OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */	202	OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */

src/lparser.c+90−70

 /*
-** $Id: lparser.c,v 2.113 2011/07/02 15:58:14 roberto Exp $
+** $Id: lparser.c,v 2.122 2011/10/31 17:46:04 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 */
 typedef struct BlockCnt {
   struct BlockCnt *previous;  /* chain */
-  int firstlabel;  /* index of first label in this block */
+  short firstlabel;  /* index of first label in this block */
-  int firstgoto;  /* index of first pending goto in this block */
+  short firstgoto;  /* index of first pending goto in this block */
   lu_byte nactvar;  /* # active locals outside the block */
   lu_byte upval;  /* true if some variable in the block is an upvalue */
   lu_byte isloop;  /* true if `block' is a loop */
 static void errorlimit (FuncState *fs, int limit, const char *what) {
+  lua_State *L = fs->ls->L;
   const char *msg;
   int line = fs->f->linedefined;
   const char *where = (line == 0)
                       ? "main function"
-                      : luaO_pushfstring(fs->L, "function at line %d", line);
+                      : luaO_pushfstring(L, "function at line %d", line);
-  msg = luaO_pushfstring(fs->L, "too many %s (limit is %d) in %s",
+  msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
-                                what, limit, where);
+                             what, limit, where);
   luaX_syntaxerror(fs->ls, msg);
 }
                   MAXVARS, "local variables");
   luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1,
                   dyd->actvar.size, Vardesc, MAX_INT, "local variables");
-  dyd->actvar.arr[dyd->actvar.n++].idx = cast(unsigned short, reg);
+  dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg);
 }
   Proto *f = fs->f;
   int oldsize = f->sizeupvalues;
   checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
-  luaM_growvector(fs->L, f->upvalues, fs->nups, f->sizeupvalues,
+  luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
                   Upvaldesc, MAXUPVAL, "upvalues");
   while (oldsize < f->sizeupvalues) f->upvalues[oldsize++].name = NULL;
   f->upvalues[fs->nups].instack = (v->k == VLOCAL);
   f->upvalues[fs->nups].idx = cast_byte(v->u.info);
   f->upvalues[fs->nups].name = name;
-  luaC_objbarrier(fs->L, f, name);
+  luaC_objbarrier(fs->ls->L, f, name);
   return fs->nups++;
 }
 static void enterlevel (LexState *ls) {
-  global_State *g = G(ls->L);
+  lua_State *L = ls->L;
-  ++g->nCcalls;
+  ++L->nCcalls;
-  checklimit(ls->fs, g->nCcalls, LUAI_MAXCCALLS, "syntax levels");
+  checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "syntax levels");
 }
-#define leavelevel(ls)	(G((ls)->L)->nCcalls--)
+#define leavelevel(ls)	((ls)->L->nCcalls--)
 static void closegoto (LexState *ls, int g, Labeldesc *label) {
   Labeldesc *gt = &gl->arr[g];
   lua_assert(eqstr(gt->name, label->name));
   if (gt->nactvar < label->nactvar) {
+    TString *vname = getlocvar(fs, gt->nactvar)->varname;
     const char *msg = luaO_pushfstring(ls->L,
       "<goto %s> at line %d jumps into the scope of local " LUA_QS,
-      getstr(gt->name), gt->line, getstr(getlocvar(fs, gt->nactvar)->varname));
+      getstr(gt->name), gt->line, getstr(vname));
     semerror(ls, msg);
   }
   luaK_patchlist(fs, gt->pc, label->pc);
 static int newlabelentry (LexState *ls, Labellist *l, TString *name,
                           int line, int pc) {
   int n = l->n;
-  luaM_growvector(ls->L, l->arr, n, l->size, Labeldesc, MAX_INT, "labels");
+  luaM_growvector(ls->L, l->arr, n, l->size,
+                  Labeldesc, SHRT_MAX, "labels/gotos");
   l->arr[n].name = name;
   l->arr[n].line = line;
   l->arr[n].nactvar = ls->fs->nactvar;
   int i = bl->firstgoto;
   Labellist *gl = &fs->ls->dyd->gt;
   /* correct pending gotos to current block and try to close it
      with visible labels */
   while (i < gl->n) {
     Labeldesc *gt = &gl->arr[i];
     if (gt->nactvar > bl->nactvar) {
   Proto *f;
   fs->prev = ls->fs;  /* linked list of funcstates */
   fs->ls = ls;
-  fs->L = L;
   ls->fs = fs;
   fs->pc = 0;
   fs->lasttarget = 0;
 ** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
 ** where `binop' is any binary operator with a priority higher than `limit'
 */
-static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
+static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
   BinOpr op;
   UnOpr uop;
   enterlevel(ls);
 /*
-** check whether, in an assignment to a local variable, the local variable
+** check whether, in an assignment to an upvalue/local variable, the
-** is needed in a previous assignment (to a table). If so, save original
+** upvalue/local variable is begin used in a previous assignment to a
-** local value in a safe place and use this safe copy in the previous
+** table. If so, save original upvalue/local value in a safe place and
-** assignment.
+** use this safe copy in the previous assignment.
 */
 static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
   FuncState *fs = ls->fs;
   int extra = fs->freereg;  /* eventual position to save local variable */
   int conflict = 0;
-  for (; lh; lh = lh->prev) {
+  for (; lh; lh = lh->prev) {  /* check all previous assignments */
-    /* conflict in table 't'? */
+    if (lh->v.k == VINDEXED) {  /* assigning to a table? */
-    if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
+      /* table is the upvalue/local being assigned now? */
-      conflict = 1;
+      if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
-      lh->v.u.ind.vt = VLOCAL;
+        conflict = 1;
-      lh->v.u.ind.t = extra;  /* previous assignment will use safe copy */
+        lh->v.u.ind.vt = VLOCAL;
-    }
+        lh->v.u.ind.t = extra;  /* previous assignment will use safe copy */
-    /* conflict in index 'idx'? */
+      }
-    if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
+      /* index is the local being assigned? (index cannot be upvalue) */
-      conflict = 1;
+      if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
-      lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
+        conflict = 1;
+        lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
+      }
     }
   }
   if (conflict) {
+    /* copy upvalue/local value to a temporary (in position 'extra') */
     OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
-    luaK_codeABC(fs, op, fs->freereg, v->u.info, 0);  /* make copy */
+    luaK_codeABC(fs, op, extra, v->u.info, 0);
     luaK_reserveregs(fs, 1);
   }
 }
     primaryexp(ls, &nv.v);
     if (nv.v.k != VINDEXED)
       check_conflict(ls, lh, &nv.v);
-    checklimit(ls->fs, nvars, LUAI_MAXCCALLS - G(ls->L)->nCcalls,
+    checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
                     "variable names");
     assignment(ls, &nv, nvars+1);
   }
 }
-static void gotostat (LexState *ls, TString *label, int line) {
+static void gotostat (LexState *ls, int pc) {
-  /* create new entry for this goto */
+  int line = ls->linenumber;
-  int g = newlabelentry(ls, &ls->dyd->gt, label, line, luaK_jump(ls->fs));
+  TString *label;
-  findlabel(ls, g);
+  int g;
+  if (testnext(ls, TK_GOTO))
+    label = str_checkname(ls);
+  else {
+    luaX_next(ls);  /* skip break */
+    label = luaS_new(ls->L, "break");
+  }
+  g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
+  findlabel(ls, g);  /* close it if label already defined */
 }
   int i;
   for (i = fs->bl->firstlabel; i < ll->n; i++) {
     if (eqstr(label, ll->arr[i].name)) {
       const char *msg = luaO_pushfstring(fs->ls->L,
                           "label " LUA_QS " already defined on line %d",
                           getstr(label), ll->arr[i].line);
       semerror(fs->ls, msg);
 }
-static int test_then_block (LexState *ls) {
+static void test_then_block (LexState *ls, int *escapelist) {
   /* test_then_block -> [IF | ELSEIF] cond THEN block */
-  int condexit;
+  BlockCnt bl;
+  FuncState *fs = ls->fs;
+  expdesc v;
+  int jf;  /* instruction to skip 'then' code (if condition is false) */
   luaX_next(ls);  /* skip IF or ELSEIF */
-  condexit = cond(ls);
+  expr(ls, &v);  /* read condition */
   checknext(ls, TK_THEN);
-  block(ls);  /* `then' part */
+  if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
-  return condexit;
+    luaK_goiffalse(ls->fs, &v);  /* will jump to label if condition is true */
+    enterblock(fs, &bl, 0);  /* must enter block before 'goto' */
+    gotostat(ls, v.t);  /* handle goto/break */
+    if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */
+      leaveblock(fs);
+      return;  /* and that is it */
+    }
+    else  /* must skip over 'then' part if condition is false */
+      jf = luaK_jump(fs);
+  }
+  else {  /* regular case (not goto/break) */
+    luaK_goiftrue(ls->fs, &v);  /* skip over block if condition is false */
+    enterblock(fs, &bl, 0);
+    jf = v.f;
+  }
+  statlist(ls);  /* `then' part */
+  leaveblock(fs);
+  if (ls->t.token == TK_ELSE ||
+      ls->t.token == TK_ELSEIF)  /* followed by 'else'/'elseif'? */
+    luaK_concat(fs, escapelist, luaK_jump(fs));  /* must jump over it */
+  luaK_patchtohere(fs, jf);
 }
 static void ifstat (LexState *ls, int line) {
   /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
   FuncState *fs = ls->fs;
-  int flist;
+  int escapelist = NO_JUMP;  /* exit list for finished parts */
-  int escapelist = NO_JUMP;
+  test_then_block(ls, &escapelist);  /* IF cond THEN block */
-  flist = test_then_block(ls);  /* IF cond THEN block */
+  while (ls->t.token == TK_ELSEIF)
-  while (ls->t.token == TK_ELSEIF) {
+    test_then_block(ls, &escapelist);  /* ELSEIF cond THEN block */
-    luaK_concat(fs, &escapelist, luaK_jump(fs));
+  if (testnext(ls, TK_ELSE))
-    luaK_patchtohere(fs, flist);
-    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
-  }
-  if (ls->t.token == TK_ELSE) {
-    luaK_concat(fs, &escapelist, luaK_jump(fs));
-    luaK_patchtohere(fs, flist);
-    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
     block(ls);  /* `else' part */
-  }
-  else
-    luaK_concat(fs, &escapelist, flist);
-  luaK_patchtohere(fs, escapelist);
   check_match(ls, TK_END, TK_IF, line);
+  luaK_patchtohere(fs, escapelist);  /* patch escape list to 'if' end */
 }
       retstat(ls);
       break;
     }
-    case TK_BREAK: {  /* stat -> breakstat */
+    case TK_BREAK:   /* stat -> breakstat */
-      luaX_next(ls);  /* skip BREAK */
-      /* code it as "goto 'break'" */
-      gotostat(ls, luaS_new(ls->L, "break"), line);
-      break;
-    }
     case TK_GOTO: {  /* stat -> 'goto' NAME */
-      luaX_next(ls);  /* skip GOTO */
+      gotostat(ls, luaK_jump(ls->fs));
-      gotostat(ls, str_checkname(ls), line);
       break;
     }
     default: {  /* stat -> func | assignment */
   close_func(&lexstate);
   L->top--;  /* pop name */
   lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
-  return funcstate.f;
   /* all scopes should be correctly finished */
   lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
+  return funcstate.f;
 }

src/lparser.h+6−7

 /*
-** $Id: lparser.h,v 1.68 2011/02/23 13:13:10 roberto Exp $
+** $Id: lparser.h,v 1.69 2011/07/27 18:09:01 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 /* description of active local variable */
 typedef struct Vardesc {
-  unsigned short idx;  /* variable index in stack */
+  short idx;  /* variable index in stack */
 } Vardesc;
   Table *h;  /* table to find (and reuse) elements in `k' */
   struct FuncState *prev;  /* enclosing function */
   struct LexState *ls;  /* lexical state */
-  struct lua_State *L;  /* copy of the Lua state */
   struct BlockCnt *bl;  /* chain of current blocks */
   int pc;  /* next position to code (equivalent to `ncode') */
-  int lasttarget;   /* `pc' of last `jump target' */
+  int lasttarget;   /* 'label' of last 'jump label' */
   int jpc;  /* list of pending jumps to `pc' */
-  int freereg;  /* first free register */
   int nk;  /* number of elements in `k' */
   int np;  /* number of elements in `p' */
-  int firstlocal;  /* index of first local var of this function */
+  int firstlocal;  /* index of first local var (in Dyndata array) */
-  short nlocvars;  /* number of elements in `locvars' */
+  short nlocvars;  /* number of elements in 'f->locvars' */
   lu_byte nactvar;  /* number of active local variables */
   lu_byte nups;  /* number of upvalues */
+  lu_byte freereg;  /* first free register */
 } FuncState;

src/lstate.c+5−8

 /*
-** $Id: lstate.c,v 2.89 2010/12/20 19:40:07 roberto Exp $
+** $Id: lstate.c,v 2.92 2011/10/03 17:54:25 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
   luaH_resize(L, registry, LUA_RIDX_LAST, 0);
   /* registry[LUA_RIDX_MAINTHREAD] = L */
   setthvalue(L, &mt, L);
-  setobj2t(L, luaH_setint(L, registry, LUA_RIDX_MAINTHREAD), &mt);
+  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
   /* registry[LUA_RIDX_GLOBALS] = table of globals */
   sethvalue(L, &mt, luaH_new(L));
-  setobj2t(L, luaH_setint(L, registry, LUA_RIDX_GLOBALS), &mt);
+  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
 }
   L->ci = NULL;
   L->stacksize = 0;
   L->errorJmp = NULL;
+  L->nCcalls = 0;
   L->hook = NULL;
   L->hookmask = 0;
   L->basehookcount = 0;
   luaZ_freebuffer(L, &g->buff);
   freestack(L);
   lua_assert(gettotalbytes(g) == sizeof(LG));
-  (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);
+  (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);  /* free main block */
 }
   g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
   L->marked = luaC_white(g);
   g->gckind = KGC_NORMAL;
-  g->nCcalls = 0;
   preinit_state(L, g);
   g->frealloc = f;
   g->ud = ud;
 LUA_API void lua_close (lua_State *L) {
   L = G(L)->mainthread;  /* only the main thread can be closed */
   lua_lock(L);
-  luaF_close(L, L->stack);  /* close all upvalues for this thread */
-  luaC_separateudata(L, 1);  /* separate all udata with GC metamethods */
-  lua_assert(L->next == NULL);
   luai_userstateclose(L);
   close_state(L);
 }

src/lstate.h+2−4

 /*
-** $Id: lstate.h,v 2.72 2011/06/02 19:31:40 roberto Exp $
+** $Id: lstate.h,v 2.74 2011/09/30 12:45:07 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 #define EXTRA_STACK   5
-#define BASIC_CI_SIZE           8
 #define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
   lu_mem lastmajormem;  /* memory in use after last major collection */
   stringtable strt;  /* hash table for strings */
   TValue l_registry;
-  unsigned short nCcalls;  /* number of nested C calls */
   lu_byte currentwhite;
   lu_byte gcstate;  /* state of garbage collector */
   lu_byte gckind;  /* kind of GC running */
   StkId stack;  /* stack base */
   int stacksize;
   unsigned short nny;  /* number of non-yieldable calls in stack */
+  unsigned short nCcalls;  /* number of nested C calls */
   lu_byte hookmask;
   lu_byte allowhook;
   int basehookcount;

src/lstrlib.c+15−6

 /*
-** $Id: lstrlib.c,v 1.170 2011/06/28 17:13:52 roberto Exp $
+** $Id: lstrlib.c,v 1.172 2011/10/25 12:01:20 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
   if (pose > l) pose = l;
   if (posi > pose) return 0;  /* empty interval; return no values */
   n = (int)(pose -  posi + 1);
-  if (posi + n <= pose)  /* overflow? */
+  if (posi + n <= pose)  /* (size_t -> int) overflow? */
     return luaL_error(L, "string slice too long");
   luaL_checkstack(L, n, "string slice too long");
   for (i=0; i<n; i++)
   char *p = luaL_buffinitsize(L, &b, n);
   for (i=1; i<=n; i++) {
     int c = luaL_checkint(L, i);
-    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
+    luaL_argcheck(L, uchar(c) == c, i, "value out of range");
     p[i - 1] = uchar(c);
   }
   luaL_pushresultsize(&b, n);
           nb = sprintf(buff, form, luaL_checkint(L, arg));
           break;
         }
-        case 'd':  case 'i':
+        case 'd':  case 'i': {
+          lua_Number n = luaL_checknumber(L, arg);
+          LUA_INTFRM_T r = (LUA_INTFRM_T)n;
+          luaL_argcheck(L, (lua_Number)r == n, arg,
+                        "not an integer in proper range");
+          addlenmod(form, LUA_INTFRMLEN);
+          nb = sprintf(buff, form, r);
+          break;
+        }
         case 'o':  case 'u':  case 'x':  case 'X': {
           lua_Number n = luaL_checknumber(L, arg);
-          LUA_INTFRM_T r = (n < 0) ? (LUA_INTFRM_T)n :
+          unsigned LUA_INTFRM_T r = (unsigned LUA_INTFRM_T)n;
-                                     (LUA_INTFRM_T)(unsigned LUA_INTFRM_T)n;
+          luaL_argcheck(L, (lua_Number)r == n, arg,
+                        "not a non-negative integer in proper range");
           addlenmod(form, LUA_INTFRMLEN);
           nb = sprintf(buff, form, r);
           break;

src/ltable.c+25−36

 /*
-** $Id: ltable.c,v 2.60 2011/06/16 14:14:31 roberto Exp $
+** $Id: ltable.c,v 2.65 2011/09/30 12:45:27 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define hashpointer(t,p)	hashmod(t, IntPoint(p))
-/*
-** number of ints inside a lua_Number
-*/
-#define numints		cast_int(sizeof(lua_Number)/sizeof(int))
 #define dummynode		(&dummynode_)
 #define isdummy(n)		((n) == dummynode)
       /* key may be dead already, but it is ok to use it in `next' */
       if (luaV_rawequalobj(gkey(n), key) ||
             (ttisdeadkey(gkey(n)) && iscollectable(key) &&
-             gcvalue(gkey(n)) == gcvalue(key))) {
+             deadvalue(gkey(n)) == gcvalue(key))) {
         i = cast_int(n - gnode(t, 0));  /* key index in hash table */
         /* hash elements are numbered after array ones */
         return i + t->sizearray;
     /* re-insert elements from vanishing slice */
     for (i=nasize; i<oldasize; i++) {
       if (!ttisnil(&t->array[i]))
-        setobjt2t(L, luaH_setint(L, t, i+1), &t->array[i]);
+        luaH_setint(L, t, i + 1, &t->array[i]);
     }
     /* shrink array */
     luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
   /* re-insert elements from hash part */
   for (i = twoto(oldhsize) - 1; i >= 0; i--) {
     Node *old = nold+i;
-    if (!ttisnil(gval(old)))
+    if (!ttisnil(gval(old))) {
+      /* doesn't need barrier/invalidate cache, as entry was
+         already present in the table */
       setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
+    }
   }
   if (!isdummy(nold))
     luaM_freearray(L, nold, twoto(oldhsize));  /* free old array */
 ** put new key in its main position; otherwise (colliding node is in its main
 ** position), new key goes to an empty position.
 */
-static TValue *newkey (lua_State *L, Table *t, const TValue *key) {
+TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
-  Node *mp = mainposition(t, key);
+  Node *mp;
+  if (ttisnil(key)) luaG_runerror(L, "table index is nil");
+  else if (ttisnumber(key) && luai_numisnan(L, nvalue(key)))
+    luaG_runerror(L, "table index is NaN");
+  mp = mainposition(t, key);
   if (!ttisnil(gval(mp)) || isdummy(mp)) {  /* main position is taken? */
     Node *othern;
     Node *n = getfreepos(t);  /* get a free place */
     if (n == NULL) {  /* cannot find a free place? */
       rehash(L, t, key);  /* grow table */
-      return luaH_set(L, t, key);  /* re-insert key into grown table */
+      /* whatever called 'newkey' take care of TM cache and GC barrier */
+      return luaH_set(L, t, key);  /* insert key into grown table */
     }
     lua_assert(!isdummy(n));
     othern = mainposition(t, gkey(mp));
 }
+/*
+** beware: when using this function you probably need to check a GC
+** barrier and invalidate the TM cache.
+*/
 TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
   const TValue *p = luaH_get(t, key);
-  t->flags = 0;
   if (p != luaO_nilobject)
     return cast(TValue *, p);
-  else {
+  else return luaH_newkey(L, t, key);
-    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
-    else if (ttisnumber(key) && luai_numisnan(L, nvalue(key)))
-      luaG_runerror(L, "table index is NaN");
-    return newkey(L, t, key);
-  }
 }
-TValue *luaH_setint (lua_State *L, Table *t, int key) {
+void luaH_setint (lua_State *L, Table *t, int key, TValue *value) {
   const TValue *p = luaH_getint(t, key);
+  TValue *cell;
   if (p != luaO_nilobject)
-    return cast(TValue *, p);
+    cell = cast(TValue *, p);
   else {
     TValue k;
     setnvalue(&k, cast_num(key));
-    return newkey(L, t, &k);
+    cell = luaH_newkey(L, t, &k);
-  }
-}
-TValue *luaH_setstr (lua_State *L, Table *t, TString *key) {
-  const TValue *p = luaH_getstr(t, key);
-  if (p != luaO_nilobject)
-    return cast(TValue *, p);
-  else {
-    TValue k;
-    setsvalue(L, &k, key);
-    return newkey(L, t, &k);
   }
+  setobj2t(L, cell, value);
 }

src/ltable.h+5−3

 /*
-** $Id: ltable.h,v 2.14 2010/06/25 12:18:10 roberto Exp $
+** $Id: ltable.h,v 2.16 2011/08/17 20:26:47 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define gval(n)		(&(n)->i_val)
 #define gnext(n)	((n)->i_key.nk.next)
+#define invalidateTMcache(t)	((t)->flags = 0)
 LUAI_FUNC const TValue *luaH_getint (Table *t, int key);
-LUAI_FUNC TValue *luaH_setint (lua_State *L, Table *t, int key);
+LUAI_FUNC void luaH_setint (lua_State *L, Table *t, int key, TValue *value);
 LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
-LUAI_FUNC TValue *luaH_setstr (lua_State *L, Table *t, TString *key);
 LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
+LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
 LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
 LUAI_FUNC Table *luaH_new (lua_State *L);
 LUAI_FUNC void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize);

src/ltablib.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltablib.c,v 1.61 2011/07/05 12:49:35 roberto Exp $	2	** $Id: ltablib.c,v 1.62 2011/09/30 12:45:45 roberto Exp $
3	** Library for Table Manipulation	3	** Library for Table Manipulation
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -86,7 +86,7 @@ static void addfield (lua_State L, luaL_Buffer b, int i) { · 80 unmodified lines
86	if (!lua_isstring(L, -1))	86	if (!lua_isstring(L, -1))
87	luaL_error(L, "invalid value (%s) at index %d in table for "	87	luaL_error(L, "invalid value (%s) at index %d in table for "
88	LUA_QL("concat"), luaL_typename(L, -1), i);	88	LUA_QL("concat"), luaL_typename(L, -1), i);
89	luaL_addvalue(b);	89	luaL_addvalue(b);
90	}	90	}
91		91
92		92

src/lua.c+39−12

 /*
-** $Id: lua.c,v 1.200 2011/06/16 14:30:58 roberto Exp $
+** $Id: lua.c,v 1.202 2011/08/17 20:19:52 roberto Exp $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
   "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
   "  -l name  require library " LUA_QL("name") "\n"
   "  -v       show version information\n"
+  "  -E       ignore environment variables\n"
   "  --       stop handling options\n"
   "  -        stop handling options and execute stdin\n"
   ,
 #define noextrachars(x)		{if ((x)[2] != '\0') return -1;}
-static int collectargs (char **argv, int *pi, int *pv, int *pe) {
+/* indices of various argument indicators in array args */
+#define has_i		0	/* -i */
+#define has_v		1	/* -v */
+#define has_e		2	/* -e */
+#define has_E		3	/* -E */
+#define num_has		4	/* number of 'has_*' */
+static int collectargs (char **argv, int *args) {
   int i;
   for (i = 1; argv[i] != NULL; i++) {
     if (argv[i][0] != '-')  /* not an option? */
         return (argv[i+1] != NULL ? i+1 : 0);
       case '\0':
         return i;
+      case 'E':
+        args[has_E] = 1;
+        break;
       case 'i':
         noextrachars(argv[i]);
-        *pi = 1;  /* go through */
+        args[has_i] = 1;  /* go through */
       case 'v':
         noextrachars(argv[i]);
-        *pv = 1;
+        args[has_v] = 1;
         break;
       case 'e':
-        *pe = 1;  /* go through */
+        args[has_e] = 1;  /* go through */
       case 'l':  /* both options need an argument */
         if (argv[i][2] == '\0') {  /* no concatenated argument? */
           i++;  /* try next 'argv' */
 }
+static void resetpaths (lua_State *L) {
+  lua_getglobal(L, "package");
+  if (!lua_istable(L, -1))  /* no module 'package'? */
+    return;  /* nothing to be done */
+  lua_pushliteral(L, LUA_PATH_DEFAULT);
+  lua_setfield(L, -2, "path");  /* package.path = default */
+  lua_pushliteral(L, LUA_CPATH_DEFAULT);
+  lua_setfield(L, -2, "cpath");  /* package.cpath = default */
+  lua_pop(L, 1);  /* remove 'package' */
+}
 static int pmain (lua_State *L) {
   int argc = (int)lua_tointeger(L, 1);
   char **argv = (char **)lua_touserdata(L, 2);
   int script;
-  int has_i = 0, has_v = 0, has_e = 0;
+  int args[num_has];
+  args[has_i] = args[has_v] = args[has_e] = args[has_E] = 0;
   if (argv[0] && argv[0][0]) progname = argv[0];
-  script = collectargs(argv, &has_i, &has_v, &has_e);
+  script = collectargs(argv, args);
   if (script < 0) {  /* invalid arg? */
     print_usage(argv[-script]);
     return 0;
   }
-  if (has_v) print_version();
+  if (args[has_v]) print_version();
   /* open standard libraries */
   luaL_checkversion(L);
   lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
   luaL_openlibs(L);  /* open libraries */
   lua_gc(L, LUA_GCRESTART, 0);
-  /* run LUA_INIT */
+  if (args[has_E])  /* avoid LUA_INIT? */
-  if (handle_luainit(L) != LUA_OK) return 0;
+    resetpaths(L);
+  else if (handle_luainit(L) != LUA_OK) return 0;
   /* execute arguments -e and -l */
   if (!runargs(L, argv, (script > 0) ? script : argc)) return 0;
   /* execute main script (if there is one) */
   if (script && handle_script(L, argv, script) != LUA_OK) return 0;
-  if (has_i)  /* -i option? */
+  if (args[has_i])  /* -i option? */
     dotty(L);
-  else if (script == 0 && !has_e && !has_v) {  /* no arguments? */
+  else if (script == 0 && !args[has_e] && !args[has_v]) {  /* no arguments? */
     if (lua_stdin_is_tty()) {
       print_version();
       dotty(L);

src/lua.h+7−10

 /*
-** $Id: lua.h,v 1.278 2011/07/02 16:00:15 roberto Exp $
+** $Id: lua.h,v 1.281 2011/10/24 16:53:05 roberto Exp $
 ** Lua - A Scripting Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
 #define LUA_VERSION_MAJOR	"5"
 #define LUA_VERSION_MINOR	"2"
 #define LUA_VERSION_NUM		502
-#define LUA_VERSION_RELEASE	"0" " (beta)"
+#define LUA_VERSION_RELEASE	"0"
 #define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
 #define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
 /*
 ** get functions (Lua -> stack)
 */
+LUA_API void  (lua_getglobal) (lua_State *L, const char *var);
 LUA_API void  (lua_gettable) (lua_State *L, int idx);
 LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
 LUA_API void  (lua_rawget) (lua_State *L, int idx);
 LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
 LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
 LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
 LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
 /*
 ** set functions (stack -> Lua)
 */
+LUA_API void  (lua_setglobal) (lua_State *L, const char *var);
 LUA_API void  (lua_settable) (lua_State *L, int idx);
 LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
 LUA_API void  (lua_rawset) (lua_State *L, int idx);
 LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
 LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
 LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
 LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,
                            lua_CFunction k);
 #define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
-LUA_API int  (lua_resume) (lua_State *L, int narg);
+LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);
 LUA_API int  (lua_status) (lua_State *L);
 /*
 #define lua_newtable(L)		lua_createtable(L, 0, 0)
-#define lua_setglobal(L,s)  \
-	(lua_pushglobaltable(L), lua_pushvalue(L, -2), \
-	 lua_setfield(L, -2, (s)), lua_pop(L, 2))
-#define lua_getglobal(L,s) \
-	(lua_pushglobaltable(L), lua_getfield(L, -1, (s)), lua_remove(L, -2))
 #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
 #define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)

src/luac.c+3−4

 /*
-** $Id: luac.c,v 1.67 2011/06/21 12:29:00 lhf Exp $
+** $Id: luac.c,v 1.68 2011/11/23 17:48:18 lhf Exp $
 ** Lua compiler (saves bytecodes to files; also list bytecodes)
 ** See Copyright Notice in lua.h
 */
  fprintf(stderr,
   "usage: %s [options] [filenames]\n"
   "Available options are:\n"
-  "  -l       list\n"
+  "  -l       list (use -l -l for full listing)\n"
   "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
   "  -p       parse only\n"
   "  -s       strip debug information\n"
 }
 /*
-** $Id: print.c,v 1.67 2011/05/06 13:37:15 lhf Exp $
+** $Id: print.c,v 1.68 2011/09/30 10:21:20 lhf Exp $
 ** print bytecodes
 ** See Copyright Notice in lua.h
 */
 #include "lobject.h"
 #include "lopcodes.h"
-#define Sizeof(x)	((int)sizeof(x))
 #define VOID(p)		((const void*)(p))
 static void PrintString(const TString* ts)

src/luaconf.h+16−11

 /*
-** $Id: luaconf.h,v 1.161 2011/07/08 20:07:11 roberto Exp $
+** $Id: luaconf.h,v 1.166 2011/11/09 14:47:14 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
 #endif
-#if !defined(LUA_ANSI) && defined(_WIN32)
+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
-#define LUA_WIN
+#define LUA_WIN		/* enable goodies for regular Windows platforms */
 #endif
 #if defined(LUA_WIN)
 /*
 @@ luai_writestring/luai_writeline define how 'print' prints its results.
+** They are only used in libraries and the stand-alone program. (The #if
+** avoids including 'stdio.h' everywhere.)
 */
+#if defined(LUA_LIB) || defined(lua_c) || defined(luaall_c)
 #include <stdio.h>
 #define luai_writestring(s,l)	fwrite((s), sizeof(char), (l), stdout)
 #define luai_writeline()	(luai_writestring("\n", 1), fflush(stdout))
+#endif
 /*
 @@ luai_writestringerror defines how to print error messages.
 /* On a Microsoft compiler on a Pentium, use assembler to avoid clashes
    with a DirectX idiosyncrasy */
-#if defined(_MSC_VER) && defined(M_IX86)		/* { */
+#if defined(LUA_WIN) && defined(_M_IX86)	/* { */
 #define MS_ASMTRICK
 /*
-@@ LUA_NANTRICKLE/LUA_NANTRICKBE controls the use of a trick to pack all
+@@ LUA_NANTRICK_LE/LUA_NANTRICK_BE controls the use of a trick to
-** types into a single double value, using NaN values to represent
+** pack all types into a single double value, using NaN values to
-** non-number values. The trick only works on 32-bit machines (ints and
+** represent non-number values. The trick only works on 32-bit machines
-** pointers are 32-bit values) with numbers represented as IEEE 754-2008
+** (ints and pointers are 32-bit values) with numbers represented as
-** doubles with conventional endianess (12345678 or 87654321), in CPUs
+** IEEE 754-2008 doubles with conventional endianess (12345678 or
-** that do not produce signaling NaN values (all NaNs are quiet).
+** 87654321), in CPUs that do not produce signaling NaN values (all NaNs
+** are quiet).
 */
 #if defined(LUA_CORE) && \
     defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)	/* { */
 #if defined(__i386__) || defined(__i386) || defined(__X86__) || \
     defined(_M_IX86)
-#define LUA_NANTRICKLE
+#define LUA_NANTRICK_LE
 #endif

src/lvm.c+29−20

 /*
-** $Id: lvm.c,v 2.141 2011/06/09 18:24:22 roberto Exp $
+** $Id: lvm.c,v 2.144 2011/10/07 20:45:19 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
   int loop;
-  TValue temp;
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
     const TValue *tm;
     if (ttistable(t)) {  /* `t' is a table? */
       Table *h = hvalue(t);
-      TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
+      TValue *oldval = cast(TValue *, luaH_get(h, key));
-      if (!ttisnil(oldval) ||  /* result is not nil? */
+      /* if previous value is not nil, there must be a previous entry
-          (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
+         in the table; moreover, a metamethod has no relevance */
-        setobj2t(L, oldval, val);
+      if (!ttisnil(oldval) ||
+         /* previous value is nil; must check the metamethod */
+         ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL &&
+         /* no metamethod; is there a previous entry in the table? */
+         (oldval != luaO_nilobject ||
+         /* no previous entry; must create one. (The next test is
+            always true; we only need the assignment.) */
+         (oldval = luaH_newkey(L, h, key), 1)))) {
+        /* no metamethod and (now) there is an entry with given key */
+        setobj2t(L, oldval, val);  /* assign new value to that entry */
+        invalidateTMcache(h);
         luaC_barrierback(L, obj2gco(h), val);
         return;
       }
-      /* else will try the tag method */
+      /* else will try the metamethod */
     }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
+    else  /* not a table; check metamethod */
-      luaG_typeerror(L, t, "index");
+      if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
+        luaG_typeerror(L, t, "index");
+    /* there is a metamethod */
     if (ttisfunction(tm)) {
       callTM(L, tm, t, key, val, 0);
       return;
     }
-    /* else repeat with 'tm' */
+    t = tm;  /* else repeat with 'tm' */
-    setobj(L, &temp, tm);  /* avoid pointing inside table (may rehash) */
-    t = &temp;
   }
   luaG_runerror(L, "loop in settable");
 }
     return luai_numlt(L, nvalue(l), nvalue(r));
   else if (ttisstring(l) && ttisstring(r))
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
-  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
+  else if ((res = call_orderTM(L, l, r, TM_LT)) < 0)
-    return res;
+    luaG_ordererror(L, l, r);
-  return luaG_ordererror(L, l, r);
+  return res;
 }
     return luai_numle(L, nvalue(l), nvalue(r));
   else if (ttisstring(l) && ttisstring(r))
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
-  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */
+  else if ((res = call_orderTM(L, l, r, TM_LE)) >= 0)  /* first try `le' */
     return res;
-  else if ((res = call_orderTM(L, r, l, TM_LT)) != -1)  /* else try `lt' */
+  else if ((res = call_orderTM(L, r, l, TM_LT)) < 0)  /* else try `lt' */
-    return !res;
+    luaG_ordererror(L, l, r);
-  return luaG_ordererror(L, l, r);
+  return !res;
 }
           luaH_resizearray(L, h, last);  /* pre-allocate it at once */
         for (; n > 0; n--) {
           TValue *val = ra+n;
-          setobj2t(L, luaH_setint(L, h, last--), val);
+          luaH_setint(L, h, last--, val);
           luaC_barrierback(L, obj2gco(h), val);
         }
         L->top = ci->top;  /* correct top (in case of previous open call) */

src/lzio.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lzio.c,v 1.33 2011/02/23 13:13:10 roberto Exp $	2	** $Id: lzio.c,v 1.34 2011/07/15 12:35:32 roberto Exp $
3	** a generic input stream interface	3	** a generic input stream interface
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -29,7 +29,7 @@ int luaZ_fill (ZIO *z) { · 23 unmodified lines
29	return EOZ;	29	return EOZ;
30	z->n = size - 1; /* discount char being returned */	30	z->n = size - 1; /* discount char being returned */
31	z->p = buff;	31	z->p = buff;
32	return char2int(*(z->p++));	32	return cast_uchar(*(z->p++));
33	}	33	}
34		34
35		35

src/lzio.h+2−6

 /*
-** $Id: lzio.h,v 1.24 2011/02/23 13:13:10 roberto Exp $
+** $Id: lzio.h,v 1.26 2011/07/15 12:48:03 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
 typedef struct Zio ZIO;
-#define char2int(c)	cast(int, cast(unsigned char, (c)))
+#define zgetc(z)  (((z)->n--)>0 ?  cast_uchar(*(z)->p++) : luaZ_fill(z))
-#define zgetc(z)  (((z)->n--)>0 ?  char2int(*(z)->p++) : luaZ_fill(z))
-#define zungetc(z)	((z)->n++, (z)->p--)
 typedef struct Mbuffer {