plan9-archive/lua

README+1−1

@@ -1,5 +1,5 @@
1		1
2	This is Lua 5.3.0 (work3), released on 19 Jul 2014.	2	This is Lua 5.3.0 (alpha), released on 31 Jul 2014.
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+9−11

 <P>
 <IMG SRC="alert.png" ALIGN="absbottom">
-<EM>All details may change in the final version.</EM>
+<EM>Some details may change in the final version.</EM>
 <P>
 The reference manual is the official definition of the Lua language.
 <A HREF="#index">index</A>
 <HR>
 <SMALL>
-Copyright &copy; 2011&ndash;2014 Lua.org, PUC-Rio.
+Copyright &copy; 2014 Lua.org, PUC-Rio.
 Freely available under the terms of the
 <A HREF="http://www.lua.org/license.html">Lua license</A>.
 </SMALL>
 <TD>
 <H3>&nbsp;</H3>
 <P>
-<A HREF="manual.html#pdf-math">math</A><BR>
 <A HREF="manual.html#pdf-math.abs">math.abs</A><BR>
 <A HREF="manual.html#pdf-math.acos">math.acos</A><BR>
 <A HREF="manual.html#pdf-math.asin">math.asin</A><BR>
 <A HREF="manual.html#pdf-math.floor">math.floor</A><BR>
 <A HREF="manual.html#pdf-math.fmod">math.fmod</A><BR>
 <A HREF="manual.html#pdf-math.huge">math.huge</A><BR>
-<A HREF="manual.html#pdf-math.ifloor">math.ifloor</A><BR>
 <A HREF="manual.html#pdf-math.log">math.log</A><BR>
 <A HREF="manual.html#pdf-math.max">math.max</A><BR>
 <A HREF="manual.html#pdf-math.maxinteger">math.maxinteger</A><BR>
 <A HREF="manual.html#pdf-math.sin">math.sin</A><BR>
 <A HREF="manual.html#pdf-math.sqrt">math.sqrt</A><BR>
 <A HREF="manual.html#pdf-math.tan">math.tan</A><BR>
+<A HREF="manual.html#pdf-math.tointeger">math.tointeger</A><BR>
 <A HREF="manual.html#pdf-math.type">math.type</A><BR>
+<A HREF="manual.html#pdf-math.ult">math.ult</A><BR>
 <P>
 <A HREF="manual.html#pdf-os.clock">os.clock</A><BR>
 <P>
 <A HREF="manual.html#pdf-table.concat">table.concat</A><BR>
+<A HREF="manual.html#pdf-table.copy">table.copy</A><BR>
 <A HREF="manual.html#pdf-table.insert">table.insert</A><BR>
 <A HREF="manual.html#pdf-table.pack">table.pack</A><BR>
 <A HREF="manual.html#pdf-table.remove">table.remove</A><BR>
 <P>
 <A HREF="manual.html#lua_Alloc">lua_Alloc</A><BR>
 <A HREF="manual.html#lua_CFunction">lua_CFunction</A><BR>
+<A HREF="manual.html#lua_Ctx">lua_Ctx</A><BR>
 <A HREF="manual.html#lua_Debug">lua_Debug</A><BR>
 <A HREF="manual.html#lua_Hook">lua_Hook</A><BR>
 <A HREF="manual.html#lua_Integer">lua_Integer</A><BR>
 <A HREF="manual.html#lua_error">lua_error</A><BR>
 <A HREF="manual.html#lua_gc">lua_gc</A><BR>
 <A HREF="manual.html#lua_getallocf">lua_getallocf</A><BR>
+<A HREF="manual.html#lua_getextraspace">lua_getextraspace</A><BR>
 <A HREF="manual.html#lua_getfield">lua_getfield</A><BR>
 <A HREF="manual.html#lua_getglobal">lua_getglobal</A><BR>
 <A HREF="manual.html#lua_gethook">lua_gethook</A><BR>
 <A HREF="manual.html#lua_pushnumber">lua_pushnumber</A><BR>
 <A HREF="manual.html#lua_pushstring">lua_pushstring</A><BR>
 <A HREF="manual.html#lua_pushthread">lua_pushthread</A><BR>
-<A HREF="manual.html#lua_pushunsigned">lua_pushunsigned</A><BR>
 <A HREF="manual.html#lua_pushvalue">lua_pushvalue</A><BR>
 <A HREF="manual.html#lua_pushvfstring">lua_pushvfstring</A><BR>
 <A HREF="manual.html#lua_rawequal">lua_rawequal</A><BR>
 <A HREF="manual.html#lua_topointer">lua_topointer</A><BR>
 <A HREF="manual.html#lua_tostring">lua_tostring</A><BR>
 <A HREF="manual.html#lua_tothread">lua_tothread</A><BR>
-<A HREF="manual.html#lua_tounsigned">lua_tounsigned</A><BR>
-<A HREF="manual.html#lua_tounsignedx">lua_tounsignedx</A><BR>
 <A HREF="manual.html#lua_touserdata">lua_touserdata</A><BR>
 <A HREF="manual.html#lua_type">lua_type</A><BR>
 <A HREF="manual.html#lua_typename">lua_typename</A><BR>
 <A HREF="manual.html#luaL_checkstring">luaL_checkstring</A><BR>
 <A HREF="manual.html#luaL_checktype">luaL_checktype</A><BR>
 <A HREF="manual.html#luaL_checkudata">luaL_checkudata</A><BR>
-<A HREF="manual.html#luaL_checkunsigned">luaL_checkunsigned</A><BR>
 <A HREF="manual.html#luaL_checkversion">luaL_checkversion</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_optlstring">luaL_optlstring</A><BR>
 <A HREF="manual.html#luaL_optnumber">luaL_optnumber</A><BR>
 <A HREF="manual.html#luaL_optstring">luaL_optstring</A><BR>
-<A HREF="manual.html#luaL_optunsigned">luaL_optunsigned</A><BR>
 <A HREF="manual.html#luaL_prepbuffer">luaL_prepbuffer</A><BR>
 <A HREF="manual.html#luaL_prepbuffsize">luaL_prepbuffsize</A><BR>
 <A HREF="manual.html#luaL_pushresult">luaL_pushresult</A><BR>
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Thu Jun 19 17:09:46 BRT 2014
+Thu Jul 31 14:04:18 BRT 2014
 </SMALL>
 <!--
-Last change: updated for Lua 5.3.0 (work3)
+Last change: updated for Lua 5.3.0 (alpha)
 -->
 </BODY>

doc/lua.css+5−2

 	color: #FF0000 ;
 }
+h1 a img {
+	vertical-align: text-bottom ;
+}
 hr {
 	border: 0 ;
 	height: 1px ;
 	border-radius: 2em ;
 	-moz-border-radius: 2em ;
 	background-image: url('images/search.png') ;
-	background-repeat: no-repeat;
+	background-repeat: no-repeat ;
 	background-position: 4px center ;
 	padding-left: 20px ;
 	height: 2em ;
 }

doc/manual.html+231−185

@@ -18,13 +18,13 @@ Lua 5.3 Reference Manual · 17 unmodified lines
18		18
19	<P>	19	<P>
20	<IMG SRC="alert.png" ALIGN="absbottom">	20	<IMG SRC="alert.png" ALIGN="absbottom">
21	<EM>All details may change in the final version.</EM>	21	<EM>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 © 2011–2014 Lua.org, PUC-Rio.	27	Copyright © 2014 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">Lua license</a>.	29	<a href="http://www.lua.org/license.html">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.121 2014/06/18 19:12:23 roberto Exp $ -->	41	<!-- $Id: manual.of,v 1.125 2014/07/31 13:58:08 roberto Exp $ -->
42		42
43		43
44		44
@@ -125,7 +125,7 @@ it usually represents the absence of a useful value. · 80 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 both	127	<em>Number</em> represents both
128	integral numbers and real (floating-point) numbers.	128	integer numbers and real (floating-point) numbers.
129	<em>String</em> represents immutable sequences of bytes.	129	<em>String</em> represents immutable sequences of bytes.
130		130
131	Lua is 8-bit clean:	131	Lua is 8-bit clean:
@@ -146,7 +146,7 @@ Standard Lua uses 64-bit integers and double-precision (64-bit) floats, · 14 unmodified lines
146	but you can also compile Lua so that it	146	but you can also compile Lua so that it
147	uses 32-bit integers and/or single-precision (32-bit) floats.	147	uses 32-bit integers and/or single-precision (32-bit) floats.
148	The option with 32 bits both for integers and floats	148	The option with 32 bits both for integers and floats
149	(what is called <em>Small Lua</em>) is particularly attractive	149	(called <em>Small Lua</em>) is particularly attractive
150	for small machines.	150	for small machines.
151		151
152		152
@@ -159,7 +159,7 @@ functions written in C · 6 unmodified lines
159	<p>	159	<p>
160	The type <em>userdata</em> is provided to allow arbitrary C data to	160	The type <em>userdata</em> is provided to allow arbitrary C data to
161	be stored in Lua variables.	161	be stored in Lua variables.
162	A userdata value is a pointer to a block of raw memory.	162	A userdata value represents a block of raw memory.
163	There are two kinds of userdata:	163	There are two kinds of userdata:
164	full userdata, where the block of memory is managed by Lua,	164	full userdata, where the block of memory is managed by Lua,
165	and light userdata, where the block of memory is managed by the host.	165	and light userdata, where the block of memory is managed by the host.
@@ -178,7 +178,7 @@ The type <em>thread</em> represents independent threads of execution · 12 unmodified lines
178	and it is used to implement coroutines (see <a href="#2.6">§2.6</a>).	178	and it is used to implement coroutines (see <a href="#2.6">§2.6</a>).
179	Do not confuse Lua threads with operating-system threads.	179	Do not confuse Lua threads with operating-system threads.
180	Lua supports coroutines on all systems,	180	Lua supports coroutines on all systems,
181	even those that do not support threads.	181	even those that do not support threads natively.
182		182
183		183
184	<p>	184	<p>
@@ -324,7 +324,9 @@ is never updated by Lua. · 139 unmodified lines
324	<p>	324	<p>
325	Because Lua is an embedded extension language,	325	Because Lua is an embedded extension language,
326	all Lua actions start from C code in the host program	326	all Lua actions start from C code in the host program
327	calling a function from the Lua library (see <a href="#lua_pcall"><code>lua_pcall</code></a>).	327	calling a function from the Lua library.
		328	(when you use Lua standalone,
		329	the <code>lua</code> application is the host program.)
328	Whenever an error occurs during	330	Whenever an error occurs during
329	the compilation or execution of a Lua chunk,	331	the compilation or execution of a Lua chunk,
330	control returns to the host,	332	control returns to the host,
@@ -1891,9 +1893,9 @@ that rounds the quotient towards minus infinite (floor). · 1560 unmodified lines
1891	In case of overflows in integer arithmetic,	1893	In case of overflows in integer arithmetic,
1892	all operations <em>wrap around</em>,	1894	all operations <em>wrap around</em>,
1893	according to the usual rules of two-complement arithmetic.	1895	according to the usual rules of two-complement arithmetic.
1894	(In other words, they return the correct result modulo <em>2<sup>64</sup></em>.)	1896	(In other words,
1895		1897	they return the unique representable integer
1896		1898	that is equal modulo <em>2<sup>64</sup></em> to the mathematical result.)
1897		1899
1898		1900
1899		1901
@@ -1921,7 +1923,7 @@ Both right and left shifts fill the vacant bits with zeros. · 21 unmodified lines
1921	Negative displacements shift to the other direction;	1923	Negative displacements shift to the other direction;
1922	displacements with absolute values equal to or higher than	1924	displacements with absolute values equal to or higher than
1923	the number of bits in an integer	1925	the number of bits in an integer
1924	result in zero (all bits are shifted out).	1926	result in zero (as all bits are shifted out).
1925		1927
1926		1928
1927		1929
@@ -1952,16 +1954,17 @@ In a conversion from integer to float, · 24 unmodified lines
1952	if the integer value has an exact representation as a float,	1954	if the integer value has an exact representation as a float,
1953	that is the result.	1955	that is the result.
1954	Otherwise,	1956	Otherwise,
1955	the conversion gets the nearest higher or lower representable value.	1957	the conversion gets the nearest higher or
		1958	the nearest lower representable value.
1956	This kind of conversion never fails.	1959	This kind of conversion never fails.
1957		1960
1958		1961
1959	<p>	1962	<p>
1960	The conversion from float to integer	1963	The conversion from float to integer
1961	first takes the floor of the float number.	1964	checks whether the float has an exact representation as an integer
1962	If that value can be represented as an integer	1965	(that is, the float has an integral value and
1963	(that is, it is in the range of integer representation),	1966	it is in the range of integer representation).
1964	that is the result.	1967	If it does, that representation is the result.
1965	Otherwise, the conversion fails.	1968	Otherwise, the conversion fails.
1966		1969
1967		1970
@@ -2005,7 +2008,7 @@ Otherwise, the values of the operands are compared. · 37 unmodified lines
2005	Strings are compared in the obvious way.	2008	Strings are compared in the obvious way.
2006	Numbers follow the usual rule for binary operations:	2009	Numbers follow the usual rule for binary operations:
2007	if both operands are integers,	2010	if both operands are integers,
2008	the are compared as integers;	2011	they are compared as integers;
2009	otherwise, they are converted to floats	2012	otherwise, they are converted to floats
2010	and compared as such.	2013	and compared as such.
2011		2014
@@ -2028,7 +2031,7 @@ by using the "eq" metamethod (see <a href="#2.4">§2.4</a>). · 16 unmodified lines
2028		2031
2029		2032
2030	<p>	2033	<p>
2031	Equality comparisons never convert strings to numbers	2034	Equality comparisons do not convert strings to numbers
2032	or vice versa.	2035	or vice versa.
2033	Thus, <code>"0"==0</code> evaluates to <b>false</b>,	2036	Thus, <code>"0"==0</code> evaluates to <b>false</b>,
2034	and <code>t[0]</code> and <code>t["0"]</code> denote different	2037	and <code>t[0]</code> and <code>t["0"]</code> denote different
@@ -2190,7 +2193,7 @@ with key <code>exp1</code> and value <code>exp2</code>. · 155 unmodified lines
2190	A field of the form <code>name = exp</code> is equivalent to	2193	A field of the form <code>name = exp</code> is equivalent to
2191	<code>["name"] = exp</code>.	2194	<code>["name"] = exp</code>.
2192	Finally, fields of the form <code>exp</code> are equivalent to	2195	Finally, fields of the form <code>exp</code> are equivalent to
2193	<code>[i] = exp</code>, where <code>i</code> are consecutive numerical integers,	2196	<code>[i] = exp</code>, where <code>i</code> are consecutive integers
2194	starting with 1.	2197	starting with 1.
2195	Fields in the other formats do not affect this counting.	2198	Fields in the other formats do not affect this counting.
2196	For example,	2199	For example,
@@ -2861,7 +2864,7 @@ the Lua code being ran by <a href="#lua_pcall"><code>lua_pcall</code></a> to yie · 664 unmodified lines
2861	First, we can rewrite our function like here:	2864	First, we can rewrite our function like here:
2862		2865
2863	<pre>	2866	<pre>
2864	int k (lua_State *L, int status, int ctx) {	2867	int k (lua_State *L, int status, lua_Ctx ctx) {
2865	... /* code 2 */	2868	... /* code 2 */
2866	}	2869	}
2867		2870
@@ -2905,6 +2908,12 @@ the status is always <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when Lu · 37 unmodified lines
2905	(For these two functions,	2908	(For these two functions,
2906	Lua will not call the continuation in case of errors,	2909	Lua will not call the continuation in case of errors,
2907	because they do not handle errors.)	2910	because they do not handle errors.)
		2911	Similarly, when using <a href="#lua_callk"><code>lua_callk</code></a>,
		2912	you should call the continuation function
		2913	with <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> as the status.
		2914	(For <a href="#lua_yieldk"><code>lua_yieldk</code></a>, there is not much point in calling
		2915	directly the continuation function,
		2916	because <a href="#lua_yieldk"><code>lua_yieldk</code></a> usually does not return.)
2908		2917
2909		2918
2910	<p>	2919	<p>
@@ -3159,7 +3168,7 @@ This is considered good programming practice. · 248 unmodified lines
3159		3168
3160	<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>	3169	<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>
3161	<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>	3170	<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
3162	<pre>void lua_callk (lua_State *L, int nargs, int nresults, int ctx,	3171	<pre>void lua_callk (lua_State *L, int nargs, int nresults, lua_Ctx ctx,
3163	lua_KFunction k);</pre>	3172	lua_KFunction k);</pre>
3164		3173
3165	<p>	3174	<p>
@@ -3307,7 +3316,7 @@ Concatenation is performed following the usual semantics of Lua · 141 unmodified lines
3307	<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>	3316	<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>
3308		3317
3309	<p>	3318	<p>
3310	Moves the element at index <code>fromidx</code>	3319	Copies the element at index <code>fromidx</code>
3311	into the valid index <code>toidx</code>	3320	into the valid index <code>toidx</code>
3312	without shifting any element	3321	without shifting any element
3313	(therefore replacing the value at that position).	3322	(therefore replacing the value at that position).
@@ -3335,6 +3344,21 @@ Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</c · 21 unmodified lines
3335		3344
3336		3345
3337		3346
		3347	<hr><h3><a name="lua_Ctx"><code>lua_Ctx</code></a></h3>
		3348	<pre>typedef ... lua_Ctx;</pre>
		3349
		3350	<p>
		3351	The type for continuation-function contexts.
		3352	It must be a numerical type.
		3353	This type is defined as <code>intptr_t</code>
		3354	when <code>intptr_t</code> is available,
		3355	so that it can store pointers too.
		3356	Otherwise, it is defined as <code>ptrdiff_t</code>.
		3357
		3358
		3359
		3360
		3361
3338	<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>	3362	<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
3339	<span class="apii">[-0, +0, <em>e</em>]</span>	3363	<span class="apii">[-0, +0, <em>e</em>]</span>
3340	<pre>int lua_dump (lua_State *L,	3364	<pre>int lua_dump (lua_State *L,
@@ -3485,6 +3509,31 @@ Returns the type of the pushed value. · 144 unmodified lines
3485		3509
3486		3510
3487		3511
		3512	<hr><h3><a name="lua_getextraspace"><code>lua_getextraspace</code></a></h3><p>
		3513	<span class="apii">[-0, +0, –]</span>
		3514	<pre>void lua_getextraspace (lua_State L);</pre>
		3515
		3516	<p>
		3517	Returns a pointer to a raw memory area associated with the
		3518	given Lua state.
		3519	The application can use this area for any purpose;
		3520	Lua does not use it for anything.
		3521
		3522
		3523	<p>
		3524	Each new thread has this area initialized with a copy
		3525	of the area of the main thread.
		3526
		3527
		3528	<p>
		3529	By default, this area has the size of a pointer to void,
		3530	but you can recompile Lua with a different size for this area.
		3531	(See <code>LUA_EXTRASPACE</code> in <code>luaconf.h</code>.)
		3532
		3533
		3534
		3535
		3536
3488	<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>	3537	<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
3489	<span class="apii">[-0, +1, <em>e</em>]</span>	3538	<span class="apii">[-0, +1, <em>e</em>]</span>
3490	<pre>int lua_getglobal (lua_State L, const char name);</pre>	3539	<pre>int lua_getglobal (lua_State L, const char name);</pre>
@@ -3502,8 +3551,9 @@ Returns the type of that value. · 11 unmodified lines
3502	<pre>int lua_getmetatable (lua_State *L, int index);</pre>	3551	<pre>int lua_getmetatable (lua_State *L, int index);</pre>
3503		3552
3504	<p>	3553	<p>
3505	Pushes onto the stack the metatable of the value at the given index.	3554	If the value at the given index has a metatable,
3506	If the value does not have a metatable,	3555	the function pushes that metatable onto the stack and returns 1.
		3556	Otherwise,
3507	the function returns 0 and pushes nothing on the stack.	3557	the function returns 0 and pushes nothing on the stack.
3508		3558
3509		3559
@@ -3588,9 +3638,9 @@ The type of integers in Lua. · 78 unmodified lines
3588	<p>	3638	<p>
3589	By default this type is <code>long long</code>	3639	By default this type is <code>long long</code>
3590	(usually a 64-bit two-complement integer),	3640	(usually a 64-bit two-complement integer),
3591	but that can be changed in <code>luaconf.h</code>	3641	but that can be changed to <code>long</code> or <code>int</code>,
3592	to <code>long</code> or <code>int</code>	3642	usually a 32-bit two-complement integer.
3593	(usually a 32-bit two-complement integer).	3643	(See <code>LUA_INT</code> in <code>luaconf.h</code>.)
3594		3644
3595		3645
3596	<p>	3646	<p>
@@ -3775,7 +3825,7 @@ and 0 otherwise. · 178 unmodified lines
3775		3825
3776		3826
3777	<hr><h3><a name="lua_KFunction"><code>lua_KFunction</code></a></h3>	3827	<hr><h3><a name="lua_KFunction"><code>lua_KFunction</code></a></h3>
3778	<pre>typedef int (lua_KFunction) (lua_State L, int status, int ctx);</pre>	3828	<pre>typedef int (lua_KFunction) (lua_State L, int status, lua_Ctx ctx);</pre>
3779		3829
3780	<p>	3830	<p>
3781	Type for continuation functions (see <a href="#4.7">§4.7</a>).	3831	Type for continuation functions (see <a href="#4.7">§4.7</a>).
@@ -3988,7 +4038,8 @@ The type of floats in Lua. · 206 unmodified lines
3988		4038
3989	<p>	4039	<p>
3990	By default this type is double,	4040	By default this type is double,
3991	but that can be changed in <code>luaconf.h</code> to a single float.	4041	but that can be changed to a single float.
		4042	(See <code>LUA_REAL</code> in <code>luaconf.h</code>.)
3992		4043
3993		4044
3994		4045
@@ -4096,7 +4147,7 @@ error while running a <code>__gc</code> metamethod. · 101 unmodified lines
4096	int nargs,	4147	int nargs,
4097	int nresults,	4148	int nresults,
4098	int errfunc,	4149	int errfunc,
4099	int ctx,	4150	lua_Ctx ctx,
4100	lua_KFunction k);</pre>	4151	lua_KFunction k);</pre>
4101		4152
4102	<p>	4153	<p>
@@ -4366,17 +4417,6 @@ Returns 1 if this thread is the main thread of its state. · 263 unmodified lines
4366		4417
4367		4418
4368		4419
4369	<hr><h3><a name="lua_pushunsigned"><code>lua_pushunsigned</code></a></h3><p>
4370	<span class="apii">[-0, +1, –]</span>
4371	<pre>void lua_pushunsigned (lua_State *L, lua_Unsigned n);</pre>
4372
4373	<p>
4374	Pushes an integer with value <code>n</code> onto the stack.
4375
4376
4377
4378
4379
4380	<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>	4420	<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p>
4381	<span class="apii">[-0, +1, –]</span>	4421	<span class="apii">[-0, +1, –]</span>
4382	<pre>void lua_pushvalue (lua_State *L, int index);</pre>	4422	<pre>void lua_pushvalue (lua_State *L, int index);</pre>
@@ -4916,9 +4956,12 @@ to a string inside the Lua state. · 533 unmodified lines
4916	This string always has a zero ('<code>\0</code>')	4956	This string always has a zero ('<code>\0</code>')
4917	after its last character (as in C),	4957	after its last character (as in C),
4918	but can contain other zeros in its body.	4958	but can contain other zeros in its body.
		4959
		4960
		4961	<p>
4919	Because Lua has garbage collection,	4962	Because Lua has garbage collection,
4920	there is no guarantee that the pointer returned by <code>lua_tolstring</code>	4963	there is no guarantee that the pointer returned by <code>lua_tolstring</code>
4921	will be valid after the corresponding value is removed from the stack.	4964	will be valid after the corresponding Lua value is removed from the stack.
4922		4965
4923		4966
4924		4967
@@ -5001,48 +5044,6 @@ otherwise, the function returns <code>NULL</code>. · 76 unmodified lines
5001		5044
5002		5045
5003		5046
5004	<hr><h3><a name="lua_tounsigned"><code>lua_tounsigned</code></a></h3><p>
5005	<span class="apii">[-0, +0, –]</span>
5006	<pre>lua_Unsigned lua_tounsigned (lua_State *L, int index);</pre>
5007
5008	<p>
5009	Equivalent to <a href="#lua_tounsignedx"><code>lua_tounsignedx</code></a> with <code>isnum</code> equal to <code>NULL</code>.
5010
5011
5012
5013
5014
5015	<hr><h3><a name="lua_tounsignedx"><code>lua_tounsignedx</code></a></h3><p>
5016	<span class="apii">[-0, +0, –]</span>
5017	<pre>lua_Unsigned lua_tounsignedx (lua_State L, int index, int isnum);</pre>
5018
5019	<p>
5020	Converts the Lua value at the given index
5021	to the unsigned integral type <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
5022	The Lua value must be an integer,
5023	or a float,
5024	or a string convertible to a number
5025	(see <a href="#3.4.3">§3.4.3</a>);
5026	otherwise, <code>lua_tounsignedx</code> returns 0.
5027
5028
5029	<p>
5030	If the number is not an integer,
5031	it is rounded towards minus infinite (floor).
5032	If the result is outside the range of representable values,
5033	it is normalized to the module of its division by
5034	one more than the maximum representable value.
5035
5036
5037	<p>
5038	If <code>isnum</code> is not <code>NULL</code>,
5039	its referent is assigned a boolean value that
5040	indicates whether the operation succeeded.
5041
5042
5043
5044
5045
5046	<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>	5047	<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p>
5047	<span class="apii">[-0, +0, –]</span>	5048	<span class="apii">[-0, +0, –]</span>
5048	<pre>void lua_touserdata (lua_State L, int index);</pre>	5049	<pre>void lua_touserdata (lua_State L, int index);</pre>
@@ -5101,11 +5102,6 @@ which must be one the values returned by <a href="#lua_type"><code>lua_type</cod · 52 unmodified lines
5101	The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>.	5102	The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>.
5102		5103
5103		5104
5104	<p>
5105	Lua also defines the constant <a name="pdf-LUA_MAXUNSIGNED"><code>LUA_MAXUNSIGNED</code></a>,
5106	with the maximum value that fits in this type.
5107
5108
5109		5105
5110		5106
5111		5107
@@ -5178,14 +5174,14 @@ and pushes them onto the stack <code>to</code>. · 66 unmodified lines
5178		5174
5179		5175
5180	<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>	5176	<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p>
5181	<span class="apii">[-?, +?, –]</span>	5177	<span class="apii">[-?, +?, <em>e</em>]</span>
5182	<pre>int lua_yield (lua_State *L, int nresults);</pre>	5178	<pre>int lua_yield (lua_State *L, int nresults);</pre>
5183		5179
5184	<p>	5180	<p>
5185	This function is equivalent to <a href="#lua_yieldk"><code>lua_yieldk</code></a>,	5181	This function is equivalent to <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
5186	but it has no continuation (see <a href="#4.7">§4.7</a>).	5182	but it has no continuation (see <a href="#4.7">§4.7</a>).
5187	Therefore, when the thread resumes,	5183	Therefore, when the thread resumes,
5188	it returns to the function that called	5184	it continues the function that called
5189	the function calling <code>lua_yield</code>.	5185	the function calling <code>lua_yield</code>.
5190		5186
5191		5187
@@ -5193,21 +5189,15 @@ the function calling <code>lua_yield</code>. · 1 unmodified line
5193		5189
5194		5190
5195	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>	5191	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>
5196	<span class="apii">[-?, +?, –]</span>	5192	<span class="apii">[-?, +?, <em>e</em>]</span>
5197	<pre>int lua_yieldk (lua_State *L, int nresults, int ctx, lua_KFunction k);</pre>	5193	<pre>int lua_yieldk (lua_State *L, int nresults, lua_Ctx ctx, lua_KFunction k);</pre>
5198		5194
5199	<p>	5195	<p>
5200	Yields a coroutine.	5196	Yields a coroutine (thread).
5201		5197
5202		5198
5203	<p>	5199	<p>
5204	This function should only be called as the	5200	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
5205	return expression of a C function, as follows:
5206
5207	<pre>
5208	return lua_yieldk (L, n, ctx, k);
5209	</pre><p>
5210	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,
5211	the running coroutine suspends its execution,	5201	the running coroutine suspends its execution,
5212	and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.	5202	and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
5213	The parameter <code>nresults</code> is the number of values from the stack	5203	The parameter <code>nresults</code> is the number of values from the stack
@@ -5227,6 +5217,29 @@ the continuation function receives the value <code>ctx</code> · 13 unmodified lines
5227	that was passed to <a href="#lua_yieldk"><code>lua_yieldk</code></a>.	5217	that was passed to <a href="#lua_yieldk"><code>lua_yieldk</code></a>.
5228		5218
5229		5219
		5220	<p>
		5221	Usually, this function does not return;
		5222	when the coroutine eventually resumes,
		5223	it continues executing the continuation function.
		5224	However, there is one special case,
		5225	which is when this function is called
		5226	from inside a line hook (see <a href="#4.9">§4.9</a>).
		5227	In that case, <code>lua_yieldk</code> should be called with no continuation
		5228	(probably in the form of <a href="#lua_yield"><code>lua_yield</code></a>),
		5229	and the hook should return immediately after the call.
		5230	Lua will yield and,
		5231	when the coroutine resumes again,
		5232	it will continue the normal execution
		5233	of the (Lua) function that triggered the hook.
		5234
		5235
		5236	<p>
		5237	This function can raise an error if it is called from a thread
		5238	with a pending C call with no continuation function,
		5239	or it is called from a thread that is not running inside a resume
		5240	(e.g., the main thread).
		5241
		5242
5230		5243
5231		5244
5232		5245
@@ -6196,18 +6209,6 @@ returns the userdata address (see <a href="#lua_touserdata"><code>lua_touserdata · 963 unmodified lines
6196		6209
6197		6210
6198		6211
6199	<hr><h3><a name="luaL_checkunsigned"><code>luaL_checkunsigned</code></a></h3><p>
6200	<span class="apii">[-0, +0, <em>v</em>]</span>
6201	<pre>lua_Unsigned luaL_checkunsigned (lua_State *L, int arg);</pre>
6202
6203	<p>
6204	Checks whether the function argument <code>arg</code> is a number
6205	and returns this number converted to a <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
6206
6207
6208
6209
6210
6211	<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>	6212	<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p>
6212	<span class="apii">[-0, +0, –]</span>	6213	<span class="apii">[-0, +0, –]</span>
6213	<pre>void luaL_checkversion (lua_State *L);</pre>	6214	<pre>void luaL_checkversion (lua_State *L);</pre>
@@ -6682,23 +6683,6 @@ Otherwise, raises an error. · 468 unmodified lines
6682		6683
6683		6684
6684		6685
6685	<hr><h3><a name="luaL_optunsigned"><code>luaL_optunsigned</code></a></h3><p>
6686	<span class="apii">[-0, +0, <em>v</em>]</span>
6687	<pre>lua_Unsigned luaL_optunsigned (lua_State *L,
6688	int arg,
6689	lua_Unsigned u);</pre>
6690
6691	<p>
6692	If the function argument <code>arg</code> is a number,
6693	returns this number converted to a <a href="#lua_Unsigned"><code>lua_Unsigned</code></a>.
6694	If this argument is absent or is <b>nil</b>,
6695	returns <code>u</code>.
6696	Otherwise, raises an error.
6697
6698
6699
6700
6701
6702	<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>	6686	<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p>
6703	<span class="apii">[-?, +?, <em>e</em>]</span>	6687	<span class="apii">[-?, +?, <em>e</em>]</span>
6704	<pre>char luaL_prepbuffer (luaL_Buffer B);</pre>	6688	<pre>char luaL_prepbuffer (luaL_Buffer B);</pre>
@@ -6803,18 +6787,19 @@ in which both <code>name</code> and <code>func</code> are <code>NULL</code>. · 98 unmodified lines
6803	lua_CFunction openf, int glb);</pre>	6787	lua_CFunction openf, int glb);</pre>
6804		6788
6805	<p>	6789	<p>
6806	Calls function <code>openf</code> with string <code>modname</code> as an argument	6790	If <code>modname</code> is not already present in <a href="#pdf-package.loaded"><code>package.loaded</code></a>,
		6791	calls function <code>openf</code> with string <code>modname</code> as an argument
6807	and sets the call result in <code>package.loaded[modname]</code>,	6792	and sets the call result in <code>package.loaded[modname]</code>,
6808	as if that function has been called through <a href="#pdf-require"><code>require</code></a>.	6793	as if that function has been called through <a href="#pdf-require"><code>require</code></a>.
6809		6794
6810		6795
6811	<p>	6796	<p>
6812	If <code>glb</code> is true,	6797	If <code>glb</code> is true,
6813	also stores the result into global <code>modname</code>.	6798	also stores the module into global <code>modname</code>.
6814		6799
6815		6800
6816	<p>	6801	<p>
6817	Leaves a copy of that result on the stack.	6802	Leaves a copy of the module on the stack.
6818		6803
6819		6804
6820		6805
@@ -7218,21 +7203,19 @@ Otherwise, returns the metatable of the given object. · 397 unmodified lines
7218		7203
7219		7204
7220	<p>	7205	<p>
7221	If <code>t</code> has a metamethod <code>__ipairs</code>,	7206	Returns three values (an iterator function, the table <code>t</code>, and 0)
7222	calls it with <code>t</code> as argument and returns the first three
7223	results from the call.
7224
7225
7226	<p>
7227	Otherwise,
7228	returns three values: an iterator function, the table <code>t</code>, and 0,
7229	so that the construction	7207	so that the construction
7230		7208
7231	<pre>	7209	<pre>
7232	for i,v in ipairs(t) do <em>body</em> end	7210	for i,v in ipairs(t) do <em>body</em> end
7233	</pre><p>	7211	</pre><p>
7234	will iterate over the pairs (<code>1,t[1]</code>), (<code>2,t[2]</code>), ...,	7212	will iterate over the pairs
7235	up to the first integer key absent from the table.	7213	(<code>1,t[1]</code>), (<code>2,t[2]</code>), ..., (<code>#t,t[#t]</code>).
		7214
		7215
		7216	<p>
		7217	The table should be a proper sequence
		7218	or have a <code>__len</code> metamethod (see <a href="#3.4.7">§3.4.7</a>).
7236		7219
7237		7220
7238		7221
@@ -7973,9 +7956,9 @@ The name of this C function is the string "<code>luaopen_</code>" · 734 unmodified lines
7973	concatenated with a copy of the module name where each dot	7956	concatenated with a copy of the module name where each dot
7974	is replaced by an underscore.	7957	is replaced by an underscore.
7975	Moreover, if the module name has a hyphen,	7958	Moreover, if the module name has a hyphen,
7976	its prefix up to (and including) the first hyphen is removed.	7959	its sufix after (and including) the first hyphen is removed.
7977	For instance, if the module name is <code>a.v1-b.c</code>,	7960	For instance, if the module name is <code>a.b.c-v2.1</code>,
7978	the function name will be <code>luaopen_b_c</code>.	7961	the function name will be <code>luaopen_a_b_c</code>.
7979		7962
7980		7963
7981	<p>	7964	<p>
@@ -8138,6 +8121,8 @@ This function may not work correctly in architectures · 156 unmodified lines
8138	with mixed endian.	8121	with mixed endian.
8139		8122
8140		8123
		8124
		8125
8141	<p>	8126	<p>
8142	<hr><h3><a name="pdf-string.dumpint"><code>string.dumpint (n [, size [, endianness]])</code></a></h3>	8127	<hr><h3><a name="pdf-string.dumpint"><code>string.dumpint (n [, size [, endianness]])</code></a></h3>
8143	Returns a string with the two-complement representation of integer <code>n</code>,	8128	Returns a string with the two-complement representation of integer <code>n</code>,
@@ -8165,7 +8150,7 @@ that do not use a two-complement representation for integers. · 21 unmodified lines
8165		8150
8166	<p>	8151	<p>
8167	Looks for the first match of	8152	Looks for the first match of
8168	<code>pattern</code> in the string <code>s</code>.	8153	<code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) in the string <code>s</code>.
8169	If it finds a match, then <code>find</code> returns the indices of <code>s</code>	8154	If it finds a match, then <code>find</code> returns the indices of <code>s</code>
8170	where this occurrence starts and ends;	8155	where this occurrence starts and ends;
8171	otherwise, it returns <b>nil</b>.	8156	otherwise, it returns <b>nil</b>.
@@ -8235,7 +8220,8 @@ it is converted to one following the same rules of <a href="#pdf-tostring"><code · 63 unmodified lines
8235	<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>	8220	<hr><h3><a name="pdf-string.gmatch"><code>string.gmatch (s, pattern)</code></a></h3>
8236	Returns an iterator function that,	8221	Returns an iterator function that,
8237	each time it is called,	8222	each time it is called,
8238	returns the next captures from <code>pattern</code> over the string <code>s</code>.	8223	returns the next captures from <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>)
		8224	over the string <code>s</code>.
8239	If <code>pattern</code> specifies no captures,	8225	If <code>pattern</code> specifies no captures,
8240	then the whole match is produced in each call.	8226	then the whole match is produced in each call.
8241		8227
@@ -8273,7 +8259,7 @@ work as an anchor, as this would prevent the iteration. · 31 unmodified lines
8273	<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>	8259	<hr><h3><a name="pdf-string.gsub"><code>string.gsub (s, pattern, repl [, n])</code></a></h3>
8274	Returns a copy of <code>s</code>	8260	Returns a copy of <code>s</code>
8275	in which all (or the first <code>n</code>, if given)	8261	in which all (or the first <code>n</code>, if given)
8276	occurrences of the <code>pattern</code> have been	8262	occurrences of the <code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) have been
8277	replaced by a replacement string specified by <code>repl</code>,	8263	replaced by a replacement string specified by <code>repl</code>,
8278	which can be a string, a table, or a function.	8264	which can be a string, a table, or a function.
8279	<code>gsub</code> also returns, as its second value,	8265	<code>gsub</code> also returns, as its second value,
@@ -8368,7 +8354,7 @@ The definition of what an uppercase letter is depends on the current locale. · 88 unmodified lines
8368	<p>	8354	<p>
8369	<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>	8355	<hr><h3><a name="pdf-string.match"><code>string.match (s, pattern [, init])</code></a></h3>
8370	Looks for the first <em>match</em> of	8356	Looks for the first <em>match</em> of
8371	<code>pattern</code> in the string <code>s</code>.	8357	<code>pattern</code> (see <a href="#6.4.1">§6.4.1</a>) in the string <code>s</code>.
8372	If it finds one, then <code>match</code> returns	8358	If it finds one, then <code>match</code> returns
8373	the captures from the pattern;	8359	the captures from the pattern;
8374	otherwise it returns <b>nil</b>.	8360	otherwise it returns <b>nil</b>.
@@ -8456,8 +8442,21 @@ The definition of what a lowercase letter is depends on the current locale. · 81 unmodified lines
8456		8442
8457		8443
8458		8444
		8445
		8446
8459	<h3>6.4.1 – <a name="6.4.1">Patterns</a></h3>	8447	<h3>6.4.1 – <a name="6.4.1">Patterns</a></h3>
8460		8448
		8449	<p>
		8450	Patterns in Lua are described by regular strings,
		8451	which are interpreted as patterns by the pattern-matching functions
		8452	<a href="#pdf-string.find"><code>string.find</code></a>,
		8453	<a href="#pdf-string.gmatch"><code>string.gmatch</code></a>,
		8454	<a href="#pdf-string.gsub"><code>string.gsub</code></a>,
		8455	and <a href="#pdf-string.match"><code>string.match</code></a>.
		8456	This section describes the syntax and the meaning
		8457	(that is, what they match) of these strings.
		8458
		8459
8461		8460
8462	<h4>Character Class:</h4><p>	8461	<h4>Character Class:</h4><p>
8463	A <em>character class</em> is used to represent a set of characters.	8462	A <em>character class</em> is used to represent a set of characters.
@@ -8649,8 +8648,6 @@ string <code>"flaaap"</code>, there will be two captures: 3 and 5. · 185 unmodified lines
8649		8648
8650		8649
8651		8650
8652
8653
8654	<h2>6.5 – <a name="6.5">UTF-8 Support</a></h2>	8651	<h2>6.5 – <a name="6.5">UTF-8 Support</a></h2>
8655		8652
8656	<p>	8653	<p>
@@ -8774,11 +8771,6 @@ All functions ignore non-numeric keys · 117 unmodified lines
8774	in tables given as arguments.	8771	in tables given as arguments.
8775		8772
8776		8773
8777	<p>
8778	For performance reasons,
8779	all table accesses (get/set) performed by these functions are raw.
8780
8781
8782	<p>	8774	<p>
8783	<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>	8775	<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
8784		8776
@@ -8794,6 +8786,22 @@ If <code>i</code> is greater than <code>j</code>, returns the empty string. · 9 unmodified lines
8794		8786
8795		8787
8796		8788
		8789	<p>
		8790	<hr><h3><a name="pdf-table.copy"><code>table.copy (a1, f, e, [a2,] t)</code></a></h3>
		8791
		8792
		8793	<p>
		8794	Copies elements from table <code>a1</code> to table <code>a2</code>.
		8795	This function performs the equivalent to the following
		8796	multiple assignment:
		8797	<code>a2[t],··· = a1[f],···,a1[e]</code>.
		8798	The default for <code>a2</code> is <code>a1</code>.
		8799	The destination range can overlap with the source range.
		8800	Index <code>f</code> must be positive.
		8801
		8802
		8803
		8804
8797	<p>	8805	<p>
8798	<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>	8806	<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>
8799		8807
@@ -9014,18 +9022,6 @@ a value larger than any other numerical value. · 214 unmodified lines
9014		9022
9015		9023
9016		9024
9017	<p>
9018	<hr><h3><a name="pdf-math.ifloor"><code>math.ifloor (x)</code></a></h3>
9019
9020
9021	<p>
9022	Returns the largest integer smaller than or equal to <code>x</code>.
9023	If the value does not fit in an integer,
9024	returns <b>nil</b>.
9025
9026
9027
9028
9029	<p>	9025	<p>
9030	<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>	9026	<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>
9031		9027
@@ -9171,6 +9167,18 @@ Returns the tangent of <code>x</code> (assumed to be in radians). · 139 unmodified lines
9171		9167
9172		9168
9173		9169
		9170	<p>
		9171	<hr><h3><a name="pdf-math.tointeger"><code>math.tointeger (x)</code></a></h3>
		9172
		9173
		9174	<p>
		9175	If the value <code>x</code> is convertible to an integer,
		9176	returns that integer.
		9177	Otherwise, returns <b>nil</b>.
		9178
		9179
		9180
		9181
9174	<p>	9182	<p>
9175	<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>	9183	<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>
9176		9184
@@ -9183,6 +9191,18 @@ or <b>nil</b> if <code>x</code> is not a number. · 6 unmodified lines
9183		9191
9184		9192
9185		9193
		9194	<p>
		9195	<hr><h3><a name="pdf-math.ult"><code>math.ult (m, n)</code></a></h3>
		9196
		9197
		9198	<p>
		9199	Returns a boolean,
		9200	true if integer <code>m</code> is below integer <code>n</code> when
		9201	they are compared as unsigned integers.
		9202
		9203
		9204
		9205
9186		9206
9187		9207
9188		9208
@@ -10272,8 +10292,7 @@ The options are: · 1083 unmodified lines
10272	<li><b><code>--</code>: </b> stops handling options;</li>	10292	<li><b><code>--</code>: </b> stops handling options;</li>
10273	<li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li>	10293	<li><b><code>-</code>: </b> executes <code>stdin</code> as a file and stops handling options.</li>
10274	</ul><p>	10294	</ul><p>
10275	After handling its options, <code>lua</code> runs the given <em>script</em>,	10295	After handling its options, <code>lua</code> runs the given <em>script</em>.
10276	passing to it the given <em>args</em> as string arguments.
10277	When called without arguments,	10296	When called without arguments,
10278	<code>lua</code> behaves as <code>lua -v -i</code>	10297	<code>lua</code> behaves as <code>lua -v -i</code>
10279	when the standard input (<code>stdin</code>) is a terminal,	10298	when the standard input (<code>stdin</code>) is a terminal,
@@ -10283,7 +10302,7 @@ and as <code>lua -</code> otherwise. · 3 unmodified lines
10283	<p>	10302	<p>
10284	When called without option <code>-E</code>,	10303	When called without option <code>-E</code>,
10285	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_3"><code>LUA_INIT_5_3</code></a>	10304	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_3"><code>LUA_INIT_5_3</code></a>
10286	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if it is not defined)	10305	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if the versioned name is not defined)
10287	before running any argument.	10306	before running any argument.
10288	If the variable content has the format <code>@<em>filename</em></code>,	10307	If the variable content has the format <code>@<em>filename</em></code>,
10289	then <code>lua</code> executes the file.	10308	then <code>lua</code> executes the file.
@@ -10343,6 +10362,11 @@ For instance, the call · 53 unmodified lines
10343	$ lua -e "print(arg[1])"	10362	$ lua -e "print(arg[1])"
10344	</pre><p>	10363	</pre><p>
10345	will print "<code>-e</code>".	10364	will print "<code>-e</code>".
		10365	If there is a script,
		10366	the script is called with parameters
		10367	<code>arg[1]</code>, ···, <code>arg[#arg]</code>.
		10368	(Like all chunks in Lua,
		10369	the script is compiled as a vararg function.)
10346		10370
10347		10371
10348	<p>	10372	<p>
@@ -10417,7 +10441,7 @@ do not imply source-code changes in a program, · 68 unmodified lines
10417	such as the numeric values for constants	10441	such as the numeric values for constants
10418	or the implementation of functions as macros.	10442	or the implementation of functions as macros.
10419	Therefore,	10443	Therefore,
10420	you should never assume that binaries are compatible between	10444	you should not assume that binaries are compatible between
10421	different Lua versions.	10445	different Lua versions.
10422	Always recompile clients of the Lua API when	10446	Always recompile clients of the Lua API when
10423	using a new version.	10447	using a new version.
@@ -10426,7 +10450,7 @@ using a new version. · 2 unmodified lines
10426	<p>	10450	<p>
10427	Similarly, Lua versions can always change the internal representation	10451	Similarly, Lua versions can always change the internal representation
10428	of precompiled chunks;	10452	of precompiled chunks;
10429	precompiled chunks are never compatible between different Lua versions.	10453	precompiled chunks are not compatible between different Lua versions.
10430		10454
10431		10455
10432	<p>	10456	<p>
@@ -10458,12 +10482,6 @@ it is not a general guideline for good programming. · 25 unmodified lines
10458	For good programming,	10482	For good programming,
10459	use floats where you need floats	10483	use floats where you need floats
10460	and integers where you need integers.)	10484	and integers where you need integers.)
10461
10462
10463	<p>
10464	Although not formally an incompatibility,
10465	the proper differentiation between floats and integers
10466	have an impact on performance.
10467	</li>	10485	</li>
10468		10486
10469	<li>	10487	<li>
@@ -10502,6 +10520,16 @@ better yet, to replace its functions with appropriate bitwise operations. · 32 unmodified lines
10502	while the bitwise operators in Standard Lua operate on 64-bit integers.)	10520	while the bitwise operators in Standard Lua operate on 64-bit integers.)
10503	</li>	10521	</li>
10504		10522
		10523	<li>
		10524	The Table library now respects metamethods
		10525	for setting and getting elements.
		10526	</li>
		10527
		10528	<li>
		10529	The <a href="#pdf-ipairs"><code>ipairs</code></a> iterator now respects metamethods and
		10530	its id{__ipairs} metamethod has been deprecated.
		10531	</li>
		10532
10505	<li>	10533	<li>
10506	Option names in <a href="#pdf-io.read"><code>io.read</code></a> do not have a starting '<code>*</code>' anymore.	10534	Option names in <a href="#pdf-io.read"><code>io.read</code></a> do not have a starting '<code>*</code>' anymore.
10507	For compatibility, Lua will continue to ignore this character.	10535	For compatibility, Lua will continue to ignore this character.
@@ -10513,12 +10541,23 @@ The following functions were deprecated in the mathematical library: · 5 unmodified lines
10513	<code>frexp</code>, and <code>ldexp</code>.	10541	<code>frexp</code>, and <code>ldexp</code>.
10514	You can replace <code>math.pow(x,y)</code> with <code>x^y</code>;	10542	You can replace <code>math.pow(x,y)</code> with <code>x^y</code>;
10515	you can replace <code>math.atan2</code> with <code>math.atan</code>,	10543	you can replace <code>math.atan2</code> with <code>math.atan</code>,
10516	which now accepts two parameters;	10544	which now accepts one or two parameters;
10517	you can replace <code>math.ldexp(x,exp)</code> with <code>x * 2.0^exp</code>.	10545	you can replace <code>math.ldexp(x,exp)</code> with <code>x * 2.0^exp</code>.
10518	For the other operations,	10546	For the other operations,
10519	the best choice is to use an external library.	10547	the best choice is to use an external library.
10520	</li>	10548	</li>
10521		10549
		10550	<li>
		10551	The searcher for C loaders used by <a href="#pdf-require"><code>require</code></a>
		10552	changed the way it handles versioned names.
		10553	Now, the version should come after the module name
		10554	(as is usual in most other tools).
		10555	For compatibility, that searcher still tries the old format
		10556	if if cannot find an open function according to the new style.
		10557	(Lua 5.2 already worked that way,
		10558	but it did not document the change.)
		10559	</li>
		10560
10522	</ul>	10561	</ul>
10523		10562
10524		10563
@@ -10541,6 +10580,13 @@ Function <a href="#lua_dump"><code>lua_dump</code></a> has an extra parameter, < · 16 unmodified lines
10541	Use 0 as the value of this parameter to get the old behavior.	10580	Use 0 as the value of this parameter to get the old behavior.
10542	</li>	10581	</li>
10543		10582
		10583	<li>
		10584	Functions to inject/project unsigned integers
		10585	(<code>lua_pushunsigned</code>, <code>lua_tounsigned</code>, etc.)
		10586	were deprecated.
		10587	Use their signed equivalents with a type cast.
		10588	</li>
		10589
10544	</ul>	10590	</ul>
10545		10591
10546		10592
@@ -10550,7 +10596,7 @@ Use 0 as the value of this parameter to get the old behavior. · 3 unmodified lines
10550		10596
10551	<p>	10597	<p>
10552	Here is the complete syntax of Lua in extended BNF.	10598	Here is the complete syntax of Lua in extended BNF.
10553	(It does not describe operator precedences.)	10599	(For operator precedences, see <a href="#3.4.8">§3.4.8</a>.)
10554		10600
10555		10601
10556		10602
@@ -10635,10 +10681,10 @@ Here is the complete syntax of Lua in extended BNF. · 78 unmodified lines
10635	<HR>	10681	<HR>
10636	<SMALL CLASS="footer">	10682	<SMALL CLASS="footer">
10637	Last update:	10683	Last update:
10638	Thu Jun 19 17:13:19 BRT 2014	10684	Thu Jul 31 14:02:14 BRT 2014
10639	</SMALL>	10685	</SMALL>
10640	<!--	10686	<!--
10641	Last change: updated for Lua 5.3.0 (work3)	10687	Last change: revised for Lua 5.3.0 (alpha)
10642	-->	10688	-->
10643		10689
10644	</body></html>	10690	</body></html>

doc/readme.html+18−16

 <HR>
 <H1>
 <A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Welcome to Lua 5.3 (work3)
+Welcome to Lua 5.3 (alpha)
 </H1>
 <P>
 <IMG SRC="alert.png" ALIGN="absbottom">
-<EM>All details may change in the final version.</EM>
+<EM>Some details may change in the final version.</EM>
 <P>
 <A HREF="#about">about</A>
 <OL>
 <LI>
 Open a terminal window and move to
-the top-level directory, which is named <TT>lua-5.3.0-work3</TT>.
+the top-level directory, which is named <TT>lua-5.3.0-alpha</TT>.
 The <TT>Makefile</TT> there controls both the build process and the installation process.
 <P>
 <LI>
 <LI> better support for small architectures ("Small Lua" with 32-bit numbers)
 <LI> bitwise operators
 <LI> basic utf-8 library
 <LI> utf-8 escapes in literal strings
-<LI> functions for packing/unpacking numbers
-<LI> userdata can have any Lua value as uservalue
 <LI> strip option in <CODE>lua_dump</CODE>/<CODE>string.dump</CODE>
 </UL>
 Here are the other changes introduced in Lua 5.3:
 <H3>Language</H3>
 <UL>
-<LI>
+<LI> userdata can have any Lua value as uservalue
+<LI> integer division
+<LI> more flexible rules for some metamethods
 </UL>
 <H3>Libraries</H3>
 <UL>
-<LI>
+<LI> functions for packing/unpacking numbers
+<LI> strip option in <CODE>string.dump</CODE>
+<LI> table library respects metamethods
+<LI> new function <CODE>table.copy</CODE>
+<LI> new function <CODE>debug.Csize</CODE>
 </UL>
 <H3>C API</H3>
 <UL>
-<LI>
+<LI>  new functions: <CODE>lua_rotate</CODE>, <CODE>lua_isyieldable</CODE>, <CODE>lua_strtonum</CODE>
-</UL>
+<LI> <CODE>lua_gettable</CODE> and similar functions return type of resulted value
-<H3>Implementation</H3>
-<UL>
-<LI>
 </UL>
 <H3>Lua standalone interpreter</H3>
 <UL>
-<LI> Can be used as calculator; no need to prefix with '='
+<LI> can be used as calculator; no need to prefix with '='
+<LI> <CODE>arg</CODE> table available to all code
 </UL>
 <H2><A NAME="license">License</A></H2>
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Wed Jun 11 22:54:18 BRT 2014
+Thu Jul 31 15:23:46 BRT 2014
 </SMALL>
 <!--
-Last change: updated for Lua 5.3.0 (work3)
+Last change: updated for Lua 5.3.0 (alpha)
 -->
 </BODY>

src/Makefile+1−1

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	PLAT= none	7	PLAT= none
8		8
9	CC= gcc	9	CC= gcc
10	CFLAGS= -O2 -Wall -Wextra -DLUA_COMPAT_ALL $(SYSCFLAGS) $(MYCFLAGS)	10	CFLAGS= -O2 -Wall -Wextra -DLUA_COMPAT_5_2 $(SYSCFLAGS) $(MYCFLAGS)
11	LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)	11	LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
12	LIBS= -lm $(SYSLIBS) $(MYLIBS)	12	LIBS= -lm $(SYSLIBS) $(MYLIBS)
13		13

src/lapi.c+84−130

 /*
-** $Id: lapi.c,v 2.219 2014/06/19 18:27:20 roberto Exp $
+** $Id: lapi.c,v 2.232 2014/07/30 14:00:14 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
 /* test for pseudo index */
 #define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)
+/* test for upvalue */
+#define isupvalue(i)		((i) < LUA_REGISTRYINDEX)
 /* test for valid but not pseudo index */
 #define isstackindex(i, o)	(isvalid(o) && !ispseudo(i))
-#define api_checkvalidindex(L, o)  api_check(L, isvalid(o), "invalid index")
+#define api_checkvalidindex(o)  api_check(isvalid(o), "invalid index")
-#define api_checkstackindex(L, i, o)  \
+#define api_checkstackindex(i, o)  \
-	api_check(L, isstackindex(i, o), "index not in the stack")
+	api_check(isstackindex(i, o), "index not in the stack")
 static TValue *index2addr (lua_State *L, int idx) {
   CallInfo *ci = L->ci;
   if (idx > 0) {
     TValue *o = ci->func + idx;
-    api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
+    api_check(idx <= ci->top - (ci->func + 1), "unacceptable index");
     if (o >= L->top) return NONVALIDVALUE;
     else return o;
   }
   else if (!ispseudo(idx)) {  /* negative index */
-    api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
+    api_check(idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
     return L->top + idx;
   }
   else if (idx == LUA_REGISTRYINDEX)
     return &G(L)->l_registry;
   else {  /* upvalues */
     idx = LUA_REGISTRYINDEX - idx;
-    api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");
+    api_check(idx <= MAXUPVAL + 1, "upvalue index too large");
     if (ttislcf(ci->func))  /* light C function? */
       return NONVALIDVALUE;  /* it has no upvalues */
     else {
   int res;
   CallInfo *ci = L->ci;
   lua_lock(L);
-  api_check(L, size >= 0, "negative 'size'");
+  api_check(size >= 0, "negative 'size'");
   if (L->stack_last - L->top > size)  /* stack large enough? */
     res = 1;  /* yes; check is OK */
   else {  /* no; need to grow stack */
   if (from == to) return;
   lua_lock(to);
   api_checknelems(from, n);
-  api_check(from, G(from) == G(to), "moving among independent states");
+  api_check(G(from) == G(to), "moving among independent states");
-  api_check(from, to->ci->top - to->top >= n, "not enough elements to move");
+  api_check(to->ci->top - to->top >= n, "not enough elements to move");
   from->top -= n;
   for (i = 0; i < n; i++) {
     setobj2s(to, to->top++, from->top + i);
   StkId func = L->ci->func;
   lua_lock(L);
   if (idx >= 0) {
-    api_check(L, idx <= L->stack_last - (func + 1), "new top too large");
+    api_check(idx <= L->stack_last - (func + 1), "new top too large");
     while (L->top < (func + 1) + idx)
       setnilvalue(L->top++);
     L->top = (func + 1) + idx;
   }
   else {
-    api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");
+    api_check(-(idx+1) <= (L->top - (func + 1)), "invalid new top");
     L->top += idx+1;  /* `subtract' index (index is negative) */
   }
   lua_unlock(L);
 /*
 ** Reverse the stack segment from 'from' to 'to'
-** (auxiliar to 'lua_rotate')
+** (auxiliary to 'lua_rotate')
 */
 static void reverse (lua_State *L, StkId from, StkId to) {
   for (; from < to; from++, to--) {
   lua_lock(L);
   t = L->top - 1;  /* end of stack segment being rotated */
   p = index2addr(L, idx);  /* start of segment */
-  api_checkstackindex(L, idx, p);
+  api_checkstackindex(idx, p);
-  api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
+  api_check((n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
   m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */
   reverse(L, p, m);  /* reverse the prefix with length 'n' */
   reverse(L, m + 1, t);  /* reverse the suffix */
 }
-static void moveto (lua_State *L, TValue *fr, int idx) {
+LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
-  TValue *to = index2addr(L, idx);
+  TValue *fr, *to;
-  api_checkvalidindex(L, to);
+  lua_lock(L);
+  fr = index2addr(L, fromidx);
+  to = index2addr(L, toidx);
+  api_checkvalidindex(to);
   setobj(L, to, fr);
-  if (idx < LUA_REGISTRYINDEX)  /* function upvalue? */
+  if (isupvalue(toidx))  /* function upvalue? */
     luaC_barrier(L, clCvalue(L->ci->func), fr);
   /* LUA_REGISTRYINDEX does not need gc barrier
      (collector revisits it before finishing collection) */
-}
-LUA_API void lua_replace (lua_State *L, int idx) {
-  lua_lock(L);
-  api_checknelems(L, 1);
-  moveto(L, L->top - 1, idx);
-  L->top--;
-  lua_unlock(L);
-}
-LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
-  TValue *fr;
-  lua_lock(L);
-  fr = index2addr(L, fromidx);
-  moveto(L, fr, toidx);
   lua_unlock(L);
 }
 LUA_API const char *lua_typename (lua_State *L, int t) {
   UNUSED(L);
+  api_check(LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag");
   return ttypename(t);
 }
 LUA_API int lua_isstring (lua_State *L, int idx) {
-  int t = lua_type(L, idx);
+  const TValue *o = index2addr(L, idx);
-  return (t == LUA_TSTRING || t == LUA_TNUMBER);
+  return (ttisstring(o) || cvt2str(o));
 }
       case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;
       case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
       case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
-      default: api_check(L, 0, "invalid option");
+      default: api_check(0, "invalid option");
     }
   }
   lua_unlock(L);
 }
-LUA_API lua_Unsigned lua_tounsignedx (lua_State *L, int idx, int *pisnum) {
-  lua_Unsigned res = 0;
-  const TValue *o = index2addr(L, idx);
-  int isnum = 0;
-  switch (ttype(o)) {
-    case LUA_TNUMINT: {
-      res = l_castS2U(ivalue(o));
-      isnum = 1;
-      break;
-    }
-    case LUA_TNUMFLT: {  /* compute floor(n) % 2^(numbits in an integer) */
-      const lua_Number two2n = cast_num(LUA_MAXUNSIGNED) + cast_num(1);
-      lua_Number n = fltvalue(o);  /* get value */
-      int neg = 0;
-      n = l_floor(n);  /* get its floor */
-      if (n < 0) {
-        neg = 1;
-        n = -n;  /* make 'n' positive, so that 'fmod' is the same as '%' */
-      }
-      n = l_mathop(fmod)(n, two2n);  /* n = n % 2^(numbits in an integer) */
-      if (luai_numisnan(n))   /* not a number? */
-        break;  /* not an integer, too */
-      res = cast(lua_Unsigned, n);  /* 'n' now must fit in an unsigned */
-      if (neg) res = 0u - res;  /* back to negative, if needed */
-      isnum = 1;
-      break;
-    }
-    default: break;
-  }
-  if (pisnum) *pisnum = isnum;
-  return res;
-}
 LUA_API int lua_toboolean (lua_State *L, int idx) {
   const TValue *o = index2addr(L, idx);
   return !l_isfalse(o);
 LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
   StkId o = index2addr(L, idx);
   if (!ttisstring(o)) {
-    lua_lock(L);  /* `luaV_tostring' may create a new string */
+    if (!cvt2str(o)) {  /* not convertible? */
-    if (!luaV_tostring(L, o)) {  /* conversion failed? */
       if (len != NULL) *len = 0;
-      lua_unlock(L);
       return NULL;
     }
+    lua_lock(L);  /* `luaO_tostring' may create a new string */
     luaC_checkGC(L);
     o = index2addr(L, idx);  /* previous call may reallocate the stack */
+    luaO_tostring(L, o);
     lua_unlock(L);
   }
   if (len != NULL) *len = tsvalue(o)->len;
 LUA_API void *lua_touserdata (lua_State *L, int idx) {
   StkId o = index2addr(L, idx);
   switch (ttnov(o)) {
-    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
+    case LUA_TUSERDATA: return getudatamem(uvalue(o));
     case LUA_TLIGHTUSERDATA: return pvalue(o);
     default: return NULL;
   }
 }
-LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) {
-  lua_lock(L);
-  setivalue(L->top, l_castU2S(u));
-  api_incr_top(L);
-  lua_unlock(L);
-}
 LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
   TString *ts;
   lua_lock(L);
   else {
     CClosure *cl;
     api_checknelems(L, n);
-    api_check(L, n <= MAXUPVAL, "upvalue index too large");
+    api_check(n <= MAXUPVAL, "upvalue index too large");
     luaC_checkGC(L);
     cl = luaF_newCclosure(L, n);
     cl->f = fn;
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
   lua_unlock(L);
   return ttnov(L->top - 1);
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   setobj2s(L, L->top, luaH_getint(hvalue(t), n));
   api_incr_top(L);
   lua_unlock(L);
   TValue k;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   setpvalue(&k, cast(void *, p));
   setobj2s(L, L->top, luaH_get(hvalue(t), &k));
   api_incr_top(L);
   StkId o;
   lua_lock(L);
   o = index2addr(L, idx);
-  api_check(L, ttisfulluserdata(o), "full userdata expected");
+  api_check(ttisfulluserdata(o), "full userdata expected");
-  getuservalue(L, rawuvalue(o), L->top);
+  getuservalue(L, uvalue(o), L->top);
   api_incr_top(L);
   lua_unlock(L);
   return ttnov(L->top - 1);
 LUA_API void lua_rawset (lua_State *L, int idx) {
-  StkId t;
+  StkId o;
+  Table *t;
   lua_lock(L);
   api_checknelems(L, 2);
-  t = index2addr(L, idx);
+  o = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(o), "table expected");
-  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
+  t = hvalue(o);
-  invalidateTMcache(hvalue(t));
+  setobj2t(L, luaH_set(L, t, L->top-2), L->top-1);
-  luaC_barrierback(L, gcvalue(t), L->top-1);
+  invalidateTMcache(t);
+  luaC_barrierback(L, t, L->top-1);
   L->top -= 2;
   lua_unlock(L);
 }
 LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
-  StkId t;
+  StkId o;
+  Table *t;
   lua_lock(L);
   api_checknelems(L, 1);
-  t = index2addr(L, idx);
+  o = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(o), "table expected");
-  luaH_setint(L, hvalue(t), n, L->top - 1);
+  t = hvalue(o);
-  luaC_barrierback(L, gcvalue(t), L->top-1);
+  luaH_setint(L, t, n, L->top - 1);
+  luaC_barrierback(L, t, L->top-1);
   L->top--;
   lua_unlock(L);
 }
 LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
-  StkId t;
+  StkId o;
+  Table *t;
   TValue k;
   lua_lock(L);
   api_checknelems(L, 1);
-  t = index2addr(L, idx);
+  o = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(o), "table expected");
+  t = hvalue(o);
   setpvalue(&k, cast(void *, p));
-  setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1);
+  setobj2t(L, luaH_set(L, t, &k), L->top - 1);
-  luaC_barrierback(L, gcvalue(t), L->top - 1);
+  luaC_barrierback(L, t, L->top - 1);
   L->top--;
   lua_unlock(L);
 }
   if (ttisnil(L->top - 1))
     mt = NULL;
   else {
-    api_check(L, ttistable(L->top - 1), "table expected");
+    api_check(ttistable(L->top - 1), "table expected");
     mt = hvalue(L->top - 1);
   }
   switch (ttnov(obj)) {
     case LUA_TUSERDATA: {
       uvalue(obj)->metatable = mt;
       if (mt) {
-        luaC_objbarrier(L, rawuvalue(obj), mt);
+        luaC_objbarrier(L, uvalue(obj), mt);
         luaC_checkfinalizer(L, gcvalue(obj), mt);
       }
       break;
   lua_lock(L);
   api_checknelems(L, 1);
   o = index2addr(L, idx);
-  api_check(L, ttisfulluserdata(o), "full userdata expected");
+  api_check(ttisfulluserdata(o), "full userdata expected");
-  setuservalue(L, rawuvalue(o), L->top - 1);
+  setuservalue(L, uvalue(o), L->top - 1);
   luaC_barrier(L, gcvalue(o), L->top - 1);
   L->top--;
   lua_unlock(L);
 #define checkresults(L,na,nr) \
-     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
+     api_check((nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \
 	"results from function overflow current stack size")
-LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
+LUA_API void lua_callk (lua_State *L, int nargs, int nresults, lua_Ctx ctx,
                         lua_KFunction k) {
   StkId func;
   lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
+  api_check(k == NULL || !isLua(L->ci),
     "cannot use continuations inside hooks");
   api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
+  api_check(L->status == LUA_OK, "cannot do calls on non-normal thread");
   checkresults(L, nargs, nresults);
   func = L->top - (nargs+1);
   if (k != NULL && L->nny == 0) {  /* need to prepare continuation? */
 LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
-                        int ctx, lua_KFunction k) {
+                        lua_Ctx ctx, lua_KFunction k) {
   struct CallS c;
   int status;
   ptrdiff_t func;
   lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
+  api_check(k == NULL || !isLua(L->ci),
     "cannot use continuations inside hooks");
   api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
+  api_check(L->status == LUA_OK, "cannot do calls on non-normal thread");
   checkresults(L, nargs, nresults);
   if (errfunc == 0)
     func = 0;
   else {
     StkId o = index2addr(L, errfunc);
-    api_checkstackindex(L, errfunc, o);
+    api_checkstackindex(errfunc, o);
     func = savestack(L, o);
   }
   c.func = L->top - (nargs+1);  /* function to be called */
       const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
       /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
       setobj(L, f->upvals[0]->v, gt);
-      luaC_barrier(L, f->upvals[0], gt);
+      luaC_upvalbarrier(L, f->upvals[0]);
     }
   }
   lua_unlock(L);
     case LUA_GCSTEP: {
       l_mem debt = 1;  /* =1 to signal that it did an actual step */
       int oldrunning = g->gcrunning;
-      g->gcrunning = 1;  /* force GC to run */
+      g->gcrunning = 1;  /* allow GC to run */
       if (data == 0) {
         luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */
         luaC_step(L);
   int more;
   lua_lock(L);
   t = index2addr(L, idx);
-  api_check(L, ttistable(t), "table expected");
+  api_check(ttistable(t), "table expected");
   more = luaH_next(L, hvalue(t), L->top - 1);
   if (more) {
     api_incr_top(L);
   setuvalue(L, L->top, u);
   api_incr_top(L);
   lua_unlock(L);
-  return u + 1;
+  return getudatamem(u);
 }
 static const char *aux_upvalue (StkId fi, int n, TValue **val,
-                                GCObject **owner, UpVal **uv) {
+                                CClosure **owner, UpVal **uv) {
   switch (ttype(fi)) {
     case LUA_TCCL: {  /* C closure */
       CClosure *f = clCvalue(fi);
       if (!(1 <= n && n <= f->nupvalues)) return NULL;
       *val = &f->upvalue[n-1];
-      if (owner) *owner = obj2gco(f);
+      if (owner) *owner = f;
       return "";
     }
     case LUA_TLCL: {  /* Lua closure */
 LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
-  GCObject *owner = NULL;
+  CClosure *owner = NULL;
   UpVal *uv = NULL;
   StkId fi;
   lua_lock(L);
 static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) {
   LClosure *f;
   StkId fi = index2addr(L, fidx);
-  api_check(L, ttisLclosure(fi), "Lua function expected");
+  api_check(ttisLclosure(fi), "Lua function expected");
   f = clLvalue(fi);
-  api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
+  api_check((1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");
   if (pf) *pf = f;
   return &f->upvals[n - 1];  /* get its upvalue pointer */
 }
     }
     case LUA_TCCL: {  /* C closure */
       CClosure *f = clCvalue(fi);
-      api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");
+      api_check(1 <= n && n <= f->nupvalues, "invalid upvalue index");
       return &f->upvalue[n - 1];
     }
     default: {
-      api_check(L, 0, "closure expected");
+      api_check(0, "closure expected");
       return NULL;
     }
   }

src/lapi.h+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lapi.h,v 2.7 2009/11/27 15:37:59 roberto Exp $	2	** $Id: lapi.h,v 2.8 2014/07/15 21:26:50 roberto Exp $
3	** Auxiliary functions from Lua API	3	** Auxiliary functions from Lua API
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -11,13 +11,13 @@ · 5 unmodified lines
11	#include "llimits.h"	11	#include "llimits.h"
12	#include "lstate.h"	12	#include "lstate.h"
13		13
14	#define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \	14	#define api_incr_top(L) {L->top++; api_check(L->top <= L->ci->top, \
15	"stack overflow");}	15	"stack overflow");}
16		16
17	#define adjustresults(L,nres) \	17	#define adjustresults(L,nres) \
18	{ if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }	18	{ if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
19		19
20	#define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \	20	#define api_checknelems(L,n) api_check((n) < (L->top - L->ci->func), \
21	"not enough elements in the stack")	21	"not enough elements in the stack")
22		22
23		23

src/lauxlib.c+19−31

 /*
-** $Id: lauxlib.c,v 1.263 2014/05/12 21:44:17 roberto Exp $
+** $Id: lauxlib.c,v 1.267 2014/07/19 14:37:09 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 static void interror (lua_State *L, int arg) {
-  if (lua_type(L, arg) == LUA_TNUMBER)
+  if (lua_isnumber(L, arg))
-    luaL_argerror(L, arg, "float value out of integer range");
+    luaL_argerror(L, arg, "number has no integer representation");
   else
     tag_error(L, arg, LUA_TNUMBER);
 }
 }
-LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int arg) {
-  int isnum;
-  lua_Unsigned d = lua_tounsignedx(L, arg, &isnum);
-  if (!isnum)
-    interror(L, arg);
-  return d;
-}
 LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
                                                       lua_Integer def) {
   return luaL_opt(L, luaL_checkinteger, arg, def);
 }
-LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int arg,
-                                                        lua_Unsigned def) {
-  return luaL_opt(L, luaL_checkunsigned, arg, def);
-}
 /* }====================================================== */
 /*
-** stripped-down 'require'. Calls 'openf' to open a module,
+** Stripped-down 'require': After checking "loaded" table, calls 'openf'
-** registers the result in 'package.loaded' table and, if 'glb'
+** to open a module, registers the result in 'package.loaded' table and,
-** is true, also registers the result in the global table.
+** if 'glb' is true, also registers the result in the global table.
 ** Leaves resulting module on the top.
 */
 LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                                lua_CFunction openf, int glb) {
-  lua_pushcfunction(L, openf);
-  lua_pushstring(L, modname);  /* argument to open function */
-  lua_call(L, 1, 1);  /* open module */
   luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_pushvalue(L, -2);  /* make copy of module (call result) */
+  lua_getfield(L, -1, modname);  /* _LOADED[modname] */
-  lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
+  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
-  lua_pop(L, 1);  /* remove _LOADED table */
+    lua_pop(L, 1);  /* remove field */
+    lua_pushcfunction(L, openf);
+    lua_pushstring(L, modname);  /* argument to open function */
+    lua_call(L, 1, 1);  /* call 'openf' to open module */
+    lua_pushvalue(L, -1);  /* make copy of module (call result) */
+    lua_setfield(L, -3, modname);  /* _LOADED[modname] = module */
+  }
+  lua_remove(L, -2);  /* remove _LOADED table */
   if (glb) {
-    lua_pushvalue(L, -1);  /* copy of 'mod' */
+    lua_pushvalue(L, -1);  /* copy of module */
     lua_setglobal(L, modname);  /* _G[modname] = module */
   }
 }
 LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
   const lua_Number *v = lua_version(L);
+  if (sz != LUAL_NUMSIZES)  /* check numeric types */
+    luaL_error(L, "core and library have incompatible numeric types");
   if (v != lua_version(NULL))
     luaL_error(L, "multiple Lua VMs detected");
   else if (*v != ver)
     luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                   ver, *v);
-  /* check numeric types */
-  if (sz != LUAL_NUMSIZES)
-    luaL_error(L, "core and library have incompatible numeric types");
 }

src/lauxlib.h+17−4

 /*
-** $Id: lauxlib.h,v 1.124 2014/04/15 18:25:49 roberto Exp $
+** $Id: lauxlib.h,v 1.125 2014/06/26 17:25:11 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
 LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
                                           lua_Integer def);
-LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int arg);
-LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int arg,
-                                            lua_Unsigned def);
 LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
 LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
 #endif
+/*
+** {============================================================
+** Compatibility with deprecated unsigned conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIUNSIGNED)
+#define luaL_checkunsigned(L,a)		((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
+#endif
+/* }============================================================ */
 #endif

src/lbaselib.c+64−15

 /*
-** $Id: lbaselib.c,v 1.289 2014/06/10 17:41:38 roberto Exp $
+** $Id: lbaselib.c,v 1.293 2014/07/24 19:33:29 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 }
+/*
+** This function has all type names as upvalues, to maximize performance.
+*/
 static int luaB_type (lua_State *L) {
   luaL_checkany(L, 1);
-  lua_pushstring(L, luaL_typename(L, 1));
+  lua_pushvalue(L, lua_upvalueindex(lua_type(L, 1) + 1));
   return 1;
 }
 }
-static int ipairsaux (lua_State *L) {
+/*
-  int i = luaL_checkint(L, 2);
+** Traversal function for 'ipairs' for raw tables
+*/
+static int ipairsaux_raw (lua_State *L) {
+  int i = luaL_checkint(L, 2) + 1;
   luaL_checktype(L, 1, LUA_TTABLE);
-  i++;  /* next value */
   lua_pushinteger(L, i);
   return (lua_rawgeti(L, 1, i) == LUA_TNIL) ? 1 : 2;
 }
+/*
+** Traversal function for 'ipairs' for tables with metamethods
+*/
+static int ipairsaux (lua_State *L) {
+  int i = luaL_checkint(L, 2) + 1;
+  if (i > luaL_len(L, 1)) {  /* larger than length? */
+    lua_pushnil(L);  /* end traversal */
+    return 1;
+  }
+  else {
+    lua_pushinteger(L, i);
+    lua_pushinteger(L, i);  /* key for indexing table */
+    lua_gettable(L, 1);
+    return 2;
+  }
+}
+/*
+** This function will use either 'ipairsaux' or 'ipairsaux_raw' to
+** traverse a table, depending on whether the table has metamethods
+** that can affect the traversal.
+*/
 static int luaB_ipairs (lua_State *L) {
-  return pairsmeta(L, "__ipairs", 1, ipairsaux);
+  lua_CFunction iter =
+     (luaL_getmetafield(L, 1, "__len") ||
+      luaL_getmetafield(L, 1, "__index"))
+        ? ipairsaux : ipairsaux_raw;
+#if defined(LUA_COMPAT_IPAIRS)
+  return pairsmeta(L, "__ipairs", 1, iter);
+#else
+  lua_pushcfunction(L, iter);  /* iteration function */
+  lua_pushvalue(L, 1);  /* state */
+  lua_pushinteger(L, 0);  /* initial value */
+  return 3;
+#endif
 }
 /* }====================================================== */
-static int dofilecont (lua_State *L, int d1, int d2) {
+static int dofilecont (lua_State *L, int d1, lua_Ctx d2) {
   (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */
   return lua_gettop(L) - 1;
 }
 /*
 ** Continuation function for 'pcall' and 'xpcall'. Both functions
-** already pushed a 'true' before doing the call, so in case of sucess
+** already pushed a 'true' before doing the call, so in case of success
 ** 'finishpcall' only has to return everything in the stack minus
 ** 'extra' values (where 'extra' is exactly the number of items to be
 ** ignored).
 */
-static int finishpcall (lua_State *L, int status, int extra) {
+static int finishpcall (lua_State *L, int status, lua_Ctx extra) {
   if (status != LUA_OK && status != LUA_YIELD) {  /* error? */
     lua_pushboolean(L, 0);  /* first result (false) */
     lua_pushvalue(L, -2);  /* error message */
   {"setmetatable", luaB_setmetatable},
   {"tonumber", luaB_tonumber},
   {"tostring", luaB_tostring},
-  {"type", luaB_type},
   {"xpcall", luaB_xpcall},
+  /* placeholders */
+  {"type", NULL},
+  {"_G", NULL},
+  {"_VERSION", NULL},
   {NULL, NULL}
 };
 LUAMOD_API int luaopen_base (lua_State *L) {
-  /* set global _G */
+  int i;
-  lua_pushglobaltable(L);
-  lua_pushglobaltable(L);
-  lua_setfield(L, -2, "_G");
   /* open lib into global table */
+  lua_pushglobaltable(L);
   luaL_setfuncs(L, base_funcs, 0);
+  /* set global _G */
+  lua_pushvalue(L, -1);
+  lua_setfield(L, -2, "_G");
+  /* set global _VERSION */
   lua_pushliteral(L, LUA_VERSION);
-  lua_setfield(L, -2, "_VERSION");  /* set global _VERSION */
+  lua_setfield(L, -2, "_VERSION");
+  /* set function 'type' with proper upvalues */
+  for (i = 0; i < LUA_NUMTAGS; i++)  /* push all type names as upvalues */
+    lua_pushstring(L, lua_typename(L, i));
+  lua_pushcclosure(L, luaB_type, LUA_NUMTAGS);
+  lua_setfield(L, -2, "type");
   return 1;
 }

src/ldebug.c+9−8

 /*
-** $Id: ldebug.c,v 2.97 2013/12/09 14:21:10 roberto Exp $
+** $Id: ldebug.c,v 2.100 2014/07/30 14:00:14 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
   if (*what == '>') {
     ci = NULL;
     func = L->top - 1;
-    api_check(L, ttisfunction(func), "function expected");
+    api_check(ttisfunction(func), "function expected");
     what++;  /* skip the '>' */
     L->top--;  /* pop function */
   }
 l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
-  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;
+  if (ttisstring(p1) || cvt2str(p1)) p1 = p2;
-  lua_assert(!ttisstring(p1) && !ttisnumber(p1));
   luaG_typeerror(L, p1, "concatenate");
 }
 l_noret luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
   lua_Number temp;
-  if (!tonumber(p1, &temp))
+  if (!tonumber(p1, &temp))  /* first operand is wrong? */
-    p2 = p1;  /* first operand is wrong */
+    p2 = p1;  /* now second is wrong */
   luaG_typeerror(L, p2, "perform arithmetic on");
 }
+/*
+** Error when both values are convertible to numbers, but not to integers
+*/
 l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
   lua_Integer temp;
   if (!tointeger(p1, &temp))
     p2 = p1;
-  luaG_runerror(L, "attempt to convert an out of range float%s to an integer",
+  luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
-                   varinfo(L, p2));
 }

src/ldo.c+5−4

 /*
-** $Id: ldo.c,v 2.123 2014/06/19 18:27:20 roberto Exp $
+** $Id: ldo.c,v 2.126 2014/07/17 13:53:37 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
 /*
 ** Do the work for 'lua_resume' in protected mode. Most of the work
 ** depends on the status of the coroutine: initial state, suspended
-** inside a hook, or regulary suspended (optionally with a continuation
+** inside a hook, or regularly suspended (optionally with a continuation
 ** function), plus erroneous cases: non-suspended coroutine or dead
 ** coroutine.
 */
 }
-LUA_API int lua_yieldk (lua_State *L, int nresults, int ctx, lua_KFunction k) {
+LUA_API int lua_yieldk (lua_State *L, int nresults, lua_Ctx ctx,
+                        lua_KFunction k) {
   CallInfo *ci = L->ci;
   luai_userstateyield(L, nresults);
   lua_lock(L);
   L->status = LUA_YIELD;
   ci->extra = savestack(L, ci->func);  /* save current 'func' */
   if (isLua(ci)) {  /* inside a hook? */
-    api_check(L, k == NULL, "hooks cannot continue after yielding");
+    api_check(k == NULL, "hooks cannot continue after yielding");
   }
   else {
     if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */

src/ldump.c+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldump.c,v 2.32 2014/06/18 18:35:43 roberto Exp $	2	** $Id: ldump.c,v 2.33 2014/07/18 13:36:14 roberto 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	*/
@@ -71,7 +71,7 @@ static void DumpString (const TString s, DumpState D) { · 65 unmodified lines
71	if (s == NULL)	71	if (s == NULL)
72	DumpByte(0, D);	72	DumpByte(0, D);
73	else {	73	else {
74	size_t size = s->tsv.len + 1; /* include trailing '\0' */	74	size_t size = s->len + 1; /* include trailing '\0' */
75	if (size < 0xFF)	75	if (size < 0xFF)
76	DumpByte(cast_int(size), D);	76	DumpByte(cast_int(size), D);
77	else {	77	else {
@@ -112,7 +112,7 @@ static void DumpConstants (const Proto f, DumpState D) { · 34 unmodified lines
112	break;	112	break;
113	case LUA_TSHRSTR:	113	case LUA_TSHRSTR:
114	case LUA_TLNGSTR:	114	case LUA_TLNGSTR:
115	DumpString(rawtsvalue(o), D);	115	DumpString(tsvalue(o), D);
116	break;	116	break;
117	default:	117	default:
118	lua_assert(0);	118	lua_assert(0);

src/lgc.c+50−52

 /*
-** $Id: lgc.c,v 2.183 2014/05/25 19:08:32 roberto Exp $
+** $Id: lgc.c,v 2.192 2014/07/29 16:22:24 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 */
 #define maskcolors	(~(bitmask(BLACKBIT) | WHITEBITS))
 #define makewhite(g,x)	\
- (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g)))
+ (x->marked = cast_byte((x->marked & maskcolors) | luaC_white(g)))
-#define white2gray(x)	resetbits(gch(x)->marked, WHITEBITS)
+#define white2gray(x)	resetbits(x->marked, WHITEBITS)
-#define black2gray(x)	resetbit(gch(x)->marked, BLACKBIT)
+#define black2gray(x)	resetbit(x->marked, BLACKBIT)
 #define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))
   if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
 #define markobject(g,t) \
-  { if ((t) && iswhite(obj2gco(t))) reallymarkobject(g, obj2gco(t)); }
+  { if ((t) && iswhite(t)) reallymarkobject(g, obj2gco(t)); }
 static void reallymarkobject (global_State *g, GCObject *o);
 static void removeentry (Node *n) {
   lua_assert(ttisnil(gval(n)));
   if (valiswhite(gkey(n)))
-    setdeadvalue(gkey(n));  /* unused and unmarked key; remove it */
+    setdeadvalue(wgkey(n));  /* unused and unmarked key; remove it */
 }
 static int iscleared (global_State *g, const TValue *o) {
   if (!iscollectable(o)) return 0;
   else if (ttisstring(o)) {
-    markobject(g, rawtsvalue(o));  /* strings are `values', so are never weak */
+    markobject(g, tsvalue(o));  /* strings are `values', so are never weak */
     return 0;
   }
   else return iswhite(gcvalue(o));
 /*
 ** barrier that moves collector forward, that is, mark the white object
-** being pointed by a black object.
+** being pointed by a black object. (If in sweep phase, clear the black
+** object to white [sweep it] to avoid other barrier calls for this
+** same object.)
 */
 void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
   global_State *g = G(L);
   lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  lua_assert(g->gcstate != GCSpause);
-  lua_assert(gch(o)->tt != LUA_TTABLE);  /* tables use a back barrier */
   if (keepinvariant(g))  /* must keep invariant? */
     reallymarkobject(g, v);  /* restore invariant */
   else {  /* sweep phase */
 /*
 ** barrier that moves collector backward, that is, mark the black object
-** pointing to a white object as gray again. (Current implementation
+** pointing to a white object as gray again.
-** only works for tables; access to 'gclist' is not uniform across
-** different types.)
 */
-void luaC_barrierback_ (lua_State *L, GCObject *o) {
+void luaC_barrierback_ (lua_State *L, Table *t) {
   global_State *g = G(L);
-  lua_assert(isblack(o) && !isdead(g, o) && gch(o)->tt == LUA_TTABLE);
+  lua_assert(isblack(t) && !isdead(g, t));
-  black2gray(o);  /* make object gray (again) */
+  black2gray(t);  /* make table gray (again) */
-  gco2t(o)->gclist = g->grayagain;
+  t->gclist = g->grayagain;
-  g->grayagain = o;
+  g->grayagain = obj2gco(t);
 }
   global_State *g = G(L);
   lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
   white2gray(o);  /* they will be gray forever */
-  g->allgc = o->gch.next;  /* remove object from 'allgc' list */
+  g->allgc = o->next;  /* remove object from 'allgc' list */
-  o->gch.next = g->fixedgc;  /* link it to 'fixedgc' list */
+  o->next = g->fixedgc;  /* link it to 'fixedgc' list */
   g->fixedgc = o;
 }
 GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
   global_State *g = G(L);
   GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
-  gch(o)->marked = luaC_white(g);
+  o->marked = luaC_white(g);
-  gch(o)->tt = tt;
+  o->tt = tt;
-  gch(o)->next = g->allgc;
+  o->next = g->allgc;
   g->allgc = o;
   return o;
 }
 static void reallymarkobject (global_State *g, GCObject *o) {
  reentry:
   white2gray(o);
-  switch (gch(o)->tt) {
+  switch (o->tt) {
     case LUA_TSHRSTR:
     case LUA_TLNGSTR: {
       gray2black(o);
       markobject(g, gco2u(o)->metatable);  /* mark its metatable */
       gray2black(o);
       g->GCmemtrav += sizeudata(gco2u(o));
-      getuservalue(g->mainthread, rawgco2u(o), &uvalue);
+      getuservalue(g->mainthread, gco2u(o), &uvalue);
       if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
         o = gcvalue(&uvalue);
         goto reentry;
 */
 static void markbeingfnz (global_State *g) {
   GCObject *o;
-  for (o = g->tobefnz; o != NULL; o = gch(o)->next)
+  for (o = g->tobefnz; o != NULL; o = o->next)
     markobject(g, o);
 }
   lua_State *thread;
   lua_State **p = &g->twups;
   while ((thread = *p) != NULL) {
-    lua_assert(!isblack(obj2gco(thread)));  /* threads are never black */
+    lua_assert(!isblack(thread));  /* threads are never black */
-    if (isgray(obj2gco(thread)) && thread->openupval != NULL)
+    if (isgray(thread) && thread->openupval != NULL)
       p = &thread->twups;  /* keep marked thread with upvalues in the list */
     else {  /* thread is not marked or without upvalues */
       UpVal *uv;
       ((weakkey = strchr(svalue(mode), 'k')),
        (weakvalue = strchr(svalue(mode), 'v')),
        (weakkey || weakvalue))) {  /* is really weak? */
-    black2gray(obj2gco(h));  /* keep table gray */
+    black2gray(h);  /* keep table gray */
     if (!weakkey)  /* strong keys? */
       traverseweakvalue(g, h);
     else if (!weakvalue)  /* strong values? */
 static int traverseproto (global_State *g, Proto *f) {
   int i;
-  if (f->cache && iswhite(obj2gco(f->cache)))
+  if (f->cache && iswhite(f->cache))
     f->cache = NULL;  /* allow cache to be collected */
   markobject(g, f->source);
   for (i = 0; i < f->sizek; i++)  /* mark literals */
   GCObject *o = g->gray;
   lua_assert(isgray(o));
   gray2black(o);
-  switch (gch(o)->tt) {
+  switch (o->tt) {
     case LUA_TTABLE: {
       Table *h = gco2t(o);
       g->gray = h->gclist;  /* remove from 'gray' list */
 static void freeobj (lua_State *L, GCObject *o) {
-  switch (gch(o)->tt) {
+  switch (o->tt) {
     case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
     case LUA_TLCL: {
       freeLclosure(L, gco2lcl(o));
     case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
     case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
     case LUA_TSHRSTR:
-      luaS_remove(L, rawgco2ts(o));  /* remove it from hash table */
+      luaS_remove(L, gco2ts(o));  /* remove it from hash table */
       /* go through */
     case LUA_TLNGSTR: {
       luaM_freemem(L, o, sizestring(gco2ts(o)));
   int white = luaC_white(g);  /* current white */
   while (*p != NULL && count-- > 0) {
     GCObject *curr = *p;
-    int marked = gch(curr)->marked;
+    int marked = curr->marked;
     if (isdeadm(ow, marked)) {  /* is 'curr' dead? */
-      *p = gch(curr)->next;  /* remove 'curr' from list */
+      *p = curr->next;  /* remove 'curr' from list */
       freeobj(L, curr);  /* erase 'curr' */
     }
     else {  /* update marks */
-      gch(curr)->marked = cast_byte((marked & maskcolors) | white);
+      curr->marked = cast_byte((marked & maskcolors) | white);
-      p = &gch(curr)->next;  /* go to next element */
+      p = &curr->next;  /* go to next element */
     }
   }
   return (*p == NULL) ? NULL : p;
 static GCObject *udata2finalize (global_State *g) {
   GCObject *o = g->tobefnz;  /* get first element */
   lua_assert(tofinalize(o));
-  g->tobefnz = gch(o)->next;  /* remove it from 'tobefnz' list */
+  g->tobefnz = o->next;  /* remove it from 'tobefnz' list */
-  gch(o)->next = g->allgc;  /* return it to 'allgc' list */
+  o->next = g->allgc;  /* return it to 'allgc' list */
   g->allgc = o;
-  resetbit(gch(o)->marked, FINALIZEDBIT);  /* object is "normal" again */
+  resetbit(o->marked, FINALIZEDBIT);  /* object is "normal" again */
   if (issweepphase(g))
     makewhite(g, o);  /* "sweep" object */
   return o;
 */
 static GCObject **findlast (GCObject **p) {
   while (*p != NULL)
-    p = &gch(*p)->next;
+    p = &(*p)->next;
   return p;
 }
   while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
     lua_assert(tofinalize(curr));
     if (!(iswhite(curr) || all))  /* not being collected? */
-      p = &gch(curr)->next;  /* don't bother with it */
+      p = &curr->next;  /* don't bother with it */
     else {
-      *p = gch(curr)->next;  /* remove 'curr' from "fin" list */
+      *p = curr->next;  /* remove 'curr' from "fin" list */
-      gch(curr)->next = *lastnext;  /* link at the end of 'tobefnz' list */
+      curr->next = *lastnext;  /* link at the end of 'tobefnz' list */
       *lastnext = curr;
-      lastnext = &gch(curr)->next;
+      lastnext = &curr->next;
     }
   }
 }
     GCObject **p;
     if (issweepphase(g)) {
       makewhite(g, o);  /* "sweep" object 'o' */
-      if (g->sweepgc == &o->gch.next)  /* shoud not remove 'sweepgc' object */
+      if (g->sweepgc == &o->next)  /* should not remove 'sweepgc' object */
         g->sweepgc = sweeptolive(L, g->sweepgc, NULL);  /* change 'sweepgc' */
     }
     /* search for pointer pointing to 'o' */
-    for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ }
+    for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
-    *p = o->gch.next;  /* remove 'o' from 'allgc' list */
+    *p = o->next;  /* remove 'o' from 'allgc' list */
-    o->gch.next = g->finobj;  /* link it in "fin" list */
+    o->next = g->finobj;  /* link it in "fin" list */
     g->finobj = o;
-    l_setbit(o->gch.marked, FINALIZEDBIT);  /* mark it as such */
+    l_setbit(o->marked, FINALIZEDBIT);  /* mark it as such */
   }
 }
   l_mem work;
   GCObject *origweak, *origall;
   g->GCmemtrav = 0;  /* start counting work */
-  lua_assert(!iswhite(obj2gco(g->mainthread)));
+  lua_assert(!iswhite(g->mainthread));
   g->gcstate = GCSinsideatomic;
   markobject(g, L);  /* mark running thread */
   /* registry and global metatables may be changed by API */
       return sweepstep(L, g, GCSswpend, NULL);
     }
     case GCSswpend: {  /* finish sweeps */
-      makewhite(g, obj2gco(g->mainthread));  /* sweep main thread */
+      makewhite(g, g->mainthread);  /* sweep main thread */
       checkSizes(L, g);
       g->gcstate = GCScallfin;
       return 0;

src/lgc.h+13−13

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lgc.h,v 2.82 2014/03/19 18:51:16 roberto Exp $	2	** $Id: lgc.h,v 2.85 2014/07/19 15:14:46 roberto Exp $
3	** Garbage Collector	3	** Garbage Collector
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -84,19 +84,19 @@ · 78 unmodified lines
84	#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)	84	#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
85		85
86		86
87	#define iswhite(x) testbits((x)->gch.marked, WHITEBITS)	87	#define iswhite(x) testbits((x)->marked, WHITEBITS)
88	#define isblack(x) testbit((x)->gch.marked, BLACKBIT)	88	#define isblack(x) testbit((x)->marked, BLACKBIT)
89	#define isgray(x) /* neither white nor black */ \	89	#define isgray(x) /* neither white nor black */ \
90	(!testbits((x)->gch.marked, WHITEBITS \| bitmask(BLACKBIT)))	90	(!testbits((x)->marked, WHITEBITS \| bitmask(BLACKBIT)))
91		91
92	#define tofinalize(x) testbit((x)->gch.marked, FINALIZEDBIT)	92	#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT)
93		93
94	#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)	94	#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)
95	#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))	95	#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
96	#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)	96	#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked)
97		97
98	#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)	98	#define changewhite(x) ((x)->marked ^= WHITEBITS)
99	#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)	99	#define gray2black(x) l_setbit((x)->marked, BLACKBIT)
100		100
101	#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)	101	#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
102		102
@@ -107,15 +107,15 @@ · 4 unmodified lines
107		107
108		108
109	#define luaC_barrier(L,p,v) { \	109	#define luaC_barrier(L,p,v) { \
110	if (iscollectable(v) && isblack(obj2gco(p)) && iswhite(gcvalue(v))) \	110	if (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) \
111	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }	111	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
112		112
113	#define luaC_barrierback(L,p,v) { \	113	#define luaC_barrierback(L,p,v) { \
114	if (iscollectable(v) && isblack(obj2gco(p)) && iswhite(gcvalue(v))) \	114	if (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) \
115	luaC_barrierback_(L,obj2gco(p)); }	115	luaC_barrierback_(L,p); }
116		116
117	#define luaC_objbarrier(L,p,o) { \	117	#define luaC_objbarrier(L,p,o) { \
118	if (isblack(obj2gco(p)) && iswhite(obj2gco(o))) \	118	if (isblack(p) && iswhite(o)) \
119	luaC_barrier_(L,obj2gco(p),obj2gco(o)); }	119	luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
120		120
121	#define luaC_upvalbarrier(L,uv) \	121	#define luaC_upvalbarrier(L,uv) \
@@ -129,7 +129,7 @@ LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask); · 7 unmodified lines
129	LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);	129	LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
130	LUAI_FUNC GCObject luaC_newobj (lua_State L, int tt, size_t sz);	130	LUAI_FUNC GCObject luaC_newobj (lua_State L, int tt, size_t sz);
131	LUAI_FUNC void luaC_barrier_ (lua_State L, GCObject o, GCObject *v);	131	LUAI_FUNC void luaC_barrier_ (lua_State L, GCObject o, GCObject *v);
132	LUAI_FUNC void luaC_barrierback_ (lua_State L, GCObject o);	132	LUAI_FUNC void luaC_barrierback_ (lua_State L, Table o);
133	LUAI_FUNC void luaC_upvalbarrier_ (lua_State L, UpVal uv);	133	LUAI_FUNC void luaC_upvalbarrier_ (lua_State L, UpVal uv);
134	LUAI_FUNC void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt);	134	LUAI_FUNC void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt);
135	LUAI_FUNC void luaC_upvdeccount (lua_State L, UpVal uv);	135	LUAI_FUNC void luaC_upvdeccount (lua_State L, UpVal uv);

src/liolib.c+10−10

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: liolib.c,v 2.126 2014/06/02 03:00:51 roberto Exp $	2	** $Id: liolib.c,v 2.128 2014/07/29 16:01:00 roberto Exp $
3	** Standard I/O (and system) library	3	** Standard I/O (and system) library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -402,11 +402,11 @@ static int test2 (RN rn, const char set) { · 396 unmodified lines
402		402
403		403
404	/*	404	/*
405	** Read a sequence of (hexa)digits	405	** Read a sequence of (hex)digits
406	*/	406	*/
407	static int readdigits (RN *rn, int hexa) {	407	static int readdigits (RN *rn, int hex) {
408	int count = 0;	408	int count = 0;
409	while ((hexa ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))	409	while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
410	count++;	410	count++;
411	return count;	411	return count;
412	}	412	}
@@ -426,7 +426,7 @@ static int readdigits (RN *rn, int hexa) { · 13 unmodified lines
426	static int read_number (lua_State L, FILE f) {	426	static int read_number (lua_State L, FILE f) {
427	RN rn;	427	RN rn;
428	int count = 0;	428	int count = 0;
429	int hexa = 0;	429	int hex = 0;
430	char decp[2] = ".";	430	char decp[2] = ".";
431	rn.f = f; rn.n = 0;	431	rn.f = f; rn.n = 0;
432	decp[0] = getlocaledecpoint(); /* get decimal point from locale */	432	decp[0] = getlocaledecpoint(); /* get decimal point from locale */
@@ -434,13 +434,13 @@ static int read_number (lua_State L, FILE f) { · 1 unmodified line
434	do { rn.c = l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */	434	do { rn.c = l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */
435	test2(&rn, "-+"); /* optional signal */	435	test2(&rn, "-+"); /* optional signal */
436	if (test2(&rn, "0")) {	436	if (test2(&rn, "0")) {
437	if (test2(&rn, "xX")) hexa = 1; /* numeral is hexadecimal */	437	if (test2(&rn, "xX")) hex = 1; /* numeral is hexadecimal */
438	else count = 1; /* count initial '0' as a valid digit */	438	else count = 1; /* count initial '0' as a valid digit */
439	}	439	}
440	count += readdigits(&rn, hexa); /* integral part */	440	count += readdigits(&rn, hex); /* integral part */
441	if (test2(&rn, decp)) /* decimal point? */	441	if (test2(&rn, decp)) /* decimal point? */
442	count += readdigits(&rn, hexa); /* fractionary part */	442	count += readdigits(&rn, hex); /* fractional part */
443	if (count > 0 && test2(&rn, (hexa ? "pP" : "eE"))) { /* exponent mark? */	443	if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) { /* exponent mark? */
444	test2(&rn, "-+"); /* exponent signal */	444	test2(&rn, "-+"); /* exponent signal */
445	readdigits(&rn, 0); /* exponent digits */	445	readdigits(&rn, 0); /* exponent digits */
446	}	446	}
@@ -654,7 +654,7 @@ static int f_setvbuf (lua_State *L) { · 207 unmodified lines
654	FILE *f = tofile(L);	654	FILE *f = tofile(L);
655	int op = luaL_checkoption(L, 2, NULL, modenames);	655	int op = luaL_checkoption(L, 2, NULL, modenames);
656	lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);	656	lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
657	int res = setvbuf(f, NULL, mode[op], sz);	657	int res = setvbuf(f, NULL, mode[op], (size_t)sz);
658	return luaL_fileresult(L, res == 0, NULL);	658	return luaL_fileresult(L, res == 0, NULL);
659	}	659	}
660		660

src/llex.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llex.c,v 2.78 2014/05/21 15:22:02 roberto Exp $	2	** $Id: llex.c,v 2.80 2014/07/18 13:36:14 roberto Exp $
3	** Lexical Analyzer	3	** Lexical Analyzer
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -71,7 +71,7 @@ void luaX_init (lua_State *L) { · 65 unmodified lines
71	for (i=0; i<NUM_RESERVED; i++) {	71	for (i=0; i<NUM_RESERVED; i++) {
72	TString *ts = luaS_new(L, luaX_tokens[i]);	72	TString *ts = luaS_new(L, luaX_tokens[i]);
73	luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */	73	luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */
74	ts->tsv.extra = cast_byte(i+1); /* reserved word */	74	ts->extra = cast_byte(i+1); /* reserved word */
75	}	75	}
76	}	76	}
77		77
@@ -137,7 +137,7 @@ TString luaX_newstring (LexState ls, const char *str, size_t l) { · 59 unmodified lines
137	luaC_checkGC(L);	137	luaC_checkGC(L);
138	}	138	}
139	else { /* string already present */	139	else { /* string already present */
140	ts = rawtsvalue(keyfromval(o)); /* re-use value previously stored */	140	ts = tsvalue(keyfromval(o)); /* re-use value previously stored */
141	}	141	}
142	L->top--; /* remove string from stack */	142	L->top--; /* remove string from stack */
143	return ts;	143	return ts;
@@ -565,7 +565,7 @@ static int llex (LexState ls, SemInfo seminfo) { · 421 unmodified lines
565	luaZ_bufflen(ls->buff));	565	luaZ_bufflen(ls->buff));
566	seminfo->ts = ts;	566	seminfo->ts = ts;
567	if (isreserved(ts)) /* reserved word? */	567	if (isreserved(ts)) /* reserved word? */
568	return ts->tsv.extra - 1 + FIRST_RESERVED;	568	return ts->extra - 1 + FIRST_RESERVED;
569	else {	569	else {
570	return TK_NAME;	570	return TK_NAME;
571	}	571	}

src/llimits.h+15−17

 /*
-** $Id: llimits.h,v 1.116 2014/04/15 16:32:49 roberto Exp $
+** $Id: llimits.h,v 1.120 2014/07/18 18:29:12 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 /* maximum value for size_t */
-#define MAX_SIZET	((size_t)(~(size_t)0)-2)
+#define MAX_SIZET	((size_t)(~(size_t)0))
 /* maximum size visible for Lua (must be representable in a lua_Integer */
 #define MAX_SIZE	(sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
-                          : (size_t)(LUA_MAXINTEGER)-2)
+                          : (size_t)(LUA_MAXINTEGER))
-#define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
+#define MAX_LUMEM	((lu_mem)(~(lu_mem)0))
-#define MAX_LMEM	((l_mem) ((MAX_LUMEM >> 1) - 2))
+#define MAX_LMEM	((l_mem)(MAX_LUMEM >> 1))
-#define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
+#define MAX_INT		INT_MAX  /* maximum value of an int */
 /*
-** conversion of pointer to integer
+** conversion of pointer to integer:
 ** this is for hashing only; there is no problem if the integer
 ** cannot hold the whole pointer value
 */
-#define IntPoint(p)  ((unsigned int)(lu_mem)(p))
+#define point2int(p)	((unsigned int)((lu_mem)(p) & UINT_MAX))
 /* type to ensure maximum alignment */
-#if !defined(LUAI_USER_ALIGNMENT_T)
+#if defined(LUAI_USER_ALIGNMENT_T)
-#define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }
+typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
+#else
+typedef union { double u; void *s; lua_Integer i; long l; } L_Umaxalign;
 #endif
-typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
 /* types of 'usual argument conversions' for lua_Number and lua_Integer */
 /*
 ** assertion for checking API calls
 */
-#if !defined(luai_apicheck)
 #if defined(LUA_USE_APICHECK)
 #include <assert.h>
-#define luai_apicheck(L,e)	assert(e)
+#define luai_apicheck(e)	assert(e)
 #else
-#define luai_apicheck(L,e)	lua_assert(e)
+#define luai_apicheck(e)	lua_assert(e)
 #endif
-#endif
-#define api_check(l,e,msg)	luai_apicheck(l,(e) && msg)
+#define api_check(e,msg)	luai_apicheck((e) && msg)
 #if !defined(UNUSED)

src/lmathlib.c+38−23

 /*
-** $Id: lmathlib.c,v 1.103 2014/06/18 12:35:53 roberto Exp $
+** $Id: lmathlib.c,v 1.108 2014/07/28 17:35:47 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 }
-static int math_ifloor (lua_State *L) {
+static int math_toint (lua_State *L) {
   int valid;
   lua_Integer n = lua_tointegerx(L, 1, &valid);
   if (valid)
-    lua_pushinteger(L, n);  /* floor computed by Lua */
+    lua_pushinteger(L, n);
   else {
-    luaL_checktype(L, 1, LUA_TNUMBER);  /* argument must be a number */
+    luaL_checkany(L, 1);
-    lua_pushnil(L);  /* number is not convertible to integer */
+    lua_pushnil(L);  /* value is not convertible to integer */
   }
   return 1;
 }
-static int math_floor (lua_State *L) {
-  int valid;
-  lua_Integer n = lua_tointegerx(L, 1, &valid);
-  if (valid)
-    lua_pushinteger(L, n);  /* floor computed by Lua */
-  else
-    lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1)));
-  return 1;
-}
 static void pushnumint (lua_State *L, lua_Number d) {
   lua_Integer n;
-  if (lua_numtointeger(d, &n))  /* fits in an integer? */
+  if (lua_numtointeger(d, &n))  /* does 'd' fit in an integer? */
     lua_pushinteger(L, n);  /* result is integer */
   else
     lua_pushnumber(L, d);  /* result is float */
 }
+static int math_floor (lua_State *L) {
+  if (lua_isinteger(L, 1))
+    lua_settop(L, 1);  /* integer is its own floor */
+  else {
+    lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
+    pushnumint(L, d);
+  }
+  return 1;
+}
 static int math_ceil (lua_State *L) {
   if (lua_isinteger(L, 1))
     lua_settop(L, 1);  /* integer is its own ceil */
 static int math_modf (lua_State *L) {
   if (lua_isinteger(L ,1)) {
     lua_settop(L, 1);  /* number is its own integer part */
-    lua_pushnumber(L, 0);  /* no fractionary part */
+    lua_pushnumber(L, 0);  /* no fractional part */
   }
   else {
     lua_Number n = luaL_checknumber(L, 1);
     /* integer part (rounds toward zero) */
     lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
     pushnumint(L, ip);
-    /* fractionary part (test needed for inf/-inf) */
+    /* fractional part (test needed for inf/-inf) */
     lua_pushnumber(L, (n == ip) ? 0.0 : (n - ip));
   }
   return 2;
   return 1;
 }
+static int math_ult (lua_State *L) {
+  lua_Integer a = luaL_checkinteger(L, 1);
+  lua_Integer b = luaL_checkinteger(L, 2);
+  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
+  return 1;
+}
 static int math_log (lua_State *L) {
   lua_Number x = luaL_checknumber(L, 1);
   lua_Number res;
 static int math_randomseed (lua_State *L) {
-  l_srand((unsigned int)luaL_checkunsigned(L, 1));
+  l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
   (void)rand(); /* discard first value to avoid undesirable correlations */
   return 0;
 }
 static int math_type (lua_State *L) {
-  luaL_checkany(L, 1);
   if (lua_type(L, 1) == LUA_TNUMBER) {
       if (lua_isinteger(L, 1))
         lua_pushliteral(L, "integer");
       else
         lua_pushliteral(L, "float");
   }
-  else
+  else {
+    luaL_checkany(L, 1);
     lua_pushnil(L);
+  }
   return 1;
 }
   {"cos",   math_cos},
   {"deg",   math_deg},
   {"exp",   math_exp},
-  {"ifloor", math_ifloor},
+  {"tointeger", math_toint},
   {"floor", math_floor},
   {"fmod",   math_fmod},
+  {"ult",   math_ult},
   {"log",   math_log},
   {"max",   math_max},
   {"min",   math_min},
   {"ldexp", math_ldexp},
   {"log10", math_log10},
 #endif
+  /* placeholders */
+  {"pi", NULL},
+  {"huge", NULL},
+  {"maxinteger", NULL},
+  {"mininteger", NULL},
   {NULL, NULL}
 };

src/lmem.c+4−6

 /*
-** $Id: lmem.c,v 1.84 2012/05/23 15:41:53 roberto Exp $
+** $Id: lmem.c,v 1.86 2014/07/15 21:26:50 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
 #endif
   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
   if (newblock == NULL && nsize > 0) {
-    api_check(L, nsize > realosize,
+    api_check( nsize > realosize,
                  "realloc cannot fail when shrinking a block");
-    if (g->gcrunning) {
+    luaC_fullgc(L, 1);  /* try to free some memory... */
-      luaC_fullgc(L, 1);  /* try to free some memory... */
+    newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
-      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
-    }
     if (newblock == NULL)
       luaD_throw(L, LUA_ERRMEM);
   }

src/loadlib.c+103−46

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: loadlib.c,v 1.113 2014/03/12 20:57:40 roberto Exp $	2	** $Id: loadlib.c,v 1.116 2014/07/29 16:01:00 roberto Exp $
3	** Dynamic library loader for Lua	3	** Dynamic library loader for Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	**	5	**
@@ -97,20 +97,33 @@ · 91 unmodified lines
97		97
98	#define LIB_FAIL "open"	98	#define LIB_FAIL "open"
99		99
100
101	/* error codes for ll_loadfunc */
102	#define ERRLIB 1
103	#define ERRFUNC 2
104
105	#define setprogdir(L) ((void)0)	100	#define setprogdir(L) ((void)0)
106		101
107		102
108	/*	103	/*
109	** system-dependent functions	104	** system-dependent functions
110	*/	105	*/
111	static void ll_unloadlib (void *lib);	106
112	static void ll_load (lua_State L, const char *path, int seeglb);	107	/*
113	static lua_CFunction ll_sym (lua_State L, void lib, const char *sym);	108	** unload library 'lib'
		109	*/
		110	static void lsys_unloadlib (void *lib);
		111
		112	/*
		113	** load C library in file 'path'. If 'seeglb', load with all names in
		114	** the library global.
		115	** Returns the library; in case of error, returns NULL plus an
		116	** error string in the stack.
		117	*/
		118	static void lsys_load (lua_State L, const char *path, int seeglb);
		119
		120	/*
		121	** Try to find a function named 'sym' in library 'lib'.
		122	** Returns the function; in case of error, returns NULL plus an
		123	** error string in the stack.
		124	*/
		125	static lua_CFunction lsys_sym (lua_State L, void lib, const char *sym);
		126
114		127
115		128
116		129
@@ -126,19 +139,19 @@ static lua_CFunction ll_sym (lua_State L, void lib, const char *sym); · 9 unmodified lines
126		139
127	#include <dlfcn.h>	140	#include <dlfcn.h>
128		141
129	static void ll_unloadlib (void *lib) {	142	static void lsys_unloadlib (void *lib) {
130	dlclose(lib);	143	dlclose(lib);
131	}	144	}
132		145
133		146
134	static void ll_load (lua_State L, const char *path, int seeglb) {	147	static void lsys_load (lua_State L, const char *path, int seeglb) {
135	void *lib = dlopen(path, RTLD_NOW \| (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));	148	void *lib = dlopen(path, RTLD_NOW \| (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
136	if (lib == NULL) lua_pushstring(L, dlerror());	149	if (lib == NULL) lua_pushstring(L, dlerror());
137	return lib;	150	return lib;
138	}	151	}
139		152
140		153
141	static lua_CFunction ll_sym (lua_State L, void lib, const char *sym) {	154	static lua_CFunction lsys_sym (lua_State L, void lib, const char *sym) {
142	lua_CFunction f = (lua_CFunction)dlsym(lib, sym);	155	lua_CFunction f = (lua_CFunction)dlsym(lib, sym);
143	if (f == NULL) lua_pushstring(L, dlerror());	156	if (f == NULL) lua_pushstring(L, dlerror());
144	return f;	157	return f;
@@ -190,12 +203,12 @@ static void pusherror (lua_State *L) { · 45 unmodified lines
190	lua_pushfstring(L, "system error %d\n", error);	203	lua_pushfstring(L, "system error %d\n", error);
191	}	204	}
192		205
193	static void ll_unloadlib (void *lib) {	206	static void lsys_unloadlib (void *lib) {
194	FreeLibrary((HMODULE)lib);	207	FreeLibrary((HMODULE)lib);
195	}	208	}
196		209
197		210
198	static void ll_load (lua_State L, const char *path, int seeglb) {	211	static void lsys_load (lua_State L, const char *path, int seeglb) {
199	HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);	212	HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
200	(void)(seeglb); /* not used: symbols are 'global' by default */	213	(void)(seeglb); /* not used: symbols are 'global' by default */
201	if (lib == NULL) pusherror(L);	214	if (lib == NULL) pusherror(L);
@@ -203,7 +216,7 @@ static void ll_load (lua_State L, const char *path, int seeglb) { · 1 unmodified line
203	}	216	}
204		217
205		218
206	static lua_CFunction ll_sym (lua_State L, void lib, const char *sym) {	219	static lua_CFunction lsys_sym (lua_State L, void lib, const char *sym) {
207	lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym);	220	lua_CFunction f = (lua_CFunction)GetProcAddress((HMODULE)lib, sym);
208	if (f == NULL) pusherror(L);	221	if (f == NULL) pusherror(L);
209	return f;	222	return f;
@@ -226,19 +239,19 @@ static lua_CFunction ll_sym (lua_State L, void lib, const char *sym) { · 16 unmodified lines
226	#define DLMSG "dynamic libraries not enabled; check your Lua installation"	239	#define DLMSG "dynamic libraries not enabled; check your Lua installation"
227		240
228		241
229	static void ll_unloadlib (void *lib) {	242	static void lsys_unloadlib (void *lib) {
230	(void)(lib); /* not used */	243	(void)(lib); /* not used */
231	}	244	}
232		245
233		246
234	static void ll_load (lua_State L, const char *path, int seeglb) {	247	static void lsys_load (lua_State L, const char *path, int seeglb) {
235	(void)(path); (void)(seeglb); /* not used */	248	(void)(path); (void)(seeglb); /* not used */
236	lua_pushliteral(L, DLMSG);	249	lua_pushliteral(L, DLMSG);
237	return NULL;	250	return NULL;
238	}	251	}
239		252
240		253
241	static lua_CFunction ll_sym (lua_State L, void lib, const char *sym) {	254	static lua_CFunction lsys_sym (lua_State L, void lib, const char *sym) {
242	(void)(lib); (void)(sym); /* not used */	255	(void)(lib); (void)(sym); /* not used */
243	lua_pushliteral(L, DLMSG);	256	lua_pushliteral(L, DLMSG);
244	return NULL;	257	return NULL;
@@ -248,7 +261,10 @@ static lua_CFunction ll_sym (lua_State L, void lib, const char *sym) { · 3 unmodified lines
248	#endif	261	#endif
249		262
250		263
251	static void ll_checkclib (lua_State L, const char *path) {	264	/*
		265	** return registry.CLIBS[path]
		266	*/
		267	static void checkclib (lua_State L, const char *path) {
252	void *plib;	268	void *plib;
253	lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);	269	lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
254	lua_getfield(L, -1, path);	270	lua_getfield(L, -1, path);
@@ -258,7 +274,11 @@ static void ll_checkclib (lua_State L, const char *path) { · 3 unmodified lines
258	}	274	}
259		275
260		276
261	static void ll_addtoclib (lua_State L, const char path, void *plib) {	277	/*
		278	** registry.CLIBS[path] = plib -- for queries
		279	** registry.CLIBS[#CLIBS + 1] = plib -- also keep a list of all libraries
		280	*/
		281	static void addtoclib (lua_State L, const char path, void *plib) {
262	lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);	282	lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
263	lua_pushlightuserdata(L, plib);	283	lua_pushlightuserdata(L, plib);
264	lua_pushvalue(L, -1);	284	lua_pushvalue(L, -1);
@@ -269,33 +289,49 @@ static void ll_addtoclib (lua_State L, const char path, void *plib) { · 4 unmodified lines
269		289
270		290
271	/*	291	/*
272	** __gc tag method for CLIBS table: calls 'll_unloadlib' for all lib	292	** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
273	** handles in list CLIBS	293	** handles in list CLIBS
274	*/	294	*/
275	static int gctm (lua_State *L) {	295	static int gctm (lua_State *L) {
276	int n = luaL_len(L, 1);	296	lua_Integer n = luaL_len(L, 1);
277	for (; n >= 1; n--) { /* for each handle, in reverse order */	297	for (; n >= 1; n--) { /* for each handle, in reverse order */
278	lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */	298	lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */
279	ll_unloadlib(lua_touserdata(L, -1));	299	lsys_unloadlib(lua_touserdata(L, -1));
280	lua_pop(L, 1); /* pop handle */	300	lua_pop(L, 1); /* pop handle */
281	}	301	}
282	return 0;	302	return 0;
283	}	303	}
284		304
285		305
286	static int ll_loadfunc (lua_State L, const char path, const char *sym) {	306
287	void reg = ll_checkclib(L, path); / check loaded C libraries */	307	/* error codes for 'lookforfunc' */
		308	#define ERRLIB 1
		309	#define ERRFUNC 2
		310
		311	/*
		312	** Look for a C function named 'sym' in a dynamically loaded library
		313	** 'path'.
		314	** First, check whether the library is already loaded; if not, try
		315	** to load it.
		316	** Then, if 'sym' is '*', return true (as library has been loaded).
		317	** Otherwise, look for symbol 'sym' in the library and push a
		318	** C function with that symbol.
		319	** Return 0 and 'true' or a function in the stack; in case of
		320	** errors, return an error code and an error message in the stack.
		321	*/
		322	static int lookforfunc (lua_State L, const char path, const char *sym) {
		323	void reg = checkclib(L, path); / check loaded C libraries */
288	if (reg == NULL) { /* must load library? */	324	if (reg == NULL) { /* must load library? */
289	reg = ll_load(L, path, sym == '');	325	reg = lsys_load(L, path, sym == ''); /* global symbols if 'sym'=='' /
290	if (reg == NULL) return ERRLIB; /* unable to load library */	326	if (reg == NULL) return ERRLIB; /* unable to load library */
291	ll_addtoclib(L, path, reg);	327	addtoclib(L, path, reg);
292	}	328	}
293	if (sym == '') { /* loading only library (no function)? */	329	if (sym == '') { /* loading only library (no function)? */
294	lua_pushboolean(L, 1); /* return 'true' */	330	lua_pushboolean(L, 1); /* return 'true' */
295	return 0; /* no errors */	331	return 0; /* no errors */
296	}	332	}
297	else {	333	else {
298	lua_CFunction f = ll_sym(L, reg, sym);	334	lua_CFunction f = lsys_sym(L, reg, sym);
299	if (f == NULL)	335	if (f == NULL)
300	return ERRFUNC; /* unable to find function */	336	return ERRFUNC; /* unable to find function */
301	lua_pushcfunction(L, f); /* else create new function */	337	lua_pushcfunction(L, f); /* else create new function */
@@ -307,7 +343,7 @@ static int ll_loadfunc (lua_State L, const char path, const char *sym) { · 5 unmodified lines
307	static int ll_loadlib (lua_State *L) {	343	static int ll_loadlib (lua_State *L) {
308	const char *path = luaL_checkstring(L, 1);	344	const char *path = luaL_checkstring(L, 1);
309	const char *init = luaL_checkstring(L, 2);	345	const char *init = luaL_checkstring(L, 2);
310	int stat = ll_loadfunc(L, path, init);	346	int stat = lookforfunc(L, path, init);
311	if (stat == 0) /* no errors? */	347	if (stat == 0) /* no errors? */
312	return 1; /* return the loaded function */	348	return 1; /* return the loaded function */
313	else { /* error; error message is on stack top */	349	else { /* error; error message is on stack top */
@@ -416,21 +452,29 @@ static int searcher_Lua (lua_State *L) { · 102 unmodified lines
416	}	452	}
417		453
418		454
		455	/*
		456	** Try to find a load function for module 'modname' at file 'filename'.
		457	** First, change '.' to '_' in 'modname'; then, if 'modname' has
		458	** the form X-Y (that is, it has an "ignore mark"), build a function
		459	** name "luaopen_X" and look for it. (For compatibility, if that
		460	** fails, it also tries "luaopen_Y".) If there is no ignore mark,
		461	** look for a function named "luaopen_modname".
		462	*/
419	static int loadfunc (lua_State L, const char filename, const char *modname) {	463	static int loadfunc (lua_State L, const char filename, const char *modname) {
420	const char *funcname;	464	const char *openfunc;
421	const char *mark;	465	const char *mark;
422	modname = luaL_gsub(L, modname, ".", LUA_OFSEP);	466	modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
423	mark = strchr(modname, *LUA_IGMARK);	467	mark = strchr(modname, *LUA_IGMARK);
424	if (mark) {	468	if (mark) {
425	int stat;	469	int stat;
426	funcname = lua_pushlstring(L, modname, mark - modname);	470	openfunc = lua_pushlstring(L, modname, mark - modname);
427	funcname = lua_pushfstring(L, LUA_POF"%s", funcname);	471	openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
428	stat = ll_loadfunc(L, filename, funcname);	472	stat = lookforfunc(L, filename, openfunc);
429	if (stat != ERRFUNC) return stat;	473	if (stat != ERRFUNC) return stat;
430	modname = mark + 1; /* else go ahead and try old-style name */	474	modname = mark + 1; /* else go ahead and try old-style name */
431	}	475	}
432	funcname = lua_pushfstring(L, LUA_POF"%s", modname);	476	openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
433	return ll_loadfunc(L, filename, funcname);	477	return lookforfunc(L, filename, openfunc);
434	}	478	}
435		479
436		480
@@ -655,6 +699,12 @@ static const luaL_Reg pk_funcs[] = { · 218 unmodified lines
655	#if defined(LUA_COMPAT_MODULE)	699	#if defined(LUA_COMPAT_MODULE)
656	{"seeall", ll_seeall},	700	{"seeall", ll_seeall},
657	#endif	701	#endif
		702	/* placeholders */
		703	{"preload", NULL},
		704	{"cpath", NULL},
		705	{"path", NULL},
		706	{"searchers", NULL},
		707	{"loaded", NULL},
658	{NULL, NULL}	708	{NULL, NULL}
659	};	709	};
660		710
@@ -680,24 +730,31 @@ static void createsearcherstable (lua_State *L) { · 19 unmodified lines
680	lua_pushcclosure(L, searchers[i], 1);	730	lua_pushcclosure(L, searchers[i], 1);
681	lua_rawseti(L, -2, i+1);	731	lua_rawseti(L, -2, i+1);
682	}	732	}
		733	#if defined(LUA_COMPAT_LOADERS)
		734	lua_pushvalue(L, -1); /* make a copy of 'searchers' table */
		735	lua_setfield(L, -3, "loaders"); /* put it in field `loaders' */
		736	#endif
		737	lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */
683	}	738	}
684		739
685		740
686	LUAMOD_API int luaopen_package (lua_State *L) {	741	/*
687	/* create table CLIBS to keep track of loaded C libraries */	742	** create table CLIBS to keep track of loaded C libraries,
688	luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS);	743	** setting a finalizer to close all libraries when closing state.
689	lua_createtable(L, 0, 1); /* metatable for CLIBS */	744	*/
		745	static void createclibstable (lua_State *L) {
		746	luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS); /* create CLIBS table */
		747	lua_createtable(L, 0, 1); /* create metatable for CLIBS */
690	lua_pushcfunction(L, gctm);	748	lua_pushcfunction(L, gctm);
691	lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */	749	lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */
692	lua_setmetatable(L, -2);	750	lua_setmetatable(L, -2);
693	/* create `package' table */	751	}
694	luaL_newlib(L, pk_funcs);	752
		753
		754	LUAMOD_API int luaopen_package (lua_State *L) {
		755	createclibstable(L);
		756	luaL_newlib(L, pk_funcs); /* create `package' table */
695	createsearcherstable(L);	757	createsearcherstable(L);
696	#if defined(LUA_COMPAT_LOADERS)
697	lua_pushvalue(L, -1); /* make a copy of 'searchers' table */
698	lua_setfield(L, -3, "loaders"); /* put it in field `loaders' */
699	#endif
700	lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */
701	/* set field 'path' */	758	/* set field 'path' */
702	setpath(L, "path", LUA_PATHVARVERSION, LUA_PATH_VAR, LUA_PATH_DEFAULT);	759	setpath(L, "path", LUA_PATHVARVERSION, LUA_PATH_VAR, LUA_PATH_DEFAULT);
703	/* set field 'cpath' */	760	/* set field 'cpath' */

src/lobject.c+34−9

 /*
-** $Id: lobject.c,v 2.86 2014/05/12 21:44:17 roberto Exp $
+** $Id: lobject.c,v 2.88 2014/07/30 14:00:14 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
   char *endptr;
   if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
     return NULL;
-  else if (strpbrk(s, "xX"))  /* hexa? */
+  else if (strpbrk(s, "xX"))  /* hex? */
     *result = lua_strx2number(s, &endptr);
   else
     *result = lua_str2number(s, &endptr);
   while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
   neg = isneg(&s);
   if (s[0] == '0' &&
-      (s[1] == 'x' || s[1] == 'X')) {  /* hexa? */
+      (s[1] == 'x' || s[1] == 'X')) {  /* hex? */
     s += 2;  /* skip '0x' */
     for (; lisxdigit(cast_uchar(*s)); s++) {
       a = a * 16 + luaO_hexavalue(cast_uchar(*s));
 }
+/* maximum length of the conversion of a number to a string */
+#define MAXNUMBER2STR	50
+/*
+** Convert a number object to a string
+*/
+void luaO_tostring (lua_State *L, StkId obj) {
+  char buff[MAXNUMBER2STR];
+  size_t len;
+  lua_assert(ttisnumber(obj));
+  if (ttisinteger(obj))
+    len = lua_integer2str(buff, ivalue(obj));
+  else {
+    len = lua_number2str(buff, fltvalue(obj));
+#if !defined(LUA_COMPAT_FLOATSTRING)
+    if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
+      buff[len++] = '.';
+      buff[len++] = '0';  /* adds '.0' to result */
+    }
+#endif
+  }
+  setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
+}
 static void pushstr (lua_State *L, const char *str, size_t l) {
   setsvalue2s(L, L->top++, luaS_newlstr(L, str, l));
 }
         break;
       }
       case 'c': {
-        char buff;
+        char buff = cast(char, va_arg(argp, int));
-        buff = cast(char, va_arg(argp, int));
         pushstr(L, &buff, 1);
         break;
       }
       case 'd': {
-        setivalue(L->top++, cast_int(va_arg(argp, int)));
+        setivalue(L->top++, va_arg(argp, int));
-        luaV_tostring(L, L->top - 1);
+        luaO_tostring(L, L->top - 1);
         break;
       }
       case 'I': {
         setivalue(L->top++, cast(lua_Integer, va_arg(argp, l_uacInt)));
-        luaV_tostring(L, L->top - 1);
+        luaO_tostring(L, L->top - 1);
         break;
       }
       case 'f': {
         setfltvalue(L->top++, cast_num(va_arg(argp, l_uacNumber)));
-        luaV_tostring(L, L->top - 1);
+        luaO_tostring(L, L->top - 1);
         break;
       }
       case 'p': {

src/lobject.h+69−38

 /*
-** $Id: lobject.h,v 2.94 2014/06/19 18:39:36 roberto Exp $
+** $Id: lobject.h,v 2.101 2014/07/30 14:00:14 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
 /*
-** Union of all collectable objects
+** Common type for all collectable objects
 */
-typedef union GCObject GCObject;
+typedef struct GCObject GCObject;
 /*
 /*
-** Common header in struct form
+** Common type has only the common header
 */
-typedef struct GCheader {
+struct GCObject {
   CommonHeader;
-} GCheader;
+};
 #define fltvalue(o)	check_exp(ttisfloat(o), val_(o).n)
 #define gcvalue(o)	check_exp(iscollectable(o), val_(o).gc)
 #define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
-#define rawtsvalue(o)	check_exp(ttisstring(o), rawgco2ts(val_(o).gc))
+#define tsvalue(o)	check_exp(ttisstring(o), gco2ts(val_(o).gc))
-#define tsvalue(o)	(&rawtsvalue(o)->tsv)
+#define uvalue(o)	check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
-#define rawuvalue(o)	check_exp(ttisfulluserdata(o), rawgco2u(val_(o).gc))
-#define uvalue(o)	(&rawuvalue(o)->uv)
 #define clvalue(o)	check_exp(ttisclosure(o), gco2cl(val_(o).gc))
 #define clLvalue(o)	check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
 #define clCvalue(o)	check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
 /* Macros for internal tests */
-#define righttt(obj)		(ttype(obj) == gcvalue(obj)->gch.tt)
+#define righttt(obj)		(ttype(obj) == gcvalue(obj)->tt)
 #define checkliveness(g,obj) \
 	lua_longassert(!iscollectable(obj) || \
 #define setgcovalue(L,obj,x) \
   { TValue *io = (obj); GCObject *i_g=(x); \
-    val_(io).gc = i_g; settt_(io, ctb(gch(i_g)->tt)); }
+    val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
 #define setsvalue(L,obj,x) \
   { TValue *io = (obj); TString *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tsv.tt)); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
     checkliveness(G(L),io); }
 #define setuvalue(L,obj,x) \
 #define setobj(L,obj1,obj2) \
-	{ const TValue *io2=(obj2); TValue *io1=(obj1); \
+	{ TValue *io1=(obj1); *io1 = *(obj2); \
-	  io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
 	  (void)L; checkliveness(G(L),io1); }
 /*
 ** Header for string value; string bytes follow the end of this structure
+** (aligned according to 'UTString'; see next).
 */
-typedef union TString {
+typedef struct TString {
-  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
+  CommonHeader;
-  struct {
+  lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
-    CommonHeader;
+  unsigned int hash;
-    lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
+  size_t len;  /* number of characters in string */
-    unsigned int hash;
+  struct TString *hnext;  /* linked list for hash table */
-    size_t len;  /* number of characters in string */
-    union TString *hnext;  /* linked list for hash table */
-  } tsv;
 } TString;
-/* get the actual string (array of bytes) from a TString */
+/*
-#define getstr(ts)	cast(const char *, (ts) + 1)
+** Ensures that address after this type is always fully aligned.
+*/
+typedef union UTString {
+  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
+  TString tsv;
+} UTString;
+/*
+** Get the actual string (array of bytes) from a 'TString'.
+** (Access to 'extra' ensures that value is really a 'TString'.)
+*/
+#define getaddrstr(ts)	(cast(char *, (ts)) + sizeof(UTString))
+#define getstr(ts)  \
+  check_exp(sizeof((ts)->extra), cast(const char*, getaddrstr(ts)))
 /* get the actual string (array of bytes) from a Lua value */
-#define svalue(o)       getstr(rawtsvalue(o))
+#define svalue(o)       getstr(tsvalue(o))
 /*
 ** Header for userdata; memory area follows the end of this structure
+** (aligned according to 'UUdata'; see next).
 */
-typedef union Udata {
+typedef struct Udata {
-  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
+  CommonHeader;
-  struct {
+  lu_byte ttuv_;  /* user value's tag */
-    CommonHeader;
+  struct Table *metatable;
-    lu_byte ttuv_;  /* user value's tag */
+  size_t len;  /* number of bytes */
-    struct Table *metatable;
+  union Value user_;  /* user value */
-    size_t len;  /* number of bytes */
-    union Value user_;  /* user value */
-  } uv;
 } Udata;
+/*
+** Ensures that address after this type is always fully aligned.
+*/
+typedef union UUdata {
+  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
+  Udata uv;
+} UUdata;
+/*
+**  Get the address of memory block inside 'Udata'.
+** (Access to 'ttuv_' ensures that value is really a 'Udata'.)
+*/
+#define getudatamem(u)  \
+  check_exp(sizeof((u)->ttuv_), (cast(char*, (u)) + sizeof(UUdata)))
 #define setuservalue(L,u,o) \
 	{ const TValue *io=(o); Udata *iu = (u); \
-	  iu->uv.user_ = io->value_; iu->uv.ttuv_ = io->tt_; \
+	  iu->user_ = io->value_; iu->ttuv_ = io->tt_; \
 	  checkliveness(G(L),io); }
 #define getuservalue(L,u,o) \
 	{ TValue *io=(o); const Udata *iu = (u); \
-	  io->value_ = iu->uv.user_; io->tt_ = iu->uv.ttuv_; \
+	  io->value_ = iu->user_; io->tt_ = iu->ttuv_; \
 	  checkliveness(G(L),io); }
 } TKey;
+/* copy a value into a key without messing up field 'next' */
+#define setkey(L,key,obj) \
+	{ TKey *k_=(key); const TValue *io_=(obj); \
+	  k_->nk.value_ = io_->value_; k_->nk.tt_ = io_->tt_; \
+	  (void)L; checkliveness(G(L),io_); }
 typedef struct Node {
   TValue i_val;
   TKey i_key;
                            const TValue *p2, TValue *res);
 LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
 LUAI_FUNC int luaO_hexavalue (int c);
+LUAI_FUNC void luaO_tostring (lua_State *L, StkId obj);
 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
                                                        va_list argp);
 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);

src/lparser.c+1−1

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lparser.c,v 2.139 2014/06/19 18:27:20 roberto Exp $	2	** $Id: lparser.c,v 2.142 2014/07/21 16:02:10 roberto Exp $
3	** Lua Parser	3	** Lua Parser
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/

src/lstate.c+7−5

 /*
-** $Id: lstate.c,v 2.121 2014/02/18 13:46:26 roberto Exp $
+** $Id: lstate.c,v 2.125 2014/07/24 16:17:56 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 ** thread state + extra space
 */
 typedef struct LX {
-#if defined(LUAI_EXTRASPACE)
+  lu_byte extra_[LUA_EXTRASPACE];
-  char buff[LUAI_EXTRASPACE];
-#endif
   lua_State l;
 } LX;
 LUA_API lua_State *lua_newthread (lua_State *L) {
-    global_State *g = G(L);
+  global_State *g = G(L);
   lua_State *L1;
   lua_lock(L);
   luaC_checkGC(L);
   /* link it on list 'allgc' */
   L1->next = g->allgc;
   g->allgc = obj2gco(L1);
+  /* anchor it on L stack */
   setthvalue(L, L->top, L1);
   api_incr_top(L);
   preinit_thread(L1, g);
   L1->basehookcount = L->basehookcount;
   L1->hook = L->hook;
   resethookcount(L1);
+  /* initialize L1 extra space */
+  memcpy(lua_getextraspace(L1), lua_getextraspace(g->mainthread),
+         LUA_EXTRASPACE);
   luai_userstatethread(L, L1);
   stack_init(L1, L);  /* init stack */
   lua_unlock(L);

src/lstate.h+33−33

 /*
-** $Id: lstate.h,v 2.107 2014/06/12 19:07:30 roberto Exp $
+** $Id: lstate.h,v 2.114 2014/07/23 17:15:43 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
   StkId func;  /* function index in the stack */
   StkId	top;  /* top for this function */
   struct CallInfo *previous, *next;  /* dynamic call link */
-  ptrdiff_t extra;
-  short nresults;  /* expected number of results from this function */
-  lu_byte callstatus;
   union {
     struct {  /* only for Lua functions */
       StkId base;  /* base for this function */
     struct {  /* only for C functions */
       lua_KFunction k;  /* continuation in case of yields */
       ptrdiff_t old_errfunc;
-      int ctx;  /* context info. in case of yields */
+      lua_Ctx ctx;  /* context info. in case of yields */
     } c;
   } u;
+  ptrdiff_t extra;
+  short nresults;  /* expected number of results from this function */
+  lu_byte callstatus;
 } CallInfo;
   const Instruction *oldpc;  /* last pc traced */
   StkId stack_last;  /* last free slot in the stack */
   StkId stack;  /* stack base */
-  int stacksize;
-  unsigned short nny;  /* number of non-yieldable calls in stack */
-  unsigned short nCcalls;  /* number of nested C calls */
-  lu_byte hookmask;
-  lu_byte allowhook;
-  int basehookcount;
-  int hookcount;
-  lua_Hook hook;
   UpVal *openupval;  /* list of open upvalues in this stack */
   GCObject *gclist;
   struct lua_State *twups;  /* list of threads with open upvalues */
   struct lua_longjmp *errorJmp;  /* current error recover point */
-  ptrdiff_t errfunc;  /* current error handling function (stack index) */
   CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
+  lua_Hook hook;
+  ptrdiff_t errfunc;  /* current error handling function (stack index) */
+  int stacksize;
+  int basehookcount;
+  int hookcount;
+  unsigned short nny;  /* number of non-yieldable calls in stack */
+  unsigned short nCcalls;  /* number of nested C calls */
+  lu_byte hookmask;
+  lu_byte allowhook;
 };
 /*
-** Union of all collectable objects
+** Union of all collectable objects (only for conversions)
 */
-union GCObject {
+union GCUnion {
-  GCheader gch;  /* common header */
+  GCObject gc;  /* common header */
-  union TString ts;
+  struct TString ts;
-  union Udata u;
+  struct Udata u;
   union Closure cl;
   struct Table h;
   struct Proto p;
 };
-#define gch(o)		(&(o)->gch)
+#define cast_u(o)	cast(union GCUnion *, (o))
 /* macros to convert a GCObject into a specific value */
-#define rawgco2ts(o)  \
+#define gco2ts(o)  \
-	check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts))
+	check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts))
-#define gco2ts(o)	(&rawgco2ts(o)->tsv)
+#define gco2u(o)  check_exp((o)->tt == LUA_TUSERDATA, &((cast_u(o))->u))
-#define rawgco2u(o)	check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
+#define gco2lcl(o)  check_exp((o)->tt == LUA_TLCL, &((cast_u(o))->cl.l))
-#define gco2u(o)	(&rawgco2u(o)->uv)
+#define gco2ccl(o)  check_exp((o)->tt == LUA_TCCL, &((cast_u(o))->cl.c))
-#define gco2lcl(o)	check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l))
-#define gco2ccl(o)	check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c))
 #define gco2cl(o)  \
-	check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl))
+	check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl))
-#define gco2t(o)	check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
+#define gco2t(o)  check_exp((o)->tt == LUA_TTABLE, &((cast_u(o))->h))
-#define gco2p(o)	check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
+#define gco2p(o)  check_exp((o)->tt == LUA_TPROTO, &((cast_u(o))->p))
-#define gco2th(o)	check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
+#define gco2th(o)  check_exp((o)->tt == LUA_TTHREAD, &((cast_u(o))->th))
-/* macro to convert any Lua object into a GCObject */
+/* macro to convert a Lua object into a GCObject */
-#define obj2gco(v)	(cast(GCObject *, (v)))
+#define obj2gco(v) \
+	check_exp(novariant((v)->tt) < LUA_TDEADKEY, (&(cast_u(v)->gc)))
 /* actual number of total bytes allocated */

src/lstring.c+26−26

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lstring.c,v 2.40 2014/06/18 22:59:29 roberto Exp $	2	** $Id: lstring.c,v 2.44 2014/07/21 16:02:10 roberto Exp $
3	** String table (keeps all strings handled by Lua)	3	** String table (keeps all strings handled by Lua)
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -34,10 +34,10 @@ · 28 unmodified lines
34	** equality for long strings	34	** equality for long strings
35	*/	35	*/
36	int luaS_eqlngstr (TString a, TString b) {	36	int luaS_eqlngstr (TString a, TString b) {
37	size_t len = a->tsv.len;	37	size_t len = a->len;
38	lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR);	38	lua_assert(a->tt == LUA_TLNGSTR && b->tt == LUA_TLNGSTR);
39	return (a == b) \|\| /* same instance or... */	39	return (a == b) \|\| /* same instance or... */
40	((len == b->tsv.len) && /* equal length and ... */	40	((len == b->len) && /* equal length and ... */
41	(memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */	41	(memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */
42	}	42	}
43		43
@@ -67,9 +67,9 @@ void luaS_resize (lua_State *L, int newsize) { · 23 unmodified lines
67	TString *p = tb->hash[i];	67	TString *p = tb->hash[i];
68	tb->hash[i] = NULL;	68	tb->hash[i] = NULL;
69	while (p) { /* for each node in the list */	69	while (p) { /* for each node in the list */
70	TString hnext = p->tsv.hnext; / save next */	70	TString hnext = p->hnext; / save next */
71	unsigned int h = lmod(p->tsv.hash, newsize); /* new position */	71	unsigned int h = lmod(p->hash, newsize); /* new position */
72	p->tsv.hnext = tb->hash[h]; /* chain it */	72	p->hnext = tb->hash[h]; /* chain it */
73	tb->hash[h] = p;	73	tb->hash[h] = p;
74	p = hnext;	74	p = hnext;
75	}	75	}
@@ -92,24 +92,24 @@ static TString createstrobj (lua_State L, const char *str, size_t l, · 16 unmodified lines
92	TString *ts;	92	TString *ts;
93	GCObject *o;	93	GCObject *o;
94	size_t totalsize; /* total size of TString object */	94	size_t totalsize; /* total size of TString object */
95	totalsize = sizeof(TString) + ((l + 1) * sizeof(char));	95	totalsize = sizelstring(l);
96	o = luaC_newobj(L, tag, totalsize);	96	o = luaC_newobj(L, tag, totalsize);
97	ts = rawgco2ts(o);	97	ts = gco2ts(o);
98	ts->tsv.len = l;	98	ts->len = l;
99	ts->tsv.hash = h;	99	ts->hash = h;
100	ts->tsv.extra = 0;	100	ts->extra = 0;
101	memcpy(ts+1, str, l*sizeof(char));	101	memcpy(getaddrstr(ts), str, l * sizeof(char));
102	((char )(ts+1))[l] = '\0'; / ending 0 */	102	getaddrstr(ts)[l] = '\0'; /* ending 0 */
103	return ts;	103	return ts;
104	}	104	}
105		105
106		106
107	void luaS_remove (lua_State L, TString ts) {	107	void luaS_remove (lua_State L, TString ts) {
108	stringtable *tb = &G(L)->strt;	108	stringtable *tb = &G(L)->strt;
109	TString **p = &tb->hash[lmod(ts->tsv.hash, tb->size)];	109	TString **p = &tb->hash[lmod(ts->hash, tb->size)];
110	while (p != ts) / find previous element */	110	while (p != ts) / find previous element */
111	p = &(*p)->tsv.hnext;	111	p = &(*p)->hnext;
112	p = (p)->tsv.hnext; /* remove element from its list */	112	p = (p)->hnext; /* remove element from its list */
113	tb->nuse--;	113	tb->nuse--;
114	}	114	}
115		115
@@ -122,12 +122,12 @@ static TString internshrstr (lua_State L, const char *str, size_t l) { · 6 unmodified lines
122	global_State *g = G(L);	122	global_State *g = G(L);
123	unsigned int h = luaS_hash(str, l, g->seed);	123	unsigned int h = luaS_hash(str, l, g->seed);
124	TString **list = &g->strt.hash[lmod(h, g->strt.size)];	124	TString **list = &g->strt.hash[lmod(h, g->strt.size)];
125	for (ts = *list; ts != NULL; ts = ts->tsv.hnext) {	125	for (ts = *list; ts != NULL; ts = ts->hnext) {
126	if (l == ts->tsv.len &&	126	if (l == ts->len &&
127	(memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {	127	(memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
128	/* found! */	128	/* found! */
129	if (isdead(g, obj2gco(ts))) /* dead (but not collected yet)? */	129	if (isdead(g, ts)) /* dead (but not collected yet)? */
130	changewhite(obj2gco(ts)); /* resurrect it */	130	changewhite(ts); /* resurrect it */
131	return ts;	131	return ts;
132	}	132	}
133	}	133	}
@@ -136,7 +136,7 @@ static TString internshrstr (lua_State L, const char *str, size_t l) { · 2 unmodified lines
136	list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */	136	list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */
137	}	137	}
138	ts = createstrobj(L, str, l, LUA_TSHRSTR, h);	138	ts = createstrobj(L, str, l, LUA_TSHRSTR, h);
139	ts->tsv.hnext = *list;	139	ts->hnext = *list;
140	*list = ts;	140	*list = ts;
141	g->strt.nuse++;	141	g->strt.nuse++;
142	return ts;	142	return ts;
@@ -170,10 +170,10 @@ Udata luaS_newudata (lua_State L, size_t s) { · 27 unmodified lines
170	GCObject *o;	170	GCObject *o;
171	if (s > MAX_SIZE - sizeof(Udata))	171	if (s > MAX_SIZE - sizeof(Udata))
172	luaM_toobig(L);	172	luaM_toobig(L);
173	o = luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s);	173	o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s));
174	u = rawgco2u(o);	174	u = gco2u(o);
175	u->uv.len = s;	175	u->len = s;
176	u->uv.metatable = NULL;	176	u->metatable = NULL;
177	setuservalue(L, u, luaO_nilobject);	177	setuservalue(L, u, luaO_nilobject);
178	return u;	178	return u;
179	}	179	}

src/lstring.h+7−5

 /*
-** $Id: lstring.h,v 1.54 2014/03/19 18:51:42 roberto Exp $
+** $Id: lstring.h,v 1.56 2014/07/18 14:46:47 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #include "lstate.h"
-#define sizestring(s)	(sizeof(union TString)+((s)->len+1)*sizeof(char))
+#define sizelstring(l)  (sizeof(union UTString) + ((l) + 1) * sizeof(char))
+#define sizestring(s)	sizelstring((s)->len)
-#define sizeudata(u)	(sizeof(union Udata)+(u)->len)
+#define sizeludata(l)	(sizeof(union UUdata) + (l))
+#define sizeudata(u)	sizeludata((u)->len)
 #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
                                  (sizeof(s)/sizeof(char))-1))
 /*
 ** test whether a string is a reserved word
 */
-#define isreserved(s)	((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0)
+#define isreserved(s)	((s)->tt == LUA_TSHRSTR && (s)->extra > 0)
 /*
 ** equality for short strings, which are always internalized
 */
-#define eqshrstr(a,b)	check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b))
+#define eqshrstr(a,b)	check_exp((a)->tt == LUA_TSHRSTR, (a) == (b))
 LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);

src/lstrlib.c+12−9

 /*
-** $Id: lstrlib.c,v 1.198 2014/04/27 14:42:26 roberto Exp $
+** $Id: lstrlib.c,v 1.200 2014/07/30 13:59:24 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
   if (start < 1) start = 1;
   if (end > (lua_Integer)l) end = l;
   if (start <= end)
-    lua_pushlstring(L, s + start - 1, end - start + 1);
+    lua_pushlstring(L, s + start - 1, (size_t)(end - start + 1));
   else lua_pushliteral(L, "");
   return 1;
 }
   else if (l + lsep < l || l + lsep > MAXSIZE / n)  /* may overflow? */
     return luaL_error(L, "resulting string too large");
   else {
-    size_t totallen = n * l + (n - 1) * lsep;
+    size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep;
     luaL_Buffer b;
     char *p = luaL_buffinitsize(L, &b, totallen);
     while (n-- > 1) {  /* first n-1 copies (followed by separator) */
   /* explicit request or no special characters? */
   if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {
     /* do a plain search */
-    const char *s2 = lmemfind(s + init - 1, ls - init + 1, p, lp);
+    const char *s2 = lmemfind(s + init - 1, ls - (size_t)init + 1, p, lp);
     if (s2) {
       lua_pushinteger(L, s2 - s + 1);
       lua_pushinteger(L, s2 - s + lp);
 static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
                                                    const char *e) {
   size_t l, i;
-  const char *news = lua_tolstring(ms->L, 3, &l);
+  lua_State *L = ms->L;
+  const char *news = lua_tolstring(L, 3, &l);
   for (i = 0; i < l; i++) {
     if (news[i] != L_ESC)
       luaL_addchar(b, news[i]);
       i++;  /* skip ESC */
       if (!isdigit(uchar(news[i]))) {
         if (news[i] != L_ESC)
-          luaL_error(ms->L, "invalid use of " LUA_QL("%c")
+          luaL_error(L, "invalid use of " LUA_QL("%c")
-                           " in replacement string", L_ESC);
+                        " in replacement string", L_ESC);
         luaL_addchar(b, news[i]);
       }
       else if (news[i] == '0')
           luaL_addlstring(b, s, e - s);
       else {
         push_onecapture(ms, news[i] - '1', s, e);
+        luaL_tolstring(L, -1, NULL);  /* if number, convert it to string */
+        lua_remove(L, -2);  /* remove original value */
         luaL_addvalue(b);  /* add capture to accumulated result */
       }
     }
   const char *src = luaL_checklstring(L, 1, &srcl);
   const char *p = luaL_checklstring(L, 2, &lp);
   int tr = lua_type(L, 3);
-  size_t max_s = luaL_optinteger(L, 4, srcl+1);
+  lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1);
   int anchor = (*p == '^');
-  size_t n = 0;
+  lua_Integer n = 0;
   MatchState ms;
   luaL_Buffer b;
   luaL_argcheck(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||

src/ltable.c+15−14

 /*
-** $Id: ltable.c,v 2.90 2014/06/18 22:59:29 roberto Exp $
+** $Id: ltable.c,v 2.93 2014/07/29 16:22:24 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define hashpow2(t,n)		(gnode(t, lmod((n), sizenode(t))))
-#define hashstr(t,str)		hashpow2(t, (str)->tsv.hash)
+#define hashstr(t,str)		hashpow2(t, (str)->hash)
 #define hashboolean(t,p)	hashpow2(t, p)
 #define hashint(t,i)		hashpow2(t, i)
 #define hashmod(t,n)	(gnode(t, ((n) % ((sizenode(t)-1)|1))))
-#define hashpointer(t,p)	hashmod(t, IntPoint(p))
+#define hashpointer(t,p)	hashmod(t, point2int(p))
 #define dummynode		(&dummynode_)
     case LUA_TNUMFLT:
       return hashfloat(t, fltvalue(key));
     case LUA_TSHRSTR:
-      return hashstr(t, rawtsvalue(key));
+      return hashstr(t, tsvalue(key));
     case LUA_TLNGSTR: {
-      TString *s = rawtsvalue(key);
+      TString *s = tsvalue(key);
-      if (s->tsv.extra == 0) {  /* no hash? */
+      if (s->extra == 0) {  /* no hash? */
-        s->tsv.hash = luaS_hash(getstr(s), s->tsv.len, s->tsv.hash);
+        s->hash = luaS_hash(getstr(s), s->len, s->hash);
-        s->tsv.extra = 1;  /* now it has its hash */
+        s->extra = 1;  /* now it has its hash */
       }
-      return hashstr(t, rawtsvalue(key));
+      return hashstr(t, tsvalue(key));
     }
     case LUA_TBOOLEAN:
       return hashboolean(t, bvalue(key));
     for (i=0; i<size; i++) {
       Node *n = gnode(t, i);
       gnext(n) = 0;
-      setnilvalue(gkey(n));
+      setnilvalue(wgkey(n));
       setnilvalue(gval(n));
     }
   }
       mp = f;
     }
   }
-  setobj2t(L, gkey(mp), key);
+  setkey(L, &mp->i_key, key);
   luaC_barrierback(L, t, key);
   lua_assert(ttisnil(gval(mp)));
   return gval(mp);
 */
 const TValue *luaH_getstr (Table *t, TString *key) {
   Node *n = hashstr(t, key);
-  lua_assert(key->tsv.tt == LUA_TSHRSTR);
+  lua_assert(key->tt == LUA_TSHRSTR);
   for (;;) {  /* check whether `key' is somewhere in the chain */
-    if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key))
+    const TValue *k = gkey(n);
+    if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
       return gval(n);  /* that's it */
     else {
       int nx = gnext(n);
 */
 const TValue *luaH_get (Table *t, const TValue *key) {
   switch (ttype(key)) {
-    case LUA_TSHRSTR: return luaH_getstr(t, rawtsvalue(key));
+    case LUA_TSHRSTR: return luaH_getstr(t, tsvalue(key));
     case LUA_TNUMINT: return luaH_getint(t, ivalue(key));
     case LUA_TNIL: return luaO_nilobject;
     case LUA_TNUMFLT: {

src/ltable.h+7−2

 /*
-** $Id: ltable.h,v 2.18 2013/08/30 16:01:37 roberto Exp $
+** $Id: ltable.h,v 2.19 2014/07/29 16:22:24 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define gnode(t,i)	(&(t)->node[i])
-#define gkey(n)		(&(n)->i_key.tvk)
 #define gval(n)		(&(n)->i_val)
 #define gnext(n)	((n)->i_key.nk.next)
+/* 'const' to avoid wrong writings that can mess up field 'next' */
+#define gkey(n)		cast(const TValue*, (&(n)->i_key.tvk))
+#define wgkey(n)		(&(n)->i_key.nk)
 #define invalidateTMcache(t)	((t)->flags = 0)

src/ltablib.c+137−46

 /*
-** $Id: ltablib.c,v 1.70 2014/05/16 18:53:25 roberto Exp $
+** $Id: ltablib.c,v 1.73 2014/07/29 16:01:00 roberto Exp $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
 #include "lualib.h"
-#define aux_getn(L,n)	(luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n))
+/*
+** Structure with table-access functions
+*/
+typedef struct {
+  int (*geti) (lua_State *L, int idx, lua_Integer n);
+  void (*seti) (lua_State *L, int idx, lua_Integer n);
+} TabA;
+/*
+** equivalent to 'lua_rawgeti', but not raw
+*/
+static int geti (lua_State *L, int idx, lua_Integer n) {
+  lua_pushinteger(L, n);
+  return lua_gettable(L, idx);  /* assume 'idx' is not negative */
+}
+/*
+** equivalent to 'lua_rawseti', but not raw
+*/
+static void seti (lua_State *L, int idx, lua_Integer n) {
+  lua_pushinteger(L, n);
+  lua_rotate(L, -2, 1);  /* exchange key and value */
+  lua_settable(L, idx);  /* assume 'idx' is not negative */
+}
+/*
+** Check that 'arg' has a table and set access functions in 'ta' to raw
+** or non-raw according to the presence of corresponding metamethods.
+*/
+static void checktab (lua_State *L, int arg, TabA *ta) {
+  luaL_checktype(L, arg, LUA_TTABLE);
+  if (!lua_getmetatable(L, arg)) {  /* fast track */
+    ta->geti = lua_rawgeti;  /* with no metatable, all is raw */
+    ta->seti = lua_rawseti;
+  }
+  else {
+    lua_pushliteral(L, "__index");  /* 'index' metamethod */
+    ta->geti = (lua_rawget(L, -2) == LUA_TNIL) ? lua_rawgeti : geti;
+    lua_pushliteral(L, "__newindex");  /* 'newindex' metamethod */
+    ta->seti = (lua_rawget(L, -3) == LUA_TNIL) ? lua_rawseti : seti;
+    lua_pop(L, 3);  /* pop metatable plus both metamethods */
+  }
+}
+#define aux_getn(L,n,ta)	(checktab(L, n, ta), luaL_len(L, n))
 #if defined(LUA_COMPAT_MAXN)
 static int tinsert (lua_State *L) {
-  lua_Integer e = aux_getn(L, 1) + 1;  /* first empty element */
+  TabA ta;
+  lua_Integer e = aux_getn(L, 1, &ta) + 1;  /* first empty element */
   lua_Integer pos;  /* where to insert new element */
   switch (lua_gettop(L)) {
     case 2: {  /* called with only 2 arguments */
       pos = luaL_checkinteger(L, 2);  /* 2nd argument is the position */
       luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds");
       for (i = e; i > pos; i--) {  /* move up elements */
-        lua_rawgeti(L, 1, i-1);
+        (*ta.geti)(L, 1, i - 1);
-        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
+        (*ta.seti)(L, 1, i);  /* t[i] = t[i - 1] */
       }
       break;
     }
       return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
     }
   }
-  lua_rawseti(L, 1, pos);  /* t[pos] = v */
+  (*ta.seti)(L, 1, pos);  /* t[pos] = v */
   return 0;
 }
 static int tremove (lua_State *L) {
-  lua_Integer size = aux_getn(L, 1);
+  TabA ta;
+  lua_Integer size = aux_getn(L, 1, &ta);
   lua_Integer pos = luaL_optinteger(L, 2, size);
   if (pos != size)  /* validate 'pos' if given */
     luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds");
-  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
+  (*ta.geti)(L, 1, pos);  /* result = t[pos] */
   for ( ; pos < size; pos++) {
-    lua_rawgeti(L, 1, pos+1);
+    (*ta.geti)(L, 1, pos + 1);
-    lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
+    (*ta.seti)(L, 1, pos);  /* t[pos] = t[pos + 1] */
   }
   lua_pushnil(L);
-  lua_rawseti(L, 1, pos);  /* t[pos] = nil */
+  (*ta.seti)(L, 1, pos);  /* t[pos] = nil */
+  return 1;
+}
+static int tcopy (lua_State *L) {
+  TabA ta;
+  lua_Integer f = luaL_checkinteger(L, 2);
+  lua_Integer e = luaL_checkinteger(L, 3);
+  lua_Integer t;
+  int tt = 4;  /* destination table */
+  /* the following restriction avoids several problems with overflows */
+  luaL_argcheck(L, f > 0, 2, "initial position must be positive");
+  if (lua_istable(L, tt))
+    t = luaL_checkinteger(L, 5);
+  else {
+    tt = 1;  /* destination table is equal to source */
+    t = luaL_checkinteger(L, 4);
+  }
+  if (e >= f) {  /* otherwise, nothing to move */
+    lua_Integer n, i;
+    ta.geti = (!luaL_getmetafield(L, 1, "__index")) ? lua_rawgeti : geti;
+    ta.seti = (!luaL_getmetafield(L, tt, "__newindex")) ? lua_rawseti : seti;
+    n = e - f + 1;  /* number of elements to move */
+    if (t > f) {
+      for (i = n - 1; i >= 0; i--) {
+        (*ta.geti)(L, 1, f + i);
+        (*ta.seti)(L, tt, t + i);
+      }
+    }
+    else {
+      for (i = 0; i < n; i++) {
+        (*ta.geti)(L, 1, f + i);
+        (*ta.seti)(L, tt, t + i);
+      }
+    }
+  }
+  lua_pushvalue(L, tt);  /* return "to table" */
   return 1;
 }
-static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) {
+static void addfield (lua_State *L, luaL_Buffer *b, TabA *ta, lua_Integer i) {
-  lua_rawgeti(L, 1, i);
+  (*ta->geti)(L, 1, i);
   if (!lua_isstring(L, -1))
     luaL_error(L, "invalid value (%s) at index %d in table for "
                   LUA_QL("concat"), luaL_typename(L, -1), i);
 static int tconcat (lua_State *L) {
+  TabA ta;
   luaL_Buffer b;
   size_t lsep;
   lua_Integer i, last;
   const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  luaL_checktype(L, 1, LUA_TTABLE);
+  checktab(L, 1, &ta);
   i = luaL_optinteger(L, 3, 1);
   last = luaL_opt(L, luaL_checkinteger, 4, luaL_len(L, 1));
   luaL_buffinit(L, &b);
   for (; i < last; i++) {
-    addfield(L, &b, i);
+    addfield(L, &b, &ta, i);
     luaL_addlstring(&b, sep, lsep);
   }
   if (i == last)  /* add last value (if interval was not empty) */
-    addfield(L, &b, i);
+    addfield(L, &b, &ta, i);
   luaL_pushresult(&b);
   return 1;
 }
 static int unpack (lua_State *L) {
+  TabA ta;
   lua_Integer i, e;
   lua_Unsigned n;
-  luaL_checktype(L, 1, LUA_TTABLE);
+  checktab(L, 1, &ta);
   i = luaL_optinteger(L, 2, 1);
   e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
   if (i > e) return 0;  /* empty range */
   n = (lua_Unsigned)e - i;  /* number of elements minus 1 (avoid overflows) */
-  if (n >= (unsigned int)INT_MAX  || !lua_checkstack(L, ++n))
+  if (n >= (unsigned int)INT_MAX  || !lua_checkstack(L, (int)(++n)))
     return luaL_error(L, "too many results to unpack");
   do {  /* must have at least one element */
-    lua_rawgeti(L, 1, i);  /* push arg[i..e] */
+    (*ta.geti)(L, 1, i);  /* push arg[i..e] */
   } while (i++ < e);
-  return n;
+  return (int)n;
 }
 /* }====================================================== */
 */
-static void set2 (lua_State *L, int i, int j) {
+static void set2 (lua_State *L, TabA *ta, int i, int j) {
-  lua_rawseti(L, 1, i);
+  (*ta->seti)(L, 1, i);
-  lua_rawseti(L, 1, j);
+  (*ta->seti)(L, 1, j);
 }
 static int sort_comp (lua_State *L, int a, int b) {
     return lua_compare(L, a, b, LUA_OPLT);
 }
-static void auxsort (lua_State *L, int l, int u) {
+static void auxsort (lua_State *L, TabA *ta, int l, int u) {
   while (l < u) {  /* for tail recursion */
     int i, j;
     /* sort elements a[l], a[(l+u)/2] and a[u] */
-    lua_rawgeti(L, 1, l);
+    (*ta->geti)(L, 1, l);
-    lua_rawgeti(L, 1, u);
+    (*ta->geti)(L, 1, u);
     if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
-      set2(L, l, u);  /* swap a[l] - a[u] */
+      set2(L, ta, l, u);  /* swap a[l] - a[u] */
     else
       lua_pop(L, 2);
     if (u-l == 1) break;  /* only 2 elements */
     i = (l+u)/2;
-    lua_rawgeti(L, 1, i);
+    (*ta->geti)(L, 1, i);
-    lua_rawgeti(L, 1, l);
+    (*ta->geti)(L, 1, l);
     if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
-      set2(L, i, l);
+      set2(L, ta, i, l);
     else {
       lua_pop(L, 1);  /* remove a[l] */
-      lua_rawgeti(L, 1, u);
+      (*ta->geti)(L, 1, u);
       if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
-        set2(L, i, u);
+        set2(L, ta, i, u);
       else
         lua_pop(L, 2);
     }
     if (u-l == 2) break;  /* only 3 elements */
-    lua_rawgeti(L, 1, i);  /* Pivot */
+    (*ta->geti)(L, 1, i);  /* Pivot */
     lua_pushvalue(L, -1);
-    lua_rawgeti(L, 1, u-1);
+    (*ta->geti)(L, 1, u-1);
-    set2(L, i, u-1);
+    set2(L, ta, i, u-1);
     /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
     i = l; j = u-1;
     for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
       /* repeat ++i until a[i] >= P */
-      while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
+      while ((*ta->geti)(L, 1, ++i), sort_comp(L, -1, -2)) {
         if (i>=u) luaL_error(L, "invalid order function for sorting");
         lua_pop(L, 1);  /* remove a[i] */
       }
       /* repeat --j until a[j] <= P */
-      while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
+      while ((*ta->geti)(L, 1, --j), sort_comp(L, -3, -1)) {
         if (j<=l) luaL_error(L, "invalid order function for sorting");
         lua_pop(L, 1);  /* remove a[j] */
       }
         lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
         break;
       }
-      set2(L, i, j);
+      set2(L, ta, i, j);
     }
-    lua_rawgeti(L, 1, u-1);
+    (*ta->geti)(L, 1, u-1);
-    lua_rawgeti(L, 1, i);
+    (*ta->geti)(L, 1, i);
-    set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
+    set2(L, ta, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
     /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
     /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
     if (i-l < u-i) {
     else {
       j=i+1; i=u; u=j-2;
     }
-    auxsort(L, j, i);  /* call recursively the smaller one */
+    auxsort(L, ta, j, i);  /* call recursively the smaller one */
   }  /* repeat the routine for the larger one */
 }
 static int sort (lua_State *L) {
-  int n = aux_getn(L, 1);
+  TabA ta;
-  luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
+  int n = (int)aux_getn(L, 1, &ta);
+  luaL_checkstack(L, 50, "");  /* assume array is smaller than 2^50 */
   if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
     luaL_checktype(L, 2, LUA_TFUNCTION);
-  lua_settop(L, 2);  /* make sure there is two arguments */
+  lua_settop(L, 2);  /* make sure there are two arguments */
-  auxsort(L, 1, n);
+  auxsort(L, &ta, 1, n);
   return 0;
 }
   {"pack", pack},
   {"unpack", unpack},
   {"remove", tremove},
+  {"copy", tcopy},
   {"sort", sort},
   {NULL, NULL}
 };

src/ltm.c+1−1

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltm.c,v 2.27 2014/06/10 18:53:18 roberto Exp $	2	** $Id: ltm.c,v 2.29 2014/07/18 13:36:14 roberto Exp $
3	** Tag methods	3	** Tag methods
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/

src/lua.c+18−12

 /*
-** $Id: lua.c,v 1.211 2014/06/05 20:42:06 roberto Exp $
+** $Id: lua.c,v 1.213 2014/06/30 19:48:08 roberto Exp $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
 /*
 ** Function to be called at a C signal. Because a C signal cannot
-** just change a Lua state (as there is no proper syncronization),
+** just change a Lua state (as there is no proper synchronization),
 ** this function only sets a hook that, when called, will stop the
 ** interpreter.
 */
 /*
 ** Check whether 'status' signals a syntax error and the error
 ** message at the top of the stack ends with the above mark for
-** incoplete statements.
+** incomplete statements.
 */
 static int incomplete (lua_State *L, int status) {
   if (status == LUA_ERRSYNTAX) {
 /*
-** Push on the stack 'n' strings from 'argv'
+** Push on the stack the contents of table 'arg' from 1 to #arg
 */
-static void pushargs (lua_State *L, char **argv, int n) {
+static int pushargs (lua_State *L) {
-  int i;
+  int i, n;
+  lua_getglobal(L, "arg");
+  if (!lua_istable(L, -1))
+    luaL_error(L, "'arg' is not a table");
+  n = (int)luaL_len(L, -1);
   luaL_checkstack(L, n + 3, "too many arguments to script");
-  for (i = 1; i < n; i++)  /* skip 0 (the script name) */
+  for (i = 1; i <= n; i++)
-    lua_pushstring(L, argv[i]);
+    lua_rawgeti(L, -i, i);
+  lua_remove(L, -i);  /* remove table from the stack */
+  return n;
 }
-static int handle_script (lua_State *L, char **argv, int n) {
+static int handle_script (lua_State *L, char **argv) {
   int status;
   const char *fname = argv[0];
   if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
     fname = NULL;  /* stdin */
   status = luaL_loadfile(L, fname);
   if (status == LUA_OK) {
-    pushargs(L, argv, n);  /* push arguments to script */
+    int n = pushargs(L);  /* push arguments to script */
-    status = docall(L, n - 1, LUA_MULTRET);
+    status = docall(L, n, LUA_MULTRET);
   }
   return report(L, status);
 }
   if (!runargs(L, argv, script))  /* execute arguments -e and -l */
     return 0;  /* something failed */
   if (script < argc &&  /* execute main script (if there is one) */
-      handle_script(L, argv + script, argc - script) != LUA_OK)
+      handle_script(L, argv + script) != LUA_OK)
     return 0;
   if (args & has_i)  /* -i option? */
     doREPL(L);  /* do read-eval-print loop */

src/lua.h+54−34

 /*
-** $Id: lua.h,v 1.307 2014/06/10 17:41:38 roberto Exp $
+** $Id: lua.h,v 1.312 2014/07/31 13:44:30 roberto Exp $
 ** Lua - A Scripting Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
 #define LUA_VERSION_MAJOR	"5"
 #define LUA_VERSION_MINOR	"3"
 #define LUA_VERSION_NUM		503
-#define LUA_VERSION_RELEASE	"0 (work3)"
+#define LUA_VERSION_RELEASE	"0 (alpha)"
 #define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
 #define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
 typedef struct lua_State lua_State;
-/*
-** Type for C functions registered with Lua
-*/
-typedef int (*lua_CFunction) (lua_State *L);
-/*
-** Type for continuation functions
-*/
-typedef int (*lua_KFunction) (lua_State *L, int status, int ctx);
-/*
-** functions that read/write blocks when loading/dumping Lua chunks
-*/
-typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
-typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
-/*
-** prototype for memory-allocation functions
-*/
-typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
 /*
 ** basic types
 /* unsigned integer type */
 typedef LUA_UNSIGNED lua_Unsigned;
+/* type for continuation-function contexts */
+typedef LUA_CTXT lua_Ctx;
+/*
+** Type for C functions registered with Lua
+*/
+typedef int (*lua_CFunction) (lua_State *L);
+/*
+** Type for continuation functions
+*/
+typedef int (*lua_KFunction) (lua_State *L, int status, lua_Ctx ctx);
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
+/*
+** Type for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
 /*
 LUA_API void  (lua_settop) (lua_State *L, int idx);
 LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
 LUA_API void  (lua_rotate) (lua_State *L, int idx, int n);
-LUA_API void  (lua_replace) (lua_State *L, int idx);
 LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
 LUA_API int   (lua_checkstack) (lua_State *L, int sz);
 LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
 LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
-LUA_API lua_Unsigned    (lua_tounsignedx) (lua_State *L, int idx, int *isnum);
 LUA_API int             (lua_toboolean) (lua_State *L, int idx);
 LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
 LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
 LUA_API void        (lua_pushnil) (lua_State *L);
 LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
 LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
-LUA_API void        (lua_pushunsigned) (lua_State *L, lua_Unsigned n);
 LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l);
 LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
 LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
 /*
 ** 'load' and 'call' functions (load and run Lua code)
 */
-LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, lua_Ctx ctx,
                            lua_KFunction k);
 #define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
 LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
-                            int ctx, lua_KFunction k);
+                            lua_Ctx ctx, lua_KFunction k);
 #define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
 LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
 /*
 ** coroutine functions
 */
-LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,
+LUA_API int  (lua_yieldk) (lua_State *L, int nresults, lua_Ctx ctx,
                            lua_KFunction k);
 #define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
 LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);
 /*
-** ===============================================================
+** {==============================================================
 ** some useful macros
 ** ===============================================================
 */
+#define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
 #define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
 #define lua_tointeger(L,i)	lua_tointegerx(L,(i),NULL)
-#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
 #define lua_pop(L,n)		lua_settop(L, -(n)-1)
 #define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
+#define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
+/* }============================================================== */
+/*
+** {==============================================================
+** compatibility macros for unsigned conversions
+** ===============================================================
+*/
+#if defined(LUA_COMPAT_APIUNSIGNED)
+#define lua_pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
+#define lua_tounsignedx(L,i,is)	((lua_Integer)lua_tointegerx(L,i,is))
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
+#endif
+/* }============================================================== */
 /*
 ** {======================================================================

src/luac.c+3−3

@@ -203,7 +203,7 @@ int main(int argc, char* argv[]) · 202 unmodified lines
203	}	203	}
204		204
205	/*	205	/*
206	** $Id: print.c,v 1.73 2014/06/12 02:41:25 lhf Exp $	206	** $Id: print.c,v 1.74 2014/07/21 01:41:45 lhf Exp $
207	** print bytecodes	207	** print bytecodes
208	** See Copyright Notice in lua.h	208	** See Copyright Notice in lua.h
209	*/	209	*/
@@ -223,7 +223,7 @@ int main(int argc, char* argv[]) · 13 unmodified lines
223	static void PrintString(const TString* ts)	223	static void PrintString(const TString* ts)
224	{	224	{
225	const char* s=getstr(ts);	225	const char* s=getstr(ts);
226	size_t i,n=ts->tsv.len;	226	size_t i,n=ts->len;
227	printf("%c",'"');	227	printf("%c",'"');
228	for (i=0; i<n; i++)	228	for (i=0; i<n; i++)
229	{	229	{
@@ -266,7 +266,7 @@ static void PrintConstant(const Proto* f, int i) · 36 unmodified lines
266	printf(LUA_INTEGER_FMT,ivalue(o));	266	printf(LUA_INTEGER_FMT,ivalue(o));
267	break;	267	break;
268	case LUA_TSHRSTR: case LUA_TLNGSTR:	268	case LUA_TSHRSTR: case LUA_TLNGSTR:
269	PrintString(rawtsvalue(o));	269	PrintString(tsvalue(o));
270	break;	270	break;
271	default: /* cannot happen */	271	default: /* cannot happen */
272	printf("? type=%d",ttype(o));	272	printf("? type=%d",ttype(o));

src/luaconf.h+36−7

 /*
-** $Id: luaconf.h,v 1.207 2014/06/10 19:21:20 roberto Exp $
+** $Id: luaconf.h,v 1.212 2014/07/24 19:33:29 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+#define LUA_EXTRASPACE		(sizeof(void *))
 /*
 @@ LUA_QL describes how error messages quote program elements.
 ** CHANGE it if you want a different appearance.
 #define LUAI_MAXSHORTLEN        40
+/*
+@@ LUA_CTXT is the type of the context ('ctx') for continuation functions.
+@@ It must be a numerical type; Lua will use 'intptr_t' if available.
+*/
+#if defined (LUA_USE_C99)
+#include <stdint.h>
+#if defined (INTPTR_MAX)  /* even in C99 this type is optional */
+#define LUA_CTXT	intptr_t
+#endif
+#endif
+#if !defined(LUA_CTXT)
+/* default definition (the nearest thing to 'intptr_t' in C89) */
+#define LUA_CTXT	ptrdiff_t
+#endif
 /*
 ** {==================================================================
 */
 #define LUA_COMPAT_BITLIB
+/*
+@@ LUA_COMPAT_IPAIRS controls the effectivness of the __ipairs metamethod.
+*/
+#define LUA_COMPAT_IPAIRS
+/*
+@@ LUA_COMPAT_APIUNSIGNED controls the presence of macros for
+** manipulating unsigned integers (lua_pushunsigned, lua_tounsigned, etc.)
+*/
+#define LUA_COMPAT_APIUNSIGNED
 /*
 @@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
 @@ LUA_INTEGER_FMT is the format for writing integers.
 @@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
 @@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
-@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
 @@ lua_integer2str converts an integer to a string.
 */
 #define LUA_INTEGER		int
 #define LUA_INTEGER_FRMLEN	""
-#define LUA_MAXUNSIGNED		UINT_MAX
 #define LUA_MAXINTEGER		INT_MAX
 #define LUA_MININTEGER		INT_MIN
 #define LUA_INTEGER		long
 #define LUA_INTEGER_FRMLEN	"l"
-#define LUA_MAXUNSIGNED		ULONG_MAX
 #define LUA_MAXINTEGER		LONG_MAX
 #define LUA_MININTEGER		LONG_MIN
 #define LUA_INTEGER		__int64
 #define LUA_INTEGER_FRMLEN	"I64"
-#define LUA_MAXUNSIGNED		_UI64_MAX
 #define LUA_MAXINTEGER		_I64_MAX
 #define LUA_MININTEGER		_I64_MIN
 #define LUA_INTEGER		long long
 #define LUA_INTEGER_FRMLEN	"ll"
-#define LUA_MAXUNSIGNED		ULLONG_MAX
 #define LUA_MAXINTEGER		LLONG_MAX
 #define LUA_MININTEGER		LLONG_MIN
 #define LUA_INTEGER		short int
 #define LUA_INTEGER_FRMLEN	""
-#define LUA_MAXUNSIGNED		((LUA_UNSIGNED)USHRT_MAX)
 #define LUA_MAXINTEGER		SHRT_MAX
 #define LUA_MININTEGER		SHRT_MIN

src/lutf8lib.c+3−1

 /*
-** $Id: lutf8lib.c,v 1.9 2014/05/14 18:33:37 roberto Exp $
+** $Id: lutf8lib.c,v 1.10 2014/07/16 13:56:14 roberto Exp $
 ** Standard library for UTF-8 manipulation
 ** See Copyright Notice in lua.h
 */
   {"char", utfchar},
   {"len", utflen},
   {"codes", iter_codes},
+  /* placeholders */
+  {"charpatt", NULL},
   {NULL, NULL}
 };

src/lvm.c+28−49

 /*
-** $Id: lvm.c,v 2.216 2014/06/19 18:27:20 roberto Exp $
+** $Id: lvm.c,v 2.222 2014/07/30 14:42:44 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 #define MAXTAGLOOP	2000
-/* maximum length of the conversion of a number to a string */
-#define MAXNUMBER2STR	50
 /*
 ** Similar to 'tonumber', but does not attempt to convert strings and
 ** ensure correct precision (no extra bits). Used in comparisons.
     *n = fltvalue(obj);
     return 1;
   }
-  else if (ttisstring(obj) &&  /* string convertible to number? */
+  else if (cvt2num(obj) &&  /* string convertible to number? */
             luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) {
     obj = &v;
     goto again;  /* convert result from 'luaO_str2num' to a float */
 /*
-** try to convert a value to an integer, rounding up if 'up' is true
+** try to convert a value to an integer, rounding according to 'mode':
+** mode == 0: accepts only integral values
+** mode < 0: takes the floor of the number
+** mode > 0: takes the ceil of the number
 */
-static int tointeger_aux (const TValue *obj, lua_Integer *p, int up) {
+static int tointeger_aux (const TValue *obj, lua_Integer *p, int mode) {
   TValue v;
  again:
   if (ttisfloat(obj)) {
     lua_Number n = fltvalue(obj);
-    n = (up ? -l_floor(-n) : l_floor(n));
+    lua_Number f = l_floor(n);
-    return lua_numtointeger(n, p);
+    if (n != f) {  /* not an integral value? */
+      if (mode == 0) return 0;  /* fails if mode demands integral value */
+      else if (mode > 0)  /* needs ceil? */
+        f += 1;  /* convert floor to ceil (remember: n != f) */
+    }
+    return lua_numtointeger(f, p);
   }
   else if (ttisinteger(obj)) {
     *p = ivalue(obj);
     return 1;
   }
-  else if (ttisstring(obj) &&
+  else if (cvt2num(obj) &&
             luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) {
     obj = &v;
     goto again;  /* convert result from 'luaO_str2num' to an integer */
 /*
-** try to convert a non-integer value to an integer, rounding down
+** try to convert a value to an integer
 */
 int luaV_tointeger_ (const TValue *obj, lua_Integer *p) {
   return tointeger_aux(obj, p, 0);
 }
-/*
-** Convert a number object to a string
-*/
-int luaV_tostring (lua_State *L, StkId obj) {
-  if (!ttisnumber(obj))
-    return 0;
-  else {
-    char buff[MAXNUMBER2STR];
-    size_t len;
-    if (ttisinteger(obj))
-      len = lua_integer2str(buff, ivalue(obj));
-    else {
-      len = lua_number2str(buff, fltvalue(obj));
-#if !defined(LUA_COMPAT_FLOATSTRING)
-      if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
-        buff[len++] = '.';
-        buff[len++] = '0';  /* adds '.0' to result */
-      }
-#endif
-    }
-    setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
-    return 1;
-  }
-}
 /*
 ** Try to convert a 'for' limit to an integer, preserving the
 ** semantics of the loop.
 static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step,
                      int *stopnow) {
   *stopnow = 0;  /* usually, let loops run */
-  if (!tointeger_aux(obj, p, (step < 0))) {  /* does not fit in integer? */
+  if (!tointeger_aux(obj, p, (step < 0 ? 1 : -1))) {  /* not fit in integer? */
     lua_Number n;  /* try to convert to float */
     if (!tonumber(obj, &n)) /* cannot convert to float? */
       return 0;  /* not a number */
       luaT_callTM(L, tm, t, key, val, 0);
       return;
     }
-    t = tm;  /* else repeat assginment over 'tm' */
+    t = tm;  /* else repeat assignment over 'tm' */
   }
   luaG_runerror(L, "settable chain too long; possible loop");
 }
 */
 static int l_strcmp (const TString *ls, const TString *rs) {
   const char *l = getstr(ls);
-  size_t ll = ls->tsv.len;
+  size_t ll = ls->len;
   const char *r = getstr(rs);
-  size_t lr = rs->tsv.len;
+  size_t lr = rs->len;
   for (;;) {  /* for each segment */
     int temp = strcoll(l, r);
     if (temp != 0)  /* not equal? */
   else if (tofloat(l, &nl) && tofloat(r, &nr))  /* both are numbers? */
     return luai_numlt(nl, nr);
   else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
-    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
+    return l_strcmp(tsvalue(l), tsvalue(r)) < 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)  /* no metamethod? */
     luaG_ordererror(L, l, r);  /* error */
   return res;
   else if (tofloat(l, &nl) && tofloat(r, &nr))  /* both are numbers? */
     return luai_numle(nl, nr);
   else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
-    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
+    return l_strcmp(tsvalue(l), tsvalue(r)) <= 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0)  /* first try `le' */
     return res;
   else if ((res = luaT_callorderTM(L, r, l, TM_LT)) < 0)  /* else try `lt' */
     case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
     case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
     case LUA_TLCF: return fvalue(t1) == fvalue(t2);
-    case LUA_TSHRSTR: return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));
+    case LUA_TSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2));
-    case LUA_TLNGSTR: return luaS_eqlngstr(rawtsvalue(t1), rawtsvalue(t2));
+    case LUA_TLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2));
     case LUA_TUSERDATA: {
       if (uvalue(t1) == uvalue(t2)) return 1;
       else if (L == NULL) return 0;
 /* macro used by 'luaV_concat' to ensure that element at 'o' is a string */
-#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o)))
+#define tostring(L,o)  \
+	(ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1)))
 /*
 ** Main operation for concatenation: concat 'total' values in the stack,
   do {
     StkId top = L->top;
     int n = 2;  /* number of elements handled in this pass (at least 2) */
-    if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1))
+    if (!(ttisstring(top-2) || cvt2str(top-2)) || !tostring(L, top-1))
       luaT_trybinTM(L, top-2, top-1, top-2, TM_CONCAT);
     else if (tsvalue(top-1)->len == 0)  /* second operand is empty? */
       cast_void(tostring(L, top - 2));  /* result is first operand */
     ncl->upvals[i]->refcount++;
     /* new closure is white, so we do not need a barrier here */
   }
-  if (!isblack(obj2gco(p)))  /* cache will not break GC invariant? */
+  if (!isblack(p))  /* cache will not break GC invariant? */
     p->cache = ncl;  /* save it on cache for reuse */
 }

src/lvm.h+15−2

 /*
-** $Id: lvm.h,v 2.31 2014/05/26 17:10:22 roberto Exp $
+** $Id: lvm.h,v 2.33 2014/07/30 14:42:44 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 #include "ltm.h"
+#if !defined(LUA_NOCVTN2S)
+#define cvt2str(o)	ttisnumber(o)
+#else
+#define cvt2str(o)	0	/* no convertion from numbers to strings */
+#endif
+#if !defined(LUA_NOCVTS2N)
+#define cvt2num(o)	ttisstring(o)
+#else
+#define cvt2num(o)	0	/* no convertion from strings to numbers */
+#endif
 #define tonumber(o,n) \
 	(ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
 LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
 LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
 LUAI_FUNC int luaV_tointeger_ (const TValue *obj, lua_Integer *p);
-LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
 LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
                                             StkId val);
 LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,

Lua 5.3.0-alpha

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code