plan9-archive/lua

README+1−1

@@ -1,5 +1,5 @@
1		1
2	This is Lua 5.2 (work5), released on 30 Oct 2010.	2	This is Lua 5.2 (alpha), released on 16 Nov 2010.
3		3
4	For installation instructions, license details, and	4	For installation instructions, license details, and
5	further information about Lua, see doc/readme.html.	5	further information about Lua, see doc/readme.html.

doc/contents.html+7−7

 <P>
 <IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
-<EM>This is a work version of Lua 5.2.
+<EM>This is an alpha version of Lua 5.2.
-Everything may change in the final version.</EM>
+Some details may change in the final version.</EM>
 <P>
 The reference manual is the official definition of the Lua language.
 <LI><A HREF="manual.html#2.1">2.1 &ndash; Values and Types</A>
 <LI><A HREF="manual.html#2.2">2.2 &ndash; Environments and the Global Environment</A>
 <LI><A HREF="manual.html#2.3">2.3 &ndash; Error Handling</A>
-<LI><A HREF="manual.html#2.4">2.4 &ndash; Metatables</A>
+<LI><A HREF="manual.html#2.4">2.4 &ndash; Metatables and Metamethods</A>
 <LI><A HREF="manual.html#2.5">2.5 &ndash; Garbage Collection</A>
 <UL>
 <LI><A HREF="manual.html#2.5.1">2.5.1 &ndash; Garbage-Collection Metamethods</A>
 <A HREF="manual.html#luaL_newlib">luaL_newlib</A><BR>
 <A HREF="manual.html#luaL_newmetatable">luaL_newmetatable</A><BR>
 <A HREF="manual.html#luaL_newstate">luaL_newstate</A><BR>
-<A HREF="manual.html#luaL_setfuncs">luaL_setfuncs</A><BR>
 <A HREF="manual.html#luaL_openlibs">luaL_openlibs</A><BR>
 <A HREF="manual.html#luaL_optint">luaL_optint</A><BR>
 <A HREF="manual.html#luaL_optinteger">luaL_optinteger</A><BR>
 <A HREF="manual.html#luaL_pushresult">luaL_pushresult</A><BR>
 <A HREF="manual.html#luaL_ref">luaL_ref</A><BR>
 <A HREF="manual.html#luaL_requiref">luaL_requiref</A><BR>
+<A HREF="manual.html#luaL_setfuncs">luaL_setfuncs</A><BR>
+<A HREF="manual.html#luaL_setmetatable">luaL_setmetatable</A><BR>
 <A HREF="manual.html#luaL_testudata">luaL_testudata</A><BR>
 <A HREF="manual.html#luaL_tolstring">luaL_tolstring</A><BR>
 <A HREF="manual.html#luaL_traceback">luaL_traceback</A><BR>
 <A HREF="manual.html#luaL_typename">luaL_typename</A><BR>
-<A HREF="manual.html#luaL_typeerror">luaL_typeerror</A><BR>
 <A HREF="manual.html#luaL_unref">luaL_unref</A><BR>
 <A HREF="manual.html#luaL_where">luaL_where</A><BR>
 <HR>
 <SMALL>
 Last update:
-Sat Oct 30 21:34:44 BRST 2010
+Tue Nov 16 09:56:07 BRST 2010
 </SMALL>
 <!--
-Last change: revised for Lua 5.2.0 (work5)
+Last change: revised for Lua 5.2.0 (alpha)
 -->
 </BODY>

doc/manual.html+36−64

 </h1>
 <IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
-<EM>This is a work version of Lua 5.2.
+<EM>This is an alpha version of Lua 5.2.
-Everything may change in the final version.</EM>
+Some details may change in the final version.</EM>
 <P>
 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
 <!-- ====================================================================== -->
 <p>
-<!-- $Id: manual.of,v 1.61 2010/10/29 12:51:39 roberto Exp $ -->
+<!-- $Id: manual.of,v 1.62 2010/11/16 11:38:25 roberto Exp $ -->
-<h2>2.4 &ndash; <a name="2.4">Metatables</a></h2>
+<h2>2.4 &ndash; <a name="2.4">Metatables and Metamethods</a></h2>
 <p>
 Every value in Lua can have a <em>metatable</em>.
 <p>
 We call the keys in a metatable <em>events</em>
 and the values <em>metamethods</em>.
-In the previous example, the event is <code>"add"</code>
+In the previous example, the event is <code>"__add"</code>
 and the metamethod is the function that performs the addition.
 <p>
 For the unary <code>-</code> and <code>#</code> operators,
-the metamethod is called repeating the first argument as a second argument.
+the metamethod is called with a dummy second argument.
 This extra argument is only to simplify Lua's internals;
 it may be removed in future versions and therefore it is not present
 in the following code.
          return realloc(ptr, nsize);
      }
 </pre><p>
-This code assumes
+Note that ANSI&nbsp;C ensures
 that <code>free(NULL)</code> has no effect and that
 <code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.
-ANSI&nbsp;C ensures both behaviors.
+This code assumes that <code>realloc</code> does not fail when shrinking a block.
-It also assumes that <code>realloc</code> does not fail when shrinking a block.
+ANSI&nbsp;C does not ensure this behavior,
-(ANSI&nbsp;C does not ensure this behavior,
+but it seems a safe assumption.
-but it seems a safe assumption.)
+<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p>
+<span class="apii">[-0, +0, <em>-</em>]</span>
+<pre>void luaL_setmetatable (lua_State *L, const char *tname);</pre>
+<p>
+Sets the metatable of the object at the top of the stack
+as the metatable associated with name <code>tname</code>
+in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
 <hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p>
 <span class="apii">[-0, +0, <em>e</em>]</span>
 <pre>void luaL_openlibs (lua_State *L);</pre>
-<hr><h3><a name="luaL_typeerror"><code>luaL_typeerror</code></a></h3><p>
-<span class="apii">[-0, +0, <em>v</em>]</span>
-<pre>int luaL_typeerror (lua_State *L, int narg, const char *tname);</pre>
-<p>
-Generates an error with a message like the following:
-<pre>
-     <em>location</em>: bad argument <em>narg</em> to '<em>func</em>' (<em>tname</em> expected, got <em>rt</em>)
-</pre><p>
-where <code><em>location</em></code> is produced by <a href="#luaL_where"><code>luaL_where</code></a>,
-<code><em>func</em></code> is the name of the current function,
-and <code><em>rt</em></code> is the type name of the actual argument.
 <hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p>
 <span class="apii">[-0, +0, <em>-</em>]</span>
 <pre>void luaL_unref (lua_State *L, int t, int ref);</pre>
 <p>
 Suspends the execution of the calling coroutine.
-The coroutine cannot be running a C&nbsp;function,
-a metamethod, or an iterator.
 Any arguments to <code>yield</code> are passed as extra results to <code>resume</code>.
 <p>
-<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename] [, keepNL])</code></a></h3>
+<hr><h3><a name="pdf-io.lines"><code>io.lines ([filename] &middot;&middot;&middot;)</code></a></h3>
 <p>
 Opens the given file name in read mode
-and returns an iterator function that,
+and returns an iterator function that
-each time it is called,
+works like <code>file:lines(&middot;&middot;&middot;)</code> over the oppened file.
-returns a new line from the file.
-Therefore, the construction
-<pre>
-     for line in io.lines(filename) do <em>body</em> end
-</pre><p>
-will iterate over all lines of the file.
 When the iterator function detects the end of file,
 it returns <b>nil</b> (to finish the loop) and automatically closes the file.
 In this case it does not close the file when the loop ends.
-<p>
-By default, <code>lines</code> removes the newline at the end of each line.
-If <code>keepNL</code> is <b>true</b>, it will keep the newlines.
 <p>
 <p>
-<hr><h3><a name="pdf-file:lines"><code>file:lines ([keepNL])</code></a></h3>
+<hr><h3><a name="pdf-file:lines"><code>file:lines (&middot;&middot;&middot;)</code></a></h3>
 <p>
 Returns an iterator function that,
 each time it is called,
-returns a new line from the file.
+reads the file according to the given formats.
+When no format is given,
+uses "*l" as a default.
 Therefore, the construction
 <pre>
-     for line in file:lines() do <em>body</em> end
+     for c in file:lines(1) do <em>body</em> end
 </pre><p>
-will iterate over all lines of the file,
+will iterate over all characters of the file,
 starting at the current position.
 (Unlike <a href="#pdf-io.lines"><code>io.lines</code></a>, this function does not close the file
 when the loop ends.)
-<p>
-By default, <code>lines</code> removes the newline at the end of each line.
-If <code>keepNL</code> is <b>true</b>, it will keep the newlines.
 <p>
 and it is easy to set up a module with regular Lua code.
 </li>
-<li>
-The debug library is not loaded by default.
-You must explicitly require it.
-</li>
 <li>
 Functions <code>setfenv</code> and <code>getfenv</code> are deprecated.
 To set the environment of a Lua function,
 </li>
 <li>
-<code>luaL_typerror</code> was renamed <a href="#luaL_typeerror"><code>luaL_typeerror</code></a>,
+<code>luaL_typerror</code> was deprecated.
-to have a correct spelling.
+Write your own version if you need it.
 </li>
 <li>
 <HR>
 <SMALL>
 Last update:
-Sat Oct 30 21:36:20 BRST 2010
+Tue Nov 16 09:52:41 BRST 2010
 </SMALL>
 <!--
-Last change: revised for Lua 5.2.0 (work5)
+Last change: revised for Lua 5.2.0 (alpha)
 -->
 </body></html>

doc/readme.html+8−7

 <HR>
 <H1>
 <A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua" BORDER=0></A>
-Welcome to Lua 5.2 (work5)
+Welcome to Lua 5.2 (alpha)
 </H1>
 <P>
 <IMG SRC="alert.png" ALIGN="absbottom" ALT="[!]">
-<EM>This is a work version of Lua 5.2.
+<EM>This is an alpha version of Lua 5.2.
-Everything may change in the final version.</EM>
+Some details may change in the final version.</EM>
 <P>
 <A HREF="#about">about</A>
 <LI> new <CODE>lua_compare</CODE>, <CODE>lua_arith</CODE>, and <CODE>lua_len</CODE>
 <LI> new <CODE>lua_version</CODE> and <CODE>luaL_version</CODE>
 <LI> <CODE>lua_pushstring</CODE> and <CODE>pushlstring</CODE> return string
-<LI> new <CODE>luaL_testudata</CODE>
+<LI> new <CODE>luaL_testudata</CODE> and <CODE>luaL_setmetatable</CODE>
 <LI> new <CODE>luaL_tolstring</CODE>
 <LI> new <CODE>lua_copy</CODE>
 <LI> new <CODE>lua_absindex</CODE>
 <LI> new <CODE>lua_upvalueid</CODE> and <CODE>lua_upvaluejoin</CODE>
 <LI> <CODE>nparams</CODE> and <CODE>isvarag</CODE> available in debug API
+<LI> new <CODE>lua_Unsigned</CODE>
 </UL>
 <H3>Implementation</H3>
 <LI> internal (immutable) version of ctypes
 <LI> simpler implementation for string buffers
 <LI> udata with finalizers are kept in a separated list for the GC
-<LI> <CODE>CallInfo</CODE>stack now is a linked list
+<LI> <CODE>CallInfo</CODE> stack now is a linked list
 <LI> parser uses much less C-stack space (no more auto arrays)
 <LI> new hash for floats
 <LI> handling of non-string error messages in the standalone interpreter
 <HR>
 <SMALL>
 Last update:
-Sat Oct 30 21:36:38 BRST 2010
+Thu Nov 11 15:16:22 BRST 2010
 </SMALL>
 <!--
-Last change: revised for Lua 5.2.0 (work5)
+Last change: revised for Lua 5.2.0 (alpha)
 -->
 </BODY>

src/Makefile+2−2

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	PLAT= none	7	PLAT= none
8		8
9	CC= gcc	9	CC= gcc
10	CFLAGS= -O2 -Wall $(MYCFLAGS)	10	CFLAGS= -O2 -Wall -DLUA_COMPAT_ALL $(MYCFLAGS)
11	LIBS= -lm $(MYLIBS)	11	LIBS= -lm $(MYLIBS)
12		12
13	AR= ar rcu	13	AR= ar rcu
@@ -97,7 +97,7 @@ freebsd: · 83 unmodified lines
97	generic: $(ALL)	97	generic: $(ALL)
98		98
99	linux:	99	linux:
100	$(MAKE) $(ALL) MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -ldl -lreadline -lncurses"	100	$(MAKE) $(ALL) MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -ldl -lreadline"
101		101
102	macosx:	102	macosx:
103	$(MAKE) $(ALL) MYCFLAGS="-DLUA_USE_MACOSX" MYLIBS="-lreadline"	103	$(MAKE) $(ALL) MYCFLAGS="-DLUA_USE_MACOSX" MYLIBS="-lreadline"

src/lapi.c+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lapi.c,v 2.139 2010/10/25 20:31:11 roberto Exp $	2	** $Id: lapi.c,v 2.140 2010/11/03 15:16:17 roberto Exp $
3	** Lua API	3	** Lua API
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -353,7 +353,7 @@ LUA_API lua_Unsigned lua_tounsignedx (lua_State L, int idx, int isnum) { · 347 unmodified lines
353	if (tonumber(o, &n)) {	353	if (tonumber(o, &n)) {
354	lua_Unsigned res;	354	lua_Unsigned res;
355	lua_Number num = nvalue(o);	355	lua_Number num = nvalue(o);
356	lua_number2uint(res, num);	356	lua_number2unsigned(res, num);
357	if (isnum) *isnum = 1;	357	if (isnum) *isnum = 1;
358	return res;	358	return res;
359	}	359	}
@@ -472,7 +472,7 @@ LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) { · 112 unmodified lines
472	LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) {	472	LUA_API void lua_pushunsigned (lua_State *L, lua_Unsigned u) {
473	lua_Number n;	473	lua_Number n;
474	lua_lock(L);	474	lua_lock(L);
475	n = lua_uint2number(u);	475	n = lua_unsigned2number(u);
476	setnvalue(L->top, n);	476	setnvalue(L->top, n);
477	api_incr_top(L);	477	api_incr_top(L);
478	lua_unlock(L);	478	lua_unlock(L);

src/lauxlib.c+11−5

 /*
-** $Id: lauxlib.c,v 1.224 2010/10/29 12:52:21 roberto Exp $
+** $Id: lauxlib.c,v 1.227 2010/11/10 18:05:36 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 }
-LUALIB_API int luaL_typeerror (lua_State *L, int narg, const char *tname) {
+static int typeerror (lua_State *L, int narg, const char *tname) {
   const char *msg = lua_pushfstring(L, "%s expected, got %s",
                                     tname, luaL_typename(L, narg));
   return luaL_argerror(L, narg, msg);
 static void tag_error (lua_State *L, int narg, int tag) {
-  luaL_typeerror(L, narg, lua_typename(L, tag));
+  typeerror(L, narg, lua_typename(L, tag));
 }
 }
+LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) {
+  luaL_getmetatable(L, tname);
+  lua_setmetatable(L, -2);
+}
 LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) {
   void *p = lua_touserdata(L, ud);
   if (p != NULL) {  /* value is a userdata? */
 LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
   void *p = luaL_testudata(L, ud, tname);
-  if (p == NULL) luaL_typeerror(L, ud, tname);
+  if (p == NULL) typeerror(L, ud, tname);
   return p;
 }
     if (newsize - B->n < sz)  /* not bit enough? */
       newsize = B->n + sz;
     if (newsize < B->n || newsize - B->n < sz)
-      luaL_error(L, "string too large");
+      luaL_error(L, "buffer too large");
     newbuff = (char *)lua_newuserdata(L, newsize);  /* create larger buffer */
     memcpy(newbuff, B->b, B->n);  /* move content to new buffer */
     if (buffonstack(B))

src/lauxlib.h+2−2

 /*
-** $Id: lauxlib.h,v 1.109 2010/10/25 20:31:11 roberto Exp $
+** $Id: lauxlib.h,v 1.111 2010/11/10 18:05:36 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
 LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
 LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
-LUALIB_API int (luaL_typeerror) (lua_State *L, int narg, const char *tname);
 LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
 LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
                                                           size_t *l);
 LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
 LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
 LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
 LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);

src/lbitlib.c+2−2

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: lbitlib.c,v 1.10 2010/10/28 15:17:29 roberto Exp $	2	** $Id: lbitlib.c,v 1.11 2010/11/08 16:31:22 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	*/
@@ -108,7 +108,7 @@ static int b_rshift (lua_State *L) { · 102 unmodified lines
108	static int b_arshift (lua_State *L) {	108	static int b_arshift (lua_State *L) {
109	b_uint r = getuintarg(L, 1);	109	b_uint r = getuintarg(L, 1);
110	int i = luaL_checkint(L, 2);	110	int i = luaL_checkint(L, 2);
111	if (i < 0 \|\| !(r & (1 << (NBITS - 1))))	111	if (i < 0 \|\| !(r & ((b_uint)1 << (NBITS - 1))))
112	return b_shift(L, r, -i);	112	return b_shift(L, r, -i);
113	else { /* arithmetic shift for 'negative' number */	113	else { /* arithmetic shift for 'negative' number */
114	if (i >= NBITS) r = ALLONES;	114	if (i >= NBITS) r = ALLONES;

src/ldblib.c+10−3

 /*
-** $Id: ldblib.c,v 1.124 2010/07/25 15:18:19 roberto Exp $
+** $Id: ldblib.c,v 1.125 2010/11/10 18:06:10 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 }
+static void checkudata (lua_State *L, int narg) {
+  if (lua_type(L, narg) == LUA_TLIGHTUSERDATA)
+    luaL_argerror(L, narg, "full userdata expected, got light userdata");
+  luaL_checktype(L, narg, LUA_TUSERDATA);
+}
 static int db_getuservalue (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TUSERDATA);
+  checkudata(L, 1);
   lua_getuservalue(L, 1);
   return 1;
 }
 static int db_setuservalue (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TUSERDATA);
+  checkudata(L, 1);
   if (!lua_isnoneornil(L, 2))
     luaL_checktype(L, 2, LUA_TTABLE);
   lua_settop(L, 2);

src/linit.c+1−4

 /*
-** $Id: linit.c,v 1.29 2010/10/25 14:32:36 roberto Exp $
+** $Id: linit.c,v 1.30 2010/11/12 15:48:30 roberto Exp $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
   {LUA_STRLIBNAME, luaopen_string},
   {LUA_BITLIBNAME, luaopen_bit32},
   {LUA_MATHLIBNAME, luaopen_math},
-#if defined(LUA_COMPAT_DEBUGLIB)
   {LUA_DBLIBNAME, luaopen_debug},
-#endif
   {NULL, NULL}
 };
 ** these libs are preloaded and must be required before used
 */
 static const luaL_Reg preloadedlibs[] = {
-  {LUA_DBLIBNAME, luaopen_debug},
   {NULL, NULL}
 };

src/liolib.c+28−16

 /*
-** $Id: liolib.c,v 2.92 2010/10/25 19:01:37 roberto Exp $
+** $Id: liolib.c,v 2.95 2010/11/10 18:05:36 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
 #include "lualib.h"
+#define MAX_SIZE_T	(~(size_t)0)
 /*
 ** lua_popen spawns a new process connected to the current one through
 ** the file streams.
 static FILE **newprefile (lua_State *L) {
   FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
   *pf = NULL;  /* file handle is currently `closed' */
-  luaL_getmetatable(L, LUA_FILEHANDLE);
+  luaL_setmetatable(L, LUA_FILEHANDLE);
-  lua_setmetatable(L, -2);
   return pf;
 }
 }
-static int read_chars (lua_State *L, FILE *f, size_t n) {
+static void read_all (lua_State *L, FILE *f) {
-  size_t tbr = n;  /* number of chars to be read */
+  size_t rlen = LUAL_BUFFERSIZE;  /* how much to read in each cycle */
-  size_t rlen;  /* how much to read in each cycle */
-  size_t nr;  /* number of chars actually read in each cycle */
   luaL_Buffer b;
   luaL_buffinit(L, &b);
-  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
+  for (;;) {
-  do {
+    char *p = luaL_prepbuffsize(&b, rlen);
-    char *p = luaL_prepbuffer(&b);
+    size_t nr = fread(p, sizeof(char), rlen, f);
-    if (rlen > tbr) rlen = tbr;  /* cannot read more than asked */
-    nr = fread(p, sizeof(char), rlen, f);
     luaL_addsize(&b, nr);
-    tbr -= nr;  /* still have to read 'tbr' chars */
+    if (nr < rlen) break;  /* eof? */
-  } while (tbr > 0 && nr == rlen);  /* until end of count or eof */
+    else if (rlen <= (MAX_SIZE_T / 4))  /* avoid buffers too large */
+      rlen *= 2;  /* double buffer size at each iteration */
+  }
+  luaL_pushresult(&b);  /* close buffer */
+}
+static int read_chars (lua_State *L, FILE *f, size_t n) {
+  size_t nr;  /* number of chars actually read */
+  char *p;
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  p = luaL_prepbuffsize(&b, n);  /* prepare buffer to read whole block */
+  nr = fread(p, sizeof(char), n, f);  /* try to read 'n' chars */
+  luaL_addsize(&b, nr);
   luaL_pushresult(&b);  /* close buffer */
-  return (tbr < n);  /* true iff read something */
+  return (nr > 0);  /* true iff read something */
 }
             success = read_line(L, f, 0);
             break;
           case 'a':  /* file */
-            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
+            read_all(L, f);  /* read entire file */
             success = 1; /* always success */
             break;
           default:

src/llimits.h+91−1

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: llimits.h,v 1.82 2010/05/31 16:08:55 roberto Exp $	2	** $Id: llimits.h,v 1.84 2010/11/08 16:33:20 roberto Exp $
3	** Limits, basic types, and some other `installation-dependent' definitions	3	** Limits, basic types, and some other `installation-dependent' definitions
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -168,6 +168,96 @@ typedef lu_int32 Instruction; · 162 unmodified lines
168	#define luai_userstateyield(L,n) ((void)L)	168	#define luai_userstateyield(L,n) ((void)L)
169	#endif	169	#endif
170		170
		171	/*
		172	** lua_number2int is a macro to convert lua_Number to int.
		173	** lua_number2integer is a macro to convert lua_Number to lua_Integer.
		174	** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned.
		175	** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number.
		176	*/
		177
		178	#if defined(MS_ASMTRICK) /* { */
		179	/* trick with Microsoft assembler for X86 */
		180
		181	#define lua_number2int(i,n) __asm {__asm fld n __asm fistp i}
		182	#define lua_number2integer(i,n) lua_number2int(i, n)
		183	#define lua_number2unsigned(i,n) \
		184	{__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;}
		185
		186
		187	#elif defined(LUA_IEEE754TRICK) /* }{ */
		188	/* the next trick should work on any machine using IEEE754 with
		189	a 32-bit integer type */
		190
		191	union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
		192
		193	#if !defined(LUA_IEEEENDIAN) /* { */
		194	#define LUAI_EXTRAIEEE \
		195	static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
		196	#define LUA_IEEEENDIAN (ieeeendian.l_p[1] == 33)
		197	#else
		198	#define LUAI_EXTRAIEEE /* empty */
		199	#endif /* } */
		200
		201	#define lua_number2int32(i,n,t) \
		202	{ LUAI_EXTRAIEEE \
		203	volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
		204	(i) = (t)u.l_p[LUA_IEEEENDIAN]; }
		205
		206	#define lua_number2int(i,n) lua_number2int32(i, n, int)
		207	#define lua_number2integer(i,n) lua_number2int32(i, n, lua_Integer)
		208	#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned)
		209
		210	#endif /* } */
		211
		212
		213	/* the following definitions always work, but may be slow */
		214
		215	#if !defined(lua_number2int)
		216	#define lua_number2int(i,n) ((i)=(int)(n))
		217	#endif
		218
		219	#if !defined(lua_number2integer)
		220	#define lua_number2integer(i,n) ((i)=(lua_Integer)(n))
		221	#endif
		222
		223	#if !defined(lua_number2unsigned) /* { */
		224	/* the following definition assures proper modulo behavior */
		225	#if defined(LUA_NUMBER_DOUBLE)
		226	#include <math.h>
		227	#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1)
		228	#define lua_number2unsigned(i,n) \
		229	((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
		230	#else
		231	#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n))
		232	#endif
		233	#endif /* } */
		234
		235
		236	#if !defined(lua_unsigned2number)
		237	/* on several machines, coercion from unsigned to double is slow,
		238	so it may be worth to avoid */
		239	#define lua_unsigned2number(u) \
		240	(((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
		241	#endif
		242
		243
		244	/*
		245	** luai_hashnum is a macro do hash a lua_Number value into an integer.
		246	** The hash must be deterministic and give reasonable values for
		247	** both small and large values (outside the range of integers).
		248	** It is used only in ltable.c.
		249	*/
		250
		251	#if !defined(luai_hashnum) /* { */
		252
		253	#include <float.h>
		254	#include <math.h>
		255
		256	#define luai_hashnum(i,n) { int e; \
		257	n = frexp(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP); \
		258	lua_number2int(i, n); i += e; }
		259
		260	#endif /* } */
171		261
172		262
173		263

src/lmathlib.c+38−28

 /*
-** $Id: lmathlib.c,v 1.76 2010/10/25 20:31:11 roberto Exp $
+** $Id: lmathlib.c,v 1.78 2010/11/12 15:47:34 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 #define RADIANS_PER_DEGREE (PI/180.0)
+/* macro 'l_tg' allows the addition of an 'l' or 'f' to all math operations */
+#if !defined(l_tg)
+#define l_tg(x)		(x)
+#endif
 static int math_abs (lua_State *L) {
-  lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(fabs)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_sin (lua_State *L) {
-  lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(sin)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_sinh (lua_State *L) {
-  lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(sinh)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_cos (lua_State *L) {
-  lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(cos)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_cosh (lua_State *L) {
-  lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(cosh)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_tan (lua_State *L) {
-  lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(tan)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_tanh (lua_State *L) {
-  lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(tanh)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_asin (lua_State *L) {
-  lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(asin)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_acos (lua_State *L) {
-  lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(acos)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_atan (lua_State *L) {
-  lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(atan)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_atan2 (lua_State *L) {
-  lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  lua_pushnumber(L, l_tg(atan2)(luaL_checknumber(L, 1),
+                                luaL_checknumber(L, 2)));
   return 1;
 }
 static int math_ceil (lua_State *L) {
-  lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(ceil)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_floor (lua_State *L) {
-  lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(floor)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_fmod (lua_State *L) {
-  lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  lua_pushnumber(L, l_tg(fmod)(luaL_checknumber(L, 1),
+                               luaL_checknumber(L, 2)));
   return 1;
 }
 static int math_modf (lua_State *L) {
-  double ip;
+  lua_Number ip;
-  double fp = modf(luaL_checknumber(L, 1), &ip);
+  lua_Number fp = l_tg(modf)(luaL_checknumber(L, 1), &ip);
   lua_pushnumber(L, ip);
   lua_pushnumber(L, fp);
   return 2;
 }
 static int math_sqrt (lua_State *L) {
-  lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(sqrt)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_pow (lua_State *L) {
-  lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  lua_pushnumber(L, l_tg(pow)(luaL_checknumber(L, 1),
+                              luaL_checknumber(L, 2)));
   return 1;
 }
   lua_Number x = luaL_checknumber(L, 1);
   lua_Number res;
   if (lua_isnoneornil(L, 2))
-    res = log(x);
+    res = l_tg(log)(x);
   else {
     lua_Number base = luaL_checknumber(L, 2);
-    if (base == 10.0) res = log10(x);
+    if (base == 10.0) res = l_tg(log10)(x);
-    else res = log(x)/log(base);
+    else res = l_tg(log)(x)/l_tg(log)(base);
   }
   lua_pushnumber(L, res);
   return 1;
   luaL_error(L, "function " LUA_QL("log10")
                 " is deprecated; use log(x, 10) instead");
 #endif
-  lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(log10)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_exp (lua_State *L) {
-  lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
+  lua_pushnumber(L, l_tg(exp)(luaL_checknumber(L, 1)));
   return 1;
 }
 static int math_frexp (lua_State *L) {
   int e;
-  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
+  lua_pushnumber(L, l_tg(frexp)(luaL_checknumber(L, 1), &e));
   lua_pushinteger(L, e);
   return 2;
 }
 static int math_ldexp (lua_State *L) {
-  lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
+  lua_pushnumber(L, l_tg(ldexp)(luaL_checknumber(L, 1),
+                                luaL_checkint(L, 2)));
   return 1;
 }
     case 1: {  /* only upper limit */
       lua_Number u = luaL_checknumber(L, 1);
       luaL_argcheck(L, 1.0 <= u, 1, "interval is empty");
-      lua_pushnumber(L, floor(r*u) + 1.0);  /* int between 1 and `u' */
+      lua_pushnumber(L, l_tg(floor)(r*u) + 1.0);  /* int in [1, u] */
       break;
     }
     case 2: {  /* lower and upper limits */
       lua_Number l = luaL_checknumber(L, 1);
       lua_Number u = luaL_checknumber(L, 2);
       luaL_argcheck(L, l <= u, 2, "interval is empty");
-      lua_pushnumber(L, floor(r*(u-l+1)) + l);  /* int between `l' and `u' */
+      lua_pushnumber(L, l_tg(floor)(r*(u-l+1)) + l);  /* int in [l, u] */
       break;
     }
     default: return luaL_error(L, "wrong number of arguments");

src/loadlib.c+4−14

 /*
-** $Id: loadlib.c,v 1.92 2010/10/29 14:35:09 roberto Exp $
+** $Id: loadlib.c,v 1.94 2010/11/10 20:00:04 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
     lua_pop(L, 1);  /* remove result from gettable */
     plib = (void **)lua_newuserdata(L, sizeof(const void *));
     *plib = NULL;
-    luaL_getmetatable(L, "_LOADLIB");
+    luaL_setmetatable(L, "_LOADLIB");
-    lua_setmetatable(L, -2);
     lua_pushfstring(L, "%s%s", LIBPREFIX, path);
     lua_pushvalue(L, -2);
     lua_settable(L, LUA_REGISTRYINDEX);
 }
-static const int sentinel_ = 0;
-#define sentinel	((void *)&sentinel_)
 static int ll_require (lua_State *L) {
   const char *name = luaL_checkstring(L, 1);
   int i;
   lua_settop(L, 1);  /* _LOADED table will be at index 2 */
   lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
   lua_getfield(L, 2, name);
-  if (lua_toboolean(L, -1)) {  /* is it there? */
+  if (lua_toboolean(L, -1))  /* is it there? */
-    if (lua_touserdata(L, -1) == sentinel)  /* check loops */
-      luaL_error(L, "loop or previous error loading module " LUA_QS, name);
     return 1;  /* package is already loaded */
-  }
   /* else must load it; iterate over available loaders */
   lua_getfield(L, lua_upvalueindex(1), "loaders");
   if (!lua_istable(L, -1))
     else
       lua_pop(L, 1);
   }
-  lua_pushlightuserdata(L, sentinel);
-  lua_setfield(L, 2, name);  /* _LOADED[name] = sentinel */
   lua_pushstring(L, name);  /* pass name as argument to module */
   lua_call(L, 1, 1);  /* run loaded module */
   if (!lua_isnil(L, -1))  /* non-nil return? */
     lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
   lua_getfield(L, 2, name);
-  if (lua_touserdata(L, -1) == sentinel) {   /* module did not set a 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 */

src/lstrlib.c+25−8

 /*
-** $Id: lstrlib.c,v 1.156 2010/10/29 17:52:46 roberto Exp $
+** $Id: lstrlib.c,v 1.157 2010/11/08 17:38:37 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
 ** 'string.format'; LUA_INTFRM_T is the integer type corresponding to
 ** the previous length
 */
+#if !defined(LUA_INTFRMLEN)	/* { */
 #if defined(LUA_USELONGLONG)
 #define LUA_INTFRMLEN           "ll"
 #define LUA_INTFRMLEN           "l"
 #define LUA_INTFRM_T            long
+#endif
+#endif				/* } */
+/*
+** LUA_FLTFRMLEN is the length modifier for float conversions in
+** 'string.format'; LUA_FLTFRM_T is the float type corresponding to
+** the previous length
+*/
+#if !defined(LUA_FLTFRMLEN)
+#define LUA_FLTFRMLEN           ""
+#define LUA_FLTFRM_T            double
 #endif
 /*
-** add length modifier into integer formats
+** add length modifier into formats
 */
-static void addintlen (char *form) {
+static void addlenmod (char *form, const char *lenmod) {
   size_t l = strlen(form);
+  size_t lm = strlen(lenmod);
   char spec = form[l - 1];
-  strcpy(form + l - 1, LUA_INTFRMLEN);
+  strcpy(form + l - 1, lenmod);
-  form[l + sizeof(LUA_INTFRMLEN) - 2] = spec;
+  form[l + lm - 1] = spec;
-  form[l + sizeof(LUA_INTFRMLEN) - 1] = '\0';
+  form[l + lm] = '\0';
 }
           lua_Number n = luaL_checknumber(L, arg);
           LUA_INTFRM_T r = (n < 0) ? (LUA_INTFRM_T)n :
                                      (LUA_INTFRM_T)(unsigned LUA_INTFRM_T)n;
-          addintlen(form);
+          addlenmod(form, LUA_INTFRMLEN);
           nb = sprintf(buff, form, r);
           break;
         }
         case 'e':  case 'E': case 'f':
         case 'g': case 'G': {
-          nb = sprintf(buff, form, (double)luaL_checknumber(L, arg));
+          addlenmod(form, LUA_FLTFRMLEN);
+          nb = sprintf(buff, form, (LUA_FLTFRM_T)luaL_checknumber(L, arg));
           break;
         }
         case 'q': {

src/ltable.c+3−3

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: ltable.c,v 2.52 2010/06/25 12:18:10 roberto Exp $	2	** $Id: ltable.c,v 2.53 2010/11/11 15:38:43 roberto Exp $
3	** Lua tables (hash)	3	** Lua tables (hash)
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -38,8 +38,8 @@ · 32 unmodified lines
38	/*	38	/*
39	** max size of array part is 2^MAXBITS	39	** max size of array part is 2^MAXBITS
40	*/	40	*/
41	#if LUAI_BITSINT > 26	41	#if LUAI_BITSINT >= 32
42	#define MAXBITS 26	42	#define MAXBITS 30
43	#else	43	#else
44	#define MAXBITS (LUAI_BITSINT-2)	44	#define MAXBITS (LUAI_BITSINT-2)
45	#endif	45	#endif

src/lua.h+1−1

@@ -18,7 +18,7 @@ · 17 unmodified lines
18		18
19	#define LUA_VERSION_MAJOR "5"	19	#define LUA_VERSION_MAJOR "5"
20	#define LUA_VERSION_MINOR "2"	20	#define LUA_VERSION_MINOR "2"
21	#define LUA_VERSION_RELEASE "0" " (work5)"	21	#define LUA_VERSION_RELEASE "0" " (alpha)"
22		22
23	#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR	23	#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
24	#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE	24	#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE

src/luaconf.h+13−115

@@ -1,5 +1,5 @@
1	/*	1	/*
2	** $Id: luaconf.h,v 1.148 2010/10/29 17:52:46 roberto Exp $	2	** $Id: luaconf.h,v 1.151 2010/11/12 15:48:30 roberto Exp $
3	** Configuration file for Lua	3	** Configuration file for Lua
4	** See Copyright Notice in lua.h	4	** See Copyright Notice in lua.h
5	*/	5	*/
@@ -229,7 +229,7 @@ · 223 unmodified lines
229	** You can define it to get all options, or change specific options	229	** You can define it to get all options, or change specific options
230	** to fit your specific needs.	230	** to fit your specific needs.
231	*/	231	*/
232	#if defined(LUA_COMPAT_ALL)	232	#if defined(LUA_COMPAT_ALL) /* { */
233		233
234	/*	234	/*
235	@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.	235	@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
@@ -238,8 +238,8 @@ · 2 unmodified lines
238	#define LUA_COMPAT_UNPACK	238	#define LUA_COMPAT_UNPACK
239		239
240	/*	240	/*
241	@@ LUA_COMPAT_CPCALL controls the presence of macro 'lua_cpcall'.	241	@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
242	** You can call your C function directly (with light C functions)	242	** You can call your C function directly (with light C functions).
243	*/	243	*/
244	#define lua_cpcall(L,f,u) \	244	#define lua_cpcall(L,f,u) \
245	(lua_pushcfunction(L, (f)), \	245	(lua_pushcfunction(L, (f)), \
@@ -258,14 +258,6 @@ · 12 unmodified lines
258	*/	258	*/
259	#define LUA_COMPAT_MAXN	259	#define LUA_COMPAT_MAXN
260		260
261	/*
262	@@ LUA_COMPAT_DEBUGLIB controls compatibility with preloading
263	** the debug library.
264	** You should add 'require"debug"' everywhere you need the debug
265	** library.
266	*/
267	#define LUA_COMPAT_DEBUGLIB
268
269	/*	261	/*
270	@@ The following macros supply trivial compatibility for some	262	@@ The following macros supply trivial compatibility for some
271	** changes in the API. The macros themselves document how to	263	** changes in the API. The macros themselves document how to
@@ -275,19 +267,16 @@ · 3 unmodified lines
275		267
276	#define lua_objlen(L,i) lua_rawlen(L, (i))	268	#define lua_objlen(L,i) lua_rawlen(L, (i))
277		269
278	#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)	270	#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
279	#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)	271	#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
280		272
281	/* compatibility with previous wrong spelling */
282	#define luaL_typerror luaL_typeerror
283
284	/*	273	/*
285	@@ LUA_COMPAT_MODULE controls compatibility with previous	274	@@ LUA_COMPAT_MODULE controls compatibility with previous
286	** module functions 'module' (Lua) and 'luaL_register' (C).	275	** module functions 'module' (Lua) and 'luaL_register' (C).
287	*/	276	*/
288	#define LUA_COMPAT_MODULE	277	#define LUA_COMPAT_MODULE
289		278
290	#endif /* LUA_COMPAT_ALL */	279	#endif /* } */
291		280
292	/* }================================================================== */	281	/* }================================================================== */
293		282
@@ -348,27 +337,13 @@ · 54 unmodified lines
348		337
349		338
350		339
351	/*
352	** {==================================================================
353	** CHANGE (to smaller values) the following definitions if your system
354	** has a small C stack. (Or you may want to change them to larger
355	** values if your system has a large C stack and these limits are
356	** too rigid for you.) Some of these constants control the size of
357	** stack-allocated arrays used by the compiler or the interpreter, while
358	** others limit the maximum number of recursive calls that the compiler
359	** or the interpreter can perform. Values too large may cause a C stack
360	** overflow for some forms of deep constructs.
361	** ===================================================================
362	*/
363
364		340
365	/*	341	/*
366	@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.	342	@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
		343	** CHANGE it if it uses too much C-stack space.
367	*/	344	*/
368	#define LUAL_BUFFERSIZE BUFSIZ	345	#define LUAL_BUFFERSIZE BUFSIZ
369		346
370	/* }================================================================== */
371
372		347
373		348
374		349
@@ -445,32 +420,21 @@ · 70 unmodified lines
445	#define LUA_UNSIGNED unsigned LUA_INT32	420	#define LUA_UNSIGNED unsigned LUA_INT32
446		421
447		422
448	/*
449	@@ lua_number2int is a macro to convert lua_Number to int.
450	@@ lua_number2integer is a macro to convert lua_Number to LUA_INTEGER.
451	@@ lua_number2uint is a macro to convert a lua_Number to a LUA_UNSIGNED.
452	@@ lua_uint2number is a macro to convert a LUA_UNSIGNED to a lua_Number.
453	*/
454
455	#if defined(LUA_CORE) /* { */	423	#if defined(LUA_CORE) /* { */
456		424
457	#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && \	425	#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */
458	!defined(LUA_NOIEEE754TRICK) /* { */
459		426
460	/* On a Microsoft compiler on a Pentium, use assembler to avoid clashes	427	/* On a Microsoft compiler on a Pentium, use assembler to avoid clashes
461	with a DirectX idiosyncrasy */	428	with a DirectX idiosyncrasy */
462	#if defined(_MSC_VER) && defined(M_IX86) /* { */	429	#if defined(_MSC_VER) && defined(M_IX86) /* { */
463		430
464	#define lua_number2int(i,n) __asm {__asm fld n __asm fistp i}	431	#define MS_ASMTRICK
465	#define lua_number2integer(i,n) lua_number2int(i, n)
466	#define lua_number2uint(i,n) \
467	{__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;}
468		432
469	#else /* }{ */	433	#else /* }{ */
470	/* the next trick should work on any machine using IEEE754 with	434	/* the next definition uses a trick that should work on any machine
471	a 32-bit integer type */	435	using IEEE754 with a 32-bit integer type */
472		436
473	union luai_Cast { double l_d; LUA_INT32 l_p[2]; };	437	#define LUA_IEEE754TRICK
474		438
475	/*	439	/*
476	@@ LUA_IEEEENDIAN is the endianness of doubles in your machine	440	@@ LUA_IEEEENDIAN is the endianness of doubles in your machine
@@ -485,77 +449,11 @@ union luai_Cast { double l_d; LUA_INT32 l_p[2]; }; · 8 unmodified lines
485	#define LUA_IEEEENDIAN 1	449	#define LUA_IEEEENDIAN 1
486	#endif	450	#endif
487		451
488	#if !defined(LUA_IEEEENDIAN) /* { */
489	#define LUAI_EXTRAIEEE \
490	static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
491	#define LUA_IEEEENDIAN (ieeeendian.l_p[1] == 33)
492	#else
493	#define LUAI_EXTRAIEEE /* empty */
494	#endif /* } */
495
496	#define lua_number2int32(i,n,t) \
497	{ LUAI_EXTRAIEEE \
498	volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
499	(i) = (t)u.l_p[LUA_IEEEENDIAN]; }
500
501	#define lua_number2int(i,n) lua_number2int32(i, n, int)
502	#define lua_number2integer(i,n) lua_number2int32(i, n, LUA_INTEGER)
503	#define lua_number2uint(i,n) lua_number2int32(i, n, LUA_UNSIGNED)
504
505	#endif /* } */	452	#endif /* } */
506		453
507
508	#endif /* } */	454	#endif /* } */
509		455
510		456	#endif /* } */
511	/* the following definitions always work, but may be slow */
512
513	#if !defined(lua_number2int)
514	#define lua_number2int(i,n) ((i)=(int)(n))
515	#endif
516
517	#if !defined(lua_number2integer)
518	#define lua_number2integer(i,n) ((i)=(LUA_INTEGER)(n))
519	#endif
520
521	#if !defined(lua_number2uint) && (defined(lapi_c) \|\| defined(luaall_c)) /* { */
522	/* the following definition assures proper modulo behavior */
523	#if defined(LUA_NUMBER_DOUBLE)
524	#include <math.h>
525	#define lua_number2uint(i,n) \
526	((i)=(LUA_UNSIGNED)((n) - floor((n)/4294967296.0)*4294967296.0))
527	#else
528	#define lua_number2uint(i,n) ((i)=(LUA_UNSIGNED)(n))
529	#endif
530	#endif /* } */
531
532	#if !defined(lua_uint2number)
533	/* on several machines, coercion from unsigned to double is slow,
534	so it may be worth to avoid */
535	#define lua_uint2number(u) \
536	((LUA_INT32)(u) < 0 ? (lua_Number)(u) : (lua_Number)(LUA_INT32)(u))
537	#endif
538
539	#endif /* } */
540
541
542	/*
543	@@ luai_hashnum is a macro do hash a lua_Number value into an integer.
544	@* The hash must be deterministic and give reasonable values for
545	@* both small and large values (outside the range of integers).
546	@* It is used only in ltable.c.
547	*/
548
549	#if defined(ltable_c) \|\| defined(luaall_c)
550
551	#include <float.h>
552	#include <math.h>
553
554	#define luai_hashnum(i,n) { int e; \
555	n = frexp(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP); \
556	lua_number2int(i, n); i += e; }
557
558	#endif /* ltable_c */
559		457
560	/* }================================================================== */	458	/* }================================================================== */
561		459