+
+
+#include "llimits.h"
+#include "lua.h"
+
+
+/*
+** Extra types for collectable non-values
+*/
+#define LUA_TUPVAL LUA_NUMTYPES /* upvalues */
+#define LUA_TPROTO (LUA_NUMTYPES+1) /* function prototypes */
+#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */
+
+
+
+/*
+** number of all possible types (including LUA_TNONE but excluding DEADKEY)
+*/
+#define LUA_TOTALTYPES (LUA_TPROTO + 2)
+
+
+/*
+** tags for Tagged Values have the following use of bits:
+** bits 0-3: actual tag (a LUA_T* constant)
+** bits 4-5: variant bits
+** bit 6: whether value is collectable
+*/
+
+/* add variant bits to a type */
+#define makevariant(t,v) ((t) | ((v) << 4))
+
+
+
+/*
+** Union of all Lua values
+*/
+typedef union Value {
+ struct GCObject *gc; /* collectable objects */
+ void *p; /* light userdata */
+ lua_CFunction f; /* light C functions */
+ lua_Integer i; /* integer numbers */
+ lua_Number n; /* float numbers */
+} Value;
+
+
+/*
+** Tagged Values. This is the basic representation of values in Lua:
+** an actual value plus a tag with its type.
+*/
+
+#define TValuefields Value value_; lu_byte tt_
+
+typedef struct TValue {
+ TValuefields;
+} TValue;
+
+
+#define val_(o) ((o)->value_)
+#define valraw(o) (val_(o))
+
+
+/* raw type tag of a TValue */
+#define rawtt(o) ((o)->tt_)
+
+/* tag with no variants (bits 0-3) */
+#define novariant(t) ((t) & 0x0F)
+
+/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
+#define withvariant(t) ((t) & 0x3F)
+#define ttypetag(o) withvariant(rawtt(o))
+
+/* type of a TValue */
+#define ttype(o) (novariant(rawtt(o)))
+
+
+/* Macros to test type */
+#define checktag(o,t) (rawtt(o) == (t))
+#define checktype(o,t) (ttype(o) == (t))
+
+
+/* Macros for internal tests */
+
+/* collectable object has the same tag as the original value */
+#define righttt(obj) (ttypetag(obj) == gcvalue(obj)->tt)
+
+/*
+** Any value being manipulated by the program either is non
+** collectable, or the collectable object has the right tag
+** and it is not dead. The option 'L == NULL' allows other
+** macros using this one to be used where L is not available.
+*/
+#define checkliveness(L,obj) \
+ ((void)L, lua_longassert(!iscollectable(obj) || \
+ (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj))))))
+
+
+/* Macros to set values */
+
+/* set a value's tag */
+#define settt_(o,t) ((o)->tt_=(t))
+
+
+/* main macro to copy values (from 'obj2' to 'obj1') */
+#define setobj(L,obj1,obj2) \
+ { TValue *io1=(obj1); const TValue *io2=(obj2); \
+ io1->value_ = io2->value_; settt_(io1, io2->tt_); \
+ checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); }
+
+/*
+** Different types of assignments, according to source and destination.
+** (They are mostly equal now, but may be different in the future.)
+*/
+
+/* from stack to stack */
+#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2))
+/* to stack (not from same stack) */
+#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2)
+/* from table to same table */
+#define setobjt2t setobj
+/* to new object */
+#define setobj2n setobj
+/* to table */
+#define setobj2t setobj
+
+
+/*
+** Entries in a Lua stack. Field 'tbclist' forms a list of all
+** to-be-closed variables active in this stack. Dummy entries are
+** used when the distance between two tbc variables does not fit
+** in an unsigned short. They are represented by delta==0, and
+** their real delta is always the maximum value that fits in
+** that field.
+*/
+typedef union StackValue {
+ TValue val;
+ struct {
+ TValuefields;
+ unsigned short delta;
+ } tbclist;
+} StackValue;
+
+
+/* index to stack elements */
+typedef StackValue *StkId;
+
+/* convert a 'StackValue' to a 'TValue' */
+#define s2v(o) (&(o)->val)
+
+
+
+/*
+** {==================================================================
+** Nil
+** ===================================================================
+*/
+
+/* Standard nil */
+#define LUA_VNIL makevariant(LUA_TNIL, 0)
+
+/* Empty slot (which might be different from a slot containing nil) */
+#define LUA_VEMPTY makevariant(LUA_TNIL, 1)
+
+/* Value returned for a key not found in a table (absent key) */
+#define LUA_VABSTKEY makevariant(LUA_TNIL, 2)
+
+
+/* macro to test for (any kind of) nil */
+#define ttisnil(v) checktype((v), LUA_TNIL)
+
+
+/* macro to test for a standard nil */
+#define ttisstrictnil(o) checktag((o), LUA_VNIL)
+
+
+#define setnilvalue(obj) settt_(obj, LUA_VNIL)
+
+
+#define isabstkey(v) checktag((v), LUA_VABSTKEY)
+
+
+/*
+** macro to detect non-standard nils (used only in assertions)
+*/
+#define isnonstrictnil(v) (ttisnil(v) && !ttisstrictnil(v))
+
+
+/*
+** By default, entries with any kind of nil are considered empty.
+** (In any definition, values associated with absent keys must also
+** be accepted as empty.)
+*/
+#define isempty(v) ttisnil(v)
+
+
+/* macro defining a value corresponding to an absent key */
+#define ABSTKEYCONSTANT {NULL}, LUA_VABSTKEY
+
+
+/* mark an entry as empty */
+#define setempty(v) settt_(v, LUA_VEMPTY)
+
+
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Booleans
+** ===================================================================
+*/
+
+
+#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0)
+#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1)
+
+#define ttisboolean(o) checktype((o), LUA_TBOOLEAN)
+#define ttisfalse(o) checktag((o), LUA_VFALSE)
+#define ttistrue(o) checktag((o), LUA_VTRUE)
+
+
+#define l_isfalse(o) (ttisfalse(o) || ttisnil(o))
+
+
+#define setbfvalue(obj) settt_(obj, LUA_VFALSE)
+#define setbtvalue(obj) settt_(obj, LUA_VTRUE)
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Threads
+** ===================================================================
+*/
+
+#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0)
+
+#define ttisthread(o) checktag((o), ctb(LUA_VTHREAD))
+
+#define thvalue(o) check_exp(ttisthread(o), gco2th(val_(o).gc))
+
+#define setthvalue(L,obj,x) \
+ { TValue *io = (obj); lua_State *x_ = (x); \
+ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \
+ checkliveness(L,io); }
+
+#define setthvalue2s(L,o,t) setthvalue(L,s2v(o),t)
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Collectable Objects
+** ===================================================================
+*/
+
+/*
+** Common Header for all collectable objects (in macro form, to be
+** included in other objects)
+*/
+#define CommonHeader struct GCObject *next; lu_byte tt; lu_byte marked
+
+
+/* Common type for all collectable objects */
+typedef struct GCObject {
+ CommonHeader;
+} GCObject;
+
+
+/* Bit mark for collectable types */
+#define BIT_ISCOLLECTABLE (1 << 6)
+
+#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE)
+
+/* mark a tag as collectable */
+#define ctb(t) ((t) | BIT_ISCOLLECTABLE)
+
+#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc)
+
+#define gcvalueraw(v) ((v).gc)
+
+#define setgcovalue(L,obj,x) \
+ { TValue *io = (obj); GCObject *i_g=(x); \
+ val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Numbers
+** ===================================================================
+*/
+
+/* Variant tags for numbers */
+#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */
+#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */
+
+#define ttisnumber(o) checktype((o), LUA_TNUMBER)
+#define ttisfloat(o) checktag((o), LUA_VNUMFLT)
+#define ttisinteger(o) checktag((o), LUA_VNUMINT)
+
+#define nvalue(o) check_exp(ttisnumber(o), \
+ (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
+#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n)
+#define ivalue(o) check_exp(ttisinteger(o), val_(o).i)
+
+#define fltvalueraw(v) ((v).n)
+#define ivalueraw(v) ((v).i)
+
+#define setfltvalue(obj,x) \
+ { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); }
+
+#define chgfltvalue(obj,x) \
+ { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }
+
+#define setivalue(obj,x) \
+ { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); }
+
+#define chgivalue(obj,x) \
+ { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Strings
+** ===================================================================
+*/
+
+/* Variant tags for strings */
+#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */
+#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */
+
+#define ttisstring(o) checktype((o), LUA_TSTRING)
+#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR))
+#define ttislngstring(o) checktag((o), ctb(LUA_VLNGSTR))
+
+#define tsvalueraw(v) (gco2ts((v).gc))
+
+#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc))
+
+#define setsvalue(L,obj,x) \
+ { TValue *io = (obj); TString *x_ = (x); \
+ val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
+ checkliveness(L,io); }
+
+/* set a string to the stack */
+#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s)
+
+/* set a string to a new object */
+#define setsvalue2n setsvalue
+
+
+/*
+** Header for a string value.
+*/
+typedef struct TString {
+ CommonHeader;
+ lu_byte extra; /* reserved words for short strings; "has hash" for longs */
+ lu_byte shrlen; /* length for short strings */
+ unsigned int hash;
+ union {
+ size_t lnglen; /* length for long strings */
+ struct TString *hnext; /* linked list for hash table */
+ } u;
+ char contents[1];
+} TString;
+
+
+
+/*
+** Get the actual string (array of bytes) from a 'TString'.
+*/
+#define getstr(ts) ((ts)->contents)
+
+
+/* get the actual string (array of bytes) from a Lua value */
+#define svalue(o) getstr(tsvalue(o))
+
+/* get string length from 'TString *s' */
+#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen)
+
+/* get string length from 'TValue *o' */
+#define vslen(o) tsslen(tsvalue(o))
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Userdata
+** ===================================================================
+*/
+
+
+/*
+** Light userdata should be a variant of userdata, but for compatibility
+** reasons they are also different types.
+*/
+#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0)
+
+#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0)
+
+#define ttislightuserdata(o) checktag((o), LUA_VLIGHTUSERDATA)
+#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA))
+
+#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p)
+#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
+
+#define pvalueraw(v) ((v).p)
+
+#define setpvalue(obj,x) \
+ { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); }
+
+#define setuvalue(L,obj,x) \
+ { TValue *io = (obj); Udata *x_ = (x); \
+ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \
+ checkliveness(L,io); }
+
+
+/* Ensures that addresses after this type are always fully aligned. */
+typedef union UValue {
+ TValue uv;
+ LUAI_MAXALIGN; /* ensures maximum alignment for udata bytes */
+} UValue;
+
+
+/*
+** Header for userdata with user values;
+** memory area follows the end of this structure.
+*/
+typedef struct Udata {
+ CommonHeader;
+ unsigned short nuvalue; /* number of user values */
+ size_t len; /* number of bytes */
+ struct Table *metatable;
+ GCObject *gclist;
+ UValue uv[1]; /* user values */
+} Udata;
+
+
+/*
+** Header for userdata with no user values. These userdata do not need
+** to be gray during GC, and therefore do not need a 'gclist' field.
+** To simplify, the code always use 'Udata' for both kinds of userdata,
+** making sure it never accesses 'gclist' on userdata with no user values.
+** This structure here is used only to compute the correct size for
+** this representation. (The 'bindata' field in its end ensures correct
+** alignment for binary data following this header.)
+*/
+typedef struct Udata0 {
+ CommonHeader;
+ unsigned short nuvalue; /* number of user values */
+ size_t len; /* number of bytes */
+ struct Table *metatable;
+ union {LUAI_MAXALIGN;} bindata;
+} Udata0;
+
+
+/* compute the offset of the memory area of a userdata */
+#define udatamemoffset(nuv) \
+ ((nuv) == 0 ? offsetof(Udata0, bindata) \
+ : offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
+
+/* get the address of the memory block inside 'Udata' */
+#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue))
+
+/* compute the size of a userdata */
+#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb))
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Prototypes
+** ===================================================================
+*/
+
+#define LUA_VPROTO makevariant(LUA_TPROTO, 0)
+
+
+/*
+** Description of an upvalue for function prototypes
+*/
+typedef struct Upvaldesc {
+ TString *name; /* upvalue name (for debug information) */
+ lu_byte instack; /* whether it is in stack (register) */
+ lu_byte idx; /* index of upvalue (in stack or in outer function's list) */
+ lu_byte kind; /* kind of corresponding variable */
+} Upvaldesc;
+
+
+/*
+** Description of a local variable for function prototypes
+** (used for debug information)
+*/
+typedef struct LocVar {
+ TString *varname;
+ int startpc; /* first point where variable is active */
+ int endpc; /* first point where variable is dead */
+} LocVar;
+
+
+/*
+** Associates the absolute line source for a given instruction ('pc').
+** The array 'lineinfo' gives, for each instruction, the difference in
+** lines from the previous instruction. When that difference does not
+** fit into a byte, Lua saves the absolute line for that instruction.
+** (Lua also saves the absolute line periodically, to speed up the
+** computation of a line number: we can use binary search in the
+** absolute-line array, but we must traverse the 'lineinfo' array
+** linearly to compute a line.)
+*/
+typedef struct AbsLineInfo {
+ int pc;
+ int line;
+} AbsLineInfo;
+
+/*
+** Function Prototypes
+*/
+typedef struct Proto {
+ CommonHeader;
+ lu_byte numparams; /* number of fixed (named) parameters */
+ lu_byte is_vararg;
+ lu_byte maxstacksize; /* number of registers needed by this function */
+ int sizeupvalues; /* size of 'upvalues' */
+ int sizek; /* size of 'k' */
+ int sizecode;
+ int sizelineinfo;
+ int sizep; /* size of 'p' */
+ int sizelocvars;
+ int sizeabslineinfo; /* size of 'abslineinfo' */
+ int linedefined; /* debug information */
+ int lastlinedefined; /* debug information */
+ TValue *k; /* constants used by the function */
+ Instruction *code; /* opcodes */
+ struct Proto **p; /* functions defined inside the function */
+ Upvaldesc *upvalues; /* upvalue information */
+ ls_byte *lineinfo; /* information about source lines (debug information) */
+ AbsLineInfo *abslineinfo; /* idem */
+ LocVar *locvars; /* information about local variables (debug information) */
+ TString *source; /* used for debug information */
+ GCObject *gclist;
+} Proto;
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Functions
+** ===================================================================
+*/
+
+#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0)
+
+
+/* Variant tags for functions */
+#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */
+#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */
+#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */
+
+#define ttisfunction(o) checktype(o, LUA_TFUNCTION)
+#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL))
+#define ttislcf(o) checktag((o), LUA_VLCF)
+#define ttisCclosure(o) checktag((o), ctb(LUA_VCCL))
+#define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o))
+
+
+#define isLfunction(o) ttisLclosure(o)
+
+#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc))
+#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
+#define fvalue(o) check_exp(ttislcf(o), val_(o).f)
+#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
+
+#define fvalueraw(v) ((v).f)
+
+#define setclLvalue(L,obj,x) \
+ { TValue *io = (obj); LClosure *x_ = (x); \
+ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \
+ checkliveness(L,io); }
+
+#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl)
+
+#define setfvalue(obj,x) \
+ { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); }
+
+#define setclCvalue(L,obj,x) \
+ { TValue *io = (obj); CClosure *x_ = (x); \
+ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \
+ checkliveness(L,io); }
+
+
+/*
+** Upvalues for Lua closures
+*/
+typedef struct UpVal {
+ CommonHeader;
+ lu_byte tbc; /* true if it represents a to-be-closed variable */
+ TValue *v; /* points to stack or to its own value */
+ union {
+ struct { /* (when open) */
+ struct UpVal *next; /* linked list */
+ struct UpVal **previous;
+ } open;
+ TValue value; /* the value (when closed) */
+ } u;
+} UpVal;
+
+
+
+#define ClosureHeader \
+ CommonHeader; lu_byte nupvalues; GCObject *gclist
+
+typedef struct CClosure {
+ ClosureHeader;
+ lua_CFunction f;
+ TValue upvalue[1]; /* list of upvalues */
+} CClosure;
+
+
+typedef struct LClosure {
+ ClosureHeader;
+ struct Proto *p;
+ UpVal *upvals[1]; /* list of upvalues */
+} LClosure;
+
+
+typedef union Closure {
+ CClosure c;
+ LClosure l;
+} Closure;
+
+
+#define getproto(o) (clLvalue(o)->p)
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Tables
+** ===================================================================
+*/
+
+#define LUA_VTABLE makevariant(LUA_TTABLE, 0)
+
+#define ttistable(o) checktag((o), ctb(LUA_VTABLE))
+
+#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc))
+
+#define sethvalue(L,obj,x) \
+ { TValue *io = (obj); Table *x_ = (x); \
+ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \
+ checkliveness(L,io); }
+
+#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h)
+
+
+/*
+** Nodes for Hash tables: A pack of two TValue's (key-value pairs)
+** plus a 'next' field to link colliding entries. The distribution
+** of the key's fields ('key_tt' and 'key_val') not forming a proper
+** 'TValue' allows for a smaller size for 'Node' both in 4-byte
+** and 8-byte alignments.
+*/
+typedef union Node {
+ struct NodeKey {
+ TValuefields; /* fields for value */
+ lu_byte key_tt; /* key type */
+ int next; /* for chaining */
+ Value key_val; /* key value */
+ } u;
+ TValue i_val; /* direct access to node's value as a proper 'TValue' */
+} Node;
+
+
+/* copy a value into a key */
+#define setnodekey(L,node,obj) \
+ { Node *n_=(node); const TValue *io_=(obj); \
+ n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \
+ checkliveness(L,io_); }
+
+
+/* copy a value from a key */
+#define getnodekey(L,obj,node) \
+ { TValue *io_=(obj); const Node *n_=(node); \
+ io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \
+ checkliveness(L,io_); }
+
+
+/*
+** About 'alimit': if 'isrealasize(t)' is true, then 'alimit' is the
+** real size of 'array'. Otherwise, the real size of 'array' is the
+** smallest power of two not smaller than 'alimit' (or zero iff 'alimit'
+** is zero); 'alimit' is then used as a hint for #t.
+*/
+
+#define BITRAS (1 << 7)
+#define isrealasize(t) (!((t)->flags & BITRAS))
+#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS))
+#define setnorealasize(t) ((t)->flags |= BITRAS)
+
+
+typedef struct Table {
+ CommonHeader;
+ lu_byte flags; /* 1<u.key_tt)
+#define keyval(node) ((node)->u.key_val)
+
+#define keyisnil(node) (keytt(node) == LUA_TNIL)
+#define keyisinteger(node) (keytt(node) == LUA_VNUMINT)
+#define keyival(node) (keyval(node).i)
+#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR))
+#define keystrval(node) (gco2ts(keyval(node).gc))
+
+#define setnilkey(node) (keytt(node) = LUA_TNIL)
+
+#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE)
+
+#define gckey(n) (keyval(n).gc)
+#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL)
+
+
+/*
+** Dead keys in tables have the tag DEADKEY but keep their original
+** gcvalue. This distinguishes them from regular keys but allows them to
+** be found when searched in a special way. ('next' needs that to find
+** keys removed from a table during a traversal.)
+*/
+#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY)
+#define keyisdead(node) (keytt(node) == LUA_TDEADKEY)
+
+/* }================================================================== */
+
+
+
+/*
+** 'module' operation for hashing (size is always a power of 2)
+*/
+#define lmod(s,size) \
+ (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1)))))
+
+
+#define twoto(x) (1<<(x))
+#define sizenode(t) (twoto((t)->lsizenode))
+
+
+/* size of buffer for 'luaO_utf8esc' function */
+#define UTF8BUFFSZ 8
+
+LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
+LUAI_FUNC int luaO_ceillog2 (unsigned int x);
+LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1,
+ const TValue *p2, TValue *res);
+LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
+ const TValue *p2, StkId res);
+LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
+LUAI_FUNC int luaO_hexavalue (int c);
+LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj);
+LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
+ va_list argp);
+LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
+LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t srclen);
+
+
+#endif
+
diff --git a/include/lua/lopcodes.h b/include/lua/lopcodes.h
new file mode 100644
index 00000000..7c274515
--- /dev/null
+++ b/include/lua/lopcodes.h
@@ -0,0 +1,405 @@
+/*
+** $Id: lopcodes.h $
+** Opcodes for Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lopcodes_h
+#define lopcodes_h
+
+#include "llimits.h"
+
+
+/*===========================================================================
+ We assume that instructions are unsigned 32-bit integers.
+ All instructions have an opcode in the first 7 bits.
+ Instructions can have the following formats:
+
+ 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+iABC C(8) | B(8) |k| A(8) | Op(7) |
+iABx Bx(17) | A(8) | Op(7) |
+iAsBx sBx (signed)(17) | A(8) | Op(7) |
+iAx Ax(25) | Op(7) |
+isJ sJ(25) | Op(7) |
+
+ A signed argument is represented in excess K: the represented value is
+ the written unsigned value minus K, where K is half the maximum for the
+ corresponding unsigned argument.
+===========================================================================*/
+
+
+enum OpMode {iABC, iABx, iAsBx, iAx, isJ}; /* basic instruction formats */
+
+
+/*
+** size and position of opcode arguments.
+*/
+#define SIZE_C 8
+#define SIZE_B 8
+#define SIZE_Bx (SIZE_C + SIZE_B + 1)
+#define SIZE_A 8
+#define SIZE_Ax (SIZE_Bx + SIZE_A)
+#define SIZE_sJ (SIZE_Bx + SIZE_A)
+
+#define SIZE_OP 7
+
+#define POS_OP 0
+
+#define POS_A (POS_OP + SIZE_OP)
+#define POS_k (POS_A + SIZE_A)
+#define POS_B (POS_k + 1)
+#define POS_C (POS_B + SIZE_B)
+
+#define POS_Bx POS_k
+
+#define POS_Ax POS_A
+
+#define POS_sJ POS_A
+
+
+/*
+** limits for opcode arguments.
+** we use (signed) 'int' to manipulate most arguments,
+** so they must fit in ints.
+*/
+
+/* Check whether type 'int' has at least 'b' bits ('b' < 32) */
+#define L_INTHASBITS(b) ((UINT_MAX >> ((b) - 1)) >= 1)
+
+
+#if L_INTHASBITS(SIZE_Bx)
+#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */
+
+
+#if L_INTHASBITS(SIZE_Ax)
+#define MAXARG_Ax ((1<> 1)
+
+
+#define MAXARG_A ((1<> 1)
+
+#define int2sC(i) ((i) + OFFSET_sC)
+#define sC2int(i) ((i) - OFFSET_sC)
+
+
+/* creates a mask with 'n' 1 bits at position 'p' */
+#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p))
+
+/* creates a mask with 'n' 0 bits at position 'p' */
+#define MASK0(n,p) (~MASK1(n,p))
+
+/*
+** the following macros help to manipulate instructions
+*/
+
+#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
+#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
+ ((cast(Instruction, o)<>(pos)) & MASK1(size,0)))
+#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \
+ ((cast(Instruction, v)<> sC */
+OP_SHLI,/* A B sC R[A] := sC << R[B] */
+
+OP_ADD,/* A B C R[A] := R[B] + R[C] */
+OP_SUB,/* A B C R[A] := R[B] - R[C] */
+OP_MUL,/* A B C R[A] := R[B] * R[C] */
+OP_MOD,/* A B C R[A] := R[B] % R[C] */
+OP_POW,/* A B C R[A] := R[B] ^ R[C] */
+OP_DIV,/* A B C R[A] := R[B] / R[C] */
+OP_IDIV,/* A B C R[A] := R[B] // R[C] */
+
+OP_BAND,/* A B C R[A] := R[B] & R[C] */
+OP_BOR,/* A B C R[A] := R[B] | R[C] */
+OP_BXOR,/* A B C R[A] := R[B] ~ R[C] */
+OP_SHL,/* A B C R[A] := R[B] << R[C] */
+OP_SHR,/* A B C R[A] := R[B] >> R[C] */
+
+OP_MMBIN,/* A B C call C metamethod over R[A] and R[B] (*) */
+OP_MMBINI,/* A sB C k call C metamethod over R[A] and sB */
+OP_MMBINK,/* A B C k call C metamethod over R[A] and K[B] */
+
+OP_UNM,/* A B R[A] := -R[B] */
+OP_BNOT,/* A B R[A] := ~R[B] */
+OP_NOT,/* A B R[A] := not R[B] */
+OP_LEN,/* A B R[A] := #R[B] (length operator) */
+
+OP_CONCAT,/* A B R[A] := R[A].. ... ..R[A + B - 1] */
+
+OP_CLOSE,/* A close all upvalues >= R[A] */
+OP_TBC,/* A mark variable A "to be closed" */
+OP_JMP,/* sJ pc += sJ */
+OP_EQ,/* A B k if ((R[A] == R[B]) ~= k) then pc++ */
+OP_LT,/* A B k if ((R[A] < R[B]) ~= k) then pc++ */
+OP_LE,/* A B k if ((R[A] <= R[B]) ~= k) then pc++ */
+
+OP_EQK,/* A B k if ((R[A] == K[B]) ~= k) then pc++ */
+OP_EQI,/* A sB k if ((R[A] == sB) ~= k) then pc++ */
+OP_LTI,/* A sB k if ((R[A] < sB) ~= k) then pc++ */
+OP_LEI,/* A sB k if ((R[A] <= sB) ~= k) then pc++ */
+OP_GTI,/* A sB k if ((R[A] > sB) ~= k) then pc++ */
+OP_GEI,/* A sB k if ((R[A] >= sB) ~= k) then pc++ */
+
+OP_TEST,/* A k if (not R[A] == k) then pc++ */
+OP_TESTSET,/* A B k if (not R[B] == k) then pc++ else R[A] := R[B] (*) */
+
+OP_CALL,/* A B C R[A], ... ,R[A+C-2] := R[A](R[A+1], ... ,R[A+B-1]) */
+OP_TAILCALL,/* A B C k return R[A](R[A+1], ... ,R[A+B-1]) */
+
+OP_RETURN,/* A B C k return R[A], ... ,R[A+B-2] (see note) */
+OP_RETURN0,/* return */
+OP_RETURN1,/* A return R[A] */
+
+OP_FORLOOP,/* A Bx update counters; if loop continues then pc-=Bx; */
+OP_FORPREP,/* A Bx ;
+ if not to run then pc+=Bx+1; */
+
+OP_TFORPREP,/* A Bx create upvalue for R[A + 3]; pc+=Bx */
+OP_TFORCALL,/* A C R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]); */
+OP_TFORLOOP,/* A Bx if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx } */
+
+OP_SETLIST,/* A B C k R[A][C+i] := R[A+i], 1 <= i <= B */
+
+OP_CLOSURE,/* A Bx R[A] := closure(KPROTO[Bx]) */
+
+OP_VARARG,/* A C R[A], R[A+1], ..., R[A+C-2] = vararg */
+
+OP_VARARGPREP,/*A (adjust vararg parameters) */
+
+OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */
+} OpCode;
+
+
+#define NUM_OPCODES ((int)(OP_EXTRAARG) + 1)
+
+
+
+/*===========================================================================
+ Notes:
+
+ (*) Opcode OP_LFALSESKIP is used to convert a condition to a boolean
+ value, in a code equivalent to (not cond ? false : true). (It
+ produces false and skips the next instruction producing true.)
+
+ (*) Opcodes OP_MMBIN and variants follow each arithmetic and
+ bitwise opcode. If the operation succeeds, it skips this next
+ opcode. Otherwise, this opcode calls the corresponding metamethod.
+
+ (*) Opcode OP_TESTSET is used in short-circuit expressions that need
+ both to jump and to produce a value, such as (a = b or c).
+
+ (*) In OP_CALL, if (B == 0) then B = top - A. If (C == 0), then
+ 'top' is set to last_result+1, so next open instruction (OP_CALL,
+ OP_RETURN*, OP_SETLIST) may use 'top'.
+
+ (*) In OP_VARARG, if (C == 0) then use actual number of varargs and
+ set top (like in OP_CALL with C == 0).
+
+ (*) In OP_RETURN, if (B == 0) then return up to 'top'.
+
+ (*) In OP_LOADKX and OP_NEWTABLE, the next instruction is always
+ OP_EXTRAARG.
+
+ (*) In OP_SETLIST, if (B == 0) then real B = 'top'; if k, then
+ real C = EXTRAARG _ C (the bits of EXTRAARG concatenated with the
+ bits of C).
+
+ (*) In OP_NEWTABLE, B is log2 of the hash size (which is always a
+ power of 2) plus 1, or zero for size zero. If not k, the array size
+ is C. Otherwise, the array size is EXTRAARG _ C.
+
+ (*) For comparisons, k specifies what condition the test should accept
+ (true or false).
+
+ (*) In OP_MMBINI/OP_MMBINK, k means the arguments were flipped
+ (the constant is the first operand).
+
+ (*) All 'skips' (pc++) assume that next instruction is a jump.
+
+ (*) In instructions OP_RETURN/OP_TAILCALL, 'k' specifies that the
+ function builds upvalues, which may need to be closed. C > 0 means
+ the function is vararg, so that its 'func' must be corrected before
+ returning; in this case, (C - 1) is its number of fixed parameters.
+
+ (*) In comparisons with an immediate operand, C signals whether the
+ original operand was a float. (It must be corrected in case of
+ metamethods.)
+
+===========================================================================*/
+
+
+/*
+** masks for instruction properties. The format is:
+** bits 0-2: op mode
+** bit 3: instruction set register A
+** bit 4: operator is a test (next instruction must be a jump)
+** bit 5: instruction uses 'L->top' set by previous instruction (when B == 0)
+** bit 6: instruction sets 'L->top' for next instruction (when C == 0)
+** bit 7: instruction is an MM instruction (call a metamethod)
+*/
+
+LUAI_DDEC(const lu_byte luaP_opmodes[NUM_OPCODES];)
+
+#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 7))
+#define testAMode(m) (luaP_opmodes[m] & (1 << 3))
+#define testTMode(m) (luaP_opmodes[m] & (1 << 4))
+#define testITMode(m) (luaP_opmodes[m] & (1 << 5))
+#define testOTMode(m) (luaP_opmodes[m] & (1 << 6))
+#define testMMMode(m) (luaP_opmodes[m] & (1 << 7))
+
+/* "out top" (set top for next instruction) */
+#define isOT(i) \
+ ((testOTMode(GET_OPCODE(i)) && GETARG_C(i) == 0) || \
+ GET_OPCODE(i) == OP_TAILCALL)
+
+/* "in top" (uses top from previous instruction) */
+#define isIT(i) (testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0)
+
+#define opmode(mm,ot,it,t,a,m) \
+ (((mm) << 7) | ((ot) << 6) | ((it) << 5) | ((t) << 4) | ((a) << 3) | (m))
+
+
+/* number of list items to accumulate before a SETLIST instruction */
+#define LFIELDS_PER_FLUSH 50
+
+#endif
diff --git a/include/lua/lopnames.h b/include/lua/lopnames.h
new file mode 100644
index 00000000..965cec9b
--- /dev/null
+++ b/include/lua/lopnames.h
@@ -0,0 +1,103 @@
+/*
+** $Id: lopnames.h $
+** Opcode names
+** See Copyright Notice in lua.h
+*/
+
+#if !defined(lopnames_h)
+#define lopnames_h
+
+#include
+
+
+/* ORDER OP */
+
+static const char *const opnames[] = {
+ "MOVE",
+ "LOADI",
+ "LOADF",
+ "LOADK",
+ "LOADKX",
+ "LOADFALSE",
+ "LFALSESKIP",
+ "LOADTRUE",
+ "LOADNIL",
+ "GETUPVAL",
+ "SETUPVAL",
+ "GETTABUP",
+ "GETTABLE",
+ "GETI",
+ "GETFIELD",
+ "SETTABUP",
+ "SETTABLE",
+ "SETI",
+ "SETFIELD",
+ "NEWTABLE",
+ "SELF",
+ "ADDI",
+ "ADDK",
+ "SUBK",
+ "MULK",
+ "MODK",
+ "POWK",
+ "DIVK",
+ "IDIVK",
+ "BANDK",
+ "BORK",
+ "BXORK",
+ "SHRI",
+ "SHLI",
+ "ADD",
+ "SUB",
+ "MUL",
+ "MOD",
+ "POW",
+ "DIV",
+ "IDIV",
+ "BAND",
+ "BOR",
+ "BXOR",
+ "SHL",
+ "SHR",
+ "MMBIN",
+ "MMBINI",
+ "MMBINK",
+ "UNM",
+ "BNOT",
+ "NOT",
+ "LEN",
+ "CONCAT",
+ "CLOSE",
+ "TBC",
+ "JMP",
+ "EQ",
+ "LT",
+ "LE",
+ "EQK",
+ "EQI",
+ "LTI",
+ "LEI",
+ "GTI",
+ "GEI",
+ "TEST",
+ "TESTSET",
+ "CALL",
+ "TAILCALL",
+ "RETURN",
+ "RETURN0",
+ "RETURN1",
+ "FORLOOP",
+ "FORPREP",
+ "TFORPREP",
+ "TFORCALL",
+ "TFORLOOP",
+ "SETLIST",
+ "CLOSURE",
+ "VARARG",
+ "VARARGPREP",
+ "EXTRAARG",
+ NULL
+};
+
+#endif
+
diff --git a/include/lua/lparser.h b/include/lua/lparser.h
new file mode 100644
index 00000000..5e4500f1
--- /dev/null
+++ b/include/lua/lparser.h
@@ -0,0 +1,171 @@
+/*
+** $Id: lparser.h $
+** Lua Parser
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lparser_h
+#define lparser_h
+
+#include "llimits.h"
+#include "lobject.h"
+#include "lzio.h"
+
+
+/*
+** Expression and variable descriptor.
+** Code generation for variables and expressions can be delayed to allow
+** optimizations; An 'expdesc' structure describes a potentially-delayed
+** variable/expression. It has a description of its "main" value plus a
+** list of conditional jumps that can also produce its value (generated
+** by short-circuit operators 'and'/'or').
+*/
+
+/* kinds of variables/expressions */
+typedef enum {
+ VVOID, /* when 'expdesc' describes the last expression of a list,
+ this kind means an empty list (so, no expression) */
+ VNIL, /* constant nil */
+ VTRUE, /* constant true */
+ VFALSE, /* constant false */
+ VK, /* constant in 'k'; info = index of constant in 'k' */
+ VKFLT, /* floating constant; nval = numerical float value */
+ VKINT, /* integer constant; ival = numerical integer value */
+ VKSTR, /* string constant; strval = TString address;
+ (string is fixed by the lexer) */
+ VNONRELOC, /* expression has its value in a fixed register;
+ info = result register */
+ VLOCAL, /* local variable; var.ridx = register index;
+ var.vidx = relative index in 'actvar.arr' */
+ VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */
+ VCONST, /* compile-time variable;
+ info = absolute index in 'actvar.arr' */
+ VINDEXED, /* indexed variable;
+ ind.t = table register;
+ ind.idx = key's R index */
+ VINDEXUP, /* indexed upvalue;
+ ind.t = table upvalue;
+ ind.idx = key's K index */
+ VINDEXI, /* indexed variable with constant integer;
+ ind.t = table register;
+ ind.idx = key's value */
+ VINDEXSTR, /* indexed variable with literal string;
+ ind.t = table register;
+ ind.idx = key's K index */
+ VJMP, /* expression is a test/comparison;
+ info = pc of corresponding jump instruction */
+ VRELOC, /* expression can put result in any register;
+ info = instruction pc */
+ VCALL, /* expression is a function call; info = instruction pc */
+ VVARARG /* vararg expression; info = instruction pc */
+} expkind;
+
+
+#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXSTR)
+#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR)
+
+
+typedef struct expdesc {
+ expkind k;
+ union {
+ lua_Integer ival; /* for VKINT */
+ lua_Number nval; /* for VKFLT */
+ TString *strval; /* for VKSTR */
+ int info; /* for generic use */
+ struct { /* for indexed variables */
+ short idx; /* index (R or "long" K) */
+ lu_byte t; /* table (register or upvalue) */
+ } ind;
+ struct { /* for local variables */
+ lu_byte ridx; /* register holding the variable */
+ unsigned short vidx; /* compiler index (in 'actvar.arr') */
+ } var;
+ } u;
+ int t; /* patch list of 'exit when true' */
+ int f; /* patch list of 'exit when false' */
+} expdesc;
+
+
+/* kinds of variables */
+#define VDKREG 0 /* regular */
+#define RDKCONST 1 /* constant */
+#define RDKTOCLOSE 2 /* to-be-closed */
+#define RDKCTC 3 /* compile-time constant */
+
+/* description of an active local variable */
+typedef union Vardesc {
+ struct {
+ TValuefields; /* constant value (if it is a compile-time constant) */
+ lu_byte kind;
+ lu_byte ridx; /* register holding the variable */
+ short pidx; /* index of the variable in the Proto's 'locvars' array */
+ TString *name; /* variable name */
+ } vd;
+ TValue k; /* constant value (if any) */
+} Vardesc;
+
+
+
+/* description of pending goto statements and label statements */
+typedef struct Labeldesc {
+ TString *name; /* label identifier */
+ int pc; /* position in code */
+ int line; /* line where it appeared */
+ lu_byte nactvar; /* number of active variables in that position */
+ lu_byte close; /* goto that escapes upvalues */
+} Labeldesc;
+
+
+/* list of labels or gotos */
+typedef struct Labellist {
+ Labeldesc *arr; /* array */
+ int n; /* number of entries in use */
+ int size; /* array size */
+} Labellist;
+
+
+/* dynamic structures used by the parser */
+typedef struct Dyndata {
+ struct { /* list of all active local variables */
+ Vardesc *arr;
+ int n;
+ int size;
+ } actvar;
+ Labellist gt; /* list of pending gotos */
+ Labellist label; /* list of active labels */
+} Dyndata;
+
+
+/* control of blocks */
+struct BlockCnt; /* defined in lparser.c */
+
+
+/* state needed to generate code for a given function */
+typedef struct FuncState {
+ Proto *f; /* current function header */
+ struct FuncState *prev; /* enclosing function */
+ struct LexState *ls; /* lexical state */
+ struct BlockCnt *bl; /* chain of current blocks */
+ int pc; /* next position to code (equivalent to 'ncode') */
+ int lasttarget; /* 'label' of last 'jump label' */
+ int previousline; /* last line that was saved in 'lineinfo' */
+ int nk; /* number of elements in 'k' */
+ int np; /* number of elements in 'p' */
+ int nabslineinfo; /* number of elements in 'abslineinfo' */
+ int firstlocal; /* index of first local var (in Dyndata array) */
+ int firstlabel; /* index of first label (in 'dyd->label->arr') */
+ short ndebugvars; /* number of elements in 'f->locvars' */
+ lu_byte nactvar; /* number of active local variables */
+ lu_byte nups; /* number of upvalues */
+ lu_byte freereg; /* first free register */
+ lu_byte iwthabs; /* instructions issued since last absolute line info */
+ lu_byte needclose; /* function needs to close upvalues when returning */
+} FuncState;
+
+
+LUAI_FUNC int luaY_nvarstack (FuncState *fs);
+LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
+ Dyndata *dyd, const char *name, int firstchar);
+
+
+#endif
diff --git a/include/lua/lprefix.h b/include/lua/lprefix.h
new file mode 100644
index 00000000..484f2ad6
--- /dev/null
+++ b/include/lua/lprefix.h
@@ -0,0 +1,45 @@
+/*
+** $Id: lprefix.h $
+** Definitions for Lua code that must come before any other header file
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lprefix_h
+#define lprefix_h
+
+
+/*
+** Allows POSIX/XSI stuff
+*/
+#if !defined(LUA_USE_C89) /* { */
+
+#if !defined(_XOPEN_SOURCE)
+#define _XOPEN_SOURCE 600
+#elif _XOPEN_SOURCE == 0
+#undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */
+#endif
+
+/*
+** Allows manipulation of large files in gcc and some other compilers
+*/
+#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
+#define _LARGEFILE_SOURCE 1
+#define _FILE_OFFSET_BITS 64
+#endif
+
+#endif /* } */
+
+
+/*
+** Windows stuff
+*/
+#if defined(_WIN32) /* { */
+
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */
+#endif
+
+#endif /* } */
+
+#endif
+
diff --git a/include/lua/lstate.h b/include/lua/lstate.h
new file mode 100644
index 00000000..61e82cde
--- /dev/null
+++ b/include/lua/lstate.h
@@ -0,0 +1,404 @@
+/*
+** $Id: lstate.h $
+** Global State
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lstate_h
+#define lstate_h
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "ltm.h"
+#include "lzio.h"
+
+
+/*
+** Some notes about garbage-collected objects: All objects in Lua must
+** be kept somehow accessible until being freed, so all objects always
+** belong to one (and only one) of these lists, using field 'next' of
+** the 'CommonHeader' for the link:
+**
+** 'allgc': all objects not marked for finalization;
+** 'finobj': all objects marked for finalization;
+** 'tobefnz': all objects ready to be finalized;
+** 'fixedgc': all objects that are not to be collected (currently
+** only small strings, such as reserved words).
+**
+** For the generational collector, some of these lists have marks for
+** generations. Each mark points to the first element in the list for
+** that particular generation; that generation goes until the next mark.
+**
+** 'allgc' -> 'survival': new objects;
+** 'survival' -> 'old': objects that survived one collection;
+** 'old1' -> 'reallyold': objects that became old in last collection;
+** 'reallyold' -> NULL: objects old for more than one cycle.
+**
+** 'finobj' -> 'finobjsur': new objects marked for finalization;
+** 'finobjsur' -> 'finobjold1': survived """";
+** 'finobjold1' -> 'finobjrold': just old """";
+** 'finobjrold' -> NULL: really old """".
+**
+** All lists can contain elements older than their main ages, due
+** to 'luaC_checkfinalizer' and 'udata2finalize', which move
+** objects between the normal lists and the "marked for finalization"
+** lists. Moreover, barriers can age young objects in young lists as
+** OLD0, which then become OLD1. However, a list never contains
+** elements younger than their main ages.
+**
+** The generational collector also uses a pointer 'firstold1', which
+** points to the first OLD1 object in the list. It is used to optimize
+** 'markold'. (Potentially OLD1 objects can be anywhere between 'allgc'
+** and 'reallyold', but often the list has no OLD1 objects or they are
+** after 'old1'.) Note the difference between it and 'old1':
+** 'firstold1': no OLD1 objects before this point; there can be all
+** ages after it.
+** 'old1': no objects younger than OLD1 after this point.
+*/
+
+/*
+** Moreover, there is another set of lists that control gray objects.
+** These lists are linked by fields 'gclist'. (All objects that
+** can become gray have such a field. The field is not the same
+** in all objects, but it always has this name.) Any gray object
+** must belong to one of these lists, and all objects in these lists
+** must be gray (with two exceptions explained below):
+**
+** 'gray': regular gray objects, still waiting to be visited.
+** 'grayagain': objects that must be revisited at the atomic phase.
+** That includes
+** - black objects got in a write barrier;
+** - all kinds of weak tables during propagation phase;
+** - all threads.
+** 'weak': tables with weak values to be cleared;
+** 'ephemeron': ephemeron tables with white->white entries;
+** 'allweak': tables with weak keys and/or weak values to be cleared.
+**
+** The exceptions to that "gray rule" are:
+** - TOUCHED2 objects in generational mode stay in a gray list (because
+** they must be visited again at the end of the cycle), but they are
+** marked black because assignments to them must activate barriers (to
+** move them back to TOUCHED1).
+** - Open upvales are kept gray to avoid barriers, but they stay out
+** of gray lists. (They don't even have a 'gclist' field.)
+*/
+
+
+
+/*
+** About 'nCcalls': This count has two parts: the lower 16 bits counts
+** the number of recursive invocations in the C stack; the higher
+** 16 bits counts the number of non-yieldable calls in the stack.
+** (They are together so that we can change and save both with one
+** instruction.)
+*/
+
+
+/* true if this thread does not have non-yieldable calls in the stack */
+#define yieldable(L) (((L)->nCcalls & 0xffff0000) == 0)
+
+/* real number of C calls */
+#define getCcalls(L) ((L)->nCcalls & 0xffff)
+
+
+/* Increment the number of non-yieldable calls */
+#define incnny(L) ((L)->nCcalls += 0x10000)
+
+/* Decrement the number of non-yieldable calls */
+#define decnny(L) ((L)->nCcalls -= 0x10000)
+
+/* Non-yieldable call increment */
+#define nyci (0x10000 | 1)
+
+
+
+
+struct lua_longjmp; /* defined in ldo.c */
+
+
+/*
+** Atomic type (relative to signals) to better ensure that 'lua_sethook'
+** is thread safe
+*/
+#if !defined(l_signalT)
+#include
+#define l_signalT sig_atomic_t
+#endif
+
+
+/*
+** Extra stack space to handle TM calls and some other extras. This
+** space is not included in 'stack_last'. It is used only to avoid stack
+** checks, either because the element will be promptly popped or because
+** there will be a stack check soon after the push. Function frames
+** never use this extra space, so it does not need to be kept clean.
+*/
+#define EXTRA_STACK 5
+
+
+#define BASIC_STACK_SIZE (2*LUA_MINSTACK)
+
+#define stacksize(th) cast_int((th)->stack_last - (th)->stack)
+
+
+/* kinds of Garbage Collection */
+#define KGC_INC 0 /* incremental gc */
+#define KGC_GEN 1 /* generational gc */
+
+
+typedef struct stringtable {
+ TString **hash;
+ int nuse; /* number of elements */
+ int size;
+} stringtable;
+
+
+/*
+** Information about a call.
+** About union 'u':
+** - field 'l' is used only for Lua functions;
+** - field 'c' is used only for C functions.
+** About union 'u2':
+** - field 'funcidx' is used only by C functions while doing a
+** protected call;
+** - field 'nyield' is used only while a function is "doing" an
+** yield (from the yield until the next resume);
+** - field 'nres' is used only while closing tbc variables when
+** returning from a function;
+** - field 'transferinfo' is used only during call/returnhooks,
+** before the function starts or after it ends.
+*/
+typedef struct CallInfo {
+ StkId func; /* function index in the stack */
+ StkId top; /* top for this function */
+ struct CallInfo *previous, *next; /* dynamic call link */
+ union {
+ struct { /* only for Lua functions */
+ const Instruction *savedpc;
+ volatile l_signalT trap;
+ int nextraargs; /* # of extra arguments in vararg functions */
+ } l;
+ struct { /* only for C functions */
+ lua_KFunction k; /* continuation in case of yields */
+ ptrdiff_t old_errfunc;
+ lua_KContext ctx; /* context info. in case of yields */
+ } c;
+ } u;
+ union {
+ int funcidx; /* called-function index */
+ int nyield; /* number of values yielded */
+ int nres; /* number of values returned */
+ struct { /* info about transferred values (for call/return hooks) */
+ unsigned short ftransfer; /* offset of first value transferred */
+ unsigned short ntransfer; /* number of values transferred */
+ } transferinfo;
+ } u2;
+ short nresults; /* expected number of results from this function */
+ unsigned short callstatus;
+} CallInfo;
+
+
+/*
+** Bits in CallInfo status
+*/
+#define CIST_OAH (1<<0) /* original value of 'allowhook' */
+#define CIST_C (1<<1) /* call is running a C function */
+#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */
+#define CIST_HOOKED (1<<3) /* call is running a debug hook */
+#define CIST_YPCALL (1<<4) /* doing a yieldable protected call */
+#define CIST_TAIL (1<<5) /* call was tail called */
+#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */
+#define CIST_FIN (1<<7) /* function "called" a finalizer */
+#define CIST_TRAN (1<<8) /* 'ci' has transfer information */
+#define CIST_CLSRET (1<<9) /* function is closing tbc variables */
+/* Bits 10-12 are used for CIST_RECST (see below) */
+#define CIST_RECST 10
+#if defined(LUA_COMPAT_LT_LE)
+#define CIST_LEQ (1<<13) /* using __lt for __le */
+#endif
+
+
+/*
+** Field CIST_RECST stores the "recover status", used to keep the error
+** status while closing to-be-closed variables in coroutines, so that
+** Lua can correctly resume after an yield from a __close method called
+** because of an error. (Three bits are enough for error status.)
+*/
+#define getcistrecst(ci) (((ci)->callstatus >> CIST_RECST) & 7)
+#define setcistrecst(ci,st) \
+ check_exp(((st) & 7) == (st), /* status must fit in three bits */ \
+ ((ci)->callstatus = ((ci)->callstatus & ~(7 << CIST_RECST)) \
+ | ((st) << CIST_RECST)))
+
+
+/* active function is a Lua function */
+#define isLua(ci) (!((ci)->callstatus & CIST_C))
+
+/* call is running Lua code (not a hook) */
+#define isLuacode(ci) (!((ci)->callstatus & (CIST_C | CIST_HOOKED)))
+
+/* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
+#define setoah(st,v) ((st) = ((st) & ~CIST_OAH) | (v))
+#define getoah(st) ((st) & CIST_OAH)
+
+
+/*
+** 'global state', shared by all threads of this state
+*/
+typedef struct global_State {
+ lua_Alloc frealloc; /* function to reallocate memory */
+ void *ud; /* auxiliary data to 'frealloc' */
+ l_mem totalbytes; /* number of bytes currently allocated - GCdebt */
+ l_mem GCdebt; /* bytes allocated not yet compensated by the collector */
+ lu_mem GCestimate; /* an estimate of the non-garbage memory in use */
+ lu_mem lastatomic; /* see function 'genstep' in file 'lgc.c' */
+ stringtable strt; /* hash table for strings */
+ TValue l_registry;
+ TValue nilvalue; /* a nil value */
+ unsigned int seed; /* randomized seed for hashes */
+ lu_byte currentwhite;
+ lu_byte gcstate; /* state of garbage collector */
+ lu_byte gckind; /* kind of GC running */
+ lu_byte gcstopem; /* stops emergency collections */
+ lu_byte genminormul; /* control for minor generational collections */
+ lu_byte genmajormul; /* control for major generational collections */
+ lu_byte gcstp; /* control whether GC is running */
+ lu_byte gcemergency; /* true if this is an emergency collection */
+ lu_byte gcpause; /* size of pause between successive GCs */
+ lu_byte gcstepmul; /* GC "speed" */
+ lu_byte gcstepsize; /* (log2 of) GC granularity */
+ GCObject *allgc; /* list of all collectable objects */
+ GCObject **sweepgc; /* current position of sweep in list */
+ GCObject *finobj; /* list of collectable objects with finalizers */
+ GCObject *gray; /* list of gray objects */
+ GCObject *grayagain; /* list of objects to be traversed atomically */
+ GCObject *weak; /* list of tables with weak values */
+ GCObject *ephemeron; /* list of ephemeron tables (weak keys) */
+ GCObject *allweak; /* list of all-weak tables */
+ GCObject *tobefnz; /* list of userdata to be GC */
+ GCObject *fixedgc; /* list of objects not to be collected */
+ /* fields for generational collector */
+ GCObject *survival; /* start of objects that survived one GC cycle */
+ GCObject *old1; /* start of old1 objects */
+ GCObject *reallyold; /* objects more than one cycle old ("really old") */
+ GCObject *firstold1; /* first OLD1 object in the list (if any) */
+ GCObject *finobjsur; /* list of survival objects with finalizers */
+ GCObject *finobjold1; /* list of old1 objects with finalizers */
+ GCObject *finobjrold; /* list of really old objects with finalizers */
+ struct lua_State *twups; /* list of threads with open upvalues */
+ lua_CFunction panic; /* to be called in unprotected errors */
+ struct lua_State *mainthread;
+ TString *memerrmsg; /* message for memory-allocation errors */
+ TString *tmname[TM_N]; /* array with tag-method names */
+ struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */
+ TString *strcache[STRCACHE_N][STRCACHE_M]; /* cache for strings in API */
+ lua_WarnFunction warnf; /* warning function */
+ void *ud_warn; /* auxiliary data to 'warnf' */
+} global_State;
+
+
+/*
+** 'per thread' state
+*/
+struct lua_State {
+ CommonHeader;
+ lu_byte status;
+ lu_byte allowhook;
+ unsigned short nci; /* number of items in 'ci' list */
+ StkId top; /* first free slot in the stack */
+ global_State *l_G;
+ CallInfo *ci; /* call info for current function */
+ StkId stack_last; /* end of stack (last element + 1) */
+ StkId stack; /* stack base */
+ UpVal *openupval; /* list of open upvalues in this stack */
+ StkId tbclist; /* list of to-be-closed variables */
+ GCObject *gclist;
+ struct lua_State *twups; /* list of threads with open upvalues */
+ struct lua_longjmp *errorJmp; /* current error recover point */
+ CallInfo base_ci; /* CallInfo for first level (C calling Lua) */
+ volatile lua_Hook hook;
+ ptrdiff_t errfunc; /* current error handling function (stack index) */
+ l_uint32 nCcalls; /* number of nested (non-yieldable | C) calls */
+ int oldpc; /* last pc traced */
+ int basehookcount;
+ int hookcount;
+ volatile l_signalT hookmask;
+};
+
+
+#define G(L) (L->l_G)
+
+/*
+** 'g->nilvalue' being a nil value flags that the state was completely
+** build.
+*/
+#define completestate(g) ttisnil(&g->nilvalue)
+
+
+/*
+** Union of all collectable objects (only for conversions)
+** ISO C99, 6.5.2.3 p.5:
+** "if a union contains several structures that share a common initial
+** sequence [...], and if the union object currently contains one
+** of these structures, it is permitted to inspect the common initial
+** part of any of them anywhere that a declaration of the complete type
+** of the union is visible."
+*/
+union GCUnion {
+ GCObject gc; /* common header */
+ struct TString ts;
+ struct Udata u;
+ union Closure cl;
+ struct Table h;
+ struct Proto p;
+ struct lua_State th; /* thread */
+ struct UpVal upv;
+};
+
+
+/*
+** ISO C99, 6.7.2.1 p.14:
+** "A pointer to a union object, suitably converted, points to each of
+** its members [...], and vice versa."
+*/
+#define cast_u(o) cast(union GCUnion *, (o))
+
+/* macros to convert a GCObject into a specific value */
+#define gco2ts(o) \
+ check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts))
+#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u))
+#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l))
+#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c))
+#define gco2cl(o) \
+ check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl))
+#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h))
+#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p))
+#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th))
+#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv))
+
+
+/*
+** macro to convert a Lua object into a GCObject
+** (The access to 'tt' tries to ensure that 'v' is actually a Lua object.)
+*/
+#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc))
+
+
+/* actual number of total bytes allocated */
+#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt)
+
+LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
+LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
+LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
+LUAI_FUNC void luaE_freeCI (lua_State *L);
+LUAI_FUNC void luaE_shrinkCI (lua_State *L);
+LUAI_FUNC void luaE_checkcstack (lua_State *L);
+LUAI_FUNC void luaE_incCstack (lua_State *L);
+LUAI_FUNC void luaE_warning (lua_State *L, const char *msg, int tocont);
+LUAI_FUNC void luaE_warnerror (lua_State *L, const char *where);
+LUAI_FUNC int luaE_resetthread (lua_State *L, int status);
+
+
+#endif
+
diff --git a/include/lua/lstring.h b/include/lua/lstring.h
new file mode 100644
index 00000000..450c2390
--- /dev/null
+++ b/include/lua/lstring.h
@@ -0,0 +1,57 @@
+/*
+** $Id: lstring.h $
+** String table (keep all strings handled by Lua)
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lstring_h
+#define lstring_h
+
+#include "lgc.h"
+#include "lobject.h"
+#include "lstate.h"
+
+
+/*
+** Memory-allocation error message must be preallocated (it cannot
+** be created after memory is exhausted)
+*/
+#define MEMERRMSG "not enough memory"
+
+
+/*
+** Size of a TString: Size of the header plus space for the string
+** itself (including final '\0').
+*/
+#define sizelstring(l) (offsetof(TString, contents) + ((l) + 1) * sizeof(char))
+
+#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \
+ (sizeof(s)/sizeof(char))-1))
+
+
+/*
+** test whether a string is a reserved word
+*/
+#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0)
+
+
+/*
+** equality for short strings, which are always internalized
+*/
+#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b))
+
+
+LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
+LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts);
+LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
+LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
+LUAI_FUNC void luaS_clearcache (global_State *g);
+LUAI_FUNC void luaS_init (lua_State *L);
+LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
+LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue);
+LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
+LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
+LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
+
+
+#endif
diff --git a/include/lua/ltable.h b/include/lua/ltable.h
new file mode 100644
index 00000000..7bbbcb21
--- /dev/null
+++ b/include/lua/ltable.h
@@ -0,0 +1,66 @@
+/*
+** $Id: ltable.h $
+** Lua tables (hash)
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltable_h
+#define ltable_h
+
+#include "lobject.h"
+
+
+#define gnode(t,i) (&(t)->node[i])
+#define gval(n) (&(n)->i_val)
+#define gnext(n) ((n)->u.next)
+
+
+/*
+** Clear all bits of fast-access metamethods, which means that the table
+** may have any of these metamethods. (First access that fails after the
+** clearing will set the bit again.)
+*/
+#define invalidateTMcache(t) ((t)->flags &= ~maskflags)
+
+
+/* true when 't' is using 'dummynode' as its hash part */
+#define isdummy(t) ((t)->lastfree == NULL)
+
+
+/* allocated size for hash nodes */
+#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t))
+
+
+/* returns the Node, given the value of a table entry */
+#define nodefromval(v) cast(Node *, (v))
+
+
+LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
+LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
+ TValue *value);
+LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key);
+LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
+LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
+LUAI_FUNC void luaH_newkey (lua_State *L, Table *t, const TValue *key,
+ TValue *value);
+LUAI_FUNC void luaH_set (lua_State *L, Table *t, const TValue *key,
+ TValue *value);
+LUAI_FUNC void luaH_finishset (lua_State *L, Table *t, const TValue *key,
+ const TValue *slot, TValue *value);
+LUAI_FUNC Table *luaH_new (lua_State *L);
+LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
+ unsigned int nhsize);
+LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize);
+LUAI_FUNC void luaH_free (lua_State *L, Table *t);
+LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
+LUAI_FUNC lua_Unsigned luaH_getn (Table *t);
+LUAI_FUNC unsigned int luaH_realasize (const Table *t);
+
+
+#if defined(LUA_DEBUG)
+LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
+LUAI_FUNC int luaH_isdummy (const Table *t);
+#endif
+
+
+#endif
diff --git a/include/lua/ltm.h b/include/lua/ltm.h
new file mode 100644
index 00000000..73b833c6
--- /dev/null
+++ b/include/lua/ltm.h
@@ -0,0 +1,103 @@
+/*
+** $Id: ltm.h $
+** Tag methods
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltm_h
+#define ltm_h
+
+
+#include "lobject.h"
+
+
+/*
+* WARNING: if you change the order of this enumeration,
+* grep "ORDER TM" and "ORDER OP"
+*/
+typedef enum {
+ TM_INDEX,
+ TM_NEWINDEX,
+ TM_GC,
+ TM_MODE,
+ TM_LEN,
+ TM_EQ, /* last tag method with fast access */
+ TM_ADD,
+ TM_SUB,
+ TM_MUL,
+ TM_MOD,
+ TM_POW,
+ TM_DIV,
+ TM_IDIV,
+ TM_BAND,
+ TM_BOR,
+ TM_BXOR,
+ TM_SHL,
+ TM_SHR,
+ TM_UNM,
+ TM_BNOT,
+ TM_LT,
+ TM_LE,
+ TM_CONCAT,
+ TM_CALL,
+ TM_CLOSE,
+ TM_N /* number of elements in the enum */
+} TMS;
+
+
+/*
+** Mask with 1 in all fast-access methods. A 1 in any of these bits
+** in the flag of a (meta)table means the metatable does not have the
+** corresponding metamethod field. (Bit 7 of the flag is used for
+** 'isrealasize'.)
+*/
+#define maskflags (~(~0u << (TM_EQ + 1)))
+
+
+/*
+** Test whether there is no tagmethod.
+** (Because tagmethods use raw accesses, the result may be an "empty" nil.)
+*/
+#define notm(tm) ttisnil(tm)
+
+
+#define gfasttm(g,et,e) ((et) == NULL ? NULL : \
+ ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
+
+#define fasttm(l,et,e) gfasttm(G(l), et, e)
+
+#define ttypename(x) luaT_typenames_[(x) + 1]
+
+LUAI_DDEC(const char *const luaT_typenames_[LUA_TOTALTYPES];)
+
+
+LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o);
+
+LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
+LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
+ TMS event);
+LUAI_FUNC void luaT_init (lua_State *L);
+
+LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
+ const TValue *p2, const TValue *p3);
+LUAI_FUNC void luaT_callTMres (lua_State *L, const TValue *f,
+ const TValue *p1, const TValue *p2, StkId p3);
+LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
+ StkId res, TMS event);
+LUAI_FUNC void luaT_tryconcatTM (lua_State *L);
+LUAI_FUNC void luaT_trybinassocTM (lua_State *L, const TValue *p1,
+ const TValue *p2, int inv, StkId res, TMS event);
+LUAI_FUNC void luaT_trybiniTM (lua_State *L, const TValue *p1, lua_Integer i2,
+ int inv, StkId res, TMS event);
+LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
+ const TValue *p2, TMS event);
+LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
+ int inv, int isfloat, TMS event);
+
+LUAI_FUNC void luaT_adjustvarargs (lua_State *L, int nfixparams,
+ struct CallInfo *ci, const Proto *p);
+LUAI_FUNC void luaT_getvarargs (lua_State *L, struct CallInfo *ci,
+ StkId where, int wanted);
+
+
+#endif
diff --git a/include/lua/lua.h b/include/lua/lua.h
new file mode 100644
index 00000000..e6618392
--- /dev/null
+++ b/include/lua/lua.h
@@ -0,0 +1,518 @@
+/*
+** $Id: lua.h $
+** 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
+#include
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR "5"
+#define LUA_VERSION_MINOR "4"
+#define LUA_VERSION_RELEASE "4"
+
+#define LUA_VERSION_NUM 504
+#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 4)
+
+#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-2022 Lua.org, PUC-Rio"
+#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('Lua') */
+#define LUA_SIGNATURE "\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET (-1)
+
+
+/*
+** Pseudo-indices
+** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
+** space after that to help overflow detection)
+*/
+#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000)
+#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_ERRERR 5
+
+
+typedef struct lua_State lua_State;
+
+
+/*
+** 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_NUMTYPES 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;
+
+/* type for continuation-function contexts */
+typedef LUA_KCONTEXT lua_KContext;
+
+
+/*
+** Type for C functions registered with Lua
+*/
+typedef int (*lua_CFunction) (lua_State *L);
+
+/*
+** Type for continuation functions
+*/
+typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
+
+
+/*
+** Type for 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);
+
+
+/*
+** Type for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** Type for warning functions
+*/
+typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont);
+
+
+
+
+/*
+** 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 int (lua_resetthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API 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_rotate) (lua_State *L, int idx, int n);
+LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int (lua_checkstack) (lua_State *L, int n);
+
+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_isinteger) (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 int (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API lua_Unsigned (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, ORDER OP */
+#define LUA_OPSUB 1
+#define LUA_OPMUL 2
+#define LUA_OPMOD 3
+#define LUA_OPPOW 4
+#define LUA_OPDIV 5
+#define LUA_OPIDIV 6
+#define LUA_OPBAND 7
+#define LUA_OPBOR 8
+#define LUA_OPBXOR 9
+#define LUA_OPSHL 10
+#define LUA_OPSHR 11
+#define LUA_OPUNM 12
+#define LUA_OPBNOT 13
+
+LUA_API void (lua_arith) (lua_State *L, int op);
+
+#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 const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
+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 int (lua_getglobal) (lua_State *L, const char *name);
+LUA_API int (lua_gettable) (lua_State *L, int idx);
+LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawget) (lua_State *L, int idx);
+LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
+
+LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue);
+LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void (lua_setglobal) (lua_State *L, const char *name);
+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_seti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void (lua_rawset) (lua_State *L, int idx);
+LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer 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 int (lua_setiuservalue) (lua_State *L, int idx, int n);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults,
+ lua_KContext ctx, lua_KFunction k);
+#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+ lua_KContext ctx, lua_KFunction k);
+#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+ const char *chunkname, const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx,
+ lua_KFunction k);
+LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg,
+ int *nres);
+LUA_API int (lua_status) (lua_State *L);
+LUA_API int (lua_isyieldable) (lua_State *L);
+
+#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)
+
+
+/*
+** Warning-related functions
+*/
+LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud);
+LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont);
+
+
+/*
+** 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_GCISRUNNING 9
+#define LUA_GCGEN 10
+#define LUA_GCINC 11
+
+LUA_API int (lua_gc) (lua_State *L, int what, ...);
+
+
+/*
+** 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 size_t (lua_stringtonumber) (lua_State *L, const char *s);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+LUA_API void (lua_toclose) (lua_State *L, int idx);
+LUA_API void (lua_closeslot) (lua_State *L, int idx);
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE))
+
+#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL)
+#define lua_tointeger(L,i) lua_tointegerx(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_pushstring(L, "" s)
+
+#define lua_pushglobaltable(L) \
+ ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
+
+#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
+
+
+#define lua_insert(L,idx) lua_rotate(L, (idx), 1)
+
+#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1))
+
+#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1))
+
+/* }============================================================== */
+
+
+/*
+** {==============================================================
+** compatibility macros
+** ===============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
+#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is))
+#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL)
+
+#endif
+
+#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1)
+#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1)
+#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1)
+
+#define LUA_NUMTAGS LUA_NUMTYPES
+
+/* }============================================================== */
+
+/*
+** {======================================================================
+** 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 void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit);
+
+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) */
+ size_t srclen; /* (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) */
+ unsigned short ftransfer; /* (r) index of first value transferred */
+ unsigned short ntransfer; /* (r) number of transferred values */
+ char short_src[LUA_IDSIZE]; /* (S) */
+ /* private part */
+ struct CallInfo *i_ci; /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2022 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/include/lua/lua.hpp b/include/lua/lua.hpp
new file mode 100644
index 00000000..ec417f59
--- /dev/null
+++ b/include/lua/lua.hpp
@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}
diff --git a/include/lua/luaconf.h b/include/lua/luaconf.h
new file mode 100644
index 00000000..d42d14b7
--- /dev/null
+++ b/include/lua/luaconf.h
@@ -0,0 +1,786 @@
+/*
+** $Id: luaconf.h $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef luaconf_h
+#define luaconf_h
+
+#include
+#include
+
+
+/*
+** ===================================================================
+** General Configuration File for Lua
+**
+** Some definitions here can be changed externally, through the compiler
+** (e.g., with '-D' options): They are commented out or protected
+** by '#if !defined' guards. However, several other definitions
+** should be changed directly here, either because they affect the
+** Lua ABI (by making the changes here, you ensure that all software
+** connected to Lua, such as C libraries, will be compiled with the same
+** configuration); or because they are seldom changed.
+**
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+** {====================================================================
+** System Configuration: macros to adapt (if needed) Lua to some
+** particular platform, for instance restricting it to C89.
+** =====================================================================
+*/
+
+/*
+@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
+** Define it if you want Lua to avoid the use of a few C99 features
+** or Windows-specific features on Windows.
+*/
+/* #define LUA_USE_C89 */
+
+
+/*
+** By default, Lua on Windows use (some) specific Windows features
+*/
+#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_USE_WINDOWS /* enable goodies for regular Windows */
+#endif
+
+
+#if defined(LUA_USE_WINDOWS)
+#define LUA_DL_DLL /* enable support for DLL */
+#define LUA_USE_C89 /* broadly, Windows is C89 */
+#endif
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN /* needs an extra library: -ldl */
+#endif
+
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN /* MacOS does not need -ldl */
+#endif
+
+
+/*
+@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits.
+*/
+#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3)
+
+/* }================================================================== */
+
+
+
+/*
+** {==================================================================
+** Configuration for Number types. These options should not be
+** set externally, because any other code connected to Lua must
+** use the same configuration.
+** ===================================================================
+*/
+
+/*
+@@ LUA_INT_TYPE defines the type for Lua integers.
+@@ LUA_FLOAT_TYPE defines the type for Lua floats.
+** Lua should work fine with any mix of these options supported
+** by your C compiler. The usual configurations are 64-bit integers
+** and 'double' (the default), 32-bit integers and 'float' (for
+** restricted platforms), and 'long'/'double' (for C compilers not
+** compliant with C99, which may not have support for 'long long').
+*/
+
+/* predefined options for LUA_INT_TYPE */
+#define LUA_INT_INT 1
+#define LUA_INT_LONG 2
+#define LUA_INT_LONGLONG 3
+
+/* predefined options for LUA_FLOAT_TYPE */
+#define LUA_FLOAT_FLOAT 1
+#define LUA_FLOAT_DOUBLE 2
+#define LUA_FLOAT_LONGDOUBLE 3
+
+
+/* Default configuration ('long long' and 'double', for 64-bit Lua) */
+#define LUA_INT_DEFAULT LUA_INT_LONGLONG
+#define LUA_FLOAT_DEFAULT LUA_FLOAT_DOUBLE
+
+
+/*
+@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats.
+*/
+#define LUA_32BITS 0
+
+
+/*
+@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
+** C89 ('long' and 'double'); Windows always has '__int64', so it does
+** not need to use this case.
+*/
+#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
+#define LUA_C89_NUMBERS 1
+#else
+#define LUA_C89_NUMBERS 0
+#endif
+
+
+#if LUA_32BITS /* { */
+/*
+** 32-bit integers and 'float'
+*/
+#if LUAI_IS32INT /* use 'int' if big enough */
+#define LUA_INT_TYPE LUA_INT_INT
+#else /* otherwise use 'long' */
+#define LUA_INT_TYPE LUA_INT_LONG
+#endif
+#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT
+
+#elif LUA_C89_NUMBERS /* }{ */
+/*
+** largest types available for C89 ('long' and 'double')
+*/
+#define LUA_INT_TYPE LUA_INT_LONG
+#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE
+
+#else /* }{ */
+/* use defaults */
+
+#define LUA_INT_TYPE LUA_INT_DEFAULT
+#define LUA_FLOAT_TYPE LUA_FLOAT_DEFAULT
+
+#endif /* } */
+
+
+/* }================================================================== */
+
+
+
+/*
+** {==================================================================
+** Configuration for Paths.
+** ===================================================================
+*/
+
+/*
+** LUA_PATH_SEP is the character that separates templates in a path.
+** LUA_PATH_MARK is the string that marks the substitution points in a
+** template.
+** LUA_EXEC_DIR in a Windows path is replaced by the executable's
+** directory.
+*/
+#define LUA_PATH_SEP ";"
+#define LUA_PATH_MARK "?"
+#define LUA_EXEC_DIR "!"
+
+
+/*
+@@ 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.
+*/
+
+#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#if defined(_WIN32) /* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR "!\\lua\\"
+#define LUA_CDIR "!\\"
+#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\"
+
+#if !defined(LUA_PATH_DEFAULT)
+#define LUA_PATH_DEFAULT \
+ LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
+ LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \
+ LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
+ ".\\?.lua;" ".\\?\\init.lua"
+#endif
+
+#if !defined(LUA_CPATH_DEFAULT)
+#define LUA_CPATH_DEFAULT \
+ LUA_CDIR"?.dll;" \
+ LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
+ LUA_CDIR"loadall.dll;" ".\\?.dll"
+#endif
+
+#else /* }{ */
+
+#define LUA_ROOT "/usr/local/"
+#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/"
+#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/"
+
+#if !defined(LUA_PATH_DEFAULT)
+#define LUA_PATH_DEFAULT \
+ LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
+ LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \
+ "./?.lua;" "./?/init.lua"
+#endif
+
+#if !defined(LUA_CPATH_DEFAULT)
+#define LUA_CPATH_DEFAULT \
+ LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
+#endif
+
+#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(LUA_DIRSEP)
+
+#if defined(_WIN32)
+#define LUA_DIRSEP "\\"
+#else
+#define LUA_DIRSEP "/"
+#endif
+
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Marks for exported symbols in the C code
+** ===================================================================
+*/
+
+/*
+@@ 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 LUA_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,
+** none of which 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("internal"))) extern
+#else /* }{ */
+#define LUAI_FUNC extern
+#endif /* } */
+
+#define LUAI_DDEC(dec) LUAI_FUNC dec
+#define LUAI_DDEF /* empty */
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_5_3) /* { */
+
+/*
+@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
+** functions in the mathematical library.
+** (These functions were already officially removed in 5.3;
+** nevertheless they are still available here.)
+*/
+#define LUA_COMPAT_MATHLIB
+
+/*
+@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
+** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
+** luaL_checkint, luaL_checklong, etc.)
+** (These macros were also officially removed in 5.3, but they are still
+** available here.)
+*/
+#define LUA_COMPAT_APIINTCASTS
+
+
+/*
+@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod
+** using '__lt'.
+*/
+#define LUA_COMPAT_LT_LE
+
+
+/*
+@@ 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.
+** (Once more, these macros were officially removed in 5.3, but they are
+** still available here.)
+*/
+#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)
+
+#endif /* } */
+
+/* }================================================================== */
+
+
+
+/*
+** {==================================================================
+** Configuration for Numbers (low-level part).
+** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
+** satisfy your needs.
+** ===================================================================
+*/
+
+/*
+@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
+@@ over a floating number.
+@@ l_floatatt(x) corrects float attribute 'x' to the proper float type
+** by prefixing it with one of FLT/DBL/LDBL.
+@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
+@@ LUA_NUMBER_FMT is the format for writing floats.
+@@ lua_number2str converts a float to a string.
+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
+@@ l_floor takes the floor of a float.
+@@ lua_str2number converts a decimal numeral to a number.
+*/
+
+
+/* The following definitions are good for most cases here */
+
+#define l_floor(x) (l_mathop(floor)(x))
+
+#define lua_number2str(s,sz,n) \
+ l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
+
+/*
+@@ lua_numbertointeger converts a float number with an integral value
+** to an integer, or returns 0 if float is not within the range of
+** a lua_Integer. (The range comparisons are tricky because of
+** rounding. The tests here assume a two-complement representation,
+** where MININTEGER always has an exact representation as a float;
+** MAXINTEGER may not have one, and therefore its conversion to float
+** may have an ill-defined value.)
+*/
+#define lua_numbertointeger(n,p) \
+ ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
+ (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
+ (*(p) = (LUA_INTEGER)(n), 1))
+
+
+/* now the variable definitions */
+
+#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
+
+#define LUA_NUMBER float
+
+#define l_floatatt(n) (FLT_##n)
+
+#define LUAI_UACNUMBER double
+
+#define LUA_NUMBER_FRMLEN ""
+#define LUA_NUMBER_FMT "%.7g"
+
+#define l_mathop(op) op##f
+
+#define lua_str2number(s,p) strtof((s), (p))
+
+
+#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */
+
+#define LUA_NUMBER long double
+
+#define l_floatatt(n) (LDBL_##n)
+
+#define LUAI_UACNUMBER long double
+
+#define LUA_NUMBER_FRMLEN "L"
+#define LUA_NUMBER_FMT "%.19Lg"
+
+#define l_mathop(op) op##l
+
+#define lua_str2number(s,p) strtold((s), (p))
+
+#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */
+
+#define LUA_NUMBER double
+
+#define l_floatatt(n) (DBL_##n)
+
+#define LUAI_UACNUMBER double
+
+#define LUA_NUMBER_FRMLEN ""
+#define LUA_NUMBER_FMT "%.14g"
+
+#define l_mathop(op) op
+
+#define lua_str2number(s,p) strtod((s), (p))
+
+#else /* }{ */
+
+#error "numeric float type not defined"
+
+#endif /* } */
+
+
+
+/*
+@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
+@@ LUAI_UACINT is the result of a 'default argument promotion'
+@@ over a LUA_INTEGER.
+@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
+@@ LUA_INTEGER_FMT is the format for writing integers.
+@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
+@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
+@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
+@@ lua_integer2str converts an integer to a string.
+*/
+
+
+/* The following definitions are good for most cases here */
+
+#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
+
+#define LUAI_UACINT LUA_INTEGER
+
+#define lua_integer2str(s,sz,n) \
+ l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
+
+/*
+** use LUAI_UACINT here to avoid problems with promotions (which
+** can turn a comparison between unsigneds into a signed comparison)
+*/
+#define LUA_UNSIGNED unsigned LUAI_UACINT
+
+
+/* now the variable definitions */
+
+#if LUA_INT_TYPE == LUA_INT_INT /* { int */
+
+#define LUA_INTEGER int
+#define LUA_INTEGER_FRMLEN ""
+
+#define LUA_MAXINTEGER INT_MAX
+#define LUA_MININTEGER INT_MIN
+
+#define LUA_MAXUNSIGNED UINT_MAX
+
+#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */
+
+#define LUA_INTEGER long
+#define LUA_INTEGER_FRMLEN "l"
+
+#define LUA_MAXINTEGER LONG_MAX
+#define LUA_MININTEGER LONG_MIN
+
+#define LUA_MAXUNSIGNED ULONG_MAX
+
+#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
+
+/* use presence of macro LLONG_MAX as proxy for C99 compliance */
+#if defined(LLONG_MAX) /* { */
+/* use ISO C99 stuff */
+
+#define LUA_INTEGER long long
+#define LUA_INTEGER_FRMLEN "ll"
+
+#define LUA_MAXINTEGER LLONG_MAX
+#define LUA_MININTEGER LLONG_MIN
+
+#define LUA_MAXUNSIGNED ULLONG_MAX
+
+#elif defined(LUA_USE_WINDOWS) /* }{ */
+/* in Windows, can use specific Windows types */
+
+#define LUA_INTEGER __int64
+#define LUA_INTEGER_FRMLEN "I64"
+
+#define LUA_MAXINTEGER _I64_MAX
+#define LUA_MININTEGER _I64_MIN
+
+#define LUA_MAXUNSIGNED _UI64_MAX
+
+#else /* }{ */
+
+#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
+ or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
+
+#endif /* } */
+
+#else /* }{ */
+
+#error "numeric integer type not defined"
+
+#endif /* } */
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Dependencies with C99 and other C details
+** ===================================================================
+*/
+
+/*
+@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
+** (All uses in Lua have only one format item.)
+*/
+#if !defined(LUA_USE_C89)
+#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
+#else
+#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
+#endif
+
+
+/*
+@@ lua_strx2number converts a hexadecimal numeral to a number.
+** In C99, 'strtod' does that conversion. Otherwise, you can
+** leave 'lua_strx2number' undefined and Lua will provide its own
+** implementation.
+*/
+#if !defined(LUA_USE_C89)
+#define lua_strx2number(s,p) lua_str2number(s,p)
+#endif
+
+
+/*
+@@ lua_pointer2str converts a pointer to a readable string in a
+** non-specified way.
+*/
+#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p)
+
+
+/*
+@@ lua_number2strx converts a float to a hexadecimal numeral.
+** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
+** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
+** provide its own implementation.
+*/
+#if !defined(LUA_USE_C89)
+#define lua_number2strx(L,b,sz,f,n) \
+ ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
+#endif
+
+
+/*
+** 'strtof' and 'opf' variants for math functions are not valid in
+** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
+** availability of these variants. ('math.h' is already included in
+** all files that use these macros.)
+*/
+#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
+#undef l_mathop /* variants not available */
+#undef lua_str2number
+#define l_mathop(op) (lua_Number)op /* no variant */
+#define lua_str2number(s,p) ((lua_Number)strtod((s), (p)))
+#endif
+
+
+/*
+@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
+** functions. It must be a numerical type; Lua will use 'intptr_t' if
+** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
+** 'intptr_t' in C89)
+*/
+#define LUA_KCONTEXT ptrdiff_t
+
+#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
+ __STDC_VERSION__ >= 199901L
+#include
+#if defined(INTPTR_MAX) /* even in C99 this type is optional */
+#undef LUA_KCONTEXT
+#define LUA_KCONTEXT intptr_t
+#endif
+#endif
+
+
+/*
+@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
+** Change that if you do not want to use C locales. (Code using this
+** macro must include the header 'locale.h'.)
+*/
+#if !defined(lua_getlocaledecpoint)
+#define lua_getlocaledecpoint() (localeconv()->decimal_point[0])
+#endif
+
+
+/*
+** macros to improve jump prediction, used mostly for error handling
+** and debug facilities. (Some macros in the Lua API use these macros.
+** Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your
+** code.)
+*/
+#if !defined(luai_likely)
+
+#if defined(__GNUC__) && !defined(LUA_NOBUILTIN)
+#define luai_likely(x) (__builtin_expect(((x) != 0), 1))
+#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0))
+#else
+#define luai_likely(x) (x)
+#define luai_unlikely(x) (x)
+#endif
+
+#endif
+
+
+#if defined(LUA_CORE) || defined(LUA_LIB)
+/* shorter names for Lua's own use */
+#define l_likely(x) luai_likely(x)
+#define l_unlikely(x) luai_unlikely(x)
+#endif
+
+
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Language Variations
+** =====================================================================
+*/
+
+/*
+@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
+** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
+** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
+** coercion from strings to numbers.
+*/
+/* #define LUA_NOCVTN2S */
+/* #define LUA_NOCVTS2N */
+
+
+/*
+@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
+** Define it as a help when debugging C code.
+*/
+#if defined(LUA_USE_APICHECK)
+#include
+#define luai_apicheck(l,e) assert(e)
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Macros that affect the API and must be stable (that is, must be the
+** same when you compile Lua and when you compile code that links to
+** Lua).
+** =====================================================================
+*/
+
+/*
+@@ 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 from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+** (It must fit into max(size_t)/32.)
+*/
+#if LUAI_IS32INT
+#define LUAI_MAXSTACK 1000000
+#else
+#define LUAI_MAXSTACK 15000
+#endif
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+#define LUA_EXTRASPACE (sizeof(void *))
+
+
+/*
+@@ 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
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number)))
+
+
+/*
+@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure
+** maximum alignment for the other items in that union.
+*/
+#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l
+
+/* }================================================================== */
+
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+
+
+#endif
+
diff --git a/include/lua/lualib.h b/include/lua/lualib.h
new file mode 100644
index 00000000..26255290
--- /dev/null
+++ b/include/lua/lualib.h
@@ -0,0 +1,52 @@
+/*
+** $Id: lualib.h $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+/* version suffix for environment variable names */
+#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
+
+
+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_UTF8LIBNAME "utf8"
+LUAMOD_API int (luaopen_utf8) (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);
+
+
+#endif
diff --git a/include/lua/lundump.h b/include/lua/lundump.h
new file mode 100644
index 00000000..f3748a99
--- /dev/null
+++ b/include/lua/lundump.h
@@ -0,0 +1,36 @@
+/*
+** $Id: lundump.h $
+** load precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lundump_h
+#define lundump_h
+
+#include "llimits.h"
+#include "lobject.h"
+#include "lzio.h"
+
+
+/* data to catch conversion errors */
+#define LUAC_DATA "\x19\x93\r\n\x1a\n"
+
+#define LUAC_INT 0x5678
+#define LUAC_NUM cast_num(370.5)
+
+/*
+** Encode major-minor version in one byte, one nibble for each
+*/
+#define MYINT(s) (s[0]-'0') /* assume one-digit numerals */
+#define LUAC_VERSION (MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
+
+#define LUAC_FORMAT 0 /* this is the official format */
+
+/* load one chunk; from lundump.c */
+LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
+
+/* dump one chunk; from ldump.c */
+LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
+ void* data, int strip);
+
+#endif
diff --git a/include/lua/lvm.h b/include/lua/lvm.h
new file mode 100644
index 00000000..1bc16f3a
--- /dev/null
+++ b/include/lua/lvm.h
@@ -0,0 +1,136 @@
+/*
+** $Id: lvm.h $
+** Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lvm_h
+#define lvm_h
+
+
+#include "ldo.h"
+#include "lobject.h"
+#include "ltm.h"
+
+
+#if !defined(LUA_NOCVTN2S)
+#define cvt2str(o) ttisnumber(o)
+#else
+#define cvt2str(o) 0 /* no conversion from numbers to strings */
+#endif
+
+
+#if !defined(LUA_NOCVTS2N)
+#define cvt2num(o) ttisstring(o)
+#else
+#define cvt2num(o) 0 /* no conversion from strings to numbers */
+#endif
+
+
+/*
+** You can define LUA_FLOORN2I if you want to convert floats to integers
+** by flooring them (instead of raising an error if they are not
+** integral values)
+*/
+#if !defined(LUA_FLOORN2I)
+#define LUA_FLOORN2I F2Ieq
+#endif
+
+
+/*
+** Rounding modes for float->integer coercion
+ */
+typedef enum {
+ F2Ieq, /* no rounding; accepts only integral values */
+ F2Ifloor, /* takes the floor of the number */
+ F2Iceil /* takes the ceil of the number */
+} F2Imod;
+
+
+/* convert an object to a float (including string coercion) */
+#define tonumber(o,n) \
+ (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
+
+
+/* convert an object to a float (without string coercion) */
+#define tonumberns(o,n) \
+ (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \
+ (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0))
+
+
+/* convert an object to an integer (including string coercion) */
+#define tointeger(o,i) \
+ (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \
+ : luaV_tointeger(o,i,LUA_FLOORN2I))
+
+
+/* convert an object to an integer (without string coercion) */
+#define tointegerns(o,i) \
+ (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \
+ : luaV_tointegerns(o,i,LUA_FLOORN2I))
+
+
+#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
+
+#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2)
+
+
+/*
+** fast track for 'gettable': if 't' is a table and 't[k]' is present,
+** return 1 with 'slot' pointing to 't[k]' (position of final result).
+** Otherwise, return 0 (meaning it will have to check metamethod)
+** with 'slot' pointing to an empty 't[k]' (if 't' is a table) or NULL
+** (otherwise). 'f' is the raw get function to use.
+*/
+#define luaV_fastget(L,t,k,slot,f) \
+ (!ttistable(t) \
+ ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \
+ : (slot = f(hvalue(t), k), /* else, do raw access */ \
+ !isempty(slot))) /* result not empty? */
+
+
+/*
+** Special case of 'luaV_fastget' for integers, inlining the fast case
+** of 'luaH_getint'.
+*/
+#define luaV_fastgeti(L,t,k,slot) \
+ (!ttistable(t) \
+ ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \
+ : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \
+ ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \
+ !isempty(slot))) /* result not empty? */
+
+
+/*
+** Finish a fast set operation (when fast get succeeds). In that case,
+** 'slot' points to the place to put the value.
+*/
+#define luaV_finishfastset(L,t,slot,v) \
+ { setobj2t(L, cast(TValue *,slot), v); \
+ luaC_barrierback(L, gcvalue(t), v); }
+
+
+
+
+LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2);
+LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
+LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
+LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
+LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode);
+LUAI_FUNC int luaV_tointegerns (const TValue *obj, lua_Integer *p,
+ F2Imod mode);
+LUAI_FUNC int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode);
+LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
+ StkId val, const TValue *slot);
+LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
+ TValue *val, const TValue *slot);
+LUAI_FUNC void luaV_finishOp (lua_State *L);
+LUAI_FUNC void luaV_execute (lua_State *L, CallInfo *ci);
+LUAI_FUNC void luaV_concat (lua_State *L, int total);
+LUAI_FUNC lua_Integer luaV_idiv (lua_State *L, lua_Integer x, lua_Integer y);
+LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
+LUAI_FUNC lua_Number luaV_modf (lua_State *L, lua_Number x, lua_Number y);
+LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
+LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
+
+#endif
diff --git a/include/lua/lzio.h b/include/lua/lzio.h
new file mode 100644
index 00000000..38f397fd
--- /dev/null
+++ b/include/lua/lzio.h
@@ -0,0 +1,66 @@
+/*
+** $Id: lzio.h $
+** Buffered streams
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lzio_h
+#define lzio_h
+
+#include "lua.h"
+
+#include "lmem.h"
+
+
+#define EOZ (-1) /* end of stream */
+
+typedef struct Zio ZIO;
+
+#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z))
+
+
+typedef struct Mbuffer {
+ char *buffer;
+ size_t n;
+ size_t buffsize;
+} Mbuffer;
+
+#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
+
+#define luaZ_buffer(buff) ((buff)->buffer)
+#define luaZ_sizebuffer(buff) ((buff)->buffsize)
+#define luaZ_bufflen(buff) ((buff)->n)
+
+#define luaZ_buffremove(buff,i) ((buff)->n -= (i))
+#define luaZ_resetbuffer(buff) ((buff)->n = 0)
+
+
+#define luaZ_resizebuffer(L, buff, size) \
+ ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
+ (buff)->buffsize, size), \
+ (buff)->buffsize = size)
+
+#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
+
+
+LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
+ void *data);
+LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */
+
+
+
+/* --------- Private Part ------------------ */
+
+struct Zio {
+ size_t n; /* bytes still unread */
+ const char *p; /* current position in buffer */
+ lua_Reader reader; /* reader function */
+ void *data; /* additional data */
+ lua_State *L; /* Lua state (for reader) */
+};
+
+
+LUAI_FUNC int luaZ_fill (ZIO *z);
+
+#endif
diff --git a/lib/win/lua54.dll b/lib/win/lua54.dll
new file mode 100644
index 0000000000000000000000000000000000000000..77ff13fd9e05518c3e62ed53264c0c1c14ce4688
GIT binary patch
literal 230180
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
z
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