Update lua plugin to 5.2.3

Prior to this patch the Lua plugin used version 5.1.4. This change
reduces the number of modifications in the Lua source using some new
defines and because the upstream source is now more flexible.

Unless otherwise stated, l*.[ch] files are taken unmodified from the
upstream lua-5.2.3.

fscanf.c:
file descriptors in rockbox are just ints, they are hidden behind a
void* now so liolib requires less modifications. fscanf is updated to
use void* too.

getc.c: this is a new file required for getc implementation in lauxlib.c

lauxlib.c: LoadF replaced FILE* with int, the rockbox file
descriptor int are cast to FILE* (actually void* due to typedef).
getc uses the PREFIX version. stdin is not used, as per 5.1.4.

lbaselib.c: now uses strspn in the number parsing. print uses DEBUGF now
rather than being commented out.

lbitlib.c: use the built-in version from 5.2.3 rather than Reuben
Thomas's external library. Backwards compatible and adds some new bit
operations.

ldo.c: the LUAI_THROW/TRY defines are now in the core lua code, so have
been removed from rockconf.h

liolib.c: here the implementation has changed to use the LStream from
the original source, and cast the FILE* pointers to int. This has
reduced the number of modifications from the upstream version.

llex.c: the only change from upstream is to remove the locale include.

lmathlib.c: updated from the 5.2.3 version and re-applied the changes
that were made vs 5.1.4 for random numbers and to remove unsupported
float functions.

loadlib.c: upstream version, with the 5.1.4 changes for missing
functions.

lobject.c: upstream version, with ctype.h added and sprintf changed to
snprintf.

loslib.c: upstream version with locale.h removed and 5.1.4 changes for
unsupportable functions.

lstrlib.c: sprintf changed to snprintf.

ltable.c: upstream with the hashnum function from 5.1.4 to avoid frexp
in luai_hashnum.

luaconf.h: updated to 5.2.3 version, restored relevant parts from the
original 5.1.4 configuration. The COMPAT defines that are no longer
available are not included.

lundump.c: VERSION macro conflicts with the core Rockbox equivalent.

rocklib.c: luaL_reg is no longer available, replaced by luaL_Reg
equivalent. Moved checkboolean/optboolean functions to this file and out
of core lua files. luaL_getn is no longer available, replaced by
luaL_rawlen. luaL_register is deprecated, use the newlib/setfuncs
replacements. rli_init has to be called before setting up the newlib to
avoid overwriting the rb table.

rocklib_aux.pl: use rli_checkboolean from rocklib.c.

rocklua.c: new default bits library used, update the library loading
code with idiomatic 5.2 code.

strcspn.c: no longer needed, but strspn.c is required for strspn in
lbaselib.c

Change-Id: I0c7945c755f79083afe98ec117e1e8cf13de2651
Reviewed-on: http://gerrit.rockbox.org/774
Tested: Richard Quirk <richard.quirk@gmail.com>
Reviewed-by: Marcin Bukat <marcin.bukat@gmail.com>

1 files changed, 343 insertions, 117 deletions

diff --git a/apps/plugins/lua/lobject.h b/apps/plugins/lua/lobject.h
index 93288fe0fb..3a630b944c 100644
--- a/apps/plugins/lua/lobject.h
+++ b/apps/plugins/lua/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id$
+** $Id: lobject.h,v 2.71.1.1 2013/04/12 18:48:47 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -16,18 +16,52 @@
 #include "lua.h"
 
 
-/* tags for values visible from Lua */
-#define LAST_TAG        LUA_TTHREAD
+/*
+** Extra tags for non-values
+*/
+#define LUA_TPROTO      LUA_NUMTAGS
+#define LUA_TUPVAL      (LUA_NUMTAGS+1)
+#define LUA_TDEADKEY    (LUA_NUMTAGS+2)
 
-#define NUM_TAGS        (LAST_TAG+1)
+/*
+** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
+*/
+#define LUA_TOTALTAGS   (LUA_TUPVAL+2)
 
 
 /*
-** Extra tags for non-values
+** tags for Tagged Values have the following use of bits:
+** bits 0-3: actual tag (a LUA_T* value)
+** bits 4-5: variant bits
+** bit 6: whether value is collectable
 */
-#define LUA_TPROTO      (LAST_TAG+1)
-#define LUA_TUPVAL      (LAST_TAG+2)
-#define LUA_TDEADKEY    (LAST_TAG+3)
+
+#define VARBITS         (3 << 4)
+
+
+/*
+** LUA_TFUNCTION variants:
+** 0 - Lua function
+** 1 - light C function
+** 2 - regular C function (closure)
+*/
+
+/* Variant tags for functions */
+#define LUA_TLCL        (LUA_TFUNCTION | (0 << 4))  /* Lua closure */
+#define LUA_TLCF        (LUA_TFUNCTION | (1 << 4))  /* light C function */
+#define LUA_TCCL        (LUA_TFUNCTION | (2 << 4))  /* C closure */
+
+
+/* Variant tags for strings */
+#define LUA_TSHRSTR     (LUA_TSTRING | (0 << 4))  /* short strings */
+#define LUA_TLNGSTR     (LUA_TSTRING | (1 << 4))  /* long strings */
+
+
+/* Bit mark for collectable types */
+#define BIT_ISCOLLECTABLE       (1 << 6)
+
+/* mark a tag as collectable */
+#define ctb(t)                  ((t) | BIT_ISCOLLECTABLE)
 
 
 /*
@@ -52,120 +86,165 @@ typedef struct GCheader {
 
 
 
-
 /*
 ** Union of all Lua values
 */
-typedef union {
-  GCObject *gc;
-  void *p;
-  lua_Number n;
-  int b;
-} Value;
+typedef union Value Value;
+
+
+#define numfield        lua_Number n;    /* numbers */
+
 
 
 /*
-** Tagged Values
+** Tagged Values. This is the basic representation of values in Lua,
+** an actual value plus a tag with its type.
 */
 
-#define TValuefields    Value value; int tt
+#define TValuefields    Value value_; int tt_
 
-typedef struct lua_TValue {
-  TValuefields;
-} TValue;
+typedef struct lua_TValue TValue;
+
+
+/* macro defining a nil value */
+#define NILCONSTANT     {NULL}, LUA_TNIL
+
+
+#define val_(o)         ((o)->value_)
+#define num_(o)         (val_(o).n)
+
+
+/* raw type tag of a TValue */
+#define rttype(o)       ((o)->tt_)
+
+/* tag with no variants (bits 0-3) */
+#define novariant(x)    ((x) & 0x0F)
+
+/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
+#define ttype(o)        (rttype(o) & 0x3F)
+
+/* type tag of a TValue with no variants (bits 0-3) */
+#define ttypenv(o)      (novariant(rttype(o)))
 
 
 /* Macros to test type */
-#define ttisnil(o)      (ttype(o) == LUA_TNIL)
-#define ttisnumber(o)   (ttype(o) == LUA_TNUMBER)
-#define ttisstring(o)   (ttype(o) == LUA_TSTRING)
-#define ttistable(o)    (ttype(o) == LUA_TTABLE)
-#define ttisfunction(o) (ttype(o) == LUA_TFUNCTION)
-#define ttisboolean(o)  (ttype(o) == LUA_TBOOLEAN)
-#define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA)
-#define ttisthread(o)   (ttype(o) == LUA_TTHREAD)
-#define ttislightuserdata(o)    (ttype(o) == LUA_TLIGHTUSERDATA)
+#define checktag(o,t)           (rttype(o) == (t))
+#define checktype(o,t)          (ttypenv(o) == (t))
+#define ttisnumber(o)           checktag((o), LUA_TNUMBER)
+#define ttisnil(o)              checktag((o), LUA_TNIL)
+#define ttisboolean(o)          checktag((o), LUA_TBOOLEAN)
+#define ttislightuserdata(o)    checktag((o), LUA_TLIGHTUSERDATA)
+#define ttisstring(o)           checktype((o), LUA_TSTRING)
+#define ttisshrstring(o)        checktag((o), ctb(LUA_TSHRSTR))
+#define ttislngstring(o)        checktag((o), ctb(LUA_TLNGSTR))
+#define ttistable(o)            checktag((o), ctb(LUA_TTABLE))
+#define ttisfunction(o)         checktype(o, LUA_TFUNCTION)
+#define ttisclosure(o)          ((rttype(o) & 0x1F) == LUA_TFUNCTION)
+#define ttisCclosure(o)         checktag((o), ctb(LUA_TCCL))
+#define ttisLclosure(o)         checktag((o), ctb(LUA_TLCL))
+#define ttislcf(o)              checktag((o), LUA_TLCF)
+#define ttisuserdata(o)         checktag((o), ctb(LUA_TUSERDATA))
+#define ttisthread(o)           checktag((o), ctb(LUA_TTHREAD))
+#define ttisdeadkey(o)          checktag((o), LUA_TDEADKEY)
+
+#define ttisequal(o1,o2)        (rttype(o1) == rttype(o2))
 
 /* Macros to access values */
-#define ttype(o)        ((o)->tt)
-#define gcvalue(o)      check_exp(iscollectable(o), (o)->value.gc)
-#define pvalue(o)       check_exp(ttislightuserdata(o), (o)->value.p)
-#define nvalue(o)       check_exp(ttisnumber(o), (o)->value.n)
-#define rawtsvalue(o)   check_exp(ttisstring(o), &(o)->value.gc->ts)
+#define nvalue(o)       check_exp(ttisnumber(o), num_(o))
+#define gcvalue(o)      check_exp(iscollectable(o), val_(o).gc)
+#define pvalue(o)       check_exp(ttislightuserdata(o), val_(o).p)
+#define rawtsvalue(o)   check_exp(ttisstring(o), &val_(o).gc->ts)
 #define tsvalue(o)      (&rawtsvalue(o)->tsv)
-#define rawuvalue(o)    check_exp(ttisuserdata(o), &(o)->value.gc->u)
+#define rawuvalue(o)    check_exp(ttisuserdata(o), &val_(o).gc->u)
 #define uvalue(o)       (&rawuvalue(o)->uv)
-#define clvalue(o)      check_exp(ttisfunction(o), &(o)->value.gc->cl)
-#define hvalue(o)       check_exp(ttistable(o), &(o)->value.gc->h)
-#define bvalue(o)       check_exp(ttisboolean(o), (o)->value.b)
-#define thvalue(o)      check_exp(ttisthread(o), &(o)->value.gc->th)
+#define clvalue(o)      check_exp(ttisclosure(o), &val_(o).gc->cl)
+#define clLvalue(o)     check_exp(ttisLclosure(o), &val_(o).gc->cl.l)
+#define clCvalue(o)     check_exp(ttisCclosure(o), &val_(o).gc->cl.c)
+#define fvalue(o)       check_exp(ttislcf(o), val_(o).f)
+#define hvalue(o)       check_exp(ttistable(o), &val_(o).gc->h)
+#define bvalue(o)       check_exp(ttisboolean(o), val_(o).b)
+#define thvalue(o)      check_exp(ttisthread(o), &val_(o).gc->th)
+/* a dead value may get the 'gc' field, but cannot access its contents */
+#define deadvalue(o)    check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
 
 #define l_isfalse(o)    (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
 
-/*
-** for internal debug only
-*/
-#define checkconsistency(obj) \
-  lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
+
+#define iscollectable(o)        (rttype(o) & BIT_ISCOLLECTABLE)
+
+
+/* Macros for internal tests */
+#define righttt(obj)            (ttype(obj) == gcvalue(obj)->gch.tt)
 
 #define checkliveness(g,obj) \
-  lua_assert(!iscollectable(obj) || \
-  ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))
+        lua_longassert(!iscollectable(obj) || \
+                        (righttt(obj) && !isdead(g,gcvalue(obj))))
 
 
 /* Macros to set values */
-#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
+#define settt_(o,t)     ((o)->tt_=(t))
 
 #define setnvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
+  { TValue *io=(obj); num_(io)=(x); settt_(io, LUA_TNUMBER); }
+
+#define setnilvalue(obj) settt_(obj, LUA_TNIL)
+
+#define setfvalue(obj,x) \
+  { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
 
 #define setpvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }
+  { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
 
 #define setbvalue(obj,x) \
-  { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
+  { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
+
+#define setgcovalue(L,obj,x) \
+  { TValue *io=(obj); GCObject *i_g=(x); \
+    val_(io).gc=i_g; settt_(io, ctb(gch(i_g)->tt)); }
 
 #define setsvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \
-    checkliveness(G(L),i_o); }
+  { TValue *io=(obj); \
+    TString *x_ = (x); \
+    val_(io).gc=cast(GCObject *, x_); settt_(io, ctb(x_->tsv.tt)); \
+    checkliveness(G(L),io); }
 
 #define setuvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \
-    checkliveness(G(L),i_o); }
+  { TValue *io=(obj); \
+    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TUSERDATA)); \
+    checkliveness(G(L),io); }
 
 #define setthvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \
-    checkliveness(G(L),i_o); }
+  { TValue *io=(obj); \
+    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTHREAD)); \
+    checkliveness(G(L),io); }
 
-#define setclvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \
-    checkliveness(G(L),i_o); }
+#define setclLvalue(L,obj,x) \
+  { TValue *io=(obj); \
+    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TLCL)); \
+    checkliveness(G(L),io); }
 
-#define sethvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \
-    checkliveness(G(L),i_o); }
+#define setclCvalue(L,obj,x) \
+  { TValue *io=(obj); \
+    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TCCL)); \
+    checkliveness(G(L),io); }
 
-#define setptvalue(L,obj,x) \
-  { TValue *i_o=(obj); \
-    i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \
-    checkliveness(G(L),i_o); }
+#define sethvalue(L,obj,x) \
+  { TValue *io=(obj); \
+    val_(io).gc=cast(GCObject *, (x)); settt_(io, ctb(LUA_TTABLE)); \
+    checkliveness(G(L),io); }
 
+#define setdeadvalue(obj)       settt_(obj, LUA_TDEADKEY)
 
 
 
 #define setobj(L,obj1,obj2) \
-  { const TValue *o2=(obj2); TValue *o1=(obj1); \
-    o1->value = o2->value; o1->tt=o2->tt; \
-    checkliveness(G(L),o1); }
+        { const TValue *io2=(obj2); TValue *io1=(obj1); \
+          io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
+          checkliveness(G(L),io1); }
 
 
 /*
-** different types of sets, according to destination
+** different types of assignments, according to destination
 */
 
 /* from stack to (same) stack */
@@ -183,47 +262,204 @@ typedef struct lua_TValue {
 #define setobj2n        setobj
 #define setsvalue2n     setsvalue
 
-#define setttype(obj, tt) (ttype(obj) = (tt))
+
+/* check whether a number is valid (useful only for NaN trick) */
+#define luai_checknum(L,o,c)    { /* empty */ }
+
+
+/*
+** {======================================================
+** NaN Trick
+** =======================================================
+*/
+#if defined(LUA_NANTRICK)
+
+/*
+** numbers are represented in the 'd_' field. All other values have the
+** value (NNMARK | tag) in 'tt__'. A number with such pattern would be
+** a "signaled NaN", which is never generated by regular operations by
+** the CPU (nor by 'strtod')
+*/
+
+/* allows for external implementation for part of the trick */
+#if !defined(NNMARK)    /* { */
+
+
+#if !defined(LUA_IEEEENDIAN)
+#error option 'LUA_NANTRICK' needs 'LUA_IEEEENDIAN'
+#endif
+
+
+#define NNMARK          0x7FF7A500
+#define NNMASK          0x7FFFFF00
+
+#undef TValuefields
+#undef NILCONSTANT
+
+#if (LUA_IEEEENDIAN == 0)       /* { */
+
+/* little endian */
+#define TValuefields  \
+        union { struct { Value v__; int tt__; } i; double d__; } u
+#define NILCONSTANT     {{{NULL}, tag2tt(LUA_TNIL)}}
+/* field-access macros */
+#define v_(o)           ((o)->u.i.v__)
+#define d_(o)           ((o)->u.d__)
+#define tt_(o)          ((o)->u.i.tt__)
+
+#else                           /* }{ */
+
+/* big endian */
+#define TValuefields  \
+        union { struct { int tt__; Value v__; } i; double d__; } u
+#define NILCONSTANT     {{tag2tt(LUA_TNIL), {NULL}}}
+/* field-access macros */
+#define v_(o)           ((o)->u.i.v__)
+#define d_(o)           ((o)->u.d__)
+#define tt_(o)          ((o)->u.i.tt__)
+
+#endif                          /* } */
+
+#endif                  /* } */
 
 
-#define iscollectable(o)        (ttype(o) >= LUA_TSTRING)
+/* correspondence with standard representation */
+#undef val_
+#define val_(o)         v_(o)
+#undef num_
+#define num_(o)         d_(o)
 
 
+#undef numfield
+#define numfield        /* no such field; numbers are the entire struct */
+
+/* basic check to distinguish numbers from non-numbers */
+#undef ttisnumber
+#define ttisnumber(o)   ((tt_(o) & NNMASK) != NNMARK)
+
+#define tag2tt(t)       (NNMARK | (t))
+
+#undef rttype
+#define rttype(o)       (ttisnumber(o) ? LUA_TNUMBER : tt_(o) & 0xff)
+
+#undef settt_
+#define settt_(o,t)     (tt_(o) = tag2tt(t))
+
+#undef setnvalue
+#define setnvalue(obj,x) \
+        { TValue *io_=(obj); num_(io_)=(x); lua_assert(ttisnumber(io_)); }
+
+#undef setobj
+#define setobj(L,obj1,obj2) \
+        { const TValue *o2_=(obj2); TValue *o1_=(obj1); \
+          o1_->u = o2_->u; \
+          checkliveness(G(L),o1_); }
+
+
+/*
+** these redefinitions are not mandatory, but these forms are more efficient
+*/
+
+#undef checktag
+#undef checktype
+#define checktag(o,t)   (tt_(o) == tag2tt(t))
+#define checktype(o,t)  (ctb(tt_(o) | VARBITS) == ctb(tag2tt(t) | VARBITS))
+
+#undef ttisequal
+#define ttisequal(o1,o2)  \
+        (ttisnumber(o1) ? ttisnumber(o2) : (tt_(o1) == tt_(o2)))
+
+
+#undef luai_checknum
+#define luai_checknum(L,o,c)    { if (!ttisnumber(o)) c; }
+
+#endif
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** types and prototypes
+** =======================================================
+*/
+
+
+union Value {
+  GCObject *gc;    /* collectable objects */
+  void *p;         /* light userdata */
+  int b;           /* booleans */
+  lua_CFunction f; /* light C functions */
+  numfield         /* numbers */
+};
+
+
+struct lua_TValue {
+  TValuefields;
+};
+
 
 typedef TValue *StkId;  /* index to stack elements */
 
 
+
+
 /*
-** String headers for string table
+** Header for string value; string bytes follow the end of this structure
 */
 typedef union TString {
   L_Umaxalign dummy;  /* ensures maximum alignment for strings */
   struct {
     CommonHeader;
-    lu_byte reserved;
+    lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
     unsigned int hash;
-    size_t len;
+    size_t len;  /* number of characters in string */
   } tsv;
 } TString;
 
 
+/* get the actual string (array of bytes) from a TString */
 #define getstr(ts)      cast(const char *, (ts) + 1)
-#define svalue(o)       getstr(rawtsvalue(o))
 
+/* get the actual string (array of bytes) from a Lua value */
+#define svalue(o)       getstr(rawtsvalue(o))
 
 
+/*
+** Header for userdata; memory area follows the end of this structure
+*/
 typedef union Udata {
   L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
   struct {
     CommonHeader;
     struct Table *metatable;
     struct Table *env;
-    size_t len;
+    size_t len;  /* number of bytes */
   } uv;
 } Udata;
 
 
 
+/*
+** 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 */
+  lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
+} 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;
+
 
 /*
 ** Function Prototypes
@@ -233,11 +469,12 @@ typedef struct Proto {
   TValue *k;  /* constants used by the function */
   Instruction *code;
   struct Proto **p;  /* functions defined inside the function */
-  int *lineinfo;  /* map from opcodes to source lines */
-  struct LocVar *locvars;  /* information about local variables */
-  TString **upvalues;  /* upvalue names */
-  TString  *source;
-  int sizeupvalues;
+  int *lineinfo;  /* map from opcodes to source lines (debug information) */
+  LocVar *locvars;  /* information about local variables (debug information) */
+  Upvaldesc *upvalues;  /* upvalue information */
+  union Closure *cache;  /* last created closure with this prototype */
+  TString  *source;  /* used for debug information */
+  int sizeupvalues;  /* size of 'upvalues' */
   int sizek;  /* size of `k' */
   int sizecode;
   int sizelineinfo;
@@ -246,31 +483,16 @@ typedef struct Proto {
   int linedefined;
   int lastlinedefined;
   GCObject *gclist;
-  lu_byte nups;  /* number of upvalues */
-  lu_byte numparams;
+  lu_byte numparams;  /* number of fixed parameters */
   lu_byte is_vararg;
-  lu_byte maxstacksize;
+  lu_byte maxstacksize;  /* maximum stack used by this function */
 } Proto;
 
 
-/* masks for new-style vararg */
-#define VARARG_HASARG           1
-#define VARARG_ISVARARG         2
-#define VARARG_NEEDSARG         4
-
-
-typedef struct LocVar {
-  TString *varname;
-  int startpc;  /* first point where variable is active */
-  int endpc;    /* first point where variable is dead */
-} LocVar;
-
-
 
 /*
-** Upvalues
+** Lua Upvalues
 */
-
 typedef struct UpVal {
   CommonHeader;
   TValue *v;  /* points to stack or to its own value */
@@ -289,20 +511,19 @@ typedef struct UpVal {
 */
 
 #define ClosureHeader \
-        CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
-        struct Table *env
+        CommonHeader; lu_byte nupvalues; GCObject *gclist
 
 typedef struct CClosure {
   ClosureHeader;
   lua_CFunction f;
-  TValue upvalue[1];
+  TValue upvalue[1];  /* list of upvalues */
 } CClosure;
 
 
 typedef struct LClosure {
   ClosureHeader;
   struct Proto *p;
-  UpVal *upvals[1];
+  UpVal *upvals[1];  /* list of upvalues */
 } LClosure;
 
 
@@ -312,8 +533,9 @@ typedef union Closure {
 } Closure;
 
 
-#define iscfunction(o)  (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
-#define isLfunction(o)  (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
+#define isLfunction(o)  ttisLclosure(o)
+
+#define getproto(o)     (clLvalue(o)->p)
 
 
 /*
@@ -337,7 +559,7 @@ typedef struct Node {
 
 typedef struct Table {
   CommonHeader;
-  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */ 
+  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
   lu_byte lsizenode;  /* log2 of size of `node' array */
   struct Table *metatable;
   TValue *array;  /* array part */
@@ -360,17 +582,21 @@ typedef struct Table {
 #define sizenode(t)     (twoto((t)->lsizenode))
 
 
+/*
+** (address of) a fixed nil value
+*/
 #define luaO_nilobject          (&luaO_nilobject_)
 
-LUAI_DATA const TValue luaO_nilobject_;
 
-#define ceillog2(x)     (luaO_log2((x)-1) + 1)
+LUAI_DDEC const TValue luaO_nilobject_;
+
 
-LUAI_FUNC int luaO_log2 (unsigned int x);
 LUAI_FUNC int luaO_int2fb (unsigned int x);
 LUAI_FUNC int luaO_fb2int (int x);
-LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
-LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
+LUAI_FUNC int luaO_ceillog2 (unsigned int x);
+LUAI_FUNC lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2);
+LUAI_FUNC int luaO_str2d (const char *s, size_t len, lua_Number *result);
+LUAI_FUNC int luaO_hexavalue (int c);
 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, ...);