Lua 5.2.0-beta-rc1

Lua Team committed 15 years ago

Commit 30837cc1 parent 9bce00553 files · +2418 −1456Browse files

Unified · Split

53 files

README +1 −1
doc/contents.html +12 −8
doc/lua.css +20 −1
doc/manual.html +601 −337
doc/readme.html +16 −9
src/Makefile +2 −2
src/lapi.c +88 −74
src/lauxlib.c +77 −13
src/lauxlib.h +5 −2
src/lbaselib.c +76 −108
src/lbitlib.c +67 −21
src/lcode.c +42 −38
src/lcode.h +3 −4
src/ldblib.c +8 −19
src/ldebug.c +74 −36
src/ldebug.h +4 −1
src/ldo.c +64 −66
src/ldump.c +3 −3
src/lgc.c +79 −58
src/lgc.h +8 −9
src/linit.c +5 −5
src/liolib.c +34 −57
src/llex.c +13 −17
src/llex.h +7 −7
src/llimits.h +15 −10
src/lmem.c +5 −9
src/loadlib.c +43 −30
src/lobject.c +86 −38
src/lobject.h +241 −87
src/lopcodes.c +5 −5
src/lopcodes.h +6 −7
src/loslib.c +11 −20
src/lparser.c +320 −145
src/lparser.h +34 −11
src/lstate.c +12 −8
src/lstate.h +11 −7
src/lstring.c +4 −3
src/lstrlib.c +51 −22
src/ltable.c +10 −8
src/ltablib.c +4 −4
src/ltm.c +4 −4
src/ltm.h +2 −2
src/lua.c +10 −11
src/lua.h +4 −4
src/luac.c +17 −12
src/luaconf.h +57 −6
src/lualib.h +2 −2
src/lundump.c +30 −23
src/lundump.h +7 −4
src/lvm.c +97 −53
src/lvm.h +7 −4
src/lzio.c +12 −18
src/lzio.h +2 −3

@@ -1,5 +1,5 @@
1		1
2	This is Lua 5.2 (alpha), released on 23 Nov 2010.	2	This is Lua 5.2 (beta), released on 13 Jun 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/contents.html+12−8

 <P>
 <IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
-<EM>This is an alpha version of Lua 5.2.
+<EM>This is a beta version of Lua 5.2.
 Some details may change in the final version.</EM>
 <P>
 <A HREF="#index">index</A>
 <HR>
 <SMALL>
-Copyright &copy; 2010 Lua.org, PUC-Rio.
+Copyright &copy; 2011 Lua.org, PUC-Rio.
 Freely available under the terms of the
 <a href="http://www.lua.org/license.html#5">Lua license</a>.
 </SMALL>
 </UL>
 <LI><A HREF="manual.html#6.5">6.5 &ndash; Table Manipulation</A>
 <LI><A HREF="manual.html#6.6">6.6 &ndash; Mathematical Functions</A>
-<LI><A HREF="manual.html#6.7">6.7 &ndash; Bitwise operations</A>
+<LI><A HREF="manual.html#6.7">6.7 &ndash; Bitwise Operations</A>
 <LI><A HREF="manual.html#6.8">6.8 &ndash; Input and Output Facilities</A>
 <LI><A HREF="manual.html#6.9">6.9 &ndash; Operating System Facilities</A>
 <LI><A HREF="manual.html#6.10">6.10 &ndash; The Debug Library</A>
 <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-loadin">loadin</A><BR>
-<A HREF="manual.html#pdf-loadstring">loadstring</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#pdf-print">print</A><BR>
 <A HREF="manual.html#pdf-rawequal">rawequal</A><BR>
 <A HREF="manual.html#pdf-rawget">rawget</A><BR>
+<A HREF="manual.html#pdf-rawlen">rawlen</A><BR>
 <A HREF="manual.html#pdf-rawset">rawset</A><BR>
 <A HREF="manual.html#pdf-require">require</A><BR>
 <A HREF="manual.html#pdf-select">select</A><BR>
 <A HREF="manual.html#pdf-bit32.bor">bit32.bor</A><BR>
 <A HREF="manual.html#pdf-bit32.btest">bit32.btest</A><BR>
 <A HREF="manual.html#pdf-bit32.bxor">bit32.bxor</A><BR>
+<A HREF="manual.html#pdf-bit32.extract">bit32.extract</A><BR>
 <A HREF="manual.html#pdf-bit32.lrotate">bit32.lrotate</A><BR>
 <A HREF="manual.html#pdf-bit32.lshift">bit32.lshift</A><BR>
+<A HREF="manual.html#pdf-bit32.replace">bit32.replace</A><BR>
 <A HREF="manual.html#pdf-bit32.rrotate">bit32.rrotate</A><BR>
 <A HREF="manual.html#pdf-bit32.rshift">bit32.rshift</A><BR>
 <A HREF="manual.html#luaL_dofile">luaL_dofile</A><BR>
 <A HREF="manual.html#luaL_dostring">luaL_dostring</A><BR>
 <A HREF="manual.html#luaL_error">luaL_error</A><BR>
-<A HREF="manual.html#luaL_findtable">luaL_findtable</A><BR>
+<A HREF="manual.html#luaL_execresult">luaL_execresult</A><BR>
+<A HREF="manual.html#luaL_fileresult">luaL_fileresult</A><BR>
 <A HREF="manual.html#luaL_getmetafield">luaL_getmetafield</A><BR>
 <A HREF="manual.html#luaL_getmetatable">luaL_getmetatable</A><BR>
+<A HREF="manual.html#luaL_getsubtable">luaL_getsubtable</A><BR>
 <A HREF="manual.html#luaL_gsub">luaL_gsub</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_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>
 <HR>
 <SMALL>
 Last update:
-Mon Nov 22 16:38:54 BRST 2010
+Mon Jun 13 15:09:33 BRT 2011
 </SMALL>
 <!--
-Last change: revised for Lua 5.2.0 (alpha)
+Last change: revised for Lua 5.2.0 (beta)
 -->
 </BODY>

doc/lua.css+20−1

@@ -8,6 +8,7 @@ body { · 7 unmodified lines
8	}	8	}
9		9
10	h1, h2, h3, h4 {	10	h1, h2, h3, h4 {
		11	font-family: Verdana, sans-serif ;
11	font-weight: normal ;	12	font-weight: normal ;
12	font-style: italic ;	13	font-style: italic ;
13	}	14	}
@@ -27,7 +28,7 @@ h3 { · 13 unmodified lines
27		28
28	table h3 {	29	table h3 {
29	padding-left: 0px ;	30	padding-left: 0px ;
30	border-left: none ;	31	border-left: none ;
31	}	32	}
32		33
33	a:link {	34	a:link {
@@ -62,3 +63,21 @@ hr { · 28 unmodified lines
62	padding: 8px ;	63	padding: 8px ;
63	border: solid #a0a0a0 2px ;	64	border: solid #a0a0a0 2px ;
64	}	65	}
		66
		67	.footer {
		68	color: gray ;
		69	font-size: small ;
		70	}
		71
		72	input[type=text] {
		73	border: solid #a0a0a0 2px ;
		74	border-radius: 2em ;
		75	-moz-border-radius: 2em ;
		76	background-image: url('images/search.png') ;
		77	background-repeat: no-repeat;
		78	background-position: left center ;
		79	background-position: 4px center ;
		80	padding-left: 20px ;
		81	height: 2em ;
		82	}
		83

doc/manual.html+601−337

@@ -17,14 +17,14 @@ Lua 5.2 Reference Manual · 16 unmodified lines
17	</h1>	17	</h1>
18		18
19	<IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">	19	<IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
20	<EM>This is an alpha version of Lua 5.2.	20	<EM>This is a beta version of Lua 5.2.
21	Some details may change in the final version.</EM>	21	Some details may change in the final version.</EM>
22	<P>	22	<P>
23		23
24	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes	24	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
25	<p>	25	<p>
26	<small>	26	<small>
27	Copyright © 2010 Lua.org, PUC-Rio.	27	Copyright © 2011 Lua.org, PUC-Rio.
28	Freely available under the terms of the	28	Freely available under the terms of the
29	<a href="http://www.lua.org/license.html#5">Lua license</a>.	29	<a href="http://www.lua.org/license.html#5">Lua license</a>.
30	</small>	30	</small>
@@ -38,7 +38,7 @@ Freely available under the terms of the · 7 unmodified lines
38	<!-- ====================================================================== -->	38	<!-- ====================================================================== -->
39	<p>	39	<p>
40		40
41	<!-- $Id: manual.of,v 1.66 2010/11/22 18:07:40 roberto Exp $ -->	41	<!-- $Id: manual.of,v 1.77 2011/06/13 16:27:54 roberto Exp $ -->
42		42
43		43
44		44
@@ -53,7 +53,7 @@ It also offers good support for object-oriented programming, · 8 unmodified lines
53	functional programming, and data-driven programming.	53	functional programming, and data-driven programming.
54	Lua is intended to be used as a powerful, light-weight	54	Lua is intended to be used as a powerful, light-weight
55	scripting language for any program that needs one.	55	scripting language for any program that needs one.
56	Lua is implemented as a library, written in <em>clean</em> C,	56	Lua is implemented as a library, written in <em>clean C</em>,
57	the common subset of ANSI C and C++.	57	the common subset of ANSI C and C++.
58		58
59		59
@@ -125,11 +125,14 @@ it usually represents the absence of a useful value. · 65 unmodified lines
125	Both <b>nil</b> and <b>false</b> make a condition false;	125	Both <b>nil</b> and <b>false</b> make a condition false;
126	any other value makes it true.	126	any other value makes it true.
127	<em>Number</em> represents real (double-precision floating-point) numbers.	127	<em>Number</em> represents real (double-precision floating-point) numbers.
		128	Operations on numbers follow the same rules of
		129	the underlying C implementation,
		130	which, in turn, usually follows the IEEE 754 standard.
128	(It is easy to build Lua interpreters that use other	131	(It is easy to build Lua interpreters that use other
129	internal representations for numbers,	132	internal representations for numbers,
130	such as single-precision floats or long integers;	133	such as single-precision floats or long integers;
131	see file <code>luaconf.h</code>.)	134	see file <code>luaconf.h</code>.)
132	<em>String</em> represents arrays of characters.	135	<em>String</em> represents immutable sequences of bytes.
133		136
134	Lua is 8-bit clean:	137	Lua is 8-bit clean:
135	strings can contain any 8-bit value,	138	strings can contain any 8-bit value,
@@ -167,11 +170,19 @@ even those that do not support threads. · 31 unmodified lines
167	<p>	170	<p>
168	The type <em>table</em> implements associative arrays,	171	The type <em>table</em> implements associative arrays,
169	that is, arrays that can be indexed not only with numbers,	172	that is, arrays that can be indexed not only with numbers,
170	but with any value (except <b>nil</b>).	173	but with any Lua value except <b>nil</b> and NaN
		174	(<em>Not a Number</em>, a special numeric value used to represent
		175	undefined or unrepresentable results, such as <code>0/0</code>).
171	Tables can be <em>heterogeneous</em>;	176	Tables can be <em>heterogeneous</em>;
172	that is, they can contain values of all types (except <b>nil</b>).	177	that is, they can contain values of all types (except <b>nil</b>).
		178	Any key with value <b>nil</b> is not considered part of the table.
		179	Conversely, any key that is not part of a table has
		180	an associated value <b>nil</b>.
		181
		182
		183	<p>
173	Tables are the sole data structuring mechanism in Lua;	184	Tables are the sole data structuring mechanism in Lua;
174	they can be used to represent ordinary arrays,	185	they can be used to represent ordinary arrays, sequences,
175	symbol tables, sets, records, graphs, trees, etc.	186	symbol tables, sets, records, graphs, trees, etc.
176	To represent records, Lua uses the field name as an index.	187	To represent records, Lua uses the field name as an index.
177	The language supports this representation by	188	The language supports this representation by
@@ -180,15 +191,29 @@ There are several convenient ways to create tables in Lua · 2 unmodified lines
180	(see <a href="#3.4.8">§3.4.8</a>).	191	(see <a href="#3.4.8">§3.4.8</a>).
181		192
182		193
		194	<p>
		195	We use the term <em>sequence</em> to denote a table where all
		196	integer keys comprise the set <em>{1..n}</em> for some integer <em>n</em>,
		197	which is called the length of the sequence (see <a href="#3.4.6">§3.4.6</a>).
		198
		199
183	<p>	200	<p>
184	Like indices,	201	Like indices,
185	the value of a table field can be of any type (except <b>nil</b>).	202	the value of a table field can be of any type.
186	In particular,	203	In particular,
187	because functions are first-class values,	204	because functions are first-class values,
188	table fields can contain functions.	205	table fields can contain functions.
189	Thus tables can also carry <em>methods</em> (see <a href="#3.4.10">§3.4.10</a>).	206	Thus tables can also carry <em>methods</em> (see <a href="#3.4.10">§3.4.10</a>).
190		207
191		208
		209	<p>
		210	The indexing of tables follows
		211	the definition of equality in the language.
		212	The expressions <code>a[i]</code> and <code>a[j]</code>
		213	denote the same table element
		214	if and only if <code>i == j</code>.
		215
		216
192	<p>	217	<p>
193	Tables, functions, threads, and (full) userdata values are <em>objects</em>:	218	Tables, functions, threads, and (full) userdata values are <em>objects</em>:
194	variables do not actually <em>contain</em> these values,	219	variables do not actually <em>contain</em> these values,
@@ -210,7 +235,7 @@ of a given value. · 15 unmodified lines
210		235
211	<p>	236	<p>
212	As discussed in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,	237	As discussed in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,
213	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
214	to <code>_ENV.var</code>.	239	to <code>_ENV.var</code>.
215	Moreover, every chunk is compiled in the scope of an external	240	Moreover, every chunk is compiled in the scope of an external
216	variable called <code>_ENV</code> (see <a href="#3.3.2">§3.3.2</a>),	241	variable called <code>_ENV</code> (see <a href="#3.3.2">§3.3.2</a>),
@@ -241,13 +266,13 @@ In Lua, the variable <a href="#pdf-_G"><code>_G</code></a> is initialized with t · 24 unmodified lines
241		266
242	<p>	267	<p>
243	When Lua compiles a chunk,	268	When Lua compiles a chunk,
244	it initializes the value of its <code>_ENV</code> variable	269	it initializes the value of its <code>_ENV</code> variable
245	with the global environment (see <a href="#pdf-load"><code>load</code></a>).	270	with the global environment (see <a href="#pdf-load"><code>load</code></a>).
246	Therefore, by default,	271	Therefore, by default,
247	global variables in Lua code refer to entries in the global environment.	272	global variables in Lua code refer to entries in the global environment.
248	Moreover, all standard libraries are loaded in the global environment,	273	Moreover, all standard libraries are loaded in the global environment,
249	and several functions there operate on that environment.	274	and several functions there operate on that environment.
250	You can use <a href="#pdf-loadin"><code>loadin</code></a> to load a chunk with a different environment.	275	You can use <a href="#pdf-load"><code>load</code></a> to load a chunk with a different environment.
251	(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
252	of its first upvalue.)	277	of its first upvalue.)
253		278
@@ -283,7 +308,32 @@ which can take appropriate measures · 29 unmodified lines
283	Lua code can explicitly generate an error by calling the	308	Lua code can explicitly generate an error by calling the
284	<a href="#pdf-error"><code>error</code></a> function.	309	<a href="#pdf-error"><code>error</code></a> function.
285	If you need to catch errors in Lua,	310	If you need to catch errors in Lua,
286	you can use the <a href="#pdf-pcall"><code>pcall</code></a> or the <a href="#pdf-xpcall"><code>xpcall</code></a> function.	311	you can use <a href="#pdf-pcall"><code>pcall</code></a> or <a href="#pdf-xpcall"><code>xpcall</code></a>
		312	to call a given function in <em>protected mode</em>.
		313
		314
		315	<p>
		316	Whenever there is an error,
		317	an <em>error object</em> (also called an <em>error message</em>)
		318	is propagated with information about the error.
		319	Lua itself only generates errors where the error object is a string,
		320	but programs may generate errors with
		321	any value for the error object.
		322
		323
		324	<p>
		325	When you use <a href="#pdf-xpcall"><code>xpcall</code></a> or <a href="#lua_pcall"><code>lua_pcall</code></a>,
		326	you may give an <em>message handler</em>
		327	to be called in case of errors.
		328	This function is called with the original error message
		329	and returns a new error message.
		330	It is called before the error unwonds the stack,
		331	so that it can gather more information about the error,
		332	for instance by inspecting the stack and creating a stack traceback.
		333	This message handler is still protected by the protected call;
		334	so, an error inside the message handler
		335	will call the message handler again.
		336	If this loop goes on, Lua breaks it and returns an appropriate message.
287		337
288		338
289		339
@@ -307,7 +357,7 @@ Lua calls this function to perform the addition. · 17 unmodified lines
307	<p>	357	<p>
308	The keys in a metatable are derived from the <em>event</em> names;	358	The keys in a metatable are derived from the <em>event</em> names;
309	the corresponding values are called <em>metamethods</em>.	359	the corresponding values are called <em>metamethods</em>.
310	In the previous example, the event is <code>"add"</code>	360	In the previous example, the event is <code>"add"</code>
311	and the metamethod is the function that performs the addition.	361	and the metamethod is the function that performs the addition.
312		362
313		363
@@ -623,6 +673,11 @@ equivalent to <code>not (b < a)</code>. · 309 unmodified lines
623		673
624	<li><b>"index":</b>	674	<li><b>"index":</b>
625	The indexing access <code>table[key]</code>.	675	The indexing access <code>table[key]</code>.
		676	Note that the metamethod is tried only
		677	when <code>key</code> is not present in <code>table</code>.
		678	(When <code>table</code> is not a table,
		679	no key is ever present,
		680	so the metamethod is always tried.)
626		681
627		682
628	<pre>	683	<pre>
@@ -630,6 +685,7 @@ The indexing access <code>table[key]</code>. · 1 unmodified line
630	local h	685	local h
631	if type(table) == "table" then	686	if type(table) == "table" then
632	local v = rawget(table, key)	687	local v = rawget(table, key)
		688	-- if key is present, return raw value
633	if v ~= nil then return v end	689	if v ~= nil then return v end
634	h = metatable(table).__index	690	h = metatable(table).__index
635	if h == nil then return nil end	691	if h == nil then return nil end
@@ -649,6 +705,8 @@ The indexing access <code>table[key]</code>. · 13 unmodified lines
649		705
650	<li><b>"newindex":</b>	706	<li><b>"newindex":</b>
651	The indexing assignment <code>table[key] = value</code>.	707	The indexing assignment <code>table[key] = value</code>.
		708	Note that the metamethod is tried only
		709	when <code>key</code> is not present in <code>table</code>.
652		710
653		711
654	<pre>	712	<pre>
@@ -656,6 +714,7 @@ The indexing assignment <code>table[key] = value</code>. · 1 unmodified line
656	local h	714	local h
657	if type(table) == "table" then	715	if type(table) == "table" then
658	local v = rawget(table, key)	716	local v = rawget(table, key)
		717	-- if key is present, do raw assignment
659	if v ~= nil then rawset(table, key, value); return end	718	if v ~= nil then rawset(table, key, value); return end
660	h = metatable(table).__newindex	719	h = metatable(table).__newindex
661	if h == nil then rawset(table, key, value); return end	720	if h == nil then rawset(table, key, value); return end
@@ -758,7 +817,7 @@ memory usage. · 96 unmodified lines
758	<p>	817	<p>
759	You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C	818	You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
760	or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.	819	or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
761	With these functions you can also control	820	With these functions you can also control
762	the collector directly (e.g., stop and restart it).	821	the collector directly (e.g., stop and restart it).
763		822
764		823
@@ -766,8 +825,9 @@ the collector directly (e.g., stop and restart it). · 1 unmodified line
766	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>	825	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>
767		826
768	<p>	827	<p>
769	Using the C API,	828	You can set garbage-collector metamethods for tables
770	you can set garbage-collector metamethods for full userdata (see <a href="#2.4">§2.4</a>).	829	and, using the C API,
		830	for full userdata (see <a href="#2.4">§2.4</a>).
771	These metamethods are also called <em>finalizers</em>.	831	These metamethods are also called <em>finalizers</em>.
772	Finalizers allow you to coordinate Lua's garbage collection	832	Finalizers allow you to coordinate Lua's garbage collection
773	with external resource management	833	with external resource management
@@ -776,43 +836,43 @@ or freeing your own memory). · 2 unmodified lines
776		836
777		837
778	<p>	838	<p>
779	For a userdata to be finalized when collected,	839	For an object (table or userdata) to be finalized when collected,
780	you must <em>mark</em> it for finalization.	840	you must <em>mark</em> it for finalization.
781		841
782	You mark a userdata for finalization when you set its metatable	842	You mark an object for finalization when you set its metatable
783	and the metatable has a field indexed by the string "<code>__gc</code>".	843	and the metatable has a field indexed by the string "<code>__gc</code>".
784	Note that if you set a metatable without a <code>__gc</code> field	844	Note that if you set a metatable without a <code>__gc</code> field
785	and later create that field in the metatable,	845	and later create that field in the metatable,
786	the userdata will not be marked for finalization.	846	the object will not be marked for finalization.
787	However, after a userdata is marked,	847	However, after a userdata is marked,
788	you can freely change the <code>__gc</code> field of its metatable.	848	you can freely change the <code>__gc</code> field of its metatable.
789		849
790		850
791	<p>	851	<p>
792	When a marked userdata becomes garbage,	852	When a marked object becomes garbage,
793	it is not collected immediately by the garbage collector.	853	it is not collected immediately by the garbage collector.
794	Instead, Lua puts it in a list.	854	Instead, Lua puts it in a list.
795	After the collection,	855	After the collection,
796	Lua does the equivalent of the following function	856	Lua does the equivalent of the following function
797	for each userdata in that list:	857	for each object in that list:
798		858
799	<pre>	859	<pre>
800	function gc_event (udata)	860	function gc_event (obj)
801	local h = metatable(udata).__gc	861	local h = metatable(obj).__gc
802	if type(h) == "function" then	862	if type(h) == "function" then
803	h(udata)	863	h(obj)
804	end	864	end
805	end	865	end
806	</pre>	866	</pre>
807		867
808	<p>	868	<p>
809	At the end of each garbage-collection cycle,	869	At the end of each garbage-collection cycle,
810	the finalizers for userdata are called in	870	the finalizers for objects are called in
811	the reverse order that they were marked for collection,	871	the reverse order that they were marked for collection,
812	among those collected in that cycle;	872	among those collected in that cycle;
813	that is, the first finalizer to be called is the one associated	873	that is, the first finalizer to be called is the one associated
814	with the userdata marked last in the program.	874	with the object marked last in the program.
815	The userdata memory is freed only in the next garbage-collection cycle.	875	The object memory is freed only in the next garbage-collection cycle.
816		876
817		877
818		878
@@ -873,15 +933,13 @@ Lua treats strings and light C functions as non-object values. · 54 unmodified lines
873		933
874		934
875	<p>	935	<p>
876	Userdata marked for finalization have a special behavior in weak tables.	936	Objects marked for finalization have a special behavior in weak tables.
877	When a marked userdata is a value in a weak table,	937	When a marked object is a value in a weak table,
878	it is removed from the table the first time it is collected,	938	it is removed from the table before running its finalizer.
879	before running its finalizer.
880	However, when it is a key,	939	However, when it is a key,
881	it is removed from the table only when it is really freed,	940	it is removed from the table only after running its finalizer.
882	after running its finalizer.	941	This behavior allows the finalizer to access properties
883	This behavior allows the finalizer to access values	942	associated with the object through weak tables.
884	associated with the userdata through weak tables.
885		943
886		944
887		945
@@ -980,7 +1038,7 @@ consider the following code: · 92 unmodified lines
980	print("co-body", r, s)	1038	print("co-body", r, s)
981	return b, "end"	1039	return b, "end"
982	end)	1040	end)
983		1041
984	print("main", coroutine.resume(co, 1, 10))	1042	print("main", coroutine.resume(co, 1, 10))
985	print("main", coroutine.resume(co, "r"))	1043	print("main", coroutine.resume(co, "r"))
986	print("main", coroutine.resume(co, "x", "y"))	1044	print("main", coroutine.resume(co, "x", "y"))
@@ -1048,8 +1106,7 @@ except as delimiters between names and keywords. · 61 unmodified lines
1048	in Lua can be any string of letters,	1106	in Lua can be any string of letters,
1049	digits, and underscores,	1107	digits, and underscores,
1050	not beginning with a digit.	1108	not beginning with a digit.
1051	This coincides with the definition of names in most languages.	1109	Identifiers are used to name variables, table fields, and labels.
1052	Identifiers are used to name variables and table fields.
1053		1110
1054		1111
1055	<p>	1112	<p>
@@ -1058,10 +1115,10 @@ and cannot be used as names: · 2 unmodified lines
1058		1115
1059		1116
1060	<pre>	1117	<pre>
1061	and break do else elseif	1118	and break do else elseif end
1062	end false for function if	1119	false for function goto if in
1063	in local nil not or	1120	local nil not or repeat return
1064	repeat return then true until while	1121	then true until while
1065	</pre>	1122	</pre>
1066		1123
1067	<p>	1124	<p>
@@ -1102,7 +1159,7 @@ results in a newline in the string. · 34 unmodified lines
1102	The escape sequence '<code>\*</code>' skips the following span	1159	The escape sequence '<code>\*</code>' skips the following span
1103	of white-space characters,	1160	of white-space characters,
1104	including line breaks;	1161	including line breaks;
1105	it is particularly useful to break and indent a long string	1162	it is particularly useful to break and indent a long string
1106	into multiple lines without adding the newlines and spaces	1163	into multiple lines without adding the newlines and spaces
1107	into the string contents.	1164	into the string contents.
1108		1165
@@ -1140,9 +1197,18 @@ Any kind of end-of-line sequence · 31 unmodified lines
1140	(carriage return, newline, carriage return followed by newline,	1197	(carriage return, newline, carriage return followed by newline,
1141	or newline followed by carriage return)	1198	or newline followed by carriage return)
1142	is converted to a simple newline.	1199	is converted to a simple newline.
1143	You should not use long strings for non-text data;	1200
1144	Use instead a regular quoted literal with explicit escape sequences	1201
1145	for control characters.	1202	<p>
		1203	When parsing a from a string source,
		1204	any byte in a literal string not
		1205	explicitly affected by the previous rules represents itself.
		1206	However, Lua opens files for parsing in text mode,
		1207	and the system file functions may have problems with
		1208	some control characters.
		1209	So, it is safer to represent
		1210	non-text data as a quoted literal with
		1211	explicit escape sequences for non-text characters.
1146		1212
1147		1213
1148	<p>	1214	<p>
@@ -1166,14 +1232,19 @@ the five literal strings below denote the same string: · 17 unmodified lines
1166	</pre>	1232	</pre>
1167		1233
1168	<p>	1234	<p>
1169	A <em>numerical constant</em> can be written with an optional decimal part	1235	A <em>numerical constant</em> can be written with an optional fractional part
1170	and an optional decimal exponent.	1236	and an optional decimal exponent,
1171	Lua also accepts integer hexadecimal constants,	1237	marked by a letter '<code>e</code>' or '<code>E</code>'.
1172	by prefixing them with <code>0x</code>.	1238	Lua also accepts hexadecimal constants,
		1239	which start with <code>0x</code> or <code>0X</code>.
		1240	Hexadecimal constants also accept an optional fractional part
		1241	plus an optional binary exponent,
		1242	marked by a letter '<code>e</code>' or '<code>E</code>'.
1173	Examples of valid numerical constants are	1243	Examples of valid numerical constants are
1174		1244
1175	<pre>	1245	<pre>
1176	3 3.0 3.1416 314.16e-2 0.31416E1 0xff 0x56	1246	3 3.0 3.1416 314.16e-2 0.31416E1
		1247	0xff 0x0.1E 0xA23p-4 0X1.921FB54442D18P+1
1177	</pre>	1248	</pre>
1178		1249
1179	<p>	1250	<p>
@@ -1194,7 +1265,6 @@ Long comments are frequently used to disable code temporarily. · 14 unmodified lines
1194		1265
1195	<p>	1266	<p>
1196	Variables are places that store values.	1267	Variables are places that store values.
1197
1198	There are three kinds of variables in Lua:	1268	There are three kinds of variables in Lua:
1199	global variables, local variables, and table fields.	1269	global variables, local variables, and table fields.
1200		1270
@@ -1293,7 +1363,7 @@ A block can be explicitly delimited to produce a single statement: · 92 unmodified lines
1293	Explicit blocks are useful	1363	Explicit blocks are useful
1294	to control the scope of variable declarations.	1364	to control the scope of variable declarations.
1295	Explicit blocks are also sometimes used to	1365	Explicit blocks are also sometimes used to
1296	add a <b>return</b> or <b>break</b> statement in the middle	1366	add a <b>return</b> statement in the middle
1297	of another block (see <a href="#3.3.4">§3.3.4</a>).	1367	of another block (see <a href="#3.3.4">§3.3.4</a>).
1298		1368
1299		1369
@@ -1312,7 +1382,7 @@ a chunk is simply a block: · 12 unmodified lines
1312	</pre>	1382	</pre>
1313		1383
1314	<p>	1384	<p>
1315	Lua handles a chunk as the body of an anonymous function	1385	Lua handles a chunk as the body of an anonymous function
1316	with a variable number of arguments	1386	with a variable number of arguments
1317	(see <a href="#3.4.10">§3.4.10</a>).	1387	(see <a href="#3.4.10">§3.4.10</a>).
1318	As such, chunks can define local variables,	1388	As such, chunks can define local variables,
@@ -1452,38 +1522,60 @@ declared inside the loop block. · 133 unmodified lines
1452		1522
1453		1523
1454	<p>	1524	<p>
1455	The <b>return</b> statement is used to return values	1525	The <b>goto</b> statement transfers the program control to a label.
1456	from a function or a chunk (which is just a function).	1526	For syntactical reasons,
		1527	labels in Lua are considered statements too:
		1528
1457		1529
1458	Functions can return more than one value,
1459	so the syntax for the <b>return</b> statement is
1460		1530
1461	<pre>	1531	<pre>
1462	stat ::= <b>return</b> [explist] [‘<b>;</b>’]	1532	stat ::= <b>goto</b> Name
		1533	stat ::= label
		1534	label ::= ‘<b>@</b>’ Name ‘<b>:</b>’
1463	</pre>	1535	</pre>
1464		1536
1465	<p>	1537	<p>
1466	The <b>break</b> statement is used to terminate the execution of a	1538	A label is visible in the entire block where it is defined
		1539	(including nested blocks, but not nested functions).
		1540	A goto may jump to any visible label as long as it does not
		1541	enter into the scope of a local variable.
		1542
		1543
		1544	<p>
		1545	Both labels and empty statements are called <em>void statements</em>,
		1546	as they perform no actions.
		1547
		1548
		1549	<p>
		1550	The <b>break</b> statement terminates the execution of a
1467	<b>while</b>, <b>repeat</b>, or <b>for</b> loop,	1551	<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
1468	skipping to the next statement after the loop:	1552	skipping to the next statement after the loop:
1469		1553
1470		1554
1471	<pre>	1555	<pre>
1472	stat ::= <b>break</b> [‘<b>;</b>’]	1556	stat ::= <b>break</b>
1473	</pre><p>	1557	</pre><p>
1474	A <b>break</b> ends the innermost enclosing loop.	1558	A <b>break</b> ends the innermost enclosing loop.
1475		1559
1476		1560
1477	<p>	1561	<p>
1478	The <b>return</b> and <b>break</b>	1562	The <b>return</b> statement is used to return values
1479	statements can only be written as the <em>last</em> statement of a block.	1563	from a function or a chunk (which is a function in disguise).
1480	If it is really necessary to <b>return</b> or <b>break</b> in the	1564
1481	middle of a block,	1565	Functions can return more than one value,
		1566	so the syntax for the <b>return</b> statement is
		1567
		1568	<pre>
		1569	stat ::= <b>return</b> [explist] [‘<b>;</b>’]
		1570	</pre>
		1571
		1572	<p>
		1573	The <b>return</b> statement can only be written
		1574	as the last statement of a block.
		1575	If it is really necessary to <b>return</b> in the middle of a block,
1482	then an explicit inner block can be used,	1576	then an explicit inner block can be used,
1483	as in the idioms	1577	as in the idiom <code>do return end</code>,
1484	<code>do return end</code> and <code>do break end</code>,	1578	because now <b>return</b> is the last statement in its (inner) block.
1485	because now <b>return</b> and <b>break</b> are the last statements in
1486	their (inner) blocks.
1487		1579
1488		1580
1489		1581
@@ -1582,8 +1674,8 @@ is equivalent to the code: · 92 unmodified lines
1582	local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>	1674	local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>
1583	while true do	1675	while true do
1584	local <em>var_1</em>, ···, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)	1676	local <em>var_1</em>, ···, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
		1677	if <em>var_1</em> == nil then break end
1585	<em>var</em> = <em>var_1</em>	1678	<em>var</em> = <em>var_1</em>
1586	if <em>var</em> == nil then break end
1587	<em>block</em>	1679	<em>block</em>
1588	end	1680	end
1589	end	1681	end
@@ -1649,7 +1741,6 @@ Otherwise, all variables are initialized with <b>nil</b>. · 59 unmodified lines
1649	<p>	1741	<p>
1650	A chunk is also a block (see <a href="#3.3.2">§3.3.2</a>),	1742	A chunk is also a block (see <a href="#3.3.2">§3.3.2</a>),
1651	and so local variables can be declared in a chunk outside any explicit block.	1743	and so local variables can be declared in a chunk outside any explicit block.
1652	The scope of such local variables extends until the end of the chunk.
1653		1744
1654		1745
1655	<p>	1746	<p>
@@ -1671,7 +1762,7 @@ The basic expressions in Lua are the following: · 15 unmodified lines
1671	exp ::= <b>nil</b> \| <b>false</b> \| <b>true</b>	1762	exp ::= <b>nil</b> \| <b>false</b> \| <b>true</b>
1672	exp ::= Number	1763	exp ::= Number
1673	exp ::= String	1764	exp ::= String
1674	exp ::= function	1765	exp ::= functiondef
1675	exp ::= tableconstructor	1766	exp ::= tableconstructor
1676	exp ::= ‘<b>...</b>’	1767	exp ::= ‘<b>...</b>’
1677	exp ::= exp binop exp	1768	exp ::= exp binop exp
@@ -1776,7 +1867,9 @@ the quotient towards minus infinity. · 98 unmodified lines
1776	Lua provides automatic conversion between	1867	Lua provides automatic conversion between
1777	string and number values at run time.	1868	string and number values at run time.
1778	Any arithmetic operation applied to a string tries to convert	1869	Any arithmetic operation applied to a string tries to convert
1779	this string to a number, following the usual conversion rules.	1870	this string to a number, following the rules of the Lua lexer.
		1871	(The string may have leading and trailing spaces,
		1872	plus an optional sign.)
1780	Conversely, whenever a number is used where a string is expected,	1873	Conversely, whenever a number is used where a string is expected,
1781	the number is converted to a string, in a reasonable format.	1874	the number is converted to a string, in a reasonable format.
1782	For complete control over how numbers are converted to strings,	1875	For complete control over how numbers are converted to strings,
@@ -1802,8 +1895,8 @@ If the types are different, then the result is <b>false</b>. · 19 unmodified lines
1802	Otherwise, the values of the operands are compared.	1895	Otherwise, the values of the operands are compared.
1803	Numbers and strings are compared in the usual way.	1896	Numbers and strings are compared in the usual way.
1804	Tables, userdata, and threads	1897	Tables, userdata, and threads
1805	are compared by <em>reference</em>:	1898	are compared by reference:
1806	two objects are considered equal only if they are the <em>same</em> object.	1899	two objects are considered equal only if they are the same object.
1807	Every time you create a new object	1900	Every time you create a new object
1808	(a table, userdata, or thread),	1901	(a table, userdata, or thread),
1809	this new object is different from any previously existing object.	1902	this new object is different from any previously existing object.
@@ -1813,13 +1906,13 @@ Closures with any detectable difference · 3 unmodified lines
1813		1906
1814		1907
1815	<p>	1908	<p>
1816	You can change the way that Lua compares tables and userdata	1909	You can change the way that Lua compares tables and userdata
1817	by using the "eq" metamethod (see <a href="#2.4">§2.4</a>).	1910	by using the "eq" metamethod (see <a href="#2.4">§2.4</a>).
1818		1911
1819		1912
1820	<p>	1913	<p>
1821	The conversion rules of <a href="#3.4.2">§3.4.2</a>	1914	The conversion rules of <a href="#3.4.2">§3.4.2</a>
1822	<em>do not</em> apply to equality comparisons.	1915	do not apply to equality comparisons.
1823	Thus, <code>"0"==0</code> evaluates to <b>false</b>,	1916	Thus, <code>"0"==0</code> evaluates to <b>false</b>,
1824	and <code>t[0]</code> and <code>t["0"]</code> denote different	1917	and <code>t[0]</code> and <code>t["0"]</code> denote different
1825	entries in a table.	1918	entries in a table.
@@ -1902,25 +1995,27 @@ character is one byte). · 76 unmodified lines
1902		1995
1903		1996
1904	<p>	1997	<p>
1905	The length of a table <code>t</code> can be any integer index <code>n</code>	1998	The length of a table <code>t</code> is only defined if the
1906	such that <code>t[n]</code> is not <b>nil</b> and <code>t[n+1]</code> is <b>nil</b>;	1999	table is a <em>sequence</em>,
1907	moreover, if <code>t[1]</code> is <b>nil</b>, <code>n</code> can be zero.	2000	that is,
1908	(All accesses are assumed to be raw for this description.)	2001	all its numeric keys comprise the set <em>{1..n}</em> for some integer <em>n</em>.
1909	For a regular array, where all non-nil values	2002	In that case, <em>n</em> is its length.
1910	have keys from 1 to a given <code>n</code>,	2003	Note that a table like
1911	its length is exactly that <code>n</code>,	2004
1912	the index of its last value.	2005	<pre>
1913	If the array has "holes"	2006	{10, 20, nil, 40}
1914	(that is, <b>nil</b> values between other non-nil values),	2007	</pre><p>
1915	then <code>#t</code> can be any of the indices that	2008	is not a sequence, because it has the key <code>4</code>
1916	directly precedes a <b>nil</b> value	2009	but does not have the key <code>3</code>.
1917	(that is, it may consider any such <b>nil</b> value as the end of	2010	(So, there is no <em>n</em> such that the set <em>{1..n}</em> is equal
1918	the array).	2011	to the set of numeric keys of that table.)
		2012	Note, however, that non-numeric keys do not interfere
		2013	with whether a table is a sequence.
1919		2014
1920		2015
1921	<p>	2016	<p>
1922	A program can modify the behavior of the length operator for	2017	A program can modify the behavior of the length operator for
1923	any value but strings through metamethods (see <a href="#2.4">§2.4</a>).	2018	any value but strings through the <code>__len</code> metamethod (see <a href="#2.4">§2.4</a>).
1924		2019
1925		2020
1926		2021
@@ -1999,9 +2094,6 @@ If the last field in the list has the form <code>exp</code> · 72 unmodified lines
1999	and the expression is a function call or a vararg expression,	2094	and the expression is a function call or a vararg expression,
2000	then all values returned by this expression enter the list consecutively	2095	then all values returned by this expression enter the list consecutively
2001	(see <a href="#3.4.9">§3.4.9</a>).	2096	(see <a href="#3.4.9">§3.4.9</a>).
2002	To avoid this,
2003	enclose the function call or the vararg expression
2004	in parentheses (see <a href="#3.4">§3.4</a>).
2005		2097
2006		2098
2007	<p>	2099	<p>
@@ -2060,7 +2152,7 @@ that is, the argument list is a single literal string. · 52 unmodified lines
2060		2152
2061		2153
2062	<p>	2154	<p>
2063	A call of the form <code>return</code> <em>functioncall</em> is called	2155	A call of the form <code>return <em>functioncall</em></code> is called
2064	a <em>tail call</em>.	2156	a <em>tail call</em>.
2065	Lua implements <em>proper tail calls</em>	2157	Lua implements <em>proper tail calls</em>
2066	(or <em>proper tail recursion</em>):	2158	(or <em>proper tail recursion</em>):
@@ -2093,7 +2185,7 @@ So, none of the following examples are tail calls: · 26 unmodified lines
2093	The syntax for function definition is	2185	The syntax for function definition is
2094		2186
2095	<pre>	2187	<pre>
2096	function ::= <b>function</b> funcbody	2188	functiondef ::= <b>function</b> funcbody
2097	funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>	2189	funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>
2098	</pre>	2190	</pre>
2099		2191
@@ -2135,7 +2227,7 @@ translates to · 35 unmodified lines
2135	<pre>	2227	<pre>
2136	local f; f = function () <em>body</em> end	2228	local f; f = function () <em>body</em> end
2137	</pre><p>	2229	</pre><p>
2138	<em>not</em> to	2230	not to
2139		2231
2140	<pre>	2232	<pre>
2141	local f = function () <em>body</em> end	2233	local f = function () <em>body</em> end
@@ -2153,8 +2245,6 @@ Then, whenever Lua executes the function definition, · 11 unmodified lines
2153	the function is <em>instantiated</em> (or <em>closed</em>).	2245	the function is <em>instantiated</em> (or <em>closed</em>).
2154	This function instance (or <em>closure</em>)	2246	This function instance (or <em>closure</em>)
2155	is the final value of the expression.	2247	is the final value of the expression.
2156	Different instances of the same function
2157	can refer to different external local variables.
2158		2248
2159		2249
2160	<p>	2250	<p>
@@ -2249,9 +2339,9 @@ is syntactic sugar for · 88 unmodified lines
2249	<p>	2339	<p>
2250		2340
2251	Lua is a lexically scoped language.	2341	Lua is a lexically scoped language.
2252	The scope of variables begins at the first statement <em>after</em>	2342	The scope of a local variable begins at the first statement after
2253	their declaration and lasts until the end of the innermost block that	2343	its declaration and lasts until the last non-void statement
2254	includes the declaration.	2344	of the innermost block that includes the declaration.
2255	Consider the following example:	2345	Consider the following example:
2256		2346
2257	<pre>	2347	<pre>
@@ -2356,9 +2446,9 @@ For convenience, · 98 unmodified lines
2356	most query operations in the API do not follow a strict stack discipline.	2446	most query operations in the API do not follow a strict stack discipline.
2357	Instead, they can refer to any element in the stack	2447	Instead, they can refer to any element in the stack
2358	by using an <em>index</em>:	2448	by using an <em>index</em>:
2359	A positive index represents an <em>absolute</em> stack position	2449	A positive index represents an absolute stack position
2360	(starting at 1);	2450	(starting at 1);
2361	a negative index represents an <em>offset</em> relative to the top of the stack.	2451	a negative index represents an offset relative to the top of the stack.
2362	More specifically, if the stack has <em>n</em> elements,	2452	More specifically, if the stack has <em>n</em> elements,
2363	then index 1 represents the first element	2453	then index 1 represents the first element
2364	(that is, the element that was pushed onto the stack first)	2454	(that is, the element that was pushed onto the stack first)
@@ -2594,7 +2684,7 @@ because its frame in the C stack was destroyed by the yield. · 229 unmodified lines
2594	Instead, Lua calls a <em>continuation function</em>,	2684	Instead, Lua calls a <em>continuation function</em>,
2595	which was given as an argument to the callee function.	2685	which was given as an argument to the callee function.
2596	As the name implies,	2686	As the name implies,
2597	the continuation function should continue the task	2687	the continuation function should continue the task
2598	of the original function.	2688	of the original function.
2599		2689
2600		2690
@@ -2684,8 +2774,7 @@ is being allocated; · 83 unmodified lines
2684		2774
2685	<p>	2775	<p>
2686	When <code>ptr</code> is not <code>NULL</code>,	2776	When <code>ptr</code> is not <code>NULL</code>,
2687	<code>osize</code> is the previous size of the block	2777	<code>osize</code> is the size of the block pointed by <code>ptr</code>,
2688	pointed by <code>ptr</code>,
2689	that is, the size given when it was allocated or reallocated.	2778	that is, the size given when it was allocated or reallocated.
2690		2779
2691		2780
@@ -2705,18 +2794,14 @@ Lua assumes the following behavior from the allocator function: · 13 unmodified lines
2705		2794
2706		2795
2707	<p>	2796	<p>
2708	When <code>nsize</code> is zero:	2797	When <code>nsize</code> is zero,
2709	if <code>ptr</code> is not <code>NULL</code>,	2798	the allocator should behave like <code>free</code>
2710	the allocator should free the block pointed to by <code>ptr</code>.	2799	and return <code>NULL</code>.
2711	Anyway, the allocator must return <code>NULL</code>.
2712		2800
2713		2801
2714	<p>	2802	<p>
2715	When <code>nsize</code> is not zero:	2803	When <code>nsize</code> is not zero,
2716	if <code>ptr</code> is <code>NULL</code>,	2804	the allocator should behave like <code>realloc</code>.
2717	the allocator should behave like <code>malloc</code>;
2718	when <code>ptr</code> is not <code>NULL</code>,
2719	the allocator behaves like <code>realloc</code>.
2720	The allocator returns <code>NULL</code>	2805	The allocator returns <code>NULL</code>
2721	if and only if it cannot fill the request.	2806	if and only if it cannot fill the request.
2722	Lua assumes that the allocator never fails when	2807	Lua assumes that the allocator never fails when
@@ -2751,12 +2836,14 @@ but it seems a safe assumption. · 28 unmodified lines
2751		2836
2752		2837
2753	<hr><h3><a name="lua_arith"><code>lua_arith</code></a></h3><p>	2838	<hr><h3><a name="lua_arith"><code>lua_arith</code></a></h3><p>
2754	<span class="apii">[-2, +1, <em>e</em>]</span>	2839	<span class="apii">[-(2/1), +1, <em>e</em>]</span>
2755	<pre>int lua_arith (lua_State *L, int op);</pre>	2840	<pre>int lua_arith (lua_State *L, int op);</pre>
2756		2841
2757	<p>	2842	<p>
2758	Performs an arithmetic operation over the two values at the top	2843	Performs an arithmetic operation over the two values
2759	of the stack (with the value at the top being the second operand),	2844	(or one, in the case of negation)
		2845	at the top of the stack,
		2846	with the value at the top being the second operand,
2760	pops these values, and pushes the result of the operation.	2847	pops these values, and pushes the result of the operation.
2761	The function follows the semantics of the corresponding Lua operator	2848	The function follows the semantics of the corresponding Lua operator
2762	(that is, it may call metamethods).	2849	(that is, it may call metamethods).
@@ -2824,7 +2911,7 @@ when the function is called. · 61 unmodified lines
2824	The function results are pushed onto the stack when the function returns.	2911	The function results are pushed onto the stack when the function returns.
2825	The number of results is adjusted to <code>nresults</code>,	2912	The number of results is adjusted to <code>nresults</code>,
2826	unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.	2913	unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
2827	In this case, <em>all</em> results from the function are pushed.	2914	In this case, all results from the function are pushed.
2828	Lua takes care that the returned values fit into the stack space.	2915	Lua takes care that the returned values fit into the stack space.
2829	The function results are pushed onto the stack in direct order	2916	The function results are pushed onto the stack in direct order
2830	(the first result is pushed first),	2917	(the first result is pushed first),
@@ -3028,10 +3115,13 @@ without shifting any element · 197 unmodified lines
3028		3115
3029	<p>	3116	<p>
3030	Creates a new empty table and pushes it onto the stack.	3117	Creates a new empty table and pushes it onto the stack.
3031	The new table has space pre-allocated	3118	Parameter <code>narr</code> is a hint for how many elements the table
3032	for <code>narr</code> array elements and <code>nrec</code> non-array elements.	3119	will have as a sequence;
3033	This pre-allocation is useful when you know exactly how many elements	3120	parameter <code>nrec</code> is a hint for how many other elements
3034	the table will have.	3121	the table will have.
		3122	Lua may use these hints to preallocate memory for the new table.
		3123	This pre-allocation is useful for performance when you know in advance
		3124	how many elements the table will have.
3035	Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.	3125	Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.
3036		3126
3037		3127
@@ -3147,6 +3237,11 @@ returns a boolean that tells whether the collector is running · 109 unmodified lines
3147		3237
3148	</ul>	3238	</ul>
3149		3239
		3240	<p>
		3241	For more details about some options,
		3242	see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.
		3243
		3244
3150		3245
3151		3246
3152		3247
@@ -3655,7 +3750,7 @@ A typical traversal looks like this: · 502 unmodified lines
3655	While traversing a table,	3750	While traversing a table,
3656	do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,	3751	do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key,
3657	unless you know that the key is actually a string.	3752	unless you know that the key is actually a string.
3658	Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> <em>changes</em>	3753	Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> may change
3659	the value at the given index;	3754	the value at the given index;
3660	this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.	3755	this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>.
3661		3756
@@ -3683,7 +3778,7 @@ Lua to operate with another type for numbers (e.g., float or long). · 21 unmodified lines
3683		3778
3684	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>	3779	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
3685	<span class="apii">[-(nargs + 1), +(nresults\|1), <em>-</em>]</span>	3780	<span class="apii">[-(nargs + 1), +(nresults\|1), <em>-</em>]</span>
3686	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);</pre>	3781	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>
3687		3782
3688	<p>	3783	<p>
3689	Calls a function in protected mode.	3784	Calls a function in protected mode.
@@ -3704,19 +3799,20 @@ and its arguments from the stack. · 14 unmodified lines
3704		3799
3705		3800
3706	<p>	3801	<p>
3707	If <code>errfunc</code> is 0,	3802	If <code>msgh</code> is 0,
3708	then the error message returned on the stack	3803	then the error message returned on the stack
3709	is exactly the original error message.	3804	is exactly the original error message.
3710	Otherwise, <code>errfunc</code> is the stack index of an	3805	Otherwise, <code>msgh</code> is the stack index of a
3711	<em>error handler function</em>.	3806	<em>message handler</em>.
3712	(In the current implementation, this index cannot be a pseudo-index.)	3807	(In the current implementation, this index cannot be a pseudo-index.)
3713	In case of runtime errors,	3808	In case of runtime errors,
3714	this function will be called with the error message	3809	this function will be called with the error message
3715	and its return value will be the message returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.	3810	and its return value will be the message
		3811	returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>.
3716		3812
3717		3813
3718	<p>	3814	<p>
3719	Typically, the error handler function is used to add more debug	3815	Typically, the message handler is used to add more debug
3720	information to the error message, such as a stack traceback.	3816	information to the error message, such as a stack traceback.
3721	Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,	3817	Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>,
3722	since by then the stack has unwound.	3818	since by then the stack has unwound.
@@ -3737,11 +3833,11 @@ a runtime error. · 14 unmodified lines
3737		3833
3738	<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>:</b>	3834	<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>:</b>
3739	memory allocation error.	3835	memory allocation error.
3740	For such errors, Lua does not call the error handler function.	3836	For such errors, Lua does not call the message handler.
3741	</li>	3837	</li>
3742		3838
3743	<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>:</b>	3839	<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>:</b>
3744	error while running the error handler function.	3840	error while running the message handler.
3745	</li>	3841	</li>
3746		3842
3747	<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>:</b>	3843	<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>:</b>
@@ -3944,7 +4040,8 @@ onto the stack. · 196 unmodified lines
3944	Lua makes (or reuses) an internal copy of the given string,	4040	Lua makes (or reuses) an internal copy of the given string,
3945	so the memory at <code>s</code> can be freed or reused immediately after	4041	so the memory at <code>s</code> can be freed or reused immediately after
3946	the function returns.	4042	the function returns.
3947	The string can contain embedded zeros.	4043	The string can contain any binary data,
		4044	including embedded zeros.
3948		4045
3949		4046
3950	<p>	4047	<p>
@@ -3986,8 +4083,6 @@ onto the stack. · 35 unmodified lines
3986	Lua makes (or reuses) an internal copy of the given string,	4083	Lua makes (or reuses) an internal copy of the given string,
3987	so the memory at <code>s</code> can be freed or reused immediately after	4084	so the memory at <code>s</code> can be freed or reused immediately after
3988	the function returns.	4085	the function returns.
3989	The string should not contain embedded zeros;
3990	it is assumed to end at the first zero.
3991		4086
3992		4087
3993	<p>	4088	<p>
@@ -4249,14 +4344,11 @@ with user data <code>ud</code>. · 255 unmodified lines
4249		4344
4250	<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p>	4345	<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p>
4251	<span class="apii">[-1, +0, <em>-</em>]</span>	4346	<span class="apii">[-1, +0, <em>-</em>]</span>
4252	<pre>int lua_setuservalue (lua_State *L, int index);</pre>	4347	<pre>void lua_setuservalue (lua_State *L, int index);</pre>
4253		4348
4254	<p>	4349	<p>
4255	Pops a table or <b>nil</b> from the stack and sets it as	4350	Pops a table or <b>nil</b> from the stack and sets it as
4256	the new value associated to the userdata at the given index.	4351	the new value associated to the userdata at the given index.
4257	If the value at the given index is not a userdata,
4258	<code>lua_setuservalue</code> returns 0.
4259	Otherwise it returns 1.
4260		4352
4261		4353
4262		4354
@@ -4296,7 +4388,7 @@ It is defined as a macro. · 33 unmodified lines
4296		4388
4297	<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>	4389	<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p>
4298	<span class="apii">[-1, +0, <em>-</em>]</span>	4390	<span class="apii">[-1, +0, <em>-</em>]</span>
4299	<pre>int lua_setmetatable (lua_State *L, int index);</pre>	4391	<pre>void lua_setmetatable (lua_State *L, int index);</pre>
4300		4392
4301	<p>	4393	<p>
4302	Pops a table from the stack and	4394	Pops a table from the stack and
@@ -4716,7 +4808,7 @@ calling the writer again. · 413 unmodified lines
4716	<pre>void lua_xmove (lua_State from, lua_State to, int n);</pre>	4808	<pre>void lua_xmove (lua_State from, lua_State to, int n);</pre>
4717		4809
4718	<p>	4810	<p>
4719	Exchange values between different threads of the <em>same</em> global state.	4811	Exchange values between different threads of the same global state.
4720		4812
4721		4813
4722	<p>	4814	<p>
@@ -5033,17 +5125,14 @@ In the first case, · 310 unmodified lines
5033	the parameter <code>ar</code> must be a valid activation record that was	5125	the parameter <code>ar</code> must be a valid activation record that was
5034	filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or	5126	filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or
5035	given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).	5127	given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
5036	The index <code>n</code> selects which local variable to inspect	5128	The index <code>n</code> selects which local variable to inspect;
5037	(1 is the first parameter or active local variable, and so on,	5129	see <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for details about variable indices
5038	until the last active local variable).	5130	and names.
5039	<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
5040	and returns its name.
5041		5131
5042		5132
5043	<p>	5133	<p>
5044	Variable names starting with '<code>(</code>' (open parentheses)	5134	<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack
5045	represent internal variables	5135	and returns its name.
5046	(loop control variables, temporaries, and C function locals).
5047		5136
5048		5137
5049	<p>	5138	<p>
@@ -5176,7 +5265,8 @@ before the function gets its arguments. · 126 unmodified lines
5176		5265
5177	<li><b>The return hook:</b> is called when the interpreter returns from a function.	5266	<li><b>The return hook:</b> is called when the interpreter returns from a function.
5178	The hook is called just before Lua leaves the function.	5267	The hook is called just before Lua leaves the function.
5179	You have no access to the values to be returned by the function.	5268	There is no standard way to access the values
		5269	to be returned by the function.
5180	</li>	5270	</li>
5181		5271
5182	<li><b>The line hook:</b> is called when the interpreter is about to	5272	<li><b>The line hook:</b> is called when the interpreter is about to
@@ -5285,7 +5375,7 @@ refer to the <code>n2</code>-th upvalue of the Lua closure at index <code>fidx2< · 102 unmodified lines
5285		5375
5286	The <em>auxiliary library</em> provides several convenient functions	5376	The <em>auxiliary library</em> provides several convenient functions
5287	to interface C with Lua.	5377	to interface C with Lua.
5288	While the basic API provides the primitive functions for all	5378	While the basic API provides the primitive functions for all
5289	interactions between C and Lua,	5379	interactions between C and Lua,
5290	the auxiliary library provides higher-level functions for some	5380	the auxiliary library provides higher-level functions for some
5291	common tasks.	5381	common tasks.
@@ -5816,15 +5906,28 @@ as <code>return luaL_error(<em>args</em>)</code>. · 524 unmodified lines
5816		5906
5817		5907
5818		5908
5819	<hr><h3><a name="luaL_findtable"><code>luaL_findtable</code></a></h3><p>	5909	<hr><h3><a name="luaL_execresult"><code>luaL_execresult</code></a></h3><p>
5820	<span class="apii">[-0, +1, <em>m</em>]</span>	5910	<span class="apii">[-0, +(1/3), <em>m</em>]</span>
5821	<pre>void luaL_findtable (lua_State L, int idx, const char fname);</pre>	5911	<pre>int luaL_execresult (lua_State *L, int stat);</pre>
5822		5912
5823	<p>	5913	<p>
5824	Ensures that the value <code>t[fname]</code>,	5914	This function produces the return values for
5825	where <code>t</code> is the value at the valid index <code>idx</code>,	5915	process-related functions in the standard library
5826	is a table,	5916	(<a href="#pdf-os.execute"><code>os.execute</code></a> and <a href="#pdf-io.close"><code>io.close</code></a>).
5827	and pushes that table onto the stack.	5917
		5918
		5919
		5920
		5921
		5922	<hr><h3><a name="luaL_fileresult"><code>luaL_fileresult</code></a></h3><p>
		5923	<span class="apii">[-0, +(1/3), <em>m</em>]</span>
		5924	<pre>int luaL_fileresult (lua_State *L, int stat,
		5925	const char *fname)</pre>
		5926
		5927	<p>
		5928	This function produces the return values for
		5929	file-related functions in the standard library
		5930	(<a href="#pdf-io.open"><code>io.open</code></a>, <a href="#pdf-os.rename"><code>os.rename</code></a>, <a href="#pdf-file:seek"><code>file:seek</code></a>, etc.).
5828		5931
5829		5932
5830		5933
@@ -5857,6 +5960,22 @@ in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code> · 26 unmodified lines
5857		5960
5858		5961
5859		5962
		5963	<hr><h3><a name="luaL_getsubtable"><code>luaL_getsubtable</code></a></h3><p>
		5964	<span class="apii">[-0, +1, <em>m</em>]</span>
		5965	<pre>int luaL_getsubtable (lua_State L, int idx, const char fname);</pre>
		5966
		5967	<p>
		5968	Ensures that the value <code>t[fname]</code>,
		5969	where <code>t</code> is the value at the valid index <code>idx</code>,
		5970	is a table,
		5971	and pushes that table onto the stack.
		5972	Returns true if it finds a previous table there
		5973	and false if it creates a new table.
		5974
		5975
		5976
		5977
		5978
5860	<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>	5979	<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p>
5861	<span class="apii">[-0, +1, <em>m</em>]</span>	5980	<span class="apii">[-0, +1, <em>m</em>]</span>
5862	<pre>const char luaL_gsub (lua_State L,	5981	<pre>const char luaL_gsub (lua_State L,
@@ -5965,13 +6084,27 @@ it does not run it. · 102 unmodified lines
5965	<pre>int luaL_newlib (lua_State L, const luaL_Reg l);</pre>	6084	<pre>int luaL_newlib (lua_State L, const luaL_Reg l);</pre>
5966		6085
5967	<p>	6086	<p>
5968	Equivalent to <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> with no upvalues,	6087	Creates a new table and registers there
5969	but first creates a new table wherein to register the functions	6088	the functions in list <code>l</code>.
5970	in list <code>l</code>.	6089	It is implemented as the following macro:
		6090
		6091	<pre>
		6092	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
		6093	</pre>
		6094
		6095
		6096
5971		6097
		6098	<hr><h3><a name="luaL_newlibtable"><code>luaL_newlibtable</code></a></h3><p>
		6099	<span class="apii">[-0, +1, <em>m</em>]</span>
		6100	<pre>int luaL_newlibtable (lua_State L, const luaL_Reg l);</pre>
5972		6101
5973	<p>	6102	<p>
5974	Leaves the new table on the stack.	6103	Creates a new table with a size optimized
		6104	to store all entries in the array <code>l</code>
		6105	(but does not actually store them).
		6106	It is intended to be used in conjunction with <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>
		6107	(see <a href="#luaL_newlib"><code>luaL_newlib</code></a>).
5975		6108
5976		6109
5977	<p>	6110	<p>
@@ -6176,7 +6309,7 @@ Returns an address to a space of size <code>sz</code> · 198 unmodified lines
6176	where you can copy a string to be added to buffer <code>B</code>	6309	where you can copy a string to be added to buffer <code>B</code>
6177	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).	6310	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
6178	After copying the string into this space you must call	6311	After copying the string into this space you must call
6179	<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add	6312	<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add
6180	it to the buffer.	6313	it to the buffer.
6181		6314
6182		6315
@@ -6284,8 +6417,6 @@ Leaves a copy of that result on the stack. · 101 unmodified lines
6284	Registers all functions in the array <code>l</code>	6417	Registers all functions in the array <code>l</code>
6285	(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack	6418	(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack
6286	(below optional upvalues, see next).	6419	(below optional upvalues, see next).
6287	The pointer <code>l</code> may be <code>NULL</code>,
6288	representing an empty list.
6289		6420
6290		6421
6291	<p>	6422	<p>
@@ -6495,7 +6626,7 @@ e.g., by using <a href="#lua_call"><code>lua_call</code></a>. · 203 unmodified lines
6495	<p>	6626	<p>
6496	The basic library provides some core functions to Lua.	6627	The basic library provides some core functions to Lua.
6497	If you do not include this library in your application,	6628	If you do not include this library in your application,
6498	you should check carefully whether you need to provide	6629	you should check carefully whether you need to provide
6499	implementations for some of its facilities.	6630	implementations for some of its facilities.
6500		6631
6501		6632
@@ -6526,11 +6657,13 @@ This is the default option. · 24 unmodified lines
6526	</li>	6657	</li>
6527		6658
6528	<li><b>"stop":</b>	6659	<li><b>"stop":</b>
6529	stops the garbage collector.	6660	stops automatic invocation of the garbage collector.
		6661	The collector will run only when explcitly invoked,
		6662	until a call to restart it.
6530	</li>	6663	</li>
6531		6664
6532	<li><b>"restart":</b>	6665	<li><b>"restart":</b>
6533	restarts the garbage collector.	6666	restarts automatic invocation the garbage collector.
6534	</li>	6667	</li>
6535		6668
6536	<li><b>"count":</b>	6669	<li><b>"count":</b>
@@ -6543,6 +6676,8 @@ so the following equality is always true: · 6 unmodified lines
6543	k, b = collectgarbage("count")	6676	k, b = collectgarbage("count")
6544	assert(k1024 == math.floor(k)1024 + b)	6677	assert(k1024 == math.floor(k)1024 + b)
6545	</pre><p>	6678	</pre><p>
		6679	(The second result is useful when Lua is compiled
		6680	with a non floating-point type for numbers.)
6546	</li>	6681	</li>
6547		6682
6548	<li><b>"step":</b>	6683	<li><b>"step":</b>
@@ -6658,7 +6793,7 @@ up to the first integer key absent from the table. · 109 unmodified lines
6658		6793
6659		6794
6660	<p>	6795	<p>
6661	<hr><h3><a name="pdf-load"><code>load (ld [, source [, mode]])</code></a></h3>	6796	<hr><h3><a name="pdf-load"><code>load (ld [, source [, mode [, env]]])</code></a></h3>
6662		6797
6663		6798
6664	<p>	6799	<p>
@@ -6666,32 +6801,35 @@ Loads a chunk. · 1 unmodified line
6666		6801
6667		6802
6668	<p>	6803	<p>
		6804	If <code>ld</code> is a string, the chunk is this string.
6669	If <code>ld</code> is a function,	6805	If <code>ld</code> is a function,
6670	calls it repeatedly to get the chunk pieces.	6806	<code>load</code> calls it repeatedly to get the chunk pieces.
6671	Each call to <code>ld</code> must return a string that concatenates	6807	Each call to <code>ld</code> must return a string that concatenates
6672	with previous results.	6808	with previous results.
6673	A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.	6809	A return of an empty string, <b>nil</b>, or no value signals the end of the chunk.
6674		6810
6675		6811
6676	<p>	6812	<p>
6677	If <code>ld</code> is a string, the chunk is this string.	6813	If there are no errors,
		6814	returns the compiled chunk as a function;
		6815	otherwise, returns <b>nil</b> plus the error message.
6678		6816
6679		6817
6680	<p>	6818	<p>
6681	If there are no errors,
6682	returns the compiled chunk as a function;
6683	otherwise, returns <b>nil</b> plus the error message.
6684	If the resulting function has upvalues,	6819	If the resulting function has upvalues,
6685	the first upvalue is set to the value of the global environment	6820	the first upvalue is set to the value of the
		6821	global environment or to <code>env</code>,
		6822	if that parameter is given.
6686	(When loading main chunks,	6823	(When loading main chunks,
6687	this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).)	6824	the first upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).)
6688		6825
6689		6826
6690	<p>	6827	<p>
6691	<code>source</code> is used as the source of the chunk for error messages	6828	<code>source</code> is used as the source of the chunk for error messages
6692	and debug information (see <a href="#4.9">§4.9</a>).	6829	and debug information (see <a href="#4.9">§4.9</a>).
6693	When absent,	6830	When absent,
6694	it defaults to "<code>=(load)</code>".	6831	it defaults to <code>ld</code>, if <code>ld</code> is a string,
		6832	or to "<code>=(load)</code>".
6695		6833
6696		6834
6697	<p>	6835	<p>
@@ -6704,21 +6842,6 @@ The default is "<code>bt</code>". · 6 unmodified lines
6704		6842
6705		6843
6706		6844
6707	<p>
6708	<hr><h3><a name="pdf-loadin"><code>loadin (env, ...)</code></a></h3>
6709
6710
6711	<p>
6712	This function is similar to <a href="#pdf-load"><code>load</code></a>,
6713	but sets <code>env</code> as the value of the first upvalue
6714	of the created function in case of success.
6715	(When loading main chunks,
6716	this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>).)
6717	The parameters after <code>env</code> are similar to those of <a href="#pdf-load"><code>load</code></a>, too.
6718
6719
6720
6721
6722	<p>	6845	<p>
6723	<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename])</code></a></h3>	6846	<hr><h3><a name="pdf-loadfile"><code>loadfile ([filename])</code></a></h3>
6724		6847
@@ -6732,29 +6855,6 @@ if no file name is given. · 7 unmodified lines
6732		6855
6733		6856
6734		6857
6735	<p>
6736	<hr><h3><a name="pdf-loadstring"><code>loadstring (string [, chunkname])</code></a></h3>
6737
6738
6739	<p>
6740	Similar to <a href="#pdf-load"><code>load</code></a>,
6741	but gets the chunk from the given string.
6742
6743
6744	<p>
6745	To load and run a given string, use the idiom
6746
6747	<pre>
6748	assert(loadstring(s))()
6749	</pre>
6750
6751	<p>
6752	When absent,
6753	<code>chunkname</code> defaults to the given string.
6754
6755
6756
6757
6758	<p>	6858	<p>
6759	<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>	6859	<hr><h3><a name="pdf-next"><code>next (table [, index])</code></a></h3>
6760		6860
@@ -6784,7 +6884,7 @@ use a numerical <b>for</b>.) · 23 unmodified lines
6784		6884
6785		6885
6786	<p>	6886	<p>
6787	The behavior of <code>next</code> is <em>undefined</em> if,	6887	The behavior of <code>next</code> is undefined if,
6788	during the traversal,	6888	during the traversal,
6789	you assign any value to a non-existent field in the table.	6889	you assign any value to a non-existent field in the table.
6790	You may however modify existing fields.	6890	You may however modify existing fields.
@@ -6872,6 +6972,16 @@ without invoking any metamethod. · 81 unmodified lines
6872		6972
6873		6973
6874		6974
		6975	<p>
		6976	<hr><h3><a name="pdf-rawlen"><code>rawlen (v)</code></a></h3>
		6977	Returns the length of the object <code>v</code>,
		6978	which must be a table or a string,
		6979	without invoking any metamethod.
		6980	Returns an integer number.
		6981
		6982
		6983
		6984
6875	<p>	6985	<p>
6876	<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>	6986	<hr><h3><a name="pdf-rawset"><code>rawset (table, index, value)</code></a></h3>
6877	Sets the real value of <code>table[index]</code> to <code>value</code>,	6987	Sets the real value of <code>table[index]</code> to <code>value</code>,
@@ -6934,9 +7044,9 @@ The base may be any integer between 2 and 36, inclusive. · 56 unmodified lines
6934	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)	7044	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)
6935	represents 10, '<code>B</code>' represents 11, and so forth,	7045	represents 10, '<code>B</code>' represents 11, and so forth,
6936	with '<code>Z</code>' representing 35.	7046	with '<code>Z</code>' representing 35.
6937	In base 10 (the default), the number can have a decimal part,	7047	In base 10 (the default),
6938	as well as an optional exponent part (see <a href="#3.1">§3.1</a>).	7048	the numeral is converted following the coercion rules (see <a href="#3.4.2">§3.4.2</a>).
6939	In other bases, only unsigned integers are accepted.	7049	In other bases, only integers are accepted.
6940		7050
6941		7051
6942		7052
@@ -6984,12 +7094,12 @@ The current contents of this variable is "<code>Lua 5.2</code>". · 41 unmodified lines
6984		7094
6985		7095
6986	<p>	7096	<p>
6987	<hr><h3><a name="pdf-xpcall"><code>xpcall (f, err [, arg1, ···])</code></a></h3>	7097	<hr><h3><a name="pdf-xpcall"><code>xpcall (f, msgh [, arg1, ···])</code></a></h3>
6988		7098
6989		7099
6990	<p>	7100	<p>
6991	This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,	7101	This function is similar to <a href="#pdf-pcall"><code>pcall</code></a>,
6992	except that it sets a new error handler <code>err</code>.	7102	except that it sets a new message handler <code>msgh</code>.
6993		7103
6994		7104
6995		7105
@@ -7130,8 +7240,8 @@ Otherwise, it tries to find a <em>loader</em> for the module. · 134 unmodified lines
7130		7240
7131	<p>	7241	<p>
7132	To find a loader,	7242	To find a loader,
7133	<code>require</code> is guided by the <a href="#pdf-package.loaders"><code>package.loaders</code></a> array.	7243	<code>require</code> is guided by the <a href="#pdf-package.loaders"><code>package.loaders</code></a> sequence.
7134	By changing this array,	7244	By changing this sequence,
7135	we can change how <code>require</code> looks for a module.	7245	we can change how <code>require</code> looks for a module.
7136	The following explanation is based on the default configuration	7246	The following explanation is based on the default configuration
7137	for <a href="#pdf-package.loaders"><code>package.loaders</code></a>.	7247	for <a href="#pdf-package.loaders"><code>package.loaders</code></a>.
@@ -7151,7 +7261,10 @@ it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.loaders"><code · 13 unmodified lines
7151		7261
7152	<p>	7262	<p>
7153	Once a loader is found,	7263	Once a loader is found,
7154	<code>require</code> calls the loader with a single argument, <code>modname</code>.	7264	<code>require</code> calls the loader with two arguments:
		7265	<code>modname</code> and an extra value dependent on how it got the loader.
		7266	(If the loader came from a file,
		7267	this extra value is the file name.)
7155	If the loader returns any non-nil value,	7268	If the loader returns any non-nil value,
7156	<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.	7269	<code>require</code> assigns the returned value to <code>package.loaded[modname]</code>.
7157	If the loader does not return a non-nil value and	7270	If the loader does not return a non-nil value and
@@ -7164,7 +7277,7 @@ final value of <code>package.loaded[modname]</code>. · 6 unmodified lines
7164	<p>	7277	<p>
7165	If there is any error loading or running the module,	7278	If there is any error loading or running the module,
7166	or if it cannot find any loader for the module,	7279	or if it cannot find any loader for the module,
7167	then <code>require</code> signals an error.	7280	then <code>require</code> signals an error.
7168		7281
7169		7282
7170		7283
@@ -7255,9 +7368,13 @@ When looking for a module, · 84 unmodified lines
7255	with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its	7368	with the module name (the argument given to <a href="#pdf-require"><code>require</code></a>) as its
7256	sole parameter.	7369	sole parameter.
7257	The function can return another function (the module <em>loader</em>)	7370	The function can return another function (the module <em>loader</em>)
		7371	plus an extra value that will be passed to that loader,
7258	or a string explaining why it did not find that module	7372	or a string explaining why it did not find that module
7259	(or <b>nil</b> if it has nothing to say).	7373	(or <b>nil</b> if it has nothing to say).
7260	Lua initializes this table with four functions.	7374
		7375
		7376	<p>
		7377	Lua initializes this table with four searcher functions.
7261		7378
7262		7379
7263	<p>	7380	<p>
@@ -7313,6 +7430,13 @@ into one single library, · 49 unmodified lines
7313	with each submodule keeping its original open function.	7430	with each submodule keeping its original open function.
7314		7431
7315		7432
		7433	<p>
		7434	All searchers except the first (preload) return as the extra value
		7435	the file name where the module was found,
		7436	as returned by <a href="#pdf-package.searchpath"><code>package.searchpath</code></a>.
		7437	The first searcher returns no extra value.
		7438
		7439
7316		7440
7317		7441
7318	<p>	7442	<p>
@@ -7384,10 +7508,16 @@ A table to store loaders for specific modules · 65 unmodified lines
7384	(see <a href="#pdf-require"><code>require</code></a>).	7508	(see <a href="#pdf-require"><code>require</code></a>).
7385		7509
7386		7510
		7511	<p>
		7512	This variable is only a reference to the real table;
		7513	assignments to this variable do not change the
		7514	table used by <a href="#pdf-require"><code>require</code></a>.
		7515
		7516
7387		7517
7388		7518
7389	<p>	7519	<p>
7390	<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path)</code></a></h3>	7520	<hr><h3><a name="pdf-package.searchpath"><code>package.searchpath (name, path [, sep])</code></a></h3>
7391		7521
7392		7522
7393	<p>	7523	<p>
@@ -7400,8 +7530,15 @@ A path is string containing a sequence of · 6 unmodified lines
7400	For each template,	7530	For each template,
7401	the function changes each interrogation	7531	the function changes each interrogation
7402	mark in the template by a copy of <code>name</code>	7532	mark in the template by a copy of <code>name</code>
7403	wherein all dots were replaced by the system's directory separator,	7533	wherein all occurrences of <code>sep</code>
		7534	(a dot, by default)
		7535	were replaced by the system's directory separator,
7404	and then tries to open the resulting file name.	7536	and then tries to open the resulting file name.
		7537	If <code>sep</code> is the empty string,
		7538	the replacement is not done.
		7539
		7540
		7541	<p>
7405	For instance, if the path is the string	7542	For instance, if the path is the string
7406		7543
7407	<pre>	7544	<pre>
@@ -7485,9 +7622,8 @@ Note that numerical codes are not necessarily portable across platforms. · 77 unmodified lines
7485		7622
7486	<p>	7623	<p>
7487	Returns a string containing a binary representation of the given function,	7624	Returns a string containing a binary representation of the given function,
7488	so that a later <a href="#pdf-loadstring"><code>loadstring</code></a> on this string returns	7625	so that a later <a href="#pdf-load"><code>load</code></a> on this string returns
7489	a copy of the function.	7626	a copy of the function (but with new upvalues).
7490	<code>function</code> must be a Lua function without upvalues.
7491		7627
7492		7628
7493		7629
@@ -7552,16 +7688,19 @@ will produce the string: · 58 unmodified lines
7552	</pre>	7688	</pre>
7553		7689
7554	<p>	7690	<p>
7555	The options <code>c</code>, <code>d</code>, <code>E</code>, <code>e</code>, <code>f</code>,	7691	Options
7556	<code>g</code>, <code>G</code>, <code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code> all	7692	<code>A</code> and <code>a</code> (when available),
7557	expect a number as argument,	7693	<code>E</code>, <code>e</code>, <code>f</code>,
7558	whereas <code>q</code> and <code>s</code> expect a string.	7694	<code>G</code>, and <code>g</code> all expect a number as argument.
7559		7695	Options <code>c</code>, <code>d</code>,
7560		7696	<code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>
7561	<p>	7697	expect an integer as argument;
7562	This function does not accept string values	7698	the range of that integer may be limited by
7563	containing embedded zeros,	7699	the underlying C implementation.
7564	except as arguments to the <code>q</code> option.	7700	Option <code>q</code> expects a string
		7701	and <code>s</code> expects a string without embedded zeros.
		7702	If the argument to option <code>s</code> is not a string,
		7703	it is converted to one following the same rules of <a href="#pdf-tostring"><code>tostring</code></a>.
7565		7704
7566		7705
7567		7706
@@ -7577,6 +7716,8 @@ then the whole match is produced in each call. · 9 unmodified lines
7577		7716
7578	<p>	7717	<p>
7579	As an example, the following loop	7718	As an example, the following loop
		7719	will iterate over all the words from string <code>s</code>,
		7720	printing one per line:
7580		7721
7581	<pre>	7722	<pre>
7582	s = "hello world from Lua"	7723	s = "hello world from Lua"
@@ -7584,8 +7725,6 @@ As an example, the following loop · 1 unmodified line
7584	print(w)	7725	print(w)
7585	end	7726	end
7586	</pre><p>	7727	</pre><p>
7587	will iterate over all the words from string <code>s</code>,
7588	printing one per line.
7589	The next example collects all pairs <code>key=value</code> from the	7728	The next example collects all pairs <code>key=value</code> from the
7590	given string into a table:	7729	given string into a table:
7591		7730
@@ -7667,7 +7806,7 @@ Here are some examples: · 75 unmodified lines
7667	--> x="home = /home/roberto, user = roberto"	7806	--> x="home = /home/roberto, user = roberto"
7668		7807
7669	x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)	7808	x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
7670	return loadstring(s)()	7809	return load(s)()
7671	end)	7810	end)
7672	--> x="4+5 = 9"	7811	--> x="4+5 = 9"
7673		7812
@@ -7715,9 +7854,11 @@ its default value is 1 and can be negative. · 41 unmodified lines
7715		7854
7716		7855
7717	<p>	7856	<p>
7718	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n)</code></a></h3>	7857	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>
7719	Returns a string that is the concatenation of <code>n</code> copies of	7858	Returns a string that is the concatenation of <code>n</code> copies of
7720	the string <code>s</code>.	7859	the string <code>s</code> separated by the string <code>sep</code>.
		7860	The default value for <code>sep</code> is the empty string
		7861	(that is, no separator).
7721		7862
7722		7863
7723		7864
@@ -7867,7 +8008,7 @@ These repetition items will always match the longest possible sequence; · 143 unmodified lines
7867	a single character class followed by '<code>-</code>',	8008	a single character class followed by '<code>-</code>',
7868	which also matches 0 or more repetitions of characters in the class.	8009	which also matches 0 or more repetitions of characters in the class.
7869	Unlike '<code>*</code>',	8010	Unlike '<code>*</code>',
7870	these repetition items will always match the <em>shortest</em> possible sequence;	8011	these repetition items will always match the shortest possible sequence;
7871	</li>	8012	</li>
7872		8013
7873	<li>	8014	<li>
@@ -7949,41 +8090,55 @@ string <code>"flaaap"</code>, there will be two captures: 3 and 5. · 75 unmodified lines
7949		8090
7950		8091
7951		8092
7952	<h2>6.5 – <a name="6.5">Table Manipulation</a></h2><p>	8093	<h2>6.5 – <a name="6.5">Table Manipulation</a></h2>
		8094
		8095	<p>
7953	This library provides generic functions for table manipulation.	8096	This library provides generic functions for table manipulation.
7954	It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.	8097	It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
7955		8098
7956		8099
7957	<p>	8100	<p>
7958	Most functions in the table library assume that the table	8101	Currently, all functions in the table library assume that the table
7959	represents an array or a list.	8102	represents a list.
7960	For these functions, when we talk about the "length" of a table	8103	In particular, they all ignore non-numeric keys
7961	we mean the result of the length operator.	8104	in tables given as arguments.
		8105	All functions in the table library,
		8106	except <a href="#pdf-table.pack"><code>table.pack</code></a>,
		8107	may apply the length operator on the list.
		8108	In that case, the list must be a proper sequence
		8109	or have a <code>__len</code> metamethod (see <a href="#3.4.6">§3.4.6</a>).
		8110
		8111
		8112	<p>
		8113	For performance reasons,
		8114	all table accesses (get/set) performed by these functions are raw.
		8115
		8116
		8117	<p>
		8118	<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
7962		8119
7963		8120
7964	<p>	8121	<p>
7965	<hr><h3><a name="pdf-table.concat"><code>table.concat (table [, sep [, i [, j]]])</code></a></h3>	8122	Given a list where all elements are strings or numbers,
7966	Given an array where all elements are strings or numbers,	8123	returns <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>.
7967	returns <code>table[i]..sep..table[i+1] ··· sep..table[j]</code>.
7968	The default value for <code>sep</code> is the empty string,	8124	The default value for <code>sep</code> is the empty string,
7969	the default for <code>i</code> is 1,	8125	the default for <code>i</code> is 1,
7970	and the default for <code>j</code> is the length of the table.	8126	and the default for <code>j</code> is <code>#list</code>.
7971	If <code>i</code> is greater than <code>j</code>, returns the empty string.	8127	If <code>i</code> is greater than <code>j</code>, returns the empty string.
7972		8128
7973		8129
7974		8130
7975		8131
7976	<p>	8132	<p>
7977	<hr><h3><a name="pdf-table.insert"><code>table.insert (table, [pos,] value)</code></a></h3>	8133	<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>
7978		8134
7979		8135
7980	<p>	8136	<p>
7981	Inserts element <code>value</code> at position <code>pos</code> in <code>table</code>,	8137	Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
7982	shifting up other elements to open space, if necessary.	8138	shifting up other elements to open space, if necessary.
7983	The default value for <code>pos</code> is <code>n+1</code>,	8139	The default value for <code>pos</code> is <code>#list+1</code>,
7984	where <code>n</code> is the length of the table (see <a href="#3.4.6">§3.4.6</a>),
7985	so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end	8140	so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
7986	of table <code>t</code>.	8141	of list <code>t</code>.
7987		8142
7988		8143
7989		8144
@@ -7993,36 +8148,38 @@ of table <code>t</code>. · 3 unmodified lines
7993		8148
7994		8149
7995	<p>	8150	<p>
7996	Returns a new table with all parameters stored into	8151	Returns a new table with all parameters stored into keys 1, 2, etc.
7997	keys 1, 2, etc.
7998	and with a field "<code>n</code>" with the total number of parameters.	8152	and with a field "<code>n</code>" with the total number of parameters.
		8153	Note that the result may not be a sequence,
		8154	if any parameter is <b>nil</b>.
7999		8155
8000		8156
8001		8157
8002		8158
8003	<p>	8159	<p>
8004	<hr><h3><a name="pdf-table.remove"><code>table.remove (table [, pos])</code></a></h3>	8160	<hr><h3><a name="pdf-table.remove"><code>table.remove (list [, pos])</code></a></h3>
8005		8161
8006		8162
8007	<p>	8163	<p>
8008	Removes from <code>table</code> the element at position <code>pos</code>,	8164	Removes from <code>list</code> the element at position <code>pos</code>,
8009	shifting down other elements to close the space, if necessary.	8165	shifting down other elements to close the space, if necessary.
8010	Returns the value of the removed element.	8166	Returns the value of the removed element.
8011	The default value for <code>pos</code> is <code>n</code>,	8167	The default value for <code>pos</code> is <code>#list</code>,
8012	where <code>n</code> is the length of the table,
8013	so that a call <code>table.remove(t)</code> removes the last element	8168	so that a call <code>table.remove(t)</code> removes the last element
8014	of table <code>t</code>.	8169	of list <code>t</code>.
8015		8170
8016		8171
8017		8172
8018		8173
8019	<p>	8174	<p>
8020	<hr><h3><a name="pdf-table.sort"><code>table.sort (table [, comp])</code></a></h3>	8175	<hr><h3><a name="pdf-table.sort"><code>table.sort (list [, comp])</code></a></h3>
8021	Sorts table elements in a given order, <em>in-place</em>,	8176
8022	from <code>table[1]</code> to <code>table[n]</code>,	8177
8023	where <code>n</code> is the length of the table.	8178	<p>
		8179	Sorts list elements in a given order, <em>in-place</em>,
		8180	from <code>table[1]</code> to <code>table[#list]</code>.
8024	If <code>comp</code> is given,	8181	If <code>comp</code> is given,
8025	then it must be a function that receives two table elements	8182	then it must be a function that receives two list elements
8026	and returns true when the first element must come	8183	and returns true when the first element must come
8027	before the second in the final order	8184	before the second in the final order
8028	(so that <code>not comp(a[i+1],a[i])</code> will be true after the sort).	8185	(so that <code>not comp(a[i+1],a[i])</code> will be true after the sort).
@@ -8040,16 +8197,16 @@ may have their relative positions changed by the sort. · 11 unmodified lines
8040		8197
8041	<p>	8198	<p>
8042	<hr><h3><a name="pdf-table.unpack"><code>table.unpack (list [, i [, j]])</code></a></h3>	8199	<hr><h3><a name="pdf-table.unpack"><code>table.unpack (list [, i [, j]])</code></a></h3>
		8200
		8201
		8202	<p>
8043	Returns the elements from the given table.	8203	Returns the elements from the given table.
8044	This function is equivalent to	8204	This function is equivalent to
8045		8205
8046	<pre>	8206	<pre>
8047	return list[i], list[i+1], ···, list[j]	8207	return list[i], list[i+1], ···, list[j]
8048	</pre><p>	8208	</pre><p>
8049	except that the above code can be written only for a fixed number	8209	By default, <code>i</code> is 1 and <code>j</code> is <code>#list</code>.
8050	of elements.
8051	By default, <code>i</code> is 1 and <code>j</code> is the length of the list,
8052	as defined by the length operator (see <a href="#3.4.6">§3.4.6</a>).
8053		8210
8054		8211
8055		8212
@@ -8386,7 +8543,7 @@ Returns the hyperbolic tangent of <code>x</code>. · 330 unmodified lines
8386		8543
8387		8544
8388		8545
8389	<h2>6.7 – <a name="6.7">Bitwise operations</a></h2>	8546	<h2>6.7 – <a name="6.7">Bitwise Operations</a></h2>
8390		8547
8391	<p>	8548	<p>
8392	This library provides bitwise operations.	8549	This library provides bitwise operations.
@@ -8468,7 +8625,7 @@ Returns the bitwise or of its operands. · 75 unmodified lines
8468		8625
8469		8626
8470	<p>	8627	<p>
8471	Returns a boolean signaling	8628	Returns a boolean signaling
8472	whether the bitwise and of its operands is different from zero.	8629	whether the bitwise and of its operands is different from zero.
8473		8630
8474		8631
@@ -8484,6 +8641,32 @@ Returns the bitwise exclusive or of its operands. · 9 unmodified lines
8484		8641
8485		8642
8486		8643
		8644	<p>
		8645	<hr><h3><a name="pdf-bit32.extract"><code>bit32.extract (n, field, width)</code></a></h3>
		8646
		8647
		8648	<p>
		8649	Returns the unsigned number formed by the bits
		8650	<code>field</code> to <code>field + width - 1</code> from <code>n</code>.
		8651	Bits are numbered from 0 (least significant) to 31 (most significant).
		8652	All accessed bits must be in the range <em>[0, 31]</em>.
		8653
		8654
		8655
		8656
		8657	<p>
		8658	<hr><h3><a name="pdf-bit32.replace"><code>bit32.replace (n, v, field, width)</code></a></h3>
		8659
		8660
		8661	<p>
		8662	Returns a copy of <code>n</code> with
		8663	the bits <code>field</code> to <code>field + width - 1</code>
		8664	replaced by the value <code>v</code>.
		8665	See <a href="#pdf-bit32.extract"><code>bit32.extract</code></a> for details about <code>field</code> and <code>width</code>.
		8666
		8667
		8668
		8669
8487	<p>	8670	<p>
8488	<hr><h3><a name="pdf-bit32.lrotate"><code>bit32.lrotate (x, disp)</code></a></h3>	8671	<hr><h3><a name="pdf-bit32.lrotate"><code>bit32.lrotate (x, disp)</code></a></h3>
8489		8672
@@ -8722,6 +8905,11 @@ Similar to <a href="#pdf-io.input"><code>io.input</code></a>, but operates over · 232 unmodified lines
8722	<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>	8905	<hr><h3><a name="pdf-io.popen"><code>io.popen (prog [, mode])</code></a></h3>
8723		8906
8724		8907
		8908	<p>
		8909	This function is system dependent and is not available
		8910	on all platforms.
		8911
		8912
8725	<p>	8913	<p>
8726	Starts program <code>prog</code> in a separated process and returns	8914	Starts program <code>prog</code> in a separated process and returns
8727	a file handle that you can use to read data from this program	8915	a file handle that you can use to read data from this program
@@ -8730,11 +8918,6 @@ or to write data to this program · 2 unmodified lines
8730	(if <code>mode</code> is <code>"w"</code>).	8918	(if <code>mode</code> is <code>"w"</code>).
8731		8919
8732		8920
8733	<p>
8734	This function is system dependent and is not available
8735	on all platforms.
8736
8737
8738		8921
8739		8922
8740	<p>	8923	<p>
@@ -8794,8 +8977,9 @@ but that takes an unpredictable amount of time to happen. · 53 unmodified lines
8794		8977
8795		8978
8796	<p>	8979	<p>
8797	If <code>file</code> was created with <a href="#pdf-io.popen"><code>io.popen</code></a>,	8980	When closing a file handle created with <a href="#pdf-io.popen"><code>io.popen</code></a>,
8798	a successful close returns the exit status of the process.	8981	<a href="#pdf-file:close"><code>file:close</code></a> returns the same values
		8982	returned by <a href="#pdf-os.execute"><code>os.execute</code></a>.
8799		8983
8800		8984
8801		8985
@@ -9020,6 +9204,8 @@ then <code>date</code> returns a table with the following fields: · 218 unmodified lines
9020	<code>wday</code> (weekday, Sunday is 1),	9204	<code>wday</code> (weekday, Sunday is 1),
9021	<code>yday</code> (day of the year),	9205	<code>yday</code> (day of the year),
9022	and <code>isdst</code> (daylight saving flag, a boolean).	9206	and <code>isdst</code> (daylight saving flag, a boolean).
		9207	This last field may be absent
		9208	if the information is not available.
9023		9209
9024		9210
9025	<p>	9211	<p>
@@ -9056,9 +9242,28 @@ this value is exactly <code>t2</code><em>-</em><code>t1</code>. · 30 unmodified lines
9056	<p>	9242	<p>
9057	This function is equivalent to the C function <code>system</code>.	9243	This function is equivalent to the C function <code>system</code>.
9058	It passes <code>command</code> to be executed by an operating system shell.	9244	It passes <code>command</code> to be executed by an operating system shell.
9059	It returns a status code, which is system-dependent.	9245	It returns <b>true</b>
9060	If <code>command</code> is absent, then it returns nonzero if a shell is available	9246	if the command terminated successfully.
9061	and zero otherwise.	9247	Otherwise, it returns <b>nil</b> plus a string and a number,
		9248	as follows:
		9249
		9250	<ul>
		9251
		9252	<li><b>"<code>exit</code>":</b>
		9253	the command terminated normally;
		9254	the following number is the exit status of the command.
		9255	</li>
		9256
		9257	<li><b>"<code>signal</code>":</b>
		9258	the command was terminated by a signal;
		9259	the following number is the signal that terminated the command.
		9260	</li>
		9261
		9262	</ul>
		9263
		9264	<p>
		9265	When called without a <code>command</code>,
		9266	<code>os.execute</code> returns a boolean that is true if a shell is available.
9062		9267
9063		9268
9064		9269
@@ -9072,10 +9277,10 @@ Calls the C function <code>exit</code> to terminate the host program. · 7 unmodified lines
9072	If <code>code</code> is <b>true</b>,	9277	If <code>code</code> is <b>true</b>,
9073	the returned status is <code>EXIT_SUCCESS</code>;	9278	the returned status is <code>EXIT_SUCCESS</code>;
9074	if <code>code</code> is <b>false</b>,	9279	if <code>code</code> is <b>false</b>,
9075	the returned status is <code>EXIT_FAILURE</code>.	9280	the returned status is <code>EXIT_FAILURE</code>;
9076	if <code>code</code> is a number,	9281	if <code>code</code> is a number,
9077	the returned status is this number.	9282	the returned status is this number.
9078	The default value for <code>code</code> is the success code.	9283	The default value for <code>code</code> is <b>true</b>.
9079		9284
9080		9285
9081	<p>	9286	<p>
@@ -9101,8 +9306,8 @@ or <b>nil</b> if the variable is not defined. · 19 unmodified lines
9101		9306
9102		9307
9103	<p>	9308	<p>
9104	Deletes the file or directory with the given name.	9309	Deletes the file (or empty directory, on POSIX systems)
9105	Directories must be empty to be removed.	9310	with the given name.
9106	If this function fails, it returns <b>nil</b>,	9311	If this function fails, it returns <b>nil</b>,
9107	plus a string describing the error.	9312	plus a string describing the error.
9108		9313
@@ -9165,7 +9370,8 @@ and may have fields <code>hour</code>, <code>min</code>, <code>sec</code>, and < · 56 unmodified lines
9165		9370
9166	<p>	9371	<p>
9167	The returned value is a number, whose meaning depends on your system.	9372	The returned value is a number, whose meaning depends on your system.
9168	In POSIX, Windows, and some other systems, this number counts the number	9373	In POSIX, Windows, and some other systems,
		9374	this number counts the number
9169	of seconds since some given start time (the "epoch").	9375	of seconds since some given start time (the "epoch").
9170	In other systems, the meaning is not specified,	9376	In other systems, the meaning is not specified,
9171	and the number returned by <code>time</code> can be used only as an argument to	9377	and the number returned by <code>time</code> can be used only as an argument to
@@ -9186,7 +9392,7 @@ and explicitly removed when no longer needed. · 14 unmodified lines
9186		9392
9187		9393
9188	<p>	9394	<p>
9189	On some systems (POSIX),	9395	On POSIX systems,
9190	this function also creates a file with that name,	9396	this function also creates a file with that name,
9191	to avoid security risks.	9397	to avoid security risks.
9192	(Someone else might create the file with wrong permissions	9398	(Someone else might create the file with wrong permissions
@@ -9327,10 +9533,16 @@ about the <a href="#pdf-print"><code>print</code></a> function. · 134 unmodified lines
9327	<p>	9533	<p>
9328	This function returns the name and the value of the local variable	9534	This function returns the name and the value of the local variable
9329	with index <code>local</code> of the function at level <code>f</code> of the stack.	9535	with index <code>local</code> of the function at level <code>f</code> of the stack.
9330	(The first parameter or local variable has index 1, and so on,	9536	This function accesses not only explicit local variables,
9331	until the last active local variable.)	9537	but also parameters, temporaries, etc.
9332	The function returns <b>nil</b> if there is no local	9538
9333	variable with the given index,	9539
		9540	<p>
		9541	The first parameter or local variable has index 1, and so on,
		9542	until the last active variable.
		9543	Negative indices refer to vararg parameters;
		9544	-1 is the first vararg parameter.
		9545	The function returns <b>nil</b> if there is no variable with the given index,
9334	and raises an error when called with a level out of range.	9546	and raises an error when called with a level out of range.
9335	(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)	9547	(You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
9336		9548
@@ -9338,7 +9550,7 @@ and raises an error when called with a level out of range. · 1 unmodified line
9338	<p>	9550	<p>
9339	Variable names starting with '<code>(</code>' (open parentheses)	9551	Variable names starting with '<code>(</code>' (open parentheses)
9340	represent internal variables	9552	represent internal variables
9341	(loop control variables, temporaries, and C function locals).	9553	(loop control variables, temporaries, varargs, and C function locals).
9342		9554
9343		9555
9344	<p>	9556	<p>
@@ -9454,6 +9666,11 @@ and raises an error when called with a <code>level</code> out of range. · 109 unmodified lines
9454	Otherwise, it returns the name of the local variable.	9666	Otherwise, it returns the name of the local variable.
9455		9667
9456		9668
		9669	<p>
		9670	See <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for more information about
		9671	variable indices and names.
		9672
		9673
9457		9674
9458		9675
9459	<p>	9676	<p>
@@ -9463,6 +9680,7 @@ Otherwise, it returns the name of the local variable. · 3 unmodified lines
9463	<p>	9680	<p>
9464	Sets the metatable for the given <code>object</code> to the given <code>table</code>	9681	Sets the metatable for the given <code>object</code> to the given <code>table</code>
9465	(which can be <b>nil</b>).	9682	(which can be <b>nil</b>).
		9683	Returns <code>object</code>.
9466		9684
9467		9685
9468		9686
@@ -9482,14 +9700,14 @@ Otherwise, it returns the name of the upvalue. · 13 unmodified lines
9482		9700
9483		9701
9484	<p>	9702	<p>
9485	<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message] [, level])</code></a></h3>	9703	<hr><h3><a name="pdf-debug.traceback"><code>debug.traceback ([thread,] [message [, level]])</code></a></h3>
9486		9704
9487		9705
9488	<p>	9706	<p>
9489	If <code>message</code> is present but is not a string,	9707	If <code>message</code> is present but is neither a string nor <b>nil</b>,
9490	this function returns <code>message</code> without further processing.	9708	this function returns <code>message</code> without further processing.
9491	Otherwise,	9709	Otherwise,
9492	returns a string with a traceback of the call stack.	9710	it returns a string with a traceback of the call stack.
9493	An optional <code>message</code> string is appended	9711	An optional <code>message</code> string is appended
9494	at the beginning of the traceback.	9712	at the beginning of the traceback.
9495	An optional <code>level</code> number tells at which level	9713	An optional <code>level</code> number tells at which level
@@ -9635,6 +9853,14 @@ Finally, if the error object is <b>nil</b>, · 139 unmodified lines
9635	the interpreter does not report the error.	9853	the interpreter does not report the error.
9636		9854
9637		9855
		9856	<p>
		9857	When finishing normally,
		9858	the interpreter closes its main Lua state
		9859	(see <a href="#lua_close"><code>lua_close</code></a>).
		9860	The script can avoid this step by terminating
		9861	through <a href="#pdf-os.exit"><code>os.exit</code></a>.
		9862
		9863
9638	<p>	9864	<p>
9639	If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,	9865	If the global variable <a name="pdf-_PROMPT"><code>_PROMPT</code></a> contains a string,
9640	then its value is used as the prompt.	9866	then its value is used as the prompt.
@@ -9671,12 +9897,12 @@ as in · 30 unmodified lines
9671	(Of course,	9897	(Of course,
9672	the location of the Lua interpreter can be different in your machine.	9898	the location of the Lua interpreter can be different in your machine.
9673	If <code>lua</code> is in your <code>PATH</code>,	9899	If <code>lua</code> is in your <code>PATH</code>,
9674	then	9900	then
9675		9901
9676	<pre>	9902	<pre>
9677	#!/usr/bin/env lua	9903	#!/usr/bin/env lua
9678	</pre><p>	9904	</pre><p>
9679	is a more portable solution.)	9905	is a more portable solution.)
9680		9906
9681		9907
9682		9908
@@ -9696,21 +9922,38 @@ all these compatibility options will be removed in the next version of Lua. · 13 unmodified lines
9696	<ul>	9922	<ul>
9697		9923
9698	<li>	9924	<li>
9699	Lua identifiers cannot use locale-dependent letters.	9925	The concept of <em>environment</em> changed.
		9926	Only Lua functions have environments.
		9927	To set the environment of a Lua function,
		9928	use the variable <code>_ENV</code> or the function <a href="#pdf-load"><code>load</code></a>.
		9929
		9930
		9931	<p>
		9932	C functions do not have environments any more.
		9933	Use an upvalue with a shared table if you need to keep
		9934	shared state among several C functions.
		9935	(You may use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> to open a C library
		9936	with all functions sharing a common upvalue.)
		9937
		9938
		9939	<p>
		9940	To manipulate the "environment" of a userdata
		9941	(which is now called user value),
		9942	use the new functions
		9943	<a href="#lua_getuservalue"><code>lua_getuservalue</code></a> and <a href="#lua_setuservalue"><code>lua_setuservalue</code></a>.
9700	</li>	9944	</li>
9701		9945
9702	<li>	9946	<li>
9703	Doing a step in the garbage collector does not restart the collector	9947	Lua identifiers cannot use locale-dependent letters.
9704	if it has been stopped.
9705	</li>	9948	</li>
9706		9949
9707	<li>	9950	<li>
9708	Weak tables with weak keys now perform like <em>ephemeron tables</em>.	9951	Doing a step or a full collection in the garbage collector
		9952	does not restart the collector if it has been stopped.
9709	</li>	9953	</li>
9710		9954
9711	<li>	9955	<li>
9712	Threads do not have individual environments.	9956	Weak tables with weak keys now perform like <em>ephemeron tables</em>.
9713	All threads share a single fixed environment.
9714	</li>	9957	</li>
9715		9958
9716	<li>	9959	<li>
@@ -9720,6 +9963,13 @@ Instead, tail calls generate a special new event, · 3 unmodified lines
9720	not be a corresponding return event.	9963	not be a corresponding return event.
9721	</li>	9964	</li>
9722		9965
		9966	<li>
		9967	Equality between function values has changed.
		9968	Now, a function definition may not create a new value;
		9969	it may reuse some previous value if there is no
		9970	observable difference to the new function.
		9971	</li>
		9972
9723	</ul>	9973	</ul>
9724		9974
9725		9975
@@ -9735,9 +9985,8 @@ and it is easy to set up a module with regular Lua code. · 9 unmodified lines
9735	</li>	9985	</li>
9736		9986
9737	<li>	9987	<li>
9738	Functions <code>setfenv</code> and <code>getfenv</code> are deprecated.	9988	Functions <code>setfenv</code> and <code>getfenv</code> are deprecated,
9739	To set the environment of a Lua function,	9989	because of the changes in environments.
9740	use the variable <code>_ENV</code> or the new function <a href="#pdf-loadin"><code>loadin</code></a>.
9741	</li>	9990	</li>
9742		9991
9743	<li>	9992	<li>
@@ -9745,11 +9994,23 @@ Function <code>math.log10</code> is deprecated. · 1 unmodified line
9745	Use <a href="#pdf-math.log"><code>math.log</code></a> with 10 as its second argument, instead.	9994	Use <a href="#pdf-math.log"><code>math.log</code></a> with 10 as its second argument, instead.
9746	</li>	9995	</li>
9747		9996
		9997	<li>
		9998	Function <code>loadstring</code> is deprecated.
		9999	Use <code>load</code> instead; it now accepts string arguments
		10000	and are exactly equivalent to <code>loadstring</code>.
		10001	</li>
		10002
9748	<li>	10003	<li>
9749	Function <code>table.maxn</code> is deprecated.	10004	Function <code>table.maxn</code> is deprecated.
9750	Write it in Lua if you really need it.	10005	Write it in Lua if you really need it.
9751	</li>	10006	</li>
9752		10007
		10008	<li>
		10009	Function <code>os.execute</code> now returns <b>true</b> when command
		10010	terminates successfully and <b>nil</b> plus error information
		10011	otherwise.
		10012	</li>
		10013
9753	<li>	10014	<li>
9754	Function <code>unpack</code> was moved into the table library	10015	Function <code>unpack</code> was moved into the table library
9755	and therefore must be called as <a href="#pdf-table.unpack"><code>table.unpack</code></a>.	10016	and therefore must be called as <a href="#pdf-table.unpack"><code>table.unpack</code></a>.
@@ -9763,7 +10024,7 @@ as now patterns may contain '<code>\0</code>' as a regular character. · 7 unmodified lines
9763	<li>	10024	<li>
9764	Lua does not have bytecode verification anymore.	10025	Lua does not have bytecode verification anymore.
9765	So, all functions that load code	10026	So, all functions that load code
9766	(<a href="#pdf-load"><code>load</code></a>, <a href="#pdf-loadfile"><code>loadfile</code></a>, <a href="#pdf-loadstring"><code>loadstring</code></a>)	10027	(<a href="#pdf-load"><code>load</code></a> and <a href="#pdf-loadfile"><code>loadfile</code></a>)
9767	are potentially insecure when loading untrusted binary data.	10028	are potentially insecure when loading untrusted binary data.
9768	(Actually, those functions were already insecure because	10029	(Actually, those functions were already insecure because
9769	of bugs in the verification algorithm.)	10030	of bugs in the verification algorithm.)
@@ -9789,19 +10050,8 @@ You must get the global environment from the registry · 19 unmodified lines
9789	<li>	10050	<li>
9790	Pseudoindex <code>LUA_ENVIRONINDEX</code>	10051	Pseudoindex <code>LUA_ENVIRONINDEX</code>
9791	and functions <code>lua_getfenv</code>/<code>lua_setfenv</code>	10052	and functions <code>lua_getfenv</code>/<code>lua_setfenv</code>
9792	were removed.	10053	were removed,
9793	C functions do not have environments any more.	10054	as C functions do not have environments any more.
9794	Use an upvalue with a shared table if you need to keep
9795	shared state among several C functions.
9796	(You may use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> to open a C library
9797	with all functions sharing a common upvalue.)
9798
9799
9800	<p>
9801	To manipulate the "environment" of a userdata
9802	(which is not called "environment" anymore),
9803	use the new functions
9804	<a href="#lua_getuservalue"><code>lua_getuservalue</code></a> and <a href="#lua_setuservalue"><code>lua_setuservalue</code></a>.
9805	</li>	10055	</li>
9806		10056
9807	<li>	10057	<li>
@@ -9812,12 +10062,21 @@ create globals anymore. · 4 unmodified lines
9812	</li>	10062	</li>
9813		10063
9814	<li>	10064	<li>
9815	Finalizers ("<code>__gc</code>" metamethods) for userdata are called in the	10065	The <code>osize</code> argument to the allocation function
		10066	may not be zero when creating a new block,
		10067	that is, when <code>ptr</code> is <code>NULL</code>
		10068	(see <a href="#lua_Alloc"><code>lua_Alloc</code></a>).
		10069	Use only the test <code>ptr == NULL</code> to check whether
		10070	the block is new.
		10071	</li>
		10072
		10073	<li>
		10074	Finalizers (<code>__gc</code> metamethods) for userdata are called in the
9816	reverse order that they were marked,	10075	reverse order that they were marked,
9817	not that they were created (see <a href="#2.5.1">§2.5.1</a>).	10076	not that they were created (see <a href="#2.5.1">§2.5.1</a>).
9818	(Most userdata are marked immediately after they are created.)	10077	(Most userdata are marked immediately after they are created.)
9819	Moreover,	10078	Moreover,
9820	if the metatable does not have a "<code>__gc</code>" field when set,	10079	if the metatable does not have a <code>__gc</code> field when set,
9821	the finalizer will not be called,	10080	the finalizer will not be called,
9822	even if it is set later.	10081	even if it is set later.
9823	</li>	10082	</li>
@@ -9860,11 +10119,14 @@ Here is the complete syntax of Lua in extended BNF. · 36 unmodified lines
9860		10119
9861	chunk ::= block	10120	chunk ::= block
9862		10121
9863	block ::= {stat} [laststat [‘<b>;</b>’]]	10122	block ::= {stat} [retstat]
9864		10123
9865	stat ::= ‘<b>;</b>’ \|	10124	stat ::= ‘<b>;</b>’ \|
9866	varlist ‘<b>=</b>’ explist \|	10125	varlist ‘<b>=</b>’ explist \|
9867	functioncall \|	10126	functioncall \|
		10127	label \|
		10128	<b>break</b> \|
		10129	<b>goto</b> Name \|
9868	<b>do</b> block <b>end</b> \|	10130	<b>do</b> block <b>end</b> \|
9869	<b>while</b> exp <b>do</b> block <b>end</b> \|	10131	<b>while</b> exp <b>do</b> block <b>end</b> \|
9870	<b>repeat</b> block <b>until</b> exp \|	10132	<b>repeat</b> block <b>until</b> exp \|
@@ -9875,7 +10137,9 @@ Here is the complete syntax of Lua in extended BNF. · 4 unmodified lines
9875	<b>local</b> <b>function</b> Name funcbody \|	10137	<b>local</b> <b>function</b> Name funcbody \|
9876	<b>local</b> namelist [‘<b>=</b>’ explist]	10138	<b>local</b> namelist [‘<b>=</b>’ explist]
9877		10139
9878	laststat ::= <b>return</b> [explist] \| <b>break</b>	10140	retstat ::= <b>return</b> [explist] [‘<b>;</b>’]
		10141
		10142	label ::= ‘<b>@</b>’ Name ‘<b>:</b>’
9879		10143
9880	funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name]	10144	funcname ::= Name {‘<b>.</b>’ Name} [‘<b>:</b>’ Name]
9881		10145
@@ -9885,7 +10149,7 @@ Here is the complete syntax of Lua in extended BNF. · 3 unmodified lines
9885		10149
9886	namelist ::= Name {‘<b>,</b>’ Name}	10150	namelist ::= Name {‘<b>,</b>’ Name}
9887		10151
9888	explist ::= {exp ‘<b>,</b>’} exp	10152	explist ::= exp {‘<b>,</b>’ exp}
9889		10153
9890	exp ::= <b>nil</b> \| <b>false</b> \| <b>true</b> \| Number \| String \| ‘<b>...</b>’ \| function \|	10154	exp ::= <b>nil</b> \| <b>false</b> \| <b>true</b> \| Number \| String \| ‘<b>...</b>’ \| function \|
9891	prefixexp \| tableconstructor \| exp binop exp \| unop exp	10155	prefixexp \| tableconstructor \| exp binop exp \| unop exp
@@ -9896,7 +10160,7 @@ Here is the complete syntax of Lua in extended BNF. · 4 unmodified lines
9896		10160
9897	args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ \| tableconstructor \| String	10161	args ::= ‘<b>(</b>’ [explist] ‘<b>)</b>’ \| tableconstructor \| String
9898		10162
9899	function ::= <b>function</b> funcbody	10163	functiondef ::= <b>function</b> funcbody
9900		10164
9901	funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>	10165	funcbody ::= ‘<b>(</b>’ [parlist] ‘<b>)</b>’ block <b>end</b>
9902		10166
@@ -9929,10 +10193,10 @@ Here is the complete syntax of Lua in extended BNF. · 26 unmodified lines
9929	<HR>	10193	<HR>
9930	<SMALL>	10194	<SMALL>
9931	Last update:	10195	Last update:
9932	Mon Nov 22 16:36:19 BRST 2010	10196	Mon Jun 13 14:56:14 BRT 2011
9933	</SMALL>	10197	</SMALL>
9934	<!--	10198	<!--
9935	Last change: revised for Lua 5.2.0 (alpha)	10199	Last change: revised for Lua 5.2.0 (beta)
9936	-->	10200	-->
9937		10201
9938	</body></html>	10202	</body></html>

doc/readme.html+16−9

 <HR>
 <H1>
 <A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Welcome to Lua 5.2 (alpha)
+Welcome to Lua 5.2 (beta)
 </H1>
 <P>
 <IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
-<EM>This is an alpha version of Lua 5.2.
+<EM>This is a beta version of Lua 5.2.
 Some details may change in the final version.</EM>
 <P>
 <H3>Main changes</H3>
 <UL>
 <LI> yieldable pcall and metamethods
-<LI> new <CODE>_ENV</CODE> scheme
+<LI> new lexical scheme for globals
 <LI> ephemeron tables
 <LI> new library for bitwise operations
 <LI> light C functions
 <LI> emergency garbage collector
+<LI> <CODE>goto</CODE> statement
+<LI> finalizers for tables
 </UL>
 Here are the other changes introduced in Lua 5.2:
 <LI> no more fenv for threads or functions
 <LI> tables honor the <CODE>__len</CODE> metamethod
 <LI> hex and <CODE>\*</CODE> escapes in strings
+<LI> support for hexadecimal floats
 <LI> order metamethods work for different types
 <LI> no more verification of opcode consistency
 <LI> hook event "tail return" replaced by "tail call"
 <LI> empty statement
+<LI> <CODE>break</CODE> statement may appear in the middle of a block
 </UL>
 <H3>Libraries</H3>
 <UL>
-<LI> new metamethods <CODE>__pairs</CODE> and <CODE>__ipairs</CODE>
 <LI> arguments for function called through <CODE>xpcall</CODE>
 <LI> optional 'mode' argument to load (to control binary x text)
-<LI> new function <CODE>loadin</CODE>
+<LI> optional 'env' argument to load (environment for loaded chunk)
 <LI> <CODE>loadlib</CODE> may load libraries with global names (RTLD_GLOBAL)
 <LI> new function <CODE>package.searchpath</CODE>
+<LI> modules receive their paths when loaded
 <LI> optional base in <CODE>math.log</CODE>
+<LI> optional separator in <CODE>string.rep</CODE>
 <LI> <CODE>file:write</CODE> returns <CODE>file</CODE>
 <LI> closing a pipe returns exit status
 <LI> <CODE>os.exit</CODE> may close state
+<LI> new metamethods <CODE>__pairs</CODE> and <CODE>__ipairs</CODE>
 <LI> new option 'isrunning' for <CODE>collectgarbage</CODE> and <CODE>lua_gc</CODE>
 <LI> frontier patterns
 <LI> <CODE>\0</CODE> in patterns
 <LI> new option <CODE>*L</CODE> for <CODE>io.read</CODE>
 <LI> options for <CODE>io.lines</CODE>
+<LI> <CODE>debug.getlocal</CODE> can access function varargs
 </UL>
 <H3>C API</H3>
 <LI> main thread predefined in the registry
 <LI> new constants <CODE>LUA_OK</CODE> and <CODE>LUA_ERRGCMM</CODE>
 <LI> new <CODE>lua_compare</CODE>, <CODE>lua_arith</CODE>, and <CODE>lua_len</CODE>
-<LI> new <CODE>lua_version</CODE> and <CODE>luaL_version</CODE>
+<LI> new <CODE>lua_version</CODE> and <CODE>luaL_checkversion</CODE>
 <LI> <CODE>lua_pushstring</CODE> and <CODE>pushlstring</CODE> return string
 <LI> new <CODE>luaL_testudata</CODE> and <CODE>luaL_setmetatable</CODE>
 <LI> new <CODE>luaL_tolstring</CODE>
 <A HREF="http://www.lua.org/license.html">this</A>.
 <BLOCKQUOTE>
-Copyright &copy; 1994&ndash;2010 Lua.org, PUC-Rio.
+Copyright &copy; 1994&ndash;2011 Lua.org, PUC-Rio.
 <P>
 Permission is hereby granted, free of charge, to any person obtaining a copy
 <HR>
 <SMALL>
 Last update:
-Sat Nov 20 19:23:14 BRST 2010
+Mon Jun 13 15:07:49 BRT 2011
 </SMALL>
 <!--
-Last change: revised for Lua 5.2.0 (alpha)
+Last change: revised for Lua 5.2.0 (beta)
 -->
 </BODY>

src/Makefile+2−2

src/lapi.c+88−74

 /*
-** $Id: lapi.c,v 2.140 2010/11/03 15:16:17 roberto Exp $
+** $Id: lapi.c,v 2.149 2011/06/13 14:13:06 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
     if (ttislcf(ci->func))  /* light C function? */
       return cast(TValue *, luaO_nilobject);  /* it has no upvalues */
     else {
-      Closure *func = clvalue(ci->func);
+      CClosure *func = clCvalue(ci->func);
-      return (idx <= func->c.nupvalues)
+      return (idx <= func->nupvalues)
-             ? &func->c.upvalue[idx-1]
+             ? &func->upvalue[idx-1]
              : cast(TValue *, luaO_nilobject);
     }
   }
   TValue *to = index2addr(L, idx);
   api_checkvalidindex(L, to);
   setobj(L, to, fr);
-  if (idx < LUA_REGISTRYINDEX) {  /* function upvalue? */
+  if (idx < LUA_REGISTRYINDEX)  /* function upvalue? */
-    lua_assert(ttisclosure(L->ci->func));
+    luaC_barrier(L, clCvalue(L->ci->func), fr);
-    luaC_barrier(L, clvalue(L->ci->func), fr);
-  }
   /* LUA_REGISTRYINDEX does not need gc barrier
      (collector revisits it before finishing collection) */
 }
 LUA_API int lua_iscfunction (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
-  return (ttislcf(o) || (ttisclosure(o) && clvalue(o)->c.isC));
+  return (ttislcf(o) || (ttisCclosure(o)));
 }
   StkId o1 = index2addr(L, index1);
   StkId o2 = index2addr(L, index2);
   return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
-         : luaO_rawequalObj(o1, o2);
+         : luaV_rawequalobj(o1, o2);
 }
 LUA_API void  lua_arith (lua_State *L, int op) {
+  StkId o1;  /* 1st operand */
+  StkId o2;  /* 2nd operand */
   lua_lock(L);
-  api_checknelems(L, 2);
+  if (op != LUA_OPUNM) /* all other operations expect two operands */
-  if (ttisnumber(L->top - 2) && ttisnumber(L->top - 1)) {
+    api_checknelems(L, 2);
-    changenvalue(L->top - 2,
+  else {  /* for unary minus, add fake 2nd operand */
-                 luaO_arith(op, nvalue(L->top - 2), nvalue(L->top - 1)));
+    api_checknelems(L, 1);
+    setobjs2s(L, L->top, L->top - 1);
+    L->top++;
+  }
+  o1 = L->top - 2;
+  o2 = L->top - 1;
+  if (ttisnumber(o1) && ttisnumber(o2)) {
+    changenvalue(o1, luaO_arith(op, nvalue(o1), nvalue(o2)));
   }
   else
-    luaV_arith(L, L->top - 2, L->top - 2, L->top - 1,
+    luaV_arith(L, o1, o1, o2, cast(TMS, op - LUA_OPADD + TM_ADD));
-               cast(TMS, op - LUA_OPADD + TM_ADD));
   L->top--;
   lua_unlock(L);
 }
 LUA_API size_t lua_rawlen (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
-  switch (ttype(o)) {
+  switch (ttypenv(o)) {
     case LUA_TSTRING: return tsvalue(o)->len;
     case LUA_TUSERDATA: return uvalue(o)->len;
     case LUA_TTABLE: return luaH_getn(hvalue(o));
 LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
   if (ttislcf(o)) return fvalue(o);
-  else if (ttisclosure(o) && clvalue(o)->c.isC)
+  else if (ttisCclosure(o))
-    return clvalue(o)->c.f;
+    return clCvalue(o)->f;
   else return NULL;  /* not a C function */
 }
 LUA_API void *lua_touserdata (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
-  switch (ttype(o)) {
+  switch (ttypenv(o)) {
     case LUA_TUSERDATA: return (rawuvalue(o) + 1);
     case LUA_TLIGHTUSERDATA: return pvalue(o);
     default: return NULL;
   StkId o = index2addr(L, idx);
   switch (ttype(o)) {
     case LUA_TTABLE: return hvalue(o);
-    case LUA_TFUNCTION: return clvalue(o);
+    case LUA_TLCL: return clLvalue(o);
+    case LUA_TCCL: return clCvalue(o);
     case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o)));
     case LUA_TTHREAD: return thvalue(o);
     case LUA_TUSERDATA:
 LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
   lua_lock(L);
   setnvalue(L->top, n);
+  luai_checknum(L, L->top,
+    luaG_runerror(L, "C API - attempt to push a signaling NaN"));
   api_incr_top(L);
   lua_unlock(L);
 }
     L->top -= n;
     while (n--)
       setobj2n(L, &cl->c.upvalue[n], L->top + n);
-    setclvalue(L, L->top, cl);
+    setclCvalue(L, L->top, cl);
   }
   api_incr_top(L);
   lua_unlock(L);
   int res;
   lua_lock(L);
   obj = index2addr(L, objindex);
-  switch (ttype(obj)) {
+  switch (ttypenv(obj)) {
     case LUA_TTABLE:
       mt = hvalue(obj)->metatable;
       break;
     api_check(L, ttistable(L->top - 1), "table expected");
     mt = hvalue(L->top - 1);
   }
-  switch (ttype(obj)) {
+  switch (ttypenv(obj)) {
     case LUA_TTABLE: {
       hvalue(obj)->metatable = mt;
       if (mt)
         luaC_objbarrierback(L, gcvalue(obj), mt);
+        luaC_checkfinalizer(L, gcvalue(obj), mt);
       break;
     }
     case LUA_TUSERDATA: {
       uvalue(obj)->metatable = mt;
       if (mt) {
         luaC_objbarrier(L, rawuvalue(obj), mt);
-        luaC_checkfinalizer(L, rawuvalue(obj));
+        luaC_checkfinalizer(L, gcvalue(obj), mt);
       }
       break;
     }
   luaZ_init(L, &z, reader, data);
   status = luaD_protectedparser(L, &z, chunkname);
   if (status == LUA_OK) {  /* no errors? */
-    Closure *f = clvalue(L->top - 1);  /* get newly created function */
+    LClosure *f = clLvalue(L->top - 1);  /* get newly created function */
-    lua_assert(!f->c.isC);
+    if (f->nupvalues == 1) {  /* does it have one upvalue? */
-    if (f->l.nupvalues == 1) {  /* does it have one upvalue? */
       /* get global table from registry */
       Table *reg = hvalue(&G(L)->l_registry);
       const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
       /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
-      setobj(L, f->l.upvals[0]->v, gt);
+      setobj(L, f->upvals[0]->v, gt);
-      luaC_barrier(L, f->l.upvals[0], gt);
+      luaC_barrier(L, f->upvals[0], gt);
     }
   }
   lua_unlock(L);
   g = G(L);
   switch (what) {
     case LUA_GCSTOP: {
-      stopgc(g);
+      g->gcrunning = 0;
       break;
     }
     case LUA_GCRESTART: {
-      g->GCdebt = 0;
+      luaE_setdebt(g, 0);
+      g->gcrunning = 1;
       break;
     }
     case LUA_GCCOLLECT: {
     }
     case LUA_GCCOUNT: {
       /* GC values are expressed in Kbytes: #bytes/2^10 */
-      res = cast_int(g->totalbytes >> 10);
+      res = cast_int(gettotalbytes(g) >> 10);
       break;
     }
     case LUA_GCCOUNTB: {
-      res = cast_int(g->totalbytes & 0x3ff);
+      res = cast_int(gettotalbytes(g) & 0x3ff);
       break;
     }
     case LUA_GCSTEP: {
-      int stopped = gcstopped(g);
       if (g->gckind == KGC_GEN) {  /* generational mode? */
         res = (g->lastmajormem == 0);  /* 1 if will do major collection */
-        luaC_step(L);  /* do a single step */
+        luaC_forcestep(L);  /* do a single step */
       }
       else {
         while (data-- >= 0) {
-          luaC_step(L);
+          luaC_forcestep(L);
           if (g->gcstate == GCSpause) {  /* end of cycle? */
             res = 1;  /* signal it */
             break;
           }
         }
       }
-      if (stopped)  /* collector was stopped? */
-        stopgc(g);  /* keep it that way */
       break;
     }
     case LUA_GCSETPAUSE: {
       break;
     }
     case LUA_GCISRUNNING: {
-      res = !gcstopped(g);
+      res = g->gcrunning;
       break;
     }
     case LUA_GCGEN: {  /* change collector to generational mode */
 static const char *aux_upvalue (StkId fi, int n, TValue **val,
                                 GCObject **owner) {
-  Closure *f;
+  switch (ttype(fi)) {
-  if (!ttisclosure(fi)) return NULL;
+    case LUA_TCCL: {  /* C closure */
-  f = clvalue(fi);
+      CClosure *f = clCvalue(fi);
-  if (f->c.isC) {
+      if (!(1 <= n && n <= f->nupvalues)) return NULL;
-    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
+      *val = &f->upvalue[n-1];
-    *val = &f->c.upvalue[n-1];
+      if (owner) *owner = obj2gco(f);
-    if (owner) *owner = obj2gco(f);
+      return "";
-    return "";
+    }
-  }
+    case LUA_TLCL: {  /* Lua closure */
-  else {
+      LClosure *f = clLvalue(fi);
-    const char *name;
+      const char *name;
-    Proto *p = f->l.p;
+      Proto *p = f->p;
-    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
+      if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
-    *val = f->l.upvals[n-1]->v;
+      *val = f->upvals[n-1]->v;
-    if (owner) *owner = obj2gco(f->l.upvals[n - 1]);
+      if (owner) *owner = obj2gco(f->upvals[n - 1]);
-    name = getstr(p->upvalues[n-1].name);
+      name = getstr(p->upvalues[n-1].name);
-    if (name == NULL)  /* no debug information? */
+      if (name == NULL)  /* no debug information? */
-      name = "";
+        name = "";
-    return name;
+      return name;
+    }
+    default: return NULL;  /* not a closure */
   }
 }
 }
-static UpVal **getupvalref (lua_State *L, int fidx, int n, Closure **pf) {
+static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) {
-  Closure *f;
+  LClosure *f;
   StkId fi = index2addr(L, fidx);
-  api_check(L, ttisclosure(fi), "Lua function expected");
+  api_check(L, ttisLclosure(fi), "Lua function expected");
-  f = clvalue(fi);
+  f = clLvalue(fi);
-  api_check(L, !f->c.isC, "Lua function expected");
+  api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
-  api_check(L, (1 <= n && n <= f->l.p->sizeupvalues), "invalid upvalue index");
   if (pf) *pf = f;
-  return &f->l.upvals[n - 1];  /* get its upvalue pointer */
+  return &f->upvals[n - 1];  /* get its upvalue pointer */
 }
 LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) {
-  Closure *f;
   StkId fi = index2addr(L, fidx);
-  api_check(L, ttisclosure(fi), "function expected");
+  switch (ttype(fi)) {
-  f = clvalue(fi);
+    case LUA_TLCL: {  /* lua closure */
-  if (f->c.isC) {
+      return *getupvalref(L, fidx, n, NULL);
-    api_check(L, 1 <= n && n <= f->c.nupvalues, "invalid upvalue index");
+    }
-    return &f->c.upvalue[n - 1];
+    case LUA_TCCL: {  /* C closure */
+      CClosure *f = clCvalue(fi);
+      api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");
+      return &f->upvalue[n - 1];
+    }
+    default: {
+      api_check(L, 0, "closure expected");
+      return NULL;
+    }
   }
-  else return *getupvalref(L, fidx, n, NULL);
 }
 LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,
                                             int fidx2, int n2) {
-  Closure *f1;
+  LClosure *f1;
   UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
   UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
   *up1 = *up2;

src/lauxlib.c+77−13

 /*
-** $Id: lauxlib.c,v 1.227 2010/11/10 18:05:36 roberto Exp $
+** $Id: lauxlib.c,v 1.232 2011/05/03 16:01:57 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
   return lua_error(L);
 }
+LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
+  int en = errno;  /* calls to Lua API may change this value */
+  if (stat) {
+    lua_pushboolean(L, 1);
+    return 1;
+  }
+  else {
+    lua_pushnil(L);
+    if (fname)
+      lua_pushfstring(L, "%s: %s", fname, strerror(en));
+    else
+      lua_pushfstring(L, "%s", strerror(en));
+    lua_pushinteger(L, en);
+    return 3;
+  }
+}
+#if !defined(inspectstat)	/* { */
+#if defined(LUA_USE_POSIX)
+#include <sys/wait.h>
+/*
+** use appropriate macros to interpret 'pclose' return status
+*/
+#define inspectstat(stat,what)  \
+   if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
+   else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
+#else
+#define inspectstat(stat,what)  /* no op */
+#endif
+#endif				/* } */
+LUALIB_API int luaL_execresult (lua_State *L, int stat) {
+  const char *what = "exit";  /* type of termination */
+  if (stat == -1)  /* error? */
+    return luaL_fileresult(L, 0, NULL);
+  else {
+    inspectstat(stat, what);  /* interpret result */
+    if (*what == 'e' && stat == 0)  /* successful termination? */
+      return luaL_fileresult(L, 1, NULL);
+    else {  /* return nil,what,code */
+      lua_pushnil(L);
+      lua_pushstring(L, what);
+      lua_pushinteger(L, stat);
+      return 3;
+    }
+  }
+}
 /* }====================================================== */
       newsize = B->n + sz;
     if (newsize < B->n || newsize - B->n < sz)
       luaL_error(L, "buffer too large");
-    newbuff = (char *)lua_newuserdata(L, newsize);  /* create larger buffer */
+    /* create larger buffer */
-    memcpy(newbuff, B->b, B->n);  /* move content to new buffer */
+    newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char));
+    /* move content to new buffer */
+    memcpy(newbuff, B->b, B->n * sizeof(char));
     if (buffonstack(B))
       lua_remove(L, -2);  /* remove old buffer */
     B->b = newbuff;
 LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
   char *b = luaL_prepbuffsize(B, l);
-  memcpy(b, s, l);
+  memcpy(b, s, l * sizeof(char));
   luaL_addsize(B, l);
 }
 */
 #if defined(LUA_COMPAT_MODULE)
-static const char *luaL_findtablex (lua_State *L, int idx,
+static const char *luaL_findtable (lua_State *L, int idx,
-                                    const char *fname, int szhint) {
+                                   const char *fname, int szhint) {
   const char *e;
   if (idx) lua_pushvalue(L, idx);
   do {
 */
 LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
                                  int sizehint) {
-  luaL_findtablex(L, LUA_REGISTRYINDEX, "_LOADED", 1);  /* get _LOADED table */
+  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);  /* get _LOADED table */
   lua_getfield(L, -1, modname);  /* get _LOADED[modname] */
   if (!lua_istable(L, -1)) {  /* not found? */
     lua_pop(L, 1);  /* remove previous result */
     /* try global variable (and create one if it does not exist) */
     lua_pushglobaltable(L);
-    if (luaL_findtablex(L, 0, modname, sizehint) != NULL)
+    if (luaL_findtable(L, 0, modname, sizehint) != NULL)
       luaL_error(L, "name conflict for module " LUA_QS, modname);
     lua_pushvalue(L, -1);
     lua_setfield(L, -3, modname);  /* _LOADED[modname] = new table */
     luaL_pushmodule(L, libname, libsize(l));  /* get/create library table */
     lua_insert(L, -(nup + 1));  /* move library table to below upvalues */
   }
-  luaL_setfuncs(L, l, nup);
+  if (l)
+    luaL_setfuncs(L, l, nup);
+  else
+    lua_pop(L, nup);  /* remove upvalues */
 }
 #endif
 */
 LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
   luaL_checkstack(L, nup, "too many upvalues");
-  for (; l && l->name; l++) {  /* fill the table with given functions */
+  for (; l->name != NULL; l++) {  /* fill the table with given functions */
     int i;
     for (i = 0; i < nup; i++)  /* copy upvalues to the top */
       lua_pushvalue(L, -nup);
 ** ensure that stack[idx][fname] has a table and push that table
 ** into the stack
 */
-LUALIB_API void luaL_findtable (lua_State *L, int idx, const char *fname) {
+LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
   lua_getfield(L, idx, fname);
-  if (lua_istable(L, -1)) return;  /* table already there */
+  if (lua_istable(L, -1)) return 1;  /* table already there */
   else {
     idx = lua_absindex(L, idx);
     lua_pop(L, 1);  /* remove previous result */
     lua_newtable(L);
     lua_pushvalue(L, -1);  /* copy to be left at top */
     lua_setfield(L, idx, fname);  /* assign new table to field */
+    return 0;  /* false, because did not find table there */
   }
 }
   lua_pushcfunction(L, openf);
   lua_pushstring(L, modname);  /* argument to open function */
   lua_call(L, 1, 1);  /* open module */
-  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED");
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
   lua_pushvalue(L, -2);  /* make copy of module (call result) */
   lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
   lua_pop(L, 1);  /* remove _LOADED table */

src/lauxlib.h+5−2

 /*
-** $Id: lauxlib.h,v 1.113 2010/11/16 19:20:01 roberto Exp $
+** $Id: lauxlib.h,v 1.116 2011/04/08 19:17:36 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
                                    const char *const lst[]);
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
 /* pre-defined references */
 #define LUA_NOREF       (-2)
 #define LUA_REFNIL      (-1)
 LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
-LUALIB_API void (luaL_findtable) (lua_State *L, int idx, const char *fname);
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
 LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
                                   const char *msg, int level);

src/lbaselib.c+76−108

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lbaselib.c,v 1.251 2010/10/28 15:36:30 roberto Exp $	2	** $Id: lbaselib.c,v 1.261 2011/05/26 16:09:40 roberto Exp $
3	** Basic library	3	** Basic library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -32,44 +32,54 @@ static int luaB_print (lua_State *L) { · 26 unmodified lines
32	lua_call(L, 1, 1);	32	lua_call(L, 1, 1);
33	s = lua_tolstring(L, -1, &l); /* get result */	33	s = lua_tolstring(L, -1, &l); /* get result */
34	if (s == NULL)	34	if (s == NULL)
35	return luaL_error(L, LUA_QL("tostring") " must return a string to "	35	return luaL_error(L,
36	LUA_QL("print"));	36	LUA_QL("tostring") " must return a string to " LUA_QL("print"));
37	if (i>1) luai_writestring("\t", 1);	37	if (i>1) luai_writestring("\t", 1);
38	luai_writestring(s, l);	38	luai_writestring(s, l);
39	lua_pop(L, 1); /* pop result */	39	lua_pop(L, 1); /* pop result */
40	}	40	}
41	luai_writestring("\n", 1);	41	luai_writeline();
42	return 0;	42	return 0;
43	}	43	}
44		44
45		45
		46	#define SPACECHARS " \f\n\r\t\v"
		47
46	static int luaB_tonumber (lua_State *L) {	48	static int luaB_tonumber (lua_State *L) {
47	int base = luaL_optint(L, 2, 10);	49	int base = luaL_optint(L, 2, 10);
		50	luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
48	if (base == 10) { /* standard conversion */	51	if (base == 10) { /* standard conversion */
49	luaL_checkany(L, 1);	52	luaL_checkany(L, 1);
50	if (lua_isnumber(L, 1)) {	53	if (lua_isnumber(L, 1)) {
51	lua_pushnumber(L, lua_tonumber(L, 1));	54	lua_pushnumber(L, lua_tonumber(L, 1));
52	return 1;	55	return 1;
53	}	56	} /* else not a number */
54	}	57	}
55	else {	58	else {
56	const char *s1 = luaL_checkstring(L, 1);	59	size_t l;
57	char *s2;	60	const char *s = luaL_checklstring(L, 1, &l);
58	unsigned long n;	61	const char e = s + l; / end point for 's' */
59	int neg = 0;	62	int neg = 0;
60	luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");	63	s += strspn(s, SPACECHARS); /* skip initial spaces */
61	while (isspace((unsigned char)(s1))) s1++; / skip initial spaces */	64	if (s == '-') { s++; neg = 1; } / handle signal */
62	if (*s1 == '-') { s1++; neg = 1; }	65	else if (*s == '+') s++;
63	n = strtoul(s1, &s2, base);	66	if (isalnum((unsigned char)*s)) {
64	if (s1 != s2) { /* at least one valid digit? */	67	lua_Number n = 0;
65	while (isspace((unsigned char)(s2))) s2++; / skip trailing spaces */	68	do {
66	if (s2 == '\0') { / no invalid trailing characters? */	69	int digit = (isdigit((unsigned char)s)) ? s - '0'
67	lua_pushnumber(L, (neg) ? -(lua_Number)n : (lua_Number)n);	70	: toupper((unsigned char)*s) - 'A' + 10;
		71	if (digit >= base) break; /* invalid numeral; force a fail */
		72	n = n * (lua_Number)base + (lua_Number)digit;
		73	s++;
		74	} while (isalnum((unsigned char)*s));
		75	s += strspn(s, SPACECHARS); /* skip trailing spaces */
		76	if (s == e) { /* no invalid trailing characters? */
		77	lua_pushnumber(L, (neg) ? -n : n);
68	return 1;	78	return 1;
69	}	79	} /* else not a number */
70	}	80	} /* else not a number */
71	}	81	}
72	lua_pushnil(L); /* else not a number */	82	lua_pushnil(L); /* not a number */
73	return 1;	83	return 1;
74	}	84	}
75		85
@@ -110,12 +120,10 @@ static int luaB_setmetatable (lua_State *L) { · 34 unmodified lines
110	}	120	}
111		121
112		122
113	static int luaB_getfenv (lua_State *L) {	123	static int luaB_deprecated (lua_State *L) {
114	return luaL_error(L, "getfenv/setfenv deprecated");	124	return luaL_error(L, "deprecated function");
115	}	125	}
116		126
117	#define luaB_setfenv luaB_getfenv
118
119		127
120	static int luaB_rawequal (lua_State *L) {	128	static int luaB_rawequal (lua_State *L) {
121	luaL_checkany(L, 1);	129	luaL_checkany(L, 1);
@@ -125,6 +133,15 @@ static int luaB_rawequal (lua_State *L) { · 3 unmodified lines
125	}	133	}
126		134
127		135
		136	static int luaB_rawlen (lua_State *L) {
		137	int t = lua_type(L, 1);
		138	luaL_argcheck(L, t == LUA_TTABLE \|\| t == LUA_TSTRING, 1,
		139	"table or string expected");
		140	lua_pushinteger(L, lua_rawlen(L, 1));
		141	return 1;
		142	}
		143
		144
128	static int luaB_rawget (lua_State *L) {	145	static int luaB_rawget (lua_State *L) {
129	luaL_checktype(L, 1, LUA_TTABLE);	146	luaL_checktype(L, 1, LUA_TTABLE);
130	luaL_checkany(L, 2);	147	luaL_checkany(L, 2);
@@ -251,6 +268,11 @@ static int luaB_loadfile (lua_State *L) { · 120 unmodified lines
251	** =======================================================	268	** =======================================================
252	*/	269	*/
253		270
		271	/*
		272	** check whether a chunk (prefix in 's') satisfies given 'mode'
		273	** ('t' for text, 'b' for binary). Returns error message (also
		274	** pushed on the stack) in case of errors.
		275	*/
254	static const char checkrights (lua_State L, const char mode, const char s) {	276	static const char checkrights (lua_State L, const char mode, const char s) {
255	if (strchr(mode, 'b') == NULL && *s == LUA_SIGNATURE[0])	277	if (strchr(mode, 'b') == NULL && *s == LUA_SIGNATURE[0])
256	return lua_pushstring(L, "attempt to load a binary chunk");	278	return lua_pushstring(L, "attempt to load a binary chunk");
@@ -261,10 +283,11 @@ static const char checkrights (lua_State L, const char mode, const char s) { · 4 unmodified lines
261		283
262		284
263	/*	285	/*
264	** reserves a slot, above all arguments, to hold a copy of the returned	286	** reserved slot, above all arguments, to hold a copy of the returned
265	** string to avoid it being collected while parsed	287	** string to avoid it being collected while parsed. 'load' has four
		288	** optional arguments (chunk, source name, mode, and environment).
266	*/	289	*/
267	#define RESERVEDSLOT 4	290	#define RESERVEDSLOT 5
268		291
269		292
270	/*	293	/*
@@ -273,25 +296,20 @@ static const char checkrights (lua_State L, const char mode, const char s) { · 2 unmodified lines
273	** stack top. Instead, it keeps its resulting string in a	296	** stack top. Instead, it keeps its resulting string in a
274	** reserved slot inside the stack.	297	** reserved slot inside the stack.
275	*/	298	*/
276	typedef struct { /* reader state */
277	int f; /* position of reader function on stack */
278	const char mode; / allowed modes (binary/text) */
279	} Readstat;
280
281	static const char generic_reader (lua_State L, void ud, size_t size) {	299	static const char generic_reader (lua_State L, void ud, size_t size) {
282	const char *s;	300	const char *s;
283	Readstat stat = (Readstat )ud;	301	const char mode = (const char )ud;
284	luaL_checkstack(L, 2, "too many nested functions");	302	luaL_checkstack(L, 2, "too many nested functions");
285	lua_pushvalue(L, stat->f); /* get function */	303	lua_pushvalue(L, 1); /* get function */
286	lua_call(L, 0, 1); /* call it */	304	lua_call(L, 0, 1); /* call it */
287	if (lua_isnil(L, -1)) {	305	if (lua_isnil(L, -1)) {
288	*size = 0;	306	*size = 0;
289	return NULL;	307	return NULL;
290	}	308	}
291	else if ((s = lua_tostring(L, -1)) != NULL) {	309	else if ((s = lua_tostring(L, -1)) != NULL) {
292	if (stat->mode != NULL) { /* first time? */	310	if (mode != NULL) { / first time? */
293	s = checkrights(L, stat->mode, s); /* check mode */	311	s = checkrights(L, mode, s); / check mode */
294	stat->mode = NULL; /* to avoid further checks */	312	mode = NULL; / to avoid further checks */
295	if (s) luaL_error(L, s);	313	if (s) luaL_error(L, s);
296	}	314	}
297	lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */	315	lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */
@@ -304,52 +322,38 @@ static const char generic_reader (lua_State L, void ud, size_t size) { · 6 unmodified lines
304	}	322	}
305		323
306		324
307	static int luaB_load_aux (lua_State *L, int farg) {	325	static int luaB_load (lua_State *L) {
308	int status;	326	int status;
309	Readstat stat;
310	size_t l;	327	size_t l;
311	const char *s = lua_tolstring(L, farg, &l);	328	int top = lua_gettop(L);
312	stat.mode = luaL_optstring(L, farg + 2, "bt");	329	const char *s = lua_tolstring(L, 1, &l);
		330	const char *mode = luaL_optstring(L, 3, "bt");
313	if (s != NULL) { /* loading a string? */	331	if (s != NULL) { /* loading a string? */
314	const char *chunkname = luaL_optstring(L, farg + 1, s);	332	const char *chunkname = luaL_optstring(L, 2, s);
315	status = (checkrights(L, stat.mode, s) != NULL)	333	status = (checkrights(L, mode, s) != NULL)
316	\|\| luaL_loadbuffer(L, s, l, chunkname);	334	\|\| luaL_loadbuffer(L, s, l, chunkname);
317	}	335	}
318	else { /* loading from a reader function */	336	else { /* loading from a reader function */
319	const char *chunkname = luaL_optstring(L, farg + 1, "=(load)");	337	const char *chunkname = luaL_optstring(L, 2, "=(load)");
320	luaL_checktype(L, farg, LUA_TFUNCTION);	338	luaL_checktype(L, 1, LUA_TFUNCTION);
321	stat.f = farg;
322	lua_settop(L, RESERVEDSLOT); /* create reserved slot */	339	lua_settop(L, RESERVEDSLOT); /* create reserved slot */
323	status = lua_load(L, generic_reader, &stat, chunkname);	340	status = lua_load(L, generic_reader, &mode, chunkname);
		341	}
		342	if (status == LUA_OK && top >= 4) { /* is there an 'env' argument */
		343	lua_pushvalue(L, 4); /* environment for loaded function */
		344	lua_setupvalue(L, -2, 1); /* set it as 1st upvalue */
324	}	345	}
325	return load_aux(L, status);	346	return load_aux(L, status);
326	}	347	}
327		348
328		349
329	static int luaB_load (lua_State *L) {	350	#if defined(LUA_COMPAT_LOADSTRING)
330	return luaB_load_aux(L, 1);	351	#define luaB_loadstring luaB_load
331	}	352	#else
332		353	#define luaB_loadstring luaB_deprecated
333		354	#endif
334	static int luaB_loadin (lua_State *L) {
335	int n;
336	luaL_checkany(L, 1);
337	n = luaB_load_aux(L, 2);
338	if (n == 1) { /* success? */
339	lua_pushvalue(L, 1); /* environment for loaded function */
340	if (lua_setupvalue(L, -2, 1) == NULL)
341	luaL_error(L, "loaded chunk does not have an upvalue");
342	}
343	return n;
344	}
345		355
346		356
347	static int luaB_loadstring (lua_State *L) {
348	lua_settop(L, 2);
349	lua_pushliteral(L, "tb");
350	return luaB_load(L); /* dostring(s, n) == load(s, n, "tb") */
351
352	}
353	/* }====================================================== */	357	/* }====================================================== */
354		358
355		359
@@ -391,7 +395,7 @@ static int luaB_select (lua_State *L) { · 35 unmodified lines
391		395
392		396
393	static int pcallcont (lua_State *L) {	397	static int pcallcont (lua_State *L) {
394	int errfunc; /* call has an error function in bottom of the stack */	398	int errfunc = 0; /* =0 to avoid warnings */
395	int status = lua_getctx(L, &errfunc);	399	int status = lua_getctx(L, &errfunc);
396	lua_assert(status != LUA_OK);	400	lua_assert(status != LUA_OK);
397	lua_pushboolean(L, (status == LUA_YIELD)); /* first result (status) */	401	lua_pushboolean(L, (status == LUA_YIELD)); /* first result (status) */
@@ -436,55 +440,27 @@ static int luaB_tostring (lua_State *L) { · 38 unmodified lines
436	}	440	}
437		441
438		442
439	static int luaB_newproxy (lua_State *L) {
440	lua_settop(L, 1);
441	lua_newuserdata(L, 0); /* create proxy */
442	if (lua_toboolean(L, 1) == 0)
443	return 1; /* no metatable */
444	else if (lua_isboolean(L, 1)) {
445	lua_createtable(L, 0, 1); /* create a new metatable `m' ... */
446	lua_pushboolean(L, 1);
447	lua_setfield(L, -2, "__gc"); /* ... m.__gc = false (HACK!!)... */
448	lua_pushvalue(L, -1); /* ... and mark `m' as a valid metatable */
449	lua_pushboolean(L, 1);
450	lua_rawset(L, lua_upvalueindex(1)); /* weaktable[m] = true */
451	}
452	else {
453	int validproxy = 0; /* to check if weaktable[metatable(u)] == true */
454	if (lua_getmetatable(L, 1)) {
455	lua_rawget(L, lua_upvalueindex(1));
456	validproxy = lua_toboolean(L, -1);
457	lua_pop(L, 1); /* remove value */
458	}
459	luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
460	lua_getmetatable(L, 1); /* metatable is valid; get it */
461	}
462	lua_setmetatable(L, 2);
463	return 1;
464	}
465
466
467	static const luaL_Reg base_funcs[] = {	443	static const luaL_Reg base_funcs[] = {
468	{"assert", luaB_assert},	444	{"assert", luaB_assert},
469	{"collectgarbage", luaB_collectgarbage},	445	{"collectgarbage", luaB_collectgarbage},
470	{"dofile", luaB_dofile},	446	{"dofile", luaB_dofile},
471	{"error", luaB_error},	447	{"error", luaB_error},
472	{"getfenv", luaB_getfenv},	448	{"getfenv", luaB_deprecated},
473	{"getmetatable", luaB_getmetatable},	449	{"getmetatable", luaB_getmetatable},
474	{"ipairs", luaB_ipairs},	450	{"ipairs", luaB_ipairs},
475	{"loadfile", luaB_loadfile},	451	{"loadfile", luaB_loadfile},
476	{"load", luaB_load},	452	{"load", luaB_load},
477	{"loadin", luaB_loadin},
478	{"loadstring", luaB_loadstring},	453	{"loadstring", luaB_loadstring},
479	{"next", luaB_next},	454	{"next", luaB_next},
480	{"pairs", luaB_pairs},	455	{"pairs", luaB_pairs},
481	{"pcall", luaB_pcall},	456	{"pcall", luaB_pcall},
482	{"print", luaB_print},	457	{"print", luaB_print},
483	{"rawequal", luaB_rawequal},	458	{"rawequal", luaB_rawequal},
		459	{"rawlen", luaB_rawlen},
484	{"rawget", luaB_rawget},	460	{"rawget", luaB_rawget},
485	{"rawset", luaB_rawset},	461	{"rawset", luaB_rawset},
486	{"select", luaB_select},	462	{"select", luaB_select},
487	{"setfenv", luaB_setfenv},	463	{"setfenv", luaB_deprecated},
488	{"setmetatable", luaB_setmetatable},	464	{"setmetatable", luaB_setmetatable},
489	{"tonumber", luaB_tonumber},	465	{"tonumber", luaB_tonumber},
490	{"tostring", luaB_tostring},	466	{"tostring", luaB_tostring},
@@ -503,14 +479,6 @@ LUAMOD_API int luaopen_base (lua_State *L) { · 12 unmodified lines
503	luaL_setfuncs(L, base_funcs, 0);	479	luaL_setfuncs(L, base_funcs, 0);
504	lua_pushliteral(L, LUA_VERSION);	480	lua_pushliteral(L, LUA_VERSION);
505	lua_setfield(L, -2, "_VERSION"); /* set global _VERSION */	481	lua_setfield(L, -2, "_VERSION"); /* set global _VERSION */
506	/* `newproxy' needs a weaktable as upvalue */
507	lua_createtable(L, 0, 1); /* new table `w' */
508	lua_pushvalue(L, -1); /* `w' will be its own metatable */
509	lua_setmetatable(L, -2);
510	lua_pushliteral(L, "kv");
511	lua_setfield(L, -2, "__mode"); /* metatable(w).__mode = "kv" */
512	lua_pushcclosure(L, luaB_newproxy, 1);
513	lua_setfield(L, -2, "newproxy"); /* set global `newproxy' */
514	return 1;	482	return 1;
515	}	483	}
516		484

src/lbitlib.c+67−21

 /*
-** $Id: lbitlib.c,v 1.13 2010/11/22 18:06:33 roberto Exp $
+** $Id: lbitlib.c,v 1.15 2010/12/17 13:26:38 roberto Exp $
 ** Standard library for bitwise operations
 ** See Copyright Notice in lua.h
 */
 /* number of bits to consider in a number */
-#define NBITS	32
+#if !defined(LUA_NBITS)
+#define LUA_NBITS	32
+#endif
-#define ALLONES		(~(((~(lua_Unsigned)0) << (NBITS - 1)) << 1))
-/* mask to trim extra bits */
+#define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
+/* macro to trim extra bits */
 #define trim(x)		((x) & ALLONES)
-typedef lua_Unsigned b_uint;
+/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
+#define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
+typedef lua_Unsigned b_uint;
-#define getuintarg(L,arg)	luaL_checkunsigned(L,arg)
 static b_uint andaux (lua_State *L) {
   int i, n = lua_gettop(L);
   b_uint r = ~(b_uint)0;
   for (i = 1; i <= n; i++)
-    r &= getuintarg(L, i);
+    r &= luaL_checkunsigned(L, i);
   return trim(r);
 }
   int i, n = lua_gettop(L);
   b_uint r = 0;
   for (i = 1; i <= n; i++)
-    r |= getuintarg(L, i);
+    r |= luaL_checkunsigned(L, i);
   lua_pushunsigned(L, trim(r));
   return 1;
 }
   int i, n = lua_gettop(L);
   b_uint r = 0;
   for (i = 1; i <= n; i++)
-    r ^= getuintarg(L, i);
+    r ^= luaL_checkunsigned(L, i);
   lua_pushunsigned(L, trim(r));
   return 1;
 }
 static int b_not (lua_State *L) {
-  b_uint r = ~getuintarg(L, 1);
+  b_uint r = ~luaL_checkunsigned(L, 1);
   lua_pushunsigned(L, trim(r));
   return 1;
 }
   if (i < 0) {  /* shift right? */
     i = -i;
     r = trim(r);
-    if (i >= NBITS) r = 0;
+    if (i >= LUA_NBITS) r = 0;
     else r >>= i;
   }
   else {  /* shift left */
-    if (i >= NBITS) r = 0;
+    if (i >= LUA_NBITS) r = 0;
     else r <<= i;
     r = trim(r);
   }
 static int b_lshift (lua_State *L) {
-  return b_shift(L, getuintarg(L, 1), luaL_checkint(L, 2));
+  return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2));
 }
 static int b_rshift (lua_State *L) {
-  return b_shift(L, getuintarg(L, 1), -luaL_checkint(L, 2));
+  return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2));
 }
 static int b_arshift (lua_State *L) {
-  b_uint r = getuintarg(L, 1);
+  b_uint r = luaL_checkunsigned(L, 1);
   int i = luaL_checkint(L, 2);
-  if (i < 0 || !(r & ((b_uint)1 << (NBITS - 1))))
+  if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1))))
     return b_shift(L, r, -i);
   else {  /* arithmetic shift for 'negative' number */
-    if (i >= NBITS) r = ALLONES;
+    if (i >= LUA_NBITS) r = ALLONES;
     else
       r = trim((r >> i) | ~(~(b_uint)0 >> i));  /* add signal bit */
     lua_pushunsigned(L, r);
 static int b_rot (lua_State *L, int i) {
-  b_uint r = getuintarg(L, 1);
+  b_uint r = luaL_checkunsigned(L, 1);
-  i &= (NBITS - 1);  /* i = i % NBITS */
+  i &= (LUA_NBITS - 1);  /* i = i % NBITS */
   r = trim(r);
-  r = (r << i) | (r >> (NBITS - i));
+  r = (r << i) | (r >> (LUA_NBITS - i));
   lua_pushunsigned(L, trim(r));
   return 1;
 }
 }
+/*
+** get field and width arguments for field-manipulation functions,
+** checking whether they are valid
+*/
+static int fieldargs (lua_State *L, int farg, int *width) {
+  int f = luaL_checkint(L, farg);
+  int w = luaL_optint(L, farg + 1, 1);
+  luaL_argcheck(L, 0 <= f, farg, "field cannot be netative");
+  luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
+  if (f + w > LUA_NBITS)
+    luaL_error(L, "trying to access non-existent bits");
+  *width = w;
+  return f;
+}
+static int b_extract (lua_State *L) {
+  int w;
+  b_uint r = luaL_checkunsigned(L, 1);
+  int f = fieldargs(L, 2, &w);
+  r = (r >> f) & mask(w);
+  lua_pushunsigned(L, r);
+  return 1;
+}
+static int b_replace (lua_State *L) {
+  int w;
+  b_uint r = luaL_checkunsigned(L, 1);
+  b_uint v = luaL_checkunsigned(L, 2);
+  int f = fieldargs(L, 3, &w);
+  int m = mask(w);
+  v &= m;  /* erase bits outside given width */
+  r = (r & ~(m << f)) | (v << f);
+  lua_pushunsigned(L, r);
+  return 1;
+}
 static const luaL_Reg bitlib[] = {
   {"arshift", b_arshift},
   {"band", b_and},
   {"bnot", b_not},
   {"bor", b_or},
   {"bxor", b_xor},
+  {"btest", b_test},
+  {"extract", b_extract},
   {"lrotate", b_lrot},
   {"lshift", b_lshift},
+  {"replace", b_replace},
   {"rrotate", b_rrot},
   {"rshift", b_rshift},
-  {"btest", b_test},
   {NULL, NULL}
 };

src/lcode.c+42−38

 /*
-** $Id: lcode.c,v 2.49 2010/07/07 16:27:29 roberto Exp $
+** $Id: lcode.c,v 2.56 2011/05/31 18:27:56 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 #include "lparser.h"
 #include "lstring.h"
 #include "ltable.h"
+#include "lvm.h"
 #define hasjumps(e)	((e)->t != (e)->f)
 void luaK_nil (FuncState *fs, int from, int n) {
   Instruction *previous;
+  int l = from + n - 1;  /* last register to set nil */
   if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
     previous = &fs->f->code[fs->pc-1];
     if (GET_OPCODE(*previous) == OP_LOADNIL) {
       int pfrom = GETARG_A(*previous);
-      int pto = GETARG_B(*previous);
+      int pl = pfrom + GETARG_B(*previous);
-      if (pfrom <= from && from <= pto+1) {  /* can connect both? */
+      if ((pfrom <= from && from <= pl + 1) ||
-        if (from+n-1 > pto)
+          (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
-          SETARG_B(*previous, from+n-1);
+        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;
       }
-    }
+    }  /* else go through */
   }
-  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
+  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */
 }
 }
+LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) {
+  level++;  /* argument is +1 to reserve 0 as non-op */
+  while (list != NO_JUMP) {
+    int next = getjump(fs, list);
+    lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
+                (GETARG_A(fs->f->code[list]) == 0 ||
+                 GETARG_A(fs->f->code[list]) >= level));
+    SETARG_A(fs->f->code[list], level);
+    list = next;
+  }
+}
 void luaK_patchtohere (FuncState *fs, int list) {
   luaK_getlabel(fs);
   luaK_concat(fs, &fs->jpc, list);
 }
-int luaK_codeABxX (FuncState *fs, OpCode o, int reg, int k) {
+int luaK_codek (FuncState *fs, int reg, int k) {
-  if (k < MAXARG_Bx)
+  if (k <= MAXARG_Bx)
-    return luaK_codeABx(fs, o, reg, k + 1);
+    return luaK_codeABx(fs, OP_LOADK, reg, k);
   else {
-    int p = luaK_codeABx(fs, o, reg, 0);
+    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
     codeextraarg(fs, k);
     return p;
   }
   if (ttisnumber(idx)) {
     lua_Number n = nvalue(idx);
     lua_number2int(k, n);
-    if (luaO_rawequalObj(&f->k[k], v))
+    if (luaV_rawequalobj(&f->k[k], v))
       return k;
     /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
        go through and create a new entry for this value */
 void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
-  int func;
+  int ereg;
   luaK_exp2anyreg(fs, e);
+  ereg = e->u.info;  /* register where 'e' was placed */
   freeexp(fs, e);
-  func = fs->freereg;
+  e->u.info = fs->freereg;  /* base register for op_self */
-  luaK_codeABC(fs, OP_SELF, func, e->u.info, luaK_exp2RK(fs, key));
-  freeexp(fs, key);
-  luaK_reserveregs(fs, 2);
-  e->u.info = func;
   e->k = VNONRELOC;
+  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
+  luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
+  freeexp(fs, key);
 }
   int pc;  /* pc of last jump */
   luaK_dischargevars(fs, e);
   switch (e->k) {
-    case VK: case VKNUM: case VTRUE: {
-      pc = NO_JUMP;  /* always true; do nothing */
-      break;
-    }
     case VJMP: {
       invertjump(fs, e);
       pc = e->u.info;
       break;
     }
-    case VFALSE: {
+    case VK: case VKNUM: case VTRUE: {
-      if (!hasjumps(e)) {
+      pc = NO_JUMP;  /* always true; do nothing */
-        pc = luaK_jump(fs);  /* always jump */
+      break;
-        break;
-      }
-      /* else go through */
     }
     default: {
       pc = jumponcond(fs, e, 0);
   int pc;  /* pc of last jump */
   luaK_dischargevars(fs, e);
   switch (e->k) {
-    case VNIL: case VFALSE: {
-      pc = NO_JUMP;  /* always false; do nothing */
-      break;
-    }
     case VJMP: {
       pc = e->u.info;
       break;
     }
-    case VTRUE: {
+    case VNIL: case VFALSE: {
-      if (!hasjumps(e)) {
+      pc = NO_JUMP;  /* always false; do nothing */
-        pc = luaK_jump(fs);  /* always jump */
+      break;
-        break;
-      }
-      /* else go through */
     }
     default: {
       pc = jumponcond(fs, e, 1);

src/lcode.h+3−4

 /*
-** $Id: lcode.h,v 1.55 2010/07/02 20:42:40 roberto Exp $
+** $Id: lcode.h,v 1.57 2011/04/07 18:14:12 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 #define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
-#define luaK_codek(fs,reg,k)	    luaK_codeABxX(fs, OP_LOADK, reg, k)
 LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
 LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
-LUAI_FUNC int luaK_codeABxX (FuncState *fs, OpCode o, int reg, int k);
+LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
 LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
 LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
 LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
 LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
 LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
 LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
+LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
 LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
 LUAI_FUNC int luaK_getlabel (FuncState *fs);
 LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);

src/ldblib.c+8−19

 /*
-** $Id: ldblib.c,v 1.126 2010/11/16 18:01:28 roberto Exp $
+** $Id: ldblib.c,v 1.130 2011/04/08 19:17:36 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 #include "lualib.h"
+#define HOOKKEY		"_HKEY"
 static int db_getregistry (lua_State *L) {
   lua_pushvalue(L, LUA_REGISTRYINDEX);
   luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                     "nil or table expected");
   lua_settop(L, 2);
-  lua_pushboolean(L, lua_setmetatable(L, 1));
+  lua_setmetatable(L, 1);
-  return 1;
+  return 1;  /* return 1st argument */
 }
 }
-static const char KEY_HOOK = 'h';
+#define gethooktable(L)	luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY);
 static void hookf (lua_State *L, lua_Debug *ar) {
   static const char *const hooknames[] =
     {"call", "return", "line", "count", "tail call"};
-  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+  gethooktable(L);
-  lua_rawget(L, LUA_REGISTRYINDEX);
   lua_pushlightuserdata(L, L);
   lua_rawget(L, -2);
   if (lua_isfunction(L, -1)) {
 }
-static void gethooktable (lua_State *L) {
-  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-  lua_rawget(L, LUA_REGISTRYINDEX);
-  if (!lua_istable(L, -1)) {
-    lua_pop(L, 1);
-    lua_createtable(L, 0, 1);
-    lua_pushlightuserdata(L, (void *)&KEY_HOOK);
-    lua_pushvalue(L, -2);
-    lua_rawset(L, LUA_REGISTRYINDEX);
-  }
-}
 static int db_sethook (lua_State *L) {
   int arg, mask, count;
   lua_Hook func;

src/ldebug.c+74−36

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldebug.c,v 2.74 2010/10/11 20:24:42 roberto Exp $	2	** $Id: ldebug.c,v 2.82 2011/06/02 19:31:40 roberto Exp $
3	** Debug Interface	3	** Debug Interface
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -35,12 +35,12 @@ static const char getfuncname (lua_State L, CallInfo ci, const char *name); · 29 unmodified lines
35		35
36	static int currentpc (CallInfo *ci) {	36	static int currentpc (CallInfo *ci) {
37	lua_assert(isLua(ci));	37	lua_assert(isLua(ci));
38	return pcRel(ci->u.l.savedpc, ci_func(ci)->l.p);	38	return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
39	}	39	}
40		40
41		41
42	static int currentline (CallInfo *ci) {	42	static int currentline (CallInfo *ci) {
43	return getfuncline(ci_func(ci)->l.p, currentpc(ci));	43	return getfuncline(ci_func(ci)->p, currentpc(ci));
44	}	44	}
45		45
46		46
@@ -94,13 +94,28 @@ LUA_API int lua_getstack (lua_State L, int level, lua_Debug ar) { · 47 unmodified lines
94	}	94	}
95		95
96		96
		97	static const char findvararg (CallInfo ci, int n, StkId *pos) {
		98	int nparams = clLvalue(ci->func)->p->numparams;
		99	if (n >= ci->u.l.base - ci->func - nparams)
		100	return NULL; /* no such vararg */
		101	else {
		102	*pos = ci->func + nparams + n;
		103	return "(vararg)"; / generic name for any vararg */
		104	}
		105	}
		106
		107
97	static const char findlocal (lua_State L, CallInfo *ci, int n,	108	static const char findlocal (lua_State L, CallInfo *ci, int n,
98	StkId *pos) {	109	StkId *pos) {
99	const char *name = NULL;	110	const char *name = NULL;
100	StkId base;	111	StkId base;
101	if (isLua(ci)) {	112	if (isLua(ci)) {
102	base = ci->u.l.base;	113	if (n < 0) /* access to vararg values? */
103	name = luaF_getlocalname(ci_func(ci)->l.p, n, currentpc(ci));	114	return findvararg(ci, -n, pos);
		115	else {
		116	base = ci->u.l.base;
		117	name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
		118	}
104	}	119	}
105	else	120	else
106	base = ci->func + 1;	121	base = ci->func + 1;
@@ -108,10 +123,8 @@ static const char findlocal (lua_State L, CallInfo *ci, int n, · 1 unmodified line
108	StkId limit = (ci == L->ci) ? L->top : ci->next->func;	123	StkId limit = (ci == L->ci) ? L->top : ci->next->func;
109	if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */	124	if (limit - base >= n && n > 0) /* is 'n' inside 'ci' stack? */
110	name = "(temporary)"; / generic name for any valid slot */	125	name = "(temporary)"; / generic name for any valid slot */
111	else {	126	else
112	pos = base; / to avoid warnings */
113	return NULL; /* no name */	127	return NULL; /* no name */
114	}
115	}	128	}
116	*pos = base + (n - 1);	129	*pos = base + (n - 1);
117	return name;	130	return name;
@@ -125,10 +138,10 @@ LUA_API const char lua_getlocal (lua_State L, const lua_Debug *ar, int n) { · 7 unmodified lines
125	if (!isLfunction(L->top - 1)) /* not a Lua function? */	138	if (!isLfunction(L->top - 1)) /* not a Lua function? */
126	name = NULL;	139	name = NULL;
127	else /* consider live variables at function start (parameters) */	140	else /* consider live variables at function start (parameters) */
128	name = luaF_getlocalname(clvalue(L->top - 1)->l.p, n, 0);	141	name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0);
129	}	142	}
130	else { /* active function; get information through 'ar' */	143	else { /* active function; get information through 'ar' */
131	StkId pos;	144	StkId pos = 0; /* to avoid warnings */
132	name = findlocal(L, ar->i_ci, n, &pos);	145	name = findlocal(L, ar->i_ci, n, &pos);
133	if (name) {	146	if (name) {
134	setobj2s(L, L->top, pos);	147	setobj2s(L, L->top, pos);
@@ -141,11 +154,11 @@ LUA_API const char lua_getlocal (lua_State L, const lua_Debug *ar, int n) { · 6 unmodified lines
141		154
142		155
143	LUA_API const char lua_setlocal (lua_State L, const lua_Debug *ar, int n) {	156	LUA_API const char lua_setlocal (lua_State L, const lua_Debug *ar, int n) {
144	StkId pos;	157	StkId pos = 0; /* to avoid warnings */
145	const char *name = findlocal(L, ar->i_ci, n, &pos);	158	const char *name = findlocal(L, ar->i_ci, n, &pos);
146	lua_lock(L);	159	lua_lock(L);
147	if (name)	160	if (name)
148	setobjs2s(L, pos, L->top - 1);	161	setobjs2s(L, pos, L->top - 1);
149	L->top--; /* pop value */	162	L->top--; /* pop value */
150	lua_unlock(L);	163	lua_unlock(L);
151	return name;	164	return name;
@@ -243,7 +256,7 @@ LUA_API int lua_getinfo (lua_State L, const char what, lua_Debug *ar) { · 91 unmodified lines
243	if (*what == '>') {	256	if (*what == '>') {
244	ci = NULL;	257	ci = NULL;
245	func = L->top - 1;	258	func = L->top - 1;
246	luai_apicheck(L, ttisfunction(func));	259	api_check(L, ttisfunction(func), "function expected");
247	what++; /* skip the '>' */	260	what++; /* skip the '>' */
248	L->top--; /* pop function */	261	L->top--; /* pop function */
249	}	262	}
@@ -271,21 +284,38 @@ LUA_API int lua_getinfo (lua_State L, const char what, lua_Debug *ar) { · 21 unmodified lines
271	** =======================================================	284	** =======================================================
272	*/	285	*/
273		286
		287	static const char getobjname (lua_State L, CallInfo *ci, int reg,
		288	const char **name);
274		289
275	static void kname (Proto p, int c, int reg, const char what,	290
276	const char **name) {	291	/*
277	if (c == reg && what && *what == 'c')	292	** find a "name" for the RK value 'c'
278	return; /* index is a constant; name already correct */	293	*/
279	else if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))	294	static void kname (lua_State L, CallInfo ci, int c, int oreg,
280	*name = svalue(&p->k[INDEXK(c)]);	295	const char what, const char *name) {
281	else	296	if (ISK(c)) { /* is 'c' a constant? */
282	*name = "?";	297	TValue *kvalue = &ci_func(ci)->p->k[INDEXK(c)];
		298	if (ttisstring(kvalue)) { /* literal constant? */
		299	name = svalue(kvalue); / it is its own name */
		300	return;
		301	}
		302	/* else no reasonable name found */
		303	}
		304	else { /* 'c' is a register */
		305	if (c != oreg) /* not the original register? */
		306	what = getobjname(L, ci, c, name); /* search for 'c' */
		307	if (what && what == 'c') { / found a constant name? */
		308	return; /* 'name' already filled */
		309	}
		310	/* else no reasonable name found */
		311	}
		312	name = "?"; / no reasonable name found */
283	}	313	}
284		314
285		315
286	static const char getobjname (lua_State L, CallInfo *ci, int reg,	316	static const char getobjname (lua_State L, CallInfo *ci, int reg,
287	const char **name) {	317	const char **name) {
288	Proto *p = ci_func(ci)->l.p;	318	Proto *p = ci_func(ci)->p;
289	const char *what = NULL;	319	const char *what = NULL;
290	int lastpc = currentpc(ci);	320	int lastpc = currentpc(ci);
291	int pc;	321	int pc;
@@ -312,10 +342,10 @@ static const char getobjname (lua_State L, CallInfo *ci, int reg, · 20 unmodified lines
312	if (reg == a) {	342	if (reg == a) {
313	int k = GETARG_C(i); /* key index */	343	int k = GETARG_C(i); /* key index */
314	int t = GETARG_B(i);	344	int t = GETARG_B(i);
315	const char vn = (op == OP_GETTABLE) / name of indexed variable */	345	const char vn = (op == OP_GETTABLE) / name of indexed variable */
316	? luaF_getlocalname(p, t + 1, pc)	346	? luaF_getlocalname(p, t + 1, pc)
317	: getstr(p->upvalues[t].name);	347	: getstr(p->upvalues[t].name);
318	kname(p, k, a, what, name);	348	kname(L, ci, k, a, what, name);
319	what = (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";	349	what = (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
320	}	350	}
321	break;	351	break;
@@ -329,10 +359,11 @@ static const char getobjname (lua_State L, CallInfo *ci, int reg, · 7 unmodified lines
329	}	359	}
330	break;	360	break;
331	}	361	}
332	case OP_LOADK: {	362	case OP_LOADK:
		363	case OP_LOADKX: {
333	if (reg == a) {	364	if (reg == a) {
334	int b = GETARG_Bx(i);	365	int b = (op == OP_LOADK) ? GETARG_Bx(i)
335	b = (b > 0) ? b - 1 : GETARG_Ax(p->code[pc + 1]);	366	: GETARG_Ax(p->code[pc + 1]);
336	if (ttisstring(&p->k[b])) {	367	if (ttisstring(&p->k[b])) {
337	what = "constant";	368	what = "constant";
338	*name = svalue(&p->k[b]);	369	*name = svalue(&p->k[b]);
@@ -341,15 +372,15 @@ static const char getobjname (lua_State L, CallInfo *ci, int reg, · 2 unmodified lines
341	break;	372	break;
342	}	373	}
343	case OP_LOADNIL: {	374	case OP_LOADNIL: {
344	int b = GETARG_B(i); /* move from 'b' to 'a' */	375	int b = GETARG_B(i);
345	if (a <= reg && reg <= b) /* set registers from 'a' to 'b' */	376	if (a <= reg && reg <= a + b) /* set registers from 'a' to 'a+b' */
346	what = NULL;	377	what = NULL;
347	break;	378	break;
348	}	379	}
349	case OP_SELF: {	380	case OP_SELF: {
350	if (reg == a) {	381	if (reg == a) {
351	int k = GETARG_C(i); /* key index */	382	int k = GETARG_C(i); /* key index */
352	kname(p, k, a, what, name);	383	kname(L, ci, k, a, what, name);
353	what = "method";	384	what = "method";
354	}	385	}
355	break;	386	break;
@@ -371,6 +402,10 @@ static const char getobjname (lua_State L, CallInfo *ci, int reg, · 15 unmodified lines
371	pc += b; /* do the jump */	402	pc += b; /* do the jump */
372	break;	403	break;
373	}	404	}
		405	case OP_TEST: {
		406	if (reg == a) what = NULL; /* jumped code can change 'a' */
		407	break;
		408	}
374	default:	409	default:
375	if (testAMode(op) && reg == a) what = NULL;	410	if (testAMode(op) && reg == a) what = NULL;
376	break;	411	break;
@@ -386,9 +421,9 @@ static const char getfuncname (lua_State L, CallInfo ci, const char *name) { · 9 unmodified lines
386	if ((ci->callstatus & CIST_TAIL) \|\| !isLua(ci->previous))	421	if ((ci->callstatus & CIST_TAIL) \|\| !isLua(ci->previous))
387	return NULL; /* calling function is not Lua (or is unknown) */	422	return NULL; /* calling function is not Lua (or is unknown) */
388	ci = ci->previous; /* calling function */	423	ci = ci->previous; /* calling function */
389	i = ci_func(ci)->l.p->code[currentpc(ci)];	424	i = ci_func(ci)->p->code[currentpc(ci)];
390	if (GET_OPCODE(i) == OP_EXTRAARG) /* extra argument? */	425	if (GET_OPCODE(i) == OP_EXTRAARG) /* extra argument? */
391	i = ci_func(ci)->l.p->code[currentpc(ci) - 1]; /* get 'real' instruction */	426	i = ci_func(ci)->p->code[currentpc(ci) - 1]; /* get 'real' instruction */
392	switch (GET_OPCODE(i)) {	427	switch (GET_OPCODE(i)) {
393	case OP_CALL:	428	case OP_CALL:
394	case OP_TAILCALL:	429	case OP_TAILCALL:
@@ -425,7 +460,10 @@ static const char getfuncname (lua_State L, CallInfo ci, const char *name) { · 30 unmodified lines
425		460
426		461
427		462
428	/* only ANSI way to check whether a pointer points to an array */	463	/*
		464	** only ANSI way to check whether a pointer points to an array
		465	** (used only for error messages, so efficiency is not a big concern)
		466	*/
429	static int isinstack (CallInfo ci, const TValue o) {	467	static int isinstack (CallInfo ci, const TValue o) {
430	StkId p;	468	StkId p;
431	for (p = ci->u.l.base; p < ci->top; p++)	469	for (p = ci->u.l.base; p < ci->top; p++)
@@ -436,7 +474,7 @@ static int isinstack (CallInfo ci, const TValue o) { · 4 unmodified lines
436		474
437	static const char getupvalname (CallInfo ci, const TValue *o,	475	static const char getupvalname (CallInfo ci, const TValue *o,
438	const char **name) {	476	const char **name) {
439	LClosure *c = &ci_func(ci)->l;	477	LClosure *c = ci_func(ci);
440	int i;	478	int i;
441	for (i = 0; i < c->nupvalues; i++) {	479	for (i = 0; i < c->nupvalues; i++) {
442	if (c->upvals[i]->v == o) {	480	if (c->upvals[i]->v == o) {
@@ -455,7 +493,7 @@ void luaG_typeerror (lua_State L, const TValue o, const char *op) { · 12 unmodified lines
455	const char *kind = NULL;	493	const char *kind = NULL;
456	if (isLua(ci)) {	494	if (isLua(ci)) {
457	kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */	495	kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */
458	if (!kind && isinstack(ci, o)) /* no? try a register */	496	if (!kind && isinstack(ci, o)) /* no? try a register */
459	kind = getobjname(L, ci, cast_int(o - ci->u.l.base), &name);	497	kind = getobjname(L, ci, cast_int(o - ci->u.l.base), &name);
460	}	498	}
461	if (kind)	499	if (kind)
@@ -497,7 +535,7 @@ static void addinfo (lua_State L, const char msg) { · 35 unmodified lines
497	if (isLua(ci)) { /* is Lua code? */	535	if (isLua(ci)) { /* is Lua code? */
498	char buff[LUA_IDSIZE]; /* add file:line information */	536	char buff[LUA_IDSIZE]; /* add file:line information */
499	int line = currentline(ci);	537	int line = currentline(ci);
500	TString *src = ci_func(ci)->l.p->source;	538	TString *src = ci_func(ci)->p->source;
501	if (src)	539	if (src)
502	luaO_chunkid(buff, getstr(src), LUA_IDSIZE);	540	luaO_chunkid(buff, getstr(src), LUA_IDSIZE);
503	else { /* no source available; use "?" instead */	541	else { /* no source available; use "?" instead */

src/ldebug.h+4−1

 /*
-** $Id: ldebug.h,v 2.5 2009/06/10 16:57:53 roberto Exp $
+** $Id: ldebug.h,v 2.6 2011/06/02 19:31:40 roberto Exp $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
 #define resethookcount(L)	(L->hookcount = L->basehookcount)
+/* Active Lua function (given call info) */
+#define ci_func(ci)		(clLvalue((ci)->func))
 LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
                                              const char *opname);

src/ldo.c+64−66

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldo.c,v 2.90 2010/10/25 19:01:37 roberto Exp $	2	** $Id: ldo.c,v 2.95 2011/06/02 19:31:40 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	*/
@@ -293,65 +293,59 @@ static StkId tryfuncTM (lua_State *L, StkId func) { · 287 unmodified lines
293	** returns true if function has been executed (C function)	293	** returns true if function has been executed (C function)
294	*/	294	*/
295	int luaD_precall (lua_State *L, StkId func, int nresults) {	295	int luaD_precall (lua_State *L, StkId func, int nresults) {
296	Closure *cl;
297	lua_CFunction f;	296	lua_CFunction f;
298	ptrdiff_t funcr;	297	CallInfo *ci;
299	if (!ttisfunction(func)) /* `func' is not a function? */	298	int n; /* number of arguments (Lua) or returns (C) */
300	func = tryfuncTM(L, func); /* check the `function' tag method */	299	ptrdiff_t funcr = savestack(L, func);
301	funcr = savestack(L, func);	300	switch (ttype(func)) {
302	if (ttislcf(func)) { /* light C function? */	301	case LUA_TLCF: /* light C function */
303	f = fvalue(func); /* get it */	302	f = fvalue(func);
304	goto isCfunc; /* go to call it */	303	goto Cfunc;
305	}	304	case LUA_TCCL: { /* C closure */
306	cl = clvalue(func);	305	f = clCvalue(func)->f;
307	if (cl->c.isC) { /* C closure? */	306	Cfunc:
308	CallInfo *ci;	307	luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
309	int n;	308	ci = next_ci(L); /* now 'enter' new function */
310	f = cl->c.f;	309	ci->nresults = nresults;
311	isCfunc: /* call C function 'f' */	310	ci->func = restorestack(L, funcr);
312	luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */	311	ci->top = L->top + LUA_MINSTACK;
313	ci = next_ci(L); /* now 'enter' new function */	312	lua_assert(ci->top <= L->stack_last);
314	ci->nresults = nresults;	313	ci->callstatus = 0;
315	ci->func = restorestack(L, funcr);	314	if (L->hookmask & LUA_MASKCALL)
316	ci->top = L->top + LUA_MINSTACK;	315	luaD_hook(L, LUA_HOOKCALL, -1);
317	lua_assert(ci->top <= L->stack_last);	316	lua_unlock(L);
318	ci->callstatus = 0;	317	n = (f)(L); / do the actual call */
319	if (L->hookmask & LUA_MASKCALL)	318	lua_lock(L);
320	luaD_hook(L, LUA_HOOKCALL, -1);	319	api_checknelems(L, n);
321	lua_unlock(L);	320	luaD_poscall(L, L->top - n);
322	n = (f)(L); / do the actual call */	321	return 1;
323	lua_lock(L);	322	}
324	api_checknelems(L, n);	323	case LUA_TLCL: { /* Lua function: prepare its call */
325	luaD_poscall(L, L->top - n);	324	StkId base;
326	return 1;	325	Proto *p = clLvalue(func)->p;
327	}	326	luaD_checkstack(L, p->maxstacksize);
328	else { /* Lua function: prepare its call */	327	func = restorestack(L, funcr);
329	CallInfo *ci;	328	n = cast_int(L->top - func) - 1; /* number of real arguments */
330	int nparams, nargs;	329	for (; n < p->numparams; n++)
331	StkId base;	330	setnilvalue(L->top++); /* complete missing arguments */
332	Proto *p = cl->l.p;	331	base = (!p->is_vararg) ? func + 1 : adjust_varargs(L, p, n);
333	luaD_checkstack(L, p->maxstacksize);	332	ci = next_ci(L); /* now 'enter' new function */
334	func = restorestack(L, funcr);	333	ci->nresults = nresults;
335	nargs = cast_int(L->top - func) - 1; /* number of real arguments */	334	ci->func = func;
336	nparams = p->numparams; /* number of expected parameters */	335	ci->u.l.base = base;
337	for (; nargs < nparams; nargs++)	336	ci->top = base + p->maxstacksize;
338	setnilvalue(L->top++); /* complete missing arguments */	337	lua_assert(ci->top <= L->stack_last);
339	if (!p->is_vararg) /* no varargs? */	338	ci->u.l.savedpc = p->code; /* starting point */
340	base = func + 1;	339	ci->callstatus = CIST_LUA;
341	else /* vararg function */	340	L->top = ci->top;
342	base = adjust_varargs(L, p, nargs);	341	if (L->hookmask & LUA_MASKCALL)
343	ci = next_ci(L); /* now 'enter' new function */	342	callhook(L, ci);
344	ci->nresults = nresults;	343	return 0;
345	ci->func = func;	344	}
346	ci->u.l.base = base;	345	default: { /* not a function */
347	ci->top = base + p->maxstacksize;	346	func = tryfuncTM(L, func); /* retry with 'function' tag method */
348	lua_assert(ci->top <= L->stack_last);	347	return luaD_precall(L, func, nresults);
349	ci->u.l.savedpc = p->code; /* starting point */	348	}
350	ci->callstatus = CIST_LUA;
351	L->top = ci->top;
352	if (L->hookmask & LUA_MASKCALL)
353	callhook(L, ci);
354	return 0;
355	}	349	}
356	}	350	}
357		351
@@ -615,8 +609,8 @@ int luaD_pcall (lua_State L, Pfunc func, void u, · 257 unmodified lines
615	*/	609	*/
616	struct SParser { /* data to `f_parser' */	610	struct SParser { /* data to `f_parser' */
617	ZIO *z;	611	ZIO *z;
618	Mbuffer buff; /* buffer to be used by the scanner */	612	Mbuffer buff; /* dynamic structure used by the scanner */
619	Varlist varl; /* list of local variables (to be used by the parser) */	613	Dyndata dyd; /* dynamic structures used by the parser */
620	const char *name;	614	const char *name;
621	};	615	};
622		616
@@ -625,14 +619,14 @@ static void f_parser (lua_State L, void ud) { · 2 unmodified lines
625	Proto *tf;	619	Proto *tf;
626	Closure *cl;	620	Closure *cl;
627	struct SParser p = cast(struct SParser , ud);	621	struct SParser p = cast(struct SParser , ud);
628	int c = luaZ_lookahead(p->z);	622	int c = zgetc(p->z); /* read first character */
629	tf = (c == LUA_SIGNATURE[0])	623	tf = (c == LUA_SIGNATURE[0])
630	? luaU_undump(L, p->z, &p->buff, p->name)	624	? luaU_undump(L, p->z, &p->buff, p->name)
631	: luaY_parser(L, p->z, &p->buff, &p->varl, p->name);	625	: luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
632	setptvalue2s(L, L->top, tf);	626	setptvalue2s(L, L->top, tf);
633	incr_top(L);	627	incr_top(L);
634	cl = luaF_newLclosure(L, tf);	628	cl = luaF_newLclosure(L, tf);
635	setclvalue(L, L->top - 1, cl);	629	setclLvalue(L, L->top - 1, cl);
636	for (i = 0; i < tf->sizeupvalues; i++) /* initialize upvalues */	630	for (i = 0; i < tf->sizeupvalues; i++) /* initialize upvalues */
637	cl->l.upvals[i] = luaF_newupval(L);	631	cl->l.upvals[i] = luaF_newupval(L);
638	}	632	}
@@ -643,11 +637,15 @@ int luaD_protectedparser (lua_State L, ZIO z, const char *name) { · 4 unmodified lines
643	int status;	637	int status;
644	L->nny++; /* cannot yield during parsing */	638	L->nny++; /* cannot yield during parsing */
645	p.z = z; p.name = name;	639	p.z = z; p.name = name;
646	p.varl.actvar = NULL; p.varl.nactvar = p.varl.actvarsize = 0;	640	p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
		641	p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
		642	p.dyd.label.arr = NULL; p.dyd.label.size = 0;
647	luaZ_initbuffer(L, &p.buff);	643	luaZ_initbuffer(L, &p.buff);
648	status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);	644	status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
649	luaZ_freebuffer(L, &p.buff);	645	luaZ_freebuffer(L, &p.buff);
650	luaM_freearray(L, p.varl.actvar, p.varl.actvarsize);	646	luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
		647	luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
		648	luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
651	L->nny--;	649	L->nny--;
652	return status;	650	return status;
653	}	651	}

src/ldump.c+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldump.c,v 1.17 2010/10/13 21:04:52 lhf Exp $	2	** $Id: ldump.c,v 1.18 2011/05/06 13:35:17 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	*/
@@ -69,7 +69,7 @@ static void DumpString(const TString* s, DumpState* D) · 63 unmodified lines
69	{	69	{
70	size_t size=s->tsv.len+1; /* include trailing '\0' */	70	size_t size=s->tsv.len+1; /* include trailing '\0' */
71	DumpVar(size,D);	71	DumpVar(size,D);
72	DumpBlock(getstr(s),size,D);	72	DumpBlock(getstr(s),size*sizeof(char),D);
73	}	73	}
74	}	74	}
75		75
@@ -150,7 +150,7 @@ static void DumpFunction(const Proto* f, DumpState* D) · 74 unmodified lines
150		150
151	static void DumpHeader(DumpState* D)	151	static void DumpHeader(DumpState* D)
152	{	152	{
153	char h[LUAC_HEADERSIZE];	153	lu_byte h[LUAC_HEADERSIZE];
154	luaU_header(h);	154	luaU_header(h);
155	DumpBlock(h,LUAC_HEADERSIZE,D);	155	DumpBlock(h,LUAC_HEADERSIZE,D);
156	}	156	}

src/lgc.c+79−58

 /*
-** $Id: lgc.c,v 2.103 2010/10/25 19:01:37 roberto Exp $
+** $Id: lgc.c,v 2.109 2011/05/05 19:42:25 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 ** standard negative debt for GC; a reasonable "time" to wait before
 ** starting a new cycle
 */
-#define stddebt(g)	(-cast(l_mem, g->totalbytes/100) * g->gcpause)
+#define stddebt(g)	(-cast(l_mem, gettotalbytes(g)/100) * g->gcpause)
 /*
 #define stringmark(s)	((void)((s) && resetbits((s)->tsv.marked, WHITEBITS)))
-#define isfinalized(u)		testbit((u)->marked, FINALIZEDBIT)
+#define isfinalized(x)		testbit(gch(x)->marked, FINALIZEDBIT)
 #define checkdeadkey(n)	lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))
+#define checkconsistency(obj)  \
+  lua_longassert(!iscollectable(obj) || righttt(obj))
 #define markvalue(g,o) { checkconsistency(o); \
   if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
 */
 static int iscleared (const TValue *o, int iskey) {
   if (!iscollectable(o)) return 0;
-  if (ttisstring(o)) {
+  else if (ttisstring(o)) {
     stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
     return 0;
   }
-  return iswhite(gcvalue(o)) ||
+  else return iswhite(gcvalue(o)) || (!iskey && isfinalized(gcvalue(o)));
-    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
 }
 ** mark root set and reset all gray lists, to start a new
 ** incremental (or full) collection
 */
-static void markroot (lua_State *L) {
+static void markroot (global_State *g) {
-  global_State *g = G(L);
   g->gray = g->grayagain = NULL;
   g->weak = g->allweak = g->ephemeron = NULL;
   markobject(g, g->mainthread);
   int ow = otherwhite(g);
   int toclear, toset;  /* bits to clear and to set in all live objects */
   int tostop;  /* stop sweep when this is true */
+  l_mem debt = g->GCdebt;  /* current debt */
   if (isgenerational(g)) {  /* generational mode? */
     toclear = ~0;  /* clear nothing */
     toset = bitmask(OLDBIT);  /* set the old bit of all surviving objects */
         sweepthread(L, gco2th(curr));  /* sweep thread's upvalues */
       if (testbits(marked, tostop)) {
         static GCObject *nullp = NULL;
-        return &nullp;  /* stop sweeping this list */
+        p = &nullp;  /* stop sweeping this list */
+        break;
       }
       /* update marks */
       gch(curr)->marked = cast_byte((marked & toclear) | toset);
       p = &gch(curr)->next;  /* go to next element */
     }
   }
+  luaE_setdebt(g, debt);  /* sweeping should not change debt */
   return p;
 }
 }
-static Udata *udata2finalize (global_State *g) {
+static GCObject *udata2finalize (global_State *g) {
   GCObject *o = g->tobefnz;  /* get first element */
-  Udata *u = rawgco2u(o);
+  lua_assert(isfinalized(o));
-  lua_assert(isfinalized(&u->uv));
+  g->tobefnz = gch(o)->next;  /* remove it from 'tobefnz' list */
-  lua_assert(!isold(o));
+  gch(o)->next = g->allgc;  /* return it to 'allgc' list */
-  g->tobefnz = u->uv.next;  /* remove it from 'tobefnz' list */
-  u->uv.next = g->allgc;  /* return it to 'allgc' list */
   g->allgc = o;
-  resetbit(u->uv.marked, SEPARATED);  /* mark that it is not in 'tobefnz' */
+  resetbit(gch(o)->marked, SEPARATED);  /* mark that it is not in 'tobefnz' */
-  resetoldbit(o); /* see MOVE OLD rule */
+  lua_assert(!isold(o));  /* see MOVE OLD rule */
   if (!keepinvariant(g))  /* not keeping invariant? */
     makewhite(g, o);  /* "sweep" object */
-  return u;
+  return o;
 }
 static void GCTM (lua_State *L, int propagateerrors) {
   global_State *g = G(L);
-  Udata *udata = udata2finalize(g);
+  const TValue *tm;
-  const TValue *tm = gfasttm(g, udata->uv.metatable, TM_GC);
+  TValue v;
+  setgcovalue(L, &v, udata2finalize(g));
+  tm = luaT_gettmbyobj(L, &v, TM_GC);
   if (tm != NULL && ttisfunction(tm)) {  /* is there a finalizer? */
     int status;
     lu_byte oldah = L->allowhook;
-    lu_mem oldd = g->GCdebt;
+    int running  = g->gcrunning;
     L->allowhook = 0;  /* stop debug hooks during GC tag method */
-    stopgc(g);  /* avoid GC steps */
+    g->gcrunning = 0;  /* avoid GC steps */
     setobj2s(L, L->top, tm);  /* push finalizer... */
-    setuvalue(L, L->top+1, udata);  /* ... and its argument */
+    setobj2s(L, L->top + 1, &v);  /* ... and its argument */
     L->top += 2;  /* and (next line) call the finalizer */
     status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
     L->allowhook = oldah;  /* restore hooks */
-    g->GCdebt = oldd;  /* restore threshold */
+    g->gcrunning = running;  /* restore state */
     if (status != LUA_OK && propagateerrors) {  /* error while running __gc? */
       if (status == LUA_ERRRUN) {  /* is there an error msg.? */
         luaO_pushfstring(L, "error in __gc tag method (%s)",
 /*
-** move all unreachable udata that need finalization from list 'udgc' to
+** move all unreachable objects that need finalization from list 'finobj'
-** list 'tobefnz'
+** to list 'tobefnz'
 */
 void luaC_separateudata (lua_State *L, int all) {
   global_State *g = G(L);
-  GCObject **p = &g->udgc;
+  GCObject **p = &g->finobj;
   GCObject *curr;
   GCObject **lastnext = &g->tobefnz;
   /* find last 'next' field in 'tobefnz' list (to add elements in its end) */
   while (*lastnext != NULL)
     lastnext = &gch(*lastnext)->next;
   while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
-    lua_assert(gch(curr)->tt == LUA_TUSERDATA && !isfinalized(gco2u(curr)));
+    lua_assert(!isfinalized(curr));
     lua_assert(testbit(gch(curr)->marked, SEPARATED));
     if (!(all || iswhite(curr)))  /* not being collected? */
       p = &gch(curr)->next;  /* don't bother with it */
     else {
       l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */
-      *p = gch(curr)->next;  /* remove 'curr' from 'udgc' list */
+      *p = gch(curr)->next;  /* remove 'curr' from 'finobj' list */
       gch(curr)->next = *lastnext;  /* link at the end of 'tobefnz' list */
       *lastnext = curr;
       lastnext = &gch(curr)->next;
 /*
-** if userdata 'u' has a finalizer, remove it from 'allgc' list (must
+** if object 'o' has a finalizer, remove it from 'allgc' list (must
-** search the list to find it) and link it in 'udgc' list.
+** search the list to find it) and link it in 'finobj' list.
 */
-void luaC_checkfinalizer (lua_State *L, Udata *u) {
+void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
   global_State *g = G(L);
-  if (testbit(u->uv.marked, SEPARATED) || /* udata is already separated... */
+  if (testbit(gch(o)->marked, SEPARATED) || /* obj. is already separated... */
-      isfinalized(&u->uv) ||                     /* ... or is finalized... */
+      isfinalized(o) ||                           /* ... or is finalized... */
-      gfasttm(g, u->uv.metatable, TM_GC) == NULL)  /* or has no finalizer? */
+      gfasttm(g, mt, TM_GC) == NULL)                /* or has no finalizer? */
     return;  /* nothing to be done */
-  else {  /* move 'u' to 'udgc' list */
+  else {  /* move 'o' to 'finobj' list */
     GCObject **p;
-    for (p = &g->allgc; *p != obj2gco(u); p = &gch(*p)->next) ;
+    for (p = &g->allgc; *p != o; p = &gch(*p)->next) ;
-    *p = u->uv.next;  /* remove 'u' from root list */
+    *p = gch(o)->next;  /* remove 'o' from root list */
-    u->uv.next = g->udgc;  /* link it in list 'udgc' */
+    gch(o)->next = g->finobj;  /* link it in list 'finobj' */
-    g->udgc = obj2gco(u);
+    g->finobj = o;
-    l_setbit(u->uv.marked, SEPARATED);  /* mark it as such */
+    l_setbit(gch(o)->marked, SEPARATED);  /* mark it as such */
-    resetoldbit(obj2gco(u));  /* see MOVE OLD rule */
+    resetoldbit(o);  /* see MOVE OLD rule */
   }
 }
   if (mode == KGC_GEN) {  /* change to generational mode */
     /* make sure gray lists are consistent */
     luaC_runtilstate(L, bitmask(GCSpropagate));
-    g->lastmajormem = g->totalbytes;
+    g->lastmajormem = gettotalbytes(g);
     g->gckind = KGC_GEN;
   }
   else {  /* change to incremental mode */
 /*
-** call all pending finalizers */
+** call all pending finalizers
+*/
 static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
   global_State *g = G(L);
-  while (g->tobefnz) GCTM(L, propagateerrors);
+  while (g->tobefnz) {
+    resetoldbit(g->tobefnz);
+    GCTM(L, propagateerrors);
+  }
 }
   /* following "white" makes all objects look dead */
   g->currentwhite = WHITEBITS;
   g->gckind = KGC_NORMAL;
-  sweepwholelist(L, &g->udgc);
+  sweepwholelist(L, &g->finobj);
-  lua_assert(g->udgc == NULL);
+  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 */
   switch (g->gcstate) {
     case GCSpause: {
       if (!isgenerational(g))
-        markroot(L);  /* start a new collection */
+        markroot(g);  /* start a new collection */
       /* in any case, root must be marked */
       lua_assert(!iswhite(obj2gco(g->mainthread))
               && !iswhite(gcvalue(&g->l_registry)));
         return GCSWEEPCOST;
       }
       else {  /* no more strings to sweep */
-        g->sweepgc = &g->udgc;  /* prepare to sweep userdata */
+        g->sweepgc = &g->finobj;  /* prepare to sweep finalizable objects */
         g->gcstate = GCSsweepudata;
         return 0;
       }
   global_State *g = G(L);
   if (g->lastmajormem == 0) {  /* signal for another major collection? */
     luaC_fullgc(L, 0);  /* perform a full regular collection */
-    g->lastmajormem = g->totalbytes;  /* update control */
+    g->lastmajormem = gettotalbytes(g);  /* update control */
   }
   else {
     luaC_runtilstate(L, ~bitmask(GCSpause));  /* run complete cycle */
     luaC_runtilstate(L, bitmask(GCSpause));
-    if (g->totalbytes > g->lastmajormem/100 * g->gcmajorinc)
+    if (gettotalbytes(g) > g->lastmajormem/100 * g->gcmajorinc)
       g->lastmajormem = 0;  /* signal for a major collection */
   }
-  g->GCdebt = stddebt(g);
+  luaE_setdebt(g, stddebt(g));
 }
     lim -= singlestep(L);
   } while (lim > 0 && g->gcstate != GCSpause);
   if (g->gcstate != GCSpause)
-    g->GCdebt -= GCSTEPSIZE;
+    luaE_setdebt(g, g->GCdebt - GCSTEPSIZE);
   else
-    g->GCdebt = stddebt(g);
+    luaE_setdebt(g, stddebt(g));
 }
-void luaC_step (lua_State *L) {
+/*
+** performs a basic GC step even if the collector is stopped
+*/
+void luaC_forcestep (lua_State *L) {
+  global_State *g = G(L);
   int i;
-  if (isgenerational(G(L))) generationalcollection(L);
+  if (isgenerational(g)) generationalcollection(L);
   else step(L);
-  for (i = 0; i < GCFINALIZENUM && G(L)->tobefnz; i++)
+  for (i = 0; i < GCFINALIZENUM && g->tobefnz; i++)
     GCTM(L, 1);  /* Call a few pending finalizers */
 }
+/*
+** performs a basic GC step only if collector is running
+*/
+void luaC_step (lua_State *L) {
+  if (G(L)->gcrunning) luaC_forcestep(L);
+}
 /*
 ** performs a full GC cycle; if "isemergency", does not call
 ** finalizers (which could change stack positions)
     luaC_runtilstate(L, bitmask(GCSpropagate));
   }
   g->gckind = origkind;
-  g->GCdebt = stddebt(g);
+  luaE_setdebt(g, stddebt(g));
   if (!isemergency)   /* do not run finalizers during emergency GC */
     callallpendingfinalizers(L, 1);
 }

src/lgc.h+8−9

 /*
-** $Id: lgc.h,v 2.44 2010/06/30 14:11:17 roberto Exp $
+** $Id: lgc.h,v 2.50 2011/01/26 16:30:02 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 #define keepinvariant(g)  (isgenerational(g) || g->gcstate <= GCSatomic)
-#define gcstopped(g)	((g)->GCdebt == MIN_LMEM)
-#define stopgc(g)	((g)->GCdebt = MIN_LMEM)
 /*
 ** some useful bit tricks
 */
 #define WHITE0BIT	0  /* object is white (type 0) */
 #define WHITE1BIT	1  /* object is white (type 1) */
 #define BLACKBIT	2  /* object is black */
-#define FINALIZEDBIT	3  /* for userdata: has been finalized */
+#define FINALIZEDBIT	3  /* object has been separated for finalization */
-#define SEPARATED	4  /*  "    ": it's in 'udgc' list or in 'tobefnz' */
+#define SEPARATED	4  /* object is in 'finobj' list or in 'tobefnz' */
 #define FIXEDBIT	5  /* object is fixed (should not be collected) */
 #define OLDBIT		6  /* object is old (only in generational mode) */
 /* bit 7 is currently used by tests (luaL_checkmemory) */
 #define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
-#define luaC_checkGC(L) {condchangemem(L); if (G(L)->GCdebt > 0) luaC_step(L);}
+#define luaC_condGC(L,c) \
+	{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
+#define luaC_checkGC(L)		luaC_condGC(L, luaC_step(L);)
 #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
 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);
 LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
 LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
 LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz,
 LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
 LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
 LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c);
-LUAI_FUNC void luaC_checkfinalizer (lua_State *L, Udata *u);
+LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
 LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv);
 LUAI_FUNC void luaC_changemode (lua_State *L, int mode);

src/linit.c+5−5

src/liolib.c+34−57

 /*
-** $Id: liolib.c,v 2.95 2010/11/10 18:05:36 roberto Exp $
+** $Id: liolib.c,v 2.99 2011/03/03 16:34:46 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
 ** lua_popen spawns a new process connected to the current one through
 ** the file streams.
 */
-#if !defined(lua_popen)
+#if !defined(lua_popen)	/* { */
-#if defined(LUA_USE_POPEN)
+#if defined(LUA_USE_POPEN)	/* { */
-#define lua_popen(L,c,m)        ((void)L, fflush(NULL), popen(c,m))
+#define lua_popen(L,c,m)	((void)L, fflush(NULL), popen(c,m))
-#define lua_pclose(L,file)      ((void)L, pclose(file))
+#define lua_pclose(L,file)	((void)L, pclose(file))
-#elif defined(LUA_WIN)
+#elif defined(LUA_WIN)		/* }{ */
-#define lua_popen(L,c,m)        ((void)L, _popen(c,m))
+#define lua_popen(L,c,m)		((void)L, _popen(c,m))
-#define lua_pclose(L,file)      ((void)L, _pclose(file))
+#define lua_pclose(L,file)		((void)L, _pclose(file))
-#else
-#define lua_popen(L,c,m)        ((void)((void)c, m),  \
+#else				/* }{ */
-                luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
-#define lua_pclose(L,file)              ((void)((void)L, file), -1)
-#endif
+#define lua_popen(L,c,m)		((void)((void)c, m),  \
+		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
+#define lua_pclose(L,file)		((void)((void)L, file), -1)
-#endif
+#endif				/* } */
+#endif			/* } */
 #define IO_INPUT	1
 static const char *const fnames[] = {"input", "output"};
-static int pushresult (lua_State *L, int i, const char *filename) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (i) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    lua_pushnil(L);
-    if (filename)
-      lua_pushfstring(L, "%s: %s", filename, strerror(en));
-    else
-      lua_pushfstring(L, "%s", strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
 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));
 static int io_pclose (lua_State *L) {
   FILE **p = tofilep(L);
   int stat = lua_pclose(L, *p);
-  *p = NULL;
+  *p = NULL;  /* mark stream as closed (for GC) */
-  if (stat == -1)  /* error? */
+  return luaL_execresult(L, stat);
-    return pushresult(L, 0, NULL);
-  else {
-    lua_pushinteger(L, stat);
-    return 1;  /* return status */
-  }
 }
 static int io_fclose (lua_State *L) {
   FILE **p = tofilep(L);
   int ok = (fclose(*p) == 0);
-  *p = NULL;
+  *p = NULL;  /* mark stream as closed (for GC) */
-  return pushresult(L, ok, NULL);
+  return luaL_fileresult(L, ok, NULL);
 }
 static int io_gc (lua_State *L) {
   FILE *f = *tofilep(L);
-  /* ignore closed files */
+  if (f != NULL)  /* ignore closed files */
-  if (f != NULL)
     aux_close(L);
   return 0;
 }
   int i = 0;
   /* check whether 'mode' matches '[rwa]%+?b?' */
   if (!(mode[i] != '\0' && strchr("rwa", mode[i++]) != NULL &&
-       (mode[i] != '+' || ++i) &&    /* skip if char is '+' */
+       (mode[i] != '+' || ++i) &&  /* skip if char is '+' */
-       (mode[i] != 'b' || ++i) &&    /* skip if char is 'b' */
+       (mode[i] != 'b' || ++i) &&  /* skip if char is 'b' */
        (mode[i] == '\0')))
     luaL_error(L, "invalid mode " LUA_QL("%s")
                   " (should match " LUA_QL("[rwa]%%+?b?") ")", mode);
   pf = newfile(L);
   *pf = fopen(filename, mode);
-  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
+  return (*pf == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 }
   const char *mode = luaL_optstring(L, 2, "r");
   FILE **pf = newfile(L);
   *pf = lua_popen(L, filename, mode);
-  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
+  return (*pf == NULL) ? luaL_fileresult(L, 0, filename) : 1;
 }
 static int io_tmpfile (lua_State *L) {
   FILE **pf = newfile(L);
   *pf = tmpfile();
-  return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
+  return (*pf == NULL) ? luaL_fileresult(L, 0, NULL) : 1;
 }
   if (lua_isnone(L, 1)) lua_pushnil(L);  /* at least one argument */
   if (lua_isnil(L, 1)) {  /* no file name? */
     lua_rawgeti(L, lua_upvalueindex(1), IO_INPUT);  /* get default input */
-    lua_replace(L, 1);   /* put it at index 1 */
+    lua_replace(L, 1);  /* put it at index 1 */
     tofile(L);  /* check that it's a valid file handle */
     toclose = 0;  /* do not close it after iteration */
   }
     *pf = fopen(filename, "r");
     if (*pf == NULL)
       fileerror(L, 1, filename);
-    lua_replace(L, 1);   /* put file at index 1 */
+    lua_replace(L, 1);  /* put file at index 1 */
     toclose = 1;  /* close it after iteration */
   }
   aux_lines(L, toclose);
     }
   }
   if (ferror(f))
-    return pushresult(L, 0, NULL);
+    return luaL_fileresult(L, 0, NULL);
   if (!success) {
     lua_pop(L, 1);  /* remove last result */
     lua_pushnil(L);  /* push nil instead */
     }
   }
   if (status) return 1;  /* file handle already on stack top */
-  else return pushresult(L, status, NULL);
+  else return luaL_fileresult(L, status, NULL);
 }
 static int f_write (lua_State *L) {
   FILE * f = tofile(L);
   lua_pushvalue(L, 1);  /* push file at the stack top (to be returned) */
   return g_write(L, f, 2);
 }
   long offset = luaL_optlong(L, 3, 0);
   op = fseek(f, offset, mode[op]);
   if (op)
-    return pushresult(L, 0, NULL);  /* error */
+    return luaL_fileresult(L, 0, NULL);  /* error */
   else {
     lua_pushinteger(L, ftell(f));
     return 1;
   int op = luaL_checkoption(L, 2, NULL, modenames);
   lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
   int res = setvbuf(f, NULL, mode[op], sz);
-  return pushresult(L, res == 0, NULL);
+  return luaL_fileresult(L, res == 0, NULL);
 }
 static int io_flush (lua_State *L) {
-  return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
+  return luaL_fileresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
 }
 static int f_flush (lua_State *L) {
-  return pushresult(L, fflush(tofile(L)) == 0, NULL);
+  return luaL_fileresult(L, fflush(tofile(L)) == 0, NULL);
 }

src/llex.c+13−17

 /*
-** $Id: llex.c,v 2.41 2010/11/18 18:38:44 roberto Exp $
+** $Id: llex.c,v 2.47 2011/05/03 15:51:16 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 /* ORDER RESERVED */
 static const char *const luaX_tokens [] = {
     "and", "break", "do", "else", "elseif",
-    "end", "false", "for", "function", "if",
+    "end", "false", "for", "function", "goto", "if",
     "in", "local", "nil", "not", "or", "repeat",
     "return", "then", "true", "until", "while",
     "..", "...", "==", ">=", "<=", "~=", "<eof>",
   for (i=0; i<NUM_RESERVED; i++) {
     TString *ts = luaS_new(L, luaX_tokens[i]);
     luaS_fix(ts);  /* reserved words are never collected */
-    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
     ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
   }
 }
   TValue *o;  /* entry for `str' */
   TString *ts = luaS_newlstr(L, str, l);  /* create new string */
   setsvalue2s(L, L->top++, ts);  /* temporarily anchor it in stack */
   o = luaH_setstr(L, ls->fs->h, ts);
   if (ttisnil(o)) {
     setbvalue(o, 1);  /* t[string] = true */
     luaC_checkGC(L);
 }
-void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
+void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
+                    int firstchar) {
   ls->decpoint = '.';
   ls->L = L;
+  ls->current = firstchar;
   ls->lookahead.token = TK_EOS;  /* no look-ahead token */
   ls->z = z;
   ls->fs = NULL;
   ls->envn = luaS_new(L, LUA_ENV);  /* create env name */
   luaS_fix(ls->envn);  /* never collect this name */
   luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
-  next(ls);  /* read first char */
 }
 }
 /*
 ** change all characters 'from' in buffer to 'to'
 */
 static void buffreplace (LexState *ls, char from, char to) {
 #define getlocaledecpoint()	(localeconv()->decimal_point[0])
 #endif
+#define buff2d(b,e)	luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e)
 /*
 ** in case of format error, try to change decimal point separator to
 ** the one defined in the current locale and check again
   char old = ls->decpoint;
   ls->decpoint = getlocaledecpoint();
   buffreplace(ls, old, ls->decpoint);  /* try new decimal separator */
-  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
+  if (!buff2d(ls->buff, &seminfo->r)) {
     /* format error with correct decimal point: no more options */
     buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
     lexerror(ls, "malformed number", TK_NUMBER);
   } while (lislalnum(ls->current) || ls->current == '.');
   save(ls, '\0');
   buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
-  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
+  if (!buff2d(ls->buff, &seminfo->r))  /* format error? */
     trydecpoint(ls, seminfo); /* try to update decimal point separator */
 }
 }
-static int hexavalue (int c) {
-  if (lisdigit(c)) return c - '0';
-  else if (lisupper(c)) return c - 'A' + 10;
-  else return c - 'a' + 10;
-}
 static int readhexaesc (LexState *ls) {
   int c1, c2 = EOZ;
   if (!lisxdigit(c1 = next(ls)) || !lisxdigit(c2 = next(ls))) {
     if (c2 != EOZ) save(ls, c2);
     lexerror(ls, "hexadecimal digit expected", TK_STRING);
   }
-  return (hexavalue(c1) << 4) + hexavalue(c2);
+  return (luaO_hexavalue(c1) << 4) + luaO_hexavalue(c2);
 }

src/llex.h+7−7

 /*
-** $Id: llex.h,v 1.65 2010/04/05 16:35:37 roberto Exp $
+** $Id: llex.h,v 1.70 2011/05/03 15:51:16 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 #define FIRST_RESERVED	257
-/* maximum length of a reserved word */
-#define TOKEN_LEN	(sizeof("function")/sizeof(char))
 /*
   /* terminal symbols denoted by reserved words */
   TK_AND = FIRST_RESERVED, TK_BREAK,
   TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
-  TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
+  TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
   /* other terminal symbols */
   TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_EOS,
 } Token;
+/* state of the lexer plus state of the parser when shared by all
+   functions */
 typedef struct LexState {
   int current;  /* current character (charint) */
   int linenumber;  /* input line counter */
   int lastline;  /* line of last token `consumed' */
   Token t;  /* current token */
   Token lookahead;  /* look ahead token */
-  struct FuncState *fs;  /* `FuncState' is private to the parser */
+  struct FuncState *fs;  /* current function (parser) */
   struct lua_State *L;
   ZIO *z;  /* input stream */
   Mbuffer *buff;  /* buffer for tokens */
-  struct Varlist *varl;  /* list of all active local variables */
+  struct Dyndata *dyd;  /* dynamic structures used by the parser */
   TString *source;  /* current source name */
   TString *envn;  /* environment variable name */
   char decpoint;  /* locale decimal point */
 LUAI_FUNC void luaX_init (lua_State *L);
 LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
-                              TString *source);
+                              TString *source, int firstchar);
 LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
 LUAI_FUNC void luaX_next (LexState *ls);
 LUAI_FUNC int luaX_lookahead (LexState *ls);

src/llimits.h+15−10

 /*
-** $Id: llimits.h,v 1.84 2010/11/08 16:33:20 roberto Exp $
+** $Id: llimits.h,v 1.89 2011/05/05 19:43:14 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 /* internal assertions for in-house debugging */
 #if defined(lua_assert)
 #define check_exp(c,e)		(lua_assert(c), (e))
+/* to avoid problems with conditions too long */
+#define lua_longassert(c)	{ if (!(c)) lua_assert(0); }
 #else
 #define lua_assert(c)		/* empty */
 #define check_exp(c,e)		(e)
+#define lua_longassert(c)	/* empty */
 #endif
 /*
 #define cast_byte(i)	cast(lu_byte, (i))
 #define cast_num(i)	cast(lua_Number, (i))
 #define cast_int(i)	cast(int, (i))
+#define cast_uchar(i)	cast(unsigned char, (i))
 /*
 ** lua_number2integer is a macro to convert lua_Number to lua_Integer.
 ** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned.
 ** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number.
+** luai_hashnum is a macro to hash a lua_Number value into an integer.
+** The hash must be deterministic and give reasonable values for
+** both small and large values (outside the range of integers).
 */
 #if defined(MS_ASMTRICK)	/* { */
     volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
     (i) = (t)u.l_p[LUA_IEEEENDIAN]; }
+#define luai_hashnum(i,n)  \
+  { volatile union luai_Cast u; u.l_d = (n) + 1.0;  /* avoid -0 */ \
+    (i) = u.l_p[0] + u.l_p[1]; }  /* add double bits for his hash */
 #define lua_number2int(i,n)		lua_number2int32(i, n, int)
 #define lua_number2integer(i,n)		lua_number2int32(i, n, lua_Integer)
 #define lua_number2unsigned(i,n)	lua_number2int32(i, n, lua_Unsigned)
 #endif
-/*
-** luai_hashnum is a macro do hash a lua_Number value into an integer.
-** The hash must be deterministic and give reasonable values for
-** both small and large values (outside the range of integers).
-** It is used only in ltable.c.
-*/
-#if !defined(luai_hashnum)	/* { */
+#if (defined(ltable_c) || defined(luaall_c)) && !defined(luai_hashnum)
 #include <float.h>
 #include <math.h>
   n = frexp(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP);  \
   lua_number2int(i, n); i += e; }
-#endif						/* } */
+#endif
 #define condchangemem(L)	condmovestack(L)
 #else
 #define condchangemem(L)  \
-	((void)(gcstopped(G(L)) || (luaC_fullgc(L, 0), 1)))
+	((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1)))
 #endif
 #endif

src/lmem.c+5−9

 /*
-** $Id: lmem.c,v 1.79 2010/05/05 18:49:56 roberto Exp $
+** $Id: lmem.c,v 1.81 2010/12/20 19:40:07 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
   size_t realosize = (block) ? osize : 0;
   lua_assert((realosize == 0) == (block == NULL));
 #if defined(HARDMEMTESTS)
-  if (nsize > realosize && !gcstopped(g))
+  if (nsize > realosize && g->gcrunning)
     luaC_fullgc(L, 1);  /* force a GC whenever possible */
 #endif
   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
   if (newblock == NULL && nsize > 0) {
     api_check(L, nsize > realosize,
                  "realloc cannot fail when shrinking a block");
-    if (!gcstopped(g)) {
+    if (g->gcrunning) {
       luaC_fullgc(L, 1);  /* try to free some memory... */
       newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
     }
       luaD_throw(L, LUA_ERRMEM);
   }
   lua_assert((nsize == 0) == (newblock == NULL));
-  g->totalbytes = (g->totalbytes - realosize) + nsize;
+  g->GCdebt = (g->GCdebt + nsize) - realosize;
-  if (!gcstopped(g))
-    g->GCdebt += nsize;  /* give some credit to garbage collector */
 #if defined(TRACEMEM)
   { /* auxiliary patch to monitor garbage collection.
     ** To plot, gnuplot with following command:
     if ((total % 200) == 0) {
       if (f == NULL) f = fopen(TRACEMEM, "w");
       fprintf(f, "%lu %u %d %d\n", total,
-              g->totalbytes,
+              g->totalbytes, g->GCdebt, g->gcstate * 1000);
-              gcstopped(g) ? 0 : g->GCdebt,
-              g->gcstate * 1000);
     }
   }
 #endif

src/loadlib.c+43−30

 /*
-** $Id: loadlib.c,v 1.94 2010/11/10 20:00:04 roberto Exp $
+** $Id: loadlib.c,v 1.98 2011/04/08 19:17:36 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
   int error = GetLastError();
   char buffer[128];
   if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
-      NULL, error, 0, buffer, sizeof(buffer), NULL))
+      NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL))
     lua_pushstring(L, buffer);
   else
     lua_pushfstring(L, "system error %d\n", error);
 static const char *searchpath (lua_State *L, const char *name,
-                                             const char *path) {
+                                             const char *path,
-  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
+                                             const char *sep) {
+  if (*sep != '\0')  /* non-empty separator? */
+    name = luaL_gsub(L, name, sep, LUA_DIRSEP);  /* replace it by proper one */
   lua_pushliteral(L, "");  /* error accumulator */
   while ((path = pushnexttemplate(L, path)) != NULL) {
     const char *filename = luaL_gsub(L, lua_tostring(L, -1),
 static int ll_searchpath (lua_State *L) {
-  const char *f = searchpath(L, luaL_checkstring(L, 1), luaL_checkstring(L, 2));
+  const char *f = searchpath(L, luaL_checkstring(L, 1),
+                                luaL_checkstring(L, 2),
+                                luaL_optstring(L, 3, "."));
   if (f != NULL) return 1;
   else {  /* error message is on top of the stack */
     lua_pushnil(L);
   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, ".");
 }
-static void loaderror (lua_State *L, const char *filename) {
+static int checkload (lua_State *L, int stat, const char *filename) {
-  luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
+  if (stat) {  /* module loaded successfully? */
-                lua_tostring(L, 1), filename, lua_tostring(L, -1));
+    lua_pushstring(L, filename);  /* will be 2nd argument to module */
+    return 2;  /* return open function and file name */
+  }
+  else
+    return luaL_error(L, "error loading module " LUA_QS
+                         " from file " LUA_QS ":\n\t%s",
+                          lua_tostring(L, 1), filename, lua_tostring(L, -1));
 }
   const char *filename;
   const char *name = luaL_checkstring(L, 1);
   filename = findfile(L, name, "path");
-  if (filename == NULL) return 1;  /* library not found in this path */
+  if (filename == NULL) return 1;  /* module not found in this path */
-  if (luaL_loadfile(L, filename) != LUA_OK)
+  return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
-    loaderror(L, filename);
-  return 1;  /* library loaded successfully */
 }
 static int loader_C (lua_State *L) {
   const char *name = luaL_checkstring(L, 1);
   const char *filename = findfile(L, name, "cpath");
-  if (filename == NULL) return 1;  /* library not found in this path */
+  if (filename == NULL) return 1;  /* module not found in this path */
-  if (loadfunc(L, filename, name) != 0)
+  return checkload(L, (loadfunc(L, filename, name) == 0), filename);
-    loaderror(L, filename);
-  return 1;  /* library loaded successfully */
 }
   filename = findfile(L, lua_tostring(L, -1), "cpath");
   if (filename == NULL) return 1;  /* root not found */
   if ((stat = loadfunc(L, filename, name)) != 0) {
-    if (stat != ERRFUNC) loaderror(L, filename);  /* real error */
+    if (stat != ERRFUNC)
-    lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
+      return checkload(L, 0, filename);  /* real error */
-                       name, filename);
+    else {  /* open function not found */
-    return 1;  /* function not found */
+      lua_pushfstring(L, "\n\tno module " LUA_QS " in file " LUA_QS,
+                         name, filename);
+      return 1;
+    }
   }
-  return 1;
+  lua_pushstring(L, filename);  /* will be 2nd argument to module */
+  return 2;
 }
       luaL_error(L, "module " LUA_QS " not found:%s",
                     name, lua_tostring(L, -2));
     lua_pushstring(L, name);
-    lua_call(L, 1, 1);  /* call it */
+    lua_call(L, 1, 2);  /* call it */
-    if (lua_isfunction(L, -1))  /* did it find module? */
+    if (lua_isfunction(L, -2))  /* did it find module? */
       break;  /* module loaded successfully */
-    else if (lua_isstring(L, -1))  /* loader returned error message? */
+    else if (lua_isstring(L, -2)) {  /* loader returned error message? */
-      lua_concat(L, 2);  /* accumulate it */
+      lua_pop(L, 1);  /* remove extra return */
+      lua_concat(L, 2);  /* accumulate error message */
+    }
     else
-      lua_pop(L, 1);
+      lua_pop(L, 2);  /* remove both returns */
   }
   lua_pushstring(L, name);  /* pass name as argument to module */
-  lua_call(L, 1, 1);  /* run loaded module */
+  lua_insert(L, -2);  /* name is 1st argument (before search data) */
+  lua_call(L, 2, 1);  /* run loaded module */
   if (!lua_isnil(L, -1))  /* non-nil return? */
     lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
   lua_getfield(L, 2, name);
                      LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
   lua_setfield(L, -2, "config");
   /* set field `loaded' */
-  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED");
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
   lua_setfield(L, -2, "loaded");
   /* set field `preload' */
-  luaL_findtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
+  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
   lua_setfield(L, -2, "preload");
   lua_pushglobaltable(L);
   lua_pushvalue(L, -2);  /* set 'package' as upvalue for next lib */

src/lobject.c+86−38

 /*
-** $Id: lobject.c,v 2.43 2010/10/29 15:54:55 roberto Exp $
+** $Id: lobject.c,v 2.49 2011/05/31 18:24:36 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
 }
-int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
-  if (ttype(t1) != ttype(t2)) return 0;
-  else switch (ttype(t1)) {
-    case LUA_TNIL:
-      return 1;
-    case LUA_TNUMBER:
-      return luai_numeq(nvalue(t1), nvalue(t2));
-    case LUA_TBOOLEAN:
-      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
-    case LUA_TLIGHTUSERDATA:
-      return pvalue(t1) == pvalue(t2);
-    case LUA_TSTRING:
-      return rawtsvalue(t1) == rawtsvalue(t2);
-    case LUA_TLCF:
-      return fvalue(t1) == fvalue(t2);
-    default:
-      lua_assert(iscollectable(t1));
-      return gcvalue(t1) == gcvalue(t2);
-  }
-}
 lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2) {
   switch (op) {
     case LUA_OPADD: return luai_numadd(NULL, v1, v2);
 }
-static int checkend (const char *s, const char *endptr) {
+int luaO_hexavalue (int c) {
-  if (endptr == s) return 0;  /* no characters converted */
+  if (lisdigit(c)) return c - '0';
-  while (lisspace(cast(unsigned char, *endptr))) endptr++;
+  else if (lisupper(c)) return c - 'A' + 10;
-  return (*endptr == '\0');  /* OK if no trailing characters */
+  else return c - 'a' + 10;
+}
+#if !defined(lua_strx2number)
+#include <math.h>
+static int isneg (const char **s) {
+  if (**s == '-') { (*s)++; return 1; }
+  else if (**s == '+') (*s)++;
+  return 0;
 }
-int luaO_str2d (const char *s, lua_Number *result) {
+static lua_Number readhexa (const char **s, lua_Number r, int *count) {
+  while (lisxdigit(cast_uchar(**s))) {  /* read integer part */
+    r = (r * 16.0) + (double)luaO_hexavalue(*(*s)++);
+    (*count)++;
+  }
+  return r;
+}
+/*
+** convert an hexadecimal numeric string to a number, following
+** C99 specification for 'strtod'
+*/
+static lua_Number lua_strx2number (const char *s, char **endptr) {
+  lua_Number r = 0.0;
+  int e = 0, i = 0;
+  int neg = 0;  /* 1 if number is negative */
+  *endptr = cast(char *, s);  /* nothing is valid yet */
+  while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
+  neg = isneg(&s);  /* check signal */
+  if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')))  /* check '0x' */
+    return 0.0;  /* invalid format (no '0x') */
+  s += 2;  /* skip '0x' */
+  r = readhexa(&s, r, &i);  /* read integer part */
+  if (*s == '.') {
+    s++;  /* skip dot */
+    r = readhexa(&s, r, &e);  /* read fractional part */
+  }
+  if (i == 0 && e == 0)
+    return 0.0;  /* invalid format (no digit) */
+  e *= -4;  /* each fractional digit divides value by 2^-4 */
+  *endptr = cast(char *, s);  /* valid up to here */
+  if (*s == 'p' || *s == 'P') {  /* exponent part? */
+    int exp1 = 0;
+    int neg1;
+    s++;  /* skip 'p' */
+    neg1 = isneg(&s);  /* signal */
+    if (!lisdigit(cast_uchar(*s)))
+      goto ret;  /* must have at least one digit */
+    while (lisdigit(cast_uchar(*s)))  /* read exponent */
+      exp1 = exp1 * 10 + *(s++) - '0';
+    if (neg1) exp1 = -exp1;
+    e += exp1;
+  }
+  *endptr = cast(char *, s);  /* valid up to here */
+ ret:
+  if (neg) r = -r;
+  return ldexp(r, e);
+}
+#endif
+int luaO_str2d (const char *s, size_t len, lua_Number *result) {
   char *endptr;
-  *result = lua_str2number(s, &endptr);
+  if (strpbrk(s, "xX"))  /* hexa? */
-  if (checkend(s, endptr)) return 1;  /* conversion OK? */
+    *result = lua_strx2number(s, &endptr);
-  *result = cast_num(strtoul(s, &endptr, 0)); /* try hexadecimal */
+  else
-  return checkend(s, endptr);
+    *result = lua_str2number(s, &endptr);
+  if (endptr == s) return 0;  /* nothing recognized */
+  while (lisspace(cast_uchar(*endptr))) endptr++;
+  return (endptr == s + len);  /* OK if no trailing characters */
 }
 }
+/* number of chars of a literal string without the ending \0 */
+#define LL(x)	(sizeof(x)/sizeof(char) - 1)
-#define LL(x)	(sizeof(x) - 1)
 #define RETS	"..."
 #define PRE	"[string \""
 #define POS	"\"]"
-#define addstr(a,b,l)	( memcpy(a,b,l), a += (l) )
+#define addstr(a,b,l)	( memcpy(a,b,(l) * sizeof(char)), a += (l) )
 void luaO_chunkid (char *out, const char *source, size_t bufflen) {
   size_t l = strlen(source);
   if (*source == '=') {  /* 'literal' source */
     if (l <= bufflen)  /* small enough? */
-      memcpy(out, source + 1, l);
+      memcpy(out, source + 1, l * sizeof(char));
     else {  /* truncate it */
       addstr(out, source + 1, bufflen - 1);
       *out = '\0';
   }
   else if (*source == '@') {  /* file name */
     if (l <= bufflen)  /* small enough? */
-      memcpy(out, source + 1, l);
+      memcpy(out, source + 1, l * sizeof(char));
     else {  /* add '...' before rest of name */
       addstr(out, RETS, LL(RETS));
       bufflen -= LL(RETS);
-      memcpy(out, source + 1 + l - bufflen, bufflen);
+      memcpy(out, source + 1 + l - bufflen, bufflen * sizeof(char));
     }
   }
   else {  /* string; format as [string "source"] */
       addstr(out, source, l);
       addstr(out, RETS, LL(RETS));
     }
-    memcpy(out, POS, LL(POS) + 1);
+    memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
   }
 }

src/lobject.h+241−87

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lobject.h,v 2.42 2010/07/26 15:53:23 roberto Exp $	2	** $Id: lobject.h,v 2.60 2011/06/13 14:13:06 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	*/
@@ -23,12 +23,38 @@ · 17 unmodified lines
23	#define LUA_TUPVAL (LUA_NUMTAGS+1)	23	#define LUA_TUPVAL (LUA_NUMTAGS+1)
24	#define LUA_TDEADKEY (LUA_NUMTAGS+2)	24	#define LUA_TDEADKEY (LUA_NUMTAGS+2)
25		25
		26	/*
		27	** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
		28	*/
		29	#define LUA_TOTALTAGS (LUA_TUPVAL+2)
		30
		31
		32	/*
		33	** tags for Tagged Values have the following use of bits:
		34	** bits 0-3: actual tag (a LUA_T* value)
		35	** bits 4-5: variant bits
		36	** bit 6: whether value is collectable
		37	*/
26		38
27	/*	39	/*
28	** Variant tag for light C functions (negative to be considered	40	** LUA_TFUNCTION variants:
29	** non collectable by 'iscollectable')	41	** 0 - Lua function
		42	** 1 - light C function
		43	** 2 - regular C function (closure)
30	*/	44	*/
31	#define LUA_TLCF (~0x0F \| LUA_TFUNCTION)	45
		46	/* Variant tags for functions */
		47	#define LUA_TLCL (LUA_TFUNCTION \| (0 << 4)) /* Lua closure */
		48	#define LUA_TLCF (LUA_TFUNCTION \| (1 << 4)) /* light C function */
		49	#define LUA_TCCL (LUA_TFUNCTION \| (2 << 4)) /* C closure */
		50
		51
		52	/* Bit mark for collectable types */
		53	#define BIT_ISCOLLECTABLE (1 << 6)
		54
		55	/* mark a tag as collectable */
		56	#define ctb(t) ((t) \| BIT_ISCOLLECTABLE)
		57
32		58
33	/*	59	/*
34	** Union of all collectable objects	60	** Union of all collectable objects
@@ -55,13 +81,10 @@ typedef struct GCheader { · 20 unmodified lines
55	/*	81	/*
56	** Union of all Lua values	82	** Union of all Lua values
57	*/	83	*/
58	typedef union {	84	typedef union Value Value;
59	GCObject gc; / collectable objects */	85
60	void p; / light userdata */	86
61	lua_Number n; /* numbers */	87	#define numfield lua_Number n; /* numbers */
62	int b; /* booleans */
63	lua_CFunction f; /* light C functions */
64	} Value;
65		88
66		89
67		90
@@ -72,125 +95,143 @@ typedef union { · 4 unmodified lines
72		95
73	#define TValuefields Value value_; int tt_	96	#define TValuefields Value value_; int tt_
74		97
75	typedef struct lua_TValue {	98	typedef struct lua_TValue TValue;
76	TValuefields;
77	} TValue;
78		99
79		100
80	/* macro defining a nil value */	101	/* macro defining a nil value */
81	#define NILCONSTANT {NULL}, LUA_TNIL	102	#define NILCONSTANT {NULL}, LUA_TNIL
82		103
83		104
84	/*	105	#define val_(o) ((o)->value_)
85	** type tag of a TValue	106	#define num_(o) (val_(o).n)
86	*/
87	#define ttype(o) ((o)->tt_)
88		107
89		108
90	/*	109	/* raw type tag of a TValue */
91	** type tag of a TValue with no variants	110	#define rttype(o) ((o)->tt_)
92	*/	111
93	#define ttypenv(o) (ttype(o) & 0x0F)	112	/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
		113	#define ttype(o) (rttype(o) & 0x3F)
		114
		115
		116	/* type tag of a TValue with no variants (bits 0-3) */
		117	#define ttypenv(o) (rttype(o) & 0x0F)
94		118
95		119
96	/* Macros to test type */	120	/* Macros to test type */
97	#define ttisnil(o) (ttype(o) == LUA_TNIL)	121	#define checktag(o,t) (rttype(o) == (t))
98	#define ttisnumber(o) (ttype(o) == LUA_TNUMBER)	122	#define ttisnumber(o) checktag((o), LUA_TNUMBER)
99	#define ttisstring(o) (ttype(o) == LUA_TSTRING)	123	#define ttisnil(o) checktag((o), LUA_TNIL)
100	#define ttistable(o) (ttype(o) == LUA_TTABLE)	124	#define ttisboolean(o) checktag((o), LUA_TBOOLEAN)
101	#define ttisfunction(o) (ttypenv(o) == LUA_TFUNCTION)	125	#define ttislightuserdata(o) checktag((o), LUA_TLIGHTUSERDATA)
102	#define ttisclosure(o) (ttype(o) == LUA_TFUNCTION)	126	#define ttisstring(o) checktag((o), ctb(LUA_TSTRING))
103	#define ttislcf(o) (ttype(o) == LUA_TLCF)	127	#define ttistable(o) checktag((o), ctb(LUA_TTABLE))
104	#define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN)	128	#define ttisfunction(o) (ttypenv(o) == LUA_TFUNCTION)
105	#define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA)	129	#define ttisclosure(o) ((rttype(o) & 0x1F) == LUA_TFUNCTION)
106	#define ttisthread(o) (ttype(o) == LUA_TTHREAD)	130	#define ttisCclosure(o) checktag((o), ctb(LUA_TCCL))
107	#define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA)	131	#define ttisLclosure(o) checktag((o), ctb(LUA_TLCL))
108	#define ttisdeadkey(o) (ttype(o) == LUA_TDEADKEY)	132	#define ttislcf(o) checktag((o), LUA_TLCF)
		133	#define ttisuserdata(o) checktag((o), ctb(LUA_TUSERDATA))
		134	#define ttisthread(o) checktag((o), ctb(LUA_TTHREAD))
		135	#define ttisdeadkey(o) checktag((o), ctb(LUA_TDEADKEY))
		136
		137	#define ttisequal(o1,o2) (rttype(o1) == rttype(o2))
109		138
110	/* Macros to access values */	139	/* Macros to access values */
111	#define gcvalue(o) check_exp(iscollectable(o), (o)->value_.gc)	140	#define nvalue(o) check_exp(ttisnumber(o), num_(o))
112	#define pvalue(o) check_exp(ttislightuserdata(o), (o)->value_.p)	141	#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc)
113	#define nvalue(o) check_exp(ttisnumber(o), (o)->value_.n)	142	#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p)
114	#define rawtsvalue(o) check_exp(ttisstring(o), &(o)->value_.gc->ts)	143	#define rawtsvalue(o) check_exp(ttisstring(o), &val_(o).gc->ts)
115	#define tsvalue(o) (&rawtsvalue(o)->tsv)	144	#define tsvalue(o) (&rawtsvalue(o)->tsv)
116	#define rawuvalue(o) check_exp(ttisuserdata(o), &(o)->value_.gc->u)	145	#define rawuvalue(o) check_exp(ttisuserdata(o), &val_(o).gc->u)
117	#define uvalue(o) (&rawuvalue(o)->uv)	146	#define uvalue(o) (&rawuvalue(o)->uv)
118	#define clvalue(o) check_exp(ttisclosure(o), &(o)->value_.gc->cl)	147	#define clvalue(o) check_exp(ttisclosure(o), &val_(o).gc->cl)
119	#define fvalue(o) check_exp(ttislcf(o), (o)->value_.f)	148	#define clLvalue(o) check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
120	#define hvalue(o) check_exp(ttistable(o), &(o)->value_.gc->h)	149	#define clCvalue(o) check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
121	#define bvalue(o) check_exp(ttisboolean(o), (o)->value_.b)	150	#define fvalue(o) check_exp(ttislcf(o), val_(o).f)
122	#define thvalue(o) check_exp(ttisthread(o), &(o)->value_.gc->th)	151	#define hvalue(o) check_exp(ttistable(o), &val_(o).gc->h)
		152	#define bvalue(o) check_exp(ttisboolean(o), val_(o).b)
		153	#define thvalue(o) check_exp(ttisthread(o), &val_(o).gc->th)
123		154
124	#define l_isfalse(o) (ttisnil(o) \|\| (ttisboolean(o) && bvalue(o) == 0))	155	#define l_isfalse(o) (ttisnil(o) \|\| (ttisboolean(o) && bvalue(o) == 0))
125		156
126		157
127	#define iscollectable(o) (ttype(o) >= LUA_TSTRING)	158	#define iscollectable(o) (rttype(o) & BIT_ISCOLLECTABLE)
128		159
129		160
130	/* Macros for internal tests */	161	/* Macros for internal tests */
131	#define righttt(obj) (ttype(obj) == gcvalue(obj)->gch.tt)	162	#define righttt(obj) (ttypenv(obj) == gcvalue(obj)->gch.tt)
132
133	#define checkconsistency(obj) lua_assert(!iscollectable(obj) \|\| righttt(obj))
134		163
135	#define checkliveness(g,obj) \	164	#define checkliveness(g,obj) \
136	lua_assert(!iscollectable(obj) \|\| (righttt(obj) && !isdead(g,gcvalue(obj))))	165	lua_longassert(!iscollectable(obj) \|\| \
		166	(righttt(obj) && !isdead(g,gcvalue(obj))))
137		167
138		168
139	/* Macros to set values */	169	/* Macros to set values */
140	#define setnilvalue(obj) ((obj)->tt_=LUA_TNIL)	170	#define settt_(o,t) ((o)->tt_=(t))
141		171
142	#define setnvalue(obj,x) \	172	#define setnvalue(obj,x) \
143	{ TValue *i_o=(obj); i_o->value_.n=(x); i_o->tt_=LUA_TNUMBER; }	173	{ TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); }
144		174
145	#define setfvalue(obj,x) \	175	#define changenvalue(o,x) check_exp(ttisnumber(o), num_(o)=(x))
146	{ TValue *i_o=(obj); i_o->value_.f=(x); i_o->tt_=LUA_TLCF; }
147		176
148	#define changenvalue(o,x) check_exp((o)->tt_==LUA_TNUMBER, (o)->value_.n=(x))	177	#define setnilvalue(obj) settt_(obj, LUA_TNIL)
		178
		179	#define setfvalue(obj,x) \
		180	{ TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
149		181
150	#define setpvalue(obj,x) \	182	#define setpvalue(obj,x) \
151	{ TValue *i_o=(obj); i_o->value_.p=(x); i_o->tt_=LUA_TLIGHTUSERDATA; }	183	{ TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
152		184
153	#define setbvalue(obj,x) \	185	#define setbvalue(obj,x) \
154	{ TValue *i_o=(obj); i_o->value_.b=(x); i_o->tt_=LUA_TBOOLEAN; }	186	{ TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
		187
		188	#define setgcovalue(L,obj,x) \
		189	{ TValue io=(obj); GCObject i_g=(x); \
		190	val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); }
155		191
156	#define setsvalue(L,obj,x) \	192	#define setsvalue(L,obj,x) \
157	{ TValue *i_o=(obj); \	193	{ TValue *io=(obj); \
158	i_o->value_.gc=cast(GCObject *, (x)); i_o->tt_=LUA_TSTRING; \	194	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TSTRING)); \
159	checkliveness(G(L),i_o); }	195	checkliveness(G(L),io); }
160		196
161	#define setuvalue(L,obj,x) \	197	#define setuvalue(L,obj,x) \
162	{ TValue *i_o=(obj); \	198	{ TValue *io=(obj); \
163	i_o->value_.gc=cast(GCObject *, (x)); i_o->tt_=LUA_TUSERDATA; \	199	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \
164	checkliveness(G(L),i_o); }	200	checkliveness(G(L),io); }
165		201
166	#define setthvalue(L,obj,x) \	202	#define setthvalue(L,obj,x) \
167	{ TValue *i_o=(obj); \	203	{ TValue *io=(obj); \
168	i_o->value_.gc=cast(GCObject *, (x)); i_o->tt_=LUA_TTHREAD; \	204	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \
169	checkliveness(G(L),i_o); }	205	checkliveness(G(L),io); }
		206
		207	#define setclLvalue(L,obj,x) \
		208	{ TValue *io=(obj); \
		209	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \
		210	checkliveness(G(L),io); }
170		211
171	#define setclvalue(L,obj,x) \	212	#define setclCvalue(L,obj,x) \
172	{ TValue *i_o=(obj); \	213	{ TValue *io=(obj); \
173	i_o->value_.gc=cast(GCObject *, (x)); i_o->tt_=LUA_TFUNCTION; \	214	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \
174	checkliveness(G(L),i_o); }	215	checkliveness(G(L),io); }
175		216
176	#define sethvalue(L,obj,x) \	217	#define sethvalue(L,obj,x) \
177	{ TValue *i_o=(obj); \	218	{ TValue *io=(obj); \
178	i_o->value_.gc=cast(GCObject *, (x)); i_o->tt_=LUA_TTABLE; \	219	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \
179	checkliveness(G(L),i_o); }	220	checkliveness(G(L),io); }
180		221
181	#define setptvalue(L,obj,x) \	222	#define setptvalue(L,obj,x) \
182	{ TValue *i_o=(obj); \	223	{ TValue *io=(obj); \
183	i_o->value_.gc=cast(GCObject *, (x)); i_o->tt_=LUA_TPROTO; \	224	val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TPROTO)); \
184	checkliveness(G(L),i_o); }	225	checkliveness(G(L),io); }
185		226
186	#define setdeadvalue(obj) ((obj)->tt_=LUA_TDEADKEY)	227	#define setdeadvalue(obj) settt_(obj, ctb(LUA_TDEADKEY))
187		228
188		229
189		230
190	#define setobj(L,obj1,obj2) \	231	#define setobj(L,obj1,obj2) \
191	{ const TValue o2=(obj2); TValue o1=(obj1); \	232	{ const TValue io2=(obj2); TValue io1=(obj1); \
192	o1->value_ = o2->value_; o1->tt_=o2->tt_; \	233	io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
193	checkliveness(G(L),o1); }	234	checkliveness(G(L),io1); }
194		235
195		236
196	/*	237	/*
@@ -214,9 +255,121 @@ typedef struct lua_TValue { · 17 unmodified lines
214		255
215		256
216		257
		258
		259	/*
		260	** {======================================================
		261	** NaN Trick
		262	** =======================================================
		263	*/
		264
		265	#if defined(LUA_NANTRICKLE) \|\| defined(LUA_NANTRICKBE)
		266
		267	/*
		268	** 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
		270	** a "signaled NaN", which is never generated by regular operations by
		271	** the CPU (nor by 'strtod')
		272	*/
		273	#if !defined(NNMARK)
		274	#define NNMARK 0x7FF7A500
		275	#endif
		276
		277	#undef TValuefields
		278	#if defined(LUA_NANTRICKLE)
		279	/* little endian */
		280	#define TValuefields \
		281	union { struct { Value v_; int tt_; } i; double d_; } u
		282	#else
		283	/* big endian */
		284	#define TValuefields \
		285	union { struct { int tt_; Value v_; } i; double d_; } u
		286	#endif
		287
		288	#undef numfield
		289	#define numfield /* no such field; numbers are the entire struct */
		290
		291	/* basic check to distinguish numbers from non-numbers */
		292	#undef ttisnumber
		293	#define ttisnumber(o) (((o)->u.i.tt_ & 0x7fffff00) != NNMARK)
		294
		295	#define tag2tt(t) (NNMARK \| (t))
		296
		297	#undef NILCONSTANT
		298	#define NILCONSTANT {{{NULL}, tag2tt(LUA_TNIL)}}
		299
		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
		306	#define rttype(o) (ttisnumber(o) ? LUA_TNUMBER : (o)->u.i.tt_ & 0xff)
		307
		308	#undef settt_
		309	#define settt_(o,t) ((o)->u.i.tt_=tag2tt(t))
		310
		311	#undef setnvalue
		312	#define setnvalue(obj,x) \
		313	{ TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); }
		314
		315	#undef setobj
		316	#define setobj(L,obj1,obj2) \
		317	{ const TValue o2_=(obj2); TValue o1_=(obj1); \
		318	o1_->u = o2_->u; \
		319	checkliveness(G(L),o1_); }
		320
		321
		322	/*
		323	** these redefinitions are not mandatory, but these forms are more efficient
		324	*/
		325
		326	#undef checktag
		327	#define checktag(o,t) ((o)->u.i.tt_ == tag2tt(t))
		328
		329	#undef ttisequal
		330	#define ttisequal(o1,o2) \
		331	(ttisnumber(o1) ? ttisnumber(o2) : ((o1)->u.i.tt_ == (o2)->u.i.tt_))
		332
		333
		334
		335	#define luai_checknum(L,o,c) { if (!ttisnumber(o)) c; }
		336
		337
		338	#else
		339
		340	#define luai_checknum(L,o,c) { /* empty */ }
		341
		342	#endif
		343	/* }====================================================== */
		344
		345
		346
		347	/*
		348	** {======================================================
		349	** types and prototypes
		350	** =======================================================
		351	*/
		352
		353
		354	union Value {
		355	GCObject gc; / collectable objects */
		356	void p; / light userdata */
		357	int b; /* booleans */
		358	lua_CFunction f; /* light C functions */
		359	numfield /* numbers */
		360	};
		361
		362
		363	struct lua_TValue {
		364	TValuefields;
		365	};
		366
		367
217	typedef TValue StkId; / index to stack elements */	368	typedef TValue StkId; / index to stack elements */
218		369
219		370
		371
		372
220	/*	373	/*
221	** Header for string value; string bytes follow the end of this structure	374	** Header for string value; string bytes follow the end of this structure
222	*/	375	*/
@@ -226,7 +379,7 @@ typedef union TString { · 3 unmodified lines
226	CommonHeader;	379	CommonHeader;
227	lu_byte reserved;	380	lu_byte reserved;
228	unsigned int hash;	381	unsigned int hash;
229	size_t len;	382	size_t len; /* number of characters in string */
230	} tsv;	383	} tsv;
231	} TString;	384	} TString;
232		385
@@ -247,7 +400,7 @@ typedef union Udata { · 14 unmodified lines
247	CommonHeader;	400	CommonHeader;
248	struct Table *metatable;	401	struct Table *metatable;
249	struct Table *env;	402	struct Table *env;
250	size_t len;	403	size_t len; /* number of bytes */
251	} uv;	404	} uv;
252	} Udata;	405	} Udata;
253		406
@@ -346,9 +499,9 @@ typedef union Closure { · 92 unmodified lines
346	} Closure;	499	} Closure;
347		500
348		501
349	#define isLfunction(o) (ttisclosure(o) && !clvalue(o)->c.isC)	502	#define isLfunction(o) ttisLclosure(o)
350		503
351	#define getproto(o) (clvalue(o)->l.p)	504	#define getproto(o) (clLvalue(o)->p)
352		505
353		506
354	/*	507	/*
@@ -403,12 +556,13 @@ typedef struct Table { · 48 unmodified lines
403		556
404	LUAI_DDEC const TValue luaO_nilobject_;	557	LUAI_DDEC const TValue luaO_nilobject_;
405		558
		559
406	LUAI_FUNC int luaO_int2fb (unsigned int x);	560	LUAI_FUNC int luaO_int2fb (unsigned int x);
407	LUAI_FUNC int luaO_fb2int (int x);	561	LUAI_FUNC int luaO_fb2int (int x);
408	LUAI_FUNC int luaO_ceillog2 (lu_int32 x);	562	LUAI_FUNC int luaO_ceillog2 (unsigned int x);
409	LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2);	563	LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2);
410	LUAI_FUNC int luaO_rawequalObj (const TValue t1, const TValue t2);	564	LUAI_FUNC int luaO_str2d (const char s, size_t len, lua_Number result);
411	LUAI_FUNC int luaO_str2d (const char s, lua_Number result);	565	LUAI_FUNC int luaO_hexavalue (int c);
412	LUAI_FUNC const char luaO_pushvfstring (lua_State L, const char *fmt,	566	LUAI_FUNC const char luaO_pushvfstring (lua_State L, const char *fmt,
413	va_list argp);	567	va_list argp);
414	LUAI_FUNC const char luaO_pushfstring (lua_State L, const char *fmt, ...);	568	LUAI_FUNC const char luaO_pushfstring (lua_State L, const char *fmt, ...);

src/lopcodes.c+5−5

 /*
-** $Id: lopcodes.c,v 1.44 2010/10/13 16:45:54 roberto Exp $
+** $Id: lopcodes.c,v 1.48 2011/04/19 16:22:13 roberto Exp $
 ** See Copyright Notice in lua.h
 */
 LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
   "MOVE",
   "LOADK",
+  "LOADKX",
   "LOADBOOL",
   "LOADNIL",
   "GETUPVAL",
   "TFORCALL",
   "TFORLOOP",
   "SETLIST",
-  "CLOSE",
   "CLOSURE",
   "VARARG",
   "EXTRAARG",
 /*       T  A    B       C     mode		   opcode	*/
   opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_MOVE */
  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
+ ,opmode(0, 1, OpArgN, OpArgN, iABx)		/* OP_LOADKX */
  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LOADNIL */
+ ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_LOADNIL */
  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
  ,opmode(0, 1, OpArgU, OpArgK, iABC)		/* OP_GETTABUP */
  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
- ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TEST */
+ ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TEST */
  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
  ,opmode(0, 0, OpArgN, OpArgU, iABC)		/* OP_TFORCALL */
  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_TFORLOOP */
  ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
- ,opmode(0, 0, OpArgN, OpArgN, iABC)		/* OP_CLOSE */
  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
  ,opmode(0, 0, OpArgU, OpArgU, iAx)		/* OP_EXTRAARG */

src/lopcodes.h+6−7

 /*
-** $Id: lopcodes.h,v 1.137 2010/10/25 12:24:55 roberto Exp $
+** $Id: lopcodes.h,v 1.141 2011/04/19 16:22:13 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 name		args	description
 ------------------------------------------------------------------------*/
 OP_MOVE,/*	A B	R(A) := R(B)					*/
-OP_LOADK,/*	A Bx	R(A) := Kst(Bx - 1)				*/
+OP_LOADK,/*	A Bx	R(A) := Kst(Bx)					*/
+OP_LOADKX,/*	A 	R(A) := Kst(extra arg)				*/
 OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
-OP_LOADNIL,/*	A B	R(A) := ... := R(B) := nil			*/
+OP_LOADNIL,/*	A B	R(A), R(A+1), ..., R(A+B) := nil		*/
 OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
 OP_GETTABUP,/*	A B C	R(A) := UpValue[B][RK(C)]			*/
 OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
-OP_JMP,/*	sBx	pc+=sBx					*/
+OP_JMP,/*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A) + 1	*/
 OP_EQ,/*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
 OP_LT,/*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++		*/
 OP_LE,/*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++		*/
 OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
-OP_CLOSE,/*	A	close all variables in the stack up to (>=) R(A)*/
 OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx])			*/
 OP_VARARG,/*	A B	R(A), R(A+1), ..., R(A+B-2) = vararg		*/
   (*) In OP_SETLIST, if (B == 0) then B = `top'; if (C == 0) then next
   'instruction' is EXTRAARG(real C).
-  (*) In OP_LOADK, if (Bx == 0) then next 'instruction' is EXTRAARG(real Bx).
+  (*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.
   (*) For comparisons, A specifies what condition the test should accept
   (true or false).

src/loslib.c+11−20

 /*
-** $Id: loslib.c,v 1.32 2010/10/05 12:18:03 roberto Exp $
+** $Id: loslib.c,v 1.34 2011/03/03 16:34:46 roberto Exp $
 ** Standard Operating System library
 ** See Copyright Notice in lua.h
 */
-static int os_pushresult (lua_State *L, int i, const char *filename) {
+static int os_execute (lua_State *L) {
-  int en = errno;  /* calls to Lua API may change this value */
+  const char *cmd = luaL_optstring(L, 1, NULL);
-  if (i) {
+  int stat = system(cmd);
-    lua_pushboolean(L, 1);
+  if (cmd != NULL)
-    return 1;
+    return luaL_execresult(L, stat);
-  }
   else {
-    lua_pushnil(L);
+    lua_pushboolean(L, stat);  /* true if there is a shell */
-    lua_pushfstring(L, "%s: %s", filename, strerror(en));
+    return 1;
-    lua_pushinteger(L, en);
-    return 3;
   }
 }
-static int os_execute (lua_State *L) {
-  lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
-  return 1;
-}
 static int os_remove (lua_State *L) {
   const char *filename = luaL_checkstring(L, 1);
-  return os_pushresult(L, remove(filename) == 0, filename);
+  return luaL_fileresult(L, remove(filename) == 0, filename);
 }
 static int os_rename (lua_State *L) {
   const char *fromname = luaL_checkstring(L, 1);
   const char *toname = luaL_checkstring(L, 2);
-  return os_pushresult(L, rename(fromname, toname) == 0, fromname);
+  return luaL_fileresult(L, rename(fromname, toname) == 0, fromname);
 }
   return conv;  /* to avoid warnings */
 }
 static int os_date (lua_State *L) {
   const char *s = luaL_optstring(L, 1, "%c");
   time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));

src/lparser.c+320−145

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lparser.c,v 2.92 2010/09/07 19:21:39 roberto Exp $	2	** $Id: lparser.c,v 2.109 2011/05/02 17:33:01 roberto Exp $
3	** Lua Parser	3	** Lua Parser
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -41,10 +41,11 @@ · 35 unmodified lines
41	*/	41	*/
42	typedef struct BlockCnt {	42	typedef struct BlockCnt {
43	struct BlockCnt previous; / chain */	43	struct BlockCnt previous; / chain */
44	int breaklist; /* list of jumps out of this loop */	44	int firstlabel; /* index of first label in this block */
45	lu_byte nactvar; /* # active locals outside the breakable structure */	45	int firstgoto; /* index of first pending goto in this block */
		46	lu_byte nactvar; /* # active locals outside the block */
46	lu_byte upval; /* true if some variable in the block is an upvalue */	47	lu_byte upval; /* true if some variable in the block is an upvalue */
47	lu_byte isbreakable; /* true if `block' is a loop */	48	lu_byte isloop; /* true if `block' is a loop */
48	} BlockCnt;	49	} BlockCnt;
49		50
50		51
@@ -52,7 +53,7 @@ typedef struct BlockCnt { · 1 unmodified line
52	/*	53	/*
53	** prototypes for recursive non-terminal functions	54	** prototypes for recursive non-terminal functions
54	*/	55	*/
55	static void chunk (LexState *ls);	56	static void statement (LexState *ls);
56	static void expr (LexState ls, expdesc v);	57	static void expr (LexState ls, expdesc v);
57		58
58		59
@@ -66,6 +67,13 @@ static void anchor_token (LexState *ls) { · 7 unmodified lines
66	}	67	}
67		68
68		69
		70	/* semantic error */
		71	static void semerror (LexState ls, const char msg) {
		72	ls->t.token = 0; /* remove 'near to' from final message */
		73	luaX_syntaxerror(ls, msg);
		74	}
		75
		76
69	static void error_expected (LexState *ls, int token) {	77	static void error_expected (LexState *ls, int token) {
70	luaX_syntaxerror(ls,	78	luaX_syntaxerror(ls,
71	luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));	79	luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));
@@ -103,6 +111,7 @@ static void check (LexState *ls, int c) { · 31 unmodified lines
103	error_expected(ls, c);	111	error_expected(ls, c);
104	}	112	}
105		113
		114
106	static void checknext (LexState *ls, int c) {	115	static void checknext (LexState *ls, int c) {
107	check(ls, c);	116	check(ls, c);
108	luaX_next(ls);	117	luaX_next(ls);
@@ -167,13 +176,13 @@ static int registerlocalvar (LexState ls, TString varname) { · 58 unmodified lines
167		176
168	static void new_localvar (LexState ls, TString name) {	177	static void new_localvar (LexState ls, TString name) {
169	FuncState *fs = ls->fs;	178	FuncState *fs = ls->fs;
170	Varlist *vl = ls->varl;	179	Dyndata *dyd = ls->dyd;
171	int reg = registerlocalvar(ls, name);	180	int reg = registerlocalvar(ls, name);
172	checklimit(fs, vl->nactvar + 1 - fs->firstlocal,	181	checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
173	MAXVARS, "local variables");	182	MAXVARS, "local variables");
174	luaM_growvector(ls->L, vl->actvar, vl->nactvar + 1,	183	luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1,
175	vl->actvarsize, vardesc, MAX_INT, "local variables");	184	dyd->actvar.size, Vardesc, MAX_INT, "local variables");
176	vl->actvar[vl->nactvar++].idx = cast(unsigned short, reg);	185	dyd->actvar.arr[dyd->actvar.n++].idx = cast(unsigned short, reg);
177	}	186	}
178		187
179		188
@@ -186,7 +195,7 @@ static void new_localvarliteral_ (LexState ls, const char name, size_t sz) { · 6 unmodified lines
186		195
187		196
188	static LocVar getlocvar (FuncState fs, int i) {	197	static LocVar getlocvar (FuncState fs, int i) {
189	int idx = fs->ls->varl->actvar[fs->firstlocal + i].idx;	198	int idx = fs->ls->dyd->actvar.arr[fs->firstlocal + i].idx;
190	lua_assert(idx < fs->nlocvars);	199	lua_assert(idx < fs->nlocvars);
191	return &fs->f->locvars[idx];	200	return &fs->f->locvars[idx];
192	}	201	}
@@ -202,7 +211,7 @@ static void adjustlocalvars (LexState *ls, int nvars) { · 9 unmodified lines
202		211
203		212
204	static void removevars (FuncState *fs, int tolevel) {	213	static void removevars (FuncState *fs, int tolevel) {
205	fs->ls->varl->nactvar -= (fs->nactvar - tolevel);	214	fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel);
206	while (fs->nactvar > tolevel)	215	while (fs->nactvar > tolevel)
207	getlocvar(fs, --fs->nactvar)->endpc = fs->pc;	216	getlocvar(fs, --fs->nactvar)->endpc = fs->pc;
208	}	217	}
@@ -245,12 +254,12 @@ static int searchvar (FuncState fs, TString n) { · 36 unmodified lines
245		254
246	/*	255	/*
247	Mark block where variable at given level was defined	256	Mark block where variable at given level was defined
248	(to emit OP_CLOSE later).	257	(to emit close instructions later).
249	*/	258	*/
250	static void markupval (FuncState *fs, int level) {	259	static void markupval (FuncState *fs, int level) {
251	BlockCnt *bl = fs->bl;	260	BlockCnt *bl = fs->bl;
252	while (bl && bl->nactvar > level) bl = bl->previous;	261	while (bl->nactvar > level) bl = bl->previous;
253	if (bl) bl->upval = 1;	262	bl->upval = 1;
254	}	263	}
255		264
256		265
@@ -327,10 +336,107 @@ static void enterlevel (LexState *ls) { · 70 unmodified lines
327	#define leavelevel(ls) (G((ls)->L)->nCcalls--)	336	#define leavelevel(ls) (G((ls)->L)->nCcalls--)
328		337
329		338
330	static void enterblock (FuncState fs, BlockCnt bl, lu_byte isbreakable) {	339	static void closegoto (LexState ls, int g, Labeldesc label) {
331	bl->breaklist = NO_JUMP;	340	int i;
332	bl->isbreakable = isbreakable;	341	FuncState *fs = ls->fs;
		342	Labellist *gl = &ls->dyd->gt;
		343	Labeldesc *gt = &gl->arr[g];
		344	lua_assert(eqstr(gt->name, label->name));
		345	if (gt->nactvar < label->nactvar) {
		346	const char *msg = luaO_pushfstring(ls->L,
		347	"<goto %s> at line %d jumps into the scope of local " LUA_QS,
		348	getstr(gt->name), gt->line, getstr(getlocvar(fs, gt->nactvar)->varname));
		349	semerror(ls, msg);
		350	}
		351	luaK_patchlist(fs, gt->pc, label->pc);
		352	/* remove goto from pending list */
		353	for (i = g; i < gl->n - 1; i++)
		354	gl->arr[i] = gl->arr[i + 1];
		355	gl->n--;
		356	}
		357
		358
		359	/*
		360	** try to close a goto with existing labels; this solves backward jumps
		361	*/
		362	static int findlabel (LexState *ls, int g) {
		363	int i;
		364	BlockCnt *bl = ls->fs->bl;
		365	Dyndata *dyd = ls->dyd;
		366	Labeldesc *gt = &dyd->gt.arr[g];
		367	/* check labels in current block for a match */
		368	for (i = bl->firstlabel; i < dyd->label.n; i++) {
		369	Labeldesc *lb = &dyd->label.arr[i];
		370	if (eqstr(lb->name, gt->name)) { /* correct label? */
		371	if (gt->nactvar > lb->nactvar &&
		372	(bl->upval \|\| dyd->label.n > bl->firstlabel))
		373	luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
		374	closegoto(ls, g, lb); /* close it */
		375	return 1;
		376	}
		377	}
		378	return 0; /* label not found; cannot close goto */
		379	}
		380
		381
		382	static int newlabelentry (LexState ls, Labellist l, TString *name,
		383	int line, int pc) {
		384	int n = l->n;
		385	luaM_growvector(ls->L, l->arr, n, l->size, Labeldesc, MAX_INT, "labels");
		386	l->arr[n].name = name;
		387	l->arr[n].line = line;
		388	l->arr[n].nactvar = ls->fs->nactvar;
		389	l->arr[n].pc = pc;
		390	l->n++;
		391	return n;
		392	}
		393
		394
		395	/*
		396	** check whether new label 'lb' matches any pending gotos in current
		397	** block; solves forward jumps
		398	*/
		399	static void findgotos (LexState ls, Labeldesc lb) {
		400	Labellist *gl = &ls->dyd->gt;
		401	int i = ls->fs->bl->firstgoto;
		402	while (i < gl->n) {
		403	if (eqstr(gl->arr[i].name, lb->name))
		404	closegoto(ls, i, lb);
		405	else
		406	i++;
		407	}
		408	}
		409
		410
		411	/*
		412	** "export" pending gotos to outer level, to check them against
		413	** outer labels; if the block being exited has upvalues, and
		414	** the goto exists the scope of any variable (which can be the
		415	** upvalue), close those variables being exited.
		416	*/
		417	static void movegotosout (FuncState fs, BlockCnt bl) {
		418	int i = bl->firstgoto;
		419	Labellist *gl = &fs->ls->dyd->gt;
		420	/* correct pending gotos to current block and try to close it
		421	with visible labels */
		422	while (i < gl->n) {
		423	Labeldesc *gt = &gl->arr[i];
		424	if (gt->nactvar > bl->nactvar) {
		425	if (bl->upval)
		426	luaK_patchclose(fs, gt->pc, bl->nactvar);
		427	gt->nactvar = bl->nactvar;
		428	}
		429	if (!findlabel(fs->ls, i))
		430	i++; /* move to next one */
		431	}
		432	}
		433
		434
		435	static void enterblock (FuncState fs, BlockCnt bl, lu_byte isloop) {
		436	bl->isloop = isloop;
333	bl->nactvar = fs->nactvar;	437	bl->nactvar = fs->nactvar;
		438	bl->firstlabel = fs->ls->dyd->label.n;
		439	bl->firstgoto = fs->ls->dyd->gt.n;
334	bl->upval = 0;	440	bl->upval = 0;
335	bl->previous = fs->bl;	441	bl->previous = fs->bl;
336	fs->bl = bl;	442	fs->bl = bl;
@@ -338,17 +444,48 @@ static void enterblock (FuncState fs, BlockCnt bl, lu_byte isbreakable) { · 1 unmodified line
338	}	444	}
339		445
340		446
		447	/*
		448	** create a label named "break" to resolve break statements
		449	*/
		450	static void breaklabel (LexState *ls) {
		451	TString *n = luaS_new(ls->L, "break");
		452	int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc);
		453	findgotos(ls, &ls->dyd->label.arr[l]);
		454	}
		455
		456	/*
		457	** generates an error for an undefined 'goto'; choose appropriate
		458	** message when label name is a reserved word (which can only be 'break')
		459	*/
		460	static void undefgoto (LexState ls, Labeldesc gt) {
		461	const char *msg = (gt->name->tsv.reserved > 0)
		462	? "<%s> at line %d not inside a loop"
		463	: "label " LUA_QS " (<goto> at line %d) undefined";
		464	msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
		465	semerror(ls, msg);
		466	}
		467
		468
341	static void leaveblock (FuncState *fs) {	469	static void leaveblock (FuncState *fs) {
342	BlockCnt *bl = fs->bl;	470	BlockCnt *bl = fs->bl;
		471	LexState *ls = fs->ls;
		472	if (bl->previous && bl->upval) {
		473	/* create a 'jump to here' to close upvalues */
		474	int j = luaK_jump(fs);
		475	luaK_patchclose(fs, j, bl->nactvar);
		476	luaK_patchtohere(fs, j);
		477	}
		478	if (bl->isloop)
		479	breaklabel(ls); /* close pending breaks */
343	fs->bl = bl->previous;	480	fs->bl = bl->previous;
344	removevars(fs, bl->nactvar);	481	removevars(fs, bl->nactvar);
345	if (bl->upval)
346	luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
347	/* a block either controls scope or breaks (never both) */
348	lua_assert(!bl->isbreakable \|\| !bl->upval);
349	lua_assert(bl->nactvar == fs->nactvar);	482	lua_assert(bl->nactvar == fs->nactvar);
350	fs->freereg = fs->nactvar; /* free registers */	483	fs->freereg = fs->nactvar; /* free registers */
351	luaK_patchtohere(fs, bl->breaklist);	484	ls->dyd->label.n = bl->firstlabel; /* remove local labels */
		485	if (bl->previous) /* inner block? */
		486	movegotosout(fs, bl); /* update pending gotos to outer block */
		487	else if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */
		488	undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */
352	}	489	}
353		490
354		491
@@ -368,10 +505,11 @@ static void codeclosure (LexState ls, Proto clp, expdesc *v) { · 13 unmodified lines
368	f->p[fs->np++] = clp;	505	f->p[fs->np++] = clp;
369	luaC_objbarrier(ls->L, f, clp);	506	luaC_objbarrier(ls->L, f, clp);
370	init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));	507	init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
		508	luaK_exp2nextreg(fs, v); /* fix it at stack top (for GC) */
371	}	509	}
372		510
373		511
374	static void open_func (LexState ls, FuncState fs) {	512	static void open_func (LexState ls, FuncState fs, BlockCnt *bl) {
375	lua_State *L = ls->L;	513	lua_State *L = ls->L;
376	Proto *f;	514	Proto *f;
377	fs->prev = ls->fs; /* linked list of funcstates */	515	fs->prev = ls->fs; /* linked list of funcstates */
@@ -387,7 +525,7 @@ static void open_func (LexState ls, FuncState fs) { · 9 unmodified lines
387	fs->nups = 0;	525	fs->nups = 0;
388	fs->nlocvars = 0;	526	fs->nlocvars = 0;
389	fs->nactvar = 0;	527	fs->nactvar = 0;
390	fs->firstlocal = ls->varl->nactvar;	528	fs->firstlocal = ls->dyd->actvar.n;
391	fs->bl = NULL;	529	fs->bl = NULL;
392	f = luaF_newproto(L);	530	f = luaF_newproto(L);
393	fs->f = f;	531	fs->f = f;
@@ -400,6 +538,7 @@ static void open_func (LexState ls, FuncState fs) { · 6 unmodified lines
400	/* anchor table of constants (to avoid being collected) */	538	/* anchor table of constants (to avoid being collected) */
401	sethvalue2s(L, L->top, fs->h);	539	sethvalue2s(L, L->top, fs->h);
402	incr_top(L);	540	incr_top(L);
		541	enterblock(fs, bl, 0);
403	}	542	}
404		543
405		544
@@ -408,7 +547,7 @@ static void close_func (LexState *ls) { · 2 unmodified lines
408	FuncState *fs = ls->fs;	547	FuncState *fs = ls->fs;
409	Proto *f = fs->f;	548	Proto *f = fs->f;
410	luaK_ret(fs, 0, 0); /* final return */	549	luaK_ret(fs, 0, 0); /* final return */
411	removevars(fs, 0);	550	leaveblock(fs);
412	luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);	551	luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
413	f->sizecode = fs->pc;	552	f->sizecode = fs->pc;
414	luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);	553	luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
@@ -435,42 +574,49 @@ static void close_func (LexState *ls) { · 20 unmodified lines
435	** opens the main function, which is a regular vararg function with an	574	** opens the main function, which is a regular vararg function with an
436	** upvalue named LUA_ENV	575	** upvalue named LUA_ENV
437	*/	576	*/
438	static void open_mainfunc (LexState ls, FuncState fs) {	577	static void open_mainfunc (LexState ls, FuncState fs, BlockCnt *bl) {
439	expdesc v;	578	expdesc v;
440	open_func(ls, fs);	579	open_func(ls, fs, bl);
441	fs->f->is_vararg = 1; /* main function is always vararg */	580	fs->f->is_vararg = 1; /* main function is always vararg */
442	init_exp(&v, VLOCAL, 0);	581	init_exp(&v, VLOCAL, 0);
443	newupvalue(fs, ls->envn, &v); /* create environment upvalue */	582	newupvalue(fs, ls->envn, &v); /* create environment upvalue */
444	}	583	}
445		584
446		585
447	Proto luaY_parser (lua_State L, ZIO z, Mbuffer buff, Varlist *varl,
448	const char *name) {
449	LexState lexstate;
450	FuncState funcstate;
451	TString *tname = luaS_new(L, name);
452	setsvalue2s(L, L->top, tname); /* push name to protect it */
453	incr_top(L);
454	lexstate.buff = buff;
455	lexstate.varl = varl;
456	luaX_setinput(L, &lexstate, z, tname);
457	open_mainfunc(&lexstate, &funcstate);
458	luaX_next(&lexstate); /* read first token */
459	chunk(&lexstate); /* read main chunk */
460	check(&lexstate, TK_EOS);
461	close_func(&lexstate);
462	L->top--; /* pop name */
463	lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
464	return funcstate.f;
465	}
466
467
468		586
469	/============================================================/	587	/============================================================/
470	/* GRAMMAR RULES */	588	/* GRAMMAR RULES */
471	/============================================================/	589	/============================================================/
472		590
473		591
		592	/*
		593	** check whether current token is in the follow set of a block.
		594	** 'until' closes syntactical blocks, but do not close scope,
		595	** so it handled in separate.
		596	*/
		597	static int block_follow (LexState *ls, int withuntil) {
		598	switch (ls->t.token) {
		599	case TK_ELSE: case TK_ELSEIF:
		600	case TK_END: case TK_EOS:
		601	return 1;
		602	case TK_UNTIL: return withuntil;
		603	default: return 0;
		604	}
		605	}
		606
		607
		608	static void statlist (LexState *ls) {
		609	/* statlist -> { stat [`;'] } */
		610	while (!block_follow(ls, 1)) {
		611	if (ls->t.token == TK_RETURN) {
		612	statement(ls);
		613	return; /* 'return' must be last statement */
		614	}
		615	statement(ls);
		616	}
		617	}
		618
		619
474	static void fieldsel (LexState ls, expdesc v) {	620	static void fieldsel (LexState ls, expdesc v) {
475	/* fieldsel -> ['.' \| ':'] NAME */	621	/* fieldsel -> ['.' \| ':'] NAME */
476	FuncState *fs = ls->fs;	622	FuncState *fs = ls->fs;
@@ -586,7 +732,7 @@ static void field (LexState ls, struct ConsControl cc) { · 109 unmodified lines
586		732
587		733
588	static void constructor (LexState ls, expdesc t) {	734	static void constructor (LexState ls, expdesc t) {
589	/* constructor -> '{' [ field { sep field } [sep] ] '}'	735	/* constructor -> '{' [ field { sep field } [sep] ] '}'
590	sep -> ',' \| ';' */	736	sep -> ',' \| ';' */
591	FuncState *fs = ls->fs;	737	FuncState *fs = ls->fs;
592	int line = ls->linenumber;	738	int line = ls->linenumber;
@@ -596,7 +742,7 @@ static void constructor (LexState ls, expdesc t) { · 3 unmodified lines
596	cc.t = t;	742	cc.t = t;
597	init_exp(t, VRELOCABLE, pc);	743	init_exp(t, VRELOCABLE, pc);
598	init_exp(&cc.v, VVOID, 0); /* no value (yet) */	744	init_exp(&cc.v, VVOID, 0); /* no value (yet) */
599	luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */	745	luaK_exp2nextreg(ls->fs, t); /* fix it at stack top */
600	checknext(ls, '{');	746	checknext(ls, '{');
601	do {	747	do {
602	lua_assert(cc.v.k == VVOID \|\| cc.tostore > 0);	748	lua_assert(cc.v.k == VVOID \|\| cc.tostore > 0);
@@ -643,19 +789,20 @@ static void parlist (LexState *ls) { · 40 unmodified lines
643	}	789	}
644		790
645		791
646	static void body (LexState ls, expdesc e, int needself, int line) {	792	static void body (LexState ls, expdesc e, int ismethod, int line) {
647	/* body -> `(' parlist `)' chunk END */	793	/* body -> `(' parlist `)' block END */
648	FuncState new_fs;	794	FuncState new_fs;
649	open_func(ls, &new_fs);	795	BlockCnt bl;
		796	open_func(ls, &new_fs, &bl);
650	new_fs.f->linedefined = line;	797	new_fs.f->linedefined = line;
651	checknext(ls, '(');	798	checknext(ls, '(');
652	if (needself) {	799	if (ismethod) {
653	new_localvarliteral(ls, "self");	800	new_localvarliteral(ls, "self"); /* create 'self' parameter */
654	adjustlocalvars(ls, 1);	801	adjustlocalvars(ls, 1);
655	}	802	}
656	parlist(ls);	803	parlist(ls);
657	checknext(ls, ')');	804	checknext(ls, ')');
658	chunk(ls);	805	statlist(ls);
659	new_fs.f->lastlinedefined = ls->linenumber;	806	new_fs.f->lastlinedefined = ls->linenumber;
660	check_match(ls, TK_END, TK_FUNCTION, line);	807	check_match(ls, TK_END, TK_FUNCTION, line);
661	codeclosure(ls, new_fs.f, e);	808	codeclosure(ls, new_fs.f, e);
@@ -663,8 +810,8 @@ static void body (LexState ls, expdesc e, int needself, int line) { · 1 unmodified line
663	}	810	}
664		811
665		812
666	static int explist1 (LexState ls, expdesc v) {	813	static int explist (LexState ls, expdesc v) {
667	/* explist1 -> expr { `,' expr } */	814	/* explist -> expr { `,' expr } */
668	int n = 1; /* at least one expression */	815	int n = 1; /* at least one expression */
669	expr(ls, v);	816	expr(ls, v);
670	while (testnext(ls, ',')) {	817	while (testnext(ls, ',')) {
@@ -681,12 +828,12 @@ static void funcargs (LexState ls, expdesc f, int line) { · 10 unmodified lines
681	expdesc args;	828	expdesc args;
682	int base, nparams;	829	int base, nparams;
683	switch (ls->t.token) {	830	switch (ls->t.token) {
684	case '(': { /* funcargs -> `(' [ explist1 ] `)' */	831	case '(': { /* funcargs -> `(' [ explist ] `)' */
685	luaX_next(ls);	832	luaX_next(ls);
686	if (ls->t.token == ')') /* arg list is empty? */	833	if (ls->t.token == ')') /* arg list is empty? */
687	args.k = VVOID;	834	args.k = VVOID;
688	else {	835	else {
689	explist1(ls, &args);	836	explist(ls, &args);
690	luaK_setmultret(fs, &args);	837	luaK_setmultret(fs, &args);
691	}	838	}
692	check_match(ls, ')', '(', line);	839	check_match(ls, ')', '(', line);
@@ -937,23 +1084,12 @@ static void expr (LexState ls, expdesc v) { · 244 unmodified lines
937	*/	1084	*/
938		1085
939		1086
940	static int block_follow (int token) {
941	switch (token) {
942	case TK_ELSE: case TK_ELSEIF: case TK_END:
943	case TK_UNTIL: case TK_EOS:
944	return 1;
945	default: return 0;
946	}
947	}
948
949
950	static void block (LexState *ls) {	1087	static void block (LexState *ls) {
951	/* block -> chunk */	1088	/* block -> statlist */
952	FuncState *fs = ls->fs;	1089	FuncState *fs = ls->fs;
953	BlockCnt bl;	1090	BlockCnt bl;
954	enterblock(fs, &bl, 0);	1091	enterblock(fs, &bl, 0);
955	chunk(ls);	1092	statlist(ls);
956	lua_assert(bl.breaklist == NO_JUMP);
957	leaveblock(fs);	1093	leaveblock(fs);
958	}	1094	}
959		1095
@@ -1012,10 +1148,10 @@ static void assignment (LexState ls, struct LHS_assign lh, int nvars) { · 52 unmodified lines
1012	"variable names");	1148	"variable names");
1013	assignment(ls, &nv, nvars+1);	1149	assignment(ls, &nv, nvars+1);
1014	}	1150	}
1015	else { /* assignment -> `=' explist1 */	1151	else { /* assignment -> `=' explist */
1016	int nexps;	1152	int nexps;
1017	checknext(ls, '=');	1153	checknext(ls, '=');
1018	nexps = explist1(ls, &e);	1154	nexps = explist(ls, &e);
1019	if (nexps != nvars) {	1155	if (nexps != nvars) {
1020	adjust_assign(ls, nvars, nexps, &e);	1156	adjust_assign(ls, nvars, nexps, &e);
1021	if (nexps > nvars)	1157	if (nexps > nvars)
@@ -1042,19 +1178,38 @@ static int cond (LexState *ls) { · 20 unmodified lines
1042	}	1178	}
1043		1179
1044		1180
1045	static void breakstat (LexState *ls) {	1181	static void gotostat (LexState ls, TString label, int line) {
		1182	/* create new entry for this goto */
		1183	int g = newlabelentry(ls, &ls->dyd->gt, label, line, luaK_jump(ls->fs));
		1184	findlabel(ls, g);
		1185	}
		1186
		1187
		1188	static void labelstat (LexState ls, TString label, int line) {
		1189	/* label -> '@' NAME ':' */
1046	FuncState *fs = ls->fs;	1190	FuncState *fs = ls->fs;
1047	BlockCnt *bl = fs->bl;	1191	Labellist *ll = &ls->dyd->label;
1048	int upval = 0;	1192	int l, i; /* index of new label being created */
1049	while (bl && !bl->isbreakable) {	1193	/* check for repeated labels on the same block */
1050	upval \|= bl->upval;	1194	for (i = ls->fs->bl->firstlabel; i < ll->n; i++) {
1051	bl = bl->previous;	1195	if (eqstr(label, ll->arr[i].name)) {
		1196	const char *msg = luaO_pushfstring(ls->L,
		1197	"label " LUA_QS " already defined on line %d",
		1198	getstr(label), ll->arr[i].line);
		1199	semerror(ls, msg);
		1200	}
1052	}	1201	}
1053	if (!bl)	1202	checknext(ls, ':'); /* skip colon */
1054	luaX_syntaxerror(ls, "no loop to break");	1203	/* create new entry for this label */
1055	if (upval)	1204	l = newlabelentry(ls, ll, label, line, fs->pc);
1056	luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);	1205	/* skip other no-op statements */
1057	luaK_concat(fs, &bl->breaklist, luaK_jump(fs));	1206	while (ls->t.token == ';' \|\| ls->t.token == '@')
		1207	statement(ls);
		1208	if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */
		1209	/* assume that locals are already out of scope */
		1210	ll->arr[l].nactvar = fs->bl->nactvar;
		1211	}
		1212	findgotos(ls, &ll->arr[l]);
1058	}	1213	}
1059		1214
1060		1215
@@ -1086,19 +1241,13 @@ static void repeatstat (LexState *ls, int line) { · 25 unmodified lines
1086	enterblock(fs, &bl1, 1); /* loop block */	1241	enterblock(fs, &bl1, 1); /* loop block */
1087	enterblock(fs, &bl2, 0); /* scope block */	1242	enterblock(fs, &bl2, 0); /* scope block */
1088	luaX_next(ls); /* skip REPEAT */	1243	luaX_next(ls); /* skip REPEAT */
1089	chunk(ls);	1244	statlist(ls);
1090	check_match(ls, TK_UNTIL, TK_REPEAT, line);	1245	check_match(ls, TK_UNTIL, TK_REPEAT, line);
1091	condexit = cond(ls); /* read condition (inside scope block) */	1246	condexit = cond(ls); /* read condition (inside scope block) */
1092	if (!bl2.upval) { /* no upvalues? */	1247	if (bl2.upval) /* upvalues? */
1093	leaveblock(fs); /* finish scope */	1248	luaK_patchclose(fs, condexit, bl2.nactvar);
1094	luaK_patchlist(fs, condexit, repeat_init); /* close the loop */	1249	leaveblock(fs); /* finish scope */
1095	}	1250	luaK_patchlist(fs, condexit, repeat_init); /* close the loop */
1096	else { /* complete semantics when there are upvalues */
1097	breakstat(ls); /* if condition then break */
1098	luaK_patchtohere(ls->fs, condexit); /* else... */
1099	leaveblock(fs); /* finish scope... */
1100	luaK_jumpto(fs, repeat_init); /* and repeat */
1101	}
1102	leaveblock(fs); /* finish loop */	1251	leaveblock(fs); /* finish loop */
1103	}	1252	}
1104		1253
@@ -1163,7 +1312,7 @@ static void fornum (LexState ls, TString varname, int line) { · 58 unmodified lines
1163		1312
1164		1313
1165	static void forlist (LexState ls, TString indexname) {	1314	static void forlist (LexState ls, TString indexname) {
1166	/* forlist -> NAME {,NAME} IN explist1 forbody */	1315	/* forlist -> NAME {,NAME} IN explist forbody */
1167	FuncState *fs = ls->fs;	1316	FuncState *fs = ls->fs;
1168	expdesc e;	1317	expdesc e;
1169	int nvars = 4; /* gen, state, control, plus at least one declared var */	1318	int nvars = 4; /* gen, state, control, plus at least one declared var */
@@ -1181,7 +1330,7 @@ static void forlist (LexState ls, TString indexname) { · 11 unmodified lines
1181	}	1330	}
1182	checknext(ls, TK_IN);	1331	checknext(ls, TK_IN);
1183	line = ls->linenumber;	1332	line = ls->linenumber;
1184	adjust_assign(ls, 3, explist1(ls, &e), &e);	1333	adjust_assign(ls, 3, explist(ls, &e), &e);
1185	luaK_checkstack(fs, 3); /* extra space to call generator */	1334	luaK_checkstack(fs, 3); /* extra space to call generator */
1186	forbody(ls, base, line, nvars - 3, 0);	1335	forbody(ls, base, line, nvars - 3, 0);
1187	}	1336	}
@@ -1241,19 +1390,20 @@ static void ifstat (LexState *ls, int line) { · 53 unmodified lines
1241		1390
1242		1391
1243	static void localfunc (LexState *ls) {	1392	static void localfunc (LexState *ls) {
1244	expdesc v, b;	1393	expdesc b;
1245	FuncState *fs = ls->fs;	1394	FuncState *fs = ls->fs;
1246	new_localvar(ls, str_checkname(ls));	1395	int varidx = fs->nactvar; /* index of new local variable */
1247	init_exp(&v, VLOCAL, fs->freereg);	1396	new_localvar(ls, str_checkname(ls)); /* new local variable */
1248	luaK_reserveregs(fs, 1);	1397	adjustlocalvars(ls, 1); /* enter its scope */
1249	adjustlocalvars(ls, 1);	1398	body(ls, &b, 0, ls->linenumber); /* function created in next register */
1250	body(ls, &b, 0, ls->linenumber);	1399	lua_assert(b.k == VNONRELOC && b.u.ind.idx == varidx);
1251	luaK_storevar(fs, &v, &b);	1400	/* debug information will only see the variable after this point! */
		1401	getlocvar(fs, varidx)->startpc = fs->pc;
1252	}	1402	}
1253		1403
1254		1404
1255	static void localstat (LexState *ls) {	1405	static void localstat (LexState *ls) {
1256	/* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */	1406	/* stat -> LOCAL NAME {`,' NAME} [`=' explist] */
1257	int nvars = 0;	1407	int nvars = 0;
1258	int nexps;	1408	int nexps;
1259	expdesc e;	1409	expdesc e;
@@ -1262,7 +1412,7 @@ static void localstat (LexState *ls) { · 2 unmodified lines
1262	nvars++;	1412	nvars++;
1263	} while (testnext(ls, ','));	1413	} while (testnext(ls, ','));
1264	if (testnext(ls, '='))	1414	if (testnext(ls, '='))
1265	nexps = explist1(ls, &e);	1415	nexps = explist(ls, &e);
1266	else {	1416	else {
1267	e.k = VVOID;	1417	e.k = VVOID;
1268	nexps = 0;	1418	nexps = 0;
@@ -1274,25 +1424,25 @@ static void localstat (LexState *ls) { · 5 unmodified lines
1274		1424
1275	static int funcname (LexState ls, expdesc v) {	1425	static int funcname (LexState ls, expdesc v) {
1276	/* funcname -> NAME {fieldsel} [`:' NAME] */	1426	/* funcname -> NAME {fieldsel} [`:' NAME] */
1277	int needself = 0;	1427	int ismethod = 0;
1278	singlevar(ls, v);	1428	singlevar(ls, v);
1279	while (ls->t.token == '.')	1429	while (ls->t.token == '.')
1280	fieldsel(ls, v);	1430	fieldsel(ls, v);
1281	if (ls->t.token == ':') {	1431	if (ls->t.token == ':') {
1282	needself = 1;	1432	ismethod = 1;
1283	fieldsel(ls, v);	1433	fieldsel(ls, v);
1284	}	1434	}
1285	return needself;	1435	return ismethod;
1286	}	1436	}
1287		1437
1288		1438
1289	static void funcstat (LexState *ls, int line) {	1439	static void funcstat (LexState *ls, int line) {
1290	/* funcstat -> FUNCTION funcname body */	1440	/* funcstat -> FUNCTION funcname body */
1291	int needself;	1441	int ismethod;
1292	expdesc v, b;	1442	expdesc v, b;
1293	luaX_next(ls); /* skip FUNCTION */	1443	luaX_next(ls); /* skip FUNCTION */
1294	needself = funcname(ls, &v);	1444	ismethod = funcname(ls, &v);
1295	body(ls, &b, needself, line);	1445	body(ls, &b, ismethod, line);
1296	luaK_storevar(ls->fs, &v, &b);	1446	luaK_storevar(ls->fs, &v, &b);
1297	luaK_fixline(ls->fs, line); /* definition `happens' in the first line */	1447	luaK_fixline(ls->fs, line); /* definition `happens' in the first line */
1298	}	1448	}
@@ -1313,14 +1463,14 @@ static void exprstat (LexState *ls) { · 14 unmodified lines
1313		1463
1314		1464
1315	static void retstat (LexState *ls) {	1465	static void retstat (LexState *ls) {
1316	/* stat -> RETURN explist */	1466	/* stat -> RETURN [explist] [';'] */
1317	FuncState *fs = ls->fs;	1467	FuncState *fs = ls->fs;
1318	expdesc e;	1468	expdesc e;
1319	int first, nret; /* registers with returned values */	1469	int first, nret; /* registers with returned values */
1320	if (block_follow(ls->t.token) \|\| ls->t.token == ';')	1470	if (block_follow(ls, 1) \|\| ls->t.token == ';')
1321	first = nret = 0; /* return no values */	1471	first = nret = 0; /* return no values */
1322	else {	1472	else {
1323	nret = explist1(ls, &e); /* optional return values */	1473	nret = explist(ls, &e); /* optional return values */
1324	if (hasmultret(e.k)) {	1474	if (hasmultret(e.k)) {
1325	luaK_setmultret(fs, &e);	1475	luaK_setmultret(fs, &e);
1326	if (e.k == VCALL && nret == 1) { /* tail call? */	1476	if (e.k == VCALL && nret == 1) { /* tail call? */
@@ -1341,41 +1491,43 @@ static void retstat (LexState *ls) { · 14 unmodified lines
1341	}	1491	}
1342	}	1492	}
1343	luaK_ret(fs, first, nret);	1493	luaK_ret(fs, first, nret);
		1494	testnext(ls, ';'); /* skip optional semicolon */
1344	}	1495	}
1345		1496
1346		1497
1347	static int statement (LexState *ls) {	1498	static void statement (LexState *ls) {
1348	int line = ls->linenumber; /* may be needed for error messages */	1499	int line = ls->linenumber; /* may be needed for error messages */
		1500	enterlevel(ls);
1349	switch (ls->t.token) {	1501	switch (ls->t.token) {
1350	case ';': { /* stat -> ';' (empty statement) */	1502	case ';': { /* stat -> ';' (empty statement) */
1351	luaX_next(ls); /* skip ';' */	1503	luaX_next(ls); /* skip ';' */
1352	return 0;	1504	break;
1353	}	1505	}
1354	case TK_IF: { /* stat -> ifstat */	1506	case TK_IF: { /* stat -> ifstat */
1355	ifstat(ls, line);	1507	ifstat(ls, line);
1356	return 0;	1508	break;
1357	}	1509	}
1358	case TK_WHILE: { /* stat -> whilestat */	1510	case TK_WHILE: { /* stat -> whilestat */
1359	whilestat(ls, line);	1511	whilestat(ls, line);
1360	return 0;	1512	break;
1361	}	1513	}
1362	case TK_DO: { /* stat -> DO block END */	1514	case TK_DO: { /* stat -> DO block END */
1363	luaX_next(ls); /* skip DO */	1515	luaX_next(ls); /* skip DO */
1364	block(ls);	1516	block(ls);
1365	check_match(ls, TK_END, TK_DO, line);	1517	check_match(ls, TK_END, TK_DO, line);
1366	return 0;	1518	break;
1367	}	1519	}
1368	case TK_FOR: { /* stat -> forstat */	1520	case TK_FOR: { /* stat -> forstat */
1369	forstat(ls, line);	1521	forstat(ls, line);
1370	return 0;	1522	break;
1371	}	1523	}
1372	case TK_REPEAT: { /* stat -> repeatstat */	1524	case TK_REPEAT: { /* stat -> repeatstat */
1373	repeatstat(ls, line);	1525	repeatstat(ls, line);
1374	return 0;	1526	break;
1375	}	1527	}
1376	case TK_FUNCTION: { /* stat -> funcstat */	1528	case TK_FUNCTION: { /* stat -> funcstat */
1377	funcstat(ls, line);	1529	funcstat(ls, line);
1378	return 0;	1530	break;
1379	}	1531	}
1380	case TK_LOCAL: { /* stat -> localstat */	1532	case TK_LOCAL: { /* stat -> localstat */
1381	luaX_next(ls); /* skip LOCAL */	1533	luaX_next(ls); /* skip LOCAL */
@@ -1383,39 +1535,62 @@ static int statement (LexState *ls) { · 1 unmodified line
1383	localfunc(ls);	1535	localfunc(ls);
1384	else	1536	else
1385	localstat(ls);	1537	localstat(ls);
1386	return 0;	1538	break;
		1539	}
		1540	case '@': { /* stat -> label */
		1541	luaX_next(ls); /* skip '@' */
		1542	labelstat(ls, str_checkname(ls), line);
		1543	break;
1387	}	1544	}
1388	case TK_RETURN: { /* stat -> retstat */	1545	case TK_RETURN: { /* stat -> retstat */
1389	luaX_next(ls); /* skip RETURN */	1546	luaX_next(ls); /* skip RETURN */
1390	retstat(ls);	1547	retstat(ls);
1391	return 1; /* must be last statement */	1548	break;
1392	}	1549	}
1393	case TK_BREAK: { /* stat -> breakstat */	1550	case TK_BREAK: { /* stat -> breakstat */
1394	luaX_next(ls); /* skip BREAK */	1551	luaX_next(ls); /* skip BREAK */
1395	breakstat(ls);	1552	/* code it as "goto 'break'" */
1396	return 1; /* must be last statement */	1553	gotostat(ls, luaS_new(ls->L, "break"), line);
		1554	break;
		1555	}
		1556	case TK_GOTO: { /* stat -> 'goto' NAME */
		1557	luaX_next(ls); /* skip GOTO */
		1558	gotostat(ls, str_checkname(ls), line);
		1559	break;
1397	}	1560	}
1398	default: { /* stat -> func \| assignment */	1561	default: { /* stat -> func \| assignment */
1399	exprstat(ls);	1562	exprstat(ls);
1400	return 0;	1563	break;
1401	}	1564	}
1402	}	1565	}
		1566	lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
		1567	ls->fs->freereg >= ls->fs->nactvar);
		1568	ls->fs->freereg = ls->fs->nactvar; /* free registers */
		1569	leavelevel(ls);
1403	}	1570	}
1404		1571
		1572	/* }====================================================================== */
1405		1573
1406	static void chunk (LexState *ls) {	1574
1407	/* chunk -> { stat [`;'] } */	1575	Proto luaY_parser (lua_State L, ZIO z, Mbuffer buff,
1408	int islast = 0;	1576	Dyndata dyd, const char name, int firstchar) {
1409	enterlevel(ls);	1577	LexState lexstate;
1410	while (!islast && !block_follow(ls->t.token)) {	1578	FuncState funcstate;
1411	islast = statement(ls);	1579	BlockCnt bl;
1412	if (islast)	1580	TString *tname = luaS_new(L, name);
1413	testnext(ls, ';');	1581	setsvalue2s(L, L->top, tname); /* push name to protect it */
1414	lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&	1582	incr_top(L);
1415	ls->fs->freereg >= ls->fs->nactvar);	1583	lexstate.buff = buff;
1416	ls->fs->freereg = ls->fs->nactvar; /* free registers */	1584	lexstate.dyd = dyd;
1417	}	1585	dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
1418	leavelevel(ls);	1586	luaX_setinput(L, &lexstate, z, tname, firstchar);
		1587	open_mainfunc(&lexstate, &funcstate, &bl);
		1588	luaX_next(&lexstate); /* read first token */
		1589	statlist(&lexstate); /* main body */
		1590	check(&lexstate, TK_EOS);
		1591	close_func(&lexstate);
		1592	L->top--; /* pop name */
		1593	lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
		1594	return funcstate.f;
1419	}	1595	}
1420		1596
1421	/* }====================================================================== */

src/lparser.h+34−11

 /*
-** $Id: lparser.h,v 1.65 2010/07/07 16:27:29 roberto Exp $
+** $Id: lparser.h,v 1.68 2011/02/23 13:13:10 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 } expdesc;
-typedef struct vardesc {
+/* description of active local variable */
-  unsigned short idx;
+typedef struct Vardesc {
-} vardesc;
+  unsigned short idx;  /* variable index in stack */
+} Vardesc;
-/* list of all active local variables */
+/* description of pending goto statements and label statements */
-typedef struct Varlist {
+typedef struct Labeldesc {
-  vardesc *actvar;
+  TString *name;  /* label identifier */
-  int nactvar;
+  int pc;  /* position in code */
-  int actvarsize;
+  int line;  /* line where it appeared */
-} Varlist;
+  lu_byte nactvar;  /* local level where it appears in current block */
+} Labeldesc;
+/* list of labels or gotos */
+typedef struct Labellist {
+  Labeldesc *arr;  /* array */
+  int n;  /* number of entries in use */
+  int size;  /* array size */
+} Labellist;
+/* dynamic structures used by the parser */
+typedef struct Dyndata {
+  struct {  /* list of active local variables */
+    Vardesc *arr;
+    int n;
+    int size;
+  } actvar;
+  Labellist gt;  /* list of pending gotos */
+  Labellist label;   /* list of active labels */
+} Dyndata;
+/* control of blocks */
 struct BlockCnt;  /* defined in lparser.c */
 LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                              Varlist *varl, const char *name);
+                              Dyndata *dyd, const char *name, int firstchar);
 #endif

src/lstate.c+12−8

 /*
-** $Id: lstate.c,v 2.86 2010/09/03 14:14:01 roberto Exp $
+** $Id: lstate.c,v 2.89 2010/12/20 19:40:07 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 #define fromstate(L)	(cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
 /*
-** maximum number of nested calls made by error-handling function
+** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
+** invariant
 */
-#define LUAI_EXTRACALLS		10
+void luaE_setdebt (global_State *g, l_mem debt) {
+  g->totalbytes -= (debt - g->GCdebt);
+  g->GCdebt = debt;
+}
 CallInfo *luaE_extendCI (lua_State *L) {
   /* pre-create memory-error message */
   g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
   luaS_fix(g->memerrmsg);  /* it should never be collected */
-  g->GCdebt = 0;
+  g->gcrunning = 1;  /* allow gc */
 }
   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
   luaZ_freebuffer(L, &g->buff);
   freestack(L);
-  lua_assert(g->totalbytes == sizeof(LG));
+  lua_assert(gettotalbytes(g) == sizeof(LG));
   (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);
 }
   g->mainthread = L;
   g->uvhead.u.l.prev = &g->uvhead;
   g->uvhead.u.l.next = &g->uvhead;
-  stopgc(g);  /* no GC while building state */
+  g->gcrunning = 0;  /* no GC while building state */
   g->lastmajormem = 0;
   g->strt.size = 0;
   g->strt.nuse = 0;
   g->version = lua_version(NULL);
   g->gcstate = GCSpause;
   g->allgc = NULL;
-  g->udgc = NULL;
+  g->finobj = NULL;
   g->tobefnz = NULL;
   g->gray = g->grayagain = NULL;
   g->weak = g->ephemeron = g->allweak = NULL;
   g->totalbytes = sizeof(LG);
+  g->GCdebt = 0;
   g->gcpause = LUAI_GCPAUSE;
   g->gcmajorinc = LUAI_GCMAJOR;
   g->gcstepmul = LUAI_GCMUL;

src/lstate.h+11−7

 /*
-** $Id: lstate.h,v 2.68 2010/10/29 17:52:46 roberto Exp $
+** $Id: lstate.h,v 2.72 2011/06/02 19:31:40 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 ** when traversing the respective threads, but the thread may already be
 ** dead, while the upvalue is still accessible through closures.)
 **
-** Userdata with finalizers are kept in the list g->udgc.
+** Objects with finalizers are kept in the list g->finobj.
 **
-** The list g->tobefnz links all userdata being finalized.
+** The list g->tobefnz links all objects being finalized.
 */
 #define CIST_TAIL	(1<<6)	/* call was tail called */
-#define ci_func(ci)	(clvalue((ci)->func))
 #define isLua(ci)	((ci)->callstatus & CIST_LUA)
 typedef struct global_State {
   lua_Alloc frealloc;  /* function to reallocate memory */
   void *ud;         /* auxiliary data to `frealloc' */
-  lu_mem totalbytes;  /* number of bytes currently allocated */
+  lu_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
-  l_mem GCdebt;  /* when positive, run a GC step */
+  l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */
   lu_mem lastmajormem;  /* memory in use after last major collection */
   stringtable strt;  /* hash table for strings */
   TValue l_registry;
   lu_byte currentwhite;
   lu_byte gcstate;  /* state of garbage collector */
   lu_byte gckind;  /* kind of GC running */
+  lu_byte gcrunning;  /* true if GC is running */
   int sweepstrgc;  /* position of sweep in `strt' */
   GCObject *allgc;  /* list of all collectable objects */
-  GCObject *udgc;  /* list of collectable userdata with finalizers */
+  GCObject *finobj;  /* list of collectable objects with finalizers */
   GCObject **sweepgc;  /* current position of sweep */
   GCObject *gray;  /* list of gray objects */
   GCObject *grayagain;  /* list of objects to be traversed atomically */
 #define obj2gco(v)	(cast(GCObject *, (v)))
+/* actual number of total bytes allocated */
+#define gettotalbytes(g)	((g)->totalbytes + (g)->GCdebt)
+LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
 LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
 LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
 LUAI_FUNC void luaE_freeCI (lua_State *L);

src/lstring.c+4−3

 /*
-** $Id: lstring.c,v 2.18 2010/05/10 18:23:45 roberto Exp $
+** $Id: lstring.c,v 2.19 2011/05/03 16:01:57 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
        o != NULL;
        o = gch(o)->next) {
     TString *ts = rawgco2ts(o);
-    if (h == ts->tsv.hash && ts->tsv.len == l &&
+    if (h == ts->tsv.hash &&
-                             (memcmp(str, getstr(ts), l) == 0)) {
+        ts->tsv.len == l &&
+        (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
       if (isdead(G(L), o))  /* string is dead (but was not collected yet)? */
         changewhite(o);  /* resurrect it */
       return ts;

src/lstrlib.c+51−22

 /*
-** $Id: lstrlib.c,v 1.159 2010/11/19 16:25:51 roberto Exp $
+** $Id: lstrlib.c,v 1.168 2011/06/09 18:22:47 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
 /* translate a relative string position: negative means back from end */
 static size_t posrelat (ptrdiff_t pos, size_t len) {
   if (pos >= 0) return (size_t)pos;
-  else if (pos == -pos || (size_t)-pos > len) return 0;
+  else if (-(size_t)pos > len) return 0;
   else return len - ((size_t)-pos) + 1;
 }
   return 1;
 }
+/* reasonable limit to avoid arithmetic overflow */
+#define MAXSIZE		((~(size_t)0) >> 1)
 static int str_rep (lua_State *L) {
-  size_t l;
+  size_t l, lsep;
-  luaL_Buffer b;
   const char *s = luaL_checklstring(L, 1, &l);
   int n = luaL_checkint(L, 2);
-  luaL_buffinit(L, &b);
+  const char *sep = luaL_optlstring(L, 3, "", &lsep);
-  while (n-- > 0)
+  if (n <= 0) lua_pushliteral(L, "");
-    luaL_addlstring(&b, s, l);
+  else if (l + lsep < l || l + lsep >= MAXSIZE / n)  /* may overflow? */
-  luaL_pushresult(&b);
+    return luaL_error(L, "resulting string too large");
+  else {
+    size_t totallen = n * l + (n - 1) * lsep;
+    luaL_Buffer b;
+    char *p = luaL_buffinitsize(L, &b, totallen);
+    while (n-- > 1) {  /* first n-1 copies (followed by separator) */
+      memcpy(p, s, l * sizeof(char)); p += l;
+      memcpy(p, sep, lsep * sizeof(char)); p += lsep;
+    }
+    memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */
+    luaL_pushresultsize(&b, totallen);
+  }
   return 1;
 }
   if (posi > pose) return 0;  /* empty interval; return no values */
   n = (int)(pose -  posi + 1);
   if (posi + n <= pose)  /* overflow? */
-    luaL_error(L, "string slice too long");
+    return luaL_error(L, "string slice too long");
   luaL_checkstack(L, n, "string slice too long");
   for (i=0; i<n; i++)
     lua_pushinteger(L, uchar(s[posi+i-1]));
   lua_settop(L, 1);
   luaL_buffinit(L,&b);
   if (lua_dump(L, writer, &b) != 0)
-    luaL_error(L, "unable to dump given function");
+    return luaL_error(L, "unable to dump given function");
   luaL_pushresult(&b);
   return 1;
 }
   size_t upto = 0;
   do {
     if (strpbrk(p + upto, SPECIALS))
       return 0;  /* pattern has a special character */
     upto += strlen(p + upto) + 1;  /* may have more after \0 */
   } while (upto <= l);
   return 1;  /* no special chars found */
 ** the previous length
 */
 #if !defined(LUA_INTFRMLEN)	/* { */
-#if defined(LUA_USELONGLONG)
+#if defined(LUA_USE_LONGLONG)
 #define LUA_INTFRMLEN           "ll"
 #define LUA_INTFRM_T            long long
 static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
   const char *p = strfrmt;
   while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++;  /* skip flags */
-  if ((size_t)(p - strfrmt) >= sizeof(FLAGS))
+  if ((size_t)(p - strfrmt) >= sizeof(FLAGS)/sizeof(char))
     luaL_error(L, "invalid format (repeated flags)");
   if (isdigit(uchar(*p))) p++;  /* skip width */
   if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
   if (isdigit(uchar(*p)))
     luaL_error(L, "invalid format (width or precision too long)");
   *(form++) = '%';
-  memcpy(form, strfrmt, p - strfrmt + 1);
+  memcpy(form, strfrmt, (p - strfrmt + 1) * sizeof(char));
   form += p - strfrmt + 1;
   *form = '\0';
   return p;
           break;
         }
         case 'e':  case 'E': case 'f':
+#if defined(LUA_USE_AFORMAT)
+        case 'a': case 'A':
+#endif
         case 'g': case 'G': {
           addlenmod(form, LUA_FLTFRMLEN);
           nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg));
         }
         case 's': {
           size_t l;
-          const char *s = luaL_checklstring(L, arg, &l);
+          const char *s = luaL_tolstring(L, arg, &l);
           if (!strchr(form, '.') && l >= 100) {
             /* no precision and string is too long to be formatted;
                keep original string */
-            lua_pushvalue(L, arg);
             luaL_addvalue(&b);
             break;
           }
           else {
             nb = sprintf(buff, form, s);
+            lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */
             break;
           }
         }
 /* }====================================================== */
+static int noindex (lua_State *L) {
+  const char *f = lua_tostring(L, 2);
+  if (f)
+    return luaL_error(L, "no field '%s' in strings", f);
+  else
+    return luaL_error(L, "no such field in strings");
+}
 static const luaL_Reg strlib[] = {
   {"byte", str_byte},
   {"char", str_char},
   {"reverse", str_reverse},
   {"sub", str_sub},
   {"upper", str_upper},
+  {"__index", noindex},
   {NULL, NULL}
 };
 static void createmetatable (lua_State *L) {
-  lua_createtable(L, 0, 1);  /* create metatable for strings */
+  /* setmetatable("", {__index = string}) */
   lua_pushliteral(L, "");  /* dummy string */
-  lua_pushvalue(L, -2);
+  lua_createtable(L, 0, 1);  /* create metatable for strings */
-  lua_setmetatable(L, -2);  /* set string metatable */
+  lua_pushvalue(L, -3);  /* set the string library... */
+  lua_setfield(L, -2, "__index");  /* ...as the __index metamethod */
+  lua_setmetatable(L, -2);  /* set metatable for strings */
   lua_pop(L, 1);  /* pop dummy string */
-  lua_pushvalue(L, -2);  /* string library... */
+  /* setmetatable(string, string) */
-  lua_setfield(L, -2, "__index");  /* ...is the __index metamethod */
+  lua_pushvalue(L, -1);  /* push string library */
-  lua_pop(L, 1);  /* pop metatable */
+  lua_setmetatable(L, -2);  /* set it as its own metatable */
 }

src/ltable.c+10−8

 /*
-** $Id: ltable.c,v 2.53 2010/11/11 15:38:43 roberto Exp $
+** $Id: ltable.c,v 2.59 2011/06/09 18:23:27 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
+#include "lvm.h"
 /*
   int i;
   luai_hashnum(i, n);
   if (i < 0) {
-     i = -i;  /* must be a positive value */
+    if ((unsigned int)i == -(unsigned int)i)
-     if (i < 0) i = 0;  /* handle INT_MIN */
+      i = 0;  /* handle INT_MIN */
+    i = -i;  /* must be a positive value */
   }
   return hashmod(t, i);
 }
     Node *n = mainposition(t, key);
     do {  /* check whether `key' is somewhere in the chain */
       /* key may be dead already, but it is ok to use it in `next' */
-      if (luaO_rawequalObj(gkey(n), key) ||
+      if (luaV_rawequalobj(gkey(n), key) ||
-            (ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
+            (ttisdeadkey(gkey(n)) && iscollectable(key) &&
              gcvalue(gkey(n)) == gcvalue(key))) {
         i = cast_int(n - gnode(t, 0));  /* key index in hash table */
         /* hash elements are numbered after array ones */
 static void rehash (lua_State *L, Table *t, const TValue *ek) {
   int nasize, na;
-  int nums[MAXBITS+1];  /* nums[i] = number of keys between 2^(i-1) and 2^i */
+  int nums[MAXBITS+1];  /* nums[i] = number of keys with 2^(i-1) < k <= 2^i */
   int i;
   int totaluse;
   for (i=0; i<=MAXBITS; i++) nums[i] = 0;  /* reset counts */
 ** main search function
 */
 const TValue *luaH_get (Table *t, const TValue *key) {
-  switch (ttype(key)) {
+  switch (ttypenv(key)) {
     case LUA_TNIL: return luaO_nilobject;
     case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
     case LUA_TNUMBER: {
     default: {
       Node *n = mainposition(t, key);
       do {  /* check whether `key' is somewhere in the chain */
-        if (luaO_rawequalObj(gkey(n), key))
+        if (luaV_rawequalobj(gkey(n), key))
           return gval(n);  /* that's it */
         else n = gnext(n);
       } while (n);

src/ltablib.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltablib.c,v 1.58 2010/11/23 17:21:14 roberto Exp $	2	** $Id: ltablib.c,v 1.59 2010/12/17 12:15:34 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	*/
@@ -17,7 +17,7 @@ · 11 unmodified lines
17		17
18		18
19	#define aux_getn(L,n) \	19	#define aux_getn(L,n) \
20	(luaL_checktype(L, n, LUA_TTABLE), (int)lua_rawlen(L, n))	20	(luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n))
21		21
22		22
23	static int deprecatedfunc (lua_State *L) {	23	static int deprecatedfunc (lua_State *L) {
@@ -104,7 +104,7 @@ static int tconcat (lua_State *L) { · 80 unmodified lines
104	const char *sep = luaL_optlstring(L, 2, "", &lsep);	104	const char *sep = luaL_optlstring(L, 2, "", &lsep);
105	luaL_checktype(L, 1, LUA_TTABLE);	105	luaL_checktype(L, 1, LUA_TTABLE);
106	i = luaL_optint(L, 3, 1);	106	i = luaL_optint(L, 3, 1);
107	last = luaL_opt(L, luaL_checkint, 4, (int)lua_rawlen(L, 1));	107	last = luaL_opt(L, luaL_checkint, 4, luaL_len(L, 1));
108	luaL_buffinit(L, &b);	108	luaL_buffinit(L, &b);
109	for (; i < last; i++) {	109	for (; i < last; i++) {
110	addfield(L, &b, i);	110	addfield(L, &b, i);
@@ -143,7 +143,7 @@ static int unpack (lua_State *L) { · 32 unmodified lines
143	int i, e, n;	143	int i, e, n;
144	luaL_checktype(L, 1, LUA_TTABLE);	144	luaL_checktype(L, 1, LUA_TTABLE);
145	i = luaL_optint(L, 2, 1);	145	i = luaL_optint(L, 2, 1);
146	e = luaL_opt(L, luaL_checkint, 3, (int)lua_rawlen(L, 1));	146	e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));
147	if (i > e) return 0; /* empty range */	147	if (i > e) return 0; /* empty range */
148	n = e - i + 1; /* number of elements */	148	n = e - i + 1; /* number of elements */
149	if (n <= 0 \|\| !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */	149	if (n <= 0 \|\| !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */

src/ltm.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltm.c,v 2.12 2010/04/13 20:48:12 roberto Exp $	2	** $Id: ltm.c,v 2.14 2011/06/02 19:31:40 roberto Exp $
3	** Tag methods	3	** Tag methods
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -21,11 +21,11 @@ · 15 unmodified lines
21		21
22	static const char udatatypename[] = "userdata";	22	static const char udatatypename[] = "userdata";
23		23
24	LUAI_DDEF const char *const luaT_typenames_[] = {	24	LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
25	"no value",	25	"no value",
26	"nil", "boolean", udatatypename, "number",	26	"nil", "boolean", udatatypename, "number",
27	"string", "table", "function", udatatypename, "thread",	27	"string", "table", "function", udatatypename, "thread",
28	"proto", "upval"	28	"proto", "upval" /* these last two cases are used for tests only */
29	};	29	};
30		30
31		31
@@ -62,7 +62,7 @@ const TValue luaT_gettm (Table events, TMS event, TString *ename) { · 30 unmodified lines
62		62
63	const TValue luaT_gettmbyobj (lua_State L, const TValue *o, TMS event) {	63	const TValue luaT_gettmbyobj (lua_State L, const TValue *o, TMS event) {
64	Table *mt;	64	Table *mt;
65	switch (ttype(o)) {	65	switch (ttypenv(o)) {
66	case LUA_TTABLE:	66	case LUA_TTABLE:
67	mt = hvalue(o)->metatable;	67	mt = hvalue(o)->metatable;
68	break;	68	break;

src/ltm.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltm.h,v 2.10 2010/04/13 20:48:12 roberto Exp $	2	** $Id: ltm.h,v 2.11 2011/02/28 17:32:10 roberto Exp $
3	** Tag methods	3	** Tag methods
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -46,7 +46,7 @@ typedef enum { · 40 unmodified lines
46	#define ttypename(x) luaT_typenames_[(x) + 1]	46	#define ttypename(x) luaT_typenames_[(x) + 1]
47	#define objtypename(x) ttypename(ttypenv(x))	47	#define objtypename(x) ttypename(ttypenv(x))
48		48
49	LUAI_DDEC const char *const luaT_typenames_[];	49	LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
50		50
51		51
52	LUAI_FUNC const TValue luaT_gettm (Table events, TMS event, TString *ename);	52	LUAI_FUNC const TValue luaT_gettm (Table events, TMS event, TString *ename);

src/lua.c+10−11

 /*
-** $Id: lua.c,v 1.194 2010/10/25 19:01:37 roberto Exp $
+** $Id: lua.c,v 1.199 2011/05/26 16:09:40 roberto Exp $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
 static void print_usage (const char *badoption) {
-  if (badoption[1] == 'e' || badoption[1] == 'l') {
+  luai_writestringerror("%s: ", progname);
-    luai_writestringerror("%s: ", progname);
+  if (badoption[1] == 'e' || badoption[1] == 'l')
     luai_writestringerror("'%s' needs argument\n", badoption);
-  } else {
+  else
-    luai_writestringerror("%s: ", progname);
     luai_writestringerror("unrecognized option '%s'\n", badoption);
-  }
   luai_writestringerror(
   "usage: %s [options] [script [args]]\n"
   "Available options are:\n"
 static void print_version (void) {
-  printf("%s\n", LUA_COPYRIGHT);
+  luai_writestring(LUA_COPYRIGHT, sizeof(LUA_COPYRIGHT));
+  luai_writeline();
 }
 }
 /* mark in error messages for incomplete statements */
-#define mark	"<eof>"
+#define EOFMARK		"<eof>"
-#define marklen	(sizeof(mark) - 1)
+#define marklen		(sizeof(EOFMARK)/sizeof(char) - 1)
 static int incomplete (lua_State *L, int status) {
   if (status == LUA_ERRSYNTAX) {
     size_t lmsg;
     const char *msg = lua_tolstring(L, -1, &lmsg);
-    if (lmsg >= marklen && strcmp(msg + lmsg - marklen, mark) == 0) {
+    if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) {
       lua_pop(L, 1);
       return 1;
     }
     }
   }
   lua_settop(L, 0);  /* clear stack */
-  luai_writestring("\n", 1);
+  luai_writeline();
   progname = oldprogname;
 }

src/lua.h+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lua.h,v 1.276 2010/10/26 19:32:19 roberto Exp $	2	** $Id: lua.h,v 1.277 2011/04/18 14:15:48 roberto Exp $
3	** Lua - A Scripting Language	3	** Lua - A Scripting Language
4	** Lua.org, PUC-Rio, Brazil (http://www.lua.org)	4	** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
5	** See Copyright Notice at the end of this file	5	** See Copyright Notice at the end of this file
@@ -18,12 +18,12 @@ · 12 unmodified lines
18		18
19	#define LUA_VERSION_MAJOR "5"	19	#define LUA_VERSION_MAJOR "5"
20	#define LUA_VERSION_MINOR "2"	20	#define LUA_VERSION_MINOR "2"
21	#define LUA_VERSION_RELEASE "0" " (alpha)"	21	#define LUA_VERSION_RELEASE "0" " (beta)"
22		22
23	#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR	23	#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
24	#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE	24	#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
25	#define LUA_VERSION_NUM 502	25	#define LUA_VERSION_NUM 502
26	#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2010 Lua.org, PUC-Rio"	26	#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2011 Lua.org, PUC-Rio"
27	#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"	27	#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
28		28
29		29
@@ -415,7 +415,7 @@ struct lua_Debug { · 385 unmodified lines
415		415
416		416
417	/******************************************************************************	417	/******************************************************************************
418	* Copyright (C) 1994-2010 Lua.org, PUC-Rio. All rights reserved.	418	* Copyright (C) 1994-2011 Lua.org, PUC-Rio. All rights reserved.
419	*	419	*
420	* Permission is hereby granted, free of charge, to any person obtaining	420	* Permission is hereby granted, free of charge, to any person obtaining
421	* a copy of this software and associated documentation files (the	421	* a copy of this software and associated documentation files (the

src/luac.c+17−12

 /*
-** $Id: luac.c,v 1.65 2010/10/26 09:07:52 lhf Exp $
+** $Id: luac.c,v 1.66 2011/05/10 01:08:57 lhf Exp $
 ** Lua compiler (saves bytecodes to files; also list bytecodes)
 ** See Copyright Notice in lua.h
 */
   int i=n;
   if (lua_load(L,reader,&i,"=(" PROGNAME ")")!=LUA_OK) fatal(lua_tostring(L,-1));
   f=toproto(L,-1);
-  for (i=0; i<n; i++) f->p[i]=toproto(L,i-n-1);
+  for (i=0; i<n; i++)
+  {
+   f->p[i]=toproto(L,i-n-1);
+   if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0;
+  }
   f->sizelineinfo=0;
-  f->sizeupvalues=0;
   return f;
  }
 }
 }
 /*
-** $Id: print.c,v 1.66 2010/10/26 09:07:52 lhf Exp $
+** $Id: print.c,v 1.67 2011/05/06 13:37:15 lhf Exp $
 ** print bytecodes
 ** See Copyright Notice in lua.h
 */
 }
 #define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
+#define MYK(x)		(-1-(x))
 static void PrintCode(const Proto* f)
 {
   {
    case iABC:
     printf("%d",a);
-    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b);
+    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (MYK(INDEXK(b))) : b);
-    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c);
+    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (MYK(INDEXK(c))) : c);
     break;
    case iABx:
-    if (getBMode(o)==OpArgK) printf("%d %d",a,-bx); else printf("%d %d",a,bx);
+    printf("%d",a);
+    if (getBMode(o)==OpArgK) printf(" %d",MYK(bx));
+    if (getBMode(o)==OpArgU) printf(" %d",bx);
     break;
    case iAsBx:
-    if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx);
+    printf("%d %d",a,sbx);
     break;
    case iAx:
-    printf("%d",-1-ax);
+    printf("%d",MYK(ax));
     break;
   }
   switch (o)
   {
    case OP_LOADK:
-    if (bx>0) { printf("\t; "); PrintConstant(f,bx-1); }
+    printf("\t; "); PrintConstant(f,bx);
     break;
    case OP_GETUPVAL:
    case OP_SETUPVAL:
     printf("\t; %p",VOID(f->p[bx]));
     break;
    case OP_SETLIST:
-    if (c==0) printf("\t; %d",(int)code[++pc]);
+    if (c==0) printf("\t; %d",(int)code[++pc]); else printf("\t; %d",c);
-    else printf("\t; %d",c);
     break;
    case OP_EXTRAARG:
     printf("\t; "); PrintConstant(f,ax);

src/luaconf.h+57−6

 /*
-** $Id: luaconf.h,v 1.151 2010/11/12 15:48:30 roberto Exp $
+** $Id: luaconf.h,v 1.159 2011/06/13 14:13:06 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
 #if defined(LUA_WIN)
 #define LUA_DL_DLL
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
 #endif
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
 #define LUA_USE_READLINE	/* needs some extra libraries */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hexa formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
 #endif
 #if defined(LUA_USE_MACOSX)
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* does not need -ldl */
 #define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hexa formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
 #endif
 /*
-@@ luai_writestring defines how 'print' prints its results.
+@@ luai_writestring/luai_writeline define how 'print' prints its results.
 */
 #include <stdio.h>
 #define luai_writestring(s,l)	fwrite((s), sizeof(char), (l), stdout)
+#define luai_writeline()	(luai_writestring("\n", 1), fflush(stdout))
 /*
 @@ luai_writestringerror defines how to print error messages.
 */
 #define LUA_COMPAT_LOG10
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
 /*
 @@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
 */
 @@ LUA_NUMBER_FMT is the format for writing numbers.
 @@ lua_number2str converts a number to a string.
 @@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
-@@ lua_str2number converts a string to a number.
 */
 #define LUA_NUMBER_SCAN		"%lf"
 #define LUA_NUMBER_FMT		"%.14g"
 #define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))
 #define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */
+/*
+@@ lua_str2number converts a decimal numeric string to a number.
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' do both conversions. C89, however, has no function
+** to convert floating hexadecimal strings to numbers. For these
+** systems, you can leave 'lua_strx2number' undefined and Lua will
+** provide its own implementation.
+*/
 #define lua_str2number(s,p)	strtod((s), (p))
+#if defined(LUA_USE_STRTODHEX)
+#define lua_strx2number(s,p)	strtod((s), (p))
+#endif
 /*
 @@ The luai_num* macros define the primitive operations over numbers.
 /*
 @@ LUA_IEEEENDIAN is the endianness of doubles in your machine
-@@ (0 for little endian, 1 for big endian); if not defined, Lua will
+** (0 for little endian, 1 for big endian); if not defined, Lua will
-@@ check it dynamically.
+** check it dynamically.
 */
 /* check for known architectures */
-#if defined(__i386__) || defined(__i386) || defined(i386) || \
+#if defined(__i386__) || defined(__i386) || defined(__X86__) || \
     defined (__x86_64)
 #define LUA_IEEEENDIAN	0
 #elif defined(__POWERPC__) || defined(__ppc__)
 /* }================================================================== */
+/*
+@@ LUA_NANTRICKLE/LUA_NANTRICKBE controls the use of a trick to pack all
+** types into a single double value, using NaN values to represent
+** non-number values. The trick only works on 32-bit machines (ints and
+** pointers are 32-bit values) with numbers represented as IEEE 754-2008
+** doubles with conventional endianess (12345678 or 87654321), in CPUs
+** that do not produce signaling NaN values (all NaNs are quiet).
+*/
+#if defined(LUA_CORE)		/* { */
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)	/* { */
+/* little-endian architectures that satisfy those conditions */
+#if defined(__i386__) || defined(__i386) || defined(__X86__)
+#define LUA_NANTRICKLE
+#endif
+#endif							/* } */
+#endif			/* } */
 /* =================================================================== */

src/lualib.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lualib.h,v 1.41 2010/10/25 14:32:36 roberto Exp $	2	** $Id: lualib.h,v 1.42 2011/05/25 14:12:28 roberto Exp $
3	** Lua standard libraries	3	** Lua standard libraries
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -50,7 +50,7 @@ LUALIB_API void (luaL_openlibs) (lua_State *L); · 44 unmodified lines
50		50
51		51
52		52
53	#ifndef lua_assert	53	#if !defined(lua_assert)
54	#define lua_assert(x) ((void)0)	54	#define lua_assert(x) ((void)0)
55	#endif	55	#endif
56		56

src/lundump.c+30−23

 /*
-** $Id: lundump.c,v 1.68 2010/10/26 00:23:46 lhf Exp $
+** $Id: lundump.c,v 1.69 2011/05/06 13:35:17 lhf Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #define LoadVar(S,x)		LoadMem(S,&x,1,sizeof(x))
 #define LoadVector(S,b,n,size)	LoadMem(S,b,n,size)
+#if !defined(luai_verifycode)
+#define luai_verifycode(L,b,f)	(f)
+#endif
 static void LoadBlock(LoadState* S, void* b, size_t size)
 {
  if (luaZ_read(S->Z,b,size)!=0) error(S,"corrupted");
 {
  int x;
  LoadVar(S,x);
+ if (x<0) error(S,"corrupted");
  return x;
 }
  else
  {
   char* s=luaZ_openspace(S->L,S->b,size);
-  LoadBlock(S,s,size);
+  LoadBlock(S,s,size*sizeof(char));
   return luaS_newlstr(S->L,s,size-1);		/* remove trailing '\0' */
  }
 }
 /* the code below must be consistent with the code in luaU_header */
 #define N0	LUAC_HEADERSIZE
-#define N1	(sizeof(LUA_SIGNATURE)-1)
+#define N1	(sizeof(LUA_SIGNATURE)-sizeof(char))
 #define N2	N1+2
 #define N3	N2+6
 static void LoadHeader(LoadState* S)
 {
- char h[LUAC_HEADERSIZE];
+ lu_byte h[LUAC_HEADERSIZE];
- char s[LUAC_HEADERSIZE];
+ lu_byte s[LUAC_HEADERSIZE];
  luaU_header(h);
- LoadBlock(S,s,LUAC_HEADERSIZE);
+ memcpy(s,h,sizeof(char));			/* first char already read */
+ LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
  if (memcmp(h,s,N0)==0) return;
  if (memcmp(h,s,N1)!=0) error(S,"not a");
  if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
  S.Z=Z;
  S.b=buff;
  LoadHeader(&S);
- return LoadFunction(&S);
+ return luai_verifycode(L,buff,LoadFunction(&S));
 }
-/* data to catch conversion errors */
+#define MYINT(s)	(s[0]-'0')
-#define TAIL	"\x19\x93\r\n\x1a\n"
+#define VERSION		MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)
+#define FORMAT		0		/* this is the official format */
 /*
 * make header for precompiled chunks
-* if you make any changes in the code below or in LUA_SIGNATURE in lua.h,
+* if you change the code below be sure to update LoadHeader and FORMAT above
-* be sure to update LoadHeader above and LUAC_HEADERSIZE in lundump.h
+* and LUAC_HEADERSIZE in lundump.h
 */
-void luaU_header (char* h)
+void luaU_header (lu_byte* h)
 {
  int x=1;
- memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
+ memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char));
- h+=sizeof(LUA_SIGNATURE)-1;
+ h+=sizeof(LUA_SIGNATURE)-sizeof(char);
- *h++=(char)0x52;				/* Lua 5.2 */
+ *h++=cast_byte(VERSION);
- *h++=(char)0;					/* the official format */
+ *h++=cast_byte(FORMAT);
- *h++=(char)*(char*)&x;				/* endianness */
+ *h++=cast_byte(*(char*)&x);			/* endianness */
- *h++=(char)sizeof(int);
+ *h++=cast_byte(sizeof(int));
- *h++=(char)sizeof(size_t);
+ *h++=cast_byte(sizeof(size_t));
- *h++=(char)sizeof(Instruction);
+ *h++=cast_byte(sizeof(Instruction));
- *h++=(char)sizeof(lua_Number);
+ *h++=cast_byte(sizeof(lua_Number));
- *h++=(char)(((lua_Number)0.5)==0);		/* is lua_Number integral? */
+ *h++=cast_byte(((lua_Number)0.5)==0);		/* is lua_Number integral? */
- memcpy(h,TAIL,sizeof(TAIL)-1);
+ memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char));
 }

src/lundump.h+7−4

 /*
-** $Id: lundump.h,v 1.43 2010/10/26 00:23:46 lhf Exp $
+** $Id: lundump.h,v 1.44 2011/05/06 13:35:17 lhf Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
 /* make header; from lundump.c */
-LUAI_FUNC void luaU_header (char* h);
+LUAI_FUNC void luaU_header (lu_byte* h);
 /* dump one chunk; from ldump.c */
 LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
-/* size of header of binary files */
+/* data to catch conversion errors */
-#define LUAC_HEADERSIZE		18
+#define LUAC_TAIL		"\x19\x93\r\n\x1a\n"
+/* size in bytes of header of binary files */
+#define LUAC_HEADERSIZE		(sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char))
 #endif

src/lvm.c+97−53

 /*
-** $Id: lvm.c,v 2.125 2010/10/29 17:52:46 roberto Exp $
+** $Id: lvm.c,v 2.141 2011/06/09 18:24:22 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
   lua_Number num;
   if (ttisnumber(obj)) return obj;
-  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
+  if (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, &num)) {
     setnvalue(n, num);
     return n;
   }
     luaD_hook(L, LUA_HOOKCOUNT, -1);
   }
   if (mask & LUA_MASKLINE) {
-    Proto *p = ci_func(ci)->l.p;
+    Proto *p = ci_func(ci)->p;
     int npc = pcRel(ci->u.l.savedpc, p);
     int newline = getfuncline(p, npc);
     if (npc == 0 ||  /* call linehook when enter a new function, */
   if (ttisnil(tm))
     tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
   if (ttisnil(tm)) return 0;
-  if (event == TM_UNM) p2 = luaO_nilobject;
   callTM(L, tm, p1, p2, res, 1);
   return 1;
 }
   if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
   tm2 = fasttm(L, mt2, event);
   if (tm2 == NULL) return NULL;  /* no metamethod */
-  if (luaO_rawequalObj(tm1, tm2))  /* same metamethods? */
+  if (luaV_rawequalobj(tm1, tm2))  /* same metamethods? */
     return tm1;
   return NULL;
 }
 }
-int luaV_equalval_ (lua_State *L, const TValue *t1, const TValue *t2) {
+/*
+** equality of Lua values. L == NULL means raw equality (no metamethods)
+*/
+int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) {
   const TValue *tm;
-  lua_assert(ttype(t1) == ttype(t2));
+  lua_assert(ttisequal(t1, t2));
   switch (ttype(t1)) {
     case LUA_TNIL: return 1;
     case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
     case LUA_TSTRING: return eqstr(rawtsvalue(t1), rawtsvalue(t2));
     case LUA_TUSERDATA: {
       if (uvalue(t1) == uvalue(t2)) return 1;
+      else if (L == NULL) return 0;
       tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ);
       break;  /* will try TM */
     }
     case LUA_TTABLE: {
       if (hvalue(t1) == hvalue(t2)) return 1;
+      else if (L == NULL) return 0;
       tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
       break;  /* will try TM */
     }
-    default: return gcvalue(t1) == gcvalue(t2);
+    default:
+      lua_assert(iscollectable(t1));
+      return gcvalue(t1) == gcvalue(t2);
   }
   if (tm == NULL) return 0;  /* no TM? */
   callTM(L, tm, t1, t2, L->top, 1);  /* call TM */
       char *buffer;
       int i;
       /* collect total length */
-      for (n = 1; n < total && tostring(L, top-n-1); n++) {
+      for (i = 1; i < total && tostring(L, top-i-1); i++) {
-        size_t l = tsvalue(top-n-1)->len;
+        size_t l = tsvalue(top-i-1)->len;
-        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
+        if (l >= (MAX_SIZET/sizeof(char)) - tl)
+          luaG_runerror(L, "string length overflow");
         tl += l;
       }
       buffer = luaZ_openspace(L, &G(L)->buff, tl);
       tl = 0;
-      for (i=n; i>0; i--) {  /* concat all strings */
+      n = i;
+      do {  /* concat all strings */
         size_t l = tsvalue(top-i)->len;
-        memcpy(buffer+tl, svalue(top-i), l);
+        memcpy(buffer+tl, svalue(top-i), l * sizeof(char));
         tl += l;
-      }
+      } while (--i > 0);
       setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
     }
     total -= n-1;  /* got 'n' strings to create 1 new */
 void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
   const TValue *tm;
-  switch (ttype(rb)) {
+  switch (ttypenv(rb)) {
     case LUA_TTABLE: {
       Table *h = hvalue(rb);
       tm = fasttm(L, h->metatable, TM_LEN);
       break;
     }
   }
-  callTM(L, tm, rb, luaO_nilobject, ra, 1);
+  callTM(L, tm, rb, rb, ra, 1);
 }
   Upvaldesc *uv = p->upvalues;
   int i;
   Closure *ncl = luaF_newLclosure(L, p);
-  setclvalue(L, ra, ncl);  /* anchor new closure in stack */
+  setclLvalue(L, ra, ncl);  /* anchor new closure in stack */
   for (i = 0; i < nup; i++) {  /* fill in its upvalues */
     if (uv[i].instack)  /* upvalue refers to local variable? */
       ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx);
 ** some macros for common tasks in `luaV_execute'
 */
+#if !defined luai_runtimecheck
+#define luai_runtimecheck(L, c)		/* void */
+#endif
 #define RA(i)	(base+GETARG_A(i))
 /* to be used after possible stack reallocation */
 #define RB(i)	check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
   (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++)))
-#define dojump(i)	(ci->u.l.savedpc += (i))
+/* execute a jump instruction */
+#define dojump(ci,i,e) \
+  { int a = GETARG_A(i); \
+    if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \
+    ci->u.l.savedpc += GETARG_sBx(i) + e; }
+/* for test instructions, execute the jump instruction that follows it */
+#define donextjump(ci)	{ i = *ci->u.l.savedpc; dojump(ci, i, 1); }
 #define Protect(x)	{ {x;}; base = ci->u.l.base; }
-#define checkGC(L)	Protect(luaC_checkGC(L); luai_threadyield(L);)
+#define checkGC(L,c)	Protect(luaC_condGC(L, c); luai_threadyield(L);)
 #define arith_op(op,tm) { \
   TValue *k;
   StkId base;
  newframe:  /* reentry point when frame changes (call/return) */
-  lua_assert(isLua(ci));
   lua_assert(ci == L->ci);
-  cl = &clvalue(ci->func)->l;
+  cl = clLvalue(ci->func);
   k = cl->p->k;
   base = ci->u.l.base;
   /* main loop of interpreter */
         setobjs2s(L, ra, RB(i));
       )
       vmcase(OP_LOADK,
-        TValue *rb = KBx(i);
+        TValue *rb = k + GETARG_Bx(i);
+        setobj2s(L, ra, rb);
+      )
+      vmcase(OP_LOADKX,
+        TValue *rb;
+        lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
+        rb = k + GETARG_Ax(*ci->u.l.savedpc++);
         setobj2s(L, ra, rb);
       )
       vmcase(OP_LOADBOOL,
         if (GETARG_C(i)) ci->u.l.savedpc++;  /* skip next instruction (if C) */
       )
       vmcase(OP_LOADNIL,
-        TValue *rb = RB(i);
+        int b = GETARG_B(i);
         do {
-          setnilvalue(rb--);
+          setnilvalue(ra++);
-        } while (rb >= ra);
+        } while (b--);
       )
       vmcase(OP_GETUPVAL,
         int b = GETARG_B(i);
         sethvalue(L, ra, t);
         if (b != 0 || c != 0)
           luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
-        checkGC(L);
+        checkGC(L,
+          L->top = ra + 1;  /* limit of live values */
+          luaC_step(L);
+          L->top = ci->top;  /* restore top */
+        )
       )
       vmcase(OP_SELF,
         StkId rb = RB(i);
         }
       )
       vmcase(OP_NOT,
-        int res = l_isfalse(RB(i));  /* next assignment may change this value */
+        TValue *rb = RB(i);
+        int res = l_isfalse(rb);  /* next assignment may change this value */
         setbvalue(ra, res);
       )
       vmcase(OP_LEN,
       vmcase(OP_CONCAT,
         int b = GETARG_B(i);
         int c = GETARG_C(i);
+        StkId rb;
         L->top = base + c + 1;  /* mark the end of concat operands */
-        Protect(luaV_concat(L, c-b+1); checkGC(L);)
+        Protect(luaV_concat(L, c - b + 1));
+        ra = RA(i);  /* 'luav_concat' may invoke TMs and move the stack */
+        rb = b + base;
+        setobjs2s(L, ra, rb);
+        checkGC(L,
+          L->top = (ra >= rb ? ra + 1 : rb);  /* limit of live values */
+          luaC_step(L);
+        )
         L->top = ci->top;  /* restore top */
-        setobjs2s(L, RA(i), base+b);
       )
       vmcase(OP_JMP,
-        dojump(GETARG_sBx(i));
+        dojump(ci, i, 0);
       )
       vmcase(OP_EQ,
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         Protect(
-          if (equalobj(L, rb, rc) == GETARG_A(i))
+          if (equalobj(L, rb, rc) != GETARG_A(i))
-            dojump(GETARG_sBx(*ci->u.l.savedpc));
+            ci->u.l.savedpc++;
+          else
+            donextjump(ci);
         )
-        ci->u.l.savedpc++;
       )
       vmcase(OP_LT,
         Protect(
-          if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
+          if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i))
-            dojump(GETARG_sBx(*ci->u.l.savedpc));
+            ci->u.l.savedpc++;
+          else
+            donextjump(ci);
         )
-        ci->u.l.savedpc++;
       )
       vmcase(OP_LE,
         Protect(
-          if (luaV_lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
+          if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i))
-            dojump(GETARG_sBx(*ci->u.l.savedpc));
+            ci->u.l.savedpc++;
+          else
+            donextjump(ci);
         )
-        ci->u.l.savedpc++;
       )
       vmcase(OP_TEST,
-        if (GETARG_C(i) ? !l_isfalse(ra) : l_isfalse(ra))
+        if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra))
-          dojump(GETARG_sBx(*ci->u.l.savedpc));
+            ci->u.l.savedpc++;
-        ci->u.l.savedpc++;
+          else
+          donextjump(ci);
       )
       vmcase(OP_TESTSET,
         TValue *rb = RB(i);
-        if (GETARG_C(i) ? !l_isfalse(rb) : l_isfalse(rb)) {
+        if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb))
+          ci->u.l.savedpc++;
+        else {
           setobjs2s(L, ra, rb);
-          dojump(GETARG_sBx(*ci->u.l.savedpc));
+          donextjump(ci);
         }
-        ci->u.l.savedpc++;
       )
       vmcase(OP_CALL,
         int b = GETARG_B(i);
         lua_Number limit = nvalue(ra+1);
         if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit)
                                    : luai_numle(L, limit, idx)) {
-          dojump(GETARG_sBx(i));  /* jump back */
+          ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
           setnvalue(ra, idx);  /* update internal index... */
           setnvalue(ra+3, idx);  /* ...and external index */
         }
         else if (!tonumber(pstep, ra+2))
           luaG_runerror(L, LUA_QL("for") " step must be a number");
         setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep)));
-        dojump(GETARG_sBx(i));
+        ci->u.l.savedpc += GETARG_sBx(i);
       )
       vmcase(OP_TFORCALL,
         StkId cb = ra + 3;  /* call base */
         l_tforloop:
         if (!ttisnil(ra + 1)) {  /* continue loop? */
           setobjs2s(L, ra, ra + 1);  /* save control variable */
-          dojump(GETARG_sBx(i));  /* jump back */
+           ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
         }
       )
       vmcase(OP_SETLIST,
           lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
           c = GETARG_Ax(*ci->u.l.savedpc++);
         }
+        luai_runtimecheck(L, ttistable(ra));
         h = hvalue(ra);
         last = ((c-1)*LFIELDS_PER_FLUSH) + n;
         if (last > h->sizearray)  /* needs more space? */
         }
         L->top = ci->top;  /* correct top (in case of previous open call) */
       )
-      vmcase(OP_CLOSE,
-        luaF_close(L, ra);
-      )
       vmcase(OP_CLOSURE,
         Proto *p = cl->p->p[GETARG_Bx(i)];
         Closure *ncl = getcached(p, cl->upvals, base);  /* cached closure */
         if (ncl == NULL)  /* no match? */
           pushclosure(L, p, cl->upvals, base, ra);  /* create a new one */
         else
-          setclvalue(L, ra, ncl);  /* push cashed closure */
+          setclLvalue(L, ra, ncl);  /* push cashed closure */
-        checkGC(L);
+        checkGC(L,
+          L->top = ra + 1;  /* limit of live values */
+          luaC_step(L);
+          L->top = ci->top;  /* restore top */
+        )
       )
       vmcase(OP_VARARG,
         int b = GETARG_B(i) - 1;

src/lvm.h+7−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lvm.h,v 2.14 2009/12/17 16:20:01 roberto Exp $	2	** $Id: lvm.h,v 2.17 2011/05/31 18:27:56 roberto Exp $
3	** Lua virtual machine	3	** Lua virtual machine
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -17,12 +17,15 @@ · 11 unmodified lines
17		17
18	#define tonumber(o,n) (ttisnumber(o) \|\| (((o) = luaV_tonumber(o,n)) != NULL))	18	#define tonumber(o,n) (ttisnumber(o) \|\| (((o) = luaV_tonumber(o,n)) != NULL))
19		19
20	#define equalobj(L,o1,o2) \	20	#define equalobj(L,o1,o2) (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2))
21	(ttype(o1) == ttype(o2) && luaV_equalval_(L, o1, o2))	21
		22	#define luaV_rawequalobj(t1,t2) \
		23	(ttisequal(t1,t2) && luaV_equalobj_(NULL,t1,t2))
22		24
23		25
24	/* not to called directly */	26	/* not to called directly */
25	LUAI_FUNC int luaV_equalval_ (lua_State L, const TValue t1, const TValue *t2);	27	LUAI_FUNC int luaV_equalobj_ (lua_State L, const TValue t1, const TValue *t2);
		28
26		29
27	LUAI_FUNC int luaV_lessthan (lua_State L, const TValue l, const TValue *r);	30	LUAI_FUNC int luaV_lessthan (lua_State L, const TValue l, const TValue *r);
28	LUAI_FUNC int luaV_lessequal (lua_State L, const TValue l, const TValue *r);	31	LUAI_FUNC int luaV_lessequal (lua_State L, const TValue l, const TValue *r);

src/lzio.c+12−18

 /*
-** $Id: lzio.c,v 1.31 2005/06/03 20:15:29 roberto Exp $
+** $Id: lzio.c,v 1.33 2011/02/23 13:13:10 roberto Exp $
 ** a generic input stream interface
 ** See Copyright Notice in lua.h
 */
   lua_unlock(L);
   buff = z->reader(L, z->data, &size);
   lua_lock(L);
-  if (buff == NULL || size == 0) return EOZ;
+  if (buff == NULL || size == 0)
-  z->n = size - 1;
+    return EOZ;
+  z->n = size - 1;  /* discount char being returned */
   z->p = buff;
   return char2int(*(z->p++));
 }
-int luaZ_lookahead (ZIO *z) {
-  if (z->n == 0) {
-    if (luaZ_fill(z) == EOZ)
-      return EOZ;
-    else {
-      z->n++;  /* luaZ_fill removed first byte; put back it */
-      z->p--;
-    }
-  }
-  return char2int(*z->p);
-}
 void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
   z->L = L;
   z->reader = reader;
 size_t luaZ_read (ZIO *z, void *b, size_t n) {
   while (n) {
     size_t m;
-    if (luaZ_lookahead(z) == EOZ)
+    if (z->n == 0) {  /* no bytes in buffer? */
-      return n;  /* return number of missing bytes */
+      if (luaZ_fill(z) == EOZ)  /* try to read more */
+        return n;  /* no more input; return number of missing bytes */
+      else {
+        z->n++;  /* luaZ_fill consumed first byte; put it back */
+        z->p--;
+      }
+    }
     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
     memcpy(b, z->p, m);
     z->n -= m;

src/lzio.h+2−3

 /*
-** $Id: lzio.h,v 1.22 2009/05/18 17:26:25 roberto Exp $
+** $Id: lzio.h,v 1.24 2011/02/23 13:13:10 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
 LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
                                         void *data);
 LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);	/* read next n bytes */
-LUAI_FUNC int luaZ_lookahead (ZIO *z);
 struct Zio {
   size_t n;			/* bytes still unread */
   const char *p;		/* current position in buffer */
-  lua_Reader reader;
+  lua_Reader reader;		/* reader function */
   void* data;			/* additional data */
   lua_State *L;			/* Lua state (for reader) */
 };

@@ -126,7 +126,7 @@ lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h · 125 unmodified lines
126	lbitlib.o: lbitlib.c lua.h luaconf.h lauxlib.h lualib.h	126	lbitlib.o: lbitlib.c lua.h luaconf.h lauxlib.h lualib.h
127	lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \	127	lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
128	lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \	128	lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
129	lstring.h ltable.h	129	lstring.h ltable.h lvm.h
130	lcorolib.o: lcorolib.c lua.h luaconf.h lauxlib.h lualib.h	130	lcorolib.o: lcorolib.c lua.h luaconf.h lauxlib.h lualib.h
131	lctype.o: lctype.c lctype.h lua.h luaconf.h llimits.h	131	lctype.o: lctype.c lctype.h lua.h luaconf.h llimits.h
132	ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h	132	ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
@@ -164,7 +164,7 @@ lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \ · 31 unmodified lines
164	ltm.h lzio.h lstring.h lgc.h	164	ltm.h lzio.h lstring.h lgc.h
165	lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h	165	lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
166	ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \	166	ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
167	ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h	167	ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
168	ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h	168	ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
169	ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \	169	ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
170	lmem.h lstring.h lgc.h ltable.h	170	lmem.h lstring.h lgc.h ltable.h

@@ -1,16 +1,16 @@
1	/*	1	/*
2	** $Id: linit.c,v 1.30 2010/11/12 15:48:30 roberto Exp $	2	** $Id: linit.c,v 1.32 2011/04/08 19:17:36 roberto Exp $
3	** Initialization of libraries for lua.c and other clients	3	** Initialization of libraries for lua.c and other clients
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
6		6
7		7
8	/*	8	/*
9	** If you embed Lua in your program and need to open the standard	9	** If you embed Lua in your program and need to open the standard
10	** libraries, call luaL_openlibs in your program. If you need a	10	** libraries, call luaL_openlibs in your program. If you need a
11	** different set of libraries, copy this file to your project and edit	11	** different set of libraries, copy this file to your project and edit
12	** it to suit your needs.	12	** it to suit your needs.
13	*/	13	*/
14		14
15		15
16	#define linit_c	16	#define linit_c
@@ -57,7 +57,7 @@ LUALIB_API void luaL_openlibs (lua_State *L) { · 40 unmodified lines
57	lua_pop(L, 1); /* remove lib */	57	lua_pop(L, 1); /* remove lib */
58	}	58	}
59	/* add open functions from 'preloadedlibs' into 'package.preload' table */	59	/* add open functions from 'preloadedlibs' into 'package.preload' table */
60	luaL_findtable(L, LUA_REGISTRYINDEX, "_PRELOAD");	60	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
61	for (lib = preloadedlibs; lib->func; lib++) {	61	for (lib = preloadedlibs; lib->func; lib++) {
62	lua_pushcfunction(L, lib->func);	62	lua_pushcfunction(L, lib->func);
63	lua_setfield(L, -2, lib->name);	63	lua_setfield(L, -2, lib->name);