Lua 5.3.0-work2

Lua Team committed 12 years ago

Commit ad386d91 parent b83a40a60 files · +3280 −2672Browse files

Unified · Split

60 files

README +1 −1
doc/alert.png +0 −0
doc/contents.html +40 −31
doc/lua.css +22 −9
doc/manual.css +5 −4
doc/manual.html +741 −922
doc/readme.html +24 −69
src/.fix +1 −1
src/Makefile +5 −4
src/lapi.c +66 −70
src/lauxlib.c +71 −59
src/lauxlib.h +15 −15
src/lbaselib.c +7 −9
src/lbitlib.c +37 −22
src/lcode.c +65 −36
src/lcode.h +7 −3
src/ldblib.c +3 −7
src/ldebug.c +20 −13
src/ldebug.h +2 −2
src/ldo.c +23 −20
src/ldump.c +154 −133
src/lfunc.c +39 −54
src/lfunc.h +24 −3
src/lgc.c +287 −336
src/lgc.h +30 −49
src/linit.c +2 −1
src/liolib.c +61 −58
src/llex.c +80 −42
src/llex.h +3 −1
src/llimits.h +7 −4
src/lmathlib.c +11 −4
src/loadlib.c +15 −19
src/lobject.c +88 −38
src/lobject.h +25 −20
src/lopcodes.c +17 −5
src/lopcodes.h +9 −3
src/loslib.c +42 −18
src/lparser.c +37 −37
src/lparser.h +1 −2
src/lstate.c +53 −32
src/lstate.h +19 −30
src/lstring.c +46 −55
src/lstring.h +3 −5
src/lstrlib.c +222 −5
src/ltable.c +47 −27
src/ltable.h +6 −1
src/ltablib.c +2 −2
src/ltm.c +18 −11
src/ltm.h +10 −4
src/lua.c +69 −31
src/lua.h +25 −21
src/luac.c +1 −1
src/luaconf.h +76 −44
src/lualib.h +4 −1
src/lundump.c +207 −209
src/lundump.h +16 −11
src/lutf8lib.c +240 −0
src/lvm.c +125 −56
src/lvm.h +3 −2
src/lzio.h +2 −1

@@ -1,5 +1,5 @@
1		1
2	This is Lua 5.3.0 (work1), released on 5 Jul 2013.	2	This is Lua 5.3.0 (work2), released on 21 Mar 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/alert.png+0−0

Binary file not shown.

doc/contents.html+40−31

 Lua 5.3 Reference Manual
 </H1>
+<P>
+<IMG SRC="alert.png" ALIGN="absbottom">
+<EM>All details may change in the final version.</EM>
 <P>
 The reference manual is the official definition of the Lua language.
 For a complete introduction to Lua programming, see the book
 <A HREF="#index">index</A>
 <HR>
 <SMALL>
-Copyright &copy; 2011&ndash;2013 Lua.org, PUC-Rio.
+Copyright &copy; 2011&ndash;2014 Lua.org, PUC-Rio.
 Freely available under the terms of the
 <A HREF="http://www.lua.org/license.html">Lua license</A>.
 </SMALL>
 <LI><A HREF="manual.html#3.4">3.4 &ndash; Expressions</A>
 <UL>
 <LI><A HREF="manual.html#3.4.1">3.4.1 &ndash; Arithmetic Operators</A>
-<LI><A HREF="manual.html#3.4.2">3.4.2 &ndash; Coercions and Conversions</A>
+<LI><A HREF="manual.html#3.4.2">3.4.2 &ndash; Bitwise Operators</A>
-<LI><A HREF="manual.html#3.4.3">3.4.3 &ndash; Relational Operators</A>
+<LI><A HREF="manual.html#3.4.3">3.4.3 &ndash; Coercions and Conversions</A>
-<LI><A HREF="manual.html#3.4.4">3.4.4 &ndash; Logical Operators</A>
+<LI><A HREF="manual.html#3.4.4">3.4.4 &ndash; Relational Operators</A>
-<LI><A HREF="manual.html#3.4.5">3.4.5 &ndash; Concatenation</A>
+<LI><A HREF="manual.html#3.4.5">3.4.5 &ndash; Logical Operators</A>
-<LI><A HREF="manual.html#3.4.6">3.4.6 &ndash; The Length Operator</A>
+<LI><A HREF="manual.html#3.4.6">3.4.6 &ndash; Concatenation</A>
-<LI><A HREF="manual.html#3.4.7">3.4.7 &ndash; Precedence</A>
+<LI><A HREF="manual.html#3.4.7">3.4.7 &ndash; The Length Operator</A>
-<LI><A HREF="manual.html#3.4.8">3.4.8 &ndash; Table Constructors</A>
+<LI><A HREF="manual.html#3.4.8">3.4.8 &ndash; Precedence</A>
-<LI><A HREF="manual.html#3.4.9">3.4.9 &ndash; Function Calls</A>
+<LI><A HREF="manual.html#3.4.9">3.4.9 &ndash; Table Constructors</A>
-<LI><A HREF="manual.html#3.4.10">3.4.10 &ndash; Function Definitions</A>
+<LI><A HREF="manual.html#3.4.10">3.4.10 &ndash; Function Calls</A>
+<LI><A HREF="manual.html#3.4.11">3.4.11 &ndash; Function Definitions</A>
 </UL>
 <LI><A HREF="manual.html#3.5">3.5 &ndash; Visibility Rules</A>
 </UL>
 <UL>
 <LI><A HREF="manual.html#6.4.1">6.4.1 &ndash; Patterns</A>
 </UL>
-<LI><A HREF="manual.html#6.5">6.5 &ndash; Table Manipulation</A>
+<LI><A HREF="manual.html#6.5">6.5 &ndash; UTF-8 Support</A>
-<LI><A HREF="manual.html#6.6">6.6 &ndash; Mathematical Functions</A>
+<LI><A HREF="manual.html#6.6">6.6 &ndash; Table Manipulation</A>
-<LI><A HREF="manual.html#6.7">6.7 &ndash; Bitwise Operations</A>
+<LI><A HREF="manual.html#6.7">6.7 &ndash; Mathematical Functions</A>
 <LI><A HREF="manual.html#6.8">6.8 &ndash; Input and Output Facilities</A>
 <LI><A HREF="manual.html#6.9">6.9 &ndash; Operating System Facilities</A>
 <LI><A HREF="manual.html#6.10">6.10 &ndash; The Debug Library</A>
 <A HREF="manual.html#pdf-type">type</A><BR>
 <A HREF="manual.html#pdf-xpcall">xpcall</A><BR>
-<P>
-<A HREF="manual.html#pdf-bit32.arshift">bit32.arshift</A><BR>
-<A HREF="manual.html#pdf-bit32.band">bit32.band</A><BR>
-<A HREF="manual.html#pdf-bit32.bnot">bit32.bnot</A><BR>
-<A HREF="manual.html#pdf-bit32.bor">bit32.bor</A><BR>
-<A HREF="manual.html#pdf-bit32.btest">bit32.btest</A><BR>
-<A HREF="manual.html#pdf-bit32.bxor">bit32.bxor</A><BR>
-<A HREF="manual.html#pdf-bit32.extract">bit32.extract</A><BR>
-<A HREF="manual.html#pdf-bit32.lrotate">bit32.lrotate</A><BR>
-<A HREF="manual.html#pdf-bit32.lshift">bit32.lshift</A><BR>
-<A HREF="manual.html#pdf-bit32.replace">bit32.replace</A><BR>
-<A HREF="manual.html#pdf-bit32.rrotate">bit32.rrotate</A><BR>
-<A HREF="manual.html#pdf-bit32.rshift">bit32.rshift</A><BR>
 <P>
 <A HREF="manual.html#pdf-coroutine.create">coroutine.create</A><BR>
 <A HREF="manual.html#pdf-coroutine.resume">coroutine.resume</A><BR>
 <P>
 <A HREF="manual.html#pdf-debug.debug">debug.debug</A><BR>
-<A HREF="manual.html#pdf-debug.getuservalue">debug.getuservalue</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.getmetatable">debug.getmetatable</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.setuservalue">debug.setuservalue</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>
 <A HREF="manual.html#pdf-debug.setupvalue">debug.setupvalue</A><BR>
+<A HREF="manual.html#pdf-debug.setuservalue">debug.setuservalue</A><BR>
 <A HREF="manual.html#pdf-debug.traceback">debug.traceback</A><BR>
 <A HREF="manual.html#pdf-debug.upvalueid">debug.upvalueid</A><BR>
 <A HREF="manual.html#pdf-debug.upvaluejoin">debug.upvaluejoin</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-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.unpackint">string.unpackint</A><BR>
 <A HREF="manual.html#pdf-string.upper">string.upper</A><BR>
 <P>
 <A HREF="manual.html#pdf-table.sort">table.sort</A><BR>
 <A HREF="manual.html#pdf-table.unpack">table.unpack</A><BR>
+<P>
+<A HREF="manual.html#pdf-utf8.char">utf8.char</A><BR>
+<A HREF="manual.html#pdf-utf8.charpatt">utf8.charpatt</A><BR>
+<A HREF="manual.html#pdf-utf8.codepoint">utf8.codepoint</A><BR>
+<A HREF="manual.html#pdf-utf8.codes">utf8.codes</A><BR>
+<A HREF="manual.html#pdf-utf8.len">utf8.len</A><BR>
+<A HREF="manual.html#pdf-utf8.offset">utf8.offset</A><BR>
 </TD>
 <TD>
 <H3>C API</H3>
 <A HREF="manual.html#lua_isboolean">lua_isboolean</A><BR>
 <A HREF="manual.html#lua_iscfunction">lua_iscfunction</A><BR>
 <A HREF="manual.html#lua_isfunction">lua_isfunction</A><BR>
+<A HREF="manual.html#lua_isinteger">lua_isinteger</A><BR>
 <A HREF="manual.html#lua_islightuserdata">lua_islightuserdata</A><BR>
 <A HREF="manual.html#lua_isnil">lua_isnil</A><BR>
 <A HREF="manual.html#lua_isnone">lua_isnone</A><BR>
 <A HREF="manual.html#lua_setupvalue">lua_setupvalue</A><BR>
 <A HREF="manual.html#lua_setuservalue">lua_setuservalue</A><BR>
 <A HREF="manual.html#lua_status">lua_status</A><BR>
+<A HREF="manual.html#lua_strtonum">lua_strtonum</A><BR>
 <A HREF="manual.html#lua_toboolean">lua_toboolean</A><BR>
 <A HREF="manual.html#lua_tocfunction">lua_tocfunction</A><BR>
 <A HREF="manual.html#lua_tointeger">lua_tointeger</A><BR>
 <P>
 <A HREF="manual.html#luaL_Buffer">luaL_Buffer</A><BR>
 <A HREF="manual.html#luaL_Reg">luaL_Reg</A><BR>
+<A HREF="manual.html#luaL_Stream">luaL_Stream</A><BR>
 <P>
 <A HREF="manual.html#luaL_addchar">luaL_addchar</A><BR>
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Fri Jul  5 23:06:54 BRT 2013
+Fri Mar 21 17:34:12 BRT 2014
 </SMALL>
 <!--
-Last change: updated for Lua 5.3.0 (work1)
+Last change: updated for Lua 5.3.0 (work2)
 -->
 </BODY>

doc/lua.css+22−9

+html {
+	background-color: #F8F8F8 ;
+}
 body {
+	border: solid #a0a0a0 1px ;
+	border-radius: 20px ;
+	padding: 26px ;
+	margin: 16px ;
 	color: #000000 ;
 	background-color: #FFFFFF ;
 	font-family: Helvetica, Arial, sans-serif ;
 	text-align: justify ;
-	margin-right: 30px ;
-	margin-left: 30px ;
 }
 h1, h2, h3, h4 {
 	font-family: Verdana, Geneva, sans-serif ;
 	font-weight: normal ;
-	font-style: italic ;
+	font-style: normal ;
 }
 h2 {
 	padding-top: 0.4em ;
 	padding-bottom: 0.4em ;
-	padding-left: 1em ;
+	padding-left: 0.8em ;
-	padding-right: 1em ;
+	padding-right: 0.8em ;
-	background-color: #E0E0FF ;
+	background-color: #D0D0FF ;
 	border-radius: 8px ;
+	border: solid #a0a0a0 1px ;
 }
 h3 {
 	padding-left: 0.5em ;
-	border-left: solid #E0E0FF 1em ;
+	border-left: solid #D0D0FF 1em ;
 }
 table h3 {
 a:link:hover, a:visited:hover {
 	color: #000080 ;
-	background-color: #E0E0FF ;
+	background-color: #D0D0FF ;
 }
 a:link:active, a:visited:active {
 	height: 1px ;
 	color: #a0a0a0 ;
 	background-color: #a0a0a0 ;
+	display: none ;
+}
+table hr {
+	display: block ;
 }
 :target {
 	background-color: #F8F8F8 ;
 	padding: 8px ;
 	border: solid #a0a0a0 2px ;
+	border-radius: 8px ;
 }
 .footer {
 	color: gray ;
-	font-size: small ;
+	font-size: x-small ;
 }
 input[type=text] {

doc/manual.css+5−4

 }
 p+h1, ul+h1 {
+	font-style: normal ;
 	padding-top: 0.4em ;
 	padding-bottom: 0.4em ;
-	padding-left: 24px ;
+	padding-left: 16px ;
-	margin-left: -24px ;
+	margin-left: -16px ;
-	background-color: #E0E0FF ;
+	background-color: #D0D0FF ;
 	border-radius: 8px ;
+	border: solid #000080 1px ;
 }

doc/manual.html+741−922

@@ -16,10 +16,15 @@ · 15 unmodified lines
16	Lua 5.3 Reference Manual	16	Lua 5.3 Reference Manual
17	</h1>	17	</h1>
18		18
		19	<P>
		20	<IMG SRC="alert.png" ALIGN="absbottom">
		21	<EM>All details may change in the final version.</EM>
		22	<P>
		23
19	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes	24	by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
20	<p>	25	<p>
21	<small>	26	<small>
22	Copyright © 2011–2013 Lua.org, PUC-Rio.	27	Copyright © 2011–2014 Lua.org, PUC-Rio.
23	Freely available under the terms of the	28	Freely available under the terms of the
24	<a href="http://www.lua.org/license.html">Lua license</a>.	29	<a href="http://www.lua.org/license.html">Lua license</a>.
25	</small>	30	</small>
@@ -33,7 +38,7 @@ Freely available under the terms of the · 7 unmodified lines
33	<!-- ====================================================================== -->	38	<!-- ====================================================================== -->
34	<p>	39	<p>
35		40
36	<!-- $Id: manual.of,v 1.105 2013/07/05 18:48:52 roberto Exp $ -->	41	<!-- $Id: manual.of,v 1.114 2014/03/21 18:32:52 roberto Exp $ -->
37		42
38		43
39		44
@@ -119,11 +124,8 @@ it usually represents the absence of a useful value. · 79 unmodified lines
119	<em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>.	124	<em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>.
120	Both <b>nil</b> and <b>false</b> make a condition false;	125	Both <b>nil</b> and <b>false</b> make a condition false;
121	any other value makes it true.	126	any other value makes it true.
122	<em>Number</em> represents both integer numbers and	127	<em>Number</em> represents both
123	real (floating-point) numbers.	128	integral numbers and real (floating-point) numbers.
124	Standard Lua uses 64-bit integers and double-precision floats,
125	but it is easy to compile Lua so that it
126	uses 32-bit integers and single-precision floats.
127	<em>String</em> represents immutable sequences of bytes.	129	<em>String</em> represents immutable sequences of bytes.
128		130
129	Lua is 8-bit clean:	131	Lua is 8-bit clean:
@@ -131,10 +133,27 @@ strings can contain any 8-bit value, · 1 unmodified line
131	including embedded zeros ('<code>\0</code>').	133	including embedded zeros ('<code>\0</code>').
132		134
133		135
		136	<p>
		137	The type <em>number</em> uses two internal representations,
		138	one called <em>integer</em> and the other called <em>float</em>.
		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>).
		141	Therefore,
		142	the programmer has the option of mostly ignore the difference
		143	between integers and floats
		144	or assume complete control about the representation of each value.
		145	Standard Lua uses 64-bit integers and double-precision (64-bit) floats,
		146	but you can also compile Lua so that it
		147	uses 32-bit integers and/or single-precision (32-bit) floats.
		148	The option with 32 bits both for integers and floats
		149	(what is called <em>Small Lua</em>) is particularly attractive
		150	for small machines.
		151
		152
134	<p>	153	<p>
135	Lua can call (and manipulate) functions written in Lua and	154	Lua can call (and manipulate) functions written in Lua and
136	functions written in C	155	functions written in C
137	(see <a href="#3.4.9">§3.4.9</a>).	156	(see <a href="#3.4.10">§3.4.10</a>).
138		157
139		158
140	<p>	159	<p>
@@ -183,14 +202,14 @@ To represent records, Lua uses the field name as an index. · 42 unmodified lines
183	The language supports this representation by	202	The language supports this representation by
184	providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.	203	providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
185	There are several convenient ways to create tables in Lua	204	There are several convenient ways to create tables in Lua
186	(see <a href="#3.4.8">§3.4.8</a>).	205	(see <a href="#3.4.9">§3.4.9</a>).
187		206
188		207
189	<p>	208	<p>
190	We use the term <em>sequence</em> to denote a table where	209	We use the term <em>sequence</em> to denote a table where
191	the set of all positive numeric keys is equal to <em>{1..n}</em>	210	the set of all positive numeric keys is equal to <em>{1..n}</em>
192	for some integer <em>n</em>,	211	for some integer <em>n</em>,
193	which is called the length of the sequence (see <a href="#3.4.6">§3.4.6</a>).	212	which is called the length of the sequence (see <a href="#3.4.7">§3.4.7</a>).
194		213
195		214
196	<p>	215	<p>
@@ -199,7 +218,7 @@ the values of table fields can be of any type. · 2 unmodified lines
199	In particular,	218	In particular,
200	because functions are first-class values,	219	because functions are first-class values,
201	table fields can contain functions.	220	table fields can contain functions.
202	Thus tables can also carry <em>methods</em> (see <a href="#3.4.10">§3.4.10</a>).	221	Thus tables can also carry <em>methods</em> (see <a href="#3.4.11">§3.4.11</a>).
203		222
204		223
205	<p>	224	<p>
@@ -211,6 +230,18 @@ if and only if <code>i</code> and <code>j</code> are raw equal · 5 unmodified lines
211	(that is, equal without metamethods).	230	(that is, equal without metamethods).
212		231
213		232
		233	<p>
		234	In particular, floats with integral values
		235	are equal to their respective integers
		236	(e.g., <code>1.0 == 1</code>).
		237	To avoid ambiguities,
		238	any float with integral value used as a key
		239	is converted to its respective integer.
		240	For instance, if you write <code>a[2.0] = true</code>,
		241	the actual key inserted into the table will be the
		242	integer <code>2</code>.
		243
		244
214	<p>	245	<p>
215	Tables, functions, threads, and (full) userdata values are <em>objects</em>:	246	Tables, functions, threads, and (full) userdata values are <em>objects</em>:
216	variables do not actually <em>contain</em> these values,	247	variables do not actually <em>contain</em> these values,
@@ -382,57 +413,37 @@ but the string library sets a metatable for the string type (see <a href="#6.4"> · 165 unmodified lines
382		413
383		414
384	<p>	415	<p>
385	A metatable controls how an object behaves in arithmetic operations,	416	A metatable controls how an object behaves in
386	order comparisons, concatenation, length operation, and indexing.	417	arithmetic and bitwise operations,
		418	order comparisons, concatenation, length operation, calls, and indexing.
387	A metatable also can define a function to be called	419	A metatable also can define a function to be called
388	when a userdata or a table is garbage collected.	420	when a userdata or a table is garbage collected.
389	When Lua performs one of these operations over a value,
390	it checks whether this value has a metatable with the corresponding event.
391	If so, the value associated with that key (the metamethod)
392	controls how Lua will perform the operation.
393		421
394		422
395	<p>	423	<p>
396	Metatables control the operations listed next.	424	A detailed list of events controlled by metatables is given next.
397	Each operation is identified by its corresponding name.	425	Each operation is identified by its corresponding event name.
398	The key for each operation is a string with its name prefixed by	426	The key for each event is a string with its name prefixed by
399	two underscores, '<code>__</code>';	427	two underscores, '<code>__</code>';
400	for instance, the key for operation "add" is the	428	for instance, the key for operation "add" is the
401	string "<code>__add</code>".	429	string "<code>__add</code>".
402		430	Note that queries for metamethods are always raw;
403		431	the access to a metamethod does not invoke other metamethods.
404	<p>	432	You can emulate how Lua queries a metamethod for an object <code>obj</code>
405	The semantics of these operations is better explained by a Lua function	433	with the following code:
406	describing how the interpreter executes the operation.
407	The code shown here in Lua is only illustrative;
408	the real behavior is hard coded in the interpreter
409	and it is much more efficient than this simulation.
410	All functions used in these descriptions
411	(<a href="#pdf-rawget"><code>rawget</code></a>, <a href="#pdf-tonumber"><code>tonumber</code></a>, etc.)
412	are described in <a href="#6.1">§6.1</a>.
413	In particular, to retrieve the metamethod of a given object,
414	we use the expression
415
416	<pre>
417	metatable(obj)[event]
418	</pre><p>
419	This should be read as
420		434
421	<pre>	435	<pre>
422	rawget(getmetatable(obj) or {}, event)	436	rawget(getmetatable(obj) or {}, event_name)
423	</pre><p>	437	</pre>
424	This means that the access to a metamethod does not invoke other metamethods,
425	and access to objects with no metatables does not fail
426	(it simply results in <b>nil</b>).
427
428		438
429	<p>	439	<p>
430	For the unary <code>-</code> and <code>#</code> operators,	440	For the unary minus and the bitwise not operators,
431	the metamethod is called with a dummy second argument.	441	the metamethod is computed and called with a dummy second operand,
432	This extra argument is only to simplify Lua's internals;	442	equal to the first one.
433	it may be removed in future versions and therefore it is not present	443	This extra operand is only to simplify Lua's internals
434	in the following code.	444	(by making these operators behave like a binary operation)
435	(For most uses this extra argument is irrelevant.)	445	and may be removed in future versions.
		446	(For most uses this extra operand is irrelevant.)
436		447
437		448
438		449
@@ -441,39 +452,19 @@ in the following code. · 2 unmodified lines
441	<li><b>"add": </b>	452	<li><b>"add": </b>
442	the <code>+</code> operation.	453	the <code>+</code> operation.
443		454
444		455	If any operand for an addition is not a number
445		456	(nor a string coercible to a number),
446	<p>	457	Lua will try to call a metamethod.
447	The function <code>getbinhandler</code> below defines how Lua chooses a handler	458	First, Lua will check the first operand (even if it is valid).
448	for a binary operation.	459	If that operand does not define a metamethod for the "<code>__add</code>" event,
449	First, Lua tries the first operand.	460	then Lua will check the second operand.
450	If its type does not define a handler for the operation,	461	If Lua cannot find a metamethod,
451	then Lua tries the second operand.	462	it raises an error.
452		463	Otherwise,
453	<pre>	464	it calls the metamethod with the two operands as arguments,
454	function getbinhandler (op1, op2, event)	465	and the result of the call
455	return metatable(op1)[event] or metatable(op2)[event]	466	(adjusted to one value)
456	end	467	is the result of the operation.
457	</pre><p>
458	By using this function,
459	the behavior of the <code>op1 + op2</code> is
460
461	<pre>
462	function add_event (op1, op2)
463	local o1, o2 = tonumber(op1), tonumber(op2)
464	if o1 and o2 then -- both operands are numeric?
465	return o1 + o2 -- '+' here is the primitive 'add'
466	else -- at least one of the operands is not numeric
467	local h = getbinhandler(op1, op2, "__add")
468	if h then
469	-- call the handler with both operands
470	return (h(op1, op2))
471	else -- no handler available: default behavior
472	error(···)
473	end
474	end
475	end
476	</pre><p>
477	</li>	468	</li>
478		469
479	<li><b>"sub": </b>	470	<li><b>"sub": </b>
@@ -497,263 +488,177 @@ Behavior similar to the "add" operation. · 17 unmodified lines
497	<li><b>"mod": </b>	488	<li><b>"mod": </b>
498	the <code>%</code> operation.	489	the <code>%</code> operation.
499		490
500	Behavior similar to the "add" operation,	491	Behavior similar to the "add" operation.
501	with the operation
502	<code>o1 - floor(o1/o2)*o2</code> as the primitive operation.
503	</li>	492	</li>
504		493
505	<li><b>"pow": </b>	494	<li><b>"pow": </b>
506	the <code>^</code> (exponentiation) operation.	495	the <code>^</code> (exponentiation) operation.
507		496
508	Behavior similar to the "add" operation,	497	Behavior similar to the "add" operation.
509	with the function <code>pow</code> (from the C math library)
510	as the primitive operation.
511	</li>	498	</li>
512		499
513	<li><b>"unm": </b>	500	<li><b>"unm": </b>
514	the unary <code>-</code> operation.	501	the <code>-</code> (unary minus) operation.
515		502
		503	Behavior similar to the "add" operation.
		504	</li>
516		505
517	<pre>	506	<li><b>"idiv": </b>
518	function unm_event (op)	507	the <code>//</code> (integer division) operation.
519	local o = tonumber(op)	508
520	if o then -- operand is numeric?	509	Behavior similar to the "add" operation,
521	return -o -- '-' here is the primitive 'unm'	510	except that Lua will try a metamethod
522	else -- the operand is not numeric.	511	if any operator is neither an integer
523	-- Try to get a handler from the operand	512	nor a value coercible to an integer (see <a href="#3.4.3">§3.4.3</a>).
524	local h = metatable(op).__unm
525	if h then
526	-- call the handler with the operand
527	return (h(op))
528	else -- no handler available: default behavior
529	error(···)
530	end
531	end
532	end
533	</pre><p>
534	</li>	513	</li>
535		514
536	<li><b>"concat": </b>	515	<li><b>"band": </b>
537	the <code>..</code> (concatenation) operation.	516	the <code>&</code> (bitwise and) operation.
538		517
		518	Behavior similar to the "idiv" operation.
		519	</li>
539		520
540	<pre>	521	<li><b>"bor": </b>
541	function concat_event (op1, op2)	522	the <code>\|</code> (bitwise or) operation.
542	if (type(op1) == "string" or type(op1) == "number") and	523
543	(type(op2) == "string" or type(op2) == "number") then	524	Behavior similar to the "band" operation.
544	return op1 .. op2 -- primitive string concatenation
545	else
546	local h = getbinhandler(op1, op2, "__concat")
547	if h then
548	return (h(op1, op2))
549	else
550	error(···)
551	end
552	end
553	end
554	</pre><p>
555	</li>	525	</li>
556		526
557	<li><b>"len": </b>	527	<li><b>"bxor": </b>
558	the <code>#</code> operation.	528	the <code>~</code> (bitwise exclusive or) operation.
559		529
		530	Behavior similar to the "band" operation.
		531	</li>
560		532
561	<pre>	533	<li><b>"bnot": </b>
562	function len_event (op)	534	the <code>~</code> (bitwise unary not) operation.
563	if type(op) == "string" then	535
564	return strlen(op) -- primitive string length	536	Behavior similar to the "band" operation.
565	else
566	local h = metatable(op).__len
567	if h then
568	return (h(op)) -- call handler with the operand
569	elseif type(op) == "table" then
570	return #op -- primitive table length
571	else -- no handler available: error
572	error(···)
573	end
574	end
575	end
576	</pre><p>
577	See <a href="#3.4.6">§3.4.6</a> for a description of the length of a table.
578	</li>	537	</li>
579		538
580	<li><b>"eq": </b>	539	<li><b>"shl": </b>
581	the <code>==</code> operation.	540	the <code><<</code> (bitwise left shift) operation.
582		541
583	The function <code>getequalhandler</code> defines how Lua chooses a metamethod	542	Behavior similar to the "band" operation.
584	for equality.	543	</li>
585	A metamethod is selected only when both values
586	being compared have the same type
587	and the same metamethod for the selected operation,
588	and the values are either tables or full userdata.
589		544
590	<pre>	545	<li><b>"shr": </b>
591	function getequalhandler (op1, op2)	546	the <code>>></code> (bitwise right shift) operation.
592	if type(op1) ~= type(op2) or
593	(type(op1) ~= "table" and type(op1) ~= "userdata") then
594	return nil -- different values
595	end
596	local mm1 = metatable(op1).__eq
597	local mm2 = metatable(op2).__eq
598	if mm1 == mm2 then return mm1 else return nil end
599	end
600	</pre><p>
601	The "eq" event is defined as follows:
602		547
603	<pre>	548	Behavior similar to the "band" operation.
604	function eq_event (op1, op2)
605	if op1 == op2 then -- primitive equal?
606	return true -- values are equal
607	end
608	-- try metamethod
609	local h = getequalhandler(op1, op2)
610	if h then
611	return not not h(op1, op2)
612	else
613	return false
614	end
615	end
616	</pre><p>
617	Note that the result is always a boolean.
618	</li>	549	</li>
619		550
620	<li><b>"lt": </b>	551	<li><b>"concat": </b>
621	the <code><</code> operation.	552	the <code>..</code> (concatenation) operation.
622		553
		554	Behavior similar to the "add" operation,
		555	except that Lua will try a metamethod
		556	if any operator is neither a string nor a number
		557	(which is always coercible to a string).
		558	</li>
623		559
624	<pre>	560	<li><b>"len": </b>
625	function lt_event (op1, op2)	561	the <code>#</code> (length) operation.
626	if type(op1) == "number" and type(op2) == "number" then	562
627	return op1 < op2 -- numeric comparison	563	If the object is not a string,
628	elseif type(op1) == "string" and type(op2) == "string" then	564	Lua will try its metamethod.
629	return op1 < op2 -- lexicographic comparison	565	If there is a metamethod,
630	else	566	Lua calls it with the object as argument,
631	local h = getbinhandler(op1, op2, "__lt")	567	and the result of the call
632	if h then	568	(always adjusted to one value)
633	return not not h(op1, op2)	569	is the result of the operation.
634	else	570	If there is no metamethod but the object is a table,
635	error(···)	571	then Lua uses the table length operation (see <a href="#3.4.7">§3.4.7</a>).
636	end	572	Otherwise, Lua raises an error.
637	end
638	end
639	</pre><p>
640	Note that the result is always a boolean.
641	</li>	573	</li>
642		574
643	<li><b>"le": </b>	575	<li><b>"eq": </b>
644	the <code><=</code> operation.	576	the <code>==</code> (equal) operation.
645		577
		578	Lua will try a metamethod only when the values
		579	being compared are both either tables or full userdata,
		580	both have the same metamethod,
		581	and they are not primitively equal.
		582	The result of the call is always converted to a boolean.
		583	</li>
646		584
647	<pre>	585	<li><b>"lt": </b>
648	function le_event (op1, op2)	586	the <code><</code> (less than) operation.
649	if type(op1) == "number" and type(op2) == "number" then
650	return op1 <= op2 -- numeric comparison
651	elseif type(op1) == "string" and type(op2) == "string" then
652	return op1 <= op2 -- lexicographic comparison
653	else
654	local h = getbinhandler(op1, op2, "__le")
655	if h then
656	return not not h(op1, op2)
657	else
658	h = getbinhandler(op1, op2, "__lt")
659	if h then
660	return not h(op2, op1)
661	else
662	error(···)
663	end
664	end
665	end
666	end
667	</pre><p>
668	Note that, in the absence of a "le" metamethod,
669	Lua tries the "lt", assuming that <code>a <= b</code> is
670	equivalent to <code>not (b < a)</code>.
671		587
		588	Behavior similar to the "add" operation,
		589	except that the result of the call is always converted to a boolean.
		590	</li>
672		591
673	<p>	592	<li><b>"le": </b>
		593	the <code><=</code> (less equal) operation.
		594
		595	Unlike other operations,
		596	The less-equal operation can use two different events.
		597	First, Lua looks for the "<code>__le</code>" metamethod in both operands,
		598	like in the "add" operation.
		599	If it cannot find such a metamethod,
		600	then it will try the "<code>__lt</code>" event,
		601	assuming that <code>a <= b</code> is equivalent to <code>not (b < a)</code>.
674	As with the other comparison operators,	602	As with the other comparison operators,
675	the result is always a boolean.	603	the result is always a boolean.
676	</li>	604	</li>
677		605
678	<li><b>"index": </b>	606	<li><b>"index": </b>
679	The indexing access <code>table[key]</code>.	607	The indexing access <code>table[key]</code>.
680	Note that the metamethod is tried only	608
		609	This event happens when <code>table</code> is not a table or
681	when <code>key</code> is not present in <code>table</code>.	610	when <code>key</code> is not present in <code>table</code>.
682	(When <code>table</code> is not a table,	611	The metamethod is looked up in <code>table</code>.
683	no key is ever present,
684	so the metamethod is always tried.)
685		612
686		613
687	<pre>	614	<p>
688	function gettable_event (table, key)	615	Despite the name,
689	local h	616	the metamethod for this event can be either a function or a table.
690	if type(table) == "table" then	617	If it is a function,
691	local v = rawget(table, key)	618	it is called with <code>table</code> and <code>key</code> as arguments.
692	-- if key is present, return raw value	619	If it is a table,
693	if v ~= nil then return v end	620	the final result is the result of indexing this table with <code>key</code>.
694	h = metatable(table).__index	621	(This indexing is regular, not raw,
695	if h == nil then return nil end	622	and therefore can trigger another metamethod.)
696	else
697	h = metatable(table).__index
698	if h == nil then
699	error(···)
700	end
701	end
702	if type(h) == "function" then
703	return (h(table, key)) -- call the handler
704	else return h[key] -- or repeat operation on it
705	end
706	end
707	</pre><p>
708	</li>	623	</li>
709		624
710	<li><b>"newindex": </b>	625	<li><b>"newindex": </b>
711	The indexing assignment <code>table[key] = value</code>.	626	The indexing assignment <code>table[key] = value</code>.
712	Note that the metamethod is tried only	627
		628	Like the index event,
		629	this event happens when <code>table</code> is not a table or
713	when <code>key</code> is not present in <code>table</code>.	630	when <code>key</code> is not present in <code>table</code>.
		631	The metamethod is looked up in <code>table</code>.
714		632
715		633
716	<pre>	634	<p>
717	function settable_event (table, key, value)	635	Again like with indexing,
718	local h	636	the metamethod for this event can be either a function or a table.
719	if type(table) == "table" then	637	If it is a function,
720	local v = rawget(table, key)	638	it is called with <code>table</code>, <code>key</code>, and <code>value</code> as arguments.
721	-- if key is present, do raw assignment	639	If it is a table,
722	if v ~= nil then rawset(table, key, value); return end	640	Lua does an indexing assignment to this table with the same key and value.
723	h = metatable(table).__newindex	641	(This assignment is regular, not raw,
724	if h == nil then rawset(table, key, value); return end	642	and therefore can trigger another metamethod.)
725	else	643
726	h = metatable(table).__newindex	644
727	if h == nil then	645	<p>
728	error(···)	646	Whenever there is a metamethod,
729	end	647	Lua does not perform the primitive assignment.
730	end	648	(If necessary,
731	if type(h) == "function" then	649	the metamethod itself can call <a href="#pdf-rawset"><code>rawset</code></a>
732	h(table, key,value) -- call the handler	650	to do the assignment.)
733	else h[key] = value -- or repeat operation on it
734	end
735	end
736	</pre><p>
737	</li>	651	</li>
738		652
739	<li><b>"call": </b>	653	<li><b>"call": </b>
740	called when Lua calls a value.	654	The call operation <code>func(args)</code>.
741
742		655
743	<pre>	656	This event happens when Lua tries to call a non-function value
744	function function_event (func, ...)	657	(that is, <code>func</code> is not a function).
745	if type(func) == "function" then	658	The metamethod is looked up in <code>func</code>.
746	return func(...) -- primitive call	659	If present,
747	else	660	the metamethod is called with <code>func</code> as its first argument,
748	local h = metatable(func).__call	661	followed by the arguments of the original call (<code>args</code>).
749	if h then
750	return h(func, ...)
751	else
752	error(···)
753	end
754	end
755	end
756	</pre><p>
757	</li>	662	</li>
758		663
759	</ul>	664	</ul>
@@ -800,7 +705,8 @@ controls the relative speed of the collector relative to · 40 unmodified lines
800	memory allocation.	705	memory allocation.
801	Larger values make the collector more aggressive but also increase	706	Larger values make the collector more aggressive but also increase
802	the size of each incremental step.	707	the size of each incremental step.
803	Values smaller than 100 make the collector too slow and	708	You should not use values smaller than 100,
		709	as they make the collector too slow and
804	can result in the collector never finishing a cycle.	710	can result in the collector never finishing a cycle.
805	The default is 200,	711	The default is 200,
806	which means that the collector runs at "twice"	712	which means that the collector runs at "twice"
@@ -825,21 +731,6 @@ You can also use these functions to control · 18 unmodified lines
825	the collector directly (e.g., stop and restart it).	731	the collector directly (e.g., stop and restart it).
826		732
827		733
828	<p>
829	As an experimental feature in Lua 5.3,
830	you can change the collector's operation mode
831	from incremental to <em>generational</em>.
832	A <em>generational collector</em> assumes that most objects die young,
833	and therefore it traverses only young (recently created) objects.
834	This behavior can reduce the time used by the collector,
835	but also increases memory usage (as old dead objects may accumulate).
836	To mitigate this second problem,
837	from time to time the generational collector performs a full collection.
838	Remember that this is an experimental feature;
839	you are welcome to try it,
840	but check your gains.
841
842
843		734
844	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>	735	<h3>2.5.1 – <a name="2.5.1">Garbage-Collection Metamethods</a></h3>
845		736
@@ -872,17 +763,14 @@ When a marked object becomes garbage, · 26 unmodified lines
872	it is not collected immediately by the garbage collector.	763	it is not collected immediately by the garbage collector.
873	Instead, Lua puts it in a list.	764	Instead, Lua puts it in a list.
874	After the collection,	765	After the collection,
875	Lua does the equivalent of the following function	766	Lua goes through that list:
876	for each object in that list:	767	For each object,
		768	it checks the object's <code>__gc</code> metamethod;
		769	if it is a function,
		770	Lua calls it with the object as its single argument.
		771	(If the metamethod is not a function,
		772	Lua simply ignores it.)
877		773
878	<pre>
879	function gc_event (obj)
880	local h = metatable(obj).__gc
881	if type(h) == "function" then
882	h(obj)
883	end
884	end
885	</pre>
886		774
887	<p>	775	<p>
888	At the end of each garbage-collection cycle,	776	At the end of each garbage-collection cycle,
@@ -1227,6 +1115,15 @@ Strings in Lua can contain any 8-bit value, including embedded zeros, · 338 unmodified lines
1227	which can be specified as '<code>\0</code>'.	1115	which can be specified as '<code>\0</code>'.
1228		1116
1229		1117
		1118	<p>
		1119	The UTF-8 encoding of a Unicode character
		1120	can be inserted in a literal string with
		1121	the escape sequence <code>\u{<em>XXX</em>}</code>
		1122	(note the mandatory enclosing brackets),
		1123	where <em>XXX</em> is a sequence of one or more hexadecimal digits
		1124	representing the character code point.
		1125
		1126
1230	<p>	1127	<p>
1231	Literal strings can also be defined using a long format	1128	Literal strings can also be defined using a long format
1232	enclosed by <em>long brackets</em>.	1129	enclosed by <em>long brackets</em>.
@@ -1290,15 +1187,15 @@ which start with <code>0x</code> or <code>0X</code>. · 57 unmodified lines
1290	Hexadecimal constants also accept an optional fractional part	1187	Hexadecimal constants also accept an optional fractional part
1291	plus an optional binary exponent,	1188	plus an optional binary exponent,
1292	marked by a letter '<code>p</code>' or '<code>P</code>'.	1189	marked by a letter '<code>p</code>' or '<code>P</code>'.
1293	A numeric constant with an fractional dot or an exponent	1190	A numeric constant with a fractional dot or an exponent
1294	denotes a floating-point number;	1191	denotes a float;
1295	otherwise it denotes an integer number.	1192	otherwise it denotes an integer.
1296	Examples of valid integer constants are	1193	Examples of valid integer constants are
1297		1194
1298	<pre>	1195	<pre>
1299	3 345 0xff 0xBEBADA	1196	3 345 0xff 0xBEBADA
1300	</pre><p>	1197	</pre><p>
1301	Examples of valid floating-point constants are	1198	Examples of valid float constants are
1302		1199
1303	<pre>	1200	<pre>
1304	3.0 3.1416 314.16e-2 0.31416E1 34e1	1201	3.0 3.1416 314.16e-2 0.31416E1 34e1
@@ -1471,7 +1368,7 @@ a chunk is simply a block: · 166 unmodified lines
1471	<p>	1368	<p>
1472	Lua handles a chunk as the body of an anonymous function	1369	Lua handles a chunk as the body of an anonymous function
1473	with a variable number of arguments	1370	with a variable number of arguments
1474	(see <a href="#3.4.10">§3.4.10</a>).	1371	(see <a href="#3.4.11">§3.4.11</a>).
1475	As such, chunks can define local variables,	1372	As such, chunks can define local variables,
1476	receive arguments, and return values.	1373	receive arguments, and return values.
1477	Moreover, such anonymous function is compiled as in the	1374	Moreover, such anonymous function is compiled as in the
@@ -1490,10 +1387,9 @@ with an interpreter for the virtual machine. · 12 unmodified lines
1490		1387
1491	<p>	1388	<p>
1492	Chunks can also be precompiled into binary form;	1389	Chunks can also be precompiled into binary form;
1493	see program <code>luac</code> for details.	1390	see program <code>luac</code> and function <a href="#pdf-string.dump"><code>string.dump</code></a> for details.
1494	Programs in source and compiled forms are interchangeable;	1391	Programs in source and compiled forms are interchangeable;
1495	Lua automatically detects the file type and acts accordingly.	1392	Lua automatically detects the file type and acts accordingly (see <a href="#pdf-load"><code>load</code></a>).
1496
1497		1393
1498		1394
1499		1395
@@ -1698,7 +1594,7 @@ is equivalent to the code: · 198 unmodified lines
1698		1594
1699	<pre>	1595	<pre>
1700	do	1596	do
1701	local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)	1597	local <em>var</em>, <em>limit</em>, <em>step</em> = convert(<em>e1</em>, <em>e2</em>, <em>e3</em>)
1702	if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end	1598	if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
1703	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	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
1704	local v = <em>var</em>	1600	local v = <em>var</em>
@@ -1707,6 +1603,13 @@ is equivalent to the code: · 2 unmodified lines
1707	end	1603	end
1708	end	1604	end
1709	</pre><p>	1605	</pre><p>
		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
		1612	<p>
1710	Note the following:	1613	Note the following:
1711		1614
1712	<ul>	1615	<ul>
@@ -1717,6 +1620,12 @@ before the loop starts. · 4 unmodified lines
1717	They must all result in numbers.	1620	They must all result in numbers.
1718	</li>	1621	</li>
1719		1622
		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
1720	<li>	1629	<li>
1721	<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.	1630	<code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
1722	The names shown here are for explanatory purposes only.	1631	The names shown here are for explanatory purposes only.
@@ -1728,14 +1637,14 @@ then a step of 1 is used. · 5 unmodified lines
1728	</li>	1637	</li>
1729		1638
1730	<li>	1639	<li>
1731	You can use <b>break</b> to exit a <b>for</b> loop.	1640	You can use <b>break</b> and <b>goto</b> to exit a <b>for</b> loop.
1732	</li>	1641	</li>
1733		1642
1734	<li>	1643	<li>
1735	The loop variable <code>v</code> is local to the loop;	1644	The loop variable <code>v</code> is local to the loop;
1736	you cannot use its value after the <b>for</b> ends or is broken.	1645	you cannot use its value after the <b>for</b> ends or is broken.
1737	If you need this value,	1646	If you need its value,
1738	assign it to another variable before breaking or exiting the loop.	1647	assign it to another variable before exiting the loop.
1739	</li>	1648	</li>
1740		1649
1741	</ul>	1650	</ul>
@@ -1809,7 +1718,7 @@ function calls can be executed as statements: · 67 unmodified lines
1809	stat ::= functioncall	1718	stat ::= functioncall
1810	</pre><p>	1719	</pre><p>
1811	In this case, all returned values are thrown away.	1720	In this case, all returned values are thrown away.
1812	Function calls are explained in <a href="#3.4.9">§3.4.9</a>.	1721	Function calls are explained in <a href="#3.4.10">§3.4.10</a>.
1813		1722
1814		1723
1815		1724
@@ -1862,22 +1771,24 @@ The basic expressions in Lua are the following: · 46 unmodified lines
1862	<p>	1771	<p>
1863	Numbers and literal strings are explained in <a href="#3.1">§3.1</a>;	1772	Numbers and literal strings are explained in <a href="#3.1">§3.1</a>;
1864	variables are explained in <a href="#3.2">§3.2</a>;	1773	variables are explained in <a href="#3.2">§3.2</a>;
1865	function definitions are explained in <a href="#3.4.10">§3.4.10</a>;	1774	function definitions are explained in <a href="#3.4.11">§3.4.11</a>;
1866	function calls are explained in <a href="#3.4.9">§3.4.9</a>;	1775	function calls are explained in <a href="#3.4.10">§3.4.10</a>;
1867	table constructors are explained in <a href="#3.4.8">§3.4.8</a>.	1776	table constructors are explained in <a href="#3.4.9">§3.4.9</a>.
1868	Vararg expressions,	1777	Vararg expressions,
1869	denoted by three dots ('<code>...</code>'), can only be used when	1778	denoted by three dots ('<code>...</code>'), can only be used when
1870	directly inside a vararg function;	1779	directly inside a vararg function;
1871	they are explained in <a href="#3.4.10">§3.4.10</a>.	1780	they are explained in <a href="#3.4.11">§3.4.11</a>.
1872		1781
1873		1782
1874	<p>	1783	<p>
1875	Binary operators comprise arithmetic operators (see <a href="#3.4.1">§3.4.1</a>),	1784	Binary operators comprise arithmetic operators (see <a href="#3.4.1">§3.4.1</a>),
1876	relational operators (see <a href="#3.4.3">§3.4.3</a>), logical operators (see <a href="#3.4.4">§3.4.4</a>),	1785	bitwise operators (see <a href="#3.4.2">§3.4.2</a>),
1877	and the concatenation operator (see <a href="#3.4.5">§3.4.5</a>).	1786	relational operators (see <a href="#3.4.4">§3.4.4</a>), logical operators (see <a href="#3.4.5">§3.4.5</a>),
		1787	and the concatenation operator (see <a href="#3.4.6">§3.4.6</a>).
1878	Unary operators comprise the unary minus (see <a href="#3.4.1">§3.4.1</a>),	1788	Unary operators comprise the unary minus (see <a href="#3.4.1">§3.4.1</a>),
1879	the unary <b>not</b> (see <a href="#3.4.4">§3.4.4</a>),	1789	the unary bitwise not (see <a href="#3.4.2">§3.4.2</a>),
1880	and the unary <em>length operator</em> (see <a href="#3.4.6">§3.4.6</a>).	1790	the unary logic <b>not</b> (see <a href="#3.4.5">§3.4.5</a>),
		1791	and the unary <em>length operator</em> (see <a href="#3.4.7">§3.4.7</a>).
1881		1792
1882		1793
1883	<p>	1794	<p>
@@ -1939,40 +1850,32 @@ that rounds the quotient towards minus infinite (floor). · 55 unmodified lines
1939		1850
1940		1851
1941	<p>	1852	<p>
1942	With the exception of division, integer division, and exponentiation,	1853	With the exception of division and integer division,
1943	the arithmetic operators work as follows:	1854	the arithmetic operators work as follows:
1944	If both operands are integers,	1855	If both operands are integers,
1945	the operation is performed over integers and the result is an integer.	1856	the operation is performed over integers and the result is an integer.
1946	Otherwise, if both operands are numbers	1857	Otherwise, if both operands are numbers
1947	or strings that can be converted to	1858	or strings that can be converted to
1948	numbers (see <a href="#3.4.2">§3.4.2</a>),	1859	numbers (see <a href="#3.4.3">§3.4.3</a>),
1949	then they are converted to floating-point numbers,	1860	then they are converted to floats,
1950	the operation is performed following the usual rules	1861	the operation is performed following the usual rules
1951	for floating-point arithmetic	1862	for floating-point arithmetic
1952	(usually following the IEEE 754 standard),	1863	(usually the IEEE 754 standard),
1953	and the result is a floating-point number.	1864	and the result is a float.
1954		1865
1955		1866
1956	<p>	1867	<p>
1957	Division (<code>/</code>) always converts its operands to floating-point numbers	1868	Division (<code>/</code>) always converts its operands to floats
1958	and its result is always a floating-point number.	1869	and its result is always a float.
1959		1870
1960		1871
1961	<p>	1872	<p>
1962	Integer division (<code>//</code>) converts its operands to integer numbers	1873	Integer division (<code>//</code>) converts its operands to integers
1963	(see <a href="#3.4.2">§3.4.2</a>)	1874	(see <a href="#3.4.3">§3.4.3</a>)
1964	and its result is always an integer number.	1875	and its result is always an integer.
1965	The result is always rounded towards minus infinite (floor).	1876	The result is always rounded towards minus infinite (floor).
1966		1877
1967		1878
1968	<p>
1969	Exponentiation (<code>^</code>) checks whether both operands are integers and
1970	the exponent is non-negative.
1971	In that case, the exponentiation is performed as an integer operation
1972	and the result is an integer number.
1973	Otherwise, it is performed as a floatint-point operation (<code>pow</code>).
1974
1975
1976	<p>	1879	<p>
1977	In case of overflows in integer arithmetic,	1880	In case of overflows in integer arithmetic,
1978	all operations <em>wrap around</em>,	1881	all operations <em>wrap around</em>,
@@ -1982,15 +1885,41 @@ according to the usual rules of two-complement arithmetic. · 3 unmodified lines
1982		1885
1983		1886
1984		1887
1985	<h3>3.4.2 – <a name="3.4.2">Coercions and Conversions</a></h3>	1888	<h3>3.4.2 – <a name="3.4.2">Bitwise Operators</a></h3><p>
		1889	Lua supports the following bitwise operators:
		1890	the binary <code>&</code> (bitwise and),
		1891	<code>\|</code> (bitwise or), <code>~</code> (bitwise exclusive or),
		1892	<code>>></code> (right shift), <code><<</code> (left shift),
		1893	and unary <code>~</code> (bitwise not).
		1894
		1895
		1896	<p>
		1897	All bitwise operations convert its operands to integers
		1898	(see <a href="#3.4.3">§3.4.3</a>),
		1899	operate on all bits of those integers,
		1900	and result in an integer.
		1901
1986		1902
1987	<p>	1903	<p>
1988	Lua provides some automatic conversions between types at run time.	1904	Both right and left shifts fill with zeros the vacant bits.
1989	Most binary operations applied to mixed numbers	1905	Negative displacements shift to the other direction;
		1906	displacements with absolute values equal to or higher than
		1907	the number of bits in an integer
		1908	result in zero (all bits are shifted out).
		1909
		1910
		1911
		1912
		1913
		1914	<h3>3.4.3 – <a name="3.4.3">Coercions and Conversions</a></h3><p>
		1915	Lua provides some automatic conversions between some
		1916	types and representations at run time.
		1917	Most arithmetic operations applied to mixed numbers
1990	(integers and floats) convert the integer operand to a float;	1918	(integers and floats) convert the integer operand to a float;
1991	this is called the <em>usual rule</em>.	1919	this is called the <em>usual rule</em>.
1992	Division always convert integer operands to floats,	1920	Division always convert integer operands to floats;
1993	and integer division always convert floating operands to integers.	1921	integer division and bitwise operators
		1922	always convert float operands to integers.
1994	The C API also converts both integers to floats and	1923	The C API also converts both integers to floats and
1995	floats to integers, as needed.	1924	floats to integers, as needed.
1996	Moreover, string concatenation accepts numbers as arguments,	1925	Moreover, string concatenation accepts numbers as arguments,
@@ -2015,8 +1944,8 @@ This kind of conversion never fails. · 18 unmodified lines
2015	<p>	1944	<p>
2016	The conversion from float to integer	1945	The conversion from float to integer
2017	first takes the floor of the float number.	1946	first takes the floor of the float number.
2018	If that value can be represented as an integer number	1947	If that value can be represented as an integer
2019	(that is, it is in the range of integer numbers),	1948	(that is, it is in the range of integer representation),
2020	that is the result.	1949	that is the result.
2021	Otherwise, the conversion fails.	1950	Otherwise, the conversion fails.
2022		1951
@@ -2027,14 +1956,12 @@ follows the rules of the Lua lexer. · 4 unmodified lines
2027	(The string may have leading and trailing spaces and a sign.)	1956	(The string may have leading and trailing spaces and a sign.)
2028	There is no direct conversion from strings to integers:	1957	There is no direct conversion from strings to integers:
2029	If a string is provided where an integer is needed,	1958	If a string is provided where an integer is needed,
2030	Lua converts the string to a float an then the float to an integer.	1959	Lua converts the string to a float and then the float to an integer.
2031		1960
2032		1961
2033	<p>	1962	<p>
2034	The conversion from numbers to strings use a reasonable,	1963	The conversion from numbers to strings use a human-readable,
2035	non-specified format.	1964	non-specified format.
2036	Floating-point numbers always produce strings with some
2037	floating-point indication (either a decimal dot or an exponent).
2038	For complete control over how numbers are converted to strings,	1965	For complete control over how numbers are converted to strings,
2039	use the <code>format</code> function from the string library	1966	use the <code>format</code> function from the string library
2040	(see <a href="#pdf-string.format"><code>string.format</code></a>).	1967	(see <a href="#pdf-string.format"><code>string.format</code></a>).
@@ -2043,7 +1970,7 @@ use the <code>format</code> function from the string library · 2 unmodified lines
2043		1970
2044		1971
2045		1972
2046	<h3>3.4.3 – <a name="3.4.3">Relational Operators</a></h3><p>	1973	<h3>3.4.4 – <a name="3.4.4">Relational Operators</a></h3><p>
2047	The relational operators in Lua are	1974	The relational operators in Lua are
2048		1975
2049	<pre>	1976	<pre>
@@ -2060,7 +1987,7 @@ Strings are compared in the obvious way. · 10 unmodified lines
2060	Numbers follow the usual rule for binary operations:	1987	Numbers follow the usual rule for binary operations:
2061	if both operands are integers,	1988	if both operands are integers,
2062	the are compared as integers.	1989	the are compared as integers.
2063	Otherwise, they are converted to floating-point numbers	1990	Otherwise, they are converted to floats
2064	and compared as such.	1991	and compared as such.
2065		1992
2066		1993
@@ -2109,7 +2036,7 @@ and <code>a >= b</code> is translated to <code>b <= a</code>. · 42 unmodified lines
2109		2036
2110		2037
2111		2038
2112	<h3>3.4.4 – <a name="3.4.4">Logical Operators</a></h3><p>	2039	<h3>3.4.5 – <a name="3.4.5">Logical Operators</a></h3><p>
2113	The logical operators in Lua are	2040	The logical operators in Lua are
2114	<b>and</b>, <b>or</b>, and <b>not</b>.	2041	<b>and</b>, <b>or</b>, and <b>not</b>.
2115	Like the control structures (see <a href="#3.3.4">§3.3.4</a>),	2042	Like the control structures (see <a href="#3.3.4">§3.3.4</a>),
@@ -2125,7 +2052,7 @@ otherwise, <b>and</b> returns its second argument. · 9 unmodified lines
2125	The disjunction operator <b>or</b> returns its first argument	2052	The disjunction operator <b>or</b> returns its first argument
2126	if this value is different from <b>nil</b> and <b>false</b>;	2053	if this value is different from <b>nil</b> and <b>false</b>;
2127	otherwise, <b>or</b> returns its second argument.	2054	otherwise, <b>or</b> returns its second argument.
2128	Both <b>and</b> and <b>or</b> use short-cut evaluation;	2055	Both <b>and</b> and <b>or</b> use short-circuit evaluation;
2129	that is,	2056	that is,
2130	the second operand is evaluated only if necessary.	2057	the second operand is evaluated only if necessary.
2131	Here are some examples:	2058	Here are some examples:
@@ -2147,18 +2074,18 @@ Here are some examples: · 15 unmodified lines
2147		2074
2148		2075
2149		2076
2150	<h3>3.4.5 – <a name="3.4.5">Concatenation</a></h3><p>	2077	<h3>3.4.6 – <a name="3.4.6">Concatenation</a></h3><p>
2151	The string concatenation operator in Lua is	2078	The string concatenation operator in Lua is
2152	denoted by two dots ('<code>..</code>').	2079	denoted by two dots ('<code>..</code>').
2153	If both operands are strings or numbers, then they are converted to	2080	If both operands are strings or numbers, then they are converted to
2154	strings according to the rules mentioned in <a href="#3.4.2">§3.4.2</a>.	2081	strings according to the rules described in <a href="#3.4.3">§3.4.3</a>.
2155	Otherwise, the <code>__concat</code> metamethod is called (see <a href="#2.4">§2.4</a>).	2082	Otherwise, the <code>__concat</code> metamethod is called (see <a href="#2.4">§2.4</a>).
2156		2083
2157		2084
2158		2085
2159		2086
2160		2087
2161	<h3>3.4.6 – <a name="3.4.6">The Length Operator</a></h3>	2088	<h3>3.4.7 – <a name="3.4.7">The Length Operator</a></h3>
2162		2089
2163	<p>	2090	<p>
2164	The length operator is denoted by the unary prefix operator <code>#</code>.	2091	The length operator is denoted by the unary prefix operator <code>#</code>.
@@ -2196,7 +2123,7 @@ with whether a table is a sequence. · 31 unmodified lines
2196		2123
2197		2124
2198		2125
2199	<h3>3.4.7 – <a name="3.4.7">Precedence</a></h3><p>	2126	<h3>3.4.8 – <a name="3.4.8">Precedence</a></h3><p>
2200	Operator precedence in Lua follows the table below,	2127	Operator precedence in Lua follows the table below,
2201	from lower to higher priority:	2128	from lower to higher priority:
2202		2129
@@ -2220,7 +2147,7 @@ All other binary operators are left associative. · 17 unmodified lines
2220		2147
2221		2148
2222		2149
2223	<h3>3.4.8 – <a name="3.4.8">Table Constructors</a></h3><p>	2150	<h3>3.4.9 – <a name="3.4.9">Table Constructors</a></h3><p>
2224	Table constructors are expressions that create tables.	2151	Table constructors are expressions that create tables.
2225	Every time a constructor is evaluated, a new table is created.	2152	Every time a constructor is evaluated, a new table is created.
2226	A constructor can be used to create an empty table	2153	A constructor can be used to create an empty table
@@ -2268,7 +2195,7 @@ is equivalent to · 41 unmodified lines
2268	If the last field in the list has the form <code>exp</code>	2195	If the last field in the list has the form <code>exp</code>
2269	and the expression is a function call or a vararg expression,	2196	and the expression is a function call or a vararg expression,
2270	then all values returned by this expression enter the list consecutively	2197	then all values returned by this expression enter the list consecutively
2271	(see <a href="#3.4.9">§3.4.9</a>).	2198	(see <a href="#3.4.10">§3.4.10</a>).
2272		2199
2273		2200
2274	<p>	2201	<p>
@@ -2279,7 +2206,7 @@ as a convenience for machine-generated code. · 4 unmodified lines
2279		2206
2280		2207
2281		2208
2282	<h3>3.4.9 – <a name="3.4.9">Function Calls</a></h3><p>	2209	<h3>3.4.10 – <a name="3.4.10">Function Calls</a></h3><p>
2283	A function call in Lua has the following syntax:	2210	A function call in Lua has the following syntax:
2284		2211
2285	<pre>	2212	<pre>
@@ -2354,7 +2281,7 @@ So, none of the following examples are tail calls: · 68 unmodified lines
2354		2281
2355		2282
2356		2283
2357	<h3>3.4.10 – <a name="3.4.10">Function Definitions</a></h3>	2284	<h3>3.4.11 – <a name="3.4.11">Function Definitions</a></h3>
2358		2285
2359	<p>	2286	<p>
2360	The syntax for function definition is	2287	The syntax for function definition is
@@ -3046,8 +2973,8 @@ it seems to be a safe assumption.) · 685 unmodified lines
3046	<pre>void lua_arith (lua_State *L, int op);</pre>	2973	<pre>void lua_arith (lua_State *L, int op);</pre>
3047		2974
3048	<p>	2975	<p>
3049	Performs an arithmetic operation over the two values	2976	Performs an arithmetic or bitwise operation over the two values
3050	(or one, in the case of negation)	2977	(or one, in the case of negations)
3051	at the top of the stack,	2978	at the top of the stack,
3052	with the value at the top being the second operand,	2979	with the value at the top being the second operand,
3053	pops these values, and pushes the result of the operation.	2980	pops these values, and pushes the result of the operation.
@@ -3064,9 +2991,16 @@ The value of <code>op</code> must be one of the following constants: · 10 unmodified lines
3064	<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>	2991	<li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>
3065	<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>	2992	<li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>
3066	<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs division (<code>/</code>)</li>	2993	<li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs division (<code>/</code>)</li>
		2994	<li><b><a name="pdf-LUA_OPIDIV"><code>LUA_OPIDIV</code></a>: </b> performs integer division (<code>//</code>)</li>
3067	<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>	2995	<li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>
3068	<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>	2996	<li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>
3069	<li><b><a name="pdf-LUA_OPUNM"><code>LUA_OPUNM</code></a>: </b> performs mathematical negation (unary <code>-</code>)</li>	2997	<li><b><a name="pdf-LUA_OPUNM"><code>LUA_OPUNM</code></a>: </b> performs mathematical negation (unary <code>-</code>)</li>
		2998	<li><b><a name="pdf-LUA_OPBNOT"><code>LUA_OPBNOT</code></a>: </b> performs bitwise negation (<code>~</code>)</li>
		2999	<li><b><a name="pdf-LUA_OPBAND"><code>LUA_OPBAND</code></a>: </b> performs bitwise and (<code>&</code>)</li>
		3000	<li><b><a name="pdf-LUA_OPBOR"><code>LUA_OPBOR</code></a>: </b> performs bitwise or (<code>\|</code>)</li>
		3001	<li><b><a name="pdf-LUA_OPBXOR"><code>LUA_OPBXOR</code></a>: </b> performs bitwise exclusive or (<code>~</code>)</li>
		3002	<li><b><a name="pdf-LUA_OPSHL"><code>LUA_OPSHL</code></a>: </b> performs left shift (<code><<</code>)</li>
		3003	<li><b><a name="pdf-LUA_OPSHR"><code>LUA_OPSHR</code></a>: </b> performs right shift (<code>>></code>)</li>
3070		3004
3071	</ul>	3005	</ul>
3072		3006
@@ -3283,7 +3217,7 @@ If <code>n</code> is 1, the result is the single value on the stack · 210 unmodified lines
3283	(that is, the function does nothing);	3217	(that is, the function does nothing);
3284	if <code>n</code> is 0, the result is the empty string.	3218	if <code>n</code> is 0, the result is the empty string.
3285	Concatenation is performed following the usual semantics of Lua	3219	Concatenation is performed following the usual semantics of Lua
3286	(see <a href="#3.4.5">§3.4.5</a>).	3220	(see <a href="#3.4.6">§3.4.6</a>).
3287		3221
3288		3222
3289		3223
@@ -3404,24 +3338,18 @@ memory in use by Lua by 1024. · 114 unmodified lines
3404		3338
3405	<li><b><code>LUA_GCSTEP</code>: </b>	3339	<li><b><code>LUA_GCSTEP</code>: </b>
3406	performs an incremental step of garbage collection.	3340	performs an incremental step of garbage collection.
3407	The step "size" is controlled by <code>data</code>
3408	(larger values mean more steps) in a non-specified way.
3409	If you want to control the step size
3410	you must experimentally tune the value of <code>data</code>.
3411	The function returns 1 if the step finished a
3412	garbage-collection cycle.
3413	</li>	3341	</li>
3414		3342
3415	<li><b><code>LUA_GCSETPAUSE</code>: </b>	3343	<li><b><code>LUA_GCSETPAUSE</code>: </b>
3416	sets <code>data</code> as the new value	3344	sets <code>data</code> as the new value
3417	for the <em>pause</em> of the collector (see <a href="#2.5">§2.5</a>).	3345	for the <em>pause</em> of the collector (see <a href="#2.5">§2.5</a>)
3418	The function returns the previous value of the pause.	3346	and returns the previous value of the pause.
3419	</li>	3347	</li>
3420		3348
3421	<li><b><code>LUA_GCSETSTEPMUL</code>: </b>	3349	<li><b><code>LUA_GCSETSTEPMUL</code>: </b>
3422	sets <code>data</code> as the new value for the <em>step multiplier</em> of	3350	sets <code>data</code> as the new value for the <em>step multiplier</em> of
3423	the collector (see <a href="#2.5">§2.5</a>).	3351	the collector (see <a href="#2.5">§2.5</a>)
3424	The function returns the previous value of the step multiplier.	3352	and returns the previous value of the step multiplier.
3425	</li>	3353	</li>
3426		3354
3427	<li><b><code>LUA_GCISRUNNING</code>: </b>	3355	<li><b><code>LUA_GCISRUNNING</code>: </b>
@@ -3429,16 +3357,6 @@ returns a boolean that tells whether the collector is running · 1 unmodified line
3429	(i.e., not stopped).	3357	(i.e., not stopped).
3430	</li>	3358	</li>
3431		3359
3432	<li><b><code>LUA_GCGEN</code>: </b>
3433	changes the collector to generational mode
3434	(see <a href="#2.5">§2.5</a>).
3435	</li>
3436
3437	<li><b><code>LUA_GCINC</code>: </b>
3438	changes the collector to incremental mode.
3439	This is the default mode.
3440	</li>
3441
3442	</ul>	3360	</ul>
3443		3361
3444	<p>	3362	<p>
@@ -3514,10 +3432,11 @@ for the "index" event (see <a href="#2.4">§2.4</a>). · 69 unmodified lines
3514		3432
3515	<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>	3433	<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
3516	<span class="apii">[-0, +1, <em>e</em>]</span>	3434	<span class="apii">[-0, +1, <em>e</em>]</span>
3517	<pre>void lua_getglobal (lua_State L, const char name);</pre>	3435	<pre>int lua_getglobal (lua_State L, const char name);</pre>
3518		3436
3519	<p>	3437	<p>
3520	Pushes onto the stack the value of the global <code>name</code>.	3438	Pushes onto the stack the value of the global <code>name</code>.
		3439	Returns the type of that value.
3521		3440
3522		3441
3523		3442
@@ -3538,7 +3457,7 @@ the function returns 0 and pushes nothing on the stack. · 14 unmodified lines
3538		3457
3539	<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>	3458	<hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
3540	<span class="apii">[-1, +1, <em>e</em>]</span>	3459	<span class="apii">[-1, +1, <em>e</em>]</span>
3541	<pre>void lua_gettable (lua_State *L, int index);</pre>	3460	<pre>int lua_gettable (lua_State *L, int index);</pre>
3542		3461
3543	<p>	3462	<p>
3544	Pushes onto the stack the value <code>t[k]</code>,	3463	Pushes onto the stack the value <code>t[k]</code>,
@@ -3553,6 +3472,10 @@ As in Lua, this function may trigger a metamethod · 8 unmodified lines
3553	for the "index" event (see <a href="#2.4">§2.4</a>).	3472	for the "index" event (see <a href="#2.4">§2.4</a>).
3554		3473
3555		3474
		3475	<p>
		3476	Returns the type of the pushed value.
		3477
		3478
3556		3479
3557		3480
3558		3481
@@ -3577,7 +3500,6 @@ this result is equal to the number of elements in the stack · 18 unmodified lines
3577	<p>	3500	<p>
3578	Pushes onto the stack the Lua value associated with the userdata	3501	Pushes onto the stack the Lua value associated with the userdata
3579	at the given index.	3502	at the given index.
3580	This Lua value must be a table or <b>nil</b>.
3581		3503
3582		3504
3583		3505
@@ -3598,17 +3520,18 @@ because a pseudo-index is not an actual stack position. · 14 unmodified lines
3598		3520
3599		3521
3600	<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>	3522	<hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
3601	<pre>typedef ptrdiff_t lua_Integer;</pre>	3523	<pre>typedef long long int lua_Integer;</pre>
3602		3524
3603	<p>	3525	<p>
3604	The type of integer numbers in Lua.	3526	The type of integers in Lua.
3605		3527
3606		3528
3607	<p>	3529	<p>
3608	By default it is defined as <code>long long</code>,	3530	By default this type is <code>long long</code>
3609	usually a 64-bit two-complement integer,	3531	(usually a 64-bit two-complement integer),
3610	but it can also be <code>long</code> or <code>int</code>,	3532	but that can be changed in <code>luaconf.h</code>
3611	usually a 32-bit two-complement integer.	3533	to <code>long</code> or <code>int</code>
		3534	(usually a 32-bit two-complement integer).
3612		3535
3613		3536
3614		3537
@@ -3780,7 +3703,7 @@ Returns 1 if the value at the given index is a userdata · 165 unmodified lines
3780		3703
3781	<p>	3704	<p>
3782	Returns the "length" of the value at the given index;	3705	Returns the "length" of the value at the given index;
3783	it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">§3.4.6</a>).	3706	it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">§3.4.7</a>).
3784	The result is pushed on the stack.	3707	The result is pushed on the stack.
3785		3708
3786		3709
@@ -3973,8 +3896,11 @@ the table during its traversal. · 186 unmodified lines
3973	<pre>typedef double lua_Number;</pre>	3896	<pre>typedef double lua_Number;</pre>
3974		3897
3975	<p>	3898	<p>
3976	The type of floating-point numbers in Lua.	3899	The type of floats in Lua.
3977	By default, it is double,	3900
		3901
		3902	<p>
		3903	By default this type is double,
3978	but that can be changed in <code>luaconf.h</code> to a single float.	3904	but that can be changed in <code>luaconf.h</code> to a single float.
3979		3905
3980		3906
@@ -4183,12 +4109,14 @@ the result is a Lua string and Lua takes care of memory allocation · 202 unmodified lines
4183	The conversion specifiers are quite restricted.	4109	The conversion specifiers are quite restricted.
4184	There are no flags, widths, or precisions.	4110	There are no flags, widths, or precisions.
4185	The conversion specifiers can only be	4111	The conversion specifiers can only be
4186	'<code>%%</code>' (inserts a '<code>%</code>' in the string),	4112	'<code>%%</code>' (inserts the character '<code>%</code>'),
4187	'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),	4113	'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions),
4188	'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),	4114	'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>),
		4115	'<code>%L</code>' (inserts a <a href="#lua_Integer"><code>lua_Integer</code></a>),
4189	'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),	4116	'<code>%p</code>' (inserts a pointer as a hexadecimal numeral),
4190	'<code>%d</code>' (inserts an <code>int</code>), and	4117	'<code>%d</code>' (inserts an <code>int</code>),
4191	'<code>%c</code>' (inserts an <code>int</code> as a byte).	4118	'<code>%c</code>' (inserts an <code>int</code> as a one-byte character), and
		4119	'<code>%U</code>' (inserts an <code>int</code> as a UTF-8 byte sequence).
4192	</li>	4120	</li>
4193		4121
4194	</ul>	4122	</ul>
@@ -4289,7 +4217,7 @@ Pushes a nil value onto the stack. · 94 unmodified lines
4289	<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>	4217	<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre>
4290		4218
4291	<p>	4219	<p>
4292	Pushes a number with value <code>n</code> onto the stack.	4220	Pushes a float with value <code>n</code> onto the stack.
4293		4221
4294		4222
4295		4223
@@ -4335,7 +4263,7 @@ Returns 1 if this thread is the main thread of its state. · 39 unmodified lines
4335	<pre>void lua_pushunsigned (lua_State *L, lua_Unsigned n);</pre>	4263	<pre>void lua_pushunsigned (lua_State *L, lua_Unsigned n);</pre>
4336		4264
4337	<p>	4265	<p>
4338	Pushes a number with value <code>n</code> onto the stack.	4266	Pushes an integer with value <code>n</code> onto the stack.
4339		4267
4340		4268
4341		4269
@@ -4384,7 +4312,7 @@ Also returns 0 if any of the indices are non valid. · 42 unmodified lines
4384		4312
4385	<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>	4313	<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p>
4386	<span class="apii">[-1, +1, –]</span>	4314	<span class="apii">[-1, +1, –]</span>
4387	<pre>void lua_rawget (lua_State *L, int index);</pre>	4315	<pre>int lua_rawget (lua_State *L, int index);</pre>
4388		4316
4389	<p>	4317	<p>
4390	Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access	4318	Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access
@@ -4396,7 +4324,7 @@ Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw · 5 unmodified lines
4396		4324
4397	<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>	4325	<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p>
4398	<span class="apii">[-0, +1, –]</span>	4326	<span class="apii">[-0, +1, –]</span>
4399	<pre>void lua_rawgeti (lua_State *L, int index, lua_Integer n);</pre>	4327	<pre>int lua_rawgeti (lua_State *L, int index, lua_Integer n);</pre>
4400		4328
4401	<p>	4329	<p>
4402	Pushes onto the stack the value <code>t[n]</code>,	4330	Pushes onto the stack the value <code>t[n]</code>,
@@ -4405,12 +4333,16 @@ The access is raw; · 2 unmodified lines
4405	that is, it does not invoke metamethods.	4333	that is, it does not invoke metamethods.
4406		4334
4407		4335
		4336	<p>
		4337	Returns the type of the pushed value.
		4338
		4339
4408		4340
4409		4341
4410		4342
4411	<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p>	4343	<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p>
4412	<span class="apii">[-0, +1, –]</span>	4344	<span class="apii">[-0, +1, –]</span>
4413	<pre>void lua_rawgetp (lua_State L, int index, const void p);</pre>	4345	<pre>int lua_rawgetp (lua_State L, int index, const void p);</pre>
4414		4346
4415	<p>	4347	<p>
4416	Pushes onto the stack the value <code>t[k]</code>,	4348	Pushes onto the stack the value <code>t[k]</code>,
@@ -4420,6 +4352,10 @@ The access is raw; · 3 unmodified lines
4420	that is, it does not invoke metamethods.	4352	that is, it does not invoke metamethods.
4421		4353
4422		4354
		4355	<p>
		4356	Returns the type of the pushed value.
		4357
		4358
4423		4359
4424		4360
4425		4361
@@ -4699,7 +4635,7 @@ If <code>index</code> is 0, then all stack elements are removed. · 273 unmodified lines
4699	<pre>void lua_setuservalue (lua_State *L, int index);</pre>	4635	<pre>void lua_setuservalue (lua_State *L, int index);</pre>
4700		4636
4701	<p>	4637	<p>
4702	Pops a table or <b>nil</b> from the stack and sets it as	4638	Pops a value from the stack and sets it as
4703	the new value associated to the userdata at the given index.	4639	the new value associated to the userdata at the given index.
4704		4640
4705		4641
@@ -4818,7 +4754,7 @@ Equivalent to <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> with <co · 112 unmodified lines
4818	Converts the Lua value at the given index	4754	Converts the Lua value at the given index
4819	to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.	4755	to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>.
4820	The Lua value must be an integer,	4756	The Lua value must be an integer,
4821	or a number or string convertible to an integer (see <a href="#3.4.2">§3.4.2</a>);	4757	or a number or string convertible to an integer (see <a href="#3.4.3">§3.4.3</a>);
4822	otherwise, <code>lua_tointegerx</code> returns 0.	4758	otherwise, <code>lua_tointegerx</code> returns 0.
4823		4759
4824		4760
@@ -4881,7 +4817,7 @@ Equivalent to <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> with <code · 56 unmodified lines
4881	Converts the Lua value at the given index	4817	Converts the Lua value at the given index
4882	to the C type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).	4818	to the C type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>).
4883	The Lua value must be a number or a string convertible to a number	4819	The Lua value must be a number or a string convertible to a number
4884	(see <a href="#3.4.2">§3.4.2</a>);	4820	(see <a href="#3.4.3">§3.4.3</a>);
4885	otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns 0.	4821	otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns 0.
4886		4822
4887		4823
@@ -4960,7 +4896,7 @@ to the unsigned integral type <a href="#lua_Unsigned"><code>lua_Unsigned</code>< · 72 unmodified lines
4960	The Lua value must be an integer,	4896	The Lua value must be an integer,
4961	or a float,	4897	or a float,
4962	or a string convertible to a number	4898	or a string convertible to a number
4963	(see <a href="#3.4.2">§3.4.2</a>);	4899	(see <a href="#3.4.3">§3.4.3</a>);
4964	otherwise, <code>lua_tounsignedx</code> returns 0.	4900	otherwise, <code>lua_tounsignedx</code> returns 0.
4965		4901
4966		4902
@@ -5544,7 +5480,7 @@ calling <a href="#lua_yield"><code>lua_yield</code></a> with <code>nresults</cod · 577 unmodified lines
5544		5480
5545	<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>	5481	<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p>
5546	<span class="apii">[-0, +0, –]</span>	5482	<span class="apii">[-0, +0, –]</span>
5547	<pre>int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>	5483	<pre>void lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre>
5548		5484
5549	<p>	5485	<p>
5550	Sets the debugging hook function.	5486	Sets the debugging hook function.
@@ -5779,7 +5715,6 @@ buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>). · 228 unmodified lines
5779	Adds the zero-terminated string pointed to by <code>s</code>	5715	Adds the zero-terminated string pointed to by <code>s</code>
5780	to the buffer <code>B</code>	5716	to the buffer <code>B</code>
5781	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).	5717	(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).
5782	The string cannot contain embedded zeros.
5783		5718
5784		5719
5785		5720
@@ -5814,7 +5749,7 @@ which is the value to be added to the buffer. · 28 unmodified lines
5814		5749
5815	<p>	5750	<p>
5816	Checks whether <code>cond</code> is true.	5751	Checks whether <code>cond</code> is true.
5817	If not, raises an error with a standard message.	5752	If it is not, raises an error with a standard message (see <a href="#luaL_argerror"><code>luaL_argerror</code></a>).
5818		5753
5819		5754
5820		5755
@@ -5825,14 +5760,15 @@ If not, raises an error with a standard message. · 4 unmodified lines
5825	<pre>int luaL_argerror (lua_State L, int arg, const char extramsg);</pre>	5760	<pre>int luaL_argerror (lua_State L, int arg, const char extramsg);</pre>
5826		5761
5827	<p>	5762	<p>
5828	Raises an error with a standard message	5763	Raises an error reporting a problem with argument <code>arg</code>
5829	that includes <code>extramsg</code> as a comment.	5764	of the C function that called it,
5830		5765	using a standard message
		5766	that includes <code>extramsg</code> as a comment:
5831		5767
5832	<p>	5768	<pre>
5833	This function never returns,	5769	bad argument #<em>arg</em> to '<em>funcname</em>' (<em>extramsg</em>)
5834	but it is an idiom to use it in C functions	5770	</pre><p>
5835	as <code>return luaL_argerror(<em>args</em>)</code>.	5771	This function never returns.
5836		5772
5837		5773
5838		5774
@@ -6304,7 +6240,7 @@ Pushes the resulting string on the stack and returns it. · 465 unmodified lines
6304	<p>	6240	<p>
6305	Returns the "length" of the value at the given index	6241	Returns the "length" of the value at the given index
6306	as a number;	6242	as a number;
6307	it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">§3.4.6</a>).	6243	it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">§3.4.7</a>).
6308	Raises an error if the result of the operation is not an integer.	6244	Raises an error if the result of the operation is not an integer.
6309	(This case only can happen through metamethods.)	6245	(This case only can happen through metamethods.)
6310		6246
@@ -6461,7 +6397,8 @@ If the registry already has the key <code>tname</code>, · 150 unmodified lines
6461	returns 0.	6397	returns 0.
6462	Otherwise,	6398	Otherwise,
6463	creates a new table to be used as a metatable for userdata,	6399	creates a new table to be used as a metatable for userdata,
6464	adds it to the registry with key <code>tname</code>,	6400	adds to this new table the pair <code>__name = tname</code>,
		6401	adds to the registry the pair <code></code>[tname] = new table,
6465	and returns 1.	6402	and returns 1.
6466		6403
6467		6404
@@ -6781,6 +6718,43 @@ in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code> · 313 unmodified lines
6781		6718
6782		6719
6783		6720
		6721	<hr><h3><a name="luaL_Stream"><code>luaL_Stream</code></a></h3>
		6722	<pre>typedef struct luaL_Stream {
		6723	FILE *f;
		6724	lua_CFunction closef;
		6725	} luaL_Stream;</pre>
		6726
		6727	<p>
		6728	The standard representation for file handles,
		6729	which is used by the standard I/O library.
		6730
		6731
		6732	<p>
		6733	A file handle is implemented as a full userdata,
		6734	with a metatable called <code>LUA_FILEHANDLE</code>.
		6735	<code>LUA_FILEHANDLE</code> is a macro with the actual metatable's name.
		6736	The metatable is created by the I/O library
		6737	(see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
		6738
		6739
		6740	<p>
		6741	This userdata must start with the structure <code>luaL_Stream</code>;
		6742	it can contain other data after this initial structure.
		6743	Field <code>f</code> points to the corresponding C stream
		6744	(or it can be <code>NULL</code> to indicate an incompletely created handle).
		6745	Field <code>closef</code> points to a Lua function
		6746	that will be called to close the stream
		6747	when the handle is closed or collected;
		6748	this function receives the file handle as its sole argument and
		6749	must return either <b>true</b> (in case of success)
		6750	or <b>nil</b> plus an error message (in case of error).
		6751	Once Lua calls this field,
		6752	the field value is changed to <b>nil</b> to signal that the handle is closed.
		6753
		6754
		6755
		6756
		6757
6784	<hr><h3><a name="luaL_testudata"><code>luaL_testudata</code></a></h3><p>	6758	<hr><h3><a name="luaL_testudata"><code>luaL_testudata</code></a></h3><p>
6785	<span class="apii">[-0, +0, <em>e</em>]</span>	6759	<span class="apii">[-0, +0, <em>e</em>]</span>
6786	<pre>void luaL_testudata (lua_State L, int arg, const char *tname);</pre>	6760	<pre>void luaL_testudata (lua_State L, int arg, const char *tname);</pre>
@@ -6888,8 +6862,6 @@ This function is used to build a prefix for error messages. · 101 unmodified lines
6888		6862
6889		6863
6890		6864
6891
6892
6893	<h1>6 – <a name="6">Standard Libraries</a></h1>	6865	<h1>6 – <a name="6">Standard Libraries</a></h1>
6894		6866
6895	<p>	6867	<p>
@@ -6918,11 +6890,11 @@ Currently, Lua has the following standard libraries: · 22 unmodified lines
6918		6890
6919	<li>string manipulation (<a href="#6.4">§6.4</a>);</li>	6891	<li>string manipulation (<a href="#6.4">§6.4</a>);</li>
6920		6892
6921	<li>table manipulation (<a href="#6.5">§6.5</a>);</li>	6893	<li>basic UTF-8 support (<a href="#6.5">§6.5</a>);</li>
6922		6894
6923	<li>mathematical functions (<a href="#6.6">§6.6</a>) (sin, log, etc.);</li>	6895	<li>table manipulation (<a href="#6.6">§6.6</a>);</li>
6924		6896
6925	<li>bitwise operations (<a href="#6.7">§6.7</a>);</li>	6897	<li>mathematical functions (<a href="#6.7">§6.7</a>) (sin, log, etc.);</li>
6926		6898
6927	<li>input and output (<a href="#6.8">§6.8</a>);</li>	6899	<li>input and output (<a href="#6.8">§6.8</a>);</li>
6928		6900
@@ -6949,7 +6921,6 @@ the host program can open them individually by using · 20 unmodified lines
6949	<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),	6921	<a name="pdf-luaopen_string"><code>luaopen_string</code></a> (for the string library),
6950	<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),	6922	<a name="pdf-luaopen_table"><code>luaopen_table</code></a> (for the table library),
6951	<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),	6923	<a name="pdf-luaopen_math"><code>luaopen_math</code></a> (for the mathematical library),
6952	<a name="pdf-luaopen_bit32"><code>luaopen_bit32</code></a> (for the bit library),
6953	<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),	6924	<a name="pdf-luaopen_io"><code>luaopen_io</code></a> (for the I/O library),
6954	<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the Operating System library),	6925	<a name="pdf-luaopen_os"><code>luaopen_os</code></a> (for the Operating System library),
6955	and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).	6926	and <a name="pdf-luaopen_debug"><code>luaopen_debug</code></a> (for the debug library).
@@ -7003,25 +6974,21 @@ restarts automatic execution of the garbage collector. · 47 unmodified lines
7003	</li>	6974	</li>
7004		6975
7005	<li><b>"<code>count</code>": </b>	6976	<li><b>"<code>count</code>": </b>
7006	returns the total memory in use by Lua (in Kbytes) and	6977	returns the total memory in use by Lua in Kbytes.
7007	a second value with the total memory in bytes modulo 1024.	6978	The value has a fractional part,
7008	The first value has a fractional part,	6979	so that it multiplied by 1024
7009	so the following equality is always true:	6980	gives the exact number of bytes in use by Lua
7010		6981	(except for overflows).
7011	<pre>
7012	k, b = collectgarbage("count")
7013	assert(k1024 == math.floor(k)1024 + b)
7014	</pre><p>
7015	(The second result is useful when Lua is compiled
7016	with a non floating-point type for numbers.)
7017	</li>	6982	</li>
7018		6983
7019	<li><b>"<code>step</code>": </b>	6984	<li><b>"<code>step</code>": </b>
7020	performs a garbage-collection step.	6985	performs a garbage-collection step.
7021	The step "size" is controlled by <code>arg</code>	6986	The step "size" is controlled by <code>arg</code>.
7022	(larger values mean more steps) in a non-specified way.	6987	With a zero value,
7023	If you want to control the step size	6988	the collector will perform one basic (indivisible) step.
7024	you must experimentally tune the value of <code>arg</code>.	6989	For non-zero values,
		6990	the collector will perform as if that amount of memory
		6991	(in KBytes) had been allocated by Lua.
7025	Returns <b>true</b> if the step finished a collection cycle.	6992	Returns <b>true</b> if the step finished a collection cycle.
7026	</li>	6993	</li>
7027		6994
@@ -7095,7 +7062,7 @@ A global variable (not a function) that · 67 unmodified lines
7095	holds the global environment (see <a href="#2.2">§2.2</a>).	7062	holds the global environment (see <a href="#2.2">§2.2</a>).
7096	Lua itself does not use this variable;	7063	Lua itself does not use this variable;
7097	changing its value does not affect any environment,	7064	changing its value does not affect any environment,
7098	nor vice-versa.	7065	nor vice versa.
7099		7066
7100		7067
7101		7068
@@ -7190,6 +7157,12 @@ or "<code>bt</code>" (both binary and text). · 88 unmodified lines
7190	The default is "<code>bt</code>".	7157	The default is "<code>bt</code>".
7191		7158
7192		7159
		7160	<p>
		7161	Lua does not check the consistency of binary chunks.
		7162	Maliciously crafted binary chunks can crash
		7163	the interpreter.
		7164
		7165
7193		7166
7194		7167
7195	<p>	7168	<p>
@@ -7328,7 +7301,7 @@ without invoking any metamethod. · 132 unmodified lines
7328	Returns the length of the object <code>v</code>,	7301	Returns the length of the object <code>v</code>,
7329	which must be a table or a string,	7302	which must be a table or a string,
7330	without invoking any metamethod.	7303	without invoking any metamethod.
7331	Returns an integer number.	7304	Returns an integer.
7332		7305
7333		7306
7334		7307
@@ -7417,7 +7390,9 @@ the function returns <b>nil</b>. · 82 unmodified lines
7417	<p>	7390	<p>
7418	<hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3>	7391	<hr><h3><a name="pdf-tostring"><code>tostring (v)</code></a></h3>
7419	Receives a value of any type and	7392	Receives a value of any type and
7420	converts it to a string in a reasonable format.	7393	converts it to a string in a human-readable format.
		7394	Floats always produce strings with some
		7395	floating-point indication (either a decimal dot or an exponent).
7421	(For complete control of how numbers are converted,	7396	(For complete control of how numbers are converted,
7422	use <a href="#pdf-string.format"><code>string.format</code></a>.)	7397	use <a href="#pdf-string.format"><code>string.format</code></a>.)
7423		7398
@@ -7451,7 +7426,7 @@ and "<code>userdata</code>". · 27 unmodified lines
7451	<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>	7426	<hr><h3><a name="pdf-_VERSION"><code>_VERSION</code></a></h3>
7452	A global variable (not a function) that	7427	A global variable (not a function) that
7453	holds a string containing the current interpreter version.	7428	holds a string containing the current interpreter version.
7454	The current contents of this variable is "<code>Lua 5.3</code>".	7429	The current value of this variable is "<code>Lua 5.3</code>".
7455		7430
7456		7431
7457		7432
@@ -7981,13 +7956,19 @@ Numerical codes are not necessarily portable across platforms. · 523 unmodified lines
7981		7956
7982		7957
7983	<p>	7958	<p>
7984	<hr><h3><a name="pdf-string.dump"><code>string.dump (function)</code></a></h3>	7959	<hr><h3><a name="pdf-string.dump"><code>string.dump (function [, strip])</code></a></h3>
7985		7960
7986		7961
7987	<p>	7962	<p>
7988	Returns a string containing a binary representation of the given function,	7963	Returns a string containing a binary representation
		7964	(a <em>binary chunk</em>)
		7965	of the given function,
7989	so that a later <a href="#pdf-load"><code>load</code></a> on this string returns	7966	so that a later <a href="#pdf-load"><code>load</code></a> on this string returns
7990	a copy of the function (but with new upvalues).	7967	a copy of the function (but with new upvalues).
		7968	If <code>strip</code> is a true value,
		7969	the binary representation is created without debug information
		7970	about the function
		7971	(local variable names, lines, etc.).
7991		7972
7992		7973
7993		7974
@@ -8055,11 +8036,7 @@ Options · 61 unmodified lines
8055	<code>G</code>, and <code>g</code> all expect a number as argument.	8036	<code>G</code>, and <code>g</code> all expect a number as argument.
8056	Options <code>c</code>, <code>d</code>,	8037	Options <code>c</code>, <code>d</code>,
8057	<code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>	8038	<code>i</code>, <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>
8058	also expect a number,	8039	expect an integer.
8059	but the range of that number may be limited by
8060	the underlying C implementation.
8061	For options <code>o</code>, <code>u</code>, <code>X</code>, and <code>x</code>,
8062	the number cannot be negative.
8063	Option <code>q</code> expects a string;	8040	Option <code>q</code> expects a string;
8064	option <code>s</code> expects a string without embedded zeros.	8041	option <code>s</code> expects a string without embedded zeros.
8065	If the argument to option <code>s</code> is not a string,	8042	If the argument to option <code>s</code> is not a string,
@@ -8175,9 +8152,9 @@ Here are some examples: · 109 unmodified lines
8175	end)	8152	end)
8176	--> x="4+5 = 9"	8153	--> x="4+5 = 9"
8177		8154
8178	local t = {name="lua", version="5.2"}	8155	local t = {name="lua", version="5.3"}
8179	x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)	8156	x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
8180	--> x="lua-5.2.tar.gz"	8157	--> x="lua-5.3.tar.gz"
8181	</pre>	8158	</pre>
8182		8159
8183		8160
@@ -8218,6 +8195,45 @@ its default value is 1 and can be negative. · 34 unmodified lines
8218		8195
8219		8196
8220		8197
		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
8221	<p>	8237	<p>
8222	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>	8238	<hr><h3><a name="pdf-string.rep"><code>string.rep (s, n [, sep])</code></a></h3>
8223	Returns a string that is the concatenation of <code>n</code> copies of	8239	Returns a string that is the concatenation of <code>n</code> copies of
@@ -8262,6 +8278,28 @@ the function returns the empty string. · 38 unmodified lines
8262		8278
8263		8279
8264		8280
		8281	<p>
		8282	<hr><h3><a name="pdf-string.unpackfloat"><code>string.unpackfloat (s [, pos [, size [, endianess]]])</code></a></h3>
		8283	Reads the machine representation of a float starting at position
		8284	<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>.
		8286
		8287
		8288
		8289
		8290	<p>
		8291	<hr><h3><a name="pdf-string.unpackint"><code>string.unpackint (s [, pos [, size [, endianess]]])</code></a></h3>
		8292	Reads the machine representation of an integer starting at position
		8293	<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>.
		8295
		8296
		8297	<p>
		8298	Integers are always read as signed.
		8299
		8300
		8301
		8302
8265	<p>	8303	<p>
8266	<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>	8304	<hr><h3><a name="pdf-string.upper"><code>string.upper (s)</code></a></h3>
8267	Receives a string and returns a copy of this string with all	8305	Receives a string and returns a copy of this string with all
@@ -8321,7 +8359,7 @@ represents the class which is the union of all · 53 unmodified lines
8321	characters in <em>set</em>.	8359	characters in <em>set</em>.
8322	A range of characters can be specified by	8360	A range of characters can be specified by
8323	separating the end characters of the range,	8361	separating the end characters of the range,
8324	in ascending order, with a '<code>-</code>',	8362	in ascending order, with a '<code>-</code>'.
8325	All classes <code>%</code><em>x</em> described above can also be used as	8363	All classes <code>%</code><em>x</em> described above can also be used as
8326	components in <em>set</em>.	8364	components in <em>set</em>.
8327	All other characters in <em>set</em> represent themselves.	8365	All other characters in <em>set</em> represent themselves.
@@ -8466,48 +8504,151 @@ string <code>"flaaap"</code>, there will be two captures: 3 and 5. · 138 unmodified lines
8466		8504
8467		8505
8468		8506
8469	<h2>6.5 – <a name="6.5">Table Manipulation</a></h2>	8507	<h2>6.5 – <a name="6.5">UTF-8 Support</a></h2>
8470		8508
8471	<p>	8509	<p>
8472	This library provides generic functions for table manipulation.	8510	This library provides basic support for UTF-8 encoding.
8473	It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.	8511	It provides all its functions inside the table <a name="pdf-utf8"><code>utf8</code></a>.
		8512	This library does not provide any support for Unicode other
		8513	than the handling of the encoding.
		8514	Any operation that needs the meaning of a character,
		8515	such as character classification, is outside its scope.
8474		8516
8475		8517
8476	<p>	8518	<p>
8477	Remember that, whenever an operation needs the length of a table,	8519	Unless stated otherwise,
8478	the table should be a proper sequence	8520	all functions that expect a byte index as a parameter
8479	or have a <code>__len</code> metamethod (see <a href="#3.4.6">§3.4.6</a>).	8521	assume that the given position is either the start of a byte sequence
8480	All functions ignore non-numeric keys	8522	or one plus the length of the subject string.
8481	in tables given as arguments.	8523	As in the string library,
		8524	negative indices count from the end of the string.
8482		8525
8483		8526
8484	<p>	8527	<p>
8485	For performance reasons,	8528	<hr><h3><a name="pdf-utf8.char"><code>utf8.char (···)</code></a></h3>
8486	all table accesses (get/set) performed by these functions are raw.	8529	Receives zero or more integers,
		8530	converts each one to its corresponding UTF-8 byte sequence
		8531	and returns a string with the concatenation of all these sequences.
8487		8532
8488		8533
8489	<p>
8490	<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
8491		8534
8492		8535
8493	<p>	8536	<p>
8494	Given a list where all elements are strings or numbers,	8537	<hr><h3><a name="pdf-utf8.charpatt"><code>utf8.charpatt</code></a></h3>
8495	returns the string <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>.	8538	The pattern (a string, not a function) "<code>[\0-\x7F\xC2-\xF4][\x80-\xBF]*</code>"
8496	The default value for <code>sep</code> is the empty string,	8539	(see <a href="#6.4.1">§6.4.1</a>),
8497	the default for <code>i</code> is 1,	8540	which matches exactly one UTF-8 byte sequence,
8498	and the default for <code>j</code> is <code>#list</code>.	8541	assuming that the subject is a valid UTF-8 string.
8499	If <code>i</code> is greater than <code>j</code>, returns the empty string.
8500		8542
8501		8543
8502		8544
8503		8545
8504	<p>	8546	<p>
8505	<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>	8547	<hr><h3><a name="pdf-utf8.codes"><code>utf8.codes (s)</code></a></h3>
8506		8548
8507		8549
8508	<p>	8550	<p>
8509	Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,	8551	Returns values so that the construction
8510	shifting up the elements	8552
		8553	<pre>
		8554	for p, c in utf8.codes(s) do <em>body</em> end
		8555	</pre><p>
		8556	will iterate over all characters in string <code>s</code>,
		8557	with <code>p</code> being the position (in bytes) and <code>c</code> the code point
		8558	of each character.
		8559	It raises an error if it meets any invalid byte sequence.
		8560
		8561
		8562
		8563
		8564	<p>
		8565	<hr><h3><a name="pdf-utf8.codepoint"><code>utf8.codepoint (s [, i [, j]])</code></a></h3>
		8566	Returns the codepoints (as integers) from all characters in <code>s</code>
		8567	that start between byte position <code>i</code> and <code>j</code> (both included).
		8568	The default for <code>i</code> is 1 and for <code>j</code> is <code>i</code>.
		8569	It raises an error if it meets any invalid byte sequence.
		8570
		8571
		8572
		8573
		8574	<p>
		8575	<hr><h3><a name="pdf-utf8.len"><code>utf8.len (s [, i])</code></a></h3>
		8576	Returns the number of UTF-8 characters in string <code>s</code>,
		8577	starting from position <code>i</code>.
		8578	The default for <code>i</code> is 1.
		8579	Returns <b>nil</b> if the sufix of <code>s</code> starting at <code>i</code>
		8580	contains any invalid byte sequence.
		8581
		8582
		8583
		8584
		8585	<p>
		8586	<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
		8588	<code>n</code>-th character of <code>s</code> starts,
		8589	counting from position <code>i</code>.
		8590	A negative <code>n</code> gets characters before position <code>i</code>.
		8591	The default for <code>i</code> is 1.
		8592	Returns <b>nil</b> if the subject does not have such character.
		8593
		8594
		8595	<p>
		8596	As a special case,
		8597	when <code>n</code> is 0 the function returns the start of the encoding
		8598	of the character that contains the <code>i</code>-th byte of <code>s</code>.
		8599
		8600
		8601	<p>
		8602	This function assumes that <code>s</code> is a valid UTF-8 string.
		8603
		8604
		8605
		8606
		8607
		8608
		8609
		8610	<h2>6.6 – <a name="6.6">Table Manipulation</a></h2>
		8611
		8612	<p>
		8613	This library provides generic functions for table manipulation.
		8614	It provides all its functions inside the table <a name="pdf-table"><code>table</code></a>.
		8615
		8616
		8617	<p>
		8618	Remember that, whenever an operation needs the length of a table,
		8619	the table should be a proper sequence
		8620	or have a <code>__len</code> metamethod (see <a href="#3.4.7">§3.4.7</a>).
		8621	All functions ignore non-numeric keys
		8622	in tables given as arguments.
		8623
		8624
		8625	<p>
		8626	For performance reasons,
		8627	all table accesses (get/set) performed by these functions are raw.
		8628
		8629
		8630	<p>
		8631	<hr><h3><a name="pdf-table.concat"><code>table.concat (list [, sep [, i [, j]]])</code></a></h3>
		8632
		8633
		8634	<p>
		8635	Given a list where all elements are strings or numbers,
		8636	returns the string <code>list[i]..sep..list[i+1] ··· sep..list[j]</code>.
		8637	The default value for <code>sep</code> is the empty string,
		8638	the default for <code>i</code> is 1,
		8639	and the default for <code>j</code> is <code>#list</code>.
		8640	If <code>i</code> is greater than <code>j</code>, returns the empty string.
		8641
		8642
		8643
		8644
		8645	<p>
		8646	<hr><h3><a name="pdf-table.insert"><code>table.insert (list, [pos,] value)</code></a></h3>
		8647
		8648
		8649	<p>
		8650	Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
		8651	shifting up the elements
8511	<code>list[pos], list[pos+1], ···, list[#list]</code>.	8652	<code>list[pos], list[pos+1], ···, list[#list]</code>.
8512	The default value for <code>pos</code> is <code>#list+1</code>,	8653	The default value for <code>pos</code> is <code>#list+1</code>,
8513	so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end	8654	so that a call <code>table.insert(t,x)</code> inserts <code>x</code> at the end
@@ -8546,8 +8687,8 @@ in those cases, the function erases the element <code>list[pos]</code>. · 32 unmodified lines
8546		8687
8547	<p>	8688	<p>
8548	The default value for <code>pos</code> is <code>#list</code>,	8689	The default value for <code>pos</code> is <code>#list</code>,
8549	so that a call <code>table.remove(t)</code> removes the last element	8690	so that a call <code>table.remove(l)</code> removes the last element
8550	of list <code>t</code>.	8691	of list <code>l</code>.
8551		8692
8552		8693
8553		8694
@@ -8581,7 +8722,7 @@ may have their relative positions changed by the sort. · 27 unmodified lines
8581		8722
8582		8723
8583	<p>	8724	<p>
8584	Returns the elements from the given table.	8725	Returns the elements from the given list.
8585	This function is equivalent to	8726	This function is equivalent to
8586		8727
8587	<pre>	8728	<pre>
@@ -8595,14 +8736,13 @@ By default, <code>i</code> is 1 and <code>j</code> is <code>#list</code>. · 7 unmodified lines
8595		8736
8596		8737
8597		8738
8598	<h2>6.6 – <a name="6.6">Mathematical Functions</a></h2>	8739	<h2>6.7 – <a name="6.7">Mathematical Functions</a></h2>
8599		8740
8600	<p>	8741	<p>
8601	This library is an interface to the standard C math library.	8742	This library is an interface to the standard C math library.
8602	It provides all its functions inside the table <a name="pdf-math"><code>math</code></a>.	8743	It provides all its functions inside the table <a name="pdf-math"><code>math</code></a>.
8603	Unless stated otherwise,	8744	Unless stated otherwise,
8604	all functions in this library operate with and return	8745	all functions in this library operate with and return floats.
8605	floating-point numbers.
8606		8746
8607		8747
8608	<p>	8748	<p>
@@ -8713,7 +8853,8 @@ Returns the value <em>e<sup>x</sup></em>. · 104 unmodified lines
8713		8853
8714		8854
8715	<p>	8855	<p>
8716	Returns the largest integer smaller than or equal to <code>x</code>.	8856	Returns a float with the largest
		8857	integral value smaller than or equal to <code>x</code>.
8717		8858
8718		8859
8719		8860
@@ -8758,24 +8899,13 @@ a value larger than or equal to any other numerical value. · 38 unmodified lines
8758		8899
8759		8900
8760	<p>	8901	<p>
8761	Returns the largest integer smaller than or equal to <code>x</code>	8902	Returns the largest integer smaller than or equal to <code>x</code>.
8762	as an integer number.
8763	If the value does not fit in an integer,	8903	If the value does not fit in an integer,
8764	returns <b>nil</b>.	8904	returns <b>nil</b>.
8765		8905
8766		8906
8767		8907
8768		8908
8769	<p>
8770	<hr><h3><a name="pdf-math.isfloat"><code>math.isfloat (x)</code></a></h3>
8771
8772
8773	<p>
8774	Returns whether <code>x</code> is a floating-point number.
8775
8776
8777
8778
8779	<p>	8909	<p>
8780	<hr><h3><a name="pdf-math.ldexp"><code>math.ldexp (m, e)</code></a></h3>	8910	<hr><h3><a name="pdf-math.ldexp"><code>math.ldexp (m, e)</code></a></h3>
8781		8911
@@ -8872,11 +9002,11 @@ pseudo-random generator function <code>rand</code> provided by Standard C. · 90 unmodified lines
8872		9002
8873	<p>	9003	<p>
8874	When called without arguments,	9004	When called without arguments,
8875	returns a uniform pseudo-random float number	9005	returns a uniform pseudo-random float
8876	in the range <em>[0,1)</em>.	9006	in the range <em>[0,1)</em>.
8877	When called with two integer values <code>m</code> and <code>n</code>,	9007	When called with two integers <code>m</code> and <code>n</code>,
8878	<code>math.random</code> returns a uniform pseudo-random	9008	<code>math.random</code> returns a uniform pseudo-random
8879	integer number in the range <em>[m, n]</em>.	9009	integer in the range <em>[m, n]</em>.
8880	The call <code>math.random(n)</code> is equivalent to <code>math.random(1,n)</code>.	9010	The call <code>math.random(n)</code> is equivalent to <code>math.random(1,n)</code>.
8881		9011
8882		9012
@@ -8945,229 +9075,14 @@ Returns the hyperbolic tangent of <code>x</code>. · 62 unmodified lines
8945		9075
8946		9076
8947		9077
8948
8949
8950
8951	<h2>6.7 – <a name="6.7">Bitwise Operations</a></h2>
8952
8953	<p>
8954	This library provides bitwise operations.
8955	It provides all its functions inside the table <a name="pdf-bit32"><code>bit32</code></a>.
8956
8957
8958	<p>
8959	Unless otherwise stated,
8960	all functions accept numeric arguments in the range
8961	<em>(-2<sup>51</sup>,+2<sup>51</sup>)</em>;
8962	each argument is normalized to
8963	the remainder of its division by <em>2<sup>32</sup></em>
8964	and truncated to an integer (in some unspecified way),
8965	so that its final value falls in the range <em>[0,2<sup>32</sup> - 1]</em>.
8966	Similarly, all results are in the range <em>[0,2<sup>32</sup> - 1]</em>.
8967	Note that <code>bit32.bnot(0)</code> is <code>0xFFFFFFFF</code>,
8968	which is different from <code>-1</code>.
8969
8970
8971	<p>
8972	<hr><h3><a name="pdf-bit32.arshift"><code>bit32.arshift (x, disp)</code></a></h3>
8973
8974
8975	<p>
8976	Returns the number <code>x</code> shifted <code>disp</code> bits to the right.
8977	The number <code>disp</code> may be any representable integer.
8978	Negative displacements shift to the left.
8979
8980
8981	<p>
8982	This shift operation is what is called arithmetic shift.
8983	Vacant bits on the left are filled
8984	with copies of the higher bit of <code>x</code>;
8985	vacant bits on the right are filled with zeros.
8986	In particular,
8987	displacements with absolute values higher than 31
8988	result in zero or <code>0xFFFFFFFF</code> (all original bits are shifted out).
8989
8990
8991
8992
8993	<p>
8994	<hr><h3><a name="pdf-bit32.band"><code>bit32.band (···)</code></a></h3>
8995
8996
8997	<p>
8998	Returns the bitwise <em>and</em> of its operands.
8999
9000
9001
9002
9003	<p>
9004	<hr><h3><a name="pdf-bit32.bnot"><code>bit32.bnot (x)</code></a></h3>
9005
9006
9007	<p>
9008	Returns the bitwise negation of <code>x</code>.
9009	For any integer <code>x</code>,
9010	the following identity holds:
9011
9012	<pre>
9013	assert(bit32.bnot(x) == (-1 - x) % 2^32)
9014	</pre>
9015
9016
9017
9018	<p>
9019	<hr><h3><a name="pdf-bit32.bor"><code>bit32.bor (···)</code></a></h3>
9020
9021
9022	<p>
9023	Returns the bitwise <em>or</em> of its operands.
9024
9025
9026
9027
9028	<p>	9078	<p>
9029	<hr><h3><a name="pdf-bit32.btest"><code>bit32.btest (···)</code></a></h3>	9079	<hr><h3><a name="pdf-math.type"><code>math.type (x)</code></a></h3>
9030		9080
9031		9081
9032	<p>	9082	<p>
9033	Returns a boolean signaling	9083	Returns "<code>integer</code>" if <code>x</code> is an integer,
9034	whether the bitwise <em>and</em> of its operands is different from zero.	9084	"<code>float</code>" if it is a float,
9035		9085	or <b>nil</b> if <code>x</code> is not a number.
9036
9037
9038
9039	<p>
9040	<hr><h3><a name="pdf-bit32.bxor"><code>bit32.bxor (···)</code></a></h3>
9041
9042
9043	<p>
9044	Returns the bitwise <em>exclusive or</em> of its operands.
9045
9046
9047
9048
9049	<p>
9050	<hr><h3><a name="pdf-bit32.extract"><code>bit32.extract (n, field [, width])</code></a></h3>
9051
9052
9053	<p>
9054	Returns the unsigned number formed by the bits
9055	<code>field</code> to <code>field + width - 1</code> from <code>n</code>.
9056	Bits are numbered from 0 (least significant) to 31 (most significant).
9057	All accessed bits must be in the range <em>[0, 31]</em>.
9058
9059
9060	<p>
9061	The default for <code>width</code> is 1.
9062
9063
9064
9065
9066	<p>
9067	<hr><h3><a name="pdf-bit32.replace"><code>bit32.replace (n, v, field [, width])</code></a></h3>
9068
9069
9070	<p>
9071	Returns a copy of <code>n</code> with
9072	the bits <code>field</code> to <code>field + width - 1</code>
9073	replaced by the value <code>v</code>.
9074	See <a href="#pdf-bit32.extract"><code>bit32.extract</code></a> for details about <code>field</code> and <code>width</code>.
9075
9076
9077
9078
9079	<p>
9080	<hr><h3><a name="pdf-bit32.lrotate"><code>bit32.lrotate (x, disp)</code></a></h3>
9081
9082
9083	<p>
9084	Returns the number <code>x</code> rotated <code>disp</code> bits to the left.
9085	The number <code>disp</code> may be any representable integer.
9086
9087
9088	<p>
9089	For any valid displacement,
9090	the following identity holds:
9091
9092	<pre>
9093	assert(bit32.lrotate(x, disp) == bit32.lrotate(x, disp % 32))
9094	</pre><p>
9095	In particular,
9096	negative displacements rotate to the right.
9097
9098
9099
9100
9101	<p>
9102	<hr><h3><a name="pdf-bit32.lshift"><code>bit32.lshift (x, disp)</code></a></h3>
9103
9104
9105	<p>
9106	Returns the number <code>x</code> shifted <code>disp</code> bits to the left.
9107	The number <code>disp</code> may be any representable integer.
9108	Negative displacements shift to the right.
9109	In any direction, vacant bits are filled with zeros.
9110	In particular,
9111	displacements with absolute values higher than 31
9112	result in zero (all bits are shifted out).
9113
9114
9115	<p>
9116	For positive displacements,
9117	the following equality holds:
9118
9119	<pre>
9120	assert(bit32.lshift(b, disp) == (b * 2^disp) % 2^32)
9121	</pre>
9122
9123
9124
9125	<p>
9126	<hr><h3><a name="pdf-bit32.rrotate"><code>bit32.rrotate (x, disp)</code></a></h3>
9127
9128
9129	<p>
9130	Returns the number <code>x</code> rotated <code>disp</code> bits to the right.
9131	The number <code>disp</code> may be any representable integer.
9132
9133
9134	<p>
9135	For any valid displacement,
9136	the following identity holds:
9137
9138	<pre>
9139	assert(bit32.rrotate(x, disp) == bit32.rrotate(x, disp % 32))
9140	</pre><p>
9141	In particular,
9142	negative displacements rotate to the left.
9143
9144
9145
9146
9147	<p>
9148	<hr><h3><a name="pdf-bit32.rshift"><code>bit32.rshift (x, disp)</code></a></h3>
9149
9150
9151	<p>
9152	Returns the number <code>x</code> shifted <code>disp</code> bits to the right.
9153	The number <code>disp</code> may be any representable integer.
9154	Negative displacements shift to the left.
9155	In any direction, vacant bits are filled with zeros.
9156	In particular,
9157	displacements with absolute values higher than 31
9158	result in zero (all bits are shifted out).
9159
9160
9161	<p>
9162	For positive displacements,
9163	the following equality holds:
9164
9165	<pre>
9166	assert(bit32.rshift(b, disp) == math.floor(b % 2^32 / 2^disp))
9167	</pre>
9168
9169	<p>
9170	This shift operation is what is called logical shift.
9171		9086
9172		9087
9173		9088
@@ -9179,24 +9094,24 @@ This shift operation is what is called logical shift. · 5 unmodified lines
9179		9094
9180	<p>	9095	<p>
9181	The I/O library provides two different styles for file manipulation.	9096	The I/O library provides two different styles for file manipulation.
9182	The first one uses implicit file descriptors;	9097	The first one uses implicit file handles;
9183	that is, there are operations to set a default input file and a	9098	that is, there are operations to set a default input file and a
9184	default output file,	9099	default output file,
9185	and all input/output operations are over these default files.	9100	and all input/output operations are over these default files.
9186	The second style uses explicit file descriptors.	9101	The second style uses explicit file handles.
9187		9102
9188		9103
9189	<p>	9104	<p>
9190	When using implicit file descriptors,	9105	When using implicit file handles,
9191	all operations are supplied by table <a name="pdf-io"><code>io</code></a>.	9106	all operations are supplied by table <a name="pdf-io"><code>io</code></a>.
9192	When using explicit file descriptors,	9107	When using explicit file handles,
9193	the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file descriptor	9108	the operation <a href="#pdf-io.open"><code>io.open</code></a> returns a file handle
9194	and then all operations are supplied as methods of the file descriptor.	9109	and then all operations are supplied as methods of the file handle.
9195		9110
9196		9111
9197	<p>	9112	<p>
9198	The table <code>io</code> also provides	9113	The table <code>io</code> also provides
9199	three predefined file descriptors with their usual meanings from C:	9114	three predefined file handles with their usual meanings from C:
9200	<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.	9115	<a name="pdf-io.stdin"><code>io.stdin</code></a>, <a name="pdf-io.stdout"><code>io.stdout</code></a>, and <a name="pdf-io.stderr"><code>io.stderr</code></a>.
9201	The I/O library never closes these files.	9116	The I/O library never closes these files.
9202		9117
@@ -9207,7 +9122,7 @@ all I/O functions return <b>nil</b> on failure · 4 unmodified lines
9207	(plus an error message as a second result and	9122	(plus an error message as a second result and
9208	a system-dependent error code as a third result)	9123	a system-dependent error code as a third result)
9209	and some value different from <b>nil</b> on success.	9124	and some value different from <b>nil</b> on success.
9210	On non-Posix systems,	9125	On non-POSIX systems,
9211	the computation of the error message and error code	9126	the computation of the error message and error code
9212	in case of errors	9127	in case of errors
9213	may be not thread safe,	9128	may be not thread safe,
@@ -9264,12 +9179,12 @@ Opens the given file name in read mode · 50 unmodified lines
9264	and returns an iterator function that	9179	and returns an iterator function that
9265	works like <code>file:lines(···)</code> over the opened file.	9180	works like <code>file:lines(···)</code> over the opened file.
9266	When the iterator function detects the end of file,	9181	When the iterator function detects the end of file,
9267	it returns <b>nil</b> (to finish the loop) and automatically closes the file.	9182	it returns no values (to finish the loop) and automatically closes the file.
9268		9183
9269		9184
9270	<p>	9185	<p>
9271	The call <code>io.lines()</code> (with no file name) is equivalent	9186	The call <code>io.lines()</code> (with no file name) is equivalent
9272	to <code>io.input():lines()</code>;	9187	to <code>io.input():lines("*l")</code>;
9273	that is, it iterates over the lines of the default input file.	9188	that is, it iterates over the lines of the default input file.
9274	In this case it does not close the file when the loop ends.	9189	In this case it does not close the file when the loop ends.
9275		9190
@@ -9449,7 +9364,7 @@ instead of returning an error code. · 173 unmodified lines
9449	Reads the file <code>file</code>,	9364	Reads the file <code>file</code>,
9450	according to the given formats, which specify what to read.	9365	according to the given formats, which specify what to read.
9451	For each format,	9366	For each format,
9452	the function returns a string (or a number) with the characters read,	9367	the function returns a string or a number with the characters read,
9453	or <b>nil</b> if it cannot read data with the specified format.	9368	or <b>nil</b> if it cannot read data with the specified format.
9454	When called without formats,	9369	When called without formats,
9455	it uses a default format that reads the next line	9370	it uses a default format that reads the next line
@@ -9462,8 +9377,15 @@ The available formats are · 6 unmodified lines
9462	<ul>	9377	<ul>
9463		9378
9464	<li><b>"<code>*n</code>": </b>	9379	<li><b>"<code>*n</code>": </b>
9465	reads a number;	9380	reads a number and returns it as a float.
9466	this is the only format that returns a number instead of a string.	9381	If the input has only a prefix of a valid number
		9382	(e.g., "<code>0x</code>" or "<code>3.4e-</code>"),
		9383	this format can read the entire prefix
		9384	even when returning <b>nil</b>.
		9385	</li>
		9386
		9387	<li><b>"<code>*i</code>": </b>
		9388	reads an integral number and returns it as an integer.
9467	</li>	9389	</li>
9468		9390
9469	<li><b>"<code>*a</code>": </b>	9391	<li><b>"<code>*a</code>": </b>
@@ -9478,19 +9400,21 @@ This is the default format. · 8 unmodified lines
9478	</li>	9400	</li>
9479		9401
9480	<li><b>"<code>*L</code>": </b>	9402	<li><b>"<code>*L</code>": </b>
9481	reads the next line keeping the end of line (if present),	9403	reads the next line keeping the end-of-line character (if present),
9482	returning <b>nil</b> on end of file.	9404	returning <b>nil</b> on end of file.
9483	</li>	9405	</li>
9484		9406
9485	<li><b><em>number</em>: </b>	9407	<li><b><em>number</em>: </b>
9486	reads a string with up to this number of bytes,	9408	reads a string with up to this number of bytes,
9487	returning <b>nil</b> on end of file.	9409	returning <b>nil</b> on end of file.
9488	If number is zero,	9410	If <code>number</code> is zero,
9489	it reads nothing and returns an empty string,	9411	it reads nothing and returns an empty string,
9490	or <b>nil</b> on end of file.	9412	or <b>nil</b> on end of file.
9491	</li>	9413	</li>
9492		9414
9493	</ul>	9415	</ul><p>
		9416	The formats "<code>l</code>" and "<code>L</code>" should be used only for text files.
		9417
9494		9418
9495		9419
9496		9420
@@ -9643,7 +9567,7 @@ the host system and on the current locale · 146 unmodified lines
9643		9567
9644		9568
9645	<p>	9569	<p>
9646	On non-Posix systems,	9570	On non-POSIX systems,
9647	this function may be not thread safe	9571	this function may be not thread safe
9648	because of its reliance on C function <code>gmtime</code> and C function <code>localtime</code>.	9572	because of its reliance on C function <code>gmtime</code> and C function <code>localtime</code>.
9649		9573
@@ -9673,7 +9597,7 @@ Its first result is <b>true</b> · 23 unmodified lines
9673	if the command terminated successfully,	9597	if the command terminated successfully,
9674	or <b>nil</b> otherwise.	9598	or <b>nil</b> otherwise.
9675	After this first result	9599	After this first result
9676	the function returns a string and a number,	9600	the function returns a string plus a number,
9677	as follows:	9601	as follows:
9678		9602
9679	<ul>	9603	<ul>
@@ -9975,8 +9899,9 @@ and raises an error when called with a level out of range. · 295 unmodified lines
9975		9899
9976	<p>	9900	<p>
9977	Variable names starting with '<code>(</code>' (open parenthesis)	9901	Variable names starting with '<code>(</code>' (open parenthesis)
9978	represent internal variables	9902	represent variables with no known names
9979	(loop control variables, temporaries, varargs, and C function locals).	9903	(internal variables like loop control variables,
		9904	and variables from chunks saved without debug information).
9980		9905
9981		9906
9982	<p>	9907	<p>
@@ -10017,6 +9942,12 @@ with index <code>up</code> of the function <code>f</code>. · 34 unmodified lines
10017	The function returns <b>nil</b> if there is no upvalue with the given index.	9942	The function returns <b>nil</b> if there is no upvalue with the given index.
10018		9943
10019		9944
		9945	<p>
		9946	Variable names starting with '<code>(</code>' (open parenthesis)
		9947	represent variables with no known names
		9948	(variables from chunks saved without debug information).
		9949
		9950
10020		9951
10021		9952
10022	<p>	9953	<p>
@@ -10037,8 +9968,8 @@ returns <b>nil</b>. · 14 unmodified lines
10037		9968
10038	<p>	9969	<p>
10039	Returns the number of bits in the underlying representation	9970	Returns the number of bits in the underlying representation
10040	of integer (if <code>t</code> is "<code>i</code>")	9971	of an integer (if <code>t</code> is "<code>i</code>")
10041	or float numbers (if <code>t</code> is "<code>f</code>").	9972	or a float (if <code>t</code> is "<code>f</code>").
10042		9973
10043		9974
10044		9975
@@ -10140,7 +10071,6 @@ Otherwise, it returns the name of the upvalue. · 95 unmodified lines
10140	<p>	10071	<p>
10141	Sets the given <code>value</code> as	10072	Sets the given <code>value</code> as
10142	the Lua value associated to the given <code>udata</code>.	10073	the Lua value associated to the given <code>udata</code>.
10143	<code>value</code> must be a table or <b>nil</b>;
10144	<code>udata</code> must be a full userdata.	10074	<code>udata</code> must be a full userdata.
10145		10075
10146		10076
@@ -10352,139 +10282,65 @@ is a more portable solution.) · 205 unmodified lines
10352		10282
10353	<p>	10283	<p>
10354	Here we list the incompatibilities that you may find when moving a program	10284	Here we list the incompatibilities that you may find when moving a program
10355	from Lua 5.1 to Lua 5.2.	10285	from Lua 5.2 to Lua 5.3.
10356	You can avoid some incompatibilities by compiling Lua with	10286	You can avoid some incompatibilities by compiling Lua with
10357	appropriate options (see file <code>luaconf.h</code>).	10287	appropriate options (see file <code>luaconf.h</code>).
10358	However,	10288	However,
10359	all these compatibility options will be removed in the next version of Lua.	10289	all these compatibility options will be removed in the future.
10360	Similarly,
10361	all features marked as deprecated in Lua 5.1
10362	have been removed in Lua 5.2.
10363
10364
10365
10366	<h2>8.1 – <a name="8.1">Changes in the Language</a></h2>
10367	<ul>
10368
10369	<li>
10370	The concept of <em>environment</em> changed.
10371	Only Lua functions have environments.
10372	To set the environment of a Lua function,
10373	use the variable <code>_ENV</code> or the function <a href="#pdf-load"><code>load</code></a>.
10374		10290
10375		10291
10376	<p>	10292	<p>
10377	C functions no longer have environments.	10293	Lua versions can always change the C API in ways that
10378	Use an upvalue with a shared table if you need to keep	10294	do not imply source-code changes in a program,
10379	shared state among several C functions.	10295	such as the numeric values for constants
10380	(You may use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> to open a C library	10296	or the implementation of functions as macros.
10381	with all functions sharing a common upvalue.)	10297	Therefore,
		10298	you should never assume that binaries are compatible between
		10299	different Lua versions.
		10300	Always recompile clients of the Lua API when
		10301	using a new version.
10382		10302
10383		10303
10384	<p>	10304	<p>
10385	To manipulate the "environment" of a userdata	10305	The standard paths in the official distribution may
10386	(which is now called user value),	10306	change between versions.
10387	use the new functions
10388	<a href="#lua_getuservalue"><code>lua_getuservalue</code></a> and <a href="#lua_setuservalue"><code>lua_setuservalue</code></a>.
10389	</li>
10390
10391	<li>
10392	Lua identifiers cannot use locale-dependent letters.
10393	</li>
10394
10395	<li>
10396	Doing a step or a full collection in the garbage collector
10397	does not restart the collector if it has been stopped.
10398	</li>
10399
10400	<li>
10401	Weak tables with weak keys now perform like <em>ephemeron tables</em>.
10402	</li>
10403
10404	<li>
10405	The event <em>tail return</em> in debug hooks was removed.
10406	Instead, tail calls generate a special new event,
10407	<em>tail call</em>, so that the debugger can know that
10408	there will not be a corresponding return event.
10409	</li>
10410
10411	<li>
10412	Equality between function values has changed.
10413	Now, a function definition may not create a new value;
10414	it may reuse some previous value if there is no
10415	observable difference to the new function.
10416	</li>
10417
10418	</ul>
10419
10420		10307
10421		10308
10422		10309
10423	<h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2>	10310	<h2>8.1 – <a name="8.1">Changes in the Language</a></h2>
10424	<ul>	10311	<ul>
10425		10312
10426	<li>	10313	<li>
10427	Function <code>module</code> is deprecated.	10314	The main difference between Lua 5.2 and Lua 5.3 is the
10428	It is easy to set up a module with regular Lua code.	10315	introduction of an integer subtype for numbers.
10429	Modules are not expected to set global variables.	10316	Although this change should not affect "normal" computations,
10430	</li>	10317	some computations
		10318	(mainly those that involve some kind of overflow)
		10319	can give different results.
10431		10320
10432	<li>
10433	Functions <code>setfenv</code> and <code>getfenv</code> were removed,
10434	because of the changes in environments.
10435	</li>
10436		10321
10437	<li>	10322	<p>
10438	Function <code>math.log10</code> is deprecated.	10323	You can fix these differences by forcing a number to be a float
10439	Use <a href="#pdf-math.log"><code>math.log</code></a> with 10 as its second argument, instead.	10324	(in Lua 5.2 all numbers were float),
10440	</li>	10325	in particular writing constants with an ending <code>.0</code>
10441		10326	or using <code>x = x + 0.0</code> to convert a variable.
10442	<li>	10327	(This recommendation is only for a quick fix
10443	Function <code>loadstring</code> is deprecated.	10328	for an occasional incompatibility,
10444	Use <code>load</code> instead; it now accepts string arguments	10329	not as a general guideline for good programming.
10445	and are exactly equivalent to <code>loadstring</code>.	10330	For good programming,
10446	</li>	10331	use floats where you need floats
10447		10332	and integers where you need integers.)
10448	<li>
10449	Function <code>table.maxn</code> is deprecated.
10450	Write it in Lua if you really need it.
10451	</li>
10452
10453	<li>
10454	Function <code>os.execute</code> now returns <b>true</b> when command
10455	terminates successfully and <b>nil</b> plus error information
10456	otherwise.
10457	</li>
10458
10459	<li>
10460	Function <code>unpack</code> was moved into the table library
10461	and therefore must be called as <a href="#pdf-table.unpack"><code>table.unpack</code></a>.
10462	</li>
10463
10464	<li>
10465	Character class <code>%z</code> in patterns is deprecated,
10466	as now patterns may contain '<code>\0</code>' as a regular character.
10467	</li>
10468		10333
10469	<li>
10470	The table <code>package.loaders</code> was renamed <code>package.searchers</code>.
10471	</li>
10472		10334
10473	<li>	10335	<p>
10474	Lua does not have bytecode verification anymore.	10336	Although not formally an incompatibility,
10475	So, all functions that load code	10337	the proper differentiation between floats and integers
10476	(<a href="#pdf-load"><code>load</code></a> and <a href="#pdf-loadfile"><code>loadfile</code></a>)	10338	can sometimes have a big impact on performance.
10477	are potentially insecure when loading untrusted binary data.
10478	(Actually, those functions were already insecure because
10479	of flaws in the verification algorithm.)
10480	When in doubt,
10481	use the <code>mode</code> argument of those functions
10482	to restrict them to loading textual chunks.
10483	</li>	10339	</li>
10484		10340
10485	<li>	10341	<li>
10486	The standard paths in the official distribution may	10342	The generational mode for the garbage collector was removed.
10487	change between versions.	10343	(It was an experimental feature in Lua 5.2.)
10488	</li>	10344	</li>
10489		10345
10490	</ul>	10346	</ul>
@@ -10492,76 +10348,39 @@ change between versions. · 1 unmodified line
10492		10348
10493		10349
10494		10350
10495	<h2>8.3 – <a name="8.3">Changes in the API</a></h2>	10351	<h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2>
10496	<ul>	10352	<ul>
10497		10353
10498	<li>	10354	<li>
10499	Pseudoindex <code>LUA_GLOBALSINDEX</code> was removed.	10355	The conversion of a float to a string through <a href="#pdf-tostring"><code>tostring</code></a>
10500	You must get the global environment from the registry	10356	(which is used by <a href="#pdf-print"><code>print</code></a>) now adds a <code>.0</code> suffix if the
10501	(see <a href="#4.5">§4.5</a>).	10357	number has an integral value.
10502	</li>	10358	(For instance, the float 2.0 will be printed as <code>2.0</code>,
10503		10359	not as <code>2</code>.)
10504	<li>	10360	You should always use an explicit format
10505	Pseudoindex <code>LUA_ENVIRONINDEX</code>	10361	when you need a specific format for numbers.
10506	and functions <code>lua_getfenv</code>/<code>lua_setfenv</code>
10507	were removed,
10508	as C functions no longer have environments.
10509	</li>	10362	</li>
10510		10363
10511	<li>	10364	<li>
10512	Function <code>luaL_register</code> is deprecated.	10365	The <code>bit32</code> library has been deprecated.
10513	Use <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> so that your module does not create globals.	10366	It is easy to require a compatible external library or,
10514	(Modules are not expected to set global variables anymore.)	10367	better yet, to replace its functions with appropriate bitwise operations.
		10368	(Just 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.)
10515	</li>	10370	</li>
10516		10371
10517	<li>	10372	</ul>
10518	The <code>osize</code> argument to the allocation function
10519	may not be zero when creating a new block,
10520	that is, when <code>ptr</code> is <code>NULL</code>
10521	(see <a href="#lua_Alloc"><code>lua_Alloc</code></a>).
10522	Use only the test <code>ptr == NULL</code> to check whether
10523	the block is new.
10524	</li>
10525		10373
10526	<li>
10527	Finalizers (<code>__gc</code> metamethods) for userdata are called in the
10528	reverse order that they were marked for finalization,
10529	not that they were created (see <a href="#2.5.1">§2.5.1</a>).
10530	(Most userdata are marked immediately after they are created.)
10531	Moreover,
10532	if the metatable does not have a <code>__gc</code> field when set,
10533	the finalizer will not be called,
10534	even if it is set later.
10535	</li>
10536		10374
10537	<li>
10538	<code>luaL_typerror</code> was removed.
10539	Write your own version if you need it.
10540	</li>
10541		10375
10542	<li>
10543	Function <code>lua_cpcall</code> is deprecated.
10544	You can simply push the function with <a href="#lua_pushcfunction"><code>lua_pushcfunction</code></a>
10545	and call it with <a href="#lua_pcall"><code>lua_pcall</code></a>.
10546	</li>
10547		10376
10548	<li>	10377	<h2>8.3 – <a name="8.3">Changes in the API</a></h2>
10549	Functions <code>lua_equal</code> and <code>lua_lessthan</code> are deprecated.
10550	Use the new <a href="#lua_compare"><code>lua_compare</code></a> with appropriate options instead.
10551	</li>
10552		10378
10553	<li>
10554	Function <code>lua_objlen</code> was renamed <a href="#lua_rawlen"><code>lua_rawlen</code></a>.
10555	</li>
10556		10379
10557	<li>	10380	<ul>
10558	Function <a href="#lua_load"><code>lua_load</code></a> has an extra parameter, <code>mode</code>.
10559	Pass <code>NULL</code> to simulate the old behavior.
10560	</li>
10561		10381
10562	<li>	10382	<li>
10563	Function <a href="#lua_resume"><code>lua_resume</code></a> has an extra parameter, <code>from</code>.	10383	No changes (yet).
10564	Pass <code>NULL</code> or the thread doing the call.
10565	</li>	10384	</li>
10566		10385
10567	</ul>	10386	</ul>
@@ -10649,17 +10468,17 @@ Here is the complete syntax of Lua in extended BNF. · 81 unmodified lines
10649		10468
10650		10469
10651		10470
10652		10471	}
10653		10472
10654		10473
10655		10474
10656	<HR>	10475	<HR>
10657	<SMALL CLASS="footer">	10476	<SMALL CLASS="footer">
10658	Last update:	10477	Last update:
10659	Fri Jul 5 23:09:01 BRT 2013	10478	Fri Mar 21 17:33:56 BRT 2014
10660	</SMALL>	10479	</SMALL>
10661	<!--	10480	<!--
10662	Last change: updated for Lua 5.3.0 (work1)	10481	Last change: updated for Lua 5.3.0 (work2)
10663	-->	10482	-->
10664		10483
10665	</body></html>	10484	</body></html>

doc/readme.html+24−69

 	border: solid #a0a0a0 2px ;
 	padding: 1em ;
 	margin: 0px ;
+	border-radius: 8px ;
 }
 .display {
 <HR>
 <H1>
 <A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Welcome to Lua 5.3 (work1)
+Welcome to Lua 5.3 (work2)
 </H1>
+<P>
+<IMG SRC="alert.png" ALIGN="absbottom">
+<EM>All details may change in the final version.</EM>
 <P>
 <A HREF="#about">about</A>
 &middot;
 lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c ltable.c
 ltm.c lundump.c lvm.c lzio.c
 lauxlib.c lbaselib.c lbitlib.c lcorolib.c ldblib.c liolib.c
-lmathlib.c loslib.c lstrlib.c ltablib.c loadlib.c linit.c
+lmathlib.c loslib.c lstrlib.c ltablib.c lutf8lib.c loadlib.c linit.c
 <DT>
 interpreter:
 <DD>
   As mentioned above, you may edit <TT>src/luaconf.h</TT> to customize
   some features before building Lua.
-<H2><A NAME="changes">Changes since Lua 5.1</A></H2>
+<H2><A NAME="changes">Changes since Lua 5.2</A></H2>
 <P>
 Here are the main changes introduced in Lua 5.3.
 <H3>Main changes</H3>
 <UL>
-<LI> yieldable pcall and metamethods
+<LI> support for integers (64-bit by default)
-<LI> new lexical scheme for globals
+<LI> better support for small architectures ("Small Lua" with 32-bit numbers)
-<LI> ephemeron tables
+<LI> bitwise operators
-<LI> new library for bitwise operations
+<LI> basic utf-8 library
-<LI> light C functions
+<LI> utf-8 escapes in literal strings
-<LI> emergency garbage collector
+<LI> functions for packing/unpacking numbers
-<LI> <CODE>goto</CODE> statement
+<LI> userdata can have any Lua value as uservalue
-<LI> finalizers for tables
+<LI> strip option in <CODE>lua_dump</CODE>/<CODE>string.dump</CODE>
 </UL>
 Here are the other changes introduced in Lua 5.3:
 <H3>Language</H3>
 <UL>
-<LI> no more fenv for threads or functions
+<LI>
-<LI> tables honor the <CODE>__len</CODE> metamethod
-<LI> hex and <CODE>\z</CODE> escapes in strings
-<LI> support for hexadecimal floats
-<LI> order metamethods work for different types
-<LI> no more verification of opcode consistency
-<LI> hook event "tail return" replaced by "tail call"
-<LI> empty statement
-<LI> <CODE>break</CODE> statement may appear in the middle of a block
 </UL>
 <H3>Libraries</H3>
 <UL>
-<LI> arguments for function called through <CODE>xpcall</CODE>
+<LI>
-<LI> optional 'mode' argument to load and loadfile (to control binary x text)
-<LI> optional 'env' argument to load and loadfile (environment for loaded chunk)
-<LI> <CODE>loadlib</CODE> may load libraries with global names (RTLD_GLOBAL)
-<LI> new function <CODE>package.searchpath</CODE>
-<LI> modules receive their paths when loaded
-<LI> optional base in <CODE>math.log</CODE>
-<LI> optional separator in <CODE>string.rep</CODE>
-<LI> <CODE>file:write</CODE> returns <CODE>file</CODE>
-<LI> closing a pipe returns exit status
-<LI> <CODE>os.exit</CODE> may close state
-<LI> new metamethods <CODE>__pairs</CODE> and <CODE>__ipairs</CODE>
-<LI> new option 'isrunning' for <CODE>collectgarbage</CODE> and <CODE>lua_gc</CODE>
-<LI> frontier patterns
-<LI> <CODE>\0</CODE> in patterns
-<LI> new option <CODE>*L</CODE> for <CODE>io.read</CODE>
-<LI> options for <CODE>io.lines</CODE>
-<LI> <CODE>debug.getlocal</CODE> can access function varargs
 </UL>
 <H3>C API</H3>
 <UL>
-<LI> main thread predefined in the registry
+<LI>
-<LI> new functions
-<CODE>lua_absindex</CODE>,
-<CODE>lua_arith</CODE>,
-<CODE>lua_compare</CODE>,
-<CODE>lua_copy</CODE>,
-<CODE>lua_len</CODE>,
-<CODE>lua_rawgetp</CODE>,
-<CODE>lua_rawsetp</CODE>,
-<CODE>lua_upvalueid</CODE>,
-<CODE>lua_upvaluejoin</CODE>,
-<CODE>lua_version</CODE>.
-<LI> new functions
-<CODE>luaL_checkversion</CODE>,
-<CODE>luaL_setmetatable</CODE>,
-<CODE>luaL_testudata</CODE>,
-<CODE>luaL_tolstring</CODE>.
-<LI> <CODE>lua_pushstring</CODE> and <CODE>pushlstring</CODE> return string
-<LI> <CODE>nparams</CODE> and <CODE>isvararg</CODE> available in debug API
-<LI> new <CODE>lua_Unsigned</CODE>
 </UL>
 <H3>Implementation</H3>
 <UL>
-<LI> max constants per function raised to 2<SUP>26</SUP>
+<LI>
-<LI> generational mode for garbage collection (experimental)
-<LI> NaN trick (experimental)
-<LI> internal (immutable) version of ctypes
-<LI> simpler implementation for string buffers
-<LI> parser uses much less C-stack space (no more auto arrays)
 </UL>
 <H3>Lua standalone interpreter</H3>
 <UL>
-<LI> new <CODE>-E</CODE> option to avoid environment variables
+<LI> Can be used as calculator; no need to prefix with '='
-<LI> handling of non-string error messages
 </UL>
 <H2><A NAME="license">License</A></H2>
 <A HREF="http://www.lua.org/license.html">this</A>.
 <BLOCKQUOTE STYLE="padding-bottom: 0em">
-Copyright &copy; 1994&ndash;2013 Lua.org, PUC-Rio.
+Copyright &copy; 1994&ndash;2014 Lua.org, PUC-Rio.
 <P>
 Permission is hereby granted, free of charge, to any person obtaining a copy
 <HR>
 <SMALL CLASS="footer">
 Last update:
-Mon Jun  3 23:13:40 BRT 2013
+Fri Mar 21 17:33:08 BRT 2014
 </SMALL>
 <!--
-Last change: revised for Lua 5.3.0
+Last change: updated for Lua 5.3.0 (work2)
 -->
 </BODY>

src/.fix+1−1

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

src/Makefile+5−4

 	lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o \
 	ltm.o lundump.o lvm.o lzio.o
 LIB_O=	lauxlib.o lbaselib.o lbitlib.o lcorolib.o ldblib.o liolib.o \
-	lmathlib.o loslib.o lstrlib.o ltablib.o loadlib.o linit.o
+	lmathlib.o loslib.o lstrlib.o ltablib.o lutf8lib.o loadlib.o linit.o
 BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
 LUA_T=	lua
 linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
 liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
 llex.o: llex.c lua.h luaconf.h lctype.h llimits.h ldo.h lobject.h \
- lstate.h ltm.h lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
+ lstate.h ltm.h lzio.h lmem.h lgc.h llex.h lparser.h lstring.h ltable.h
 lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
 lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
  ltm.h lzio.h lmem.h ldo.h lgc.h
 lstate.o: lstate.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h \
  ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h lstring.h \
  ltable.h
-lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
+lstring.o: lstring.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
- ltm.h lzio.h lstring.h lgc.h
+ llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h
 lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
 ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
  ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
  ltm.h lzio.h lmem.h lundump.h ldebug.h lopcodes.h
 lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
+lutf8lib.o: lutf8lib.c lua.h luaconf.h lauxlib.h lualib.h
 lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
 lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \

src/lapi.c+66−70

 /*
-** $Id: lapi.c,v 2.185 2013/07/05 14:29:51 roberto Exp $
+** $Id: lapi.c,v 2.201 2014/03/12 20:57:40 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
 LUA_API int lua_isuserdata (lua_State *L, int idx) {
   const TValue *o = index2addr(L, idx);
-  return (ttisuserdata(o) || ttislightuserdata(o));
+  return (ttisfulluserdata(o) || ttislightuserdata(o));
 }
 LUA_API void lua_arith (lua_State *L, int op) {
   lua_lock(L);
-  if (op != LUA_OPUNM) /* all other operations expect two operands */
+  if (op != LUA_OPUNM && op != LUA_OPBNOT)
-    api_checknelems(L, 2);
+    api_checknelems(L, 2);  /* all other operations expect two operands */
-  else {  /* for unary minus, add fake 2nd operand */
+  else {  /* for unary operations, add fake 2nd operand */
     api_checknelems(L, 1);
     setobjs2s(L, L->top, L->top - 1);
     L->top++;
       isnum = 1;
       break;
     }
-    case LUA_TNUMFLT: {
+    case LUA_TNUMFLT: {  /* compute floor(n) % 2^(numbits in an integer) */
-      const lua_Number twop = (~(lua_Unsigned)0) + cast_num(1);
+      const lua_Number twop = cast_num(MAX_UINTEGER) + cast_num(1);  /* 2^n */
-      lua_Number n = fltvalue(o);
+      lua_Number n = fltvalue(o);  /* get value */
       int neg = 0;
-      n = l_floor(n);
+      n = l_floor(n);  /* get its floor */
       if (n < 0) {
         neg = 1;
-        n = -n;
+        n = -n;  /* make 'n' positive, so that 'fmod' is the same as '%' */
       }
-      n = l_mathop(fmod)(n, twop);
+      n = l_mathop(fmod)(n, twop);  /* n = n % 2^(numbits in an integer) */
-      if (luai_numisnan(L,n))   /* not a number? */
+      if (luai_numisnan(n))   /* not a number? */
         break;  /* not an integer, too */
-      res = cast_unsigned(n);
+      res = cast_unsigned(n);  /* 'n' now must fit in an unsigned */
-      if (neg) res = 0u - res;
+      if (neg) res = 0u - res;  /* back to negative, if needed */
       isnum = 1;
       break;
     }
     cl = luaF_newCclosure(L, n);
     cl->c.f = fn;
     L->top -= n;
-    while (n--)
+    while (n--) {
       setobj2n(L, &cl->c.upvalue[n], L->top + n);
+      /* does not need barrier because closure is white */
+    }
     setclCvalue(L, L->top, cl);
   }
   api_incr_top(L);
 */
-LUA_API void lua_getglobal (lua_State *L, const char *var) {
+LUA_API int lua_getglobal (lua_State *L, const char *var) {
   Table *reg = hvalue(&G(L)->l_registry);
   const TValue *gt;  /* global table */
   lua_lock(L);
   setsvalue2s(L, L->top++, luaS_new(L, var));
   luaV_gettable(L, gt, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_gettable (lua_State *L, int idx) {
+LUA_API int lua_gettable (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   luaV_gettable(L, t, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
+LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   api_incr_top(L);
   luaV_gettable(L, t, L->top - 1, L->top - 1);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_rawget (lua_State *L, int idx) {
+LUA_API int lua_rawget (lua_State *L, int idx) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   api_check(L, ttistable(t), "table expected");
   setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
+LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
   StkId t;
   lua_lock(L);
   t = index2addr(L, idx);
   setobj2s(L, L->top, luaH_getint(hvalue(t), n));
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
-LUA_API void lua_rawgetp (lua_State *L, int idx, const void *p) {
+LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
   StkId t;
   TValue k;
   lua_lock(L);
   setobj2s(L, L->top, luaH_get(hvalue(t), &k));
   api_incr_top(L);
   lua_unlock(L);
+  return ttnov(L->top - 1);
 }
   StkId o;
   lua_lock(L);
   o = index2addr(L, idx);
-  api_check(L, ttisuserdata(o), "userdata expected");
+  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  if (uvalue(o)->env) {
+  getuservalue(L, rawuvalue(o), L->top);
-    sethvalue(L, L->top, uvalue(o)->env);
-  } else
-    setnilvalue(L->top);
   api_incr_top(L);
   lua_unlock(L);
 }
     case LUA_TTABLE: {
       hvalue(obj)->metatable = mt;
       if (mt) {
-        luaC_objbarrierback(L, gcvalue(obj), mt);
+        luaC_objbarrier(L, gcvalue(obj), mt);
         luaC_checkfinalizer(L, gcvalue(obj), mt);
       }
       break;
   lua_lock(L);
   api_checknelems(L, 1);
   o = index2addr(L, idx);
-  api_check(L, ttisuserdata(o), "userdata expected");
+  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  if (ttisnil(L->top - 1))
+  setuservalue(L, rawuvalue(o), L->top - 1);
-    uvalue(o)->env = NULL;
+  luaC_barrier(L, gcvalue(o), L->top - 1);
-  else {
-    api_check(L, ttistable(L->top - 1), "table expected");
-    uvalue(o)->env = hvalue(L->top - 1);
-    luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
-  }
   L->top--;
   lua_unlock(L);
 }
 }
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
+LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {
   int status;
   TValue *o;
   lua_lock(L);
   api_checknelems(L, 1);
   o = L->top - 1;
   if (isLfunction(o))
-    status = luaU_dump(L, getproto(o), writer, data, 0);
+    status = luaU_dump(L, getproto(o), writer, data, strip);
   else
     status = 1;
   lua_unlock(L);
       break;
     }
     case LUA_GCSTEP: {
-      if (g->gckind == KGC_GEN) {  /* generational mode? */
+      l_mem debt = 1;  /* =1 to signal that it did an actual step */
-        res = (g->GCestimate == 0);  /* true if it will do major collection */
+      int oldrunning = g->gcrunning;
-        luaC_forcestep(L);  /* do a single step */
+      g->gcrunning = 1;  /* force GC to run */
+      if (data == 0) {
+        luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */
+        luaC_step(L);
       }
-      else {
+      else {  /* add 'data' to total debt */
-       lu_mem debt = cast(lu_mem, data) * 1024 - GCSTEPSIZE;
+        debt = cast(l_mem, data) * 1024 + g->GCdebt;
-       if (g->gcrunning)
+        luaE_setdebt(g, debt);
-         debt += g->GCdebt;  /* include current debt */
+        luaC_checkGC(L);
-       luaE_setdebt(g, debt);
-       luaC_forcestep(L);
-       if (g->gcstate == GCSpause)  /* end of cycle? */
-         res = 1;  /* signal it */
       }
+      g->gcrunning = oldrunning;  /* restore previous state */
+      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */
+        res = 1;  /* signal it */
       break;
     }
     case LUA_GCSETPAUSE: {
       g->gcpause = data;
       break;
     }
-    case LUA_GCSETMAJORINC: {
-      res = g->gcmajorinc;
-      g->gcmajorinc = data;
-      break;
-    }
     case LUA_GCSETSTEPMUL: {
       res = g->gcstepmul;
+      if (data < 40) data = 40;  /* avoid ridiculous low values (and 0) */
       g->gcstepmul = data;
       break;
     }
       res = g->gcrunning;
       break;
     }
-    case LUA_GCGEN: {  /* change collector to generational mode */
-      luaC_changemode(L, KGC_GEN);
-      break;
-    }
-    case LUA_GCINC: {  /* change collector to incremental mode */
-      luaC_changemode(L, KGC_NORMAL);
-      break;
-    }
     default: res = -1;  /* invalid option */
   }
   lua_unlock(L);
   Udata *u;
   lua_lock(L);
   luaC_checkGC(L);
-  u = luaS_newudata(L, size, NULL);
+  u = luaS_newudata(L, size);
   setuvalue(L, L->top, u);
   api_incr_top(L);
   lua_unlock(L);
 static const char *aux_upvalue (StkId fi, int n, TValue **val,
-                                GCObject **owner) {
+                                GCObject **owner, UpVal **uv) {
   switch (ttype(fi)) {
     case LUA_TCCL: {  /* C closure */
       CClosure *f = clCvalue(fi);
       Proto *p = f->p;
       if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
       *val = f->upvals[n-1]->v;
-      if (owner) *owner = obj2gco(f->upvals[n - 1]);
+      if (uv) *uv = f->upvals[n - 1];
       name = p->upvalues[n-1].name;
-      return (name == NULL) ? "" : getstr(name);
+      return (name == NULL) ? "(*no name)" : getstr(name);
     }
     default: return NULL;  /* not a closure */
   }
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
   lua_lock(L);
-  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL);
+  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL);
   if (name) {
     setobj2s(L, L->top, val);
     api_incr_top(L);
 LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
   const char *name;
   TValue *val = NULL;  /* to avoid warnings */
-  GCObject *owner = NULL;  /* to avoid warnings */
+  GCObject *owner = NULL;
+  UpVal *uv = NULL;
   StkId fi;
   lua_lock(L);
   fi = index2addr(L, funcindex);
   api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val, &owner);
+  name = aux_upvalue(fi, n, &val, &owner, &uv);
   if (name) {
     L->top--;
     setobj(L, val, L->top);
-    luaC_barrier(L, owner, L->top);
+    if (owner) { luaC_barrier(L, owner, L->top); }
+    else if (uv) { luaC_upvalbarrier(L, uv); }
   }
   lua_unlock(L);
   return name;
   LClosure *f1;
   UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
   UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
+  luaC_upvdeccount(L, *up1);
   *up1 = *up2;
-  luaC_objbarrier(L, f1, *up2);
+  (*up1)->refcount++;
+  if (upisopen(*up1)) (*up1)->u.open.touched = 1;
+  luaC_upvalbarrier(L, *up1);
 }

src/lauxlib.c+71−59

 /*
-** $Id: lauxlib.c,v 1.255 2013/06/27 18:32:33 roberto Exp $
+** $Id: lauxlib.c,v 1.260 2014/03/12 20:57:40 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 ** =======================================================
 */
-LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
   lua_Debug ar;
   if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
+    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
   lua_getinfo(L, "n", &ar);
   if (strcmp(ar.namewhat, "method") == 0) {
-    narg--;  /* do not count `self' */
+    arg--;  /* do not count `self' */
-    if (narg == 0)  /* error is in the self argument itself? */
+    if (arg == 0)  /* error is in the self argument itself? */
       return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
                            ar.name, extramsg);
   }
   if (ar.name == NULL)
     ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
   return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
-                        narg, ar.name, extramsg);
+                        arg, ar.name, extramsg);
 }
-static int typeerror (lua_State *L, int narg, const char *tname) {
+static int typeerror (lua_State *L, int arg, const char *tname) {
-  const char *msg = lua_pushfstring(L, "%s expected, got %s",
+  const char *msg;
-                                    tname, luaL_typename(L, narg));
+  const char *typearg = luaL_typename(L, arg);
-  return luaL_argerror(L, narg, msg);
+  if (lua_getmetatable(L, arg)) {
+    if (lua_getfield(L, -1, "__name") == LUA_TSTRING)
+      typearg = lua_tostring(L, -1);
+  }
+  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
+    typearg = "light userdata";
+  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
+  return luaL_argerror(L, arg, msg);
 }
-static void tag_error (lua_State *L, int narg, int tag) {
+static void tag_error (lua_State *L, int arg, int tag) {
-  typeerror(L, narg, lua_typename(L, tag));
+  typeerror(L, arg, lua_typename(L, tag));
 }
     return 0;  /* leave previous value on top, but return 0 */
   lua_pop(L, 1);
   lua_newtable(L);  /* create metatable */
+  lua_pushstring(L, tname);
+  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
   lua_pushvalue(L, -1);
   lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
   return 1;
 ** =======================================================
 */
-LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
+LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
                                  const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, narg, def) :
+  const char *name = (def) ? luaL_optstring(L, arg, def) :
-                             luaL_checkstring(L, narg);
+                             luaL_checkstring(L, arg);
   int i;
   for (i=0; lst[i]; i++)
     if (strcmp(lst[i], name) == 0)
       return i;
-  return luaL_argerror(L, narg,
+  return luaL_argerror(L, arg,
                        lua_pushfstring(L, "invalid option " LUA_QS, name));
 }
 }
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
+LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
-  if (lua_type(L, narg) != t)
+  if (lua_type(L, arg) != t)
-    tag_error(L, narg, t);
+    tag_error(L, arg, t);
 }
-LUALIB_API void luaL_checkany (lua_State *L, int narg) {
+LUALIB_API void luaL_checkany (lua_State *L, int arg) {
-  if (lua_type(L, narg) == LUA_TNONE)
+  if (lua_type(L, arg) == LUA_TNONE)
-    luaL_argerror(L, narg, "value expected");
+    luaL_argerror(L, arg, "value expected");
 }
-LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
+LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
-  const char *s = lua_tolstring(L, narg, len);
+  const char *s = lua_tolstring(L, arg, len);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
+  if (!s) tag_error(L, arg, LUA_TSTRING);
   return s;
 }
-LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
+LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
                                         const char *def, size_t *len) {
-  if (lua_isnoneornil(L, narg)) {
+  if (lua_isnoneornil(L, arg)) {
     if (len)
       *len = (def ? strlen(def) : 0);
     return def;
   }
-  else return luaL_checklstring(L, narg, len);
+  else return luaL_checklstring(L, arg, len);
 }
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
+LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
   int isnum;
-  lua_Number d = lua_tonumberx(L, narg, &isnum);
+  lua_Number d = lua_tonumberx(L, arg, &isnum);
   if (!isnum)
-    tag_error(L, narg, LUA_TNUMBER);
+    tag_error(L, arg, LUA_TNUMBER);
   return d;
 }
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
+LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, narg, def);
+  return luaL_opt(L, luaL_checknumber, arg, def);
 }
-static void interror (lua_State *L, int narg) {
+static void interror (lua_State *L, int arg) {
-  if (lua_type(L, narg) == LUA_TNUMBER)
+  if (lua_type(L, arg) == LUA_TNUMBER)
-    luaL_argerror(L, narg, "float value out of range");
+    luaL_argerror(L, arg, "float value out of range");
   else
-    tag_error(L, narg, LUA_TNUMBER);
+    tag_error(L, arg, LUA_TNUMBER);
 }
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
+LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
   int isnum;
-  lua_Integer d = lua_tointegerx(L, narg, &isnum);
+  lua_Integer d = lua_tointegerx(L, arg, &isnum);
   if (!isnum) {
-    interror(L, narg);
+    interror(L, arg);
   }
   return d;
 }
-LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) {
+LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int arg) {
   int isnum;
-  lua_Unsigned d = lua_tounsignedx(L, narg, &isnum);
+  lua_Unsigned d = lua_tounsignedx(L, arg, &isnum);
   if (!isnum)
-    interror(L, narg);
+    interror(L, arg);
   return d;
 }
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
+LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
                                                       lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, narg, def);
+  return luaL_opt(L, luaL_checkinteger, arg, def);
 }
-LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int narg,
+LUALIB_API lua_Unsigned luaL_optunsigned (lua_State *L, int arg,
                                                         lua_Unsigned def) {
-  return luaL_opt(L, luaL_checkunsigned, narg, def);
+  return luaL_opt(L, luaL_checkunsigned, arg, def);
 }
 /* }====================================================== */
   if (!lua_getmetatable(L, obj))  /* no metatable? */
     return 0;
   lua_pushstring(L, event);
-  lua_rawget(L, -2);
+  if (lua_rawget(L, -2) == LUA_TNIL) {  /* is metafield nil? */
-  if (lua_isnil(L, -1)) {
     lua_pop(L, 2);  /* remove metatable and metafield */
     return 0;
   }
 LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
   if (!luaL_callmeta(L, idx, "__tostring")) {  /* no metafield? */
     switch (lua_type(L, idx)) {
-      case LUA_TNUMBER: {  /* concatenate with empty string to convert */
+      case LUA_TNUMBER: {
-        lua_pushvalue(L, idx);
+        if (lua_isinteger(L, idx))
-        lua_pushliteral(L, "");
+          lua_pushfstring(L, "%I", lua_tointeger(L, idx));
-        lua_concat(L, 2);
+        else {
+          const char *s = 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:
     e = strchr(fname, '.');
     if (e == NULL) e = fname + strlen(fname);
     lua_pushlstring(L, fname, e - fname);
-    lua_rawget(L, -2);
+    if (lua_rawget(L, -2) == LUA_TNIL) {  /* no such field? */
-    if (lua_isnil(L, -1)) {  /* no such field? */
       lua_pop(L, 1);  /* remove this nil */
       lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
       lua_pushlstring(L, fname, e - fname);
 LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
                                  int sizehint) {
   luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);  /* get _LOADED table */
-  lua_getfield(L, -1, modname);  /* get _LOADED[modname] */
+  if (lua_getfield(L, -1, modname) != LUA_TTABLE) {  /* no _LOADED[modname]? */
-  if (!lua_istable(L, -1)) {  /* not found? */
     lua_pop(L, 1);  /* remove previous result */
     /* try global variable (and create one if it does not exist) */
     lua_pushglobaltable(L);
 ** into the stack
 */
 LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
-  lua_getfield(L, idx, fname);
+  if (lua_getfield(L, idx, fname) == LUA_TTABLE)
-  if (lua_istable(L, -1)) return 1;  /* table already there */
+    return 1;  /* table already there */
   else {
     lua_pop(L, 1);  /* remove previous result */
     idx = lua_absindex(L, idx);

src/lauxlib.h+15−15

src/lbaselib.c+7−9

 /*
-** $Id: lbaselib.c,v 1.279 2013/07/05 14:39:15 roberto Exp $
+** $Id: lbaselib.c,v 1.285 2014/03/12 20:57:40 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
   s += strspn(s, SPACECHARS);  /* skip trailing spaces */
   if (s != e)  /* invalid trailing characters? */
     return 0;
-  *pn = (neg) ? -(lua_Integer)n : (lua_Integer)n;
+  *pn = (lua_Integer)((neg) ? (0u - n) : n);
   return 1;
 }
 static int luaB_collectgarbage (lua_State *L) {
   static const char *const opts[] = {"stop", "restart", "collect",
     "count", "step", "setpause", "setstepmul",
-    "setmajorinc", "isrunning", "generational", "incremental", NULL};
+    "isrunning", NULL};
   static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
     LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
-    LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
+    LUA_GCISRUNNING};
   int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
   int ex = luaL_optint(L, 2, 0);
   int res = lua_gc(L, o, ex);
   switch (o) {
     case LUA_GCCOUNT: {
       int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, res + ((lua_Number)b/1024));
+      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
-      lua_pushinteger(L, b);
+      return 1;
-      return 2;
     }
     case LUA_GCSTEP: case LUA_GCISRUNNING: {
       lua_pushboolean(L, res);
   luaL_checktype(L, 1, LUA_TTABLE);
   i++;  /* next value */
   lua_pushinteger(L, i);
-  lua_rawgeti(L, 1, i);
+  return (lua_rawgeti(L, 1, i) == LUA_TNIL) ? 1 : 2;
-  return (lua_isnil(L, -1)) ? 1 : 2;
 }

src/lbitlib.c+37−22

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lbitlib.c,v 1.20 2013/06/21 17:27:24 roberto Exp $	2	** $Id: lbitlib.c,v 1.25 2014/03/20 19:22:16 roberto Exp $
3	** Standard library for bitwise operations	3	** Standard library for bitwise operations
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -13,17 +13,21 @@ · 7 unmodified lines
13	#include "lualib.h"	13	#include "lualib.h"
14		14
15		15
		16	#if defined(LUA_COMPAT_BITLIB) /* { */
		17
		18
16	/* number of bits to consider in a number */	19	/* number of bits to consider in a number */
17	#if !defined(LUA_NBITS)	20	#if !defined(LUA_NBITS)
18	#define LUA_NBITS 32	21	#define LUA_NBITS 32
19	#endif	22	#endif
20		23
21		24
22	/* type with (at least) LUA_NBITS bits */	25	/*
23	typedef unsigned long b_uint;	26	** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
24		27	** be made in two parts to avoid problems when LUA_NBITS is equal to the
25		28	** number of bits in a lua_Unsigned.)
26	#define ALLONES (~(((~(b_uint)0) << (LUA_NBITS - 1)) << 1))	29	*/
		30	#define ALLONES (~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
27		31
28		32
29	/* macro to trim extra bits */	33	/* macro to trim extra bits */
@@ -35,9 +39,9 @@ typedef unsigned long b_uint; · 5 unmodified lines
35		39
36		40
37		41
38	static b_uint andaux (lua_State *L) {	42	static lua_Unsigned andaux (lua_State *L) {
39	int i, n = lua_gettop(L);	43	int i, n = lua_gettop(L);
40	b_uint r = ~(b_uint)0;	44	lua_Unsigned r = ~(lua_Unsigned)0;
41	for (i = 1; i <= n; i++)	45	for (i = 1; i <= n; i++)
42	r &= luaL_checkunsigned(L, i);	46	r &= luaL_checkunsigned(L, i);
43	return trim(r);	47	return trim(r);
@@ -45,14 +49,14 @@ static b_uint andaux (lua_State *L) { · 1 unmodified line
45		49
46		50
47	static int b_and (lua_State *L) {	51	static int b_and (lua_State *L) {
48	b_uint r = andaux(L);	52	lua_Unsigned r = andaux(L);
49	lua_pushunsigned(L, r);	53	lua_pushunsigned(L, r);
50	return 1;	54	return 1;
51	}	55	}
52		56
53		57
54	static int b_test (lua_State *L) {	58	static int b_test (lua_State *L) {
55	b_uint r = andaux(L);	59	lua_Unsigned r = andaux(L);
56	lua_pushboolean(L, r != 0);	60	lua_pushboolean(L, r != 0);
57	return 1;	61	return 1;
58	}	62	}
@@ -60,7 +64,7 @@ static int b_test (lua_State *L) { · 1 unmodified line
60		64
61	static int b_or (lua_State *L) {	65	static int b_or (lua_State *L) {
62	int i, n = lua_gettop(L);	66	int i, n = lua_gettop(L);
63	b_uint r = 0;	67	lua_Unsigned r = 0;
64	for (i = 1; i <= n; i++)	68	for (i = 1; i <= n; i++)
65	r \|= luaL_checkunsigned(L, i);	69	r \|= luaL_checkunsigned(L, i);
66	lua_pushunsigned(L, trim(r));	70	lua_pushunsigned(L, trim(r));
@@ -70,7 +74,7 @@ static int b_or (lua_State *L) { · 3 unmodified lines
70		74
71	static int b_xor (lua_State *L) {	75	static int b_xor (lua_State *L) {
72	int i, n = lua_gettop(L);	76	int i, n = lua_gettop(L);
73	b_uint r = 0;	77	lua_Unsigned r = 0;
74	for (i = 1; i <= n; i++)	78	for (i = 1; i <= n; i++)
75	r ^= luaL_checkunsigned(L, i);	79	r ^= luaL_checkunsigned(L, i);
76	lua_pushunsigned(L, trim(r));	80	lua_pushunsigned(L, trim(r));
@@ -79,13 +83,13 @@ static int b_xor (lua_State *L) { · 2 unmodified lines
79		83
80		84
81	static int b_not (lua_State *L) {	85	static int b_not (lua_State *L) {
82	b_uint r = ~luaL_checkunsigned(L, 1);	86	lua_Unsigned r = ~luaL_checkunsigned(L, 1);
83	lua_pushunsigned(L, trim(r));	87	lua_pushunsigned(L, trim(r));
84	return 1;	88	return 1;
85	}	89	}
86		90
87		91
88	static int b_shift (lua_State *L, b_uint r, int i) {	92	static int b_shift (lua_State *L, lua_Unsigned r, int i) {
89	if (i < 0) { /* shift right? */	93	if (i < 0) { /* shift right? */
90	i = -i;	94	i = -i;
91	r = trim(r);	95	r = trim(r);
@@ -113,14 +117,14 @@ static int b_rshift (lua_State *L) { · 21 unmodified lines
113		117
114		118
115	static int b_arshift (lua_State *L) {	119	static int b_arshift (lua_State *L) {
116	b_uint r = luaL_checkunsigned(L, 1);	120	lua_Unsigned r = luaL_checkunsigned(L, 1);
117	int i = luaL_checkint(L, 2);	121	int i = luaL_checkint(L, 2);
118	if (i < 0 \|\| !(r & ((b_uint)1 << (LUA_NBITS - 1))))	122	if (i < 0 \|\| !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
119	return b_shift(L, r, -i);	123	return b_shift(L, r, -i);
120	else { /* arithmetic shift for 'negative' number */	124	else { /* arithmetic shift for 'negative' number */
121	if (i >= LUA_NBITS) r = ALLONES;	125	if (i >= LUA_NBITS) r = ALLONES;
122	else	126	else
123	r = trim((r >> i) \| ~(trim(~(b_uint)0) >> i)); /* add signal bit */	127	r = trim((r >> i) \| ~(trim(~(lua_Unsigned)0) >> i)); /* add signal bit */
124	lua_pushunsigned(L, r);	128	lua_pushunsigned(L, r);
125	return 1;	129	return 1;
126	}	130	}
@@ -128,10 +132,11 @@ static int b_arshift (lua_State *L) { · 1 unmodified line
128		132
129		133
130	static int b_rot (lua_State *L, int i) {	134	static int b_rot (lua_State *L, int i) {
131	b_uint r = luaL_checkunsigned(L, 1);	135	lua_Unsigned r = luaL_checkunsigned(L, 1);
132	i &= (LUA_NBITS - 1); /* i = i % NBITS */	136	i &= (LUA_NBITS - 1); /* i = i % NBITS */
133	r = trim(r);	137	r = trim(r);
134	r = (r << i) \| (r >> (LUA_NBITS - i));	138	if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */
		139	r = (r << i) \| (r >> (LUA_NBITS - i));
135	lua_pushunsigned(L, trim(r));	140	lua_pushunsigned(L, trim(r));
136	return 1;	141	return 1;
137	}	142	}
@@ -167,7 +172,7 @@ static int fieldargs (lua_State L, int farg, int width) { · 29 unmodified lines
167		172
168	static int b_extract (lua_State *L) {	173	static int b_extract (lua_State *L) {
169	int w;	174	int w;
170	b_uint r = trim(luaL_checkunsigned(L, 1));	175	lua_Unsigned r = trim(luaL_checkunsigned(L, 1));
171	int f = fieldargs(L, 2, &w);	176	int f = fieldargs(L, 2, &w);
172	r = (r >> f) & mask(w);	177	r = (r >> f) & mask(w);
173	lua_pushunsigned(L, r);	178	lua_pushunsigned(L, r);
@@ -177,8 +182,8 @@ static int b_extract (lua_State *L) { · 3 unmodified lines
177		182
178	static int b_replace (lua_State *L) {	183	static int b_replace (lua_State *L) {
179	int w;	184	int w;
180	b_uint r = trim(luaL_checkunsigned(L, 1));	185	lua_Unsigned r = trim(luaL_checkunsigned(L, 1));
181	b_uint v = luaL_checkunsigned(L, 2);	186	lua_Unsigned v = luaL_checkunsigned(L, 2);
182	int f = fieldargs(L, 3, &w);	187	int f = fieldargs(L, 3, &w);
183	int m = mask(w);	188	int m = mask(w);
184	v &= m; /* erase bits outside given width */	189	v &= m; /* erase bits outside given width */
@@ -211,3 +216,13 @@ LUAMOD_API int luaopen_bit32 (lua_State *L) { · 26 unmodified lines
211	return 1;	216	return 1;
212	}	217	}
213		218
		219
		220	#else /* }{ */
		221
		222
		223	LUAMOD_API int luaopen_bit32 (lua_State *L) {
		224	lua_pushnil(L);
		225	return 1;
		226	}
		227
		228	#endif /* } */

src/lcode.c+65−36

 /*
-** $Id: lcode.c,v 2.71 2013/06/25 18:57:18 roberto Exp $
+** $Id: lcode.c,v 2.85 2014/03/21 13:52:33 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 }
+/*
+** Use scanner's table to cache position of constants in constant list
+** and try to reuse constants
+*/
 static int addk (FuncState *fs, TValue *key, TValue *v) {
   lua_State *L = fs->ls->L;
-  TValue *idx = luaH_set(L, fs->h, key);
   Proto *f = fs->f;
+  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
   int k, oldsize;
-  if (ttisinteger(idx)) {
+  if (ttisinteger(idx)) {  /* is there an index there? */
     k = ivalue(idx);
-    if (luaV_rawequalobj(&f->k[k], v))
+    /* correct value? (warning: must distinguish floats from integers!) */
-      return k;
+    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
-    /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
+                      luaV_rawequalobj(&f->k[k], v))
-       go through and create a new entry for this value */
+      return k;  /* reuse index */
   }
   /* constant not found; create a new entry */
   oldsize = f->sizek;
 */
 static int luaK_numberK (FuncState *fs, lua_Number r) {
   TValue o;
-  lua_assert(!luai_numisnan(NULL, r) && !isminuszero(r));
+  lua_assert(!luai_numisnan(r) && !isminuszero(r));
   setnvalue(&o, r);
   return addk(fs, &o, &o);
 }
   TValue k, v;
   setnilvalue(&v);
   /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->ls->L, &k, fs->h);
+  sethvalue(fs->ls->L, &k, fs->ls->h);
   return addk(fs, &k, &v);
 }
 }
-static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
+/*
-  TValue v1, v2, res;
+** return false if folding can raise an error
+*/
+static int validop (int op, TValue *v1, TValue *v2) {
+  lua_Number a, b;
   lua_Integer i;
-  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2))
+  cast_void(a); cast_void(b);  /* macro may not use its arguments */
+  if (luai_numinvalidop(op, (cast_void(tonumber(v1, &a)), a),
+                            (cast_void(tonumber(v2, &b)), b)))
     return 0;
-  if (op == OP_IDIV &&
+  switch (op) {
-        (!tointeger(&v1, &i) || !tointeger(&v2, &i) || i == 0))
+    case LUA_OPIDIV:  /* division by 0 and conversion errors */
-    return 0;  /* avoid division by 0 and conversion errors */
+      return (tointeger(v1, &i) && tointeger(v2, &i) && i != 0);
-  if (op == OP_MOD && ttisinteger(&v1) && ttisinteger(&v2) && ivalue(&v2) == 0)
+    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
-    return 0;  /* avoid module by 0 at compile time */
+    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT:  /* conversion errors */
-  luaO_arith(NULL, op - OP_ADD + LUA_OPADD, &v1, &v2, &res);
+      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 */
+  }
+}
+/*
+** Try to "constant-fold" an operation; return 1 iff successful
+*/
+static int constfolding (FuncState *fs, int op, expdesc *e1, expdesc *e2) {
+  TValue v1, v2, res;
+  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
+    return 0;  /* non-numeric operands or not safe to fold */
+  luaO_arith(fs->ls->L, op, &v1, &v2, &res);
   if (ttisinteger(&res)) {
     e1->k = VKINT;
     e1->u.ival = ivalue(&res);
   }
   else {
     lua_Number n = fltvalue(&res);
-    if (luai_numisnan(NULL, n) || isminuszero(n))
+    if (luai_numisnan(n) || isminuszero(n))
       return 0;  /* folds neither NaN nor -0 */
     e1->k = VKFLT;
     e1->u.nval = n;
 static void codearith (FuncState *fs, OpCode op,
                        expdesc *e1, expdesc *e2, int line) {
-  if (!constfolding(op, e1, e2)) {  /* could not fold operation? */
+  if (!constfolding(fs, op - OP_ADD + LUA_OPADD, e1, e2)) {
-    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
+    int o1, o2;
-    int o1 = luaK_exp2RK(fs, e1);
+    if (op == OP_UNM || op == OP_BNOT || op == OP_LEN) {
+      o2 = 0;
+      o1 = luaK_exp2anyreg(fs, e1);  /* cannot operate on constants */
+    }
+    else {  /* regular case (binary operators) */
+      o2 = luaK_exp2RK(fs, e2);
+      o1 = luaK_exp2RK(fs, e1);
+    }
     if (o1 > o2) {
       freeexp(fs, e1);
       freeexp(fs, e2);
 void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
   expdesc e2;
-  e2.t = e2.f = NO_JUMP; e2.k = VKFLT; e2.u.nval = 0;
+  e2.t = e2.f = NO_JUMP; e2.k = VKINT; e2.u.ival = 0;
   switch (op) {
-    case OPR_MINUS: {
+    case OPR_MINUS: case OPR_BNOT: case OPR_LEN: {
-      if (!constfolding(OP_UNM, e, e)) {  /* cannot fold it? */
+      codearith(fs, cast(OpCode, (op - OPR_MINUS) + OP_UNM), e, &e2, line);
-        luaK_exp2anyreg(fs, e);
-        codearith(fs, OP_UNM, e, &e2, line);
-      }
       break;
     }
     case OPR_NOT: codenot(fs, e); break;
-    case OPR_LEN: {
-      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
-      codearith(fs, OP_LEN, e, &e2, line);
-      break;
-    }
     default: lua_assert(0);
   }
 }
     }
     case OPR_ADD: case OPR_SUB:
     case OPR_MUL: case OPR_DIV: case OPR_IDIV:
-    case OPR_MOD: case OPR_POW: {
+    case OPR_MOD: case OPR_POW:
+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
+    case OPR_SHL: case OPR_SHR: {
       if (!tonumeral(v, NULL)) luaK_exp2RK(fs, v);
       break;
     }
       break;
     }
     case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
-    case OPR_IDIV: case OPR_MOD: case OPR_POW: {
+    case OPR_IDIV: case OPR_MOD: case OPR_POW:
-      codearith(fs, cast(OpCode, op - OPR_ADD + OP_ADD), e1, e2, line);
+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
+    case OPR_SHL: case OPR_SHR: {
+      codearith(fs, cast(OpCode, (op - OPR_ADD) + OP_ADD), e1, e2, line);
       break;
     }
     case OPR_EQ: case OPR_LT: case OPR_LE: {

src/lcode.h+7−3

 /*
-** $Id: lcode.h,v 1.60 2013/04/26 13:07:53 roberto Exp $
+** $Id: lcode.h,v 1.63 2013/12/30 20:47:58 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 ** grep "ORDER OPR" if you change these enums  (ORDER OP)
 */
 typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_IDIV, OPR_MOD, OPR_POW,
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
+  OPR_DIV,
+  OPR_IDIV,
+  OPR_BAND, OPR_BOR, OPR_BXOR,
+  OPR_SHL, OPR_SHR,
   OPR_CONCAT,
   OPR_EQ, OPR_LT, OPR_LE,
   OPR_NE, OPR_GT, OPR_GE,
 } BinOpr;
-typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
 #define getcode(fs,e)	((fs)->f->code[(e)->u.info])

src/ldblib.c+3−7

 /*
-** $Id: ldblib.c,v 1.133 2013/06/25 19:37:00 roberto Exp $
+** $Id: ldblib.c,v 1.137 2014/03/12 20:57:40 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 static int db_setuservalue (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TLIGHTUSERDATA)
-    luaL_argerror(L, 1, "full userdata expected, got light userdata");
   luaL_checktype(L, 1, LUA_TUSERDATA);
-  if (!lua_isnoneornil(L, 2))
+  luaL_checkany(L, 2);
-    luaL_checktype(L, 2, LUA_TTABLE);
   lua_settop(L, 2);
   lua_setuservalue(L, 1);
   return 1;
     {"call", "return", "line", "count", "tail call"};
   gethooktable(L);
   lua_pushthread(L);
-  lua_rawget(L, -2);
+  if (lua_rawget(L, -2) == LUA_TFUNCTION) {
-  if (lua_isfunction(L, -1)) {
     lua_pushstring(L, hooknames[(int)ar->event]);
     if (ar->currentline >= 0)
       lua_pushinteger(L, ar->currentline);

src/ldebug.c+20−13

 /*
-** $Id: ldebug.c,v 2.95 2013/05/06 17:21:59 roberto Exp $
+** $Id: ldebug.c,v 2.97 2013/12/09 14:21:10 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
 /*
 ** this function can be called asynchronous (e.g. during a signal)
 */
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
+LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
   if (func == NULL || mask == 0) {  /* turn off hooks? */
     mask = 0;
     func = NULL;
   L->basehookcount = count;
   resethookcount(L);
   L->hookmask = cast_byte(mask);
-  return 1;
 }
 }
+static int filterpc (int pc, int jmptarget) {
+  if (pc < jmptarget)  /* is code conditional (inside a jump)? */
+    return -1;  /* cannot know who sets that register */
+  else return pc;  /* current position sets that register */
+}
 /*
 ** try to find last instruction before 'lastpc' that modified register 'reg'
 */
 static int findsetreg (Proto *p, int lastpc, int reg) {
   int pc;
   int setreg = -1;  /* keep last instruction that changed 'reg' */
+  int jmptarget = 0;  /* any code before this address is conditional */
   for (pc = 0; pc < lastpc; pc++) {
     Instruction i = p->code[pc];
     OpCode op = GET_OPCODE(i);
       case OP_LOADNIL: {
         int b = GETARG_B(i);
         if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */
-          setreg = pc;
+          setreg = filterpc(pc, jmptarget);
         break;
       }
       case OP_TFORCALL: {
-        if (reg >= a + 2) setreg = pc;  /* affect all regs above its base */
+        if (reg >= a + 2)  /* affect all regs above its base */
+          setreg = filterpc(pc, jmptarget);
         break;
       }
       case OP_CALL:
       case OP_TAILCALL: {
-        if (reg >= a) setreg = pc;  /* affect all registers above base */
+        if (reg >= a)  /* affect all registers above base */
+          setreg = filterpc(pc, jmptarget);
         break;
       }
       case OP_JMP: {
         int b = GETARG_sBx(i);
         int dest = pc + 1 + b;
         /* jump is forward and do not skip `lastpc'? */
-        if (pc < dest && dest <= lastpc)
+        if (pc < dest && dest <= lastpc) {
-          pc += b;  /* do the jump */
+          if (dest > jmptarget)
-        break;
+            jmptarget = dest;  /* update 'jmptarget' */
-      }
+        }
-      case OP_TEST: {
-        if (reg == a) setreg = pc;  /* jumped code can change 'a' */
         break;
       }
       default:
         if (testAMode(op) && reg == a)  /* any instruction that set A */
-          setreg = pc;
+          setreg = filterpc(pc, jmptarget);
         break;
     }
   }

src/ldebug.h+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldebug.h,v 2.10 2013/05/06 17:19:11 roberto Exp $	2	** $Id: ldebug.h,v 2.11 2014/02/25 14:31:16 roberto Exp $
3	** Auxiliary functions from Debug Interface module	3	** Auxiliary functions from Debug Interface module
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -13,7 +13,7 @@ · 7 unmodified lines
13		13
14	#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)	14	#define pcRel(pc, p) (cast(int, (pc) - (p)->code) - 1)
15		15
16	#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)	16	#define getfuncline(f,pc) (((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
17		17
18	#define resethookcount(L) (L->hookcount = L->basehookcount)	18	#define resethookcount(L) (L->hookcount = L->basehookcount)
19		19

src/ldo.c+23−20

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldo.c,v 2.109 2013/04/19 21:05:04 roberto Exp $	2	** $Id: ldo.c,v 2.115 2014/03/21 13:52:33 roberto Exp $
3	** Stack and Call structure of Lua	3	** Stack and Call structure of Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -46,30 +46,33 @@ · 40 unmodified lines
46	** C++ code, with _longjmp/_setjmp when asked to use them, and with	46	** C++ code, with _longjmp/_setjmp when asked to use them, and with
47	** longjmp/setjmp otherwise.	47	** longjmp/setjmp otherwise.
48	*/	48	*/
49	#if !defined(LUAI_THROW)	49	#if !defined(LUAI_THROW) /* { */
		50
		51	#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* { */
50		52
51	#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)
52	/* C++ exceptions */	53	/* C++ exceptions */
53	#define LUAI_THROW(L,c) throw(c)	54	#define LUAI_THROW(L,c) throw(c)
54	#define LUAI_TRY(L,c,a) \	55	#define LUAI_TRY(L,c,a) \
55	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }	56	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
56	#define luai_jmpbuf int /* dummy variable */	57	#define luai_jmpbuf int /* dummy variable */
57		58
58	#elif defined(LUA_USE_ULONGJMP)	59	#elif defined(LUA_USE_POSIX) /* }{ */
59	/* in Unix, try _longjmp/_setjmp (more efficient) */	60
		61	/* in POSIX, try _longjmp/_setjmp (more efficient) */
60	#define LUAI_THROW(L,c) _longjmp((c)->b, 1)	62	#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
61	#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }	63	#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
62	#define luai_jmpbuf jmp_buf	64	#define luai_jmpbuf jmp_buf
63		65
64	#else	66	#else /* }{ */
65	/* default handling with long jumps */	67
		68	/* ANSI handling with long jumps */
66	#define LUAI_THROW(L,c) longjmp((c)->b, 1)	69	#define LUAI_THROW(L,c) longjmp((c)->b, 1)
67	#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }	70	#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
68	#define luai_jmpbuf jmp_buf	71	#define luai_jmpbuf jmp_buf
69		72
70	#endif	73	#endif /* } */
71		74
72	#endif	75	#endif /* } */
73		76
74		77
75		78
@@ -141,10 +144,10 @@ int luaD_rawrunprotected (lua_State L, Pfunc f, void ud) { · 65 unmodified lines
141		144
142	static void correctstack (lua_State L, TValue oldstack) {	145	static void correctstack (lua_State L, TValue oldstack) {
143	CallInfo *ci;	146	CallInfo *ci;
144	GCObject *up;	147	UpVal *up;
145	L->top = (L->top - oldstack) + L->stack;	148	L->top = (L->top - oldstack) + L->stack;
146	for (up = L->openupval; up != NULL; up = up->gch.next)	149	for (up = L->openupval; up != NULL; up = up->u.open.next)
147	gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;	150	up->v = (up->v - oldstack) + L->stack;
148	for (ci = L->ci; ci != NULL; ci = ci->previous) {	151	for (ci = L->ci; ci != NULL; ci = ci->previous) {
149	ci->top = (ci->top - oldstack) + L->stack;	152	ci->top = (ci->top - oldstack) + L->stack;
150	ci->func = (ci->func - oldstack) + L->stack;	153	ci->func = (ci->func - oldstack) + L->stack;
@@ -206,7 +209,11 @@ void luaD_shrinkstack (lua_State *L) { · 55 unmodified lines
206	int inuse = stackinuse(L);	209	int inuse = stackinuse(L);
207	int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;	210	int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
208	if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK;	211	if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK;
209	if (inuse > LUAI_MAXSTACK \|\| /* handling stack overflow? */	212	if (L->stacksize > LUAI_MAXSTACK) /* was handling stack overflow? */
		213	luaE_freeCI(L); /* free all CIs (list grew because of an error) */
		214	else
		215	luaE_shrinkCI(L); /* shrink list */
		216	if (inuse > LUAI_MAXSTACK \|\| /* still handling stack overflow? */
210	goodsize >= L->stacksize) /* would grow instead of shrink? */	217	goodsize >= L->stacksize) /* would grow instead of shrink? */
211	condmovestack(L); /* don't change stack (change only for debugging) */	218	condmovestack(L); /* don't change stack (change only for debugging) */
212	else	219	else
@@ -534,6 +541,7 @@ static void resume (lua_State L, void ud) { · 321 unmodified lines
534		541
535	LUA_API int lua_resume (lua_State L, lua_State from, int nargs) {	542	LUA_API int lua_resume (lua_State L, lua_State from, int nargs) {
536	int status;	543	int status;
		544	int oldnny = L->nny; /* save 'nny' */
537	lua_lock(L);	545	lua_lock(L);
538	luai_userstateresume(L, nargs);	546	luai_userstateresume(L, nargs);
539	L->nCcalls = (from) ? from->nCcalls + 1 : 1;	547	L->nCcalls = (from) ? from->nCcalls + 1 : 1;
@@ -555,7 +563,7 @@ LUA_API int lua_resume (lua_State L, lua_State from, int nargs) { · 15 unmodified lines
555	}	563	}
556	lua_assert(status == L->status);	564	lua_assert(status == L->status);
557	}	565	}
558	L->nny = 1; /* do not allow yields */	566	L->nny = oldnny; /* restore 'nny' */
559	L->nCcalls--;	567	L->nCcalls--;
560	lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));	568	lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
561	lua_unlock(L);	569	lua_unlock(L);
@@ -637,7 +645,6 @@ static void checkmode (lua_State L, const char mode, const char *x) { · 75 unmodified lines
637		645
638		646
639	static void f_parser (lua_State L, void ud) {	647	static void f_parser (lua_State L, void ud) {
640	int i;
641	Closure *cl;	648	Closure *cl;
642	struct SParser p = cast(struct SParser , ud);	649	struct SParser p = cast(struct SParser , ud);
643	int c = zgetc(p->z); /* read first character */	650	int c = zgetc(p->z); /* read first character */
@@ -650,11 +657,7 @@ static void f_parser (lua_State L, void ud) { · 6 unmodified lines
650	cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);	657	cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
651	}	658	}
652	lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);	659	lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
653	for (i = 0; i < cl->l.nupvalues; i++) { /* initialize upvalues */	660	luaF_initupvals(L, &cl->l);
654	UpVal *up = luaF_newupval(L);
655	cl->l.upvals[i] = up;
656	luaC_objbarrier(L, cl, up);
657	}
658	}	661	}
659		662
660		663

src/ldump.c+154−133

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ldump.c,v 2.19 2013/04/26 18:48:35 roberto Exp $	2	** $Id: ldump.c,v 2.27 2014/03/11 18:56:27 roberto Exp $
3	** save precompiled Lua chunks	3	** save precompiled Lua chunks
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -15,167 +15,188 @@ · 9 unmodified lines
15	#include "lstate.h"	15	#include "lstate.h"
16	#include "lundump.h"	16	#include "lundump.h"
17		17
		18
18	typedef struct {	19	typedef struct {
19	lua_State* L;	20	lua_State *L;
20	lua_Writer writer;	21	lua_Writer writer;
21	void* data;	22	void *data;
22	int strip;	23	int strip;
23	int status;	24	int status;
24	} DumpState;	25	} DumpState;
25		26
26	#define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D)	27
27	#define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D)	28	/*
28		29	** All high-level dumps go through DumpVector; you can change it to
29	static void DumpBlock(const void* b, size_t size, DumpState* D)	30	** change the endianess of the result
30	{	31	*/
31	if (D->status==0)	32	#define DumpVector(v,n,D) DumpBlock(v,(n)*sizeof((v)[0]),D)
32	{	33
33	lua_unlock(D->L);	34	#define DumpLiteral(s,D) DumpBlock(s, sizeof(s) - sizeof(char), D)
34	D->status=(*D->writer)(D->L,b,size,D->data);	35
35	lua_lock(D->L);	36
36	}	37	static void DumpBlock (const void b, size_t size, DumpState D) {
		38	if (D->status == 0) {
		39	lua_unlock(D->L);
		40	D->status = (*D->writer)(D->L, b, size, D->data);
		41	lua_lock(D->L);
		42	}
37	}	43	}
38		44
39	static void DumpChar(int y, DumpState* D)	45
40	{	46	#define DumpVar(x,D) DumpVector(&x,1,D)
41	char x=(char)y;	47
42	DumpVar(x,D);	48
		49	static void DumpByte (int y, DumpState *D) {
		50	lu_byte x = (lu_byte)y;
		51	DumpVar(x, D);
43	}	52	}
44		53
45	static void DumpInt(int x, DumpState* D)	54
46	{	55	static void DumpInt (int x, DumpState *D) {
47	DumpVar(x,D);	56	DumpVar(x, D);
48	}	57	}
49		58
50	static void DumpNumber(lua_Number x, DumpState* D)	59
51	{	60	static void DumpNumber (lua_Number x, DumpState *D) {
52	DumpVar(x,D);	61	DumpVar(x, D);
53	}	62	}
54		63
55	static void DumpInteger(lua_Integer x, DumpState* D)	64
56	{	65	static void DumpInteger (lua_Integer x, DumpState *D) {
57	DumpVar(x,D);	66	DumpVar(x, D);
58	}	67	}
59		68
60	static void DumpVector(const void* b, int n, size_t size, DumpState* D)	69
61	{	70	static void DumpString (const TString s, DumpState D) {
62	DumpInt(n,D);	71	if (s == NULL)
63	DumpMem(b,n,size,D);	72	DumpByte(0, D);
		73	else {
		74	size_t size = s->tsv.len + 1; /* include trailing '\0' */
		75	if (size < 0xFF)
		76	DumpByte(size, D);
		77	else {
		78	DumpByte(0xFF, D);
		79	DumpVar(size, D);
		80	}
		81	DumpVector(getstr(s), size - 1, D); /* no need to save '\0' */
		82	}
64	}	83	}
65		84
66	static void DumpString(const TString* s, DumpState* D)	85
67	{	86	static void DumpCode (const Proto f, DumpState D) {
68	if (s==NULL)	87	DumpInt(f->sizecode, D);
69	{	88	DumpVector(f->code, f->sizecode, D);
70	size_t size=0;
71	DumpVar(size,D);
72	}
73	else
74	{
75	size_t size=s->tsv.len+1; /* include trailing '\0' */
76	DumpVar(size,D);
77	DumpBlock(getstr(s),size*sizeof(char),D);
78	}
79	}	89	}
80		90
81	#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D)	91
82		92	static void DumpFunction(const Proto f, DumpState D);
83	static void DumpFunction(const Proto* f, DumpState* D);	93
84		94	static void DumpConstants (const Proto f, DumpState D) {
85	static void DumpConstants(const Proto* f, DumpState* D)	95	int i;
86	{	96	int n = f->sizek;
87	int i,n=f->sizek;	97	DumpInt(n, D);
88	DumpInt(n,D);	98	for (i = 0; i < n; i++) {
89	for (i=0; i<n; i++)	99	const TValue *o = &f->k[i];
90	{	100	DumpByte(ttype(o), D);
91	const TValue* o=&f->k[i];	101	switch (ttype(o)) {
92	DumpChar(ttype(o),D);	102	case LUA_TNIL:
93	switch (ttype(o))	103	break;
94	{	104	case LUA_TBOOLEAN:
95	case LUA_TNIL:	105	DumpByte(bvalue(o), D);
96	break;	106	break;
97	case LUA_TBOOLEAN:	107	case LUA_TNUMFLT:
98	DumpChar(bvalue(o),D);	108	DumpNumber(fltvalue(o), D);
99	break;	109	break;
100	case LUA_TNUMFLT:	110	case LUA_TNUMINT:
101	DumpNumber(fltvalue(o),D);	111	DumpInteger(ivalue(o), D);
102	break;	112	break;
103	case LUA_TNUMINT:	113	case LUA_TSHRSTR:
104	DumpInteger(ivalue(o),D);	114	case LUA_TLNGSTR:
105	break;	115	DumpString(rawtsvalue(o), D);
106	case LUA_TSHRSTR: case LUA_TLNGSTR:	116	break;
107	DumpString(rawtsvalue(o),D);	117	default:
108	break;	118	lua_assert(0);
109	default: lua_assert(0);	119	}
110	}	120	}
111	}	121	n = f->sizep;
112	n=f->sizep;	122	DumpInt(n, D);
113	DumpInt(n,D);	123	for (i = 0; i < n; i++)
114	for (i=0; i<n; i++) DumpFunction(f->p[i],D);	124	DumpFunction(f->p[i], D);
115	}	125	}
116		126
117	static void DumpUpvalues(const Proto* f, DumpState* D)	127
118	{	128	static void DumpUpvalues (const Proto f, DumpState D) {
119	int i,n=f->sizeupvalues;	129	int i, n = f->sizeupvalues;
120	DumpInt(n,D);	130	DumpInt(n, D);
121	for (i=0; i<n; i++)	131	for (i = 0; i < n; i++) {
122	{	132	DumpByte(f->upvalues[i].instack, D);
123	DumpChar(f->upvalues[i].instack,D);	133	DumpByte(f->upvalues[i].idx, D);
124	DumpChar(f->upvalues[i].idx,D);	134	}
125	}
126	}	135	}
127		136
128	static void DumpDebug(const Proto* f, DumpState* D)	137
129	{	138	static void DumpDebug (const Proto f, DumpState D) {
130	int i,n;	139	int i, n;
131	DumpString((D->strip) ? NULL : f->source,D);	140	DumpString((D->strip) ? NULL : f->source, D);
132	n= (D->strip) ? 0 : f->sizelineinfo;	141	n = (D->strip) ? 0 : f->sizelineinfo;
133	DumpVector(f->lineinfo,n,sizeof(int),D);	142	DumpInt(n, D);
134	n= (D->strip) ? 0 : f->sizelocvars;	143	DumpVector(f->lineinfo, n, D);
135	DumpInt(n,D);	144	n = (D->strip) ? 0 : f->sizelocvars;
136	for (i=0; i<n; i++)	145	DumpInt(n, D);
137	{	146	for (i = 0; i < n; i++) {
138	DumpString(f->locvars[i].varname,D);	147	DumpString(f->locvars[i].varname, D);
139	DumpInt(f->locvars[i].startpc,D);	148	DumpInt(f->locvars[i].startpc, D);
140	DumpInt(f->locvars[i].endpc,D);	149	DumpInt(f->locvars[i].endpc, D);
141	}	150	}
142	n= (D->strip) ? 0 : f->sizeupvalues;	151	n = (D->strip) ? 0 : f->sizeupvalues;
143	DumpInt(n,D);	152	DumpInt(n, D);
144	for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);	153	for (i = 0; i < n; i++)
		154	DumpString(f->upvalues[i].name, D);
145	}	155	}
146		156
147	static void DumpFunction(const Proto* f, DumpState* D)	157
148	{	158	static void DumpFunction (const Proto f, DumpState D) {
149	DumpInt(f->linedefined,D);	159	DumpInt(f->linedefined, D);
150	DumpInt(f->lastlinedefined,D);	160	DumpInt(f->lastlinedefined, D);
151	DumpChar(f->numparams,D);	161	DumpByte(f->numparams, D);
152	DumpChar(f->is_vararg,D);	162	DumpByte(f->is_vararg, D);
153	DumpChar(f->maxstacksize,D);	163	DumpByte(f->maxstacksize, D);
154	DumpCode(f,D);	164	DumpCode(f, D);
155	DumpConstants(f,D);	165	DumpConstants(f, D);
156	DumpUpvalues(f,D);	166	DumpUpvalues(f, D);
157	DumpDebug(f,D);	167	DumpDebug(f, D);
158	}	168	}
159		169
160	static void DumpHeader(DumpState* D)	170
161	{	171	static void DumpHeader (DumpState *D) {
162	lu_byte h[LUAC_HEADERSIZE];	172	DumpLiteral(LUA_SIGNATURE, D);
163	luaU_header(h);	173	DumpByte(LUAC_VERSION, D);
164	DumpBlock(h,LUAC_HEADERSIZE,D);	174	DumpByte(LUAC_FORMAT, D);
		175	DumpLiteral(LUAC_DATA, D);
		176	DumpByte(sizeof(int), D);
		177	DumpByte(sizeof(size_t), D);
		178	DumpByte(sizeof(Instruction), D);
		179	DumpByte(sizeof(lua_Integer), D);
		180	DumpByte(sizeof(lua_Number), D);
		181	DumpInteger(LUAC_INT, D);
		182	DumpNumber(LUAC_NUM, D);
165	}	183	}
166		184
		185
167	/*	186	/*
168	** dump Lua function as precompiled chunk	187	** dump Lua function as precompiled chunk
169	*/	188	*/
170	int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)	189	int luaU_dump(lua_State L, const Proto f, lua_Writer w, void *data,
171	{	190	int strip) {
172	DumpState D;	191	DumpState D;
173	D.L=L;	192	D.L = L;
174	D.writer=w;	193	D.writer = w;
175	D.data=data;	194	D.data = data;
176	D.strip=strip;	195	D.strip = strip;
177	D.status=0;	196	D.status = 0;
178	DumpHeader(&D);	197	DumpHeader(&D);
179	DumpFunction(f,&D);	198	DumpByte(f->sizeupvalues, &D);
180	return D.status;	199	DumpFunction(f, &D);
		200	return D.status;
181	}	201	}
		202

src/lfunc.c+39−54

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lfunc.c,v 2.30 2012/10/03 12:36:46 roberto Exp $	2	** $Id: lfunc.c,v 2.41 2014/02/18 13:39:37 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	*/
@@ -21,94 +21,79 @@ · 15 unmodified lines
21		21
22		22
23	Closure luaF_newCclosure (lua_State L, int n) {	23	Closure luaF_newCclosure (lua_State L, int n) {
24	Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl;	24	Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n))->cl;
25	c->c.nupvalues = cast_byte(n);	25	c->c.nupvalues = cast_byte(n);
26	return c;	26	return c;
27	}	27	}
28		28
29		29
30	Closure luaF_newLclosure (lua_State L, int n) {	30	Closure luaF_newLclosure (lua_State L, int n) {
31	Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;	31	Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n))->cl;
32	c->l.p = NULL;	32	c->l.p = NULL;
33	c->l.nupvalues = cast_byte(n);	33	c->l.nupvalues = cast_byte(n);
34	while (n--) c->l.upvals[n] = NULL;	34	while (n--) c->l.upvals[n] = NULL;
35	return c;	35	return c;
36	}	36	}
37		37
38		38	/*
39	UpVal luaF_newupval (lua_State L) {	39	** fill a closure with new closed upvalues
40	UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;	40	*/
41	uv->v = &uv->u.value;	41	void luaF_initupvals (lua_State L, LClosure cl) {
42	setnilvalue(uv->v);	42	int i;
43	return uv;	43	for (i = 0; i < cl->nupvalues; i++) {
		44	UpVal *uv = luaM_new(L, UpVal);
		45	uv->refcount = 1;
		46	uv->v = &uv->u.value; /* make it closed */
		47	setnilvalue(uv->v);
		48	cl->upvals[i] = uv;
		49	}
44	}	50	}
45		51
46		52
47	UpVal luaF_findupval (lua_State L, StkId level) {	53	UpVal luaF_findupval (lua_State L, StkId level) {
48	global_State *g = G(L);	54	UpVal **pp = &L->openupval;
49	GCObject **pp = &L->openupval;
50	UpVal *p;	55	UpVal *p;
51	UpVal *uv;	56	UpVal *uv;
52	while (pp != NULL && (p = gco2uv(pp))->v >= level) {	57	lua_assert(isintwups(L) \|\| L->openupval == NULL);
53	GCObject *o = obj2gco(p);	58	while (pp != NULL && (p = pp)->v >= level) {
54	lua_assert(p->v != &p->u.value);	59	lua_assert(upisopen(p));
55	lua_assert(!isold(o) \|\| isold(obj2gco(L)));	60	if (p->v == level) /* found a corresponding upvalue? */
56	if (p->v == level) { /* found a corresponding upvalue? */	61	return p; /* return it */
57	if (isdead(g, o)) /* is it dead? */	62	pp = &p->u.open.next;
58	changewhite(o); /* resurrect it */
59	return p;
60	}
61	pp = &p->next;
62	}	63	}
63	/* not found: create a new one */	64	/* not found: create a new upvalue */
64	uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;	65	uv = luaM_new(L, UpVal);
		66	uv->refcount = 0;
		67	uv->u.open.next = pp; / link it to list of open upvalues */
		68	uv->u.open.touched = 1;
		69	*pp = uv;
65	uv->v = level; /* current value lives in the stack */	70	uv->v = level; /* current value lives in the stack */
66	uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */	71	if (!isintwups(L)) { /* thread not in list of threads with upvalues? */
67	uv->u.l.next = g->uvhead.u.l.next;	72	L->twups = G(L)->twups; /* link it to the list */
68	uv->u.l.next->u.l.prev = uv;	73	G(L)->twups = L;
69	g->uvhead.u.l.next = uv;	74	}
70	lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
71	return uv;	75	return uv;
72	}	76	}
73		77
74		78
75	static void unlinkupval (UpVal *uv) {
76	lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
77	uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */
78	uv->u.l.prev->u.l.next = uv->u.l.next;
79	}
80
81
82	void luaF_freeupval (lua_State L, UpVal uv) {
83	if (uv->v != &uv->u.value) /* is it open? */
84	unlinkupval(uv); /* remove from open list */
85	luaM_free(L, uv); /* free upvalue */
86	}
87
88
89	void luaF_close (lua_State *L, StkId level) {	79	void luaF_close (lua_State *L, StkId level) {
90	UpVal *uv;	80	UpVal *uv;
91	global_State *g = G(L);	81	while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
92	while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) {	82	lua_assert(upisopen(uv));
93	GCObject *o = obj2gco(uv);	83	L->openupval = uv->u.open.next; /* remove from `open' list */
94	lua_assert(!isblack(o) && uv->v != &uv->u.value);	84	if (uv->refcount == 0) /* no references? */
95	L->openupval = uv->next; /* remove from `open' list */	85	luaM_free(L, uv); /* free upvalue */
96	if (isdead(g, o))
97	luaF_freeupval(L, uv); /* free upvalue */
98	else {	86	else {
99	unlinkupval(uv); /* remove upvalue from 'uvhead' list */
100	setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */	87	setobj(L, &uv->u.value, uv->v); /* move value to upvalue slot */
101	uv->v = &uv->u.value; /* now current value lives here */	88	uv->v = &uv->u.value; /* now current value lives here */
102	gch(o)->next = g->allgc; /* link upvalue into 'allgc' list */	89	luaC_upvalbarrier(L, uv);
103	g->allgc = o;
104	luaC_checkupvalcolor(g, uv);
105	}	90	}
106	}	91	}
107	}	92	}
108		93
109		94
110	Proto luaF_newproto (lua_State L) {	95	Proto luaF_newproto (lua_State L) {
111	Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p;	96	Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto))->p;
112	f->k = NULL;	97	f->k = NULL;
113	f->sizek = 0;	98	f->sizek = 0;
114	f->p = NULL;	99	f->p = NULL;

src/lfunc.h+24−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lfunc.h,v 2.8 2012/05/08 13:53:33 roberto Exp $	2	** $Id: lfunc.h,v 2.13 2014/02/18 13:39:37 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	*/
@@ -18,14 +18,35 @@ · 12 unmodified lines
18	cast(int, sizeof(TValue )((n)-1)))	18	cast(int, sizeof(TValue )((n)-1)))
19		19
20		20
		21	/* test whether thread is in 'twups' list */
		22	#define isintwups(L) (L->twups != L)
		23
		24
		25	/*
		26	** Upvalues for Lua closures
		27	*/
		28	struct UpVal {
		29	TValue v; / points to stack or to its own value */
		30	lu_mem refcount; /* reference counter */
		31	union {
		32	struct { /* (when open) */
		33	UpVal next; / linked list */
		34	int touched; /* mark to avoid cycles with dead threads */
		35	} open;
		36	TValue value; /* the value (when closed) */
		37	} u;
		38	};
		39
		40	#define upisopen(up) ((up)->v != &(up)->u.value)
		41
		42
21	LUAI_FUNC Proto luaF_newproto (lua_State L);	43	LUAI_FUNC Proto luaF_newproto (lua_State L);
22	LUAI_FUNC Closure luaF_newCclosure (lua_State L, int nelems);	44	LUAI_FUNC Closure luaF_newCclosure (lua_State L, int nelems);
23	LUAI_FUNC Closure luaF_newLclosure (lua_State L, int nelems);	45	LUAI_FUNC Closure luaF_newLclosure (lua_State L, int nelems);
24	LUAI_FUNC UpVal luaF_newupval (lua_State L);	46	LUAI_FUNC void luaF_initupvals (lua_State L, LClosure cl);
25	LUAI_FUNC UpVal luaF_findupval (lua_State L, StkId level);	47	LUAI_FUNC UpVal luaF_findupval (lua_State L, StkId level);
26	LUAI_FUNC void luaF_close (lua_State *L, StkId level);	48	LUAI_FUNC void luaF_close (lua_State *L, StkId level);
27	LUAI_FUNC void luaF_freeproto (lua_State L, Proto f);	49	LUAI_FUNC void luaF_freeproto (lua_State L, Proto f);
28	LUAI_FUNC void luaF_freeupval (lua_State L, UpVal uv);
29	LUAI_FUNC const char luaF_getlocalname (const Proto func, int local_number,	50	LUAI_FUNC const char luaF_getlocalname (const Proto func, int local_number,
30	int pc);	51	int pc);
31		52

src/lgc.c+287−336

 /*
-** $Id: lgc.c,v 2.141 2013/04/26 18:26:49 roberto Exp $
+** $Id: lgc.c,v 2.179 2014/03/21 13:52:33 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 #include "ltm.h"
+/*
+** internal state for collector while inside the atomic phase. The
+** collector should never be in this state while running regular code.
+*/
+#define GCSinsideatomic		(GCSpause + 1)
 /*
 ** cost of sweeping one element (the size of a small object divided
 /* maximum number of elements to sweep in each single step */
 #define GCSWEEPMAX	(cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))
-/* maximum number of finalizers to call in each GC step */
+/* cost of calling one finalizer */
-#define GCFINALIZENUM	4
+#define GCFINALIZECOST	GCSWEEPCOST
 /*
 /*
-** 'makewhite' erases all color bits plus the old bit and then
+** 'makewhite' erases all color bits then sets only the current white
-** sets only the current white bit
+** bit
 */
-#define maskcolors	(~(bit2mask(BLACKBIT, OLDBIT) | WHITEBITS))
+#define maskcolors	(~(bitmask(BLACKBIT) | WHITEBITS))
 #define makewhite(g,x)	\
  (gch(x)->marked = cast_byte((gch(x)->marked & maskcolors) | luaC_white(g)))
 #define black2gray(x)	resetbit(gch(x)->marked, BLACKBIT)
-#define isfinalized(x)		testbit(gch(x)->marked, FINALIZEDBIT)
+#define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))
 #define checkdeadkey(n)	lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))
 #define markvalue(g,o) { checkconsistency(o); \
   if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
-#define markobject(g,t) { if ((t) && iswhite(obj2gco(t))) \
+#define markobject(g,t) \
-		reallymarkobject(g, obj2gco(t)); }
+  { if ((t) && iswhite(obj2gco(t))) reallymarkobject(g, obj2gco(t)); }
 static void reallymarkobject (global_State *g, GCObject *o);
   global_State *g = G(L);
   lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
   lua_assert(g->gcstate != GCSpause);
-  lua_assert(gch(o)->tt != LUA_TTABLE);
+  lua_assert(gch(o)->tt != LUA_TTABLE);  /* tables use a back barrier */
-  if (keepinvariantout(g))  /* must keep invariant? */
+  if (keepinvariant(g))  /* must keep invariant? */
     reallymarkobject(g, v);  /* restore invariant */
   else {  /* sweep phase */
     lua_assert(issweepphase(g));
 /*
-** barrier for prototypes. When creating first closure (cache is
+** barrier for assignments to closed upvalues. Because upvalues are
-** NULL), use a forward barrier; this may be the only closure of the
+** shared among closures, it is impossible to know the color of all
-** prototype (if it is a "regular" function, with a single instance)
+** closures pointing to it. So, we assume that the object being assigned
-** and the prototype may be big, so it is better to avoid traversing
+** must be marked.
-** it again. Otherwise, use a backward barrier, to avoid marking all
-** possible instances.
 */
-LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c) {
+LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
   global_State *g = G(L);
-  lua_assert(isblack(obj2gco(p)));
+  GCObject *o = gcvalue(uv->v);
-  if (p->cache == NULL) {  /* first time? */
+  lua_assert(!upisopen(uv));  /* ensured by macro luaC_upvalbarrier */
-    luaC_objbarrier(L, p, c);
+  if (keepinvariant(g))
-  }
+    markobject(g, o);
-  else {  /* use a backward barrier */
-    black2gray(obj2gco(p));  /* make prototype gray (again) */
-    p->gclist = g->grayagain;
-    g->grayagain = obj2gco(p);
-  }
 }
-/*
+void luaC_fix (lua_State *L, GCObject *o) {
-** check color (and invariants) for an upvalue that was closed,
+  global_State *g = G(L);
-** i.e., moved into the 'allgc' list
+  lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
-*/
+  white2gray(o);  /* they will be gray forever */
-void luaC_checkupvalcolor (global_State *g, UpVal *uv) {
+  g->allgc = o->gch.next;  /* remove object from 'allgc' list */
-  GCObject *o = obj2gco(uv);
+  o->gch.next = g->fixedgc;  /* link it to 'fixedgc' list */
-  lua_assert(!isblack(o));  /* open upvalues are never black */
+  g->fixedgc = o;
-  if (isgray(o)) {
-    if (keepinvariant(g)) {
-      resetoldbit(o);  /* see MOVE OLD rule */
-      gray2black(o);  /* it is being visited now */
-      markvalue(g, uv->v);
-    }
-    else {
-      lua_assert(issweepphase(g));
-      makewhite(g, o);
-    }
-  }
 }
 /*
 ** create a new collectable object (with given type and size) and link
-** it to '*list'. 'offset' tells how many bytes to allocate before the
+** it to 'allgc' list.
-** object itself (used only by states).
 */
-GCObject *luaC_newobj (lua_State *L, int tt, size_t sz, GCObject **list,
+GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
-                       int offset) {
   global_State *g = G(L);
-  char *raw = cast(char *, luaM_newobject(L, novariant(tt), sz));
+  GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
-  GCObject *o = obj2gco(raw + offset);
-  if (list == NULL)
-    list = &g->allgc;  /* standard list for collectable objects */
   gch(o)->marked = luaC_white(g);
   gch(o)->tt = tt;
-  gch(o)->next = *list;
+  gch(o)->next = g->allgc;
-  *list = o;
+  g->allgc = o;
   return o;
 }
 ** upvalues are already linked in 'headuv' list.)
 */
 static void reallymarkobject (global_State *g, GCObject *o) {
-  lu_mem size;
+ reentry:
   white2gray(o);
   switch (gch(o)->tt) {
     case LUA_TSHRSTR:
     case LUA_TLNGSTR: {
-      size = sizestring(gco2ts(o));
+      gray2black(o);
-      break;  /* nothing else to mark; make it black */
+      g->GCmemtrav += sizestring(gco2ts(o));
-    }
-    case LUA_TUSERDATA: {
-      Table *mt = gco2u(o)->metatable;
-      markobject(g, mt);
-      markobject(g, gco2u(o)->env);
-      size = sizeudata(gco2u(o));
       break;
     }
-    case LUA_TUPVAL: {
+    case LUA_TUSERDATA: {
-      UpVal *uv = gco2uv(o);
+      TValue uvalue;
-      markvalue(g, uv->v);
+      markobject(g, gco2u(o)->metatable);  /* mark its metatable */
-      if (uv->v != &uv->u.value)  /* open? */
+      gray2black(o);
-        return;  /* open upvalues remain gray */
+      g->GCmemtrav += sizeudata(gco2u(o));
-      size = sizeof(UpVal);
+      getuservalue(g->mainthread, rawgco2u(o), &uvalue);
+      if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
+        o = gcvalue(&uvalue);
+        goto reentry;
+      }
       break;
     }
     case LUA_TLCL: {
       gco2lcl(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
     case LUA_TCCL: {
       gco2ccl(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
     case LUA_TTABLE: {
       linktable(gco2t(o), &g->gray);
-      return;
+      break;
     }
     case LUA_TTHREAD: {
       gco2th(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
     case LUA_TPROTO: {
       gco2p(o)->gclist = g->gray;
       g->gray = o;
-      return;
+      break;
     }
-    default: lua_assert(0); return;
+    default: lua_assert(0); break;
   }
-  gray2black(o);
-  g->GCmemtrav += size;
 }
 */
 static void markbeingfnz (global_State *g) {
   GCObject *o;
-  for (o = g->tobefnz; o != NULL; o = gch(o)->next) {
+  for (o = g->tobefnz; o != NULL; o = gch(o)->next)
-    makewhite(g, o);
+    markobject(g, o);
-    reallymarkobject(g, o);
-  }
 }
 /*
-** mark all values stored in marked open upvalues. (See comment in
+** Mark all values stored in marked open upvalues from non-marked threads.
-** 'lstate.h'.)
+** (Values from marked threads were already marked when traversing the
+** thread.) Remove from the list threads that no longer have upvalues and
+** not-marked threads.
 */
 static void remarkupvals (global_State *g) {
-  UpVal *uv;
+  lua_State *thread;
-  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
+  lua_State **p = &g->twups;
-    if (isgray(obj2gco(uv)))
+  while ((thread = *p) != NULL) {
-      markvalue(g, uv->v);
+    lua_assert(!isblack(obj2gco(thread)));  /* threads are never black */
+    if (isgray(obj2gco(thread)) && thread->openupval != NULL)
+      p = &thread->twups;  /* keep marked thread with upvalues in the list */
+    else {  /* thread is not marked or without upvalues */
+      UpVal *uv;
+      *p = thread->twups;  /* remove thread from the list */
+      thread->twups = thread;  /* mark that it is out of list */
+      for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) {
+        if (uv->u.open.touched) {
+          markvalue(g, uv->v);  /* remark upvalue's value */
+          uv->u.open.touched = 0;
+        }
+      }
+    }
   }
 }
 /*
-** mark root set and reset all gray lists, to start a new
+** mark root set and reset all gray lists, to start a new collection
-** incremental (or full) collection
 */
 static void restartcollection (global_State *g) {
   g->gray = g->grayagain = NULL;
   return sizeCclosure(cl->nupvalues);
 }
+/*
+** open upvalues point to values in a thread, so those values should
+** be marked when the thread is traversed except in the atomic phase
+** (because then the value cannot be changed by the thread and the
+** thread may not be traversed again)
+*/
 static lu_mem traverseLclosure (global_State *g, LClosure *cl) {
   int i;
   markobject(g, cl->p);  /* mark its prototype */
-  for (i = 0; i < cl->nupvalues; i++)  /* mark its upvalues */
+  for (i = 0; i < cl->nupvalues; i++) {  /* mark its upvalues */
-    markobject(g, cl->upvals[i]);
+    UpVal *uv = cl->upvals[i];
+    if (uv != NULL) {
+      if (upisopen(uv) && g->gcstate != GCSinsideatomic)
+        uv->u.open.touched = 1;  /* can be marked in 'remarkupvals' */
+      else
+        markvalue(g, uv->v);
+    }
+  }
   return sizeLclosure(cl->nupvalues);
 }
   StkId o = th->stack;
   if (o == NULL)
     return 1;  /* stack not completely built yet */
+  lua_assert(g->gcstate == GCSinsideatomic ||
+             th->openupval == NULL || isintwups(th));
   for (; o < th->top; o++)  /* mark live elements in the stack */
     markvalue(g, o);
-  if (g->gcstate == GCSatomic) {  /* final traversal? */
+  if (g->gcstate == GCSinsideatomic) {  /* final traversal? */
     StkId lim = th->stack + th->stacksize;  /* real end of stack */
     for (; o < lim; o++)  /* clear not-marked stack slice */
       setnilvalue(o);
+    /* 'remarkupvals' may have removed thread from 'twups' list */
+    if (!isintwups(th) && th->openupval != NULL) {
+      th->twups = g->twups;  /* link it back to the list */
+      g->twups = th;
+    }
   }
-  else {  /* count call infos to compute size */
+  else {
     CallInfo *ci;
     for (ci = &th->base_ci; ci != th->ci; ci = ci->next)
-      n++;
+      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;
 }
+void luaC_upvdeccount (lua_State *L, UpVal *uv) {
+  lua_assert(uv->refcount > 0);
+  uv->refcount--;
+  if (uv->refcount == 0 && !upisopen(uv))
+    luaM_free(L, uv);
+}
+static void freeLclosure (lua_State *L, LClosure *cl) {
+  int i;
+  for (i = 0; i < cl->nupvalues; i++) {
+    UpVal *uv = cl->upvals[i];
+    if (uv)
+      luaC_upvdeccount(L, uv);
+  }
+  luaM_freemem(L, cl, sizeLclosure(cl->nupvalues));
+}
 static void freeobj (lua_State *L, GCObject *o) {
   switch (gch(o)->tt) {
     case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
     case LUA_TLCL: {
-      luaM_freemem(L, o, sizeLclosure(gco2lcl(o)->nupvalues));
+      freeLclosure(L, gco2lcl(o));
       break;
     }
     case LUA_TCCL: {
       luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues));
       break;
     }
-    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
     case LUA_TTABLE: luaH_free(L, gco2t(o)); break;
     case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
     case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
     case LUA_TSHRSTR:
-      G(L)->strt.nuse--;
+      luaS_remove(L, rawgco2ts(o));  /* remove it from hash table */
       /* go through */
     case LUA_TLNGSTR: {
       luaM_freemem(L, o, sizestring(gco2ts(o)));
 static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count);
-/*
-** sweep the (open) upvalues of a thread and resize its stack and
-** list of call-info structures.
-*/
-static void sweepthread (lua_State *L, lua_State *L1) {
-  if (L1->stack == NULL) return;  /* stack not completely built yet */
-  sweepwholelist(L, &L1->openupval);  /* sweep open upvalues */
-  luaE_freeCI(L1);  /* free extra CallInfo slots */
-  /* should not change the stack during an emergency gc cycle */
-  if (G(L)->gckind != KGC_EMERGENCY)
-    luaD_shrinkstack(L1);
-}
 /*
 ** sweep at most 'count' elements from a list of GCObjects erasing dead
 ** objects, where a dead (not alive) object is one marked with the "old"
-** (non current) white and not fixed.
+** (non current) white and not fixed; change all non-dead objects back
-** In non-generational mode, change all non-dead objects back to white,
+** to white, preparing for next collection cycle.
-** preparing for next collection cycle.
-** In generational mode, keep black objects black, and also mark them as
-** old; stop when hitting an old object, as all objects after that
-** one will be old too.
 ** When object is a thread, sweep its list of open upvalues too.
 */
 static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
   global_State *g = G(L);
   int ow = otherwhite(g);
-  int toclear, toset;  /* bits to clear and to set in all live objects */
+  int white = luaC_white(g);  /* current white */
-  int tostop;  /* stop sweep when this is true */
-  if (isgenerational(g)) {  /* generational mode? */
-    toclear = ~0;  /* clear nothing */
-    toset = bitmask(OLDBIT);  /* set the old bit of all surviving objects */
-    tostop = bitmask(OLDBIT);  /* do not sweep old generation */
-  }
-  else {  /* normal mode */
-    toclear = maskcolors;  /* clear all color bits + old bit */
-    toset = luaC_white(g);  /* make object white */
-    tostop = 0;  /* do not stop */
-  }
   while (*p != NULL && count-- > 0) {
     GCObject *curr = *p;
     int marked = gch(curr)->marked;
       *p = gch(curr)->next;  /* remove 'curr' from list */
       freeobj(L, curr);  /* erase 'curr' */
     }
-    else {
+    else {  /* update marks */
-      if (testbits(marked, tostop))
+      gch(curr)->marked = cast_byte((marked & maskcolors) | white);
-        return NULL;  /* stop sweeping this list */
-      if (gch(curr)->tt == LUA_TTHREAD)
-        sweepthread(L, gco2th(curr));  /* sweep thread's upvalues */
-      /* update marks */
-      gch(curr)->marked = cast_byte((marked & toclear) | toset);
       p = &gch(curr)->next;  /* go to next element */
     }
   }
 ** sweep a list until a live object (or end of list)
 */
 static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) {
-  GCObject ** old = p;
+  GCObject **old = p;
   int i = 0;
   do {
     i++;
 ** =======================================================
 */
-static void checkSizes (lua_State *L) {
+/*
-  global_State *g = G(L);
+** If possible, free concatenation buffer and shrink string table
-  if (g->gckind != KGC_EMERGENCY) {  /* do not change sizes in emergency */
+*/
-    int hs = g->strt.size / 2;  /* half the size of the string table */
+static void checkSizes (lua_State *L, global_State *g) {
-    if (g->strt.nuse < cast(lu_int32, hs))  /* using less than that half? */
+  if (g->gckind != KGC_EMERGENCY) {
-      luaS_resize(L, hs);  /* halve its size */
     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 */
   }
 }
 static GCObject *udata2finalize (global_State *g) {
   GCObject *o = g->tobefnz;  /* get first element */
-  lua_assert(isfinalized(o));
+  lua_assert(tofinalize(o));
   g->tobefnz = gch(o)->next;  /* remove it from 'tobefnz' list */
   gch(o)->next = g->allgc;  /* return it to 'allgc' list */
   g->allgc = o;
-  resetbit(gch(o)->marked, SEPARATED);  /* mark that it is not in 'tobefnz' */
+  resetbit(gch(o)->marked, FINALIZEDBIT);  /* object is "normal" again */
-  lua_assert(!isold(o));  /* see MOVE OLD rule */
+  if (issweepphase(g))
-  if (!keepinvariantout(g))  /* not keeping invariant? */
     makewhite(g, o);  /* "sweep" object */
   return o;
 }
 /*
-** move all unreachable objects (or 'all' objects) that need
+** call all pending finalizers
-** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
 */
-static void separatetobefnz (lua_State *L, int all) {
+static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
   global_State *g = G(L);
-  GCObject **p = &g->finobj;
+  while (g->tobefnz)
+    GCTM(L, propagateerrors);
+}
+/*
+** find last 'next' field in list 'p' list (to add elements in its end)
+*/
+static GCObject **findlast (GCObject **p) {
+  while (*p != NULL)
+    p = &gch(*p)->next;
+  return p;
+}
+/*
+** move all unreachable objects (or 'all' objects) that need
+** finalization from list 'p' to list 'tobefnz' (to be finalized)
+*/
+static void separatetobefnz (global_State *g, int all) {
   GCObject *curr;
-  GCObject **lastnext = &g->tobefnz;
+  GCObject **p = &g->finobj;
-  /* find last 'next' field in 'tobefnz' list (to add elements in its end) */
+  GCObject **lastnext = findlast(&g->tobefnz);
-  while (*lastnext != NULL)
-    lastnext = &gch(*lastnext)->next;
   while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
-    lua_assert(!isfinalized(curr));
+    lua_assert(tofinalize(curr));
-    lua_assert(testbit(gch(curr)->marked, SEPARATED));
     if (!(iswhite(curr) || all))  /* not being collected? */
       p = &gch(curr)->next;  /* don't bother with it */
     else {
-      l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */
+      *p = gch(curr)->next;  /* remove 'curr' from "fin" list */
-      *p = gch(curr)->next;  /* remove 'curr' from 'finobj' list */
       gch(curr)->next = *lastnext;  /* link at the end of 'tobefnz' list */
       *lastnext = curr;
       lastnext = &gch(curr)->next;
 */
 void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
   global_State *g = G(L);
-  if (testbit(gch(o)->marked, SEPARATED) || /* obj. is already separated... */
+  if (tofinalize(o) ||                 /* obj. is already marked... */
-      isfinalized(o) ||                           /* ... or is finalized... */
+      gfasttm(g, mt, TM_GC) == NULL)   /* or has no finalizer? */
-      gfasttm(g, mt, TM_GC) == NULL)                /* or has no finalizer? */
     return;  /* nothing to be done */
   else {  /* move 'o' to 'finobj' list */
     GCObject **p;
-    GCheader *ho = gch(o);
+    if (g->sweepgc == &o->gch.next) {  /* avoid removing current sweep object */
-    if (g->sweepgc == &ho->next) {  /* avoid removing current sweep object */
       lua_assert(issweepphase(g));
       g->sweepgc = sweeptolive(L, g->sweepgc, NULL);
     }
     /* search for pointer pointing to 'o' */
     for (p = &g->allgc; *p != o; p = &gch(*p)->next) { /* empty */ }
-    *p = ho->next;  /* remove 'o' from root list */
+    *p = o->gch.next;  /* remove 'o' from its list */
-    ho->next = g->finobj;  /* link it in list 'finobj' */
+    o->gch.next = g->finobj;  /* link it in "fin" list */
     g->finobj = o;
-    l_setbit(ho->marked, SEPARATED);  /* mark it as such */
+    l_setbit(o->gch.marked, FINALIZEDBIT);  /* mark it as such */
-    if (!keepinvariantout(g))  /* not keeping invariant? */
+    if (issweepphase(g))
       makewhite(g, o);  /* "sweep" object */
-    else
-      resetoldbit(o);  /* see MOVE OLD rule */
   }
 }
 /* }====================================================== */
 /*
 ** {======================================================
 ** GC control
 ** cycle will start when memory use hits threshold
 */
 static void setpause (global_State *g, l_mem estimate) {
-  l_mem debt, threshold;
+  l_mem threshold, debt;
   estimate = estimate / PAUSEADJ;  /* adjust 'estimate' */
   threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
             ? estimate * g->gcpause  /* no overflow */
             : MAX_LMEM;  /* overflow; truncate to maximum */
-  debt = -cast(l_mem, threshold - gettotalbytes(g));
+  debt = gettotalbytes(g) - threshold;
   luaE_setdebt(g, debt);
 }
-#define sweepphases  \
-	(bitmask(GCSsweepstring) | bitmask(GCSsweepudata) | bitmask(GCSsweep))
 /*
-** enter first sweep phase (strings) and prepare pointers for other
+** Enter first sweep phase.
-** sweep phases.  The calls to 'sweeptolive' make pointers point to an
+** The call to 'sweeptolive' makes pointer point to an object inside
-** object inside the list (instead of to the header), so that the real
+** the list (instead of to the header), so that the real sweep do not
-** sweep do not need to skip objects created between "now" and the start
+** need to skip objects created between "now" and the start of the real
-** of the real sweep.
+** sweep.
 ** Returns how many objects it swept.
 */
 static int entersweep (lua_State *L) {
   global_State *g = G(L);
   int n = 0;
-  g->gcstate = GCSsweepstring;
+  g->gcstate = GCSswpallgc;
-  lua_assert(g->sweepgc == NULL && g->sweepfin == NULL);
+  lua_assert(g->sweepgc == NULL);
-  /* prepare to sweep strings, finalizable objects, and regular objects */
-  g->sweepstrgc = 0;
-  g->sweepfin = sweeptolive(L, &g->finobj, &n);
   g->sweepgc = sweeptolive(L, &g->allgc, &n);
   return n;
 }
-/*
-** change GC mode
-*/
-void luaC_changemode (lua_State *L, int mode) {
-  global_State *g = G(L);
-  if (mode == g->gckind) return;  /* nothing to change */
-  if (mode == KGC_GEN) {  /* change to generational mode */
-    /* make sure gray lists are consistent */
-    luaC_runtilstate(L, bitmask(GCSpropagate));
-    g->GCestimate = gettotalbytes(g);
-    g->gckind = KGC_GEN;
-  }
-  else {  /* change to incremental mode */
-    /* sweep all objects to turn them back to white
-       (as white has not changed, nothing extra will be collected) */
-    g->gckind = KGC_NORMAL;
-    entersweep(L);
-    luaC_runtilstate(L, ~sweepphases);
-  }
-}
-/*
-** call all pending finalizers
-*/
-static void callallpendingfinalizers (lua_State *L, int propagateerrors) {
-  global_State *g = G(L);
-  while (g->tobefnz) {
-    resetoldbit(g->tobefnz);
-    GCTM(L, propagateerrors);
-  }
-}
 void luaC_freeallobjects (lua_State *L) {
   global_State *g = G(L);
-  int i;
+  separatetobefnz(g, 1);  /* separate all objects with finalizers */
-  separatetobefnz(L, 1);  /* separate all objects with finalizers */
   lua_assert(g->finobj == NULL);
   callallpendingfinalizers(L, 0);
+  lua_assert(g->tobefnz == NULL);
   g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
   g->gckind = KGC_NORMAL;
-  sweepwholelist(L, &g->finobj);  /* finalizers can create objs. in 'finobj' */
+  sweepwholelist(L, &g->finobj);
   sweepwholelist(L, &g->allgc);
-  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
+  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */
-    sweepwholelist(L, &g->strt.hash[i]);
   lua_assert(g->strt.nuse == 0);
 }
   l_mem work = -cast(l_mem, g->GCmemtrav);  /* start counting work */
   GCObject *origweak, *origall;
   lua_assert(!iswhite(obj2gco(g->mainthread)));
+  g->gcstate = GCSinsideatomic;
   markobject(g, L);  /* mark running thread */
   /* registry and global metatables may be changed by API */
   markvalue(g, &g->l_registry);
   work -= g->GCmemtrav;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all strongly accessible objects are marked. */
-  /* clear values from weak tables, before checking finalizers */
+  /* Clear values from weak tables, before checking finalizers */
   clearvalues(g, g->weak, NULL);
   clearvalues(g, g->allweak, NULL);
   origweak = g->weak; origall = g->allweak;
   work += g->GCmemtrav;  /* stop counting (objects being finalized) */
-  separatetobefnz(L, 0);  /* separate objects to be finalized */
+  separatetobefnz(g, 0);  /* separate objects to be finalized */
+  g->gcfinnum = 1;  /* there may be objects to be finalized */
   markbeingfnz(g);  /* mark objects that will be finalized */
-  propagateall(g);  /* remark, to propagate `preserveness' */
+  propagateall(g);  /* remark, to propagate 'resurrection' */
   work -= g->GCmemtrav;  /* restart counting */
   convergeephemerons(g);
   /* at this point, all resurrected objects are marked. */
 }
+static lu_mem sweepstep (lua_State *L, global_State *g,
+                         int nextstate, GCObject **nextlist) {
+  if (g->sweepgc) {
+    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+    if (g->sweepgc)  /* is there still something to sweep? */
+      return (GCSWEEPMAX * GCSWEEPCOST);
+  }
+  /* else enter next state */
+  g->gcstate = nextstate;
+  g->sweepgc = nextlist;
+  return 0;
+}
 static lu_mem singlestep (lua_State *L) {
   global_State *g = G(L);
   switch (g->gcstate) {
     case GCSpause: {
       /* start to count memory traversed */
       g->GCmemtrav = g->strt.size * sizeof(GCObject*);
-      lua_assert(!isgenerational(g));
       restartcollection(g);
       g->gcstate = GCSpropagate;
       return g->GCmemtrav;
     }
     case GCSpropagate: {
-      if (g->gray) {
+      lu_mem oldtrav = g->GCmemtrav;
-        lu_mem oldtrav = g->GCmemtrav;
+      lua_assert(g->gray);
-        propagatemark(g);
+      propagatemark(g);
-        return g->GCmemtrav - oldtrav;  /* memory traversed in this step */
+       if (g->gray == NULL)  /* no more `gray' objects? */
-      }
+        g->gcstate = GCSatomic;  /* finish propagate phase */
-      else {  /* no more `gray' objects */
+      return g->GCmemtrav - oldtrav;  /* memory traversed in this step */
-        lu_mem work;
-        int sw;
-        g->gcstate = GCSatomic;  /* finish mark phase */
-        g->GCestimate = g->GCmemtrav;  /* save what was counted */;
-        work = atomic(L);  /* add what was traversed by 'atomic' */
-        g->GCestimate += work;  /* estimate of total memory traversed */
-        sw = entersweep(L);
-        return work + sw * GCSWEEPCOST;
-      }
     }
-    case GCSsweepstring: {
+    case GCSatomic: {
-      int i;
+      lu_mem work;
-      for (i = 0; i < GCSWEEPMAX && g->sweepstrgc + i < g->strt.size; i++)
+      int sw;
-        sweepwholelist(L, &g->strt.hash[g->sweepstrgc + i]);
+      propagateall(g);  /* make sure gray list is empty */
-      g->sweepstrgc += i;
+      g->GCestimate = g->GCmemtrav;  /* save what was counted */;
-      if (g->sweepstrgc >= g->strt.size)  /* no more strings to sweep? */
+      work = atomic(L);  /* work is what was traversed by 'atomic' */
-        g->gcstate = GCSsweepudata;
+      g->GCestimate += work;  /* estimate of total memory traversed */
-      return i * GCSWEEPCOST;
+      sw = entersweep(L);
+      return work + sw * GCSWEEPCOST;
     }
-    case GCSsweepudata: {
+    case GCSswpallgc: {  /* sweep "regular" objects */
-      if (g->sweepfin) {
+      return sweepstep(L, g, GCSswpfinobj, &g->finobj);
-        g->sweepfin = sweeplist(L, g->sweepfin, GCSWEEPMAX);
-        return GCSWEEPMAX*GCSWEEPCOST;
-      }
-      else {
-        g->gcstate = GCSsweep;
-        return 0;
-      }
     }
-    case GCSsweep: {
+    case GCSswpfinobj: {  /* sweep objects with finalizers */
-      if (g->sweepgc) {
+      return sweepstep(L, g, GCSswptobefnz, &g->tobefnz);
-        g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+    }
-        return GCSWEEPMAX*GCSWEEPCOST;
+    case GCSswptobefnz: {  /* sweep objects to be finalized */
-      }
+      return sweepstep(L, g, GCSswpend, NULL);
-      else {
+    }
-        /* sweep main thread */
+    case GCSswpend: {  /* finish sweeps */
-        GCObject *mt = obj2gco(g->mainthread);
+      makewhite(g, obj2gco(g->mainthread));  /* sweep main thread */
-        sweeplist(L, &mt, 1);
+      checkSizes(L, g);
-        checkSizes(L);
+      g->gcstate = GCScallfin;
-        g->gcstate = GCSpause;  /* finish collection */
+      return 0;
-        return GCSWEEPCOST;
+    }
-      }
+    case GCScallfin: {  /* state to finish calling finalizers */
+      /* do nothing here; should be handled by 'luaC_forcestep' */
+      g->gcstate = GCSpause;  /* finish collection */
+      return 0;
     }
     default: lua_assert(0); return 0;
   }
 }
-static void generationalcollection (lua_State *L) {
+/*
+** run a few (up to 'g->gcfinnum') finalizers
+*/
+static int runafewfinalizers (lua_State *L) {
   global_State *g = G(L);
-  lua_assert(g->gcstate == GCSpropagate);
+  unsigned int i;
-  if (g->GCestimate == 0) {  /* signal for another major collection? */
+  lua_assert(!g->tobefnz || g->gcfinnum > 0);
-    luaC_fullgc(L, 0);  /* perform a full regular collection */
+  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
-    g->GCestimate = gettotalbytes(g);  /* update control */
+    GCTM(L, 1);  /* call one finalizer */
-  }
+  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
-  else {
+                    : g->gcfinnum * 2;  /* else call a few more next time */
-    lu_mem estimate = g->GCestimate;
+  return i;
-    luaC_runtilstate(L, bitmask(GCSpause));  /* run complete (minor) cycle */
-    g->gcstate = GCSpropagate;  /* skip restart */
-    if (gettotalbytes(g) > (estimate / 100) * g->gcmajorinc)
-      g->GCestimate = 0;  /* signal for a major collection */
-    else
-      g->GCestimate = estimate;  /* keep estimate from last major coll. */
-  }
-  setpause(g, gettotalbytes(g));
-  lua_assert(g->gcstate == GCSpropagate);
 }
-static void incstep (lua_State *L) {
+/*
-  global_State *g = G(L);
+** get GC debt and convert it from Kb to 'work units' (avoid zero debt
+** and overflows)
+*/
+static l_mem getdebt (global_State *g) {
   l_mem debt = g->GCdebt;
   int stepmul = g->gcstepmul;
-  if (stepmul < 40) stepmul = 40;  /* avoid ridiculous low values (and 0) */
-  /* convert debt from Kb to 'work units' (avoid zero debt and overflows) */
   debt = (debt / STEPMULADJ) + 1;
   debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
-  do {  /* always perform at least one single step */
+  return debt;
-    lu_mem work = singlestep(L);  /* do some work */
-    debt -= work;
-  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
-  if (g->gcstate == GCSpause)
-    setpause(g, g->GCestimate);  /* pause until next cycle */
-  else {
-    debt = (debt / stepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
-    luaE_setdebt(g, debt);
-  }
 }
 /*
-** performs a basic GC step
+** performs a basic GC step when collector is running
-*/
-void luaC_forcestep (lua_State *L) {
-  global_State *g = G(L);
-  int i;
-  if (isgenerational(g)) generationalcollection(L);
-  else incstep(L);
-  /* run a few finalizers (or all of them at the end of a collect cycle) */
-  for (i = 0; g->tobefnz && (i < GCFINALIZENUM || g->gcstate == GCSpause); i++)
-    GCTM(L, 1);  /* call one finalizer */
-}
-/*
-** performs a basic GC step only if collector is running
 */
 void luaC_step (lua_State *L) {
   global_State *g = G(L);
-  if (g->gcrunning) luaC_forcestep(L);
+  l_mem debt = getdebt(g);
-  else luaE_setdebt(g, -GCSTEPSIZE);  /* avoid being called too often */
+  if (!g->gcrunning) {  /* not running? */
+    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
+    return;
+  }
+  do {
+    if (g->gcstate == GCScallfin && g->tobefnz) {
+      unsigned int n = runafewfinalizers(L);
+      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 */
+  else {
+    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
+    luaE_setdebt(g, debt);
+    runafewfinalizers(L);
+  }
 }
 /*
 ** performs a full GC cycle; if "isemergency", does not call
 ** finalizers (which could change stack positions)
 */
 void luaC_fullgc (lua_State *L, int isemergency) {
   global_State *g = G(L);
-  int origkind = g->gckind;
+  lua_assert(g->gckind == KGC_NORMAL);
-  lua_assert(origkind != KGC_EMERGENCY);
   if (isemergency)  /* do not run finalizers during emergency GC */
     g->gckind = KGC_EMERGENCY;
-  else {
+  else
-    g->gckind = KGC_NORMAL;
     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) */
   luaC_runtilstate(L, bitmask(GCSpause));
   luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
   luaC_runtilstate(L, bitmask(GCSpause));  /* run entire collection */
-  if (origkind == KGC_GEN) {  /* generational mode? */
+  g->gckind = KGC_NORMAL;
-    /* generational mode must be kept in propagate phase */
-    luaC_runtilstate(L, bitmask(GCSpropagate));
-  }
-  g->gckind = origkind;
   setpause(g, gettotalbytes(g));
   if (!isemergency)   /* do not run finalizers during emergency GC */
     callallpendingfinalizers(L, 1);

src/lgc.h+30−49

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lgc.h,v 2.58 2012/09/11 12:53:08 roberto Exp $	2	** $Id: lgc.h,v 2.82 2014/03/19 18:51:16 roberto Exp $
3	** Garbage Collector	3	** Garbage Collector
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -38,36 +38,27 @@ · 32 unmodified lines
38	*/	38	*/
39	#define GCSpropagate 0	39	#define GCSpropagate 0
40	#define GCSatomic 1	40	#define GCSatomic 1
41	#define GCSsweepstring 2	41	#define GCSswpallgc 2
42	#define GCSsweepudata 3	42	#define GCSswpfinobj 3
43	#define GCSsweep 4	43	#define GCSswptobefnz 4
44	#define GCSpause 5	44	#define GCSswpend 5
		45	#define GCScallfin 6
		46	#define GCSpause 7
45		47
46		48
47	#define issweepphase(g) \	49	#define issweepphase(g) \
48	(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)	50	(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
49		51
50	#define isgenerational(g) ((g)->gckind == KGC_GEN)
51		52
52	/*	53	/*
53	** macros to tell when main invariant (white objects cannot point to black	54	** macro to tell when main invariant (white objects cannot point to black
54	** ones) must be kept. During a non-generational collection, the sweep	55	** ones) must be kept. During a collection, the sweep
55	** phase may break the invariant, as objects turned white may point to	56	** phase may break the invariant, as objects turned white may point to
56	** still-black objects. The invariant is restored when sweep ends and	57	** still-black objects. The invariant is restored when sweep ends and
57	** all objects are white again. During a generational collection, the	58	** all objects are white again.
58	** invariant must be kept all times.
59	*/	59	*/
60		60
61	#define keepinvariant(g) (isgenerational(g) \|\| g->gcstate <= GCSatomic)	61	#define keepinvariant(g) ((g)->gcstate <= GCSatomic)
62
63
64	/*
65	** Outside the collector, the state in generational mode is kept in
66	** 'propagate', so 'keepinvariant' is always true.
67	*/
68	#define keepinvariantout(g) \
69	check_exp(g->gcstate == GCSpropagate \|\| !isgenerational(g), \
70	g->gcstate <= GCSatomic)
71		62
72		63
73	/*	64	/*
@@ -87,10 +78,7 @@ · 13 unmodified lines
87	#define WHITE0BIT 0 /* object is white (type 0) */	78	#define WHITE0BIT 0 /* object is white (type 0) */
88	#define WHITE1BIT 1 /* object is white (type 1) */	79	#define WHITE1BIT 1 /* object is white (type 1) */
89	#define BLACKBIT 2 /* object is black */	80	#define BLACKBIT 2 /* object is black */
90	#define FINALIZEDBIT 3 /* object has been separated for finalization */	81	#define FINALIZEDBIT 3 /* object has been marked for finalization */
91	#define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */
92	#define FIXEDBIT 5 /* object is fixed (should not be collected) */
93	#define OLDBIT 6 /* object is old (only in generational mode) */
94	/* bit 7 is currently used by tests (luaL_checkmemory) */	82	/* bit 7 is currently used by tests (luaL_checkmemory) */
95		83
96	#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)	84	#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
@@ -101,21 +89,15 @@ · 4 unmodified lines
101	#define isgray(x) /* neither white nor black */ \	89	#define isgray(x) /* neither white nor black */ \
102	(!testbits((x)->gch.marked, WHITEBITS \| bitmask(BLACKBIT)))	90	(!testbits((x)->gch.marked, WHITEBITS \| bitmask(BLACKBIT)))
103		91
104	#define isold(x) testbit((x)->gch.marked, OLDBIT)	92	#define tofinalize(x) testbit((x)->gch.marked, FINALIZEDBIT)
105		93
106	/* MOVE OLD rule: whenever an object is moved to the beginning of	94	#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)
107	a GC list, its old bit must be cleared */
108	#define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT)
109
110	#define otherwhite(g) (g->currentwhite ^ WHITEBITS)
111	#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))	95	#define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
112	#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)	96	#define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)
113		97
114	#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)	98	#define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
115	#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)	99	#define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)
116		100
117	#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
118
119	#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)	101	#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
120		102
121		103
@@ -124,34 +106,33 @@ · 2 unmodified lines
124	#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)	106	#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)
125		107
126		108
127	#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \	109	#define luaC_barrier(L,p,v) { \
		110	if (iscollectable(v) && isblack(obj2gco(p)) && iswhite(gcvalue(v))) \
128	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }	111	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
129		112
130	#define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \	113	#define luaC_barrierback(L,p,v) { \
131	luaC_barrierback_(L,p); }	114	if (iscollectable(v) && isblack(obj2gco(p)) && iswhite(gcvalue(v))) \
		115	luaC_barrierback_(L,obj2gco(p)); }
132		116
133	#define luaC_objbarrier(L,p,o) \	117	#define luaC_objbarrier(L,p,o) { \
134	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \	118	if (isblack(obj2gco(p)) && iswhite(obj2gco(o))) \
135	luaC_barrier_(L,obj2gco(p),obj2gco(o)); }	119	luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
136		120
137	#define luaC_objbarrierback(L,p,o) \	121	#define luaC_upvalbarrier(L,uv) \
138	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }	122	{ if (iscollectable((uv)->v) && !upisopen(uv)) \
139		123	luaC_upvalbarrier_(L,uv); }
140	#define luaC_barrierproto(L,p,c) \
141	{ if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); }
142		124
		125	LUAI_FUNC void luaC_fix (lua_State L, GCObject o);
143	LUAI_FUNC void luaC_freeallobjects (lua_State *L);	126	LUAI_FUNC void luaC_freeallobjects (lua_State *L);
144	LUAI_FUNC void luaC_step (lua_State *L);	127	LUAI_FUNC void luaC_step (lua_State *L);
145	LUAI_FUNC void luaC_forcestep (lua_State *L);
146	LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);	128	LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
147	LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);	129	LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
148	LUAI_FUNC GCObject luaC_newobj (lua_State L, int tt, size_t sz,	130	LUAI_FUNC GCObject luaC_newobj (lua_State L, int tt, size_t sz);
149	GCObject **list, int offset);
150	LUAI_FUNC void luaC_barrier_ (lua_State L, GCObject o, GCObject *v);	131	LUAI_FUNC void luaC_barrier_ (lua_State L, GCObject o, GCObject *v);
151	LUAI_FUNC void luaC_barrierback_ (lua_State L, GCObject o);	132	LUAI_FUNC void luaC_barrierback_ (lua_State L, GCObject o);
152	LUAI_FUNC void luaC_barrierproto_ (lua_State L, Proto p, Closure *c);	133	LUAI_FUNC void luaC_upvalbarrier_ (lua_State L, UpVal uv);
153	LUAI_FUNC void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt);	134	LUAI_FUNC void luaC_checkfinalizer (lua_State L, GCObject o, Table *mt);
154	LUAI_FUNC void luaC_checkupvalcolor (global_State g, UpVal uv);	135	LUAI_FUNC void luaC_upvdeccount (lua_State L, UpVal uv);
155	LUAI_FUNC void luaC_changemode (lua_State *L, int mode);	136
156		137
157	#endif	138	#endif

src/linit.c+2−1

 /*
-** $Id: linit.c,v 1.32 2011/04/08 19:17:36 roberto Exp $
+** $Id: linit.c,v 1.33 2014/02/06 17:32:33 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},

src/liolib.c+61−58

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: liolib.c,v 2.114 2013/06/07 19:01:35 roberto Exp $	2	** $Id: liolib.c,v 2.120 2014/03/19 18:57:42 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	*/
@@ -29,14 +29,14 @@ · 23 unmodified lines
29	#include "lualib.h"	29	#include "lualib.h"
30		30
31		31
32	#if !defined(lua_checkmode)	32	#if !defined(l_checkmode)
33		33
34	/*	34	/*
35	** Check whether 'mode' matches '[rwa]%+?b?'.	35	** Check whether 'mode' matches '[rwa]%+?b?'.
36	** Change this macro to accept other modes for 'fopen' besides	36	** Change this macro to accept other modes for 'fopen' besides
37	** the standard ones.	37	** the standard ones.
38	*/	38	*/
39	#define lua_checkmode(mode) \	39	#define l_checkmode(mode) \
40	(mode != '\0' && strchr("rwa", (mode++)) != NULL && \	40	(mode != '\0' && strchr("rwa", (mode++)) != NULL && \
41	(mode != '+' \|\| ++mode) && / skip if char is '+' */ \	41	(mode != '+' \|\| ++mode) && / skip if char is '+' */ \
42	(mode != 'b' \|\| ++mode) && / skip if char is 'b' */ \	42	(mode != 'b' \|\| ++mode) && / skip if char is 'b' */ \
@@ -46,45 +46,61 @@ · 3 unmodified lines
46		46
47	/*	47	/*
48	** {======================================================	48	** {======================================================
49	** lua_popen spawns a new process connected to the current	49	** l_popen spawns a new process connected to the current
50	** one through the file streams.	50	** one through the file streams.
51	** =======================================================	51	** =======================================================
52	*/	52	*/
53		53
54	#if !defined(lua_popen) /* { */	54	#if !defined(l_popen) /* { */
55		55
56	#if defined(LUA_USE_POPEN) /* { */	56	#if defined(LUA_USE_POSIX) /* { */
57		57
58	#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))	58	#define l_popen(L,c,m) (fflush(NULL), popen(c,m))
59	#define lua_pclose(L,file) ((void)L, pclose(file))	59	#define l_pclose(L,file) (pclose(file))
60		60
61	#elif defined(LUA_WIN) /* }{ */	61	#elif defined(LUA_WIN) /* }{ */
62		62
63	#define lua_popen(L,c,m) ((void)L, _popen(c,m))	63	#define l_popen(L,c,m) (_popen(c,m))
64	#define lua_pclose(L,file) ((void)L, _pclose(file))	64	#define l_pclose(L,file) (_pclose(file))
65
66		65
67	#else /* }{ */	66	#else /* }{ */
68		67
69	#define lua_popen(L,c,m) ((void)((void)c, m), \	68	/* ANSI definitions */
70	luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)	69	#define l_popen(L,c,m) \
71	#define lua_pclose(L,file) ((void)((void)L, file), -1)	70	((void)((void)c, m), \
72		71	luaL_error(L, LUA_QL("popen") " not supported"), \
		72	(FILE*)0)
		73	#define l_pclose(L,file) ((void)L, (void)file, -1)
73		74
74	#endif /* } */	75	#endif /* } */
75		76
76	#endif /* } */	77	#endif /* } */
77		78
78	/* }====================================================== */	79	/* }====================================================== */
79		80
80		81
		82	#if !defined(l_getc) /* { */
		83
		84	#if defined(LUA_USE_POSIX)
		85	#define l_getc(f) getc_unlocked(f)
		86	#define l_lockfile(f) flockfile(f)
		87	#define l_unlockfile(f) funlockfile(f)
		88	#else
		89	#define l_getc(f) getc(f)
		90	#define l_lockfile(f) ((void)0)
		91	#define l_unlockfile(f) ((void)0)
		92	#endif
		93
		94	#endif /* } */
		95
		96
81	/*	97	/*
82	** {======================================================	98	** {======================================================
83	** lua_fseek: configuration for longer offsets	99	** l_fseek: configuration for longer offsets
84	** =======================================================	100	** =======================================================
85	*/	101	*/
86		102
87	#if !defined(lua_fseek) && !defined(LUA_ANSI) /* { */	103	#if !defined(l_fseek) /* { */
88		104
89	#if defined(LUA_USE_POSIX) /* { */	105	#if defined(LUA_USE_POSIX) /* { */
90		106
@@ -94,22 +110,22 @@ · 3 unmodified lines
94		110
95	#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \	111	#elif defined(LUA_WIN) && !defined(_CRTIMP_TYPEINFO) \
96	&& defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */	112	&& defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */
97	/* Windows (but not DDK) and Visual C++ 2005 or higher */
98		113
		114	/* Windows (but not DDK) and Visual C++ 2005 or higher */
99	#define l_fseek(f,o,w) _fseeki64(f,o,w)	115	#define l_fseek(f,o,w) _fseeki64(f,o,w)
100	#define l_ftell(f) _ftelli64(f)	116	#define l_ftell(f) _ftelli64(f)
101	#define l_seeknum __int64	117	#define l_seeknum __int64
102		118
103	#endif /* } */	119	#else /* }{ */
104
105	#endif /* } */
106
107		120
108	#if !defined(l_fseek) /* default definitions */	121	/* ANSI definitions */
109	#define l_fseek(f,o,w) fseek(f,o,w)	122	#define l_fseek(f,o,w) fseek(f,o,w)
110	#define l_ftell(f) ftell(f)	123	#define l_ftell(f) ftell(f)
111	#define l_seeknum long	124	#define l_seeknum long
112	#endif	125
		126	#endif /* } */
		127
		128	#endif /* } */
113		129
114	/* }====================================================== */	130	/* }====================================================== */
115		131
@@ -228,7 +244,7 @@ static int io_open (lua_State *L) { · 112 unmodified lines
228	const char *mode = luaL_optstring(L, 2, "r");	244	const char *mode = luaL_optstring(L, 2, "r");
229	LStream *p = newfile(L);	245	LStream *p = newfile(L);
230	const char md = mode; / to traverse/check mode */	246	const char md = mode; / to traverse/check mode */
231	luaL_argcheck(L, lua_checkmode(md), 2, "invalid mode");	247	luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
232	p->f = fopen(filename, mode);	248	p->f = fopen(filename, mode);
233	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;	249	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
234	}	250	}
@@ -239,7 +255,7 @@ static int io_open (lua_State *L) { · 4 unmodified lines
239	*/	255	*/
240	static int io_pclose (lua_State *L) {	256	static int io_pclose (lua_State *L) {
241	LStream *p = tolstream(L);	257	LStream *p = tolstream(L);
242	return luaL_execresult(L, lua_pclose(L, p->f));	258	return luaL_execresult(L, l_pclose(L, p->f));
243	}	259	}
244		260
245		261
@@ -247,7 +263,7 @@ static int io_popen (lua_State *L) { · 1 unmodified line
247	const char *filename = luaL_checkstring(L, 1);	263	const char *filename = luaL_checkstring(L, 1);
248	const char *mode = luaL_optstring(L, 2, "r");	264	const char *mode = luaL_optstring(L, 2, "r");
249	LStream *p = newprefile(L);	265	LStream *p = newprefile(L);
250	p->f = lua_popen(L, filename, mode);	266	p->f = l_popen(L, filename, mode);
251	p->closef = &io_pclose;	267	p->closef = &io_pclose;
252	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;	268	return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
253	}	269	}
@@ -375,7 +391,7 @@ static int read_number (lua_State L, FILE f) { · 121 unmodified lines
375		391
376	static int test_eof (lua_State L, FILE f) {	392	static int test_eof (lua_State L, FILE f) {
377	int c = getc(f);	393	int c = getc(f);
378	ungetc(c, f);	394	ungetc(c, f); /* no-op when c == EOF */
379	lua_pushlstring(L, NULL, 0);	395	lua_pushlstring(L, NULL, 0);
380	return (c != EOF);	396	return (c != EOF);
381	}	397	}
@@ -383,40 +399,27 @@ static int test_eof (lua_State L, FILE f) { · 1 unmodified line
383		399
384	static int read_line (lua_State L, FILE f, int chop) {	400	static int read_line (lua_State L, FILE f, int chop) {
385	luaL_Buffer b;	401	luaL_Buffer b;
		402	int c;
386	luaL_buffinit(L, &b);	403	luaL_buffinit(L, &b);
387	for (;;) {	404	l_lockfile(f);
388	size_t l;	405	while ((c = l_getc(f)) != EOF && c != '\n')
389	char *p = luaL_prepbuffer(&b);	406	luaL_addchar(&b, c);
390	if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */	407	l_unlockfile(f);
391	luaL_pushresult(&b); /* close buffer */	408	if (!chop && c == '\n') luaL_addchar(&b, c);
392	return (lua_rawlen(L, -1) > 0); /* check whether read something */	409	luaL_pushresult(&b); /* close buffer */
393	}	410	return (c == '\n' \|\| lua_rawlen(L, -1) > 0);
394	l = strlen(p);
395	if (l == 0 \|\| p[l-1] != '\n')
396	luaL_addsize(&b, l);
397	else {
398	luaL_addsize(&b, l - chop); /* chop 'eol' if needed */
399	luaL_pushresult(&b); /* close buffer */
400	return 1; /* read at least an `eol' */
401	}
402	}
403	}	411	}
404		412
405		413
406	#define MAX_SIZE_T (~(size_t)0)
407
408	static void read_all (lua_State L, FILE f) {	414	static void read_all (lua_State L, FILE f) {
409	size_t rlen = LUAL_BUFFERSIZE; /* how much to read in each cycle */	415	size_t nr;
410	luaL_Buffer b;	416	luaL_Buffer b;
411	luaL_buffinit(L, &b);	417	luaL_buffinit(L, &b);
412	for (;;) {	418	do { /* read file in chunks of LUAL_BUFFERSIZE bytes */
413	char *p = luaL_prepbuffsize(&b, rlen);	419	char *p = luaL_prepbuffsize(&b, LUAL_BUFFERSIZE);
414	size_t nr = fread(p, sizeof(char), rlen, f);	420	nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
415	luaL_addsize(&b, nr);	421	luaL_addsize(&b, nr);
416	if (nr < rlen) break; /* eof? */	422	} while (nr == LUAL_BUFFERSIZE);
417	else if (rlen <= (MAX_SIZE_T / 4)) /* avoid buffers too large */
418	rlen = 2; / double buffer size at each iteration */
419	}
420	luaL_pushresult(&b); /* close buffer */	423	luaL_pushresult(&b); /* close buffer */
421	}	424	}
422		425
@@ -566,15 +569,15 @@ static int f_seek (lua_State *L) { · 143 unmodified lines
566	static const char *const modenames[] = {"set", "cur", "end", NULL};	569	static const char *const modenames[] = {"set", "cur", "end", NULL};
567	FILE *f = tofile(L);	570	FILE *f = tofile(L);
568	int op = luaL_checkoption(L, 2, "cur", modenames);	571	int op = luaL_checkoption(L, 2, "cur", modenames);
569	lua_Number p3 = luaL_optnumber(L, 3, 0);	572	lua_Integer p3 = luaL_optinteger(L, 3, 0);
570	l_seeknum offset = (l_seeknum)p3;	573	l_seeknum offset = (l_seeknum)p3;
571	luaL_argcheck(L, (lua_Number)offset == p3, 3,	574	luaL_argcheck(L, (lua_Integer)offset == p3, 3,
572	"not an integer in proper range");	575	"not an integer in proper range");
573	op = l_fseek(f, offset, mode[op]);	576	op = l_fseek(f, offset, mode[op]);
574	if (op)	577	if (op)
575	return luaL_fileresult(L, 0, NULL); /* error */	578	return luaL_fileresult(L, 0, NULL); /* error */
576	else {	579	else {
577	lua_pushnumber(L, (lua_Number)l_ftell(f));	580	lua_pushinteger(L, (lua_Integer)l_ftell(f));
578	return 1;	581	return 1;
579	}	582	}
580	}	583	}

src/llex.c+80−42

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llex.c,v 2.67 2013/06/19 14:27:00 roberto Exp $	2	** $Id: llex.c,v 2.74 2014/02/14 15:23:51 roberto Exp $
3	** Lexical Analyzer	3	** Lexical Analyzer
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -15,6 +15,7 @@ · 9 unmodified lines
15		15
16	#include "lctype.h"	16	#include "lctype.h"
17	#include "ldo.h"	17	#include "ldo.h"
		18	#include "lgc.h"
18	#include "llex.h"	19	#include "llex.h"
19	#include "lobject.h"	20	#include "lobject.h"
20	#include "lparser.h"	21	#include "lparser.h"
@@ -38,7 +39,8 @@ static const char *const luaX_tokens [] = { · 17 unmodified lines
38	"end", "false", "for", "function", "goto", "if",	39	"end", "false", "for", "function", "goto", "if",
39	"in", "local", "nil", "not", "or", "repeat",	40	"in", "local", "nil", "not", "or", "repeat",
40	"return", "then", "true", "until", "while",	41	"return", "then", "true", "until", "while",
41	"//", "..", "...", "==", ">=", "<=", "~=", "::", "<eof>",	42	"//", "..", "...", "==", ">=", "<=", "~=",
		43	"<<", ">>", "::", "<eof>",
42	"<number>", "<number>", "<name>", "<string>"	44	"<number>", "<number>", "<name>", "<string>"
43	};	45	};
44		46
@@ -64,9 +66,11 @@ static void save (LexState *ls, int c) { · 19 unmodified lines
64		66
65	void luaX_init (lua_State *L) {	67	void luaX_init (lua_State *L) {
66	int i;	68	int i;
		69	TString e = luaS_new(L, LUA_ENV); / create env name */
		70	luaC_fix(L, obj2gco(e)); /* never collect this name */
67	for (i=0; i<NUM_RESERVED; i++) {	71	for (i=0; i<NUM_RESERVED; i++) {
68	TString *ts = luaS_new(L, luaX_tokens[i]);	72	TString *ts = luaS_new(L, luaX_tokens[i]);
69	luaS_fix(ts); /* reserved words are never collected */	73	luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */
70	ts->tsv.extra = cast_byte(i+1); /* reserved word */	74	ts->tsv.extra = cast_byte(i+1); /* reserved word */
71	}	75	}
72	}	76	}
@@ -116,22 +120,25 @@ l_noret luaX_syntaxerror (LexState ls, const char msg) { · 43 unmodified lines
116		120
117		121
118	/*	122	/*
119	** creates a new string and anchors it in function's table so that	123	** creates a new string and anchors it in scanner's table so that
120	** it will not be collected until the end of the function's compilation	124	** it will not be collected until the end of the compilation
121	** (by that time it should be anchored in function's prototype)	125	** (by that time it should be anchored somewhere)
122	*/	126	*/
123	TString luaX_newstring (LexState ls, const char *str, size_t l) {	127	TString luaX_newstring (LexState ls, const char *str, size_t l) {
124	lua_State *L = ls->L;	128	lua_State *L = ls->L;
125	TValue o; / entry for `str' */	129	TValue o; / entry for `str' */
126	TString ts = luaS_newlstr(L, str, l); / create new string */	130	TString ts = luaS_newlstr(L, str, l); / create new string */
127	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */	131	setsvalue2s(L, L->top++, ts); /* temporarily anchor it in stack */
128	o = luaH_set(L, ls->fs->h, L->top - 1);	132	o = luaH_set(L, ls->h, L->top - 1);
129	if (ttisnil(o)) { /* not in use yet? (see 'addK') */	133	if (ttisnil(o)) { /* not in use yet? */
130	/* boolean value does not need GC barrier;	134	/* boolean value does not need GC barrier;
131	table has no metatable, so it does not need to invalidate cache */	135	table has no metatable, so it does not need to invalidate cache */
132	setbvalue(o, 1); /* t[string] = true */	136	setbvalue(o, 1); /* t[string] = true */
133	luaC_checkGC(L);	137	luaC_checkGC(L);
134	}	138	}
		139	else { /* string already present */
		140	ts = rawtsvalue(keyfromval(o)); /* re-use value previously stored */
		141	}
135	L->top--; /* remove string from stack */	142	L->top--; /* remove string from stack */
136	return ts;	143	return ts;
137	}	144	}
@@ -163,8 +170,7 @@ void luaX_setinput (lua_State L, LexState ls, ZIO z, TString source, · 25 unmodified lines
163	ls->linenumber = 1;	170	ls->linenumber = 1;
164	ls->lastline = 1;	171	ls->lastline = 1;
165	ls->source = source;	172	ls->source = source;
166	ls->envn = luaS_new(L, LUA_ENV); /* create env name */	173	ls->envn = luaS_new(L, LUA_ENV); /* get env name */
167	luaS_fix(ls->envn); /* never collect this name */
168	luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */	174	luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
169	}	175	}
170		176
@@ -314,40 +320,65 @@ static void read_long_string (LexState ls, SemInfo seminfo, int sep) { · 143 unmodified lines
314	}	320	}
315		321
316		322
317	static void escerror (LexState ls, int c, int n, const char *msg) {	323	static void esccheck (LexState ls, int c, const char msg) {
318	int i;	324	if (!c) {
319	luaZ_resetbuffer(ls->buff); /* prepare error message */	325	if (ls->current != EOZ)
320	save(ls, '\\');	326	save_and_next(ls); /* add current to buffer for error message */
321	for (i = 0; i < n && c[i] != EOZ; i++)	327	lexerror(ls, msg, TK_STRING);
322	save(ls, c[i]);	328	}
323	lexerror(ls, msg, TK_STRING);	329	}
		330
		331
		332	static int gethexa (LexState *ls) {
		333	save_and_next(ls);
		334	esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
		335	return luaO_hexavalue(ls->current);
324	}	336	}
325		337
326		338
327	static int readhexaesc (LexState *ls) {	339	static int readhexaesc (LexState *ls) {
328	int c[3], i; /* keep input for error message */	340	int r = gethexa(ls);
329	int r = 0; /* result accumulator */	341	r = (r << 4) + gethexa(ls);
330	c[0] = 'x'; /* for error message */	342	luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */
331	for (i = 1; i < 3; i++) { /* read two hexadecimal digits */	343	return r;
332	c[i] = next(ls);	344	}
333	if (!lisxdigit(c[i]))	345
334	escerror(ls, c, i + 1, "hexadecimal digit expected");	346
335	r = (r << 4) + luaO_hexavalue(c[i]);	347	static unsigned int readutf8esc (LexState *ls) {
		348	unsigned int r;
		349	int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */
		350	save_and_next(ls); /* skip 'u' */
		351	esccheck(ls, ls->current == '{', "missing '{'");
		352	r = gethexa(ls); /* must have at least one digit */
		353	while ((save_and_next(ls), lisxdigit(ls->current))) {
		354	i++;
		355	r = (r << 4) + luaO_hexavalue(ls->current);
		356	esccheck(ls, r <= 0x10FFFF, "UTF-8 value too large");
336	}	357	}
		358	esccheck(ls, ls->current == '}', "missing '}'");
		359	next(ls); /* skip '}' */
		360	luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */
337	return r;	361	return r;
338	}	362	}
339		363
340		364
		365	static void utf8esc (LexState *ls) {
		366	char buff[UTF8BUFFSZ];
		367	int n = luaO_utf8esc(buff, readutf8esc(ls));
		368	for (; n > 0; n--) /* add 'buff' to string */
		369	save(ls, buff[UTF8BUFFSZ - n]);
		370	}
		371
		372
341	static int readdecesc (LexState *ls) {	373	static int readdecesc (LexState *ls) {
342	int c[3], i;	374	int i;
343	int r = 0; /* result accumulator */	375	int r = 0; /* result accumulator */
344	for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */	376	for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */
345	c[i] = ls->current;	377	r = 10*r + ls->current - '0';
346	r = 10*r + c[i] - '0';	378	save_and_next(ls);
347	next(ls);
348	}	379	}
349	if (r > UCHAR_MAX)	380	esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
350	escerror(ls, c, i, "decimal escape too large");	381	luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */
351	return r;	382	return r;
352	}	383	}
353		384
@@ -365,7 +396,7 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 11 unmodified lines
365	break; /* to avoid warnings */	396	break; /* to avoid warnings */
366	case '\\': { /* escape sequences */	397	case '\\': { /* escape sequences */
367	int c; /* final character to be saved */	398	int c; /* final character to be saved */
368	next(ls); /* do not save the `\' */	399	save_and_next(ls); /* keep '\\' for error messages */
369	switch (ls->current) {	400	switch (ls->current) {
370	case 'a': c = '\a'; goto read_save;	401	case 'a': c = '\a'; goto read_save;
371	case 'b': c = '\b'; goto read_save;	402	case 'b': c = '\b'; goto read_save;
@@ -375,12 +406,14 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 3 unmodified lines
375	case 't': c = '\t'; goto read_save;	406	case 't': c = '\t'; goto read_save;
376	case 'v': c = '\v'; goto read_save;	407	case 'v': c = '\v'; goto read_save;
377	case 'x': c = readhexaesc(ls); goto read_save;	408	case 'x': c = readhexaesc(ls); goto read_save;
		409	case 'u': utf8esc(ls); goto no_save;
378	case '\n': case '\r':	410	case '\n': case '\r':
379	inclinenumber(ls); c = '\n'; goto only_save;	411	inclinenumber(ls); c = '\n'; goto only_save;
380	case '\\': case '\"': case '\'':	412	case '\\': case '\"': case '\'':
381	c = ls->current; goto read_save;	413	c = ls->current; goto read_save;
382	case EOZ: goto no_save; /* will raise an error next loop */	414	case EOZ: goto no_save; /* will raise an error next loop */
383	case 'z': { /* zap following span of spaces */	415	case 'z': { /* zap following span of spaces */
		416	luaZ_buffremove(ls->buff, 1); /* remove '\\' */
384	next(ls); /* skip the 'z' */	417	next(ls); /* skip the 'z' */
385	while (lisspace(ls->current)) {	418	while (lisspace(ls->current)) {
386	if (currIsNewline(ls)) inclinenumber(ls);	419	if (currIsNewline(ls)) inclinenumber(ls);
@@ -389,15 +422,18 @@ static void read_string (LexState ls, int del, SemInfo seminfo) { · 2 unmodified lines
389	goto no_save;	422	goto no_save;
390	}	423	}
391	default: {	424	default: {
392	if (!lisdigit(ls->current))	425	esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
393	escerror(ls, &ls->current, 1, "invalid escape sequence");	426	c = readdecesc(ls); /* digital escape \ddd */
394	/* digital escape \ddd */
395	c = readdecesc(ls);
396	goto only_save;	427	goto only_save;
397	}	428	}
398	}	429	}
399	read_save: next(ls); /* read next character */	430	read_save:
400	only_save: save(ls, c); /* save 'c' */	431	next(ls);
		432	/* go through */
		433	only_save:
		434	luaZ_buffremove(ls->buff, 1); /* remove '\\' */
		435	save(ls, c);
		436	/* go through */
401	no_save: break;	437	no_save: break;
402	}	438	}
403	default:	439	default:
@@ -457,13 +493,15 @@ static int llex (LexState ls, SemInfo seminfo) { · 53 unmodified lines
457	}	493	}
458	case '<': {	494	case '<': {
459	next(ls);	495	next(ls);
460	if (ls->current != '=') return '<';	496	if (ls->current == '=') { next(ls); return TK_LE; }
461	else { next(ls); return TK_LE; }	497	if (ls->current == '<') { next(ls); return TK_SHL; }
		498	return '<';
462	}	499	}
463	case '>': {	500	case '>': {
464	next(ls);	501	next(ls);
465	if (ls->current != '=') return '>';	502	if (ls->current == '=') { next(ls); return TK_GE; }
466	else { next(ls); return TK_GE; }	503	if (ls->current == '>') { next(ls); return TK_SHR; }
		504	return '>';
467	}	505	}
468	case '/': {	506	case '/': {
469	next(ls);	507	next(ls);

src/llex.h+3−1

 /*
-** $Id: llex.h,v 1.74 2013/04/26 13:07:53 roberto Exp $
+** $Id: llex.h,v 1.76 2013/12/30 20:47:58 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
   /* other terminal symbols */
   TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
+  TK_SHL, TK_SHR,
   TK_DBCOLON, TK_EOS,
   TK_FLT, TK_INT, TK_NAME, TK_STRING
 };
   struct lua_State *L;
   ZIO *z;  /* input stream */
   Mbuffer *buff;  /* buffer for tokens */
+  Table *h;  /* to avoid collection/reuse strings */
   struct Dyndata *dyd;  /* dynamic structures used by the parser */
   TString *source;  /* current source name */
   TString *envn;  /* environment variable name */

src/llimits.h+7−4

 /*
-** $Id: llimits.h,v 1.108 2013/06/19 14:27:00 roberto Exp $
+** $Id: llimits.h,v 1.111 2014/03/07 16:19:00 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
+/* maximum value for a lua_Unsigned */
+#define MAX_UINTEGER	(~(lua_Unsigned)0)
 /* minimum and maximum values for lua_Integer */
-#define MAX_INTEGER	((lua_Integer)(~(lua_Unsigned)0 >> 1))
+#define MAX_INTEGER	((lua_Integer)(MAX_UINTEGER >> 1))
 #define MIN_INTEGER	(~MAX_INTEGER)
 /*
 ** conversion of pointer to integer
 ** this is for hashing only; there is no problem if the integer
 #define cast(t, exp)	((t)(exp))
+#define cast_void(i)	cast(void, (i))
 #define cast_byte(i)	cast(lu_byte, (i))
 #define cast_num(i)	cast(lua_Number, (i))
 #define cast_int(i)	cast(int, (i))
 /* minimum size for the string table (must be power of 2) */
 #if !defined(MINSTRTABSIZE)
-#define MINSTRTABSIZE	32
+#define MINSTRTABSIZE	64	/* minimum size for "predefined" strings */
 #endif

src/lmathlib.c+11−4

 /*
-** $Id: lmathlib.c,v 1.90 2013/07/03 17:23:19 roberto Exp $
+** $Id: lmathlib.c,v 1.92 2013/07/22 16:05:53 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 }
-static int math_isfloat (lua_State *L) {
+static int math_type (lua_State *L) {
   luaL_checkany(L, 1);
-  lua_pushboolean(L, (lua_type(L, 1) == LUA_TNUMBER && !lua_isinteger(L, 1)));
+  if (lua_type(L, 1) == LUA_TNUMBER) {
+      if (lua_isinteger(L, 1))
+        lua_pushliteral(L, "integer");
+      else
+        lua_pushliteral(L, "float");
+  }
+  else
+    lua_pushnil(L);
   return 1;
 }
   {"ifloor", math_ifloor},
   {"fmod",   math_fmod},
   {"frexp", math_frexp},
-  {"isfloat", math_isfloat},
   {"ldexp", math_ldexp},
 #if defined(LUA_COMPAT_LOG10)
   {"log10", math_log10},
   {"sqrt",  math_sqrt},
   {"tanh",   math_tanh},
   {"tan",   math_tan},
+  {"type", math_type},
   {NULL, NULL}
 };

src/loadlib.c+15−19

 /*
-** $Id: loadlib.c,v 1.111 2012/05/30 12:33:44 roberto Exp $
+** $Id: loadlib.c,v 1.113 2014/03/12 20:57:40 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
 /*
-** LUA_PATH and LUA_CPATH are the names of the environment
+** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
 ** variables that Lua check to set its paths.
 */
-#if !defined(LUA_PATH)
+#if !defined(LUA_PATH_VAR)
-#define LUA_PATH	"LUA_PATH"
+#define LUA_PATH_VAR	"LUA_PATH"
 #endif
-#if !defined(LUA_CPATH)
+#if !defined(LUA_CPATH_VAR)
-#define LUA_CPATH	"LUA_CPATH"
+#define LUA_CPATH_VAR	"LUA_CPATH"
 #endif
 #define LUA_PATHSUFFIX		"_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
-#define LUA_PATHVERSION		LUA_PATH LUA_PATHSUFFIX
+#define LUA_PATHVARVERSION		LUA_PATH_VAR LUA_PATHSUFFIX
-#define LUA_CPATHVERSION	LUA_CPATH LUA_PATHSUFFIX
+#define LUA_CPATHVARVERSION		LUA_CPATH_VAR LUA_PATHSUFFIX
 /*
 ** LUA_PATH_SEP is the character that separates templates in a path.
 static int searcher_preload (lua_State *L) {
   const char *name = luaL_checkstring(L, 1);
   lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
-  lua_getfield(L, -1, name);
+  if (lua_getfield(L, -1, name) == LUA_TNIL)  /* not found? */
-  if (lua_isnil(L, -1))  /* not found? */
     lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
   return 1;
 }
     luaL_error(L, LUA_QL("package.searchers") " must be a table");
   /*  iterate over available searchers to find a loader */
   for (i = 1; ; i++) {
-    lua_rawgeti(L, 3, i);  /* get a searcher */
+    if (lua_rawgeti(L, 3, i) == LUA_TNIL) {  /* no more searchers? */
-    if (lua_isnil(L, -1)) {  /* no more searchers? */
       lua_pop(L, 1);  /* remove nil */
       luaL_pushresult(&msg);  /* create error message */
       luaL_error(L, "module " LUA_QS " not found:%s",
   lua_call(L, 2, 1);  /* run loader to load module */
   if (!lua_isnil(L, -1))  /* non-nil return? */
     lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
-  lua_getfield(L, 2, name);
+  if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no value? */
-  if (lua_isnil(L, -1)) {   /* module did not set a value? */
     lua_pushboolean(L, 1);  /* use true as result */
     lua_pushvalue(L, -1);  /* extra copy to be returned */
     lua_setfield(L, 2, name);  /* _LOADED[name] = true */
   int lastarg = lua_gettop(L);  /* last parameter */
   luaL_pushmodule(L, modname, 1);  /* get/create module table */
   /* check whether table already has a _NAME field */
-  lua_getfield(L, -1, "_NAME");
+  if (lua_getfield(L, -1, "_NAME") != LUA_TNIL)
-  if (!lua_isnil(L, -1))  /* is table an initialized module? */
+    lua_pop(L, 1);  /* table is an initialized module */
-    lua_pop(L, 1);
   else {  /* no; initialize it */
     lua_pop(L, 1);
     modinit(L, modname);
 #endif
   lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
   /* set field 'path' */
-  setpath(L, "path", LUA_PATHVERSION, LUA_PATH, LUA_PATH_DEFAULT);
+  setpath(L, "path", LUA_PATHVARVERSION, LUA_PATH_VAR, LUA_PATH_DEFAULT);
   /* set field 'cpath' */
-  setpath(L, "cpath", LUA_CPATHVERSION, LUA_CPATH, LUA_CPATH_DEFAULT);
+  setpath(L, "cpath", LUA_CPATHVARVERSION, LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
   /* store config information */
   lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
                      LUA_EXEC_DIR "\n" LUA_IGMARK "\n");

src/lobject.c+88−38

 /*
-** $Id: lobject.c,v 2.67 2013/06/25 18:58:32 roberto Exp $
+** $Id: lobject.c,v 2.76 2014/03/21 13:52:33 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(v1, v2);
+    case LUA_OPPOW: return luaV_pow(L, v1, v2);
-    case LUA_OPUNM: return -v1;
+    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_OPBXOR: 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);
     default: lua_assert(0); return 0;
   }
 }
-static lua_Number numarith (int op, lua_Number v1, lua_Number v2) {
+static lua_Number numarith (lua_State *L, int op, lua_Number v1,
+                                                  lua_Number v2) {
   switch (op) {
-    case LUA_OPADD: return luai_numadd(NULL, v1, v2);
+    case LUA_OPADD: return luai_numadd(L, v1, v2);
-    case LUA_OPSUB: return luai_numsub(NULL, v1, v2);
+    case LUA_OPSUB: return luai_numsub(L, v1, v2);
-    case LUA_OPMUL: return luai_nummul(NULL, v1, v2);
+    case LUA_OPMUL: return luai_nummul(L, v1, v2);
-    case LUA_OPDIV: return luai_numdiv(NULL, v1, v2);
+    case LUA_OPDIV: return luai_numdiv(L, v1, v2);
-    case LUA_OPMOD: return luai_nummod(NULL, v1, v2);
+    case LUA_OPMOD: return luai_nummod(L, v1, v2);
-    case LUA_OPPOW: return luai_numpow(NULL, v1, v2);
+    case LUA_OPPOW: return luai_numpow(L, v1, v2);
-    case LUA_OPUNM: return luai_numunm(NULL, v1);
+    case LUA_OPUNM: return luai_numunm(L, v1);
     default: lua_assert(0); return 0;
   }
 }
 void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
                  TValue *res) {
-  if (op == LUA_OPIDIV) {  /* operates only on integers */
+  switch (op) {
-    lua_Integer i1; lua_Integer i2;
+    case LUA_OPIDIV: case LUA_OPBAND: case LUA_OPBOR:
-    if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
+    case LUA_OPBXOR: case LUA_OPSHL: case LUA_OPSHR:
-      setivalue(res, luaV_div(L, i1, i2));
+    case LUA_OPBNOT: {  /* operates only on integers */
-      return;
+      lua_Integer i1; lua_Integer i2;
+      if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
+        setivalue(res, intarith(L, op, i1, i2));
+        return;
+      }
+      else break;  /* go to the end */
     }
-    /* else go to the end */
+    case LUA_OPDIV: {  /* operates only on floats */
-  }
+      lua_Number n1; lua_Number n2;
-  else {  /* other operations */
+      if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
-    lua_Number n1; lua_Number n2;
+        setnvalue(res, numarith(L, op, n1, n2));
-    if (ttisinteger(p1) && ttisinteger(p2) && op != LUA_OPDIV &&
+        return;
-        (op != LUA_OPPOW || ivalue(p2) >= 0)) {
+      }
-      setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
+      else break;  /* go to the end */
-      return;
     }
-    else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
+    default: {  /* other operations */
-      setnvalue(res, numarith(op, n1, n2));
+      lua_Number n1; lua_Number n2;
-      return;
+      if (ttisinteger(p1) && ttisinteger(p2)) {
+        setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
+        return;
+      }
+      else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
+        setnvalue(res, numarith(L, op, n1, n2));
+        return;
+      }
+      else break;  /* go to the end */
     }
-    /* else go to the end */
   }
-  /* could not perform raw operation; try metmethod */
+  /* could not perform raw operation; try metamethod */
-  lua_assert(L != NULL);  /* cannot fail when folding (compile time) */
+  lua_assert(L != NULL);  /* should not fail when folding (compile time) */
   luaT_trybinTM(L, p1, p2, res, cast(TMS, op - LUA_OPADD + TM_ADD));
 }
 /*
+** {======================================================
 ** lua_strx2number converts an hexadecimal numeric string to a number.
 ** In C99, 'strtod' does both conversions. C89, however, has no function
 ** to convert floating hexadecimal strings to numbers. For these
 ** systems, you can leave 'lua_strx2number' undefined and Lua will
 ** provide its own implementation.
+** =======================================================
 */
-#if defined(LUA_USE_STRTODHEX)
+#if !defined(lua_strx2number)		/* { */
+#if defined(LUA_USE_C99)		/* { */
 #define lua_strx2number(s,p)    lua_str2number(s,p)
-#endif
+#else					/* }{ */
-#if !defined(lua_strx2number)
+/* Lua's implementation for 'lua_strx2number' */
 #include <math.h>
 /* maximum number of significant digits to read (to avoid overflows
    even with single floats) */
 #define MAXSIGDIG	30
   return l_mathop(ldexp)(r, e);
 }
-#endif
+#endif					/* } */
+#endif					/* } */
+/* }====================================================== */
 int luaO_str2d (const char *s, size_t len, lua_Number *result) {
   while (lisspace(cast_uchar(*s))) s++;  /* skip trailing spaces */
   if (empty || s != ends) return 0;  /* something wrong in the numeral */
   else {
-    if (neg) *result = -cast(lua_Integer, a);
+    *result = cast_integer((neg) ? 0u - a : a);
-    else *result = cast(lua_Integer, a);
     return 1;
   }
 }
+int luaO_utf8esc (char *buff, unsigned int x) {
+  int n = 1;  /* number of bytes put in buffer (backwards) */
+  if (x < 0x80)  /* ascii? */
+    buff[UTF8BUFFSZ - 1] = x;
+  else {  /* need continuation bytes */
+    unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
+    do {
+      buff[UTF8BUFFSZ - (n++)] = 0x80 | (x & 0x3f);  /* add continuation byte */
+      x >>= 6;  /* remove added bits */
+      mfb >>= 1;  /* now there is one less bit available in first byte */
+    } while (x > mfb);  /* still needs continuation byte? */
+    buff[UTF8BUFFSZ - n] = (~mfb << 1) | x;  /* add first byte */
+  }
+  return n;
+}
 static void pushstr (lua_State *L, const char *str, size_t l) {
   setsvalue2s(L, L->top++, luaS_newlstr(L, str, l));
 }
-/* this function handles only `%d', `%c', %f, %p, and `%s' formats */
+/* this function handles only '%d', '%c', '%f', '%p', and '%s'
+   conventional formats, plus Lua-specific '%L' and '%U' */
 const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
   int n = 0;
   for (;;) {
         pushstr(L, buff, l);
         break;
       }
+      case 'U': {
+        char buff[UTF8BUFFSZ];
+        int l = luaO_utf8esc(buff, va_arg(argp, int));
+        pushstr(L, buff + UTF8BUFFSZ - l, l);
+        break;
+      }
       case '%': {
         pushstr(L, "%", 1);
         break;

src/lobject.h+25−20

 /*
-** $Id: lobject.h,v 2.78 2013/05/14 15:59:04 roberto Exp $
+** $Id: lobject.h,v 2.86 2014/02/19 13:52:42 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
 ** Extra tags for non-values
 */
 #define LUA_TPROTO	LUA_NUMTAGS
-#define LUA_TUPVAL	(LUA_NUMTAGS+1)
+#define LUA_TDEADKEY	(LUA_NUMTAGS+1)
-#define LUA_TDEADKEY	(LUA_NUMTAGS+2)
 /*
 ** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
 */
-#define LUA_TOTALTAGS	(LUA_TUPVAL+2)
+#define LUA_TOTALTAGS	(LUA_TPROTO + 2)
 /*
 #define ttisCclosure(o)		checktag((o), ctb(LUA_TCCL))
 #define ttisLclosure(o)		checktag((o), ctb(LUA_TLCL))
 #define ttislcf(o)		checktag((o), LUA_TLCF)
-#define ttisuserdata(o)		checktag((o), ctb(LUA_TUSERDATA))
+#define ttisfulluserdata(o)	checktag((o), ctb(LUA_TUSERDATA))
 #define ttisthread(o)		checktag((o), ctb(LUA_TTHREAD))
 #define ttisdeadkey(o)		checktag((o), LUA_TDEADKEY)
 #define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
 #define rawtsvalue(o)	check_exp(ttisstring(o), &val_(o).gc->ts)
 #define tsvalue(o)	(&rawtsvalue(o)->tsv)
-#define rawuvalue(o)	check_exp(ttisuserdata(o), &val_(o).gc->u)
+#define rawuvalue(o)	check_exp(ttisfulluserdata(o), &val_(o).gc->u)
 #define uvalue(o)	(&rawuvalue(o)->uv)
 #define clvalue(o)	check_exp(ttisclosure(o), &val_(o).gc->cl)
 #define clLvalue(o)	check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
   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;
   L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
   struct {
     CommonHeader;
+    lu_byte ttuv_;  /* user value's tag */
     struct Table *metatable;
-    struct Table *env;
     size_t len;  /* number of bytes */
+    union Value user_;  /* user value */
   } uv;
 } Udata;
+#define setuservalue(L,u,o) \
+	{ const TValue *io=(o); Udata *iu = (u); \
+	  iu->uv.user_ = io->value_; iu->uv.ttuv_ = io->tt_; \
+	  checkliveness(G(L),io); }
+#define getuservalue(L,u,o) \
+	{ TValue *io=(o); const Udata *iu = (u); \
+	  io->value_ = iu->uv.user_; io->tt_ = iu->uv.ttuv_; \
+	  checkliveness(G(L),io); }
 /*
 ** Description of an upvalue for function prototypes
 /*
 ** Lua Upvalues
 */
-typedef struct UpVal {
+typedef struct UpVal UpVal;
-  CommonHeader;
-  TValue *v;  /* points to stack or to its own value */
-  union {
-    TValue value;  /* the value (when closed) */
-    struct {  /* double linked list (when open) */
-      struct UpVal *prev;
-      struct UpVal *next;
-    } l;
-  } u;
-} UpVal;
 /*
 typedef union TKey {
   struct {
     TValuefields;
-    struct Node *next;  /* for chaining */
+    int next;  /* for chaining (offset for next node) */
   } nk;
   TValue tvk;
 } TKey;
 LUAI_DDEC const TValue luaO_nilobject_;
+/* size of buffer for 'luaO_utf8esc' function */
+#define UTF8BUFFSZ	8
 LUAI_FUNC int luaO_int2fb (unsigned int x);
 LUAI_FUNC int luaO_fb2int (int x);
+LUAI_FUNC int luaO_utf8esc (char *buff, unsigned int x);
 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);

src/lopcodes.c+17−5

 /*
-** $Id: lopcodes.c,v 1.50 2013/04/26 13:07:53 roberto Exp $
+** $Id: lopcodes.c,v 1.53 2013/12/30 20:47:58 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
   "ADD",
   "SUB",
   "MUL",
-  "DIV",
-  "IDIV",
   "MOD",
   "POW",
+  "DIV",
+  "IDIV",
+  "BAND",
+  "BOR",
+  "BXOR",
+  "SHL",
+  "SHR",
   "UNM",
+  "BNOT",
   "NOT",
   "LEN",
   "CONCAT",
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BAND */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BOR */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BXOR */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHL */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHR */
  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_BNOT */
  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */

src/lopcodes.h+9−3

 /*
-** $Id: lopcodes.h,v 1.143 2013/04/26 13:07:53 roberto Exp $
+** $Id: lopcodes.h,v 1.146 2013/12/30 20:47:58 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
 OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
 OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
-OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
-OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
 OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
 OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
+OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
+OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
+OP_BAND,/*	A B C	R(A) := RK(B) & RK(C)				*/
+OP_BOR,/*	A B C	R(A) := RK(B) | RK(C)				*/
+OP_BXOR,/*	A B C	R(A) := RK(B) ~ RK(C)				*/
+OP_SHL,/*	A B C	R(A) := RK(B) << RK(C)				*/
+OP_SHR,/*	A B C	R(A) := RK(B) >> RK(C)				*/
 OP_UNM,/*	A B	R(A) := -R(B)					*/
+OP_BNOT,/*	A B	R(A) := ~R(B)					*/
 OP_NOT,/*	A B	R(A) := not R(B)				*/
 OP_LEN,/*	A B	R(A) := length of R(B)				*/

src/loslib.c+42−18

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: loslib.c,v 1.41 2013/05/14 15:57:11 roberto Exp $	2	** $Id: loslib.c,v 1.45 2014/03/20 19:18:54 roberto Exp $
3	** Standard Operating System library	3	** Standard Operating System library
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -20,29 +20,44 @@ · 14 unmodified lines
20	#include "lualib.h"	20	#include "lualib.h"
21		21
22		22
		23	#if !defined(LUA_STRFTIMEOPTIONS) /* { */
23	/*	24	/*
24	** list of valid conversion specifiers for the 'strftime' function	25	** list of valid conversion specifiers for the 'strftime' function
25	*/	26	*/
26	#if !defined(LUA_STRFTIMEOPTIONS)
27		27
28	#if !defined(LUA_USE_POSIX)	28	#if !defined(LUA_USE_POSIX)
29	#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" }	29	#define LUA_STRFTIMEOPTIONS { "aAbBcdHIjmMpSUwWxXyYz%", "" }
30	#else	30	#else
31	#define LUA_STRFTIMEOPTIONS \	31	#define LUA_STRFTIMEOPTIONS \
32	{ "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \	32	{ "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "", \
33	"", "E", "cCxXyY", \	33	"E", "cCxXyY", \
34	"O", "deHImMSuUVwWy" }	34	"O", "deHImMSuUVwWy" }
35	#endif	35	#endif
36		36
37	#endif	37	#endif /* } */
		38
		39
		40
		41	#if !defined(l_time_t) /* { */
		42	/*
		43	** type to represent time_t in Lua
		44	*/
		45	#define l_timet lua_Integer
		46	#define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t))
		47	#define l_checktime(L,a) ((time_t)luaL_checkinteger(L,a))
38		48
		49	#endif /* } */
39		50
40		51
		52
		53	#if !defined(lua_tmpnam) /* { */
41	/*	54	/*
42	** By default, Lua uses tmpnam except when POSIX is available, where it	55	** By default, Lua uses tmpnam except when POSIX is available, where it
43	** uses mkstemp.	56	** uses mkstemp.
44	*/	57	*/
45	#if defined(LUA_USE_MKSTEMP)	58
		59	#if defined(LUA_USE_POSIX) /* { */
		60
46	#include <unistd.h>	61	#include <unistd.h>
47	#define LUA_TMPNAMBUFSIZE 32	62	#define LUA_TMPNAMBUFSIZE 32
48	#define lua_tmpnam(b,e) { \	63	#define lua_tmpnam(b,e) { \
@@ -51,29 +66,38 @@ · 2 unmodified lines
51	if (e != -1) close(e); \	66	if (e != -1) close(e); \
52	e = (e == -1); }	67	e = (e == -1); }
53		68
54	#elif !defined(lua_tmpnam)	69	#else /* }{ */
55		70
		71	/* ANSI definitions */
56	#define LUA_TMPNAMBUFSIZE L_tmpnam	72	#define LUA_TMPNAMBUFSIZE L_tmpnam
57	#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }	73	#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }
58		74
59	#endif	75	#endif /* } */
		76
		77	#endif /* } */
		78
60		79
61		80
		81	#if !defined(l_gmtime) /* { */
62	/*	82	/*
63	** By default, Lua uses gmtime/localtime, except when POSIX is available,	83	** By default, Lua uses gmtime/localtime, except when POSIX is available,
64	** where it uses gmtime_r/localtime_r	84	** where it uses gmtime_r/localtime_r
65	*/	85	*/
66	#if defined(LUA_USE_GMTIME_R)	86
		87	#if defined(LUA_USE_POSIX) /* { */
67		88
68	#define l_gmtime(t,r) gmtime_r(t,r)	89	#define l_gmtime(t,r) gmtime_r(t,r)
69	#define l_localtime(t,r) localtime_r(t,r)	90	#define l_localtime(t,r) localtime_r(t,r)
70		91
71	#elif !defined(l_gmtime)	92	#else /* }{ */
72		93
		94	/* ANSI definitions */
73	#define l_gmtime(t,r) ((void)r, gmtime(t))	95	#define l_gmtime(t,r) ((void)r, gmtime(t))
74	#define l_localtime(t,r) ((void)r, localtime(t))	96	#define l_localtime(t,r) ((void)r, localtime(t))
75		97
76	#endif	98	#endif /* } */
		99
		100	#endif /* } */
77		101
78		102
79		103
@@ -147,8 +171,7 @@ static void setboolfield (lua_State L, const char key, int value) { · 67 unmodified lines
147		171
148	static int getboolfield (lua_State L, const char key) {	172	static int getboolfield (lua_State L, const char key) {
149	int res;	173	int res;
150	lua_getfield(L, -1, key);	174	res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1);
151	res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
152	lua_pop(L, 1);	175	lua_pop(L, 1);
153	return res;	176	return res;
154	}	177	}
@@ -194,7 +217,7 @@ static const char checkoption (lua_State L, const char conv, char buff) { · 39 unmodified lines
194		217
195	static int os_date (lua_State *L) {	218	static int os_date (lua_State *L) {
196	const char *s = luaL_optstring(L, 1, "%c");	219	const char *s = luaL_optstring(L, 1, "%c");
197	time_t t = luaL_opt(L, (time_t)luaL_checkinteger, 2, time(NULL));	220	time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
198	struct tm tmr, *stm;	221	struct tm tmr, *stm;
199	if (s == '!') { / UTC? */	222	if (s == '!') { / UTC? */
200	stm = l_gmtime(&t, &tmr);	223	stm = l_gmtime(&t, &tmr);
@@ -255,17 +278,18 @@ static int os_time (lua_State *L) { · 54 unmodified lines
255	ts.tm_isdst = getboolfield(L, "isdst");	278	ts.tm_isdst = getboolfield(L, "isdst");
256	t = mktime(&ts);	279	t = mktime(&ts);
257	}	280	}
258	if (t == (time_t)(-1))	281	if (t != (time_t)(l_timet)t)
		282	luaL_error(L, "time result cannot be represented in this Lua instalation");
		283	else if (t == (time_t)(-1))
259	lua_pushnil(L);	284	lua_pushnil(L);
260	else	285	else
261	lua_pushinteger(L, t);	286	l_pushtime(L, t);
262	return 1;	287	return 1;
263	}	288	}
264		289
265		290
266	static int os_difftime (lua_State *L) {	291	static int os_difftime (lua_State *L) {
267	lua_pushnumber(L, difftime((time_t)(luaL_checkinteger(L, 1)),	292	lua_pushnumber(L, difftime((l_checktime(L, 1)), (l_checktime(L, 2))));
268	(time_t)(luaL_optinteger(L, 2, 0))));
269	return 1;	293	return 1;
270	}	294	}
271		295

src/lparser.c+37−37

 /*
-** $Id: lparser.c,v 2.133 2013/04/26 13:07:53 roberto Exp $
+** $Id: lparser.c,v 2.138 2013/12/30 20:47:58 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 #define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
+/* because all strings are unified by the scanner, the parser
+   can use pointer equality for string equality */
+#define eqstr(a,b)	((a) == (b))
 /*
 ** nodes for block list (list of active blocks)
 static void expr (LexState *ls, expdesc *v);
-static void anchor_token (LexState *ls) {
-  /* last token from outer function must be EOS */
-  lua_assert(ls->fs != NULL || ls->t.token == TK_EOS);
-  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
-    TString *ts = ls->t.seminfo.ts;
-    luaX_newstring(ls, getstr(ts), ts->tsv.len);
-  }
-}
 /* semantic error */
 static l_noret semerror (LexState *ls, const char *msg) {
   ls->t.token = 0;  /* remove 'near to' from final message */
   int i;
   Upvaldesc *up = fs->f->upvalues;
   for (i = 0; i < fs->nups; i++) {
-    if (luaS_eqstr(up[i].name, name)) return i;
+    if (eqstr(up[i].name, name)) return i;
   }
   return -1;  /* not found */
 }
 static int searchvar (FuncState *fs, TString *n) {
   int i;
   for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
-    if (luaS_eqstr(n, getlocvar(fs, i)->varname))
+    if (eqstr(n, getlocvar(fs, i)->varname))
       return i;
   }
   return -1;  /* not found */
   FuncState *fs = ls->fs;
   Labellist *gl = &ls->dyd->gt;
   Labeldesc *gt = &gl->arr[g];
-  lua_assert(luaS_eqstr(gt->name, label->name));
+  lua_assert(eqstr(gt->name, label->name));
   if (gt->nactvar < label->nactvar) {
     TString *vname = getlocvar(fs, gt->nactvar)->varname;
     const char *msg = luaO_pushfstring(ls->L,
   /* check labels in current block for a match */
   for (i = bl->firstlabel; i < dyd->label.n; i++) {
     Labeldesc *lb = &dyd->label.arr[i];
-    if (luaS_eqstr(lb->name, gt->name)) {  /* correct label? */
+    if (eqstr(lb->name, gt->name)) {  /* correct label? */
       if (gt->nactvar > lb->nactvar &&
           (bl->upval || dyd->label.n > bl->firstlabel))
         luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
   Labellist *gl = &ls->dyd->gt;
   int i = ls->fs->bl->firstgoto;
   while (i < gl->n) {
-    if (luaS_eqstr(gl->arr[i].name, lb->name))
+    if (eqstr(gl->arr[i].name, lb->name))
       closegoto(ls, i, lb);
     else
       i++;
 static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
-  lua_State *L = ls->L;
   Proto *f;
   fs->prev = ls->fs;  /* linked list of funcstates */
   fs->ls = ls;
   f = fs->f;
   f->source = ls->source;
   f->maxstacksize = 2;  /* registers 0/1 are always valid */
-  fs->h = luaH_new(L);
-  /* anchor table of constants (to avoid being collected) */
-  sethvalue2s(L, L->top, fs->h);
-  incr_top(L);
   enterblock(fs, bl, 0);
 }
   f->sizeupvalues = fs->nups;
   lua_assert(fs->bl == NULL);
   ls->fs = fs->prev;
-  /* last token read was anchored in defunct function; must re-anchor it */
-  anchor_token(ls);
-  L->top--;  /* pop table of constants */
   luaC_checkGC(L);
 }
   switch (op) {
     case TK_NOT: return OPR_NOT;
     case '-': return OPR_MINUS;
+    case '~': return OPR_BNOT;
     case '#': return OPR_LEN;
     default: return OPR_NOUNOPR;
   }
     case '+': return OPR_ADD;
     case '-': return OPR_SUB;
     case '*': return OPR_MUL;
-    case '/': return OPR_DIV;
-    case TK_IDIV: return OPR_IDIV;
     case '%': return OPR_MOD;
     case '^': return OPR_POW;
+    case '/': return OPR_DIV;
+    case TK_IDIV: return OPR_IDIV;
+    case '&': return OPR_BAND;
+    case '|': return OPR_BOR;
+    case '~': return OPR_BXOR;
+    case TK_SHL: return OPR_SHL;
+    case TK_SHR: return OPR_SHR;
     case TK_CONCAT: return OPR_CONCAT;
     case TK_NE: return OPR_NE;
     case TK_EQ: return OPR_EQ;
   lu_byte left;  /* left priority for each binary operator */
   lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
-   {6, 6}, {6, 6},  /* '+' '-' */
+   {10, 10}, {10, 10},           /* '+' '-' */
-   {7, 7}, {7, 7}, {7, 7}, {7, 7},  /* '*' '/' '//' '%' */
+   {11, 11}, {11, 11},           /* '*' '%' */
-   {10, 9}, {5, 4},                 /* ^, .. (right associative) */
+   {14, 13},                  /* '^' (right associative) */
-   {3, 3}, {3, 3}, {3, 3},          /* ==, <, <= */
+   {11, 11}, {11, 11},           /* '/' '//' */
-   {3, 3}, {3, 3}, {3, 3},          /* ~=, >, >= */
+   {6, 6}, {4, 4}, {5, 5},   /* '&' '|' '~' */
-   {2, 2}, {1, 1}                   /* and, or */
+   {7, 7}, {7, 7},           /* '<<' '>>' */
+   {9, 8},                   /* '..' (right associative) */
+   {3, 3}, {3, 3}, {3, 3},   /* ==, <, <= */
+   {3, 3}, {3, 3}, {3, 3},   /* ~=, >, >= */
+   {2, 2}, {1, 1}            /* and, or */
 };
-#define UNARY_PRIORITY	8  /* priority for unary operators */
+#define UNARY_PRIORITY	12  /* priority for unary operators */
 /*
 static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
   int i;
   for (i = fs->bl->firstlabel; i < ll->n; i++) {
-    if (luaS_eqstr(label, ll->arr[i].name)) {
+    if (eqstr(label, ll->arr[i].name)) {
       const char *msg = luaO_pushfstring(fs->ls->L,
                           "label " LUA_QS " already defined on line %d",
                           getstr(label), ll->arr[i].line);
   LexState lexstate;
   FuncState funcstate;
   Closure *cl = luaF_newLclosure(L, 1);  /* create main closure */
-  /* anchor closure (to avoid being collected) */
+  setclLvalue(L, L->top, cl);  /* anchor it (to avoid being collected) */
-  setclLvalue(L, L->top, cl);
+  incr_top(L);
+  lexstate.h = luaH_new(L);  /* create table for scanner */
+  sethvalue(L, L->top, lexstate.h);  /* anchor it */
   incr_top(L);
   funcstate.f = cl->l.p = luaF_newproto(L);
   funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
+  luaC_objbarrier(L, funcstate.f, funcstate.f->source);
   lexstate.buff = buff;
   lexstate.dyd = dyd;
   dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
   lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
   /* all scopes should be correctly finished */
   lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
-  return cl;  /* it's on the stack too */
+  L->top--;  /* remove scanner's table */
+  return cl;  /* closure is on the stack, too */
 }

src/lparser.h+1−2

 /*
-** $Id: lparser.h,v 1.71 2013/04/16 18:46:28 roberto Exp $
+** $Id: lparser.h,v 1.72 2013/08/30 16:01:37 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 /* state needed to generate code for a given function */
 typedef struct FuncState {
   Proto *f;  /* current function header */
-  Table *h;  /* table to find (and reuse) elements in `k' */
   struct FuncState *prev;  /* enclosing function */
   struct LexState *ls;  /* lexical state */
   struct BlockCnt *bl;  /* chain of current blocks */

src/lstate.c+53−32

 /*
-** $Id: lstate.c,v 2.99 2012/10/02 17:40:53 roberto Exp $
+** $Id: lstate.c,v 2.121 2014/02/18 13:46:26 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 #define LUAI_GCPAUSE	200  /* 200% */
 #endif
-#if !defined(LUAI_GCMAJOR)
-#define LUAI_GCMAJOR	200  /* 200% */
-#endif
 #if !defined(LUAI_GCMUL)
 #define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
 #endif
 }
+/*
+** free all CallInfo structures not in use by a thread
+*/
 void luaE_freeCI (lua_State *L) {
   CallInfo *ci = L->ci;
   CallInfo *next = ci->next;
 }
+/*
+** free half of the CallInfo structures not in use by a thread
+*/
+void luaE_shrinkCI (lua_State *L) {
+  CallInfo *ci = L->ci;
+  while (ci->next != NULL) {  /* while there is 'next' */
+    CallInfo *next2 = ci->next->next;  /* next's next */
+    if (next2 == NULL) break;
+    luaM_free(L, ci->next);  /* remove next */
+    ci->next = next2;  /* remove 'next' from the list */
+    next2->previous = ci;
+    ci = next2;
+  }
+}
 static void stack_init (lua_State *L1, lua_State *L) {
   int i; CallInfo *ci;
   /* initialize stack array */
 ** Create registry table and its predefined values
 */
 static void init_registry (lua_State *L, global_State *g) {
-  TValue mt;
+  TValue temp;
   /* create registry */
   Table *registry = luaH_new(L);
   sethvalue(L, &g->l_registry, registry);
   luaH_resize(L, registry, LUA_RIDX_LAST, 0);
   /* registry[LUA_RIDX_MAINTHREAD] = L */
-  setthvalue(L, &mt, L);
+  setthvalue(L, &temp, L);  /* temp = L */
-  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
+  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &temp);
   /* registry[LUA_RIDX_GLOBALS] = table of globals */
-  sethvalue(L, &mt, luaH_new(L));
+  sethvalue(L, &temp, luaH_new(L));  /* temp = new table (global table) */
-  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
+  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &temp);
 }
 /*
-** open parts of the state that may cause memory-allocation errors
+** open parts of the state that may cause memory-allocation errors.
+** ('g->version' != NULL flags that the state was completely build)
 */
 static void f_luaopen (lua_State *L, void *ud) {
   global_State *g = G(L);
   luaX_init(L);
   /* pre-create memory-error message */
   g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
-  luaS_fix(g->memerrmsg);  /* it should never be collected */
+  luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
   g->gcrunning = 1;  /* allow gc */
+  g->version = lua_version(NULL);
+  luai_userstateopen(L);
 }
 /*
-** preinitialize a state with consistent values without allocating
+** preinitialize a thread with consistent values without allocating
 ** any memory (to avoid errors)
 */
-static void preinit_state (lua_State *L, global_State *g) {
+static void preinit_thread (lua_State *L, global_State *g) {
   G(L) = g;
   L->stack = NULL;
   L->ci = NULL;
   L->stacksize = 0;
+  L->twups = L;  /* thread has no upvalues */
   L->errorJmp = NULL;
   L->nCcalls = 0;
   L->hook = NULL;
   global_State *g = G(L);
   luaF_close(L, L->stack);  /* close all upvalues for this thread */
   luaC_freeallobjects(L);  /* collect all objects */
+  if (g->version)  /* closing a fully built state? */
+    luai_userstateclose(L);
   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
   luaZ_freebuffer(L, &g->buff);
   freestack(L);
 LUA_API lua_State *lua_newthread (lua_State *L) {
+    global_State *g = G(L);
   lua_State *L1;
   lua_lock(L);
   luaC_checkGC(L);
-  L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
+  /* create new thread */
+  L1 = &cast(LX *, luaM_newobject(L, LUA_TTHREAD, sizeof(LX)))->l;
+  L1->marked = luaC_white(g);
+  L1->tt = LUA_TTHREAD;
+  /* link it on list 'allgc' */
+  L1->next = g->allgc;
+  g->allgc = obj2gco(L1);
   setthvalue(L, L->top, L1);
   api_incr_top(L);
-  preinit_state(L1, G(L));
+  preinit_thread(L1, g);
   L1->hookmask = L->hookmask;
   L1->basehookcount = L->basehookcount;
   L1->hook = L->hook;
   g = &l->g;
   L->next = NULL;
   L->tt = LUA_TTHREAD;
-  g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
+  g->currentwhite = bitmask(WHITE0BIT);
   L->marked = luaC_white(g);
-  g->gckind = KGC_NORMAL;
+  preinit_thread(L, g);
-  preinit_state(L, g);
   g->frealloc = f;
   g->ud = ud;
   g->mainthread = L;
   g->seed = makeseed(L);
-  g->uvhead.u.l.prev = &g->uvhead;
-  g->uvhead.u.l.next = &g->uvhead;
   g->gcrunning = 0;  /* no GC while building state */
   g->GCestimate = 0;
-  g->strt.size = 0;
+  g->strt.size = g->strt.nuse = 0;
-  g->strt.nuse = 0;
   g->strt.hash = NULL;
   setnilvalue(&g->l_registry);
   luaZ_initbuffer(L, &g->buff);
   g->panic = NULL;
-  g->version = lua_version(NULL);
+  g->version = NULL;
   g->gcstate = GCSpause;
-  g->allgc = NULL;
+  g->gckind = KGC_NORMAL;
-  g->finobj = NULL;
+  g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
-  g->tobefnz = NULL;
+  g->sweepgc = NULL;
-  g->sweepgc = g->sweepfin = NULL;
   g->gray = g->grayagain = NULL;
   g->weak = g->ephemeron = g->allweak = NULL;
+  g->twups = NULL;
   g->totalbytes = sizeof(LG);
   g->GCdebt = 0;
+  g->gcfinnum = 0;
   g->gcpause = LUAI_GCPAUSE;
-  g->gcmajorinc = LUAI_GCMAJOR;
   g->gcstepmul = LUAI_GCMUL;
   for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
   if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
     close_state(L);
     L = NULL;
   }
-  else
-    luai_userstateopen(L);
   return L;
 }
 LUA_API void lua_close (lua_State *L) {
   L = G(L)->mainthread;  /* only the main thread can be closed */
   lua_lock(L);
-  luai_userstateclose(L);
   close_state(L);
 }

src/lstate.h+19−30

 /*
-** $Id: lstate.h,v 2.82 2012/07/02 13:37:04 roberto Exp $
+** $Id: lstate.h,v 2.102 2014/02/18 13:46:26 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 /*
-** Some notes about garbage-collected objects:  All objects in Lua must
+** Some notes about garbage-collected objects: All objects in Lua must
-** be kept somehow accessible until being freed.
+** be kept somehow accessible until being freed, so all objects always
+** belong to one (and only one) of these lists, using field 'next' of
+** the 'CommonHeader' for the link:
 **
-** Lua keeps most objects linked in list g->allgc. The link uses field
+** allgc: all objects not marked for finalization;
-** 'next' of the CommonHeader.
+** finobj: all objects marked for finalization;
-**
+** tobefnz: all objects ready to be finalized;
-** Strings are kept in several lists headed by the array g->strt.hash.
+** fixedgc: all objects that are not to be collected (currently
-**
+** only small strings, such as reserved words).
-** Open upvalues are not subject to independent garbage collection. They
-** are collected together with their respective threads. Lua keeps a
-** double-linked list with all open upvalues (g->uvhead) so that it can
-** mark objects referred by them. (They are always gray, so they must
-** be remarked in the atomic step. Usually their contents would be marked
-** when traversing the respective threads, but the thread may already be
-** dead, while the upvalue is still accessible through closures.)
-**
-** Objects with finalizers are kept in the list g->finobj.
-**
-** The list g->tobefnz links all objects being finalized.
 */
 /* kinds of Garbage Collection */
 #define KGC_NORMAL	0
 #define KGC_EMERGENCY	1	/* gc was forced by an allocation failure */
-#define KGC_GEN		2	/* generational collection */
 typedef struct stringtable {
-  GCObject **hash;
+  TString **hash;
-  lu_int32 nuse;  /* number of elements */
+  int nuse;  /* number of elements */
   int size;
 } stringtable;
   lu_byte gcstate;  /* state of garbage collector */
   lu_byte gckind;  /* kind of GC running */
   lu_byte gcrunning;  /* true if GC is running */
-  int sweepstrgc;  /* position of sweep in `strt' */
   GCObject *allgc;  /* list of all collectable objects */
+  GCObject **sweepgc;  /* current position of sweep in list */
   GCObject *finobj;  /* list of collectable objects with finalizers */
-  GCObject **sweepgc;  /* current position of sweep in list 'allgc' */
-  GCObject **sweepfin;  /* current position of sweep in list 'finobj' */
   GCObject *gray;  /* list of gray objects */
   GCObject *grayagain;  /* list of objects to be traversed atomically */
   GCObject *weak;  /* list of tables with weak values */
   GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
   GCObject *allweak;  /* list of all-weak tables */
   GCObject *tobefnz;  /* list of userdata to be GC */
-  UpVal uvhead;  /* head of double-linked list of all open upvalues */
+  GCObject *fixedgc;  /* list of objects not to be collected */
+  struct lua_State *twups;  /* list of threads with open upvalues */
   Mbuffer buff;  /* temporary buffer for string concatenation */
+  unsigned int gcfinnum;  /* number of finalizers to call in each GC step */
   int gcpause;  /* size of pause between successive GCs */
-  int gcmajorinc;  /* pause between major collections (only in gen. mode) */
   int gcstepmul;  /* GC `granularity' */
   lua_CFunction panic;  /* to be called in unprotected errors */
   struct lua_State *mainthread;
   int basehookcount;
   int hookcount;
   lua_Hook hook;
-  GCObject *openupval;  /* list of open upvalues in this stack */
+  UpVal *openupval;  /* list of open upvalues in this stack */
   GCObject *gclist;
+  struct lua_State *twups;  /* list of threads with open upvalues */
   struct lua_longjmp *errorJmp;  /* current error recover point */
   ptrdiff_t errfunc;  /* current error handling function (stack index) */
   CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
   union Closure cl;
   struct Table h;
   struct Proto p;
-  struct UpVal uv;
   struct lua_State th;  /* thread */
 };
 	check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl))
 #define gco2t(o)	check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
 #define gco2p(o)	check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
-#define gco2uv(o)	check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
 #define gco2th(o)	check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
 /* macro to convert any Lua object into a GCObject */
 LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
 LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
 LUAI_FUNC void luaE_freeCI (lua_State *L);
+LUAI_FUNC void luaE_shrinkCI (lua_State *L);
 #endif

src/lstring.c+46−55

 /*
-** $Id: lstring.c,v 2.27 2013/06/19 14:27:00 roberto Exp $
+** $Id: lstring.c,v 2.38 2014/03/19 18:51:42 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #include "lua.h"
+#include "ldebug.h"
+#include "ldo.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "lstring.h"
 /*
 ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
 ** compute its hash
 }
-/*
-** equality for strings
-*/
-int luaS_eqstr (TString *a, TString *b) {
-  return (a->tsv.tt == b->tsv.tt) &&
-         (a->tsv.tt == LUA_TSHRSTR ? eqshrstr(a, b) : luaS_eqlngstr(a, b));
-}
 unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
   unsigned int h = seed ^ cast(unsigned int, l);
   size_t l1;
 void luaS_resize (lua_State *L, int newsize) {
   int i;
   stringtable *tb = &G(L)->strt;
-  /* cannot resize while GC is traversing strings */
+  if (newsize > tb->size) {  /* grow table if needed */
-  luaC_runtilstate(L, ~bitmask(GCSsweepstring));
+    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
-  if (newsize > tb->size) {
+    for (i = tb->size; i < newsize; i++)
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
+      tb->hash[i] = NULL;
-    for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL;
   }
-  /* rehash */
+  for (i = 0; i < tb->size; i++) {  /* rehash */
-  for (i=0; i<tb->size; i++) {
+    TString *p = tb->hash[i];
-    GCObject *p = tb->hash[i];
     tb->hash[i] = NULL;
     while (p) {  /* for each node in the list */
-      GCObject *next = gch(p)->next;  /* save next */
+      TString *hnext = p->tsv.hnext;  /* save next */
-      unsigned int h = lmod(gco2ts(p)->hash, newsize);  /* new position */
+      unsigned int h = lmod(p->tsv.hash, newsize);  /* new position */
-      gch(p)->next = tb->hash[h];  /* chain it */
+      p->tsv.hnext = tb->hash[h];  /* chain it */
       tb->hash[h] = p;
-      resetoldbit(p);  /* see MOVE OLD rule */
+      p = hnext;
-      p = next;
     }
   }
-  if (newsize < tb->size) {
+  if (newsize < tb->size) {  /* shrink table if needed */
-    /* shrinking slice must be empty */
+    /* vanishing slice should be empty */
     lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
+    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
   }
   tb->size = newsize;
 }
 /*
 ** creates a new string object
 */
 static TString *createstrobj (lua_State *L, const char *str, size_t l,
-                              int tag, unsigned int h, GCObject **list) {
+                              int tag, unsigned int h) {
   TString *ts;
   size_t totalsize;  /* total size of TString object */
   totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
-  ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
+  ts = &luaC_newobj(L, tag, totalsize)->ts;
   ts->tsv.len = l;
   ts->tsv.hash = h;
   ts->tsv.extra = 0;
 }
-/*
+LUAI_FUNC void luaS_remove (lua_State *L, TString *ts) {
-** creates a new short string, inserting it into string table
-*/
-static TString *newshrstr (lua_State *L, const char *str, size_t l,
-                                       unsigned int h) {
-  GCObject **list;  /* (pointer to) list where it will be inserted */
   stringtable *tb = &G(L)->strt;
-  TString *s;
+  TString **p = &tb->hash[lmod(ts->tsv.hash, tb->size)];
-  if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
+  while (*p != ts)  /* find previous element */
-    luaS_resize(L, tb->size*2);  /* too crowded */
+    p = &(*p)->tsv.hnext;
-  list = &tb->hash[lmod(h, tb->size)];
+  *p = (*p)->tsv.hnext;  /* remove element from its list */
-  s = createstrobj(L, str, l, LUA_TSHRSTR, h, list);
+  tb->nuse--;
-  tb->nuse++;
-  return s;
 }
 ** checks whether short string exists and reuses it or creates a new one
 */
 static TString *internshrstr (lua_State *L, const char *str, size_t l) {
-  GCObject *o;
+  TString *ts;
   global_State *g = G(L);
   unsigned int h = luaS_hash(str, l, g->seed);
-  for (o = g->strt.hash[lmod(h, g->strt.size)];
+  TString **list = &g->strt.hash[lmod(h, g->strt.size)];
-       o != NULL;
+  for (ts = *list; ts != NULL; ts = ts->tsv.hnext) {
-       o = gch(o)->next) {
+    if (l == ts->tsv.len &&
-    TString *ts = rawgco2ts(o);
-    if (h == ts->tsv.hash &&
-        l == ts->tsv.len &&
         (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
-      if (isdead(G(L), o))  /* string is dead (but was not collected yet)? */
+      /* found! */
-        changewhite(o);  /* resurrect it */
+      if (isdead(g, obj2gco(ts)))  /* dead (but not collected yet)? */
+        changewhite(obj2gco(ts));  /* resurrect it */
       return ts;
     }
   }
-  return newshrstr(L, str, l, h);  /* not found; create a new string */
+  if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
+    luaS_resize(L, g->strt.size * 2);
+    list = &g->strt.hash[lmod(h, g->strt.size)];  /* recompute with new size */
+  }
+  ts = createstrobj(L, str, l, LUA_TSHRSTR, h);
+  ts->tsv.hnext = *list;
+  *list = ts;
+  g->strt.nuse++;
+  return ts;
 }
   else {
     if (l + 1 > (MAX_SIZE - sizeof(TString))/sizeof(char))
       luaM_toobig(L);
-    return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
+    return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed);
   }
 }
 }
-Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
+Udata *luaS_newudata (lua_State *L, size_t s) {
   Udata *u;
   if (s > MAX_SIZE - sizeof(Udata))
     luaM_toobig(L);
-  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u;
+  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s)->u;
   u->uv.len = s;
   u->uv.metatable = NULL;
-  u->uv.env = e;
+  setuservalue(L, u, luaO_nilobject);
   return u;
 }

src/lstring.h+3−5

 /*
-** $Id: lstring.h,v 1.49 2012/02/01 21:57:15 roberto Exp $
+** $Id: lstring.h,v 1.54 2014/03/19 18:51:42 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
                                  (sizeof(s)/sizeof(char))-1))
-#define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
 /*
 ** test whether a string is a reserved word
 LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
 LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
-LUAI_FUNC int luaS_eqstr (TString *a, TString *b);
 LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
+LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
+LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
 LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
 LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);

src/lstrlib.c+222−5

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lstrlib.c,v 1.182 2013/06/20 15:06:51 roberto Exp $	2	** $Id: lstrlib.c,v 1.189 2014/03/21 14:26:44 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	*/
@@ -116,7 +116,7 @@ static int str_rep (lua_State *L) { · 110 unmodified lines
116	lua_Integer n = luaL_checkinteger(L, 2);	116	lua_Integer n = luaL_checkinteger(L, 2);
117	const char *sep = luaL_optlstring(L, 3, "", &lsep);	117	const char *sep = luaL_optlstring(L, 3, "", &lsep);
118	if (n <= 0) lua_pushliteral(L, "");	118	if (n <= 0) lua_pushliteral(L, "");
119	else if (l + lsep < l \|\| l + lsep >= MAXSIZE / n) /* may overflow? */	119	else if (l + lsep < l \|\| l + lsep > MAXSIZE / n) /* may overflow? */
120	return luaL_error(L, "resulting string too large");	120	return luaL_error(L, "resulting string too large");
121	else {	121	else {
122	size_t totallen = n * l + (n - 1) * lsep;	122	size_t totallen = n * l + (n - 1) * lsep;
@@ -124,8 +124,9 @@ static int str_rep (lua_State *L) { · 1 unmodified line
124	char *p = luaL_buffinitsize(L, &b, totallen);	124	char *p = luaL_buffinitsize(L, &b, totallen);
125	while (n-- > 1) { /* first n-1 copies (followed by separator) */	125	while (n-- > 1) { /* first n-1 copies (followed by separator) */
126	memcpy(p, s, l * sizeof(char)); p += l;	126	memcpy(p, s, l * sizeof(char)); p += l;
127	if (lsep > 0) { /* avoid empty 'memcpy' (may be expensive) */	127	if (lsep > 0) { /* empty 'memcpy' is not that cheap */
128	memcpy(p, sep, lsep * sizeof(char)); p += lsep;	128	memcpy(p, sep, lsep * sizeof(char));
		129	p += lsep;
129	}	130	}
130	}	131	}
131	memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */	132	memcpy(p, s, l * sizeof(char)); /* last copy (not followed by separator) */
@@ -178,10 +179,11 @@ static int writer (lua_State L, const void b, size_t size, void *B) { · 46 unmodified lines
178		179
179	static int str_dump (lua_State *L) {	180	static int str_dump (lua_State *L) {
180	luaL_Buffer b;	181	luaL_Buffer b;
		182	int strip = lua_toboolean(L, 2);
181	luaL_checktype(L, 1, LUA_TFUNCTION);	183	luaL_checktype(L, 1, LUA_TFUNCTION);
182	lua_settop(L, 1);	184	lua_settop(L, 1);
183	luaL_buffinit(L,&b);	185	luaL_buffinit(L,&b);
184	if (lua_dump(L, writer, &b) != 0)	186	if (lua_dump(L, writer, &b, strip) != 0)
185	return luaL_error(L, "unable to dump given function");	187	return luaL_error(L, "unable to dump given function");
186	luaL_pushresult(&b);	188	luaL_pushresult(&b);
187	return 1;	189	return 1;
@@ -938,6 +940,217 @@ static int str_format (lua_State *L) { · 750 unmodified lines
938	/* }====================================================== */	940	/* }====================================================== */
939		941
940		942
		943	/*
		944	** {======================================================
		945	** PACK/UNPACK
		946	** =======================================================
		947	*/
		948
		949	/* maximum size for the binary representation of an integer */
		950	#define MAXINTSIZE 8
		951
		952
		953	/* number of bits in a character */
		954	#define NB CHAR_BIT
		955
		956	/* mask for one character (NB ones) */
		957	#define MC (((lua_Integer)1 << NB) - 1)
		958
		959	/* mask for one character without sign ((NB - 1) ones) */
		960	#define SM (((lua_Integer)1 << (NB - 1)) - 1)
		961
		962
		963	#define SZINT ((int)sizeof(lua_Integer))
		964
		965
		966	static union {
		967	int dummy;
		968	char little; /* true iff machine is little endian */
		969	} const nativeendian = {1};
		970
		971
		972	static int getendian (lua_State *L, int arg) {
		973	const char *endian = luaL_optstring(L, arg,
		974	(nativeendian.little ? "l" : "b"));
		975	if (endian == 'n') / native? */
		976	return nativeendian.little;
		977	luaL_argcheck(L, endian == 'l' \|\| endian == 'b', arg,
		978	"endianess must be 'l'/'b'/'n'");
		979	return (*endian == 'l');
		980	}
		981
		982
		983	static int getintsize (lua_State *L, int arg) {
		984	int size = luaL_optint(L, arg, 0);
		985	if (size == 0) size = SZINT;
		986	luaL_argcheck(L, 1 <= size && size <= MAXINTSIZE, arg,
		987	"integer size out of valid range");
		988	return size;
		989	}
		990
		991
		992	static int packint (char *buff, lua_Integer n, int littleendian, int size) {
		993	int i;
		994	if (littleendian) {
		995	for (i = 0; i < size - 1; i++) {
		996	buff[i] = (n & MC);
		997	n >>= NB;
		998	}
		999	}
		1000	else {
		1001	for (i = size - 1; i > 0; i--) {
		1002	buff[i] = (n & MC);
		1003	n >>= NB;
		1004	}
		1005	}
		1006	buff[i] = (n & MC); /* last byte */
		1007	/* test for overflow: OK if there are only zeros left in higher bytes,
		1008	or if there are only ones left and packed number is negative (signal
		1009	bit, the higher bit in last byte, is one) */
		1010	return ((n & ~MC) == 0 \|\| (n \| SM) == ~(lua_Integer)0);
		1011	}
		1012
		1013
		1014	static int packint_l (lua_State *L) {
		1015	char buff[MAXINTSIZE];
		1016	lua_Integer n = luaL_checkinteger(L, 1);
		1017	int size = getintsize(L, 2);
		1018	int endian = getendian(L, 3);
		1019	if (packint(buff, n, endian, size))
		1020	lua_pushlstring(L, buff, size);
		1021	else
		1022	luaL_error(L, "integer does not fit into given size (%d)", size);
		1023	return 1;
		1024	}
		1025
		1026
		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 */
		1031	#define HIGHERBYTE1 (HIGHERBYTE \| (HIGHERBYTE >> 1))
		1032
		1033	static int unpackint (const char buff, lua_Integer res,
		1034	int littleendian, int size) {
		1035	lua_Integer n = 0;
		1036	int i;
		1037	for (i = 0; i < size; i++) {
		1038	if (i >= SZINT) { /* will throw away a byte? */
		1039	/* check for overflow: it is OK to throw away leading zeros for a
		1040	positive number, leading ones for a negative number, and a
		1041	leading zero byte to allow unsigned integers with a 1 in
		1042	its "signal bit" */
		1043	if (!((n & HIGHERBYTE1) == 0 \|\| /* zeros for positive number */
		1044	(n & HIGHERBYTE1) == HIGHERBYTE1 \|\| /* ones for negative number */
		1045	((n & HIGHERBYTE) == 0 && i == size - 1))) /* leading zero */
		1046	return 0; /* overflow */
		1047	}
		1048	n <<= NB;
		1049	n \|= (lua_Integer)(unsigned char)buff[littleendian ? size - 1 - i : i];
		1050	}
		1051	if (size < SZINT) { /* need sign extension? */
		1052	lua_Integer mask = (~(lua_Integer)0) << (size*NB - 1);
		1053	if (n & mask) /* negative value? */
		1054	n \|= mask; /* signal extension */
		1055	}
		1056	*res = n;
		1057	return 1;
		1058	}
		1059
		1060
		1061	static int unpackint_l (lua_State *L) {
		1062	lua_Integer res;
		1063	size_t len;
		1064	const char *s = luaL_checklstring(L, 1, &len);
		1065	lua_Integer pos = posrelat(luaL_optinteger(L, 2, 1), len);
		1066	int size = getintsize(L, 3);
		1067	int endian = getendian(L, 4);
		1068	luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,
		1069	"string too short");
		1070	if(unpackint(s + pos - 1, &res, endian, size))
		1071	lua_pushinteger(L, res);
		1072	else
		1073	luaL_error(L, "result does not fit into a Lua integer");
		1074	return 1;
		1075	}
		1076
		1077
		1078	static void correctendianess (lua_State L, char b, int size, int endianarg) {
		1079	int endian = getendian(L, endianarg);
		1080	if (endian != nativeendian.little) { /* not native endianess? */
		1081	int i = 0;
		1082	while (i < --size) {
		1083	char temp = b[i];
		1084	b[i++] = b[size];
		1085	b[size] = temp;
		1086	}
		1087	}
		1088	}
		1089
		1090
		1091	static int getfloatsize (lua_State *L, int arg) {
		1092	const char *size = luaL_optstring(L, arg, "n");
		1093	if (*size == 'n') return sizeof(lua_Number);
		1094	luaL_argcheck(L, size == 'd' \|\| size == 'f', arg,
		1095	"size must be 'f'/'d'/'n'");
		1096	return (*size == 'd' ? sizeof(double) : sizeof(float));
		1097	}
		1098
		1099
		1100	static int packfloat_l (lua_State *L) {
		1101	float f; double d;
		1102	char pn; / pointer to number */
		1103	lua_Number n = luaL_checknumber(L, 1);
		1104	int size = getfloatsize(L, 2);
		1105	if (size == sizeof(lua_Number))
		1106	pn = (char*)&n;
		1107	else if (size == sizeof(float)) {
		1108	f = (float)n;
		1109	pn = (char*)&f;
		1110	}
		1111	else { /* native lua_Number may be neither float nor double */
		1112	lua_assert(size == sizeof(double));
		1113	d = (double)n;
		1114	pn = (char*)&d;
		1115	}
		1116	correctendianess(L, pn, size, 3);
		1117	lua_pushlstring(L, pn, size);
		1118	return 1;
		1119	}
		1120
		1121
		1122	static int unpackfloat_l (lua_State *L) {
		1123	lua_Number res;
		1124	size_t len;
		1125	const char *s = luaL_checklstring(L, 1, &len);
		1126	lua_Integer pos = posrelat(luaL_optinteger(L, 2, 1), len);
		1127	int size = getfloatsize(L, 3);
		1128	luaL_argcheck(L, 1 <= pos && (size_t)pos + size - 1 <= len, 1,
		1129	"string too short");
		1130	if (size == sizeof(lua_Number)) {
		1131	memcpy(&res, s + pos - 1, size);
		1132	correctendianess(L, (char*)&res, size, 4);
		1133	}
		1134	else if (size == sizeof(float)) {
		1135	float f;
		1136	memcpy(&f, s + pos - 1, size);
		1137	correctendianess(L, (char*)&f, size, 4);
		1138	res = (lua_Number)f;
		1139	}
		1140	else { /* native lua_Number may be neither float nor double */
		1141	double d;
		1142	lua_assert(size == sizeof(double));
		1143	memcpy(&d, s + pos - 1, size);
		1144	correctendianess(L, (char*)&d, size, 4);
		1145	res = (lua_Number)d;
		1146	}
		1147	lua_pushnumber(L, res);
		1148	return 1;
		1149	}
		1150
		1151	/* }====================================================== */
		1152
		1153
941	static const luaL_Reg strlib[] = {	1154	static const luaL_Reg strlib[] = {
942	{"byte", str_byte},	1155	{"byte", str_byte},
943	{"char", str_char},	1156	{"char", str_char},
@@ -953,6 +1166,10 @@ static const luaL_Reg strlib[] = { · 9 unmodified lines
953	{"reverse", str_reverse},	1166	{"reverse", str_reverse},
954	{"sub", str_sub},	1167	{"sub", str_sub},
955	{"upper", str_upper},	1168	{"upper", str_upper},
		1169	{"packfloat", packfloat_l},
		1170	{"packint", packint_l},
		1171	{"unpackfloat", unpackfloat_l},
		1172	{"unpackint", unpackint_l},
956	{NULL, NULL}	1173	{NULL, NULL}
957	};	1174	};
958		1175

src/ltable.c+47−27

 /*
-** $Id: ltable.c,v 2.78 2013/06/20 15:02:49 roberto Exp $
+** $Id: ltable.c,v 2.84 2014/01/27 13:34:32 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 static const Node dummynode_ = {
   {NILCONSTANT},  /* value */
-  {{NILCONSTANT, NULL}}  /* key */
+  {{NILCONSTANT, 0}}  /* key */
 };
   if (0 < i && i <= t->sizearray)  /* is `key' inside array part? */
     return i-1;  /* yes; that's the index (corrected to C) */
   else {
+    int nx;
     Node *n = mainposition(t, key);
     for (;;) {  /* check whether `key' is somewhere in the chain */
       /* key may be dead already, but it is ok to use it in `next' */
         /* hash elements are numbered after array ones */
         return i + t->sizearray;
       }
-      else n = gnext(n);
+      nx = gnext(n);
-      if (n == NULL)
+      if (nx == 0)
         luaG_runerror(L, "invalid key to " LUA_QL("next"));  /* key not found */
+      else n += nx;
     }
   }
 }
     t->node = luaM_newvector(L, size, Node);
     for (i=0; i<size; i++) {
       Node *n = gnode(t, i);
-      gnext(n) = NULL;
+      gnext(n) = 0;
       setnilvalue(gkey(n));
       setnilvalue(gval(n));
     }
 Table *luaH_new (lua_State *L) {
-  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table), NULL, 0)->h;
+  Table *t = &luaC_newobj(L, LUA_TTABLE, sizeof(Table))->h;
   t->metatable = NULL;
   t->flags = cast_byte(~0);
   t->array = NULL;
   else if (ttisfloat(key)) {
     lua_Number n = fltvalue(key);
     lua_Integer k;
-    if (luai_numisnan(L, n))
+    if (luai_numisnan(n))
       luaG_runerror(L, "table index is NaN");
     if (numisinteger(n, &k)) {  /* index is int? */
       setivalue(&aux, k);
   mp = mainposition(t, key);
   if (!ttisnil(gval(mp)) || isdummy(mp)) {  /* main position is taken? */
     Node *othern;
-    Node *n = getfreepos(t);  /* get a free place */
+    Node *f = getfreepos(t);  /* get a free place */
-    if (n == NULL) {  /* cannot find a free place? */
+    if (f == NULL) {  /* cannot find a free place? */
       rehash(L, t, key);  /* grow table */
       /* whatever called 'newkey' take care of TM cache and GC barrier */
       return luaH_set(L, t, key);  /* insert key into grown table */
     }
-    lua_assert(!isdummy(n));
+    lua_assert(!isdummy(f));
     othern = mainposition(t, gkey(mp));
     if (othern != mp) {  /* is colliding node out of its main position? */
       /* yes; move colliding node into free position */
-      while (gnext(othern) != mp) othern = gnext(othern);  /* find previous */
+      while (othern + gnext(othern) != mp)  /* find previous */
-      gnext(othern) = n;  /* redo the chain with `n' in place of `mp' */
+        othern += gnext(othern);
-      *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
+      gnext(othern) = f - othern;  /* re-chain with 'f' in place of 'mp' */
-      gnext(mp) = NULL;  /* now `mp' is free */
+      *f = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
+      if (gnext(mp) != 0) {
+        gnext(f) += 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 */
-      gnext(n) = gnext(mp);  /* chain new position */
+      if (gnext(mp) != 0)
-      gnext(mp) = n;
+        gnext(f) = (mp + gnext(mp)) - f;  /* chain new position */
-      mp = n;
+      else lua_assert(gnext(f) == 0);
+      gnext(mp) = f - mp;
+      mp = f;
     }
   }
   setobj2t(L, gkey(mp), key);
-  luaC_barrierback(L, obj2gco(t), key);
+  luaC_barrierback(L, t, key);
   lua_assert(ttisnil(gval(mp)));
   return gval(mp);
 }
     return &t->array[key - 1];
   else {
     Node *n = hashint(t, key);
-    do {  /* check whether `key' is somewhere in the chain */
+    for (;;) {  /* check whether `key' is somewhere in the chain */
       if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key)
         return gval(n);  /* that's it */
-      else n = gnext(n);
+      else {
-    } while (n);
+        int nx = gnext(n);
+        if (nx == 0) break;
+        n += nx;
+      }
+    };
     return luaO_nilobject;
   }
 }
 const TValue *luaH_getstr (Table *t, TString *key) {
   Node *n = hashstr(t, key);
   lua_assert(key->tsv.tt == LUA_TSHRSTR);
-  do {  /* check whether `key' is somewhere in the chain */
+  for (;;) {  /* check whether `key' is somewhere in the chain */
     if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key))
       return gval(n);  /* that's it */
-    else n = gnext(n);
+    else {
-  } while (n);
+      int nx = gnext(n);
+      if (nx == 0) break;
+      n += nx;
+    }
+  };
   return luaO_nilobject;
 }
     }
     default: {
       Node *n = mainposition(t, key);
-      do {  /* check whether `key' is somewhere in the chain */
+      for (;;) {  /* check whether `key' is somewhere in the chain */
         if (luaV_rawequalobj(gkey(n), key))
           return gval(n);  /* that's it */
-        else n = gnext(n);
+        else {
-      } while (n);
+          int nx = gnext(n);
+          if (nx == 0) break;
+          n += nx;
+        }
+      };
       return luaO_nilobject;
     }
   }

src/ltable.h+6−1

 /*
-** $Id: ltable.h,v 2.17 2013/04/26 15:39:25 roberto Exp $
+** $Id: ltable.h,v 2.18 2013/08/30 16:01:37 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 #define invalidateTMcache(t)	((t)->flags = 0)
+/* returns the key, given the value of a table entry */
+#define keyfromval(v) \
+  (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
 LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
 LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
                             TValue *value);

src/ltablib.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltablib.c,v 1.65 2013/03/07 18:17:24 roberto Exp $	2	** $Id: ltablib.c,v 1.66 2014/03/21 13:52:33 roberto Exp $
3	** Library for Table Manipulation	3	** Library for Table Manipulation
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -140,7 +140,7 @@ static int unpack (lua_State *L) { · 134 unmodified lines
140	e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));	140	e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));
141	if (i > e) return 0; /* empty range */	141	if (i > e) return 0; /* empty range */
142	n = e - i + 1; /* number of elements */	142	n = e - i + 1; /* number of elements */
143	if (n <= 0 \|\| !lua_checkstack(L, n)) /* n <= 0 means arith. overflow */	143	if (n <= 0 \|\| !lua_checkstack(L, n)) /* n <= 0 means arithmetic overflow */
144	return luaL_error(L, "too many results to unpack");	144	return luaL_error(L, "too many results to unpack");
145	lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */	145	lua_rawgeti(L, 1, i); /* push arg[i] (avoiding overflow problems) */
146	while (i++ < e) /* push arg[i + 1...e] */	146	while (i++ < e) /* push arg[i + 1...e] */

src/ltm.c+18−11

 /*
-** $Id: ltm.c,v 2.20 2013/05/06 17:19:11 roberto Exp $
+** $Id: ltm.c,v 2.25 2013/12/30 20:47:58 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
   "no value",
   "nil", "boolean", udatatypename, "number",
   "string", "table", "function", udatatypename, "thread",
-  "proto", "upval"  /* these last two cases are used for tests only */
+  "proto" /* this last case is used for tests only */
 };
   static const char *const luaT_eventname[] = {  /* ORDER TM */
     "__index", "__newindex",
     "__gc", "__mode", "__len", "__eq",
-    "__add", "__sub", "__mul", "__div", "__idiv", "__mod",
+    "__add", "__sub", "__mul", "__mod", "__pow",
-    "__pow", "__unm", "__lt", "__le",
+    "__div", "__idiv",
+    "__band", "__bor", "__bxor", "__shl", "__shr",
+    "__unm", "__bnot", "__lt", "__le",
     "__concat", "__call"
   };
   int i;
   for (i=0; i<TM_N; i++) {
     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
-    luaS_fix(G(L)->tmname[i]);  /* never collect these names */
+    luaC_fix(L, obj2gco(G(L)->tmname[i]));  /* never collect these names */
   }
 }
 void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                     StkId res, TMS event) {
   if (!luaT_callbinTM(L, p1, p2, res, event)) {
-    if (event == TM_CONCAT)
+    switch (event) {
-      luaG_concaterror(L, p1, p2);
+      case TM_CONCAT:
-    else if (event == TM_IDIV && ttisnumber(p1) && ttisnumber(p2))
+        luaG_concaterror(L, p1, p2);
-      luaG_tointerror(L, p1, p2);
+      case TM_IDIV: case TM_BAND: case TM_BOR: case TM_BXOR:
-    else
+      case TM_SHL: case TM_SHR: case TM_BNOT:
-      luaG_aritherror(L, p1, p2);
+        if (ttisnumber(p1) && ttisnumber(p2))
+          luaG_tointerror(L, p1, p2);
+        /* else go through */
+      default:
+        luaG_aritherror(L, p1, p2);
+    }
   }
 }

src/ltm.h+10−4

 /*
-** $Id: ltm.h,v 2.16 2013/04/29 16:56:50 roberto Exp $
+** $Id: ltm.h,v 2.19 2013/12/30 20:47:58 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
 /*
 * WARNING: if you change the order of this enumeration,
-* grep "ORDER TM"
+* grep "ORDER TM" and "ORDER OP"
 */
 typedef enum {
   TM_INDEX,
   TM_ADD,
   TM_SUB,
   TM_MUL,
-  TM_DIV,
-  TM_IDIV,
   TM_MOD,
   TM_POW,
+  TM_DIV,
+  TM_IDIV,
+  TM_BAND,
+  TM_BOR,
+  TM_BXOR,
+  TM_SHL,
+  TM_SHR,
   TM_UNM,
+  TM_BNOT,
   TM_LT,
   TM_LE,
   TM_CONCAT,

src/lua.c+69−31

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lua.c,v 1.206 2012/09/29 20:07:06 roberto Exp $	2	** $Id: lua.c,v 1.210 2014/02/26 15:27:56 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	*/
@@ -31,28 +31,38 @@ · 25 unmodified lines
31	#define LUA_MAXINPUT 512	31	#define LUA_MAXINPUT 512
32	#endif	32	#endif
33		33
34	#if !defined(LUA_INIT)	34	#if !defined(LUA_INIT_VAR)
35	#define LUA_INIT "LUA_INIT"	35	#define LUA_INIT_VAR "LUA_INIT"
36	#endif	36	#endif
37		37
38	#define LUA_INITVERSION \	38	#define LUA_INITVARVERSION \
39	LUA_INIT "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR	39	LUA_INIT_VAR "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
40		40
41		41
42	/*	42	/*
43	** lua_stdin_is_tty detects whether the standard input is a 'tty' (that	43	** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
44	** is, whether we're running lua interactively).	44	** is, whether we're running lua interactively).
45	*/	45	*/
46	#if defined(LUA_USE_ISATTY)	46	#if !defined(lua_stdin_is_tty) /* { */
		47
		48	#if defined(LUA_USE_POSIX) /* { */
		49
47	#include <unistd.h>	50	#include <unistd.h>
48	#define lua_stdin_is_tty() isatty(0)	51	#define lua_stdin_is_tty() isatty(0)
49	#elif defined(LUA_WIN)	52
		53	#elif defined(LUA_WIN) /* }{ */
		54
50	#include <io.h>	55	#include <io.h>
51	#include <stdio.h>
52	#define lua_stdin_is_tty() _isatty(_fileno(stdin))	56	#define lua_stdin_is_tty() _isatty(_fileno(stdin))
53	#else	57
		58	#else /* }{ */
		59
		60	/* ANSI definition */
54	#define lua_stdin_is_tty() 1 /* assume stdin is a tty */	61	#define lua_stdin_is_tty() 1 /* assume stdin is a tty */
55	#endif	62
		63	#endif /* } */
		64
		65	#endif /* } */
56		66
57		67
58	/*	68	/*
@@ -61,9 +71,10 @@ · 2 unmodified lines
61	** lua_saveline defines how to "save" a read line in a "history".	71	** lua_saveline defines how to "save" a read line in a "history".
62	** lua_freeline defines how to free a line read by lua_readline.	72	** lua_freeline defines how to free a line read by lua_readline.
63	*/	73	*/
64	#if defined(LUA_USE_READLINE)	74	#if !defined(lua_readline) /* { */
		75
		76	#if defined(LUA_USE_READLINE) /* { */
65		77
66	#include <stdio.h>
67	#include <readline/readline.h>	78	#include <readline/readline.h>
68	#include <readline/history.h>	79	#include <readline/history.h>
69	#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)	80	#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)
@@ -72,7 +83,7 @@ · 2 unmodified lines
72	add_history(lua_tostring(L, idx)); /* add it to history */	83	add_history(lua_tostring(L, idx)); /* add it to history */
73	#define lua_freeline(L,b) ((void)L, free(b))	84	#define lua_freeline(L,b) ((void)L, free(b))
74		85
75	#elif !defined(lua_readline)	86	#else /* }{ */
76		87
77	#define lua_readline(L,b,p) \	88	#define lua_readline(L,b,p) \
78	((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \	89	((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \
@@ -80,7 +91,9 @@ · 1 unmodified line
80	#define lua_saveline(L,idx) { (void)L; (void)idx; }	91	#define lua_saveline(L,idx) { (void)L; (void)idx; }
81	#define lua_freeline(L,b) { (void)L; (void)b; }	92	#define lua_freeline(L,b) { (void)L; (void)b; }
82		93
83	#endif	94	#endif /* } */
		95
		96	#endif /* } */
84		97
85		98
86		99
@@ -257,20 +270,21 @@ static int incomplete (lua_State *L, int status) { · 170 unmodified lines
257	}	270	}
258		271
259		272
		273	/* prompt the user, read a line, and push it into the Lua stack */
260	static int pushline (lua_State *L, int firstline) {	274	static int pushline (lua_State *L, int firstline) {
261	char buffer[LUA_MAXINPUT];	275	char buffer[LUA_MAXINPUT];
262	char *b = buffer;	276	char *b = buffer;
263	size_t l;	277	size_t l;
264	const char *prmt = get_prompt(L, firstline);	278	const char *prmt = get_prompt(L, firstline);
265	int readstatus = lua_readline(L, b, prmt);	279	int readstatus = lua_readline(L, b, prmt);
266	lua_pop(L, 1); /* remove result from 'get_prompt' */
267	if (readstatus == 0)	280	if (readstatus == 0)
268	return 0; /* no input */	281	return 0; /* no input (prompt will be popped by caller) */
		282	lua_pop(L, 1); /* remove prompt */
269	l = strlen(b);	283	l = strlen(b);
270	if (l > 0 && b[l-1] == '\n') /* line ends with newline? */	284	if (l > 0 && b[l-1] == '\n') /* line ends with newline? */
271	b[l-1] = '\0'; /* remove it */	285	b[l-1] = '\0'; /* remove it */
272	if (firstline && b[0] == '=') /* first line starts with `=' ? */	286	if (firstline && b[0] == '=') /* for compatibility with 5.2, ... */
273	lua_pushfstring(L, "return %s", b+1); /* change it to `return' */	287	lua_pushfstring(L, "return %s", b + 1); /* change '=' to 'return' */
274	else	288	else
275	lua_pushstring(L, b);	289	lua_pushstring(L, b);
276	lua_freeline(L, b);	290	lua_freeline(L, b);
@@ -278,24 +292,48 @@ static int pushline (lua_State *L, int firstline) { · 1 unmodified line
278	}	292	}
279		293
280		294
281	static int loadline (lua_State *L) {	295	/* try to compile line on the stack as 'return <line>'; on return, stack
		296	has either compiled chunk or original line (if compilation failed) */
		297	static int addreturn (lua_State *L) {
282	int status;	298	int status;
283	lua_settop(L, 0);	299	size_t len; const char *line;
284	if (!pushline(L, 1))	300	lua_pushliteral(L, "return ");
285	return -1; /* no input */	301	lua_pushvalue(L, -2); /* duplicate line */
		302	lua_concat(L, 2); /* new line is "return ..." */
		303	line = lua_tolstring(L, -1, &len);
		304	if ((status = luaL_loadbuffer(L, line, len, "=stdin")) == LUA_OK)
		305	lua_remove(L, -3); /* remove original line */
		306	else
		307	lua_pop(L, 2); /* remove result from 'luaL_loadbuffer' and new line */
		308	return status;
		309	}
		310
		311
		312	/* read multiple lines until a complete line */
		313	static int multiline (lua_State *L) {
286	for (;;) { /* repeat until gets a complete line */	314	for (;;) { /* repeat until gets a complete line */
287	size_t l;	315	size_t len;
288	const char *line = lua_tolstring(L, 1, &l);	316	const char line = lua_tolstring(L, 1, &len); / get what it has */
289	status = luaL_loadbuffer(L, line, l, "=stdin");	317	int status = luaL_loadbuffer(L, line, len, "=stdin"); /* try it */
290	if (!incomplete(L, status)) break; /* cannot try to add lines? */	318	if (!incomplete(L, status) \|\| !pushline(L, 0))
291	if (!pushline(L, 0)) /* no more input? */	319	return status; /* cannot/should not try to add continuation line */
292	return -1;	320	lua_pushliteral(L, "\n"); /* add newline... */
293	lua_pushliteral(L, "\n"); /* add a new line... */
294	lua_insert(L, -2); /* ...between the two lines */	321	lua_insert(L, -2); /* ...between the two lines */
295	lua_concat(L, 3); /* join them */	322	lua_concat(L, 3); /* join them */
296	}	323	}
		324	}
		325
		326
		327	static int loadline (lua_State *L) {
		328	int status;
		329	lua_settop(L, 0);
		330	if (!pushline(L, 1))
		331	return -1; /* no input */
		332	if ((status = addreturn(L)) != LUA_OK) /* 'return ...' did not work? */
		333	status = multiline(L); /* try as command, maybe with continuation lines */
297	lua_saveline(L, 1);	334	lua_saveline(L, 1);
298	lua_remove(L, 1); /* remove line */	335	lua_remove(L, 1); /* remove line */
		336	lua_assert(lua_gettop(L) == 1);
299	return status;	337	return status;
300	}	338	}
301		339
@@ -421,10 +459,10 @@ static int runargs (lua_State L, char *argv, int n) { · 119 unmodified lines
421		459
422		460
423	static int handle_luainit (lua_State *L) {	461	static int handle_luainit (lua_State *L) {
424	const char *name = "=" LUA_INITVERSION;	462	const char *name = "=" LUA_INITVARVERSION;
425	const char *init = getenv(name + 1);	463	const char *init = getenv(name + 1);
426	if (init == NULL) {	464	if (init == NULL) {
427	name = "=" LUA_INIT;	465	name = "=" LUA_INIT_VAR;
428	init = getenv(name + 1); /* try alternative name */	466	init = getenv(name + 1); /* try alternative name */
429	}	467	}
430	if (init == NULL) return LUA_OK;	468	if (init == NULL) return LUA_OK;

src/lua.h+25−21

 /*
-** $Id: lua.h,v 1.292 2013/07/05 14:29:51 roberto Exp $
+** $Id: lua.h,v 1.302 2014/03/20 19:42:35 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 (work1)"
+#define LUA_VERSION_RELEASE	"0 (work2)"
 #define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
 #define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
-#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2013 Lua.org, PUC-Rio"
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2014 Lua.org, PUC-Rio"
 #define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
 ** Comparison and arithmetic functions
 */
-#define LUA_OPADD	0	/* ORDER TM */
+#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
 #define LUA_OPSUB	1
 #define LUA_OPMUL	2
-#define LUA_OPDIV	3
+#define LUA_OPMOD	3
-#define LUA_OPIDIV	4
+#define LUA_OPPOW	4
-#define LUA_OPMOD	5
+#define LUA_OPDIV	5
-#define LUA_OPPOW	6
+#define LUA_OPIDIV	6
-#define LUA_OPUNM	7
+#define LUA_OPBAND	7
+#define LUA_OPBOR	8
+#define LUA_OPBXOR	9
+#define LUA_OPSHL	10
+#define LUA_OPSHR	11
+#define LUA_OPUNM	12
+#define LUA_OPBNOT	13
 LUA_API void  (lua_arith) (lua_State *L, int op);
 /*
 ** get functions (Lua -> stack)
 */
-LUA_API void  (lua_getglobal) (lua_State *L, const char *var);
+LUA_API int (lua_getglobal) (lua_State *L, const char *var);
-LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API int (lua_gettable) (lua_State *L, int idx);
-LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API int (lua_rawget) (lua_State *L, int idx);
-LUA_API void  (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
-LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
+LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
 LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
 LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
 LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
                                         const char *chunkname,
                                         const char *mode);
-LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
 /*
 #define LUA_GCSTEP		5
 #define LUA_GCSETPAUSE		6
 #define LUA_GCSETSTEPMUL	7
-#define LUA_GCSETMAJORINC	8
 #define LUA_GCISRUNNING		9
-#define LUA_GCGEN		10
-#define LUA_GCINC		11
 LUA_API int (lua_gc) (lua_State *L, int what, int data);
 LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
                                                int fidx2, int n2);
-LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
 LUA_API lua_Hook (lua_gethook) (lua_State *L);
 LUA_API int (lua_gethookmask) (lua_State *L);
 LUA_API int (lua_gethookcount) (lua_State *L);
 /******************************************************************************
-* Copyright (C) 1994-2013 Lua.org, PUC-Rio.
+* Copyright (C) 1994-2014 Lua.org, PUC-Rio.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the

src/luac.c+1−1

@@ -202,7 +202,7 @@ int main(int argc, char* argv[]) · 201 unmodified lines
202	return EXIT_SUCCESS;	202	return EXIT_SUCCESS;
203	}	203	}
204		204
205	#define nvalue(x) 0	205	#define nvalue(x) ((lua_Number)0)
206	#define ttypenv(x) ttnov(x)	206	#define ttypenv(x) ttnov(x)
207	/*	207	/*
208	** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $	208	** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $

src/luaconf.h+76−44

 /*
-** $Id: luaconf.h,v 1.185 2013/06/25 19:04:40 roberto Exp $
+** $Id: luaconf.h,v 1.193 2014/03/21 14:27:16 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 integers;
+@@ LUA_REAL_FLOAT / LUA_REAL_DOUBLE / LUA_REAL_LONGDOUBLE defines size 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
+** floats. The usual configurations are 64-bit integers and floats (the
+** default) and 32-bit integers and floats (Small Lua, for restricted
+** hardware).
+** =====================================================================
+*/
+#define LUA_INT_LONGLONG
+#define LUA_REAL_DOUBLE
 /*
 @@ LUA_ANSI controls the use of non-ansi features.
 ** CHANGE it (define it) if you want Lua to avoid the use of any
 #if defined(LUA_USE_LINUX)
+#define LUA_USE_C99
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
 #define LUA_USE_READLINE	/* needs some extra libraries */
-#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
-#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
-#define LUA_USE_LONGLONG	/* assume support for long long */
 #endif
 #if defined(LUA_USE_MACOSX)
+#define LUA_USE_C99
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* does not need -ldl */
 #define LUA_USE_READLINE	/* needs an extra library: -lreadline */
-#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hex formats */
-#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
-#define LUA_USE_LONGLONG	/* assume support for long long */
 #endif
+/*
+@@ LUA_USE_C99 includes all functionality from C 99.
+** CHANGE it (define it) if your system is compatible.
+*/
+#if defined(LUA_USE_C99)
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#endif
 /*
 @@ LUA_USE_POSIX includes all functionality listed as X/Open System
 ** CHANGE it (define it) if your system is XSI compatible.
 */
 #if defined(LUA_USE_POSIX)
-#define LUA_USE_MKSTEMP
-#define LUA_USE_ISATTY
-#define LUA_USE_POPEN
-#define LUA_USE_ULONGJMP
-#define LUA_USE_GMTIME_R
 #endif
 #define LUA_CDIR	"!\\"
 #define LUA_PATH_DEFAULT  \
 		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" ".\\?.lua"
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
+		".\\?.lua;" ".\\?\\init.lua"
 #define LUA_CPATH_DEFAULT \
 		LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll"
 #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;" "./?.lua"
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
+		"./?.lua;" "./?/init.lua"
 #define LUA_CPATH_DEFAULT \
 		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
 #endif			/* } */
 */
 #if defined(LUA_COMPAT_ALL)	/* { */
+/*
+@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
+*/
+#define LUA_COMPAT_BITLIB
 /*
 @@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
 ** You can replace it with 'table.unpack'.
 /*
 @@ LUAI_MAXSTACK limits the size of the Lua stack.
 ** CHANGE it if you need a different limit. This limit is arbitrary;
-** its only purpose is to stop Lua to consume unlimited stack
+** its only purpose is to stop Lua from consuming unlimited stack
 ** space (and to reserve some numbers for pseudo-indices).
 */
 #if LUAI_BITSINT >= 32
 #define LUAL_BUFFERSIZE		BUFSIZ
 /*
 ** {==================================================================
-** The following definitions set the numeric types for Lua.
+** Configuration for Numbers.
-** Lua should work fine with 32-bit or 64-bit integers mixed with
+** Change these definitions if no predefined LUA_REAL_* / LUA_INT_*
-** 32-bit or 64-bit floats. The usual configurations are 64-bit
+** satisfy your needs.
-** integers and floats (the default) and 32-bit integers and floats.
 ** ===================================================================
 */
-/*
-@@ LUA_INTSIZE defines size for Lua integer: 1=int, 2=long, 3=long long
-@@ LUA_FLOATSIZE defines size for Lua float: 1=float, 2=double, 3=long double
-** Default is long long + double
-*/
-#define LUA_INTSIZE		3
-#define LUA_FLOATSIZE		2
 /*
 @@ LUA_NUMBER is the floating-point type used by Lua.
 **
 @@ 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 floats to a string.
+@@ lua_number2str converts a float to a string.
 **
 @@ l_mathop allows the addition of an 'l' or 'f' to all math operations
 **
 @@ lua_str2number converts a decimal numeric string to a number.
 */
-#if LUA_FLOATSIZE == 1	/* { single float */
+#if defined(LUA_REAL_FLOAT)		/* { single float */
 #define LUA_NUMBER	float
 #define lua_str2number(s,p)	strtof((s), (p))
-#elif LUA_FLOATSIZE == 3	/* }{ long double */
+#elif defined(LUA_REAL_LONGDOUBLE)	/* }{ long double */
 #define LUA_NUMBER	long double
 #define lua_str2number(s,p)	strtold((s), (p))
-#else	/* }{ default: double */
+#elif defined(LUA_REAL_DOUBLE)		/* }{ double */
 #define LUA_NUMBER	double
 #define lua_str2number(s,p)	strtod((s), (p))
-#endif	/* } */
+#else					/* }{ */
+#error "numeric real type not defined"
+#endif					/* } */
 #if defined(LUA_ANSI)
 /* the following operations need the math library */
 #if defined(lobject_c) || defined(lvm_c)
 #include <math.h>
-#define luai_nummod(L,a,b)	((a) - l_floor((a)/(b))*(b))
+#define luai_nummod(L,a,b)	((void)L, (a) - l_floor((a)/(b))*(b))
-#define luai_numpow(L,a,b)	(l_mathop(pow)(a,b))
+#define luai_numpow(L,a,b)	((void)L, l_mathop(pow)(a,b))
 #endif
 /* these are quite standard operations */
 #define luai_numdiv(L,a,b)	((a)/(b))
 #define luai_numunm(L,a)	(-(a))
 #define luai_numeq(a,b)		((a)==(b))
-#define luai_numlt(L,a,b)	((a)<(b))
+#define luai_numlt(a,b)		((a)<(b))
-#define luai_numle(L,a,b)	((a)<=(b))
+#define luai_numle(a,b)		((a)<=(b))
-#define luai_numisnan(L,a)	(!luai_numeq((a), (a)))
+#define luai_numisnan(a)	(!luai_numeq((a), (a)))
 #endif
+/*
+** The following macro checks whether an operation is not safe to be
+** performed by the constant folder. It should result in zero only if
+** the operation is safe.
+*/
+#define luai_numinvalidop(op,a,b)	0
 /*
 @@ LUA_INTEGER is the integer type used by Lua.
 @@ lua_integer2str converts an integer to a string.
 */
-#if LUA_INTSIZE == 1	/* { int */
+#if defined(LUA_INT_INT)		/* { int */
 #define LUA_INTEGER		int
 #define LUA_INTEGER_FRMLEN	""
-#elif LUA_INTSIZE == 2	/* }{ long */
+#elif defined(LUA_INT_LONG)	/* }{ long */
 #define LUA_INTEGER		long
 #define LUA_INTEGER_FRMLEN	"l"
-#else	/* }{ default: long long */
+#elif defined(LUA_INT_LONGLONG)	/* }{ long long */
+#if defined(_WIN32)
+#define LUA_INTEGER		__int64
+#define LUA_INTEGER_FRMLEN	"I64"
+#else
 #define LUA_INTEGER		long long
 #define LUA_INTEGER_FRMLEN	"ll"
+#endif
-#endif	/* } */
+#else				/* }{ */
+#error "numeric integer type not defined"
+#endif				/* } */
 #define LUA_INTEGER_SCAN	"%" LUA_INTEGER_FRMLEN "d"

src/lualib.h+4−1

 /*
-** $Id: lualib.h,v 1.43 2011/12/08 12:11:37 roberto Exp $
+** $Id: lualib.h,v 1.44 2014/02/06 17:32:33 roberto Exp $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
 #define LUA_STRLIBNAME	"string"
 LUAMOD_API int (luaopen_string) (lua_State *L);
+#define LUA_UTF8LIBNAME	"utf8"
+LUAMOD_API int (luaopen_utf8) (lua_State *L);
 #define LUA_BITLIBNAME	"bit32"
 LUAMOD_API int (luaopen_bit32) (lua_State *L);

src/lundump.c+207−209

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lundump.c,v 2.23 2013/04/26 18:48:35 roberto Exp $	2	** $Id: lundump.c,v 2.34 2014/03/11 18:56:27 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	*/
@@ -20,249 +20,247 @@ · 14 unmodified lines
20	#include "lundump.h"	20	#include "lundump.h"
21	#include "lzio.h"	21	#include "lzio.h"
22		22
		23
		24	#if !defined(luai_verifycode)
		25	#define luai_verifycode(L,b,f) /* empty */
		26	#endif
		27
		28
23	typedef struct {	29	typedef struct {
24	lua_State* L;	30	lua_State *L;
25	ZIO* Z;	31	ZIO *Z;
26	Mbuffer* b;	32	Mbuffer *b;
27	const char* name;	33	const char *name;
28	} LoadState;	34	} LoadState;
29		35
30	static l_noret error(LoadState* S, const char* why)	36
31	{	37	static l_noret error(LoadState S, const char why) {
32	luaO_pushfstring(S->L,"%s: %s precompiled chunk",S->name,why);	38	luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why);
33	luaD_throw(S->L,LUA_ERRSYNTAX);	39	luaD_throw(S->L, LUA_ERRSYNTAX);
34	}	40	}
35		41
36	#define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size))
37	#define LoadByte(S) (lu_byte)LoadChar(S)
38	#define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x))
39	#define LoadVector(S,b,n,size) LoadMem(S,b,n,size)
40		42
41	#if !defined(luai_verifycode)	43	/*
42	#define luai_verifycode(L,b,f) /* empty */	44	** All high-level loads go through LoadVector; you can change it to
43	#endif	45	** adapt to the endianess of the input
		46	*/
		47	#define LoadVector(S,b,n) LoadBlock(S,b,(n)*sizeof((b)[0]))
44		48
45	static void LoadBlock(LoadState* S, void* b, size_t size)	49	static void LoadBlock (LoadState S, void b, size_t size) {
46	{	50	if (luaZ_read(S->Z, b, size) != 0)
47	if (luaZ_read(S->Z,b,size)!=0) error(S,"truncated");	51	error(S, "truncated");
48	}	52	}
49		53
50	static int LoadChar(LoadState* S)	54
51	{	55	#define LoadVar(S,x) LoadVector(S,&x,1)
52	char x;	56
53	LoadVar(S,x);	57
54	return x;	58	static lu_byte LoadByte (LoadState *S) {
		59	lu_byte x;
		60	LoadVar(S, x);
		61	return x;
55	}	62	}
56		63
57	static int LoadInt(LoadState* S)	64
58	{	65	static int LoadInt (LoadState *S) {
59	int x;	66	int x;
60	LoadVar(S,x);	67	LoadVar(S, x);
61	if (x<0) error(S,"corrupted");	68	return x;
62	return x;
63	}	69	}
64		70
65	static lua_Number LoadNumber(LoadState* S)	71
66	{	72	static lua_Number LoadNumber (LoadState *S) {
67	lua_Number x;	73	lua_Number x;
68	LoadVar(S,x);	74	LoadVar(S, x);
69	return x;	75	return x;
70	}	76	}
71		77
72	static lua_Integer LoadInteger(LoadState* S)	78
73	{	79	static lua_Integer LoadInteger (LoadState *S) {
74	lua_Integer x;	80	lua_Integer x;
75	LoadVar(S,x);	81	LoadVar(S, x);
76	return x;	82	return x;
77	}	83	}
78		84
79	static TString* LoadString(LoadState* S)	85
80	{	86	static TString LoadString (LoadState S) {
81	size_t size;	87	size_t size = LoadByte(S);
82	LoadVar(S,size);	88	if (size == 0xFF)
83	if (size==0)	89	LoadVar(S, size);
84	return NULL;	90	if (size == 0)
85	else	91	return NULL;
86	{	92	else {
87	char* s=luaZ_openspace(S->L,S->b,size);	93	char *s = luaZ_openspace(S->L, S->b, --size);
88	LoadBlock(S,s,size*sizeof(char));	94	LoadVector(S, s, size);
89	return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */	95	return luaS_newlstr(S->L, s, size);
90	}	96	}
91	}	97	}
92		98
93	static void LoadCode(LoadState* S, Proto* f)	99
94	{	100	static void LoadCode (LoadState S, Proto f) {
95	int n=LoadInt(S);	101	int n = LoadInt(S);
96	f->code=luaM_newvector(S->L,n,Instruction);	102	f->code = luaM_newvector(S->L, n, Instruction);
97	f->sizecode=n;	103	f->sizecode = n;
98	LoadVector(S,f->code,n,sizeof(Instruction));	104	LoadVector(S, f->code, n);
99	}	105	}
100		106
101	static void LoadFunction(LoadState* S, Proto* f);	107
102		108	static void LoadFunction(LoadState S, Proto f);
103	static void LoadConstants(LoadState* S, Proto* f)	109
104	{	110
105	int i,n;	111	static void LoadConstants (LoadState S, Proto f) {
106	n=LoadInt(S);	112	int i, n;
107	f->k=luaM_newvector(S->L,n,TValue);	113	n = LoadInt(S);
108	f->sizek=n;	114	f->k = luaM_newvector(S->L, n, TValue);
109	for (i=0; i<n; i++) setnilvalue(&f->k[i]);	115	f->sizek = n;
110	for (i=0; i<n; i++)	116	for (i = 0; i < n; i++)
111	{	117	setnilvalue(&f->k[i]);
112	TValue* o=&f->k[i];	118	for (i = 0; i < n; i++) {
113	int t=LoadChar(S);	119	TValue *o = &f->k[i];
114	switch (t)	120	int t = LoadByte(S);
115	{	121	switch (t) {
116	case LUA_TNIL:	122	case LUA_TNIL:
117	setnilvalue(o);	123	setnilvalue(o);
118	break;	124	break;
119	case LUA_TBOOLEAN:	125	case LUA_TBOOLEAN:
120	setbvalue(o,LoadChar(S));	126	setbvalue(o, LoadByte(S));
121	break;	127	break;
122	case LUA_TNUMFLT:	128	case LUA_TNUMFLT:
123	setnvalue(o,LoadNumber(S));	129	setnvalue(o, LoadNumber(S));
124	break;	130	break;
125	case LUA_TNUMINT:	131	case LUA_TNUMINT:
126	setivalue(o,LoadInteger(S));	132	setivalue(o, LoadInteger(S));
127	break;	133	break;
128	case LUA_TSHRSTR: case LUA_TLNGSTR:	134	case LUA_TSHRSTR:
129	setsvalue2n(S->L,o,LoadString(S));	135	case LUA_TLNGSTR:
130	break;	136	setsvalue2n(S->L, o, LoadString(S));
131	default: lua_assert(0);	137	break;
		138	default:
		139	lua_assert(0);
		140	}
		141	}
		142	n = LoadInt(S);
		143	f->p = luaM_newvector(S->L, n, Proto *);
		144	f->sizep = n;
		145	for (i = 0; i < n; i++)
		146	f->p[i] = NULL;
		147	for (i = 0; i < n; i++) {
		148	f->p[i] = luaF_newproto(S->L);
		149	LoadFunction(S, f->p[i]);
132	}	150	}
133	}
134	n=LoadInt(S);
135	f->p=luaM_newvector(S->L,n,Proto*);
136	f->sizep=n;
137	for (i=0; i<n; i++) f->p[i]=NULL;
138	for (i=0; i<n; i++)
139	{
140	f->p[i]=luaF_newproto(S->L);
141	LoadFunction(S,f->p[i]);
142	}
143	}	151	}
144		152
145	static void LoadUpvalues(LoadState* S, Proto* f)	153
146	{	154	static void LoadUpvalues (LoadState S, Proto f) {
147	int i,n;	155	int i, n;
148	n=LoadInt(S);	156	n = LoadInt(S);
149	f->upvalues=luaM_newvector(S->L,n,Upvaldesc);	157	f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
150	f->sizeupvalues=n;	158	f->sizeupvalues = n;
151	for (i=0; i<n; i++) f->upvalues[i].name=NULL;	159	for (i = 0; i < n; i++)
152	for (i=0; i<n; i++)	160	f->upvalues[i].name = NULL;
153	{	161	for (i = 0; i < n; i++) {
154	f->upvalues[i].instack=LoadByte(S);	162	f->upvalues[i].instack = LoadByte(S);
155	f->upvalues[i].idx=LoadByte(S);	163	f->upvalues[i].idx = LoadByte(S);
156	}	164	}
157	}	165	}
158		166
159	static void LoadDebug(LoadState* S, Proto* f)	167
160	{	168	static void LoadDebug (LoadState S, Proto f) {
161	int i,n;	169	int i, n;
162	f->source=LoadString(S);	170	f->source = LoadString(S);
163	n=LoadInt(S);	171	n = LoadInt(S);
164	f->lineinfo=luaM_newvector(S->L,n,int);	172	f->lineinfo = luaM_newvector(S->L, n, int);
165	f->sizelineinfo=n;	173	f->sizelineinfo = n;
166	LoadVector(S,f->lineinfo,n,sizeof(int));	174	LoadVector(S, f->lineinfo, n);
167	n=LoadInt(S);	175	n = LoadInt(S);
168	f->locvars=luaM_newvector(S->L,n,LocVar);	176	f->locvars = luaM_newvector(S->L, n, LocVar);
169	f->sizelocvars=n;	177	f->sizelocvars = n;
170	for (i=0; i<n; i++) f->locvars[i].varname=NULL;	178	for (i = 0; i < n; i++)
171	for (i=0; i<n; i++)	179	f->locvars[i].varname = NULL;
172	{	180	for (i = 0; i < n; i++) {
173	f->locvars[i].varname=LoadString(S);	181	f->locvars[i].varname = LoadString(S);
174	f->locvars[i].startpc=LoadInt(S);	182	f->locvars[i].startpc = LoadInt(S);
175	f->locvars[i].endpc=LoadInt(S);	183	f->locvars[i].endpc = LoadInt(S);
176	}	184	}
177	n=LoadInt(S);	185	n = LoadInt(S);
178	for (i=0; i<n; i++) f->upvalues[i].name=LoadString(S);	186	for (i = 0; i < n; i++)
		187	f->upvalues[i].name = LoadString(S);
179	}	188	}
180		189
181	static void LoadFunction(LoadState* S, Proto* f)	190
182	{	191	static void LoadFunction (LoadState S, Proto f) {
183	f->linedefined=LoadInt(S);	192	f->linedefined = LoadInt(S);
184	f->lastlinedefined=LoadInt(S);	193	f->lastlinedefined = LoadInt(S);
185	f->numparams=LoadByte(S);	194	f->numparams = LoadByte(S);
186	f->is_vararg=LoadByte(S);	195	f->is_vararg = LoadByte(S);
187	f->maxstacksize=LoadByte(S);	196	f->maxstacksize = LoadByte(S);
188	LoadCode(S,f);	197	LoadCode(S, f);
189	LoadConstants(S,f);	198	LoadConstants(S, f);
190	LoadUpvalues(S,f);	199	LoadUpvalues(S, f);
191	LoadDebug(S,f);	200	LoadDebug(S, f);
192	}	201	}
193		202
194	/* the code below must be consistent with the code in luaU_header */	203
195	#define N0 LUAC_HEADERSIZE	204	static void checkliteral (LoadState S, const char s, const char *msg) {
196	#define N1 (sizeof(LUA_SIGNATURE)-sizeof(char))	205	char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
197	#define N2 N1+2	206	int len = strlen(s);
198	#define N3 N2+6	207	LoadVector(S, buff, len);
199		208	if (memcmp(s, buff, len) != 0)
200	static void LoadHeader(LoadState* S)	209	error(S, msg);
201	{
202	lu_byte h[LUAC_HEADERSIZE];
203	lu_byte s[LUAC_HEADERSIZE];
204	luaU_header(h);
205	memcpy(s,h,sizeof(char)); /* first char already read */
206	LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
207	if (memcmp(h,s,N0)==0) return;
208	if (memcmp(h,s,N1)!=0) error(S,"not a");
209	if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
210	if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted");
211	}	210	}
212		211
213	/*	212
214	** load precompiled chunk	213	static void fchecksize (LoadState S, size_t size, const char tname) {
215	*/	214	if (LoadByte(S) != size)
216	Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)	215	error(S, luaO_pushfstring(S->L, "%s size mismatch in", tname));
217	{	216	}
218	LoadState S;	217
219	Closure* cl;	218
220	if (name=='@' \|\| name=='=')	219	#define checksize(S,t) fchecksize(S,sizeof(t),#t)
221	S.name=name+1;	220
222	else if (*name==LUA_SIGNATURE[0])	221	static void checkHeader (LoadState *S) {
223	S.name="binary string";	222	checkliteral(S, LUA_SIGNATURE + 1, "not a"); /* 1st char already checked */
224	else	223	if (LoadByte(S) != LUAC_VERSION)
225	S.name=name;	224	error(S, "version mismatch in");
226	S.L=L;	225	if (LoadByte(S) != LUAC_FORMAT)
227	S.Z=Z;	226	error(S, "format mismatch in");
228	S.b=buff;	227	checkliteral(S, LUAC_DATA, "corrupted");
229	LoadHeader(&S);	228	checksize(S, int);
230	cl=luaF_newLclosure(L,1);	229	checksize(S, size_t);
231	setclLvalue(L,L->top,cl); incr_top(L);	230	checksize(S, Instruction);
232	cl->l.p=luaF_newproto(L);	231	checksize(S, lua_Integer);
233	LoadFunction(&S,cl->l.p);	232	checksize(S, lua_Number);
234	if (cl->l.p->sizeupvalues != 1)	233	if (LoadInteger(S) != LUAC_INT)
235	{	234	error(S, "endianess mismatch in");
236	Proto* p=cl->l.p;	235	if (LoadNumber(S) != LUAC_NUM)
237	cl=luaF_newLclosure(L,cl->l.p->sizeupvalues);	236	error(S, "float format mismatch in");
238	cl->l.p=p;
239	setclLvalue(L,L->top-1,cl);
240	}
241	luai_verifycode(L,buff,cl->l.p);
242	return cl;
243	}	237	}
244		238
245	#define MYINT(s) (s[0]-'0')
246	#define VERSION MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)
247	#define FORMAT 0 /* this is the official format */
248		239
249	/*	240	/*
250	* make header for precompiled chunks	241	** load precompiled chunk
251	* if you change the code below be sure to update LoadHeader and FORMAT above
252	* and LUAC_HEADERSIZE in lundump.h
253	*/	242	*/
254	void luaU_header (lu_byte* h)	243	Closure luaU_undump(lua_State L, ZIO Z, Mbuffer buff,
255	{	244	const char *name) {
256	int x=1;	245	LoadState S;
257	memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char));	246	Closure *cl;
258	h+=sizeof(LUA_SIGNATURE)-sizeof(char);	247	if (name == '@' \|\| name == '=')
259	*h++=cast_byte(VERSION);	248	S.name = name + 1;
260	*h++=cast_byte(FORMAT);	249	else if (*name == LUA_SIGNATURE[0])
261	h++=cast_byte((char)&x); / endianness */	250	S.name = "binary string";
262	*h++=cast_byte(sizeof(int));	251	else
263	*h++=cast_byte(sizeof(size_t));	252	S.name = name;
264	*h++=cast_byte(sizeof(Instruction));	253	S.L = L;
265	*h++=cast_byte(sizeof(lua_Number));	254	S.Z = Z;
266	h++=cast_byte(((lua_Number)0.5)==0); / is lua_Number integral? */	255	S.b = buff;
267	memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char));	256	checkHeader(&S);
		257	cl = luaF_newLclosure(L, LoadByte(&S));
		258	setclLvalue(L, L->top, cl);
		259	incr_top(L);
		260	cl->l.p = luaF_newproto(L);
		261	LoadFunction(&S, cl->l.p);
		262	lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
		263	luai_verifycode(L, buff, cl->l.p);
		264	return cl;
268	}	265	}
		266

src/lundump.h+16−11

 /*
-** $Id: lundump.h,v 1.39 2012/05/08 13:53:33 roberto Exp $
+** $Id: lundump.h,v 1.42 2014/03/11 14:22:54 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 #ifndef lundump_h
 #define lundump_h
+#include "llimits.h"
 #include "lobject.h"
 #include "lzio.h"
-/* load one chunk; from lundump.c */
-LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
-/* make header; from lundump.c */
+/* data to catch conversion errors */
-LUAI_FUNC void luaU_header (lu_byte* h);
+#define LUAC_DATA	"\x19\x93\r\n\x1a\n"
-/* dump one chunk; from ldump.c */
+#define LUAC_INT	cast_integer(0xABCD)
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
+#define LUAC_NUM	cast_num(370.5)
-/* data to catch conversion errors */
+#define MYINT(s)	(s[0]-'0')
-#define LUAC_TAIL		"\x19\x93\r\n\x1a\n"
+#define LUAC_VERSION	(MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
+#define LUAC_FORMAT	0	/* this is the official format */
-/* size in bytes of header of binary files */
+/* load one chunk; from lundump.c */
-#define LUAC_HEADERSIZE		(sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char))
+LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff,
+                                const char* name);
+/* dump one chunk; from ldump.c */
+LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
+                         void* data, int strip);
 #endif

src/lutf8lib.c+240−0

@@ -0,0 +1,240 @@
	1	/*
	2	** $Id: lutf8lib.c,v 1.4 2014/03/20 19:36:02 roberto Exp $
	3	** Standard library for UTF-8 manipulation
	4	** See Copyright Notice in lua.h
	5	*/
	6
	7
	8	#include <assert.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11
	12	#define lutf8lib_c
	13	#define LUA_LIB
	14
	15	#include "lua.h"
	16
	17	#include "lauxlib.h"
	18	#include "lualib.h"
	19
	20	#define MAXUNICODE 0x10FFFF
	21
	22	#define iscont(p) ((*(p) & 0xC0) == 0x80)
	23
	24
	25	/* from strlib */
	26	/* translate a relative string position: negative means back from end */
	27	static lua_Integer u_posrelat (lua_Integer pos, size_t len) {
	28	if (pos >= 0) return pos;
	29	else if (0u - (size_t)pos > len) return 0;
	30	else return (lua_Integer)len + pos + 1;
	31	}
	32
	33
	34	/*
	35	** Decode an UTF-8 sequence, returning NULL if byte sequence is invalid.
	36	*/
	37	static const char utf8_decode (const char o, int *val) {
	38	static unsigned int limits[] = {0xFF, 0x7F, 0x7FF, 0xFFFF};
	39	const unsigned char s = (const unsigned char )o;
	40	unsigned int c = s[0];
	41	unsigned int res = 0; /* final result */
	42	if (c < 0x80) /* ascii? */
	43	res = c;
	44	else {
	45	int count = 0; /* to count number of continuation bytes */
	46	while (c & 0x40) { /* still have continuation bytes? */
	47	int cc = s[++count]; /* read next byte */
	48	if ((cc & 0xC0) != 0x80) /* not a continuation byte? */
	49	return NULL; /* invalid byte sequence */
	50	res = (res << 6) \| (cc & 0x3F); /* add lower 6 bits from cont. byte */
	51	c <<= 1; /* to test next bit */
	52	}
	53	res \|= ((c & 0x7F) << (count * 5)); /* add first byte */
	54	if (count > 3 \|\| res > MAXUNICODE \|\| res <= limits[count])
	55	return NULL; /* invalid byte sequence */
	56	s += count; /* skip continuation bytes read */
	57	}
	58	if (val) *val = res;
	59	return (const char )s + 1; / +1 to include first byte */
	60	}
	61
	62
	63	/*
	64	** utf8len(s, [i]) --> number of codepoints in 's' after 'i';
	65	** nil if 's' not well formed
	66	*/
	67	static int utflen (lua_State *L) {
	68	int n = 0;
	69	const char *ends;
	70	size_t len;
	71	const char *s = luaL_checklstring(L, 1, &len);
	72	lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), 1);
	73	luaL_argcheck(L, 1 <= posi && posi <= (lua_Integer)len, 1,
	74	"initial position out of string");
	75	ends = s + len;
	76	s += posi - 1;
	77	while (s < ends && (s = utf8_decode(s, NULL)) != NULL)
	78	n++;
	79	if (s == ends)
	80	lua_pushinteger(L, n);
	81	else
	82	lua_pushnil(L);
	83	return 1;
	84	}
	85
	86
	87	/*
	88	** codepoint(s, [i, [j]]) -> returns codepoints for all characters
	89	** between i and j
	90	*/
	91	static int codepoint (lua_State *L) {
	92	size_t len;
	93	const char *s = luaL_checklstring(L, 1, &len);
	94	lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
	95	lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len);
	96	int n;
	97	const char *se;
	98	luaL_argcheck(L, posi >= 1, 2, "out of range");
	99	luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of range");
	100	if (posi > pose) return 0; /* empty interval; return no values */
	101	n = (int)(pose - posi + 1);
	102	if (posi + n <= pose) /* (lua_Integer -> int) overflow? */
	103	return luaL_error(L, "string slice too long");
	104	luaL_checkstack(L, n, "string slice too long");
	105	n = 0;
	106	se = s + pose;
	107	for (s += posi - 1; s < se;) {
	108	int code;
	109	s = utf8_decode(s, &code);
	110	if (s == NULL)
	111	return luaL_error(L, "invalid UTF-8 code");
	112	lua_pushinteger(L, code);
	113	n++;
	114	}
	115	return n;
	116	}
	117
	118
	119	static void pushutfchar (lua_State *L, int arg) {
	120	int code = luaL_checkint(L, arg);
	121	luaL_argcheck(L, 0 <= code && code <= MAXUNICODE, arg, "value out of range");
	122	lua_pushfstring(L, "%U", code);
	123	}
	124
	125
	126	/*
	127	** utfchar(n1, n2, ...) -> char(n1)..char(n2)...
	128	*/
	129	static int utfchar (lua_State *L) {
	130	int n = lua_gettop(L); /* number of arguments */
	131	if (n == 1) /* optimize common case of single char */
	132	pushutfchar(L, 1);
	133	else {
	134	int i;
	135	luaL_Buffer b;
	136	luaL_buffinit(L, &b);
	137	for (i = 1; i <= n; i++) {
	138	pushutfchar(L, i);
	139	luaL_addvalue(&b);
	140	}
	141	luaL_pushresult(&b);
	142	}
	143	return 1;
	144	}
	145
	146
	147	/*
	148	** offset(s, n, [i]) -> index where n-th character after
	149	** position 'i' starts; 0 means character at 'i'.
	150	*/
	151	static int byteoffset (lua_State *L) {
	152	size_t len;
	153	const char *s = luaL_checklstring(L, 1, &len);
	154	int n = luaL_checkint(L, 2);
	155	lua_Integer posi = u_posrelat(luaL_optinteger(L, 3, 1), len) - 1;
	156	luaL_argcheck(L, 0 <= posi && posi <= (lua_Integer)len, 3,
	157	"position out of range");
	158	if (n == 0) {
	159	/* find beginning of current byte sequence */
	160	while (posi > 0 && iscont(s + posi)) posi--;
	161	}
	162	else if (n < 0) {
	163	while (n < 0 && posi > 0) { /* move back */
	164	do { /* find beginning of previous character */
	165	posi--;
	166	} while (posi > 0 && iscont(s + posi));
	167	n++;
	168	}
	169	}
	170	else {
	171	n--; /* do not move for 1st character */
	172	while (n > 0 && posi < (lua_Integer)len) {
	173	do { /* find beginning of next character */
	174	posi++;
	175	} while (iscont(s + posi)); /* ('\0' is not continuation) */
	176	n--;
	177	}
	178	}
	179	if (n == 0)
	180	lua_pushinteger(L, posi + 1);
	181	else
	182	lua_pushnil(L); /* no such position */
	183	return 1;
	184	}
	185
	186
	187	static int iter_aux (lua_State *L) {
	188	size_t len;
	189	const char *s = luaL_checklstring(L, 1, &len);
	190	int n = lua_tointeger(L, 2) - 1;
	191	if (n < 0) /* first iteration? */
	192	n = 0; /* start from here */
	193	else if (n < (lua_Integer)len) {
	194	n++; /* skip current byte */
	195	while (iscont(s + n)) n++; /* and its continuations */
	196	}
	197	if (n >= (lua_Integer)len)
	198	return 0; /* no more codepoints */
	199	else {
	200	int code;
	201	const char *next = utf8_decode(s + n, &code);
	202	if (next == NULL \|\| iscont(next))
	203	return luaL_error(L, "invalid UTF-8 code");
	204	lua_pushinteger(L, n + 1);
	205	lua_pushinteger(L, code);
	206	return 2;
	207	}
	208	}
	209
	210
	211	static int iter_codes (lua_State *L) {
	212	luaL_checkstring(L, 1);
	213	lua_pushcfunction(L, iter_aux);
	214	lua_pushvalue(L, 1);
	215	lua_pushinteger(L, 0);
	216	return 3;
	217	}
	218
	219
	220	/* pattern to match a single UTF-8 character */
	221	#define UTF8PATT "[\0-\x7F\xC2-\xF4][\x80-\xBF]*"
	222
	223
	224	static struct luaL_Reg funcs[] = {
	225	{"offset", byteoffset},
	226	{"codepoint", codepoint},
	227	{"char", utfchar},
	228	{"len", utflen},
	229	{"codes", iter_codes},
	230	{NULL, NULL}
	231	};
	232
	233
	234	int luaopen_utf8 (lua_State *L) {
	235	luaL_newlib(L, funcs);
	236	lua_pushliteral(L, UTF8PATT);
	237	lua_setfield(L, -2, "charpatt");
	238	return 1;
	239	}
	240

src/lvm.c+125−56

 /*
-** $Id: lvm.c,v 2.175 2013/06/20 15:02:49 roberto Exp $
+** $Id: lvm.c,v 2.190 2014/03/15 12:29:48 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 /* limit for table tag-method chains (to avoid loops) */
-#define MAXTAGLOOP	100
+#define MAXTAGLOOP	2000
 /* maximum length of the conversion of a number to a string */
     return 0;
   else {
     char buff[MAXNUMBER2STR];
-    size_t len;
+    size_t len = (ttisinteger(obj))
-    if (ttisinteger(obj))
+                 ? lua_integer2str(buff, ivalue(obj))
-      len = lua_integer2str(buff, ivalue(obj));
+                 : lua_number2str(buff, fltvalue(obj));
-    else {
-      len = lua_number2str(buff, fltvalue(obj));
-      if (strspn(buff, "-0123456789") == len) {  /* look like an integer? */
-        buff[len++] = '.';  /* add a '.0' */
-        buff[len++] = '0';
-        buff[len] = '\0';
-      }
-    }
     setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
     return 1;
   }
 ** Check whether a float number is within the range of a lua_Integer.
 ** (The comparisons are tricky because of rounding, which can or
 ** not occur depending on the relative sizes of floats and integers.)
-** This function is called only when 'n' has an integer value.
+** This function should be called only when 'n' has an integral value.
 */
 int luaV_numtointeger (lua_Number n, lua_Integer *p) {
   if (cast_num(MIN_INTEGER) <= n && n < (MAX_INTEGER + cast_num(1))) {
     }
     t = tm;  /* else repeat with 'tm' */
   }
-  luaG_runerror(L, "loop in gettable");
+  luaG_runerror(L, "gettable chain too long; possible loop");
 }
         /* no metamethod and (now) there is an entry with given key */
         setobj2t(L, oldval, val);  /* assign new value to that entry */
         invalidateTMcache(h);
-        luaC_barrierback(L, obj2gco(h), val);
+        luaC_barrierback(L, h, val);
         return;
       }
       /* else will try the metamethod */
     }
     t = tm;  /* else repeat with 'tm' */
   }
-  luaG_runerror(L, "loop in settable");
+  luaG_runerror(L, "settable chain too long; possible loop");
 }
   if (ttisinteger(l) && ttisinteger(r))
     return (ivalue(l) < ivalue(r));
   else if (tonumber(l, &nl) && tonumber(r, &nr))
-    return luai_numlt(L, nl, nr);
+    return luai_numlt(nl, nr);
   else if (ttisstring(l) && ttisstring(r))
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0)
   if (ttisinteger(l) && ttisinteger(r))
     return (ivalue(l) <= ivalue(r));
   else if (tonumber(l, &nl) && tonumber(r, &nr))
-    return luai_numle(L, nl, nr);
+    return luai_numle(nl, nr);
   else if (ttisstring(l) && ttisstring(r))
     return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
   else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0)  /* first try `le' */
     else {  /* two numbers with different variants */
       lua_Number n1, n2;
       lua_assert(ttisnumber(t1) && ttisnumber(t2));
-      (void)tonumber(t1, &n1); (void)tonumber(t2, &n2);
+      cast_void(tonumber(t1, &n1)); cast_void(tonumber(t2, &n2));
       return luai_numeq(n1, n2);
     }
   }
     if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1))
       luaT_trybinTM(L, top-2, top-1, top-2, TM_CONCAT);
     else if (tsvalue(top-1)->len == 0)  /* second operand is empty? */
-      (void)tostring(L, top - 2);  /* result is first operand */
+      cast_void(tostring(L, top - 2));  /* result is first operand */
     else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) {
       setobjs2s(L, top - 2, top - 1);  /* result is second op. */
     }
   if (cast_unsigned(y) + 1 <= 1U) {  /* special cases: -1 or 0 */
     if (y == 0)
       luaG_runerror(L, "attempt to divide by zero");
-    else  /* -1 */
+    return intop(-, 0, x);   /* y==-1; avoid overflow with 0x80000...//-1 */
-      return -x;   /* avoid overflow with 0x80000... */
   }
   else {
     lua_Integer d = x / y;  /* perform division */
   if (cast_unsigned(y) + 1 <= 1U) {  /* special cases: -1 or 0 */
     if (y == 0)
       luaG_runerror(L, "attempt to perform 'n%%0'");
-    else  /* -1 */
+    return 0;   /* y==-1; avoid overflow with 0x80000...%-1 */
-      return 0;   /* avoid overflow with 0x80000... */
   }
   else {
     lua_Integer r = x % y;
 }
-lua_Integer luaV_pow (lua_Integer x, lua_Integer y) {
+lua_Integer luaV_pow (lua_State *L, lua_Integer x, lua_Integer y) {
-  lua_Integer r = 1;
+  if (y <= 0) {  /* special cases: 0 or negative exponent */
-  lua_assert(y >= 0);
+    if (y < 0)
-  if (y == 0) return r;
+      luaG_runerror(L, "integer exponentiation with negative exponent");
-  for (; y > 1; y >>= 1) {
+    return 1;  /* x^0 == 1 */
-    if (y & 1) r = intop(*, r, x);
+  }
-    x = intop(*, x, x);
+  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) {
+  if (y < 0) {  /* shift right? */
+    if (y <= -NBITS) return 0;
+    else return cast_integer(cast_unsigned(x) >> (-y));
+  }
+  else {  /* shift left */
+    if (y >= NBITS) return 0;
+    else return x << y;
   }
-  r = intop(*, r, x);
-  return r;
 }
 /*
 ** create a new Lua closure, push it in the stack, and initialize
-** its upvalues. Note that the call to 'luaC_barrierproto' must come
+** its upvalues. Note that the closure is not cached if prototype is
-** before the assignment to 'p->cache', as the function needs the
+** already black (which means that 'cache' was already cleared by the
-** original value of that field.
+** GC).
 */
 static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
                          StkId ra) {
       ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx);
     else  /* get upvalue from enclosing function */
       ncl->l.upvals[i] = encup[uv[i].idx];
+    ncl->l.upvals[i]->refcount++;
+    /* new closure is white, so we do not need a barrier here */
   }
-  luaC_barrierproto(L, p, ncl);
+  if (!isblack(obj2gco(p)))  /* cache will not break GC invariant? */
-  p->cache = ncl;  /* save it on cache for reuse */
+    p->cache = ncl;  /* save it on cache for reuse */
 }
   OpCode op = GET_OPCODE(inst);
   switch (op) {  /* finish its execution */
     case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_IDIV:
-    case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN:
+    case OP_BAND: case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR:
+    case OP_MOD: case OP_POW:
+    case OP_UNM: case OP_BNOT: case OP_LEN:
     case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: {
       setobjs2s(L, base + GETARG_A(inst), --L->top);
       break;
       vmcase(OP_SETUPVAL,
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
-        luaC_barrier(L, uv, ra);
+        luaC_upvalbarrier(L, uv);
       )
       vmcase(OP_SETTABLE,
         Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
         }
         else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_IDIV)); }
       )
+      vmcase(OP_BAND,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, intop(&, ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BAND)); }
+      )
+      vmcase(OP_BOR,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, intop(|, ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BOR)); }
+      )
+      vmcase(OP_BXOR,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, intop(^, ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BXOR)); }
+      )
+      vmcase(OP_SHL,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, luaV_shiftl(ib, ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHL)); }
+      )
+      vmcase(OP_SHR,
+        TValue *rb = RKB(i);
+        TValue *rc = RKC(i);
+        lua_Integer ib; lua_Integer ic;
+        if (tointeger(rb, &ib) && tointeger(rc, &ic)) {
+          setivalue(ra, luaV_shiftl(ib, -ic));
+        }
+        else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHR)); }
+      )
       vmcase(OP_MOD,
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         lua_Number nb; lua_Number nc;
-        lua_Integer ic;
+        if (ttisinteger(rb) && ttisinteger(rc)) {
-        if (ttisinteger(rb) && ttisinteger(rc) &&
+          lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc);
-            (ic = ivalue(rc)) >= 0) {
+          setivalue(ra, luaV_pow(L, ib, ic));
-          lua_Integer ib = ivalue(rb);
-          setivalue(ra, luaV_pow(ib, ic));
         }
         else if (tonumber(rb, &nb) && tonumber(rc, &nc)) {
           setnvalue(ra, luai_numpow(L, nb, nc));
         lua_Number nb;
         if (ttisinteger(rb)) {
           lua_Integer ib = ivalue(rb);
-          setivalue(ra, -ib);
+          setivalue(ra, intop(-, 0, ib));
         }
         else if (tonumber(rb, &nb)) {
           setnvalue(ra, luai_numunm(L, nb));
           Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
         }
       )
+      vmcase(OP_BNOT,
+        TValue *rb = RB(i);
+        lua_Integer ib;
+        if (tointeger(rb, &ib)) {
+          setivalue(ra, intop(^, cast_integer(-1), ib));
+        }
+        else {
+          Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
+        }
+      )
       vmcase(OP_NOT,
         TValue *rb = RB(i);
         int res = l_isfalse(rb);  /* next assignment may change this value */
         }
       )
       vmcase(OP_FORLOOP,
-        if (ttisinteger(ra)) {  /* integer count? */
+        if (ttisinteger(ra)) {  /* integer loop? */
           lua_Integer step = ivalue(ra + 2);
           lua_Integer idx = ivalue(ra) + step; /* increment index */
           lua_Integer limit = ivalue(ra + 1);
             setivalue(ra + 3, idx);  /* ...and external index */
           }
         }
-        else {  /* floating count */
+        else {  /* floating loop */
           lua_Number step = fltvalue(ra + 2);
           lua_Number idx = luai_numadd(L, fltvalue(ra), step); /* inc. index */
           lua_Number limit = fltvalue(ra + 1);
-          if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit)
+          if (luai_numlt(0, step) ? luai_numle(idx, limit)
-                                     : luai_numle(L, limit, idx)) {
+                                  : luai_numle(limit, idx)) {
             ci->u.l.savedpc += GETARG_sBx(i);  /* jump back */
             setnvalue(ra, idx);  /* update internal index... */
             setnvalue(ra + 3, idx);  /* ...and external index */
         TValue *init = ra;
         TValue *plimit = ra + 1;
         TValue *pstep = ra + 2;
-        if (ttisinteger(ra) && ttisinteger(ra + 1) && ttisinteger(ra + 2)) {
+        if (ttisinteger(init) && ttisinteger(plimit) && ttisinteger(pstep)) {
-          setivalue(ra, ivalue(ra) - ivalue(pstep));
+          /* all values are integer */
+          setivalue(init, ivalue(init) - ivalue(pstep));
         }
-        else {  /* try with floats */
+        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(pstep, nstep);
           if (!tonumber(init, &ninit))
             luaG_runerror(L, LUA_QL("for") " initial value must be a number");
-          setnvalue(ra, luai_numsub(L, ninit, nstep));
+          setnvalue(init, luai_numsub(L, ninit, nstep));
         }
         ci->u.l.savedpc += GETARG_sBx(i);
       )
         for (; n > 0; n--) {
           TValue *val = ra+n;
           luaH_setint(L, h, last--, val);
-          luaC_barrierback(L, obj2gco(h), val);
+          luaC_barrierback(L, h, val);
         }
         L->top = ci->top;  /* correct top (in case of previous open call) */
       )

src/lvm.h+3−2

 /*
-** $Id: lvm.h,v 2.23 2013/05/02 12:31:26 roberto Exp $
+** $Id: lvm.h,v 2.25 2013/12/30 20:47:58 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 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_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);
 #endif

src/lzio.h+2−1

 /*
-** $Id: lzio.h,v 1.27 2013/06/07 14:51:10 roberto Exp $
+** $Id: lzio.h,v 1.28 2014/01/31 15:14:22 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
 #define luaZ_sizebuffer(buff)	((buff)->buffsize)
 #define luaZ_bufflen(buff)	((buff)->n)
+#define luaZ_buffremove(buff,i)	((buff)->n -= (i))
 #define luaZ_resetbuffer(buff) ((buff)->n = 0)

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lauxlib.h,v 1.122 2013/06/27 18:32:33 roberto Exp $	2	** $Id: lauxlib.h,v 1.123 2014/01/05 14:04:46 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	*/
@@ -35,24 +35,24 @@ LUALIB_API void (luaL_checkversion_) (lua_State *L, int ver, size_t sz); · 29 unmodified lines
35	LUALIB_API int (luaL_getmetafield) (lua_State L, int obj, const char e);	35	LUALIB_API int (luaL_getmetafield) (lua_State L, int obj, const char e);
36	LUALIB_API int (luaL_callmeta) (lua_State L, int obj, const char e);	36	LUALIB_API int (luaL_callmeta) (lua_State L, int obj, const char e);
37	LUALIB_API const char (luaL_tolstring) (lua_State L, int idx, size_t *len);	37	LUALIB_API const char (luaL_tolstring) (lua_State L, int idx, size_t *len);
38	LUALIB_API int (luaL_argerror) (lua_State L, int numarg, const char extramsg);	38	LUALIB_API int (luaL_argerror) (lua_State L, int arg, const char extramsg);
39	LUALIB_API const char (luaL_checklstring) (lua_State L, int numArg,	39	LUALIB_API const char (luaL_checklstring) (lua_State L, int arg,
40	size_t *l);	40	size_t *l);
41	LUALIB_API const char (luaL_optlstring) (lua_State L, int numArg,	41	LUALIB_API const char (luaL_optlstring) (lua_State L, int arg,
42	const char def, size_t l);	42	const char def, size_t l);
43	LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);	43	LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
44	LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);	44	LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
45		45
46	LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);	46	LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
47	LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,	47	LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
48	lua_Integer def);	48	lua_Integer def);
49	LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);	49	LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int arg);
50	LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,	50	LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int arg,
51	lua_Unsigned def);	51	lua_Unsigned def);
52		52
53	LUALIB_API void (luaL_checkstack) (lua_State L, int sz, const char msg);	53	LUALIB_API void (luaL_checkstack) (lua_State L, int sz, const char msg);
54	LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);	54	LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
55	LUALIB_API void (luaL_checkany) (lua_State *L, int narg);	55	LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
56		56
57	LUALIB_API int (luaL_newmetatable) (lua_State L, const char tname);	57	LUALIB_API int (luaL_newmetatable) (lua_State L, const char tname);
58	LUALIB_API void (luaL_setmetatable) (lua_State L, const char tname);	58	LUALIB_API void (luaL_setmetatable) (lua_State L, const char tname);
@@ -62,7 +62,7 @@ LUALIB_API void (luaL_checkudata) (lua_State L, int ud, const char *tname); · 3 unmodified lines
62	LUALIB_API void (luaL_where) (lua_State *L, int lvl);	62	LUALIB_API void (luaL_where) (lua_State *L, int lvl);
63	LUALIB_API int (luaL_error) (lua_State L, const char fmt, ...);	63	LUALIB_API int (luaL_error) (lua_State L, const char fmt, ...);
64		64
65	LUALIB_API int (luaL_checkoption) (lua_State L, int narg, const char def,	65	LUALIB_API int (luaL_checkoption) (lua_State L, int arg, const char def,
66	const char *const lst[]);	66	const char *const lst[]);
67		67
68	LUALIB_API int (luaL_fileresult) (lua_State L, int stat, const char fname);	68	LUALIB_API int (luaL_fileresult) (lua_State L, int stat, const char fname);
@@ -114,8 +114,8 @@ LUALIB_API void (luaL_requiref) (lua_State L, const char modname, · 45 unmodified lines
114	#define luaL_newlib(L,l) \	114	#define luaL_newlib(L,l) \
115	(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))	115	(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
116		116
117	#define luaL_argcheck(L, cond,numarg,extramsg) \	117	#define luaL_argcheck(L, cond,arg,extramsg) \
118	((void)((cond) \|\| luaL_argerror(L, (numarg), (extramsg))))	118	((void)((cond) \|\| luaL_argerror(L, (arg), (extramsg))))
119	#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))	119	#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
120	#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))	120	#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
121	#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))	121	#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))