summaryloggraphiclog1graphiclog2commitcommitdifftreerefseditfork
rawpatchinlineside by side (parent: 89275cc)
rawpatchinlineside by side (parent: 89275cc)
| author | Lua Team <[email protected]> | |
| Tue, 25 Nov 2003 18:33:28 +0000 (25 18:33 +0000) | ||
| committer | Lua Team <[email protected]> | |
| Tue, 25 Nov 2003 18:33:28 +0000 (25 18:33 +0000) |
15 files changed:
diff --git a/DIFFS b/DIFFS
--- /dev/null
+++ b/DIFFS
@@ -0,0 +1,623 @@
+diff -r lua-5.0/doc/manual.html lua-5.0.1/doc/manual.html
+5c5
+< <title>Lua 5.0 Reference Manual</title>
+---
+> <TITLE>Lua: 5.0 reference manual</TITLE>
+12,14c12
+< <a HREF="http://www.lua.org/home.html">
+< <img SRC="logo.gif" ALT="[Lua logo]" BORDER=0>
+< </a>
+---
+> <A HREF="http://www.lua.org/home.html"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
+22c20
+< © 2003 TeCGraf, PUC-Rio. All rights reserved.
+---
+> © 2003 Tecgraf, PUC-Rio. All rights reserved.
+32c30
+< <h1>1 - Introduction</h1>
+---
+> <a name="1"><h1>1 - Introduction</h1></a>
+37c35
+< It also offers good suport for object-oriented programming,
+---
+> It also offers good support for object-oriented programming,
+54c52
+< <p>The Lua distribuition includes a stand-alone embedding program,
+---
+> <p>The Lua distribution includes a stand-alone embedding program,
+90c88
+< <a name="language"><h1>2 - The Language</h1></a>
+---
+> <a name="language"><a name="2"><h1>2 - The Language</h1></a></a>
+108c106
+< <p><a name="lexical"><h2>2.1 - Lexical Conventions</h2></a>
+---
+> <p><a name="lexical"><a name="2.1"><h2>2.1 - Lexical Conventions</h2></a></a>
+125,126c123
+< repeat return then true until
+< while
+---
+> repeat return then true until while
+214c211
+< <p><a name="TypesSec"><h2>2.2 - Values and Types</h2></a>
+---
+> <p><a name="TypesSec"><a name="2.2"><h2>2.2 - Values and Types</h2></a></a>
+295c292
+< <p><a name="coercion"><h3>2.2.1 - Coercion</h3></a>
+---
+> <p><a name="coercion"><a name="2.2.1"><h3>2.2.1 - Coercion</h3></a></a>
+306c303
+< <p><a name="variables"><h2>2.3 - Variables</h2></a>
+---
+> <p><a name="variables"><a name="2.3"><h2>2.3 - Variables</h2></a></a>
+375c372
+< <p><a name="stats"><h2>2.4 - Statements</h2></a>
+---
+> <p><a name="stats"><a name="2.4"><h2>2.4 - Statements</h2></a></a>
+383c380
+< <p><a name="chunks"><h3>2.4.1 - Chunks</h3></a>
+---
+> <p><a name="chunks"><a name="2.4.1"><h3>2.4.1 - Chunks</h3></a></a>
+408c405
+< <p><h3>2.4.2 - Blocks</h3>
+---
+> <p><a name="2.4.2"><h3>2.4.2 - Blocks</h3></a>
+426c423
+< <p><a name="assignment"><h3>2.4.3 - Assignment</h3></a>
+---
+> <p><a name="assignment"><a name="2.4.3"><h3>2.4.3 - Assignment</h3></a></a>
+461c458
+< before it is assigned 4.
+---
+> before it is assigned 4.
+488c485
+< <p><a name="control"><h3>2.4.4 - Control Structures</h3></a>
+---
+> <p><a name="control"><a name="2.4.4"><h3>2.4.4 - Control Structures</h3></a></a>
+519c516
+< skiping to the next statement after the loop:
+---
+> skipping to the next statement after the loop:
+539c536
+< <p><a name="for"><h3>2.4.5 - For Statement</h3></a>
+---
+> <p><a name="for"><a name="2.4.5"><h3>2.4.5 - For Statement</h3></a></a>
+626c623
+< <p><a name="funcstat"><h3>2.4.6 - Function Calls as Statements</h3></a>
+---
+> <p><a name="funcstat"><a name="2.4.6"><h3>2.4.6 - Function Calls as Statements</h3></a></a>
+635c632
+< <p><a name="localvar"><h3>2.4.7 - Local Declarations</h3></a>
+---
+> <p><a name="localvar"><a name="2.4.7"><h3>2.4.7 - Local Declarations</h3></a></a>
+652c649
+< <p><a name="expressions"><h2>2.5 - Expressions</h2></a>
+---
+> <p><a name="expressions"><a name="2.5"><h2>2.5 - Expressions</h2></a></a>
+683c680
+< <p><h3>2.5.1 - Arithmetic Operators</h3>
+---
+> <p><a name="2.5.1"><h3>2.5.1 - Arithmetic Operators</h3></a>
+698c695
+< <p><a name="rel-ops"><h3>2.5.2 - Relational Operators</h3></a>
+---
+> <p><a name="rel-ops"><a name="2.5.2"><h3>2.5.2 - Relational Operators</h3></a></a>
+734c731
+< <p><h3>2.5.3 - Logical Operators</h3>
+---
+> <p><a name="2.5.3"><h3>2.5.3 - Logical Operators</h3></a>
+767c764
+< <p><a name="concat"><h3>2.5.4 - Concatenation</h3></a>
+---
+> <p><a name="concat"><a name="2.5.4"><h3>2.5.4 - Concatenation</h3></a></a>
+774c771
+< <p><h3>2.5.5 - Precedence</h3>
+---
+> <p><a name="2.5.5"><h3>2.5.5 - Precedence</h3></a>
+787c784
+< As usual, you can use parentheses to change the precedences of an expression.
+---
+> You can use parentheses to change the precedences in an expression.
+792c789
+< <p><a name="tableconstructor"><h3>2.5.6 - Table Constructors</h3></a>
+---
+> <p><a name="tableconstructor"><a name="2.5.6"><h3>2.5.6 - Table Constructors</h3></a></a>
+842c839
+< <p><a name="functioncall"><h3>2.5.7 - Function Calls</h3></a>
+---
+> <p><a name="functioncall"><a name="2.5.7"><h3>2.5.7 - Function Calls</h3></a></a>
+947c944
+< return x, f(x) -- adicional results
+---
+> return x, f(x) -- additional results
+952c949
+< <p><a name="func-def"><h3>2.5.8 - Function Definitions</h3></a>
+---
+> <p><a name="func-def"><a name="2.5.8"><h3>2.5.8 - Function Definitions</h3></a></a>
+1061c1058
+< <p><a name="visibility"><h2>2.6 - Visibility Rules</h2></a>
+---
+> <p><a name="visibility"><a name="2.6"><h2>2.6 - Visibility Rules</h2></a></a>
+1118c1115
+< <p><a name="error"><h2>2.7 - Error Handling</h2></a>
+---
+> <p><a name="error"><a name="2.7"><h2>2.7 - Error Handling</h2></a></a>
+1133c1130
+< <p><a name="metatable"><h2>2.8 - Metatables</h2></a>
+---
+> <p><a name="metatable"><a name="2.8"><h2>2.8 - Metatables</h2></a></a>
+1315c1312
+< if type(op1) ~= type(op2) then -- diferent types?
+---
+> if type(op1) ~= type(op2) then -- different types?
+1443c1440
+< <p><a name="GC"><h2>2.9 - Garbage Collection</h2></a>
+---
+> <p><a name="GC"><a name="2.9"><h2>2.9 - Garbage Collection</h2></a></a>
+1474c1471
+< <p><h3>2.9.1 - Garbage-Collection Metamethods</h3>
+---
+> <p><a name="2.9.1"><h3>2.9.1 - Garbage-Collection Metamethods</h3></a>
+1506c1503
+< <p><a name="weak-table"><h3>2.9.2 - Weak Tables</h3></a>
+---
+> <p><a name="weak-table"><a name="2.9.2"><h3>2.9.2 - Weak Tables</h3></a></a>
+1524c1521
+< If the <code>__mode</code> field is a string containing the character `<code>k</code>´,
+---
+> If the <code>__mode</code> field is a string containing the character `<code>k</code>´,
+1534c1531
+< <p><a name="coroutine"><h2>2.10 - Coroutines</h2></a>
+---
+> <p><a name="coroutine"><a name="2.10"><h2>2.10 - Coroutines</h2></a></a>
+1552c1549
+< passing as argument the thread returned by <code>coroutine.create</code>,
+---
+> passing as its first argument the thread returned by <code>coroutine.create</code>,
+1633c1630
+< <a name="API"><h1>3 - The Application Program Interface</h1></a>
+---
+> <a name="API"><a name="3"><h1>3 - The Application Program Interface</h1></a></a>
+1648c1645
+< <p><a name="mangstate"><h2>3.1 - States</h2></a>
+---
+> <p><a name="mangstate"><a name="3.1"><h2>3.1 - States</h2></a></a>
+1684c1681
+< <p><h2>3.2 - The Stack and Indices</h2>
+---
+> <p><a name="3.2"><h2>3.2 - The Stack and Indices</h2></a>
+1694c1691
+< and it is where the C function pushes its results (see <a href="#LuacallC">3.16</a>)
+---
+> and it is where the C function pushes its results to be returned to the caller (see <a href="#LuacallC">3.16</a>)
+1739c1736
+< it ensures that at least <code>LUA_MINSTACK</code> positions are available.
+---
+> it ensures that at least <code>LUA_MINSTACK</code> stack positions are available.
+1763c1760
+< <p><h2>3.3 - Stack Manipulation</h2>
+---
+> <p><a name="3.3"><h2>3.3 - Stack Manipulation</h2></a>
+1816c1813
+< <p><h2>3.4 - Querying the Stack</h2>
+---
+> <p><a name="3.4"><h2>3.4 - Querying the Stack</h2></a>
+1890c1887
+< <p><a name="lua-to"><h2>3.5 - Getting Values from the Stack</h2></a>
+---
+> <p><a name="lua-to"><a name="3.5"><h2>3.5 - Getting Values from the Stack</h2></a></a>
+1969c1966
+< <p><a name="pushing"><h2>3.6 - Pushing Values onto the Stack</h2></a>
+---
+> <p><a name="pushing"><a name="3.6"><h2>3.6 - Pushing Values onto the Stack</h2></a></a>
+1999,2000c1996
+< const char *lua_pushvfstring (lua_State *L, const char *fmt,
+< va_list argp);
+---
+> const char *lua_pushvfstring (lua_State *L, const char *fmt, va_list argp);
+2028c2024
+< If <code>n</code> is 1, the result is that single string
+---
+> If <code>n</code> is 1, the result is that single string
+2034c2030
+< <p><a name="GC-API"><h2>3.7 - Controlling Garbage Collection</h2></a>
+---
+> <p><a name="GC-API"><a name="3.7"><h2>3.7 - Controlling Garbage Collection</h2></a></a>
+2047c2043
+< int lua_getgccount (lua_State *L);
+---
+> int lua_getgccount (lua_State *L);
+2067c2063
+< <p><a name="userdata"><h2>3.8 - Userdata</h2></a>
+---
+> <p><a name="userdata"><a name="3.8"><h2>3.8 - Userdata</h2></a></a>
+2112c2108
+< <p><h2>3.9 - Metatables</h2>
+---
+> <p><a name="3.9"><h2>3.9 - Metatables</h2></a>
+2133c2129
+< <p><h2>3.10 - Loading Lua Chunks</h2>
+---
+> <p><a name="3.10"><h2>3.10 - Loading Lua Chunks</h2></a>
+2160c2156
+< <p><code>lua_load</code> uses an user-supplied <em>reader</em> function to read the chunk.
+---
+> <p><code>lua_load</code> uses a user-supplied <em>reader</em> function to read the chunk.
+2162c2158
+< it calls the reader,
+---
+> <code>lua_load</code> calls the reader,
+2182c2178
+< <p><h2>3.11 - Manipulating Tables</h2>
+---
+> <p><a name="3.11"><h2>3.11 - Manipulating Tables</h2></a>
+2263c2259
+< <p><a name="globals"><h2>3.12 - Manipulating Environments</h2></a>
+---
+> <p><a name="globals"><a name="3.12"><h2>3.12 - Manipulating Environments</h2></a></a>
+2295c2291
+< <p><h2>3.13 - Using Tables as Arrays</h2>
+---
+> <p><a name="3.13"><h2>3.13 - Using Tables as Arrays</h2></a>
+2312c2308
+< <p><h2>3.14 - Calling Functions</h2>
+---
+> <p><a name="3.14"><h2>3.14 - Calling Functions</h2></a>
+2367c2363
+< <p><a name="lua_pcall"><h2>3.15 - Protected Calls</h2></a>
+---
+> <p><a name="lua_pcall"><a name="3.15"><h2>3.15 - Protected Calls</h2></a></a>
+2414c2410
+< <p><a name="LuacallC"><h2>3.16 - Defining C Functions</h2></a>
+---
+> <p><a name="LuacallC"><a name="3.16"><h2>3.16 - Defining C Functions</h2></a></a>
+2482c2478
+< <p><a name="c-closure"><h2>3.17 - Defining C Closures</h2></a>
+---
+> <p><a name="c-closure"><a name="3.17"><h2>3.17 - Defining C Closures</h2></a></a>
+2517c2513
+< <p><a name="registry"><h2>3.18 - Registry</h2></a>
+---
+> <p><a name="registry"><a name="3.18"><h2>3.18 - Registry</h2></a></a>
+2535c2531
+< <p><h2>3.19 - Error Handling in C</h2>
+---
+> <p><a name="3.19"><h2>3.19 - Error Handling in C</h2></a>
+2542,2543c2538,2539
+< to set a recover point,
+< and any error jumps to the most recent active recover point.
+---
+> to set a recover point;
+> any error jumps to the most recent active recover point.
+2546c2542
+< Lua calls a <em>panic function</em>,
+---
+> Lua calls a <em>panic function</em>
+2553,2554c2549,2550
+< never returning (e.g. doing a long jump).
+< Nevertheless, the corresponding Lua will not be consistent;
+---
+> never returning (e.g., by doing a long jump).
+> Nevertheless, the corresponding Lua state will not be consistent;
+2578c2574
+< Any value returned by <code>func</code> is dicarded.
+---
+> Any value returned by <code>func</code> is discarded.
+2590c2586
+< <p><h2>3.20 - Threads</h2>
+---
+> <p><a name="3.20"><h2>3.20 - Threads</h2></a>
+2611,2616c2607,2609
+< <p>You destroy threads with <code>lua_closethread</code>:
+< <PRE>
+< void lua_closethread (lua_State *L, lua_State *thread);
+< </PRE>
+< You cannot close the sole (or last) thread of a state.
+< Instead, you must close the state itself.
+---
+> <p>There is no explicit function to close or to destroy a thread.
+> Threads are subject to garbage collection,
+> like any Lua object.
+2622c2615
+< int lua_yield (lua_State *L, int nresults);
+---
+> int lua_yield (lua_State *L, int nresults);
+2632c2625
+< <code>lua_resume</code> returns 0 if there is no errors running the coroutine,
+---
+> <code>lua_resume</code> returns 0 if there are no errors running the coroutine,
+2660c2653
+< <a name="debugI"><h1>4 - The Debug Interface</h1></a>
+---
+> <a name="debugI"><a name="4"><h1>4 - The Debug Interface</h1></a></a>
+2669c2662
+< <p><h2>4.1 - Stack and Function Information</h2>
+---
+> <p><a name="4.1"><h2>4.1 - Stack and Function Information</h2></a>
+2681c2674
+< When there is no errors, <code>lua_getstack</code> returns 1;
+---
+> When there are no errors, <code>lua_getstack</code> returns 1;
+2789c2782
+< <p><h2>4.2 - Manipulating Local Variables and Upvalues</h2>
+---
+> <p><a name="4.2"><h2>4.2 - Manipulating Local Variables and Upvalues</h2></a>
+2866c2859
+< <p><a name="sub-hooks"><h2>4.3 - Hooks</h2></a>
+---
+> <p><a name="sub-hooks"><a name="4.3"><h2>4.3 - Hooks</h2></a></a>
+2942c2935
+< <a name="libraries"><h1>5 - Standard Libraries</h1></a>
+---
+> <a name="libraries"><a name="5"><h1>5 - Standard Libraries</h1></a></a>
+2985c2978
+< <p><a name="predefined"><h2>5.1 - Basic Functions</h2></a>
+---
+> <p><a name="predefined"><a name="5.1"><h2>5.1 - Basic Functions</h2></a></a>
+3018c3011
+< Terminates the last protected function called,
+---
+> Terminates the last protected function called
+3046c3039
+< <p>if the environment has a <code>"__fenv"</code> field,
+---
+> <p>If the environment has a <code>"__fenv"</code> field,
+3151c3144
+< That means that any error inside <code>f</code> is not propagated;
+---
+> That means that any error inside <code>f</code> is not propagated;
+3155c3148
+< which is true if the call succeeds without errors.
+---
+> which is <B>true</B> if the call succeeds without errors.
+3330c3323
+< <p><h2>5.2 - Coroutine Manipulation</h2>
+---
+> <p><a name="5.2"><h2>5.2 - Coroutine Manipulation</h2></a>
+3333c3326
+< the basic library, and come inside the table .
+---
+> the basic library and come inside the table <code>coroutine</code>.
+3388c3381
+< <p><h2>5.3 - String Manipulation</h2>
+---
+> <p><a name="5.3"><h2>5.3 - String Manipulation</h2></a>
+3595c3588
+< a <em>character class</em> is used to represent a set of characters.
+---
+> A <em>character class</em> is used to represent a set of characters.
+3651c3644
+< a <em>pattern item</em> may be
+---
+> A <em>pattern item</em> may be
+3688c3681
+< a <em>pattern</em> is a sequence of pattern items.
+---
+> A <em>pattern</em> is a sequence of pattern items.
+3715c3708
+< <p><h2>5.4 - Table Manipulation</h2>
+---
+> <p><a name="5.4"><h2>5.4 - Table Manipulation</h2></a>
+3824c3817
+< <p><a name="mathlib"><h2>5.5 - Mathematical Functions</h2></a>
+---
+> <p><a name="mathlib"><a name="5.5"><h2>5.5 - Mathematical Functions</h2></a></a>
+3879c3872
+< <p><a name="libio"><h2>5.6 - Input and Output Facilities</h2></a>
+---
+> <p><a name="libio"><a name="5.6"><h2>5.6 - Input and Output Facilities</h2></a></a>
+4072c4065
+< <p><a name="libiosys"><h2>5.7 - Operating System Facilities</h2></a>
+---
+> <p><a name="libiosys"><a name="5.7"><h2>5.7 - Operating System Facilities</h2></a></a>
+4098c4091
+< <code>wday</code> (weekday, Sunday is 1),
+---
+> <code>wday</code> (weekday, Sunday is 1),
+4187c4180
+< <p><h2>5.8 - The Reflexive Debug Interface</h2>
+---
+> <p><a name="5.8"><h2>5.8 - The Reflexive Debug Interface</h2></a>
+4323c4316
+< <a name="lua-sa"><h1>6 - Lua Stand-alone</h1></a>
+---
+> <a name="lua-sa"><a name="6"><h1>6 - Lua Stand-alone</h1></a></a>
+4462c4455
+< Vincent Penquerc'h,
+---
+> Vincent Penquerc'h.
+4583c4576
+< <p> exp ::= <b>nil</b> <b>false</b> <b>true</b> | Number | Literal | function | prefixexp | tableconstructor | exp binop exp | unop exp
+---
+> <p> exp ::= <b>nil</b> | <b>false</b> | <b>true</b> | Number | Literal | function | prefixexp | tableconstructor | exp binop exp | unop exp
+4612c4605,4609
+< </body></html>
+---
+> <HR>
+> <SMALL>
+> Last update:
+> Tue Nov 25 16:08:37 BRST 2003
+> </SMALL>
+4613a4611,4612
+> </BODY>
+> </HTML>
+diff -r lua-5.0/include/lua.h lua-5.0.1/include/lua.h
+2c2
+< ** $Id: lua.h,v 1.175 2003/03/18 12:31:39 roberto Exp $
+---
+> ** $Id: lua.h,v 1.175a 2003/03/18 12:31:39 roberto Exp $
+17c17
+< #define LUA_VERSION "Lua 5.0"
+---
+> #define LUA_VERSION "Lua 5.0.1"
+diff -r lua-5.0/src/ldo.c lua-5.0.1/src/ldo.c
+2c2
+< ** $Id: ldo.c,v 1.217 2003/04/03 13:35:34 roberto Exp $
+---
+> ** $Id: ldo.c,v 1.217a 2003/04/03 13:35:34 roberto Exp $
+325,326c325
+< if (nargs >= L->top - L->base)
+< luaG_runerror(L, "cannot resume dead coroutine");
+---
+> lua_assert(nargs < L->top - L->base);
+329c328,329
+< else if (ci->state & CI_YIELD) { /* inside a yield? */
+---
+> else { /* inside a yield */
+> lua_assert(ci->state & CI_YIELD);
+344,345d343
+< else
+< luaG_runerror(L, "cannot resume non-suspended coroutine");
+351a350,358
+> static int resume_error (lua_State *L, const char *msg) {
+> L->top = L->ci->base;
+> setsvalue2s(L->top, luaS_new(L, msg));
+> incr_top(L);
+> lua_unlock(L);
+> return LUA_ERRRUN;
+> }
+>
+>
+355a363,368
+> if (L->ci == L->base_ci) {
+> if (nargs >= L->top - L->base)
+> return resume_error(L, "cannot resume dead coroutine");
+> }
+> else if (!(L->ci->state & CI_YIELD)) /* not inside a yield? */
+> return resume_error(L, "cannot resume non-suspended coroutine");
+diff -r lua-5.0/src/lgc.c lua-5.0.1/src/lgc.c
+2c2
+< ** $Id: lgc.c,v 1.171 2003/04/03 13:35:34 roberto Exp $
+---
+> ** $Id: lgc.c,v 1.171a 2003/04/03 13:35:34 roberto Exp $
+113c113,114
+< void luaC_separateudata (lua_State *L) {
+---
+> size_t luaC_separateudata (lua_State *L) {
+> size_t deadmem = 0;
+127a129
+> deadmem += sizeudata(gcotou(curr)->uv.len);
+136a139
+> return deadmem;
+247c250
+< if (!(ci->state & CI_C) && lim < ci->top)
+---
+> if (lim < ci->top)
+390c393
+< static void checkSizes (lua_State *L) {
+---
+> static void checkSizes (lua_State *L, size_t deadmem) {
+400c403
+< G(L)->GCthreshold = 2*G(L)->nblocks; /* new threshold */
+---
+> G(L)->GCthreshold = 2*G(L)->nblocks - deadmem; /* new threshold */
+454c457,458
+< static void mark (lua_State *L) {
+---
+> static size_t mark (lua_State *L) {
+> size_t deadmem;
+467c471
+< luaC_separateudata(L); /* separate userdata to be preserved */
+---
+> deadmem = luaC_separateudata(L); /* separate userdata to be preserved */
+475a480
+> return deadmem;
+480c485
+< mark(L);
+---
+> size_t deadmem = mark(L);
+482c487
+< checkSizes(L);
+---
+> checkSizes(L, deadmem);
+diff -r lua-5.0/src/lgc.h lua-5.0.1/src/lgc.h
+2c2
+< ** $Id: lgc.h,v 1.19 2003/02/28 19:45:15 roberto Exp $
+---
+> ** $Id: lgc.h,v 1.19a 2003/02/28 19:45:15 roberto Exp $
+18c18
+< void luaC_separateudata (lua_State *L);
+---
+> size_t luaC_separateudata (lua_State *L);
+diff -r lua-5.0/src/lib/lbaselib.c lua-5.0.1/src/lib/lbaselib.c
+2c2
+< ** $Id: lbaselib.c,v 1.130 2003/04/03 13:35:34 roberto Exp $
+---
+> ** $Id: lbaselib.c,v 1.130a 2003/04/03 13:35:34 roberto Exp $
+327c327
+< char buff[64];
+---
+> char buff[128];
+diff -r lua-5.0/src/lib/liolib.c lua-5.0.1/src/lib/liolib.c
+2c2
+< ** $Id: liolib.c,v 2.39 2003/03/19 21:16:12 roberto Exp $
+---
+> ** $Id: liolib.c,v 2.39a 2003/03/19 21:16:12 roberto Exp $
+161c161
+< if (lua_isnone(L, 1)) {
+---
+> if (lua_isnone(L, 1) && lua_type(L, lua_upvalueindex(1)) == LUA_TTABLE) {
+178c178
+< char buff[32];
+---
+> char buff[128];
+diff -r lua-5.0/src/lparser.c lua-5.0.1/src/lparser.c
+2c2
+< ** $Id: lparser.c,v 1.208 2003/04/03 13:35:34 roberto Exp $
+---
+> ** $Id: lparser.c,v 1.208a 2003/04/03 13:35:34 roberto Exp $
+1143a1144
+> FuncState *fs = ls->fs;
+1145c1146,1147
+< init_exp(&v, VLOCAL, ls->fs->freereg++);
+---
+> init_exp(&v, VLOCAL, fs->freereg);
+> luaK_reserveregs(fs, 1);
+1148c1150,1152
+< luaK_storevar(ls->fs, &v, &b);
+---
+> luaK_storevar(fs, &v, &b);
+> /* debug information will only see the variable after this point! */
+> getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
+diff -r lua-5.0/src/luac/Makefile lua-5.0.1/src/luac/Makefile
+16c16
+< $(CC) -o $@ $(MYLDFLAGS) $(OBJS) -L$(LIB) -llua -llualib $(EXTRA_LIBS)
+---
+> $(CC) -o $@ $(MYLDFLAGS) $(OBJS) -L$(LIB) -llua -llualib $(EXTRA_LIBS) $(DLLIB)
+diff -r lua-5.0/src/luac/luac.c lua-5.0.1/src/luac/luac.c
+2c2
+< ** $Id: luac.c,v 1.44 2003/04/07 20:34:20 lhf Exp $
+---
+> ** $Id: luac.c,v 1.44a 2003/04/07 20:34:20 lhf Exp $
+184a185
+> lua_lock(L);
+185a187
+> lua_unlock(L);
+diff -r lua-5.0/src/lvm.c lua-5.0.1/src/lvm.c
+2c2
+< ** $Id: lvm.c,v 1.284 2003/04/03 13:35:34 roberto Exp $
+---
+> ** $Id: lvm.c,v 1.284a 2003/04/03 13:35:34 roberto Exp $
+69c69
+< if (mask > LUA_MASKLINE) { /* instruction-hook set? */
+---
+> if (mask & LUA_MASKCOUNT) { /* instruction-hook set? */
+402d401
+< L->ci->u.l.pc = &pc;
+405a405
+> L->ci->u.l.pc = &pc;
+676,678c676
+< lua_assert(ci->u.l.pc == &pc &&
+< ttisfunction(ci->base - 1) &&
+< (ci->state & CI_SAVEDPC));
+---
+> lua_assert(ttisfunction(ci->base - 1) && (ci->state & CI_SAVEDPC));
+diff -r lua-5.0/test/luac.lua lua-5.0.1/test/luac.lua
+4,6c4,6
+< assert(arg[1]~=nil,"usage: lua luac.lua file.lua")
+< f=assert(io.open("luac.out","w"))
+< f:write(string.dump(loadfile(arg[1])))
+---
+> assert(arg[1]~=nil and arg[2]==nil,"usage: lua luac.lua file.lua")
+> f=assert(io.open("luac.out","wb"))
+> f:write(string.dump(assert(loadfile(arg[1]))))
diff --git a/UPDATE b/UPDATE
--- /dev/null
+++ b/UPDATE
@@ -0,0 +1,24 @@
+This is Lua 5.0.1, an update of Lua 5.0 that includes the following changes,
+which fix all known bugs in Lua 5.0.
+
+src/ldo.c
+ Attempt to resume running coroutine crashed Lua
+src/lgc.c
+ C functions also may have stacks larger than current top
+ Userdata to be collected still counted into new GC threshold
+src/lgc.h
+ Userdata to be collected still counted into new GC threshold
+src/lparser.c
+ Syntax `local function' did not increment stack size
+src/lvm.c
+ `pc' address was invalidated when a coroutine was suspended
+ Count hook might be called without being set
+src/lib/lbaselib.c
+ Buffer overflow for unusual %p representation
+src/lib/liolib.c
+ `file.close()' could not be called without arguments
+ Buffer overflow for unusual %p representation
+src/luac/luac.c
+ Missing lock/unlock
+
+To use this update, simply open this tarball over the original Lua 5.0 source.
diff --git a/doc/manual.html b/doc/manual.html
--- a/doc/manual.html
+++ b/doc/manual.html
<html>
<head>
-<title>Lua 5.0 Reference Manual</title>
+<TITLE>Lua: 5.0 reference manual</TITLE>
</head>
<body BGCOLOR="#FFFFFF">
<hr>
<h1>
-<a HREF="http://www.lua.org/home.html">
-<img SRC="logo.gif" ALT="[Lua logo]" BORDER=0>
-</a>
+<A HREF="http://www.lua.org/home.html"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
Lua 5.0 Reference Manual
</h1>
<p>
<small>
<a HREF="http://www.lua.org/copyright.html">Copyright</a>
-© 2003 TeCGraf, PUC-Rio. All rights reserved.
+© 2003 Tecgraf, PUC-Rio. All rights reserved.
</small>
<hr>
-<h1>1 - Introduction</h1>
+<a name="1"><h1>1 - Introduction</h1></a>
<p>Lua is an extension programming language designed to support
general procedural programming with data description
facilities.
-It also offers good suport for object-oriented programming,
+It also offers good support for object-oriented programming,
functional programming, and data-driven programming.
Lua is intended to be used as a powerful, light-weight
configuration language for any program that needs one.
a wide range of different domains,
thus creating customized programming languages sharing a syntactical framework.
-<p>The Lua distribuition includes a stand-alone embedding program,
+<p>The Lua distribution includes a stand-alone embedding program,
<code>lua</code>, that uses the Lua library to offer a complete Lua interpreter.
<p>Lua is free software,
<p>Lua means "moon" in Portuguese and is pronounced LOO-ah.
<p>
-<a name="language"><h1>2 - The Language</h1></a>
+<a name="language"><a name="2"><h1>2 - The Language</h1></a></a>
<p>This section describes the lexis, the syntax, and the semantics of Lua.
In other words,
and other terminal symbols are shown in <code>typewriter</code> font,
enclosed in single quotes.
-<p><a name="lexical"><h2>2.1 - Lexical Conventions</h2></a>
+<p><a name="lexical"><a name="2.1"><h2>2.1 - Lexical Conventions</h2></a></a>
<p><em>Identifiers</em> in Lua can be any string of letters,
digits, and underscores,
and break do else elseif
end false for function if
in local nil not or
- repeat return then true until
- while
+ repeat return then true until while
</PRE>
<p>Lua is a case-sensitive language:
This facility allows the use of Lua as a script interpreter
in Unix systems (see <a href="#lua-sa">6</a>).
-<p><a name="TypesSec"><h2>2.2 - Values and Types</h2></a>
+<p><a name="TypesSec"><a name="2.2"><h2>2.2 - Values and Types</h2></a></a>
<p>Lua is a <em>dynamically typed language</em>.
That means that
<p>The library function <code>type</code> returns a string describing the type
of a given value (see <a href="#pdf-type">5.1</a>).
-<p><a name="coercion"><h3>2.2.1 - Coercion</h3></a>
+<p><a name="coercion"><a name="2.2.1"><h3>2.2.1 - Coercion</h3></a></a>
<p>Lua provides automatic conversion between
string and number values at run time.
For complete control of how numbers are converted to strings,
use the <code>format</code> function from the string library (see <a href="#format">5.3</a>).
-<p><a name="variables"><h2>2.3 - Variables</h2></a>
+<p><a name="variables"><a name="2.3"><h2>2.3 - Variables</h2></a></a>
<p>Variables are places that store values.
(The <code>_env</code> variable is not defined in Lua.
We use it here only for explanatory purposes.)
-<p><a name="stats"><h2>2.4 - Statements</h2></a>
+<p><a name="stats"><a name="2.4"><h2>2.4 - Statements</h2></a></a>
<p>Lua supports an almost conventional set of statements,
similar to those in Pascal or C.
assignment, control structures, procedure calls,
table constructors, and variable declarations.
-<p><a name="chunks"><h3>2.4.1 - Chunks</h3></a>
+<p><a name="chunks"><a name="2.4.1"><h3>2.4.1 - Chunks</h3></a></a>
<p>The unit of execution of Lua is called a <em>chunk</em>.
A chunk is simply a sequence of statements,
Lua automatically detects the file type and acts accordingly.
-<p><h3>2.4.2 - Blocks</h3>
+<p><a name="2.4.2"><h3>2.4.2 - Blocks</h3></a>
A block is a list of statements;
syntactically, a block is equal to a chunk:
<pre>
of another block (see <a href="#control">2.4.4</a>).
-<p><a name="assignment"><h3>2.4.3 - Assignment</h3></a>
+<p><a name="assignment"><a name="2.4.3"><h3>2.4.3 - Assignment</h3></a></a>
<p>Lua allows multiple assignment.
Therefore, the syntax for assignment
</PRE>
sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
-before it is assigned 4.
+before it is assigned 4.
Similarly, the line
<PRE>
x, y = y, x
(The <code>_env</code> variable is not defined in Lua.
We use it here only for explanatory purposes.)
-<p><a name="control"><h3>2.4.4 - Control Structures</h3></a>
+<p><a name="control"><a name="2.4.4"><h3>2.4.4 - Control Structures</h3></a></a>
The control structures
<b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
familiar syntax:
<p>The <b>break</b> statement can be used to terminate the execution of a
<b>while</b>, <b>repeat</b>, or <b>for</b> loop,
-skiping to the next statement after the loop:
+skipping to the next statement after the loop:
<pre>
stat ::= <b>break</b>
In practice,
those idioms are only used during debugging.
-<p><a name="for"><h3>2.4.5 - For Statement</h3></a>
+<p><a name="for"><a name="2.4.5"><h3>2.4.5 - For Statement</h3></a></a>
<p>The <b>for</b> statement has two forms:
one numeric and one generic.
then assign them to other variables before breaking or exiting the loop.
</ul>
-<p><a name="funcstat"><h3>2.4.6 - Function Calls as Statements</h3></a>
+<p><a name="funcstat"><a name="2.4.6"><h3>2.4.6 - Function Calls as Statements</h3></a></a>
To allow possible side-effects,
function calls can be executed as statements:
<pre>
In this case, all returned values are thrown away.
Function calls are explained in <a href="#functioncall">2.5.7</a>.
-<p><a name="localvar"><h3>2.4.7 - Local Declarations</h3></a>
+<p><a name="localvar"><a name="2.4.7"><h3>2.4.7 - Local Declarations</h3></a></a>
Local variables may be declared anywhere inside a block.
The declaration may include an initial assignment:
<pre>
<p>The visibility rules for local variables are explained in <a href="#visibility">2.6</a>.
-<p><a name="expressions"><h2>2.5 - Expressions</h2></a>
+<p><a name="expressions"><a name="2.5"><h2>2.5 - Expressions</h2></a></a>
<p>
The basic expressions in Lua are the following:
<p>Expressions can also be built with arithmetic operators, relational operators,
and logical operators, all of which are explained below.
-<p><h3>2.5.1 - Arithmetic Operators</h3>
+<p><a name="2.5.1"><h3>2.5.1 - Arithmetic Operators</h3></a>
Lua supports the usual arithmetic operators:
the binary <code>+</code> (addition),
<code>-</code> (subtraction), <code>*</code> (multiplication),
giving the expected meaning to exponentiation
(see <a href="#mathlib">5.5</a>).
-<p><a name="rel-ops"><h3>2.5.2 - Relational Operators</h3></a>
+<p><a name="rel-ops"><a name="2.5.2"><h3>2.5.2 - Relational Operators</h3></a></a>
The relational operators in Lua are
<PRE>
== ~= < > <= >=
Otherwise, Lua tries to call the "lt" or the "le"
metamethod (see <a href="#metatable">2.8</a>).
-<p><h3>2.5.3 - Logical Operators</h3>
+<p><a name="2.5.3"><h3>2.5.3 - Logical Operators</h3></a>
The logical operators in Lua are
<PRE>
10 and 20 -> 20
</PRE>
-<p><a name="concat"><h3>2.5.4 - Concatenation</h3></a>
+<p><a name="concat"><a name="2.5.4"><h3>2.5.4 - Concatenation</h3></a></a>
The string concatenation operator in Lua is
denoted by two dots (`<code>..</code>´).
If both operands are strings or numbers, then they are converted to
strings according to the rules mentioned in <a href="#coercion">2.2.1</a>.
Otherwise, the "concat" metamethod is called (see <a href="#metatable">2.8</a>).
-<p><h3>2.5.5 - Precedence</h3>
+<p><a name="2.5.5"><h3>2.5.5 - Precedence</h3></a>
Operator precedence in Lua follows the table below,
from lower to higher priority:
<PRE>
not - (unary)
^
</PRE>
-As usual, you can use parentheses to change the precedences of an expression.
+You can use parentheses to change the precedences in an expression.
The concatenation (`<code>..</code>´) and exponentiation (`<code>^</code>´)
operators are right associative.
All other binary operators are left associative.
-<p><a name="tableconstructor"><h3>2.5.6 - Table Constructors</h3></a>
+<p><a name="tableconstructor"><a name="2.5.6"><h3>2.5.6 - Table Constructors</h3></a></a>
Table constructors are expressions that create tables.
Every time a constructor is evaluated, a new table is created.
Constructors can be used to create empty tables,
<p>The field list may have an optional trailing separator,
as a convenience for machine-generated code.
-<p><a name="functioncall"><h3>2.5.7 - Function Calls</h3></a>
+<p><a name="functioncall"><a name="2.5.7"><h3>2.5.7 - Function Calls</h3></a></a>
A function call in Lua has the following syntax:
<pre>
functioncall ::= prefixexp args
<PRE>
return (f(x)) -- results adjusted to 1
return 2 * f(x)
- return x, f(x) -- adicional results
+ return x, f(x) -- additional results
f(x); return -- results discarded
return x or f(x) -- results adjusted to 1
</PRE>
-<p><a name="func-def"><h3>2.5.8 - Function Definitions</h3></a>
+<p><a name="func-def"><a name="2.5.8"><h3>2.5.8 - Function Definitions</h3></a></a>
<p>The syntax for function definition is
<pre>
t.a.b.c.f = function (self, ...) ... end
</PRE>
-<p><a name="visibility"><h2>2.6 - Visibility Rules</h2></a>
+<p><a name="visibility"><a name="2.6"><h2>2.6 - Visibility Rules</h2></a></a>
<p>Lua is a lexically scoped language.
Each of these closures uses a different <code>y</code> variable,
while all of them share the same <code>x</code>.
-<p><a name="error"><h2>2.7 - Error Handling</h2></a>
+<p><a name="error"><a name="2.7"><h2>2.7 - Error Handling</h2></a></a>
<p>Because Lua is an extension language,
all Lua actions start from C code in the host program
If you need to catch errors in Lua,
you can use the <code>pcall</code> function (see <a href="#pdf-pcall">5.1</a>).
-<p><a name="metatable"><h2>2.8 - Metatables</h2></a>
+<p><a name="metatable"><a name="2.8"><h2>2.8 - Metatables</h2></a></a>
<p>Every table and userdata object in Lua may have a <em>metatable</em>.
This <em>metatable</em> is an ordinary Lua table
The "eq" event is defined as follows:
<PRE>
function eq_event (op1, op2)
- if type(op1) ~= type(op2) then -- diferent types?
+ if type(op1) ~= type(op2) then -- different types?
return false -- different objects
end
if op1 == op2 then -- primitive equal?
<p></ul>
-<p><a name="GC"><h2>2.9 - Garbage Collection</h2></a>
+<p><a name="GC"><a name="2.9"><h2>2.9 - Garbage Collection</h2></a></a>
<p>Lua does automatic memory management.
That means that
@@ -1471,7 +1468,7 @@ Using Lua code you have a more limited control over garbage-collection cycles,
through the <code>gcinfo</code> and <code>collectgarbage</code> functions
(see <a href="#predefined">5.1</a>).
-<p><h3>2.9.1 - Garbage-Collection Metamethods</h3>
+<p><a name="2.9.1"><h3>2.9.1 - Garbage-Collection Metamethods</h3></a>
<p>Using the C API,
you can set garbage-collector metamethods for userdata (see <a href="#metatable">2.8</a>).
That is, the first finalizer to be called is the one associated
with the userdata created last in the program.
-<p><a name="weak-table"><h3>2.9.2 - Weak Tables</h3></a>
+<p><a name="weak-table"><a name="2.9.2"><h3>2.9.2 - Weak Tables</h3></a></a>
<p>A <em>weak table</em> is a table whose elements are
<em>weak references</em>.
the whole pair is removed from the table.
The weakness of a table is controlled by the value of the
<code>__mode</code> field of its metatable.
-If the <code>__mode</code> field is a string containing the character `<code>k</code>´,
+If the <code>__mode</code> field is a string containing the character `<code>k</code>´,
the keys in the table are weak.
If <code>__mode</code> contains `<code>v</code>´,
the values in the table are weak.
Otherwise, the weak behavior of the tables controlled by this
metatable is undefined.
-<p><a name="coroutine"><h2>2.10 - Coroutines</h2></a>
+<p><a name="coroutine"><a name="2.10"><h2>2.10 - Coroutines</h2></a></a>
<p>Lua supports coroutines,
also called <em>semi-coroutines</em>
it does not start the coroutine execution.
<p>When you first call <code>coroutine.resume</code>,
-passing as argument the thread returned by <code>coroutine.create</code>,
+passing as its first argument the thread returned by <code>coroutine.create</code>,
the coroutine starts its execution,
at the first line of its main function.
Extra arguments passed to <code>coroutine.resume</code> are given as
</PRE>
<p>
-<a name="API"><h1>3 - The Application Program Interface</h1></a>
+<a name="API"><a name="3"><h1>3 - The Application Program Interface</h1></a></a>
<p>This section describes the C API for Lua, that is,
(except for the first argument, which is always a Lua state),
and so do not generate hidden side-effects.
-<p><a name="mangstate"><h2>3.1 - States</h2></a>
+<p><a name="mangstate"><a name="3.1"><h2>3.1 - States</h2></a></a>
<p>The Lua library is fully reentrant:
it has no global variables.
might need to release states as soon as they are not needed,
to avoid growing too large.
-<p><h2>3.2 - The Stack and Indices</h2>
+<p><a name="3.2"><h2>3.2 - The Stack and Indices</h2></a>
<p>Lua uses a <em>virtual stack</em> to pass values to and from C.
Each element in this stack represents a Lua value
which is independent of previous stacks and of stacks of
C functions that are still active.
That stack initially contains any arguments to the C function,
-and it is where the C function pushes its results (see <a href="#LuacallC">3.16</a>)
+and it is where the C function pushes its results to be returned to the caller (see <a href="#LuacallC">3.16</a>)
to be returned to the caller.
<p>For convenience,
it is left unchanged.
<p>Whenever Lua calls C,
-it ensures that at least <code>LUA_MINSTACK</code> positions are available.
+it ensures that at least <code>LUA_MINSTACK</code> stack positions are available.
<code>LUA_MINSTACK</code> is defined in <code>lua.h</code> as 20,
so that usually you do not have to worry about stack space
unless your code has loops pushing elements onto the stack.
Pseudo-indices are used to access the global environment,
the registry, and the upvalues of a C function (see <a href="#c-closure">3.17</a>).
-<p><h2>3.3 - Stack Manipulation</h2>
+<p><a name="3.3"><h2>3.3 - Stack Manipulation</h2></a>
The API offers the following functions for basic stack manipulation:
<PRE>
void lua_settop (lua_State *L, int index);
lua_settop(L, 6) --> 30 40 nil nil nil nil*
</PRE>
-<p><h2>3.4 - Querying the Stack</h2>
+<p><a name="3.4"><h2>3.4 - Querying the Stack</h2></a>
<p>To check the type of a stack element,
the following functions are available:
@@ -1887,7 +1884,7 @@ are equivalent to their counterparts in Lua (see <a href="#rel-ops">2.5.2</a>).
without metamethods.
These functions return 0 (false) if any of the indices are non-valid.
-<p><a name="lua-to"><h2>3.5 - Getting Values from the Stack</h2></a>
+<p><a name="lua-to"><a name="3.5"><h2>3.5 - Getting Values from the Stack</h2></a></a>
<p>To translate a value in the stack to a specific C type,
you can use the following conversion functions:
<p><code>lua_touserdata</code> is explained in <a href="#userdata">3.8</a>.
-<p><a name="pushing"><h2>3.6 - Pushing Values onto the Stack</h2></a>
+<p><a name="pushing"><a name="3.6"><h2>3.6 - Pushing Values onto the Stack</h2></a></a>
<p>The API has the following functions to
push C values onto the stack:
<p>You can also push "formatted" strings:
<PRE>
const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
- const char *lua_pushvfstring (lua_State *L, const char *fmt,
- va_list argp);
+ const char *lua_pushvfstring (lua_State *L, const char *fmt, va_list argp);
</PRE>
These functions push onto the stack a formatted string
concatenates the <code>n</code> values at the top of the stack,
pops them, and leaves the result at the top.
-If <code>n</code> is 1, the result is that single string
+If <code>n</code> is 1, the result is that single string
(that is, the function does nothing);
if <code>n</code> is 0, the result is the empty string.
Concatenation is done following the usual semantics of Lua
(see <a href="#concat">2.5.4</a>).
-<p><a name="GC-API"><h2>3.7 - Controlling Garbage Collection</h2></a>
+<p><a name="GC-API"><a name="3.7"><h2>3.7 - Controlling Garbage Collection</h2></a></a>
<p>Lua uses two numbers to control its garbage collection:
the <em>count</em> and the <em>threshold</em> (see <a href="#GC">2.9</a>).
<p>You can access the current values of these two numbers through the
following functions:
<PRE>
- int lua_getgccount (lua_State *L);
+ int lua_getgccount (lua_State *L);
int lua_getgcthreshold (lua_State *L);
</PRE>
After the collection,
a new threshold is set according to the previous rule.
-<p><a name="userdata"><h2>3.8 - Userdata</h2></a>
+<p><a name="userdata"><a name="3.8"><h2>3.8 - Userdata</h2></a></a>
<p>Userdata represents C values in Lua.
Lua supports two types of userdata:
it calls the userdata's <code>gc</code> metamethod, if any,
and then it frees the userdata's corresponding memory.
-<p><h2>3.9 - Metatables</h2>
+<p><a name="3.9"><h2>3.9 - Metatables</h2></a>
<p>The following functions allow you to manipulate the metatables
of an object:
(that is, when the object is neither a userdata nor a table);
even then it pops the table from the stack.
-<p><h2>3.10 - Loading Lua Chunks</h2>
+<p><a name="3.10"><h2>3.10 - Loading Lua Chunks</h2></a>
<p>You can load a Lua chunk with <code>lua_load</code>:
<PRE>
<p><code>lua_load</code> automatically detects whether the chunk is text or binary,
and loads it accordingly (see program <code>luac</code>).
-<p><code>lua_load</code> uses an user-supplied <em>reader</em> function to read the chunk.
+<p><code>lua_load</code> uses a user-supplied <em>reader</em> function to read the chunk.
Everytime it needs another piece of the chunk,
-it calls the reader,
+<code>lua_load</code> calls the reader,
passing along its <code>data</code> parameter.
The reader must return a pointer to a block of memory
with a new piece of the chunk
and for some ready-to-use functions to load chunks
from files and strings.
-<p><h2>3.11 - Manipulating Tables</h2>
+<p><a name="3.11"><h2>3.11 - Manipulating Tables</h2></a>
<p>Tables are created by calling
the function
Recall that <code>lua_tostring</code> <em>changes</em> the value at the given index;
this confuses the next call to <code>lua_next</code>.
-<p><a name="globals"><h2>3.12 - Manipulating Environments</h2></a>
+<p><a name="globals"><a name="3.12"><h2>3.12 - Manipulating Environments</h2></a></a>
<p>All global variables are kept in ordinary Lua tables,
called environments.
@@ -2292,7 +2288,7 @@ the new environment for the function at index <code>index</code> in the stack.
If the object at the given index is not a Lua function,
<code>lua_setfenv</code> returns 0.
-<p><h2>3.13 - Using Tables as Arrays</h2>
+<p><a name="3.13"><h2>3.13 - Using Tables as Arrays</h2></a>
The API has functions that help to use Lua tables as arrays,
that is,
tables indexed by numbers only:
at stack position <code>index</code> to the value at the top of the stack,
removing this value from the stack.
-<p><h2>3.14 - Calling Functions</h2>
+<p><a name="3.14"><h2>3.14 - Calling Functions</h2></a>
<p>Functions defined in Lua
and C functions registered in Lua
that provide higher level access to Lua.
See the source code of the standard libraries for examples.)
-<p><a name="lua_pcall"><h2>3.15 - Protected Calls</h2></a>
+<p><a name="lua_pcall"><a name="3.15"><h2>3.15 - Protected Calls</h2></a></a>
<p>When you call a function with <code>lua_call</code>,
any error inside the called function is propagated upwards
error while running the error handler function.
</ul>
-<p><a name="LuacallC"><h2>3.16 - Defining C Functions</h2></a>
+<p><a name="LuacallC"><a name="3.16"><h2>3.16 - Defining C Functions</h2></a></a>
<p>Lua can be extended with functions written in C.
These functions must be of type <code>lua_CFunction</code>,
lua_register(L, "average", foo);
</PRE>
-<p><a name="c-closure"><h2>3.17 - Defining C Closures</h2></a>
+<p><a name="c-closure"><a name="3.17"><h2>3.17 - Defining C Closures</h2></a></a>
<p>When a C function is created,
it is possible to associate some values with it,
see the standard libraries in the official Lua distribution
(<code>src/lib/*.c</code>).
-<p><a name="registry"><h2>3.18 - Registry</h2></a>
+<p><a name="registry"><a name="3.18"><h2>3.18 - Registry</h2></a></a>
<p>Lua provides a registry,
a pre-defined table that can be used by any C code to
implemented by the auxiliary library,
and therefore should not be used by other purposes.
-<p><h2>3.19 - Error Handling in C</h2>
+<p><a name="3.19"><h2>3.19 - Error Handling in C</h2></a>
<p>Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
When Lua faces any error
(such as memory allocation errors, type errors, syntax errors)
it <em>raises</em> an error, that is, it does a long jump.
A <em>protected environment</em> uses <code>setjmp</code>
-to set a recover point,
-and any error jumps to the most recent active recover point.
+to set a recover point;
+any error jumps to the most recent active recover point.
<p>If an error happens outside any protected environment,
-Lua calls a <em>panic function</em>,
+Lua calls a <em>panic function</em>
and then calls <code>exit(EXIT_FAILURE)</code>.
You can change the panic function with
<PRE>
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
</PRE>
Your new panic function may avoid the application exit by
-never returning (e.g. doing a long jump).
-Nevertheless, the corresponding Lua will not be consistent;
+never returning (e.g., by doing a long jump).
+Nevertheless, the corresponding Lua state will not be consistent;
the only safe operation with it is to close it.
<p>Almost any function in the API may raise an error,
(see <a href="#lua_pcall">3.15</a>),
plus the error object on the top of the stack;
otherwise, it returns zero, and does not change the stack.
-Any value returned by <code>func</code> is dicarded.
+Any value returned by <code>func</code> is discarded.
<p>C code can generate a Lua error calling the function
<PRE>
This function does a long jump,
and therefore never returns.
-<p><h2>3.20 - Threads</h2>
+<p><a name="3.20"><h2>3.20 - Threads</h2></a>
<p>Lua offers partial support for multiple threads of execution.
If you have a C library that offers multi-threading,
When you create a thread, this table is the same as that of the given state,
but you can change each one independently.
-<p>You destroy threads with <code>lua_closethread</code>:
-<PRE>
- void lua_closethread (lua_State *L, lua_State *thread);
-</PRE>
-You cannot close the sole (or last) thread of a state.
-Instead, you must close the state itself.
+<p>There is no explicit function to close or to destroy a thread.
+Threads are subject to garbage collection,
+like any Lua object.
<p>To manipulate threads as coroutines,
Lua offers the following functions:
<PRE>
int lua_resume (lua_State *L, int narg);
- int lua_yield (lua_State *L, int nresults);
+ int lua_yield (lua_State *L, int nresults);
</PRE>
To start a coroutine, you first create a new thread;
This call returns when the coroutine suspends or finishes its execution.
When it returns, the stack contains all values passed to <code>lua_yield</code>,
or all values returned by the body function.
-<code>lua_resume</code> returns 0 if there is no errors running the coroutine,
+<code>lua_resume</code> returns 0 if there are no errors running the coroutine,
or an error code (see <a href="#lua_pcall">3.15</a>).
In case of errors,
the stack contains only the error message.
and puhses them into the stack <code>to</code>.
<p>
-<a name="debugI"><h1>4 - The Debug Interface</h1></a>
+<a name="debugI"><a name="4"><h1>4 - The Debug Interface</h1></a></a>
<p>Lua has no built-in debugging facilities.
Instead, it offers a special interface
kinds of debuggers, profilers, and other tools
that need "inside information" from the interpreter.
-<p><h2>4.1 - Stack and Function Information</h2>
+<p><a name="4.1"><h2>4.1 - Stack and Function Information</h2></a>
<p>The main function to get information about the interpreter runtime stack is
<PRE>
of the function executing at a given level.
Level 0 is the current running function,
whereas level <em>n+1</em> is the function that has called level <em>n</em>.
-When there is no errors, <code>lua_getstack</code> returns 1;
+When there are no errors, <code>lua_getstack</code> returns 1;
when called with a level greater than the stack depth,
it returns 0.
<p></ul>
-<p><h2>4.2 - Manipulating Local Variables and Upvalues</h2>
+<p><a name="4.2"><h2>4.2 - Manipulating Local Variables and Upvalues</h2></a>
<p>For the manipulation of local variables and upvalues,
the debug interface uses indices:
}
</PRE>
-<p><a name="sub-hooks"><h2>4.3 - Hooks</h2></a>
+<p><a name="sub-hooks"><a name="4.3"><h2>4.3 - Hooks</h2></a></a>
<p>Lua offers a mechanism of hooks, which are
user-defined C functions that are called during the program execution.
that execution occurs without any calls to hooks.
<p>
-<a name="libraries"><h1>5 - Standard Libraries</h1></a>
+<a name="libraries"><a name="5"><h1>5 - Standard Libraries</h1></a></a>
<p>The standard libraries provide useful functions
that are implemented directly through the C API.
-<p><a name="predefined"><h2>5.1 - Basic Functions</h2></a>
+<p><a name="predefined"><a name="5.1"><h2>5.1 - Basic Functions</h2></a></a>
<p>The basic library provides some core functions to Lua.
If you do not include this library in your application,
<p><a name="pdf-error"><h3><code>error (message [, level])</code></h3></a>
-Terminates the last protected function called,
+Terminates the last protected function called
and returns <code>message</code> as the error message.
Function <code>error</code> never returns.
<code>getfenv</code> returns the global environment.
The default for <code>f</code> is 1.
-<p>if the environment has a <code>"__fenv"</code> field,
+<p>If the environment has a <code>"__fenv"</code> field,
returns the associated value, instead of the environment.
<p><a name="pdf-getmetatable"><h3><code>getmetatable (object)</code></h3></a>
<p>Calls function <code>f</code> with
the given arguments in protected mode.
-That means that any error inside <code>f</code> is not propagated;
+That means that any error inside <code>f</code> is not propagated;
instead, <code>pcall</code> catches the error
and returns a status code.
Its first result is the status code (a boolean),
-which is true if the call succeeds without errors.
+which is <B>true</B> if the call succeeds without errors.
In such case, <code>pcall</code> also returns all results from the call,
after this first result.
In case of any error, <code>pcall</code> returns <B>false</B> plus the error message.
In case of any error,
<code>xpcall</code> returns false plus the result from <code>err</code>.
-<p><h2>5.2 - Coroutine Manipulation</h2>
+<p><a name="5.2"><h2>5.2 - Coroutine Manipulation</h2></a>
<p>The operations related to coroutines comprise a sub-library of
-the basic library, and come inside the table .
+the basic library and come inside the table <code>coroutine</code>.
See <a href="#coroutine">2.10</a> for a general description of coroutines.
<p><h3><code>coroutine.create (f)</code></h3>
nor a metamethod, nor an iterator.
Any arguments to <code>yield</code> go as extra results to <code>resume</code>.
-<p><h2>5.3 - String Manipulation</h2>
+<p><a name="5.3"><h2>5.3 - String Manipulation</h2></a>
This library provides generic functions for string manipulation,
such as finding and extracting substrings, and pattern matching.
When indexing a string in Lua, the first character is at position 1
<p><a name="pm"><h3>Patterns</h3></a>
<p><p>
-a <em>character class</em> is used to represent a set of characters.
+A <em>character class</em> is used to represent a set of characters.
The following combinations are allowed in describing a character class:
<ul>
<li><b><em>x</em></b> (where <em>x</em> is not one of the magic characters
@@ -3648,7 +3641,7 @@ In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</c
The second form should be preferred for portability.
<p><p>
-a <em>pattern item</em> may be
+A <em>pattern item</em> may be
<ul>
<li>
a single character class,
</ul>
<p><p>
-a <em>pattern</em> is a sequence of pattern items.
+A <em>pattern</em> is a sequence of pattern items.
A `<code>^</code>´ at the beginning of a pattern anchors the match at the
beginning of the subject string.
A `<code>$</code>´ at the end of a pattern anchors the match at the
<p>A pattern cannot contain embedded zeros. Use <code>%z</code> instead.
-<p><h2>5.4 - Table Manipulation</h2>
+<p><a name="5.4"><h2>5.4 - Table Manipulation</h2></a>
This library provides generic functions for table manipulation.
It provides all its functions inside the table <code>table</code>.
Otherwise, it updates an internal state
so that subsequent calls to <code>table.getn(table)</code> return <code>n</code>.
-<p><a name="mathlib"><h2>5.5 - Mathematical Functions</h2></a>
+<p><a name="mathlib"><a name="5.5"><h2>5.5 - Mathematical Functions</h2></a></a>
<p>This library is an interface to most of the functions of the
standard C math library.
for the pseudo-random generator:
Equal seeds produce equal sequences of numbers.
-<p><a name="libio"><h2>5.6 - Input and Output Facilities</h2></a>
+<p><a name="libio"><a name="5.6"><h2>5.6 - Input and Output Facilities</h2></a></a>
<p>The I/O library provides two different styles for file manipulation.
The first one uses implicit file descriptors,
To write other values,
use <code>tostring</code> or <code>string.format</code> before <code>write</code>.
-<p><a name="libiosys"><h2>5.7 - Operating System Facilities</h2></a>
+<p><a name="libiosys"><a name="5.7"><h2>5.7 - Operating System Facilities</h2></a></a>
<p>This library is implemented through table <code>os</code>.
then <code>date</code> returns a table with the following fields:
<code>year</code> (four digits), <code>month</code> (1--12), <code>day</code> (1--31),
<code>hour</code> (0--23), <code>min</code> (0--59), <code>sec</code> (0--61),
-<code>wday</code> (weekday, Sunday is 1),
+<code>wday</code> (weekday, Sunday is 1),
<code>yday</code> (day of the year),
and <code>isdst</code> (daylight saving flag, a boolean).
it is possible for another process
to create a file with the same name.
-<p><h2>5.8 - The Reflexive Debug Interface</h2>
+<p><a name="5.8"><h2>5.8 - The Reflexive Debug Interface</h2></a>
<p>The <code>debug</code> library provides
the functionality of the debug interface to Lua programs.
better error messages.
<p>
-<a name="lua-sa"><h1>6 - Lua Stand-alone</h1></a>
+<a name="lua-sa"><a name="6"><h1>6 - Lua Stand-alone</h1></a></a>
<p>Although Lua has been designed as an extension language,
to be embedded in a host C program,
Steve Dekorte,
Thatcher Ulrich,
Tomás Gorham,
-Vincent Penquerc'h,
+Vincent Penquerc'h.
Thank you!
<p><hr>
@@ -4580,7 +4573,7 @@ Use <code>lua_newuserdata</code> or <code>lua_pushlightuserdata</code> instead.
<p> explist1 ::= {exp `<b>,</b>´} exp
-<p> exp ::= <b>nil</b> <b>false</b> <b>true</b> | Number | Literal | function | prefixexp | tableconstructor | exp binop exp | unop exp
+<p> exp ::= <b>nil</b> | <b>false</b> | <b>true</b> | Number | Literal | function | prefixexp | tableconstructor | exp binop exp | unop exp
<p> prefixexp ::= var | functioncall | `<b>(</b>´ exp `<b>)</b>´
@@ -4609,5 +4602,11 @@ Use <code>lua_newuserdata</code> or <code>lua_pushlightuserdata</code> instead.
<p>
-</body></html>
+<HR>
+<SMALL>
+Last update:
+Tue Nov 25 16:08:37 BRST 2003
+</SMALL>
+</BODY>
+</HTML>
diff --git a/etc/.exrc b/etc/.exrc
diff --git a/include/lua.h b/include/lua.h
--- a/include/lua.h
+++ b/include/lua.h
/*
-** $Id: lua.h,v 1.175 2003/03/18 12:31:39 roberto Exp $
+** $Id: lua.h,v 1.175a 2003/03/18 12:31:39 roberto Exp $
** Lua - An Extensible Extension Language
** Tecgraf: Computer Graphics Technology Group, PUC-Rio, Brazil
** http://www.lua.org mailto:[email protected]
#include <stddef.h>
-#define LUA_VERSION "Lua 5.0"
+#define LUA_VERSION "Lua 5.0.1"
#define LUA_COPYRIGHT "Copyright (C) 1994-2003 Tecgraf, PUC-Rio"
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
diff --git a/src/ldo.c b/src/ldo.c
--- a/src/ldo.c
+++ b/src/ldo.c
/*
-** $Id: ldo.c,v 1.217 2003/04/03 13:35:34 roberto Exp $
+** $Id: ldo.c,v 1.217a 2003/04/03 13:35:34 roberto Exp $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
int nargs = *cast(int *, ud);
CallInfo *ci = L->ci;
if (ci == L->base_ci) { /* no activation record? */
- if (nargs >= L->top - L->base)
- luaG_runerror(L, "cannot resume dead coroutine");
+ lua_assert(nargs < L->top - L->base);
luaD_precall(L, L->top - (nargs + 1)); /* start coroutine */
}
- else if (ci->state & CI_YIELD) { /* inside a yield? */
+ else { /* inside a yield */
+ lua_assert(ci->state & CI_YIELD);
if (ci->state & CI_C) { /* `common' yield? */
/* finish interrupted execution of `OP_CALL' */
int nresults;
ci->state &= ~CI_YIELD;
}
}
- else
- luaG_runerror(L, "cannot resume non-suspended coroutine");
firstResult = luaV_execute(L);
if (firstResult != NULL) /* return? */
luaD_poscall(L, LUA_MULTRET, firstResult); /* finalize this coroutine */
}
+static int resume_error (lua_State *L, const char *msg) {
+ L->top = L->ci->base;
+ setsvalue2s(L->top, luaS_new(L, msg));
+ incr_top(L);
+ lua_unlock(L);
+ return LUA_ERRRUN;
+}
+
+
LUA_API int lua_resume (lua_State *L, int nargs) {
int status;
lu_byte old_allowhooks;
lua_lock(L);
+ if (L->ci == L->base_ci) {
+ if (nargs >= L->top - L->base)
+ return resume_error(L, "cannot resume dead coroutine");
+ }
+ else if (!(L->ci->state & CI_YIELD)) /* not inside a yield? */
+ return resume_error(L, "cannot resume non-suspended coroutine");
old_allowhooks = L->allowhook;
lua_assert(L->errfunc == 0 && L->nCcalls == 0);
status = luaD_rawrunprotected(L, resume, &nargs);
diff --git a/src/lgc.c b/src/lgc.c
--- a/src/lgc.c
+++ b/src/lgc.c
/*
-** $Id: lgc.c,v 1.171 2003/04/03 13:35:34 roberto Exp $
+** $Id: lgc.c,v 1.171a 2003/04/03 13:35:34 roberto Exp $
** Garbage Collector
** See Copyright Notice in lua.h
*/
/* move `dead' udata that need finalization to list `tmudata' */
-void luaC_separateudata (lua_State *L) {
+size_t luaC_separateudata (lua_State *L) {
+ size_t deadmem = 0;
GCObject **p = &G(L)->rootudata;
GCObject *curr;
GCObject *collected = NULL; /* to collect udata with gc event */
p = &curr->gch.next;
}
else { /* must call its gc method */
+ deadmem += sizeudata(gcotou(curr)->uv.len);
*p = curr->gch.next;
curr->gch.next = NULL; /* link `curr' at the end of `collected' list */
*lastcollected = curr;
/* insert collected udata with gc event into `tmudata' list */
*lastcollected = G(L)->tmudata;
G(L)->tmudata = collected;
+ return deadmem;
}
for (ci = L1->base_ci; ci <= L1->ci; ci++) {
lua_assert(ci->top <= L1->stack_last);
lua_assert(ci->state & (CI_C | CI_HASFRAME | CI_SAVEDPC));
- if (!(ci->state & CI_C) && lim < ci->top)
+ if (lim < ci->top)
lim = ci->top;
}
for (o = L1->stack; o < L1->top; o++)
}
-static void checkSizes (lua_State *L) {
+static void checkSizes (lua_State *L, size_t deadmem) {
/* check size of string hash */
if (G(L)->strt.nuse < cast(ls_nstr, G(L)->strt.size/4) &&
G(L)->strt.size > MINSTRTABSIZE*2)
size_t newsize = luaZ_sizebuffer(&G(L)->buff) / 2;
luaZ_resizebuffer(L, &G(L)->buff, newsize);
}
- G(L)->GCthreshold = 2*G(L)->nblocks; /* new threshold */
+ G(L)->GCthreshold = 2*G(L)->nblocks - deadmem; /* new threshold */
}
}
-static void mark (lua_State *L) {
+static size_t mark (lua_State *L) {
+ size_t deadmem;
GCState st;
GCObject *wkv;
st.g = G(L);
wkv = st.wkv; /* keys must be cleared after preserving udata */
st.wkv = NULL;
st.wv = NULL;
- luaC_separateudata(L); /* separate userdata to be preserved */
+ deadmem = luaC_separateudata(L); /* separate userdata to be preserved */
marktmu(&st); /* mark `preserved' userdata */
propagatemarks(&st); /* remark, to propagate `preserveness' */
cleartablekeys(wkv);
cleartablevalues(st.wv);
cleartablekeys(st.wkv);
cleartablevalues(st.wkv);
+ return deadmem;
}
void luaC_collectgarbage (lua_State *L) {
- mark(L);
+ size_t deadmem = mark(L);
luaC_sweep(L, 0);
- checkSizes(L);
+ checkSizes(L, deadmem);
luaC_callGCTM(L);
}
diff --git a/src/lgc.h b/src/lgc.h
--- a/src/lgc.h
+++ b/src/lgc.h
/*
-** $Id: lgc.h,v 1.19 2003/02/28 19:45:15 roberto Exp $
+** $Id: lgc.h,v 1.19a 2003/02/28 19:45:15 roberto Exp $
** Garbage Collector
** See Copyright Notice in lua.h
*/
if (G(L)->nblocks >= G(L)->GCthreshold) luaC_collectgarbage(L); }
-void luaC_separateudata (lua_State *L);
+size_t luaC_separateudata (lua_State *L);
void luaC_callGCTM (lua_State *L);
void luaC_sweep (lua_State *L, int all);
void luaC_collectgarbage (lua_State *L);
diff --git a/src/lib/lbaselib.c b/src/lib/lbaselib.c
--- a/src/lib/lbaselib.c
+++ b/src/lib/lbaselib.c
/*
-** $Id: lbaselib.c,v 1.130 2003/04/03 13:35:34 roberto Exp $
+** $Id: lbaselib.c,v 1.130a 2003/04/03 13:35:34 roberto Exp $
** Basic library
** See Copyright Notice in lua.h
*/
static int luaB_tostring (lua_State *L) {
- char buff[64];
+ char buff[128];
luaL_checkany(L, 1);
if (luaL_callmeta(L, 1, "__tostring")) /* is there a metafield? */
return 1; /* use its value */
diff --git a/src/lib/liolib.c b/src/lib/liolib.c
--- a/src/lib/liolib.c
+++ b/src/lib/liolib.c
/*
-** $Id: liolib.c,v 2.39 2003/03/19 21:16:12 roberto Exp $
+** $Id: liolib.c,v 2.39a 2003/03/19 21:16:12 roberto Exp $
** Standard I/O (and system) library
** See Copyright Notice in lua.h
*/
static int io_close (lua_State *L) {
- if (lua_isnone(L, 1)) {
+ if (lua_isnone(L, 1) && lua_type(L, lua_upvalueindex(1)) == LUA_TTABLE) {
lua_pushstring(L, IO_OUTPUT);
lua_rawget(L, lua_upvalueindex(1));
}
static int io_tostring (lua_State *L) {
- char buff[32];
+ char buff[128];
FILE **f = topfile(L, 1);
if (*f == NULL)
strcpy(buff, "closed");
diff --git a/src/lparser.c b/src/lparser.c
--- a/src/lparser.c
+++ b/src/lparser.c
/*
-** $Id: lparser.c,v 1.208 2003/04/03 13:35:34 roberto Exp $
+** $Id: lparser.c,v 1.208a 2003/04/03 13:35:34 roberto Exp $
** Lua Parser
** See Copyright Notice in lua.h
*/
static void localfunc (LexState *ls) {
expdesc v, b;
+ FuncState *fs = ls->fs;
new_localvar(ls, str_checkname(ls), 0);
- init_exp(&v, VLOCAL, ls->fs->freereg++);
+ init_exp(&v, VLOCAL, fs->freereg);
+ luaK_reserveregs(fs, 1);
adjustlocalvars(ls, 1);
body(ls, &b, 0, ls->linenumber);
- luaK_storevar(ls->fs, &v, &b);
+ luaK_storevar(fs, &v, &b);
+ /* debug information will only see the variable after this point! */
+ getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
}
diff --git a/src/luac/Makefile b/src/luac/Makefile
--- a/src/luac/Makefile
+++ b/src/luac/Makefile
all: $T
$T: $(OBJS) $(LIB)/liblua.a $(LIB)/liblualib.a
- $(CC) -o $@ $(MYLDFLAGS) $(OBJS) -L$(LIB) -llua -llualib $(EXTRA_LIBS)
+ $(CC) -o $@ $(MYLDFLAGS) $(OBJS) -L$(LIB) -llua -llualib $(EXTRA_LIBS) $(DLLIB)
# print.c needs opcode names from lopcodes.c
lopcodes.o: ../lopcodes.c ../lopcodes.h
diff --git a/src/luac/luac.c b/src/luac/luac.c
--- a/src/luac/luac.c
+++ b/src/luac/luac.c
/*
-** $Id: luac.c,v 1.44 2003/04/07 20:34:20 lhf Exp $
+** $Id: luac.c,v 1.44a 2003/04/07 20:34:20 lhf Exp $
** Lua compiler (saves bytecodes to files; also list bytecodes)
** See Copyright Notice in lua.h
*/
FILE* D=fopen(output,"wb");
if (D==NULL) cannot(output,"open","out");
if (stripping) strip(L,f);
+ lua_lock(L);
luaU_dump(L,f,writer,D);
+ lua_unlock(L);
if (ferror(D)) cannot(output,"write","out");
fclose(D);
}
diff --git a/src/lvm.c b/src/lvm.c
--- a/src/lvm.c
+++ b/src/lvm.c
/*
-** $Id: lvm.c,v 1.284 2003/04/03 13:35:34 roberto Exp $
+** $Id: lvm.c,v 1.284a 2003/04/03 13:35:34 roberto Exp $
** Lua virtual machine
** See Copyright Notice in lua.h
*/
static void traceexec (lua_State *L) {
lu_byte mask = L->hookmask;
- if (mask > LUA_MASKLINE) { /* instruction-hook set? */
+ if (mask & LUA_MASKCOUNT) { /* instruction-hook set? */
if (L->hookcount == 0) {
resethookcount(L);
luaD_callhook(L, LUA_HOOKCOUNT, -1);
TObject *k;
const Instruction *pc;
callentry: /* entry point when calling new functions */
- L->ci->u.l.pc = &pc;
if (L->hookmask & LUA_MASKCALL)
luaD_callhook(L, LUA_HOOKCALL, -1);
retentry: /* entry point when returning to old functions */
+ L->ci->u.l.pc = &pc;
lua_assert(L->ci->state == CI_SAVEDPC ||
L->ci->state == (CI_SAVEDPC | CI_CALLING));
L->ci->state = CI_HASFRAME; /* activate frame */
}
else { /* yes: continue its execution */
int nresults;
- lua_assert(ci->u.l.pc == &pc &&
- ttisfunction(ci->base - 1) &&
- (ci->state & CI_SAVEDPC));
+ lua_assert(ttisfunction(ci->base - 1) && (ci->state & CI_SAVEDPC));
lua_assert(GET_OPCODE(*(ci->u.l.savedpc - 1)) == OP_CALL);
nresults = GETARG_C(*(ci->u.l.savedpc - 1)) - 1;
luaD_poscall(L, nresults, ra);
diff --git a/test/luac.lua b/test/luac.lua
--- a/test/luac.lua
+++ b/test/luac.lua
-- bare-bones luac in Lua
-- usage: lua luac.lua file.lua
-assert(arg[1]~=nil,"usage: lua luac.lua file.lua")
-f=assert(io.open("luac.out","w"))
-f:write(string.dump(loadfile(arg[1])))
+assert(arg[1]~=nil and arg[2]==nil,"usage: lua luac.lua file.lua")
+f=assert(io.open("luac.out","wb"))
+f:write(string.dump(assert(loadfile(arg[1]))))
io.close(f)