AppPkg: Add the Lua interpreter and library.

StdLib: Add support and include files for Lua.

The sources for the Lua standalone interpreter, as well as its library, have been added to AppPkg/Applications/Lua.  The Lua library, LuaLib, can be used to embed Lua into new applications.

The Lua header files, needed for both building and embedding, are located in StdLib/Include/Lua.  The original versions of these header files, in the source directory, have been converted into stubs that reference the include files in StdLib.  This allows us to keep the Lua sources as close to the distributed version as possible.

Documentation is contained in the Lua/doc directory.  Further information is available at www.lua.org.

Contributed-under: TianoCore Contribution Agreement 1.0
Signed Off by:  Bruce Maynard <Bruce.Maynard@Emulex.Com>
Reviewed by:    Daryl McDaniel <daryl.mcdaniel@intel.com>


git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@16313 6f19259b-4bc3-4df7-8a09-765794883524

4 files changed, 1261 insertions, 0 deletions

diff --git a/StdLib/Include/Lua/lauxlib.h b/StdLib/Include/Lua/lauxlib.h
new file mode 100644
index 0000000000..c21d2455b7
--- /dev/null
+++ b/StdLib/Include/Lua/lauxlib.h
@@ -0,0 +1,212 @@
+/*

+** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $

+** Auxiliary functions for building Lua libraries

+** See Copyright Notice in lua.h

+*/

+

+

+#ifndef lauxlib_h

+#define lauxlib_h

+

+

+#include <stddef.h>

+#include <stdio.h>

+

+#include <Lua/lua.h>

+

+

+

+/* extra error code for `luaL_load' */

+#define LUA_ERRFILE     (LUA_ERRERR+1)

+

+

+typedef struct luaL_Reg {

+  const char *name;

+  lua_CFunction func;

+} luaL_Reg;

+

+

+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);

+#define luaL_checkversion(L)    luaL_checkversion_(L, LUA_VERSION_NUM)

+

+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_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 const char *(luaL_optlstring) (lua_State *L, int numArg,

+                                          const char *def, size_t *l);

+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);

+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);

+

+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);

+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,

+                                          lua_Integer def);

+LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);

+LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,

+                                            lua_Unsigned def);

+

+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);

+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);

+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);

+

+LUALIB_API void (luaL_where) (lua_State *L, int lvl);

+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);

+

+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,

+                                   const char *const lst[]);

+

+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);

+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);

+

+/* pre-defined references */

+#define LUA_NOREF       (-2)

+#define LUA_REFNIL      (-1)

+

+LUALIB_API int (luaL_ref) (lua_State *L, int t);

+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);

+

+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,

+                                               const char *mode);

+

+#define luaL_loadfile(L,f)  luaL_loadfilex(L,f,NULL)

+

+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,

+                                   const char *name, const char *mode);

+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);

+

+LUALIB_API lua_State *(luaL_newstate) (void);

+

+LUALIB_API int (luaL_len) (lua_State *L, int idx);

+

+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,

+                                                  const char *r);

+

+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);

+

+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);

+

+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,

+                                  const char *msg, int level);

+

+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,

+                                 lua_CFunction openf, int glb);

+

+/*

+** ===============================================================

+** some useful macros

+** ===============================================================

+*/

+

+

+#define luaL_newlibtable(L,l)   \

+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)

+

+#define luaL_newlib(L,l)    (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))

+

+#define luaL_argcheck(L, cond,numarg,extramsg)  \

+        ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))

+#define luaL_checkstring(L,n)   (luaL_checklstring(L, (n), NULL))

+#define luaL_optstring(L,n,d)   (luaL_optlstring(L, (n), (d), NULL))

+#define luaL_checkint(L,n)  ((int)luaL_checkinteger(L, (n)))

+#define luaL_optint(L,n,d)  ((int)luaL_optinteger(L, (n), (d)))

+#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))

+#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))

+

+#define luaL_typename(L,i)  lua_typename(L, lua_type(L,(i)))

+

+#define luaL_dofile(L, fn) \

+    (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))

+

+#define luaL_dostring(L, s) \

+    (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))

+

+#define luaL_getmetatable(L,n)  (lua_getfield(L, LUA_REGISTRYINDEX, (n)))

+

+#define luaL_opt(L,f,n,d)   (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))

+

+#define luaL_loadbuffer(L,s,sz,n)   luaL_loadbufferx(L,s,sz,n,NULL)

+

+

+/*

+** {======================================================

+** Generic Buffer manipulation

+** =======================================================

+*/

+

+typedef struct luaL_Buffer {

+  char *b;  /* buffer address */

+  size_t size;  /* buffer size */

+  size_t n;  /* number of characters in buffer */

+  lua_State *L;

+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */

+} luaL_Buffer;

+

+

+#define luaL_addchar(B,c) \

+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \

+   ((B)->b[(B)->n++] = (c)))

+

+#define luaL_addsize(B,s)   ((B)->n += (s))

+

+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);

+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);

+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);

+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);

+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);

+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);

+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);

+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);

+

+#define luaL_prepbuffer(B)  luaL_prepbuffsize(B, LUAL_BUFFERSIZE)

+

+/* }====================================================== */

+

+

+

+/*

+** {======================================================

+** File handles for IO library

+** =======================================================

+*/

+

+/*

+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and

+** initial structure 'luaL_Stream' (it may contain other fields

+** after that initial structure).

+*/

+

+#define LUA_FILEHANDLE          "FILE*"

+

+

+typedef struct luaL_Stream {

+  FILE *f;  /* stream (NULL for incompletely created streams) */

+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */

+} luaL_Stream;

+

+/* }====================================================== */

+

+

+

+/* compatibility with old module system */

+#if defined(LUA_COMPAT_MODULE)

+

+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,

+                                   int sizehint);

+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,

+                                const luaL_Reg *l, int nup);

+

+#define luaL_register(L,n,l)    (luaL_openlib(L,(n),(l),0))

+

+#endif

+

+

+#endif

+

+

diff --git a/StdLib/Include/Lua/lua.h b/StdLib/Include/Lua/lua.h
new file mode 100644
index 0000000000..bf3a2e240d
--- /dev/null
+++ b/StdLib/Include/Lua/lua.h
@@ -0,0 +1,444 @@
+/*

+** $Id: lua.h,v 1.285.1.2 2013/11/11 12:09:16 roberto Exp $

+** Lua - A Scripting Language

+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)

+** See Copyright Notice at the end of this file

+*/

+

+

+#ifndef lua_h

+#define lua_h

+

+#include <stdarg.h>

+#include <stddef.h>

+

+

+#include <Lua/luaconf.h>

+

+

+#define LUA_VERSION_MAJOR   "5"

+#define LUA_VERSION_MINOR   "2"

+#define LUA_VERSION_NUM     502

+#define LUA_VERSION_RELEASE "3"

+

+#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR

+#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE

+#define LUA_COPYRIGHT   LUA_RELEASE "  Copyright (C) 1994-2013 Lua.org, PUC-Rio"

+#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"

+

+

+/* mark for precompiled code ('<esc>Lua') */

+#define LUA_SIGNATURE   "\033Lua"

+

+/* option for multiple returns in 'lua_pcall' and 'lua_call' */

+#define LUA_MULTRET (-1)

+

+

+/*

+** pseudo-indices

+*/

+#define LUA_REGISTRYINDEX   LUAI_FIRSTPSEUDOIDX

+#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))

+

+

+/* thread status */

+#define LUA_OK      0

+#define LUA_YIELD   1

+#define LUA_ERRRUN  2

+#define LUA_ERRSYNTAX   3

+#define LUA_ERRMEM  4

+#define LUA_ERRGCMM 5

+#define LUA_ERRERR  6

+

+

+typedef struct lua_State lua_State;

+

+typedef int (*lua_CFunction) (lua_State *L);

+

+

+/*

+** functions that read/write blocks when loading/dumping Lua chunks

+*/

+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);

+

+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);

+

+

+/*

+** prototype for memory-allocation functions

+*/

+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);

+

+

+/*

+** basic types

+*/

+#define LUA_TNONE       (-1)

+

+#define LUA_TNIL        0

+#define LUA_TBOOLEAN        1

+#define LUA_TLIGHTUSERDATA  2

+#define LUA_TNUMBER     3

+#define LUA_TSTRING     4

+#define LUA_TTABLE      5

+#define LUA_TFUNCTION       6

+#define LUA_TUSERDATA       7

+#define LUA_TTHREAD     8

+

+#define LUA_NUMTAGS     9

+

+

+

+/* minimum Lua stack available to a C function */

+#define LUA_MINSTACK    20

+

+

+/* predefined values in the registry */

+#define LUA_RIDX_MAINTHREAD 1

+#define LUA_RIDX_GLOBALS    2

+#define LUA_RIDX_LAST       LUA_RIDX_GLOBALS

+

+

+/* type of numbers in Lua */

+typedef LUA_NUMBER lua_Number;

+

+

+/* type for integer functions */

+typedef LUA_INTEGER lua_Integer;

+

+/* unsigned integer type */

+typedef LUA_UNSIGNED lua_Unsigned;

+

+

+

+/*

+** generic extra include file

+*/

+#if defined(LUA_USER_H)

+#include LUA_USER_H

+#endif

+

+

+/*

+** RCS ident string

+*/

+extern const char lua_ident[];

+

+

+/*

+** state manipulation

+*/

+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);

+LUA_API void       (lua_close) (lua_State *L);

+LUA_API lua_State *(lua_newthread) (lua_State *L);

+

+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);

+

+

+LUA_API const lua_Number *(lua_version) (lua_State *L);

+

+

+/*

+** basic stack manipulation

+*/

+LUA_API int   (lua_absindex) (lua_State *L, int idx);

+LUA_API int   (lua_gettop) (lua_State *L);

+LUA_API void  (lua_settop) (lua_State *L, int idx);

+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);

+LUA_API void  (lua_remove) (lua_State *L, int idx);

+LUA_API void  (lua_insert) (lua_State *L, int idx);

+LUA_API void  (lua_replace) (lua_State *L, int idx);

+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);

+LUA_API int   (lua_checkstack) (lua_State *L, int sz);

+

+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);

+

+

+/*

+** access functions (stack -> C)

+*/

+

+LUA_API int             (lua_isnumber) (lua_State *L, int idx);

+LUA_API int             (lua_isstring) (lua_State *L, int idx);

+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);

+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);

+LUA_API int             (lua_type) (lua_State *L, int idx);

+LUA_API const char     *(lua_typename) (lua_State *L, int tp);

+

+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);

+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);

+LUA_API lua_Unsigned    (lua_tounsignedx) (lua_State *L, int idx, int *isnum);

+LUA_API int             (lua_toboolean) (lua_State *L, int idx);

+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);

+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);

+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);

+LUA_API void           *(lua_touserdata) (lua_State *L, int idx);

+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);

+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);

+

+

+/*

+** Comparison and arithmetic functions

+*/

+

+#define LUA_OPADD   0   /* ORDER TM */

+#define LUA_OPSUB   1

+#define LUA_OPMUL   2

+#define LUA_OPDIV   3

+#define LUA_OPMOD   4

+#define LUA_OPPOW   5

+#define LUA_OPUNM   6

+

+LUA_API void  (lua_arith) (lua_State *L, int op);

+

+#define LUA_OPEQ    0

+#define LUA_OPLT    1

+#define LUA_OPLE    2

+

+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);

+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);

+

+

+/*

+** push functions (C -> stack)

+*/

+LUA_API void        (lua_pushnil) (lua_State *L);

+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);

+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);

+LUA_API void        (lua_pushunsigned) (lua_State *L, lua_Unsigned n);

+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l);

+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);

+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,

+                                                      va_list argp);

+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);

+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);

+LUA_API void  (lua_pushboolean) (lua_State *L, int b);

+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);

+LUA_API int   (lua_pushthread) (lua_State *L);

+

+

+/*

+** get functions (Lua -> stack)

+*/

+LUA_API void  (lua_getglobal) (lua_State *L, const char *var);

+LUA_API void  (lua_gettable) (lua_State *L, int idx);

+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);

+LUA_API void  (lua_rawget) (lua_State *L, int idx);

+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);

+LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);

+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);

+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);

+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);

+LUA_API void  (lua_getuservalue) (lua_State *L, int idx);

+

+

+/*

+** set functions (stack -> Lua)

+*/

+LUA_API void  (lua_setglobal) (lua_State *L, const char *var);

+LUA_API void  (lua_settable) (lua_State *L, int idx);

+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);

+LUA_API void  (lua_rawset) (lua_State *L, int idx);

+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);

+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);

+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);

+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);

+

+

+/*

+** 'load' and 'call' functions (load and run Lua code)

+*/

+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,

+                           lua_CFunction k);

+#define lua_call(L,n,r)     lua_callk(L, (n), (r), 0, NULL)

+

+LUA_API int   (lua_getctx) (lua_State *L, int *ctx);

+

+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,

+                            int ctx, lua_CFunction k);

+#define lua_pcall(L,n,r,f)  lua_pcallk(L, (n), (r), (f), 0, NULL)

+

+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,

+                                        const char *chunkname,

+                                        const char *mode);

+

+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);

+

+

+/*

+** coroutine functions

+*/

+LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,

+                           lua_CFunction k);

+#define lua_yield(L,n)      lua_yieldk(L, (n), 0, NULL)

+LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);

+LUA_API int  (lua_status) (lua_State *L);

+

+/*

+** garbage-collection function and options

+*/

+

+#define LUA_GCSTOP      0

+#define LUA_GCRESTART       1

+#define LUA_GCCOLLECT       2

+#define LUA_GCCOUNT     3

+#define LUA_GCCOUNTB        4

+#define LUA_GCSTEP      5

+#define LUA_GCSETPAUSE      6

+#define LUA_GCSETSTEPMUL    7

+#define LUA_GCSETMAJORINC   8

+#define LUA_GCISRUNNING     9

+#define LUA_GCGEN       10

+#define LUA_GCINC       11

+

+LUA_API int (lua_gc) (lua_State *L, int what, int data);

+

+

+/*

+** miscellaneous functions

+*/

+

+LUA_API int (lua_error) (lua_State *L);

+

+LUA_API int   (lua_next) (lua_State *L, int idx);

+

+LUA_API void  (lua_concat) (lua_State *L, int n);

+LUA_API void  (lua_len)    (lua_State *L, int idx);

+

+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);

+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);

+

+

+

+/*

+** ===============================================================

+** some useful macros

+** ===============================================================

+*/

+

+#define lua_tonumber(L,i)   lua_tonumberx(L,i,NULL)

+#define lua_tointeger(L,i)  lua_tointegerx(L,i,NULL)

+#define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL)

+

+#define lua_pop(L,n)        lua_settop(L, -(n)-1)

+

+#define lua_newtable(L)     lua_createtable(L, 0, 0)

+

+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))

+

+#define lua_pushcfunction(L,f)  lua_pushcclosure(L, (f), 0)

+

+#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)

+#define lua_istable(L,n)    (lua_type(L, (n)) == LUA_TTABLE)

+#define lua_islightuserdata(L,n)    (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)

+#define lua_isnil(L,n)      (lua_type(L, (n)) == LUA_TNIL)

+#define lua_isboolean(L,n)  (lua_type(L, (n)) == LUA_TBOOLEAN)

+#define lua_isthread(L,n)   (lua_type(L, (n)) == LUA_TTHREAD)

+#define lua_isnone(L,n)     (lua_type(L, (n)) == LUA_TNONE)

+#define lua_isnoneornil(L, n)   (lua_type(L, (n)) <= 0)

+

+#define lua_pushliteral(L, s)   \

+    lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)

+

+#define lua_pushglobaltable(L)  \

+    lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)

+

+#define lua_tostring(L,i)   lua_tolstring(L, (i), NULL)

+

+

+

+/*

+** {======================================================================

+** Debug API

+** =======================================================================

+*/

+

+

+/*

+** Event codes

+*/

+#define LUA_HOOKCALL    0

+#define LUA_HOOKRET 1

+#define LUA_HOOKLINE    2

+#define LUA_HOOKCOUNT   3

+#define LUA_HOOKTAILCALL 4

+

+

+/*

+** Event masks

+*/

+#define LUA_MASKCALL    (1 << LUA_HOOKCALL)

+#define LUA_MASKRET (1 << LUA_HOOKRET)

+#define LUA_MASKLINE    (1 << LUA_HOOKLINE)

+#define LUA_MASKCOUNT   (1 << LUA_HOOKCOUNT)

+

+typedef struct lua_Debug lua_Debug;  /* activation record */

+

+

+/* Functions to be called by the debugger in specific events */

+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);

+

+

+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);

+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);

+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);

+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);

+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);

+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);

+

+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);

+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,

+                                               int fidx2, int n2);

+

+LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);

+LUA_API lua_Hook (lua_gethook) (lua_State *L);

+LUA_API int (lua_gethookmask) (lua_State *L);

+LUA_API int (lua_gethookcount) (lua_State *L);

+

+

+struct lua_Debug {

+  int event;

+  const char *name; /* (n) */

+  const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */

+  const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */

+  const char *source;   /* (S) */

+  int currentline;  /* (l) */

+  int linedefined;  /* (S) */

+  int lastlinedefined;  /* (S) */

+  unsigned char nups;   /* (u) number of upvalues */

+  unsigned char nparams;/* (u) number of parameters */

+  char isvararg;        /* (u) */

+  char istailcall;  /* (t) */

+  char short_src[LUA_IDSIZE]; /* (S) */

+  /* private part */

+  struct CallInfo *i_ci;  /* active function */

+};

+

+/* }====================================================================== */

+

+

+/******************************************************************************

+* Copyright (C) 1994-2013 Lua.org, PUC-Rio.

+*

+* Permission is hereby granted, free of charge, to any person obtaining

+* a copy of this software and associated documentation files (the

+* "Software"), to deal in the Software without restriction, including

+* without limitation the rights to use, copy, modify, merge, publish,

+* distribute, sublicense, and/or sell copies of the Software, and to

+* permit persons to whom the Software is furnished to do so, subject to

+* the following conditions:

+*

+* The above copyright notice and this permission notice shall be

+* included in all copies or substantial portions of the Software.

+*

+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+******************************************************************************/

+

+

+#endif

diff --git a/StdLib/Include/Lua/luaconf.h b/StdLib/Include/Lua/luaconf.h
new file mode 100644
index 0000000000..db154d62a3
--- /dev/null
+++ b/StdLib/Include/Lua/luaconf.h
@@ -0,0 +1,550 @@
+/*

+** $Id: luaconf.h,v 1.176.1.1 2013/04/12 18:48:47 roberto Exp $

+** Configuration file for Lua

+** See Copyright Notice in lua.h

+*/

+

+

+#ifndef lconfig_h

+#define lconfig_h

+

+#include <limits.h>

+#include <stddef.h>

+

+

+/*

+** ==================================================================

+** Search for "@@" to find all configurable definitions.

+** ===================================================================

+*/

+

+#if defined(_DOS_WATCOM) || defined(UEFI_C_SOURCE)

+#undef _WIN32

+#define LUA_ANSI

+#endif

+

+/*

+@@ LUA_ANSI controls the use of non-ansi features.

+** CHANGE it (define it) if you want Lua to avoid the use of any

+** non-ansi feature or library.

+*/

+#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__)

+#define LUA_ANSI

+#endif

+

+

+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)

+#define LUA_WIN     /* enable goodies for regular Windows platforms */

+#endif

+

+#if defined(LUA_WIN)

+#define LUA_DL_DLL

+#define LUA_USE_AFORMAT     /* assume 'printf' handles 'aA' specifiers */

+#endif

+

+#if defined(LUA_USE_LINUX)

+#define LUA_USE_POSIX

+#define LUA_USE_DLOPEN      /* needs an extra library: -ldl */

+#define LUA_USE_READLINE    /* needs some extra libraries */

+#define LUA_USE_STRTODHEX   /* assume 'strtod' handles hex formats */

+#define LUA_USE_AFORMAT     /* assume 'printf' handles 'aA' specifiers */

+#define LUA_USE_LONGLONG    /* assume support for long long */

+#endif

+

+#if defined(LUA_USE_MACOSX)

+#define LUA_USE_POSIX

+#define LUA_USE_DLOPEN      /* does not need -ldl */

+#define LUA_USE_READLINE    /* needs an extra library: -lreadline */

+#define LUA_USE_STRTODHEX   /* assume 'strtod' handles hex formats */

+#define LUA_USE_AFORMAT     /* assume 'printf' handles 'aA' specifiers */

+#define LUA_USE_LONGLONG    /* assume support for long long */

+#endif

+

+/*

+@@ LUA_USE_POSIX includes all functionality listed as X/Open System

+@* Interfaces Extension (XSI).

+** CHANGE it (define it) if your system is XSI compatible.

+*/

+#if defined(LUA_USE_POSIX)

+#define LUA_USE_MKSTEMP

+#define LUA_USE_ISATTY

+#define LUA_USE_POPEN

+#define LUA_USE_ULONGJMP

+#define LUA_USE_GMTIME_R

+#endif

+

+

+

+/*

+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for

+@* Lua libraries.

+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for

+@* C libraries.

+** CHANGE them if your machine has a non-conventional directory

+** hierarchy or if you want to install your libraries in

+** non-conventional directories.

+*/

+#if defined(_WIN32) /* { */

+/*

+** In Windows, any exclamation mark ('!') in the path is replaced by the

+** path of the directory of the executable file of the current process.

+*/

+#define LUA_LDIR    "!\\lua\\"

+#define LUA_CDIR    "!\\"

+#define LUA_PATH_DEFAULT  \

+        LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \

+        LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" ".\\?.lua"

+#define LUA_CPATH_DEFAULT \

+        LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll"

+

+#else           /* }{ */

+

+#define LUA_VDIR    LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"

+#define LUA_ROOT    "/usr/local/"

+#define LUA_LDIR    LUA_ROOT "share/lua/" LUA_VDIR

+#define LUA_CDIR    LUA_ROOT "lib/lua/" LUA_VDIR

+#define LUA_PATH_DEFAULT  \

+        LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \

+        LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" "./?.lua"

+#define LUA_CPATH_DEFAULT \

+        LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"

+#endif          /* } */

+

+

+/*

+@@ LUA_DIRSEP is the directory separator (for submodules).

+** CHANGE it if your machine does not use "/" as the directory separator

+** and is not Windows. (On Windows Lua automatically uses "\".)

+*/

+#if defined(_WIN32) || defined (_DOS_WATCOM) || defined(_EFI)

+#define LUA_DIRSEP  "\\"

+#else

+#define LUA_DIRSEP  "/"

+#endif

+

+

+/*

+@@ LUA_ENV is the name of the variable that holds the current

+@@ environment, used to access global names.

+** CHANGE it if you do not like this name.

+*/

+#define LUA_ENV     "_ENV"

+

+

+/*

+@@ LUA_API is a mark for all core API functions.

+@@ LUALIB_API is a mark for all auxiliary library functions.

+@@ LUAMOD_API is a mark for all standard library opening functions.

+** CHANGE them if you need to define those functions in some special way.

+** For instance, if you want to create one Windows DLL with the core and

+** the libraries, you may want to use the following definition (define

+** LUA_BUILD_AS_DLL to get it).

+*/

+#if defined(LUA_BUILD_AS_DLL)   /* { */

+

+#if defined(LUA_CORE) || defined(LUA_LIB)   /* { */

+#define LUA_API __declspec(dllexport)

+#else                       /* }{ */

+#define LUA_API __declspec(dllimport)

+#endif                      /* } */

+

+#else               /* }{ */

+

+#define LUA_API     extern

+

+#endif              /* } */

+

+

+/* more often than not the libs go together with the core */

+#define LUALIB_API  LUA_API

+#define LUAMOD_API  LUALIB_API

+

+

+/*

+@@ LUAI_FUNC is a mark for all extern functions that are not to be

+@* exported to outside modules.

+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables

+@* that are not to be exported to outside modules (LUAI_DDEF for

+@* definitions and LUAI_DDEC for declarations).

+** CHANGE them if you need to mark them in some special way. Elf/gcc

+** (versions 3.2 and later) mark them as "hidden" to optimize access

+** when Lua is compiled as a shared library. Not all elf targets support

+** this attribute. Unfortunately, gcc does not offer a way to check

+** whether the target offers that support, and those without support

+** give a warning about it. To avoid these warnings, change to the

+** default definition.

+*/

+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \

+    defined(__ELF__)        /* { */

+#define LUAI_FUNC   __attribute__((visibility("hidden"))) extern

+#define LUAI_DDEC   LUAI_FUNC

+#define LUAI_DDEF   /* empty */

+

+#else               /* }{ */

+#define LUAI_FUNC   extern

+#define LUAI_DDEC   extern

+#define LUAI_DDEF   /* empty */

+#endif              /* } */

+

+

+

+/*

+@@ LUA_QL describes how error messages quote program elements.

+** CHANGE it if you want a different appearance.

+*/

+#define LUA_QL(x)   "'" x "'"

+#define LUA_QS      LUA_QL("%s")

+

+

+/*

+@@ LUA_IDSIZE gives the maximum size for the description of the source

+@* of a function in debug information.

+** CHANGE it if you want a different size.

+*/

+#define LUA_IDSIZE  60

+

+

+/*

+@@ luai_writestring/luai_writeline define how 'print' prints its results.

+** They are only used in libraries and the stand-alone program. (The #if

+** avoids including 'stdio.h' everywhere.)

+*/

+#if defined(LUA_LIB) || defined(lua_c)

+#include <stdio.h>

+#define luai_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)

+#define luai_writeline()    (luai_writestring("\n", 1), fflush(stdout))

+#endif

+

+/*

+@@ luai_writestringerror defines how to print error messages.

+** (A format string with one argument is enough for Lua...)

+*/

+#define luai_writestringerror(s,p) \

+    (fprintf(stderr, (s), (p)), fflush(stderr))

+

+

+/*

+@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is,

+** strings that are internalized. (Cannot be smaller than reserved words

+** or tags for metamethods, as these strings must be internalized;

+** #("function") = 8, #("__newindex") = 10.)

+*/

+#define LUAI_MAXSHORTLEN        40

+

+

+

+/*

+** {==================================================================

+** Compatibility with previous versions

+** ===================================================================

+*/

+

+/*

+@@ LUA_COMPAT_ALL controls all compatibility options.

+** You can define it to get all options, or change specific options

+** to fit your specific needs.

+*/

+#if defined(LUA_COMPAT_ALL) /* { */

+

+/*

+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.

+** You can replace it with 'table.unpack'.

+*/

+#define LUA_COMPAT_UNPACK

+

+/*

+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.

+** You can replace it with 'package.searchers'.

+*/

+#define LUA_COMPAT_LOADERS

+

+/*

+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.

+** You can call your C function directly (with light C functions).

+*/

+#define lua_cpcall(L,f,u)  \

+    (lua_pushcfunction(L, (f)), \

+     lua_pushlightuserdata(L,(u)), \

+     lua_pcall(L,1,0,0))

+

+

+/*

+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.

+** You can rewrite 'log10(x)' as 'log(x, 10)'.

+*/

+#define LUA_COMPAT_LOG10

+

+/*

+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base

+** library. You can rewrite 'loadstring(s)' as 'load(s)'.

+*/

+#define LUA_COMPAT_LOADSTRING

+

+/*

+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.

+*/

+#define LUA_COMPAT_MAXN

+

+/*

+@@ The following macros supply trivial compatibility for some

+** changes in the API. The macros themselves document how to

+** change your code to avoid using them.

+*/

+#define lua_strlen(L,i)     lua_rawlen(L, (i))

+

+#define lua_objlen(L,i)     lua_rawlen(L, (i))

+

+#define lua_equal(L,idx1,idx2)      lua_compare(L,(idx1),(idx2),LUA_OPEQ)

+#define lua_lessthan(L,idx1,idx2)   lua_compare(L,(idx1),(idx2),LUA_OPLT)

+

+/*

+@@ LUA_COMPAT_MODULE controls compatibility with previous

+** module functions 'module' (Lua) and 'luaL_register' (C).

+*/

+#define LUA_COMPAT_MODULE

+

+#endif              /* } */

+

+/* }================================================================== */

+

+

+

+/*

+@@ LUAI_BITSINT defines the number of bits in an int.

+** CHANGE here if Lua cannot automatically detect the number of bits of

+** your machine. Probably you do not need to change this.

+*/

+/* avoid overflows in comparison */

+#if INT_MAX-20 < 32760      /* { */

+#define LUAI_BITSINT    16

+#elif INT_MAX > 2147483640L /* }{ */

+/* int has at least 32 bits */

+#define LUAI_BITSINT    32

+#else               /* }{ */

+#error "you must define LUA_BITSINT with number of bits in an integer"

+#endif              /* } */

+

+

+/*

+@@ LUA_INT32 is an signed integer with exactly 32 bits.

+@@ LUAI_UMEM is an unsigned integer big enough to count the total

+@* memory used by Lua.

+@@ LUAI_MEM is a signed integer big enough to count the total memory

+@* used by Lua.

+** CHANGE here if for some weird reason the default definitions are not

+** good enough for your machine. Probably you do not need to change

+** this.

+*/

+#if LUAI_BITSINT >= 32      /* { */

+#define LUA_INT32   int

+#define LUAI_UMEM   size_t

+#define LUAI_MEM    ptrdiff_t

+#else               /* }{ */

+/* 16-bit ints */

+#define LUA_INT32   long

+#define LUAI_UMEM   unsigned long

+#define LUAI_MEM    long

+#endif              /* } */

+

+

+/*

+@@ LUAI_MAXSTACK limits the size of the Lua stack.

+** CHANGE it if you need a different limit. This limit is arbitrary;

+** its only purpose is to stop Lua to consume unlimited stack

+** space (and to reserve some numbers for pseudo-indices).

+*/

+#if LUAI_BITSINT >= 32

+#define LUAI_MAXSTACK       1000000

+#else

+#define LUAI_MAXSTACK       15000

+#endif

+

+/* reserve some space for error handling */

+#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000)

+

+

+

+

+/*

+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.

+** CHANGE it if it uses too much C-stack space.

+*/

+#define LUAL_BUFFERSIZE     BUFSIZ

+

+

+

+

+/*

+** {==================================================================

+@@ LUA_NUMBER is the type of numbers in Lua.

+** CHANGE the following definitions only if you want to build Lua

+** with a number type different from double. You may also need to

+** change lua_number2int & lua_number2integer.

+** ===================================================================

+*/

+

+#define LUA_NUMBER_DOUBLE

+#define LUA_NUMBER  double

+

+/*

+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'

+@* over a number.

+*/

+#define LUAI_UACNUMBER  double

+

+/*

+@@ LUA_NUMBER_SCAN is the format for reading numbers.

+@@ LUA_NUMBER_FMT is the format for writing numbers.

+@@ lua_number2str converts a number to a string.

+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.

+*/

+#define LUA_NUMBER_SCAN     "%lf"

+#define LUA_NUMBER_FMT      "%.14g"

+#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))

+#define LUAI_MAXNUMBER2STR  32 /* 16 digits, sign, point, and \0 */

+

+

+/*

+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations

+*/

+#define l_mathop(x)     (x)

+

+

+/*

+@@ lua_str2number converts a decimal numeric string to a number.

+@@ lua_strx2number converts an hexadecimal numeric string to a number.

+** In C99, 'strtod' does both conversions. C89, however, has no function

+** to convert floating hexadecimal strings to numbers. For these

+** systems, you can leave 'lua_strx2number' undefined and Lua will

+** provide its own implementation.

+*/

+#define lua_str2number(s,p) strtod((s), (p))

+

+#if defined(LUA_USE_STRTODHEX)

+#define lua_strx2number(s,p)    strtod((s), (p))

+#endif

+

+

+/*

+@@ The luai_num* macros define the primitive operations over numbers.

+*/

+

+/* the following operations need the math library */

+#if defined(lobject_c) || defined(lvm_c)

+#include <math.h>

+#define luai_nummod(L,a,b)  ((a) - l_mathop(floor)((a)/(b))*(b))

+#define luai_numpow(L,a,b)  (l_mathop(pow)(a,b))

+#endif

+

+/* these are quite standard operations */

+#if defined(LUA_CORE)

+#define luai_numadd(L,a,b)  ((a)+(b))

+#define luai_numsub(L,a,b)  ((a)-(b))

+#define luai_nummul(L,a,b)  ((a)*(b))

+#define luai_numdiv(L,a,b)  ((a)/(b))

+#define luai_numunm(L,a)    (-(a))

+#define luai_numeq(a,b)     ((a)==(b))

+#define luai_numlt(L,a,b)   ((a)<(b))

+#define luai_numle(L,a,b)   ((a)<=(b))

+#define luai_numisnan(L,a)  (!luai_numeq((a), (a)))

+#endif

+

+

+

+/*

+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.

+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most

+** machines, ptrdiff_t gives a good choice between int or long.)

+*/

+#define LUA_INTEGER ptrdiff_t

+

+/*

+@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.

+** It must have at least 32 bits.

+*/

+#define LUA_UNSIGNED    unsigned LUA_INT32

+

+

+

+/*

+** Some tricks with doubles

+*/

+

+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)    /* { */

+/*

+** The next definitions activate some tricks to speed up the

+** conversion from doubles to integer types, mainly to LUA_UNSIGNED.

+**

+@@ LUA_MSASMTRICK uses Microsoft assembler to avoid clashes with a

+** DirectX idiosyncrasy.

+**

+@@ LUA_IEEE754TRICK uses a trick that should work on any machine

+** using IEEE754 with a 32-bit integer type.

+**

+@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be

+** defined when LUA_INTEGER is a 32-bit integer.

+**

+@@ LUA_IEEEENDIAN is the endianness of doubles in your machine

+** (0 for little endian, 1 for big endian); if not defined, Lua will

+** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK).

+**

+@@ LUA_NANTRICK controls the use of a trick to pack all types into

+** a single double value, using NaN values to represent non-number

+** values. The trick only works on 32-bit machines (ints and pointers

+** are 32-bit values) with numbers represented as IEEE 754-2008 doubles

+** with conventional endianess (12345678 or 87654321), in CPUs that do

+** not produce signaling NaN values (all NaNs are quiet).

+*/

+

+/* Microsoft compiler on a Pentium (32 bit) ? */

+#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86)   /* { */

+

+#define LUA_MSASMTRICK

+#define LUA_IEEEENDIAN      0

+#define LUA_NANTRICK

+

+

+/* pentium 32 bits? */

+#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */

+

+#define LUA_IEEE754TRICK

+#define LUA_IEEELL

+#define LUA_IEEEENDIAN      0

+#define LUA_NANTRICK

+

+/* pentium 64 bits? */

+#elif defined(__x86_64)                     /* }{ */

+

+#define LUA_IEEE754TRICK

+#define LUA_IEEEENDIAN      0

+

+#elif defined(__POWERPC__) || defined(__ppc__)          /* }{ */

+

+#define LUA_IEEE754TRICK

+#define LUA_IEEEENDIAN      1

+

+#else                               /* }{ */

+

+/* assume IEEE754 and a 32-bit integer type */

+#define LUA_IEEE754TRICK

+

+#endif                              /* } */

+

+#endif                          /* } */

+

+/* }================================================================== */

+

+

+

+

+/* =================================================================== */

+

+/*

+** Local configuration. You can use this space to add your redefinitions

+** without modifying the main part of the file.

+*/

+

+

+

+#endif

+

diff --git a/StdLib/Include/Lua/lualib.h b/StdLib/Include/Lua/lualib.h
new file mode 100644
index 0000000000..5a5ecb2842
--- /dev/null
+++ b/StdLib/Include/Lua/lualib.h
@@ -0,0 +1,55 @@
+/*

+** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $

+** Lua standard libraries

+** See Copyright Notice in lua.h

+*/

+

+

+#ifndef lualib_h

+#define lualib_h

+

+#include <Lua/lua.h>

+

+

+

+LUAMOD_API int (luaopen_base) (lua_State *L);

+

+#define LUA_COLIBNAME "coroutine"

+LUAMOD_API int (luaopen_coroutine) (lua_State *L);

+

+#define LUA_TABLIBNAME  "table"

+LUAMOD_API int (luaopen_table) (lua_State *L);

+

+#define LUA_IOLIBNAME "io"

+LUAMOD_API int (luaopen_io) (lua_State *L);

+

+#define LUA_OSLIBNAME "os"

+LUAMOD_API int (luaopen_os) (lua_State *L);

+

+#define LUA_STRLIBNAME  "string"

+LUAMOD_API int (luaopen_string) (lua_State *L);

+

+#define LUA_BITLIBNAME  "bit32"

+LUAMOD_API int (luaopen_bit32) (lua_State *L);

+

+#define LUA_MATHLIBNAME "math"

+LUAMOD_API int (luaopen_math) (lua_State *L);

+

+#define LUA_DBLIBNAME "debug"

+LUAMOD_API int (luaopen_debug) (lua_State *L);

+

+#define LUA_LOADLIBNAME "package"

+LUAMOD_API int (luaopen_package) (lua_State *L);

+

+

+/* open all previous libraries */

+LUALIB_API void (luaL_openlibs) (lua_State *L);

+

+

+

+#if !defined(lua_assert)

+#define lua_assert(x) ((void)0)

+#endif

+

+

+#endif