tas: lua: sync up to official source code with fixes
authorFerry Huberts <ferry.huberts@pelagic.nl>
Fri, 26 Oct 2012 11:27:29 +0000 (13:27 +0200)
committerFerry Huberts <ferry.huberts@pelagic.nl>
Fri, 26 Oct 2012 11:27:29 +0000 (13:27 +0200)
Signed-off-by: Ferry Huberts <ferry.huberts@pelagic.nl>
50 files changed:
lib/tas/src/lua/lapi.c
lib/tas/src/lua/lapi.h
lib/tas/src/lua/lauxlib.c
lib/tas/src/lua/lauxlib.h
lib/tas/src/lua/lbaselib.c
lib/tas/src/lua/lcode.c
lib/tas/src/lua/lcode.h
lib/tas/src/lua/ldblib.c
lib/tas/src/lua/ldebug.c
lib/tas/src/lua/ldebug.h
lib/tas/src/lua/ldo.c
lib/tas/src/lua/ldo.h
lib/tas/src/lua/ldump.c
lib/tas/src/lua/lfunc.c
lib/tas/src/lua/lfunc.h
lib/tas/src/lua/lgc.c
lib/tas/src/lua/lgc.h
lib/tas/src/lua/liolib.c
lib/tas/src/lua/llex.c
lib/tas/src/lua/llex.h
lib/tas/src/lua/llimits.h
lib/tas/src/lua/lmathlib.c
lib/tas/src/lua/lmem.c
lib/tas/src/lua/lmem.h
lib/tas/src/lua/loadlib.c
lib/tas/src/lua/lobject.c
lib/tas/src/lua/lobject.h
lib/tas/src/lua/lopcodes.c
lib/tas/src/lua/lopcodes.h
lib/tas/src/lua/lparser.c
lib/tas/src/lua/lparser.h
lib/tas/src/lua/lstate.c
lib/tas/src/lua/lstate.h
lib/tas/src/lua/lstring.c
lib/tas/src/lua/lstring.h
lib/tas/src/lua/lstrlib.c
lib/tas/src/lua/ltable.c
lib/tas/src/lua/ltable.h
lib/tas/src/lua/ltablib.c
lib/tas/src/lua/ltests.c
lib/tas/src/lua/ltm.c
lib/tas/src/lua/ltm.h
lib/tas/src/lua/lua.h
lib/tas/src/lua/lualib.h
lib/tas/src/lua/lundump.c
lib/tas/src/lua/lundump.h
lib/tas/src/lua/lvm.c
lib/tas/src/lua/lvm.h
lib/tas/src/lua/lzio.c
lib/tas/src/lua/lzio.h

index 8c19205..1dc2bdd 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lapi.c,v 1.235 2003/04/07 14:36:08 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
 
+
 #include <assert.h>
 #include <string.h>
 
 #include "lundump.h"
 #include "lvm.h"
 
+
 const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n" "$Authors: " LUA_AUTHORS " $\n" "$URL: www.lua.org $\n";
 
+
+
 #ifndef api_check
 #define api_check(L, o)         /*{ assert(o); } */
 #endif
@@ -35,6 +40,9 @@ const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n" "$Authors
 
 #define api_incr_top(L)   {api_check(L, L->top < L->ci->top); L->top++;}
 
+
+
+
 static TObject *
 negindex(lua_State * L, int idx)
 {
@@ -47,16 +55,18 @@ negindex(lua_State * L, int idx)
       return registry(L);
     case LUA_GLOBALSINDEX:
       return gt(L);
-    default:
-      {
+    default:{
         TObject *func = (L->base - 1);
         idx = LUA_GLOBALSINDEX - idx;
         lua_assert(iscfunction(func));
-        return (idx <= clvalue(func)->c.nupvalues) ? &clvalue(func)->c.upvalue[idx - 1] : NULL;
+        return (idx <= clvalue(func)->c.nupvalues)
+          ? &clvalue(func)->c.upvalue[idx - 1]
+          : NULL;
       }
     }
 }
 
+
 static TObject *
 luaA_index(lua_State * L, int idx)
 {
@@ -70,6 +80,7 @@ luaA_index(lua_State * L, int idx)
   }
 }
 
+
 static TObject *
 luaA_indexAcceptable(lua_State * L, int idx)
 {
@@ -84,6 +95,7 @@ luaA_indexAcceptable(lua_State * L, int idx)
     return negindex(L, idx);
 }
 
+
 void
 luaA_pushobject(lua_State * L, const TObject * o)
 {
@@ -91,6 +103,7 @@ luaA_pushobject(lua_State * L, const TObject * o)
   incr_top(L);
 }
 
+
 LUA_API int
 lua_checkstack(lua_State * L, int size)
 {
@@ -108,6 +121,7 @@ lua_checkstack(lua_State * L, int size)
   return res;
 }
 
+
 LUA_API void
 lua_xmove(lua_State * from, lua_State * to, int n)
 {
@@ -122,6 +136,7 @@ lua_xmove(lua_State * from, lua_State * to, int n)
   lua_unlock(to);
 }
 
+
 LUA_API lua_CFunction
 lua_atpanic(lua_State * L, lua_CFunction panicf)
 {
@@ -133,6 +148,7 @@ lua_atpanic(lua_State * L, lua_CFunction panicf)
   return old;
 }
 
+
 LUA_API lua_State *
 lua_newthread(lua_State * L)
 {
@@ -147,16 +163,20 @@ lua_newthread(lua_State * L)
   return L1;
 }
 
+
+
 /*
 ** basic stack manipulation
 */
 
+
 LUA_API int
 lua_gettop(lua_State * L)
 {
   return (L->top - L->base);
 }
 
+
 LUA_API void
 lua_settop(lua_State * L, int idx)
 {
@@ -173,6 +193,7 @@ lua_settop(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_remove(lua_State * L, int idx)
 {
@@ -185,6 +206,7 @@ lua_remove(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_insert(lua_State * L, int idx)
 {
@@ -198,6 +220,7 @@ lua_insert(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_replace(lua_State * L, int idx)
 {
@@ -208,6 +231,7 @@ lua_replace(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_pushvalue(lua_State * L, int idx)
 {
@@ -217,10 +241,13 @@ lua_pushvalue(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
+
 /*
 ** access functions (stack -> C)
 */
 
+
 LUA_API int
 lua_type(lua_State * L, int idx)
 {
@@ -228,6 +255,7 @@ lua_type(lua_State * L, int idx)
   return (o == NULL) ? LUA_TNONE : ttype(o);
 }
 
+
 LUA_API const char *
 lua_typename(lua_State * L, int t)
 {
@@ -235,6 +263,7 @@ lua_typename(lua_State * L, int t)
   return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
 }
 
+
 LUA_API int
 lua_iscfunction(lua_State * L, int idx)
 {
@@ -242,6 +271,7 @@ lua_iscfunction(lua_State * L, int idx)
   return (o == NULL) ? 0 : iscfunction(o);
 }
 
+
 LUA_API int
 lua_isnumber(lua_State * L, int idx)
 {
@@ -250,6 +280,7 @@ lua_isnumber(lua_State * L, int idx)
   return (o != NULL && tonumber(o, &n));
 }
 
+
 LUA_API int
 lua_isstring(lua_State * L, int idx)
 {
@@ -257,6 +288,7 @@ lua_isstring(lua_State * L, int idx)
   return (t == LUA_TSTRING || t == LUA_TNUMBER);
 }
 
+
 LUA_API int
 lua_isuserdata(lua_State * L, int idx)
 {
@@ -264,6 +296,7 @@ lua_isuserdata(lua_State * L, int idx)
   return (o != NULL && (ttisuserdata(o) || ttislightuserdata(o)));
 }
 
+
 LUA_API int
 lua_rawequal(lua_State * L, int index1, int index2)
 {
@@ -273,6 +306,7 @@ lua_rawequal(lua_State * L, int index1, int index2)
     : luaO_rawequalObj(o1, o2);
 }
 
+
 LUA_API int
 lua_equal(lua_State * L, int index1, int index2)
 {
@@ -287,6 +321,7 @@ lua_equal(lua_State * L, int index1, int index2)
   return i;
 }
 
+
 LUA_API int
 lua_lessthan(lua_State * L, int index1, int index2)
 {
@@ -301,6 +336,8 @@ lua_lessthan(lua_State * L, int index1, int index2)
   return i;
 }
 
+
+
 LUA_API lua_Number
 lua_tonumber(lua_State * L, int idx)
 {
@@ -312,6 +349,7 @@ lua_tonumber(lua_State * L, int idx)
     return 0;
 }
 
+
 LUA_API int
 lua_toboolean(lua_State * L, int idx)
 {
@@ -319,6 +357,7 @@ lua_toboolean(lua_State * L, int idx)
   return (o != NULL) && !l_isfalse(o);
 }
 
+
 LUA_API const char *
 lua_tostring(lua_State * L, int idx)
 {
@@ -337,6 +376,7 @@ lua_tostring(lua_State * L, int idx)
   }
 }
 
+
 LUA_API size_t
 lua_strlen(lua_State * L, int idx)
 {
@@ -354,6 +394,7 @@ lua_strlen(lua_State * L, int idx)
   }
 }
 
+
 LUA_API lua_CFunction
 lua_tocfunction(lua_State * L, int idx)
 {
@@ -361,6 +402,7 @@ lua_tocfunction(lua_State * L, int idx)
   return (o == NULL || !iscfunction(o)) ? NULL : clvalue(o)->c.f;
 }
 
+
 LUA_API void *
 lua_touserdata(lua_State * L, int idx)
 {
@@ -377,6 +419,7 @@ lua_touserdata(lua_State * L, int idx)
   }
 }
 
+
 LUA_API lua_State *
 lua_tothread(lua_State * L, int idx)
 {
@@ -384,6 +427,7 @@ lua_tothread(lua_State * L, int idx)
   return (o == NULL || !ttisthread(o)) ? NULL : thvalue(o);
 }
 
+
 LUA_API const void *
 lua_topointer(lua_State * L, int idx)
 {
@@ -407,10 +451,13 @@ lua_topointer(lua_State * L, int idx)
   }
 }
 
+
+
 /*
 ** push functions (C -> stack)
 */
 
+
 LUA_API void
 lua_pushnil(lua_State * L)
 {
@@ -420,6 +467,7 @@ lua_pushnil(lua_State * L)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_pushnumber(lua_State * L, lua_Number n)
 {
@@ -429,6 +477,7 @@ lua_pushnumber(lua_State * L, lua_Number n)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_pushlstring(lua_State * L, const char *s, size_t len)
 {
@@ -439,6 +488,7 @@ lua_pushlstring(lua_State * L, const char *s, size_t len)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_pushstring(lua_State * L, const char *s)
 {
@@ -448,6 +498,7 @@ lua_pushstring(lua_State * L, const char *s)
     lua_pushlstring(L, s, strlen(s));
 }
 
+
 LUA_API const char *
 lua_pushvfstring(lua_State * L, const char *fmt, va_list argp)
 {
@@ -459,6 +510,7 @@ lua_pushvfstring(lua_State * L, const char *fmt, va_list argp)
   return ret;
 }
 
+
 LUA_API const char *
 lua_pushfstring(lua_State * L, const char *fmt, ...)
 {
@@ -473,6 +525,7 @@ lua_pushfstring(lua_State * L, const char *fmt, ...)
   return ret;
 }
 
+
 LUA_API void
 lua_pushcclosure(lua_State * L, lua_CFunction fn, int n)
 {
@@ -490,6 +543,7 @@ lua_pushcclosure(lua_State * L, lua_CFunction fn, int n)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_pushboolean(lua_State * L, int b)
 {
@@ -499,6 +553,7 @@ lua_pushboolean(lua_State * L, int b)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_pushlightuserdata(lua_State * L, const void *p)
 {
@@ -508,10 +563,13 @@ lua_pushlightuserdata(lua_State * L, const void *p)
   lua_unlock(L);
 }
 
+
+
 /*
 ** get functions (Lua -> stack)
 */
 
+
 LUA_API void
 lua_gettable(lua_State * L, int idx)
 {
@@ -522,6 +580,7 @@ lua_gettable(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_rawget(lua_State * L, int idx)
 {
@@ -533,6 +592,7 @@ lua_rawget(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_rawgeti(lua_State * L, int idx, int n)
 {
@@ -545,6 +605,7 @@ lua_rawgeti(lua_State * L, int idx, int n)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_newtable(lua_State * L)
 {
@@ -555,6 +616,7 @@ lua_newtable(lua_State * L)
   lua_unlock(L);
 }
 
+
 LUA_API int
 lua_getmetatable(lua_State * L, int objindex)
 {
@@ -584,6 +646,7 @@ lua_getmetatable(lua_State * L, int objindex)
   return res;
 }
 
+
 LUA_API void
 lua_getfenv(lua_State * L, int idx)
 {
@@ -595,10 +658,12 @@ lua_getfenv(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 /*
 ** set functions (stack -> Lua)
 */
 
+
 LUA_API void
 lua_settable(lua_State * L, int idx)
 {
@@ -611,6 +676,7 @@ lua_settable(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_rawset(lua_State * L, int idx)
 {
@@ -624,6 +690,7 @@ lua_rawset(lua_State * L, int idx)
   lua_unlock(L);
 }
 
+
 LUA_API void
 lua_rawseti(lua_State * L, int idx, int n)
 {
@@ -637,6 +704,7 @@ lua_rawseti(lua_State * L, int idx, int n)
   lua_unlock(L);
 }
 
+
 LUA_API int
 lua_setmetatable(lua_State * L, int objindex)
 {
@@ -648,18 +716,15 @@ lua_setmetatable(lua_State * L, int objindex)
   mt = (!ttisnil(L->top - 1)) ? L->top - 1 : defaultmeta(L);
   api_check(L, ttistable(mt));
   switch (ttype(obj)) {
-  case LUA_TTABLE:
-    {
+  case LUA_TTABLE:{
       hvalue(obj)->metatable = hvalue(mt);      /* write barrier */
       break;
     }
-  case LUA_TUSERDATA:
-    {
+  case LUA_TUSERDATA:{
       uvalue(obj)->uv.metatable = hvalue(mt);   /* write barrier */
       break;
     }
-  default:
-    {
+  default:{
       res = 0;                  /* cannot set */
       break;
     }
@@ -669,6 +734,7 @@ lua_setmetatable(lua_State * L, int objindex)
   return res;
 }
 
+
 LUA_API int
 lua_setfenv(lua_State * L, int idx)
 {
@@ -687,6 +753,7 @@ lua_setfenv(lua_State * L, int idx)
   return res;
 }
 
+
 /*
 ** `load' and `call' functions (run Lua code)
 */
@@ -702,6 +769,8 @@ lua_call(lua_State * L, int nargs, int nresults)
   lua_unlock(L);
 }
 
+
+
 /*
 ** Execute a protected call.
 */
@@ -710,6 +779,7 @@ struct CallS {                         /* data to `f_call' */
   int nresults;
 };
 
+
 static void
 f_call(lua_State * L, void *ud)
 {
@@ -717,6 +787,8 @@ f_call(lua_State * L, void *ud)
   luaD_call(L, c->func, c->nresults);
 }
 
+
+
 LUA_API int
 lua_pcall(lua_State * L, int nargs, int nresults, int errfunc)
 {
@@ -732,6 +804,7 @@ lua_pcall(lua_State * L, int nargs, int nresults, int errfunc)
   return status;
 }
 
+
 /*
 ** Execute a protected C call.
 */
@@ -740,6 +813,7 @@ struct CCallS {                        /* data to `f_Ccall' */
   void *ud;
 };
 
+
 static void
 f_Ccall(lua_State * L, void *ud)
 {
@@ -754,6 +828,7 @@ f_Ccall(lua_State * L, void *ud)
   luaD_call(L, L->top - 2, 0);
 }
 
+
 LUA_API int
 lua_cpcall(lua_State * L, lua_CFunction func, void *ud)
 {
@@ -767,6 +842,7 @@ lua_cpcall(lua_State * L, lua_CFunction func, void *ud)
   return status;
 }
 
+
 LUA_API int
 lua_load(lua_State * L, lua_Chunkreader reader, void *data, const char *chunkname)
 {
@@ -783,6 +859,7 @@ lua_load(lua_State * L, lua_Chunkreader reader, void *data, const char *chunknam
   return status;
 }
 
+
 LUA_API int
 lua_dump(lua_State * L, lua_Chunkwriter writer, void *data)
 {
@@ -800,6 +877,7 @@ lua_dump(lua_State * L, lua_Chunkwriter writer, void *data)
   return status;
 }
 
+
 /*
 ** Garbage-collection functions
 */
@@ -841,16 +919,19 @@ lua_setgcthreshold(lua_State * L, int newthreshold)
   lua_unlock(L);
 }
 
+
 /*
 ** miscellaneous functions
 */
 
+
 LUA_API const char *
 lua_version(void)
 {
   return LUA_VERSION;
 }
 
+
 LUA_API int
 lua_error(lua_State * L)
 {
@@ -860,6 +941,7 @@ lua_error(lua_State * L)
   lua_unlock(L);
 }
 
+
 LUA_API int
 lua_next(lua_State * L, int idx)
 {
@@ -877,6 +959,7 @@ lua_next(lua_State * L, int idx)
   return more;
 }
 
+
 LUA_API void
 lua_concat(lua_State * L, int n)
 {
@@ -894,6 +977,7 @@ lua_concat(lua_State * L, int n)
   lua_unlock(L);
 }
 
+
 LUA_API void *
 lua_newuserdata(lua_State * L, size_t size)
 {
@@ -907,6 +991,7 @@ lua_newuserdata(lua_State * L, size_t size)
   return u + 1;
 }
 
+
 LUA_API int
 lua_pushupvalues(lua_State * L)
 {
@@ -925,6 +1010,7 @@ lua_pushupvalues(lua_State * L)
   return n;
 }
 
+
 static const char *
 aux_upvalue(lua_State * L, int funcindex, int n, TObject ** val)
 {
@@ -947,6 +1033,7 @@ aux_upvalue(lua_State * L, int funcindex, int n, TObject ** val)
   }
 }
 
+
 LUA_API const char *
 lua_getupvalue(lua_State * L, int funcindex, int n)
 {
@@ -962,6 +1049,7 @@ lua_getupvalue(lua_State * L, int funcindex, int n)
   return name;
 }
 
+
 LUA_API const char *
 lua_setupvalue(lua_State * L, int funcindex, int n)
 {
@@ -977,10 +1065,3 @@ lua_setupvalue(lua_State * L, int funcindex, int n)
   lua_unlock(L);
   return name;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 8e48c9f..2098b74 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lapi.h,v 1.21 2002/03/04 21:29:41 roberto Exp $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
@@ -7,15 +8,10 @@
 #ifndef lapi_h
 #define lapi_h
 
+
 #include "lobject.h"
 
+
 void luaA_pushobject(lua_State * L, const TObject * o);
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index a808e1a..cf45ff1 100644 (file)
@@ -1,15 +1,18 @@
 
 /*
+** $Id: lauxlib.c,v 1.100 2003/04/07 14:35:00 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 
+
 #include <ctype.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
+
 /* This file uses only the official API of Lua.
 ** Any function declared here could be written as an application function.
 */
@@ -20,6 +23,7 @@
 
 #include "lauxlib.h"
 
+
 /* number of prereserved references (for internal use) */
 #define RESERVED_REFS  2
 
 #define FREELIST_REF   1       /* free list of references */
 #define ARRAYSIZE_REF  2       /* array sizes */
 
+
 /* convert a stack index to positive */
 #define abs_index(L, i)                ((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
                                        lua_gettop(L) + (i) + 1)
 
+
 /*
 ** {======================================================
 ** Error-report functions
 ** =======================================================
 */
 
+
 LUALIB_API int
 luaL_argerror(lua_State * L, int narg, const char *extramsg)
 {
@@ -53,16 +60,16 @@ luaL_argerror(lua_State * L, int narg, const char *extramsg)
   luaL_error(L, "bad argument #%d to `%s' (%s)", narg, ar.name, extramsg);
 }
 
+
 LUALIB_API int
 luaL_typerror(lua_State * L, int narg, const char *tname)
 {
   const char *msg = lua_pushfstring(L, "%s expected, got %s",
-                                    tname, lua_typename(L,
-                                                        lua_type(L,
-                                                                 narg)));
+                                    tname, lua_typename(L, lua_type(L, narg)));
   luaL_argerror(L, narg, msg);
 }
 
+
 static void tag_error(lua_State * L, int narg, int tag) __attribute__ ((noreturn));
 static void
 tag_error(lua_State * L, int narg, int tag)
@@ -70,6 +77,7 @@ tag_error(lua_State * L, int narg, int tag)
   luaL_typerror(L, narg, lua_typename(L, tag));
 }
 
+
 LUALIB_API void
 luaL_where(lua_State * L, int level)
 {
@@ -84,6 +92,7 @@ luaL_where(lua_State * L, int level)
   lua_pushliteral(L, "");       /* else, no information available... */
 }
 
+
 LUALIB_API int
 luaL_error(lua_State * L, const char *fmt, ...)
 {
@@ -98,6 +107,7 @@ luaL_error(lua_State * L, const char *fmt, ...)
 
 /* }====================================================== */
 
+
 LUALIB_API int
 luaL_findstring(const char *name, const char *const list[])
 {
@@ -108,6 +118,7 @@ luaL_findstring(const char *name, const char *const list[])
   return -1;                    /* name not found */
 }
 
+
 LUALIB_API int
 luaL_newmetatable(lua_State * L, const char *tname)
 {
@@ -126,6 +137,7 @@ luaL_newmetatable(lua_State * L, const char *tname)
   return 1;
 }
 
+
 LUALIB_API void
 luaL_getmetatable(lua_State * L, const char *tname)
 {
@@ -133,6 +145,7 @@ luaL_getmetatable(lua_State * L, const char *tname)
   lua_rawget(L, LUA_REGISTRYINDEX);
 }
 
+
 LUALIB_API void *
 luaL_checkudata(lua_State * L, int ud, const char *tname)
 {
@@ -150,6 +163,7 @@ luaL_checkudata(lua_State * L, int ud, const char *tname)
   }
 }
 
+
 LUALIB_API void
 luaL_checkstack(lua_State * L, int space, const char *mes)
 {
@@ -157,6 +171,7 @@ luaL_checkstack(lua_State * L, int space, const char *mes)
     luaL_error(L, "stack overflow (%s)", mes);
 }
 
+
 LUALIB_API void
 luaL_checktype(lua_State * L, int narg, int t)
 {
@@ -164,6 +179,7 @@ luaL_checktype(lua_State * L, int narg, int t)
     tag_error(L, narg, t);
 }
 
+
 LUALIB_API void
 luaL_checkany(lua_State * L, int narg)
 {
@@ -171,6 +187,7 @@ luaL_checkany(lua_State * L, int narg)
     luaL_argerror(L, narg, "value expected");
 }
 
+
 LUALIB_API const char *
 luaL_checklstring(lua_State * L, int narg, size_t * len)
 {
@@ -182,6 +199,7 @@ luaL_checklstring(lua_State * L, int narg, size_t * len)
   return s;
 }
 
+
 LUALIB_API const char *
 luaL_optlstring(lua_State * L, int narg, const char *def, size_t * len)
 {
@@ -193,6 +211,7 @@ luaL_optlstring(lua_State * L, int narg, const char *def, size_t * len)
     return luaL_checklstring(L, narg, len);
 }
 
+
 LUALIB_API lua_Number
 luaL_checknumber(lua_State * L, int narg)
 {
@@ -202,6 +221,7 @@ luaL_checknumber(lua_State * L, int narg)
   return d;
 }
 
+
 LUALIB_API lua_Number
 luaL_optnumber(lua_State * L, int narg, lua_Number def)
 {
@@ -211,6 +231,7 @@ luaL_optnumber(lua_State * L, int narg, lua_Number def)
     return luaL_checknumber(L, narg);
 }
 
+
 LUALIB_API int
 luaL_getmetafield(lua_State * L, int obj, const char *event)
 {
@@ -227,6 +248,7 @@ luaL_getmetafield(lua_State * L, int obj, const char *event)
   }
 }
 
+
 LUALIB_API int
 luaL_callmeta(lua_State * L, int obj, const char *event)
 {
@@ -238,6 +260,7 @@ luaL_callmeta(lua_State * L, int obj, const char *event)
   return 1;
 }
 
+
 LUALIB_API void
 luaL_openlib(lua_State * L, const char *libname, const luaL_reg * l, int nup)
 {
@@ -264,6 +287,8 @@ luaL_openlib(lua_State * L, const char *libname, const luaL_reg * l, int nup)
   lua_pop(L, nup);              /* remove upvalues */
 }
 
+
+
 /*
 ** {======================================================
 ** getn-setn: size for arrays
@@ -280,6 +305,7 @@ checkint(lua_State * L, int topop)
   return n;
 }
 
+
 static void
 getsizes(lua_State * L)
 {
@@ -297,6 +323,7 @@ getsizes(lua_State * L)
   }
 }
 
+
 void
 luaL_setn(lua_State * L, int t, int n)
 {
@@ -316,6 +343,7 @@ luaL_setn(lua_State * L, int t, int n)
   }
 }
 
+
 int
 luaL_getn(lua_State * L, int t)
 {
@@ -342,17 +370,21 @@ luaL_getn(lua_State * L, int t)
 
 /* }====================================================== */
 
+
+
 /*
 ** {======================================================
 ** Generic Buffer manipulation
 ** =======================================================
 */
 
+
 #define bufflen(B)     ((B)->p - (B)->buffer)
 #define bufffree(B)    ((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
 
 #define LIMIT  (LUA_MINSTACK/2)
 
+
 static int
 emptybuffer(luaL_Buffer * B)
 {
@@ -367,6 +399,7 @@ emptybuffer(luaL_Buffer * B)
   }
 }
 
+
 static void
 adjuststack(luaL_Buffer * B)
 {
@@ -381,13 +414,13 @@ adjuststack(luaL_Buffer * B)
         toget++;
       } else
         break;
-    }
-    while (toget < B->lvl);
+    } while (toget < B->lvl);
     lua_concat(L, toget);
     B->lvl = B->lvl - toget + 1;
   }
 }
 
+
 LUALIB_API char *
 luaL_prepbuffer(luaL_Buffer * B)
 {
@@ -396,6 +429,7 @@ luaL_prepbuffer(luaL_Buffer * B)
   return B->buffer;
 }
 
+
 LUALIB_API void
 luaL_addlstring(luaL_Buffer * B, const char *s, size_t l)
 {
@@ -403,12 +437,14 @@ luaL_addlstring(luaL_Buffer * B, const char *s, size_t l)
     luaL_putchar(B, *s++);
 }
 
+
 LUALIB_API void
 luaL_addstring(luaL_Buffer * B, const char *s)
 {
   luaL_addlstring(B, s, strlen(s));
 }
 
+
 LUALIB_API void
 luaL_pushresult(luaL_Buffer * B)
 {
@@ -417,6 +453,7 @@ luaL_pushresult(luaL_Buffer * B)
   B->lvl = 1;
 }
 
+
 LUALIB_API void
 luaL_addvalue(luaL_Buffer * B)
 {
@@ -434,6 +471,7 @@ luaL_addvalue(luaL_Buffer * B)
   }
 }
 
+
 LUALIB_API void
 luaL_buffinit(lua_State * L, luaL_Buffer * B)
 {
@@ -444,6 +482,7 @@ luaL_buffinit(lua_State * L, luaL_Buffer * B)
 
 /* }====================================================== */
 
+
 LUALIB_API int
 luaL_ref(lua_State * L, int t)
 {
@@ -470,6 +509,7 @@ luaL_ref(lua_State * L, int t)
   return ref;
 }
 
+
 LUALIB_API void
 luaL_unref(lua_State * L, int t, int ref)
 {
@@ -482,6 +522,8 @@ luaL_unref(lua_State * L, int t, int ref)
   }
 }
 
+
+
 /*
 ** {======================================================
 ** Load functions
@@ -493,6 +535,7 @@ typedef struct LoadF {
   char buff[LUAL_BUFFERSIZE];
 } LoadF;
 
+
 static const char *
 getF(lua_State * L, void *ud, size_t * size)
 {
@@ -504,6 +547,7 @@ getF(lua_State * L, void *ud, size_t * size)
   return (*size > 0) ? lf->buff : NULL;
 }
 
+
 static int
 errfile(lua_State * L, int fnameindex)
 {
@@ -513,6 +557,7 @@ errfile(lua_State * L, int fnameindex)
   return LUA_ERRFILE;
 }
 
+
 LUALIB_API int
 luaL_loadfile(lua_State * L, const char *filename)
 {
@@ -548,11 +593,13 @@ luaL_loadfile(lua_State * L, const char *filename)
   return status;
 }
 
+
 typedef struct LoadS {
   const char *s;
   size_t size;
 } LoadS;
 
+
 static const char *
 getS(lua_State * L, void *ud, size_t * size)
 {
@@ -565,6 +612,7 @@ getS(lua_State * L, void *ud, size_t * size)
   return ls->s;
 }
 
+
 LUALIB_API int
 luaL_loadbuffer(lua_State * L, const char *buff, size_t size, const char *name)
 {
@@ -576,12 +624,14 @@ luaL_loadbuffer(lua_State * L, const char *buff, size_t size, const char *name)
 
 /* }====================================================== */
 
+
 /*
 ** {======================================================
 ** compatibility code
 ** =======================================================
 */
 
+
 static void
 callalert(lua_State * L, int status)
 {
@@ -597,6 +647,7 @@ callalert(lua_State * L, int status)
   }
 }
 
+
 static int
 aux_do(lua_State * L, int status)
 {
@@ -607,18 +658,21 @@ aux_do(lua_State * L, int status)
   return status;
 }
 
+
 LUALIB_API int
 lua_dofile(lua_State * L, const char *filename)
 {
   return aux_do(L, luaL_loadfile(L, filename));
 }
 
+
 LUALIB_API int
 lua_dobuffer(lua_State * L, const char *buff, size_t size, const char *name)
 {
   return aux_do(L, luaL_loadbuffer(L, buff, size, name));
 }
 
+
 LUALIB_API int
 lua_dostring(lua_State * L, const char *str)
 {
@@ -626,10 +680,3 @@ lua_dostring(lua_State * L, const char *str)
 }
 
 /* }====================================================== */
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index c1256cb..ff47cb0 100644 (file)
@@ -1,26 +1,33 @@
 
 /*
+** $Id: lauxlib.h,v 1.60 2003/04/03 13:35:34 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
 
+
 #ifndef lauxlib_h
 #define lauxlib_h
 
+
 #include <stddef.h>
 #include <stdio.h>
 
 #include "lua.h"
 
+
 #ifndef LUALIB_API
 #define LUALIB_API     LUA_API
 #endif
 
+
+
 typedef struct luaL_reg {
   const char *name;
   lua_CFunction func;
 } luaL_reg;
 
+
 LUALIB_API void luaL_openlib(lua_State * L, const char *libname, const luaL_reg * l, int nup);
 LUALIB_API int luaL_getmetafield(lua_State * L, int obj, const char *e);
 LUALIB_API int luaL_callmeta(lua_State * L, int obj, const char *e);
@@ -53,6 +60,8 @@ LUALIB_API void luaL_setn(lua_State * L, int t, int n);
 LUALIB_API int luaL_loadfile(lua_State * L, const char *filename);
 LUALIB_API int luaL_loadbuffer(lua_State * L, const char *buff, size_t sz, const char *name);
 
+
+
 /*
 ** ===============================================================
 ** some useful macros
@@ -68,16 +77,19 @@ LUALIB_API int luaL_loadbuffer(lua_State * L, const char *buff, size_t sz, const
 #define luaL_optint(L,n,d)     luaL_optnumber(L, n,(lua_Number)(d))
 #define luaL_optlong(L,n,d)    luaL_optnumber(L, n,(lua_Number)(d))
 
+
 /*
 ** {======================================================
 ** Generic Buffer manipulation
 ** =======================================================
 */
 
+
 #ifndef LUAL_BUFFERSIZE
 #define LUAL_BUFFERSIZE          BUFSIZ
 #endif
 
+
 typedef struct luaL_Buffer {
   char *p;                             /* current position in buffer */
   int lvl;                             /* number of strings in the stack (level) */
@@ -98,8 +110,11 @@ LUALIB_API void luaL_addstring(luaL_Buffer * B, const char *s);
 LUALIB_API void luaL_addvalue(luaL_Buffer * B);
 LUALIB_API void luaL_pushresult(luaL_Buffer * B);
 
+
 /* }====================================================== */
 
+
+
 /*
 ** Compatibility macros and functions
 */
@@ -108,6 +123,7 @@ LUALIB_API int lua_dofile(lua_State * L, const char *filename);
 LUALIB_API int lua_dostring(lua_State * L, const char *str);
 LUALIB_API int lua_dobuffer(lua_State * L, const char *buff, size_t sz, const char *n);
 
+
 #define luaL_check_lstr        luaL_checklstring
 #define luaL_opt_lstr  luaL_optlstring
 #define luaL_check_number      luaL_checknumber
@@ -120,11 +136,5 @@ LUALIB_API int lua_dobuffer(lua_State * L, const char *buff, size_t sz, const ch
 #define luaL_opt_int   luaL_optint
 #define luaL_opt_long  luaL_optlong
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 69324f8..9882071 100644 (file)
@@ -1,9 +1,12 @@
 
 /*
+** $Id: lbaselib.c,v 1.130b 2003/04/03 13:35:34 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
 
+
+
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -16,6 +19,9 @@
 #include "lauxlib.h"
 #include "lualib.h"
 
+
+
+
 /*
 ** If your system does not support `stdout', you can just remove this function.
 ** If you need, you can define your own `print' function, following this
@@ -45,6 +51,7 @@ luaB_print(lua_State * L)
   return 0;
 }
 
+
 static int
 luaB_tonumber(lua_State * L)
 {
@@ -74,6 +81,7 @@ luaB_tonumber(lua_State * L)
   return 1;
 }
 
+
 static int luaB_error(lua_State * L) __attribute__ ((noreturn));
 static int
 luaB_error(lua_State * L)
@@ -90,6 +98,7 @@ luaB_error(lua_State * L)
   lua_error(L);
 }
 
+
 static int
 luaB_getmetatable(lua_State * L)
 {
@@ -102,6 +111,7 @@ luaB_getmetatable(lua_State * L)
   return 1;                     /* returns either __metatable field (if present) or metatable */
 }
 
+
 static int
 luaB_setmetatable(lua_State * L)
 {
@@ -115,6 +125,7 @@ luaB_setmetatable(lua_State * L)
   return 1;
 }
 
+
 static void
 getfunc(lua_State * L)
 {
@@ -132,6 +143,7 @@ getfunc(lua_State * L)
   }
 }
 
+
 static int
 aux_getfenv(lua_State * L)
 {
@@ -141,6 +153,7 @@ aux_getfenv(lua_State * L)
   return !lua_isnil(L, -1);
 }
 
+
 static int
 luaB_getfenv(lua_State * L)
 {
@@ -150,6 +163,7 @@ luaB_getfenv(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_setfenv(lua_State * L)
 {
@@ -167,6 +181,7 @@ luaB_setfenv(lua_State * L)
   return 0;
 }
 
+
 static int
 luaB_rawequal(lua_State * L)
 {
@@ -176,6 +191,7 @@ luaB_rawequal(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_rawget(lua_State * L)
 {
@@ -195,6 +211,7 @@ luaB_rawset(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_gcinfo(lua_State * L)
 {
@@ -203,6 +220,7 @@ luaB_gcinfo(lua_State * L)
   return 2;
 }
 
+
 static int
 luaB_collectgarbage(lua_State * L)
 {
@@ -210,6 +228,7 @@ luaB_collectgarbage(lua_State * L)
   return 0;
 }
 
+
 static int
 luaB_type(lua_State * L)
 {
@@ -218,6 +237,7 @@ luaB_type(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_next(lua_State * L)
 {
@@ -231,6 +251,7 @@ luaB_next(lua_State * L)
   }
 }
 
+
 static int
 luaB_pairs(lua_State * L)
 {
@@ -242,6 +263,7 @@ luaB_pairs(lua_State * L)
   return 3;
 }
 
+
 static int
 luaB_ipairs(lua_State * L)
 {
@@ -261,6 +283,7 @@ luaB_ipairs(lua_State * L)
   }
 }
 
+
 static int
 load_aux(lua_State * L, int status)
 {
@@ -273,6 +296,7 @@ load_aux(lua_State * L, int status)
   }
 }
 
+
 static int
 luaB_loadstring(lua_State * L)
 {
@@ -282,6 +306,7 @@ luaB_loadstring(lua_State * L)
   return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
 }
 
+
 static int
 luaB_loadfile(lua_State * L)
 {
@@ -289,6 +314,7 @@ luaB_loadfile(lua_State * L)
   return load_aux(L, luaL_loadfile(L, fname));
 }
 
+
 static int
 luaB_dofile(lua_State * L)
 {
@@ -301,6 +327,7 @@ luaB_dofile(lua_State * L)
   return lua_gettop(L) - n;
 }
 
+
 static int
 luaB_assert(lua_State * L)
 {
@@ -311,6 +338,7 @@ luaB_assert(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_unpack(lua_State * L)
 {
@@ -323,6 +351,7 @@ luaB_unpack(lua_State * L)
   return n;
 }
 
+
 static int
 luaB_pcall(lua_State * L)
 {
@@ -334,6 +363,7 @@ luaB_pcall(lua_State * L)
   return lua_gettop(L);         /* return status + all results */
 }
 
+
 static int
 luaB_xpcall(lua_State * L)
 {
@@ -347,6 +377,7 @@ luaB_xpcall(lua_State * L)
   return lua_gettop(L);         /* return status + all results */
 }
 
+
 static int
 luaB_tostring(lua_State * L)
 {
@@ -385,6 +416,7 @@ luaB_tostring(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_newproxy(lua_State * L)
 {
@@ -411,12 +443,14 @@ luaB_newproxy(lua_State * L)
   return 1;
 }
 
+
 /*
 ** {======================================================
 ** `require' function
 ** =======================================================
 */
 
+
 /* name of global that holds table with loaded packages */
 #define REQTAB         "_LOADED"
 
@@ -435,6 +469,7 @@ luaB_newproxy(lua_State * L)
 #define LUA_PATH_DEFAULT       "?;?.lua"
 #endif
 
+
 static const char *
 getpath(lua_State * L)
 {
@@ -450,6 +485,7 @@ getpath(lua_State * L)
   return LUA_PATH_DEFAULT;      /* else use default */
 }
 
+
 static const char *
 pushnextpath(lua_State * L, const char *path)
 {
@@ -465,6 +501,7 @@ pushnextpath(lua_State * L, const char *path)
   return l;
 }
 
+
 static void
 pushcomposename(lua_State * L)
 {
@@ -483,6 +520,7 @@ pushcomposename(lua_State * L)
   lua_concat(L, n);
 }
 
+
 static int
 luaB_require(lua_State * L)
 {
@@ -508,8 +546,7 @@ luaB_require(lua_State * L)
     }
   }
   switch (status) {
-  case 0:
-    {
+  case 0:{
       lua_getglobal(L, "_REQUIREDNAME");        /* save previous name */
       lua_insert(L, -2);        /* put it below function */
       lua_pushvalue(L, 1);
@@ -526,12 +563,10 @@ luaB_require(lua_State * L)
       lua_rawset(L, 2);         /* mark it as loaded */
       return 1;                 /* return value */
     }
-  case LUA_ERRFILE:
-    {                           /* file not found */
+  case LUA_ERRFILE:{           /* file not found */
       return luaL_error(L, "could not load package `%s' from path `%s'", lua_tostring(L, 1), getpath(L));
     }
-  default:
-    {
+  default:{
       return luaL_error(L, "error loading package `%s' (%s)", lua_tostring(L, 1), lua_tostring(L, -1));
     }
   }
@@ -539,6 +574,7 @@ luaB_require(lua_State * L)
 
 /* }====================================================== */
 
+
 static const luaL_reg base_funcs[] = {
   {"error", luaB_error},
   {"getmetatable", luaB_getmetatable},
@@ -568,6 +604,7 @@ static const luaL_reg base_funcs[] = {
   {NULL, NULL}
 };
 
+
 /*
 ** {======================================================
 ** Coroutine library
@@ -594,6 +631,7 @@ auxresume(lua_State * L, lua_State * co, int narg)
   }
 }
 
+
 static int
 luaB_coresume(lua_State * L)
 {
@@ -612,6 +650,7 @@ luaB_coresume(lua_State * L)
   }
 }
 
+
 static int
 luaB_auxwrap(lua_State * L)
 {
@@ -628,6 +667,7 @@ luaB_auxwrap(lua_State * L)
   return r;
 }
 
+
 static int
 luaB_cocreate(lua_State * L)
 {
@@ -638,6 +678,7 @@ luaB_cocreate(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_cowrap(lua_State * L)
 {
@@ -646,12 +687,14 @@ luaB_cowrap(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_yield(lua_State * L)
 {
   return lua_yield(L, lua_gettop(L));
 }
 
+
 static int
 luaB_costatus(lua_State * L)
 {
@@ -669,6 +712,7 @@ luaB_costatus(lua_State * L)
   return 1;
 }
 
+
 static const luaL_reg co_funcs[] = {
   {"create", luaB_cocreate},
   {"wrap", luaB_cowrap},
@@ -680,6 +724,8 @@ static const luaL_reg co_funcs[] = {
 
 /* }====================================================== */
 
+
+
 static void
 base_open(lua_State * L)
 {
@@ -702,6 +748,7 @@ base_open(lua_State * L)
   lua_rawset(L, -1);            /* set global _G */
 }
 
+
 LUALIB_API int
 luaopen_base(lua_State * L)
 {
@@ -711,10 +758,3 @@ luaopen_base(lua_State * L)
   lua_setglobal(L, REQTAB);
   return 0;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 0724d36..5e601f8 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lcode.c,v 1.117 2003/04/03 13:35:34 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdlib.h>
 
 #define lcode_c
 #include "lparser.h"
 #include "ltable.h"
 
+
 #define hasjumps(e)    ((e)->t != (e)->f)
 
+
 void
 luaK_nil(FuncState * fs, int from, int n)
 {
@@ -39,6 +43,7 @@ luaK_nil(FuncState * fs, int from, int n)
   luaK_codeABC(fs, OP_LOADNIL, from, from + n - 1, 0);  /* else no optimization */
 }
 
+
 int
 luaK_jump(FuncState * fs)
 {
@@ -50,6 +55,7 @@ luaK_jump(FuncState * fs)
   return j;
 }
 
+
 static int
 luaK_condjump(FuncState * fs, OpCode op, int A, int B, int C)
 {
@@ -57,6 +63,7 @@ luaK_condjump(FuncState * fs, OpCode op, int A, int B, int C)
   return luaK_jump(fs);
 }
 
+
 static void
 luaK_fixjump(FuncState * fs, int pc, int dest)
 {
@@ -68,6 +75,7 @@ luaK_fixjump(FuncState * fs, int pc, int dest)
   SETARG_sBx(*jmp, offset);
 }
 
+
 /*
 ** returns current `pc' and marks it as a jump target (to avoid wrong
 ** optimizations with consecutive instructions not in the same basic block).
@@ -79,6 +87,7 @@ luaK_getlabel(FuncState * fs)
   return fs->pc;
 }
 
+
 static int
 luaK_getjump(FuncState * fs, int pc)
 {
@@ -89,6 +98,7 @@ luaK_getjump(FuncState * fs, int pc)
     return (pc + 1) + offset;   /* turn offset into absolute position */
 }
 
+
 static Instruction *
 getjumpcontrol(FuncState * fs, int pc)
 {
@@ -99,6 +109,7 @@ getjumpcontrol(FuncState * fs, int pc)
     return pi;
 }
 
+
 /*
 ** check whether list has any jump that do not produce a value
 ** (or produce an inverted value)
@@ -114,6 +125,7 @@ need_value(FuncState * fs, int list, int cond)
   return 0;                     /* not found */
 }
 
+
 static void
 patchtestreg(Instruction * i, int reg)
 {
@@ -122,6 +134,7 @@ patchtestreg(Instruction * i, int reg)
   SETARG_A(*i, reg);
 }
 
+
 static void
 luaK_patchlistaux(FuncState * fs, int list, int ttarget, int treg, int ftarget, int freg, int dtarget)
 {
@@ -146,6 +159,7 @@ luaK_patchlistaux(FuncState * fs, int list, int ttarget, int treg, int ftarget,
   }
 }
 
+
 static void
 luaK_dischargejpc(FuncState * fs)
 {
@@ -153,6 +167,7 @@ luaK_dischargejpc(FuncState * fs)
   fs->jpc = NO_JUMP;
 }
 
+
 void
 luaK_patchlist(FuncState * fs, int list, int target)
 {
@@ -164,6 +179,7 @@ luaK_patchlist(FuncState * fs, int list, int target)
   }
 }
 
+
 void
 luaK_patchtohere(FuncState * fs, int list)
 {
@@ -171,6 +187,7 @@ luaK_patchtohere(FuncState * fs, int list)
   luaK_concat(fs, &fs->jpc, list);
 }
 
+
 void
 luaK_concat(FuncState * fs, int *l1, int l2)
 {
@@ -187,6 +204,7 @@ luaK_concat(FuncState * fs, int *l1, int l2)
   }
 }
 
+
 void
 luaK_checkstack(FuncState * fs, int n)
 {
@@ -198,6 +216,7 @@ luaK_checkstack(FuncState * fs, int n)
   }
 }
 
+
 void
 luaK_reserveregs(FuncState * fs, int n)
 {
@@ -205,6 +224,7 @@ luaK_reserveregs(FuncState * fs, int n)
   fs->freereg += n;
 }
 
+
 static void
 freereg(FuncState * fs, int reg)
 {
@@ -214,6 +234,7 @@ freereg(FuncState * fs, int reg)
   }
 }
 
+
 static void
 freeexp(FuncState * fs, expdesc * e)
 {
@@ -221,6 +242,7 @@ freeexp(FuncState * fs, expdesc * e)
     freereg(fs, e->info);
 }
 
+
 static int
 addk(FuncState * fs, TObject * k, TObject * v)
 {
@@ -237,6 +259,7 @@ addk(FuncState * fs, TObject * k, TObject * v)
   }
 }
 
+
 int
 luaK_stringK(FuncState * fs, TString * s)
 {
@@ -245,6 +268,7 @@ luaK_stringK(FuncState * fs, TString * s)
   return addk(fs, &o, &o);
 }
 
+
 int
 luaK_numberK(FuncState * fs, lua_Number r)
 {
@@ -253,6 +277,7 @@ luaK_numberK(FuncState * fs, lua_Number r)
   return addk(fs, &o, &o);
 }
 
+
 static int
 nil_constant(FuncState * fs)
 {
@@ -262,6 +287,7 @@ nil_constant(FuncState * fs)
   return addk(fs, &k, &v);
 }
 
+
 void
 luaK_setcallreturns(FuncState * fs, expdesc * e, int nresults)
 {
@@ -274,37 +300,33 @@ luaK_setcallreturns(FuncState * fs, expdesc * e, int nresults)
   }
 }
 
+
 void
 luaK_dischargevars(FuncState * fs, expdesc * e)
 {
   switch (e->k) {
-  case VLOCAL:
-    {
+  case VLOCAL:{
       e->k = VNONRELOC;
       break;
     }
-  case VUPVAL:
-    {
+  case VUPVAL:{
       e->info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->info, 0);
       e->k = VRELOCABLE;
       break;
     }
-  case VGLOBAL:
-    {
+  case VGLOBAL:{
       e->info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->info);
       e->k = VRELOCABLE;
       break;
     }
-  case VINDEXED:
-    {
+  case VINDEXED:{
       freereg(fs, e->aux);
       freereg(fs, e->info);
       e->info = luaK_codeABC(fs, OP_GETTABLE, 0, e->info, e->aux);
       e->k = VRELOCABLE;
       break;
     }
-  case VCALL:
-    {
+  case VCALL:{
       luaK_setcallreturns(fs, e, 1);
       break;
     }
@@ -313,6 +335,7 @@ luaK_dischargevars(FuncState * fs, expdesc * e)
   }
 }
 
+
 static int
 code_label(FuncState * fs, int A, int b, int jump)
 {
@@ -320,41 +343,36 @@ code_label(FuncState * fs, int A, int b, int jump)
   return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
 }
 
+
 static void
 discharge2reg(FuncState * fs, expdesc * e, int reg)
 {
   luaK_dischargevars(fs, e);
   switch (e->k) {
-  case VNIL:
-    {
+  case VNIL:{
       luaK_nil(fs, reg, 1);
       break;
     }
   case VFALSE:
-  case VTRUE:
-    {
+  case VTRUE:{
       luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
       break;
     }
-  case VK:
-    {
+  case VK:{
       luaK_codeABx(fs, OP_LOADK, reg, e->info);
       break;
     }
-  case VRELOCABLE:
-    {
+  case VRELOCABLE:{
       Instruction *pc = &getcode(fs, e);
       SETARG_A(*pc, reg);
       break;
     }
-  case VNONRELOC:
-    {
+  case VNONRELOC:{
       if (reg != e->info)
         luaK_codeABC(fs, OP_MOVE, reg, e->info, 0);
       break;
     }
-  default:
-    {
+  default:{
       lua_assert(e->k == VVOID || e->k == VJMP);
       return;                   /* nothing to do... */
     }
@@ -363,6 +381,7 @@ discharge2reg(FuncState * fs, expdesc * e, int reg)
   e->k = VNONRELOC;
 }
 
+
 static void
 discharge2anyreg(FuncState * fs, expdesc * e)
 {
@@ -372,6 +391,7 @@ discharge2anyreg(FuncState * fs, expdesc * e)
   }
 }
 
+
 static void
 luaK_exp2reg(FuncState * fs, expdesc * e, int reg)
 {
@@ -399,6 +419,7 @@ luaK_exp2reg(FuncState * fs, expdesc * e, int reg)
   e->k = VNONRELOC;
 }
 
+
 void
 luaK_exp2nextreg(FuncState * fs, expdesc * e)
 {
@@ -408,6 +429,7 @@ luaK_exp2nextreg(FuncState * fs, expdesc * e)
   luaK_exp2reg(fs, e, fs->freereg - 1);
 }
 
+
 int
 luaK_exp2anyreg(FuncState * fs, expdesc * e)
 {
@@ -424,6 +446,7 @@ luaK_exp2anyreg(FuncState * fs, expdesc * e)
   return e->info;
 }
 
+
 void
 luaK_exp2val(FuncState * fs, expdesc * e)
 {
@@ -433,13 +456,13 @@ luaK_exp2val(FuncState * fs, expdesc * e)
     luaK_dischargevars(fs, e);
 }
 
+
 int
 luaK_exp2RK(FuncState * fs, expdesc * e)
 {
   luaK_exp2val(fs, e);
   switch (e->k) {
-  case VNIL:
-    {
+  case VNIL:{
       if (fs->nk + MAXSTACK <= MAXARG_C) {      /* constant fit in argC? */
         e->info = nil_constant(fs);
         e->k = VK;
@@ -447,8 +470,7 @@ luaK_exp2RK(FuncState * fs, expdesc * e)
       } else
         break;
     }
-  case VK:
-    {
+  case VK:{
       if (e->info + MAXSTACK <= MAXARG_C)       /* constant fit in argC? */
         return e->info + MAXSTACK;
       else
@@ -461,36 +483,32 @@ luaK_exp2RK(FuncState * fs, expdesc * e)
   return luaK_exp2anyreg(fs, e);
 }
 
+
 void
 luaK_storevar(FuncState * fs, expdesc * var, expdesc * exp)
 {
   switch (var->k) {
-  case VLOCAL:
-    {
+  case VLOCAL:{
       freeexp(fs, exp);
       luaK_exp2reg(fs, exp, var->info);
       return;
     }
-  case VUPVAL:
-    {
+  case VUPVAL:{
       int e = luaK_exp2anyreg(fs, exp);
       luaK_codeABC(fs, OP_SETUPVAL, e, var->info, 0);
       break;
     }
-  case VGLOBAL:
-    {
+  case VGLOBAL:{
       int e = luaK_exp2anyreg(fs, exp);
       luaK_codeABx(fs, OP_SETGLOBAL, e, var->info);
       break;
     }
-  case VINDEXED:
-    {
+  case VINDEXED:{
       int e = luaK_exp2RK(fs, exp);
       luaK_codeABC(fs, OP_SETTABLE, var->info, var->aux, e);
       break;
     }
-  default:
-    {
+  default:{
       lua_assert(0);            /* invalid var kind to store */
       break;
     }
@@ -498,6 +516,7 @@ luaK_storevar(FuncState * fs, expdesc * var, expdesc * exp)
   freeexp(fs, exp);
 }
 
+
 void
 luaK_self(FuncState * fs, expdesc * e, expdesc * key)
 {
@@ -512,6 +531,7 @@ luaK_self(FuncState * fs, expdesc * e, expdesc * key)
   e->k = VNONRELOC;
 }
 
+
 static void
 invertjump(FuncState * fs, expdesc * e)
 {
@@ -520,6 +540,7 @@ invertjump(FuncState * fs, expdesc * e)
   SETARG_A(*pc, !(GETARG_A(*pc)));
 }
 
+
 static int
 jumponcond(FuncState * fs, expdesc * e, int cond)
 {
@@ -536,6 +557,7 @@ jumponcond(FuncState * fs, expdesc * e, int cond)
   return luaK_condjump(fs, OP_TEST, NO_REG, e->info, cond);
 }
 
+
 void
 luaK_goiftrue(FuncState * fs, expdesc * e)
 {
@@ -543,24 +565,20 @@ luaK_goiftrue(FuncState * fs, expdesc * e)
   luaK_dischargevars(fs, e);
   switch (e->k) {
   case VK:
-  case VTRUE:
-    {
+  case VTRUE:{
       pc = NO_JUMP;             /* always true; do nothing */
       break;
     }
-  case VFALSE:
-    {
+  case VFALSE:{
       pc = luaK_jump(fs);       /* always jump */
       break;
     }
-  case VJMP:
-    {
+  case VJMP:{
       invertjump(fs, e);
       pc = e->info;
       break;
     }
-  default:
-    {
+  default:{
       pc = jumponcond(fs, e, 0);
       break;
     }
@@ -568,6 +586,7 @@ luaK_goiftrue(FuncState * fs, expdesc * e)
   luaK_concat(fs, &e->f, pc);   /* insert last jump in `f' list */
 }
 
+
 void
 luaK_goiffalse(FuncState * fs, expdesc * e)
 {
@@ -575,23 +594,19 @@ luaK_goiffalse(FuncState * fs, expdesc * e)
   luaK_dischargevars(fs, e);
   switch (e->k) {
   case VNIL:
-  case VFALSE:
-    {
+  case VFALSE:{
       pc = NO_JUMP;             /* always false; do nothing */
       break;
     }
-  case VTRUE:
-    {
+  case VTRUE:{
       pc = luaK_jump(fs);       /* always jump */
       break;
     }
-  case VJMP:
-    {
+  case VJMP:{
       pc = e->info;
       break;
     }
-  default:
-    {
+  default:{
       pc = jumponcond(fs, e, 1);
       break;
     }
@@ -599,39 +614,35 @@ luaK_goiffalse(FuncState * fs, expdesc * e)
   luaK_concat(fs, &e->t, pc);   /* insert last jump in `t' list */
 }
 
+
 static void
 codenot(FuncState * fs, expdesc * e)
 {
   luaK_dischargevars(fs, e);
   switch (e->k) {
   case VNIL:
-  case VFALSE:
-    {
+  case VFALSE:{
       e->k = VTRUE;
       break;
     }
   case VK:
-  case VTRUE:
-    {
+  case VTRUE:{
       e->k = VFALSE;
       break;
     }
-  case VJMP:
-    {
+  case VJMP:{
       invertjump(fs, e);
       break;
     }
   case VRELOCABLE:
-  case VNONRELOC:
-    {
+  case VNONRELOC:{
       discharge2anyreg(fs, e);
       freeexp(fs, e);
       e->info = luaK_codeABC(fs, OP_NOT, 0, e->info, 0);
       e->k = VRELOCABLE;
       break;
     }
-  default:
-    {
+  default:{
       lua_assert(0);            /* cannot happen */
       break;
     }
@@ -644,6 +655,7 @@ codenot(FuncState * fs, expdesc * e)
   }
 }
 
+
 void
 luaK_indexed(FuncState * fs, expdesc * t, expdesc * k)
 {
@@ -651,6 +663,7 @@ luaK_indexed(FuncState * fs, expdesc * t, expdesc * k)
   t->k = VINDEXED;
 }
 
+
 void
 luaK_prefix(FuncState * fs, UnOpr op, expdesc * e)
 {
@@ -668,37 +681,35 @@ luaK_prefix(FuncState * fs, UnOpr op, expdesc * e)
     codenot(fs, e);
 }
 
+
 void
 luaK_infix(FuncState * fs, BinOpr op, expdesc * v)
 {
   switch (op) {
-  case OPR_AND:
-    {
+  case OPR_AND:{
       luaK_goiftrue(fs, v);
       luaK_patchtohere(fs, v->t);
       v->t = NO_JUMP;
       break;
     }
-  case OPR_OR:
-    {
+  case OPR_OR:{
       luaK_goiffalse(fs, v);
       luaK_patchtohere(fs, v->f);
       v->f = NO_JUMP;
       break;
     }
-  case OPR_CONCAT:
-    {
+  case OPR_CONCAT:{
       luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
       break;
     }
-  default:
-    {
+  default:{
       luaK_exp2RK(fs, v);
       break;
     }
   }
 }
 
+
 static void
 codebinop(FuncState * fs, expdesc * res, BinOpr op, int o1, int o2)
 {
@@ -721,12 +732,12 @@ codebinop(FuncState * fs, expdesc * res, BinOpr op, int o1, int o2)
   }
 }
 
+
 void
 luaK_posfix(FuncState * fs, BinOpr op, expdesc * e1, expdesc * e2)
 {
   switch (op) {
-  case OPR_AND:
-    {
+  case OPR_AND:{
       lua_assert(e1->t == NO_JUMP);     /* list must be closed */
       luaK_dischargevars(fs, e2);
       luaK_concat(fs, &e1->f, e2->f);
@@ -736,8 +747,7 @@ luaK_posfix(FuncState * fs, BinOpr op, expdesc * e1, expdesc * e2)
       e1->t = e2->t;
       break;
     }
-  case OPR_OR:
-    {
+  case OPR_OR:{
       lua_assert(e1->f == NO_JUMP);     /* list must be closed */
       luaK_dischargevars(fs, e2);
       luaK_concat(fs, &e1->t, e2->t);
@@ -747,8 +757,7 @@ luaK_posfix(FuncState * fs, BinOpr op, expdesc * e1, expdesc * e2)
       e1->f = e2->f;
       break;
     }
-  case OPR_CONCAT:
-    {
+  case OPR_CONCAT:{
       luaK_exp2val(fs, e2);
       if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
         lua_assert(e1->info == GETARG_B(getcode(fs, e2)) - 1);
@@ -765,8 +774,7 @@ luaK_posfix(FuncState * fs, BinOpr op, expdesc * e1, expdesc * e2)
       }
       break;
     }
-  default:
-    {
+  default:{
       int o1 = luaK_exp2RK(fs, e1);
       int o2 = luaK_exp2RK(fs, e2);
       freeexp(fs, e2);
@@ -776,12 +784,14 @@ luaK_posfix(FuncState * fs, BinOpr op, expdesc * e1, expdesc * e2)
   }
 }
 
+
 void
 luaK_fixline(FuncState * fs, int line)
 {
   fs->f->lineinfo[fs->pc - 1] = line;
 }
 
+
 int
 luaK_code(FuncState * fs, Instruction i, int line)
 {
@@ -796,6 +806,7 @@ luaK_code(FuncState * fs, Instruction i, int line)
   return fs->pc++;
 }
 
+
 int
 luaK_codeABC(FuncState * fs, OpCode o, int a, int b, int c)
 {
@@ -803,16 +814,10 @@ luaK_codeABC(FuncState * fs, OpCode o, int a, int b, int c)
   return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
 }
 
+
 int
 luaK_codeABx(FuncState * fs, OpCode o, int a, unsigned int bc)
 {
   lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
   return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 51a87ba..f179cee 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lcode.h,v 1.38 2002/12/11 12:34:22 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 #include "lopcodes.h"
 #include "lparser.h"
 
+
 /*
 ** Marks the end of a patch list. It is an invalid value both as an absolute
 ** address, and as a list link (would link an element to itself).
 */
 #define NO_JUMP (-1)
 
+
 /*
 ** grep "ORDER OPR" if you change these enums
 */
@@ -34,6 +37,7 @@ typedef enum BinOpr {
 
 typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr;
 
+
 #define getcode(fs,e)  ((fs)->f->code[(e)->info])
 
 #define luaK_codeAsBx(fs,o,A,sBx)      luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
@@ -67,11 +71,5 @@ void luaK_prefix(FuncState * fs, UnOpr op, expdesc * v);
 void luaK_infix(FuncState * fs, BinOpr op, expdesc * v);
 void luaK_posfix(FuncState * fs, BinOpr op, expdesc * v1, expdesc * v2);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 200daa2..f4abbd4 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ldblib.c,v 1.80 2003/04/03 13:35:34 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -15,6 +17,8 @@
 #include "lauxlib.h"
 #include "lualib.h"
 
+
+
 static void
 settabss(lua_State * L, const char *i, const char *v)
 {
@@ -23,6 +27,7 @@ settabss(lua_State * L, const char *i, const char *v)
   lua_rawset(L, -3);
 }
 
+
 static void
 settabsi(lua_State * L, const char *i, int v)
 {
@@ -31,6 +36,7 @@ settabsi(lua_State * L, const char *i, int v)
   lua_rawset(L, -3);
 }
 
+
 static int
 getinfo(lua_State * L)
 {
@@ -78,6 +84,7 @@ getinfo(lua_State * L)
   return 1;                     /* return table */
 }
 
+
 static int
 getlocal(lua_State * L)
 {
@@ -96,6 +103,7 @@ getlocal(lua_State * L)
   }
 }
 
+
 static int
 setlocal(lua_State * L)
 {
@@ -107,6 +115,7 @@ setlocal(lua_State * L)
   return 1;
 }
 
+
 static int
 auxupvalue(lua_State * L, int get)
 {
@@ -123,12 +132,14 @@ auxupvalue(lua_State * L, int get)
   return get + 1;
 }
 
+
 static int
 getupvalue(lua_State * L)
 {
   return auxupvalue(L, 1);
 }
 
+
 static int
 setupvalue(lua_State * L)
 {
@@ -136,8 +147,11 @@ setupvalue(lua_State * L)
   return auxupvalue(L, 0);
 }
 
+
+
 static const char KEY_HOOK = 'h';
 
+
 static void
 hookf(lua_State * L, lua_Debug * ar)
 {
@@ -156,6 +170,7 @@ hookf(lua_State * L, lua_Debug * ar)
     lua_pop(L, 1);              /* pop result from gettable */
 }
 
+
 static int
 makemask(const char *smask, int count)
 {
@@ -171,6 +186,7 @@ makemask(const char *smask, int count)
   return mask;
 }
 
+
 static char *
 unmakemask(int mask, char *smask)
 {
@@ -185,6 +201,7 @@ unmakemask(int mask, char *smask)
   return smask;
 }
 
+
 static int
 sethook(lua_State * L)
 {
@@ -203,6 +220,7 @@ sethook(lua_State * L)
   return 0;
 }
 
+
 static int
 gethook(lua_State * L)
 {
@@ -220,6 +238,7 @@ gethook(lua_State * L)
   return 3;
 }
 
+
 static int
 debug(lua_State * L)
 {
@@ -233,6 +252,7 @@ debug(lua_State * L)
   }
 }
 
+
 #define LEVELS1        12              /* size of the first part of the stack */
 #define LEVELS2        10              /* size of the second part of the stack */
 
@@ -274,8 +294,7 @@ errorfb(lua_State * L)
     case 'm':                  /* method */
       lua_pushfstring(L, " in function `%s'", ar.name);
       break;
-    default:
-      {
+    default:{
         if (*ar.what == 'm')    /* main? */
           lua_pushfstring(L, " in main chunk");
         else if (*ar.what == 'C' || *ar.what == 't')
@@ -290,6 +309,7 @@ errorfb(lua_State * L)
   return 1;
 }
 
+
 static const luaL_reg dblib[] = {
   {"getlocal", getlocal},
   {"getinfo", getinfo},
@@ -303,6 +323,7 @@ static const luaL_reg dblib[] = {
   {NULL, NULL}
 };
 
+
 LUALIB_API int
 luaopen_debug(lua_State * L)
 {
@@ -312,10 +333,3 @@ luaopen_debug(lua_State * L)
   lua_settable(L, LUA_GLOBALSINDEX);
   return 1;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index dacba3e..ad498d2 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ldebug.c,v 1.150 2003/03/19 21:24:04 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdlib.h>
 #include <string.h>
 
 #include "ltm.h"
 #include "lvm.h"
 
+
+
 static const char *getfuncname(CallInfo * ci, const char **name);
 
+
 #define isLua(ci)      (!((ci)->state & CI_C))
 
+
 static int
 currentpc(CallInfo * ci)
 {
@@ -39,6 +45,7 @@ currentpc(CallInfo * ci)
   return pcRel(ci->u.l.savedpc, ci_func(ci)->l.p);
 }
 
+
 static int
 currentline(CallInfo * ci)
 {
@@ -49,6 +56,7 @@ currentline(CallInfo * ci)
     return getline(ci_func(ci)->l.p, pc);
 }
 
+
 void
 luaG_inithooks(lua_State * L)
 {
@@ -58,6 +66,7 @@ luaG_inithooks(lua_State * L)
   L->hookinit = 1;
 }
 
+
 /*
 ** this function can be called asynchronous (e.g. during a signal)
 */
@@ -76,24 +85,28 @@ lua_sethook(lua_State * L, lua_Hook func, int mask, int count)
   return 1;
 }
 
+
 LUA_API lua_Hook
 lua_gethook(lua_State * L)
 {
   return L->hook;
 }
 
+
 LUA_API int
 lua_gethookmask(lua_State * L)
 {
   return L->hookmask;
 }
 
+
 LUA_API int
 lua_gethookcount(lua_State * L)
 {
   return L->basehookcount;
 }
 
+
 LUA_API int
 lua_getstack(lua_State * L, int level, lua_Debug * ar)
 {
@@ -118,12 +131,14 @@ lua_getstack(lua_State * L, int level, lua_Debug * ar)
   return status;
 }
 
+
 static Proto *
 getluaproto(CallInfo * ci)
 {
   return (isLua(ci) ? ci_func(ci)->l.p : NULL);
 }
 
+
 LUA_API const char *
 lua_getlocal(lua_State * L, const lua_Debug * ar, int n)
 {
@@ -143,6 +158,7 @@ lua_getlocal(lua_State * L, const lua_Debug * ar, int n)
   return name;
 }
 
+
 LUA_API const char *
 lua_setlocal(lua_State * L, const lua_Debug * ar, int n)
 {
@@ -165,6 +181,7 @@ lua_setlocal(lua_State * L, const lua_Debug * ar, int n)
   return name;
 }
 
+
 static void
 funcinfo(lua_Debug * ar, StkId func)
 {
@@ -181,6 +198,7 @@ funcinfo(lua_Debug * ar, StkId func)
   luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
 }
 
+
 static const char *
 travglobals(lua_State * L, const TObject * o)
 {
@@ -194,6 +212,7 @@ travglobals(lua_State * L, const TObject * o)
   return NULL;
 }
 
+
 static void
 info_tailcall(lua_State * L, lua_Debug * ar)
 {
@@ -206,29 +225,26 @@ info_tailcall(lua_State * L, lua_Debug * ar)
   setnilvalue(L->top);
 }
 
+
 static int
 auxgetinfo(lua_State * L, const char *what, lua_Debug * ar, StkId f, CallInfo * ci)
 {
   int status = 1;
   for (; *what; what++) {
     switch (*what) {
-    case 'S':
-      {
+    case 'S':{
         funcinfo(ar, f);
         break;
       }
-    case 'l':
-      {
+    case 'l':{
         ar->currentline = (ci) ? currentline(ci) : -1;
         break;
       }
-    case 'u':
-      {
+    case 'u':{
         ar->nups = clvalue(f)->c.nupvalues;
         break;
       }
-    case 'n':
-      {
+    case 'n':{
         ar->namewhat = (ci) ? getfuncname(ci, &ar->name) : NULL;
         if (ar->namewhat == NULL) {
           /* try to find a global name */
@@ -239,8 +255,7 @@ auxgetinfo(lua_State * L, const char *what, lua_Debug * ar, StkId f, CallInfo *
         }
         break;
       }
-    case 'f':
-      {
+    case 'f':{
         setobj2s(L->top, f);
         break;
       }
@@ -251,6 +266,7 @@ auxgetinfo(lua_State * L, const char *what, lua_Debug * ar, StkId f, CallInfo *
   return status;
 }
 
+
 LUA_API int
 lua_getinfo(lua_State * L, const char *what, lua_Debug * ar)
 {
@@ -274,6 +290,7 @@ lua_getinfo(lua_State * L, const char *what, lua_Debug * ar)
   return status;
 }
 
+
 /*
 ** {======================================================
 ** Symbolic Execution and code checker
@@ -286,6 +303,8 @@ lua_getinfo(lua_State * L, const char *what, lua_Debug * ar)
 
 #define checkreg(pt,reg)       check((reg) < (pt)->maxstacksize)
 
+
+
 static int
 precheck(const Proto * pt)
 {
@@ -296,6 +315,7 @@ precheck(const Proto * pt)
   return 1;
 }
 
+
 static int
 checkopenop(const Proto * pt, int pc)
 {
@@ -303,8 +323,7 @@ checkopenop(const Proto * pt, int pc)
   switch (GET_OPCODE(i)) {
   case OP_CALL:
   case OP_TAILCALL:
-  case OP_RETURN:
-    {
+  case OP_RETURN:{
       check(GETARG_B(i) == 0);
       return 1;
     }
@@ -315,12 +334,14 @@ checkopenop(const Proto * pt, int pc)
   }
 }
 
+
 static int
 checkRK(const Proto * pt, int r)
 {
   return (r < pt->maxstacksize || (r >= MAXSTACK && r - MAXSTACK < pt->sizek));
 }
 
+
 static Instruction
 luaG_symbexec(const Proto * pt, int lastpc, int reg)
 {
@@ -336,8 +357,7 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
     int c = 0;
     checkreg(pt, a);
     switch (getOpMode(op)) {
-    case iABC:
-      {
+    case iABC:{
         b = GETARG_B(i);
         c = GETARG_C(i);
         if (testOpMode(op, OpModeBreg)) {
@@ -348,15 +368,13 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
           check(checkRK(pt, c));
         break;
       }
-    case iABx:
-      {
+    case iABx:{
         b = GETARG_Bx(i);
         if (testOpMode(op, OpModeK))
           check(b < pt->sizek);
         break;
       }
-    case iAsBx:
-      {
+    case iAsBx:{
         b = GETARG_sBx(i);
         break;
       }
@@ -370,38 +388,32 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
       check(GET_OPCODE(pt->code[pc + 1]) == OP_JMP);
     }
     switch (op) {
-    case OP_LOADBOOL:
-      {
+    case OP_LOADBOOL:{
         check(c == 0 || pc + 2 < pt->sizecode); /* check its jump */
         break;
       }
-    case OP_LOADNIL:
-      {
+    case OP_LOADNIL:{
         if (a <= reg && reg <= b)
           last = pc;            /* set registers from `a' to `b' */
         break;
       }
     case OP_GETUPVAL:
-    case OP_SETUPVAL:
-      {
+    case OP_SETUPVAL:{
         check(b < pt->nups);
         break;
       }
     case OP_GETGLOBAL:
-    case OP_SETGLOBAL:
-      {
+    case OP_SETGLOBAL:{
         check(ttisstring(&pt->k[b]));
         break;
       }
-    case OP_SELF:
-      {
+    case OP_SELF:{
         checkreg(pt, a + 1);
         if (reg == a + 1)
           last = pc;
         break;
       }
-    case OP_CONCAT:
-      {
+    case OP_CONCAT:{
         /* `c' is a register, and at least two operands */
         check(c < MAXSTACK && b < c);
         break;
@@ -414,8 +426,7 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
     case OP_FORLOOP:
       checkreg(pt, a + 2);
       /* go through */
-    case OP_JMP:
-      {
+    case OP_JMP:{
         int dest = pc + 1 + b;
         check(0 <= dest && dest < pt->sizecode);
         /* not full check and jump is forward and do not skip `lastpc'? */
@@ -424,8 +435,7 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
         break;
       }
     case OP_CALL:
-    case OP_TAILCALL:
-      {
+    case OP_TAILCALL:{
         if (b != 0) {
           checkreg(pt, a + b - 1);
         }
@@ -438,20 +448,17 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
           last = pc;            /* affect all registers above base */
         break;
       }
-    case OP_RETURN:
-      {
+    case OP_RETURN:{
         b--;                    /* b = num. returns */
         if (b > 0)
           checkreg(pt, a + b - 1);
         break;
       }
-    case OP_SETLIST:
-      {
+    case OP_SETLIST:{
         checkreg(pt, a + (b & (LFIELDS_PER_FLUSH - 1)) + 1);
         break;
       }
-    case OP_CLOSURE:
-      {
+    case OP_CLOSURE:{
         int nup;
         check(b < pt->sizep);
         nup = pt->p[b]->nups;
@@ -475,12 +482,14 @@ luaG_symbexec(const Proto * pt, int lastpc, int reg)
 
 /* }====================================================== */
 
+
 int
 luaG_checkcode(const Proto * pt)
 {
   return luaG_symbexec(pt, pt->sizecode, NO_REG);
 }
 
+
 static const char *
 kname(Proto * p, int c)
 {
@@ -491,6 +500,7 @@ kname(Proto * p, int c)
     return "?";
 }
 
+
 static const char *
 getobjname(CallInfo * ci, int stackpos, const char **name)
 {
@@ -504,29 +514,25 @@ getobjname(CallInfo * ci, int stackpos, const char **name)
     i = luaG_symbexec(p, pc, stackpos); /* try symbolic execution */
     lua_assert(pc != -1);
     switch (GET_OPCODE(i)) {
-    case OP_GETGLOBAL:
-      {
+    case OP_GETGLOBAL:{
         int g = GETARG_Bx(i);          /* global index */
         lua_assert(ttisstring(&p->k[g]));
         *name = svalue(&p->k[g]);
         return "global";
       }
-    case OP_MOVE:
-      {
+    case OP_MOVE:{
         int a = GETARG_A(i);
         int b = GETARG_B(i);           /* move from `b' to `a' */
         if (b < a)
           return getobjname(ci, b, name);       /* get name for `b' */
         break;
       }
-    case OP_GETTABLE:
-      {
+    case OP_GETTABLE:{
         int k = GETARG_C(i);           /* key index */
         *name = kname(p, k);
         return "field";
       }
-    case OP_SELF:
-      {
+    case OP_SELF:{
         int k = GETARG_C(i);           /* key index */
         *name = kname(p, k);
         return "method";
@@ -538,6 +544,7 @@ getobjname(CallInfo * ci, int stackpos, const char **name)
   return NULL;                  /* no useful name found */
 }
 
+
 static const char *
 getfuncname(CallInfo * ci, const char **name)
 {
@@ -552,6 +559,7 @@ getfuncname(CallInfo * ci, const char **name)
     return NULL;                /* no useful name can be found */
 }
 
+
 /* only ANSI way to check whether a pointer points to an array */
 static int
 isinstack(CallInfo * ci, const TObject * o)
@@ -563,6 +571,7 @@ isinstack(CallInfo * ci, const TObject * o)
   return 0;
 }
 
+
 void
 luaG_typeerror(lua_State * L, const TObject * o, const char *op)
 {
@@ -575,6 +584,7 @@ luaG_typeerror(lua_State * L, const TObject * o, const char *op)
     luaG_runerror(L, "attempt to %s a %s value", op, t);
 }
 
+
 void
 luaG_concaterror(lua_State * L, StkId p1, StkId p2)
 {
@@ -584,6 +594,7 @@ luaG_concaterror(lua_State * L, StkId p1, StkId p2)
   luaG_typeerror(L, p1, "concatenate");
 }
 
+
 void
 luaG_aritherror(lua_State * L, const TObject * p1, const TObject * p2)
 {
@@ -593,6 +604,7 @@ luaG_aritherror(lua_State * L, const TObject * p1, const TObject * p2)
   luaG_typeerror(L, p2, "perform arithmetic on");
 }
 
+
 int
 luaG_ordererror(lua_State * L, const TObject * p1, const TObject * p2)
 {
@@ -604,6 +616,7 @@ luaG_ordererror(lua_State * L, const TObject * p1, const TObject * p2)
     luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
 }
 
+
 static void
 addinfo(lua_State * L, const char *msg)
 {
@@ -616,6 +629,7 @@ addinfo(lua_State * L, const char *msg)
   }
 }
 
+
 void
 luaG_errormsg(lua_State * L)
 {
@@ -631,6 +645,7 @@ luaG_errormsg(lua_State * L)
   luaD_throw(L, LUA_ERRRUN);
 }
 
+
 void
 luaG_runerror(lua_State * L, const char *fmt, ...)
 {
@@ -640,10 +655,3 @@ luaG_runerror(lua_State * L, const char *fmt, ...)
   va_end(argp);
   luaG_errormsg(L);
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 27dbff8..bb78fa6 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: ldebug.h,v 1.32 2002/11/18 11:01:55 roberto Exp $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
@@ -7,14 +8,17 @@
 #ifndef ldebug_h
 #define ldebug_h
 
+
 #include "lstate.h"
 
+
 #define pcRel(pc, p)   (cast(int, (pc) - (p)->code) - 1)
 
 #define getline(f,pc)  (((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
 
 #define resethookcount(L)      (L->hookcount = L->basehookcount)
 
+
 void luaG_inithooks(lua_State * L);
 void luaG_typeerror(lua_State * L, const TObject * o, const char *opname) __attribute__ ((noreturn));
 void luaG_concaterror(lua_State * L, StkId p1, StkId p2) __attribute__ ((noreturn));
@@ -24,11 +28,5 @@ void luaG_runerror(lua_State * L, const char *fmt, ...) __attribute__ ((noreturn
 void luaG_errormsg(lua_State * L) __attribute__ ((noreturn));
 int luaG_checkcode(const Proto * pt);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 6092f96..67e548b 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ldo.c,v 1.217a 2003/04/03 13:35:34 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
 
+
 #include <setjmp.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lvm.h"
 #include "lzio.h"
 
+
+
+
 /*
 ** {======================================================
 ** Error-recovery functions (based on long jumps)
 ** =======================================================
 */
 
+
 /* chain list of long jump buffers */
 struct lua_longjmp {
   struct lua_longjmp *previous;
@@ -41,23 +47,21 @@ struct lua_longjmp {
   volatile int status;                 /* error code */
 };
 
+
 static void
 seterrorobj(lua_State * L, int errcode, StkId oldtop)
 {
   switch (errcode) {
-  case LUA_ERRMEM:
-    {
+  case LUA_ERRMEM:{
       setsvalue2s(oldtop, luaS_new(L, MEMERRMSG));
       break;
     }
-  case LUA_ERRERR:
-    {
+  case LUA_ERRERR:{
       setsvalue2s(oldtop, luaS_new(L, "error in error handling"));
       break;
     }
   case LUA_ERRSYNTAX:
-  case LUA_ERRRUN:
-    {
+  case LUA_ERRRUN:{
       setobjs2s(oldtop, L->top - 1);    /* error message on current top */
       break;
     }
@@ -65,6 +69,7 @@ seterrorobj(lua_State * L, int errcode, StkId oldtop)
   L->top = oldtop + 1;
 }
 
+
 void
 luaD_throw(lua_State * L, int errcode)
 {
@@ -77,6 +82,7 @@ luaD_throw(lua_State * L, int errcode)
   }
 }
 
+
 int
 luaD_rawrunprotected(lua_State * L, Pfunc f, void *ud)
 {
@@ -90,6 +96,7 @@ luaD_rawrunprotected(lua_State * L, Pfunc f, void *ud)
   return lj.status;
 }
 
+
 static void
 restore_stack_limit(lua_State * L)
 {
@@ -103,6 +110,7 @@ restore_stack_limit(lua_State * L)
 
 /* }====================================================== */
 
+
 static void
 correctstack(lua_State * L, TObject * oldstack)
 {
@@ -118,6 +126,7 @@ correctstack(lua_State * L, TObject * oldstack)
   L->base = L->ci->base;
 }
 
+
 void
 luaD_reallocstack(lua_State * L, int newsize)
 {
@@ -128,6 +137,7 @@ luaD_reallocstack(lua_State * L, int newsize)
   correctstack(L, oldstack);
 }
 
+
 void
 luaD_reallocCI(lua_State * L, int newsize)
 {
@@ -138,6 +148,7 @@ luaD_reallocCI(lua_State * L, int newsize)
   L->end_ci = L->base_ci + L->size_ci;
 }
 
+
 void
 luaD_growstack(lua_State * L, int n)
 {
@@ -147,6 +158,7 @@ luaD_growstack(lua_State * L, int n)
     luaD_reallocstack(L, L->stacksize + n + EXTRA_STACK);
 }
 
+
 static void
 luaD_growCI(lua_State * L)
 {
@@ -159,6 +171,7 @@ luaD_growCI(lua_State * L)
   }
 }
 
+
 void
 luaD_callhook(lua_State * L, int event, int line)
 {
@@ -186,6 +199,7 @@ luaD_callhook(lua_State * L, int event, int line)
   }
 }
 
+
 static void
 adjust_varargs(lua_State * L, int nfixargs, StkId base)
 {
@@ -210,6 +224,7 @@ adjust_varargs(lua_State * L, int nfixargs, StkId base)
   incr_top(L);
 }
 
+
 static StkId
 tryfuncTM(lua_State * L, StkId func)
 {
@@ -227,6 +242,7 @@ tryfuncTM(lua_State * L, StkId func)
   return func;
 }
 
+
 StkId
 luaD_precall(lua_State * L, StkId func)
 {
@@ -275,6 +291,7 @@ luaD_precall(lua_State * L, StkId func)
   }
 }
 
+
 static StkId
 callrethooks(lua_State * L, StkId firstResult)
 {
@@ -287,6 +304,7 @@ callrethooks(lua_State * L, StkId firstResult)
   return restorestack(L, fr);
 }
 
+
 void
 luaD_poscall(lua_State * L, int wanted, StkId firstResult)
 {
@@ -306,6 +324,7 @@ luaD_poscall(lua_State * L, int wanted, StkId firstResult)
   L->top = res;
 }
 
+
 /*
 ** Call a function (C or Lua). The function to be called is at *func.
 ** The arguments are on the stack, right after the function.
@@ -331,6 +350,7 @@ luaD_call(lua_State * L, StkId func, int nResults)
   luaC_checkGC(L);
 }
 
+
 static void
 resume(lua_State * L, void *ud)
 {
@@ -360,6 +380,7 @@ resume(lua_State * L, void *ud)
     luaD_poscall(L, LUA_MULTRET, firstResult);  /* finalize this coroutine */
 }
 
+
 static int
 resume_error(lua_State * L, const char *msg)
 {
@@ -370,6 +391,7 @@ resume_error(lua_State * L, const char *msg)
   return LUA_ERRRUN;
 }
 
+
 LUA_API int
 lua_resume(lua_State * L, int nargs)
 {
@@ -397,6 +419,7 @@ lua_resume(lua_State * L, int nargs)
   return status;
 }
 
+
 LUA_API int
 lua_yield(lua_State * L, int nresults)
 {
@@ -420,6 +443,7 @@ lua_yield(lua_State * L, int nresults)
   return -1;
 }
 
+
 int
 luaD_pcall(lua_State * L, Pfunc func, void *u, ptrdiff_t old_top, ptrdiff_t ef)
 {
@@ -444,6 +468,8 @@ luaD_pcall(lua_State * L, Pfunc func, void *u, ptrdiff_t old_top, ptrdiff_t ef)
   return status;
 }
 
+
+
 /*
 ** Execute a protected parser.
 */
@@ -468,6 +494,7 @@ f_parser(lua_State * L, void *ud)
   incr_top(L);
 }
 
+
 int
 luaD_protectedparser(lua_State * L, ZIO * z, int bin)
 {
@@ -485,10 +512,3 @@ luaD_protectedparser(lua_State * L, ZIO * z, int bin)
   }
   return status;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 461d4ed..6d10698 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: ldo.h,v 1.56 2002/12/04 17:29:32 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -7,6 +8,7 @@
 #ifndef ldo_h
 #define ldo_h
 
+
 #include "lobject.h"
 #include "lstate.h"
 #include "lzio.h"
 #define condhardstacktests(x)  x
 #endif
 
+
 #define luaD_checkstack(L,n)   \
   if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TObject)) \
     luaD_growstack(L, n); \
   else condhardstacktests(luaD_reallocstack(L, L->stacksize));
 
+
 #define incr_top(L) {luaD_checkstack(L,1); L->top++;}
 
 #define savestack(L,p)         ((char *)(p) - (char *)L->stack)
@@ -35,6 +39,7 @@
 #define saveci(L,p)            ((char *)(p) - (char *)L->base_ci)
 #define restoreci(L,n)         ((CallInfo *)ARM_NOWARN_ALIGN((char *)L->base_ci + (n)))
 
+
 /* type of protected functions, to be ran by `runprotected' */
 typedef void (*Pfunc) (lua_State * L, void *ud);
 
@@ -52,11 +57,5 @@ void luaD_growstack(lua_State * L, int n);
 void luaD_throw(lua_State * L, int errcode) __attribute__ ((noreturn));
 int luaD_rawrunprotected(lua_State * L, Pfunc f, void *ud);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index f8e0bc3..0258957 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: ldump.c,v 1.4 2003/02/11 23:52:12 lhf Exp $
 ** save bytecodes
 ** See Copyright Notice in lua.h
 */
@@ -179,10 +180,3 @@ luaU_dump(lua_State * L, const Proto * Main, lua_Chunkwriter w, void *data)
   DumpHeader(&D);
   DumpFunction(Main, NULL, &D);
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 997339b..cae9520 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lfunc.c,v 1.67 2003/03/18 12:50:04 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdlib.h>
 
 #define lfunc_c
 #include "lobject.h"
 #include "lstate.h"
 
+
 #define sizeCclosure(n)        (cast(int, sizeof(CClosure)) + \
                          cast(int, sizeof(TObject)*((n)-1)))
 
 #define sizeLclosure(n)        (cast(int, sizeof(LClosure)) + \
                          cast(int, sizeof(TObject *)*((n)-1)))
 
+
+
 Closure *
 luaF_newCclosure(lua_State * L, int nelems)
 {
@@ -32,6 +37,7 @@ luaF_newCclosure(lua_State * L, int nelems)
   return c;
 }
 
+
 Closure *
 luaF_newLclosure(lua_State * L, int nelems, TObject * e)
 {
@@ -43,6 +49,7 @@ luaF_newLclosure(lua_State * L, int nelems, TObject * e)
   return c;
 }
 
+
 UpVal *
 luaF_findupval(lua_State * L, StkId level)
 {
@@ -63,6 +70,7 @@ luaF_findupval(lua_State * L, StkId level)
   return v;
 }
 
+
 void
 luaF_close(lua_State * L, StkId level)
 {
@@ -75,6 +83,7 @@ luaF_close(lua_State * L, StkId level)
   }
 }
 
+
 Proto *
 luaF_newproto(lua_State * L)
 {
@@ -101,6 +110,7 @@ luaF_newproto(lua_State * L)
   return f;
 }
 
+
 void
 luaF_freeproto(lua_State * L, Proto * f)
 {
@@ -113,6 +123,7 @@ luaF_freeproto(lua_State * L, Proto * f)
   luaM_freelem(L, f);
 }
 
+
 void
 luaF_freeclosure(lua_State * L, Closure * c)
 {
@@ -120,6 +131,7 @@ luaF_freeclosure(lua_State * L, Closure * c)
   luaM_free(L, c, size);
 }
 
+
 /*
 ** Look for n-th local variable at line `line' in function `func'.
 ** Returns NULL if not found.
@@ -137,10 +149,3 @@ luaF_getlocalname(const Proto * f, int local_number, int pc)
   }
   return NULL;                  /* not found */
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 166c46e..263d5f6 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lfunc.h,v 1.21 2003/03/18 12:50:04 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -7,8 +8,10 @@
 #ifndef lfunc_h
 #define lfunc_h
 
+
 #include "lobject.h"
 
+
 Proto *luaF_newproto(lua_State * L);
 Closure *luaF_newCclosure(lua_State * L, int nelems);
 Closure *luaF_newLclosure(lua_State * L, int nelems, TObject * e);
@@ -19,11 +22,5 @@ void luaF_freeclosure(lua_State * L, Closure * c);
 
 const char *luaF_getlocalname(const Proto * func, int local_number, int pc);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 684ec9e..b801666 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lgc.c,v 1.171a 2003/04/03 13:35:34 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -21,6 +22,7 @@
 #include "ltable.h"
 #include "ltm.h"
 
+
 typedef struct GCState {
   GCObject *tmark;                     /* list of marked objects to be traversed */
   GCObject *wk;                        /* list of traversed key-weak tables (to be cleared) */
@@ -29,6 +31,7 @@ typedef struct GCState {
   global_State *g;
 } GCState;
 
+
 /*
 ** some userful bit tricks
 */
@@ -41,14 +44,18 @@ typedef struct GCState {
 
 #define stringmark(s)  setbit((s)->tsv.marked, 0)
 
+
 #define isfinalized(u)         (!testbit((u)->uv.marked, 1))
 #define markfinalized(u)       resetbit((u)->uv.marked, 1)
 
+
 #define KEYWEAKBIT    1
 #define VALUEWEAKBIT  2
 #define KEYWEAK         (1<<KEYWEAKBIT)
 #define VALUEWEAK       (1<<VALUEWEAKBIT)
 
+
+
 #define markobject(st,o) { checkconsistency(o); \
   if (iscollectable(o) && !ismarked(gcvalue(o))) reallymarkobject(st,gcvalue(o)); }
 
@@ -59,37 +66,34 @@ typedef struct GCState {
 #define markvalue(st,t) { if (!ismarked(valtogco(t))) \
                reallymarkobject(st, valtogco(t)); }
 
+
+
 static void
 reallymarkobject(GCState * st, GCObject * o)
 {
   lua_assert(!ismarked(o));
   setbit(o->gch.marked, 0);     /* mark object */
   switch (o->gch.tt) {
-  case LUA_TUSERDATA:
-    {
+  case LUA_TUSERDATA:{
       markvalue(st, gcotou(o)->uv.metatable);
       break;
     }
-  case LUA_TFUNCTION:
-    {
+  case LUA_TFUNCTION:{
       gcotocl(o)->c.gclist = st->tmark;
       st->tmark = o;
       break;
     }
-  case LUA_TTABLE:
-    {
+  case LUA_TTABLE:{
       gcotoh(o)->gclist = st->tmark;
       st->tmark = o;
       break;
     }
-  case LUA_TTHREAD:
-    {
+  case LUA_TTHREAD:{
       gcototh(o)->gclist = st->tmark;
       st->tmark = o;
       break;
     }
-  case LUA_TPROTO:
-    {
+  case LUA_TPROTO:{
       gcotop(o)->gclist = st->tmark;
       st->tmark = o;
       break;
@@ -99,6 +103,7 @@ reallymarkobject(GCState * st, GCObject * o)
   }
 }
 
+
 static void
 marktmu(GCState * st)
 {
@@ -109,6 +114,7 @@ marktmu(GCState * st)
   }
 }
 
+
 /* move `dead' udata that need finalization to list `tmudata' */
 size_t
 luaC_separateudata(lua_State * L)
@@ -140,6 +146,7 @@ luaC_separateudata(lua_State * L)
   return deadmem;
 }
 
+
 static void
 removekey(Node * n)
 {
@@ -148,6 +155,7 @@ removekey(Node * n)
     setttype(gkey(n), LUA_TNONE);       /* dead key; remove it */
 }
 
+
 static void
 traversetable(GCState * st, Table * h)
 {
@@ -186,6 +194,7 @@ traversetable(GCState * st, Table * h)
   }
 }
 
+
 static void
 traverseproto(GCState * st, Proto * f)
 {
@@ -204,6 +213,8 @@ traverseproto(GCState * st, Proto * f)
   lua_assert(luaG_checkcode(f));
 }
 
+
+
 static void
 traverseclosure(GCState * st, Closure * cl)
 {
@@ -226,6 +237,7 @@ traverseclosure(GCState * st, Closure * cl)
   }
 }
 
+
 static void
 checkstacksizes(lua_State * L, StkId max)
 {
@@ -241,6 +253,7 @@ checkstacksizes(lua_State * L, StkId max)
     condhardstacktests(luaD_reallocstack(L, L->stacksize));
 }
 
+
 static void
 traversestack(GCState * st, lua_State * L1)
 {
@@ -261,34 +274,31 @@ traversestack(GCState * st, lua_State * L1)
   checkstacksizes(L1, lim);
 }
 
+
 static void
 propagatemarks(GCState * st)
 {
   while (st->tmark) {           /* traverse marked objects */
     switch (st->tmark->gch.tt) {
-    case LUA_TTABLE:
-      {
+    case LUA_TTABLE:{
         Table *h = gcotoh(st->tmark);
         st->tmark = h->gclist;
         traversetable(st, h);
         break;
       }
-    case LUA_TFUNCTION:
-      {
+    case LUA_TFUNCTION:{
         Closure *cl = gcotocl(st->tmark);
         st->tmark = cl->c.gclist;
         traverseclosure(st, cl);
         break;
       }
-    case LUA_TTHREAD:
-      {
+    case LUA_TTHREAD:{
         lua_State *th = gcototh(st->tmark);
         st->tmark = th->gclist;
         traversestack(st, th);
         break;
       }
-    case LUA_TPROTO:
-      {
+    case LUA_TPROTO:{
         Proto *p = gcotop(st->tmark);
         st->tmark = p->gclist;
         traverseproto(st, p);
@@ -300,6 +310,7 @@ propagatemarks(GCState * st)
   }
 }
 
+
 static int
 valismarked(const TObject * o)
 {
@@ -308,6 +319,7 @@ valismarked(const TObject * o)
   return !iscollectable(o) || testbit(o->value.gc->gch.marked, 0);
 }
 
+
 /*
 ** clear collected keys from weaktables
 */
@@ -327,6 +339,7 @@ cleartablekeys(GCObject * l)
   }
 }
 
+
 /*
 ** clear collected values from weaktables
 */
@@ -352,6 +365,7 @@ cleartablevalues(GCObject * l)
   }
 }
 
+
 static void
 freeobj(lua_State * L, GCObject * o)
 {
@@ -368,19 +382,16 @@ freeobj(lua_State * L, GCObject * o)
   case LUA_TTABLE:
     luaH_free(L, gcotoh(o));
     break;
-  case LUA_TTHREAD:
-    {
+  case LUA_TTHREAD:{
       lua_assert(gcototh(o) != L && gcototh(o) != G(L)->mainthread);
       luaE_freethread(L, gcototh(o));
       break;
     }
-  case LUA_TSTRING:
-    {
+  case LUA_TSTRING:{
       luaM_free(L, o, sizestring(gcotots(o)->tsv.len));
       break;
     }
-  case LUA_TUSERDATA:
-    {
+  case LUA_TUSERDATA:{
       luaM_free(L, o, sizeudata(gcotou(o)->uv.len));
       break;
     }
@@ -389,6 +400,7 @@ freeobj(lua_State * L, GCObject * o)
   }
 }
 
+
 static int
 sweeplist(lua_State * L, GCObject ** p, int limit)
 {
@@ -407,6 +419,7 @@ sweeplist(lua_State * L, GCObject ** p, int limit)
   return count;
 }
 
+
 static void
 sweepstrings(lua_State * L, int all)
 {
@@ -416,6 +429,7 @@ sweepstrings(lua_State * L, int all)
   }
 }
 
+
 static void
 checkSizes(lua_State * L, size_t deadmem)
 {
@@ -430,6 +444,7 @@ checkSizes(lua_State * L, size_t deadmem)
   G(L)->GCthreshold = 2 * G(L)->nblocks - deadmem;      /* new threshold */
 }
 
+
 static void
 do1gcTM(lua_State * L, Udata * udata)
 {
@@ -442,6 +457,7 @@ do1gcTM(lua_State * L, Udata * udata)
   }
 }
 
+
 void
 luaC_callGCTM(lua_State * L)
 {
@@ -463,6 +479,7 @@ luaC_callGCTM(lua_State * L)
   L->allowhook = oldah;         /* restore hooks */
 }
 
+
 void
 luaC_sweep(lua_State * L, int all)
 {
@@ -473,6 +490,7 @@ luaC_sweep(lua_State * L, int all)
   sweeplist(L, &G(L)->rootgc, all);
 }
 
+
 /* mark root set */
 static void
 markroot(GCState * st, lua_State * L)
@@ -485,6 +503,7 @@ markroot(GCState * st, lua_State * L)
     markvalue(st, L);           /* cannot collect it */
 }
 
+
 static size_t
 mark(lua_State * L)
 {
@@ -513,6 +532,7 @@ mark(lua_State * L)
   return deadmem;
 }
 
+
 void
 luaC_collectgarbage(lua_State * L)
 {
@@ -522,6 +542,7 @@ luaC_collectgarbage(lua_State * L)
   luaC_callGCTM(L);
 }
 
+
 void
 luaC_link(lua_State * L, GCObject * o, lu_byte tt)
 {
@@ -530,10 +551,3 @@ luaC_link(lua_State * L, GCObject * o, lu_byte tt)
   o->gch.marked = 0;
   o->gch.tt = tt;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 6730d33..d3ad6a5 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lgc.h,v 1.19a 2003/02/28 19:45:15 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -7,22 +8,19 @@
 #ifndef lgc_h
 #define lgc_h
 
+
 #include "lobject.h"
 
+
 #define luaC_checkGC(L) { lua_assert(!(L->ci->state & CI_CALLING)); \
        if (G(L)->nblocks >= G(L)->GCthreshold) luaC_collectgarbage(L); }
 
+
 size_t luaC_separateudata(lua_State * L);
 void luaC_callGCTM(lua_State * L);
 void luaC_sweep(lua_State * L, int all);
 void luaC_collectgarbage(lua_State * L);
 void luaC_link(lua_State * L, GCObject * o, lu_byte tt);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 8606880..013b06a 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: liolib.c,v 2.39a 2003/03/19 21:16:12 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
 
+
 #include <errno.h>
 #include <locale.h>
 #include <stdio.h>
@@ -18,6 +20,8 @@
 #include "lauxlib.h"
 #include "lualib.h"
 
+
+
 /*
 ** by default, gcc does not get `tmpname'
 */
@@ -29,6 +33,7 @@
 #endif
 #endif
 
+
 /*
 ** by default, posix systems get `popen'
 */
@@ -44,6 +49,8 @@
 #define USE_POPEN      0
 #endif
 
+
+
 static int io_exit(lua_State * L) __attribute__ ((noreturn));
 
 /*
@@ -52,15 +59,18 @@ static int io_exit(lua_State * L) __attribute__ ((noreturn));
 ** =======================================================
 */
 
+
 #if !USE_POPEN
 #define pclose(f)    (-1)
 #endif
 
+
 #define FILEHANDLE             "FILE*"
 
 #define IO_INPUT               "_input"
 #define IO_OUTPUT              "_output"
 
+
 static int
 pushresult(lua_State * L, int i, const char *filename)
 {
@@ -78,6 +88,7 @@ pushresult(lua_State * L, int i, const char *filename)
   }
 }
 
+
 static FILE **
 topfile(lua_State * L, int findex)
 {
@@ -87,6 +98,7 @@ topfile(lua_State * L, int findex)
   return f;
 }
 
+
 static int
 io_type(lua_State * L)
 {
@@ -100,6 +112,7 @@ io_type(lua_State * L)
   return 1;
 }
 
+
 static FILE *
 tofile(lua_State * L, int findex)
 {
@@ -109,6 +122,8 @@ tofile(lua_State * L, int findex)
   return *f;
 }
 
+
+
 /*
 ** When creating file handles, always creates a `closed' file handle
 ** before opening the actual file; so, if there is a memory error, the
@@ -124,6 +139,7 @@ newfile(lua_State * L)
   return pf;
 }
 
+
 /*
 ** assumes that top of the stack is the `io' library, and next is
 ** the `io' metatable
@@ -141,6 +157,7 @@ registerfile(lua_State * L, FILE * f, const char *name, const char *impname)
   lua_settable(L, -3);          /* io[name] = file */
 }
 
+
 static int
 aux_close(lua_State * L)
 {
@@ -155,6 +172,7 @@ aux_close(lua_State * L)
   }
 }
 
+
 static int
 io_close(lua_State * L)
 {
@@ -165,6 +183,7 @@ io_close(lua_State * L)
   return pushresult(L, aux_close(L), NULL);
 }
 
+
 static int
 io_gc(lua_State * L)
 {
@@ -174,6 +193,7 @@ io_gc(lua_State * L)
   return 0;
 }
 
+
 static int
 io_tostring(lua_State * L)
 {
@@ -187,6 +207,7 @@ io_tostring(lua_State * L)
   return 1;
 }
 
+
 static int
 io_open(lua_State * L)
 {
@@ -197,6 +218,7 @@ io_open(lua_State * L)
   return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
 }
 
+
 static int
 io_popen(lua_State * L)
 {
@@ -212,6 +234,7 @@ io_popen(lua_State * L)
 #endif
 }
 
+
 static int
 io_tmpfile(lua_State * L)
 {
@@ -220,6 +243,7 @@ io_tmpfile(lua_State * L)
   return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
 }
 
+
 static FILE *
 getiofile(lua_State * L, const char *name)
 {
@@ -228,6 +252,7 @@ getiofile(lua_State * L, const char *name)
   return tofile(L, -1);
 }
 
+
 static int
 g_iofile(lua_State * L, const char *name, const char *mode)
 {
@@ -253,20 +278,24 @@ g_iofile(lua_State * L, const char *name, const char *mode)
   return 1;
 }
 
+
 static int
 io_input(lua_State * L)
 {
   return g_iofile(L, IO_INPUT, "r");
 }
 
+
 static int
 io_output(lua_State * L)
 {
   return g_iofile(L, IO_OUTPUT, "w");
 }
 
+
 static int io_readline(lua_State * L);
 
+
 static void
 aux_lines(lua_State * L, int idx, int close)
 {
@@ -277,6 +306,7 @@ aux_lines(lua_State * L, int idx, int close)
   lua_pushcclosure(L, io_readline, 3);
 }
 
+
 static int
 f_lines(lua_State * L)
 {
@@ -285,6 +315,7 @@ f_lines(lua_State * L)
   return 1;
 }
 
+
 static int
 io_lines(lua_State * L)
 {
@@ -302,12 +333,14 @@ io_lines(lua_State * L)
   }
 }
 
+
 /*
 ** {======================================================
 ** READ
 ** =======================================================
 */
 
+
 static int
 read_number(lua_State * L, FILE * f)
 {
@@ -319,6 +352,7 @@ read_number(lua_State * L, FILE * f)
     return 0;                   /* read fails */
 }
 
+
 static int
 test_eof(lua_State * L, FILE * f)
 {
@@ -328,6 +362,7 @@ test_eof(lua_State * L, FILE * f)
   return (c != EOF);
 }
 
+
 static int
 read_line(lua_State * L, FILE * f)
 {
@@ -351,6 +386,7 @@ read_line(lua_State * L, FILE * f)
   }
 }
 
+
 static int
 read_chars(lua_State * L, FILE * f, size_t n)
 {
@@ -366,12 +402,12 @@ read_chars(lua_State * L, FILE * f, size_t n)
     nr = fread(p, sizeof(char), rlen, f);
     luaL_addsize(&b, nr);
     n -= nr;                    /* still have to read `n' chars */
-  }
-  while (n > 0 && nr == rlen);  /* until end of count or eof */
+  } while (n > 0 && nr == rlen);        /* until end of count or eof */
   luaL_pushresult(&b);          /* close buffer */
   return (n == 0 || lua_strlen(L, -1) > 0);
 }
 
+
 static int
 g_read(lua_State * L, FILE * f, int first)
 {
@@ -417,18 +453,21 @@ g_read(lua_State * L, FILE * f, int first)
   return n - first;
 }
 
+
 static int
 io_read(lua_State * L)
 {
   return g_read(L, getiofile(L, IO_INPUT), 1);
 }
 
+
 static int
 f_read(lua_State * L)
 {
   return g_read(L, tofile(L, 1), 2);
 }
 
+
 static int
 io_readline(lua_State * L)
 {
@@ -449,6 +488,7 @@ io_readline(lua_State * L)
 
 /* }====================================================== */
 
+
 static int
 g_write(lua_State * L, FILE * f, int arg)
 {
@@ -467,18 +507,21 @@ g_write(lua_State * L, FILE * f, int arg)
   return pushresult(L, status, NULL);
 }
 
+
 static int
 io_write(lua_State * L)
 {
   return g_write(L, getiofile(L, IO_OUTPUT), 1);
 }
 
+
 static int
 f_write(lua_State * L)
 {
   return g_write(L, tofile(L, 1), 2);
 }
 
+
 static int
 f_seek(lua_State * L)
 {
@@ -497,18 +540,21 @@ f_seek(lua_State * L)
   }
 }
 
+
 static int
 io_flush(lua_State * L)
 {
   return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
 }
 
+
 static int
 f_flush(lua_State * L)
 {
   return pushresult(L, fflush(tofile(L, 1)) == 0, NULL);
 }
 
+
 static const luaL_reg iolib[] = {
   {"input", io_input},
   {"output", io_output},
@@ -524,6 +570,7 @@ static const luaL_reg iolib[] = {
   {NULL, NULL}
 };
 
+
 static const luaL_reg flib[] = {
   {"flush", f_flush},
   {"read", f_read},
@@ -536,6 +583,7 @@ static const luaL_reg flib[] = {
   {NULL, NULL}
 };
 
+
 static void
 createmeta(lua_State * L)
 {
@@ -549,6 +597,7 @@ createmeta(lua_State * L)
 
 /* }====================================================== */
 
+
 /*
 ** {======================================================
 ** Other O.S. Operations
@@ -562,6 +611,7 @@ io_execute(lua_State * L)
   return 1;
 }
 
+
 static int
 io_remove(lua_State * L)
 {
@@ -569,6 +619,7 @@ io_remove(lua_State * L)
   return pushresult(L, remove(filename) == 0, filename);
 }
 
+
 static int
 io_rename(lua_State * L)
 {
@@ -577,6 +628,7 @@ io_rename(lua_State * L)
   return pushresult(L, rename(fromname, toname) == 0, fromname);
 }
 
+
 #if !USE_TMPNAME
 static int io_tmpname(lua_State * L) __attribute__ ((noreturn));
 #else
@@ -597,6 +649,7 @@ io_tmpname(lua_State * L)
 #endif
 }
 
+
 static int
 io_getenv(lua_State * L)
 {
@@ -604,6 +657,7 @@ io_getenv(lua_State * L)
   return 1;
 }
 
+
 static int
 io_clock(lua_State * L)
 {
@@ -611,6 +665,7 @@ io_clock(lua_State * L)
   return 1;
 }
 
+
 /*
 ** {======================================================
 ** Time/Date operations
@@ -646,6 +701,7 @@ getboolfield(lua_State * L, const char *key)
   return res;
 }
 
+
 static int
 getfield(lua_State * L, const char *key, int d)
 {
@@ -663,6 +719,7 @@ getfield(lua_State * L, const char *key, int d)
   return res;
 }
 
+
 static int
 io_date(lua_State * L)
 {
@@ -699,6 +756,7 @@ io_date(lua_State * L)
   return 1;
 }
 
+
 static int
 io_time(lua_State * L)
 {
@@ -725,6 +783,7 @@ io_time(lua_State * L)
   return 1;
 }
 
+
 static int
 io_difftime(lua_State * L)
 {
@@ -734,6 +793,7 @@ io_difftime(lua_State * L)
 
 /* }====================================================== */
 
+
 static int
 io_setloc(lua_State * L)
 {
@@ -751,6 +811,7 @@ io_setloc(lua_State * L)
   return 1;
 }
 
+
 static int
 io_exit(lua_State * L)
 {
@@ -774,6 +835,8 @@ static const luaL_reg syslib[] = {
 
 /* }====================================================== */
 
+
+
 LUALIB_API int
 luaopen_io(lua_State * L)
 {
@@ -787,10 +850,3 @@ luaopen_io(lua_State * L)
   registerfile(L, stderr, "stderr", NULL);
   return 1;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 24e460e..768ea98 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: llex.c,v 1.119 2003/03/24 12:39:34 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 
+
 #include <ctype.h>
 #include <string.h>
 
 #include "lstring.h"
 #include "lzio.h"
 
+
+
 #define next(LS) (LS->current = zgetc(LS->z))
 
 static void luaX_error(LexState * ls, const char *s, const char *token) __attribute__ ((noreturn));
 static void luaX_lexerror(LexState * ls, const char *s, int token) __attribute__ ((noreturn));
 
+
 /* ORDER RESERVED */
 static const char *const token2string[] = {
   "and", "break", "do", "else", "elseif",
@@ -34,6 +39,7 @@ static const char *const token2string[] = {
   "*number", "*string", "<eof>"
 };
 
+
 void
 luaX_init(lua_State * L)
 {
@@ -46,8 +52,10 @@ luaX_init(lua_State * L)
   }
 }
 
+
 #define MAXSRC          80
 
+
 void
 luaX_checklimit(LexState * ls, int val, int limit, const char *msg)
 {
@@ -57,6 +65,7 @@ luaX_checklimit(LexState * ls, int val, int limit, const char *msg)
   }
 }
 
+
 void
 luaX_errorline(LexState * ls, const char *s, const char *token, int line)
 {
@@ -67,12 +76,14 @@ luaX_errorline(LexState * ls, const char *s, const char *token, int line)
   luaD_throw(L, LUA_ERRSYNTAX);
 }
 
+
 static void
 luaX_error(LexState * ls, const char *s, const char *token)
 {
   luaX_errorline(ls, s, token, ls->linenumber);
 }
 
+
 void
 luaX_syntaxerror(LexState * ls, const char *msg)
 {
@@ -92,6 +103,7 @@ luaX_syntaxerror(LexState * ls, const char *msg)
   luaX_error(ls, msg, lasttoken);
 }
 
+
 const char *
 luaX_token2str(LexState * ls, int token)
 {
@@ -102,6 +114,7 @@ luaX_token2str(LexState * ls, int token)
     return token2string[token - FIRST_RESERVED];
 }
 
+
 static void
 luaX_lexerror(LexState * ls, const char *s, int token)
 {
@@ -111,6 +124,7 @@ luaX_lexerror(LexState * ls, const char *s, int token)
     luaX_error(ls, s, luaZ_buffer(ls->buff));
 }
 
+
 static void
 inclinenumber(LexState * LS)
 {
@@ -119,6 +133,7 @@ inclinenumber(LexState * LS)
   luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk");
 }
 
+
 void
 luaX_setinput(lua_State * L, LexState * LS, ZIO * z, TString * source)
 {
@@ -133,17 +148,19 @@ luaX_setinput(lua_State * L, LexState * LS, ZIO * z, TString * source)
   if (LS->current == '#') {
     do {                        /* skip first line */
       next(LS);
-    }
-    while (LS->current != '\n' && LS->current != EOZ);
+    } while (LS->current != '\n' && LS->current != EOZ);
   }
 }
 
+
+
 /*
 ** =======================================================
 ** LEXICAL ANALYZER
 ** =======================================================
 */
 
+
 /* use buffer to store names, literal strings and numbers */
 
 /* extra space to allocate when growing buffer */
@@ -160,6 +177,7 @@ luaX_setinput(lua_State * L, LexState * LS, ZIO * z, TString * source)
        (luaZ_buffer((LS)->buff)[l++] = cast(char, c))
 #define save_and_next(LS, l)  (save(LS, LS->current, l), next(LS))
 
+
 static size_t
 readname(LexState * LS)
 {
@@ -168,12 +186,12 @@ readname(LexState * LS)
   do {
     checkbuffer(LS, l);
     save_and_next(LS, l);
-  }
-  while (isalnum(LS->current) || LS->current == '_');
+  } while (isalnum(LS->current) || LS->current == '_');
   save(LS, '\0', l);
   return l - 1;
 }
 
+
 /* LUA_NUMBER */
 static void
 read_numeral(LexState * LS, int comma, SemInfo * seminfo)
@@ -212,6 +230,7 @@ read_numeral(LexState * LS, int comma, SemInfo * seminfo)
     luaX_lexerror(LS, "malformed number", TK_NUMBER);
 }
 
+
 static void
 read_long_string(LexState * LS, SemInfo * seminfo)
 {
@@ -262,6 +281,7 @@ endloop:
     seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 2, l - 5);
 }
 
+
 static void
 read_string(LexState * LS, int del, SemInfo * seminfo)
 {
@@ -316,8 +336,7 @@ read_string(LexState * LS, int del, SemInfo * seminfo)
         break;
       case EOZ:
         break;                  /* will raise an error next loop */
-      default:
-        {
+      default:{
           if (!isdigit(LS->current))
             save_and_next(LS, l);       /* handles \\, \", \', and \? */
           else {                /* \xxx */
@@ -326,8 +345,7 @@ read_string(LexState * LS, int del, SemInfo * seminfo)
             do {
               c = 10 * c + (LS->current - '0');
               next(LS);
-            }
-            while (++i < 3 && isdigit(LS->current));
+            } while (++i < 3 && isdigit(LS->current));
             if (c > UCHAR_MAX) {
               save(LS, '\0', l);
               luaX_lexerror(LS, "escape sequence too large", TK_STRING);
@@ -346,19 +364,18 @@ read_string(LexState * LS, int del, SemInfo * seminfo)
   seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 1, l - 3);
 }
 
+
 int
 luaX_lex(LexState * LS, SemInfo * seminfo)
 {
   for (;;) {
     switch (LS->current) {
 
-    case '\n':
-      {
+    case '\n':{
         inclinenumber(LS);
         continue;
       }
-    case '-':
-      {
+    case '-':{
         next(LS);
         if (LS->current != '-')
           return '-';
@@ -371,8 +388,7 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
             next(LS);
         continue;
       }
-    case '[':
-      {
+    case '[':{
         next(LS);
         if (LS->current != '[')
           return '[';
@@ -381,8 +397,7 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
           return TK_STRING;
         }
       }
-    case '=':
-      {
+    case '=':{
         next(LS);
         if (LS->current != '=')
           return '=';
@@ -391,8 +406,7 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
           return TK_EQ;
         }
       }
-    case '<':
-      {
+    case '<':{
         next(LS);
         if (LS->current != '=')
           return '<';
@@ -401,8 +415,7 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
           return TK_LE;
         }
       }
-    case '>':
-      {
+    case '>':{
         next(LS);
         if (LS->current != '=')
           return '>';
@@ -411,8 +424,7 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
           return TK_GE;
         }
       }
-    case '~':
-      {
+    case '~':{
         next(LS);
         if (LS->current != '=')
           return '~';
@@ -422,13 +434,11 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
         }
       }
     case '"':
-    case '\'':
-      {
+    case '\'':{
         read_string(LS, LS->current, seminfo);
         return TK_STRING;
       }
-    case '.':
-      {
+    case '.':{
         next(LS);
         if (LS->current == '.') {
           next(LS);
@@ -444,12 +454,10 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
           return TK_NUMBER;
         }
       }
-    case EOZ:
-      {
+    case EOZ:{
         return TK_EOS;
       }
-    default:
-      {
+    default:{
         if (isspace(LS->current)) {
           next(LS);
           continue;
@@ -477,10 +485,3 @@ luaX_lex(LexState * LS, SemInfo * seminfo)
 }
 
 #undef next
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index efa68b5..fa22f01 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: llex.h,v 1.47 2003/02/28 17:19:47 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
 #include "lobject.h"
 #include "lzio.h"
 
+
 #define FIRST_RESERVED 257
 
 /* maximum length of a reserved word */
 #define TOKEN_LEN      (sizeof("function")/sizeof(char))
 
+
 /*
 * WARNING: if you change the order of this enumeration,
 * grep "ORDER RESERVED"
@@ -33,16 +36,19 @@ enum RESERVED {
 /* number of reserved words */
 #define NUM_RESERVED   (cast(int, TK_WHILE-FIRST_RESERVED+1))
 
+
 typedef union {
   lua_Number r;
   TString *ts;
 } SemInfo;                             /* semantics information */
 
+
 typedef struct Token {
   int token;
   SemInfo seminfo;
 } Token;
 
+
 typedef struct LexState {
   int current;                         /* current character (charint) */
   int linenumber;                      /* input line counter */
@@ -57,6 +63,7 @@ typedef struct LexState {
   int nestlevel;                       /* level of nested non-terminals */
 } LexState;
 
+
 void luaX_init(lua_State * L);
 void luaX_setinput(lua_State * L, LexState * LS, ZIO * z, TString * source);
 int luaX_lex(LexState * LS, SemInfo * seminfo);
@@ -65,11 +72,5 @@ void luaX_syntaxerror(LexState * ls, const char *s) __attribute__ ((noreturn));
 void luaX_errorline(LexState * ls, const char *s, const char *token, int line) __attribute__ ((noreturn));
 const char *luaX_token2str(LexState * ls, int token);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 958700b..5b38c61 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: llimits.h,v 1.52 2003/02/20 19:33:23 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
@@ -7,12 +8,15 @@
 #ifndef llimits_h
 #define llimits_h
 
+
 #include <limits.h>
 #include <stddef.h>
 
+
 #include "lua.h"
 #include "defs.h"               /* ARM_NOWARN_ALIGN */
 
+
 /*
 ** try to find number of bits in an integer
 */
@@ -32,6 +36,7 @@
 #endif
 #endif
 
+
 /*
 ** the following types define integer types for values that may not
 ** fit in a `small int' (16 bits), but may waste space in a
@@ -52,14 +57,17 @@ typedef unsigned long lu_mem;
 
 #define MAX_LUMEM      ULONG_MAX
 
+
 /* an integer big enough to count the number of strings in use */
 typedef long ls_nstr;
 
 /* chars used as small naturals (so that `char' is reserved for characters) */
 typedef unsigned char lu_byte;
 
+
 #define MAX_SIZET      ((size_t)(~(size_t)0)-2)
 
+
 #define MAX_INT (INT_MAX-2)     /* maximum value of an int (-2 for safety) */
 
 /*
@@ -69,6 +77,8 @@ typedef unsigned char lu_byte;
 */
 #define IntPoint(p)  ((lu_hash)(p))
 
+
+
 /* type to ensure maximum alignment */
 #ifndef LUSER_ALIGNMENT_T
 typedef union {
@@ -80,6 +90,7 @@ typedef union {
 typedef LUSER_ALIGNMENT_T L_Umaxalign;
 #endif
 
+
 /* result of `usual argument conversion' over lua_Number */
 #ifndef LUA_UACNUMBER
 typedef double l_uacNumber;
@@ -87,18 +98,22 @@ typedef double l_uacNumber;
 typedef LUA_UACNUMBER l_uacNumber;
 #endif
 
+
 #ifndef lua_assert
 #define lua_assert(c)           /* empty */
 #endif
 
+
 #ifndef check_exp
 #define check_exp(c,e) (e)
 #endif
 
+
 #ifndef UNUSED
 #define UNUSED(x)      ((void)(x))     /* to avoid warnings */
 #endif
 
+
 #ifndef cast
 #define cast(t, exp)   ((t)(exp))
 #endif
@@ -107,17 +122,20 @@ typedef LUA_UACNUMBER l_uacNumber;
 #define cast_align(t, exp)     ((t)ARM_NOWARN_ALIGN(exp))
 #endif
 
+
 /*
 ** type for virtual-machine instructions
 ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
 */
 typedef unsigned long Instruction;
 
+
 /* maximum depth for calls (unsigned short) */
 #ifndef LUA_MAXCALLS
 #define LUA_MAXCALLS        4096
 #endif
 
+
 /*
 ** maximum depth for C calls (unsigned short): Not too big, or may
 ** overflow the C stack...
@@ -127,39 +145,47 @@ typedef unsigned long Instruction;
 #define LUA_MAXCCALLS        200
 #endif
 
+
 /* maximum size for the C stack */
 #ifndef LUA_MAXCSTACK
 #define LUA_MAXCSTACK        2048
 #endif
 
+
 /* maximum stack for a Lua function */
 #define MAXSTACK       250
 
+
 /* maximum number of variables declared in a function */
 #ifndef MAXVARS
 #define MAXVARS 200             /* arbitrary limit (<MAXSTACK) */
 #endif
 
+
 /* maximum number of upvalues per function */
 #ifndef MAXUPVALUES
 #define MAXUPVALUES    32
 #endif
 
+
 /* maximum number of parameters in a function */
 #ifndef MAXPARAMS
 #define MAXPARAMS 100           /* arbitrary limit (<MAXLOCALS) */
 #endif
 
+
 /* minimum size for the string table (must be power of 2) */
 #ifndef MINSTRTABSIZE
 #define MINSTRTABSIZE  32
 #endif
 
+
 /* minimum size for string buffer */
 #ifndef LUA_MINBUFFER
 #define LUA_MINBUFFER  32
 #endif
 
+
 /*
 ** maximum number of syntactical nested non-terminals: Not too big,
 ** or may overflow the C stack...
@@ -168,11 +194,5 @@ typedef unsigned long Instruction;
 #define LUA_MAXPARSERLEVEL     200
 #endif
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 7cfa36e..ac3a869 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lmathlib.c,v 1.56 2003/03/11 12:30:37 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdlib.h>
 #include <math.h>
 
 #include "lauxlib.h"
 #include "lualib.h"
 
+
 #undef PI
 #define PI (3.14159265358979323846)
 #define RADIANS_PER_DEGREE (PI/180.0)
 
+
+
 /*
 ** If you want Lua to operate in degrees (instead of radians),
 ** define USE_DEGREES
@@ -30,6 +35,7 @@
 #define TORAD(a)       (a)
 #endif
 
+
 static int
 math_abs(lua_State * L)
 {
@@ -172,6 +178,8 @@ math_ldexp(lua_State * L)
   return 1;
 }
 
+
+
 static int
 math_min(lua_State * L)
 {
@@ -187,6 +195,7 @@ math_min(lua_State * L)
   return 1;
 }
 
+
 static int
 math_max(lua_State * L)
 {
@@ -202,6 +211,7 @@ math_max(lua_State * L)
   return 1;
 }
 
+
 static int
 math_random(lua_State * L)
 {
@@ -209,20 +219,17 @@ math_random(lua_State * L)
      some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
   lua_Number r = (lua_Number) (rand() % RAND_MAX) / (lua_Number) RAND_MAX;
   switch (lua_gettop(L)) {      /* check number of arguments */
-  case 0:
-    {                           /* no arguments */
+  case 0:{                     /* no arguments */
       lua_pushnumber(L, r);     /* Number between 0 and 1 */
       break;
     }
-  case 1:
-    {                           /* only upper limit */
+  case 1:{                     /* only upper limit */
       int u = luaL_checkint(L, 1);
       luaL_argcheck(L, 1 <= u, 1, "interval is empty");
       lua_pushnumber(L, floor(r * u) + 1);      /* int between 1 and `u' */
       break;
     }
-  case 2:
-    {                           /* lower and upper limits */
+  case 2:{                     /* lower and upper limits */
       int l = luaL_checkint(L, 1);
       int u = luaL_checkint(L, 2);
       luaL_argcheck(L, l <= u, 2, "interval is empty");
@@ -235,6 +242,7 @@ math_random(lua_State * L)
   return 1;
 }
 
+
 static int
 math_randomseed(lua_State * L)
 {
@@ -242,6 +250,7 @@ math_randomseed(lua_State * L)
   return 0;
 }
 
+
 static const luaL_reg mathlib[] = {
   {"abs", math_abs},
   {"sin", math_sin},
@@ -270,6 +279,7 @@ static const luaL_reg mathlib[] = {
   {NULL, NULL}
 };
 
+
 /*
 ** Open math library
 */
@@ -285,10 +295,3 @@ luaopen_math(lua_State * L)
   lua_settable(L, LUA_GLOBALSINDEX);
   return 1;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 7a32710..60b41f9 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lmem.c,v 1.61 2002/12/04 17:38:31 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdlib.h>
 
 #define lmem_c
@@ -16,6 +18,8 @@
 #include "lobject.h"
 #include "lstate.h"
 
+
+
 /*
 ** definition for realloc function. It must assure that l_realloc(NULL,
 ** 0, x) allocates a new block (ANSI C assures that). (`os' is the old
 #define l_free(b,os)   free(b)
 #endif
 
+
 #define MINSIZEARRAY   4
 
+
 void *
 luaM_growaux(lua_State * L, void *block, int *size, int size_elems, int limit, const char *errormsg)
 {
@@ -48,12 +54,13 @@ luaM_growaux(lua_State * L, void *block, int *size, int size_elems, int limit, c
     else
       luaG_runerror(L, errormsg);
   }
-  newblock =
-    luaM_realloc(L, block, cast(lu_mem, *size) * cast(lu_mem, size_elems), cast(lu_mem, newsize) * cast(lu_mem, size_elems));
+  newblock = luaM_realloc(L, block,
+                          cast(lu_mem, *size) * cast(lu_mem, size_elems), cast(lu_mem, newsize) * cast(lu_mem, size_elems));
   *size = newsize;              /* update only when everything else is OK */
   return newblock;
 }
 
+
 /*
 ** generic allocation routine.
 */
@@ -85,10 +92,3 @@ luaM_realloc(lua_State * L, void *block, lu_mem oldsize, lu_mem size)
   }
   return block;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index ca01a61..581fce9 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lmem.h,v 1.26 2002/05/01 20:40:42 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -7,6 +8,7 @@
 #ifndef lmem_h
 #define lmem_h
 
+
 #include <stddef.h>
 
 #include "llimits.h"
@@ -14,6 +16,7 @@
 
 #define MEMERRMSG      "not enough memory"
 
+
 void *luaM_realloc(lua_State * L, void *oldblock, lu_mem oldsize, lu_mem size);
 
 void *luaM_growaux(lua_State * L, void *block, int *size, int size_elem, int limit, const char *errormsg);
@@ -36,11 +39,5 @@ void *luaM_growaux(lua_State * L, void *block, int *size, int size_elem, int lim
    ((v)=cast(t *, luaM_realloc(L, v,cast(lu_mem, oldn)*cast(lu_mem, sizeof(t)), \
                                     cast(lu_mem, n)*cast(lu_mem, sizeof(t)))))
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 1958581..6a68e83 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: loadlib.c,v 1.4 2003/04/07 20:11:53 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 *
 #include "lauxlib.h"
 #include "lualib.h"
 
+
 #undef LOADLIB
 
+
 #ifdef USE_DLOPEN
 #define LOADLIB
 
@@ -69,6 +72,8 @@ loadlib(lua_State * L)
 
 #endif
 
+
+
 /*
 ** In Windows, default is to use dll; otherwise, default is not to use dll
 */
@@ -80,6 +85,7 @@ loadlib(lua_State * L)
 #endif
 #endif
 
+
 #if USE_DLL
 #define LOADLIB
 
@@ -124,6 +130,8 @@ loadlib(lua_State * L)
 
 #endif
 
+
+
 #ifndef LOADLIB
 
 /* Fallback for other systems */
@@ -201,10 +209,3 @@ luaopen_loadlib(lua_State * L)
 * http://cvs.gnome.org/lxr/source/glib/gmodule/
 *
 */
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 90aa8e5..9875965 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lobject.c,v 1.97 2003/04/03 13:35:34 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
 #include "lstring.h"
 #include "lvm.h"
 
+
 /* function to convert a string to a lua_Number */
 #ifndef lua_str2number
 #define lua_str2number(s,p)     strtod((s), (p))
 #endif
 
+
 const TObject luaO_nilobject = { LUA_TNIL, {NULL} };
 
+
 /*
 ** converts an integer to a "floating point byte", represented as
 ** (mmmmmxxx), where the real value is (xxx) * 2^(mmmmm)
@@ -42,10 +46,9 @@ luaO_int2fb(unsigned int x)
   return (m << 3) | cast(int, x);
 }
 
+
 /* *INDENT-OFF* */
-int
-luaO_log2(unsigned int x)
-{
+int luaO_log2 (unsigned int x) {
   static const lu_byte log_8[255] = {
     0,
     1,1,
@@ -61,20 +64,18 @@ luaO_log2(unsigned int x)
     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
   };
   if (x >= 0x00010000) {
-    if (x >= 0x01000000)
-      return log_8[((x >> 24) & 0xff) - 1] + 24;
-    else
-      return log_8[((x >> 16) & 0xff) - 1] + 16;
-  } else {
-    if (x >= 0x00000100)
-      return log_8[((x >> 8) & 0xff) - 1] + 8;
-    else if (x)
-      return log_8[(x & 0xff) - 1];
-    return -1;                  /* special `log' for 0 */
+    if (x >= 0x01000000) return log_8[((x>>24) & 0xff) - 1]+24;
+    else return log_8[((x>>16) & 0xff) - 1]+16;
+  }
+  else {
+    if (x >= 0x00000100) return log_8[((x>>8) & 0xff) - 1]+8;
+    else if (x) return log_8[(x & 0xff) - 1];
+    return -1;  /* special `log' for 0 */
   }
 }
 /* *INDENT-ON* */
 
+
 int
 luaO_rawequalObj(const TObject * t1, const TObject * t2)
 {
@@ -96,6 +97,7 @@ luaO_rawequalObj(const TObject * t1, const TObject * t2)
     }
 }
 
+
 int
 luaO_str2d(const char *s, lua_Number * result)
 {
@@ -111,6 +113,8 @@ luaO_str2d(const char *s, lua_Number * result)
   return 1;
 }
 
+
+
 static void
 pushstr(lua_State * L, const char *str)
 {
@@ -118,6 +122,7 @@ pushstr(lua_State * L, const char *str)
   incr_top(L);
 }
 
+
 /* this function handles only `%d', `%c', %f, and `%s' formats */
 const char *
 luaO_pushvfstring(lua_State * L, const char *fmt, va_list argp)
@@ -134,8 +139,7 @@ luaO_pushvfstring(lua_State * L, const char *fmt, va_list argp)
     case 's':
       pushstr(L, va_arg(argp, char *));
       break;
-    case 'c':
-      {
+    case 'c':{
         char buff[2];
         buff[0] = cast(char, va_arg(argp, int));
         buff[1] = '\0';
@@ -165,6 +169,7 @@ luaO_pushvfstring(lua_State * L, const char *fmt, va_list argp)
   return svalue(L->top - 1);
 }
 
+
 const char *
 luaO_pushfstring(lua_State * L, const char *fmt, ...)
 {
@@ -176,6 +181,7 @@ luaO_pushfstring(lua_State * L, const char *fmt, ...)
   return msg;
 }
 
+
 void
 luaO_chunkid(char *out, const char *source, int bufflen)
 {
@@ -209,10 +215,3 @@ luaO_chunkid(char *out, const char *source, int bufflen)
     }
   }
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index b0aa841..a4ac402 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lobject.h,v 1.159 2003/03/18 12:50:04 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -7,29 +8,35 @@
 #ifndef lobject_h
 #define lobject_h
 
+
 #include "llimits.h"
 #include "lua.h"
 
+
 /* tags for values visible from Lua */
 #define NUM_TAGS       LUA_TTHREAD
 
+
 /*
 ** Extra tags for non-values
 */
 #define LUA_TPROTO     (NUM_TAGS+1)
 #define LUA_TUPVAL     (NUM_TAGS+2)
 
+
 /*
 ** Union of all collectable objects
 */
 typedef union GCObject GCObject;
 
+
 /*
 ** Common Header for all collectable objects (in macro form, to be
 ** included in other objects)
 */
 #define CommonHeader   GCObject *next; lu_byte tt; lu_byte marked
 
+
 /*
 ** Common header in struct form
 */
@@ -37,6 +44,9 @@ typedef struct GCheader {
   CommonHeader;
 } GCheader;
 
+
+
+
 /*
 ** Union of all Lua values
 */
@@ -47,6 +57,7 @@ typedef union {
   int b;
 } Value;
 
+
 /*
 ** Lua values (or `tagged objects')
 */
@@ -55,6 +66,7 @@ typedef struct lua_TObject {
   Value value;
 } TObject;
 
+
 /* Macros to test type */
 #define ttisnil(o)     (ttype(o) == LUA_TNIL)
 #define ttisnumber(o)  (ttype(o) == LUA_TNUMBER)
@@ -120,17 +132,21 @@ typedef struct lua_TObject {
 
 #define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
 
+
+
 /*
 ** for internal debug only
 */
 #define checkconsistency(obj) \
   lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
 
+
 #define setobj(obj1,obj2) \
   { const TObject *o2=(obj2); TObject *o1=(obj1); \
     checkconsistency(o2); \
     o1->tt=o2->tt; o1->value = o2->value; }
 
+
 /*
 ** different types of sets, according to destination
 */
@@ -154,10 +170,14 @@ typedef struct lua_TObject {
 
 #define setttype(obj, tt) (ttype(obj) = (tt))
 
+
 #define iscollectable(o)       (ttype(o) >= LUA_TSTRING)
 
+
+
 typedef TObject *StkId;                /* index to stack elements */
 
+
 /*
 ** String headers for string table
 */
@@ -171,9 +191,12 @@ typedef union TString {
   } tsv;
 } TString;
 
+
 #define getstr(ts)     cast(const char *, (ts) + 1)
 #define svalue(o)       getstr(tsvalue(o))
 
+
+
 typedef union Udata {
   L_Umaxalign dummy;                   /* ensures maximum alignment for `local' udata */
   struct {
@@ -183,6 +206,9 @@ typedef union Udata {
   } uv;
 } Udata;
 
+
+
+
 /*
 ** Function Prototypes
 */
@@ -209,12 +235,15 @@ typedef struct Proto {
   lu_byte maxstacksize;
 } Proto;
 
+
 typedef struct LocVar {
   TString *varname;
   int startpc;                         /* first point where variable is active */
   int endpc;                           /* first point where variable is dead */
 } LocVar;
 
+
+
 /*
 ** Upvalues
 */
@@ -225,6 +254,7 @@ typedef struct UpVal {
   TObject value;                       /* the value (when closed) */
 } UpVal;
 
+
 /*
 ** Closures
 */
@@ -238,6 +268,7 @@ typedef struct CClosure {
   TObject upvalue[1];
 } CClosure;
 
+
 typedef struct LClosure {
   ClosureHeader;
   struct Proto *p;
@@ -245,14 +276,17 @@ typedef struct LClosure {
   UpVal *upvals[1];
 } LClosure;
 
+
 typedef union Closure {
   CClosure c;
   LClosure l;
 } Closure;
 
+
 #define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
 #define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
 
+
 /*
 ** Tables
 */
@@ -263,6 +297,7 @@ typedef struct Node {
   struct Node *next;                   /* for chaining */
 } Node;
 
+
 typedef struct Table {
   CommonHeader;
   lu_byte flags;                       /* 1<<p means tagmethod(p) is not present */
@@ -275,15 +310,20 @@ typedef struct Table {
   int sizearray;                       /* size of `array' array */
 } Table;
 
+
+
 /*
 ** `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))
 
+
+
 extern const TObject luaO_nilobject;
 
 int luaO_log2(unsigned int x);
@@ -297,11 +337,5 @@ const char *luaO_pushvfstring(lua_State * L, const char *fmt, va_list argp);
 const char *luaO_pushfstring(lua_State * L, const char *fmt, ...);
 void luaO_chunkid(char *out, const char *source, int len);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 2bdfe95..c170bab 100644 (file)
@@ -1,10 +1,12 @@
 
 /*
+** $Id: lopcodes.c,v 1.22 2002/12/04 17:38:31 roberto Exp $
 ** extracted automatically from lopcodes.h by mkprint.lua
 ** DO NOT EDIT
 ** See Copyright Notice in lua.h
 */
 
+
 #define lopcodes_c
 
 #include "lua.h"
@@ -12,6 +14,7 @@
 #include "lobject.h"
 #include "lopcodes.h"
 
+
 #ifdef LUA_OPNAMES
 
 const char *const luaP_opnames[] = {
@@ -58,6 +61,7 @@ const char *const luaP_opnames[] = {
    ((b)<<OpModeBreg) | ((bk)<<OpModeBrk) | ((ck)<<OpModeCrk) | \
    ((sa)<<OpModesetA) | ((k)<<OpModeK) | (m))
 
+
 const lu_byte luaP_opmodes[NUM_OPCODES] = {
 
 /*       T  B Bk Ck sA  K  mode                           opcode    */
@@ -97,10 +101,3 @@ const lu_byte luaP_opmodes[NUM_OPCODES] = {
     , opmode(0, 0, 0, 0, 0, 0, iABC)    /* OP_CLOSE */
     , opmode(0, 0, 0, 0, 1, 0, iABx)    /* OP_CLOSURE */
 };
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index df100f6..3426794 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lopcodes.h,v 1.102 2002/08/21 18:56:09 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -9,6 +10,7 @@
 
 #include "llimits.h"
 
+
 /*===========================================================================
   We assume that instructions are unsigned numbers.
   All instructions have an opcode in the first 6 bits.
   unsigned argument.
 ===========================================================================*/
 
+
 enum OpMode { iABC, iABx, iAsBx };     /* basic instruction format */
 
+
 /*
 ** size and position of opcode arguments.
 */
@@ -43,6 +47,7 @@ enum OpMode { iABC, iABx, iAsBx };     /* basic instruction format */
 #define POS_Bx         POS_C
 #define POS_A          (POS_B + SIZE_B)
 
+
 /*
 ** limits for opcode arguments.
 ** we use (signed) int to manipulate most arguments,
@@ -56,10 +61,12 @@ enum OpMode { iABC, iABx, iAsBx };     /* basic instruction format */
 #define MAXARG_sBx        MAX_INT
 #endif
 
+
 #define MAXARG_A        ((1<<SIZE_A)-1)
 #define MAXARG_B        ((1<<SIZE_B)-1)
 #define MAXARG_C        ((1<<SIZE_C)-1)
 
+
 /* creates a mask with `n' 1 bits at position `p' */
 #define MASK1(n,p)     ((~((~(Instruction)0)<<n))<<p)
 
@@ -92,6 +99,7 @@ enum OpMode { iABC, iABx, iAsBx };     /* basic instruction format */
 #define GETARG_sBx(i)  (GETARG_Bx(i)-MAXARG_sBx)
 #define SETARG_sBx(i,b)        SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
 
+
 #define CREATE_ABC(o,a,b,c)    (cast(Instruction, o) \
                        | (cast(Instruction, a)<<POS_A) \
                        | (cast(Instruction, b)<<POS_B) \
@@ -101,17 +109,22 @@ enum OpMode { iABC, iABx, iAsBx };     /* basic instruction format */
                        | (cast(Instruction, a)<<POS_A) \
                        | (cast(Instruction, bc)<<POS_Bx))
 
+
+
+
 /*
 ** invalid register that fits in 8 bits
 */
 #define NO_REG         MAXARG_A
 
+
 /*
 ** R(x) - register
 ** Kst(x) - constant (in constant table)
 ** RK(x) == if x < MAXSTACK then R(x) else Kst(x-MAXSTACK)
 */
 
+
 /*
 ** grep "ORDER OP" if you change these enums
 */
@@ -174,8 +187,11 @@ name               args    description
   OP_CLOSURE                           /*    A Bx    R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))  */
 } OpCode;
 
+
 #define NUM_OPCODES    (cast(int, OP_CLOSURE+1))
 
+
+
 /*===========================================================================
   Notes:
   (1) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
@@ -189,6 +205,7 @@ name                args    description
   (4) All `skips' (pc++) assume that next instruction is a jump
 ===========================================================================*/
 
+
 /*
 ** masks for instruction properties
 */
@@ -201,25 +218,23 @@ enum OpModeMask {
   OpModeT                       /* operator is a test */
 };
 
+
 extern const lu_byte luaP_opmodes[NUM_OPCODES];
 
 #define getOpMode(m)            (cast(enum OpMode, luaP_opmodes[m] & 3))
 #define testOpMode(m, b)        (luaP_opmodes[m] & (1 << (b)))
 
+
 #ifdef LUA_OPNAMES
 extern const char *const luaP_opnames[];        /* opcode names */
 #endif
 
+
+
 /* number of list items to accumulate before a SETLIST instruction */
 
 /* (must be a power of 2) */
 #define LFIELDS_PER_FLUSH      32
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index 915c4ad..c653c29 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lparser.c,v 1.208a 2003/04/03 13:35:34 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
 
+
 #include <string.h>
 
 #define lparser_c
 #include "lstate.h"
 #include "lstring.h"
 
+
+
+
 #define getlocvar(fs, i)       ((fs)->f->locvars[(fs)->actvar[i]])
 
+
 #define enterlevel(ls) if (++(ls)->nestlevel > LUA_MAXPARSERLEVEL) \
                luaX_syntaxerror(ls, "too many syntax levels");
 #define leavelevel(ls) ((ls)->nestlevel--)
 
+
 /*
 ** nodes for block list (list of active blocks)
 */
@@ -38,6 +45,8 @@ typedef struct BlockCnt {
   int isbreakable;                     /* true if `block' is a loop */
 } BlockCnt;
 
+
+
 /*
 ** prototypes for recursive non-terminal functions
 */
@@ -45,6 +54,8 @@ static void chunk(LexState * ls);
 static void expr(LexState * ls, expdesc * v);
 static void error_expected(LexState * ls, int token) __attribute__ ((noreturn));
 
+
+
 static void
 next(LexState * ls)
 {
@@ -56,6 +67,7 @@ next(LexState * ls)
     ls->t.token = luaX_lex(ls, &ls->t.seminfo); /* read next token */
 }
 
+
 static void
 lookahead(LexState * ls)
 {
@@ -63,12 +75,14 @@ lookahead(LexState * ls)
   ls->lookahead.token = luaX_lex(ls, &ls->lookahead.seminfo);
 }
 
+
 static void
 error_expected(LexState * ls, int token)
 {
   luaX_syntaxerror(ls, luaO_pushfstring(ls->L, "`%s' expected", luaX_token2str(ls, token)));
 }
 
+
 static int
 testnext(LexState * ls, int c)
 {
@@ -79,6 +93,7 @@ testnext(LexState * ls, int c)
     return 0;
 }
 
+
 static void
 check(LexState * ls, int c)
 {
@@ -86,8 +101,11 @@ check(LexState * ls, int c)
     error_expected(ls, c);
 }
 
+
 #define check_condition(ls,c,msg)      { if (!(c)) luaX_syntaxerror(ls, msg); }
 
+
+
 static void
 check_match(LexState * ls, int what, int who, int where)
 {
@@ -95,13 +113,14 @@ check_match(LexState * ls, int what, int who, int where)
     if (where == ls->linenumber)
       error_expected(ls, what);
     else {
-      luaX_syntaxerror(ls,
-                       luaO_pushfstring(ls->L, "`%s' expected (to close `%s' at line %d)", luaX_token2str(ls, what),
-                                        luaX_token2str(ls, who), where));
+      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
+                                            "`%s' expected (to close `%s' at line %d)",
+                                            luaX_token2str(ls, what), luaX_token2str(ls, who), where));
     }
   }
 }
 
+
 static TString *
 str_checkname(LexState * ls)
 {
@@ -112,6 +131,7 @@ str_checkname(LexState * ls)
   return ts;
 }
 
+
 static void
 init_exp(expdesc * e, expkind k, int i)
 {
@@ -120,18 +140,21 @@ init_exp(expdesc * e, expkind k, int i)
   e->info = i;
 }
 
+
 static void
 codestring(LexState * ls, expdesc * e, TString * s)
 {
   init_exp(e, VK, luaK_stringK(ls->fs, s));
 }
 
+
 static void
 checkname(LexState * ls, expdesc * e)
 {
   codestring(ls, e, str_checkname(ls));
 }
 
+
 static int
 luaI_registerlocalvar(LexState * ls, TString * varname)
 {
@@ -142,6 +165,7 @@ luaI_registerlocalvar(LexState * ls, TString * varname)
   return fs->nlocvars++;
 }
 
+
 static void
 new_localvar(LexState * ls, TString * name, int n)
 {
@@ -150,6 +174,7 @@ new_localvar(LexState * ls, TString * name, int n)
   fs->actvar[fs->nactvar + n] = luaI_registerlocalvar(ls, name);
 }
 
+
 static void
 adjustlocalvars(LexState * ls, int nvars)
 {
@@ -160,6 +185,7 @@ adjustlocalvars(LexState * ls, int nvars)
   }
 }
 
+
 static void
 removevars(LexState * ls, int tolevel)
 {
@@ -168,12 +194,14 @@ removevars(LexState * ls, int tolevel)
     getlocvar(fs, --fs->nactvar).endpc = fs->pc;
 }
 
+
 static void
 new_localvarstr(LexState * ls, const char *name, int n)
 {
   new_localvar(ls, luaS_new(ls->L, name), n);
 }
 
+
 static void
 create_local(LexState * ls, const char *name)
 {
@@ -181,6 +209,7 @@ create_local(LexState * ls, const char *name)
   adjustlocalvars(ls, 1);
 }
 
+
 static int
 indexupvalue(FuncState * fs, TString * name, expdesc * v)
 {
@@ -200,6 +229,7 @@ indexupvalue(FuncState * fs, TString * name, expdesc * v)
   return f->nups++;
 }
 
+
 static int
 searchvar(FuncState * fs, TString * n)
 {
@@ -211,6 +241,7 @@ searchvar(FuncState * fs, TString * n)
   return -1;                    /* not found */
 }
 
+
 static void
 markupval(FuncState * fs, int level)
 {
@@ -221,6 +252,7 @@ markupval(FuncState * fs, int level)
     bl->upval = 1;
 }
 
+
 static void
 singlevaraux(FuncState * fs, TString * n, expdesc * var, int base)
 {
@@ -245,6 +277,7 @@ singlevaraux(FuncState * fs, TString * n, expdesc * var, int base)
   }
 }
 
+
 static TString *
 singlevar(LexState * ls, expdesc * var, int base)
 {
@@ -253,6 +286,7 @@ singlevar(LexState * ls, expdesc * var, int base)
   return varname;
 }
 
+
 static void
 adjust_assign(LexState * ls, int nvars, int nexps, expdesc * e)
 {
@@ -276,6 +310,7 @@ adjust_assign(LexState * ls, int nvars, int nexps, expdesc * e)
   }
 }
 
+
 static void
 code_params(LexState * ls, int nparams, int dots)
 {
@@ -289,6 +324,7 @@ code_params(LexState * ls, int nparams, int dots)
   luaK_reserveregs(fs, fs->nactvar);    /* reserve register for parameters */
 }
 
+
 static void
 enterblock(FuncState * fs, BlockCnt * bl, int isbreakable)
 {
@@ -301,6 +337,7 @@ enterblock(FuncState * fs, BlockCnt * bl, int isbreakable)
   lua_assert(fs->freereg == fs->nactvar);
 }
 
+
 static void
 leaveblock(FuncState * fs)
 {
@@ -314,6 +351,7 @@ leaveblock(FuncState * fs)
   luaK_patchtohere(fs, bl->breaklist);
 }
 
+
 static void
 pushclosure(LexState * ls, FuncState * func, expdesc * v)
 {
@@ -329,6 +367,7 @@ pushclosure(LexState * ls, FuncState * func, expdesc * v)
   }
 }
 
+
 static void
 open_func(LexState * ls, FuncState * fs)
 {
@@ -352,6 +391,7 @@ open_func(LexState * ls, FuncState * fs)
   f->maxstacksize = 2;          /* registers 0/1 are always valid */
 }
 
+
 static void
 close_func(LexState * ls)
 {
@@ -377,6 +417,7 @@ close_func(LexState * ls)
   ls->fs = fs->prev;
 }
 
+
 Proto *
 luaY_parser(lua_State * L, ZIO * z, Mbuffer * buff)
 {
@@ -396,12 +437,15 @@ luaY_parser(lua_State * L, ZIO * z, Mbuffer * buff)
   return funcstate.f;
 }
 
+
+
 /*============================================================*/
 
 /* GRAMMAR RULES */
 
 /*============================================================*/
 
+
 static void
 luaY_field(LexState * ls, expdesc * v)
 {
@@ -414,6 +458,7 @@ luaY_field(LexState * ls, expdesc * v)
   luaK_indexed(fs, v, &key);
 }
 
+
 static void
 luaY_index(LexState * ls, expdesc * v)
 {
@@ -424,12 +469,14 @@ luaY_index(LexState * ls, expdesc * v)
   check(ls, ']');
 }
 
+
 /*
 ** {======================================================================
 ** Rules for Constructors
 ** =======================================================================
 */
 
+
 struct ConsControl {
   expdesc v;                           /* last list item read */
   expdesc *t;                          /* table descriptor */
@@ -438,6 +485,7 @@ struct ConsControl {
   int tostore;                         /* number of array elements pending to be stored */
 };
 
+
 static void
 recfield(LexState * ls, struct ConsControl *cc)
 {
@@ -458,6 +506,7 @@ recfield(LexState * ls, struct ConsControl *cc)
   fs->freereg = reg;            /* free registers */
 }
 
+
 static void
 closelistfield(FuncState * fs, struct ConsControl *cc)
 {
@@ -472,6 +521,7 @@ closelistfield(FuncState * fs, struct ConsControl *cc)
   }
 }
 
+
 static void
 lastlistfield(FuncState * fs, struct ConsControl *cc)
 {
@@ -488,6 +538,7 @@ lastlistfield(FuncState * fs, struct ConsControl *cc)
   fs->freereg = cc->t->info + 1;        /* free registers */
 }
 
+
 static void
 listfield(LexState * ls, struct ConsControl *cc)
 {
@@ -497,6 +548,7 @@ listfield(LexState * ls, struct ConsControl *cc)
   cc->tostore++;
 }
 
+
 static void
 constructor(LexState * ls, expdesc * t)
 {
@@ -518,8 +570,7 @@ constructor(LexState * ls, expdesc * t)
       break;
     closelistfield(fs, &cc);
     switch (ls->t.token) {
-    case TK_NAME:
-      {                         /* may be listfields or recfields */
+    case TK_NAME:{             /* may be listfields or recfields */
         lookahead(ls);
         if (ls->lookahead.token != '=') /* expression? */
           listfield(ls, &cc);
@@ -527,19 +578,16 @@ constructor(LexState * ls, expdesc * t)
           recfield(ls, &cc);
         break;
       }
-    case '[':
-      {                         /* constructor_item -> recfield */
+    case '[':{                 /* constructor_item -> recfield */
         recfield(ls, &cc);
         break;
       }
-    default:
-      {                         /* constructor_part -> listfield */
+    default:{                  /* constructor_part -> listfield */
         listfield(ls, &cc);
         break;
       }
     }
-  }
-  while (testnext(ls, ',') || testnext(ls, ';'));
+  } while (testnext(ls, ',') || testnext(ls, ';'));
   check_match(ls, '}', '{', line);
   lastlistfield(fs, &cc);
   SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na));        /* set initial array size */
@@ -548,6 +596,8 @@ constructor(LexState * ls, expdesc * t)
 
 /* }====================================================================== */
 
+
+
 static void
 parlist(LexState * ls)
 {
@@ -567,12 +617,12 @@ parlist(LexState * ls)
       default:
         luaX_syntaxerror(ls, "<name> or `...' expected");
       }
-    }
-    while (!dots && testnext(ls, ','));
+    } while (!dots && testnext(ls, ','));
   }
   code_params(ls, nparams, dots);
 }
 
+
 static void
 body(LexState * ls, expdesc * e, int needself, int line)
 {
@@ -591,6 +641,7 @@ body(LexState * ls, expdesc * e, int needself, int line)
   pushclosure(ls, &new_fs, e);
 }
 
+
 static int
 explist1(LexState * ls, expdesc * v)
 {
@@ -605,6 +656,7 @@ explist1(LexState * ls, expdesc * v)
   return n;
 }
 
+
 static void
 funcargs(LexState * ls, expdesc * f)
 {
@@ -613,8 +665,7 @@ funcargs(LexState * ls, expdesc * f)
   int base, nparams;
   int line = ls->linenumber;
   switch (ls->t.token) {
-  case '(':
-    {                           /* funcargs -> `(' [ explist1 ] `)' */
+  case '(':{                   /* funcargs -> `(' [ explist1 ] `)' */
       if (line != ls->lastline)
         luaX_syntaxerror(ls, "ambiguous syntax (function call x new statement)");
       next(ls);
@@ -627,19 +678,16 @@ funcargs(LexState * ls, expdesc * f)
       check_match(ls, ')', '(', line);
       break;
     }
-  case '{':
-    {                           /* funcargs -> constructor */
+  case '{':{                   /* funcargs -> constructor */
       constructor(ls, &args);
       break;
     }
-  case TK_STRING:
-    {                           /* funcargs -> STRING */
+  case TK_STRING:{             /* funcargs -> STRING */
       codestring(ls, &args, ls->t.seminfo.ts);
       next(ls);                 /* must use `seminfo' before `next' */
       break;
     }
-  default:
-    {
+  default:{
       luaX_syntaxerror(ls, "function arguments expected");
       return;
     }
@@ -659,19 +707,22 @@ funcargs(LexState * ls, expdesc * f)
                                    (unless changed) one result */
 }
 
+
+
+
 /*
 ** {======================================================================
 ** Expression parsing
 ** =======================================================================
 */
 
+
 static void
 prefixexp(LexState * ls, expdesc * v)
 {
   /* prefixexp -> NAME | '(' expr ')' */
   switch (ls->t.token) {
-  case '(':
-    {
+  case '(':{
       int line = ls->linenumber;
       next(ls);
       expr(ls, v);
@@ -679,14 +730,12 @@ prefixexp(LexState * ls, expdesc * v)
       luaK_dischargevars(ls->fs, v);
       return;
     }
-  case TK_NAME:
-    {
+  case TK_NAME:{
       singlevar(ls, v, 1);
       return;
     }
 #ifdef LUA_COMPATUPSYNTAX
-  case '%':
-    {                           /* for compatibility only */
+  case '%':{                   /* for compatibility only */
       TString *varname;
       int line = ls->linenumber;
       next(ls);                 /* skip `%' */
@@ -696,14 +745,14 @@ prefixexp(LexState * ls, expdesc * v)
       return;
     }
 #endif
-  default:
-    {
+  default:{
       luaX_syntaxerror(ls, "unexpected symbol");
       return;
     }
   }
 }
 
+
 static void
 primaryexp(LexState * ls, expdesc * v)
 {
@@ -713,21 +762,18 @@ primaryexp(LexState * ls, expdesc * v)
   prefixexp(ls, v);
   for (;;) {
     switch (ls->t.token) {
-    case '.':
-      {                         /* field */
+    case '.':{                 /* field */
         luaY_field(ls, v);
         break;
       }
-    case '[':
-      {                         /* `[' exp1 `]' */
+    case '[':{                 /* `[' exp1 `]' */
         expdesc key;
         luaK_exp2anyreg(fs, v);
         luaY_index(ls, &key);
         luaK_indexed(fs, v, &key);
         break;
       }
-    case ':':
-      {                         /* `:' NAME funcargs */
+    case ':':{                 /* `:' NAME funcargs */
         expdesc key;
         next(ls);
         checkname(ls, &key);
@@ -737,8 +783,7 @@ primaryexp(LexState * ls, expdesc * v)
       }
     case '(':
     case TK_STRING:
-    case '{':
-      {                         /* funcargs */
+    case '{':{                 /* funcargs */
         luaK_exp2nextreg(fs, v);
         funcargs(ls, v);
         break;
@@ -749,61 +794,55 @@ primaryexp(LexState * ls, expdesc * v)
   }
 }
 
+
 static void
 simpleexp(LexState * ls, expdesc * v)
 {
   /* simpleexp -> NUMBER | STRING | NIL | constructor | FUNCTION body
      | primaryexp */
   switch (ls->t.token) {
-  case TK_NUMBER:
-    {
+  case TK_NUMBER:{
       init_exp(v, VK, luaK_numberK(ls->fs, ls->t.seminfo.r));
       next(ls);                 /* must use `seminfo' before `next' */
       break;
     }
-  case TK_STRING:
-    {
+  case TK_STRING:{
       codestring(ls, v, ls->t.seminfo.ts);
       next(ls);                 /* must use `seminfo' before `next' */
       break;
     }
-  case TK_NIL:
-    {
+  case TK_NIL:{
       init_exp(v, VNIL, 0);
       next(ls);
       break;
     }
-  case TK_TRUE:
-    {
+  case TK_TRUE:{
       init_exp(v, VTRUE, 0);
       next(ls);
       break;
     }
-  case TK_FALSE:
-    {
+  case TK_FALSE:{
       init_exp(v, VFALSE, 0);
       next(ls);
       break;
     }
-  case '{':
-    {                           /* constructor */
+  case '{':{                   /* constructor */
       constructor(ls, v);
       break;
     }
-  case TK_FUNCTION:
-    {
+  case TK_FUNCTION:{
       next(ls);
       body(ls, v, 0, ls->linenumber);
       break;
     }
-  default:
-    {
+  default:{
       primaryexp(ls, v);
       break;
     }
   }
 }
 
+
 static UnOpr
 getunopr(int op)
 {
@@ -817,6 +856,7 @@ getunopr(int op)
   }
 }
 
+
 static BinOpr
 getbinopr(int op)
 {
@@ -854,6 +894,7 @@ getbinopr(int op)
   }
 }
 
+
 static const struct {
   lu_byte left;                        /* left priority for each binary operator */
   lu_byte right;                       /* right priority */
@@ -881,6 +922,7 @@ static const struct {
 
 #define UNARY_PRIORITY 8       /* priority for unary operators */
 
+
 /*
 ** subexpr -> (simplexep | unop subexpr) { binop subexpr }
 ** where `binop' is any binary operator with a priority higher than `limit'
@@ -914,6 +956,7 @@ subexpr(LexState * ls, expdesc * v, int limit)
   return op;                    /* return first untreated operator */
 }
 
+
 static void
 expr(LexState * ls, expdesc * v)
 {
@@ -922,12 +965,15 @@ expr(LexState * ls, expdesc * v)
 
 /* }==================================================================== */
 
+
+
 /*
 ** {======================================================================
 ** Rules for Statements
 ** =======================================================================
 */
 
+
 static int
 block_follow(int token)
 {
@@ -943,6 +989,7 @@ block_follow(int token)
   }
 }
 
+
 static void
 block(LexState * ls)
 {
@@ -955,6 +1002,7 @@ block(LexState * ls)
   leaveblock(fs);
 }
 
+
 /*
 ** structure to chain all variables in the left-hand side of an
 ** assignment
@@ -964,6 +1012,7 @@ struct LHS_assign {
   expdesc v;                           /* variable (global, local, upvalue, or indexed) */
 };
 
+
 /*
 ** check whether, in an assignment to a local variable, the local variable
 ** is needed in a previous assignment (to a table). If so, save original
@@ -994,6 +1043,7 @@ check_conflict(LexState * ls, struct LHS_assign *lh, expdesc * v)
   }
 }
 
+
 static void
 assignment(LexState * ls, struct LHS_assign *lh, int nvars)
 {
@@ -1024,6 +1074,7 @@ assignment(LexState * ls, struct LHS_assign *lh, int nvars)
   luaK_storevar(ls->fs, &lh->v, &e);
 }
 
+
 static void
 cond(LexState * ls, expdesc * v)
 {
@@ -1035,6 +1086,7 @@ cond(LexState * ls, expdesc * v)
   luaK_patchtohere(ls->fs, v->t);
 }
 
+
 /*
 ** The while statement optimizes its code by coding the condition
 ** after its body (and thus avoiding one jump in the loop).
@@ -1099,6 +1151,7 @@ whilestat(LexState * ls, int line)
   luaK_patchtohere(fs, v.f);    /* false conditions finish the loop */
 }
 
+
 static void
 repeatstat(LexState * ls, int line)
 {
@@ -1116,6 +1169,7 @@ repeatstat(LexState * ls, int line)
   leaveblock(fs);
 }
 
+
 static int
 exp1(LexState * ls)
 {
@@ -1127,6 +1181,7 @@ exp1(LexState * ls)
   return k;
 }
 
+
 static void
 forbody(LexState * ls, int base, int line, int nvars, int isnum)
 {
@@ -1145,6 +1200,7 @@ forbody(LexState * ls, int base, int line, int nvars, int isnum)
   leaveblock(fs);
 }
 
+
 static void
 fornum(LexState * ls, TString * varname, int line)
 {
@@ -1169,6 +1225,7 @@ fornum(LexState * ls, TString * varname, int line)
   forbody(ls, base, line, 3, 1);
 }
 
+
 static void
 forlist(LexState * ls, TString * indexname)
 {
@@ -1191,6 +1248,7 @@ forlist(LexState * ls, TString * indexname)
   forbody(ls, base, line, nvars, 0);
 }
 
+
 static void
 forstat(LexState * ls, int line)
 {
@@ -1216,6 +1274,7 @@ forstat(LexState * ls, int line)
   leaveblock(fs);
 }
 
+
 static void
 test_then_block(LexState * ls, expdesc * v)
 {
@@ -1226,6 +1285,7 @@ test_then_block(LexState * ls, expdesc * v)
   block(ls);                    /* `then' part */
 }
 
+
 static void
 ifstat(LexState * ls, int line)
 {
@@ -1250,6 +1310,7 @@ ifstat(LexState * ls, int line)
   check_match(ls, TK_END, TK_IF, line);
 }
 
+
 static void
 localfunc(LexState * ls)
 {
@@ -1265,6 +1326,7 @@ localfunc(LexState * ls)
   getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
 }
 
+
 static void
 localstat(LexState * ls)
 {
@@ -1274,8 +1336,7 @@ localstat(LexState * ls)
   expdesc e;
   do {
     new_localvar(ls, str_checkname(ls), nvars++);
-  }
-  while (testnext(ls, ','));
+  } while (testnext(ls, ','));
   if (testnext(ls, '='))
     nexps = explist1(ls, &e);
   else {
@@ -1286,6 +1347,7 @@ localstat(LexState * ls)
   adjustlocalvars(ls, nvars);
 }
 
+
 static int
 funcname(LexState * ls, expdesc * v)
 {
@@ -1301,6 +1363,7 @@ funcname(LexState * ls, expdesc * v)
   return needself;
 }
 
+
 static void
 funcstat(LexState * ls, int line)
 {
@@ -1314,6 +1377,7 @@ funcstat(LexState * ls, int line)
   luaK_fixline(ls->fs, line);   /* definition `happens' in the first line */
 }
 
+
 static void
 exprstat(LexState * ls)
 {
@@ -1329,6 +1393,7 @@ exprstat(LexState * ls)
   }
 }
 
+
 static void
 retstat(LexState * ls)
 {
@@ -1362,6 +1427,7 @@ retstat(LexState * ls)
   luaK_codeABC(fs, OP_RETURN, first, nret + 1, 0);
 }
 
+
 static void
 breakstat(LexState * ls)
 {
@@ -1381,45 +1447,39 @@ breakstat(LexState * ls)
   luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
 }
 
+
 static int
 statement(LexState * ls)
 {
   int line = ls->linenumber;           /* may be needed for error messages */
   switch (ls->t.token) {
-  case TK_IF:
-    {                           /* stat -> ifstat */
+  case TK_IF:{                 /* stat -> ifstat */
       ifstat(ls, line);
       return 0;
     }
-  case TK_WHILE:
-    {                           /* stat -> whilestat */
+  case TK_WHILE:{              /* stat -> whilestat */
       whilestat(ls, line);
       return 0;
     }
-  case TK_DO:
-    {                           /* stat -> DO block END */
+  case TK_DO:{                 /* stat -> DO block END */
       next(ls);                 /* skip DO */
       block(ls);
       check_match(ls, TK_END, TK_DO, line);
       return 0;
     }
-  case TK_FOR:
-    {                           /* stat -> forstat */
+  case TK_FOR:{                /* stat -> forstat */
       forstat(ls, line);
       return 0;
     }
-  case TK_REPEAT:
-    {                           /* stat -> repeatstat */
+  case TK_REPEAT:{             /* stat -> repeatstat */
       repeatstat(ls, line);
       return 0;
     }
-  case TK_FUNCTION:
-    {
+  case TK_FUNCTION:{
       funcstat(ls, line);       /* stat -> funcstat */
       return 0;
     }
-  case TK_LOCAL:
-    {                           /* stat -> localstat */
+  case TK_LOCAL:{              /* stat -> localstat */
       next(ls);                 /* skip LOCAL */
       if (testnext(ls, TK_FUNCTION))    /* local function? */
         localfunc(ls);
@@ -1427,24 +1487,22 @@ statement(LexState * ls)
         localstat(ls);
       return 0;
     }
-  case TK_RETURN:
-    {                           /* stat -> retstat */
+  case TK_RETURN:{             /* stat -> retstat */
       retstat(ls);
       return 1;                 /* must be last statement */
     }
-  case TK_BREAK:
-    {                           /* stat -> breakstat */
+  case TK_BREAK:{              /* stat -> breakstat */
       breakstat(ls);
       return 1;                 /* must be last statement */
     }
-  default:
-    {
+  default:{
       exprstat(ls);
       return 0;                 /* to avoid warnings */
     }
   }
 }
 
+
 static void
 chunk(LexState * ls)
 {
@@ -1461,10 +1519,3 @@ chunk(LexState * ls)
 }
 
 /* }====================================================================== */
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index bb5c159..8049f57 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lparser.h,v 1.47 2003/02/11 10:46:24 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -12,6 +13,7 @@
 #include "ltable.h"
 #include "lzio.h"
 
+
 /*
 ** Expression descriptor
 */
@@ -39,8 +41,10 @@ typedef struct expdesc {
   int f;                               /* patch list of `exit when false' */
 } expdesc;
 
+
 struct BlockCnt;                       /* defined in lparser.c */
 
+
 /* state needed to generate code for a given function */
 typedef struct FuncState {
   Proto *f;                            /* current function header */
@@ -61,13 +65,8 @@ typedef struct FuncState {
   int actvar[MAXVARS];                 /* declared-variable stack */
 } FuncState;
 
+
 Proto *luaY_parser(lua_State * L, ZIO * z, Mbuffer * buff);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index ac279b3..d790493 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lstate.c,v 1.123 2003/04/03 13:35:34 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdlib.h>
 
 #define lstate_c
@@ -21,6 +23,7 @@
 #include "ltable.h"
 #include "ltm.h"
 
+
 /*
 ** macro to allow the inclusion of user information in Lua state
 */
@@ -34,6 +37,8 @@ union UEXTRASPACE {
 #define EXTRASPACE (sizeof(union UEXTRASPACE))
 #endif
 
+
+
 /*
 ** you can change this function through the official API:
 ** call `lua_setpanicf'
@@ -45,6 +50,7 @@ default_panic(lua_State * L)
   return 0;
 }
 
+
 static lua_State *
 mallocstate(lua_State * L)
 {
@@ -57,12 +63,14 @@ mallocstate(lua_State * L)
   }
 }
 
+
 static void
 freestate(lua_State * L, lua_State * L1)
 {
   luaM_free(L, cast(lu_byte *, L1) - EXTRASPACE, sizeof(lua_State) + EXTRASPACE);
 }
 
+
 static void
 stack_init(lua_State * L1, lua_State * L)
 {
@@ -80,6 +88,7 @@ stack_init(lua_State * L1, lua_State * L)
   L1->end_ci = L1->base_ci + L1->size_ci;
 }
 
+
 static void
 freestack(lua_State * L, lua_State * L1)
 {
@@ -87,6 +96,7 @@ freestack(lua_State * L, lua_State * L1)
   luaM_freearray(L, L1->stack, L1->stacksize, TObject);
 }
 
+
 /*
 ** open parts that may cause memory-allocation errors
 */
@@ -129,6 +139,7 @@ f_luaopen(lua_State * L, void *ud)
   g->GCthreshold = 4 * G(L)->nblocks;
 }
 
+
 static void
 preinit_state(lua_State * L)
 {
@@ -148,6 +159,7 @@ preinit_state(lua_State * L)
   setnilvalue(gt(L));
 }
 
+
 static void
 close_state(lua_State * L)
 {
@@ -167,6 +179,7 @@ close_state(lua_State * L)
   freestate(NULL, L);
 }
 
+
 lua_State *
 luaE_newthread(lua_State * L)
 {
@@ -179,6 +192,7 @@ luaE_newthread(lua_State * L)
   return L1;
 }
 
+
 void
 luaE_freethread(lua_State * L, lua_State * L1)
 {
@@ -188,6 +202,7 @@ luaE_freethread(lua_State * L, lua_State * L1)
   freestate(L, L1);
 }
 
+
 LUA_API lua_State *
 lua_open(void)
 {
@@ -208,6 +223,7 @@ lua_open(void)
   return L;
 }
 
+
 static void
 callallgcTM(lua_State * L, void *ud)
 {
@@ -215,6 +231,7 @@ callallgcTM(lua_State * L, void *ud)
   luaC_callGCTM(L);             /* call GC metamethods for all udata */
 }
 
+
 LUA_API void
 lua_close(lua_State * L)
 {
@@ -227,15 +244,7 @@ lua_close(lua_State * L)
     L->ci = L->base_ci;
     L->base = L->top = L->ci->base;
     L->nCcalls = 0;
-  }
-  while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
+  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
   lua_assert(G(L)->tmudata == NULL);
   close_state(L);
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index ed90345..5225f66 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lstate.h,v 1.109 2003/02/27 11:52:30 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -13,6 +14,7 @@
 #include "ltm.h"
 #include "lzio.h"
 
+
 /*
 ** macros for thread synchronization inside Lua core machine:
 ** all accesses to the global state and to global objects are synchronized.
 #define lua_unlock(L)  ((void) 0)
 #endif
 
+
 #ifndef lua_userstateopen
 #define lua_userstateopen(l)
 #endif
 
+
+
 struct lua_longjmp;                    /* defined in ldo.c */
 
+
 /* default meta table (both for tables and udata) */
 #define defaultmeta(L) (&G(L)->_defaultmeta)
 
@@ -46,19 +52,24 @@ struct lua_longjmp;                    /* defined in ldo.c */
 /* registry */
 #define registry(L)    (&G(L)->_registry)
 
+
 /* extra stack space to handle TM calls and some other extras */
 #define EXTRA_STACK   5
 
+
 #define BASIC_CI_SIZE           8
 
 #define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
 
+
+
 typedef struct stringtable {
   GCObject **hash;
   ls_nstr nuse;                        /* number of elements */
   int size;
 } stringtable;
 
+
 /*
 ** informations about a call
 */
@@ -78,6 +89,7 @@ typedef struct CallInfo {
   } u;
 } CallInfo;
 
+
 /*
 ** bit fields for `CallInfo.state'
 */
@@ -92,8 +104,10 @@ typedef struct CallInfo {
 #define CI_SAVEDPC     (1<<3)  /* 1 if `savedpc' is updated */
 #define CI_YIELD       (1<<4)  /* 1 if thread is suspended */
 
+
 #define ci_func(ci)    (clvalue((ci)->base - 1))
 
+
 /*
 ** `global state', shared by all threads of this state
 */
@@ -113,6 +127,7 @@ typedef struct global_State {
   TString *tmname[TM_N];               /* array with tag-method names */
 } global_State;
 
+
 /*
 ** `per thread' state
 */
@@ -142,8 +157,10 @@ struct lua_State {
   ptrdiff_t errfunc;                   /* current error handling function (stack index) */
 };
 
+
 #define G(L)   (L->l_G)
 
+
 /*
 ** Union of all collectable objects
 */
@@ -158,6 +175,7 @@ union GCObject {
   struct lua_State th;                 /* thread */
 };
 
+
 /* macros to convert a GCObject into a specific value */
 #define gcotots(o)     check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
 #define gcotou(o)      check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
@@ -172,14 +190,8 @@ union GCObject {
 /* macro to convert any value into a GCObject */
 #define valtogco(v)    (cast_align(GCObject *, (v)))
 
+
 lua_State *luaE_newthread(lua_State * L);
 void luaE_freethread(lua_State * L, lua_State * L1);
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index e723e5d..4771586 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lstring.c,v 1.78 2002/12/04 17:38:31 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
 
+
 #include <string.h>
 
 #define lstring_c
@@ -15,6 +17,8 @@
 #include "lstate.h"
 #include "lstring.h"
 
+
+
 void
 luaS_freeall(lua_State * L)
 {
@@ -22,6 +26,7 @@ luaS_freeall(lua_State * L)
   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
 }
 
+
 void
 luaS_resize(lua_State * L, int newsize)
 {
@@ -48,6 +53,7 @@ luaS_resize(lua_State * L, int newsize)
   tb->hash = newhash;
 }
 
+
 static TString *
 newlstr(lua_State * L, const char *str, size_t l, lu_hash h)
 {
@@ -70,6 +76,7 @@ newlstr(lua_State * L, const char *str, size_t l, lu_hash h)
   return ts;
 }
 
+
 TString *
 luaS_newlstr(lua_State * L, const char *str, size_t l)
 {
@@ -87,6 +94,7 @@ luaS_newlstr(lua_State * L, const char *str, size_t l)
   return newlstr(L, str, l, h); /* not found */
 }
 
+
 Udata *
 luaS_newudata(lua_State * L, size_t s)
 {
@@ -101,10 +109,3 @@ luaS_newudata(lua_State * L, size_t s)
   G(L)->rootudata = valtogco(u);
   return u;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 67ea8f9..be1eaee 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lstring.h,v 1.37 2002/08/16 14:45:55 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -7,9 +8,12 @@
 #ifndef lstring_h
 #define lstring_h
 
+
 #include "lobject.h"
 #include "lstate.h"
 
+
+
 #define sizestring(l)  (cast(lu_mem, sizeof(union TString))+ \
                          (cast(lu_mem, l)+1)*sizeof(char))
 
@@ -26,11 +30,5 @@ Udata *luaS_newudata(lua_State * L, size_t s);
 void luaS_freeall(lua_State * L);
 TString *luaS_newlstr(lua_State * L, const char *str, size_t l);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index ba1d4fb..cd26770 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lstrlib.c,v 1.98 2003/04/03 13:35:34 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
 
+
 #include <ctype.h>
 #include <stddef.h>
 #include <stdio.h>
 #include "lauxlib.h"
 #include "lualib.h"
 
+
 /* macro to `unsign' a character */
 #ifndef uchar
 #define uchar(c)        ((unsigned char)(c))
 #endif
 
+
 typedef long sint32;                   /* a signed version for size_t */
 
+
 static int
 str_len(lua_State * L)
 {
@@ -33,6 +38,7 @@ str_len(lua_State * L)
   return 1;
 }
 
+
 static sint32
 posrelat(sint32 pos, size_t len)
 {
@@ -40,6 +46,7 @@ posrelat(sint32 pos, size_t len)
   return (pos >= 0) ? pos : (sint32) len + pos + 1;
 }
 
+
 static int
 str_sub(lua_State * L)
 {
@@ -58,6 +65,7 @@ str_sub(lua_State * L)
   return 1;
 }
 
+
 static int
 str_lower(lua_State * L)
 {
@@ -72,6 +80,7 @@ str_lower(lua_State * L)
   return 1;
 }
 
+
 static int
 str_upper(lua_State * L)
 {
@@ -100,6 +109,7 @@ str_rep(lua_State * L)
   return 1;
 }
 
+
 static int
 str_byte(lua_State * L)
 {
@@ -112,6 +122,7 @@ str_byte(lua_State * L)
   return 1;
 }
 
+
 static int
 str_char(lua_State * L)
 {
@@ -128,6 +139,7 @@ str_char(lua_State * L)
   return 1;
 }
 
+
 static int
 writer(lua_State * L, const void *b, size_t size, void *B)
 {
@@ -136,6 +148,7 @@ writer(lua_State * L, const void *b, size_t size, void *B)
   return 1;
 }
 
+
 static int
 str_dump(lua_State * L)
 {
@@ -148,6 +161,8 @@ str_dump(lua_State * L)
   return 1;
 }
 
+
+
 /*
 ** {======================================================
 ** PATTERN MATCHING
@@ -158,6 +173,7 @@ str_dump(lua_State * L)
 #define MAX_CAPTURES 32         /* arbitrary limit */
 #endif
 
+
 #define CAP_UNFINISHED (-1)
 #define CAP_POSITION   (-2)
 
@@ -172,9 +188,11 @@ typedef struct MatchState {
   } capture[MAX_CAPTURES];
 } MatchState;
 
+
 #define ESC            '%'
 #define SPECIALS       "^$*+?.([%-"
 
+
 static int
 check_capture(MatchState * ms, int l)
 {
@@ -184,6 +202,7 @@ check_capture(MatchState * ms, int l)
   return l;
 }
 
+
 static int
 capture_to_close(MatchState * ms)
 {
@@ -194,18 +213,17 @@ capture_to_close(MatchState * ms)
   return luaL_error(ms->L, "invalid pattern capture");
 }
 
+
 static const char *
 luaI_classend(MatchState * ms, const char *p)
 {
   switch (*p++) {
-  case ESC:
-    {
+  case ESC:{
       if (*p == '\0')
         luaL_error(ms->L, "malformed pattern (ends with `%')");
       return p + 1;
     }
-  case '[':
-    {
+  case '[':{
       if (*p == '^')
         p++;
       do {                      /* look for a `]' */
@@ -213,17 +231,16 @@ luaI_classend(MatchState * ms, const char *p)
           luaL_error(ms->L, "malformed pattern (missing `]')");
         if (*(p++) == ESC && *p != '\0')
           p++;                  /* skip escapes (e.g. `%]') */
-      }
-      while (*p != ']');
+      } while (*p != ']');
       return p + 1;
     }
-  default:
-    {
+  default:{
       return p;
     }
   }
 }
 
+
 static int
 match_class(int c, int cl)
 {
@@ -265,6 +282,7 @@ match_class(int c, int cl)
   return (islower(cl) ? res : !res);
 }
 
+
 static int
 matchbracketclass(int c, const char *p, const char *ec)
 {
@@ -288,6 +306,7 @@ matchbracketclass(int c, const char *p, const char *ec)
   return !sig;
 }
 
+
 static int
 luaI_singlematch(int c, const char *p, const char *ep)
 {
@@ -303,8 +322,10 @@ luaI_singlematch(int c, const char *p, const char *ep)
   }
 }
 
+
 static const char *match(MatchState * ms, const char *s, const char *p);
 
+
 static const char *
 matchbalance(MatchState * ms, const char *s, const char *p)
 {
@@ -327,6 +348,7 @@ matchbalance(MatchState * ms, const char *s, const char *p)
   return NULL;                  /* string ends out of balance */
 }
 
+
 static const char *
 max_expand(MatchState * ms, const char *s, const char *p, const char *ep)
 {
@@ -343,6 +365,7 @@ max_expand(MatchState * ms, const char *s, const char *p, const char *ep)
   return NULL;
 }
 
+
 static const char *
 min_expand(MatchState * ms, const char *s, const char *p, const char *ep)
 {
@@ -357,6 +380,7 @@ min_expand(MatchState * ms, const char *s, const char *p, const char *ep)
   }
 }
 
+
 static const char *
 start_capture(MatchState * ms, const char *s, const char *p, int what)
 {
@@ -372,6 +396,7 @@ start_capture(MatchState * ms, const char *s, const char *p, int what)
   return res;
 }
 
+
 static const char *
 end_capture(MatchState * ms, const char *s, const char *p)
 {
@@ -383,6 +408,7 @@ end_capture(MatchState * ms, const char *s, const char *p)
   return res;
 }
 
+
 static const char *
 match_capture(MatchState * ms, const char *s, int l)
 {
@@ -395,35 +421,31 @@ match_capture(MatchState * ms, const char *s, int l)
     return NULL;
 }
 
+
 static const char *
 match(MatchState * ms, const char *s, const char *p)
 {
 init:                          /* using goto's to optimize tail recursion */
   switch (*p) {
-  case '(':
-    {                           /* start capture */
+  case '(':{                   /* start capture */
       if (*(p + 1) == ')')      /* position capture? */
         return start_capture(ms, s, p + 2, CAP_POSITION);
       else
         return start_capture(ms, s, p + 1, CAP_UNFINISHED);
     }
-  case ')':
-    {                           /* end capture */
+  case ')':{                   /* end capture */
       return end_capture(ms, s, p + 1);
     }
-  case ESC:
-    {
+  case ESC:{
       switch (*(p + 1)) {
-      case 'b':
-        {                       /* balanced string? */
+      case 'b':{               /* balanced string? */
           s = matchbalance(ms, s, p + 2);
           if (s == NULL)
             return NULL;
           p += 4;
           goto init;            /* else return match(ms, s, p+4); */
         }
-      case 'f':
-        {                       /* frontier? */
+      case 'f':{               /* frontier? */
           const char *ep;
           char previous;
           p += 2;
@@ -436,8 +458,7 @@ init:                          /* using goto's to optimize tail recursion */
           p = ep;
           goto init;            /* else return match(ms, s, ep); */
         }
-      default:
-        {
+      default:{
           if (isdigit(uchar(*(p + 1)))) {       /* capture results (%0-%9)? */
             s = match_capture(ms, s, *(p + 1));
             if (s == NULL)
@@ -449,12 +470,10 @@ init:                          /* using goto's to optimize tail recursion */
         }
       }
     }
-  case '\0':
-    {                           /* end of pattern */
+  case '\0':{                  /* end of pattern */
       return s;                 /* match succeeded */
     }
-  case '$':
-    {
+  case '$':{
       if (*(p + 1) == '\0')     /* is the `$' the last char in pattern? */
         return (s == ms->src_end) ? s : NULL;   /* check end of string */
       else
@@ -465,28 +484,23 @@ init:                          /* using goto's to optimize tail recursion */
       const char *ep = luaI_classend(ms, p);    /* points to what is next */
       int m = s < ms->src_end && luaI_singlematch(uchar(*s), p, ep);
       switch (*ep) {
-      case '?':
-        {                       /* optional */
+      case '?':{               /* optional */
           const char *res;
           if (m && ((res = match(ms, s + 1, ep + 1)) != NULL))
             return res;
           p = ep + 1;
           goto init;            /* else return match(ms, s, ep+1); */
         }
-      case '*':
-        {                       /* 0 or more repetitions */
+      case '*':{               /* 0 or more repetitions */
           return max_expand(ms, s, p, ep);
         }
-      case '+':
-        {                       /* 1 or more repetitions */
+      case '+':{               /* 1 or more repetitions */
           return (m ? max_expand(ms, s + 1, p, ep) : NULL);
         }
-      case '-':
-        {                       /* 0 or more repetitions (minimum) */
+      case '-':{               /* 0 or more repetitions (minimum) */
           return min_expand(ms, s, p, ep);
         }
-      default:
-        {
+      default:{
           if (!m)
             return NULL;
           s++;
@@ -498,6 +512,8 @@ init:                          /* using goto's to optimize tail recursion */
   }
 }
 
+
+
 static const char *
 lmemfind(const char *s1, size_t l1, const char *s2, size_t l2)
 {
@@ -522,6 +538,7 @@ lmemfind(const char *s1, size_t l1, const char *s2, size_t l2)
   }
 }
 
+
 static void
 push_onecapture(MatchState * ms, int i)
 {
@@ -534,6 +551,7 @@ push_onecapture(MatchState * ms, int i)
     lua_pushlstring(ms->L, ms->capture[i].init, l);
 }
 
+
 static int
 push_captures(MatchState * ms, const char *s, const char *e)
 {
@@ -549,6 +567,7 @@ push_captures(MatchState * ms, const char *s, const char *e)
   }
 }
 
+
 static int
 str_find(lua_State * L)
 {
@@ -584,13 +603,13 @@ str_find(lua_State * L)
         lua_pushnumber(L, (lua_Number) (res - s));      /* end */
         return push_captures(&ms, NULL, 0) + 2;
       }
-    }
-    while (s1++ < ms.src_end && !anchor);
+    } while (s1++ < ms.src_end && !anchor);
   }
   lua_pushnil(L);               /* not found */
   return 1;
 }
 
+
 static int
 gfind_aux(lua_State * L)
 {
@@ -618,6 +637,7 @@ gfind_aux(lua_State * L)
   return 0;                     /* not found */
 }
 
+
 static int
 gfind(lua_State * L)
 {
@@ -629,6 +649,7 @@ gfind(lua_State * L)
   return 1;
 }
 
+
 static void
 add_s(MatchState * ms, luaL_Buffer * b, const char *s, const char *e)
 {
@@ -663,6 +684,7 @@ add_s(MatchState * ms, luaL_Buffer * b, const char *s, const char *e)
   }
 }
 
+
 static int
 str_gsub(lua_State * L)
 {
@@ -704,12 +726,14 @@ str_gsub(lua_State * L)
 
 /* }====================================================== */
 
+
 /* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
 #define MAX_ITEM       512
 
 /* maximum size of each format specification (such as '%-099.99d') */
 #define MAX_FORMAT     20
 
+
 static void
 luaI_addquoted(lua_State * L, luaL_Buffer * b, int arg)
 {
@@ -720,19 +744,16 @@ luaI_addquoted(lua_State * L, luaL_Buffer * b, int arg)
     switch (*s) {
     case '"':
     case '\\':
-    case '\n':
-      {
+    case '\n':{
         luaL_putchar(b, '\\');
         luaL_putchar(b, *s);
         break;
       }
-    case '\0':
-      {
+    case '\0':{
         luaL_addlstring(b, "\\000", 4);
         break;
       }
-    default:
-      {
+    default:{
         luaL_putchar(b, *s);
         break;
       }
@@ -742,6 +763,7 @@ luaI_addquoted(lua_State * L, luaL_Buffer * b, int arg)
   luaL_putchar(b, '"');
 }
 
+
 static const char *
 scanformat(lua_State * L, const char *strfrmt, char *form, int *hasprecision)
 {
@@ -770,6 +792,7 @@ scanformat(lua_State * L, const char *strfrmt, char *form, int *hasprecision)
   return p;
 }
 
+
 static int
 str_format(lua_State * L)
 {
@@ -795,16 +818,14 @@ str_format(lua_State * L)
       switch (*strfrmt++) {
       case 'c':
       case 'd':
-      case 'i':
-        {
+      case 'i':{
           sprintf(buff, form, luaL_checkint(L, arg));
           break;
         }
       case 'o':
       case 'u':
       case 'x':
-      case 'X':
-        {
+      case 'X':{
           const unsigned int n = luaL_checknumber(L, arg);
           sprintf(buff, form, n);
           break;
@@ -813,18 +834,15 @@ str_format(lua_State * L)
       case 'E':
       case 'f':
       case 'g':
-      case 'G':
-        {
+      case 'G':{
           sprintf(buff, form, luaL_checknumber(L, arg));
           break;
         }
-      case 'q':
-        {
+      case 'q':{
           luaI_addquoted(L, &b, arg);
           continue;             /* skip the `addsize' at the end */
         }
-      case 's':
-        {
+      case 's':{
           size_t l;
           const char *s = luaL_checklstring(L, arg, &l);
           if (!hasprecision && l >= 100) {
@@ -838,8 +856,7 @@ str_format(lua_State * L)
             break;
           }
         }
-      default:
-        {                       /* also treat cases `pnLlh' */
+      default:{                /* also treat cases `pnLlh' */
           return luaL_error(L, "invalid option to `format'");
         }
       }
@@ -850,6 +867,7 @@ str_format(lua_State * L)
   return 1;
 }
 
+
 static const luaL_reg strlib[] = {
   {"len", str_len},
   {"sub", str_sub},
@@ -866,6 +884,7 @@ static const luaL_reg strlib[] = {
   {NULL, NULL}
 };
 
+
 /*
 ** Open string library
 */
@@ -875,10 +894,3 @@ luaopen_string(lua_State * L)
   luaL_openlib(L, LUA_STRLIBNAME, strlib, 0);
   return 1;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 3f81093..3d1b670 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ltable.c,v 1.132 2003/04/03 13:35:34 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 
+
 /*
 ** Implementation of tables (aka arrays, objects, or hash tables).
 ** Tables keep its elements in two parts: an array part and a hash part.
@@ -34,6 +36,7 @@
 #include "lstate.h"
 #include "ltable.h"
 
+
 /*
 ** max size of array part is 2^MAXBITS
 */
 /* check whether `x' < 2^MAXBITS */
 #define toobig(x)      ((((x)-1) >> MAXBITS) != 0)
 
+
 /* function to convert a lua_Number to int (with any rounding method) */
 #ifndef lua_number2int
 #define lua_number2int(i,n)    ((i)=(int)(n))
 #endif
 
+
 #define hashpow2(t,n)      (gnode(t, lmod((n), sizenode(t))))
 
 #define hashstr(t,str)  hashpow2(t, (str)->tsv.hash)
 #define hashboolean(t,p)        hashpow2(t, p)
 
+
 /*
 ** for some types, it is better to avoid modulus by power of 2, as
 ** they tend to have many 2 factors.
 */
 #define hashmod(t,n)   (gnode(t, ((n) % ((sizenode(t)-1)|1))))
 
+
 #define hashpointer(t,p)       hashmod(t, IntPoint(p))
 
+
 /*
 ** number of ints inside a lua_Number
 */
 #define numints                cast(int, sizeof(lua_Number)/sizeof(int))
 
+
 /*
 ** hash for lua_Numbers
 */
@@ -85,6 +94,8 @@ hashnum(const Table * t, lua_Number n)
   return hashmod(t, cast(lu_hash, a[0]));
 }
 
+
+
 /*
 ** returns the `main' position of an element in a table (that is, the index
 ** of its hash value)
@@ -106,6 +117,7 @@ luaH_mainposition(const Table * t, const TObject * key)
   }
 }
 
+
 /*
 ** returns the index for `key' if `key' is an appropriate key to live in
 ** the array part of the table, -1 otherwise.
@@ -122,6 +134,7 @@ arrayindex(const TObject * key)
   return -1;                    /* `key' did not match some condition */
 }
 
+
 /*
 ** returns the index of a `key' for table traversals. First goes all
 ** elements in the array part, then elements in the hash part. The
@@ -145,6 +158,7 @@ luaH_index(lua_State * L, Table * t, StkId key)
   }
 }
 
+
 int
 luaH_next(lua_State * L, Table * t, StkId key)
 {
@@ -166,12 +180,14 @@ luaH_next(lua_State * L, Table * t, StkId key)
   return 0;                     /* no more elements */
 }
 
+
 /*
 ** {=============================================================
 ** Rehash
 ** ==============================================================
 */
 
+
 static void
 computesizes(int nums[], int ntotal, int *narray, int *nhash)
 {
@@ -194,6 +210,7 @@ computesizes(int nums[], int ntotal, int *narray, int *nhash)
   lua_assert(na <= *narray && na >= *narray / 2);
 }
 
+
 static void
 numuse(const Table * t, int *narray, int *nhash)
 {
@@ -235,6 +252,7 @@ numuse(const Table * t, int *narray, int *nhash)
   computesizes(nums, totaluse, narray, nhash);
 }
 
+
 static void
 setarrayvector(lua_State * L, Table * t, int size)
 {
@@ -245,6 +263,7 @@ setarrayvector(lua_State * L, Table * t, int size)
   t->sizearray = size;
 }
 
+
 static void
 setnodevector(lua_State * L, Table * t, int lsize)
 {
@@ -269,6 +288,7 @@ setnodevector(lua_State * L, Table * t, int lsize)
   t->firstfree = gnode(t, size - 1);    /* first free position to be used */
 }
 
+
 static void
 resize(lua_State * L, Table * t, int nasize, int nhsize)
 {
@@ -312,6 +332,7 @@ resize(lua_State * L, Table * t, int nasize, int nhsize)
     luaM_freearray(L, nold, twoto(oldhsize), Node);     /* free old array */
 }
 
+
 static void
 rehash(lua_State * L, Table * t)
 {
@@ -320,10 +341,13 @@ rehash(lua_State * L, Table * t)
   resize(L, t, nasize, luaO_log2(nhsize) + 1);
 }
 
+
+
 /*
 ** }=============================================================
 */
 
+
 Table *
 luaH_new(lua_State * L, int narray, int lnhash)
 {
@@ -341,6 +365,7 @@ luaH_new(lua_State * L, int narray, int lnhash)
   return t;
 }
 
+
 void
 luaH_free(lua_State * L, Table * t)
 {
@@ -350,6 +375,7 @@ luaH_free(lua_State * L, Table * t)
   luaM_freelem(L, t);
 }
 
+
 #if 0
 
 /*
@@ -374,6 +400,7 @@ luaH_remove(Table * t, Node * e)
 }
 #endif
 
+
 /*
 ** inserts a new key into a hash table; first, check whether key's main
 ** position is free. If not, check whether colliding node is in its main
@@ -423,6 +450,7 @@ newkey(lua_State * L, Table * t, const TObject * key)
   return val;
 }
 
+
 /*
 ** generic search function
 */
@@ -438,12 +466,12 @@ luaH_getany(Table * t, const TObject * key)
         return gval(n);         /* that's it */
       else
         n = n->next;
-    }
-    while (n);
+    } while (n);
     return &luaO_nilobject;
   }
 }
 
+
 /*
 ** search function for integers
 */
@@ -460,12 +488,12 @@ luaH_getnum(Table * t, int key)
         return gval(n);         /* that's it */
       else
         n = n->next;
-    }
-    while (n);
+    } while (n);
     return &luaO_nilobject;
   }
 }
 
+
 /*
 ** search function for strings
 */
@@ -478,11 +506,11 @@ luaH_getstr(Table * t, TString * key)
       return gval(n);           /* that's it */
     else
       n = n->next;
-  }
-  while (n);
+  } while (n);
   return &luaO_nilobject;
 }
 
+
 /*
 ** main search function
 */
@@ -492,8 +520,7 @@ luaH_get(Table * t, const TObject * key)
   switch (ttype(key)) {
   case LUA_TSTRING:
     return luaH_getstr(t, tsvalue(key));
-  case LUA_TNUMBER:
-    {
+  case LUA_TNUMBER:{
       int k;
       lua_number2int(k, (nvalue(key)));
       if (cast(lua_Number, k) == nvalue(key))   /* is an integer index? */
@@ -505,6 +532,7 @@ luaH_get(Table * t, const TObject * key)
   }
 }
 
+
 TObject *
 luaH_set(lua_State * L, Table * t, const TObject * key)
 {
@@ -521,6 +549,7 @@ luaH_set(lua_State * L, Table * t, const TObject * key)
   }
 }
 
+
 TObject *
 luaH_setnum(lua_State * L, Table * t, int key)
 {
@@ -533,10 +562,3 @@ luaH_setnum(lua_State * L, Table * t, int key)
     return newkey(L, t, &k);
   }
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 524512a..3f4a443 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: ltable.h,v 1.44 2003/03/18 12:50:04 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
 
 #include "lobject.h"
 
+
 #define gnode(t,i)     (&(t)->node[i])
 #define gkey(n)                (&(n)->i_key)
 #define gval(n)                (&(n)->i_val)
 
+
 const TObject *luaH_getnum(Table * t, int key);
 TObject *luaH_setnum(lua_State * L, Table * t, int key);
 const TObject *luaH_getstr(Table * t, TString * key);
@@ -25,11 +28,5 @@ int luaH_next(lua_State * L, Table * t, StkId key);
 /* exported only for debugging */
 Node *luaH_mainposition(const Table * t, const TObject * key);
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index eade9fd..0d1629e 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ltablib.c,v 1.21 2003/04/03 13:35:34 roberto Exp $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stddef.h>
 
 #define ltablib_c
 #include "lauxlib.h"
 #include "lualib.h"
 
+
 #define aux_getn(L,n)  (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))
 
+
 static int
 luaB_foreachi(lua_State * L)
 {
@@ -33,6 +37,7 @@ luaB_foreachi(lua_State * L)
   return 0;
 }
 
+
 static int
 luaB_foreach(lua_State * L)
 {
@@ -52,6 +57,7 @@ luaB_foreach(lua_State * L)
   }
 }
 
+
 static int
 luaB_getn(lua_State * L)
 {
@@ -59,6 +65,7 @@ luaB_getn(lua_State * L)
   return 1;
 }
 
+
 static int
 luaB_setn(lua_State * L)
 {
@@ -67,6 +74,7 @@ luaB_setn(lua_State * L)
   return 0;
 }
 
+
 static int
 luaB_tinsert(lua_State * L)
 {
@@ -91,6 +99,7 @@ luaB_tinsert(lua_State * L)
   return 0;
 }
 
+
 static int
 luaB_tremove(lua_State * L)
 {
@@ -109,6 +118,7 @@ luaB_tremove(lua_State * L)
   return 1;
 }
 
+
 static int
 str_concat(lua_State * L)
 {
@@ -132,6 +142,8 @@ str_concat(lua_State * L)
   return 1;
 }
 
+
+
 /*
 ** {======================================================
 ** Quicksort
@@ -139,6 +151,7 @@ str_concat(lua_State * L)
 **  Addison-Wesley, 1993.)
 */
 
+
 static void
 set2(lua_State * L, int i, int j)
 {
@@ -249,6 +262,7 @@ luaB_sort(lua_State * L)
 
 /* }====================================================== */
 
+
 static const luaL_reg tab_funcs[] = {
   {"concat", str_concat},
   {"foreach", luaB_foreach},
@@ -261,16 +275,10 @@ static const luaL_reg tab_funcs[] = {
   {NULL, NULL}
 };
 
+
 LUALIB_API int
 luaopen_table(lua_State * L)
 {
   luaL_openlib(L, LUA_TABLIBNAME, tab_funcs, 0);
   return 1;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 6e42958..9e8f411 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ltests.c,v 1.158 2003/04/07 14:35:00 roberto Exp $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
 
+
 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 #include "ltable.h"
 #include "lualib.h"
 
+
+
 /*
 ** The whole module only makes sense with LUA_DEBUG on
 */
 #ifdef LUA_DEBUG
 
+
 #define lua_pushintegral(L,i)  lua_pushnumber(L, cast(lua_Number, (i)))
 
+
 static lua_State *lua_state = NULL;
 
 int islocked = 0;
 
+
 #define func_at(L,k)   (L->ci->base+(k) - 1)
 
+
 static void
 setnameval(lua_State * L, const char *name, int val)
 {
@@ -48,6 +56,7 @@ setnameval(lua_State * L, const char *name, int val)
   lua_settable(L, -3);
 }
 
+
 /*
 ** {======================================================================
 ** Controlled version for realloc.
@@ -81,6 +90,7 @@ unsigned long memdebug_total = 0;
 unsigned long memdebug_maxmem = 0;
 unsigned long memdebug_memlimit = ULONG_MAX;
 
+
 static void *
 checkblock(void *block, size_t size)
 {
@@ -91,6 +101,7 @@ checkblock(void *block, size_t size)
   return b;
 }
 
+
 static void
 freeblock(void *block, size_t size)
 {
@@ -104,6 +115,7 @@ freeblock(void *block, size_t size)
   }
 }
 
+
 void *
 debug_realloc(void *block, size_t oldsize, size_t size)
 {
@@ -142,14 +154,18 @@ debug_realloc(void *block, size_t oldsize, size_t size)
   }
 }
 
+
 /* }====================================================================== */
 
+
+
 /*
 ** {======================================================
 ** Disassembler
 ** =======================================================
 */
 
+
 static char *
 buildop(Proto * p, int pc, char *buff)
 {
@@ -172,6 +188,7 @@ buildop(Proto * p, int pc, char *buff)
   return buff;
 }
 
+
 #if 0
 void
 luaI_printcode(Proto * pt, int size)
@@ -185,6 +202,7 @@ luaI_printcode(Proto * pt, int size)
 }
 #endif
 
+
 static int
 listcode(lua_State * L)
 {
@@ -204,6 +222,7 @@ listcode(lua_State * L)
   return 1;
 }
 
+
 static int
 listk(lua_State * L)
 {
@@ -220,6 +239,7 @@ listk(lua_State * L)
   return 1;
 }
 
+
 static int
 listlocals(lua_State * L)
 {
@@ -236,6 +256,9 @@ listlocals(lua_State * L)
 
 /* }====================================================== */
 
+
+
+
 static int
 get_limits(lua_State * L)
 {
@@ -249,6 +272,7 @@ get_limits(lua_State * L)
   return 1;
 }
 
+
 static int
 mem_query(lua_State * L)
 {
@@ -263,6 +287,7 @@ mem_query(lua_State * L)
   }
 }
 
+
 static int
 hash_query(lua_State * L)
 {
@@ -279,6 +304,7 @@ hash_query(lua_State * L)
   return 1;
 }
 
+
 static int
 stacklevel(lua_State * L)
 {
@@ -291,6 +317,7 @@ stacklevel(lua_State * L)
   return 5;
 }
 
+
 static int
 table_query(lua_State * L)
 {
@@ -320,6 +347,7 @@ table_query(lua_State * L)
   return 3;
 }
 
+
 static int
 string_query(lua_State * L)
 {
@@ -342,6 +370,7 @@ string_query(lua_State * L)
   return 0;
 }
 
+
 static int
 tref(lua_State * L)
 {
@@ -387,6 +416,7 @@ metatable(lua_State * L)
   return 1;
 }
 
+
 static int
 upvalue(lua_State * L)
 {
@@ -405,6 +435,7 @@ upvalue(lua_State * L)
   }
 }
 
+
 static int
 newuserdata(lua_State * L)
 {
@@ -415,6 +446,7 @@ newuserdata(lua_State * L)
   return 1;
 }
 
+
 static int
 pushuserdata(lua_State * L)
 {
@@ -422,6 +454,7 @@ pushuserdata(lua_State * L)
   return 1;
 }
 
+
 static int
 udataval(lua_State * L)
 {
@@ -429,6 +462,7 @@ udataval(lua_State * L)
   return 1;
 }
 
+
 static int
 doonnewstack(lua_State * L)
 {
@@ -442,6 +476,7 @@ doonnewstack(lua_State * L)
   return 1;
 }
 
+
 static int
 s2d(lua_State * L)
 {
@@ -457,6 +492,7 @@ d2s(lua_State * L)
   return 1;
 }
 
+
 static int
 newstate(lua_State * L)
 {
@@ -469,6 +505,7 @@ newstate(lua_State * L)
   return 1;
 }
 
+
 static int
 loadlib(lua_State * L)
 {
@@ -522,6 +559,7 @@ doremote(lua_State * L)
   }
 }
 
+
 static int
 log2_aux(lua_State * L)
 {
@@ -538,6 +576,7 @@ int2fb_aux(lua_State * L)
   return 2;
 }
 
+
 static int
 test_do(lua_State * L)
 {
@@ -549,6 +588,8 @@ test_do(lua_State * L)
   return lua_gettop(L);
 }
 
+
+
 /*
 ** {======================================================
 ** function to test the API with C. It interprets a kind of assembler
@@ -596,11 +637,13 @@ getname_aux(char *buff, const char **pc)
   return buff;
 }
 
+
 #define EQ(s1) (strcmp(s1, inst) == 0)
 
 #define getnum (getnum_aux(L, &pc))
 #define getname        (getname_aux(buff, &pc))
 
+
 static int
 testC(lua_State * L)
 {
@@ -758,6 +801,7 @@ testC(lua_State * L)
 
 /* }====================================================== */
 
+
 /*
 ** {======================================================
 ** tests for yield inside hooks
@@ -788,6 +832,7 @@ setyhook(lua_State * L)
   return 0;
 }
 
+
 static int
 coresume(lua_State * L)
 {
@@ -807,6 +852,8 @@ coresume(lua_State * L)
 
 /* }====================================================== */
 
+
+
 static const struct luaL_reg tests_funcs[] = {
   {"hash", hash_query},
   {"limits", get_limits},
@@ -841,6 +888,7 @@ static const struct luaL_reg tests_funcs[] = {
   {NULL, NULL}
 };
 
+
 static void
 fim(void)
 {
@@ -850,6 +898,7 @@ fim(void)
   lua_assert(memdebug_total == 0);
 }
 
+
 static int
 l_panic(lua_State * L)
 {
@@ -858,6 +907,7 @@ l_panic(lua_State * L)
   return 0;
 }
 
+
 int
 luaB_opentests(lua_State * L)
 {
@@ -869,6 +919,7 @@ luaB_opentests(lua_State * L)
   return 0;
 }
 
+
 #undef main
 int
 main(int argc, char *argv[])
@@ -881,10 +932,3 @@ main(int argc, char *argv[])
 }
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 3bbf4c3..bff507e 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: ltm.c,v 1.106 2003/04/03 13:35:34 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
 
+
 #include <string.h>
 
 #define ltm_c
 #include "ltable.h"
 #include "ltm.h"
 
+
+
 const char *const luaT_typenames[] = {
   "nil", "boolean", "userdata", "number",
   "string", "table", "function", "userdata", "thread"
 };
 
+
 void
 luaT_init(lua_State * L)
 {
@@ -38,6 +43,7 @@ luaT_init(lua_State * L)
   }
 }
 
+
 /*
 ** function to be used with macro "fasttm": optimized for absence of
 ** tag methods
@@ -54,6 +60,7 @@ luaT_gettm(Table * events, TMS event, TString * ename)
     return tm;
 }
 
+
 const TObject *
 luaT_gettmbyobj(lua_State * L, const TObject * o, TMS event)
 {
@@ -67,10 +74,3 @@ luaT_gettmbyobj(lua_State * L, const TObject * o, TMS event)
     return &luaO_nilobject;
   }
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index a3ed3c8..fa2b788 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: ltm.h,v 1.41 2002/11/14 11:51:50 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -7,8 +8,10 @@
 #ifndef ltm_h
 #define ltm_h
 
+
 #include "lobject.h"
 
+
 /*
 * WARNING: if you change the order of this enumeration,
 * grep "ORDER TM"
@@ -32,11 +35,14 @@ typedef enum {
   TM_N                                 /* number of elements in the enum */
 } TMS;
 
+
+
 #define gfasttm(g,et,e) \
   (((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
 
 #define fasttm(l,et,e) gfasttm(G(l), et, e)
 
+
 const TObject *luaT_gettm(Table * events, TMS event, TString * ename);
 const TObject *luaT_gettmbyobj(lua_State * L, const TObject * o, TMS event);
 void luaT_init(lua_State * L);
@@ -44,10 +50,3 @@ void luaT_init(lua_State * L);
 extern const char *const luaT_typenames[];
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 2a18bef..e8d5aae 100644 (file)
@@ -1,24 +1,30 @@
 
 /*
+** $Id: lua.h,v 1.175b 2003/03/18 12:31:39 roberto Exp $
 ** Lua - An Extensible Extension Language
 ** Tecgraf: Computer Graphics Technology Group, PUC-Rio, Brazil
 ** http://www.lua.org  mailto:info@lua.org
 ** See Copyright Notice at the end of this file
 */
 
+
 #ifndef lua_h
 #define lua_h
 
 #include <stdarg.h>
 #include <stddef.h>
 
+
 #define LUA_VERSION    "Lua 5.0.2"
 #define LUA_COPYRIGHT  "Copyright (C) 1994-2004 Tecgraf, PUC-Rio"
 #define LUA_AUTHORS    "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
 
+
+
 /* option for multiple returns in `lua_pcall' and `lua_call' */
 #define LUA_MULTRET    (-1)
 
+
 /*
 ** pseudo-indices
 */
@@ -26,6 +32,7 @@
 #define LUA_GLOBALSINDEX       (-10001)
 #define lua_upvalueindex(i)    (LUA_GLOBALSINDEX-(i))
 
+
 /* error codes for `lua_load' and `lua_pcall' */
 #define LUA_ERRRUN     1
 #define LUA_ERRFILE    2
 #define LUA_ERRMEM     4
 #define LUA_ERRERR     5
 
+
 typedef struct lua_State lua_State;
 
 typedef int (*lua_CFunction) (lua_State * L);
 
+
 /*
 ** functions that read/write blocks when loading/dumping Lua chunks
 */
@@ -44,6 +53,7 @@ typedef const char *(*lua_Chunkreader) (lua_State * L, void *ud, size_t * sz);
 
 typedef int (*lua_Chunkwriter) (lua_State * L, const void *p, size_t sz, void *ud);
 
+
 /*
 ** basic types
 */
@@ -59,9 +69,11 @@ typedef int (*lua_Chunkwriter) (lua_State * L, const void *p, size_t sz, void *u
 #define LUA_TUSERDATA  7
 #define LUA_TTHREAD    8
 
+
 /* minimum Lua stack available to a C function */
 #define LUA_MINSTACK   20
 
+
 /*
 ** generic extra include file
 */
@@ -69,6 +81,7 @@ typedef int (*lua_Chunkwriter) (lua_State * L, const void *p, size_t sz, void *u
 #include LUA_USER_H
 #endif
 
+
 /* type of numbers in Lua */
 #ifndef LUA_NUMBER
 typedef double lua_Number;
@@ -76,11 +89,13 @@ typedef double lua_Number;
 typedef LUA_NUMBER lua_Number;
 #endif
 
+
 /* mark for all API functions */
 #ifndef LUA_API
 #define LUA_API                extern
 #endif
 
+
 /*
 ** state manipulation
 */
@@ -90,6 +105,7 @@ LUA_API lua_State *lua_newthread(lua_State * L);
 
 LUA_API lua_CFunction lua_atpanic(lua_State * L, lua_CFunction panicf);
 
+
 /*
 ** basic stack manipulation
 */
@@ -103,6 +119,7 @@ LUA_API int lua_checkstack(lua_State * L, int sz);
 
 LUA_API void lua_xmove(lua_State * from, lua_State * to, int n);
 
+
 /*
 ** access functions (stack -> C)
 */
@@ -127,6 +144,7 @@ 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);
 
+
 /*
 ** push functions (C -> stack)
 */
@@ -140,6 +158,7 @@ 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, const void *p);
 
+
 /*
 ** get functions (Lua -> stack)
 */
@@ -151,6 +170,7 @@ LUA_API void *lua_newuserdata(lua_State * L, size_t sz);
 LUA_API int lua_getmetatable(lua_State * L, int objindex);
 LUA_API void lua_getfenv(lua_State * L, int idx);
 
+
 /*
 ** set functions (stack -> Lua)
 */
@@ -160,6 +180,7 @@ LUA_API void lua_rawseti(lua_State * L, int idx, int n);
 LUA_API int lua_setmetatable(lua_State * L, int objindex);
 LUA_API int lua_setfenv(lua_State * L, int idx);
 
+
 /*
 ** `load' and `call' functions (load and run Lua code)
 */
@@ -170,6 +191,7 @@ LUA_API int lua_load(lua_State * L, lua_Chunkreader reader, void *dt, const char
 
 LUA_API int lua_dump(lua_State * L, lua_Chunkwriter writer, void *data);
 
+
 /*
 ** coroutine functions
 */
@@ -195,6 +217,8 @@ LUA_API int lua_next(lua_State * L, int idx);
 
 LUA_API void lua_concat(lua_State * L, int n);
 
+
+
 /*
 ** ===============================================================
 ** some useful macros
@@ -226,10 +250,13 @@ LUA_API void lua_concat(lua_State * L, int n);
 #define lua_pushliteral(L, s)  \
        lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
 
+
+
 /*
 ** compatibility macros and functions
 */
 
+
 LUA_API int lua_pushupvalues(lua_State * L);
 
 #define lua_getregistry(L)     lua_pushvalue(L, LUA_REGISTRYINDEX)
@@ -239,6 +266,7 @@ LUA_API int lua_pushupvalues(lua_State * L);
 #define lua_getglobal(L,s)     \
                (lua_pushstring(L, s), lua_gettable(L, LUA_GLOBALSINDEX))
 
+
 /* compatibility with ref system */
 
 /* pre-defined references */
@@ -252,6 +280,8 @@ LUA_API int lua_pushupvalues(lua_State * L);
 
 #define lua_getref(L,ref)      lua_rawgeti(L, LUA_REGISTRYINDEX, ref)
 
+
+
 /*
 ** {======================================================================
 ** useful definitions for Lua kernel and libraries
@@ -269,12 +299,14 @@ LUA_API int lua_pushupvalues(lua_State * L);
 
 /* }====================================================================== */
 
+
 /*
 ** {======================================================================
 ** Debug API
 ** =======================================================================
 */
 
+
 /*
 ** Event codes
 */
@@ -284,6 +316,7 @@ LUA_API int lua_pushupvalues(lua_State * L);
 #define LUA_HOOKCOUNT  3
 #define LUA_HOOKTAILRET 4
 
+
 /*
 ** Event masks
 */
@@ -296,6 +329,7 @@ typedef struct lua_Debug lua_Debug;    /* activation record */
 
 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);
@@ -308,6 +342,7 @@ 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);
 
+
 #define LUA_IDSIZE     60
 
 struct lua_Debug {
@@ -326,6 +361,7 @@ struct lua_Debug {
 
 /* }====================================================================== */
 
+
 /******************************************************************************
 * Copyright (C) 1994-2004 Tecgraf, PUC-Rio.  All rights reserved.
 *
@@ -349,11 +385,5 @@ struct lua_Debug {
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ******************************************************************************/
 
-#endif
 
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
+#endif
index b5efb48..d298d2e 100644 (file)
@@ -1,18 +1,22 @@
 
 /*
+** $Id: lualib.h,v 1.28 2003/03/18 12:24:26 roberto Exp $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
 
+
 #ifndef lualib_h
 #define lualib_h
 
 #include "lua.h"
 
+
 #ifndef LUALIB_API
 #define LUALIB_API     LUA_API
 #endif
 
+
 #define LUA_COLIBNAME  "coroutine"
 LUALIB_API int luaopen_base(lua_State * L);
 
@@ -32,13 +36,16 @@ LUALIB_API int luaopen_math(lua_State * L);
 #define LUA_DBLIBNAME  "debug"
 LUALIB_API int luaopen_debug(lua_State * L);
 
+
 LUALIB_API int luaopen_loadlib(lua_State * L);
 
+
 /* to help testing the libraries */
 #ifndef lua_assert
 #define lua_assert(c)           /* empty */
 #endif
 
+
 /* compatibility code */
 #define lua_baselibopen        luaopen_base
 #define lua_tablibopen luaopen_table
@@ -48,10 +55,3 @@ LUALIB_API int luaopen_loadlib(lua_State * L);
 #define lua_dblibopen  luaopen_debug
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index ab5b372..0e840cf 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lundump.c,v 1.49 2003/04/07 20:34:20 lhf Exp $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
@@ -303,10 +304,3 @@ luaU_endianness(void)
   int x = 1;
   return *(char *)&x;
 }
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index 669b9de..582cb68 100644 (file)
@@ -1,5 +1,6 @@
 
 /*
+** $Id: lundump.h,v 1.30 2003/04/07 20:34:20 lhf Exp $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
@@ -33,10 +34,3 @@ void luaU_print(const Proto * Main);
 #define        TEST_NUMBER     ((lua_Number)3.14159265358979323846E7)
 
 #endif
-
-/*
- * Local Variables:
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * End:
- */
index d239656..194ce7e 100644 (file)
@@ -1,9 +1,11 @@
 
 /*
+** $Id: lvm.c,v 1.284b 2003/04/03 13:35:34 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
 
+
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include "ltm.h"
 #include "lvm.h"
 
+
+
 /* function to convert a lua_Number to a string */
 #ifndef lua_number2str
 #define lua_number2str(s,n)     sprintf((s), LUA_NUMBER_FMT, (n))
 #endif
 
+
 /* limit for table tag-method chains (to avoid loops) */
 #define MAXTAGLOOP     100
 
+
 const TObject *
 luaV_tonumber(const TObject * obj, TObject * n)
 {
@@ -48,6 +54,7 @@ luaV_tonumber(const TObject * obj, TObject * n)
     return NULL;
 }
 
+
 int
 luaV_tostring(lua_State * L, StkId obj)
 {
@@ -61,6 +68,7 @@ luaV_tostring(lua_State * L, StkId obj)
   }
 }
 
+
 static void
 traceexec(lua_State * L)
 {
@@ -92,6 +100,7 @@ traceexec(lua_State * L)
   }
 }
 
+
 static void
 callTMres(lua_State * L, const TObject * f, const TObject * p1, const TObject * p2)
 {
@@ -104,6 +113,8 @@ callTMres(lua_State * L, const TObject * f, const TObject * p1, const TObject *
   L->top--;                     /* result will be in L->top */
 }
 
+
+
 static void
 callTM(lua_State * L, const TObject * f, const TObject * p1, const TObject * p2, const TObject * p3)
 {
@@ -116,6 +127,7 @@ callTM(lua_State * L, const TObject * f, const TObject * p1, const TObject * p2,
   luaD_call(L, L->top - 4, 0);
 }
 
+
 static const TObject *
 luaV_index(lua_State * L, const TObject * t, TObject * key, int loop)
 {
@@ -142,6 +154,7 @@ luaV_getnotable(lua_State * L, const TObject * t, TObject * key, int loop)
     return luaV_gettable(L, tm, key, loop);
 }
 
+
 /*
 ** Function to index a table.
 ** Receives the table at `t' and the key at `key'.
@@ -163,6 +176,7 @@ luaV_gettable(lua_State * L, const TObject * t, TObject * key, int loop)
     return luaV_getnotable(L, t, key, loop + 1);
 }
 
+
 /*
 ** Receives table at `t', key at `key' and value at `val'.
 */
@@ -188,11 +202,11 @@ luaV_settable(lua_State * L, const TObject * t, TObject * key, StkId val)
       return;
     }
     t = tm;                     /* else repeat with `tm' */
-  }
-  while (++loop <= MAXTAGLOOP);
+  } while (++loop <= MAXTAGLOOP);
   luaG_runerror(L, "loop in settable");
 }
 
+
 static int
 call_binTM(lua_State * L, const TObject * p1, const TObject * p2, StkId res, TMS event)
 {
@@ -208,6 +222,7 @@ call_binTM(lua_State * L, const TObject * p1, const TObject * p2, StkId res, TMS
   return 1;
 }
 
+
 static const TObject *
 get_compTM(lua_State * L, Table * mt1, Table * mt2, TMS event)
 {
@@ -225,6 +240,7 @@ get_compTM(lua_State * L, Table * mt1, Table * mt2, TMS event)
   return NULL;
 }
 
+
 static int
 call_orderTM(lua_State * L, const TObject * p1, const TObject * p2, TMS event)
 {
@@ -239,6 +255,7 @@ call_orderTM(lua_State * L, const TObject * p1, const TObject * p2, TMS event)
   return !l_isfalse(L->top);
 }
 
+
 static int
 luaV_strcmp(const TString * ls, const TString * rs)
 {
@@ -266,6 +283,7 @@ luaV_strcmp(const TString * ls, const TString * rs)
   }
 }
 
+
 int
 luaV_lessthan(lua_State * L, const TObject * l, const TObject * r)
 {
@@ -281,6 +299,7 @@ luaV_lessthan(lua_State * L, const TObject * l, const TObject * r)
   return luaG_ordererror(L, l, r);
 }
 
+
 static int
 luaV_lessequal(lua_State * L, const TObject * l, const TObject * r)
 {
@@ -298,6 +317,7 @@ luaV_lessequal(lua_State * L, const TObject * l, const TObject * r)
   return luaG_ordererror(L, l, r);
 }
 
+
 int
 luaV_equalval(lua_State * L, const TObject * t1, const TObject * t2)
 {
@@ -312,15 +332,13 @@ luaV_equalval(lua_State * L, const TObject * t1, const TObject * t2)
     return bvalue(t1) == bvalue(t2);    /* true must be 1 !! */
   case LUA_TLIGHTUSERDATA:
     return pvalue(t1) == pvalue(t2);
-  case LUA_TUSERDATA:
-    {
+  case LUA_TUSERDATA:{
       if (uvalue(t1) == uvalue(t2))
         return 1;
       tm = get_compTM(L, uvalue(t1)->uv.metatable, uvalue(t2)->uv.metatable, TM_EQ);
       break;                    /* will try TM */
     }
-  case LUA_TTABLE:
-    {
+  case LUA_TTABLE:{
       if (hvalue(t1) == hvalue(t2))
         return 1;
       tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
@@ -335,6 +353,7 @@ luaV_equalval(lua_State * L, const TObject * t1, const TObject * t2)
   return !l_isfalse(L->top);
 }
 
+
 void
 luaV_concat(lua_State * L, int total, int last)
 {
@@ -346,8 +365,7 @@ luaV_concat(lua_State * L, int total, int last)
         luaG_concaterror(L, top - 2, top - 1);
     } else if (tsvalue(top - 1)->tsv.len > 0) { /* if len=0, do nothing */
       /* at least two string values; get as many as possible */
-      lu_mem tl = cast(lu_mem, tsvalue(top - 1)->tsv.len) + cast(lu_mem,
-                                                                 tsvalue(top - 2)->tsv.len);
+      lu_mem tl = cast(lu_mem, tsvalue(top - 1)->tsv.len) + cast(lu_mem, tsvalue(top - 2)->tsv.len);
       char *buffer;
       int i;
       while (n < total && tostring(L, top - n - 1)) {   /* collect total length */
@@ -367,10 +385,10 @@ luaV_concat(lua_State * L, int total, int last)
     }
     total -= n - 1;             /* got `n' strings to create 1 new */
     last -= n - 1;
-  }
-  while (total > 1);            /* repeat until only 1 result left */
+  } while (total > 1);          /* repeat until only 1 result left */
 }
 
+
 static void
 Arith(lua_State * L, StkId ra, const TObject * rb, const TObject * rc, TMS op)
 {
@@ -390,8 +408,7 @@ Arith(lua_State * L, StkId ra, const TObject * rb, const TObject * rc, TMS op)
     case TM_DIV:
       setnvalue(ra, nvalue(b) / nvalue(c));
       break;
-    case TM_POW:
-      {
+    case TM_POW:{
         const TObject *f = luaH_getstr(hvalue(gt(L)), G(L)->tmname[TM_POW]);
         ptrdiff_t res = savestack(L, ra);
         if (!ttisfunction(f))
@@ -409,6 +426,8 @@ Arith(lua_State * L, StkId ra, const TObject * rb, const TObject * rc, TMS op)
     luaG_aritherror(L, rb, rc);
 }
 
+
+
 /*
 ** some macros for common tasks in `luaV_execute'
 */
@@ -425,8 +444,10 @@ Arith(lua_State * L, StkId ra, const TObject * rb, const TObject * rc, TMS op)
 #define RKC(i) ((GETARG_C(i) < MAXSTACK) ? RC(i) : k+GETARG_C(i)-MAXSTACK)
 #define KBx(i) (k+GETARG_Bx(i))
 
+
 #define dojump(pc, i)  ((pc) += (i))
 
+
 StkId
 luaV_execute(lua_State * L)
 {
@@ -463,43 +484,37 @@ retentry:                      /* entry point when returning to old functions */
     lua_assert(L->ci->state & CI_HASFRAME);
     lua_assert(base == L->ci->base);
     lua_assert(L->top <= L->stack + L->stacksize && L->top >= base);
-    lua_assert(L->top == L->ci->top || GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL || GET_OPCODE(i) == OP_RETURN
-               || GET_OPCODE(i) == OP_SETLISTO);
+    lua_assert(L->top == L->ci->top ||
+               GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
+               GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO);
     switch (GET_OPCODE(i)) {
-    case OP_MOVE:
-      {
+    case OP_MOVE:{
         setobjs2s(ra, RB(i));
         break;
       }
-    case OP_LOADK:
-      {
+    case OP_LOADK:{
         setobj2s(ra, KBx(i));
         break;
       }
-    case OP_LOADBOOL:
-      {
+    case OP_LOADBOOL:{
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i))
           pc++;                 /* skip next instruction (if C) */
         break;
       }
-    case OP_LOADNIL:
-      {
+    case OP_LOADNIL:{
         TObject *rb = RB(i);
         do {
           setnilvalue(rb--);
-        }
-        while (rb >= ra);
+        } while (rb >= ra);
         break;
       }
-    case OP_GETUPVAL:
-      {
+    case OP_GETUPVAL:{
         int b = GETARG_B(i);
         setobj2s(ra, cl->upvals[b]->v);
         break;
       }
-    case OP_GETGLOBAL:
-      {
+    case OP_GETGLOBAL:{
         TObject *rb = KBx(i);
         const TObject *v;
         lua_assert(ttisstring(rb) && ttistable(&cl->g));
@@ -510,8 +525,7 @@ retentry:                      /* entry point when returning to old functions */
           setobj2s(XRA(i), luaV_index(L, &cl->g, rb, 0));
         break;
       }
-    case OP_GETTABLE:
-      {
+    case OP_GETTABLE:{
         StkId rb = RB(i);
         TObject *rc = RKC(i);
         if (ttistable(rb)) {
@@ -524,33 +538,28 @@ retentry:                      /* entry point when returning to old functions */
           setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));
         break;
       }
-    case OP_SETGLOBAL:
-      {
+    case OP_SETGLOBAL:{
         lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g));
         luaV_settable(L, &cl->g, KBx(i), ra);
         break;
       }
-    case OP_SETUPVAL:
-      {
+    case OP_SETUPVAL:{
         int b = GETARG_B(i);
         setobj(cl->upvals[b]->v, ra);   /* write barrier */
         break;
       }
-    case OP_SETTABLE:
-      {
+    case OP_SETTABLE:{
         luaV_settable(L, ra, RKB(i), RKC(i));
         break;
       }
-    case OP_NEWTABLE:
-      {
+    case OP_NEWTABLE:{
         int b = GETARG_B(i);
         b = fb2int(b);
         sethvalue(ra, luaH_new(L, b, GETARG_C(i)));
         luaC_checkGC(L);
         break;
       }
-    case OP_SELF:
-      {
+    case OP_SELF:{
         StkId rb = RB(i);
         TObject *rc = RKC(i);
         runtime_check(L, ttisstring(rc));
@@ -565,8 +574,7 @@ retentry:                      /* entry point when returning to old functions */
           setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));
         break;
       }
-    case OP_ADD:
-      {
+    case OP_ADD:{
         TObject *rb = RKB(i);
         TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -575,8 +583,7 @@ retentry:                      /* entry point when returning to old functions */
           Arith(L, ra, rb, rc, TM_ADD);
         break;
       }
-    case OP_SUB:
-      {
+    case OP_SUB:{
         TObject *rb = RKB(i);
         TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -585,8 +592,7 @@ retentry:                      /* entry point when returning to old functions */
           Arith(L, ra, rb, rc, TM_SUB);
         break;
       }
-    case OP_MUL:
-      {
+    case OP_MUL:{
         TObject *rb = RKB(i);
         TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -595,8 +601,7 @@ retentry:                      /* entry point when returning to old functions */
           Arith(L, ra, rb, rc, TM_MUL);
         break;
       }
-    case OP_DIV: