Lua 5.3.0-work3

Lua Team committed 12 years ago

Commit f8a66271 parent ad386d945 files · +2323 −1590Browse files

Unified · Split

45 files

README +1 −1
doc/contents.html +15 −18
doc/manual.html +557 −397
doc/readme.html +16 −19
src/.fix +0 −2
src/Makefile +2 −2
src/lapi.c +46 −54
src/lauxlib.c +6 −11
src/lauxlib.h +2 −2
src/lbaselib.c +51 −41
src/lbitlib.c +2 −3
src/lcode.c +10 −11
src/lcorolib.c +17 −5
src/ldblib.c +117 −70
src/ldo.c +64 −42
src/ldump.c +18 −9
src/lfunc.c +13 −10
src/lfunc.h +3 −3
src/lgc.c +70 −76
src/linit.c +5 −3
src/liolib.c +89 −24
src/llex.c +69 −53
src/llimits.h +20 −13
src/lmathlib.c +175 −106
src/lobject.c +37 −17
src/lobject.h +39 −45
src/loslib.c +8 −2
src/lparser.c +5 −5
src/lparser.h +3 −3
src/lstate.h +14 −14
src/lstring.c +8 −4
src/lstrlib.c +54 −47
src/ltable.c +27 −21
src/ltablib.c +27 −28
src/ltm.c +5 −16
src/ltm.h +1 −2
src/lua.c +223 −153
src/lua.h +25 −14
src/luac.c +15 −8
src/luaconf.h +131 −41
src/lundump.c +27 −19
src/lundump.h +4 −4
src/lutf8lib.c +49 −38
src/lvm.c +251 −127
src/lvm.h +2 −7

@@ -1,5 +1,5 @@
1		1
2	This is Lua 5.3.0 (work2), released on 21 Mar 2014.	2	This is Lua 5.3.0 (work3), released on 19 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+15−18

 <P>
 <A HREF="manual.html#pdf-coroutine.create">coroutine.create</A><BR>
+<A HREF="manual.html#pdf-coroutine.isyieldable">coroutine.isyieldable</A><BR>
 <A HREF="manual.html#pdf-coroutine.resume">coroutine.resume</A><BR>
 <A HREF="manual.html#pdf-coroutine.running">coroutine.running</A><BR>
 <A HREF="manual.html#pdf-coroutine.status">coroutine.status</A><BR>
 <P>
 <A HREF="manual.html#pdf-debug.debug">debug.debug</A><BR>
+<A HREF="manual.html#pdf-debug.Csize">debug.Csize</A><BR>
 <A HREF="manual.html#pdf-debug.gethook">debug.gethook</A><BR>
 <A HREF="manual.html#pdf-debug.getinfo">debug.getinfo</A><BR>
 <A HREF="manual.html#pdf-debug.getlocal">debug.getlocal</A><BR>
 <A HREF="manual.html#pdf-debug.getregistry">debug.getregistry</A><BR>
 <A HREF="manual.html#pdf-debug.getupvalue">debug.getupvalue</A><BR>
 <A HREF="manual.html#pdf-debug.getuservalue">debug.getuservalue</A><BR>
-<A HREF="manual.html#pdf-debug.numbits">debug.numbits</A><BR>
 <A HREF="manual.html#pdf-debug.sethook">debug.sethook</A><BR>
 <A HREF="manual.html#pdf-debug.setlocal">debug.setlocal</A><BR>
 <A HREF="manual.html#pdf-debug.setmetatable">debug.setmetatable</A><BR>
 <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.atan">math.atan</A><BR>
-<A HREF="manual.html#pdf-math.atan2">math.atan2</A><BR>
 <A HREF="manual.html#pdf-math.ceil">math.ceil</A><BR>
 <A HREF="manual.html#pdf-math.cos">math.cos</A><BR>
-<A HREF="manual.html#pdf-math.cosh">math.cosh</A><BR>
 <A HREF="manual.html#pdf-math.deg">math.deg</A><BR>
-<A HREF="manual.html#pdf-math.exp">math.exp</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.frexp">math.frexp</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.isfloat">math.isfloat</A><BR>
-<A HREF="manual.html#pdf-math.ldexp">math.ldexp</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.min">math.min</A><BR>
+<A HREF="manual.html#pdf-math.mininteger">math.mininteger</A><BR>
 <A HREF="manual.html#pdf-math.modf">math.modf</A><BR>
 <A HREF="manual.html#pdf-math.pi">math.pi</A><BR>
-<A HREF="manual.html#pdf-math.pow">math.pow</A><BR>
 <A HREF="manual.html#pdf-math.rad">math.rad</A><BR>
 <A HREF="manual.html#pdf-math.random">math.random</A><BR>
 <A HREF="manual.html#pdf-math.randomseed">math.randomseed</A><BR>
 <A HREF="manual.html#pdf-math.sin">math.sin</A><BR>
-<A HREF="manual.html#pdf-math.sinh">math.sinh</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.tanh">math.tanh</A><BR>
 <A HREF="manual.html#pdf-math.type">math.type</A><BR>
 <P>
 <A HREF="manual.html#pdf-os.clock">os.clock</A><BR>
 <A HREF="manual.html#pdf-os.date">os.date</A><BR>
 <A HREF="manual.html#pdf-string.byte">string.byte</A><BR>
 <A HREF="manual.html#pdf-string.char">string.char</A><BR>
 <A HREF="manual.html#pdf-string.dump">string.dump</A><BR>
+<A HREF="manual.html#pdf-string.dumpfloat">string.dumpfloat</A><BR>
+<A HREF="manual.html#pdf-string.dumpint">string.dumpint</A><BR>
 <A HREF="manual.html#pdf-string.find">string.find</A><BR>
 <A HREF="manual.html#pdf-string.format">string.format</A><BR>
 <A HREF="manual.html#pdf-string.gmatch">string.gmatch</A><BR>
 <A HREF="manual.html#pdf-string.len">string.len</A><BR>
 <A HREF="manual.html#pdf-string.lower">string.lower</A><BR>
 <A HREF="manual.html#pdf-string.match">string.match</A><BR>
-<A HREF="manual.html#pdf-string.packfloat">string.packfloat</A><BR>
-<A HREF="manual.html#pdf-string.packint">string.packint</A><BR>
 <A HREF="manual.html#pdf-string.rep">string.rep</A><BR>
 <A HREF="manual.html#pdf-string.reverse">string.reverse</A><BR>
 <A HREF="manual.html#pdf-string.sub">string.sub</A><BR>
-<A HREF="manual.html#pdf-string.unpackfloat">string.unpackfloat</A><BR>
+<A HREF="manual.html#pdf-string.undumpfloat">string.undumpfloat</A><BR>
-<A HREF="manual.html#pdf-string.unpackint">string.unpackint</A><BR>
+<A HREF="manual.html#pdf-string.undumpint">string.undumpint</A><BR>
 <A HREF="manual.html#pdf-string.upper">string.upper</A><BR>
 <P>
 <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_KFunction">lua_KFunction</A><BR>
 <A HREF="manual.html#lua_Number">lua_Number</A><BR>
 <A HREF="manual.html#lua_Reader">lua_Reader</A><BR>
 <A HREF="manual.html#lua_State">lua_State</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_getctx">lua_getctx</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_istable">lua_istable</A><BR>
 <A HREF="manual.html#lua_isthread">lua_isthread</A><BR>
 <A HREF="manual.html#lua_isuserdata">lua_isuserdata</A><BR>
+<A HREF="manual.html#lua_isyieldable">lua_isyieldable</A><BR>
 <A HREF="manual.html#lua_len">lua_len</A><BR>
 <A HREF="manual.html#lua_load">lua_load</A><BR>
 <A HREF="manual.html#lua_newstate">lua_newstate</A><BR>
 <A HREF="manual.html#lua_newthread">lua_newthread</A><BR>
 <A HREF="manual.html#lua_newuserdata">lua_newuserdata</A><BR>
 <A HREF="manual.html#lua_next">lua_next</A><BR>
+<A HREF="manual.html#lua_numtointeger">lua_numtointeger</A><BR>
 <A HREF="manual.html#lua_pcall">lua_pcall</A><BR>
 <A HREF="manual.html#lua_pcallk">lua_pcallk</A><BR>
 <A HREF="manual.html#lua_pop">lua_pop</A><BR>
 <A HREF="manual.html#lua_remove">lua_remove</A><BR>
 <A HREF="manual.html#lua_replace">lua_replace</A><BR>
 <A HREF="manual.html#lua_resume">lua_resume</A><BR>
+<A HREF="manual.html#lua_rotate">lua_rotate</A><BR>
 <A HREF="manual.html#lua_setallocf">lua_setallocf</A><BR>
 <A HREF="manual.html#lua_setfield">lua_setfield</A><BR>
 <A HREF="manual.html#lua_setglobal">lua_setglobal</A><BR>
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Fri Mar 21 17:34:12 BRT 2014
+Thu Jun 19 17:09:46 BRT 2014
 </SMALL>
 <!--
-Last change: updated for Lua 5.3.0 (work2)
+Last change: updated for Lua 5.3.0 (work3)
 -->
 </BODY>

doc/manual.html+557−397

@@ -38,7 +38,7 @@ Freely available under the terms of the · 37 unmodified lines
38	<!-- ====================================================================== -->	38	<!-- ====================================================================== -->
39	<p>	39	<p>
40		40
41	<!-- $Id: manual.of,v 1.114 2014/03/21 18:32:52 roberto Exp $ -->	41	<!-- $Id: manual.of,v 1.121 2014/06/18 19:12:23 roberto Exp $ -->
42		42
43		43
44		44
@@ -139,9 +139,9 @@ one called <em>integer</em> and the other called <em>float</em>. · 94 unmodified lines
139	Lua has explicit rules about when each representation is used,	139	Lua has explicit rules about when each representation is used,
140	but it also converts between them automatically as needed (see <a href="#3.4.3">§3.4.3</a>).	140	but it also converts between them automatically as needed (see <a href="#3.4.3">§3.4.3</a>).
141	Therefore,	141	Therefore,
142	the programmer has the option of mostly ignore the difference	142	the programmer has the option of mostly ignoring the difference
143	between integers and floats	143	between integers and floats
144	or assume complete control about the representation of each value.	144	or assuming complete control over the representation of each value.
145	Standard Lua uses 64-bit integers and double-precision (64-bit) floats,	145	Standard Lua uses 64-bit integers and double-precision (64-bit) floats,
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.
@@ -437,7 +437,7 @@ with the following code: · 289 unmodified lines
437	</pre>	437	</pre>
438		438
439	<p>	439	<p>
440	For the unary minus and the bitwise not operators,	440	For the unary operators (negation, length, and bitwise not),
441	the metamethod is computed and called with a dummy second operand,	441	the metamethod is computed and called with a dummy second operand,
442	equal to the first one.	442	equal to the first one.
443	This extra operand is only to simplify Lua's internals	443	This extra operand is only to simplify Lua's internals
@@ -575,9 +575,9 @@ Otherwise, Lua raises an error. · 131 unmodified lines
575	<li><b>"eq": </b>	575	<li><b>"eq": </b>
576	the <code>==</code> (equal) operation.	576	the <code>==</code> (equal) operation.
577		577
578	Lua will try a metamethod only when the values	578	Behavior similar to the "add" operation,
579	being compared are both either tables or full userdata,	579	except that Lua will try a metamethod only when the values
580	both have the same metamethod,	580	being compared are either both tables or both full userdata
581	and they are not primitively equal.	581	and they are not primitively equal.
582	The result of the call is always converted to a boolean.	582	The result of the call is always converted to a boolean.
583	</li>	583	</li>
@@ -586,7 +586,9 @@ The result of the call is always converted to a boolean. · 2 unmodified lines
586	the <code><</code> (less than) operation.	586	the <code><</code> (less than) operation.
587		587
588	Behavior similar to the "add" operation,	588	Behavior similar to the "add" operation,
589	except that the result of the call is always converted to a boolean.	589	except that Lua will try a metamethod only when the values
		590	being compared are neither both numbers nor both strings.
		591	The result of the call is always converted to a boolean.
590	</li>	592	</li>
591		593
592	<li><b>"le": </b>	594	<li><b>"le": </b>
@@ -595,7 +597,7 @@ the <code><=</code> (less equal) operation. · 2 unmodified lines
595	Unlike other operations,	597	Unlike other operations,
596	The less-equal operation can use two different events.	598	The less-equal operation can use two different events.
597	First, Lua looks for the "<code>__le</code>" metamethod in both operands,	599	First, Lua looks for the "<code>__le</code>" metamethod in both operands,
598	like in the "add" operation.	600	like in the "lt" operation.
599	If it cannot find such a metamethod,	601	If it cannot find such a metamethod,
600	then it will try the "<code>__lt</code>" event,	602	then it will try the "<code>__lt</code>" event,
601	assuming that <code>a <= b</code> is equivalent to <code>not (b < a)</code>.	603	assuming that <code>a <= b</code> is equivalent to <code>not (b < a)</code>.
@@ -775,7 +777,7 @@ Lua simply ignores it.) · 173 unmodified lines
775	<p>	777	<p>
776	At the end of each garbage-collection cycle,	778	At the end of each garbage-collection cycle,
777	the finalizers for objects are called in	779	the finalizers for objects are called in
778	the reverse order that they were marked for collection,	780	the reverse order that they were marked for finalization,
779	among those collected in that cycle;	781	among those collected in that cycle;
780	that is, the first finalizer to be called is the one associated	782	that is, the first finalizer to be called is the one associated
781	with the object marked last in the program.	783	with the object marked last in the program.
@@ -792,17 +794,20 @@ and the object memory is freed in the next garbage-collection cycle. · 10 unmodified lines
792	However, if the finalizer stores the object in some global place	794	However, if the finalizer stores the object in some global place
793	(e.g., a global variable),	795	(e.g., a global variable),
794	then there is a permanent resurrection.	796	then there is a permanent resurrection.
		797	Moreover, if the finalizer marks a finalizing object for finalization again,
		798	its finalizer will be called again in the next cycle where the
		799	object is unreachable.
795	In any case,	800	In any case,
796	the object memory is freed only when it becomes completely inaccessible;	801	the object memory is freed only in the GC cycle where
797	its finalizer will never be called twice.	802	the object is unreachable and not marked for finalization.
798		803
799		804
800	<p>	805	<p>
801	When you close a state (see <a href="#lua_close"><code>lua_close</code></a>),	806	When you close a state (see <a href="#lua_close"><code>lua_close</code></a>),
802	Lua calls the finalizers of all objects marked for finalization,	807	Lua calls the finalizers of all objects marked for finalization,
803	following the reverse order that they were marked.	808	following the reverse order that they were marked.
804	If any finalizer marks new objects for collection during that phase,	809	If any finalizer marks objects for collection during that phase,
805	these new objects will not be finalized.	810	these marks have no effect.
806		811
807		812
808		813
@@ -1064,9 +1069,10 @@ and cannot be used as names: · 255 unmodified lines
1064	Lua is a case-sensitive language:	1069	Lua is a case-sensitive language:
1065	<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>	1070	<code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
1066	are two different, valid names.	1071	are two different, valid names.
1067	As a convention, names starting with an underscore followed by	1072	As a convention,
1068	uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>)	1073	programs should avoid creating
1069	are reserved for variables used by Lua.	1074	names that start with an underscore followed by
		1075	one or more uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>).
1070		1076
1071		1077
1072	<p>	1078	<p>
@@ -1074,6 +1080,7 @@ The following strings denote other tokens: · 1 unmodified line
1074		1080
1075	<pre>	1081	<pre>
1076	+ - * / % ^ #	1082	+ - * / % ^ #
		1083	& ~ \| << >> //
1077	== ~= <= >= < > =	1084	== ~= <= >= < > =
1078	( ) { } [ ] ::	1085	( ) { } [ ] ::
1079	; : , . .. ...	1086	; : , . .. ...
@@ -1130,11 +1137,12 @@ enclosed by <em>long brackets</em>. · 50 unmodified lines
1130	We define an <em>opening long bracket of level <em>n</em></em> as an opening	1137	We define an <em>opening long bracket of level <em>n</em></em> as an opening
1131	square bracket followed by <em>n</em> equal signs followed by another	1138	square bracket followed by <em>n</em> equal signs followed by another
1132	opening square bracket.	1139	opening square bracket.
1133	So, an opening long bracket of level 0 is written as <code>[[</code>,	1140	So, an opening long bracket of level 0 is written as <code>[[</code>,
1134	an opening long bracket of level 1 is written as <code>[=[</code>,	1141	an opening long bracket of level 1 is written as <code>[=[</code>,
1135	and so on.	1142	and so on.
1136	A <em>closing long bracket</em> is defined similarly;	1143	A <em>closing long bracket</em> is defined similarly;
1137	for instance, a closing long bracket of level 4 is written as <code>]====]</code>.	1144	for instance,
		1145	a closing long bracket of level 4 is written as <code>]====]</code>.
1138	A <em>long literal</em> starts with an opening long bracket of any level and	1146	A <em>long literal</em> starts with an opening long bracket of any level and
1139	ends at the first closing long bracket of the same level.	1147	ends at the first closing long bracket of the same level.
1140	It can contain any text except a closing bracket of the proper level.	1148	It can contain any text except a closing bracket of the proper level.
@@ -1594,20 +1602,19 @@ is equivalent to the code: · 453 unmodified lines
1594		1602
1595	<pre>	1603	<pre>
1596	do	1604	do
1597	local <em>var</em>, <em>limit</em>, <em>step</em> = convert(<em>e1</em>, <em>e2</em>, <em>e3</em>)	1605	local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
1598	if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end	1606	if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
1599	while (<em>step</em> > 0 and <em>var</em> <= <em>limit</em>) or (<em>step</em> <= 0 and <em>var</em> >= <em>limit</em>) do	1607	<em>var</em> = <em>var</em> - <em>step</em>
		1608	while true do
		1609	<em>var</em> = <em>var</em> + <em>step</em>
		1610	if (<em>step</em> >= 0 and <em>var</em> > <em>limit</em>) or (<em>step</em> < 0 and <em>var</em> < <em>limit</em>) then
		1611	break
		1612	end
1600	local v = <em>var</em>	1613	local v = <em>var</em>
1601	<em>block</em>	1614	<em>block</em>
1602	<em>var</em> = <em>var</em> + <em>step</em>
1603	end	1615	end
1604	end	1616	end
1605	</pre><p>	1617	</pre>
1606	where <code>convert</code> returns
1607	its three arguments unaltered
1608	if they are all integers,
1609	otherwise it converts them to floats.
1610
1611		1618
1612	<p>	1619	<p>
1613	Note the following:	1620	Note the following:
@@ -1620,12 +1627,6 @@ before the loop starts. · 6 unmodified lines
1620	They must all result in numbers.	1627	They must all result in numbers.
1621	</li>	1628	</li>
1622		1629
1623	<li>
1624	If any of the three control values is not an integer,
1625	all three values are converted to floats,
1626	so that the loop is done with floats.
1627	</li>
1628
1629	<li>	1630	<li>
1630	<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.	1631	<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
1631	The names shown here are for explanatory purposes only.	1632	The names shown here are for explanatory purposes only.
@@ -1641,9 +1642,8 @@ You can use <b>break</b> and <b>goto</b> to exit a <b>for</b> loop. · 9 unmodified lines
1641	</li>	1642	</li>
1642		1643
1643	<li>	1644	<li>
1644	The loop variable <code>v</code> is local to the loop;	1645	The loop variable <code>v</code> is local to the loop body.
1645	you cannot use its value after the <b>for</b> ends or is broken.	1646	If you need its value after the loop,
1646	If you need its value,
1647	assign it to another variable before exiting the loop.	1647	assign it to another variable before exiting the loop.
1648	</li>	1648	</li>
1649		1649
@@ -1840,17 +1840,20 @@ or <b>nil</b> if <code>f</code> does not return any values.) · 190 unmodified lines
1840		1840
1841	<h3>3.4.1 – <a name="3.4.1">Arithmetic Operators</a></h3><p>	1841	<h3>3.4.1 – <a name="3.4.1">Arithmetic Operators</a></h3><p>
1842	Lua supports the following arithmetic operators:	1842	Lua supports the following arithmetic operators:
1843	the binary <code>+</code> (addition),	1843	<table border="1">
1844	<code>-</code> (subtraction), <code>*</code> (multiplication),	1844	<tr><td><code>+</code></td><td>addition</td></tr>
1845	<code>/</code> (division), <code>//</code> (integer division),	1845	<tr><td><code>-</code></td><td>subtraction</td></tr>
1846	<code>%</code> (modulo), and <code>^</code> (exponentiation);	1846	<tr><td><code>*</code></td><td>multiplication</td></tr>
1847	and unary <code>-</code> (mathematical negation).	1847	<tr><td><code>/</code></td><td>float division</td></tr>
1848	Modulo is defined as the remainder of a division	1848	<tr><td><code>//</code></td><td>integer division</td></tr>
1849	that rounds the quotient towards minus infinite (floor).	1849	<tr><td><code>%</code></td><td>modulo</td></tr>
		1850	<tr><td><code>^</code></td><td>exponentiation</td></tr>
		1851	<tr><td><code>-</code></td><td>unary minus</td></tr>
		1852	</table>
1850		1853
1851		1854
1852	<p>	1855	<p>
1853	With the exception of division and integer division,	1856	With the exception of divisions and exponentiation,
1854	the arithmetic operators work as follows:	1857	the arithmetic operators work as follows:
1855	If both operands are integers,	1858	If both operands are integers,
1856	the operation is performed over integers and the result is an integer.	1859	the operation is performed over integers and the result is an integer.
@@ -1865,8 +1868,11 @@ and the result is a float. · 8 unmodified lines
1865		1868
1866		1869
1867	<p>	1870	<p>
1868	Division (<code>/</code>) always converts its operands to floats	1871	Float division (<code>/</code>) and exponentiation
1869	and its result is always a float.	1872	always convert their operands to floats
		1873	and the result is always a float.
		1874	Exponentiation uses the ANSI C function <code>pow</code>,
		1875	so that it works for non-integer exponents too.
1870		1876
1871		1877
1872	<p>	1878	<p>
@@ -1876,10 +1882,16 @@ and its result is always an integer. · 3 unmodified lines
1876	The result is always rounded towards minus infinite (floor).	1882	The result is always rounded towards minus infinite (floor).
1877		1883
1878		1884
		1885	<p>
		1886	Modulo is defined as the remainder of a division
		1887	that rounds the quotient towards minus infinite (floor).
		1888
		1889
1879	<p>	1890	<p>
1880	In case of overflows in integer arithmetic,	1891	In case of overflows in integer arithmetic,
1881	all operations <em>wrap around</em>,	1892	all operations <em>wrap around</em>,
1882	according to the usual rules of two-complement arithmetic.	1893	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>.)
1883		1895
1884		1896
1885		1897
@@ -1887,10 +1899,14 @@ according to the usual rules of two-complement arithmetic. · 1 unmodified line
1887		1899
1888	<h3>3.4.2 – <a name="3.4.2">Bitwise Operators</a></h3><p>	1900	<h3>3.4.2 – <a name="3.4.2">Bitwise Operators</a></h3><p>
1889	Lua supports the following bitwise operators:	1901	Lua supports the following bitwise operators:
1890	the binary <code>&</code> (bitwise and),	1902	<table border="1">
1891	<code>\|</code> (bitwise or), <code>~</code> (bitwise exclusive or),	1903	<tr><td><code>&</code></td><td>bitwise and</td></tr>
1892	<code>>></code> (right shift), <code><<</code> (left shift),	1904	<tr><td><code>\|</code></td><td>bitwise or</td></tr>
1893	and unary <code>~</code> (bitwise not).	1905	<tr><td><code>~</code></td><td>bitwise exclusive or</td></tr>
		1906	<tr><td><code>>></code></td><td>right shift</td></tr>
		1907	<tr><td><code><<</code></td><td>left shift</td></tr>
		1908	<tr><td><code>~</code></td><td>unary bitwise not</td></tr>
		1909	</table>
1894		1910
1895		1911
1896	<p>	1912	<p>
@@ -1901,7 +1917,7 @@ and result in an integer. · 4 unmodified lines
1901		1917
1902		1918
1903	<p>	1919	<p>
1904	Both right and left shifts fill with zeros the vacant bits.	1920	Both right and left shifts fill the vacant bits with zeros.
1905	Negative displacements shift to the other direction;	1921	Negative displacements shift to the other direction;
1906	displacements with absolute values equal to or higher than	1922	displacements with absolute values equal to or higher than
1907	the number of bits in an integer	1923	the number of bits in an integer
@@ -1917,7 +1933,7 @@ types and representations at run time. · 9 unmodified lines
1917	Most arithmetic operations applied to mixed numbers	1933	Most arithmetic operations applied to mixed numbers
1918	(integers and floats) convert the integer operand to a float;	1934	(integers and floats) convert the integer operand to a float;
1919	this is called the <em>usual rule</em>.	1935	this is called the <em>usual rule</em>.
1920	Division always convert integer operands to floats;	1936	Float division always convert integer operands to floats;
1921	integer division and bitwise operators	1937	integer division and bitwise operators
1922	always convert float operands to integers.	1938	always convert float operands to integers.
1923	The C API also converts both integers to floats and	1939	The C API also converts both integers to floats and
@@ -1929,7 +1945,6 @@ besides strings. · 5 unmodified lines
1929	<p>	1945	<p>
1930	Lua also converts strings to numbers,	1946	Lua also converts strings to numbers,
1931	whenever a number is expected.	1947	whenever a number is expected.
1932	(This conversion may be deprecated in future versions.)
1933		1948
1934		1949
1935	<p>	1950	<p>
@@ -1951,16 +1966,16 @@ Otherwise, the conversion fails. · 15 unmodified lines
1951		1966
1952		1967
1953	<p>	1968	<p>
1954	The conversion from strings to floats	1969	The conversion from strings to numbers goes as follows:
1955	follows the rules of the Lua lexer.	1970	First, the string is converted to an integer or a float,
1956	(The string may have leading and trailing spaces and a sign.)	1971	following its syntax and the rules of the Lua lexer.
1957	There is no direct conversion from strings to integers:	1972	(The string may have also leading and trailing spaces and a sign.)
1958	If a string is provided where an integer is needed,	1973	Then, the resulting number is converted to the required type
1959	Lua converts the string to a float and then the float to an integer.	1974	(float or integer) according to the previous rules.
1960		1975
1961		1976
1962	<p>	1977	<p>
1963	The conversion from numbers to strings use a human-readable,	1978	The conversion from numbers to strings uses a human-readable,
1964	non-specified format.	1979	non-specified format.
1965	For complete control over how numbers are converted to strings,	1980	For complete control over how numbers are converted to strings,
1966	use the <code>format</code> function from the string library	1981	use the <code>format</code> function from the string library
@@ -1971,11 +1986,15 @@ use the <code>format</code> function from the string library · 4 unmodified lines
1971		1986
1972		1987
1973	<h3>3.4.4 – <a name="3.4.4">Relational Operators</a></h3><p>	1988	<h3>3.4.4 – <a name="3.4.4">Relational Operators</a></h3><p>
1974	The relational operators in Lua are	1989	Lua supports the following relational operators:
1975		1990	<table border="1">
1976	<pre>	1991	<tr><td><code>==</code></td><td>equality</td></tr>
1977	== ~= < > <= >=	1992	<tr><td><code>~=</code></td><td>inequality</td></tr>
1978	</pre><p>	1993	<tr><td><code><</code></td><td>less than</td></tr>
		1994	<tr><td><code>></code></td><td>greater than</td></tr>
		1995	<tr><td><code><=</code></td><td>less or equal</td></tr>
		1996	<tr><td><code>>=</code></td><td>greater or equal</td></tr>
		1997	</table>
1979	These operators always result in <b>false</b> or <b>true</b>.	1998	These operators always result in <b>false</b> or <b>true</b>.
1980		1999
1981		2000
@@ -1986,8 +2005,8 @@ Otherwise, the values of the operands are compared. · 4 unmodified lines
1986	Strings are compared in the obvious way.	2005	Strings are compared in the obvious way.
1987	Numbers follow the usual rule for binary operations:	2006	Numbers follow the usual rule for binary operations:
1988	if both operands are integers,	2007	if both operands are integers,
1989	the are compared as integers.	2008	the are compared as integers;
1990	Otherwise, they are converted to floats	2009	otherwise, they are converted to floats
1991	and compared as such.	2010	and compared as such.
1992		2011
1993		2012
@@ -2131,10 +2150,14 @@ from lower to higher priority: · 137 unmodified lines
2131	or	2150	or
2132	and	2151	and
2133	< > <= >= ~= ==	2152	< > <= >= ~= ==
		2153	\|
		2154	~
		2155	&
		2156	<< >>
2134	..	2157	..
2135	+ -	2158	+ -
2136	* / // %	2159	* / // %
2137	not # - (unary)	2160	unary operators (not # - ~)
2138	^	2161	^
2139	</pre><p>	2162	</pre><p>
2140	As usual,	2163	As usual,
@@ -2690,7 +2713,7 @@ The registry table is always located at pseudo-index · 549 unmodified lines
2690	<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>,	2713	<a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>,
2691	which is a valid index.	2714	which is a valid index.
2692	Any C library can store data into this table,	2715	Any C library can store data into this table,
2693	but it should take care to choose keys	2716	but it must take care to choose keys
2694	that are different from those used	2717	that are different from those used
2695	by other libraries, to avoid collisions.	2718	by other libraries, to avoid collisions.
2696	Typically, you should use as key a string containing your library name,	2719	Typically, you should use as key a string containing your library name,
@@ -2705,7 +2728,7 @@ uppercase letters are reserved for Lua. · 8 unmodified lines
2705	The integer keys in the registry are used by the reference mechanism,	2728	The integer keys in the registry are used by the reference mechanism,
2706	implemented by the auxiliary library,	2729	implemented by the auxiliary library,
2707	and by some predefined values.	2730	and by some predefined values.
2708	Therefore, integer keys should not be used for other purposes.	2731	Therefore, integer keys must not be used for other purposes.
2709		2732
2710		2733
2711	<p>	2734	<p>
@@ -2760,18 +2783,18 @@ The panic function runs as if it were a message handler (see <a href="#2.3">&sec · 48 unmodified lines
2760	in particular, the error message is at the top of the stack.	2783	in particular, the error message is at the top of the stack.
2761	However, there is no guarantees about stack space.	2784	However, there is no guarantees about stack space.
2762	To push anything on the stack,	2785	To push anything on the stack,
2763	the panic function should first check the available space (see <a href="#4.2">§4.2</a>).	2786	the panic function must first check the available space (see <a href="#4.2">§4.2</a>).
2764		2787
2765		2788
2766	<p>	2789	<p>
2767	Most functions in the API can throw an error,	2790	Most functions in the API can raise an error,
2768	for instance due to a memory allocation error.	2791	for instance due to a memory allocation error.
2769	The documentation for each function indicates whether	2792	The documentation for each function indicates whether
2770	it can throw errors.	2793	it can raise errors.
2771		2794
2772		2795
2773	<p>	2796	<p>
2774	Inside a C function you can throw an error by calling <a href="#lua_error"><code>lua_error</code></a>.	2797	Inside a C function you can raise an error by calling <a href="#lua_error"><code>lua_error</code></a>.
2775		2798
2776		2799
2777		2800
@@ -2781,7 +2804,7 @@ Inside a C function you can throw an error by calling <a href="#lua_error"> · 3 unmodified lines
2781		2804
2782	<p>	2805	<p>
2783	Internally, Lua uses the C <code>longjmp</code> facility to yield a coroutine.	2806	Internally, Lua uses the C <code>longjmp</code> facility to yield a coroutine.
2784	Therefore, if a function <code>foo</code> calls an API function	2807	Therefore, if a C function <code>foo</code> calls an API function
2785	and this API function yields	2808	and this API function yields
2786	(directly or indirectly by calling another function that yields),	2809	(directly or indirectly by calling another function that yields),
2787	Lua cannot return to <code>foo</code> any more,	2810	Lua cannot return to <code>foo</code> any more,
@@ -2823,6 +2846,67 @@ the continuation function should continue the task · 35 unmodified lines
2823	of the original function.	2846	of the original function.
2824		2847
2825		2848
		2849	<p>
		2850	As an illustration, consider the following function:
		2851
		2852	<pre>
		2853	int original_function (lua_State *L) {
		2854	... /* code 1 */
		2855	status = lua_pcall(L, n, m, h); /* calls Lua */
		2856	... /* code 2 */
		2857	}
		2858	</pre><p>
		2859	Now we want to allow
		2860	the Lua code being ran by <a href="#lua_pcall"><code>lua_pcall</code></a> to yield.
		2861	First, we can rewrite our function like here:
		2862
		2863	<pre>
		2864	int k (lua_State *L, int status, int ctx) {
		2865	... /* code 2 */
		2866	}
		2867
		2868	int original_function (lua_State *L) {
		2869	... /* code 1 */
		2870	return k(L, lua_pcall(L, n, m, h), ctx);
		2871	}
		2872	</pre><p>
		2873	In the above code,
		2874	the new function <code>k</code> is a
		2875	<em>continuation function</em> (with type <a href="#lua_KFunction"><code>lua_KFunction</code></a>),
		2876	which should do all the work that the original function
		2877	was doing after calling <a href="#lua_pcall"><code>lua_pcall</code></a>.
		2878	Now, we must inform Lua that it must call <code>k</code> if the Lua code
		2879	begin running by <a href="#lua_pcall"><code>lua_pcall</code></a> gets interrupted in some way
		2880	(errors or yielding),
		2881	so we rewrite the code as here,
		2882	replacing <a href="#lua_pcall"><code>lua_pcall</code></a> by <a href="#lua_pcallk"><code>lua_pcallk</code></a>:
		2883
		2884	<pre>
		2885	int original_function (lua_State *L) {
		2886	... /* code 1 */
		2887	return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
		2888	}
		2889	</pre>
		2890
		2891	<p>
		2892	Besides the Lua state,
		2893	the continuation function has two other parameters:
		2894	the final status of the call plus the context value (<code>ctx</code>) that
		2895	was passed originally to <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
		2896	(Lua does not use this context value;
		2897	it only passes this value from the original function to the
		2898	continuation function.)
		2899	For <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
		2900	the status is the same value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
		2901	except that it is <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when being executed after an yield
		2902	(instead of <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>).
		2903	For <a href="#lua_yieldk"><code>lua_yieldk</code></a> and <a href="#lua_callk"><code>lua_callk</code></a>,
		2904	the status is always <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when Lua calls the continuation.
		2905	(For these two functions,
		2906	Lua will not call the continuation in case of errors,
		2907	because they do not handle errors.)
		2908
		2909
2826	<p>	2910	<p>
2827	Lua treats the continuation function as if it were the original function.	2911	Lua treats the continuation function as if it were the original function.
2828	The continuation function receives the same Lua stack	2912	The continuation function receives the same Lua stack
@@ -2836,11 +2920,6 @@ Whatever it returns is handled by Lua as if it were the return · 7 unmodified lines
2836	of the original function.	2920	of the original function.
2837		2921
2838		2922
2839	<p>
2840	The only difference in the Lua state between the original function
2841	and its continuation is the result of a call to <a href="#lua_getctx"><code>lua_getctx</code></a>.
2842
2843
2844		2923
2845		2924
2846		2925
@@ -2867,10 +2946,10 @@ we cannot know how many elements the function pops/pushes · 20 unmodified lines
2867	by looking only at its arguments	2946	by looking only at its arguments
2868	(e.g., they may depend on what is on the stack).	2947	(e.g., they may depend on what is on the stack).
2869	The third field, <code>x</code>,	2948	The third field, <code>x</code>,
2870	tells whether the function may throw errors:	2949	tells whether the function may raise errors:
2871	'<code>-</code>' means the function never throws any error;	2950	'<code>-</code>' means the function never raises any error;
2872	'<code>e</code>' means the function may throw errors;	2951	'<code>e</code>' means the function may raise errors;
2873	'<code>v</code>' means the function may throw an error on purpose.	2952	'<code>v</code>' means the function may raise an error on purpose.
2874		2953
2875		2954
2876		2955
@@ -2928,13 +3007,13 @@ Lua assumes the following behavior from the allocator function: · 51 unmodified lines
2928		3007
2929	<p>	3008	<p>
2930	When <code>nsize</code> is zero,	3009	When <code>nsize</code> is zero,
2931	the allocator should behave like <code>free</code>	3010	the allocator must behave like <code>free</code>
2932	and return <code>NULL</code>.	3011	and return <code>NULL</code>.
2933		3012
2934		3013
2935	<p>	3014	<p>
2936	When <code>nsize</code> is not zero,	3015	When <code>nsize</code> is not zero,
2937	the allocator should behave like <code>realloc</code>.	3016	the allocator must behave like <code>realloc</code>.
2938	The allocator returns <code>NULL</code>	3017	The allocator returns <code>NULL</code>
2939	if and only if it cannot fulfill the request.	3018	if and only if it cannot fulfill the request.
2940	Lua assumes that the allocator never fails when	3019	Lua assumes that the allocator never fails when
@@ -2990,7 +3069,7 @@ The value of <code>op</code> must be one of the following constants: · 49 unmodified lines
2990	<li><b><a name="pdf-LUA_OPADD"><code>LUA_OPADD</code></a>: </b> performs addition (<code>+</code>)</li>	3069	<li><b><a name="pdf-LUA_OPADD"><code>LUA_OPADD</code></a>: </b> performs addition (<code>+</code>)</li>
2991	<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>	3070	<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>
2992	<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>	3071	<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>
2993	<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs division (<code>/</code>)</li>	3072	<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs float division (<code>/</code>)</li>
2994	<li><b><a name="pdf-LUA_OPIDIV"><code>LUA_OPIDIV</code></a>: </b> performs integer division (<code>//</code>)</li>	3073	<li><b><a name="pdf-LUA_OPIDIV"><code>LUA_OPIDIV</code></a>: </b> performs integer division (<code>//</code>)</li>
2995	<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>	3074	<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>
2996	<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>	3075	<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>
@@ -3081,7 +3160,7 @@ This is considered good programming practice. · 84 unmodified lines
3081	<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>	3160	<hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>
3082	<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>	3161	<span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
3083	<pre>void lua_callk (lua_State *L, int nargs, int nresults, int ctx,	3162	<pre>void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
3084	lua_CFunction k);</pre>	3163	lua_KFunction k);</pre>
3085		3164
3086	<p>	3165	<p>
3087	This function behaves exactly like <a href="#lua_call"><code>lua_call</code></a>,	3166	This function behaves exactly like <a href="#lua_call"><code>lua_call</code></a>,
@@ -3258,7 +3337,10 @@ Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</c · 170 unmodified lines
3258		3337
3259	<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>	3338	<hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
3260	<span class="apii">[-0, +0, <em>e</em>]</span>	3339	<span class="apii">[-0, +0, <em>e</em>]</span>
3261	<pre>int lua_dump (lua_State L, lua_Writer writer, void data);</pre>	3340	<pre>int lua_dump (lua_State *L,
		3341	lua_Writer writer,
		3342	void *data,
		3343	int strip);</pre>
3262		3344
3263	<p>	3345	<p>
3264	Dumps a function as a binary chunk.	3346	Dumps a function as a binary chunk.
@@ -3272,6 +3354,12 @@ with the given <code>data</code> · 7 unmodified lines
3272	to write them.	3354	to write them.
3273		3355
3274		3356
		3357	<p>
		3358	If <code>strip</code> is true,
		3359	the binary representation is created without debug information
		3360	about the function.
		3361
		3362
3275	<p>	3363	<p>
3276	The value returned is the error code returned by the last	3364	The value returned is the error code returned by the last
3277	call to the writer;	3365	call to the writer;
@@ -3291,8 +3379,7 @@ This function does not pop the Lua function from the stack. · 13 unmodified lines
3291		3379
3292	<p>	3380	<p>
3293	Generates a Lua error.	3381	Generates a Lua error.
3294	The error message (which can actually be a Lua value of any type)	3382	The error object must be on the stack top.
3295	must be on the stack top.
3296	This function does a long jump,	3383	This function does a long jump,
3297	and therefore never returns	3384	and therefore never returns
3298	(see <a href="#luaL_error"><code>luaL_error</code></a>).	3385	(see <a href="#luaL_error"><code>luaL_error</code></a>).
@@ -3380,45 +3467,9 @@ opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>. · 81 unmodified lines
3380		3467
3381		3468
3382		3469
3383	<hr><h3><a name="lua_getctx"><code>lua_getctx</code></a></h3><p>
3384	<span class="apii">[-0, +0, –]</span>
3385	<pre>int lua_getctx (lua_State L, int ctx);</pre>
3386
3387	<p>
3388	This function is called by a continuation function (see <a href="#4.7">§4.7</a>)
3389	to retrieve the status of the thread and a context information.
3390
3391
3392	<p>
3393	When called in the original function,
3394	<a href="#lua_getctx"><code>lua_getctx</code></a> always returns <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>
3395	and does not change the value of its argument <code>ctx</code>.
3396	When called inside a continuation function,
3397	<a href="#lua_getctx"><code>lua_getctx</code></a> returns <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> and sets
3398	the value of <code>ctx</code> to be the context information
3399	(the value passed as the <code>ctx</code> argument
3400	to the callee together with the continuation function).
3401
3402
3403	<p>
3404	When the callee is <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
3405	Lua may also call its continuation function
3406	to handle errors during the call.
3407	That is, upon an error in the function called by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
3408	Lua may not return to the original function
3409	but instead may call the continuation function.
3410	In that case, a call to <a href="#lua_getctx"><code>lua_getctx</code></a> will return the error code
3411	(the value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>);
3412	the value of <code>ctx</code> will be set to the context information,
3413	as in the case of a yield.
3414
3415
3416
3417
3418
3419	<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>	3470	<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
3420	<span class="apii">[-0, +1, <em>e</em>]</span>	3471	<span class="apii">[-0, +1, <em>e</em>]</span>
3421	<pre>void lua_getfield (lua_State L, int index, const char k);</pre>	3472	<pre>int lua_getfield (lua_State L, int index, const char k);</pre>
3422		3473
3423	<p>	3474	<p>
3424	Pushes onto the stack the value <code>t[k]</code>,	3475	Pushes onto the stack the value <code>t[k]</code>,
@@ -3427,6 +3478,10 @@ As in Lua, this function may trigger a metamethod · 2 unmodified lines
3427	for the "index" event (see <a href="#2.4">§2.4</a>).	3478	for the "index" event (see <a href="#2.4">§2.4</a>).
3428		3479
3429		3480
		3481	<p>
		3482	Returns the type of the pushed value.
		3483
		3484
3430		3485
3431		3486
3432		3487
@@ -3495,13 +3550,17 @@ this result is equal to the number of elements in the stack · 62 unmodified lines
3495		3550
3496	<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>	3551	<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>
3497	<span class="apii">[-0, +1, –]</span>	3552	<span class="apii">[-0, +1, –]</span>
3498	<pre>void lua_getuservalue (lua_State *L, int index);</pre>	3553	<pre>int lua_getuservalue (lua_State *L, int index);</pre>
3499		3554
3500	<p>	3555	<p>
3501	Pushes onto the stack the Lua value associated with the userdata	3556	Pushes onto the stack the Lua value associated with the userdata
3502	at the given index.	3557	at the given index.
3503		3558
3504		3559
		3560	<p>
		3561	Returns the type of the pushed value.
		3562
		3563
3505		3564
3506		3565
3507		3566
@@ -3520,7 +3579,7 @@ because a pseudo-index is not an actual stack position. · 12 unmodified lines
3520		3579
3521		3580
3522	<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>	3581	<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
3523	<pre>typedef long long int lua_Integer;</pre>	3582	<pre>typedef ... lua_Integer;</pre>
3524		3583
3525	<p>	3584	<p>
3526	The type of integers in Lua.	3585	The type of integers in Lua.
@@ -3534,6 +3593,12 @@ to <code>long</code> or <code>int</code> · 7 unmodified lines
3534	(usually a 32-bit two-complement integer).	3593	(usually a 32-bit two-complement integer).
3535		3594
3536		3595
		3596	<p>
		3597	Lua also defines the constants
		3598	<a name="pdf-LUA_MININTEGER"><code>LUA_MININTEGER</code></a> and <a name="pdf-LUA_MAXINTEGER"><code>LUA_MAXINTEGER</code></a>,
		3599	with the minimum and the maximum values that fit in this type.
		3600
		3601
3537		3602
3538		3603
3539		3604
@@ -3697,6 +3762,28 @@ Returns 1 if the value at the given index is a userdata · 157 unmodified lines
3697		3762
3698		3763
3699		3764
		3765	<hr><h3><a name="lua_isyieldable"><code>lua_isyieldable</code></a></h3><p>
		3766	<span class="apii">[-0, +0, –]</span>
		3767	<pre>int lua_isyieldable (lua_State *L);</pre>
		3768
		3769	<p>
		3770	Returns 1 if the given coroutine can yield,
		3771	and 0 otherwise.
		3772
		3773
		3774
		3775
		3776
		3777	<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>
		3779
		3780	<p>
		3781	Type for continuation functions (see <a href="#4.7">§4.7</a>).
		3782
		3783
		3784
		3785
		3786
3700	<hr><h3><a name="lua_len"><code>lua_len</code></a></h3><p>	3787	<hr><h3><a name="lua_len"><code>lua_len</code></a></h3><p>
3701	<span class="apii">[-0, +1, <em>e</em>]</span>	3788	<span class="apii">[-0, +1, <em>e</em>]</span>
3702	<pre>void lua_len (lua_State *L, int index);</pre>	3789	<pre>void lua_len (lua_State *L, int index);</pre>
@@ -3768,7 +3855,7 @@ a <code>NULL</code> value is equivalent to the string "<code>bt</code>". · 65 unmodified lines
3768		3855
3769	<p>	3856	<p>
3770	<code>lua_load</code> uses the stack internally,	3857	<code>lua_load</code> uses the stack internally,
3771	so the reader function should always leave the stack	3858	so the reader function must always leave the stack
3772	unmodified when returning.	3859	unmodified when returning.
3773		3860
3774		3861
@@ -3907,6 +3994,28 @@ but that can be changed in <code>luaconf.h</code> to a single float. · 132 unmodified lines
3907		3994
3908		3995
3909		3996
		3997	<hr><h3><a name="lua_numtointeger"><code>lua_numtointeger</code></a></h3>
		3998	<pre>int lua_numtointeger (lua_Number n, lua_Integer *p);</pre>
		3999
		4000	<p>
		4001	Converts a Lua float to a Lua integer.
		4002	This macro assumes that <code>n</code> has an integral value.
		4003	If that value is within the range of Lua integers,
		4004	it is converted to an integer and assigned to <code>*p</code>.
		4005	The macro results in a boolean indicating whether the
		4006	conversion was successful.
		4007	(Note that this range test can be tricky to do
		4008	correctly without this macro,
		4009	due to roundings.)
		4010
		4011
		4012	<p>
		4013	This macro may evaluate its arguments more than once.
		4014
		4015
		4016
		4017
		4018
3910	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>	4019	<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p>
3911	<span class="apii">[-(nargs + 1), +(nresults\|1), –]</span>	4020	<span class="apii">[-(nargs + 1), +(nresults\|1), –]</span>
3912	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>	4021	<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre>
@@ -3950,7 +4059,7 @@ since by then the stack has unwound. · 37 unmodified lines
3950		4059
3951		4060
3952	<p>	4061	<p>
3953	The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns one of the following codes	4062	The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns one of the following constants
3954	(defined in <code>lua.h</code>):	4063	(defined in <code>lua.h</code>):
3955		4064
3956	<ul>	4065	<ul>
@@ -3973,8 +4082,7 @@ error while running the message handler. · 16 unmodified lines
3973		4082
3974	<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>	4083	<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
3975	error while running a <code>__gc</code> metamethod.	4084	error while running a <code>__gc</code> metamethod.
3976	(This error typically has no relation with the function being called.	4085	(This error typically has no relation with the function being called.)
3977	It is generated by the garbage collector.)
3978	</li>	4086	</li>
3979		4087
3980	</ul>	4088	</ul>
@@ -3989,7 +4097,7 @@ It is generated by the garbage collector.) · 8 unmodified lines
3989	int nresults,	4097	int nresults,
3990	int errfunc,	4098	int errfunc,
3991	int ctx,	4099	int ctx,
3992	lua_CFunction k);</pre>	4100	lua_KFunction k);</pre>
3993		4101
3994	<p>	4102	<p>
3995	This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,	4103	This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>,
@@ -4035,11 +4143,11 @@ it is possible to associate some values with it, · 39 unmodified lines
4035	thus creating a C closure (see <a href="#4.4">§4.4</a>);	4143	thus creating a C closure (see <a href="#4.4">§4.4</a>);
4036	these values are then accessible to the function whenever it is called.	4144	these values are then accessible to the function whenever it is called.
4037	To associate values with a C function,	4145	To associate values with a C function,
4038	first these values should be pushed onto the stack	4146	first these values must be pushed onto the stack
4039	(when there are multiple values, the first value is pushed first).	4147	(when there are multiple values, the first value is pushed first).
4040	Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>	4148	Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>
4041	is called to create and push the C function onto the stack,	4149	is called to create and push the C function onto the stack,
4042	with the argument <code>n</code> telling how many values should be	4150	with the argument <code>n</code> telling how many values will be
4043	associated with the function.	4151	associated with the function.
4044	<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.	4152	<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack.
4045		4153
@@ -4052,7 +4160,7 @@ The maximum value for <code>n</code> is 255. · 6 unmodified lines
4052	When <code>n</code> is zero,	4160	When <code>n</code> is zero,
4053	this function creates a <em>light C function</em>,	4161	this function creates a <em>light C function</em>,
4054	which is just a pointer to the C function.	4162	which is just a pointer to the C function.
4055	In that case, it never throws a memory error.	4163	In that case, it never raises a memory error.
4056		4164
4057		4165
4058		4166
@@ -4540,6 +4648,22 @@ this parameter can be <code>NULL</code>. · 481 unmodified lines
4540		4648
4541		4649
4542		4650
		4651	<hr><h3><a name="lua_rotate"><code>lua_rotate</code></a></h3><p>
		4652	<span class="apii">[-0, +0, –]</span>
		4653	<pre>void lua_rotate (lua_State *L, int idx, int n);</pre>
		4654
		4655	<p>
		4656	Rotates the stack elements from <code>idx</code> to the top <code>n</code> positions
		4657	in the direction of the top, for a positive <code>n</code>,
		4658	or <code>-n</code> positions in the direction of the bottom,
		4659	for a negative <code>n</code>.
		4660	The absolute value of <code>n</code> must not be greater than the size
		4661	of the slice being rotated.
		4662
		4663
		4664
		4665
		4666
4543	<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>	4667	<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p>
4544	<span class="apii">[-0, +0, –]</span>	4668	<span class="apii">[-0, +0, –]</span>
4545	<pre>void lua_setallocf (lua_State L, lua_Alloc f, void ud);</pre>	4669	<pre>void lua_setallocf (lua_State L, lua_Alloc f, void ud);</pre>
@@ -4689,11 +4813,13 @@ You can resume threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> · 143 unmodified lines
4689		4813
4690	<hr><h3><a name="lua_strtonum"><code>lua_strtonum</code></a></h3><p>	4814	<hr><h3><a name="lua_strtonum"><code>lua_strtonum</code></a></h3><p>
4691	<span class="apii">[-0, +1, –]</span>	4815	<span class="apii">[-0, +1, –]</span>
4692	<pre>int lua_strtonum (lua_State L, const char s, size_t len);</pre>	4816	<pre>size_t lua_strtonum (lua_State L, const char s);</pre>
4693		4817
4694	<p>	4818	<p>
4695	Converts the string <code>s</code> (with length <code>len</code>) to a number and	4819	Converts the zero-terminated string <code>s</code> to a number,
4696	pushes that number into the stack.	4820	pushes that number into the stack,
		4821	and returns the total size of the string
		4822	(that is, its length plus one).
4697	The conversion can result in an integer or a float,	4823	The conversion can result in an integer or a float,
4698	according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>).	4824	according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>).
4699	The string may have leading and trailing spaces and a sign.	4825	The string may have leading and trailing spaces and a sign.
@@ -4969,12 +5095,17 @@ which must be one the values returned by <a href="#lua_type"><code>lua_type</cod · 269 unmodified lines
4969		5095
4970		5096
4971	<hr><h3><a name="lua_Unsigned"><code>lua_Unsigned</code></a></h3>	5097	<hr><h3><a name="lua_Unsigned"><code>lua_Unsigned</code></a></h3>
4972	<pre>typedef unsigned long lua_Unsigned;</pre>	5098	<pre>typedef ... lua_Unsigned;</pre>
4973		5099
4974	<p>	5100	<p>
4975	The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>.	5101	The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>.
4976		5102
4977		5103
		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
4978		5109
4979		5110
4980		5111
@@ -5063,7 +5194,7 @@ the function calling <code>lua_yield</code>. · 82 unmodified lines
5063		5194
5064	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>	5195	<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p>
5065	<span class="apii">[-?, +?, –]</span>	5196	<span class="apii">[-?, +?, –]</span>
5066	<pre>int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k);</pre>	5197	<pre>int lua_yieldk (lua_State *L, int nresults, int ctx, lua_KFunction k);</pre>
5067		5198
5068	<p>	5199	<p>
5069	Yields a coroutine.	5200	Yields a coroutine.
@@ -5074,13 +5205,13 @@ This function should only be called as the · 4 unmodified lines
5074	return expression of a C function, as follows:	5205	return expression of a C function, as follows:
5075		5206
5076	<pre>	5207	<pre>
5077	return lua_yieldk (L, n, i, k);	5208	return lua_yieldk (L, n, ctx, k);
5078	</pre><p>	5209	</pre><p>
5079	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,	5210	When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,
5080	the running coroutine suspends its execution,	5211	the running coroutine suspends its execution,
5081	and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.	5212	and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns.
5082	The parameter <code>nresults</code> is the number of values from the stack	5213	The parameter <code>nresults</code> is the number of values from the stack
5083	that are passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.	5214	that will be passed as results to <a href="#lua_resume"><code>lua_resume</code></a>.
5084		5215
5085		5216
5086	<p>	5217	<p>
@@ -5089,11 +5220,11 @@ Lua calls the given continuation function <code>k</code> to continue · 2 unmodified lines
5089	the execution of the C function that yielded (see <a href="#4.7">§4.7</a>).	5220	the execution of the C function that yielded (see <a href="#4.7">§4.7</a>).
5090	This continuation function receives the same stack	5221	This continuation function receives the same stack
5091	from the previous function,	5222	from the previous function,
5092	with the results removed and	5223	with the <code>n</code> results removed and
5093	replaced by the arguments passed to <a href="#lua_resume"><code>lua_resume</code></a>.	5224	replaced by the arguments passed to <a href="#lua_resume"><code>lua_resume</code></a>.
5094	Moreover,	5225	Moreover,
5095	the continuation function may access the value <code>ctx</code>	5226	the continuation function receives the value <code>ctx</code>
5096	by calling <a href="#lua_getctx"><code>lua_getctx</code></a>.	5227	that was passed to <a href="#lua_yieldk"><code>lua_yieldk</code></a>.
5097		5228
5098		5229
5099		5230
@@ -5326,6 +5457,11 @@ numbers of the lines that are valid on the function. · 226 unmodified lines
5326	(A <em>valid line</em> is a line with some associated code,	5457	(A <em>valid line</em> is a line with some associated code,
5327	that is, a line where you can put a break point.	5458	that is, a line where you can put a break point.
5328	Non-valid lines include empty lines and comments.)	5459	Non-valid lines include empty lines and comments.)
		5460
		5461
		5462	<p>
		5463	If this option is given together with option '<code>f</code>',
		5464	its table is pushed after the function.
5329	</li>	5465	</li>
5330		5466
5331	</ul>	5467	</ul>
@@ -5363,7 +5499,7 @@ and returns its name. · 31 unmodified lines
5363		5499
5364		5500
5365	<p>	5501	<p>
5366	In the second case, <code>ar</code> should be <code>NULL</code> and the function	5502	In the second case, <code>ar</code> must be <code>NULL</code> and the function
5367	to be inspected must be at the top of the stack.	5503	to be inspected must be at the top of the stack.
5368	In this case, only parameters of Lua functions are visible	5504	In this case, only parameters of Lua functions are visible
5369	(as there is no information about what variables are active)	5505	(as there is no information about what variables are active)
@@ -5656,7 +5792,7 @@ you should not use these functions for other stack values. · 286 unmodified lines
5656		5792
5657	<p>	5793	<p>
5658	Functions called <code>luaL_check*</code>	5794	Functions called <code>luaL_check*</code>
5659	always throw an error if the check is not satisfied.	5795	always raise an error if the check is not satisfied.
5660		5796
5661		5797
5662		5798
@@ -6398,7 +6534,7 @@ returns 0. · 735 unmodified lines
6398	Otherwise,	6534	Otherwise,
6399	creates a new table to be used as a metatable for userdata,	6535	creates a new table to be used as a metatable for userdata,
6400	adds to this new table the pair <code>__name = tname</code>,	6536	adds to this new table the pair <code>__name = tname</code>,
6401	adds to the registry the pair <code></code>[tname] = new table,	6537	adds to the registry the pair <code>[tname] = new table</code>,
6402	and returns 1.	6538	and returns 1.
6403		6539
6404		6540
@@ -6762,7 +6898,7 @@ the field value is changed to <b>nil</b> to signal that the handle is closed. · 357 unmodified lines
6762	<p>	6898	<p>
6763	This function works like <a href="#luaL_checkudata"><code>luaL_checkudata</code></a>,	6899	This function works like <a href="#luaL_checkudata"><code>luaL_checkudata</code></a>,
6764	except that, when the test fails,	6900	except that, when the test fails,
6765	it returns <code>NULL</code> instead of throwing an error.	6901	it returns <code>NULL</code> instead of raising an error.
6766		6902
6767		6903
6768		6904
@@ -6862,6 +6998,8 @@ This function is used to build a prefix for error messages. · 93 unmodified lines
6862		6998
6863		6999
6864		7000
		7001
		7002
6865	<h1>6 – <a name="6">Standard Libraries</a></h1>	7003	<h1>6 – <a name="6">Standard Libraries</a></h1>
6866		7004
6867	<p>	7005	<p>
@@ -6939,11 +7077,15 @@ implementations for some of its facilities. · 71 unmodified lines
6939		7077
6940	<p>	7078	<p>
6941	<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>	7079	<hr><h3><a name="pdf-assert"><code>assert (v [, message])</code></a></h3>
6942	Issues an error when	7080
		7081
		7082	<p>
		7083	Calls <a href="#pdf-error"><code>error</code></a> if
6943	the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);	7084	the value of its argument <code>v</code> is false (i.e., <b>nil</b> or <b>false</b>);
6944	otherwise, returns all its arguments.	7085	otherwise, returns all its arguments.
6945	<code>message</code> is an error message;	7086	In case of error,
6946	when absent, it defaults to "assertion failed!"	7087	<code>message</code> is the error object;
		7088	when absent, it defaults to "<code>assertion failed!</code>"
6947		7089
6948		7090
6949		7091
@@ -7009,16 +7151,6 @@ returns a boolean that tells whether the collector is running · 59 unmodified lines
7009	(i.e., not stopped).	7151	(i.e., not stopped).
7010	</li>	7152	</li>
7011		7153
7012	<li><b>"<code>generational</code>": </b>
7013	changes the collector to generational mode.
7014	This is an experimental feature (see <a href="#2.5">§2.5</a>).
7015	</li>
7016
7017	<li><b>"<code>incremental</code>": </b>
7018	changes the collector to incremental mode.
7019	This is the default mode.
7020	</li>
7021
7022	</ul>	7154	</ul>
7023		7155
7024		7156
@@ -7038,7 +7170,7 @@ to its caller (that is, <code>dofile</code> does not run in protected mode). · 13 unmodified lines
7038	<p>	7170	<p>
7039	<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>	7171	<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>
7040	Terminates the last protected function called	7172	Terminates the last protected function called
7041	and returns <code>message</code> as the error message.	7173	and returns <code>message</code> as the error object.
7042	Function <code>error</code> never returns.	7174	Function <code>error</code> never returns.
7043		7175
7044		7176
@@ -7375,7 +7507,7 @@ according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>). · 330 unmodified lines
7375		7507
7376	<p>	7508	<p>
7377	When called with <code>base</code>,	7509	When called with <code>base</code>,
7378	then <code>e</code> should be a string to be interpreted as	7510	then <code>e</code> must be a string to be interpreted as
7379	an integer numeral in that base.	7511	an integer numeral in that base.
7380	The base may be any integer between 2 and 36, inclusive.	7512	The base may be any integer between 2 and 36, inclusive.
7381	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)	7513	In bases above 10, the letter '<code>A</code>' (in either upper or lower case)
@@ -7466,6 +7598,21 @@ an object with type <code>"thread"</code>. · 84 unmodified lines
7466		7598
7467		7599
7468		7600
		7601	<p>
		7602	<hr><h3><a name="pdf-coroutine.isyieldable"><code>coroutine.isyieldable ()</code></a></h3>
		7603
		7604
		7605	<p>
		7606	Returns true when the running coroutine can yield.
		7607
		7608
		7609	<p>
		7610	A running coroutine is yieldable if it is not the main thread and
		7611	it is not inside a non-yieldable C function.
		7612
		7613
		7614
		7615
7469	<p>	7616	<p>
7470	<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, ···])</code></a></h3>	7617	<hr><h3><a name="pdf-coroutine.resume"><code>coroutine.resume (co [, val1, ···])</code></a></h3>
7471		7618
@@ -7485,8 +7632,8 @@ as the results from the yield. · 13 unmodified lines
7485	<p>	7632	<p>
7486	If the coroutine runs without any errors,	7633	If the coroutine runs without any errors,
7487	<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>	7634	<code>resume</code> returns <b>true</b> plus any values passed to <code>yield</code>
7488	(if the coroutine yields) or any values returned by the body function	7635	(when the coroutine yields) or any values returned by the body function
7489	(if the coroutine terminates).	7636	(when the coroutine terminates).
7490	If there is any error,	7637	If there is any error,
7491	<code>resume</code> returns <b>false</b> plus the error message.	7638	<code>resume</code> returns <b>false</b> plus the error message.
7492		7639
@@ -7588,7 +7735,7 @@ for <a href="#pdf-package.searchers"><code>package.searchers</code></a>. · 95 unmodified lines
7588	<p>	7735	<p>
7589	First <code>require</code> queries <code>package.preload[modname]</code>.	7736	First <code>require</code> queries <code>package.preload[modname]</code>.
7590	If it has a value,	7737	If it has a value,
7591	this value (which should be a function) is the loader.	7738	this value (which must be a function) is the loader.
7592	Otherwise <code>require</code> searches for a Lua loader using the	7739	Otherwise <code>require</code> searches for a Lua loader using the
7593	path stored in <a href="#pdf-package.path"><code>package.path</code></a>.	7740	path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
7594	If that also fails, it searches for a C loader using the	7741	If that also fails, it searches for a C loader using the
@@ -7663,7 +7810,7 @@ The path used by <a href="#pdf-require"><code>require</code></a> to search for a · 68 unmodified lines
7663	<p>	7810	<p>
7664	Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way	7811	Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the same way
7665	it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,	7812	it initializes the Lua path <a href="#pdf-package.path"><code>package.path</code></a>,
7666	using the environment variable <a name="pdf-LUA_CPATH_5_2"><code>LUA_CPATH_5_2</code></a>	7813	using the environment variable <a name="pdf-LUA_CPATH_5_3"><code>LUA_CPATH_5_3</code></a>
7667	or the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>	7814	or the environment variable <a name="pdf-LUA_CPATH"><code>LUA_CPATH</code></a>
7668	or a default path defined in <code>luaconf.h</code>.	7815	or a default path defined in <code>luaconf.h</code>.
7669		7816
@@ -7741,7 +7888,7 @@ The path used by <a href="#pdf-require"><code>require</code></a> to search for a · 71 unmodified lines
7741		7888
7742	<p>	7889	<p>
7743	At start-up, Lua initializes this variable with	7890	At start-up, Lua initializes this variable with
7744	the value of the environment variable <a name="pdf-LUA_PATH_5_2"><code>LUA_PATH_5_2</code></a> or	7891	the value of the environment variable <a name="pdf-LUA_PATH_5_3"><code>LUA_PATH_5_3</code></a> or
7745	the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or	7892	the environment variable <a name="pdf-LUA_PATH"><code>LUA_PATH</code></a> or
7746	with a default path defined in <code>luaconf.h</code>,	7893	with a default path defined in <code>luaconf.h</code>,
7747	if those environment variables are not defined.	7894	if those environment variables are not defined.
@@ -7973,6 +8120,45 @@ about the function · 225 unmodified lines
7973		8120
7974		8121
7975		8122
		8123	<p>
		8124	<hr><h3><a name="pdf-string.dumpfloat"><code>string.dumpfloat (n [, size [, endianness]])</code></a></h3>
		8125	Returns a string with the machine representation of float <code>n</code>,
		8126	with given size and endianness.
		8127	The <code>size</code> is the string "<code>f</code>" (single precision),
		8128	"<code>d</code>" (double precision), or "<code>n</code>",
		8129	which means the size of a <a href="#lua_Number"><code>lua_Number</code></a>;
		8130	its default is "<code>n</code>".
		8131	The endianness is the string "<code>l</code>" (little endian), "<code>b</code>" (big endian),
		8132	or "<code>n</code>" (native);
		8133	the default is the native endianness.
		8134
		8135
		8136	<p>
		8137	This function may not work correctly in architectures
		8138	with mixed endian.
		8139
		8140
		8141	<p>
		8142	<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>,
		8144	with <code>size</code> bytes and given endianness.
		8145	The <code>size</code> can be any value from 1 to 12,
		8146	or 0, which means the size of a <a href="#lua_Integer"><code>lua_Integer</code></a>
		8147	(8 bytes in standard Lua);
		8148	its default is zero.
		8149	The endianness is the string "<code>l</code>" (little endian), "<code>b</code>" (big endian),
		8150	or "<code>n</code>" (native);
		8151	the default is the native endianness.
		8152
		8153
		8154	<p>
		8155	This function may not work correctly in architectures
		8156	with mixed endian or
		8157	that do not use a two-complement representation for integers.
		8158
		8159
		8160
		8161
7976	<p>	8162	<p>
7977	<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>	8163	<hr><h3><a name="pdf-string.find"><code>string.find (s, pattern [, init [, plain]])</code></a></h3>
7978		8164
@@ -8195,45 +8381,6 @@ its default value is 1 and can be negative. · 216 unmodified lines
8195		8381
8196		8382
8197		8383
8198	<p>
8199	<hr><h3><a name="pdf-string.packfloat"><code>string.packfloat (n [, size [, endianess]])</code></a></h3>
8200	Returns a string with the machine representation of float <code>n</code>,
8201	with given size and endianess.
8202	The <code>size</code> is the string "<code>f</code>" (single precision),
8203	"<code>d</code>" (double precision), or "<code>n</code>",
8204	which means the size of a <a href="#lua_Number"><code>lua_Number</code></a>;
8205	its default is St{n}.
8206	The endianess is the string "<code>l</code>" (little endian), "<code>b</code>" (big endian),
8207	or "<code>n</code>" (native);
8208	the default is the native endianess.
8209
8210
8211	<p>
8212	(This function may not work correctly for non-native endianess
8213	in mixed-endian architectures.)
8214
8215
8216
8217
8218	<p>
8219	<hr><h3><a name="pdf-string.packint"><code>string.packint (n [, size [, endianess]])</code></a></h3>
8220	Returns a string with the machine representation of integer <code>n</code>,
8221	with <code>size</code> bytes and given endianess.
8222	The <code>size</code> can be any value from 1 to 8 or 0,
8223	which means the size of a <a href="#lua_Integer"><code>lua_Integer</code></a>;
8224	its default is zero.
8225	The endianess is the string "<code>l</code>" (little endian), "<code>b</code>" (big endian),
8226	or "<code>n</code>" (native);
8227	the default is the native endianess.
8228
8229
8230	<p>
8231	(This function may not work correctly for native endianess
8232	in mixed-endian architectures.)
8233
8234
8235
8236
8237	<p>	8384	<p>
8238	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>	8385	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>
8239	Returns a string that is the concatenation of <code>n</code> copies of	8386	Returns a string that is the concatenation of <code>n</code> copies of
@@ -8279,19 +8426,19 @@ the function returns the empty string. · 39 unmodified lines
8279		8426
8280		8427
8281	<p>	8428	<p>
8282	<hr><h3><a name="pdf-string.unpackfloat"><code>string.unpackfloat (s [, pos [, size [, endianess]]])</code></a></h3>	8429	<hr><h3><a name="pdf-string.undumpfloat"><code>string.undumpfloat (s [, pos [, size [, endianness]]])</code></a></h3>
8283	Reads the machine representation of a float starting at position	8430	Reads the machine representation of a float starting at position
8284	<code>pos</code> in string <code>s</code> and returns that number.	8431	<code>pos</code> in string <code>s</code> and returns that number.
8285	See <a href="#pdf-string.packfloat"><code>string.packfloat</code></a> for details about <code>size</code> and <code>endianess</code>.	8432	See <a href="#pdf-string.dumpfloat"><code>string.dumpfloat</code></a> for details about <code>size</code> and <code>endianness</code>.
8286		8433
8287		8434
8288		8435
8289		8436
8290	<p>	8437	<p>
8291	<hr><h3><a name="pdf-string.unpackint"><code>string.unpackint (s [, pos [, size [, endianess]]])</code></a></h3>	8438	<hr><h3><a name="pdf-string.undumpint"><code>string.undumpint (s [, pos [, size [, endianness]]])</code></a></h3>
8292	Reads the machine representation of an integer starting at position	8439	Reads the machine representation of an integer starting at position
8293	<code>pos</code> in string <code>s</code> and returns that integer.	8440	<code>pos</code> in string <code>s</code> and returns that integer.
8294	See <a href="#pdf-string.packint"><code>string.packint</code></a> for details about <code>size</code> and <code>endianess</code>.	8441	See <a href="#pdf-string.dumpint"><code>string.dumpint</code></a> for details about <code>size</code> and <code>endianness</code>.
8295		8442
8296		8443
8297	<p>	8444	<p>
@@ -8517,7 +8664,7 @@ such as character classification, is outside its scope. · 219 unmodified lines
8517		8664
8518	<p>	8665	<p>
8519	Unless stated otherwise,	8666	Unless stated otherwise,
8520	all functions that expect a byte index as a parameter	8667	all functions that expect a byte position as a parameter
8521	assume that the given position is either the start of a byte sequence	8668	assume that the given position is either the start of a byte sequence
8522	or one plus the length of the subject string.	8669	or one plus the length of the subject string.
8523	As in the string library,	8670	As in the string library,
@@ -8572,24 +8719,29 @@ It raises an error if it meets any invalid byte sequence. · 48 unmodified lines
8572		8719
8573		8720
8574	<p>	8721	<p>
8575	<hr><h3><a name="pdf-utf8.len"><code>utf8.len (s [, i])</code></a></h3>	8722	<hr><h3><a name="pdf-utf8.len"><code>utf8.len (s [, i [, j]])</code></a></h3>
8576	Returns the number of UTF-8 characters in string <code>s</code>,	8723	Returns the number of UTF-8 characters in string <code>s</code>
8577	starting from position <code>i</code>.	8724	that start between positions <code>i</code> and @{j} (both inclusive).
8578	The default for <code>i</code> is 1.	8725	The default for <code>i</code> is 1 and for <code>j</code> is -1.
8579	Returns <b>nil</b> if the sufix of <code>s</code> starting at <code>i</code>	8726	If it finds any invalid byte sequence,
8580	contains any invalid byte sequence.	8727	returns <b>nil</b> plus the position of the first invalid byte.
8581		8728
8582		8729
8583		8730
8584		8731
8585	<p>	8732	<p>
8586	<hr><h3><a name="pdf-utf8.offset"><code>utf8.offset (s, n [, i])</code></a></h3>	8733	<hr><h3><a name="pdf-utf8.offset"><code>utf8.offset (s, n [, i])</code></a></h3>
8587	Returns the byte index where the encoding of the	8734	Returns the position (in bytes) where the encoding of the
8588	<code>n</code>-th character of <code>s</code> starts,	8735	<code>n</code>-th character of <code>s</code>
8589	counting from position <code>i</code>.	8736	(counting from position <code>i</code>) starts.
8590	A negative <code>n</code> gets characters before position <code>i</code>.	8737	A negative <code>n</code> gets characters before position <code>i</code>.
8591	The default for <code>i</code> is 1.	8738	The default for <code>i</code> is 1 when <code>n</code> is non-negative
8592	Returns <b>nil</b> if the subject does not have such character.	8739	and <code>#s + 1</code> otherwise,
		8740	so that <code>utf8.offset(s, -n)</code> gets the offset of the
		8741	<code>n</code>-th character from the end of the string.
		8742	If the specified character is not in the subject
		8743	or right after its end,
		8744	the function returns <b>nil</b>.
8593		8745
8594		8746
8595	<p>	8747	<p>
@@ -8616,7 +8768,7 @@ It provides all its functions inside the table <a name="pdf-table"><code>table</ · 20 unmodified lines
8616		8768
8617	<p>	8769	<p>
8618	Remember that, whenever an operation needs the length of a table,	8770	Remember that, whenever an operation needs the length of a table,
8619	the table should be a proper sequence	8771	the table must be a proper sequence
8620	or have a <code>__len</code> metamethod (see <a href="#3.4.7">§3.4.7</a>).	8772	or have a <code>__len</code> metamethod (see <a href="#3.4.7">§3.4.7</a>).
8621	All functions ignore non-numeric keys	8773	All functions ignore non-numeric keys
8622	in tables given as arguments.	8774	in tables given as arguments.
@@ -8739,10 +8891,15 @@ By default, <code>i</code> is 1 and <code>j</code> is <code>#list</code>. · 116 unmodified lines
8739	<h2>6.7 – <a name="6.7">Mathematical Functions</a></h2>	8891	<h2>6.7 – <a name="6.7">Mathematical Functions</a></h2>
8740		8892
8741	<p>	8893	<p>
8742	This library is an interface to the standard C math library.	8894	This library provides basic mathematical functions.
8743	It provides all its functions inside the table <a name="pdf-math"><code>math</code></a>.	8895	It provides all its functions and constants inside the table <a name="pdf-math"><code>math</code></a>.
8744	Unless stated otherwise,	8896	Functions with the annotation "<code>integer/float</code>" give
8745	all functions in this library operate with and return floats.	8897	integer results for integer arguments
		8898	and float results for float (or mixed) arguments.
		8899	Rounding functions
		8900	(<a href="#pdf-math.ceil"><code>math.ceil</code></a>, <a href="#pdf-math.floor"><code>math.floor</code></a>, and <a href="#pdf-math.modf"><code>math.modf</code></a>)
		8901	return an integer when the result fits in the range of an integer,
		8902	otherwise they return a float.
8746		8903
8747		8904
8748	<p>	8905	<p>
@@ -8750,7 +8907,7 @@ all functions in this library operate with and return floats. · 1 unmodified line
8750		8907
8751		8908
8752	<p>	8909	<p>
8753	Returns the absolute value of <code>x</code>.	8910	Returns the absolute value of <code>x</code>. (integer/float)
8754		8911
8755		8912
8756		8913
@@ -8776,54 +8933,41 @@ Returns the arc sine of <code>x</code> (in radians). · 19 unmodified lines
8776		8933
8777		8934
8778	<p>	8935	<p>
8779	<hr><h3><a name="pdf-math.atan"><code>math.atan (x)</code></a></h3>	8936	<hr><h3><a name="pdf-math.atan"><code>math.atan (y [, x])</code></a></h3>
8780		8937
8781		8938
8782	<p>	8939	<p>
8783	Returns the arc tangent of <code>x</code> (in radians).
8784
8785
8786		8940
8787
8788	<p>
8789	<hr><h3><a name="pdf-math.atan2"><code>math.atan2 (y, x)</code></a></h3>
8790
8791
8792	<p>
8793	Returns the arc tangent of <code>y/x</code> (in radians),	8941	Returns the arc tangent of <code>y/x</code> (in radians),
8794	but uses the signs of both parameters to find the	8942	but uses the signs of both parameters to find the
8795	quadrant of the result.	8943	quadrant of the result.
8796	(It also handles correctly the case of <code>x</code> being zero.)	8944	(It also handles correctly the case of <code>x</code> being zero.)
8797		8945
8798		8946
8799
8800
8801	<p>
8802	<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
8803
8804
8805	<p>	8947	<p>
8806	Returns the smallest integer larger than or equal to <code>x</code>.	8948	The default value for <code>x</code> is 1,
		8949	so that the call <code>math.atan(y)</code>
		8950	returns the arc tangent of <code>y</code>.
8807		8951
8808		8952
8809		8953
8810		8954
8811	<p>	8955	<p>
8812	<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>	8956	<hr><h3><a name="pdf-math.ceil"><code>math.ceil (x)</code></a></h3>
8813		8957
8814		8958
8815	<p>	8959	<p>
8816	Returns the cosine of <code>x</code> (assumed to be in radians).	8960	Returns the smaller integral value larger than or equal to <code>x</code>.
8817		8961
8818		8962
8819		8963
8820		8964
8821	<p>	8965	<p>
8822	<hr><h3><a name="pdf-math.cosh"><code>math.cosh (x)</code></a></h3>	8966	<hr><h3><a name="pdf-math.cos"><code>math.cos (x)</code></a></h3>
8823		8967
8824		8968
8825	<p>	8969	<p>
8826	Returns the hyperbolic cosine of <code>x</code>.	8970	Returns the cosine of <code>x</code> (assumed to be in radians).
8827		8971
8828		8972
8829		8973
@@ -8833,17 +8977,7 @@ Returns the hyperbolic cosine of <code>x</code>. · 3 unmodified lines
8833		8977
8834		8978
8835	<p>	8979	<p>
8836	Returns the angle <code>x</code> (given in radians) in degrees.	8980	Converts the angle <code>x</code> from radians to degrees.
8837
8838
8839
8840
8841	<p>
8842	<hr><h3><a name="pdf-math.exp"><code>math.exp (x)</code></a></h3>
8843
8844
8845	<p>
8846	Returns the value <em>e<sup>x</sup></em>.
8847		8981
8848		8982
8849		8983
@@ -8853,8 +8987,7 @@ Returns the value <em>e<sup>x</sup></em>. · 3 unmodified lines
8853		8987
8854		8988
8855	<p>	8989	<p>
8856	Returns a float with the largest	8990	Returns the largest integral value smaller than or equal to <code>x</code>.
8857	integral value smaller than or equal to <code>x</code>.
8858		8991
8859		8992
8860		8993
@@ -8865,20 +8998,7 @@ integral value smaller than or equal to <code>x</code>. · 4 unmodified lines
8865		8998
8866	<p>	8999	<p>
8867	Returns the remainder of the division of <code>x</code> by <code>y</code>	9000	Returns the remainder of the division of <code>x</code> by <code>y</code>
8868	that rounds the quotient towards zero.	9001	that rounds the quotient towards zero. (integer/float)
8869
8870
8871
8872
8873	<p>
8874	<hr><h3><a name="pdf-math.frexp"><code>math.frexp (x)</code></a></h3>
8875
8876
8877	<p>
8878	Returns <code>m</code> and <code>e</code> such that <em>x = m2<sup>e</sup></em>,
8879	<code>e</code> is an integer and the absolute value of <code>m</code> is
8880	in the range <em>[0.5, 1)</em>
8881	(or zero when <code>x</code> is zero).
8882		9002
8883		9003
8884		9004
@@ -8888,8 +9008,8 @@ in the range <em>[0.5, 1)</em> · 3 unmodified lines
8888		9008
8889		9009
8890	<p>	9010	<p>
8891	The value <code>HUGE_VAL</code>,	9011	The float value <code>HUGE_VAL</code>,
8892	a value larger than or equal to any other numerical value.	9012	a value larger than any other numerical value.
8893		9013
8894		9014
8895		9015
@@ -8906,16 +9026,6 @@ returns <b>nil</b>. · 10 unmodified lines
8906		9026
8907		9027
8908		9028
8909	<p>
8910	<hr><h3><a name="pdf-math.ldexp"><code>math.ldexp (m, e)</code></a></h3>
8911
8912
8913	<p>
8914	Returns <em>m2<sup>e</sup></em> (<code>e</code> should be an integer).
8915
8916
8917
8918
8919	<p>	9029	<p>
8920	<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>	9030	<hr><h3><a name="pdf-math.log"><code>math.log (x [, base])</code></a></h3>
8921		9031
@@ -8933,49 +9043,54 @@ The default for <code>base</code> is <em>e</em> · 11 unmodified lines
8933		9043
8934		9044
8935	<p>	9045	<p>
8936	Returns the maximum value among its arguments.	9046	Returns the argument with the maximum value,
		9047	according to the Lua operator <code><</code>. (integer/float)
8937		9048
8938		9049
8939		9050
8940		9051
8941	<p>	9052	<p>
8942	<hr><h3><a name="pdf-math.min"><code>math.min (x, ···)</code></a></h3>	9053	<hr><h3><a name="pdf-math.maxinteger"><code>math.maxinteger</code></a></h3>
		9054	An integer with the maximum value for an integer.
8943		9055
8944		9056
8945	<p>
8946	Returns the minimum value among its arguments.
8947		9057
8948		9058
		9059	<p>
		9060	<hr><h3><a name="pdf-math.min"><code>math.min (x, ···)</code></a></h3>
8949		9061
8950		9062
8951	<p>	9063	<p>
8952	<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>	9064	Returns the argument with the minimum value,
		9065	according to the Lua operator <code><</code>. (integer/float)
		9066
		9067
8953		9068
8954		9069
8955	<p>	9070	<p>
8956	Returns two numbers,	9071	<hr><h3><a name="pdf-math.mininteger"><code>math.mininteger</code></a></h3>
8957	the integral part of <code>x</code> and the fractional part of <code>x</code>.	9072	An integer with the minimum value for an integer.
8958		9073
8959		9074
8960		9075
8961		9076
8962	<p>	9077	<p>
8963	<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>	9078	<hr><h3><a name="pdf-math.modf"><code>math.modf (x)</code></a></h3>
8964		9079
8965		9080
8966	<p>	9081	<p>
8967	The value of <em>π</em>.	9082	Returns the integral part of <code>x</code> and the fractional part of <code>x</code>.
		9083	Its second result is always a float.
8968		9084
8969		9085
8970		9086
8971		9087
8972	<p>	9088	<p>
8973	<hr><h3><a name="pdf-math.pow"><code>math.pow (x, y)</code></a></h3>	9089	<hr><h3><a name="pdf-math.pi"><code>math.pi</code></a></h3>
8974		9090
8975		9091
8976	<p>	9092	<p>
8977	Returns <em>x<sup>y</sup></em>.	9093	The value of <em>π</em>.
8978	(You can also use the expression <code>x^y</code> to compute this value.)
8979		9094
8980		9095
8981		9096
@@ -8985,7 +9100,7 @@ Returns <em>x<sup>y</sup></em>. · 3 unmodified lines
8985		9100
8986		9101
8987	<p>	9102	<p>
8988	Returns the angle <code>x</code> (given in degrees) in radians.	9103	Converts the angle <code>x</code> from degrees to radians.
8989		9104
8990		9105
8991		9106
@@ -8994,22 +9109,23 @@ Returns the angle <code>x</code> (given in degrees) in radians. · 2 unmodified lines
8994	<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>	9109	<hr><h3><a name="pdf-math.random"><code>math.random ([m [, n]])</code></a></h3>
8995		9110
8996		9111
8997	<p>
8998	This function is an interface to the simple
8999	pseudo-random generator function <code>rand</code> provided by Standard C.
9000	(No guarantees can be given for its statistical properties.)
9001
9002
9003	<p>	9112	<p>
9004	When called without arguments,	9113	When called without arguments,
9005	returns a uniform pseudo-random float	9114	returns a pseudo-random float with uniform distribution
9006	in the range <em>[0,1)</em>.	9115	in the range <em>[0,1)</em>.
9007	When called with two integers <code>m</code> and <code>n</code>,	9116	When called with two integers <code>m</code> and <code>n</code>,
9008	<code>math.random</code> returns a uniform pseudo-random	9117	<code>math.random</code> returns a pseudo-random integer
9009	integer in the range <em>[m, n]</em>.	9118	with uniform distribution in the range <em>[m, n]</em>.
		9119	(The interval size must fit in a Lua integer.)
9010	The call <code>math.random(n)</code> is equivalent to <code>math.random(1,n)</code>.	9120	The call <code>math.random(n)</code> is equivalent to <code>math.random(1,n)</code>.
9011		9121
9012		9122
		9123	<p>
		9124	This function is an interface to the underling
		9125	pseudo-random generator function provided by C.
		9126	No guarantees can be given for its statistical properties.
		9127
		9128
9013		9129
9014		9130
9015	<p>	9131	<p>
@@ -9034,16 +9150,6 @@ Returns the sine of <code>x</code> (assumed to be in radians). · 18 unmodified lines
9034		9150
9035		9151
9036		9152
9037	<p>
9038	<hr><h3><a name="pdf-math.sinh"><code>math.sinh (x)</code></a></h3>
9039
9040
9041	<p>
9042	Returns the hyperbolic sine of <code>x</code>.
9043
9044
9045
9046
9047	<p>	9153	<p>
9048	<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>	9154	<hr><h3><a name="pdf-math.sqrt"><code>math.sqrt (x)</code></a></h3>
9049		9155
@@ -9065,16 +9171,6 @@ Returns the tangent of <code>x</code> (assumed to be in radians). · 15 unmodified lines
9065		9171
9066		9172
9067		9173
9068	<p>
9069	<hr><h3><a name="pdf-math.tanh"><code>math.tanh (x)</code></a></h3>
9070
9071
9072	<p>
9073	Returns the hyperbolic tangent of <code>x</code>.
9074
9075
9076
9077
9078	<p>	9174	<p>
9079	<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>	9175	<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>
9080		9176
@@ -9337,7 +9433,7 @@ Returns an iterator function that, · 256 unmodified lines
9337	each time it is called,	9433	each time it is called,
9338	reads the file according to the given formats.	9434	reads the file according to the given formats.
9339	When no format is given,	9435	When no format is given,
9340	uses "*l" as a default.	9436	uses "<code>l</code>" as a default.
9341	As an example, the construction	9437	As an example, the construction
9342		9438
9343	<pre>	9439	<pre>
@@ -9376,30 +9472,33 @@ The available formats are · 32 unmodified lines
9376		9472
9377	<ul>	9473	<ul>
9378		9474
9379	<li><b>"<code>*n</code>": </b>	9475	<li><b>"<code>n</code>": </b>
9380	reads a number and returns it as a float.	9476	reads a numeral and returns it as a float or an integer,
9381	If the input has only a prefix of a valid number	9477	following the lexical conventions of Lua.
9382	(e.g., "<code>0x</code>" or "<code>3.4e-</code>"),	9478	(The numeral may have leading spaces and a sign.)
9383	this format can read the entire prefix	9479	This format always reads the longest input sequence that
9384	even when returning <b>nil</b>.	9480	is a valid prefix for a number;
		9481	if that prefix does not form a valid number
		9482	(e.g., an empty string, "<code>0x</code>", or "<code>3.4e-</code>"),
		9483	it is discarded and the function returns <b>nil</b>.
9385	</li>	9484	</li>
9386		9485
9387	<li><b>"<code>*i</code>": </b>	9486	<li><b>"<code>i</code>": </b>
9388	reads an integral number and returns it as an integer.	9487	reads an integral number and returns it as an integer.
9389	</li>	9488	</li>
9390		9489
9391	<li><b>"<code>*a</code>": </b>	9490	<li><b>"<code>a</code>": </b>
9392	reads the whole file, starting at the current position.	9491	reads the whole file, starting at the current position.
9393	On end of file, it returns the empty string.	9492	On end of file, it returns the empty string.
9394	</li>	9493	</li>
9395		9494
9396	<li><b>"<code>*l</code>": </b>	9495	<li><b>"<code>l</code>": </b>
9397	reads the next line skipping the end of line,	9496	reads the next line skipping the end of line,
9398	returning <b>nil</b> on end of file.	9497	returning <b>nil</b> on end of file.
9399	This is the default format.	9498	This is the default format.
9400	</li>	9499	</li>
9401		9500
9402	<li><b>"<code>*L</code>": </b>	9501	<li><b>"<code>L</code>": </b>
9403	reads the next line keeping the end-of-line character (if present),	9502	reads the next line keeping the end-of-line character (if present),
9404	returning <b>nil</b> on end of file.	9503	returning <b>nil</b> on end of file.
9405	</li>	9504	</li>
@@ -9413,7 +9512,7 @@ or <b>nil</b> on end of file. · 7 unmodified lines
9413	</li>	9512	</li>
9414		9513
9415	</ul><p>	9514	</ul><p>
9416	The formats "<code>l</code>" and "<code>L</code>" should be used only for text files.	9515	The formats "<code>l</code>" and "<code>L</code>" should be used only for text files.
9417		9516
9418		9517
9419		9518
@@ -9622,7 +9721,7 @@ When called without a <code>command</code>, · 202 unmodified lines
9622		9721
9623		9722
9624	<p>	9723	<p>
9625	<hr><h3><a name="pdf-os.exit"><code>os.exit ([code [, close])</code></a></h3>	9724	<hr><h3><a name="pdf-os.exit"><code>os.exit ([code [, close]])</code></a></h3>
9626		9725
9627		9726
9628	<p>	9727	<p>
@@ -9799,6 +9898,32 @@ thread to operate over. · 170 unmodified lines
9799	The default is always the current thread.	9898	The default is always the current thread.
9800		9899
9801		9900
		9901	<p>
		9902	<hr><h3><a name="pdf-debug.Csize"><code>debug.Csize (t)</code></a></h3>
		9903
		9904
		9905	<p>
		9906	Returns the size of the underlying representation of a given C type,
		9907	according to the following table:
		9908	<table border="1">
		9909	<tr><td>'<code>I</code>'</td><td><code>lua_Integer</code></td></tr>
		9910	<tr><td>'<code>F</code>'</td><td><code>lua_Number</code></td></tr>
		9911	<tr><td>'<code>b</code>'</td><td><code>byte</code></td></tr>
		9912	<tr><td>'<code>d</code>'</td><td><code>double</code></td></tr>
		9913	<tr><td>'<code>f</code>'</td><td><code>float</code></td></tr>
		9914	<tr><td>'<code>h</code>'</td><td><code>short int</code></td></tr>
		9915	<tr><td>'<code>i</code>'</td><td><code>int</code></td></tr>
		9916	<tr><td>'<code>l</code>'</td><td><code>long int</code></td></tr>
		9917	<tr><td>'<code>z</code>'</td><td><code>size_t</code></td></tr>
		9918	</table>
		9919	For all options except '<code>b</code>',
		9920	the size is given in number of bytes;
		9921	for option '<code>b</code>',
		9922	the size is its number of bits.
		9923
		9924
		9925
		9926
9802	<p>	9927	<p>
9803	<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>	9928	<hr><h3><a name="pdf-debug.debug"><code>debug.debug ()</code></a></h3>
9804		9929
@@ -9898,7 +10023,7 @@ and raises an error when called with a level out of range. · 93 unmodified lines
9898		10023
9899		10024
9900	<p>	10025	<p>
9901	Variable names starting with '<code>(</code>' (open parenthesis)	10026	Variable names starting with '<code>(</code>' (open parenthesis)
9902	represent variables with no known names	10027	represent variables with no known names
9903	(internal variables like loop control variables,	10028	(internal variables like loop control variables,
9904	and variables from chunks saved without debug information).	10029	and variables from chunks saved without debug information).
@@ -9943,7 +10068,7 @@ The function returns <b>nil</b> if there is no upvalue with the given index. · 38 unmodified lines
9943		10068
9944		10069
9945	<p>	10070	<p>
9946	Variable names starting with '<code>(</code>' (open parenthesis)	10071	Variable names starting with '<code>(</code>' (open parenthesis)
9947	represent variables with no known names	10072	represent variables with no known names
9948	(variables from chunks saved without debug information).	10073	(variables from chunks saved without debug information).
9949		10074
@@ -9962,18 +10087,6 @@ returns <b>nil</b>. · 12 unmodified lines
9962		10087
9963		10088
9964		10089
9965	<p>
9966	<hr><h3><a name="pdf-debug.numbits"><code>debug.numbits (t)</code></a></h3>
9967
9968
9969	<p>
9970	Returns the number of bits in the underlying representation
9971	of an integer (if <code>t</code> is "<code>i</code>")
9972	or a float (if <code>t</code> is "<code>f</code>").
9973
9974
9975
9976
9977	<p>	10090	<p>
9978	<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>	10091	<hr><h3><a name="pdf-debug.sethook"><code>debug.sethook ([thread,] hook, mask [, count])</code></a></h3>
9979		10092
@@ -10169,7 +10282,7 @@ and as <code>lua -</code> otherwise. · 189 unmodified lines
10169		10282
10170	<p>	10283	<p>
10171	When called without option <code>-E</code>,	10284	When called without option <code>-E</code>,
10172	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_2"><code>LUA_INIT_5_2</code></a>	10285	the interpreter checks for an environment variable <a name="pdf-LUA_INIT_5_3"><code>LUA_INIT_5_3</code></a>
10173	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if it is not defined)	10286	(or <a name="pdf-LUA_INIT"><code>LUA_INIT</code></a> if it is not defined)
10174	before running any argument.	10287	before running any argument.
10175	If the variable content has the format <code>@<em>filename</em></code>,	10288	If the variable content has the format <code>@<em>filename</em></code>,
@@ -10200,37 +10313,46 @@ and finally run the file <code>script.lua</code> with no arguments. · 24 unmodified lines
10200		10313
10201		10314
10202	<p>	10315	<p>
10203	Before starting to run the script,	10316	Before running any code,
10204	<code>lua</code> collects all arguments in the command line	10317	<code>lua</code> collects all command-line arguments
10205	in a global table called <code>arg</code>.	10318	in a global table called <code>arg</code>.
10206	The script name is stored at index 0,	10319	The script name goes to index 0,
10207	the first argument after the script name goes to index 1,	10320	the first argument after the script name goes to index 1,
10208	and so on.	10321	and so on.
10209	Any arguments before the script name	10322	Any arguments before the script name
10210	(that is, the interpreter name plus the options)	10323	(that is, the interpreter name plus its options)
10211	go to negative indices.	10324	go to negative indices.
10212	For instance, in the call	10325	For instance, in the call
10213		10326
10214	<pre>	10327	<pre>
10215	$ lua -la b.lua t1 t2	10328	$ lua -la b.lua t1 t2
10216	</pre><p>	10329	</pre><p>
10217	the interpreter first runs the file <code>a.lua</code>,	10330	the table is like this:
10218	then creates a table
10219		10331
10220	<pre>	10332	<pre>
10221	arg = { [-2] = "lua", [-1] = "-la",	10333	arg = { [-2] = "lua", [-1] = "-la",
10222	[0] = "b.lua",	10334	[0] = "b.lua",
10223	[1] = "t1", [2] = "t2" }	10335	[1] = "t1", [2] = "t2" }
10224	</pre><p>	10336	</pre><p>
10225	and finally runs the file <code>b.lua</code>.	10337	If there is no script in the call,
10226	The script is called with <code>arg[1]</code>, <code>arg[2]</code>, ...	10338	the interpreter name goes to index 0,
10227	as arguments;	10339	followed by the other arguments.
10228	it can also access these arguments with the vararg expression '<code>...</code>'.	10340	For instance, the call
		10341
		10342	<pre>
		10343	$ lua -e "print(arg[1])"
		10344	</pre><p>
		10345	will print "<code>-e</code>".
10229		10346
10230		10347
10231	<p>	10348	<p>
10232	In interactive mode,	10349	In interactive mode,
10233	if you write an incomplete statement,	10350	Lua repeatedly prompts and waits for a line.
		10351	After reading a line,
		10352	Lua first try to interpret the line as an expression.
		10353	If it succeeds, it prints its value.
		10354	Otherwise, it interprets the line as a statement.
		10355	If you write an incomplete statement,
10234	the interpreter waits for its completion	10356	the interpreter waits for its completion
10235	by issuing a different prompt.	10357	by issuing a different prompt.
10236		10358
@@ -10301,6 +10423,12 @@ Always recompile clients of the Lua API when · 64 unmodified lines
10301	using a new version.	10423	using a new version.
10302		10424
10303		10425
		10426	<p>
		10427	Similarly, Lua versions can always change the internal representation
		10428	of precompiled chunks;
		10429	precompiled chunks are never compatible between different Lua versions.
		10430
		10431
10304	<p>	10432	<p>
10305	The standard paths in the official distribution may	10433	The standard paths in the official distribution may
10306	change between versions.	10434	change between versions.
@@ -10325,8 +10453,8 @@ You can fix these differences by forcing a number to be a float · 18 unmodified lines
10325	in particular writing constants with an ending <code>.0</code>	10453	in particular writing constants with an ending <code>.0</code>
10326	or using <code>x = x + 0.0</code> to convert a variable.	10454	or using <code>x = x + 0.0</code> to convert a variable.
10327	(This recommendation is only for a quick fix	10455	(This recommendation is only for a quick fix
10328	for an occasional incompatibility,	10456	for an occasional incompatibility;
10329	not as a general guideline for good programming.	10457	it is not a general guideline for good programming.
10330	For good programming,	10458	For good programming,
10331	use floats where you need floats	10459	use floats where you need floats
10332	and integers where you need integers.)	10460	and integers where you need integers.)
@@ -10335,7 +10463,22 @@ and integers where you need integers.) · 2 unmodified lines
10335	<p>	10463	<p>
10336	Although not formally an incompatibility,	10464	Although not formally an incompatibility,
10337	the proper differentiation between floats and integers	10465	the proper differentiation between floats and integers
10338	can sometimes have a big impact on performance.	10466	have an impact on performance.
		10467	</li>
		10468
		10469	<li>
		10470	The conversion of a float to a string now adds a <code>.0</code> suffix
		10471	to the result if it looks like an integer.
		10472	(For instance, the float 2.0 will be printed as <code>2.0</code>,
		10473	not as <code>2</code>.)
		10474	You should always use an explicit format
		10475	when you need a specific format for numbers.
		10476
		10477
		10478	<p>
		10479	(Formally this is not an incompatibility,
		10480	because Lua does not specify how numbers are formatted as strings,
		10481	but some programs assumed a specific format.)
10339	</li>	10482	</li>
10340		10483
10341	<li>	10484	<li>
@@ -10351,24 +10494,31 @@ The generational mode for the garbage collector was removed. · 9 unmodified lines
10351	<h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2>	10494	<h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2>
10352	<ul>	10495	<ul>
10353		10496
10354	<li>
10355	The conversion of a float to a string through <a href="#pdf-tostring"><code>tostring</code></a>
10356	(which is used by <a href="#pdf-print"><code>print</code></a>) now adds a <code>.0</code> suffix if the
10357	number has an integral value.
10358	(For instance, the float 2.0 will be printed as <code>2.0</code>,
10359	not as <code>2</code>.)
10360	You should always use an explicit format
10361	when you need a specific format for numbers.
10362	</li>
10363
10364	<li>	10497	<li>
10365	The <code>bit32</code> library has been deprecated.	10498	The <code>bit32</code> library has been deprecated.
10366	It is easy to require a compatible external library or,	10499	It is easy to require a compatible external library or,
10367	better yet, to replace its functions with appropriate bitwise operations.	10500	better yet, to replace its functions with appropriate bitwise operations.
10368	(Just keep in mind that <code>bit32</code> operates on 32-bit integers,	10501	(Keep in mind that <code>bit32</code> operates on 32-bit integers,
10369	while the bitwise operators in Standard Lua operate on 64-bit integers.)	10502	while the bitwise operators in Standard Lua operate on 64-bit integers.)
10370	</li>	10503	</li>
10371		10504
		10505	<li>
		10506	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.
		10508	</li>
		10509
		10510	<li>
		10511	The following functions were deprecated in the mathematical library:
		10512	<code>atan2</code>, <code>cosh</code>, <code>sinh</code>, <code>tanh</code>, <code>pow</code>,
		10513	<code>frexp</code>, and <code>ldexp</code>.
		10514	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>,
		10516	which now accepts two parameters;
		10517	you can replace <code>math.ldexp(x,exp)</code> with <code>x * 2.0^exp</code>.
		10518	For the other operations,
		10519	the best choice is to use an external library.
		10520	</li>
		10521
10372	</ul>	10522	</ul>
10373		10523
10374		10524
@@ -10380,7 +10530,15 @@ while the bitwise operators in Standard Lua operate on 64-bit integers.) · 5 unmodified lines
10380	<ul>	10530	<ul>
10381		10531
10382	<li>	10532	<li>
10383	No changes (yet).	10533	Continuation functions now receive as parameters what they needed
		10534	to get through <code>lua_getctx</code>,
		10535	so <code>lua_getctx</code> has been removed.
		10536	Adapt your code accordingly.
		10537	</li>
		10538
		10539	<li>
		10540	Function <a href="#lua_dump"><code>lua_dump</code></a> has an extra parameter, <code>strip</code>.
		10541	Use 0 as the value of this parameter to get the old behavior.
10384	</li>	10542	</li>
10385		10543
10386	</ul>	10544	</ul>
@@ -10456,11 +10614,12 @@ Here is the complete syntax of Lua in extended BNF. · 69 unmodified lines
10456		10614
10457	fieldsep ::= ‘<b>,</b>’ \| ‘<b>;</b>’	10615	fieldsep ::= ‘<b>,</b>’ \| ‘<b>;</b>’
10458		10616
10459	binop ::= ‘<b>+</b>’ \| ‘<b>-</b>’ \| ‘<b>*</b>’ \| ‘<b>/</b>’ \| ‘<b>^</b>’ \| ‘<b>%</b>’ \| ‘<b>..</b>’ \|	10617	binop ::= ‘<b>+</b>’ \| ‘<b>-</b>’ \| ‘<b>*</b>’ \| ‘<b>/</b>’ \| ‘<b>//</b>’ \| ‘<b>^</b>’ \| ‘<b>%</b>’ \|
		10618	‘<b>&</b>’ \| ‘<b>~</b>’ \| ‘<b>\|</b>’ \| ‘<b>>></b>’ \| ‘<b><<</b>’ \| ‘<b>..</b>’ \|
10460	‘<b><</b>’ \| ‘<b><=</b>’ \| ‘<b>></b>’ \| ‘<b>>=</b>’ \| ‘<b>==</b>’ \| ‘<b>~=</b>’ \|	10619	‘<b><</b>’ \| ‘<b><=</b>’ \| ‘<b>></b>’ \| ‘<b>>=</b>’ \| ‘<b>==</b>’ \| ‘<b>~=</b>’ \|
10461	<b>and</b> \| <b>or</b>	10620	<b>and</b> \| <b>or</b>
10462		10621
10463	unop ::= ‘<b>-</b>’ \| <b>not</b> \| ‘<b>#</b>’	10622	unop ::= ‘<b>-</b>’ \| <b>not</b> \| ‘<b>#</b>’ \| ‘<b>~</b>’
10464		10623
10465	</pre>	10624	</pre>
10466		10625
@@ -10468,17 +10627,18 @@ Here is the complete syntax of Lua in extended BNF. · 1 unmodified line
10468		10627
10469		10628
10470		10629
10471	}	10630
		10631
10472		10632
10473		10633
10474		10634
10475	<HR>	10635	<HR>
10476	<SMALL CLASS="footer">	10636	<SMALL CLASS="footer">
10477	Last update:	10637	Last update:
10478	Fri Mar 21 17:33:56 BRT 2014	10638	Thu Jun 19 17:13:19 BRT 2014
10479	</SMALL>	10639	</SMALL>
10480	<!--	10640	<!--
10481	Last change: updated for Lua 5.3.0 (work2)	10641	Last change: updated for Lua 5.3.0 (work3)
10482	-->	10642	-->
10483		10643
10484	</body></html>	10644	</body></html>

doc/readme.html+16−19

 <HR>
 <H1>
 <A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Welcome to Lua 5.3 (work2)
+Welcome to Lua 5.3 (work3)
 </H1>
 <P>
 get a binary from
 <A HREF="http://lua-users.org/wiki/LuaBinaries">LuaBinaries</A>.
 Try also
-<A HREF="http://luaforwindows.luaforge.net/">Lua for Windows</A>,
+<A HREF="http://luadist.org/">LuaDist</A>,
-an easy-to-use distribution of Lua that includes many useful libraries.
+a multi-platform distribution of Lua that includes batteries.
 <H3>Building Lua</H3>
 <OL>
 <LI>
 Open a terminal window and move to
-the top-level directory, which is named <TT>lua-5.3.0</TT>.
+the top-level directory, which is named <TT>lua-5.3.0-work3</TT>.
-The Makefile there controls both the build process and the installation process.
+The <TT>Makefile</TT> there controls both the build process and the installation process.
 <P>
 <LI>
   Do "<KBD>make</KBD>" and see if your platform is listed.
 <P>
 <LI>
   To check that Lua has been built correctly, do "<KBD>make test</KBD>"
-  after building Lua. This will run the interpreter and print its version string.
+  after building Lua. This will run the interpreter and print its version.
 </OL>
 <P>
 If you're running Linux and get compilation errors,
 <P>
   Once you have built Lua, you may want to install it in an official
   place in your system. In this case, do "<KBD>make install</KBD>". The official
-  place and the way to install files are defined in the Makefile. You'll
+  place and the way to install files are defined in the <TT>Makefile</TT>. You'll
   probably need the right permissions to install files.
 <P>
 <P>
   To install Lua locally, do "<KBD>make local</KBD>".
   This will create a directory <TT>install</TT> with subdirectories
-  <TT>bin</TT>, <TT>include</TT>, <TT>lib</TT>, <TT>man</TT>,
+  <TT>bin</TT>, <TT>include</TT>, <TT>lib</TT>, <TT>man</TT>, <TT>share</TT>,
   and install Lua as listed below.
   To install Lua locally, but in some other directory, do
   "<KBD>make install INSTALL_TOP=xxx</KBD>", where xxx is your chosen directory.
+  The installation starts in the <TT>src</TT> and <TT>doc</TT> directories,
+  so take care if <TT>INSTALL_TOP</TT> is not an absolute path.
 <DL CLASS="display">
 <DT>
 <DT>
     include:
 <DD>
-    lua.h luaconf.h lualib.h lauxlib.h lua.hpp
+    lauxlib.h lua.h lua.hpp luaconf.h lualib.h
 <DT>
     lib:
 <DD>
 <P>
   These are the only directories you need for development.
   If you only want to run Lua programs,
-  you only need the files in bin and man.
+  you only need the files in <TT>bin</TT> and <TT>man</TT>.
-  The files in include and lib are needed for
+  The files in <TT>include</TT> and <TT>lib</TT> are needed for
   embedding Lua in C or C++ programs.
 <H3><A NAME="customization">Customization</A></H3>
   You don't actually need to edit the Makefiles because you may set the
   relevant variables in the command line when invoking make.
   Nevertheless, it's probably best to edit and save the Makefiles to
-  record the changes you need.
+  record the changes you've made.
 <P>
   On the other hand, if you need to customize some Lua features, you'll need
   it will be used by any Lua clients that you build, to ensure consistency.
   Further customization is available to experts by editing the Lua sources.
-<P>
-  We strongly recommend that you enable dynamic loading in <TT>src/luaconf.h</TT>.
-  This is done automatically for all platforms listed above that have
-  this feature and also for Windows.
 <H3><A NAME="other">Building Lua on other systems</A></H3>
 <P>
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Fri Mar 21 17:33:08 BRT 2014
+Wed Jun 11 22:54:18 BRT 2014
 </SMALL>
 <!--
-Last change: updated for Lua 5.3.0 (work2)
+Last change: updated for Lua 5.3.0 (work3)
 -->
 </BODY>

src/.fix+0−2

@@ -1,2 +0,0 @@
1	#define nvalue(x) ((lua_Number)0)
2	#define ttypenv(x) ttnov(x)

src/Makefile+2−2

@@ -109,7 +109,7 @@ macosx: · 108 unmodified lines
109	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline" CC=cc	109	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline" CC=cc
110		110
111	mingw:	111	mingw:
112	$(MAKE) "LUA_A=lua52.dll" "LUA_T=lua.exe" \	112	$(MAKE) "LUA_A=lua53.dll" "LUA_T=lua.exe" \
113	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \	113	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
114	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe	114	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
115	$(MAKE) "LUAC_T=luac.exe" luac.exe	115	$(MAKE) "LUAC_T=luac.exe" luac.exe
@@ -118,7 +118,7 @@ posix: · 2 unmodified lines
118	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"	118	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
119		119
120	solaris:	120	solaris:
121	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl"	121	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -D_REENTRANT" SYSLIBS="-ldl"
122		122
123	# list targets that do not create files (but not all makes understand .PHONY)	123	# list targets that do not create files (but not all makes understand .PHONY)
124	.PHONY: all $(PLATS) default o a clean depend echo none	124	.PHONY: all $(PLATS) default o a clean depend echo none

src/lapi.c+46−54

 /*
-** $Id: lapi.c,v 2.201 2014/03/12 20:57:40 roberto Exp $
+** $Id: lapi.c,v 2.219 2014/06/19 18:27:20 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
   int res;
   CallInfo *ci = L->ci;
   lua_lock(L);
+  api_check(L, 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 */
 }
-LUA_API void lua_remove (lua_State *L, int idx) {
+/*
-  StkId p;
+** Reverse the stack segment from 'from' to 'to'
-  lua_lock(L);
+** (auxiliar to 'lua_rotate')
-  p = index2addr(L, idx);
+*/
-  api_checkstackindex(L, idx, p);
+static void reverse (lua_State *L, StkId from, StkId to) {
-  while (++p < L->top) setobjs2s(L, p-1, p);
+  for (; from < to; from++, to--) {
-  L->top--;
+    TValue temp;
-  lua_unlock(L);
+    setobj(L, &temp, from);
+    setobjs2s(L, from, to);
+    setobj2s(L, to, &temp);
+  }
 }
-LUA_API void lua_insert (lua_State *L, int idx) {
+/*
-  StkId p;
+** Let x = AB, where A is a prefix of length 'n'. Then,
-  StkId q;
+** rotate x n == BA. But BA == (A^r . B^r)^r.
+*/
+LUA_API void lua_rotate (lua_State *L, int idx, int n) {
+  StkId p, t, m;
   lua_lock(L);
-  p = index2addr(L, idx);
+  t = L->top - 1;  /* end of stack segment being rotated */
+  p = index2addr(L, idx);  /* start of segment */
   api_checkstackindex(L, idx, p);
-  for (q = L->top; q > p; q--)  /* use L->top as a temporary */
+  api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
-    setobjs2s(L, q, q - 1);
+  m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */
-  setobjs2s(L, p, L->top);
+  reverse(L, p, m);  /* reverse the prefix with length 'n' */
+  reverse(L, m + 1, t);  /* reverse the suffix */
+  reverse(L, p, t);  /* reverse the entire segment */
   lua_unlock(L);
 }
 }
-LUA_API int lua_strtonum (lua_State *L, const char *s, size_t len) {
+LUA_API size_t lua_strtonum (lua_State *L, const char *s) {
-  lua_Integer i; lua_Number n;
+  size_t sz = luaO_str2num(s, L->top);
-  if (luaO_str2int(s, len, &i)) {  /* try as an integer */
+  if (sz != 0)
-    setivalue(L->top, i);
+    api_incr_top(L);
-  }
+  return sz;
-  else if (luaO_str2d(s, len, &n)) {  /* else try as a float */
-    setnvalue(L->top, n);
-  }
-  else
-    return 0;  /* conversion failed */
-  api_incr_top(L);
-  return 1;
 }
   int isnum = 0;
   switch (ttype(o)) {
     case LUA_TNUMINT: {
-      res = cast_unsigned(ivalue(o));
+      res = l_castS2U(ivalue(o));
       isnum = 1;
       break;
     }
     case LUA_TNUMFLT: {  /* compute floor(n) % 2^(numbits in an integer) */
-      const lua_Number twop = cast_num(MAX_UINTEGER) + cast_num(1);  /* 2^n */
+      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 */
         neg = 1;
         n = -n;  /* make 'n' positive, so that 'fmod' is the same as '%' */
       }
-      n = l_mathop(fmod)(n, twop);  /* n = n % 2^(numbits in an integer) */
+      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_unsigned(n);  /* 'n' now must fit in an unsigned */
+      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;
 LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
   lua_lock(L);
-  setnvalue(L->top, n);
+  setfltvalue(L->top, n);
-  luai_checknum(L, L->top,
-    luaG_runerror(L, "C API - attempt to push a signaling NaN"));
   api_incr_top(L);
   lua_unlock(L);
 }
 LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) {
   lua_lock(L);
-  setivalue(L->top, cast_integer(u));
+  setivalue(L->top, l_castU2S(u));
   api_incr_top(L);
   lua_unlock(L);
 }
     setfvalue(L->top, fn);
   }
   else {
-    Closure *cl;
+    CClosure *cl;
     api_checknelems(L, n);
     api_check(L, n <= MAXUPVAL, "upvalue index too large");
     luaC_checkGC(L);
     cl = luaF_newCclosure(L, n);
-    cl->c.f = fn;
+    cl->f = fn;
     L->top -= n;
     while (n--) {
-      setobj2n(L, &cl->c.upvalue[n], L->top + n);
+      setobj2n(L, &cl->upvalue[n], L->top + n);
       /* does not need barrier because closure is white */
     }
     setclCvalue(L, L->top, cl);
 }
-LUA_API void lua_getuservalue (lua_State *L, int idx) {
+LUA_API int lua_getuservalue (lua_State *L, int idx) {
   StkId o;
   lua_lock(L);
   o = index2addr(L, idx);
   getuservalue(L, rawuvalue(o), L->top);
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
 	"results from function overflow current stack size")
-LUA_API int lua_getctx (lua_State *L, int *ctx) {
-  if (L->ci->callstatus & CIST_YIELDED) {
-    if (ctx) *ctx = L->ci->u.c.ctx;
-    return L->ci->u.c.status;
-  }
-  else return LUA_OK;
-}
 LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
-                        lua_CFunction k) {
+                        lua_KFunction k) {
   StkId func;
   lua_lock(L);
   api_check(L, k == NULL || !isLua(L->ci),
 LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
-                        int ctx, lua_CFunction k) {
+                        int ctx, lua_KFunction k) {
   struct CallS c;
   int status;
   ptrdiff_t func;
     ci->u.c.ctx = ctx;  /* save context */
     /* save information for error recovery */
     ci->extra = savestack(L, c.func);
-    ci->u.c.old_allowhook = L->allowhook;
     ci->u.c.old_errfunc = L->errfunc;
     L->errfunc = func;
-    /* mark that function may do error recovery */
+    setoah(ci->callstatus, L->allowhook);  /* save value of 'allowhook' */
-    ci->callstatus |= CIST_YPCALL;
+    ci->callstatus |= CIST_YPCALL;  /* function can do error recovery */
     luaD_call(L, c.func, nresults, 1);  /* do the call */
     ci->callstatus &= ~CIST_YPCALL;
     L->errfunc = ci->u.c.old_errfunc;

src/lauxlib.c+6−11

 /*
-** $Id: lauxlib.c,v 1.260 2014/03/12 20:57:40 roberto Exp $
+** $Id: lauxlib.c,v 1.263 2014/05/12 21:44:17 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)
-    luaL_argerror(L, arg, "float value out of range");
+    luaL_argerror(L, arg, "float value out of integer range");
   else
     tag_error(L, arg, LUA_TNUMBER);
 }
       case LUA_TNUMBER: {
         if (lua_isinteger(L, idx))
           lua_pushfstring(L, "%I", lua_tointeger(L, idx));
-        else {
+        else
-          const char *s = lua_pushfstring(L, "%f", lua_tonumber(L, idx));
+          lua_pushfstring(L, "%f", lua_tonumber(L, idx));
-          if (s[strspn(s, "-0123456789")] == '\0') {  /* looks like an int? */
-            lua_pushliteral(L, ".0");  /* add a '.0' to result */
-            lua_concat(L, 2);
-          }
-        }
         break;
       }
       case LUA_TSTRING:
 }
-LUALIB_API void luaL_checkversion_ (lua_State *L, int ver, size_t sz) {
+LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
   const lua_Number *v = lua_version(L);
   if (v != lua_version(NULL))
     luaL_error(L, "multiple Lua VMs detected");
   else if (*v != ver)
-    luaL_error(L, "version mismatch: app. needs %d, Lua core provides %f",
+    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                   ver, *v);
   /* check numeric types */
   if (sz != LUAL_NUMSIZES)

src/lauxlib.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lauxlib.h,v 1.123 2014/01/05 14:04:46 roberto Exp $	2	** $Id: lauxlib.h,v 1.124 2014/04/15 18:25:49 roberto Exp $
3	** Auxiliary functions for building Lua libraries	3	** Auxiliary functions for building Lua libraries
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -28,7 +28,7 @@ typedef struct luaL_Reg { · 22 unmodified lines
28		28
29	#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number))	29	#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number))
30		30
31	LUALIB_API void (luaL_checkversion_) (lua_State *L, int ver, size_t sz);	31	LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
32	#define luaL_checkversion(L) \	32	#define luaL_checkversion(L) \
33	luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)	33	luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
34		34

src/lbaselib.c+51−41

 /*
-** $Id: lbaselib.c,v 1.285 2014/03/12 20:57:40 roberto Exp $
+** $Id: lbaselib.c,v 1.289 2014/06/10 17:41:38 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 #define SPACECHARS	" \f\n\r\t\v"
-static int b_str2int (const char *s, const char *e, int base, lua_Integer *pn) {
+static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
   lua_Unsigned n = 0;
   int neg = 0;
   s += strspn(s, SPACECHARS);  /* skip initial spaces */
   if (*s == '-') { s++; neg = 1; }  /* handle signal */
   else if (*s == '+') s++;
   if (!isalnum((unsigned char)*s))  /* no digit? */
-    return 0;
+    return NULL;
   do {
     int digit = (isdigit((unsigned char)*s)) ? *s - '0'
                    : toupper((unsigned char)*s) - 'A' + 10;
-    if (digit >= base) return 0;  /* invalid numeral */
+    if (digit >= base) return NULL;  /* invalid numeral */
     n = n * base + digit;
     s++;
   } while (isalnum((unsigned char)*s));
   s += strspn(s, SPACECHARS);  /* skip trailing spaces */
-  if (s != e)  /* invalid trailing characters? */
+  if (*s != '\0')  /* invalid trailing characters? */
-    return 0;
+    return NULL;
   *pn = (lua_Integer)((neg) ? (0u - n) : n);
-  return 1;
+  return s;
 }
 static int luaB_tonumber (lua_State *L) {
-  if (lua_isnoneornil(L, 2)) {  /* standard conversion */
+  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */
     luaL_checkany(L, 1);
     if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */
       lua_settop(L, 1);  /* yes; return it */
     else {
       size_t l;
       const char *s = lua_tolstring(L, 1, &l);
-      if (s != NULL && lua_strtonum(L, s, l))  /* can convert to a number? */
+      if (s != NULL && lua_strtonum(L, s) == l + 1)
-        return 1;
+        return 1;  /* successful conversion to number */
       /* else not a number */
     }
   }
   else {
     size_t l;
     const char *s;
-    lua_Integer n;
+    lua_Integer n = 0;  /* to avoid warnings */
     int base = luaL_checkint(L, 2);
     luaL_checktype(L, 1, LUA_TSTRING);  /* before 'luaL_checklstring'! */
     s = luaL_checklstring(L, 1, &l);
     luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    if (b_str2int(s, s + l, base, &n)) {
+    if (b_str2int(s, base, &n) == s + l) {
       lua_pushinteger(L, n);
       return 1;
     }  /* else not a number */
 /* }====================================================== */
-static int dofilecont (lua_State *L) {
+static int dofilecont (lua_State *L, int d1, int d2) {
+  (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */
   return lua_gettop(L) - 1;
 }
   if (luaL_loadfile(L, fname) != LUA_OK)
     return lua_error(L);
   lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
-  return dofilecont(L);
+  return dofilecont(L, 0, 0);
 }
 static int luaB_assert (lua_State *L) {
-  if (!lua_toboolean(L, 1))
+  if (lua_toboolean(L, 1))  /* condition is true? */
-    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
+    return lua_gettop(L);  /* return all arguments */
-  return lua_gettop(L);
+  else {  /* error */
+    if (lua_isnone(L, 2))  /* no error message? */
+      lua_pushliteral(L, "assertion failed!");  /* use standard message */
+    lua_remove(L, 1);  /* remove the condition (if there is one...) */
+    return luaB_error(L);  /* call 'error' */
+  }
 }
 }
-static int finishpcall (lua_State *L, int status) {
+/*
-  if (!lua_checkstack(L, 1)) {  /* no space for extra boolean? */
+** Continuation function for 'pcall' and 'xpcall'. Both functions
-    lua_settop(L, 0);  /* create space for return values */
+** already pushed a 'true' before doing the call, so in case of sucess
-    lua_pushboolean(L, 0);
+** 'finishpcall' only has to return everything in the stack minus
-    lua_pushstring(L, "stack overflow");
+** 'extra' values (where 'extra' is exactly the number of items to be
+** ignored).
+*/
+static int finishpcall (lua_State *L, int status, int extra) {
+  if (status != LUA_OK && status != LUA_YIELD) {  /* error? */
+    lua_pushboolean(L, 0);  /* first result (false) */
+    lua_pushvalue(L, -2);  /* error message */
     return 2;  /* return false, msg */
   }
-  lua_pushboolean(L, status);  /* first result (status) */
+  else
-  lua_replace(L, 1);  /* put first result in first slot */
+    return lua_gettop(L) - extra;  /* return all results */
-  return lua_gettop(L);
-}
-static int pcallcont (lua_State *L) {
-  int status = lua_getctx(L, NULL);
-  return finishpcall(L, (status == LUA_YIELD));
 }
 static int luaB_pcall (lua_State *L) {
   int status;
   luaL_checkany(L, 1);
-  lua_pushnil(L);
+  lua_pushboolean(L, 1);  /* first result if no errors */
-  lua_insert(L, 1);  /* create space for status result */
+  lua_insert(L, 1);  /* put it in place */
-  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont);
+  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
-  return finishpcall(L, (status == LUA_OK));
+  return finishpcall(L, status, 0);
 }
+/*
+** Do a protected call with error handling. After 'lua_rotate', the
+** stack will have <f, err, true, f, [args...]>; so, the function passes
+** 2 to 'finishpcall' to skip the 2 first values when returning results.
+*/
 static int luaB_xpcall (lua_State *L) {
   int status;
   int n = lua_gettop(L);
-  luaL_argcheck(L, n >= 2, 2, "value expected");
+  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
-  lua_pushvalue(L, 1);  /* exchange function... */
+  lua_pushboolean(L, 1);  /* first result */
-  lua_copy(L, 2, 1);  /* ...and error handler */
+  lua_pushvalue(L, 1);  /* function */
-  lua_replace(L, 2);
+  lua_rotate(L, 3, 2);  /* move them below function's arguments */
-  status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont);
+  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
-  return finishpcall(L, (status == LUA_OK));
+  return finishpcall(L, status, 2);
 }

src/lbitlib.c+2−3

 /*
-** $Id: lbitlib.c,v 1.25 2014/03/20 19:22:16 roberto Exp $
+** $Id: lbitlib.c,v 1.26 2014/05/15 19:28:34 roberto Exp $
 ** Standard library for bitwise operations
 ** See Copyright Notice in lua.h
 */
 LUAMOD_API int luaopen_bit32 (lua_State *L) {
-  lua_pushnil(L);
+  return luaL_error(L, "library 'bit32' has been deprecated");
-  return 1;
 }
 #endif					/* } */

src/lcode.c+10−11

 /*
-** $Id: lcode.c,v 2.85 2014/03/21 13:52:33 roberto Exp $
+** $Id: lcode.c,v 2.90 2014/05/08 18:58:46 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
       if (v) setivalue(v, e->u.ival);
       return 1;
     case VKFLT:
-      if (v) setnvalue(v, e->u.nval);
+      if (v) setfltvalue(v, e->u.nval);
       return 1;
     default: return 0;
   }
 }
-LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) {
+void luaK_patchclose (FuncState *fs, int list, int level) {
   level++;  /* argument is +1 to reserve 0 as non-op */
   while (list != NO_JUMP) {
     int next = getjump(fs, list);
   TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
   int k, oldsize;
   if (ttisinteger(idx)) {  /* is there an index there? */
-    k = ivalue(idx);
+    k = cast_int(ivalue(idx));
     /* correct value? (warning: must distinguish floats from integers!) */
     if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
                       luaV_rawequalobj(&f->k[k], v))
 /*
-** use userdata as key to avoid collision with float with same value;
+** Integers use userdata as keys to avoid collision with floats with same
-** conversion to 'void*' used only for hash, no "precision" problems
+** value; conversion to 'void*' used only for hashing, no "precision"
+** problems
 */
 int luaK_intK (FuncState *fs, lua_Integer n) {
   TValue k, o;
 /*
 ** Both NaN and -0.0 should not go to the constant table, as they have
-** problems with the hashing. (NaN is not ** a valid key,
+** problems with the hashing. (NaN is not a valid key, -0.0 collides
-** -0.0 collides with +0.0.)
+** with +0.0.)
 */
 static int luaK_numberK (FuncState *fs, lua_Number r) {
   TValue o;
   lua_assert(!luai_numisnan(r) && !isminuszero(r));
-  setnvalue(&o, r);
+  setfltvalue(&o, r);
   return addk(fs, &o, &o);
 }
       return (tointeger(v1, &i) && tointeger(v2, &i));
     case LUA_OPMOD:  /* integer module by 0 */
       return !(ttisinteger(v1) && ttisinteger(v2) && ivalue(v2) == 0);
-    case LUA_OPPOW:  /* negative integer exponentiation */
-      return !(ttisinteger(v1) && ttisinteger(v2) && ivalue(v2) < 0);
     default: return 1;  /* everything else is valid */
   }
 }

src/lcorolib.c+17−5

 /*
-** $Id: lcorolib.c,v 1.5 2013/02/21 13:44:53 roberto Exp $
+** $Id: lcorolib.c,v 1.6 2014/05/08 13:52:20 roberto Exp $
 ** Coroutine Library
 ** See Copyright Notice in lua.h
 */
 #include "lualib.h"
+static lua_State *getco (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  luaL_argcheck(L, co, 1, "coroutine expected");
+  return co;
+}
 static int auxresume (lua_State *L, lua_State *co, int narg) {
   int status;
   if (!lua_checkstack(co, narg)) {
 static int luaB_coresume (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
+  lua_State *co = getco(L);
   int r;
-  luaL_argcheck(L, co, 1, "coroutine expected");
   r = auxresume(L, co, lua_gettop(L) - 1);
   if (r < 0) {
     lua_pushboolean(L, 0);
 static int luaB_costatus (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
+  lua_State *co = getco(L);
-  luaL_argcheck(L, co, 1, "coroutine expected");
   if (L == co) lua_pushliteral(L, "running");
   else {
     switch (lua_status(co)) {
 }
+static int luaB_yieldable (lua_State *L) {
+  lua_pushboolean(L, lua_isyieldable(L));
+  return 1;
+}
 static int luaB_corunning (lua_State *L) {
   int ismain = lua_pushthread(L);
   lua_pushboolean(L, ismain);
   {"status", luaB_costatus},
   {"wrap", luaB_cowrap},
   {"yield", luaB_yield},
+  {"isyieldable", luaB_yieldable},
   {NULL, NULL}
 };

src/ldblib.c+117−70

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldblib.c,v 1.137 2014/03/12 20:57:40 roberto Exp $	2	** $Id: ldblib.c,v 1.139 2014/05/15 19:27:33 roberto Exp $
3	** Interface from Lua to its debug API	3	** Interface from Lua to its debug API
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -21,16 +21,30 @@ · 15 unmodified lines
21	#define HOOKKEY "_HKEY"	21	#define HOOKKEY "_HKEY"
22		22
23		23
24		24	static int db_Csize (lua_State *L) {
25	static int db_numbits (lua_State *L) {	25	static struct {
		26	char c;
		27	unsigned char sz;
		28	} sizes[] = {
		29	{'I', sizeof(lua_Integer)},
		30	{'F', sizeof(lua_Number)},
		31	{'b', CHAR_BIT}, /* here is number of bits (not bytes) */
		32	{'h', sizeof(short)},
		33	{'i', sizeof(int)},
		34	{'l', sizeof(long)},
		35	{'z', sizeof(size_t)},
		36	{'f', sizeof(float)},
		37	{'d', sizeof(double)}
		38	};
26	const char *s = luaL_checkstring(L, 1);	39	const char *s = luaL_checkstring(L, 1);
27	if (*s == 'i')	40	int i;
28	lua_pushinteger(L, sizeof(lua_Integer) * CHAR_BIT);	41	for (i = 0; i < (int)(sizeof(sizes)/sizeof(sizes[0])); i++) {
29	else if (*s == 'f')	42	if (*s == sizes[i].c) {
30	lua_pushinteger(L, sizeof(lua_Number) * CHAR_BIT);	43	lua_pushinteger(L, sizes[i].sz);
31	else	44	return 1;
32	luaL_argerror(L, 1, lua_pushfstring(L, "invalid option '%s'", s));	45	}
33	return 1;	46	}
		47	return luaL_argerror(L, 1, lua_pushfstring(L, "invalid option '%c'", *s));
34	}	48	}
35		49
36		50
@@ -77,24 +91,12 @@ static int db_setuservalue (lua_State *L) { · 40 unmodified lines
77	}	91	}
78		92
79		93
80	static void settabss (lua_State L, const char i, const char *v) {	94	/*
81	lua_pushstring(L, v);	95	** Auxiliary function used by several library functions: check for
82	lua_setfield(L, -2, i);	96	** an optional thread as function's first argument and set 'arg' with
83	}	97	** 1 if this argument is present (so that functions can skip it to
84		98	** access their other arguments)
85		99	*/
86	static void settabsi (lua_State L, const char i, int v) {
87	lua_pushinteger(L, v);
88	lua_setfield(L, -2, i);
89	}
90
91
92	static void settabsb (lua_State L, const char i, int v) {
93	lua_pushboolean(L, v);
94	lua_setfield(L, -2, i);
95	}
96
97
98	static lua_State getthread (lua_State L, int *arg) {	100	static lua_State getthread (lua_State L, int *arg) {
99	if (lua_isthread(L, 1)) {	101	if (lua_isthread(L, 1)) {
100	*arg = 1;	102	*arg = 1;
@@ -102,44 +104,70 @@ static lua_State getthread (lua_State L, int *arg) { · 1 unmodified line
102	}	104	}
103	else {	105	else {
104	*arg = 0;	106	*arg = 0;
105	return L;	107	return L; /* function will operate over current thread */
106	}	108	}
107	}	109	}
108		110
109		111
		112	/*
		113	** Variations of 'lua_settable', used by 'db_getinfo' to put results
		114	** from 'lua_getinfo' into result table. Key is always a string;
		115	** value can be a string, an int, or a boolean.
		116	*/
		117	static void settabss (lua_State L, const char k, const char *v) {
		118	lua_pushstring(L, v);
		119	lua_setfield(L, -2, k);
		120	}
		121
		122	static void settabsi (lua_State L, const char k, int v) {
		123	lua_pushinteger(L, v);
		124	lua_setfield(L, -2, k);
		125	}
		126
		127	static void settabsb (lua_State L, const char k, int v) {
		128	lua_pushboolean(L, v);
		129	lua_setfield(L, -2, k);
		130	}
		131
		132
		133	/*
		134	** In function 'db_getinfo', the call to 'lua_getinfo' may push
		135	** results on the stack; later it creates the result table to put
		136	** these objects. Function 'treatstackoption' puts the result from
		137	** 'lua_getinfo' on top of the result table so that it can call
		138	** 'lua_setfield'.
		139	*/
110	static void treatstackoption (lua_State L, lua_State L1, const char *fname) {	140	static void treatstackoption (lua_State L, lua_State L1, const char *fname) {
111	if (L == L1) {	141	if (L == L1)
112	lua_pushvalue(L, -2);	142	lua_rotate(L, -2, 1); /* exchange object and table */
113	lua_remove(L, -3);
114	}
115	else	143	else
116	lua_xmove(L1, L, 1);	144	lua_xmove(L1, L, 1); /* move object to the "main" stack */
117	lua_setfield(L, -2, fname);	145	lua_setfield(L, -2, fname); /* put object into table */
118	}	146	}
119		147
120		148
		149	/*
		150	** Calls 'lua_getinfo' and collects all results in a new table.
		151	*/
121	static int db_getinfo (lua_State *L) {	152	static int db_getinfo (lua_State *L) {
122	lua_Debug ar;	153	lua_Debug ar;
123	int arg;	154	int arg;
124	lua_State *L1 = getthread(L, &arg);	155	lua_State *L1 = getthread(L, &arg);
125	const char *options = luaL_optstring(L, arg+2, "flnStu");	156	const char *options = luaL_optstring(L, arg+2, "flnStu");
126	if (lua_isnumber(L, arg+1)) {	157	if (lua_isfunction(L, arg + 1)) { /* info about a function? */
127	if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {	158	options = lua_pushfstring(L, ">%s", options); /* add '>' to 'options' */
		159	lua_pushvalue(L, arg + 1); /* move function to 'L1' stack */
		160	lua_xmove(L, L1, 1);
		161	}
		162	else { /* stack level */
		163	if (!lua_getstack(L1, luaL_checkint(L, arg + 1), &ar)) {
128	lua_pushnil(L); /* level out of range */	164	lua_pushnil(L); /* level out of range */
129	return 1;	165	return 1;
130	}	166	}
131	}	167	}
132	else if (lua_isfunction(L, arg+1)) {
133	lua_pushfstring(L, ">%s", options);
134	options = lua_tostring(L, -1);
135	lua_pushvalue(L, arg+1);
136	lua_xmove(L, L1, 1);
137	}
138	else
139	return luaL_argerror(L, arg+1, "function or level expected");
140	if (!lua_getinfo(L1, options, &ar))	168	if (!lua_getinfo(L1, options, &ar))
141	return luaL_argerror(L, arg+2, "invalid option");	169	return luaL_argerror(L, arg+2, "invalid option");
142	lua_createtable(L, 0, 2);	170	lua_newtable(L); /* table to collect results */
143	if (strchr(options, 'S')) {	171	if (strchr(options, 'S')) {
144	settabss(L, "source", ar.source);	172	settabss(L, "source", ar.source);
145	settabss(L, "short_src", ar.short_src);	173	settabss(L, "short_src", ar.short_src);
@@ -177,16 +205,16 @@ static int db_getlocal (lua_State *L) { · 31 unmodified lines
177	if (lua_isfunction(L, arg + 1)) { /* function argument? */	205	if (lua_isfunction(L, arg + 1)) { /* function argument? */
178	lua_pushvalue(L, arg + 1); /* push function */	206	lua_pushvalue(L, arg + 1); /* push function */
179	lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */	207	lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */
180	return 1;	208	return 1; /* return only name (there is no value) */
181	}	209	}
182	else { /* stack-level argument */	210	else { /* stack-level argument */
183	if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */	211	if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */
184	return luaL_argerror(L, arg+1, "level out of range");	212	return luaL_argerror(L, arg+1, "level out of range");
185	name = lua_getlocal(L1, &ar, nvar);	213	name = lua_getlocal(L1, &ar, nvar);
186	if (name) {	214	if (name) {
187	lua_xmove(L1, L, 1); /* push local value */	215	lua_xmove(L1, L, 1); /* move local value */
188	lua_pushstring(L, name); /* push name */	216	lua_pushstring(L, name); /* push name */
189	lua_pushvalue(L, -2); /* re-order */	217	lua_rotate(L, -2, 1); /* re-order */
190	return 2;	218	return 2;
191	}	219	}
192	else {	220	else {
@@ -211,14 +239,17 @@ static int db_setlocal (lua_State *L) { · 18 unmodified lines
211	}	239	}
212		240
213		241
		242	/*
		243	** get (if 'get' is true) or set an upvalue from a closure
		244	*/
214	static int auxupvalue (lua_State *L, int get) {	245	static int auxupvalue (lua_State *L, int get) {
215	const char *name;	246	const char *name;
216	int n = luaL_checkint(L, 2);	247	int n = luaL_checkint(L, 2); /* upvalue index */
217	luaL_checktype(L, 1, LUA_TFUNCTION);	248	luaL_checktype(L, 1, LUA_TFUNCTION); /* closure */
218	name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);	249	name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
219	if (name == NULL) return 0;	250	if (name == NULL) return 0;
220	lua_pushstring(L, name);	251	lua_pushstring(L, name);
221	lua_insert(L, -(get+1));	252	lua_insert(L, -(get+1)); /* no-op if get is false */
222	return get + 1;	253	return get + 1;
223	}	254	}
224		255
@@ -234,13 +265,15 @@ static int db_setupvalue (lua_State *L) { · 9 unmodified lines
234	}	265	}
235		266
236		267
		268	/*
		269	** Check whether a given upvalue from a given closure exists and
		270	** returns its index
		271	*/
237	static int checkupval (lua_State *L, int argf, int argnup) {	272	static int checkupval (lua_State *L, int argf, int argnup) {
238	lua_Debug ar;	273	int nup = luaL_checkint(L, argnup); /* upvalue index */
239	int nup = luaL_checkint(L, argnup);	274	luaL_checktype(L, argf, LUA_TFUNCTION); /* closure */
240	luaL_checktype(L, argf, LUA_TFUNCTION);	275	luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup,
241	lua_pushvalue(L, argf);	276	"invalid upvalue index");
242	lua_getinfo(L, ">u", &ar);
243	luaL_argcheck(L, 1 <= nup && nup <= ar.nups, argnup, "invalid upvalue index");
244	return nup;	277	return nup;
245	}	278	}
246		279
@@ -262,25 +295,36 @@ static int db_upvaluejoin (lua_State *L) { · 15 unmodified lines
262	}	295	}
263		296
264		297
		298	/*
		299	** The hook table (at registry[HOOKKEY]) maps threads to their current
		300	** hook function
		301	*/
265	#define gethooktable(L) luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)	302	#define gethooktable(L) luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)
266		303
267		304
		305	/*
		306	** Call hook function registered at hook table for the current
		307	** thread (if there is one)
		308	*/
268	static void hookf (lua_State L, lua_Debug ar) {	309	static void hookf (lua_State L, lua_Debug ar) {
269	static const char *const hooknames[] =	310	static const char *const hooknames[] =
270	{"call", "return", "line", "count", "tail call"};	311	{"call", "return", "line", "count", "tail call"};
271	gethooktable(L);	312	gethooktable(L);
272	lua_pushthread(L);	313	lua_pushthread(L);
273	if (lua_rawget(L, -2) == LUA_TFUNCTION) {	314	if (lua_rawget(L, -2) == LUA_TFUNCTION) { /* is there a hook function? */
274	lua_pushstring(L, hooknames[(int)ar->event]);	315	lua_pushstring(L, hooknames[(int)ar->event]); /* push event name */
275	if (ar->currentline >= 0)	316	if (ar->currentline >= 0)
276	lua_pushinteger(L, ar->currentline);	317	lua_pushinteger(L, ar->currentline); /* push current line */
277	else lua_pushnil(L);	318	else lua_pushnil(L);
278	lua_assert(lua_getinfo(L, "lS", ar));	319	lua_assert(lua_getinfo(L, "lS", ar));
279	lua_call(L, 2, 0);	320	lua_call(L, 2, 0); /* call hook function */
280	}	321	}
281	}	322	}
282		323
283		324
		325	/*
		326	** Convert a string mask (for 'sethook') into a bit mask
		327	*/
284	static int makemask (const char *smask, int count) {	328	static int makemask (const char *smask, int count) {
285	int mask = 0;	329	int mask = 0;
286	if (strchr(smask, 'c')) mask \|= LUA_MASKCALL;	330	if (strchr(smask, 'c')) mask \|= LUA_MASKCALL;
@@ -291,6 +335,9 @@ static int makemask (const char *smask, int count) { · 4 unmodified lines
291	}	335	}
292		336
293		337
		338	/*
		339	** Convert a bit mask (for 'gethook') into a string mask
		340	*/
294	static char unmakemask (int mask, char smask) {	341	static char unmakemask (int mask, char smask) {
295	int i = 0;	342	int i = 0;
296	if (mask & LUA_MASKCALL) smask[i++] = 'c';	343	if (mask & LUA_MASKCALL) smask[i++] = 'c';
@@ -305,7 +352,7 @@ static int db_sethook (lua_State *L) { · 8 unmodified lines
305	int arg, mask, count;	352	int arg, mask, count;
306	lua_Hook func;	353	lua_Hook func;
307	lua_State *L1 = getthread(L, &arg);	354	lua_State *L1 = getthread(L, &arg);
308	if (lua_isnoneornil(L, arg+1)) {	355	if (lua_isnoneornil(L, arg+1)) { /* no hook? */
309	lua_settop(L, arg+1);	356	lua_settop(L, arg+1);
310	func = NULL; mask = 0; count = 0; /* turn off hooks */	357	func = NULL; mask = 0; count = 0; /* turn off hooks */
311	}	358	}
@@ -321,9 +368,9 @@ static int db_sethook (lua_State *L) { · 9 unmodified lines
321	lua_pushvalue(L, -1);	368	lua_pushvalue(L, -1);
322	lua_setmetatable(L, -2); /* setmetatable(hooktable) = hooktable */	369	lua_setmetatable(L, -2); /* setmetatable(hooktable) = hooktable */
323	}	370	}
324	lua_pushthread(L1); lua_xmove(L1, L, 1);	371	lua_pushthread(L1); lua_xmove(L1, L, 1); /* key */
325	lua_pushvalue(L, arg+1);	372	lua_pushvalue(L, arg+1); /* value */
326	lua_rawset(L, -3); /* set new hook */	373	lua_rawset(L, -3); /* hooktable[L1] = new Lua hook */
327	lua_sethook(L1, func, mask, count); /* set hooks */	374	lua_sethook(L1, func, mask, count); /* set hooks */
328	return 0;	375	return 0;
329	}	376	}
@@ -340,11 +387,11 @@ static int db_gethook (lua_State *L) { · 10 unmodified lines
340	else {	387	else {
341	gethooktable(L);	388	gethooktable(L);
342	lua_pushthread(L1); lua_xmove(L1, L, 1);	389	lua_pushthread(L1); lua_xmove(L1, L, 1);
343	lua_rawget(L, -2); /* get hook */	390	lua_rawget(L, -2); /* 1st result = hooktable[L1] */
344	lua_remove(L, -2); /* remove hook table */	391	lua_remove(L, -2); /* remove hook table */
345	}	392	}
346	lua_pushstring(L, unmakemask(mask, buff));	393	lua_pushstring(L, unmakemask(mask, buff)); /* 2nd result = mask */
347	lua_pushinteger(L, lua_gethookcount(L1));	394	lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */
348	return 3;	395	return 3;
349	}	396	}
350		397
@@ -379,6 +426,7 @@ static int db_traceback (lua_State *L) { · 28 unmodified lines
379		426
380		427
381	static const luaL_Reg dblib[] = {	428	static const luaL_Reg dblib[] = {
		429	{"Csize", db_Csize},
382	{"debug", db_debug},	430	{"debug", db_debug},
383	{"getuservalue", db_getuservalue},	431	{"getuservalue", db_getuservalue},
384	{"gethook", db_gethook},	432	{"gethook", db_gethook},
@@ -387,7 +435,6 @@ static const luaL_Reg dblib[] = { · 2 unmodified lines
387	{"getregistry", db_getregistry},	435	{"getregistry", db_getregistry},
388	{"getmetatable", db_getmetatable},	436	{"getmetatable", db_getmetatable},
389	{"getupvalue", db_getupvalue},	437	{"getupvalue", db_getupvalue},
390	{"numbits", db_numbits},
391	{"upvaluejoin", db_upvaluejoin},	438	{"upvaluejoin", db_upvaluejoin},
392	{"upvalueid", db_upvalueid},	439	{"upvalueid", db_upvalueid},
393	{"setuservalue", db_setuservalue},	440	{"setuservalue", db_setuservalue},

src/ldo.c+64−42

 /*
-** $Id: ldo.c,v 2.115 2014/03/21 13:52:33 roberto Exp $
+** $Id: ldo.c,v 2.123 2014/06/19 18:27:20 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
+#define errorstatus(s)	((s) > LUA_YIELD)
 /*
 ** {======================================================
 }
-static void finishCcall (lua_State *L) {
+/*
+** Completes the execution of an interrupted C function, calling its
+** continuation function.
+*/
+static void finishCcall (lua_State *L, int status) {
   CallInfo *ci = L->ci;
   int n;
-  lua_assert(ci->u.c.k != NULL);  /* must have a continuation */
+  /* must have a continuation and must be able to call it */
-  lua_assert(L->nny == 0);
+  lua_assert(ci->u.c.k != NULL && L->nny == 0);
+  /* error status can only happen in a protected call */
+  lua_assert((ci->callstatus & CIST_YPCALL) || status == LUA_YIELD);
   if (ci->callstatus & CIST_YPCALL) {  /* was inside a pcall? */
     ci->callstatus &= ~CIST_YPCALL;  /* finish 'lua_pcall' */
     L->errfunc = ci->u.c.old_errfunc;
   }
-  /* finish 'lua_callk'/'lua_pcall' */
+  /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already
+     handled */
   adjustresults(L, ci->nresults);
   /* call continuation function */
-  if (!(ci->callstatus & CIST_STAT))  /* no call status? */
-    ci->u.c.status = LUA_YIELD;  /* 'default' status */
-  lua_assert(ci->u.c.status != LUA_OK);
-  ci->callstatus = (ci->callstatus & ~(CIST_YPCALL | CIST_STAT)) | CIST_YIELDED;
   lua_unlock(L);
-  n = (*ci->u.c.k)(L);
+  n = (*ci->u.c.k)(L, status, ci->u.c.ctx);
   lua_lock(L);
   api_checknelems(L, n);
   /* finish 'luaD_precall' */
 }
+/*
+** Executes "full continuation" (everything in the stack) of a
+** previously interrupted coroutine until the stack is empty (or another
+** interruption long-jumps out of the loop). If the coroutine is
+** recovering from an error, 'ud' points to the error status, which must
+** be passed to the first continuation function (otherwise the default
+** status is LUA_YIELD).
+*/
 static void unroll (lua_State *L, void *ud) {
-  UNUSED(ud);
+  if (ud != NULL)  /* error status? */
-  for (;;) {
+    finishCcall(L, *(int *)ud);  /* finish 'lua_pcallk' callee */
-    if (L->ci == &L->base_ci)  /* stack is empty? */
+  while (L->ci != &L->base_ci) {  /* something in the stack */
-      return;  /* coroutine finished normally */
     if (!isLua(L->ci))  /* C function? */
-      finishCcall(L);
+      finishCcall(L, LUA_YIELD);  /* complete its execution */
     else {  /* Lua function */
       luaV_finishOp(L);  /* finish interrupted instruction */
       luaV_execute(L);  /* execute down to higher C 'boundary' */
 /*
-** check whether thread has a suspended protected call
+** Try to find a suspended protected call (a "recover point") for the
+** given thread.
 */
 static CallInfo *findpcall (lua_State *L) {
   CallInfo *ci;
 }
+/*
+** Recovers from an error in a coroutine. Finds a recover point (if
+** there is one) and completes the execution of the interrupted
+** 'luaD_pcall'. If there is no recover point, returns zero.
+*/
 static int recover (lua_State *L, int status) {
   StkId oldtop;
   CallInfo *ci = findpcall(L);
   luaF_close(L, oldtop);
   seterrorobj(L, status, oldtop);
   L->ci = ci;
-  L->allowhook = ci->u.c.old_allowhook;
+  L->allowhook = getoah(ci->callstatus);  /* restore original 'allowhook' */
   L->nny = 0;  /* should be zero to be yieldable */
   luaD_shrinkstack(L);
   L->errfunc = ci->u.c.old_errfunc;
-  ci->callstatus |= CIST_STAT;  /* call has error status */
-  ci->u.c.status = status;  /* (here it is) */
   return 1;  /* continue running the coroutine */
 }
 /*
-** do the work for 'lua_resume' in protected mode
+** 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
+** function), plus erroneous cases: non-suspended coroutine or dead
+** coroutine.
 */
 static void resume (lua_State *L, void *ud) {
   int nCcalls = L->nCcalls;
   else if (L->status != LUA_YIELD)
     resume_error(L, "cannot resume dead coroutine", firstArg);
   else {  /* resuming from previous yield */
-    L->status = LUA_OK;
+    L->status = LUA_OK;  /* mark that it is running (again) */
     ci->func = restorestack(L, ci->extra);
     if (isLua(ci))  /* yielded inside a hook? */
       luaV_execute(L);  /* just continue running Lua code */
     else {  /* 'common' yield */
-      if (ci->u.c.k != NULL) {  /* does it have a continuation? */
+      if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
         int n;
-        ci->u.c.status = LUA_YIELD;  /* 'default' status */
-        ci->callstatus |= CIST_YIELDED;
         lua_unlock(L);
-        n = (*ci->u.c.k)(L);  /* call continuation */
+        n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
         lua_lock(L);
         api_checknelems(L, n);
         firstArg = L->top - n;  /* yield results come from continuation */
       }
       luaD_poscall(L, firstArg);  /* finish 'luaD_precall' */
     }
-    unroll(L, NULL);
+    unroll(L, NULL);  /* run continuation */
   }
   lua_assert(nCcalls == L->nCcalls);
 }
 LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
   int status;
-  int oldnny = L->nny;  /* save 'nny' */
+  int oldnny = L->nny;  /* save "number of non-yieldable" calls */
   lua_lock(L);
   luai_userstateresume(L, nargs);
   L->nCcalls = (from) ? from->nCcalls + 1 : 1;
   status = luaD_rawrunprotected(L, resume, L->top - nargs);
   if (status == -1)  /* error calling 'lua_resume'? */
     status = LUA_ERRRUN;
-  else {  /* yield or regular error */
+  else {  /* continue running after recoverable errors */
-    while (status != LUA_OK && status != LUA_YIELD) {  /* error? */
+    while (errorstatus(status) && recover(L, status)) {
-      if (recover(L, status))  /* recover point? */
+      /* unroll continuation */
-        status = luaD_rawrunprotected(L, unroll, NULL);  /* run continuation */
+      status = luaD_rawrunprotected(L, unroll, &status);
-      else {  /* unrecoverable error */
+    }
-        L->status = cast_byte(status);  /* mark thread as `dead' */
+    if (errorstatus(status)) {  /* unrecoverable error? */
-        seterrorobj(L, status, L->top);
+      L->status = cast_byte(status);  /* mark thread as `dead' */
-        L->ci->top = L->top;
+      seterrorobj(L, status, L->top);  /* push error message */
-        break;
+      L->ci->top = L->top;
-      }
     }
-    lua_assert(status == L->status);
+    else lua_assert(status == L->status);  /* normal end or yield */
   }
   L->nny = oldnny;  /* restore 'nny' */
   L->nCcalls--;
 }
-LUA_API int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k) {
+LUA_API int lua_isyieldable (lua_State *L) {
+  return (L->nny == 0);
+}
+LUA_API int lua_yieldk (lua_State *L, int nresults, int ctx, lua_KFunction k) {
   CallInfo *ci = L->ci;
   luai_userstateyield(L, nresults);
   lua_lock(L);
 static void f_parser (lua_State *L, void *ud) {
-  Closure *cl;
+  LClosure *cl;
   struct SParser *p = cast(struct SParser *, ud);
   int c = zgetc(p->z);  /* read first character */
   if (c == LUA_SIGNATURE[0]) {
     checkmode(L, p->mode, "text");
     cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
   }
-  lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
+  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
-  luaF_initupvals(L, &cl->l);
+  luaF_initupvals(L, cl);
 }

src/ldump.c+18−9

 /*
-** $Id: ldump.c,v 2.27 2014/03/11 18:56:27 roberto Exp $
+** $Id: ldump.c,v 2.32 2014/06/18 18:35:43 roberto Exp $
 ** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 /*
 ** All high-level dumps go through DumpVector; you can change it to
-** change the endianess of the result
+** change the endianness of the result
 */
 #define DumpVector(v,n,D)	DumpBlock(v,(n)*sizeof((v)[0]),D)
   else {
     size_t size = s->tsv.len + 1;  /* include trailing '\0' */
     if (size < 0xFF)
-      DumpByte(size, D);
+      DumpByte(cast_int(size), D);
     else {
       DumpByte(0xFF, D);
       DumpVar(size, D);
 }
-static void DumpFunction(const Proto *f, DumpState *D);
+static void DumpFunction(const Proto *f, TString *psource, DumpState *D);
 static void DumpConstants (const Proto *f, DumpState *D) {
   int i;
       lua_assert(0);
     }
   }
-  n = f->sizep;
+}
+static void DumpProtos (const Proto *f, DumpState *D) {
+  int i;
+  int n = f->sizep;
   DumpInt(n, D);
   for (i = 0; i < n; i++)
-    DumpFunction(f->p[i], D);
+    DumpFunction(f->p[i], f->source, D);
 }
 static void DumpDebug (const Proto *f, DumpState *D) {
   int i, n;
-  DumpString((D->strip) ? NULL : f->source, D);
   n = (D->strip) ? 0 : f->sizelineinfo;
   DumpInt(n, D);
   DumpVector(f->lineinfo, n, D);
 }
-static void DumpFunction (const Proto *f, DumpState *D) {
+static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
+  if (D->strip || f->source == psource)
+    DumpString(NULL, D);  /* no debug info or same source as its parent */
+  else
+    DumpString(f->source, D);
   DumpInt(f->linedefined, D);
   DumpInt(f->lastlinedefined, D);
   DumpByte(f->numparams, D);
   DumpCode(f, D);
   DumpConstants(f, D);
   DumpUpvalues(f, D);
+  DumpProtos(f, D);
   DumpDebug(f, D);
 }
   D.status = 0;
   DumpHeader(&D);
   DumpByte(f->sizeupvalues, &D);
-  DumpFunction(f, &D);
+  DumpFunction(f, NULL, &D);
   return D.status;
 }

src/lfunc.c+13−10

 /*
-** $Id: lfunc.c,v 2.41 2014/02/18 13:39:37 roberto Exp $
+** $Id: lfunc.c,v 2.43 2014/06/19 18:27:20 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
-Closure *luaF_newCclosure (lua_State *L, int n) {
+CClosure *luaF_newCclosure (lua_State *L, int n) {
-  Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n))->cl;
+  GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n));
-  c->c.nupvalues = cast_byte(n);
+  CClosure *c = gco2ccl(o);
+  c->nupvalues = cast_byte(n);
   return c;
 }
-Closure *luaF_newLclosure (lua_State *L, int n) {
+LClosure *luaF_newLclosure (lua_State *L, int n) {
-  Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n))->cl;
+  GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n));
-  c->l.p = NULL;
+  LClosure *c = gco2lcl(o);
-  c->l.nupvalues = cast_byte(n);
+  c->p = NULL;
-  while (n--) c->l.upvals[n] = NULL;
+  c->nupvalues = cast_byte(n);
+  while (n--) c->upvals[n] = NULL;
   return c;
 }
 Proto *luaF_newproto (lua_State *L) {
-  Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto))->p;
+  GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto));
+  Proto *f = gco2p(o);
   f->k = NULL;
   f->sizek = 0;
   f->p = NULL;

src/lfunc.h+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lfunc.h,v 2.13 2014/02/18 13:39:37 roberto Exp $	2	** $Id: lfunc.h,v 2.14 2014/06/19 18:27:20 roberto Exp $
3	** Auxiliary functions to manipulate prototypes and closures	3	** Auxiliary functions to manipulate prototypes and closures
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -41,8 +41,8 @@ struct UpVal { · 35 unmodified lines
41		41
42		42
43	LUAI_FUNC Proto luaF_newproto (lua_State L);	43	LUAI_FUNC Proto luaF_newproto (lua_State L);
44	LUAI_FUNC Closure luaF_newCclosure (lua_State L, int nelems);	44	LUAI_FUNC CClosure luaF_newCclosure (lua_State L, int nelems);
45	LUAI_FUNC Closure luaF_newLclosure (lua_State L, int nelems);	45	LUAI_FUNC LClosure luaF_newLclosure (lua_State L, int nelems);
46	LUAI_FUNC void luaF_initupvals (lua_State L, LClosure cl);	46	LUAI_FUNC void luaF_initupvals (lua_State L, LClosure cl);
47	LUAI_FUNC UpVal luaF_findupval (lua_State L, StkId level);	47	LUAI_FUNC UpVal luaF_findupval (lua_State L, StkId level);
48	LUAI_FUNC void luaF_close (lua_State *L, StkId level);	48	LUAI_FUNC void luaF_close (lua_State *L, StkId level);

src/lgc.c+70−76

 /*
-** $Id: lgc.c,v 2.179 2014/03/21 13:52:33 roberto Exp $
+** $Id: lgc.c,v 2.183 2014/05/25 19:08:32 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 ** closures pointing to it. So, we assume that the object being assigned
 ** must be marked.
 */
-LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
+void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
   global_State *g = G(L);
   GCObject *o = gcvalue(uv->v);
   lua_assert(!upisopen(uv));  /* ensured by macro luaC_upvalbarrier */
 }
-static lu_mem traversestack (global_State *g, lua_State *th) {
+static lu_mem traversethread (global_State *g, lua_State *th) {
-  int n = 0;
   StkId o = th->stack;
   if (o == NULL)
     return 1;  /* stack not completely built yet */
       g->twups = th;
     }
   }
-  else {
+  else if (g->gckind != KGC_EMERGENCY)
-    CallInfo *ci;
+    luaD_shrinkstack(th); /* do not change stack in emergency cycle */
-    for (ci = &th->base_ci; ci != th->ci; ci = ci->next)
+  return (sizeof(lua_State) + sizeof(TValue) * th->stacksize);
-      n++;  /* count call infos to compute size */
-    /* should not change the stack during an emergency gc cycle */
-    if (g->gckind != KGC_EMERGENCY)
-      luaD_shrinkstack(th);
-  }
-  return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
-         sizeof(CallInfo) * n;
 }
       th->gclist = g->grayagain;
       g->grayagain = o;  /* insert into 'grayagain' list */
       black2gray(o);
-      size = traversestack(g, th);
+      size = traversethread(g, th);
       break;
     }
     case LUA_TPROTO: {
 */
 static void checkSizes (lua_State *L, global_State *g) {
   if (g->gckind != KGC_EMERGENCY) {
+    l_mem olddebt = g->GCdebt;
     luaZ_freebuffer(L, &g->buff);  /* free concatenation buffer */
     if (g->strt.nuse < g->strt.size / 4)  /* string table too big? */
       luaS_resize(L, g->strt.size / 2);  /* shrink it a little */
+    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
   }
 }
 }
+/*
+** call a few (up to 'g->gcfinnum') finalizers
+*/
+static int runafewfinalizers (lua_State *L) {
+  global_State *g = G(L);
+  unsigned int i;
+  lua_assert(!g->tobefnz || g->gcfinnum > 0);
+  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
+    GCTM(L, 1);  /* call one finalizer */
+  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
+                    : g->gcfinnum * 2;  /* else call a few more next time */
+  return i;
+}
 /*
 ** call all pending finalizers
 */
     return;  /* nothing to be done */
   else {  /* move 'o' to 'finobj' list */
     GCObject **p;
-    if (g->sweepgc == &o->gch.next) {  /* avoid removing current sweep object */
+    if (issweepphase(g)) {
-      lua_assert(issweepphase(g));
+      makewhite(g, o);  /* "sweep" object 'o' */
-      g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
+      if (g->sweepgc == &o->gch.next)  /* shoud 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 */ }
-    *p = o->gch.next;  /* remove 'o' from its list */
+    *p = o->gch.next;  /* remove 'o' from 'allgc' list */
     o->gch.next = g->finobj;  /* link it in "fin" list */
     g->finobj = o;
     l_setbit(o->gch.marked, FINALIZEDBIT);  /* mark it as such */
-    if (issweepphase(g))
-      makewhite(g, o);  /* "sweep" object */
   }
 }
 ** set a reasonable "time" to wait before starting a new GC cycle;
 ** cycle will start when memory use hits threshold
 */
-static void setpause (global_State *g, l_mem estimate) {
+static void setpause (global_State *g) {
   l_mem threshold, debt;
-  estimate = estimate / PAUSEADJ;  /* adjust 'estimate' */
+  l_mem estimate = g->GCestimate / PAUSEADJ;  /* adjust 'estimate' */
   threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
             ? estimate * g->gcpause  /* no overflow */
             : MAX_LMEM;  /* overflow; truncate to maximum */
 static l_mem atomic (lua_State *L) {
   global_State *g = G(L);
-  l_mem work = -cast(l_mem, g->GCmemtrav);  /* start counting work */
+  l_mem work;
   GCObject *origweak, *origall;
+  g->GCmemtrav = 0;  /* start counting work */
   lua_assert(!iswhite(obj2gco(g->mainthread)));
   g->gcstate = GCSinsideatomic;
   markobject(g, L);  /* mark running thread */
   /* remark occasional upvalues of (maybe) dead threads */
   remarkupvals(g);
   propagateall(g);  /* propagate changes */
-  work += g->GCmemtrav;  /* stop counting (do not (re)count grays) */
+  work = g->GCmemtrav;  /* stop counting (do not (re)count grays) */
   /* traverse objects caught by write barrier and by 'remarkupvals' */
   retraversegrays(g);
-  work -= g->GCmemtrav;  /* restart counting */
+  g->GCmemtrav = 0;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all strongly accessible objects are marked. */
   /* Clear values from weak tables, before checking finalizers */
   g->gcfinnum = 1;  /* there may be objects to be finalized */
   markbeingfnz(g);  /* mark objects that will be finalized */
   propagateall(g);  /* remark, to propagate 'resurrection' */
-  work -= g->GCmemtrav;  /* restart counting */
+  g->GCmemtrav = 0;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all resurrected objects are marked. */
   /* remove dead objects from weak tables */
 static lu_mem sweepstep (lua_State *L, global_State *g,
                          int nextstate, GCObject **nextlist) {
   if (g->sweepgc) {
+    l_mem olddebt = g->GCdebt;
     g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
     if (g->sweepgc)  /* is there still something to sweep? */
       return (GCSWEEPMAX * GCSWEEPCOST);
   }
   global_State *g = G(L);
   switch (g->gcstate) {
     case GCSpause: {
-      /* start to count memory traversed */
       g->GCmemtrav = g->strt.size * sizeof(GCObject*);
       restartcollection(g);
       g->gcstate = GCSpropagate;
       return g->GCmemtrav;
     }
     case GCSpropagate: {
-      lu_mem oldtrav = g->GCmemtrav;
+      g->GCmemtrav = 0;
       lua_assert(g->gray);
       propagatemark(g);
        if (g->gray == NULL)  /* no more `gray' objects? */
         g->gcstate = GCSatomic;  /* finish propagate phase */
-      return g->GCmemtrav - oldtrav;  /* memory traversed in this step */
+      return g->GCmemtrav;  /* memory traversed in this step */
     }
     case GCSatomic: {
       lu_mem work;
       int sw;
       propagateall(g);  /* make sure gray list is empty */
-      g->GCestimate = g->GCmemtrav;  /* save what was counted */;
       work = atomic(L);  /* work is what was traversed by 'atomic' */
-      g->GCestimate += work;  /* estimate of total memory traversed */
       sw = entersweep(L);
+      g->GCestimate = gettotalbytes(g);  /* first estimate */;
       return work + sw * GCSWEEPCOST;
     }
     case GCSswpallgc: {  /* sweep "regular" objects */
       g->gcstate = GCScallfin;
       return 0;
     }
-    case GCScallfin: {  /* state to finish calling finalizers */
+    case GCScallfin: {  /* call remaining finalizers */
-      /* do nothing here; should be handled by 'luaC_forcestep' */
+      if (g->tobefnz && g->gckind != KGC_EMERGENCY) {
-      g->gcstate = GCSpause;  /* finish collection */
+        int n = runafewfinalizers(L);
-      return 0;
+        return (n * GCFINALIZECOST);
+      }
+      else {  /* emergency mode or no more finalizers */
+        g->gcstate = GCSpause;  /* finish collection */
+        return 0;
+      }
     }
     default: lua_assert(0); return 0;
   }
 }
-/*
-** run a few (up to 'g->gcfinnum') finalizers
-*/
-static int runafewfinalizers (lua_State *L) {
-  global_State *g = G(L);
-  unsigned int i;
-  lua_assert(!g->tobefnz || g->gcfinnum > 0);
-  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
-    GCTM(L, 1);  /* call one finalizer */
-  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
-                    : g->gcfinnum * 2;  /* else call a few more next time */
-  return i;
-}
 /*
 ** get GC debt and convert it from Kb to 'work units' (avoid zero debt
 ** and overflows)
 */
 void luaC_step (lua_State *L) {
   global_State *g = G(L);
-  l_mem debt = getdebt(g);
+  l_mem debt = getdebt(g);  /* GC deficit (be paid now) */
   if (!g->gcrunning) {  /* not running? */
     luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
     return;
   }
-  do {
+  do {  /* repeat until pause or enough "credit" (negative debt) */
-    if (g->gcstate == GCScallfin && g->tobefnz) {
+    lu_mem work = singlestep(L);  /* perform one single step */
-      unsigned int n = runafewfinalizers(L);
+    debt -= work;
-      debt -= (n * GCFINALIZECOST);
-    }
-    else {  /* perform one single step */
-      lu_mem work = singlestep(L);
-      debt -= work;
-    }
   } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
   if (g->gcstate == GCSpause)
-    setpause(g, g->GCestimate);  /* pause until next cycle */
+    setpause(g);  /* pause until next cycle */
   else {
     debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
     luaE_setdebt(g, debt);
 /*
-** performs a full GC cycle; if "isemergency", does not call
+** Performs a full GC cycle; if "isemergency", set a flag to avoid
-** finalizers (which could change stack positions)
+** some operations which could change the interpreter state in some
+** unexpected ways (running finalizers and shrinking some structures).
+** Before running the collection, check 'keepinvariant'; if it is true,
+** there may be some objects marked as black, so the collector has
+** to sweep all objects to turn them back to white (as white has not
+** changed, nothing will be collected).
 */
 void luaC_fullgc (lua_State *L, int isemergency) {
   global_State *g = G(L);
   lua_assert(g->gckind == KGC_NORMAL);
-  if (isemergency)  /* do not run finalizers during emergency GC */
+  if (isemergency) g->gckind = KGC_EMERGENCY;  /* set flag */
-    g->gckind = KGC_EMERGENCY;
+  if (keepinvariant(g)) {  /* black objects? */
-  else
+    entersweep(L); /* sweep everything to turn them back to white */
-    callallpendingfinalizers(L, 1);
-  if (keepinvariant(g)) {  /* may there be some black objects? */
-    /* must sweep all objects to turn them back to white
-       (as white has not changed, nothing will be collected) */
-    entersweep(L);
   }
   /* finish any pending sweep phase to start a new cycle */
   luaC_runtilstate(L, bitmask(GCSpause));
   luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
-  luaC_runtilstate(L, bitmask(GCSpause));  /* run entire collection */
+  luaC_runtilstate(L, bitmask(GCScallfin));  /* run up to finalizers */
+  /* estimate must be correct after a full GC cycle */
+  lua_assert(g->GCestimate == gettotalbytes(g));
+  luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
   g->gckind = KGC_NORMAL;
-  setpause(g, gettotalbytes(g));
+  setpause(g);
-  if (!isemergency)   /* do not run finalizers during emergency GC */
-    callallpendingfinalizers(L, 1);
 }
 /* }====================================================== */

src/linit.c+5−3

 /*
-** $Id: linit.c,v 1.33 2014/02/06 17:32:33 roberto Exp $
+** $Id: linit.c,v 1.34 2014/05/15 19:28:34 roberto Exp $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
   {LUA_IOLIBNAME, luaopen_io},
   {LUA_OSLIBNAME, luaopen_os},
   {LUA_STRLIBNAME, luaopen_string},
-  {LUA_UTF8LIBNAME, luaopen_utf8},
-  {LUA_BITLIBNAME, luaopen_bit32},
   {LUA_MATHLIBNAME, luaopen_math},
   {LUA_DBLIBNAME, luaopen_debug},
+  {LUA_UTF8LIBNAME, luaopen_utf8},
+#if defined(LUA_COMPAT_BITLIB)
+  {LUA_BITLIBNAME, luaopen_bit32},
+#endif
   {NULL, NULL}
 };

src/liolib.c+89−24

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: liolib.c,v 2.120 2014/03/19 18:57:42 roberto Exp $	2	** $Id: liolib.c,v 2.126 2014/06/02 03:00:51 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	*/
@@ -15,7 +15,9 @@ · 9 unmodified lines
15	#endif	15	#endif
16		16
17		17
		18	#include <ctype.h>
18	#include <errno.h>	19	#include <errno.h>
		20	#include <locale.h>
19	#include <stdio.h>	21	#include <stdio.h>
20	#include <stdlib.h>	22	#include <stdlib.h>
21	#include <string.h>	23	#include <string.h>
@@ -104,6 +106,8 @@ · 82 unmodified lines
104		106
105	#if defined(LUA_USE_POSIX) /* { */	107	#if defined(LUA_USE_POSIX) /* { */
106		108
		109	#include <sys/types.h>
		110
107	#define l_fseek(f,o,w) fseeko(f,o,w)	111	#define l_fseek(f,o,w) fseeko(f,o,w)
108	#define l_ftell(f) ftello(f)	112	#define l_ftell(f) ftello(f)
109	#define l_seeknum off_t	113	#define l_seeknum off_t
@@ -317,14 +321,10 @@ static int io_readline (lua_State *L); · 207 unmodified lines
317		321
318		322
319	static void aux_lines (lua_State *L, int toclose) {	323	static void aux_lines (lua_State *L, int toclose) {
320	int i;
321	int n = lua_gettop(L) - 1; /* number of arguments to read */	324	int n = lua_gettop(L) - 1; /* number of arguments to read */
322	/* ensure that arguments will fit here and into 'io_readline' stack */
323	luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options");
324	lua_pushvalue(L, 1); /* file handle */
325	lua_pushinteger(L, n); /* number of arguments to read */	325	lua_pushinteger(L, n); /* number of arguments to read */
326	lua_pushboolean(L, toclose); /* close/not close file when finished */	326	lua_pushboolean(L, toclose); /* close/not close file when finished */
327	for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1); /* copy arguments */	327	lua_rotate(L, 2, 2); /* move 'n' and 'toclose' to their positions */
328	lua_pushcclosure(L, io_readline, 3 + n);	328	lua_pushcclosure(L, io_readline, 3 + n);
329	}	329	}
330		330
@@ -363,26 +363,93 @@ static int io_lines (lua_State *L) { · 32 unmodified lines
363	*/	363	*/
364		364
365		365
366	static int read_integer (lua_State L, FILE f) {	366	/* maximum length of a numeral */
367	lua_Integer d;	367	#define MAXRN 200
368	if (fscanf(f, LUA_INTEGER_SCAN, &d) == 1) {	368
369	lua_pushinteger(L, d);	369	/* auxiliary structure used by 'read_number' */
370	return 1;	370	typedef struct {
		371	FILE f; / file being read */
		372	int c; /* current character (look ahead) */
		373	int n; /* number of elements in buffer 'buff' */
		374	char buff[MAXRN + 1]; /* +1 for ending '\0' */
		375	} RN;
		376
		377
		378	/*
		379	** Add current char to buffer (if not out of space) and read next one
		380	*/
		381	static int nextc (RN *rn) {
		382	if (rn->n >= MAXRN) { /* buffer overflow? */
		383	rn->buff[0] = '\0'; /* invalidate result */
		384	return 0; /* fail */
371	}	385	}
372	else {	386	else {
373	lua_pushnil(L); /* "result" to be removed */	387	rn->buff[rn->n++] = rn->c; /* save current char */
374	return 0; /* read fails */	388	rn->c = l_getc(rn->f); /* read next one */
		389	return 1;
375	}	390	}
376	}	391	}
377		392
378		393
		394	/*
		395	** Accept current char if it is in 'set' (of size 1 or 2)
		396	*/
		397	static int test2 (RN rn, const char set) {
		398	if (rn->c == set[0] \|\| (rn->c == set[1] && rn->c != '\0'))
		399	return nextc(rn);
		400	else return 0;
		401	}
		402
		403
		404	/*
		405	** Read a sequence of (hexa)digits
		406	*/
		407	static int readdigits (RN *rn, int hexa) {
		408	int count = 0;
		409	while ((hexa ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
		410	count++;
		411	return count;
		412	}
		413
		414
		415	/* access to locale "radix character" (decimal point) */
		416	#if !defined(getlocaledecpoint)
		417	#define getlocaledecpoint() (localeconv()->decimal_point[0])
		418	#endif
		419
		420
		421	/*
		422	** Read a number: first reads a valid prefix of a numeral into a buffer.
		423	** Then it calls 'lua_strtonum' to check whether the format is correct
		424	** and to convert it to a Lua number
		425	*/
379	static int read_number (lua_State L, FILE f) {	426	static int read_number (lua_State L, FILE f) {
380	lua_Number d;	427	RN rn;
381	if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {	428	int count = 0;
382	lua_pushnumber(L, d);	429	int hexa = 0;
383	return 1;	430	char decp[2] = ".";
		431	rn.f = f; rn.n = 0;
		432	decp[0] = getlocaledecpoint(); /* get decimal point from locale */
		433	l_lockfile(rn.f);
		434	do { rn.c = l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */
		435	test2(&rn, "-+"); /* optional signal */
		436	if (test2(&rn, "0")) {
		437	if (test2(&rn, "xX")) hexa = 1; /* numeral is hexadecimal */
		438	else count = 1; /* count initial '0' as a valid digit */
384	}	439	}
385	else {	440	count += readdigits(&rn, hexa); /* integral part */
		441	if (test2(&rn, decp)) /* decimal point? */
		442	count += readdigits(&rn, hexa); /* fractionary part */
		443	if (count > 0 && test2(&rn, (hexa ? "pP" : "eE"))) { /* exponent mark? */
		444	test2(&rn, "-+"); /* exponent signal */
		445	readdigits(&rn, 0); /* exponent digits */
		446	}
		447	ungetc(rn.c, rn.f); /* unread look-ahead char */
		448	l_unlockfile(rn.f);
		449	rn.buff[rn.n] = '\0'; /* finish string */
		450	if (lua_strtonum(L, rn.buff)) /* is this a valid number? */
		451	return 1; /* ok */
		452	else { /* invalid format */
386	lua_pushnil(L); /* "result" to be removed */	453	lua_pushnil(L); /* "result" to be removed */
387	return 0; /* read fails */	454	return 0; /* read fails */
388	}	455	}
@@ -455,12 +522,9 @@ static int g_read (lua_State L, FILE f, int first) { · 66 unmodified lines
455	success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);	522	success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
456	}	523	}
457	else {	524	else {
458	const char *p = lua_tostring(L, n);	525	const char *p = luaL_checkstring(L, n);
459	luaL_argcheck(L, p && p[0] == '*', n, "invalid option");	526	if (p == '') p++; /* skip optional '' (for compatibility) /
460	switch (p[1]) {	527	switch (*p) {
461	case 'i': /* integer */
462	success = read_integer(L, f);
463	break;
464	case 'n': /* number */	528	case 'n': /* number */
465	success = read_number(L, f);	529	success = read_number(L, f);
466	break;	530	break;
@@ -507,6 +571,7 @@ static int io_readline (lua_State *L) { · 40 unmodified lines
507	if (isclosed(p)) /* file is already closed? */	571	if (isclosed(p)) /* file is already closed? */
508	return luaL_error(L, "file is already closed");	572	return luaL_error(L, "file is already closed");
509	lua_settop(L , 1);	573	lua_settop(L , 1);
		574	luaL_checkstack(L, n, "too many arguments");
510	for (i = 1; i <= n; i++) /* push arguments to 'g_read' */	575	for (i = 1; i <= n; i++) /* push arguments to 'g_read' */
511	lua_pushvalue(L, lua_upvalueindex(3 + i));	576	lua_pushvalue(L, lua_upvalueindex(3 + i));
512	n = g_read(L, p->f, 2); /* 'n' is number of results */	577	n = g_read(L, p->f, 2); /* 'n' is number of results */

src/llex.c+69−53

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llex.c,v 2.74 2014/02/14 15:23:51 roberto Exp $	2	** $Id: llex.c,v 2.78 2014/05/21 15:22:02 roberto Exp $
3	** Lexical Analyzer	3	** Lexical Analyzer
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -183,12 +183,26 @@ void luaX_setinput (lua_State L, LexState ls, ZIO z, TString source, · 177 unmodified lines
183	*/	183	*/
184		184
185		185
		186	static int check_next1 (LexState *ls, int c) {
		187	if (ls->current == c) {
		188	next(ls);
		189	return 1;
		190	}
		191	else return 0;
		192	}
186		193
187	static int check_next (LexState ls, const char set) {	194
188	if (ls->current == '\0' \|\| !strchr(set, ls->current))	195	/*
189	return 0;	196	** Check whether current char is in set 'set' (with two chars) and
190	save_and_next(ls);	197	** saves it
191	return 1;	198	*/
		199	static int check_next2 (LexState ls, const char set) {
		200	lua_assert(set[2] == '\0');
		201	if (ls->current == set[0] \|\| ls->current == set[1]) {
		202	save_and_next(ls);
		203	return 1;
		204	}
		205	else return 0;
192	}	206	}
193		207
194		208
@@ -196,10 +210,12 @@ static int check_next (LexState ls, const char set) { · 1 unmodified line
196	** change all characters 'from' in buffer to 'to'	210	** change all characters 'from' in buffer to 'to'
197	*/	211	*/
198	static void buffreplace (LexState *ls, char from, char to) {	212	static void buffreplace (LexState *ls, char from, char to) {
199	size_t n = luaZ_bufflen(ls->buff);	213	if (from != to) {
200	char *p = luaZ_buffer(ls->buff);	214	size_t n = luaZ_bufflen(ls->buff);
201	while (n--)	215	char *p = luaZ_buffer(ls->buff);
202	if (p[n] == from) p[n] = to;	216	while (n--)
		217	if (p[n] == from) p[n] = to;
		218	}
203	}	219	}
204		220
205		221
@@ -208,17 +224,17 @@ static void buffreplace (LexState *ls, char from, char to) { · 2 unmodified lines
208	#endif	224	#endif
209		225
210		226
211	#define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e)	227	#define buff2num(b,o) (luaO_str2num(luaZ_buffer(b), o) != 0)
212		228
213	/*	229	/*
214	** in case of format error, try to change decimal point separator to	230	** in case of format error, try to change decimal point separator to
215	** the one defined in the current locale and check again	231	** the one defined in the current locale and check again
216	*/	232	*/
217	static void trydecpoint (LexState ls, SemInfo seminfo) {	233	static void trydecpoint (LexState ls, TValue o) {
218	char old = ls->decpoint;	234	char old = ls->decpoint;
219	ls->decpoint = getlocaledecpoint();	235	ls->decpoint = getlocaledecpoint();
220	buffreplace(ls, old, ls->decpoint); /* try new decimal separator */	236	buffreplace(ls, old, ls->decpoint); /* try new decimal separator */
221	if (!buff2d(ls->buff, &seminfo->r)) {	237	if (!buff2num(ls->buff, o)) {
222	/* format error with correct decimal point: no more options */	238	/* format error with correct decimal point: no more options */
223	buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */	239	buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */
224	lexerror(ls, "malformed number", TK_FLT);	240	lexerror(ls, "malformed number", TK_FLT);
@@ -228,41 +244,37 @@ static void trydecpoint (LexState ls, SemInfo seminfo) { · 3 unmodified lines
228		244
229	/* LUA_NUMBER */	245	/* LUA_NUMBER */
230	/*	246	/*
231	** this function is quite liberal in what it accepts, as 'luaO_str2d'	247	** this function is quite liberal in what it accepts, as 'luaO_str2num'
232	** will reject ill-formed numerals. 'isf' means the numeral is not	248	** will reject ill-formed numerals.
233	** an integer (it has a dot or an exponent).
234	*/	249	*/
235	static int read_numeral (LexState ls, SemInfo seminfo, int isf) {	250	static int read_numeral (LexState ls, SemInfo seminfo) {
		251	TValue obj;
236	const char *expo = "Ee";	252	const char *expo = "Ee";
237	int first = ls->current;	253	int first = ls->current;
238	lua_assert(lisdigit(ls->current));	254	lua_assert(lisdigit(ls->current));
239	save_and_next(ls);	255	save_and_next(ls);
240	if (first == '0' && check_next(ls, "Xx")) /* hexadecimal? */	256	if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */
241	expo = "Pp";	257	expo = "Pp";
242	for (;;) {	258	for (;;) {
243	if (check_next(ls, expo)) { /* exponent part? */	259	if (check_next2(ls, expo)) /* exponent part? */
244	check_next(ls, "+-"); /* optional exponent sign */	260	check_next2(ls, "-+"); /* optional exponent sign */
245	isf = 1;
246	}
247	if (lisxdigit(ls->current))	261	if (lisxdigit(ls->current))
248	save_and_next(ls);	262	save_and_next(ls);
249	else if (ls->current == '.') {	263	else if (ls->current == '.')
250	save_and_next(ls);	264	save_and_next(ls);
251	isf = 1;
252	}
253	else break;	265	else break;
254	}	266	}
255	save(ls, '\0');	267	save(ls, '\0');
256	if (!isf) {	268	buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */
257	if (!luaO_str2int(luaZ_buffer(ls->buff), luaZ_bufflen(ls->buff) - 1,	269	if (!buff2num(ls->buff, &obj)) /* format error? */
258	&seminfo->i))	270	trydecpoint(ls, &obj); /* try to update decimal point separator */
259	lexerror(ls, "malformed number", TK_INT);	271	if (ttisinteger(&obj)) {
		272	seminfo->i = ivalue(&obj);
260	return TK_INT;	273	return TK_INT;
261	}	274	}
262	else {	275	else {
263	buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */	276	lua_assert(ttisfloat(&obj));
264	if (!buff2d(ls->buff, &seminfo->r)) /* format error? */	277	seminfo->r = fltvalue(&obj);
265	trydecpoint(ls, seminfo); /* try to update decimal point separator */
266	return TK_FLT;	278	return TK_FLT;
267	}	279	}
268	}	280	}
@@ -286,15 +298,19 @@ static int skip_sep (LexState *ls) { · 17 unmodified lines
286		298
287		299
288	static void read_long_string (LexState ls, SemInfo seminfo, int sep) {	300	static void read_long_string (LexState ls, SemInfo seminfo, int sep) {
		301	int line = ls->linenumber; /* initial line (for error message) */
289	save_and_next(ls); /* skip 2nd `[' */	302	save_and_next(ls); /* skip 2nd `[' */
290	if (currIsNewline(ls)) /* string starts with a newline? */	303	if (currIsNewline(ls)) /* string starts with a newline? */
291	inclinenumber(ls); /* skip it */	304	inclinenumber(ls); /* skip it */
292	for (;;) {	305	for (;;) {
293	switch (ls->current) {	306	switch (ls->current) {
294	case EOZ:	307	case EOZ: { /* error */
295	lexerror(ls, (seminfo) ? "unfinished long string" :	308	const char *what = (seminfo ? "string" : "comment");
296	"unfinished long comment", TK_EOS);	309	const char *msg = luaO_pushfstring(ls->L,
		310	"unfinished long %s (starting at line %d)", what, line);
		311	lexerror(ls, msg, TK_EOS);
297	break; /* to avoid warnings */	312	break; /* to avoid warnings */
		313	}
298	case ']': {	314	case ']': {
299	if (skip_sep(ls) == sep) {	315	if (skip_sep(ls) == sep) {
300	save_and_next(ls); /* skip 2nd `]' */	316	save_and_next(ls); /* skip 2nd `]' */
@@ -488,35 +504,35 @@ static int llex (LexState ls, SemInfo seminfo) { · 187 unmodified lines
488	}	504	}
489	case '=': {	505	case '=': {
490	next(ls);	506	next(ls);
491	if (ls->current != '=') return '=';	507	if (check_next1(ls, '=')) return TK_EQ;
492	else { next(ls); return TK_EQ; }	508	else return '=';
493	}	509	}
494	case '<': {	510	case '<': {
495	next(ls);	511	next(ls);
496	if (ls->current == '=') { next(ls); return TK_LE; }	512	if (check_next1(ls, '=')) return TK_LE;
497	if (ls->current == '<') { next(ls); return TK_SHL; }	513	else if (check_next1(ls, '<')) return TK_SHL;
498	return '<';	514	else return '<';
499	}	515	}
500	case '>': {	516	case '>': {
501	next(ls);	517	next(ls);
502	if (ls->current == '=') { next(ls); return TK_GE; }	518	if (check_next1(ls, '=')) return TK_GE;
503	if (ls->current == '>') { next(ls); return TK_SHR; }	519	else if (check_next1(ls, '>')) return TK_SHR;
504	return '>';	520	else return '>';
505	}	521	}
506	case '/': {	522	case '/': {
507	next(ls);	523	next(ls);
508	if (ls->current != '/') return '/';	524	if (check_next1(ls, '/')) return TK_IDIV;
509	else { next(ls); return TK_IDIV; }	525	else return '/';
510	}	526	}
511	case '~': {	527	case '~': {
512	next(ls);	528	next(ls);
513	if (ls->current != '=') return '~';	529	if (check_next1(ls, '=')) return TK_NE;
514	else { next(ls); return TK_NE; }	530	else return '~';
515	}	531	}
516	case ':': {	532	case ':': {
517	next(ls);	533	next(ls);
518	if (ls->current != ':') return ':';	534	if (check_next1(ls, ':')) return TK_DBCOLON;
519	else { next(ls); return TK_DBCOLON; }	535	else return ':';
520	}	536	}
521	case '"': case '\'': { /* short literal strings */	537	case '"': case '\'': { /* short literal strings */
522	read_string(ls, ls->current, seminfo);	538	read_string(ls, ls->current, seminfo);
@@ -524,17 +540,17 @@ static int llex (LexState ls, SemInfo seminfo) { · 1 unmodified line
524	}	540	}
525	case '.': { /* '.', '..', '...', or number */	541	case '.': { /* '.', '..', '...', or number */
526	save_and_next(ls);	542	save_and_next(ls);
527	if (check_next(ls, ".")) {	543	if (check_next1(ls, '.')) {
528	if (check_next(ls, "."))	544	if (check_next1(ls, '.'))
529	return TK_DOTS; /* '...' */	545	return TK_DOTS; /* '...' */
530	else return TK_CONCAT; /* '..' */	546	else return TK_CONCAT; /* '..' */
531	}	547	}
532	else if (!lisdigit(ls->current)) return '.';	548	else if (!lisdigit(ls->current)) return '.';
533	else return read_numeral(ls, seminfo, 1);	549	else return read_numeral(ls, seminfo);
534	}	550	}
535	case '0': case '1': case '2': case '3': case '4':	551	case '0': case '1': case '2': case '3': case '4':
536	case '5': case '6': case '7': case '8': case '9': {	552	case '5': case '6': case '7': case '8': case '9': {
537	return read_numeral(ls, seminfo, 0);	553	return read_numeral(ls, seminfo);
538	}	554	}
539	case EOZ: {	555	case EOZ: {
540	return TK_EOS;	556	return TK_EOS;

src/llimits.h+20−13

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llimits.h,v 1.111 2014/03/07 16:19:00 roberto Exp $	2	** $Id: llimits.h,v 1.116 2014/04/15 16:32:49 roberto Exp $
3	** Limits, basic types, and some other `installation-dependent' definitions	3	** Limits, basic types, and some other `installation-dependent' definitions
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -31,8 +31,8 @@ typedef unsigned char lu_byte; · 25 unmodified lines
31	#define MAX_SIZET ((size_t)(~(size_t)0)-2)	31	#define MAX_SIZET ((size_t)(~(size_t)0)-2)
32		32
33	/* maximum size visible for Lua (must be representable in a lua_Integer */	33	/* maximum size visible for Lua (must be representable in a lua_Integer */
34	#define MAX_SIZE (sizeof(size_t) <= sizeof(lua_Integer) ? MAX_SIZET \	34	#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
35	: (size_t)(~(lua_Unsigned)0)-2)	35	: (size_t)(LUA_MAXINTEGER)-2)
36		36
37		37
38	#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2)	38	#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2)
@@ -43,13 +43,6 @@ typedef unsigned char lu_byte; · 4 unmodified lines
43	#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */	43	#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */
44		44
45		45
46	/* maximum value for a lua_Unsigned */
47	#define MAX_UINTEGER (~(lua_Unsigned)0)
48
49	/* minimum and maximum values for lua_Integer */
50	#define MAX_INTEGER ((lua_Integer)(MAX_UINTEGER >> 1))
51	#define MIN_INTEGER (~MAX_INTEGER)
52
53	/*	46	/*
54	** conversion of pointer to integer	47	** conversion of pointer to integer
55	** this is for hashing only; there is no problem if the integer	48	** this is for hashing only; there is no problem if the integer
@@ -67,8 +60,9 @@ typedef unsigned char lu_byte; · 11 unmodified lines
67	typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;	60	typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
68		61
69		62
70	/* result of a `usual argument conversion' over lua_Number */	63	/* types of 'usual argument conversions' for lua_Number and lua_Integer */
71	typedef LUAI_UACNUMBER l_uacNumber;	64	typedef LUAI_UACNUMBER l_uacNumber;
		65	typedef LUAI_UACINT l_uacInt;
72		66
73		67
74	/* internal assertions for in-house debugging */	68	/* internal assertions for in-house debugging */
@@ -111,8 +105,21 @@ typedef LUAI_UACNUMBER l_uacNumber; · 36 unmodified lines
111	#define cast_num(i) cast(lua_Number, (i))	105	#define cast_num(i) cast(lua_Number, (i))
112	#define cast_int(i) cast(int, (i))	106	#define cast_int(i) cast(int, (i))
113	#define cast_uchar(i) cast(unsigned char, (i))	107	#define cast_uchar(i) cast(unsigned char, (i))
114	#define cast_integer(i) cast(lua_Integer, (i))	108
115	#define cast_unsigned(i) cast(lua_Unsigned, (i))	109
		110	/* cast a signed lua_Integer to lua_Unsigned */
		111	#if !defined(l_castS2U)
		112	#define l_castS2U(i) ((lua_Unsigned)(i))
		113	#endif
		114
		115	/*
		116	** cast a lua_Unsigned to a signed lua_Integer; this cast is
		117	** not strict ANSI C, but two-complement architectures should
		118	** work fine.
		119	*/
		120	#if !defined(l_castU2S)
		121	#define l_castU2S(i) ((lua_Integer)(i))
		122	#endif
116		123
117		124
118	/*	125	/*

src/lmathlib.c+175−106

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lmathlib.c,v 1.92 2013/07/22 16:05:53 roberto Exp $	2	** $Id: lmathlib.c,v 1.103 2014/06/18 12:35:53 roberto Exp $
3	** Standard mathematical library	3	** Standard mathematical library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -18,12 +18,28 @@ · 12 unmodified lines
18		18
19		19
20	#undef PI	20	#undef PI
21	#define PI ((lua_Number)(3.1415926535897932384626433832795))	21	#define PI (l_mathop(3.141592653589793238462643383279502884))
22	#define RADIANS_PER_DEGREE ((lua_Number)(PI/180.0))	22
		23
		24	#if !defined(l_rand) /* { */
		25	#if defined(LUA_USE_POSIX)
		26	#define l_rand() random()
		27	#define l_srand(x) srandom(x)
		28	#else
		29	#define l_rand() rand()
		30	#define l_srand(x) srand(x)
		31	#endif
		32	#endif /* } */
23		33
24		34
25	static int math_abs (lua_State *L) {	35	static int math_abs (lua_State *L) {
26	lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));	36	if (lua_isinteger(L, 1)) {
		37	lua_Integer n = lua_tointeger(L, 1);
		38	if (n < 0) n = (lua_Integer)(0u - n);
		39	lua_pushinteger(L, n);
		40	}
		41	else
		42	lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
27	return 1;	43	return 1;
28	}	44	}
29		45
@@ -32,31 +48,16 @@ static int math_sin (lua_State *L) { · 2 unmodified lines
32	return 1;	48	return 1;
33	}	49	}
34		50
35	static int math_sinh (lua_State *L) {
36	lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
37	return 1;
38	}
39
40	static int math_cos (lua_State *L) {	51	static int math_cos (lua_State *L) {
41	lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));	52	lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
42	return 1;	53	return 1;
43	}	54	}
44		55
45	static int math_cosh (lua_State *L) {
46	lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
47	return 1;
48	}
49
50	static int math_tan (lua_State *L) {	56	static int math_tan (lua_State *L) {
51	lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));	57	lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
52	return 1;	58	return 1;
53	}	59	}
54		60
55	static int math_tanh (lua_State *L) {
56	lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
57	return 1;
58	}
59
60	static int math_asin (lua_State *L) {	61	static int math_asin (lua_State *L) {
61	lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));	62	lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
62	return 1;	63	return 1;
@@ -68,56 +69,92 @@ static int math_acos (lua_State *L) { · 5 unmodified lines
68	}	69	}
69		70
70	static int math_atan (lua_State *L) {	71	static int math_atan (lua_State *L) {
71	lua_pushnumber(L, l_mathop(atan)(luaL_checknumber(L, 1)));	72	lua_Number y = luaL_checknumber(L, 1);
		73	lua_Number x = luaL_optnumber(L, 2, 1);
		74	lua_pushnumber(L, l_mathop(atan2)(y, x));
72	return 1;	75	return 1;
73	}	76	}
74		77
75	static int math_atan2 (lua_State *L) {
76	lua_pushnumber(L, l_mathop(atan2)(luaL_checknumber(L, 1),
77	luaL_checknumber(L, 2)));
78	return 1;
79	}
80		78
81	static int math_ceil (lua_State *L) {	79	static int math_ifloor (lua_State *L) {
82	lua_pushnumber(L, l_mathop(ceil)(luaL_checknumber(L, 1)));	80	int valid;
		81	lua_Integer n = lua_tointegerx(L, 1, &valid);
		82	if (valid)
		83	lua_pushinteger(L, n); /* floor computed by Lua */
		84	else {
		85	luaL_checktype(L, 1, LUA_TNUMBER); /* argument must be a number */
		86	lua_pushnil(L); /* number is not convertible to integer */
		87	}
83	return 1;	88	return 1;
84	}	89	}
85		90
86	static int math_floor (lua_State *L) {
87	lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1)));
88	return 1;
89	}
90		91
91	static int math_ifloor (lua_State *L) {	92	static int math_floor (lua_State *L) {
92	int valid;	93	int valid;
93	lua_Integer n = lua_tointegerx(L, 1, &valid);	94	lua_Integer n = lua_tointegerx(L, 1, &valid);
94	if (valid)	95	if (valid)
95	lua_pushinteger(L, n);	96	lua_pushinteger(L, n); /* floor computed by Lua */
		97	else
		98	lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1)));
		99	return 1;
		100	}
		101
		102
		103	static void pushnumint (lua_State *L, lua_Number d) {
		104	lua_Integer n;
		105	if (lua_numtointeger(d, &n)) /* fits in an integer? */
		106	lua_pushinteger(L, n); /* result is integer */
		107	else
		108	lua_pushnumber(L, d); /* result is float */
		109	}
		110
		111
		112	static int math_ceil (lua_State *L) {
		113	if (lua_isinteger(L, 1))
		114	lua_settop(L, 1); /* integer is its own ceil */
96	else {	115	else {
97	luaL_checktype(L, 1, LUA_TNUMBER); /* error if not a number */	116	lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
98	lua_pushnil(L); /* number with invalid integer value */	117	pushnumint(L, d);
99	}	118	}
100	return 1;	119	return 1;
101	}	120	}
102		121
		122
103	static int math_fmod (lua_State *L) {	123	static int math_fmod (lua_State *L) {
104	lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),	124	if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
105	luaL_checknumber(L, 2)));	125	lua_Integer d = lua_tointeger(L, 2);
		126	if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
		127	luaL_argcheck(L, d != 0, 2, "zero");
		128	lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
		129	}
		130	else
		131	lua_pushinteger(L, lua_tointeger(L, 1) % d);
		132	}
		133	else
		134	lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
		135	luaL_checknumber(L, 2)));
106	return 1;	136	return 1;
107	}	137	}
108		138
		139
109	/*	140	/*
110	** next function does not use 'modf', avoiding problems with 'double*'	141	** next function does not use 'modf', avoiding problems with 'double*'
111	** (which is not compatible with 'float*') when lua_Number is not	142	** (which is not compatible with 'float*') when lua_Number is not
112	** 'double'.	143	** 'double'.
113	*/	144	*/
114	static int math_modf (lua_State *L) {	145	static int math_modf (lua_State *L) {
115	lua_Number n = luaL_checknumber(L, 1);	146	if (lua_isinteger(L ,1)) {
116	/* integer part (rounds toward zero) */	147	lua_settop(L, 1); /* number is its own integer part */
117	lua_Number ip = (n < 0) ? -l_mathop(floor)(-n) : l_mathop(floor)(n);	148	lua_pushnumber(L, 0); /* no fractionary part */
118	lua_pushnumber(L, ip);	149	}
119	/* fractionary part (test handles inf/-inf) */	150	else {
120	lua_pushnumber(L, (n == ip) ? 0.0 : (n - ip));	151	lua_Number n = luaL_checknumber(L, 1);
		152	/* integer part (rounds toward zero) */
		153	lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
		154	pushnumint(L, ip);
		155	/* fractionary part (test needed for inf/-inf) */
		156	lua_pushnumber(L, (n == ip) ? 0.0 : (n - ip));
		157	}
121	return 2;	158	return 2;
122	}	159	}
123		160
@@ -127,13 +164,6 @@ static int math_sqrt (lua_State *L) { · 3 unmodified lines
127	return 1;	164	return 1;
128	}	165	}
129		166
130	static int math_pow (lua_State *L) {
131	lua_Number x = luaL_checknumber(L, 1);
132	lua_Number y = luaL_checknumber(L, 2);
133	lua_pushnumber(L, l_mathop(pow)(x, y));
134	return 1;
135	}
136
137	static int math_log (lua_State *L) {	167	static int math_log (lua_State *L) {
138	lua_Number x = luaL_checknumber(L, 1);	168	lua_Number x = luaL_checknumber(L, 1);
139	lua_Number res;	169	lua_Number res;
@@ -141,84 +171,64 @@ static int math_log (lua_State *L) { · 1 unmodified line
141	res = l_mathop(log)(x);	171	res = l_mathop(log)(x);
142	else {	172	else {
143	lua_Number base = luaL_checknumber(L, 2);	173	lua_Number base = luaL_checknumber(L, 2);
144	if (base == (lua_Number)10.0) res = l_mathop(log10)(x);	174	if (base == 10.0) res = l_mathop(log10)(x);
145	else res = l_mathop(log)(x)/l_mathop(log)(base);	175	else res = l_mathop(log)(x)/l_mathop(log)(base);
146	}	176	}
147	lua_pushnumber(L, res);	177	lua_pushnumber(L, res);
148	return 1;	178	return 1;
149	}	179	}
150		180
151	#if defined(LUA_COMPAT_LOG10)
152	static int math_log10 (lua_State *L) {
153	lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
154	return 1;
155	}
156	#endif
157
158	static int math_exp (lua_State *L) {	181	static int math_exp (lua_State *L) {
159	lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));	182	lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
160	return 1;	183	return 1;
161	}	184	}
162		185
163	static int math_deg (lua_State *L) {	186	static int math_deg (lua_State *L) {
164	lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);	187	lua_pushnumber(L, luaL_checknumber(L, 1) * (180.0 / PI));
165	return 1;	188	return 1;
166	}	189	}
167		190
168	static int math_rad (lua_State *L) {	191	static int math_rad (lua_State *L) {
169	lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);	192	lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / 180.0));
170	return 1;	193	return 1;
171	}	194	}
172		195
173	static int math_frexp (lua_State *L) {
174	int e;
175	lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
176	lua_pushinteger(L, e);
177	return 2;
178	}
179
180	static int math_ldexp (lua_State *L) {
181	lua_Number x = luaL_checknumber(L, 1);
182	int ep = luaL_checkint(L, 2);
183	lua_pushnumber(L, l_mathop(ldexp)(x, ep));
184	return 1;
185	}
186
187
188		196
189	static int math_min (lua_State *L) {	197	static int math_min (lua_State *L) {
190	int n = lua_gettop(L); /* number of arguments */	198	int n = lua_gettop(L); /* number of arguments */
191	lua_Number dmin = luaL_checknumber(L, 1);	199	int imin = 1; /* index of current minimum value */
192	int i;	200	int i;
193	for (i=2; i<=n; i++) {	201	luaL_argcheck(L, n >= 1, 1, "value expected");
194	lua_Number d = luaL_checknumber(L, i);	202	for (i = 2; i <= n; i++) {
195	if (d < dmin)	203	if (lua_compare(L, i, imin, LUA_OPLT))
196	dmin = d;	204	imin = i;
197	}	205	}
198	lua_pushnumber(L, dmin);	206	lua_pushvalue(L, imin);
199	return 1;	207	return 1;
200	}	208	}
201		209
202		210
203	static int math_max (lua_State *L) {	211	static int math_max (lua_State *L) {
204	int n = lua_gettop(L); /* number of arguments */	212	int n = lua_gettop(L); /* number of arguments */
205	lua_Number dmax = luaL_checknumber(L, 1);	213	int imax = 1; /* index of current maximum value */
206	int i;	214	int i;
207	for (i=2; i<=n; i++) {	215	luaL_argcheck(L, n >= 1, 1, "value expected");
208	lua_Number d = luaL_checknumber(L, i);	216	for (i = 2; i <= n; i++) {
209	if (d > dmax)	217	if (lua_compare(L, imax, i, LUA_OPLT))
210	dmax = d;	218	imax = i;
211	}	219	}
212	lua_pushnumber(L, dmax);	220	lua_pushvalue(L, imax);
213	return 1;	221	return 1;
214	}	222	}
215		223
216		224	/*
		225	** This function uses 'double' (instead of 'lua_Number') to ensure that
		226	** all bits from 'l_rand' can be represented, and that 'RAND_MAX + 1.0'
		227	** will keep full precision (ensuring that 'r' is always less than 1.0.)
		228	*/
217	static int math_random (lua_State *L) {	229	static int math_random (lua_State *L) {
218	/* the `%' avoids the (rare) case of r==1, and is needed also because on
219	some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
220	lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
221	lua_Integer low, up;	230	lua_Integer low, up;
		231	double r = (double)l_rand() * (1.0 / ((double)RAND_MAX + 1.0));
222	switch (lua_gettop(L)) { /* check number of arguments */	232	switch (lua_gettop(L)) { /* check number of arguments */
223	case 0: { /* no arguments */	233	case 0: { /* no arguments */
224	lua_pushnumber(L, r); /* Number between 0 and 1 */	234	lua_pushnumber(L, r); /* Number between 0 and 1 */
@@ -237,15 +247,17 @@ static int math_random (lua_State *L) { · 12 unmodified lines
237	default: return luaL_error(L, "wrong number of arguments");	247	default: return luaL_error(L, "wrong number of arguments");
238	}	248	}
239	/* random integer in the interval [low, up] */	249	/* random integer in the interval [low, up] */
240	up++; /* change interval to [low, up) */	250	luaL_argcheck(L, low <= up, 1, "interval is empty");
241	luaL_argcheck(L, up - low > 0, 1, "interval is empty");	251	luaL_argcheck(L, (lua_Unsigned)up - low <= (lua_Unsigned)LUA_MAXINTEGER,
242	lua_pushinteger(L, (lua_Integer)(r * (lua_Number)(up - low)) + low);	252	1, "interval too large");
		253	r *= (double)(up - low) + 1.0;
		254	lua_pushinteger(L, (lua_Integer)r + low);
243	return 1;	255	return 1;
244	}	256	}
245		257
246		258
247	static int math_randomseed (lua_State *L) {	259	static int math_randomseed (lua_State *L) {
248	srand(luaL_checkunsigned(L, 1));	260	l_srand((unsigned int)luaL_checkunsigned(L, 1));
249	(void)rand(); /* discard first value to avoid undesirable correlations */	261	(void)rand(); /* discard first value to avoid undesirable correlations */
250	return 0;	262	return 0;
251	}	263	}
@@ -265,39 +277,92 @@ static int math_type (lua_State *L) { · 13 unmodified lines
265	}	277	}
266		278
267		279
		280	/*
		281	** {==================================================================
		282	** Deprecated functions (for compatibility only)
		283	** ===================================================================
		284	*/
		285	#if defined(LUA_COMPAT_MATHLIB)
		286
		287	static int math_cosh (lua_State *L) {
		288	lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
		289	return 1;
		290	}
		291
		292	static int math_sinh (lua_State *L) {
		293	lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
		294	return 1;
		295	}
		296
		297	static int math_tanh (lua_State *L) {
		298	lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
		299	return 1;
		300	}
		301
		302	static int math_pow (lua_State *L) {
		303	lua_Number x = luaL_checknumber(L, 1);
		304	lua_Number y = luaL_checknumber(L, 2);
		305	lua_pushnumber(L, l_mathop(pow)(x, y));
		306	return 1;
		307	}
		308
		309	static int math_frexp (lua_State *L) {
		310	int e;
		311	lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
		312	lua_pushinteger(L, e);
		313	return 2;
		314	}
		315
		316	static int math_ldexp (lua_State *L) {
		317	lua_Number x = luaL_checknumber(L, 1);
		318	int ep = luaL_checkint(L, 2);
		319	lua_pushnumber(L, l_mathop(ldexp)(x, ep));
		320	return 1;
		321	}
		322
		323	static int math_log10 (lua_State *L) {
		324	lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
		325	return 1;
		326	}
		327
		328	#endif
		329	/* }================================================================== */
		330
		331
		332
268	static const luaL_Reg mathlib[] = {	333	static const luaL_Reg mathlib[] = {
269	{"abs", math_abs},	334	{"abs", math_abs},
270	{"acos", math_acos},	335	{"acos", math_acos},
271	{"asin", math_asin},	336	{"asin", math_asin},
272	{"atan2", math_atan2},
273	{"atan", math_atan},	337	{"atan", math_atan},
274	{"ceil", math_ceil},	338	{"ceil", math_ceil},
275	{"cosh", math_cosh},
276	{"cos", math_cos},	339	{"cos", math_cos},
277	{"deg", math_deg},	340	{"deg", math_deg},
278	{"exp", math_exp},	341	{"exp", math_exp},
279	{"floor", math_floor},
280	{"ifloor", math_ifloor},	342	{"ifloor", math_ifloor},
		343	{"floor", math_floor},
281	{"fmod", math_fmod},	344	{"fmod", math_fmod},
282	{"frexp", math_frexp},
283	{"ldexp", math_ldexp},
284	#if defined(LUA_COMPAT_LOG10)
285	{"log10", math_log10},
286	#endif
287	{"log", math_log},	345	{"log", math_log},
288	{"max", math_max},	346	{"max", math_max},
289	{"min", math_min},	347	{"min", math_min},
290	{"modf", math_modf},	348	{"modf", math_modf},
291	{"pow", math_pow},
292	{"rad", math_rad},	349	{"rad", math_rad},
293	{"random", math_random},	350	{"random", math_random},
294	{"randomseed", math_randomseed},	351	{"randomseed", math_randomseed},
295	{"sinh", math_sinh},
296	{"sin", math_sin},	352	{"sin", math_sin},
297	{"sqrt", math_sqrt},	353	{"sqrt", math_sqrt},
298	{"tanh", math_tanh},
299	{"tan", math_tan},	354	{"tan", math_tan},
300	{"type", math_type},	355	{"type", math_type},
		356	#if defined(LUA_COMPAT_MATHLIB)
		357	{"atan2", math_atan},
		358	{"cosh", math_cosh},
		359	{"sinh", math_sinh},
		360	{"tanh", math_tanh},
		361	{"pow", math_pow},
		362	{"frexp", math_frexp},
		363	{"ldexp", math_ldexp},
		364	{"log10", math_log10},
		365	#endif
301	{NULL, NULL}	366	{NULL, NULL}
302	};	367	};
303		368
@@ -311,6 +376,10 @@ LUAMOD_API int luaopen_math (lua_State *L) { · 7 unmodified lines
311	lua_setfield(L, -2, "pi");	376	lua_setfield(L, -2, "pi");
312	lua_pushnumber(L, HUGE_VAL);	377	lua_pushnumber(L, HUGE_VAL);
313	lua_setfield(L, -2, "huge");	378	lua_setfield(L, -2, "huge");
		379	lua_pushinteger(L, LUA_MAXINTEGER);
		380	lua_setfield(L, -2, "maxinteger");
		381	lua_pushinteger(L, LUA_MININTEGER);
		382	lua_setfield(L, -2, "mininteger");
314	return 1;	383	return 1;
315	}	384	}
316		385

src/lobject.c+37−17

 /*
-** $Id: lobject.c,v 2.76 2014/03/21 13:52:33 roberto Exp $
+** $Id: lobject.c,v 2.86 2014/05/12 21:44:17 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
     case LUA_OPSUB:return intop(-, v1, v2);
     case LUA_OPMUL:return intop(*, v1, v2);
     case LUA_OPMOD: return luaV_mod(L, v1, v2);
-    case LUA_OPPOW: return luaV_pow(L, v1, v2);
     case LUA_OPIDIV: return luaV_div(L, v1, v2);
     case LUA_OPBAND: return intop(&, v1, v2);
     case LUA_OPBOR: return intop(|, v1, v2);
     case LUA_OPSHL: return luaV_shiftl(v1, v2);
     case LUA_OPSHR: return luaV_shiftl(v1, -v2);
     case LUA_OPUNM: return intop(-, 0, v1);
-    case LUA_OPBNOT: return intop(^, cast_integer(-1), v1);
+    case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
     default: lua_assert(0); return 0;
   }
 }
     case LUA_OPSUB: return luai_numsub(L, v1, v2);
     case LUA_OPMUL: return luai_nummul(L, v1, v2);
     case LUA_OPDIV: return luai_numdiv(L, v1, v2);
-    case LUA_OPMOD: return luai_nummod(L, v1, v2);
     case LUA_OPPOW: return luai_numpow(L, v1, v2);
     case LUA_OPUNM: return luai_numunm(L, v1);
+    case LUA_OPMOD: {
+      lua_Number m;
+      luai_nummod(L, v1, v2, m);
+      return m;
+    }
     default: lua_assert(0); return 0;
   }
 }
       }
       else break;  /* go to the end */
     }
-    case LUA_OPDIV: {  /* operates only on floats */
+    case LUA_OPDIV: case LUA_OPPOW: {  /* operate only on floats */
       lua_Number n1; lua_Number n2;
       if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
-        setnvalue(res, numarith(L, op, n1, n2));
+        setfltvalue(res, numarith(L, op, n1, n2));
         return;
       }
       else break;  /* go to the end */
         return;
       }
       else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
-        setnvalue(res, numarith(L, op, n1, n2));
+        setfltvalue(res, numarith(L, op, n1, n2));
         return;
       }
       else break;  /* go to the end */
 /* }====================================================== */
-int luaO_str2d (const char *s, size_t len, lua_Number *result) {
+static const char *l_str2d (const char *s, lua_Number *result) {
   char *endptr;
   if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
-    return 0;
+    return NULL;
   else if (strpbrk(s, "xX"))  /* hexa? */
     *result = lua_strx2number(s, &endptr);
   else
     *result = lua_str2number(s, &endptr);
   if (endptr == s) return 0;  /* nothing recognized */
   while (lisspace(cast_uchar(*endptr))) endptr++;
-  return (endptr == s + len);  /* OK if no trailing characters */
+  return (*endptr == '\0' ? endptr : NULL);  /* OK if no trailing characters */
 }
-int luaO_str2int (const char *s, size_t len, lua_Integer *result) {
+static const char *l_str2int (const char *s, lua_Integer *result) {
-  const char *ends = s + len;
   lua_Unsigned a = 0;
   int empty = 1;
   int neg;
     }
   }
   while (lisspace(cast_uchar(*s))) s++;  /* skip trailing spaces */
-  if (empty || s != ends) return 0;  /* something wrong in the numeral */
+  if (empty || *s != '\0') return NULL;  /* something wrong in the numeral */
   else {
-    *result = cast_integer((neg) ? 0u - a : a);
+    *result = l_castU2S((neg) ? 0u - a : a);
-    return 1;
+    return s;
   }
 }
+size_t luaO_str2num (const char *s, TValue *o) {
+  lua_Integer i; lua_Number n;
+  const char *e;
+  if ((e = l_str2int(s, &i)) != NULL) {  /* try as an integer */
+    setivalue(o, i);
+  }
+  else if ((e = l_str2d(s, &n)) != NULL) {  /* else try as a float */
+    setfltvalue(o, n);
+  }
+  else
+    return 0;  /* conversion failed */
+  return (e - s + 1);  /* success; return string size */
+}
 int luaO_utf8esc (char *buff, unsigned int x) {
   int n = 1;  /* number of bytes put in buffer (backwards) */
   if (x < 0x80)  /* ascii? */
       }
       case 'd': {
         setivalue(L->top++, cast_int(va_arg(argp, int)));
+        luaV_tostring(L, L->top - 1);
         break;
       }
       case 'I': {
-        setivalue(L->top++, cast_integer(va_arg(argp, lua_Integer)));
+        setivalue(L->top++, cast(lua_Integer, va_arg(argp, l_uacInt)));
+        luaV_tostring(L, L->top - 1);
         break;
       }
       case 'f': {
-        setnvalue(L->top++, cast_num(va_arg(argp, l_uacNumber)));
+        setfltvalue(L->top++, cast_num(va_arg(argp, l_uacNumber)));
+        luaV_tostring(L, L->top - 1);
         break;
       }
       case 'p': {

src/lobject.h+39−45

 /*
-** $Id: lobject.h,v 2.86 2014/02/19 13:52:42 roberto Exp $
+** $Id: lobject.h,v 2.94 2014/06/19 18:39:36 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
 #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), &val_(o).gc->ts)
+#define rawtsvalue(o)	check_exp(ttisstring(o), rawgco2ts(val_(o).gc))
 #define tsvalue(o)	(&rawtsvalue(o)->tsv)
-#define rawuvalue(o)	check_exp(ttisfulluserdata(o), &val_(o).gc->u)
+#define rawuvalue(o)	check_exp(ttisfulluserdata(o), rawgco2u(val_(o).gc))
 #define uvalue(o)	(&rawuvalue(o)->uv)
-#define clvalue(o)	check_exp(ttisclosure(o), &val_(o).gc->cl)
+#define clvalue(o)	check_exp(ttisclosure(o), gco2cl(val_(o).gc))
-#define clLvalue(o)	check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
+#define clLvalue(o)	check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
-#define clCvalue(o)	check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
+#define clCvalue(o)	check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
 #define fvalue(o)	check_exp(ttislcf(o), val_(o).f)
-#define hvalue(o)	check_exp(ttistable(o), &val_(o).gc->h)
+#define hvalue(o)	check_exp(ttistable(o), gco2t(val_(o).gc))
 #define bvalue(o)	check_exp(ttisboolean(o), val_(o).b)
-#define thvalue(o)	check_exp(ttisthread(o), &val_(o).gc->th)
+#define thvalue(o)	check_exp(ttisthread(o), gco2th(val_(o).gc))
 /* a dead value may get the 'gc' field, but cannot access its contents */
 #define deadvalue(o)	check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
 /* Macros to set values */
 #define settt_(o,t)	((o)->tt_=(t))
-#define setnvalue(obj,x) \
+#define setfltvalue(obj,x) \
   { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_TNUMFLT); }
 #define setivalue(obj,x) \
   { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
 #define setgcovalue(L,obj,x) \
-  { TValue *io=(obj); GCObject *i_g=(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(gch(i_g)->tt)); }
 #define setsvalue(L,obj,x) \
-  { TValue *io=(obj); \
+  { TValue *io = (obj); TString *x_ = (x); \
-    TString *x_ = (x); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tsv.tt)); \
-    val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \
     checkliveness(G(L),io); }
 #define setuvalue(L,obj,x) \
-  { TValue *io=(obj); \
+  { TValue *io = (obj); Udata *x_ = (x); \
-    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \
     checkliveness(G(L),io); }
 #define setthvalue(L,obj,x) \
-  { TValue *io=(obj); \
+  { TValue *io = (obj); lua_State *x_ = (x); \
-    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \
     checkliveness(G(L),io); }
 #define setclLvalue(L,obj,x) \
-  { TValue *io=(obj); \
+  { TValue *io = (obj); LClosure *x_ = (x); \
-    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \
     checkliveness(G(L),io); }
 #define setclCvalue(L,obj,x) \
-  { TValue *io=(obj); \
+  { TValue *io = (obj); CClosure *x_ = (x); \
-    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \
     checkliveness(G(L),io); }
 #define sethvalue(L,obj,x) \
-  { TValue *io=(obj); \
+  { TValue *io = (obj); Table *x_ = (x); \
-    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \
     checkliveness(G(L),io); }
 #define setdeadvalue(obj)	settt_(obj, LUA_TDEADKEY)
 #define setobj(L,obj1,obj2) \
 	{ const TValue *io2=(obj2); TValue *io1=(obj1); \
 	  io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
-	  checkliveness(G(L),io1); }
+	  (void)L; checkliveness(G(L),io1); }
 /*
 #define setsvalue2n	setsvalue
-/* check whether a number is valid (useful only for NaN trick) */
-#define luai_checknum(L,o,c)	{ /* empty */ }
 /*
   struct {
     CommonHeader;
     lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
+    unsigned int hash;
     size_t len;  /* number of characters in string */
     union TString *hnext;  /* linked list for hash table */
-    unsigned int hash;
   } tsv;
 } TString;
 */
 typedef struct Proto {
   CommonHeader;
-  TValue *k;  /* constants used by the function */
+  lu_byte numparams;  /* number of fixed parameters */
-  Instruction *code;
+  lu_byte is_vararg;
-  struct Proto **p;  /* functions defined inside the function */
+  lu_byte maxstacksize;  /* maximum stack used by this function */
-  int *lineinfo;  /* map from opcodes to source lines (debug information) */
-  LocVar *locvars;  /* information about local variables (debug information) */
-  Upvaldesc *upvalues;  /* upvalue information */
-  union Closure *cache;  /* last created closure with this prototype */
-  TString  *source;  /* used for debug information */
   int sizeupvalues;  /* size of 'upvalues' */
   int sizek;  /* size of `k' */
   int sizecode;
   int sizelocvars;
   int linedefined;
   int lastlinedefined;
+  TValue *k;  /* constants used by the function */
+  Instruction *code;
+  struct Proto **p;  /* functions defined inside the function */
+  int *lineinfo;  /* map from opcodes to source lines (debug information) */
+  LocVar *locvars;  /* information about local variables (debug information) */
+  Upvaldesc *upvalues;  /* upvalue information */
+  struct LClosure *cache;  /* last created closure with this prototype */
+  TString  *source;  /* used for debug information */
   GCObject *gclist;
-  lu_byte numparams;  /* number of fixed parameters */
-  lu_byte is_vararg;
-  lu_byte maxstacksize;  /* maximum stack used by this function */
 } Proto;
   CommonHeader;
   lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
   lu_byte lsizenode;  /* log2 of size of `node' array */
-  struct Table *metatable;
+  int sizearray;  /* size of `array' array */
   TValue *array;  /* array part */
   Node *node;
   Node *lastfree;  /* any free position is before this position */
+  struct Table *metatable;
   GCObject *gclist;
-  int sizearray;  /* size of `array' array */
 } Table;
 LUAI_FUNC int luaO_ceillog2 (unsigned int x);
 LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
                            const TValue *p2, TValue *res);
-LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result);
+LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
-LUAI_FUNC int luaO_str2int (const char *s, size_t len, lua_Integer *result);
 LUAI_FUNC int luaO_hexavalue (int c);
 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
                                                        va_list argp);

src/loslib.c+8−2

 /*
-** $Id: loslib.c,v 1.45 2014/03/20 19:18:54 roberto Exp $
+** $Id: loslib.c,v 1.46 2014/04/29 17:05:13 roberto Exp $
 ** Standard Operating System library
 ** See Copyright Notice in lua.h
 */
 #if defined(LUA_USE_POSIX)	/* { */
 #include <unistd.h>
 #define LUA_TMPNAMBUFSIZE	32
+#if !defined(LUA_TMPNAMTEMPLATE)
+#define LUA_TMPNAMTEMPLATE	"/tmp/lua_XXXXXX"
+#endif
 #define lua_tmpnam(b,e) { \
-        strcpy(b, "/tmp/lua_XXXXXX"); \
+        strcpy(b, LUA_TMPNAMTEMPLATE); \
         e = mkstemp(b); \
         if (e != -1) close(e); \
         e = (e == -1); }

src/lparser.c+5−5

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lparser.c,v 2.138 2013/12/30 20:47:58 roberto Exp $	2	** $Id: lparser.c,v 2.139 2014/06/19 18:27:20 roberto Exp $
3	** Lua Parser	3	** Lua Parser
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -1618,17 +1618,17 @@ static void mainfunc (LexState ls, FuncState fs) { · 1612 unmodified lines
1618	}	1618	}
1619		1619
1620		1620
1621	Closure luaY_parser (lua_State L, ZIO z, Mbuffer buff,	1621	LClosure luaY_parser (lua_State L, ZIO z, Mbuffer buff,
1622	Dyndata dyd, const char name, int firstchar) {	1622	Dyndata dyd, const char name, int firstchar) {
1623	LexState lexstate;	1623	LexState lexstate;
1624	FuncState funcstate;	1624	FuncState funcstate;
1625	Closure cl = luaF_newLclosure(L, 1); / create main closure */	1625	LClosure cl = luaF_newLclosure(L, 1); / create main closure */
1626	setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */	1626	setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */
1627	incr_top(L);	1627	incr_top(L);
1628	lexstate.h = luaH_new(L); /* create table for scanner */	1628	lexstate.h = luaH_new(L); /* create table for scanner */
1629	sethvalue(L, L->top, lexstate.h); /* anchor it */	1629	sethvalue(L, L->top, lexstate.h); /* anchor it */
1630	incr_top(L);	1630	incr_top(L);
1631	funcstate.f = cl->l.p = luaF_newproto(L);	1631	funcstate.f = cl->p = luaF_newproto(L);
1632	funcstate.f->source = luaS_new(L, name); /* create and anchor TString */	1632	funcstate.f->source = luaS_new(L, name); /* create and anchor TString */
1633	luaC_objbarrier(L, funcstate.f, funcstate.f->source);	1633	luaC_objbarrier(L, funcstate.f, funcstate.f->source);
1634	lexstate.buff = buff;	1634	lexstate.buff = buff;

src/lparser.h+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lparser.h,v 1.72 2013/08/30 16:01:37 roberto Exp $	2	** $Id: lparser.h,v 1.73 2014/06/19 18:27:20 roberto Exp $
3	** Lua Parser	3	** Lua Parser
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -113,8 +113,8 @@ typedef struct FuncState { · 107 unmodified lines
113	} FuncState;	113	} FuncState;
114		114
115		115
116	LUAI_FUNC Closure luaY_parser (lua_State L, ZIO z, Mbuffer buff,	116	LUAI_FUNC LClosure luaY_parser (lua_State L, ZIO z, Mbuffer buff,
117	Dyndata dyd, const char name, int firstchar);	117	Dyndata dyd, const char name, int firstchar);
118		118
119		119
120	#endif	120	#endif

src/lstate.h+14−14

 /*
-** $Id: lstate.h,v 2.102 2014/02/18 13:46:26 roberto Exp $
+** $Id: lstate.h,v 2.107 2014/06/12 19:07:30 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;
-  ptrdiff_t extra;
   union {
     struct {  /* only for Lua functions */
       StkId base;  /* base for this function */
       const Instruction *savedpc;
     } l;
     struct {  /* only for C functions */
-      int ctx;  /* context info. in case of yields */
+      lua_KFunction k;  /* continuation in case of yields */
-      lua_CFunction k;  /* continuation in case of yields */
       ptrdiff_t old_errfunc;
-      lu_byte old_allowhook;
+      int ctx;  /* context info. in case of yields */
-      lu_byte status;
     } c;
   } u;
 } CallInfo;
 /*
 ** Bits in CallInfo status
 */
-#define CIST_LUA	(1<<0)	/* call is running a Lua function */
+#define CIST_OAH	(1<<0)	/* original value of 'allowhook' */
-#define CIST_HOOKED	(1<<1)	/* call is running a debug hook */
+#define CIST_LUA	(1<<1)	/* call is running a Lua function */
-#define CIST_REENTRY	(1<<2)	/* call is running on same invocation of
+#define CIST_HOOKED	(1<<2)	/* call is running a debug hook */
+#define CIST_REENTRY	(1<<3)	/* call is running on same invocation of
                                    luaV_execute of previous call */
-#define CIST_YIELDED	(1<<3)	/* call reentered after suspension */
 #define CIST_YPCALL	(1<<4)	/* call is a yieldable protected call */
-#define CIST_STAT	(1<<5)	/* call has an error status (pcall) */
+#define CIST_TAIL	(1<<5)	/* call was tail called */
-#define CIST_TAIL	(1<<6)	/* call was tail called */
+#define CIST_HOOKYIELD	(1<<6)	/* last hook called yielded */
-#define CIST_HOOKYIELD	(1<<7)	/* last hook called yielded */
 #define isLua(ci)	((ci)->callstatus & CIST_LUA)
+/* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
+#define setoah(st,v)	((st) = ((st) & ~CIST_OAH) | (v))
+#define getoah(st)	((st) & CIST_OAH)
 /*
 ** `global state', shared by all threads of this state

src/lstring.c+8−4

 /*
-** $Id: lstring.c,v 2.38 2014/03/19 18:51:42 roberto Exp $
+** $Id: lstring.c,v 2.40 2014/06/18 22:59:29 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 static TString *createstrobj (lua_State *L, const char *str, size_t l,
                               int tag, unsigned int h) {
   TString *ts;
+  GCObject *o;
   size_t totalsize;  /* total size of TString object */
   totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
-  ts = &luaC_newobj(L, tag, totalsize)->ts;
+  o = luaC_newobj(L, tag, totalsize);
+  ts = rawgco2ts(o);
   ts->tsv.len = l;
   ts->tsv.hash = h;
   ts->tsv.extra = 0;
 }
-LUAI_FUNC void luaS_remove (lua_State *L, TString *ts) {
+void luaS_remove (lua_State *L, TString *ts) {
   stringtable *tb = &G(L)->strt;
   TString **p = &tb->hash[lmod(ts->tsv.hash, tb->size)];
   while (*p != ts)  /* find previous element */
 Udata *luaS_newudata (lua_State *L, size_t s) {
   Udata *u;
+  GCObject *o;
   if (s > MAX_SIZE - sizeof(Udata))
     luaM_toobig(L);
-  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s)->u;
+  o = luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s);
+  u = rawgco2u(o);
   u->uv.len = s;
   u->uv.metatable = NULL;
   setuservalue(L, u, luaO_nilobject);

src/lstrlib.c+54−47

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lstrlib.c,v 1.189 2014/03/21 14:26:44 roberto Exp $	2	** $Id: lstrlib.c,v 1.198 2014/04/27 14:42:26 roberto Exp $
3	** Standard library for string operations and pattern-matching	3	** Standard library for string operations and pattern-matching
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -104,8 +104,8 @@ static int str_upper (lua_State *L) { · 98 unmodified lines
104		104
105		105
106	/* reasonable limit to avoid arithmetic overflow and strings too big */	106	/* reasonable limit to avoid arithmetic overflow and strings too big */
107	#if INT_MAX / 2 <= 0x10000000	107	#if LUA_MAXINTEGER / 2 <= 0x10000000
108	#define MAXSIZE ((size_t)(INT_MAX / 2))	108	#define MAXSIZE ((size_t)(LUA_MAXINTEGER / 2))
109	#else	109	#else
110	#define MAXSIZE ((size_t)0x10000000)	110	#define MAXSIZE ((size_t)0x10000000)
111	#endif	111	#endif
@@ -946,22 +946,22 @@ static int str_format (lua_State *L) { · 834 unmodified lines
946	** =======================================================	946	** =======================================================
947	*/	947	*/
948		948
949	/* maximum size for the binary representation of an integer */
950	#define MAXINTSIZE 8
951
952		949
953	/* number of bits in a character */	950	/* number of bits in a character */
954	#define NB CHAR_BIT	951	#define NB CHAR_BIT
955		952
956	/* mask for one character (NB ones) */	953	/* mask for one character (NB 1's) */
957	#define MC (((lua_Integer)1 << NB) - 1)	954	#define MC ((1 << NB) - 1)
958
959	/* mask for one character without sign ((NB - 1) ones) */
960	#define SM (((lua_Integer)1 << (NB - 1)) - 1)
961		955
		956	/* mask for one character without sign bit ((NB - 1) 1's) */
		957	#define SM (MC >> 1)
962		958
		959	/* size of a lua_Integer */
963	#define SZINT ((int)sizeof(lua_Integer))	960	#define SZINT ((int)sizeof(lua_Integer))
964		961
		962	/* maximum size for the binary representation of an integer */
		963	#define MAXINTSIZE 12
		964
965		965
966	static union {	966	static union {
967	int dummy;	967	int dummy;
@@ -975,7 +975,7 @@ static int getendian (lua_State *L, int arg) { · 7 unmodified lines
975	if (endian == 'n') / native? */	975	if (endian == 'n') / native? */
976	return nativeendian.little;	976	return nativeendian.little;
977	luaL_argcheck(L, endian == 'l' \|\| endian == 'b', arg,	977	luaL_argcheck(L, endian == 'l' \|\| endian == 'b', arg,
978	"endianess must be 'l'/'b'/'n'");	978	"endianness must be 'l'/'b'/'n'");
979	return (*endian == 'l');	979	return (*endian == 'l');
980	}	980	}
981		981
@@ -989,34 +989,43 @@ static int getintsize (lua_State *L, int arg) { · 7 unmodified lines
989	}	989	}
990		990
991		991
992	static int packint (char *buff, lua_Integer n, int littleendian, int size) {	992	/* mask for all ones in last byte in a lua Integer */
		993	#define HIGHERBYTE ((lua_Unsigned)MC << (NB * (SZINT - 1)))
		994
		995
		996	static int dumpint (char *buff, lua_Integer m, int littleendian, int size) {
993	int i;	997	int i;
		998	lua_Unsigned n = (lua_Unsigned)m;
		999	lua_Unsigned mask = (m >= 0) ? 0 : HIGHERBYTE; /* sign extension */
994	if (littleendian) {	1000	if (littleendian) {
995	for (i = 0; i < size - 1; i++) {	1001	for (i = 0; i < size - 1; i++) {
996	buff[i] = (n & MC);	1002	buff[i] = (n & MC);
997	n >>= NB;	1003	n = (n >> NB) \| mask;
998	}	1004	}
999	}	1005	}
1000	else {	1006	else {
1001	for (i = size - 1; i > 0; i--) {	1007	for (i = size - 1; i > 0; i--) {
1002	buff[i] = (n & MC);	1008	buff[i] = (n & MC);
1003	n >>= NB;	1009	n = (n >> NB) \| mask;
1004	}	1010	}
1005	}	1011	}
1006	buff[i] = (n & MC); /* last byte */	1012	buff[i] = (n & MC); /* last byte */
1007	/* test for overflow: OK if there are only zeros left in higher bytes,	1013	if (size < SZINT) { /* need test for overflow? */
1008	or if there are only ones left and packed number is negative (signal	1014	/* OK if there are only zeros left in higher bytes,
1009	bit, the higher bit in last byte, is one) */	1015	or only ones left (excluding non-signal bits in last byte) */
1010	return ((n & ~MC) == 0 \|\| (n \| SM) == ~(lua_Integer)0);	1016	return ((n & ~(lua_Unsigned)MC) == 0 \|\|
		1017	(n \| SM) == ~(lua_Unsigned)0);
		1018	}
		1019	else return 1; /* no overflow can occur with full size */
1011	}	1020	}
1012		1021
1013		1022
1014	static int packint_l (lua_State *L) {	1023	static int dumpint_l (lua_State *L) {
1015	char buff[MAXINTSIZE];	1024	char buff[MAXINTSIZE];
1016	lua_Integer n = luaL_checkinteger(L, 1);	1025	lua_Integer n = luaL_checkinteger(L, 1);
1017	int size = getintsize(L, 2);	1026	int size = getintsize(L, 2);
1018	int endian = getendian(L, 3);	1027	int endian = getendian(L, 3);
1019	if (packint(buff, n, endian, size))	1028	if (dumpint(buff, n, endian, size))
1020	lua_pushlstring(L, buff, size);	1029	lua_pushlstring(L, buff, size);
1021	else	1030	else
1022	luaL_error(L, "integer does not fit into given size (%d)", size);	1031	luaL_error(L, "integer does not fit into given size (%d)", size);
@@ -1024,15 +1033,13 @@ static int packint_l (lua_State *L) { · 1 unmodified line
1024	}	1033	}
1025		1034
1026		1035
1027	/* mask to check higher-order byte in a Lua integer */
1028	#define HIGHERBYTE (MC << (NB * (SZINT - 1)))
1029
1030	/* mask to check higher-order byte + signal bit of next (lower) byte */	1036	/* mask to check higher-order byte + signal bit of next (lower) byte */
1031	#define HIGHERBYTE1 (HIGHERBYTE \| (HIGHERBYTE >> 1))	1037	#define HIGHERBYTE1 (HIGHERBYTE \| (HIGHERBYTE >> 1))
1032		1038
1033	static int unpackint (const char buff, lua_Integer res,	1039
		1040	static int undumpint (const char buff, lua_Integer res,
1034	int littleendian, int size) {	1041	int littleendian, int size) {
1035	lua_Integer n = 0;	1042	lua_Unsigned n = 0;
1036	int i;	1043	int i;
1037	for (i = 0; i < size; i++) {	1044	for (i = 0; i < size; i++) {
1038	if (i >= SZINT) { /* will throw away a byte? */	1045	if (i >= SZINT) { /* will throw away a byte? */
@@ -1042,23 +1049,23 @@ static int unpackint (const char buff, lua_Integer res, · 3 unmodified lines
1042	its "signal bit" */	1049	its "signal bit" */
1043	if (!((n & HIGHERBYTE1) == 0 \|\| /* zeros for positive number */	1050	if (!((n & HIGHERBYTE1) == 0 \|\| /* zeros for positive number */
1044	(n & HIGHERBYTE1) == HIGHERBYTE1 \|\| /* ones for negative number */	1051	(n & HIGHERBYTE1) == HIGHERBYTE1 \|\| /* ones for negative number */
1045	((n & HIGHERBYTE) == 0 && i == size - 1))) /* leading zero */	1052	(i == size - 1 && (n & HIGHERBYTE) == 0))) /* leading zero */
1046	return 0; /* overflow */	1053	return 0; /* overflow */
1047	}	1054	}
1048	n <<= NB;	1055	n <<= NB;
1049	n \|= (lua_Integer)(unsigned char)buff[littleendian ? size - 1 - i : i];	1056	n \|= (lua_Unsigned)(unsigned char)buff[littleendian ? size - 1 - i : i];
1050	}	1057	}
1051	if (size < SZINT) { /* need sign extension? */	1058	if (size < SZINT) { /* need sign extension? */
1052	lua_Integer mask = (~(lua_Integer)0) << (size*NB - 1);	1059	lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
1053	if (n & mask) /* negative value? */	1060	res = (lua_Integer)((n ^ mask) - mask); / do sign extension */
1054	n \|= mask; /* signal extension */
1055	}	1061	}
1056	*res = n;	1062	else
		1063	*res = (lua_Integer)n;
1057	return 1;	1064	return 1;
1058	}	1065	}
1059		1066
1060		1067
1061	static int unpackint_l (lua_State *L) {	1068	static int undumpint_l (lua_State *L) {
1062	lua_Integer res;	1069	lua_Integer res;
1063	size_t len;	1070	size_t len;
1064	const char *s = luaL_checklstring(L, 1, &len);	1071	const char *s = luaL_checklstring(L, 1, &len);
@@ -1067,7 +1074,7 @@ static int unpackint_l (lua_State *L) { · 2 unmodified lines
1067	int endian = getendian(L, 4);	1074	int endian = getendian(L, 4);
1068	luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,	1075	luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,
1069	"string too short");	1076	"string too short");
1070	if(unpackint(s + pos - 1, &res, endian, size))	1077	if(undumpint(s + pos - 1, &res, endian, size))
1071	lua_pushinteger(L, res);	1078	lua_pushinteger(L, res);
1072	else	1079	else
1073	luaL_error(L, "result does not fit into a Lua integer");	1080	luaL_error(L, "result does not fit into a Lua integer");
@@ -1075,9 +1082,9 @@ static int unpackint_l (lua_State *L) { · 1 unmodified line
1075	}	1082	}
1076		1083
1077		1084
1078	static void correctendianess (lua_State L, char b, int size, int endianarg) {	1085	static void correctendianness (lua_State L, char b, int size, int endianarg) {
1079	int endian = getendian(L, endianarg);	1086	int endian = getendian(L, endianarg);
1080	if (endian != nativeendian.little) { /* not native endianess? */	1087	if (endian != nativeendian.little) { /* not native endianness? */
1081	int i = 0;	1088	int i = 0;
1082	while (i < --size) {	1089	while (i < --size) {
1083	char temp = b[i];	1090	char temp = b[i];
@@ -1097,7 +1104,7 @@ static int getfloatsize (lua_State *L, int arg) { · 13 unmodified lines
1097	}	1104	}
1098		1105
1099		1106
1100	static int packfloat_l (lua_State *L) {	1107	static int dumpfloat_l (lua_State *L) {
1101	float f; double d;	1108	float f; double d;
1102	char pn; / pointer to number */	1109	char pn; / pointer to number */
1103	lua_Number n = luaL_checknumber(L, 1);	1110	lua_Number n = luaL_checknumber(L, 1);
@@ -1113,13 +1120,13 @@ static int packfloat_l (lua_State *L) { · 9 unmodified lines
1113	d = (double)n;	1120	d = (double)n;
1114	pn = (char*)&d;	1121	pn = (char*)&d;
1115	}	1122	}
1116	correctendianess(L, pn, size, 3);	1123	correctendianness(L, pn, size, 3);
1117	lua_pushlstring(L, pn, size);	1124	lua_pushlstring(L, pn, size);
1118	return 1;	1125	return 1;
1119	}	1126	}
1120		1127
1121		1128
1122	static int unpackfloat_l (lua_State *L) {	1129	static int undumpfloat_l (lua_State *L) {
1123	lua_Number res;	1130	lua_Number res;
1124	size_t len;	1131	size_t len;
1125	const char *s = luaL_checklstring(L, 1, &len);	1132	const char *s = luaL_checklstring(L, 1, &len);
@@ -1129,19 +1136,19 @@ static int unpackfloat_l (lua_State *L) { · 3 unmodified lines
1129	"string too short");	1136	"string too short");
1130	if (size == sizeof(lua_Number)) {	1137	if (size == sizeof(lua_Number)) {
1131	memcpy(&res, s + pos - 1, size);	1138	memcpy(&res, s + pos - 1, size);
1132	correctendianess(L, (char*)&res, size, 4);	1139	correctendianness(L, (char*)&res, size, 4);
1133	}	1140	}
1134	else if (size == sizeof(float)) {	1141	else if (size == sizeof(float)) {
1135	float f;	1142	float f;
1136	memcpy(&f, s + pos - 1, size);	1143	memcpy(&f, s + pos - 1, size);
1137	correctendianess(L, (char*)&f, size, 4);	1144	correctendianness(L, (char*)&f, size, 4);
1138	res = (lua_Number)f;	1145	res = (lua_Number)f;
1139	}	1146	}
1140	else { /* native lua_Number may be neither float nor double */	1147	else { /* native lua_Number may be neither float nor double */
1141	double d;	1148	double d;
1142	lua_assert(size == sizeof(double));	1149	lua_assert(size == sizeof(double));
1143	memcpy(&d, s + pos - 1, size);	1150	memcpy(&d, s + pos - 1, size);
1144	correctendianess(L, (char*)&d, size, 4);	1151	correctendianness(L, (char*)&d, size, 4);
1145	res = (lua_Number)d;	1152	res = (lua_Number)d;
1146	}	1153	}
1147	lua_pushnumber(L, res);	1154	lua_pushnumber(L, res);
@@ -1166,10 +1173,10 @@ static const luaL_Reg strlib[] = { · 18 unmodified lines
1166	{"reverse", str_reverse},	1173	{"reverse", str_reverse},
1167	{"sub", str_sub},	1174	{"sub", str_sub},
1168	{"upper", str_upper},	1175	{"upper", str_upper},
1169	{"packfloat", packfloat_l},	1176	{"dumpfloat", dumpfloat_l},
1170	{"packint", packint_l},	1177	{"dumpint", dumpint_l},
1171	{"unpackfloat", unpackfloat_l},	1178	{"undumpfloat", undumpfloat_l},
1172	{"unpackint", unpackint_l},	1179	{"undumpint", undumpint_l},
1173	{NULL, NULL}	1180	{NULL, NULL}
1174	};	1181	};
1175		1182

src/ltable.c+27−21

 /*
-** $Id: ltable.c,v 2.84 2014/01/27 13:34:32 roberto Exp $
+** $Id: ltable.c,v 2.90 2014/06/18 22:59:29 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #include <float.h>
 #include <math.h>
 #include <string.h>
+#include <limits.h>
 #define ltable_c
 #define LUA_CORE
 /*
-** max size of array part is 2^MAXBITS
+** Maximum size of array part (MAXASIZE) is 2^MAXBITS. (SIZEINT is the
+** minimum between size of int and size of LUA_INTEGER; array indices
+** are limited by both types.)
 */
-#if LUAI_BITSINT >= 32
+#define SIZEINT	 \
-#define MAXBITS		30
+  (sizeof(int) < sizeof(LUA_INTEGER) ? sizeof(int) : sizeof(LUA_INTEGER))
-#else
+#define MAXBITS		cast_int(SIZEINT * CHAR_BIT - 2)
-#define MAXBITS		(LUAI_BITSINT-2)
-#endif
 #define MAXASIZE	(1 << MAXBITS)
 #define hashpointer(t,p)	hashmod(t, IntPoint(p))
-/* checks whether a float has a value representable as a lua_Integer
-   (and does the conversion if so) */
-#define numisinteger(x,i) \
-	(((x) == l_floor(x)) && luaV_numtointeger(x, i))
 #define dummynode		(&dummynode_)
 #define isdummy(n)		((n) == dummynode)
 };
+/*
+** Checks whether a float has a value representable as a lua_Integer
+** (and does the conversion if so)
+*/
+static int numisinteger (lua_Number x, lua_Integer *p) {
+  if ((x) == l_floor(x))  /* integral value? */
+    return lua_numtointeger(x, p);  /* try as an integer */
+  else return 0;
+}
 /*
 ** hash for floating-point numbers
 */
 Table *luaH_new (lua_State *L) {
-  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table))->h;
+  GCObject *o = luaC_newobj(L, LUA_TTABLE, sizeof(Table));
+  Table *t = gco2t(o);
   t->metatable = NULL;
   t->flags = cast_byte(~0);
   t->array = NULL;
     if (luai_numisnan(n))
       luaG_runerror(L, "table index is NaN");
     if (numisinteger(n, &k)) {  /* index is int? */
       setivalue(&aux, k);
       key = &aux;  /* insert it as an integer */
     }
   }
       /* yes; move colliding node into free position */
       while (othern + gnext(othern) != mp)  /* find previous */
         othern += gnext(othern);
-      gnext(othern) = f - othern;  /* re-chain with 'f' in place of 'mp' */
+      gnext(othern) = cast_int(f - othern);  /* rechain to point to 'f' */
       *f = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
       if (gnext(mp) != 0) {
-        gnext(f) += mp - f;  /* correct 'next' */
+        gnext(f) += cast_int(mp - f);  /* correct 'next' */
         gnext(mp) = 0;  /* now 'mp' is free */
       }
       setnilvalue(gval(mp));
     else {  /* colliding node is in its own main position */
       /* new node will go into free position */
       if (gnext(mp) != 0)
-        gnext(f) = (mp + gnext(mp)) - f;  /* chain new position */
+        gnext(f) = cast_int((mp + gnext(mp)) - f);  /* chain new position */
       else lua_assert(gnext(f) == 0);
-      gnext(mp) = f - mp;
+      gnext(mp) = cast_int(f - mp);
       mp = f;
     }
   }
 */
 const TValue *luaH_getint (Table *t, lua_Integer key) {
   /* (1 <= key && key <= t->sizearray) */
-  if (cast_unsigned(key - 1) < cast_unsigned(t->sizearray))
+  if (l_castS2U(key - 1) < cast(unsigned int, t->sizearray))
     return &t->array[key - 1];
   else {
     Node *n = hashint(t, key);

src/ltablib.c+27−28

 /*
-** $Id: ltablib.c,v 1.66 2014/03/21 13:52:33 roberto Exp $
+** $Id: ltablib.c,v 1.70 2014/05/16 18:53:25 roberto Exp $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
+#include <limits.h>
 #include <stddef.h>
 #define ltablib_c
 static int tinsert (lua_State *L) {
-  int e = aux_getn(L, 1) + 1;  /* first empty element */
+  lua_Integer e = aux_getn(L, 1) + 1;  /* first empty element */
-  int pos;  /* where to insert new element */
+  lua_Integer pos;  /* where to insert new element */
   switch (lua_gettop(L)) {
     case 2: {  /* called with only 2 arguments */
       pos = e;  /* insert new element at the end */
       break;
     }
     case 3: {
-      int i;
+      lua_Integer i;
-      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
+      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);
 static int tremove (lua_State *L) {
-  int size = aux_getn(L, 1);
+  lua_Integer size = aux_getn(L, 1);
-  int pos = luaL_optint(L, 2, size);
+  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] */
 }
-static void addfield (lua_State *L, luaL_Buffer *b, int i) {
+static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) {
   lua_rawgeti(L, 1, i);
   if (!lua_isstring(L, -1))
     luaL_error(L, "invalid value (%s) at index %d in table for "
 static int tconcat (lua_State *L) {
   luaL_Buffer b;
   size_t lsep;
-  int i, last;
+  lua_Integer i, last;
   const char *sep = luaL_optlstring(L, 2, "", &lsep);
   luaL_checktype(L, 1, LUA_TTABLE);
-  i = luaL_optint(L, 3, 1);
+  i = luaL_optinteger(L, 3, 1);
-  last = luaL_opt(L, luaL_checkint, 4, luaL_len(L, 1));
+  last = luaL_opt(L, luaL_checkinteger, 4, luaL_len(L, 1));
   luaL_buffinit(L, &b);
   for (; i < last; i++) {
     addfield(L, &b, i);
 */
 static int pack (lua_State *L) {
+  int i;
   int n = lua_gettop(L);  /* number of elements to pack */
   lua_createtable(L, n, 1);  /* create result table */
+  lua_insert(L, 1);  /* put it at index 1 */
+  for (i = n; i >= 1; i--)  /* assign elements */
+    lua_rawseti(L, 1, i);
   lua_pushinteger(L, n);
-  lua_setfield(L, -2, "n");  /* t.n = number of elements */
+  lua_setfield(L, 1, "n");  /* t.n = number of elements */
-  if (n > 0) {  /* at least one element? */
-    int i;
-    lua_pushvalue(L, 1);
-    lua_rawseti(L, -2, 1);  /* insert first element */
-    lua_replace(L, 1);  /* move table into index 1 */
-    for (i = n; i >= 2; i--)  /* assign other elements */
-      lua_rawseti(L, 1, i);
-  }
   return 1;  /* return table */
 }
 static int unpack (lua_State *L) {
-  int i, e, n;
+  lua_Integer i, e;
+  lua_Unsigned n;
   luaL_checktype(L, 1, LUA_TTABLE);
-  i = luaL_optint(L, 2, 1);
+  i = luaL_optinteger(L, 2, 1);
-  e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));
+  e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
   if (i > e) return 0;  /* empty range */
-  n = e - i + 1;  /* number of elements */
+  n = (lua_Unsigned)e - i;  /* number of elements minus 1 (avoid overflows) */
-  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arithmetic overflow */
+  if (n >= (unsigned int)INT_MAX  || !lua_checkstack(L, ++n))
     return luaL_error(L, "too many results to unpack");
-  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
+  do {  /* must have at least one element */
-  while (i++ < e)  /* push arg[i + 1...e] */
+    lua_rawgeti(L, 1, i);  /* push arg[i..e] */
-    lua_rawgeti(L, 1, i);
+  } while (i++ < e);
   return n;
 }

src/ltm.c+5−16

 /*
-** $Id: ltm.c,v 2.25 2013/12/30 20:47:58 roberto Exp $
+** $Id: ltm.c,v 2.27 2014/06/10 18:53:18 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
       case TM_CONCAT:
         luaG_concaterror(L, p1, p2);
       case TM_IDIV: case TM_BAND: case TM_BOR: case TM_BXOR:
-      case TM_SHL: case TM_SHR: case TM_BNOT:
+      case TM_SHL: case TM_SHR: case TM_BNOT: {
-        if (ttisnumber(p1) && ttisnumber(p2))
+        lua_Number dummy;
+        if (tonumber(p1, &dummy) && tonumber(p2, &dummy))
           luaG_tointerror(L, p1, p2);
         /* else go through */
+      }
       default:
         luaG_aritherror(L, p1, p2);
     }
 }
-const TValue *luaT_getequalTM (lua_State *L, Table *mt1, Table *mt2) {
-  const TValue *tm1 = fasttm(L, mt1, TM_EQ);
-  const TValue *tm2;
-  if (tm1 == NULL) return NULL;  /* no metamethod */
-  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
-  tm2 = fasttm(L, mt2, TM_EQ);
-  if (tm2 == NULL) return NULL;  /* no metamethod */
-  if (luaV_rawequalobj(tm1, tm2))  /* same metamethods? */
-    return tm1;
-  return NULL;
-}
 int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
                       TMS event) {
   if (!luaT_callbinTM(L, p1, p2, L->top, event))

src/ltm.h+1−2

 /*
-** $Id: ltm.h,v 2.19 2013/12/30 20:47:58 roberto Exp $
+** $Id: ltm.h,v 2.20 2014/06/10 18:53:18 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
                               StkId res, TMS event);
 LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                               StkId res, TMS event);
-LUAI_FUNC const TValue *luaT_getequalTM (lua_State *L, Table *mt1, Table *mt2);
 LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
                                 const TValue *p2, TMS event);

src/lua.c+223−153

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lua.c,v 1.210 2014/02/26 15:27:56 roberto Exp $	2	** $Id: lua.c,v 1.211 2014/06/05 20:42:06 roberto Exp $
3	** Lua stand-alone interpreter	3	** Lua stand-alone interpreter
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -103,17 +103,24 @@ static lua_State *globalL = NULL; · 97 unmodified lines
103	static const char *progname = LUA_PROGNAME;	103	static const char *progname = LUA_PROGNAME;
104		104
105		105
106		106	/*
		107	** Hook set by signal function to stop the interpreter.
		108	*/
107	static void lstop (lua_State L, lua_Debug ar) {	109	static void lstop (lua_State L, lua_Debug ar) {
108	(void)ar; /* unused arg. */	110	(void)ar; /* unused arg. */
109	lua_sethook(L, NULL, 0, 0);	111	lua_sethook(L, NULL, 0, 0); /* reset hook */
110	luaL_error(L, "interrupted!");	112	luaL_error(L, "interrupted!");
111	}	113	}
112		114
113		115
		116	/*
		117	** Function to be called at a C signal. Because a C signal cannot
		118	** just change a Lua state (as there is no proper syncronization),
		119	** this function only sets a hook that, when called, will stop the
		120	** interpreter.
		121	*/
114	static void laction (int i) {	122	static void laction (int i) {
115	signal(i, SIG_DFL); /* if another SIGINT happens before lstop,	123	signal(i, SIG_DFL); /* if another SIGINT happens, terminate process */
116	terminate process (default action) */
117	lua_sethook(globalL, lstop, LUA_MASKCALL \| LUA_MASKRET \| LUA_MASKCOUNT, 1);	124	lua_sethook(globalL, lstop, LUA_MASKCALL \| LUA_MASKRET \| LUA_MASKCOUNT, 1);
118	}	125	}
119		126
@@ -139,27 +146,23 @@ static void print_usage (const char *badoption) { · 19 unmodified lines
139	}	146	}
140		147
141		148
		149	/*
		150	** Prints an error message, adding the program name in front of it
		151	** (if present)
		152	*/
142	static void l_message (const char pname, const char msg) {	153	static void l_message (const char pname, const char msg) {
143	if (pname) luai_writestringerror("%s: ", pname);	154	if (pname) luai_writestringerror("%s: ", pname);
144	luai_writestringerror("%s\n", msg);	155	luai_writestringerror("%s\n", msg);
145	}	156	}
146		157
147		158
		159	/*
		160	** Check whether 'status' is not OK and, if so, prints the error
		161	** message on the top of the stack. Because this function can be called
		162	** unprotected, it only accepts actual strings as error messages. (A
		163	** coercion could raise a memory error.)
		164	*/
148	static int report (lua_State *L, int status) {	165	static int report (lua_State *L, int status) {
149	if (status != LUA_OK && !lua_isnil(L, -1)) {
150	const char *msg = lua_tostring(L, -1);
151	if (msg == NULL) msg = "(error object is not a string)";
152	l_message(progname, msg);
153	lua_pop(L, 1);
154	/* force a complete garbage collection in case of errors */
155	lua_gc(L, LUA_GCCOLLECT, 0);
156	}
157	return status;
158	}
159
160
161	/* the next function is called unprotected, so it must avoid errors */
162	static void finalreport (lua_State *L, int status) {
163	if (status != LUA_OK) {	166	if (status != LUA_OK) {
164	const char *msg = (lua_type(L, -1) == LUA_TSTRING) ? lua_tostring(L, -1)	167	const char *msg = (lua_type(L, -1) == LUA_TSTRING) ? lua_tostring(L, -1)
165	: NULL;	168	: NULL;
@@ -167,31 +170,39 @@ static void finalreport (lua_State *L, int status) { · 1 unmodified line
167	l_message(progname, msg);	170	l_message(progname, msg);
168	lua_pop(L, 1);	171	lua_pop(L, 1);
169	}	172	}
		173	return status;
170	}	174	}
171		175
172		176
173	static int traceback (lua_State *L) {	177	/*
		178	** Message handler to be used to run all chunks
		179	*/
		180	static int msghandler (lua_State *L) {
174	const char *msg = lua_tostring(L, 1);	181	const char *msg = lua_tostring(L, 1);
175	if (msg)	182	if (msg) /* is error object a string? */
176	luaL_traceback(L, L, msg, 1);	183	luaL_traceback(L, L, msg, 1); /* use standard traceback */
177	else if (!lua_isnoneornil(L, 1)) { /* is there an error object? */	184	else if (!lua_isnoneornil(L, 1)) { /* non-string error object? */
178	if (!luaL_callmeta(L, 1, "__tostring")) /* try its 'tostring' metamethod */	185	if (!luaL_callmeta(L, 1, "__tostring")) /* try its 'tostring' metamethod */
179	lua_pushliteral(L, "(no error message)");	186	lua_pushliteral(L, "(no error message)");
180	}	187	} /* else no error object, does nothing */
181	return 1;	188	return 1;
182	}	189	}
183		190
184		191
		192	/*
		193	** Interface to 'lua_pcall', which sets appropriate message function
		194	** and C-signal handler. Used to run all chunks.
		195	*/
185	static int docall (lua_State *L, int narg, int nres) {	196	static int docall (lua_State *L, int narg, int nres) {
186	int status;	197	int status;
187	int base = lua_gettop(L) - narg; /* function index */	198	int base = lua_gettop(L) - narg; /* function index */
188	lua_pushcfunction(L, traceback); /* push traceback function */	199	lua_pushcfunction(L, msghandler); /* push message handler */
189	lua_insert(L, base); /* put it under chunk and args */	200	lua_insert(L, base); /* put it under function and args */
190	globalL = L; /* to be available to 'laction' */	201	globalL = L; /* to be available to 'laction' */
191	signal(SIGINT, laction);	202	signal(SIGINT, laction); /* set C-signal handler */
192	status = lua_pcall(L, narg, nres, base);	203	status = lua_pcall(L, narg, nres, base);
193	signal(SIGINT, SIG_DFL);	204	signal(SIGINT, SIG_DFL); /* reset C-signal handler */
194	lua_remove(L, base); /* remove traceback function */	205	lua_remove(L, base); /* remove message handler from the stack */
195	return status;	206	return status;
196	}	207	}
197		208
@@ -202,38 +213,47 @@ static void print_version (void) { · 4 unmodified lines
202	}	213	}
203		214
204		215
205	static int getargs (lua_State L, char *argv, int n) {	216	/*
206	int narg;	217	** Create the 'arg' table, which stores all arguments from the
207	int i;	218	** command line ('argv'). It should be aligned so that, at index 0,
208	int argc = 0;	219	** it has 'argv[script]', which is the script name. The arguments
209	while (argv[argc]) argc++; /* count total number of arguments */	220	** to the script (everything after 'script') go to positive indices;
210	narg = argc - (n + 1); /* number of arguments to the script */	221	** other arguments (before the script name) go to negative indices.
211	luaL_checkstack(L, narg + 3, "too many arguments to script");	222	** If there is no script name, assume interpreter's name as base.
212	for (i=n+1; i < argc; i++)	223	*/
213	lua_pushstring(L, argv[i]);	224	static void createargtable (lua_State L, char *argv, int argc, int script) {
214	lua_createtable(L, narg, n + 1);	225	int i, narg;
215	for (i=0; i < argc; i++) {	226	if (script == argc) script = 0; /* no script name? */
		227	narg = argc - (script + 1); /* number of positive indices */
		228	lua_createtable(L, narg, script + 1);
		229	for (i = 0; i < argc; i++) {
216	lua_pushstring(L, argv[i]);	230	lua_pushstring(L, argv[i]);
217	lua_rawseti(L, -2, i - n);	231	lua_rawseti(L, -2, i - script);
218	}	232	}
219	return narg;	233	lua_setglobal(L, "arg");
220	}	234	}
221		235
222		236
223	static int dofile (lua_State L, const char name) {	237	static int dochunk (lua_State *L, int status) {
224	int status = luaL_loadfile(L, name);
225	if (status == LUA_OK) status = docall(L, 0, 0);	238	if (status == LUA_OK) status = docall(L, 0, 0);
226	return report(L, status);	239	return report(L, status);
227	}	240	}
228		241
229		242
		243	static int dofile (lua_State L, const char name) {
		244	return dochunk(L, luaL_loadfile(L, name));
		245	}
		246
		247
230	static int dostring (lua_State L, const char s, const char *name) {	248	static int dostring (lua_State L, const char s, const char *name) {
231	int status = luaL_loadbuffer(L, s, strlen(s), name);	249	return dochunk(L, luaL_loadbuffer(L, s, strlen(s), name));
232	if (status == LUA_OK) status = docall(L, 0, 0);
233	return report(L, status);
234	}	250	}
235		251
236		252
		253	/*
		254	** Calls 'require(name)' and stores the result in a global variable
		255	** with the given name.
		256	*/
237	static int dolibrary (lua_State L, const char name) {	257	static int dolibrary (lua_State L, const char name) {
238	int status;	258	int status;
239	lua_getglobal(L, "require");	259	lua_getglobal(L, "require");
@@ -245,6 +265,9 @@ static int dolibrary (lua_State L, const char name) { · 5 unmodified lines
245	}	265	}
246		266
247		267
		268	/*
		269	** Returns the string to be used as a prompt by the interpreter.
		270	*/
248	static const char get_prompt (lua_State L, int firstline) {	271	static const char get_prompt (lua_State L, int firstline) {
249	const char *p;	272	const char *p;
250	lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2");	273	lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2");
@@ -257,6 +280,12 @@ static const char get_prompt (lua_State L, int firstline) { · 6 unmodified lines
257	#define EOFMARK "<eof>"	280	#define EOFMARK "<eof>"
258	#define marklen (sizeof(EOFMARK)/sizeof(char) - 1)	281	#define marklen (sizeof(EOFMARK)/sizeof(char) - 1)
259		282
		283
		284	/*
		285	** Check whether 'status' signals a syntax error and the error
		286	** message at the top of the stack ends with the above mark for
		287	** incoplete statements.
		288	*/
260	static int incomplete (lua_State *L, int status) {	289	static int incomplete (lua_State *L, int status) {
261	if (status == LUA_ERRSYNTAX) {	290	if (status == LUA_ERRSYNTAX) {
262	size_t lmsg;	291	size_t lmsg;
@@ -270,7 +299,9 @@ static int incomplete (lua_State *L, int status) { · 7 unmodified lines
270	}	299	}
271		300
272		301
273	/* prompt the user, read a line, and push it into the Lua stack */	302	/*
		303	** Prompt the user, read a line, and push it into the Lua stack.
		304	*/
274	static int pushline (lua_State *L, int firstline) {	305	static int pushline (lua_State *L, int firstline) {
275	char buffer[LUA_MAXINPUT];	306	char buffer[LUA_MAXINPUT];
276	char *b = buffer;	307	char *b = buffer;
@@ -292,8 +323,10 @@ static int pushline (lua_State *L, int firstline) { · 15 unmodified lines
292	}	323	}
293		324
294		325
295	/* try to compile line on the stack as 'return <line>'; on return, stack	326	/*
296	has either compiled chunk or original line (if compilation failed) */	327	** Try to compile line on the stack as 'return <line>'; on return, stack
		328	** has either compiled chunk or original line (if compilation failed).
		329	*/
297	static int addreturn (lua_State *L) {	330	static int addreturn (lua_State *L) {
298	int status;	331	int status;
299	size_t len; const char *line;	332	size_t len; const char *line;
@@ -309,14 +342,16 @@ static int addreturn (lua_State *L) { · 9 unmodified lines
309	}	342	}
310		343
311		344
312	/* read multiple lines until a complete line */	345	/*
		346	** Read multiple lines until a complete Lua statement
		347	*/
313	static int multiline (lua_State *L) {	348	static int multiline (lua_State *L) {
314	for (;;) { /* repeat until gets a complete line */	349	for (;;) { /* repeat until gets a complete statement */
315	size_t len;	350	size_t len;
316	const char line = lua_tolstring(L, 1, &len); / get what it has */	351	const char line = lua_tolstring(L, 1, &len); / get what it has */
317	int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */	352	int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */
318	if (!incomplete(L, status) \|\| !pushline(L, 0))	353	if (!incomplete(L, status) \|\| !pushline(L, 0))
319	return status; /* cannot/should not try to add continuation line */	354	return status; /* cannot or should not try to add continuation line */
320	lua_pushliteral(L, "\n"); /* add newline... */	355	lua_pushliteral(L, "\n"); /* add newline... */
321	lua_insert(L, -2); /* ...between the two lines */	356	lua_insert(L, -2); /* ...between the two lines */
322	lua_concat(L, 3); /* join them */	357	lua_concat(L, 3); /* join them */
@@ -324,6 +359,12 @@ static int multiline (lua_State *L) { · 1 unmodified line
324	}	359	}
325		360
326		361
		362	/*
		363	** Read a line and try to load (compile) it first as an expression (by
		364	** adding "return " in front of it) and second as a statement. Return
		365	** the final status of load/call with the resulting function (if any)
		366	** in the top of the stack.
		367	*/
327	static int loadline (lua_State *L) {	368	static int loadline (lua_State *L) {
328	int status;	369	int status;
329	lua_settop(L, 0);	370	lua_settop(L, 0);
@@ -331,29 +372,43 @@ static int loadline (lua_State *L) { · 1 unmodified line
331	return -1; /* no input */	372	return -1; /* no input */
332	if ((status = addreturn(L)) != LUA_OK) /* 'return ...' did not work? */	373	if ((status = addreturn(L)) != LUA_OK) /* 'return ...' did not work? */
333	status = multiline(L); /* try as command, maybe with continuation lines */	374	status = multiline(L); /* try as command, maybe with continuation lines */
334	lua_saveline(L, 1);	375	lua_saveline(L, 1); /* keep history */
335	lua_remove(L, 1); /* remove line */	376	lua_remove(L, 1); /* remove line from the stack */
336	lua_assert(lua_gettop(L) == 1);	377	lua_assert(lua_gettop(L) == 1);
337	return status;	378	return status;
338	}	379	}
339		380
340		381
341	static void dotty (lua_State *L) {	382	/*
		383	** Prints (calling the Lua 'print' function) any values on the stack
		384	*/
		385	static void l_print (lua_State *L) {
		386	int n = lua_gettop(L);
		387	if (n > 0) { /* any result to be printed? */
		388	luaL_checkstack(L, LUA_MINSTACK, "too many results to print");
		389	lua_getglobal(L, "print");
		390	lua_insert(L, 1);
		391	if (lua_pcall(L, n, 0, 0) != LUA_OK)
		392	l_message(progname, lua_pushfstring(L,
		393	"error calling " LUA_QL("print") " (%s)",
		394	lua_tostring(L, -1)));
		395	}
		396	}
		397
		398
		399	/*
		400	** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and
		401	** print any results.
		402	*/
		403	static void doREPL (lua_State *L) {
342	int status;	404	int status;
343	const char *oldprogname = progname;	405	const char *oldprogname = progname;
344	progname = NULL;	406	progname = NULL; /* no 'progname' on errors in interactive mode */
345	while ((status = loadline(L)) != -1) {	407	while ((status = loadline(L)) != -1) {
346	if (status == LUA_OK) status = docall(L, 0, LUA_MULTRET);	408	if (status == LUA_OK)
347	report(L, status);	409	status = docall(L, 0, LUA_MULTRET);
348	if (status == LUA_OK && lua_gettop(L) > 0) { /* any result to print? */	410	if (status == LUA_OK) l_print(L);
349	luaL_checkstack(L, LUA_MINSTACK, "too many results to print");	411	else report(L, status);
350	lua_getglobal(L, "print");
351	lua_insert(L, 1);
352	if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != LUA_OK)
353	l_message(progname, lua_pushfstring(L,
354	"error calling " LUA_QL("print") " (%s)",
355	lua_tostring(L, -1)));
356	}
357	}	412	}
358	lua_settop(L, 0); /* clear stack */	413	lua_settop(L, 0); /* clear stack */
359	luai_writeline();	414	luai_writeline();
@@ -361,97 +416,109 @@ static void dotty (lua_State *L) { · 1 unmodified line
361	}	416	}
362		417
363		418
		419	/*
		420	** Push on the stack 'n' strings from 'argv'
		421	*/
		422	static void pushargs (lua_State L, char *argv, int n) {
		423	int i;
		424	luaL_checkstack(L, n + 3, "too many arguments to script");
		425	for (i = 1; i < n; i++) /* skip 0 (the script name) */
		426	lua_pushstring(L, argv[i]);
		427	}
		428
		429
364	static int handle_script (lua_State L, char *argv, int n) {	430	static int handle_script (lua_State L, char *argv, int n) {
365	int status;	431	int status;
366	const char *fname;	432	const char *fname = argv[0];
367	int narg = getargs(L, argv, n); /* collect arguments */	433	if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
368	lua_setglobal(L, "arg");
369	fname = argv[n];
370	if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0)
371	fname = NULL; /* stdin */	434	fname = NULL; /* stdin */
372	status = luaL_loadfile(L, fname);	435	status = luaL_loadfile(L, fname);
373	lua_insert(L, -(narg+1));	436	if (status == LUA_OK) {
374	if (status == LUA_OK)	437	pushargs(L, argv, n); /* push arguments to script */
375	status = docall(L, narg, LUA_MULTRET);	438	status = docall(L, n - 1, LUA_MULTRET);
376	else	439	}
377	lua_pop(L, narg);
378	return report(L, status);	440	return report(L, status);
379	}	441	}
380		442
381		443
382	/* check that argument has no extra characters at the end */
383	#define noextrachars(x) {if ((x)[2] != '\0') return -1;}
384
385
386	/* indices of various argument indicators in array args */
387	#define has_i 0 /* -i */
388	#define has_v 1 /* -v */
389	#define has_e 2 /* -e */
390	#define has_E 3 /* -E */
391
392	#define num_has 4 /* number of 'has_' /
393		444
		445	/* bits of various argument indicators in 'args' */
		446	#define has_error 1 /* bad option */
		447	#define has_i 2 /* -i */
		448	#define has_v 4 /* -v */
		449	#define has_e 8 /* -e */
		450	#define has_E 16 /* -E */
394		451
395	static int collectargs (char *argv, int args) {	452	/*
		453	** Traverses all arguments from 'argv', returning a mask with those
		454	** needed before running any Lua code (or an error code if it finds
		455	** any invalid argument). 'first' returns the first not-handled argument
		456	** (either the script name or a bad argument in case of error).
		457	*/
		458	static int collectargs (char *argv, int first) {
		459	int args = 0;
396	int i;	460	int i;
397	for (i = 1; argv[i] != NULL; i++) {	461	for (i = 1; argv[i] != NULL; i++) {
		462	*first = i;
398	if (argv[i][0] != '-') /* not an option? */	463	if (argv[i][0] != '-') /* not an option? */
399	return i;	464	return args; /* stop handling options */
400	switch (argv[i][1]) { /* option */	465	switch (argv[i][1]) { /* else check option */
401	case '-':	466	case '-': /* '--' */
402	noextrachars(argv[i]);	467	if (argv[i][2] != '\0') /* extra characters after '--'? */
403	return (argv[i+1] != NULL ? i+1 : 0);	468	return has_error; /* invalid option */
404	case '\0':	469	*first = i + 1;
405	return i;	470	return args;
		471	case '\0': /* '-' */
		472	return args; /* script "name" is '-' */
406	case 'E':	473	case 'E':
407	args[has_E] = 1;	474	if (argv[i][2] != '\0') /* extra characters after 1st? */
		475	return has_error; /* invalid option */
		476	args \|= has_E;
408	break;	477	break;
409	case 'i':	478	case 'i':
410	noextrachars(argv[i]);	479	args \|= has_i; /* goes through (-i implies -v) */
411	args[has_i] = 1; /* go through */
412	case 'v':	480	case 'v':
413	noextrachars(argv[i]);	481	if (argv[i][2] != '\0') /* extra characters after 1st? */
414	args[has_v] = 1;	482	return has_error; /* invalid option */
		483	args \|= has_v;
415	break;	484	break;
416	case 'e':	485	case 'e':
417	args[has_e] = 1; /* go through */	486	args \|= has_e; /* go through */
418	case 'l': /* both options need an argument */	487	case 'l': /* both options need an argument */
419	if (argv[i][2] == '\0') { /* no concatenated argument? */	488	if (argv[i][2] == '\0') { /* no concatenated argument? */
420	i++; /* try next 'argv' */	489	i++; /* try next 'argv' */
421	if (argv[i] == NULL \|\| argv[i][0] == '-')	490	if (argv[i] == NULL \|\| argv[i][0] == '-')
422	return -(i - 1); /* no next argument or it is another option */	491	return has_error; /* no next argument or it is another option */
423	}	492	}
424	break;	493	break;
425	default: /* invalid option; return its index... */	494	default: /* invalid option */
426	return -i; /* ...as a negative value */	495	return has_error;
427	}	496	}
428	}	497	}
429	return 0;	498	first = i; / no script name */
		499	return args;
430	}	500	}
431		501
432		502
		503	/*
		504	** Processes options 'e' and 'l', which involve running Lua code.
		505	** Returns 0 if some code raises an error.
		506	*/
433	static int runargs (lua_State L, char *argv, int n) {	507	static int runargs (lua_State L, char *argv, int n) {
434	int i;	508	int i;
435	for (i = 1; i < n; i++) {	509	for (i = 1; i < n; i++) {
436	lua_assert(argv[i][0] == '-');	510	int status;
437	switch (argv[i][1]) { /* option */	511	int option = argv[i][1];
438	case 'e': {	512	lua_assert(argv[i][0] == '-'); /* already checked */
439	const char *chunk = argv[i] + 2;	513	if (option == 'e' \|\| option == 'l') {
440	if (*chunk == '\0') chunk = argv[++i];	514	const char extra = argv[i] + 2; / both options need an argument */
441	lua_assert(chunk != NULL);	515	if (*extra == '\0') extra = argv[++i];
442	if (dostring(L, chunk, "=(command line)") != LUA_OK)	516	lua_assert(extra != NULL);
443	return 0;	517	if (option == 'e')
444	break;	518	status = dostring(L, extra, "=(command line)");
445	}	519	else
446	case 'l': {	520	status = dolibrary(L, extra);
447	const char *filename = argv[i] + 2;	521	if (status != LUA_OK) return 0;
448	if (*filename == '\0') filename = argv[++i];
449	lua_assert(filename != NULL);
450	if (dolibrary(L, filename) != LUA_OK)
451	return 0; /* stop if file fails */
452	break;
453	}
454	default: break;
455	}	522	}
456	}	523	}
457	return 1;	524	return 1;
@@ -473,40 +540,44 @@ static int handle_luainit (lua_State *L) { · 15 unmodified lines
473	}	540	}
474		541
475		542
		543	/*
		544	** Main body of stand-alone interpreter (to be called in protected mode).
		545	** Reads the options and handles them all.
		546	*/
476	static int pmain (lua_State *L) {	547	static int pmain (lua_State *L) {
477	int argc = (int)lua_tointeger(L, 1);	548	int argc = (int)lua_tointeger(L, 1);
478	char argv = (char )lua_touserdata(L, 2);	549	char argv = (char )lua_touserdata(L, 2);
479	int script;	550	int script;
480	int args[num_has];	551	int args = collectargs(argv, &script);
481	args[has_i] = args[has_v] = args[has_e] = args[has_E] = 0;	552	luaL_checkversion(L); /* check that interpreter has correct version */
482	if (argv[0] && argv[0][0]) progname = argv[0];	553	if (argv[0] && argv[0][0]) progname = argv[0];
483	script = collectargs(argv, args);	554	if (args == has_error) { /* bad arg? */
484	if (script < 0) { /* invalid arg? */	555	print_usage(argv[script]); /* 'script' has index of bad arg. */
485	print_usage(argv[-script]);
486	return 0;	556	return 0;
487	}	557	}
488	if (args[has_v]) print_version();	558	if (args & has_v) /* option '-v'? */
489	if (args[has_E]) { /* option '-E'? */	559	print_version();
		560	if (args & has_E) { /* option '-E'? */
490	lua_pushboolean(L, 1); /* signal for libraries to ignore env. vars. */	561	lua_pushboolean(L, 1); /* signal for libraries to ignore env. vars. */
491	lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");	562	lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
492	}	563	}
493	/* open standard libraries */	564	luaL_openlibs(L); /* open standard libraries */
494	luaL_checkversion(L);	565	createargtable(L, argv, argc, script); /* create table 'arg' */
495	lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */	566	if (!(args & has_E)) { /* no option '-E'? */
496	luaL_openlibs(L); /* open libraries */	567	if (handle_luainit(L) != LUA_OK) /* run LUA_INIT */
497	lua_gc(L, LUA_GCRESTART, 0);	568	return 0; /* error running LUA_INIT */
498	if (!args[has_E] && handle_luainit(L) != LUA_OK)	569	}
499	return 0; /* error running LUA_INIT */	570	if (!runargs(L, argv, script)) /* execute arguments -e and -l */
500	/* execute arguments -e and -l */	571	return 0; /* something failed */
501	if (!runargs(L, argv, (script > 0) ? script : argc)) return 0;	572	if (script < argc && /* execute main script (if there is one) */
502	/* execute main script (if there is one) */	573	handle_script(L, argv + script, argc - script) != LUA_OK)
503	if (script && handle_script(L, argv, script) != LUA_OK) return 0;	574	return 0;
504	if (args[has_i]) /* -i option? */	575	if (args & has_i) /* -i option? */
505	dotty(L);	576	doREPL(L); /* do read-eval-print loop */
506	else if (script == 0 && !args[has_e] && !args[has_v]) { /* no arguments? */	577	else if (script == argc && !(args & (has_e \| has_v))) { /* no arguments? */
507	if (lua_stdin_is_tty()) {	578	if (lua_stdin_is_tty()) { /* running in interactive mode? */
508	print_version();	579	print_version();
509	dotty(L);	580	doREPL(L); /* do read-eval-print loop */
510	}	581	}
511	else dofile(L, NULL); /* executes stdin as a file */	582	else dofile(L, NULL); /* executes stdin as a file */
512	}	583	}
@@ -522,13 +593,12 @@ int main (int argc, char **argv) { · 9 unmodified lines
522	l_message(argv[0], "cannot create state: not enough memory");	593	l_message(argv[0], "cannot create state: not enough memory");
523	return EXIT_FAILURE;	594	return EXIT_FAILURE;
524	}	595	}
525	/* call 'pmain' in protected mode */	596	lua_pushcfunction(L, &pmain); /* to call 'pmain' in protected mode */
526	lua_pushcfunction(L, &pmain);
527	lua_pushinteger(L, argc); /* 1st argument */	597	lua_pushinteger(L, argc); /* 1st argument */
528	lua_pushlightuserdata(L, argv); /* 2nd argument */	598	lua_pushlightuserdata(L, argv); /* 2nd argument */
529	status = lua_pcall(L, 2, 1, 0);	599	status = lua_pcall(L, 2, 1, 0); /* do the call */
530	result = lua_toboolean(L, -1); /* get result */	600	result = lua_toboolean(L, -1); /* get result */
531	finalreport(L, status);	601	report(L, status);
532	lua_close(L);	602	lua_close(L);
533	return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;	603	return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
534	}	604	}

src/lua.h+25−14

 /*
-** $Id: lua.h,v 1.302 2014/03/20 19:42:35 roberto Exp $
+** $Id: lua.h,v 1.307 2014/06/10 17:41:38 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 (work2)"
+#define LUA_VERSION_RELEASE	"0 (work3)"
 #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
 LUA_API int   (lua_gettop) (lua_State *L);
 LUA_API void  (lua_settop) (lua_State *L, int idx);
 LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
-LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_rotate) (lua_State *L, int idx, int n);
-LUA_API void  (lua_insert) (lua_State *L, int idx);
 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 void  (lua_createtable) (lua_State *L, int narr, int nrec);
 LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
 LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
-LUA_API void  (lua_getuservalue) (lua_State *L, int idx);
+LUA_API int  (lua_getuservalue) (lua_State *L, int idx);
 /*
 ** 'load' and 'call' functions (load and run Lua code)
 */
 LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
-                           lua_CFunction k);
+                           lua_KFunction k);
 #define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
-LUA_API int   (lua_getctx) (lua_State *L, int *ctx);
 LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
-                            int ctx, lua_CFunction k);
+                            int 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_CFunction k);
+                           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);
 LUA_API int  (lua_status) (lua_State *L);
+LUA_API int lua_isyieldable (lua_State *L);
 /*
 ** garbage-collection function and options
 LUA_API void  (lua_concat) (lua_State *L, int n);
 LUA_API void  (lua_len)    (lua_State *L, int idx);
-LUA_API int   (lua_strtonum) (lua_State *L, const char *s, size_t len);
+LUA_API size_t   (lua_strtonum) (lua_State *L, const char *s);
 LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
 LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
 ** ===============================================================
 */
-#define lua_tonumber(L,i)	lua_tonumberx(L,i,NULL)
+#define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
-#define lua_tointeger(L,i)	lua_tointegerx(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_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
 #define lua_pop(L,n)		lua_settop(L, -(n)-1)
 #define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+#define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
+#define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
 /*
 ** {======================================================================

src/luac.c+15−8

  return EXIT_SUCCESS;
 }
-#define nvalue(x) ((lua_Number)0)
-#define ttypenv(x) ttnov(x)
 /*
-** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $
+** $Id: print.c,v 1.73 2014/06/12 02:41:25 lhf Exp $
 ** print bytecodes
 ** See Copyright Notice in lua.h
 */
 static void PrintConstant(const Proto* f, int i)
 {
  const TValue* o=&f->k[i];
- switch (ttypenv(o))
+ switch (ttype(o))
  {
   case LUA_TNIL:
 	printf("nil");
   case LUA_TBOOLEAN:
 	printf(bvalue(o) ? "true" : "false");
 	break;
-  case LUA_TNUMBER:
+  case LUA_TNUMFLT:
-	printf(LUA_NUMBER_FMT,nvalue(o));
+	printf(LUA_NUMBER_FMT,fltvalue(o));
 	break;
-  case LUA_TSTRING:
+  case LUA_TNUMINT:
+	printf(LUA_INTEGER_FMT,ivalue(o));
+	break;
+  case LUA_TSHRSTR: case LUA_TLNGSTR:
 	PrintString(rawtsvalue(o));
 	break;
   default:				/* cannot happen */
    case OP_ADD:
    case OP_SUB:
    case OP_MUL:
-   case OP_DIV:
    case OP_POW:
+   case OP_DIV:
+   case OP_IDIV:
+   case OP_BAND:
+   case OP_BOR:
+   case OP_BXOR:
+   case OP_SHL:
+   case OP_SHR:
    case OP_EQ:
    case OP_LT:
    case OP_LE:

src/luaconf.h+131−41

 /*
-** $Id: luaconf.h,v 1.193 2014/03/21 14:27:16 roberto Exp $
+** $Id: luaconf.h,v 1.207 2014/06/10 19:21:20 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
 /*
 ** ===================================================================
-@@ LUA_INT_INT / LUA_INT_LONG / LUA_INT_LONGLONG defines size for
+@@ LUA_INT_INT / LUA_INT_LONG / LUA_INT_LONGLONG defines type for
-@* Lua integers;
+@@ Lua integers;
-@@ LUA_REAL_FLOAT / LUA_REAL_DOUBLE / LUA_REAL_LONGDOUBLE defines size for
+@@ LUA_REAL_FLOAT / LUA_REAL_DOUBLE / LUA_REAL_LONGDOUBLE defines
-@* Lua floats.
+@@ type for Lua floats.
 **
 ** These definitions set the numeric types for Lua. Lua should work
-** fine with 32-bit or 64-bit integers mixed with 32-bit or 64-bit
+** fine with any mix of these previous options.
-** floats. The usual configurations are 64-bit integers and floats (the
+** The usual configurations are 64-bit integers and floats (the default)
-** default) and 32-bit integers and floats (Small Lua, for restricted
+** and 32-bit integers and floats (Small Lua, for restricted hardware).
-** hardware).
 ** =====================================================================
 */
 #define LUA_INT_LONGLONG
 /*
-@@ LUA_USE_C99 includes all functionality from C 99.
+@@ LUA_USE_C99 includes all functionality that depends on C 99.
 ** CHANGE it (define it) if your system is compatible.
 */
 #if defined(LUA_USE_C99)
 /*
 @@ LUA_USE_POSIX includes all functionality listed as X/Open System
-@* Interfaces Extension (XSI).
+@@ Interfaces Extension (XSI).
 ** CHANGE it (define it) if your system is XSI compatible.
 */
 #if defined(LUA_USE_POSIX)
 /*
 @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
-@* Lua libraries.
+@@ Lua libraries.
 @@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
-@* C libraries.
+@@ C libraries.
 ** CHANGE them if your machine has a non-conventional directory
 ** hierarchy or if you want to install your libraries in
 ** non-conventional directories.
 */
-#if defined(_WIN32)	/* { */
+#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#if defined(_WIN32) 	/* { */
 /*
 ** In Windows, any exclamation mark ('!') in the path is replaced by the
 ** path of the directory of the executable file of the current process.
 */
 #define LUA_LDIR	"!\\lua\\"
 #define LUA_CDIR	"!\\"
+#define LUA_SHRDIR	"!\\..\\share\\lua\\" LUA_VDIR "\\"
 #define LUA_PATH_DEFAULT  \
 		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
 		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
+                LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
 		".\\?.lua;" ".\\?\\init.lua"
 #define LUA_CPATH_DEFAULT \
-		LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll"
+		LUA_CDIR"?.dll;" \
+		LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
+		LUA_CDIR"loadall.dll;" ".\\?.dll"
 #else			/* }{ */
-#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
 #define LUA_ROOT	"/usr/local/"
-#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR
+#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR "/"
-#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR
+#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR "/"
 #define LUA_PATH_DEFAULT  \
 		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
 		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
 /*
 @@ LUAI_FUNC is a mark for all extern functions that are not to be
-@* exported to outside modules.
+@@ exported to outside modules.
 @@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
-@* that are not to be exported to outside modules (LUAI_DDEF for
+@@ that are not to be exported to outside modules (LUAI_DDEF for
-@* definitions and LUAI_DDEC for declarations).
+@@ definitions and LUAI_DDEC for declarations).
 ** CHANGE them if you need to mark them in some special way. Elf/gcc
 ** (versions 3.2 and later) mark them as "hidden" to optimize access
 ** when Lua is compiled as a shared library. Not all elf targets support
 /*
 @@ LUA_IDSIZE gives the maximum size for the description of the source
-@* of a function in debug information.
+@@ of a function in debug information.
 ** CHANGE it if you want a different size.
 */
 #define LUA_IDSIZE	60
 */
 /*
-@@ LUA_COMPAT_ALL controls all compatibility options.
+@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
+@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
 ** You can define it to get all options, or change specific options
 ** to fit your specific needs.
 */
-#if defined(LUA_COMPAT_ALL)	/* { */
+#if defined(LUA_COMPAT_5_2)	/* { */
+/*
+@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
+** functions in the mathematical library.
+*/
+#define LUA_COMPAT_MATHLIB
 /*
 @@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
 */
 #define LUA_COMPAT_BITLIB
+/*
+@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
+@@ a float mark ('.0').
+** This macro is not on by default even in compatibility mode,
+** because this is not really an incompatibility.
+*/
+/* #define LUA_COMPAT_FLOATSTRING */
+#endif				/* } */
+#if defined(LUA_COMPAT_5_1)	/* { */
 /*
 @@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
 ** You can replace it with 'table.unpack'.
 /*
 @@ LUA_INT32 is an signed integer with exactly 32 bits.
 @@ LUAI_UMEM is an unsigned integer big enough to count the total
-@* memory used by Lua.
+@@ memory used by Lua.
 @@ LUAI_MEM is a signed integer big enough to count the total memory
-@* used by Lua.
+@@ used by Lua.
 ** CHANGE here if for some weird reason the default definitions are not
 ** good enough for your machine. Probably you do not need to change
 ** this.
 @@ LUA_NUMBER is the floating-point type used by Lua.
 **
 @@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
-@* over a floating number.
+@@ over a floating number.
 **
 @@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
-@@ LUA_NUMBER_SCAN is the format for reading floats.
 @@ LUA_NUMBER_FMT is the format for writing floats.
 @@ lua_number2str converts a float to a string.
 **
 #define LUAI_UACNUMBER	double
 #define LUA_NUMBER_FRMLEN	""
-#define LUA_NUMBER_SCAN		"%f"
 #define LUA_NUMBER_FMT		"%.7g"
 #define l_mathop(op)		op##f
 #define LUAI_UACNUMBER	long double
 #define LUA_NUMBER_FRMLEN	"L"
-#define LUA_NUMBER_SCAN		"%Lf"
 #define LUA_NUMBER_FMT		"%.19Lg"
 #define l_mathop(op)		op##l
 #define LUAI_UACNUMBER	double
 #define LUA_NUMBER_FRMLEN	""
-#define LUA_NUMBER_SCAN		"%lf"
 #define LUA_NUMBER_FMT		"%.14g"
 #define l_mathop(op)		op
 #define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))
+/*
+@@ lua_numtointeger converts a float number to an integer, or
+** returns 0 if float is not within the range of a lua_Integer.
+** (The range comparisons are tricky because of rounding. The tests
+** here assume a two-complement representation, where MININTEGER always
+** has an exact representation as a float; MAXINTEGER may not have one,
+** and therefore its conversion to float may have an ill-defined value.)
+*/
+#define lua_numtointeger(n,p) \
+  ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
+   (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
+      (*(p) = (LUA_INTEGER)(n), 1))
 /*
 @@ The luai_num* macros define the primitive operations over numbers.
-@* They should work for any size of floating numbers.
+** They should work for any size of floating numbers.
 */
 /* the following operations need the math library */
 #if defined(lobject_c) || defined(lvm_c)
 #include <math.h>
-#define luai_nummod(L,a,b)	((void)L, (a) - l_floor((a)/(b))*(b))
+#define luai_nummod(L,a,b,m)  \
+  { (m) = l_mathop(fmod)(a,b); if ((m) != 0 && (a)*(b) < 0) (m) += (b); }
 #define luai_numpow(L,a,b)	((void)L, l_mathop(pow)(a,b))
 #endif
 **
 @@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
 **
+@@ LUAI_UACINT is the result of an 'usual argument conversion'
+@@ over a lUA_INTEGER.
 @@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
-@@ LUA_INTEGER_SCAN is the format for reading integers.
 @@ 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.
 */
+/* The following definitions are good for most cases here */
+#define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
+#define lua_integer2str(s,n)	sprintf((s), LUA_INTEGER_FMT, (n))
+#define LUAI_UACINT		LUA_INTEGER
+/*
+** use LUAI_UACINT here to avoid problems with promotions (which
+** can turn a comparison between unsigneds into a signed comparison)
+*/
+#define LUA_UNSIGNED		unsigned LUAI_UACINT
+/* now the variable definitions */
 #if defined(LUA_INT_INT)		/* { int */
 #define LUA_INTEGER		int
 #define LUA_INTEGER_FRMLEN	""
+#define LUA_MAXUNSIGNED		UINT_MAX
+#define LUA_MAXINTEGER		INT_MAX
+#define LUA_MININTEGER		INT_MIN
 #elif defined(LUA_INT_LONG)	/* }{ long */
 #define LUA_INTEGER		long
 #define LUA_INTEGER_FRMLEN	"l"
+#define LUA_MAXUNSIGNED		ULONG_MAX
+#define LUA_MAXINTEGER		LONG_MAX
+#define LUA_MININTEGER		LONG_MIN
 #elif defined(LUA_INT_LONGLONG)	/* }{ long long */
 #if defined(_WIN32)
 #define LUA_INTEGER		__int64
 #define LUA_INTEGER_FRMLEN	"I64"
+#define LUA_MAXUNSIGNED		_UI64_MAX
+#define LUA_MAXINTEGER		_I64_MAX
+#define LUA_MININTEGER		_I64_MIN
 #else
 #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
 #endif
-#else				/* }{ */
+#elif defined(LUA_INT_SHORT)	/* }{ short int */
+/*
+** this option is for tests only; it is not particularly useful and
+** it does not pass the test suit.
+*/
-#error "numeric integer type not defined"
+#define LUA_INTEGER		short int
+#define LUA_INTEGER_FRMLEN	""
-#endif				/* } */
+#define LUA_MAXUNSIGNED		((LUA_UNSIGNED)USHRT_MAX)
+#define LUA_MAXINTEGER		SHRT_MAX
+#define LUA_MININTEGER		SHRT_MIN
+#undef  LUAI_UACINT
+#define LUAI_UACINT		int
-#define LUA_INTEGER_SCAN	"%" LUA_INTEGER_FRMLEN "d"
+#undef  LUAI_MAXSTACK
-#define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
+#define LUAI_MAXSTACK           15000
-#define lua_integer2str(s,n)	sprintf((s), LUA_INTEGER_FMT, (n))
-#define LUA_UNSIGNED		unsigned LUA_INTEGER
+#define l_castS2U(x)		((LUA_UNSIGNED)(unsigned short)(x))
+#else				/* }{ */
+#error "numeric integer type not defined"
+#endif				/* } */
 /* }================================================================== */

src/lundump.c+27−19

 /*
-** $Id: lundump.c,v 2.34 2014/03/11 18:56:27 roberto Exp $
+** $Id: lundump.c,v 2.40 2014/06/19 18:27:20 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 /*
 ** All high-level loads go through LoadVector; you can change it to
-** adapt to the endianess of the input
+** adapt to the endianness of the input
 */
 #define LoadVector(S,b,n)	LoadBlock(S,b,(n)*sizeof((b)[0]))
 }
-static void LoadFunction(LoadState *S, Proto *f);
+static void LoadFunction(LoadState *S, Proto *f, TString *psource);
 static void LoadConstants (LoadState *S, Proto *f) {
-  int i, n;
+  int i;
-  n = LoadInt(S);
+  int n = LoadInt(S);
   f->k = luaM_newvector(S->L, n, TValue);
   f->sizek = n;
   for (i = 0; i < n; i++)
       setbvalue(o, LoadByte(S));
       break;
     case LUA_TNUMFLT:
-      setnvalue(o, LoadNumber(S));
+      setfltvalue(o, LoadNumber(S));
       break;
     case LUA_TNUMINT:
       setivalue(o, LoadInteger(S));
       lua_assert(0);
     }
   }
-  n = LoadInt(S);
+}
+static void LoadProtos (LoadState *S, Proto *f) {
+  int i;
+  int n = LoadInt(S);
   f->p = luaM_newvector(S->L, n, Proto *);
   f->sizep = n;
   for (i = 0; i < n; i++)
     f->p[i] = NULL;
   for (i = 0; i < n; i++) {
     f->p[i] = luaF_newproto(S->L);
-    LoadFunction(S, f->p[i]);
+    LoadFunction(S, f->p[i], f->source);
   }
 }
 static void LoadDebug (LoadState *S, Proto *f) {
   int i, n;
-  f->source = LoadString(S);
   n = LoadInt(S);
   f->lineinfo = luaM_newvector(S->L, n, int);
   f->sizelineinfo = n;
 }
-static void LoadFunction (LoadState *S, Proto *f) {
+static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
+  f->source = LoadString(S);
+  if (f->source == NULL)  /* no source in dump? */
+    f->source = psource;  /* reuse parent's source */
   f->linedefined = LoadInt(S);
   f->lastlinedefined = LoadInt(S);
   f->numparams = LoadByte(S);
   LoadCode(S, f);
   LoadConstants(S, f);
   LoadUpvalues(S, f);
+  LoadProtos(S, f);
   LoadDebug(S, f);
 }
 static void checkliteral (LoadState *S, const char *s, const char *msg) {
   char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
-  int len = strlen(s);
+  size_t len = strlen(s);
   LoadVector(S, buff, len);
   if (memcmp(s, buff, len) != 0)
     error(S, msg);
   checksize(S, lua_Integer);
   checksize(S, lua_Number);
   if (LoadInteger(S) != LUAC_INT)
-    error(S, "endianess mismatch in");
+    error(S, "endianness mismatch in");
   if (LoadNumber(S) != LUAC_NUM)
     error(S, "float format mismatch in");
 }
 /*
 ** load precompiled chunk
 */
-Closure *luaU_undump(lua_State *L, ZIO *Z, Mbuffer *buff,
+LClosure *luaU_undump(lua_State *L, ZIO *Z, Mbuffer *buff,
-                     const char *name) {
+                      const char *name) {
   LoadState S;
-  Closure *cl;
+  LClosure *cl;
   if (*name == '@' || *name == '=')
     S.name = name + 1;
   else if (*name == LUA_SIGNATURE[0])
   cl = luaF_newLclosure(L, LoadByte(&S));
   setclLvalue(L, L->top, cl);
   incr_top(L);
-  cl->l.p = luaF_newproto(L);
+  cl->p = luaF_newproto(L);
-  LoadFunction(&S, cl->l.p);
+  LoadFunction(&S, cl->p, NULL);
-  lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
+  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
-  luai_verifycode(L, buff, cl->l.p);
+  luai_verifycode(L, buff, cl->p);
   return cl;
 }

src/lundump.h+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lundump.h,v 1.42 2014/03/11 14:22:54 roberto Exp $	2	** $Id: lundump.h,v 1.44 2014/06/19 18:27:20 roberto Exp $
3	** load precompiled Lua chunks	3	** load precompiled Lua chunks
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -15,7 +15,7 @@ · 9 unmodified lines
15	/* data to catch conversion errors */	15	/* data to catch conversion errors */
16	#define LUAC_DATA "\x19\x93\r\n\x1a\n"	16	#define LUAC_DATA "\x19\x93\r\n\x1a\n"
17		17
18	#define LUAC_INT cast_integer(0xABCD)	18	#define LUAC_INT 0x5678
19	#define LUAC_NUM cast_num(370.5)	19	#define LUAC_NUM cast_num(370.5)
20		20
21	#define MYINT(s) (s[0]-'0')	21	#define MYINT(s) (s[0]-'0')
@@ -23,8 +23,8 @@ · 1 unmodified line
23	#define LUAC_FORMAT 0 /* this is the official format */	23	#define LUAC_FORMAT 0 /* this is the official format */
24		24
25	/* load one chunk; from lundump.c */	25	/* load one chunk; from lundump.c */
26	LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff,	26	LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff,
27	const char* name);	27	const char* name);
28		28
29	/* dump one chunk; from ldump.c */	29	/* dump one chunk; from ldump.c */
30	LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,	30	LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,

src/lutf8lib.c+49−38

 /*
-** $Id: lutf8lib.c,v 1.4 2014/03/20 19:36:02 roberto Exp $
+** $Id: lutf8lib.c,v 1.9 2014/05/14 18:33:37 roberto Exp $
 ** Standard library for UTF-8 manipulation
 ** See Copyright Notice in lua.h
 */
 /*
-** Decode an UTF-8 sequence, returning NULL if byte sequence is invalid.
+** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid.
 */
 static const char *utf8_decode (const char *o, int *val) {
   static unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
 /*
-** utf8len(s, [i])   --> number of codepoints in 's' after 'i';
+** utf8len(s [, i [, j]]) --> number of characters that start in the
-** nil if 's' not well formed
+** range [i,j], or nil + current position if 's' is not well formed in
+** that interval
 */
 static int utflen (lua_State *L) {
   int n = 0;
-  const char *ends;
   size_t len;
   const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), 1);
+  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
-  luaL_argcheck(L, 1 <= posi && posi <= (lua_Integer)len, 1,
+  lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len);
+  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2,
                    "initial position out of string");
-  ends = s + len;
+  luaL_argcheck(L, --posj < (lua_Integer)len, 3,
-  s += posi - 1;
+                   "final position out of string");
-  while (s < ends && (s = utf8_decode(s, NULL)) != NULL)
+  while (posi <= posj) {
+    const char *s1 = utf8_decode(s + posi, NULL);
+    if (s1 == NULL) {  /* conversion error? */
+      lua_pushnil(L);  /* return nil ... */
+      lua_pushinteger(L, posi + 1);  /* ... and current position */
+      return 2;
+    }
+    posi = s1 - s;
     n++;
-  if (s == ends)
+  }
-    lua_pushinteger(L, n);
+  lua_pushinteger(L, n);
-  else
-    lua_pushnil(L);
   return 1;
 }
 /*
 ** codepoint(s, [i, [j]])  -> returns codepoints for all characters
-** between i and j
+** that start in the range [i,j]
 */
 static int codepoint (lua_State *L) {
   size_t len;
 /*
-** offset(s, n, [i])  -> index where n-th character *after*
+** offset(s, n, [i])  -> index where n-th character counting from
 **   position 'i' starts; 0 means character at 'i'.
 */
 static int byteoffset (lua_State *L) {
   size_t len;
   const char *s = luaL_checklstring(L, 1, &len);
   int n  = luaL_checkint(L, 2);
-  lua_Integer posi = u_posrelat(luaL_optinteger(L, 3, 1), len) - 1;
+  lua_Integer posi = (n >= 0) ? 1 : len + 1;
-  luaL_argcheck(L, 0 <= posi && posi <= (lua_Integer)len, 3,
+  posi = u_posrelat(luaL_optinteger(L, 3, posi), len);
+  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3,
                    "position out of range");
   if (n == 0) {
     /* find beginning of current byte sequence */
     while (posi > 0 && iscont(s + posi)) posi--;
   }
-  else if (n < 0) {
-    while (n < 0 && posi > 0) {  /* move back */
-      do {  /* find beginning of previous character */
-        posi--;
-      } while (posi > 0 && iscont(s + posi));
-      n++;
-    }
-  }
   else {
-    n--;  /* do not move for 1st character */
+    if (iscont(s + posi))
-    while (n > 0 && posi < (lua_Integer)len) {
+      luaL_error(L, "initial position is a continuation byte");
-      do {  /* find beginning of next character */
+    if (n < 0) {
-        posi++;
+       while (n < 0 && posi > 0) {  /* move back */
-      } while (iscont(s + posi));  /* ('\0' is not continuation) */
+         do {  /* find beginning of previous character */
-      n--;
+           posi--;
-    }
+         } while (posi > 0 && iscont(s + posi));
+         n++;
+       }
+     }
+     else {
+       n--;  /* do not move for 1st character */
+       while (n > 0 && posi < (lua_Integer)len) {
+         do {  /* find beginning of next character */
+           posi++;
+         } while (iscont(s + posi));  /* (cannot pass final '\0') */
+         n--;
+       }
+     }
   }
-  if (n == 0)
+  if (n == 0)  /* did it find given character? */
     lua_pushinteger(L, posi + 1);
-  else
+  else  /* no such character */
-    lua_pushnil(L);  /* no such position */
+    lua_pushnil(L);
   return 1;
 }
 static int iter_aux (lua_State *L) {
   size_t len;
   const char *s = luaL_checklstring(L, 1, &len);
-  int n = lua_tointeger(L, 2) - 1;
+  lua_Integer n = lua_tointeger(L, 2) - 1;
   if (n < 0)  /* first iteration? */
     n = 0;  /* start from here */
   else if (n < (lua_Integer)len) {
 };
-int luaopen_utf8 (lua_State *L) {
+LUAMOD_API int luaopen_utf8 (lua_State *L) {
   luaL_newlib(L, funcs);
   lua_pushliteral(L, UTF8PATT);
   lua_setfield(L, -2, "charpatt");

src/lvm.c+251−127

 /*
-** $Id: lvm.c,v 2.190 2014/03/15 12:29:48 roberto Exp $
+** $Id: lvm.c,v 2.216 2014/06/19 18:27:20 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 #define MAXNUMBER2STR	50
+/*
+** Similar to 'tonumber', but does not attempt to convert strings and
+** ensure correct precision (no extra bits). Used in comparisons.
+*/
+static int tofloat (const TValue *obj, lua_Number *n) {
+  if (ttisfloat(obj)) *n = fltvalue(obj);
+  else if (ttisinteger(obj)) {
+    volatile lua_Number x = cast_num(ivalue(obj));  /* avoid extra precision */
+    *n = x;
+  }
+  else {
+    *n = 0;  /* to avoid warnings */
+    return 0;
+  }
+  return 1;
+}
+/*
+** Try to convert a value to a float. Check 'isinteger' first, because
+** in general the float case is already handled by the macro 'tonumber'.
+*/
 int luaV_tonumber_ (const TValue *obj, lua_Number *n) {
-  lua_assert(!ttisfloat(obj));
+  TValue v;
+ again:
   if (ttisinteger(obj)) {
     *n = cast_num(ivalue(obj));
     return 1;
   }
-  else
+  else if (ttisfloat(obj)) {
-    return (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, n));
+    *n = fltvalue(obj);
+    return 1;
+  }
+  else if (ttisstring(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 */
+  }
+  return 0;  /* conversion failed */
+}
+/*
+** try to convert a value to an integer, rounding up if 'up' is true
+*/
+static int tointeger_aux (const TValue *obj, lua_Integer *p, int up) {
+  TValue v;
+ again:
+  if (ttisfloat(obj)) {
+    lua_Number n = fltvalue(obj);
+    n = (up ? -l_floor(-n) : l_floor(n));
+    return lua_numtointeger(n, p);
+  }
+  else if (ttisinteger(obj)) {
+    *p = ivalue(obj);
+    return 1;
+  }
+  else if (ttisstring(obj) &&
+            luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) {
+    obj = &v;
+    goto again;  /* convert result from 'luaO_str2num' to an integer */
+  }
+  return 0;  /* conversion failed */
 }
+/*
+** try to convert a non-integer value to an integer, rounding down
+*/
+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 = (ttisinteger(obj))
+    size_t len;
-                 ? lua_integer2str(buff, ivalue(obj))
+    if (ttisinteger(obj))
-                 : lua_number2str(buff, fltvalue(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;
   }
 /*
-** Check whether a float number is within the range of a lua_Integer.
+** Try to convert a 'for' limit to an integer, preserving the
-** (The comparisons are tricky because of rounding, which can or
+** semantics of the loop.
-** not occur depending on the relative sizes of floats and integers.)
+** (The following explanation assumes a non-negative step; it is valid
-** This function should be called only when 'n' has an integral value.
+** for negative steps mutatis mutandis.)
+** If the limit can be converted to an integer, rounding down, that is
+** it.
+** Otherwise, check whether the limit can be converted to a number.  If
+** the number is too large, it is OK to set the limit as LUA_MAXINTEGER,
+** which means no limit.  If the number is too negative, the loop
+** should not run, because any initial integer value is larger than the
+** limit. So, it sets the limit to LUA_MININTEGER. 'stopnow' corrects
+** the extreme case when the initial value is LUA_MININTEGER, in which
+** case the LUA_MININTEGER limit would still run the loop once.
 */
-int luaV_numtointeger (lua_Number n, lua_Integer *p) {
+static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step,
-  if (cast_num(MIN_INTEGER) <= n && n < (MAX_INTEGER + cast_num(1))) {
+                     int *stopnow) {
-    *p = cast_integer(n);
+  *stopnow = 0;  /* usually, let loops run */
-    lua_assert(cast_num(*p) == n);
+  if (!tointeger_aux(obj, p, (step < 0))) {  /* does not fit in integer? */
-    return 1;
+    lua_Number n;  /* try to convert to float */
+    if (!tonumber(obj, &n)) /* cannot convert to float? */
+      return 0;  /* not a number */
+    if (n > 0) {  /* if true, float is larger than max integer */
+      *p = LUA_MAXINTEGER;
+      if (step < 0) *stopnow = 1;
+    }
+    else {  /* float is smaller than min integer */
+      *p = LUA_MININTEGER;
+      if (step >= 0) *stopnow = 1;
+    }
   }
-  return 0;  /* number is outside integer limits */
+  return 1;
 }
 /*
-** try to convert a non-integer value to an integer
+** Main function for table access (invoking metamethods if needed).
+** Compute 'val = t[key]'
 */
-int luaV_tointeger_ (const TValue *obj, lua_Integer *p) {
-  lua_Number n;
-  lua_assert(!ttisinteger(obj));
-  if (tonumber(obj, &n)) {
-    n = l_floor(n);
-    return luaV_numtointeger(n, p);
-  }
-  else return 0;
-}
 void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
-  int loop;
+  int loop;  /* counter to avoid infinite loops */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
     const TValue *tm;
     if (ttistable(t)) {  /* `t' is a table? */
       const TValue *res = luaH_get(h, key); /* do a primitive get */
       if (!ttisnil(res) ||  /* result is not nil? */
           (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
-        setobj2s(L, val, res);
+        setobj2s(L, val, res);  /* result is the raw get */
         return;
       }
-      /* else will try the tag method */
+      /* else will try metamethod */
     }
     else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
-      luaG_typeerror(L, t, "index");
+      luaG_typeerror(L, t, "index");  /* no metamethod */
-    if (ttisfunction(tm)) {
+    if (ttisfunction(tm)) {  /* metamethod is a function */
       luaT_callTM(L, tm, t, key, val, 1);
       return;
     }
-    t = tm;  /* else repeat with 'tm' */
+    t = tm;  /* else repeat access over 'tm' */
   }
   luaG_runerror(L, "gettable chain too long; possible loop");
 }
+/*
+** Main function for table assignment (invoking metamethods if needed).
+** Compute 't[key] = val'
+*/
 void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
-  int loop;
+  int loop;  /* counter to avoid infinite loops */
   for (loop = 0; loop < MAXTAGLOOP; loop++) {
     const TValue *tm;
     if (ttistable(t)) {  /* `t' is a table? */
       Table *h = hvalue(t);
       TValue *oldval = cast(TValue *, luaH_get(h, key));
       /* if previous value is not nil, there must be a previous entry
-         in the table; moreover, a metamethod has no relevance */
+         in the table; a metamethod has no relevance */
       if (!ttisnil(oldval) ||
          /* previous value is nil; must check the metamethod */
          ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL &&
     else  /* not a table; check metamethod */
       if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
         luaG_typeerror(L, t, "index");
-    /* there is a metamethod */
+    /* try the metamethod */
     if (ttisfunction(tm)) {
       luaT_callTM(L, tm, t, key, val, 0);
       return;
     }
-    t = tm;  /* else repeat with 'tm' */
+    t = tm;  /* else repeat assginment over 'tm' */
   }
   luaG_runerror(L, "settable chain too long; possible loop");
 }
+/*
+** Compare two strings 'ls' x 'rs', returning an integer smaller-equal-
+** -larger than zero if 'ls' is smaller-equal-larger than 'rs'.
+** The code is a little tricky because it allows '\0' in the strings
+** and it uses 'strcoll' (to respect locales) for each segments
+** of the strings.
+*/
 static int l_strcmp (const TString *ls, const TString *rs) {
   const char *l = getstr(ls);
   size_t ll = ls->tsv.len;
   const char *r = getstr(rs);
   size_t lr = rs->tsv.len;
-  for (;;) {
+  for (;;) {  /* for each segment */
     int temp = strcoll(l, r);
-    if (temp != 0) return temp;
+    if (temp != 0)  /* not equal? */
-    else {  /* strings are equal up to a `\0' */
+      return temp;  /* done */
+    else {  /* strings are equal up to a '\0' */
       size_t len = strlen(l);  /* index of first `\0' in both strings */
-      if (len == lr)  /* r is finished? */
+      if (len == lr)  /* 'rs' is finished? */
-        return (len == ll) ? 0 : 1;
+        return (len == ll) ? 0 : 1;  /* check 'ls' */
-      else if (len == ll)  /* l is finished? */
+      else if (len == ll)  /* 'ls' is finished? */
-        return -1;  /* l is smaller than r (because r is not finished) */
+        return -1;  /* 'ls' is smaller than 'rs' ('rs' is not finished) */
-      /* both strings longer than `len'; go on comparing (after the `\0') */
+      /* both strings longer than `len'; go on comparing after the '\0' */
       len++;
       l += len; ll -= len; r += len; lr -= len;
     }
 }
+/*
+** Main operation less than; return 'l < r'.
+*/
 int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
   int res;
   lua_Number nl, nr;
-  if (ttisinteger(l) && ttisinteger(r))
+  if (ttisinteger(l) && ttisinteger(r))  /* both operands are integers? */
     return (ivalue(l) < ivalue(r));
-  else if (tonumber(l, &nl) && tonumber(r, &nr))
+  else if (tofloat(l, &nl) && tofloat(r, &nr))  /* both are numbers? */
     return luai_numlt(nl, nr);
-  else if (ttisstring(l) && ttisstring(r))
+  else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
-  else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)
+  else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)  /* no metamethod? */
-    luaG_ordererror(L, l, r);
+    luaG_ordererror(L, l, r);  /* error */
   return res;
 }
+/*
+** Main operation less than or equal to; return 'l <= r'.
+*/
 int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
   int res;
   lua_Number nl, nr;
-  if (ttisinteger(l) && ttisinteger(r))
+  if (ttisinteger(l) && ttisinteger(r))  /* both operands are integers? */
     return (ivalue(l) <= ivalue(r));
-  else if (tonumber(l, &nl) && tonumber(r, &nr))
+  else if (tofloat(l, &nl) && tofloat(r, &nr))  /* both are numbers? */
     return luai_numle(nl, nr);
-  else if (ttisstring(l) && ttisstring(r))
+  else if (ttisstring(l) && ttisstring(r))  /* both are strings? */
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0)  /* first try `le' */
     return res;
 /*
-** equality of Lua values. L == NULL means raw equality (no metamethods)
+** Main operation for equality of Lua values; return 't1 == t2'.
+** L == NULL means raw equality (no metamethods)
 */
 int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) {
   const TValue *tm;
-  if (ttype(t1) != ttype(t2)) {
+  if (ttype(t1) != ttype(t2)) {  /* not the same variant? */
     if (ttnov(t1) != ttnov(t2) || ttnov(t1) != LUA_TNUMBER)
       return 0;  /* only numbers can be equal with different variants */
     else {  /* two numbers with different variants */
-      lua_Number n1, n2;
+      lua_Number n1, n2;  /* compare them as floats */
       lua_assert(ttisnumber(t1) && ttisnumber(t2));
-      cast_void(tonumber(t1, &n1)); cast_void(tonumber(t2, &n2));
+      cast_void(tofloat(t1, &n1)); cast_void(tofloat(t2, &n2));
       return luai_numeq(n1, n2);
     }
   }
     case LUA_TUSERDATA: {
       if (uvalue(t1) == uvalue(t2)) return 1;
       else if (L == NULL) return 0;
-      tm = luaT_getequalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable);
+      tm = fasttm(L, uvalue(t1)->metatable, TM_EQ);
+      if (tm == NULL)
+        tm = fasttm(L, uvalue(t2)->metatable, TM_EQ);
       break;  /* will try TM */
     }
     case LUA_TTABLE: {
       if (hvalue(t1) == hvalue(t2)) return 1;
       else if (L == NULL) return 0;
-      tm = luaT_getequalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable);
+      tm = fasttm(L, hvalue(t1)->metatable, TM_EQ);
+      if (tm == NULL)
+        tm = fasttm(L, hvalue(t2)->metatable, TM_EQ);
       break;  /* will try TM */
     }
     default:
       return gcvalue(t1) == gcvalue(t2);
   }
-  if (tm == NULL) return 0;  /* no TM? */
+  if (tm == NULL)  /* no TM? */
+    return 0;  /* objects are different */
   luaT_callTM(L, tm, t1, t2, L->top, 1);  /* call TM */
   return !l_isfalse(L->top);
 }
+/* macro used by 'luaV_concat' to ensure that element at 'o' is a string */
+#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o)))
+/*
+** Main operation for concatenation: concat 'total' values in the stack,
+** from 'L->top - total' up to 'L->top - 1'.
+*/
 void luaV_concat (lua_State *L, int total) {
   lua_assert(total >= 2);
   do {
       buffer = luaZ_openspace(L, &G(L)->buff, tl);
       tl = 0;
       n = i;
-      do {  /* concat all strings */
+      do {  /* copy all strings to buffer */
         size_t l = tsvalue(top-i)->len;
         memcpy(buffer+tl, svalue(top-i), l * sizeof(char));
         tl += l;
       } while (--i > 0);
-      setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
+      setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));  /* create result */
     }
     total -= n-1;  /* got 'n' strings to create 1 new */
     L->top -= n-1;  /* popped 'n' strings and pushed one */
 }
+/*
+** Main operation 'ra' = #rb'.
+*/
 void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
   const TValue *tm;
   switch (ttnov(rb)) {
 }
-lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y) {
+/*
-  if (cast_unsigned(y) + 1 <= 1U) {  /* special cases: -1 or 0 */
+** Integer division; return 'm // n'. (Assume that C division with
-    if (y == 0)
+** negative operands follows C99 behavior.)
+*/
+lua_Integer luaV_div (lua_State *L, lua_Integer m, lua_Integer n) {
+  if (l_castS2U(n) + 1u <= 1u) {  /* special cases: -1 or 0 */
+    if (n == 0)
       luaG_runerror(L, "attempt to divide by zero");
-    return intop(-, 0, x);   /* y==-1; avoid overflow with 0x80000...//-1 */
+    return intop(-, 0, m);   /* n==-1; avoid overflow with 0x80000...//-1 */
   }
   else {
-    lua_Integer d = x / y;  /* perform division */
+    lua_Integer d = m / n;  /* perform division */
-    if ((x ^ y) >= 0 || x % y == 0)   /* same signal or no rest? */
+    if ((m ^ n) >= 0 || m % n == 0)   /* same signal or no rest? */
       return d;
     else
       return d - 1;  /* correct 'div' for negative case */
 }
-lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y) {
+/*
-  if (cast_unsigned(y) + 1 <= 1U) {  /* special cases: -1 or 0 */
+** Integer modulus; return 'm % n'. (Assume that C '%' with
-    if (y == 0)
+** negative operands follows C99 behavior.)
+*/
+lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) {
+  if (l_castS2U(n) + 1u <= 1u) {  /* special cases: -1 or 0 */
+    if (n == 0)
       luaG_runerror(L, "attempt to perform 'n%%0'");
-    return 0;   /* y==-1; avoid overflow with 0x80000...%-1 */
+    return 0;   /* m % -1 == 0; avoid overflow with 0x80000...%-1 */
   }
   else {
-    lua_Integer r = x % y;
+    lua_Integer r = m % n;
-    if (r == 0 || (x ^ y) >= 0)
+    if (r == 0 || (m ^ n) >= 0)  /* no rest or same signal? */
       return r;
     else
-      return r + y;  /* correct 'mod' for negative case */
+      return r + n;  /* correct 'mod' for negative case */
-  }
-}
-lua_Integer luaV_pow (lua_State *L, lua_Integer x, lua_Integer y) {
-  if (y <= 0) {  /* special cases: 0 or negative exponent */
-    if (y < 0)
-      luaG_runerror(L, "integer exponentiation with negative exponent");
-    return 1;  /* x^0 == 1 */
-  }
-  else {
-    lua_Integer r = 1;
-    for (; y > 1; y >>= 1) {
-      if (y & 1) r = intop(*, r, x);
-      x = intop(*, x, x);
-    }
-    r = intop(*, r, x);
-    return r;
   }
 }
 /* number of bits in an integer */
 #define NBITS	cast_int(sizeof(lua_Integer) * CHAR_BIT)
-LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
+/*
+** Shift left operation. (Shift right just negates 'y'.)
+*/
+lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
   if (y < 0) {  /* shift right? */
     if (y <= -NBITS) return 0;
-    else return cast_integer(cast_unsigned(x) >> (-y));
+    else return intop(>>, x, -y);
   }
   else {  /* shift left */
     if (y >= NBITS) return 0;
-    else return x << y;
+    else return intop(<<, x, y);
   }
 }
 ** whether there is a cached closure with the same upvalues needed by
 ** new closure to be created.
 */
-static Closure *getcached (Proto *p, UpVal **encup, StkId base) {
+static LClosure *getcached (Proto *p, UpVal **encup, StkId base) {
-  Closure *c = p->cache;
+  LClosure *c = p->cache;
   if (c != NULL) {  /* is there a cached closure? */
     int nup = p->sizeupvalues;
     Upvaldesc *uv = p->upvalues;
     int i;
     for (i = 0; i < nup; i++) {  /* check whether it has right upvalues */
       TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v;
-      if (c->l.upvals[i]->v != v)
+      if (c->upvals[i]->v != v)
         return NULL;  /* wrong upvalue; cannot reuse closure */
     }
   }
   int nup = p->sizeupvalues;
   Upvaldesc *uv = p->upvalues;
   int i;
-  Closure *ncl = luaF_newLclosure(L, nup);
+  LClosure *ncl = luaF_newLclosure(L, nup);
-  ncl->l.p = p;
+  ncl->p = p;
   setclLvalue(L, ra, ncl);  /* anchor new closure in stack */
   for (i = 0; i < nup; i++) {  /* fill in its upvalues */
     if (uv[i].instack)  /* upvalue refers to local variable? */
-      ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx);
+      ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx);
     else  /* get upvalue from enclosing function */
-      ncl->l.upvals[i] = encup[uv[i].idx];
+      ncl->upvals[i] = encup[uv[i].idx];
-    ncl->l.upvals[i]->refcount++;
+    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? */
+/*
+** {==================================================================
+** Function 'luaV_execute': main interpreter loop
+** ===================================================================
+*/
 /*
 ** some macros for common tasks in `luaV_execute'
 */
           setivalue(ra, intop(+, ib, ic));
         }
         else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setnvalue(ra, luai_numadd(L, nb, nc));
+          setfltvalue(ra, luai_numadd(L, nb, nc));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_ADD)); }
       )
           setivalue(ra, intop(-, ib, ic));
         }
         else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setnvalue(ra, luai_numsub(L, nb, nc));
+          setfltvalue(ra, luai_numsub(L, nb, nc));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SUB)); }
       )
           setivalue(ra, intop(*, ib, ic));
         }
         else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setnvalue(ra, luai_nummul(L, nb, nc));
+          setfltvalue(ra, luai_nummul(L, nb, nc));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MUL)); }
       )
         TValue *rc = RKC(i);
         lua_Number nb; lua_Number nc;
         if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setnvalue(ra, luai_numdiv(L, nb, nc));
+          setfltvalue(ra, luai_numdiv(L, nb, nc));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_DIV)); }
       )
           setivalue(ra, luaV_mod(L, ib, ic));
         }
         else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setnvalue(ra, luai_nummod(L, nb, nc));
+          lua_Number m;
+          luai_nummod(L, nb, nc, m);
+          setfltvalue(ra, m);
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MOD)); }
       )
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         lua_Number nb; lua_Number nc;
-        if (ttisinteger(rb) && ttisinteger(rc)) {
+        if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
+          setfltvalue(ra, luai_numpow(L, nb, nc));
-          setivalue(ra, luaV_pow(L, ib, ic));
-        }
-        else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
-          setnvalue(ra, luai_numpow(L, nb, nc));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_POW)); }
       )
           setivalue(ra, intop(-, 0, ib));
         }
         else if (tonumber(rb, &nb)) {
-          setnvalue(ra, luai_numunm(L, nb));
+          setfltvalue(ra, luai_numunm(L, nb));
         }
         else {
           Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
         TValue *rb = RB(i);
         lua_Integer ib;
         if (tointeger(rb, &ib)) {
-          setivalue(ra, intop(^, cast_integer(-1), ib));
+          setivalue(ra, intop(^, ~l_castS2U(0), ib));
         }
         else {
           Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
           if (luai_numlt(0, step) ? luai_numle(idx, limit)
                                   : luai_numle(limit, idx)) {
             ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
-            setnvalue(ra, idx);  /* update internal index... */
+            setfltvalue(ra, idx);  /* update internal index... */
-            setnvalue(ra + 3, idx);  /* ...and external index */
+            setfltvalue(ra + 3, idx);  /* ...and external index */
           }
         }
       )
         TValue *init = ra;
         TValue *plimit = ra + 1;
         TValue *pstep = ra + 2;
-        if (ttisinteger(init) && ttisinteger(plimit) && ttisinteger(pstep)) {
+        lua_Integer ilimit;
+        int stopnow;
+        if (ttisinteger(init) && ttisinteger(pstep) &&
+            forlimit(plimit, &ilimit, ivalue(pstep), &stopnow)) {
           /* all values are integer */
-          setivalue(init, ivalue(init) - ivalue(pstep));
+          lua_Integer initv = (stopnow ? 0 : ivalue(init));
+          setivalue(plimit, ilimit);
+          setivalue(init, initv - ivalue(pstep));
         }
         else {  /* try making all values floats */
           lua_Number ninit; lua_Number nlimit; lua_Number nstep;
           if (!tonumber(plimit, &nlimit))
             luaG_runerror(L, LUA_QL("for") " limit must be a number");
-          setnvalue(plimit, nlimit);
+          setfltvalue(plimit, nlimit);
           if (!tonumber(pstep, &nstep))
             luaG_runerror(L, LUA_QL("for") " step must be a number");
-          setnvalue(pstep, nstep);
+          setfltvalue(pstep, nstep);
           if (!tonumber(init, &ninit))
             luaG_runerror(L, LUA_QL("for") " initial value must be a number");
-          setnvalue(init, luai_numsub(L, ninit, nstep));
+          setfltvalue(init, luai_numsub(L, ninit, nstep));
         }
         ci->u.l.savedpc += GETARG_sBx(i);
       )
       )
       vmcase(OP_CLOSURE,
         Proto *p = cl->p->p[GETARG_Bx(i)];
-        Closure *ncl = getcached(p, cl->upvals, base);  /* cached closure */
+        LClosure *ncl = getcached(p, cl->upvals, base);  /* cached closure */
         if (ncl == NULL)  /* no match? */
           pushclosure(L, p, cl->upvals, base, ra);  /* create a new one */
         else
   }
 }
+/* }================================================================== */

src/lvm.h+2−7

 /*
-** $Id: lvm.h,v 2.25 2013/12/30 20:47:58 roberto Exp $
+** $Id: lvm.h,v 2.31 2014/05/26 17:10:22 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 #include "ltm.h"
-#define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o)))
 #define tonumber(o,n) \
 	(ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
 #define tointeger(o,i) \
 	(ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger_(o,i))
-#define intop(op,v1,v2) \
+#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
-	cast_integer(cast_unsigned(v1) op cast_unsigned(v2))
 #define luaV_rawequalobj(t1,t2)		luaV_equalobj(NULL,t1,t2)
 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_numtointeger (lua_Number n, 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_concat (lua_State *L, int total);
 LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
 LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
-LUAI_FUNC lua_Integer luaV_pow (lua_State *L, lua_Integer x, lua_Integer y);
 LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
 LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);