tas: lua: run gnu-indent.sh script
authorFerry Huberts <ferry.huberts@pelagic.nl>
Fri, 26 Oct 2012 11:15:36 +0000 (13:15 +0200)
committerFerry Huberts <ferry.huberts@pelagic.nl>
Fri, 26 Oct 2012 11:15:36 +0000 (13:15 +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 226cd71..1dc2bdd 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lapi.c,v 1.235 2003/04/07 14:36:08 roberto Exp $
 ** Lua API
 #include "lvm.h"
 
 
-const char lua_ident[] =
-  "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
-  "$Authors: " LUA_AUTHORS " $\n"
-  "$URL: www.lua.org $\n";
+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); }*/
+#define api_check(L, o)         /*{ assert(o); } */
 #endif
 
 #define api_checknelems(L, n)  api_check(L, (n) <= (L->top - L->base))
@@ -45,32 +43,37 @@ const char lua_ident[] =
 
 
 
-static TObject *negindex (lua_State *L, int idx) {
+static TObject *
+negindex(lua_State * L, int idx)
+{
   if (idx > LUA_REGISTRYINDEX) {
     api_check(L, idx != 0 && -idx <= L->top - L->base);
-    return L->top+idx;
-  }
-  else switch (idx) {  /* pseudo-indices */
-    case LUA_REGISTRYINDEX: return registry(L);
-    case LUA_GLOBALSINDEX: return gt(L);
-    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 L->top + idx;
+  } else
+    switch (idx) {              /* pseudo-indices */
+    case LUA_REGISTRYINDEX:
+      return registry(L);
+    case LUA_GLOBALSINDEX:
+      return gt(L);
+    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;
+      }
     }
-  }
 }
 
 
-static TObject *luaA_index (lua_State *L, int idx) {
+static TObject *
+luaA_index(lua_State * L, int idx)
+{
   if (idx > 0) {
     api_check(L, idx <= L->top - L->base);
     return L->base + idx - 1;
-  }
-  else {
+  } else {
     TObject *o = negindex(L, idx);
     api_check(L, o != NULL);
     return o;
@@ -78,29 +81,36 @@ static TObject *luaA_index (lua_State *L, int idx) {
 }
 
 
-static TObject *luaA_indexAcceptable (lua_State *L, int idx) {
+static TObject *
+luaA_indexAcceptable(lua_State * L, int idx)
+{
   if (idx > 0) {
-    TObject *o = L->base+(idx-1);
+    TObject *o = L->base + (idx - 1);
     api_check(L, idx <= L->stack_last - L->base);
-    if (o >= L->top) return NULL;
-    else return o;
-  }
-  else
+    if (o >= L->top)
+      return NULL;
+    else
+      return o;
+  } else
     return negindex(L, idx);
 }
 
 
-void luaA_pushobject (lua_State *L, const TObject *o) {
+void
+luaA_pushobject(lua_State * L, const TObject * o)
+{
   setobj2s(L->top, o);
   incr_top(L);
 }
 
 
-LUA_API int lua_checkstack (lua_State *L, int size) {
+LUA_API int
+lua_checkstack(lua_State * L, int size)
+{
   int res;
   lua_lock(L);
   if ((L->top - L->base + size) > LUA_MAXCSTACK)
-    res = 0;  /* stack overflow */
+    res = 0;                    /* stack overflow */
   else {
     luaD_checkstack(L, size);
     if (L->ci->top < L->top + size)
@@ -112,7 +122,9 @@ LUA_API int lua_checkstack (lua_State *L, int size) {
 }
 
 
-LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
+LUA_API void
+lua_xmove(lua_State * from, lua_State * to, int n)
+{
   int i;
   lua_lock(to);
   api_checknelems(from, n);
@@ -125,7 +137,9 @@ LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
 }
 
 
-LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
+LUA_API lua_CFunction
+lua_atpanic(lua_State * L, lua_CFunction panicf)
+{
   lua_CFunction old;
   lua_lock(L);
   old = G(L)->panic;
@@ -135,7 +149,9 @@ LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
 }
 
 
-LUA_API lua_State *lua_newthread (lua_State *L) {
+LUA_API lua_State *
+lua_newthread(lua_State * L)
+{
   lua_State *L1;
   lua_lock(L);
   luaC_checkGC(L);
@@ -154,58 +170,71 @@ LUA_API lua_State *lua_newthread (lua_State *L) {
 */
 
 
-LUA_API int lua_gettop (lua_State *L) {
+LUA_API int
+lua_gettop(lua_State * L)
+{
   return (L->top - L->base);
 }
 
 
-LUA_API void lua_settop (lua_State *L, int idx) {
+LUA_API void
+lua_settop(lua_State * L, int idx)
+{
   lua_lock(L);
   if (idx >= 0) {
     api_check(L, idx <= L->stack_last - L->base);
     while (L->top < L->base + idx)
       setnilvalue(L->top++);
     L->top = L->base + idx;
-  }
-  else {
-    api_check(L, -(idx+1) <= (L->top - L->base));
-    L->top += idx+1;  /* `subtract' index (index is negative) */
+  } else {
+    api_check(L, -(idx + 1) <= (L->top - L->base));
+    L->top += idx + 1;          /* `subtract' index (index is negative) */
   }
   lua_unlock(L);
 }
 
 
-LUA_API void lua_remove (lua_State *L, int idx) {
+LUA_API void
+lua_remove(lua_State * L, int idx)
+{
   StkId p;
   lua_lock(L);
   p = luaA_index(L, idx);
-  while (++p < L->top) setobjs2s(p-1, p);
+  while (++p < L->top)
+    setobjs2s(p - 1, p);
   L->top--;
   lua_unlock(L);
 }
 
 
-LUA_API void lua_insert (lua_State *L, int idx) {
+LUA_API void
+lua_insert(lua_State * L, int idx)
+{
   StkId p;
   StkId q;
   lua_lock(L);
   p = luaA_index(L, idx);
-  for (q = L->top; q>p; q--) setobjs2s(q, q-1);
+  for (q = L->top; q > p; q--)
+    setobjs2s(q, q - 1);
   setobjs2s(p, L->top);
   lua_unlock(L);
 }
 
 
-LUA_API void lua_replace (lua_State *L, int idx) {
+LUA_API void
+lua_replace(lua_State * L, int idx)
+{
   lua_lock(L);
   api_checknelems(L, 1);
-  setobj(luaA_index(L, idx), L->top - 1);  /* write barrier */
+  setobj(luaA_index(L, idx), L->top - 1);       /* write barrier */
   L->top--;
   lua_unlock(L);
 }
 
 
-LUA_API void lua_pushvalue (lua_State *L, int idx) {
+LUA_API void
+lua_pushvalue(lua_State * L, int idx)
+{
   lua_lock(L);
   setobj2s(L->top, luaA_index(L, idx));
   api_incr_top(L);
@@ -219,79 +248,99 @@ LUA_API void lua_pushvalue (lua_State *L, int idx) {
 */
 
 
-LUA_API int lua_type (lua_State *L, int idx) {
+LUA_API int
+lua_type(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
   return (o == NULL) ? LUA_TNONE : ttype(o);
 }
 
 
-LUA_API const char *lua_typename (lua_State *L, int t) {
+LUA_API const char *
+lua_typename(lua_State * L, int t)
+{
   UNUSED(L);
   return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
 }
 
 
-LUA_API int lua_iscfunction (lua_State *L, int idx) {
+LUA_API int
+lua_iscfunction(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
   return (o == NULL) ? 0 : iscfunction(o);
 }
 
 
-LUA_API int lua_isnumber (lua_State *L, int idx) {
+LUA_API int
+lua_isnumber(lua_State * L, int idx)
+{
   TObject n;
   const TObject *o = luaA_indexAcceptable(L, idx);
   return (o != NULL && tonumber(o, &n));
 }
 
 
-LUA_API int lua_isstring (lua_State *L, int idx) {
+LUA_API int
+lua_isstring(lua_State * L, int idx)
+{
   int t = lua_type(L, idx);
   return (t == LUA_TSTRING || t == LUA_TNUMBER);
 }
 
 
-LUA_API int lua_isuserdata (lua_State *L, int idx) {
+LUA_API int
+lua_isuserdata(lua_State * L, int idx)
+{
   const TObject *o = luaA_indexAcceptable(L, idx);
   return (o != NULL && (ttisuserdata(o) || ttislightuserdata(o)));
 }
 
 
-LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
+LUA_API int
+lua_rawequal(lua_State * L, int index1, int index2)
+{
   StkId o1 = luaA_indexAcceptable(L, index1);
   StkId o2 = luaA_indexAcceptable(L, index2);
-  return (o1 == NULL || o2 == NULL) ? 0  /* index out of range */
-                                    : luaO_rawequalObj(o1, o2);
+  return (o1 == NULL || o2 == NULL) ? 0 /* index out of range */
+    : luaO_rawequalObj(o1, o2);
 }
 
 
-LUA_API int lua_equal (lua_State *L, int index1, int index2) {
+LUA_API int
+lua_equal(lua_State * L, int index1, int index2)
+{
   StkId o1, o2;
   int i;
-  lua_lock(L);  /* may call tag method */
+  lua_lock(L);                  /* may call tag method */
   o1 = luaA_indexAcceptable(L, index1);
   o2 = luaA_indexAcceptable(L, index2);
-  i = (o1 == NULL || o2 == NULL) ? 0  /* index out of range */
-                                 : equalobj(L, o1, o2);
+  i = (o1 == NULL || o2 == NULL) ? 0    /* index out of range */
+    : equalobj(L, o1, o2);
   lua_unlock(L);
   return i;
 }
 
 
-LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
+LUA_API int
+lua_lessthan(lua_State * L, int index1, int index2)
+{
   StkId o1, o2;
   int i;
-  lua_lock(L);  /* may call tag method */
+  lua_lock(L);                  /* may call tag method */
   o1 = luaA_indexAcceptable(L, index1);
   o2 = luaA_indexAcceptable(L, index2);
-  i = (o1 == NULL || o2 == NULL) ? 0  /* index out-of-range */
-                                 : luaV_lessthan(L, o1, o2);
+  i = (o1 == NULL || o2 == NULL) ? 0    /* index out-of-range */
+    : luaV_lessthan(L, o1, o2);
   lua_unlock(L);
   return i;
 }
 
 
 
-LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
+LUA_API lua_Number
+lua_tonumber(lua_State * L, int idx)
+{
   TObject n;
   const TObject *o = luaA_indexAcceptable(L, idx);
   if (o != NULL && tonumber(o, &n))
@@ -301,13 +350,17 @@ LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
 }
 
 
-LUA_API int lua_toboolean (lua_State *L, int idx) {
+LUA_API int
+lua_toboolean(lua_State * L, int idx)
+{
   const TObject *o = luaA_indexAcceptable(L, idx);
   return (o != NULL) && !l_isfalse(o);
 }
 
 
-LUA_API const char *lua_tostring (lua_State *L, int idx) {
+LUA_API const char *
+lua_tostring(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
   if (o == NULL)
     return NULL;
@@ -315,7 +368,7 @@ LUA_API const char *lua_tostring (lua_State *L, int idx) {
     return svalue(o);
   else {
     const char *s;
-    lua_lock(L);  /* `luaV_tostring' may create a new string */
+    lua_lock(L);                /* `luaV_tostring' may create a new string */
     s = (luaV_tostring(L, o) ? svalue(o) : NULL);
     luaC_checkGC(L);
     lua_unlock(L);
@@ -324,7 +377,9 @@ LUA_API const char *lua_tostring (lua_State *L, int idx) {
 }
 
 
-LUA_API size_t lua_strlen (lua_State *L, int idx) {
+LUA_API size_t
+lua_strlen(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
   if (o == NULL)
     return 0;
@@ -332,7 +387,7 @@ LUA_API size_t lua_strlen (lua_State *L, int idx) {
     return tsvalue(o)->tsv.len;
   else {
     size_t l;
-    lua_lock(L);  /* `luaV_tostring' may create a new string */
+    lua_lock(L);                /* `luaV_tostring' may create a new string */
     l = (luaV_tostring(L, o) ? tsvalue(o)->tsv.len : 0);
     lua_unlock(L);
     return l;
@@ -340,41 +395,58 @@ LUA_API size_t lua_strlen (lua_State *L, int idx) {
 }
 
 
-LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
+LUA_API lua_CFunction
+lua_tocfunction(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
   return (o == NULL || !iscfunction(o)) ? NULL : clvalue(o)->c.f;
 }
 
 
-LUA_API void *lua_touserdata (lua_State *L, int idx) {
+LUA_API void *
+lua_touserdata(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
-  if (o == NULL) return NULL;
+  if (o == NULL)
+    return NULL;
   switch (ttype(o)) {
-    case LUA_TUSERDATA: return (uvalue(o) + 1);
-    case LUA_TLIGHTUSERDATA: return pvalue(o);
-    default: return NULL;
+  case LUA_TUSERDATA:
+    return (uvalue(o) + 1);
+  case LUA_TLIGHTUSERDATA:
+    return pvalue(o);
+  default:
+    return NULL;
   }
 }
 
 
-LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
+LUA_API lua_State *
+lua_tothread(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
   return (o == NULL || !ttisthread(o)) ? NULL : thvalue(o);
 }
 
 
-LUA_API const void *lua_topointer (lua_State *L, int idx) {
+LUA_API const void *
+lua_topointer(lua_State * L, int idx)
+{
   StkId o = luaA_indexAcceptable(L, idx);
-  if (o == NULL) return NULL;
+  if (o == NULL)
+    return NULL;
   else {
     switch (ttype(o)) {
-      case LUA_TTABLE: return hvalue(o);
-      case LUA_TFUNCTION: return clvalue(o);
-      case LUA_TTHREAD: return thvalue(o);
-      case LUA_TUSERDATA:
-      case LUA_TLIGHTUSERDATA:
-        return lua_touserdata(L, idx);
-      default: return NULL;
+    case LUA_TTABLE:
+      return hvalue(o);
+    case LUA_TFUNCTION:
+      return clvalue(o);
+    case LUA_TTHREAD:
+      return thvalue(o);
+    case LUA_TUSERDATA:
+    case LUA_TLIGHTUSERDATA:
+      return lua_touserdata(L, idx);
+    default:
+      return NULL;
     }
   }
 }
@@ -386,7 +458,9 @@ LUA_API const void *lua_topointer (lua_State *L, int idx) {
 */
 
 
-LUA_API void lua_pushnil (lua_State *L) {
+LUA_API void
+lua_pushnil(lua_State * L)
+{
   lua_lock(L);
   setnilvalue(L->top);
   api_incr_top(L);
@@ -394,7 +468,9 @@ LUA_API void lua_pushnil (lua_State *L) {
 }
 
 
-LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
+LUA_API void
+lua_pushnumber(lua_State * L, lua_Number n)
+{
   lua_lock(L);
   setnvalue(L->top, n);
   api_incr_top(L);
@@ -402,7 +478,9 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
 }
 
 
-LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
+LUA_API void
+lua_pushlstring(lua_State * L, const char *s, size_t len)
+{
   lua_lock(L);
   luaC_checkGC(L);
   setsvalue2s(L->top, luaS_newlstr(L, s, len));
@@ -411,7 +489,9 @@ LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
 }
 
 
-LUA_API void lua_pushstring (lua_State *L, const char *s) {
+LUA_API void
+lua_pushstring(lua_State * L, const char *s)
+{
   if (s == NULL)
     lua_pushnil(L);
   else
@@ -419,8 +499,9 @@ LUA_API void lua_pushstring (lua_State *L, const char *s) {
 }
 
 
-LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
-                                      va_list argp) {
+LUA_API const char *
+lua_pushvfstring(lua_State * L, const char *fmt, va_list argp)
+{
   const char *ret;
   lua_lock(L);
   luaC_checkGC(L);
@@ -430,7 +511,9 @@ LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
 }
 
 
-LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
+LUA_API const char *
+lua_pushfstring(lua_State * L, const char *fmt, ...)
+{
   const char *ret;
   va_list argp;
   lua_lock(L);
@@ -443,7 +526,9 @@ LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
 }
 
 
-LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
+LUA_API void
+lua_pushcclosure(lua_State * L, lua_CFunction fn, int n)
+{
   Closure *cl;
   lua_lock(L);
   luaC_checkGC(L);
@@ -452,14 +537,16 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
   cl->c.f = fn;
   L->top -= n;
   while (n--)
-    setobj2n(&cl->c.upvalue[n], L->top+n);
+    setobj2n(&cl->c.upvalue[n], L->top + n);
   setclvalue(L->top, cl);
   api_incr_top(L);
   lua_unlock(L);
 }
 
 
-LUA_API void lua_pushboolean (lua_State *L, int b) {
+LUA_API void
+lua_pushboolean(lua_State * L, int b)
+{
   lua_lock(L);
   setbvalue(L->top, (b != 0));  /* ensure that true is 1 */
   api_incr_top(L);
@@ -467,7 +554,9 @@ LUA_API void lua_pushboolean (lua_State *L, int b) {
 }
 
 
-LUA_API void lua_pushlightuserdata (lua_State *L, const void *p) {
+LUA_API void
+lua_pushlightuserdata(lua_State * L, const void *p)
+{
   lua_lock(L);
   setpvalue(L->top, (void *)p);
   api_incr_top(L);
@@ -481,7 +570,9 @@ LUA_API void lua_pushlightuserdata (lua_State *L, const void *p) {
 */
 
 
-LUA_API void lua_gettable (lua_State *L, int idx) {
+LUA_API void
+lua_gettable(lua_State * L, int idx)
+{
   StkId t;
   lua_lock(L);
   t = luaA_index(L, idx);
@@ -490,7 +581,9 @@ LUA_API void lua_gettable (lua_State *L, int idx) {
 }
 
 
-LUA_API void lua_rawget (lua_State *L, int idx) {
+LUA_API void
+lua_rawget(lua_State * L, int idx)
+{
   StkId t;
   lua_lock(L);
   t = luaA_index(L, idx);
@@ -500,7 +593,9 @@ LUA_API void lua_rawget (lua_State *L, int idx) {
 }
 
 
-LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
+LUA_API void
+lua_rawgeti(lua_State * L, int idx, int n)
+{
   StkId o;
   lua_lock(L);
   o = luaA_index(L, idx);
@@ -511,7 +606,9 @@ LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
 }
 
 
-LUA_API void lua_newtable (lua_State *L) {
+LUA_API void
+lua_newtable(lua_State * L)
+{
   lua_lock(L);
   luaC_checkGC(L);
   sethvalue(L->top, luaH_new(L, 0, 0));
@@ -520,7 +617,9 @@ LUA_API void lua_newtable (lua_State *L) {
 }
 
 
-LUA_API int lua_getmetatable (lua_State *L, int objindex) {
+LUA_API int
+lua_getmetatable(lua_State * L, int objindex)
+{
   const TObject *obj;
   Table *mt = NULL;
   int res;
@@ -528,12 +627,12 @@ LUA_API int lua_getmetatable (lua_State *L, int objindex) {
   obj = luaA_indexAcceptable(L, objindex);
   if (obj != NULL) {
     switch (ttype(obj)) {
-      case LUA_TTABLE:
-        mt = hvalue(obj)->metatable;
-        break;
-      case LUA_TUSERDATA:
-        mt = uvalue(obj)->uv.metatable;
-        break;
+    case LUA_TTABLE:
+      mt = hvalue(obj)->metatable;
+      break;
+    case LUA_TUSERDATA:
+      mt = uvalue(obj)->uv.metatable;
+      break;
     }
   }
   if (mt == NULL || mt == hvalue(defaultmeta(L)))
@@ -548,7 +647,9 @@ LUA_API int lua_getmetatable (lua_State *L, int objindex) {
 }
 
 
-LUA_API void lua_getfenv (lua_State *L, int idx) {
+LUA_API void
+lua_getfenv(lua_State * L, int idx)
+{
   StkId o;
   lua_lock(L);
   o = luaA_index(L, idx);
@@ -563,42 +664,50 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
 */
 
 
-LUA_API void lua_settable (lua_State *L, int idx) {
+LUA_API void
+lua_settable(lua_State * L, int idx)
+{
   StkId t;
   lua_lock(L);
   api_checknelems(L, 2);
   t = luaA_index(L, idx);
   luaV_settable(L, t, L->top - 2, L->top - 1);
-  L->top -= 2;  /* pop index and value */
+  L->top -= 2;                  /* pop index and value */
   lua_unlock(L);
 }
 
 
-LUA_API void lua_rawset (lua_State *L, int idx) {
+LUA_API void
+lua_rawset(lua_State * L, int idx)
+{
   StkId t;
   lua_lock(L);
   api_checknelems(L, 2);
   t = luaA_index(L, idx);
   api_check(L, ttistable(t));
-  setobj2t(luaH_set(L, hvalue(t), L->top-2), L->top-1);  /* write barrier */
+  setobj2t(luaH_set(L, hvalue(t), L->top - 2), L->top - 1);     /* write barrier */
   L->top -= 2;
   lua_unlock(L);
 }
 
 
-LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
+LUA_API void
+lua_rawseti(lua_State * L, int idx, int n)
+{
   StkId o;
   lua_lock(L);
   api_checknelems(L, 1);
   o = luaA_index(L, idx);
   api_check(L, ttistable(o));
-  setobj2t(luaH_setnum(L, hvalue(o), n), L->top-1);  /* write barrier */
+  setobj2t(luaH_setnum(L, hvalue(o), n), L->top - 1);   /* write barrier */
   L->top--;
   lua_unlock(L);
 }
 
 
-LUA_API int lua_setmetatable (lua_State *L, int objindex) {
+LUA_API int
+lua_setmetatable(lua_State * L, int objindex)
+{
   TObject *obj, *mt;
   int res = 1;
   lua_lock(L);
@@ -607,16 +716,16 @@ LUA_API int 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: {
-      hvalue(obj)->metatable = hvalue(mt);  /* write barrier */
+  case LUA_TTABLE:{
+      hvalue(obj)->metatable = hvalue(mt);      /* write barrier */
       break;
     }
-    case LUA_TUSERDATA: {
-      uvalue(obj)->uv.metatable = hvalue(mt);  /* write barrier */
+  case LUA_TUSERDATA:{
+      uvalue(obj)->uv.metatable = hvalue(mt);   /* write barrier */
       break;
     }
-    default: {
-      res = 0;  /* cannot set */
+  default:{
+      res = 0;                  /* cannot set */
       break;
     }
   }
@@ -626,7 +735,9 @@ LUA_API int lua_setmetatable (lua_State *L, int objindex) {
 }
 
 
-LUA_API int lua_setfenv (lua_State *L, int idx) {
+LUA_API int
+lua_setfenv(lua_State * L, int idx)
+{
   StkId o;
   int res = 0;
   lua_lock(L);
@@ -647,11 +758,13 @@ LUA_API int lua_setfenv (lua_State *L, int idx) {
 ** `load' and `call' functions (run Lua code)
 */
 
-LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
+LUA_API void
+lua_call(lua_State * L, int nargs, int nresults)
+{
   StkId func;
   lua_lock(L);
-  api_checknelems(L, nargs+1);
-  func = L->top - (nargs+1);
+  api_checknelems(L, nargs + 1);
+  func = L->top - (nargs + 1);
   luaD_call(L, func, nresults);
   lua_unlock(L);
 }
@@ -661,26 +774,30 @@ LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
 /*
 ** Execute a protected call.
 */
-struct CallS {  /* data to `f_call' */
+struct CallS {                         /* data to `f_call' */
   StkId func;
   int nresults;
 };
 
 
-static void f_call (lua_State *L, void *ud) {
+static void
+f_call(lua_State * L, void *ud)
+{
   struct CallS *c = cast(struct CallS *, ud);
   luaD_call(L, c->func, c->nresults);
 }
 
 
 
-LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
+LUA_API int
+lua_pcall(lua_State * L, int nargs, int nresults, int errfunc)
+{
   struct CallS c;
   int status;
   ptrdiff_t func;
   lua_lock(L);
   func = (errfunc == 0) ? 0 : savestack(L, luaA_index(L, errfunc));
-  c.func = L->top - (nargs+1);  /* function to be called */
+  c.func = L->top - (nargs + 1);        /* function to be called */
   c.nresults = nresults;
   status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
   lua_unlock(L);
@@ -691,26 +808,30 @@ LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
 /*
 ** Execute a protected C call.
 */
-struct CCallS {  /* data to `f_Ccall' */
+struct CCallS {                        /* data to `f_Ccall' */
   lua_CFunction func;
   void *ud;
 };
 
 
-static void f_Ccall (lua_State *L, void *ud) {
+static void
+f_Ccall(lua_State * L, void *ud)
+{
   struct CCallS *c = cast(struct CCallS *, ud);
   Closure *cl;
   cl = luaF_newCclosure(L, 0);
   cl->c.f = c->func;
-  setclvalue(L->top, cl);  /* push function */
+  setclvalue(L->top, cl);       /* push function */
   incr_top(L);
-  setpvalue(L->top, c->ud);  /* push only argument */
+  setpvalue(L->top, c->ud);     /* push only argument */
   incr_top(L);
   luaD_call(L, L->top - 2, 0);
 }
 
 
-LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
+LUA_API int
+lua_cpcall(lua_State * L, lua_CFunction func, void *ud)
+{
   struct CCallS c;
   int status;
   lua_lock(L);
@@ -722,13 +843,15 @@ LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
 }
 
 
-LUA_API int lua_load (lua_State *L, lua_Chunkreader reader, void *data,
-                      const char *chunkname) {
+LUA_API int
+lua_load(lua_State * L, lua_Chunkreader reader, void *data, const char *chunkname)
+{
   ZIO z;
   int status;
   int c;
   lua_lock(L);
-  if (!chunkname) chunkname = "?";
+  if (!chunkname)
+    chunkname = "?";
   luaZ_init(&z, reader, data, chunkname);
   c = luaZ_lookahead(&z);
   status = luaD_protectedparser(L, &z, (c == LUA_SIGNATURE[0]));
@@ -737,7 +860,9 @@ LUA_API int lua_load (lua_State *L, lua_Chunkreader reader, void *data,
 }
 
 
-LUA_API int lua_dump (lua_State *L, lua_Chunkwriter writer, void *data) {
+LUA_API int
+lua_dump(lua_State * L, lua_Chunkwriter writer, void *data)
+{
   int status;
   TObject *o;
   lua_lock(L);
@@ -746,8 +871,7 @@ LUA_API int lua_dump (lua_State *L, lua_Chunkwriter writer, void *data) {
   if (isLfunction(o) && clvalue(o)->l.nupvalues == 0) {
     luaU_dump(L, clvalue(o)->l.p, writer, data);
     status = 1;
-  }
-  else
+  } else
     status = 0;
   lua_unlock(L);
   return status;
@@ -763,7 +887,9 @@ LUA_API int lua_dump (lua_State *L, lua_Chunkwriter writer, void *data) {
 #define GCscale(x)             (cast(int, GCscalel(x)))
 #define GCunscale(x)           (cast(lu_mem, x)<<10)
 
-LUA_API int lua_getgcthreshold (lua_State *L) {
+LUA_API int
+lua_getgcthreshold(lua_State * L)
+{
   int threshold;
   lua_lock(L);
   threshold = GCscale(G(L)->GCthreshold);
@@ -771,7 +897,9 @@ LUA_API int lua_getgcthreshold (lua_State *L) {
   return threshold;
 }
 
-LUA_API int lua_getgccount (lua_State *L) {
+LUA_API int
+lua_getgccount(lua_State * L)
+{
   int count;
   lua_lock(L);
   count = GCscale(G(L)->nblocks);
@@ -779,7 +907,9 @@ LUA_API int lua_getgccount (lua_State *L) {
   return count;
 }
 
-LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) {
+LUA_API void
+lua_setgcthreshold(lua_State * L, int newthreshold)
+{
   lua_lock(L);
   if (cast(lu_mem, newthreshold) > GCscalel(MAX_LUMEM))
     G(L)->GCthreshold = MAX_LUMEM;
@@ -795,12 +925,16 @@ LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) {
 */
 
 
-LUA_API const char *lua_version (void) {
+LUA_API const char *
+lua_version(void)
+{
   return LUA_VERSION;
 }
 
 
-LUA_API int lua_error (lua_State *L) {
+LUA_API int
+lua_error(lua_State * L)
+{
   lua_lock(L);
   api_checknelems(L, 1);
   luaG_errormsg(L);
@@ -808,7 +942,9 @@ LUA_API int lua_error (lua_State *L) {
 }
 
 
-LUA_API int lua_next (lua_State *L, int idx) {
+LUA_API int
+lua_next(lua_State * L, int idx)
+{
   StkId t;
   int more;
   lua_lock(L);
@@ -817,23 +953,23 @@ LUA_API int lua_next (lua_State *L, int idx) {
   more = luaH_next(L, hvalue(t), L->top - 1);
   if (more) {
     api_incr_top(L);
-  }
-  else  /* no more elements */
-    L->top -= 1;  /* remove key */
+  } else                        /* no more elements */
+    L->top -= 1;                /* remove key */
   lua_unlock(L);
   return more;
 }
 
 
-LUA_API void lua_concat (lua_State *L, int n) {
+LUA_API void
+lua_concat(lua_State * L, int n)
+{
   lua_lock(L);
   luaC_checkGC(L);
   api_checknelems(L, n);
   if (n >= 2) {
     luaV_concat(L, n, L->top - L->base - 1);
-    L->top -= (n-1);
-  }
-  else if (n == 0) {  /* push empty string */
+    L->top -= (n - 1);
+  } else if (n == 0) {          /* push empty string */
     setsvalue2s(L->top, luaS_newlstr(L, NULL, 0));
     api_incr_top(L);
   }
@@ -842,7 +978,9 @@ LUA_API void lua_concat (lua_State *L, int n) {
 }
 
 
-LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
+LUA_API void *
+lua_newuserdata(lua_State * L, size_t size)
+{
   Udata *u;
   lua_lock(L);
   luaC_checkGC(L);
@@ -854,7 +992,9 @@ LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
 }
 
 
-LUA_API int lua_pushupvalues (lua_State *L) {
+LUA_API int
+lua_pushupvalues(lua_State * L)
+{
   Closure *func;
   int n, i;
   lua_lock(L);
@@ -862,7 +1002,7 @@ LUA_API int lua_pushupvalues (lua_State *L) {
   func = clvalue(L->base - 1);
   n = func->c.nupvalues;
   luaD_checkstack(L, n + LUA_MINSTACK);
-  for (i=0; i<n; i++) {
+  for (i = 0; i < n; i++) {
     setobj2s(L->top, &func->c.upvalue[i]);
     L->top++;
   }
@@ -871,27 +1011,32 @@ LUA_API int lua_pushupvalues (lua_State *L) {
 }
 
 
-static const char *aux_upvalue (lua_State *L, int funcindex, int n,
-                                TObject **val) {
+static const char *
+aux_upvalue(lua_State * L, int funcindex, int n, TObject ** val)
+{
   Closure *f;
   StkId fi = luaA_index(L, funcindex);
-  if (!ttisfunction(fi)) return NULL;
+  if (!ttisfunction(fi))
+    return NULL;
   f = clvalue(fi);
   if (f->c.isC) {
-    if (n > f->c.nupvalues) return NULL;
-    *val = &f->c.upvalue[n-1];
+    if (n > f->c.nupvalues)
+      return NULL;
+    *val = &f->c.upvalue[n - 1];
     return "";
-  }
-  else {
+  } else {
     Proto *p = f->l.p;
-    if (n > p->sizeupvalues) return NULL;
-    *val = f->l.upvals[n-1]->v;
-    return getstr(p->upvalues[n-1]);
+    if (n > p->sizeupvalues)
+      return NULL;
+    *val = f->l.upvals[n - 1]->v;
+    return getstr(p->upvalues[n - 1]);
   }
 }
 
 
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
+LUA_API const char *
+lua_getupvalue(lua_State * L, int funcindex, int n)
+{
   const char *name;
   TObject *val;
   lua_lock(L);
@@ -905,7 +1050,9 @@ LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
 }
 
 
-LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
+LUA_API const char *
+lua_setupvalue(lua_State * L, int funcindex, int n)
+{
   const char *name;
   TObject *val;
   lua_lock(L);
@@ -913,9 +1060,8 @@ LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
   name = aux_upvalue(L, funcindex, n, &val);
   if (name) {
     L->top--;
-    setobj(val, L->top);  /* write barrier */
+    setobj(val, L->top);        /* write barrier */
   }
   lua_unlock(L);
   return name;
 }
-
index d12612f..2098b74 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lapi.h,v 1.21 2002/03/04 21:29:41 roberto Exp $
 ** Auxiliary functions from Lua API
@@ -11,6 +12,6 @@
 #include "lobject.h"
 
 
-void luaA_pushobject (lua_State *L, const TObject *o);
+void luaA_pushobject(lua_State * L, const TObject * o);
 
 #endif
index 6093a5f..cf45ff1 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lauxlib.c,v 1.100 2003/04/07 14:35:00 roberto Exp $
 ** Auxiliary functions for building Lua libraries
@@ -27,8 +28,8 @@
 #define RESERVED_REFS  2
 
 /* reserved references */
-#define FREELIST_REF   1       /* free list of references */
-#define ARRAYSIZE_REF  2       /* array sizes */
+#define FREELIST_REF   1       /* free list of references */
+#define ARRAYSIZE_REF  2       /* array sizes */
 
 
 /* convert a stack index to positive */
 */
 
 
-LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+LUALIB_API int
+luaL_argerror(lua_State * L, int narg, const char *extramsg)
+{
   lua_Debug ar;
   lua_getstack(L, 0, &ar);
   lua_getinfo(L, "n", &ar);
   if (strcmp(ar.namewhat, "method") == 0) {
-    narg--;  /* do not count `self' */
-    if (narg == 0)  /* error is in the self argument itself? */
+    narg--;                     /* do not count `self' */
+    if (narg == 0)              /* error is in the self argument itself? */
       luaL_error(L, "calling `%s' on bad self (%s)", ar.name, extramsg);
   }
   if (ar.name == NULL)
     ar.name = "?";
-  luaL_error(L, "bad argument #%d to `%s' (%s)",
-                        narg, ar.name, 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) {
+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) {
-  luaL_typerror(L, narg, lua_typename(L, tag)); 
+static void tag_error(lua_State * L, int narg, int tag) __attribute__ ((noreturn));
+static void
+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) {
+LUALIB_API void
+luaL_where(lua_State * L, int level)
+{
   lua_Debug ar;
-  if (lua_getstack(L, level, &ar)) {  /* check function at level */
-    lua_getinfo(L, "Snl", &ar);  /* get info about it */
-    if (ar.currentline > 0) {  /* is there info? */
+  if (lua_getstack(L, level, &ar)) {    /* check function at level */
+    lua_getinfo(L, "Snl", &ar); /* get info about it */
+    if (ar.currentline > 0) {   /* is there info? */
       lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
       return;
     }
   }
-  lua_pushliteral(L, "");  /* else, no information available... */
+  lua_pushliteral(L, "");       /* else, no information available... */
 }
 
 
-LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
+LUALIB_API int
+luaL_error(lua_State * L, const char *fmt, ...)
+{
   va_list argp;
   va_start(argp, fmt);
   luaL_where(L, 1);
@@ -98,124 +108,152 @@ LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
 /* }====================================================== */
 
 
-LUALIB_API int luaL_findstring (const char *name, const char *const list[]) {
+LUALIB_API int
+luaL_findstring(const char *name, const char *const list[])
+{
   int i;
-  for (i=0; list[i]; i++)
+  for (i = 0; list[i]; i++)
     if (strcmp(list[i], name) == 0)
       return i;
-  return -1;  /* name not found */
+  return -1;                    /* name not found */
 }
 
 
-LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
+LUALIB_API int
+luaL_newmetatable(lua_State * L, const char *tname)
+{
   lua_pushstring(L, tname);
-  lua_rawget(L, LUA_REGISTRYINDEX);  /* get registry.name */
-  if (!lua_isnil(L, -1))  /* name already in use? */
-    return 0;  /* leave previous value on top, but return 0 */
+  lua_rawget(L, LUA_REGISTRYINDEX);     /* get registry.name */
+  if (!lua_isnil(L, -1))        /* name already in use? */
+    return 0;                   /* leave previous value on top, but return 0 */
   lua_pop(L, 1);
-  lua_newtable(L);  /* create metatable */
+  lua_newtable(L);              /* create metatable */
   lua_pushstring(L, tname);
   lua_pushvalue(L, -2);
-  lua_rawset(L, LUA_REGISTRYINDEX);  /* registry.name = metatable */
+  lua_rawset(L, LUA_REGISTRYINDEX);     /* registry.name = metatable */
   lua_pushvalue(L, -1);
   lua_pushstring(L, tname);
-  lua_rawset(L, LUA_REGISTRYINDEX);  /* registry[metatable] = name */
+  lua_rawset(L, LUA_REGISTRYINDEX);     /* registry[metatable] = name */
   return 1;
 }
 
 
-LUALIB_API void  luaL_getmetatable (lua_State *L, const char *tname) {
+LUALIB_API void
+luaL_getmetatable(lua_State * L, const char *tname)
+{
   lua_pushstring(L, tname);
   lua_rawget(L, LUA_REGISTRYINDEX);
 }
 
 
-LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
+LUALIB_API void *
+luaL_checkudata(lua_State * L, int ud, const char *tname)
+{
   const char *tn;
-  if (!lua_getmetatable(L, ud)) return NULL;  /* no metatable? */
-  lua_rawget(L, LUA_REGISTRYINDEX);  /* get registry[metatable] */
+  if (!lua_getmetatable(L, ud))
+    return NULL;                /* no metatable? */
+  lua_rawget(L, LUA_REGISTRYINDEX);     /* get registry[metatable] */
   tn = lua_tostring(L, -1);
   if (tn && (strcmp(tn, tname) == 0)) {
     lua_pop(L, 1);
     return lua_touserdata(L, ud);
-  }
-  else {
+  } else {
     lua_pop(L, 1);
     return NULL;
   }
 }
 
 
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
+LUALIB_API void
+luaL_checkstack(lua_State * L, int space, const char *mes)
+{
   if (!lua_checkstack(L, space))
     luaL_error(L, "stack overflow (%s)", mes);
 }
 
 
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
+LUALIB_API void
+luaL_checktype(lua_State * L, int narg, int t)
+{
   if (lua_type(L, narg) != t)
     tag_error(L, narg, t);
 }
 
 
-LUALIB_API void luaL_checkany (lua_State *L, int narg) {
+LUALIB_API void
+luaL_checkany(lua_State * L, int narg)
+{
   if (lua_type(L, narg) == LUA_TNONE)
     luaL_argerror(L, narg, "value expected");
 }
 
 
-LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
+LUALIB_API const char *
+luaL_checklstring(lua_State * L, int narg, size_t * len)
+{
   const char *s = lua_tostring(L, narg);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
-  if (len) *len = lua_strlen(L, narg);
+  if (!s)
+    tag_error(L, narg, LUA_TSTRING);
+  if (len)
+    *len = lua_strlen(L, narg);
   return s;
 }
 
 
-LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
-                                        const char *def, size_t *len) {
+LUALIB_API const char *
+luaL_optlstring(lua_State * L, int narg, const char *def, size_t * len)
+{
   if (lua_isnoneornil(L, narg)) {
     if (len)
       *len = (def ? strlen(def) : 0);
     return def;
-  }
-  else return luaL_checklstring(L, narg, len);
+  } else
+    return luaL_checklstring(L, narg, len);
 }
 
 
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
+LUALIB_API lua_Number
+luaL_checknumber(lua_State * L, int narg)
+{
   lua_Number d = lua_tonumber(L, narg);
-  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+  if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
     tag_error(L, narg, LUA_TNUMBER);
   return d;
 }
 
 
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
-  if (lua_isnoneornil(L, narg)) return def;
-  else return luaL_checknumber(L, narg);
+LUALIB_API lua_Number
+luaL_optnumber(lua_State * L, int narg, lua_Number def)
+{
+  if (lua_isnoneornil(L, narg))
+    return def;
+  else
+    return luaL_checknumber(L, narg);
 }
 
 
-LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
-  if (!lua_getmetatable(L, obj))  /* no metatable? */
+LUALIB_API int
+luaL_getmetafield(lua_State * L, int obj, const char *event)
+{
+  if (!lua_getmetatable(L, obj))        /* no metatable? */
     return 0;
   lua_pushstring(L, event);
   lua_rawget(L, -2);
   if (lua_isnil(L, -1)) {
-    lua_pop(L, 2);  /* remove metatable and metafield */
+    lua_pop(L, 2);              /* remove metatable and metafield */
     return 0;
-  }
-  else {
-    lua_remove(L, -2);  /* remove only metatable */
+  } else {
+    lua_remove(L, -2);          /* remove only metatable */
     return 1;
   }
 }
 
 
-LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
+LUALIB_API int
+luaL_callmeta(lua_State * L, int obj, const char *event)
+{
   obj = abs_index(L, obj);
-  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
+  if (!luaL_getmetafield(L, obj, event))        /* no metafield? */
     return 0;
   lua_pushvalue(L, obj);
   lua_call(L, 1, 1);
@@ -223,29 +261,30 @@ LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
 }
 
 
-LUALIB_API void luaL_openlib (lua_State *L, const char *libname,
-                              const luaL_reg *l, int nup) {
+LUALIB_API void
+luaL_openlib(lua_State * L, const char *libname, const luaL_reg * l, int nup)
+{
   if (libname) {
     lua_pushstring(L, libname);
     lua_gettable(L, LUA_GLOBALSINDEX);  /* check whether lib already exists */
-    if (lua_isnil(L, -1)) {  /* no? */
+    if (lua_isnil(L, -1)) {     /* no? */
       lua_pop(L, 1);
-      lua_newtable(L);  /* create it */
+      lua_newtable(L);          /* create it */
       lua_pushstring(L, libname);
       lua_pushvalue(L, -2);
-      lua_settable(L, LUA_GLOBALSINDEX);  /* register it with given name */
+      lua_settable(L, LUA_GLOBALSINDEX);        /* register it with given name */
     }
-    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
+    lua_insert(L, -(nup + 1));  /* move library table to below upvalues */
   }
   for (; l->name; l++) {
     int i;
     lua_pushstring(L, l->name);
-    for (i=0; i<nup; i++)  /* copy upvalues to the top */
-      lua_pushvalue(L, -(nup+1));
+    for (i = 0; i < nup; i++)   /* copy upvalues to the top */
+      lua_pushvalue(L, -(nup + 1));
     lua_pushcclosure(L, l->func, nup);
-    lua_settable(L, -(nup+3));
+    lua_settable(L, -(nup + 3));
   }
-  lua_pop(L, nup);  /* remove upvalues */
+  lua_pop(L, nup);              /* remove upvalues */
 }
 
 
@@ -256,62 +295,73 @@ LUALIB_API void luaL_openlib (lua_State *L, const char *libname,
 ** =======================================================
 */
 
-static int checkint (lua_State *L, int topop) {
+static int
+checkint(lua_State * L, int topop)
+{
   int n = lua_tonumber(L, -1);
-  if (n == 0 && !lua_isnumber(L, -1)) n = -1;
+  if (n == 0 && !lua_isnumber(L, -1))
+    n = -1;
   lua_pop(L, topop);
   return n;
 }
 
 
-static void getsizes (lua_State *L) {
+static void
+getsizes(lua_State * L)
+{
   lua_rawgeti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF);
-  if (lua_isnil(L, -1)) {  /* no `size' table? */
-    lua_pop(L, 1);  /* remove nil */
-    lua_newtable(L);  /* create it */
-    lua_pushvalue(L, -1);  /* `size' will be its own metatable */
+  if (lua_isnil(L, -1)) {       /* no `size' table? */
+    lua_pop(L, 1);              /* remove nil */
+    lua_newtable(L);            /* create it */
+    lua_pushvalue(L, -1);       /* `size' will be its own metatable */
     lua_setmetatable(L, -2);
     lua_pushliteral(L, "__mode");
     lua_pushliteral(L, "k");
-    lua_rawset(L, -3);  /* metatable(N).__mode = "k" */
+    lua_rawset(L, -3);          /* metatable(N).__mode = "k" */
     lua_pushvalue(L, -1);
-    lua_rawseti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF);  /* store in register */
+    lua_rawseti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF);   /* store in register */
   }
 }
 
 
-void luaL_setn (lua_State *L, int t, int n) {
+void
+luaL_setn(lua_State * L, int t, int n)
+{
   t = abs_index(L, t);
   lua_pushliteral(L, "n");
   lua_rawget(L, t);
-  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */
-    lua_pushliteral(L, "n");  /* use it */
-    lua_pushnumber(L, (lua_Number)n);
+  if (checkint(L, 1) >= 0) {    /* is there a numeric field `n'? */
+    lua_pushliteral(L, "n");    /* use it */
+    lua_pushnumber(L, (lua_Number) n);
     lua_rawset(L, t);
-  }
-  else {  /* use `sizes' */
+  } else {                      /* use `sizes' */
     getsizes(L);
     lua_pushvalue(L, t);
-    lua_pushnumber(L, (lua_Number)n);
-    lua_rawset(L, -3);  /* sizes[t] = n */
-    lua_pop(L, 1);  /* remove `sizes' */
+    lua_pushnumber(L, (lua_Number) n);
+    lua_rawset(L, -3);          /* sizes[t] = n */
+    lua_pop(L, 1);              /* remove `sizes' */
   }
 }
 
 
-int luaL_getn (lua_State *L, int t) {
+int
+luaL_getn(lua_State * L, int t)
+{
   int n;
   t = abs_index(L, t);
-  lua_pushliteral(L, "n");  /* try t.n */
+  lua_pushliteral(L, "n");      /* try t.n */
   lua_rawget(L, t);
-  if ((n = checkint(L, 1)) >= 0) return n;
-  getsizes(L);  /* else try sizes[t] */
+  if ((n = checkint(L, 1)) >= 0)
+    return n;
+  getsizes(L);                  /* else try sizes[t] */
   lua_pushvalue(L, t);
   lua_rawget(L, -2);
-  if ((n = checkint(L, 2)) >= 0) return n;
-  for (n = 1; ; n++) {  /* else must count elements */
+  if ((n = checkint(L, 2)) >= 0)
+    return n;
+  for (n = 1;; n++) {           /* else must count elements */
     lua_rawgeti(L, t, n);
-    if (lua_isnil(L, -1)) break;
+    if (lua_isnil(L, -1))
+      break;
     lua_pop(L, 1);
   }
   lua_pop(L, 1);
@@ -335,9 +385,12 @@ int luaL_getn (lua_State *L, int t) {
 #define LIMIT  (LUA_MINSTACK/2)
 
 
-static int emptybuffer (luaL_Buffer *B) {
+static int
+emptybuffer(luaL_Buffer * B)
+{
   size_t l = bufflen(B);
-  if (l == 0) return 0;  /* put nothing on stack */
+  if (l == 0)
+    return 0;                   /* put nothing on stack */
   else {
     lua_pushlstring(B->L, B->buffer, l);
     B->p = B->buffer;
@@ -347,18 +400,20 @@ static int emptybuffer (luaL_Buffer *B) {
 }
 
 
-static void adjuststack (luaL_Buffer *B) {
+static void
+adjuststack(luaL_Buffer * B)
+{
   if (B->lvl > 1) {
     lua_State *L = B->L;
-    int toget = 1;  /* number of levels to concat */
+    int toget = 1;                     /* number of levels to concat */
     size_t toplen = lua_strlen(L, -1);
     do {
-      size_t l = lua_strlen(L, -(toget+1));
+      size_t l = lua_strlen(L, -(toget + 1));
       if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
         toplen += l;
         toget++;
-      }
-      else break;
+      } else
+        break;
     } while (toget < B->lvl);
     lua_concat(L, toget);
     B->lvl = B->lvl - toget + 1;
@@ -366,49 +421,60 @@ static void adjuststack (luaL_Buffer *B) {
 }
 
 
-LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
+LUALIB_API char *
+luaL_prepbuffer(luaL_Buffer * B)
+{
   if (emptybuffer(B))
     adjuststack(B);
   return B->buffer;
 }
 
 
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
+LUALIB_API void
+luaL_addlstring(luaL_Buffer * B, const char *s, size_t l)
+{
   while (l--)
     luaL_putchar(B, *s++);
 }
 
 
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *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) {
+LUALIB_API void
+luaL_pushresult(luaL_Buffer * B)
+{
   emptybuffer(B);
   lua_concat(B->L, B->lvl);
   B->lvl = 1;
 }
 
 
-LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
+LUALIB_API void
+luaL_addvalue(luaL_Buffer * B)
+{
   lua_State *L = B->L;
   size_t vl = lua_strlen(L, -1);
-  if (vl <= bufffree(B)) {  /* fit into buffer? */
-    memcpy(B->p, lua_tostring(L, -1), vl);  /* put it there */
+  if (vl <= bufffree(B)) {      /* fit into buffer? */
+    memcpy(B->p, lua_tostring(L, -1), vl);      /* put it there */
     B->p += vl;
-    lua_pop(L, 1);  /* remove from stack */
-  }
-  else {
+    lua_pop(L, 1);              /* remove from stack */
+  } else {
     if (emptybuffer(B))
-      lua_insert(L, -2);  /* put buffer before new value */
-    B->lvl++;  /* add new value into B stack */
+      lua_insert(L, -2);        /* put buffer before new value */
+    B->lvl++;                   /* add new value into B stack */
     adjuststack(B);
   }
 }
 
 
-LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
+LUALIB_API void
+luaL_buffinit(lua_State * L, luaL_Buffer * B)
+{
   B->L = L;
   B->p = B->buffer;
   B->lvl = 0;
@@ -417,25 +483,26 @@ LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
 /* }====================================================== */
 
 
-LUALIB_API int luaL_ref (lua_State *L, int t) {
+LUALIB_API int
+luaL_ref(lua_State * L, int t)
+{
   int ref;
   t = abs_index(L, t);
   if (lua_isnil(L, -1)) {
-    lua_pop(L, 1);  /* remove from stack */
-    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
+    lua_pop(L, 1);              /* remove from stack */
+    return LUA_REFNIL;          /* `nil' has a unique fixed reference */
   }
-  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
-  ref = lua_tonumber(L, -1);  /* ref = t[FREELIST_REF] */
-  lua_pop(L, 1);  /* remove it from stack */
-  if (ref != 0) {  /* any free element? */
-    lua_rawgeti(L, t, ref);  /* remove it from list */
-    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
-  }
-  else {  /* no free elements */
+  lua_rawgeti(L, t, FREELIST_REF);      /* get first free element */
+  ref = lua_tonumber(L, -1);    /* ref = t[FREELIST_REF] */
+  lua_pop(L, 1);                /* remove it from stack */
+  if (ref != 0) {               /* any free element? */
+    lua_rawgeti(L, t, ref);     /* remove it from list */
+    lua_rawseti(L, t, FREELIST_REF);    /* (t[FREELIST_REF] = t[ref]) */
+  } else {                      /* no free elements */
     ref = luaL_getn(L, t);
     if (ref < RESERVED_REFS)
-      ref = RESERVED_REFS;  /* skip reserved references */
-    ref++;  /* create new reference */
+      ref = RESERVED_REFS;      /* skip reserved references */
+    ref++;                      /* create new reference */
     luaL_setn(L, t, ref);
   }
   lua_rawseti(L, t, ref);
@@ -443,13 +510,15 @@ LUALIB_API int luaL_ref (lua_State *L, int t) {
 }
 
 
-LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
+LUALIB_API void
+luaL_unref(lua_State * L, int t, int ref)
+{
   if (ref >= 0) {
     t = abs_index(L, t);
     lua_rawgeti(L, t, FREELIST_REF);
-    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
-    lua_pushnumber(L, (lua_Number)ref);
-    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
+    lua_rawseti(L, t, ref);     /* t[ref] = t[FREELIST_REF] */
+    lua_pushnumber(L, (lua_Number) ref);
+    lua_rawseti(L, t, FREELIST_REF);    /* t[FREELIST_REF] = ref */
   }
 }
 
@@ -467,16 +536,21 @@ typedef struct LoadF {
 } LoadF;
 
 
-static const char *getF (lua_State *L, void *ud, size_t *size) {
-  LoadF *lf = (LoadF *)ud;
+static const char *
+getF(lua_State * L, void *ud, size_t * size)
+{
+  LoadF *lf = (LoadF *) ud;
   (void)L;
-  if (feof(lf->f)) return NULL;
+  if (feof(lf->f))
+    return NULL;
   *size = fread(lf->buff, 1, LUAL_BUFFERSIZE, lf->f);
   return (*size > 0) ? lf->buff : NULL;
 }
 
 
-static int errfile (lua_State *L, int fnameindex) {
+static int
+errfile(lua_State * L, int fnameindex)
+{
   const char *filename = lua_tostring(L, fnameindex) + 1;
   lua_pushfstring(L, "cannot read %s: %s", filename, strerror(errno));
   lua_remove(L, fnameindex);
@@ -484,7 +558,9 @@ static int errfile (lua_State *L, int fnameindex) {
 }
 
 
-LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
+LUALIB_API int
+luaL_loadfile(lua_State * L, const char *filename)
+{
   LoadF lf;
   int status, readstatus;
   int c;
@@ -492,21 +568,23 @@ LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
   if (filename == NULL) {
     lua_pushliteral(L, "=stdin");
     lf.f = stdin;
-  }
-  else {
+  } else {
     lua_pushfstring(L, "@%s", filename);
     lf.f = fopen(filename, "r");
   }
-  if (lf.f == NULL) return errfile(L, fnameindex);  /* unable to open file */
+  if (lf.f == NULL)
+    return errfile(L, fnameindex);      /* unable to open file */
   c = ungetc(getc(lf.f), lf.f);
-  if (!(isspace(c) || isprint(c)) && lf.f != stdin) {  /* binary file? */
+  if (!(isspace(c) || isprint(c)) && lf.f != stdin) {   /* binary file? */
     fclose(lf.f);
-    lf.f = fopen(filename, "rb");  /* reopen in binary mode */
-    if (lf.f == NULL) return errfile(L, fnameindex); /* unable to reopen file */
+    lf.f = fopen(filename, "rb");       /* reopen in binary mode */
+    if (lf.f == NULL)
+      return errfile(L, fnameindex);    /* unable to reopen file */
   }
   status = lua_load(L, getF, &lf, lua_tostring(L, -1));
   readstatus = ferror(lf.f);
-  if (lf.f != stdin) fclose(lf.f);  /* close file (even in case of errors) */
+  if (lf.f != stdin)
+    fclose(lf.f);               /* close file (even in case of errors) */
   if (readstatus) {
     lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
     return errfile(L, fnameindex);
@@ -522,18 +600,22 @@ typedef struct LoadS {
 } LoadS;
 
 
-static const char *getS (lua_State *L, void *ud, size_t *size) {
-  LoadS *ls = (LoadS *)ud;
+static const char *
+getS(lua_State * L, void *ud, size_t * size)
+{
+  LoadS *ls = (LoadS *) ud;
   (void)L;
-  if (ls->size == 0) return NULL;
+  if (ls->size == 0)
+    return NULL;
   *size = ls->size;
   ls->size = 0;
   return ls->s;
 }
 
 
-LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
-                                const char *name) {
+LUALIB_API int
+luaL_loadbuffer(lua_State * L, const char *buff, size_t size, const char *name)
+{
   LoadS ls;
   ls.s = buff;
   ls.size = size;
@@ -550,42 +632,50 @@ LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
 */
 
 
-static void callalert (lua_State *L, int status) {
+static void
+callalert(lua_State * L, int status)
+{
   if (status != 0) {
     lua_getglobal(L, "_ALERT");
     if (lua_isfunction(L, -1)) {
       lua_insert(L, -2);
       lua_call(L, 1, 0);
-    }
-    else {  /* no _ALERT function; print it on stderr */
+    } else {                    /* no _ALERT function; print it on stderr */
       fprintf(stderr, "%s\n", lua_tostring(L, -2));
-      lua_pop(L, 2);  /* remove error message and _ALERT */
+      lua_pop(L, 2);            /* remove error message and _ALERT */
     }
   }
 }
 
 
-static int aux_do (lua_State *L, int status) {
-  if (status == 0) {  /* parse OK? */
-    status = lua_pcall(L, 0, LUA_MULTRET, 0);  /* call main */
+static int
+aux_do(lua_State * L, int status)
+{
+  if (status == 0) {            /* parse OK? */
+    status = lua_pcall(L, 0, LUA_MULTRET, 0);   /* call main */
   }
   callalert(L, status);
   return status;
 }
 
 
-LUALIB_API int lua_dofile (lua_State *L, const char *filename) {
+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) {
+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) {
+LUALIB_API int
+lua_dostring(lua_State * L, const char *str)
+{
   return lua_dobuffer(L, str, strlen(str), str);
 }
 
index 4dd22b1..ff47cb0 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lauxlib.h,v 1.60 2003/04/03 13:35:34 roberto Exp $
 ** Auxiliary functions for building Lua libraries
@@ -27,40 +28,37 @@ typedef struct luaL_reg {
 } 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);
-LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) __attribute__((noreturn));
-LUALIB_API int luaL_argerror (lua_State *L, int numarg, const char *extramsg) __attribute__((noreturn));
-LUALIB_API const char *luaL_checklstring (lua_State *L, int numArg, size_t *l);
-LUALIB_API const char *luaL_optlstring (lua_State *L, int numArg,
-                                           const char *def, size_t *l);
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int numArg);
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int nArg, lua_Number def);
+LUALIB_API 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);
+LUALIB_API int luaL_typerror(lua_State * L, int narg, const char *tname) __attribute__ ((noreturn));
+LUALIB_API int luaL_argerror(lua_State * L, int numarg, const char *extramsg) __attribute__ ((noreturn));
+LUALIB_API const char *luaL_checklstring(lua_State * L, int numArg, size_t * l);
+LUALIB_API const char *luaL_optlstring(lua_State * L, int numArg, const char *def, size_t * l);
+LUALIB_API lua_Number luaL_checknumber(lua_State * L, int numArg);
+LUALIB_API lua_Number luaL_optnumber(lua_State * L, int nArg, lua_Number def);
 
-LUALIB_API void luaL_checkstack (lua_State *L, int sz, const char *msg);
-LUALIB_API void luaL_checktype (lua_State *L, int narg, int t);
-LUALIB_API void luaL_checkany (lua_State *L, int narg);
+LUALIB_API void luaL_checkstack(lua_State * L, int sz, const char *msg);
+LUALIB_API void luaL_checktype(lua_State * L, int narg, int t);
+LUALIB_API void luaL_checkany(lua_State * L, int narg);
 
-LUALIB_API int   luaL_newmetatable (lua_State *L, const char *tname);
-LUALIB_API void  luaL_getmetatable (lua_State *L, const char *tname);
-LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname);
+LUALIB_API int luaL_newmetatable(lua_State * L, const char *tname);
+LUALIB_API void luaL_getmetatable(lua_State * L, const char *tname);
+LUALIB_API void *luaL_checkudata(lua_State * L, int ud, const char *tname);
 
-LUALIB_API void luaL_where (lua_State *L, int lvl);
-LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) __attribute__((noreturn));
+LUALIB_API void luaL_where(lua_State * L, int lvl);
+LUALIB_API int luaL_error(lua_State * L, const char *fmt, ...) __attribute__ ((noreturn));
 
-LUALIB_API int luaL_findstring (const char *st, const char *const lst[]);
+LUALIB_API int luaL_findstring(const char *st, const char *const lst[]);
 
-LUALIB_API int luaL_ref (lua_State *L, int t);
-LUALIB_API void luaL_unref (lua_State *L, int t, int ref);
+LUALIB_API int luaL_ref(lua_State * L, int t);
+LUALIB_API void luaL_unref(lua_State * L, int t, int ref);
 
-LUALIB_API int luaL_getn (lua_State *L, int t);
-LUALIB_API void luaL_setn (lua_State *L, int t, int n);
+LUALIB_API int luaL_getn(lua_State * L, int t);
+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);
+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);
 
 
 
@@ -93,8 +91,8 @@ LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t sz,
 
 
 typedef struct luaL_Buffer {
-  char *p;                     /* current position in buffer */
-  int lvl;  /* number of strings in the stack (level) */
+  char *p;                             /* current position in buffer */
+  int lvl;                             /* number of strings in the stack (level) */
   lua_State *L;
   char buffer[LUAL_BUFFERSIZE];
 } luaL_Buffer;
@@ -105,12 +103,12 @@ typedef struct luaL_Buffer {
 
 #define luaL_addsize(B,n)      ((B)->p += (n))
 
-LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B);
-LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B);
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s);
-LUALIB_API void luaL_addvalue (luaL_Buffer *B);
-LUALIB_API void luaL_pushresult (luaL_Buffer *B);
+LUALIB_API void luaL_buffinit(lua_State * L, luaL_Buffer * B);
+LUALIB_API char *luaL_prepbuffer(luaL_Buffer * B);
+LUALIB_API void luaL_addlstring(luaL_Buffer * B, const char *s, size_t l);
+LUALIB_API void luaL_addstring(luaL_Buffer * B, const char *s);
+LUALIB_API void luaL_addvalue(luaL_Buffer * B);
+LUALIB_API void luaL_pushresult(luaL_Buffer * B);
 
 
 /* }====================================================== */
@@ -121,15 +119,14 @@ LUALIB_API void luaL_pushresult (luaL_Buffer *B);
 ** Compatibility macros and functions
 */
 
-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);
+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 
+#define luaL_opt_lstr  luaL_optlstring
+#define luaL_check_number      luaL_checknumber
 #define luaL_opt_number        luaL_optnumber
 #define luaL_arg_check luaL_argcheck
 #define luaL_check_string      luaL_checkstring
@@ -141,5 +138,3 @@ LUALIB_API int   lua_dobuffer (lua_State *L, const char *buff, size_t sz,
 
 
 #endif
-
-
index 659713b..9882071 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lbaselib.c,v 1.130b 2003/04/03 13:35:34 roberto Exp $
 ** Basic library
 ** model but changing `fputs' to put the strings at a proper place
 ** (a console window or a log file, for instance).
 */
-static int luaB_print (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
+static int
+luaB_print(lua_State * L)
+{
+  int n = lua_gettop(L);               /* number of arguments */
   int i;
   lua_getglobal(L, "tostring");
-  for (i=1; i<=n; i++) {
+  for (i = 1; i <= n; i++) {
     const char *s;
-    lua_pushvalue(L, -1);  /* function to be called */
-    lua_pushvalue(L, i);   /* value to print */
+    lua_pushvalue(L, -1);       /* function to be called */
+    lua_pushvalue(L, i);        /* value to print */
     lua_call(L, 1, 1);
-    s = lua_tostring(L, -1);  /* get result */
+    s = lua_tostring(L, -1);    /* get result */
     if (s == NULL)
       return luaL_error(L, "`tostring' must return a string to `print'");
-    if (i>1) fputs("\t", stdout);
+    if (i > 1)
+      fputs("\t", stdout);
     fputs(s, stdout);
-    lua_pop(L, 1);  /* pop result */
+    lua_pop(L, 1);              /* pop result */
   }
   fputs("\n", stdout);
   return 0;
 }
 
 
-static int luaB_tonumber (lua_State *L) {
+static int
+luaB_tonumber(lua_State * L)
+{
   int base = luaL_optint(L, 2, 10);
-  if (base == 10) {  /* standard conversion */
+  if (base == 10) {             /* standard conversion */
     luaL_checkany(L, 1);
     if (lua_isnumber(L, 1)) {
       lua_pushnumber(L, lua_tonumber(L, 1));
       return 1;
     }
-  }
-  else {
+  } else {
     const char *s1 = luaL_checkstring(L, 1);
     char *s2;
     unsigned long n;
     luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
     n = strtoul(s1, &s2, base);
-    if (s1 != s2) {  /* at least one valid digit? */
-      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
-      if (*s2 == '\0') {  /* no invalid trailing characters? */
-        lua_pushnumber(L, (lua_Number)n);
+    if (s1 != s2) {             /* at least one valid digit? */
+      while (isspace((unsigned char)(*s2)))
+        s2++;                   /* skip trailing spaces */
+      if (*s2 == '\0') {        /* no invalid trailing characters? */
+        lua_pushnumber(L, (lua_Number) n);
         return 1;
       }
     }
   }
-  lua_pushnil(L);  /* else not a number */
+  lua_pushnil(L);               /* else not a number */
   return 1;
 }
 
 
-static int luaB_error (lua_State *L)  __attribute__((noreturn));
-static int luaB_error (lua_State *L) {
+static int luaB_error(lua_State * L) __attribute__ ((noreturn));
+static int
+luaB_error(lua_State * L)
+{
   int level = luaL_optint(L, 2, 1);
   luaL_checkany(L, 1);
   if (!lua_isstring(L, 1) || level == 0)
-    lua_pushvalue(L, 1);  /* propagate error message without changes */
-  else {  /* add extra information */
+    lua_pushvalue(L, 1);        /* propagate error message without changes */
+  else {                        /* add extra information */
     luaL_where(L, level);
     lua_pushvalue(L, 1);
     lua_concat(L, 2);
@@ -91,22 +99,25 @@ static int luaB_error (lua_State *L) {
 }
 
 
-static int luaB_getmetatable (lua_State *L) {
+static int
+luaB_getmetatable(lua_State * L)
+{
   luaL_checkany(L, 1);
   if (!lua_getmetatable(L, 1)) {
     lua_pushnil(L);
-    return 1;  /* no metatable */
+    return 1;                   /* no metatable */
   }
   luaL_getmetafield(L, 1, "__metatable");
-  return 1;  /* returns either __metatable field (if present) or metatable */
+  return 1;                     /* returns either __metatable field (if present) or metatable */
 }
 
 
-static int luaB_setmetatable (lua_State *L) {
+static int
+luaB_setmetatable(lua_State * L)
+{
   int t = lua_type(L, 2);
   luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
-                    "nil or table expected");
+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table expected");
   if (luaL_getmetafield(L, 1, "__metatable"))
     luaL_error(L, "cannot change a protected metatable");
   lua_settop(L, 2);
@@ -115,8 +126,11 @@ static int luaB_setmetatable (lua_State *L) {
 }
 
 
-static void getfunc (lua_State *L) {
-  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
+static void
+getfunc(lua_State * L)
+{
+  if (lua_isfunction(L, 1))
+    lua_pushvalue(L, 1);
   else {
     lua_Debug ar;
     int level = luaL_optint(L, 1, 1);
@@ -125,13 +139,14 @@ static void getfunc (lua_State *L) {
       luaL_argerror(L, 1, "invalid level");
     lua_getinfo(L, "f", &ar);
     if (lua_isnil(L, -1))
-      luaL_error(L, "no function environment for tail call at level %d",
-                    level);
+      luaL_error(L, "no function environment for tail call at level %d", level);
   }
 }
 
 
-static int aux_getfenv (lua_State *L) {
+static int
+aux_getfenv(lua_State * L)
+{
   lua_getfenv(L, -1);
   lua_pushliteral(L, "__fenv");
   lua_rawget(L, -2);
@@ -139,21 +154,25 @@ static int aux_getfenv (lua_State *L) {
 }
 
 
-static int luaB_getfenv (lua_State *L) {
+static int
+luaB_getfenv(lua_State * L)
+{
   getfunc(L);
-  if (!aux_getfenv(L))  /* __fenv not defined? */
-    lua_pop(L, 1);  /* remove it, to return real environment */
+  if (!aux_getfenv(L))          /* __fenv not defined? */
+    lua_pop(L, 1);              /* remove it, to return real environment */
   return 1;
 }
 
 
-static int luaB_setfenv (lua_State *L) {
+static int
+luaB_setfenv(lua_State * L)
+{
   luaL_checktype(L, 2, LUA_TTABLE);
   getfunc(L);
-  if (aux_getfenv(L))  /* __fenv defined? */
+  if (aux_getfenv(L))           /* __fenv defined? */
     luaL_error(L, "`setfenv' cannot change a protected environment");
   else
-    lua_pop(L, 2);  /* remove __fenv and real environment table */
+    lua_pop(L, 2);              /* remove __fenv and real environment table */
   lua_pushvalue(L, 2);
   if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0)
     lua_replace(L, LUA_GLOBALSINDEX);
@@ -163,7 +182,9 @@ static int luaB_setfenv (lua_State *L) {
 }
 
 
-static int luaB_rawequal (lua_State *L) {
+static int
+luaB_rawequal(lua_State * L)
+{
   luaL_checkany(L, 1);
   luaL_checkany(L, 2);
   lua_pushboolean(L, lua_rawequal(L, 1, 2));
@@ -171,14 +192,18 @@ static int luaB_rawequal (lua_State *L) {
 }
 
 
-static int luaB_rawget (lua_State *L) {
+static int
+luaB_rawget(lua_State * L)
+{
   luaL_checktype(L, 1, LUA_TTABLE);
   luaL_checkany(L, 2);
   lua_rawget(L, 1);
   return 1;
 }
 
-static int luaB_rawset (lua_State *L) {
+static int
+luaB_rawset(lua_State * L)
+{
   luaL_checktype(L, 1, LUA_TTABLE);
   luaL_checkany(L, 2);
   luaL_checkany(L, 3);
@@ -187,29 +212,37 @@ static int luaB_rawset (lua_State *L) {
 }
 
 
-static int luaB_gcinfo (lua_State *L) {
+static int
+luaB_gcinfo(lua_State * L)
+{
   lua_pushnumber(L, lua_getgccount(L));
   lua_pushnumber(L, lua_getgcthreshold(L));
   return 2;
 }
 
 
-static int luaB_collectgarbage (lua_State *L) {
+static int
+luaB_collectgarbage(lua_State * L)
+{
   lua_setgcthreshold(L, luaL_optint(L, 1, 0));
   return 0;
 }
 
 
-static int luaB_type (lua_State *L) {
+static int
+luaB_type(lua_State * L)
+{
   luaL_checkany(L, 1);
   lua_pushstring(L, lua_typename(L, lua_type(L, 1)));
   return 1;
 }
 
 
-static int luaB_next (lua_State *L) {
+static int
+luaB_next(lua_State * L)
+{
   luaL_checktype(L, 1, LUA_TTABLE);
-  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
+  lua_settop(L, 2);             /* create a 2nd argument if there isn't one */
   if (lua_next(L, 1))
     return 2;
   else {
@@ -219,28 +252,31 @@ static int luaB_next (lua_State *L) {
 }
 
 
-static int luaB_pairs (lua_State *L) {
+static int
+luaB_pairs(lua_State * L)
+{
   luaL_checktype(L, 1, LUA_TTABLE);
   lua_pushliteral(L, "next");
-  lua_rawget(L, LUA_GLOBALSINDEX);  /* return generator, */
-  lua_pushvalue(L, 1);  /* state, */
-  lua_pushnil(L);  /* and initial value */
+  lua_rawget(L, LUA_GLOBALSINDEX);      /* return generator, */
+  lua_pushvalue(L, 1);          /* state, */
+  lua_pushnil(L);               /* and initial value */
   return 3;
 }
 
 
-static int luaB_ipairs (lua_State *L) {
+static int
+luaB_ipairs(lua_State * L)
+{
   lua_Number i = lua_tonumber(L, 2);
   luaL_checktype(L, 1, LUA_TTABLE);
-  if (i == 0 && lua_isnone(L, 2)) {  /* `for' start? */
+  if (i == 0 && lua_isnone(L, 2)) {     /* `for' start? */
     lua_pushliteral(L, "ipairs");
-    lua_rawget(L, LUA_GLOBALSINDEX);  /* return generator, */
-    lua_pushvalue(L, 1);  /* state, */
-    lua_pushnumber(L, 0);  /* and initial value */
+    lua_rawget(L, LUA_GLOBALSINDEX);    /* return generator, */
+    lua_pushvalue(L, 1);        /* state, */
+    lua_pushnumber(L, 0);       /* and initial value */
     return 3;
-  }
-  else {  /* `for' step */
-    i++;  /* next value */
+  } else {                      /* `for' step */
+    i++;                        /* next value */
     lua_pushnumber(L, i);
     lua_rawgeti(L, 1, (int)i);
     return (lua_isnil(L, -1)) ? 0 : 2;
@@ -248,18 +284,22 @@ static int luaB_ipairs (lua_State *L) {
 }
 
 
-static int load_aux (lua_State *L, int status) {
-  if (status == 0)  /* OK? */
+static int
+load_aux(lua_State * L, int status)
+{
+  if (status == 0)              /* OK? */
     return 1;
   else {
     lua_pushnil(L);
-    lua_insert(L, -2);  /* put before error message */
-    return 2;  /* return nil plus error message */
+    lua_insert(L, -2);          /* put before error message */
+    return 2;                   /* return nil plus error message */
   }
 }
 
 
-static int luaB_loadstring (lua_State *L) {
+static int
+luaB_loadstring(lua_State * L)
+{
   size_t l;
   const char *s = luaL_checklstring(L, 1, &l);
   const char *chunkname = luaL_optstring(L, 2, s);
@@ -267,23 +307,30 @@ static int luaB_loadstring (lua_State *L) {
 }
 
 
-static int luaB_loadfile (lua_State *L) {
+static int
+luaB_loadfile(lua_State * L)
+{
   const char *fname = luaL_optstring(L, 1, NULL);
   return load_aux(L, luaL_loadfile(L, fname));
 }
 
 
-static int luaB_dofile (lua_State *L) {
+static int
+luaB_dofile(lua_State * L)
+{
   const char *fname = luaL_optstring(L, 1, NULL);
   int n = lua_gettop(L);
   int status = luaL_loadfile(L, fname);
-  if (status != 0) lua_error(L);
+  if (status != 0)
+    lua_error(L);
   lua_call(L, 0, LUA_MULTRET);
   return lua_gettop(L) - n;
 }
 
 
-static int luaB_assert (lua_State *L) {
+static int
+luaB_assert(lua_State * L)
+{
   luaL_checkany(L, 1);
   if (!lua_toboolean(L, 1))
     return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
@@ -292,96 +339,105 @@ static int luaB_assert (lua_State *L) {
 }
 
 
-static int luaB_unpack (lua_State *L) {
+static int
+luaB_unpack(lua_State * L)
+{
   int n, i;
   luaL_checktype(L, 1, LUA_TTABLE);
   n = luaL_getn(L, 1);
   luaL_checkstack(L, n, "table too big to unpack");
-  for (i=1; i<=n; i++)  /* push arg[1...n] */
+  for (i = 1; i <= n; i++)      /* push arg[1...n] */
     lua_rawgeti(L, 1, i);
   return n;
 }
 
 
-static int luaB_pcall (lua_State *L) {
+static int
+luaB_pcall(lua_State * L)
+{
   int status;
   luaL_checkany(L, 1);
   status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
   lua_pushboolean(L, (status == 0));
   lua_insert(L, 1);
-  return lua_gettop(L);  /* return status + all results */
+  return lua_gettop(L);         /* return status + all results */
 }
 
 
-static int luaB_xpcall (lua_State *L) {
+static int
+luaB_xpcall(lua_State * L)
+{
   int status;
   luaL_checkany(L, 2);
   lua_settop(L, 2);
-  lua_insert(L, 1);  /* put error function under function to be called */
+  lua_insert(L, 1);             /* put error function under function to be called */
   status = lua_pcall(L, 0, LUA_MULTRET, 1);
   lua_pushboolean(L, (status == 0));
   lua_replace(L, 1);
-  return lua_gettop(L);  /* return status + all results */
+  return lua_gettop(L);         /* return status + all results */
 }
 
 
-static int luaB_tostring (lua_State *L) {
+static int
+luaB_tostring(lua_State * L)
+{
   char buff[128];
   luaL_checkany(L, 1);
-  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
-    return 1;  /* use its value */
+  if (luaL_callmeta(L, 1, "__tostring"))        /* is there a metafield? */
+    return 1;                   /* use its value */
   switch (lua_type(L, 1)) {
-    case LUA_TNUMBER:
-      lua_pushstring(L, lua_tostring(L, 1));
-      return 1;
-    case LUA_TSTRING:
-      lua_pushvalue(L, 1);
-      return 1;
-    case LUA_TBOOLEAN:
-      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
-      return 1;
-    case LUA_TTABLE:
-      sprintf(buff, "table: %p", lua_topointer(L, 1));
-      break;
-    case LUA_TFUNCTION:
-      sprintf(buff, "function: %p", lua_topointer(L, 1));
-      break;
-    case LUA_TUSERDATA:
-    case LUA_TLIGHTUSERDATA:
-      sprintf(buff, "userdata: %p", lua_touserdata(L, 1));
-      break;
-    case LUA_TTHREAD:
-      sprintf(buff, "thread: %p", (void *)lua_tothread(L, 1));
-      break;
-    case LUA_TNIL:
-      lua_pushliteral(L, "nil");
-      return 1;
+  case LUA_TNUMBER:
+    lua_pushstring(L, lua_tostring(L, 1));
+    return 1;
+  case LUA_TSTRING:
+    lua_pushvalue(L, 1);
+    return 1;
+  case LUA_TBOOLEAN:
+    lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
+    return 1;
+  case LUA_TTABLE:
+    sprintf(buff, "table: %p", lua_topointer(L, 1));
+    break;
+  case LUA_TFUNCTION:
+    sprintf(buff, "function: %p", lua_topointer(L, 1));
+    break;
+  case LUA_TUSERDATA:
+  case LUA_TLIGHTUSERDATA:
+    sprintf(buff, "userdata: %p", lua_touserdata(L, 1));
+    break;
+  case LUA_TTHREAD:
+    sprintf(buff, "thread: %p", (void *)lua_tothread(L, 1));
+    break;
+  case LUA_TNIL:
+    lua_pushliteral(L, "nil");
+    return 1;
   }
   lua_pushstring(L, buff);
   return 1;
 }
 
 
-static int luaB_newproxy (lua_State *L) {
+static int
+luaB_newproxy(lua_State * L)
+{
   lua_settop(L, 1);
-  lua_newuserdata(L, 0);  /* create proxy */
+  lua_newuserdata(L, 0);        /* create proxy */
   if (lua_toboolean(L, 1) == 0)
-    return 1;  /* no metatable */
+    return 1;                   /* no metatable */
   else if (lua_isboolean(L, 1)) {
-    lua_newtable(L);  /* create a new metatable `m' ... */
-    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
+    lua_newtable(L);            /* create a new metatable `m' ... */
+    lua_pushvalue(L, -1);       /* ... and mark `m' as a valid metatable */
     lua_pushboolean(L, 1);
-    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
-  }
-  else {
-    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
+    lua_rawset(L, lua_upvalueindex(1)); /* weaktable[m] = true */
+  } else {
+    int validproxy = 0;                /* to check if weaktable[metatable(u)] == true */
     if (lua_getmetatable(L, 1)) {
       lua_rawget(L, lua_upvalueindex(1));
       validproxy = lua_toboolean(L, -1);
-      lua_pop(L, 1);  /* remove value */
+      lua_pop(L, 1);            /* remove value */
     }
     luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
-    lua_getmetatable(L, 1);  /* metatable is valid; get it */
+    lua_getmetatable(L, 1);     /* metatable is valid; get it */
   }
   lua_setmetatable(L, 2);
   return 1;
@@ -414,91 +470,104 @@ static int luaB_newproxy (lua_State *L) {
 #endif
 
 
-static const char *getpath (lua_State *L) {
+static const char *
+getpath(lua_State * L)
+{
   const char *path;
-  lua_getglobal(L, LUA_PATH);  /* try global variable */
+  lua_getglobal(L, LUA_PATH);   /* try global variable */
   path = lua_tostring(L, -1);
   lua_pop(L, 1);
-  if (path) return path;
-  path = getenv(LUA_PATH);  /* else try environment variable */
-  if (path) return path;
-  return LUA_PATH_DEFAULT;  /* else use default */
+  if (path)
+    return path;
+  path = getenv(LUA_PATH);      /* else try environment variable */
+  if (path)
+    return path;
+  return LUA_PATH_DEFAULT;      /* else use default */
 }
 
 
-static const char *pushnextpath (lua_State *L, const char *path) {
+static const char *
+pushnextpath(lua_State * L, const char *path)
+{
   const char *l;
-  if (*path == '\0') return NULL;  /* no more paths */
-  if (*path == LUA_PATH_SEP) path++;  /* skip separator */
-  l = strchr(path, LUA_PATH_SEP);  /* find next separator */
-  if (l == NULL) l = path+strlen(path);
-  lua_pushlstring(L, path, l - path);  /* directory name */
+  if (*path == '\0')
+    return NULL;                /* no more paths */
+  if (*path == LUA_PATH_SEP)
+    path++;                     /* skip separator */
+  l = strchr(path, LUA_PATH_SEP);       /* find next separator */
+  if (l == NULL)
+    l = path + strlen(path);
+  lua_pushlstring(L, path, l - path);   /* directory name */
   return l;
 }
 
 
-static void pushcomposename (lua_State *L) {
+static void
+pushcomposename(lua_State * L)
+{
   const char *path = lua_tostring(L, -1);
   const char *wild;
   int n = 1;
   while ((wild = strchr(path, LUA_PATH_MARK)) != NULL) {
     /* is there stack space for prefix, name, and eventual last sufix? */
     luaL_checkstack(L, 3, "too many marks in a path component");
-    lua_pushlstring(L, path, wild - path);  /* push prefix */
-    lua_pushvalue(L, 1);  /* push package name (in place of MARK) */
-    path = wild + 1;  /* continue after MARK */
+    lua_pushlstring(L, path, wild - path);      /* push prefix */
+    lua_pushvalue(L, 1);        /* push package name (in place of MARK) */
+    path = wild + 1;            /* continue after MARK */
     n += 2;
   }
-  lua_pushstring(L, path);  /* push last sufix (`n' already includes this) */
+  lua_pushstring(L, path);      /* push last sufix (`n' already includes this) */
   lua_concat(L, n);
 }
 
 
-static int luaB_require (lua_State *L) {
+static int
+luaB_require(lua_State * L)
+{
   const char *path;
-  int status = LUA_ERRFILE;  /* not found (yet) */
+  int status = LUA_ERRFILE;            /* not found (yet) */
   luaL_checkstring(L, 1);
   lua_settop(L, 1);
   lua_getglobal(L, REQTAB);
-  if (!lua_istable(L, 2)) return luaL_error(L, "`" REQTAB "' is not a table");
+  if (!lua_istable(L, 2))
+    return luaL_error(L, "`" REQTAB "' is not a table");
   path = getpath(L);
-  lua_pushvalue(L, 1);  /* check package's name in book-keeping table */
+  lua_pushvalue(L, 1);          /* check package's name in book-keeping table */
   lua_rawget(L, 2);
-  if (lua_toboolean(L, -1))  /* is it there? */
-    return 1;  /* package is already loaded; return its result */
-  else {  /* must load it */
+  if (lua_toboolean(L, -1))     /* is it there? */
+    return 1;                   /* package is already loaded; return its result */
+  else {                        /* must load it */
     while (status == LUA_ERRFILE) {
-      lua_settop(L, 3);  /* reset stack position */
-      if ((path = pushnextpath(L, path)) == NULL) break;
+      lua_settop(L, 3);         /* reset stack position */
+      if ((path = pushnextpath(L, path)) == NULL)
+        break;
       pushcomposename(L);
-      status = luaL_loadfile(L, lua_tostring(L, -1));  /* try to load it */
+      status = luaL_loadfile(L, lua_tostring(L, -1));   /* try to load it */
     }
   }
   switch (status) {
-    case 0: {
-      lua_getglobal(L, "_REQUIREDNAME");  /* save previous name */
-      lua_insert(L, -2);  /* put it below function */
+  case 0:{
+      lua_getglobal(L, "_REQUIREDNAME");        /* save previous name */
+      lua_insert(L, -2);        /* put it below function */
       lua_pushvalue(L, 1);
-      lua_setglobal(L, "_REQUIREDNAME");  /* set new name */
-      lua_call(L, 0, 1);  /* run loaded module */
-      lua_insert(L, -2);  /* put result below previous name */
-      lua_setglobal(L, "_REQUIREDNAME");  /* reset to previous name */
-      if (lua_isnil(L, -1)) {  /* no/nil return? */
+      lua_setglobal(L, "_REQUIREDNAME");        /* set new name */
+      lua_call(L, 0, 1);        /* run loaded module */
+      lua_insert(L, -2);        /* put result below previous name */
+      lua_setglobal(L, "_REQUIREDNAME");        /* reset to previous name */
+      if (lua_isnil(L, -1)) {   /* no/nil return? */
         lua_pushboolean(L, 1);
-        lua_replace(L, -2);  /* replace to true */
+        lua_replace(L, -2);     /* replace to true */
       }
       lua_pushvalue(L, 1);
       lua_pushvalue(L, -2);
-      lua_rawset(L, 2);  /* mark it as loaded */
-      return 1;  /* return value */
+      lua_rawset(L, 2);         /* mark it as loaded */
+      return 1;                 /* return value */
     }
-    case LUA_ERRFILE: {  /* file not found */
-      return luaL_error(L, "could not load package `%s' from path `%s'",
-                            lua_tostring(L, 1), getpath(L));
+  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: {
-      return luaL_error(L, "error loading package `%s' (%s)",
-                           lua_tostring(L, 1), lua_tostring(L, -1));
+  default:{
+      return luaL_error(L, "error loading package `%s' (%s)", lua_tostring(L, 1), lua_tostring(L, -1));
     }
   }
 }
@@ -542,7 +611,9 @@ static const luaL_reg base_funcs[] = {
 ** =======================================================
 */
 
-static int auxresume (lua_State *L, lua_State *co, int narg) {
+static int
+auxresume(lua_State * L, lua_State * co, int narg)
+{
   int status;
   if (!lua_checkstack(co, narg))
     luaL_error(L, "too many arguments to resume");
@@ -552,17 +623,18 @@ static int auxresume (lua_State *L, lua_State *co, int narg) {
     int nres = lua_gettop(co);
     if (!lua_checkstack(L, nres))
       luaL_error(L, "too many results to resume");
-    lua_xmove(co, L, nres);  /* move yielded values */
+    lua_xmove(co, L, nres);     /* move yielded values */
     return nres;
-  }
-  else {
-    lua_xmove(co, L, 1);  /* move error message */
-    return -1;  /* error flag */
+  } else {
+    lua_xmove(co, L, 1);        /* move error message */
+    return -1;                  /* error flag */
   }
 }
 
 
-static int luaB_coresume (lua_State *L) {
+static int
+luaB_coresume(lua_State * L)
+{
   lua_State *co = lua_tothread(L, 1);
   int r;
   luaL_argcheck(L, co, 1, "coroutine expected");
@@ -570,57 +642,66 @@ static int luaB_coresume (lua_State *L) {
   if (r < 0) {
     lua_pushboolean(L, 0);
     lua_insert(L, -2);
-    return 2;  /* return false + error message */
-  }
-  else {
+    return 2;                   /* return false + error message */
+  } else {
     lua_pushboolean(L, 1);
     lua_insert(L, -(r + 1));
-    return r + 1;  /* return true + `resume' returns */
+    return r + 1;               /* return true + `resume' returns */
   }
 }
 
 
-static int luaB_auxwrap (lua_State *L) {
+static int
+luaB_auxwrap(lua_State * L)
+{
   lua_State *co = lua_tothread(L, lua_upvalueindex(1));
   int r = auxresume(L, co, lua_gettop(L));
   if (r < 0) {
     if (lua_isstring(L, -1)) {  /* error object is a string? */
-      luaL_where(L, 1);  /* add extra info */
+      luaL_where(L, 1);         /* add extra info */
       lua_insert(L, -2);
       lua_concat(L, 2);
     }
-    lua_error(L);  /* propagate error */
+    lua_error(L);               /* propagate error */
   }
   return r;
 }
 
 
-static int luaB_cocreate (lua_State *L) {
+static int
+luaB_cocreate(lua_State * L)
+{
   lua_State *NL = lua_newthread(L);
-  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
-    "Lua function expected");
-  lua_pushvalue(L, 1);  /* move function to top */
-  lua_xmove(L, NL, 1);  /* move function from L to NL */
+  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1, "Lua function expected");
+  lua_pushvalue(L, 1);          /* move function to top */
+  lua_xmove(L, NL, 1);          /* move function from L to NL */
   return 1;
 }
 
 
-static int luaB_cowrap (lua_State *L) {
+static int
+luaB_cowrap(lua_State * L)
+{
   luaB_cocreate(L);
   lua_pushcclosure(L, luaB_auxwrap, 1);
   return 1;
 }
 
 
-static int luaB_yield (lua_State *L) {
+static int
+luaB_yield(lua_State * L)
+{
   return lua_yield(L, lua_gettop(L));
 }
 
 
-static int luaB_costatus (lua_State *L) {
+static int
+luaB_costatus(lua_State * L)
+{
   lua_State *co = lua_tothread(L, 1);
   luaL_argcheck(L, co, 1, "coroutine expected");
-  if (L == co) lua_pushliteral(L, "running");
+  if (L == co)
+    lua_pushliteral(L, "running");
   else {
     lua_Debug ar;
     if (lua_getstack(co, 0, &ar) == 0 && lua_gettop(co) == 0)
@@ -645,32 +726,35 @@ static const luaL_reg co_funcs[] = {
 
 
 
-static void base_open (lua_State *L) {
+static void
+base_open(lua_State * L)
+{
   lua_pushliteral(L, "_G");
   lua_pushvalue(L, LUA_GLOBALSINDEX);
-  luaL_openlib(L, NULL, base_funcs, 0);  /* open lib into global table */
+  luaL_openlib(L, NULL, base_funcs, 0); /* open lib into global table */
   lua_pushliteral(L, "_VERSION");
   lua_pushliteral(L, LUA_VERSION);
-  lua_rawset(L, -3);  /* set global _VERSION */
+  lua_rawset(L, -3);            /* set global _VERSION */
   /* `newproxy' needs a weaktable as upvalue */
   lua_pushliteral(L, "newproxy");
-  lua_newtable(L);  /* new table `w' */
-  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
+  lua_newtable(L);              /* new table `w' */
+  lua_pushvalue(L, -1);         /* `w' will be its own metatable */
   lua_setmetatable(L, -2);
   lua_pushliteral(L, "__mode");
   lua_pushliteral(L, "k");
-  lua_rawset(L, -3);  /* metatable(w).__mode = "k" */
+  lua_rawset(L, -3);            /* metatable(w).__mode = "k" */
   lua_pushcclosure(L, luaB_newproxy, 1);
-  lua_rawset(L, -3);  /* set global `newproxy' */
-  lua_rawset(L, -1);  /* set global _G */
+  lua_rawset(L, -3);            /* set global `newproxy' */
+  lua_rawset(L, -1);            /* set global _G */
 }
 
 
-LUALIB_API int luaopen_base (lua_State *L) {
+LUALIB_API int
+luaopen_base(lua_State * L)
+{
   base_open(L);
   luaL_openlib(L, LUA_COLIBNAME, co_funcs, 0);
   lua_newtable(L);
   lua_setglobal(L, REQTAB);
   return 0;
 }
-
index d626ecd..5e601f8 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lcode.c,v 1.117 2003/04/03 13:35:34 roberto Exp $
 ** Code generator for Lua
 #define hasjumps(e)    ((e)->t != (e)->f)
 
 
-void luaK_nil (FuncState *fs, int from, int n) {
+void
+luaK_nil(FuncState * fs, int from, int n)
+{
   Instruction *previous;
-  if (fs->pc > fs->lasttarget &&  /* no jumps to current position? */
-      GET_OPCODE(*(previous = &fs->f->code[fs->pc-1])) == OP_LOADNIL) {
+  if (fs->pc > fs->lasttarget &&        /* no jumps to current position? */
+      GET_OPCODE(*(previous = &fs->f->code[fs->pc - 1])) == OP_LOADNIL) {
     int pfrom = GETARG_A(*previous);
     int pto = GETARG_B(*previous);
-    if (pfrom <= from && from <= pto+1) {  /* can connect both? */
-      if (from+n-1 > pto)
-        SETARG_B(*previous, from+n-1);
+    if (pfrom <= from && from <= pto + 1) {     /* can connect both? */
+      if (from + n - 1 > pto)
+        SETARG_B(*previous, from + n - 1);
       return;
     }
   }
-  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
+  luaK_codeABC(fs, OP_LOADNIL, from, from + n - 1, 0);  /* else no optimization */
 }
 
 
-int luaK_jump (FuncState *fs) {
-  int jpc = fs->jpc;  /* save list of jumps to here */
+int
+luaK_jump(FuncState * fs)
+{
+  int jpc = fs->jpc;                   /* save list of jumps to here */
   int j;
   fs->jpc = NO_JUMP;
   j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
-  luaK_concat(fs, &j, jpc);  /* keep them on hold */
+  luaK_concat(fs, &j, jpc);     /* keep them on hold */
   return j;
 }
 
 
-static int luaK_condjump (FuncState *fs, OpCode op, int A, int B, int C) {
+static int
+luaK_condjump(FuncState * fs, OpCode op, int A, int B, int C)
+{
   luaK_codeABC(fs, op, A, B, C);
   return luaK_jump(fs);
 }
 
 
-static void luaK_fixjump (FuncState *fs, int pc, int dest) {
+static void
+luaK_fixjump(FuncState * fs, int pc, int dest)
+{
   Instruction *jmp = &fs->f->code[pc];
-  int offset = dest-(pc+1);
+  int offset = dest - (pc + 1);
   lua_assert(dest != NO_JUMP);
   if (abs(offset) > MAXARG_sBx)
     luaX_syntaxerror(fs->ls, "control structure too long");
@@ -71,25 +80,31 @@ static void luaK_fixjump (FuncState *fs, int pc, int dest) {
 ** returns current `pc' and marks it as a jump target (to avoid wrong
 ** optimizations with consecutive instructions not in the same basic block).
 */
-int luaK_getlabel (FuncState *fs) {
+int
+luaK_getlabel(FuncState * fs)
+{
   fs->lasttarget = fs->pc;
   return fs->pc;
 }
 
 
-static int luaK_getjump (FuncState *fs, int pc) {
+static int
+luaK_getjump(FuncState * fs, int pc)
+{
   int offset = GETARG_sBx(fs->f->code[pc]);
-  if (offset == NO_JUMP)  /* point to itself represents end of list */
-    return NO_JUMP;  /* end of list */
+  if (offset == NO_JUMP)        /* point to itself represents end of list */
+    return NO_JUMP;             /* end of list */
   else
-    return (pc+1)+offset;  /* turn offset into absolute position */
+    return (pc + 1) + offset;   /* turn offset into absolute position */
 }
 
 
-static Instruction *getjumpcontrol (FuncState *fs, int pc) {
+static Instruction *
+getjumpcontrol(FuncState * fs, int pc)
+{
   Instruction *pi = &fs->f->code[pc];
-  if (pc >= 1 && testOpMode(GET_OPCODE(*(pi-1)), OpModeT))
-    return pi-1;
+  if (pc >= 1 && testOpMode(GET_OPCODE(*(pi - 1)), OpModeT))
+    return pi - 1;
   else
     return pi;
 }
@@ -99,37 +114,42 @@ static Instruction *getjumpcontrol (FuncState *fs, int pc) {
 ** check whether list has any jump that do not produce a value
 ** (or produce an inverted value)
 */
-static int need_value (FuncState *fs, int list, int cond) {
+static int
+need_value(FuncState * fs, int list, int cond)
+{
   for (; list != NO_JUMP; list = luaK_getjump(fs, list)) {
     Instruction i = *getjumpcontrol(fs, list);
-    if (GET_OPCODE(i) != OP_TEST || GETARG_C(i) != cond) return 1;
+    if (GET_OPCODE(i) != OP_TEST || GETARG_C(i) != cond)
+      return 1;
   }
-  return 0;  /* not found */
+  return 0;                     /* not found */
 }
 
 
-static void patchtestreg (Instruction *i, int reg) {
-  if (reg == NO_REG) reg = GETARG_B(*i);
+static void
+patchtestreg(Instruction * i, int reg)
+{
+  if (reg == NO_REG)
+    reg = GETARG_B(*i);
   SETARG_A(*i, reg);
 }
 
 
-static void luaK_patchlistaux (FuncState *fs, int list,
-          int ttarget, int treg, int ftarget, int freg, int dtarget) {
+static void
+luaK_patchlistaux(FuncState * fs, int list, int ttarget, int treg, int ftarget, int freg, int dtarget)
+{
   while (list != NO_JUMP) {
     int next = luaK_getjump(fs, list);
     Instruction *i = getjumpcontrol(fs, list);
     if (GET_OPCODE(*i) != OP_TEST) {
       lua_assert(dtarget != NO_JUMP);
       luaK_fixjump(fs, list, dtarget);  /* jump to default target */
-    }
-    else {
+    } else {
       if (GETARG_C(*i)) {
         lua_assert(ttarget != NO_JUMP);
         patchtestreg(i, treg);
         luaK_fixjump(fs, list, ttarget);
-      }
-      else {
+      } else {
         lua_assert(ftarget != NO_JUMP);
         patchtestreg(i, freg);
         luaK_fixjump(fs, list, ftarget);
@@ -140,13 +160,17 @@ static void luaK_patchlistaux (FuncState *fs, int list,
 }
 
 
-static void luaK_dischargejpc (FuncState *fs) {
+static void
+luaK_dischargejpc(FuncState * fs)
+{
   luaK_patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc, NO_REG, fs->pc);
   fs->jpc = NO_JUMP;
 }
 
 
-void luaK_patchlist (FuncState *fs, int list, int target) {
+void
+luaK_patchlist(FuncState * fs, int list, int target)
+{
   if (target == fs->pc)
     luaK_patchtohere(fs, list);
   else {
@@ -156,14 +180,19 @@ void luaK_patchlist (FuncState *fs, int list, int target) {
 }
 
 
-void luaK_patchtohere (FuncState *fs, int list) {
+void
+luaK_patchtohere(FuncState * fs, int list)
+{
   luaK_getlabel(fs);
   luaK_concat(fs, &fs->jpc, list);
 }
 
 
-void luaK_concat (FuncState *fs, int *l1, int l2) {
-  if (l2 == NO_JUMP) return;
+void
+luaK_concat(FuncState * fs, int *l1, int l2)
+{
+  if (l2 == NO_JUMP)
+    return;
   else if (*l1 == NO_JUMP)
     *l1 = l2;
   else {
@@ -176,7 +205,9 @@ void luaK_concat (FuncState *fs, int *l1, int l2) {
 }
 
 
-void luaK_checkstack (FuncState *fs, int n) {
+void
+luaK_checkstack(FuncState * fs, int n)
+{
   int newstack = fs->freereg + n;
   if (newstack > fs->f->maxstacksize) {
     if (newstack >= MAXSTACK)
@@ -186,13 +217,17 @@ void luaK_checkstack (FuncState *fs, int n) {
 }
 
 
-void luaK_reserveregs (FuncState *fs, int n) {
+void
+luaK_reserveregs(FuncState * fs, int n)
+{
   luaK_checkstack(fs, n);
   fs->freereg += n;
 }
 
 
-static void freereg (FuncState *fs, int reg) {
+static void
+freereg(FuncState * fs, int reg)
+{
   if (reg >= fs->nactvar && reg < MAXSTACK) {
     fs->freereg--;
     lua_assert(reg == fs->freereg);
@@ -200,22 +235,24 @@ static void freereg (FuncState *fs, int reg) {
 }
 
 
-static void freeexp (FuncState *fs, expdesc *e) {
+static void
+freeexp(FuncState * fs, expdesc * e)
+{
   if (e->k == VNONRELOC)
     freereg(fs, e->info);
 }
 
 
-static int addk (FuncState *fs, TObject *k, TObject *v) {
+static int
+addk(FuncState * fs, TObject * k, TObject * v)
+{
   const TObject *idx = luaH_get(fs->h, k);
   if (ttisnumber(idx)) {
     lua_assert(luaO_rawequalObj(&fs->f->k[cast(int, nvalue(idx))], v));
     return cast(int, nvalue(idx));
-  }
-  else {  /* constant not found; create a new entry */
+  } else {                      /* constant not found; create a new entry */
     Proto *f = fs->f;
-    luaM_growvector(fs->L, f->k, fs->nk, f->sizek, TObject,
-                    MAXARG_Bx, "constant table overflow");
+    luaM_growvector(fs->L, f->k, fs->nk, f->sizek, TObject, MAXARG_Bx, "constant table overflow");
     setobj2n(&f->k[fs->nk], v);
     setnvalue(luaH_set(fs->L, fs->h, k), cast(lua_Number, fs->nk));
     return fs->nk++;
@@ -223,32 +260,40 @@ static int addk (FuncState *fs, TObject *k, TObject *v) {
 }
 
 
-int luaK_stringK (FuncState *fs, TString *s) {
+int
+luaK_stringK(FuncState * fs, TString * s)
+{
   TObject o;
   setsvalue(&o, s);
   return addk(fs, &o, &o);
 }
 
 
-int luaK_numberK (FuncState *fs, lua_Number r) {
+int
+luaK_numberK(FuncState * fs, lua_Number r)
+{
   TObject o;
   setnvalue(&o, r);
   return addk(fs, &o, &o);
 }
 
 
-static int nil_constant (FuncState *fs) {
+static int
+nil_constant(FuncState * fs)
+{
   TObject k, v;
   setnilvalue(&v);
-  sethvalue(&k, fs->h);  /* cannot use nil as key; instead use table itself */
+  sethvalue(&k, fs->h);         /* cannot use nil as key; instead use table itself */
   return addk(fs, &k, &v);
 }
 
 
-void luaK_setcallreturns (FuncState *fs, expdesc *e, int nresults) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    SETARG_C(getcode(fs, e), nresults+1);
-    if (nresults == 1) {  /* `regular' expression? */
+void
+luaK_setcallreturns(FuncState * fs, expdesc * e, int nresults)
+{
+  if (e->k == VCALL) {          /* expression is an open function call? */
+    SETARG_C(getcode(fs, e), nresults + 1);
+    if (nresults == 1) {        /* `regular' expression? */
       e->k = VNONRELOC;
       e->info = GETARG_A(getcode(fs, e));
     }
@@ -256,72 +301,80 @@ void luaK_setcallreturns (FuncState *fs, expdesc *e, int nresults) {
 }
 
 
-void luaK_dischargevars (FuncState *fs, expdesc *e) {
+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;
     }
-    default: break;  /* there is one value available (somewhere) */
+  default:
+    break;                      /* there is one value available (somewhere) */
   }
 }
 
 
-static int code_label (FuncState *fs, int A, int b, int jump) {
-  luaK_getlabel(fs);  /* those instructions may be jump targets */
+static int
+code_label(FuncState * fs, int A, int b, int jump)
+{
+  luaK_getlabel(fs);            /* those instructions may be jump targets */
   return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
 }
 
 
-static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
+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 VFALSE:
+  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... */
+      return;                   /* nothing to do... */
     }
   }
   e->info = reg;
@@ -329,24 +382,28 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
 }
 
 
-static void discharge2anyreg (FuncState *fs, expdesc *e) {
+static void
+discharge2anyreg(FuncState * fs, expdesc * e)
+{
   if (e->k != VNONRELOC) {
     luaK_reserveregs(fs, 1);
-    discharge2reg(fs, e, fs->freereg-1);
+    discharge2reg(fs, e, fs->freereg - 1);
   }
 }
 
 
-static void luaK_exp2reg (FuncState *fs, expdesc *e, int reg) {
+static void
+luaK_exp2reg(FuncState * fs, expdesc * e, int reg)
+{
   discharge2reg(fs, e, reg);
   if (e->k == VJMP)
-    luaK_concat(fs, &e->t, e->info);  /* put this jump in `t' list */
+    luaK_concat(fs, &e->t, e->info);    /* put this jump in `t' list */
   if (hasjumps(e)) {
-    int final;  /* position after whole expression */
-    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
-    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
+    int final;                         /* position after whole expression */
+    int p_f = NO_JUMP;                 /* position of an eventual LOAD false */
+    int p_t = NO_JUMP;                 /* position of an eventual LOAD true */
     if (need_value(fs, e->t, 1) || need_value(fs, e->f, 0)) {
-      int fj = NO_JUMP;  /* first jump (over LOAD ops.) */
+      int fj = NO_JUMP;                /* first jump (over LOAD ops.) */
       if (e->k != VJMP)
         fj = luaK_jump(fs);
       p_f = code_label(fs, reg, 0, 1);
@@ -363,7 +420,9 @@ static void luaK_exp2reg (FuncState *fs, expdesc *e, int reg) {
 }
 
 
-void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
+void
+luaK_exp2nextreg(FuncState * fs, expdesc * e)
+{
   luaK_dischargevars(fs, e);
   freeexp(fs, e);
   luaK_reserveregs(fs, 1);
@@ -371,21 +430,26 @@ void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
 }
 
 
-int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
+int
+luaK_exp2anyreg(FuncState * fs, expdesc * e)
+{
   luaK_dischargevars(fs, e);
   if (e->k == VNONRELOC) {
-    if (!hasjumps(e)) return e->info;  /* exp is already in a register */ 
-    if (e->info >= fs->nactvar) {  /* reg. is not a local? */
-      luaK_exp2reg(fs, e, e->info);  /* put value on it */
+    if (!hasjumps(e))
+      return e->info;           /* exp is already in a register */
+    if (e->info >= fs->nactvar) {       /* reg. is not a local? */
+      luaK_exp2reg(fs, e, e->info);     /* put value on it */
       return e->info;
     }
   }
-  luaK_exp2nextreg(fs, e);  /* default */
+  luaK_exp2nextreg(fs, e);      /* default */
   return e->info;
 }
 
 
-void luaK_exp2val (FuncState *fs, expdesc *e) {
+void
+luaK_exp2val(FuncState * fs, expdesc * e)
+{
   if (hasjumps(e))
     luaK_exp2anyreg(fs, e);
   else
@@ -393,53 +457,59 @@ void luaK_exp2val (FuncState *fs, expdesc *e) {
 }
 
 
-int luaK_exp2RK (FuncState *fs, expdesc *e) {
+int
+luaK_exp2RK(FuncState * fs, expdesc * e)
+{
   luaK_exp2val(fs, e);
   switch (e->k) {
-    case VNIL: {
-      if (fs->nk + MAXSTACK <= MAXARG_C) {  /* constant fit in argC? */
+  case VNIL:{
+      if (fs->nk + MAXSTACK <= MAXARG_C) {      /* constant fit in argC? */
         e->info = nil_constant(fs);
         e->k = VK;
         return e->info + MAXSTACK;
-      }
-      else break;
+      } else
+        break;
     }
-    case VK: {
-      if (e->info + MAXSTACK <= MAXARG_C)  /* constant fit in argC? */
+  case VK:{
+      if (e->info + MAXSTACK <= MAXARG_C)       /* constant fit in argC? */
         return e->info + MAXSTACK;
-      else break;
+      else
+        break;
     }
-    default: break;
+  default:
+    break;
   }
   /* not a constant in the right range: put it in a register */
   return luaK_exp2anyreg(fs, e);
 }
 
 
-void luaK_storevar (FuncState *fs, expdesc *var, expdesc *exp) {
+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: {
-      lua_assert(0);  /* invalid var kind to store */
+  default:{
+      lua_assert(0);            /* invalid var kind to store */
       break;
     }
   }
@@ -447,7 +517,9 @@ void luaK_storevar (FuncState *fs, expdesc *var, expdesc *exp) {
 }
 
 
-void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
+void
+luaK_self(FuncState * fs, expdesc * e, expdesc * key)
+{
   int func;
   luaK_exp2anyreg(fs, e);
   freeexp(fs, e);
@@ -460,19 +532,22 @@ void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
 }
 
 
-static void invertjump (FuncState *fs, expdesc *e) {
+static void
+invertjump(FuncState * fs, expdesc * e)
+{
   Instruction *pc = getjumpcontrol(fs, e->info);
-  lua_assert(testOpMode(GET_OPCODE(*pc), OpModeT) &&
-             GET_OPCODE(*pc) != OP_TEST);
+  lua_assert(testOpMode(GET_OPCODE(*pc), OpModeT) && GET_OPCODE(*pc) != OP_TEST);
   SETARG_A(*pc, !(GETARG_A(*pc)));
 }
 
 
-static int jumponcond (FuncState *fs, expdesc *e, int cond) {
+static int
+jumponcond(FuncState * fs, expdesc * e, int cond)
+{
   if (e->k == VRELOCABLE) {
     Instruction ie = getcode(fs, e);
     if (GET_OPCODE(ie) == OP_NOT) {
-      fs->pc--;  /* remove previous OP_NOT */
+      fs->pc--;                 /* remove previous OP_NOT */
       return luaK_condjump(fs, OP_TEST, NO_REG, GETARG_B(ie), !cond);
     }
     /* else go through */
@@ -483,97 +558,115 @@ static int jumponcond (FuncState *fs, expdesc *e, int cond) {
 }
 
 
-void luaK_goiftrue (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of last jump */
+void
+luaK_goiftrue(FuncState * fs, expdesc * e)
+{
+  int pc;                              /* pc of last jump */
   luaK_dischargevars(fs, e);
   switch (e->k) {
-    case VK: case VTRUE: {
-      pc = NO_JUMP;  /* always true; do nothing */
+  case VK:
+  case VTRUE:{
+      pc = NO_JUMP;             /* always true; do nothing */
       break;
     }
-    case VFALSE: {
-      pc = luaK_jump(fs);  /* always jump */
+  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;
     }
   }
-  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
+  luaK_concat(fs, &e->f, pc);   /* insert last jump in `f' list */
 }
 
 
-void luaK_goiffalse (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of last jump */
+void
+luaK_goiffalse(FuncState * fs, expdesc * e)
+{
+  int pc;                              /* pc of last jump */
   luaK_dischargevars(fs, e);
   switch (e->k) {
-    case VNIL: case VFALSE: {
-      pc = NO_JUMP;  /* always false; do nothing */
+  case VNIL:
+  case VFALSE:{
+      pc = NO_JUMP;             /* always false; do nothing */
       break;
     }
-    case VTRUE: {
-      pc = luaK_jump(fs);  /* always jump */
+  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;
     }
   }
-  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
+  luaK_concat(fs, &e->t, pc);   /* insert last jump in `t' list */
 }
 
 
-static void codenot (FuncState *fs, expdesc *e) {
+static void
+codenot(FuncState * fs, expdesc * e)
+{
   luaK_dischargevars(fs, e);
   switch (e->k) {
-    case VNIL: case VFALSE: {
+  case VNIL:
+  case VFALSE:{
       e->k = VTRUE;
       break;
     }
-    case VK: case VTRUE: {
+  case VK:
+  case VTRUE:{
       e->k = VFALSE;
       break;
     }
-    case VJMP: {
+  case VJMP:{
       invertjump(fs, e);
       break;
     }
-    case VRELOCABLE:
-    case VNONRELOC: {
+  case VRELOCABLE:
+  case VNONRELOC:{
       discharge2anyreg(fs, e);
       freeexp(fs, e);
       e->info = luaK_codeABC(fs, OP_NOT, 0, e->info, 0);
       e->k = VRELOCABLE;
       break;
     }
-    default: {
-      lua_assert(0);  /* cannot happen */
+  default:{
+      lua_assert(0);            /* cannot happen */
       break;
     }
   }
   /* interchange true and false lists */
-  { int temp = e->f; e->f = e->t; e->t = temp; }
+  {
+    int temp = e->f;
+    e->f = e->t;
+    e->t = temp;
+  }
 }
 
 
-void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
+void
+luaK_indexed(FuncState * fs, expdesc * t, expdesc * k)
+{
   t->aux = luaK_exp2RK(fs, k);
   t->k = VINDEXED;
 }
 
 
-void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
+void
+luaK_prefix(FuncState * fs, UnOpr op, expdesc * e)
+{
   if (op == OPR_MINUS) {
     luaK_exp2val(fs, e);
     if (e->k == VK && ttisnumber(&fs->f->k[e->info]))
@@ -584,31 +677,32 @@ void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
       e->info = luaK_codeABC(fs, OP_UNM, 0, e->info, 0);
       e->k = VRELOCABLE;
     }
-  }
-  else  /* op == NOT */
+  } else                        /* op == NOT */
     codenot(fs, e);
 }
 
 
-void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
+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;
     }
@@ -616,52 +710,62 @@ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
 }
 
 
-static void codebinop (FuncState *fs, expdesc *res, BinOpr op,
-                       int o1, int o2) {
-  if (op <= OPR_POW) {  /* arithmetic operator? */
-    OpCode opc = cast(OpCode, (op - OPR_ADD) + OP_ADD);  /* ORDER OP */
+static void
+codebinop(FuncState * fs, expdesc * res, BinOpr op, int o1, int o2)
+{
+  if (op <= OPR_POW) {          /* arithmetic operator? */
+    OpCode opc = cast(OpCode, (op - OPR_ADD) + OP_ADD); /* ORDER OP */
     res->info = luaK_codeABC(fs, opc, 0, o1, o2);
     res->k = VRELOCABLE;
-  }
-  else {  /* test operator */
-    static const OpCode ops[] = {OP_EQ, OP_EQ, OP_LT, OP_LE, OP_LT, OP_LE};
+  } else {                      /* test operator */
+    static const OpCode ops[] = { OP_EQ, OP_EQ, OP_LT, OP_LE, OP_LT, OP_LE };
     int cond = 1;
-    if (op >= OPR_GT) {  /* `>' or `>='? */
-      int temp;  /* exchange args and replace by `<' or `<=' */
-      temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
-    }
-    else if (op == OPR_NE) cond = 0;
+    if (op >= OPR_GT) {         /* `>' or `>='? */
+      int temp;                        /* exchange args and replace by `<' or `<=' */
+      temp = o1;
+      o1 = o2;
+      o2 = temp;                /* o1 <==> o2 */
+    } else if (op == OPR_NE)
+      cond = 0;
     res->info = luaK_condjump(fs, ops[op - OPR_NE], cond, o1, o2);
     res->k = VJMP;
   }
 }
 
 
-void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
+void
+luaK_posfix(FuncState * fs, BinOpr op, expdesc * e1, expdesc * e2)
+{
   switch (op) {
-    case OPR_AND: {
-      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
+  case OPR_AND:{
+      lua_assert(e1->t == NO_JUMP);     /* list must be closed */
       luaK_dischargevars(fs, e2);
       luaK_concat(fs, &e1->f, e2->f);
-      e1->k = e2->k; e1->info = e2->info; e1->aux = e2->aux; e1->t = e2->t;
+      e1->k = e2->k;
+      e1->info = e2->info;
+      e1->aux = e2->aux;
+      e1->t = e2->t;
       break;
     }
-    case OPR_OR: {
-      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
+  case OPR_OR:{
+      lua_assert(e1->f == NO_JUMP);     /* list must be closed */
       luaK_dischargevars(fs, e2);
       luaK_concat(fs, &e1->t, e2->t);
-      e1->k = e2->k; e1->info = e2->info; e1->aux = e2->aux; e1->f = e2->f;
+      e1->k = e2->k;
+      e1->info = e2->info;
+      e1->aux = e2->aux;
+      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);
+        lua_assert(e1->info == GETARG_B(getcode(fs, e2)) - 1);
         freeexp(fs, e1);
         SETARG_B(getcode(fs, e2), e1->info);
-        e1->k = e2->k; e1->info = e2->info;
-      }
-      else {
+        e1->k = e2->k;
+        e1->info = e2->info;
+      else {
         luaK_exp2nextreg(fs, e2);
         freeexp(fs, e2);
         freeexp(fs, e1);
@@ -670,7 +774,7 @@ void 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);
@@ -681,34 +785,39 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
 }
 
 
-void luaK_fixline (FuncState *fs, int line) {
+void
+luaK_fixline(FuncState * fs, int line)
+{
   fs->f->lineinfo[fs->pc - 1] = line;
 }
 
 
-int luaK_code (FuncState *fs, Instruction i, int line) {
+int
+luaK_code(FuncState * fs, Instruction i, int line)
+{
   Proto *f = fs->f;
-  luaK_dischargejpc(fs);  /* `pc' will change */
+  luaK_dischargejpc(fs);        /* `pc' will change */
   /* put new instruction in code array */
-  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
-                  MAX_INT, "code size overflow");
+  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction, MAX_INT, "code size overflow");
   f->code[fs->pc] = i;
   /* save corresponding line information */
-  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
-                  MAX_INT, "code size overflow");
+  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int, MAX_INT, "code size overflow");
   f->lineinfo[fs->pc] = line;
   return fs->pc++;
 }
 
 
-int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
+int
+luaK_codeABC(FuncState * fs, OpCode o, int a, int b, int c)
+{
   lua_assert(getOpMode(o) == iABC);
   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) {
+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);
 }
-
index 74908c6..f179cee 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lcode.h,v 1.38 2002/12/11 12:34:22 roberto Exp $
 ** Code generator for Lua
@@ -41,34 +42,34 @@ typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr;
 
 #define luaK_codeAsBx(fs,o,A,sBx)      luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
 
-int luaK_code (FuncState *fs, Instruction i, int line);
-int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
-int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
-void luaK_fixline (FuncState *fs, int line);
-void luaK_nil (FuncState *fs, int from, int n);
-void luaK_reserveregs (FuncState *fs, int n);
-void luaK_checkstack (FuncState *fs, int n);
-int luaK_stringK (FuncState *fs, TString *s);
-int luaK_numberK (FuncState *fs, lua_Number r);
-void luaK_dischargevars (FuncState *fs, expdesc *e);
-int luaK_exp2anyreg (FuncState *fs, expdesc *e);
-void luaK_exp2nextreg (FuncState *fs, expdesc *e);
-void luaK_exp2val (FuncState *fs, expdesc *e);
-int luaK_exp2RK (FuncState *fs, expdesc *e);
-void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
-void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
-void luaK_goiftrue (FuncState *fs, expdesc *e);
-void luaK_goiffalse (FuncState *fs, expdesc *e);
-void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
-void luaK_setcallreturns (FuncState *fs, expdesc *var, int nresults);
-int luaK_jump (FuncState *fs);
-void luaK_patchlist (FuncState *fs, int list, int target);
-void luaK_patchtohere (FuncState *fs, int list);
-void luaK_concat (FuncState *fs, int *l1, int l2);
-int luaK_getlabel (FuncState *fs);
-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);
+int luaK_code(FuncState * fs, Instruction i, int line);
+int luaK_codeABx(FuncState * fs, OpCode o, int A, unsigned int Bx);
+int luaK_codeABC(FuncState * fs, OpCode o, int A, int B, int C);
+void luaK_fixline(FuncState * fs, int line);
+void luaK_nil(FuncState * fs, int from, int n);
+void luaK_reserveregs(FuncState * fs, int n);
+void luaK_checkstack(FuncState * fs, int n);
+int luaK_stringK(FuncState * fs, TString * s);
+int luaK_numberK(FuncState * fs, lua_Number r);
+void luaK_dischargevars(FuncState * fs, expdesc * e);
+int luaK_exp2anyreg(FuncState * fs, expdesc * e);
+void luaK_exp2nextreg(FuncState * fs, expdesc * e);
+void luaK_exp2val(FuncState * fs, expdesc * e);
+int luaK_exp2RK(FuncState * fs, expdesc * e);
+void luaK_self(FuncState * fs, expdesc * e, expdesc * key);
+void luaK_indexed(FuncState * fs, expdesc * t, expdesc * k);
+void luaK_goiftrue(FuncState * fs, expdesc * e);
+void luaK_goiffalse(FuncState * fs, expdesc * e);
+void luaK_storevar(FuncState * fs, expdesc * var, expdesc * e);
+void luaK_setcallreturns(FuncState * fs, expdesc * var, int nresults);
+int luaK_jump(FuncState * fs);
+void luaK_patchlist(FuncState * fs, int list, int target);
+void luaK_patchtohere(FuncState * fs, int list);
+void luaK_concat(FuncState * fs, int *l1, int l2);
+int luaK_getlabel(FuncState * fs);
+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
index 6cc89f5..f4abbd4 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: ldblib.c,v 1.80 2003/04/03 13:35:34 roberto Exp $
 ** Interface from Lua to its debug API
 
 
 
-static void settabss (lua_State *L, const char *i, const char *v) {
+static void
+settabss(lua_State * L, const char *i, const char *v)
+{
   lua_pushstring(L, i);
   lua_pushstring(L, v);
   lua_rawset(L, -3);
 }
 
 
-static void settabsi (lua_State *L, const char *i, int v) {
+static void
+settabsi(lua_State * L, const char *i, int v)
+{
   lua_pushstring(L, i);
-  lua_pushnumber(L, (lua_Number)v);
+  lua_pushnumber(L, (lua_Number) v);
   lua_rawset(L, -3);
 }
 
 
-static int getinfo (lua_State *L) {
+static int
+getinfo(lua_State * L)
+{
   lua_Debug ar;
   const char *options = luaL_optstring(L, 2, "flnSu");
   if (lua_isnumber(L, 1)) {
     if (!lua_getstack(L, lua_tonumber(L, 1), &ar)) {
-      lua_pushnil(L);  /* level out of range */
+      lua_pushnil(L);           /* level out of range */
       return 1;
     }
-  }
-  else if (lua_isfunction(L, 1)) {
+  } else if (lua_isfunction(L, 1)) {
     lua_pushfstring(L, ">%s", options);
     options = lua_tostring(L, -1);
     lua_pushvalue(L, 1);
-  }
-  else
+  } else
     return luaL_argerror(L, 1, "function or level expected");
   if (!lua_getinfo(L, options, &ar))
     return luaL_argerror(L, 2, "invalid option");
   lua_newtable(L);
   for (; *options; options++) {
     switch (*options) {
-      case 'S':
-        settabss(L, "source", ar.source);
-        settabss(L, "short_src", ar.short_src);
-        settabsi(L, "linedefined", ar.linedefined);
-        settabss(L, "what", ar.what);
-        break;
-      case 'l':
-        settabsi(L, "currentline", ar.currentline);
-        break;
-      case 'u':
-        settabsi(L, "nups", ar.nups);
-        break;
-      case 'n':
-        settabss(L, "name", ar.name);
-        settabss(L, "namewhat", ar.namewhat);
-        break;
-      case 'f':
-        lua_pushliteral(L, "func");
-        lua_pushvalue(L, -3);
-        lua_rawset(L, -3);
-        break;
+    case 'S':
+      settabss(L, "source", ar.source);
+      settabss(L, "short_src", ar.short_src);
+      settabsi(L, "linedefined", ar.linedefined);
+      settabss(L, "what", ar.what);
+      break;
+    case 'l':
+      settabsi(L, "currentline", ar.currentline);
+      break;
+    case 'u':
+      settabsi(L, "nups", ar.nups);
+      break;
+    case 'n':
+      settabss(L, "name", ar.name);
+      settabss(L, "namewhat", ar.namewhat);
+      break;
+    case 'f':
+      lua_pushliteral(L, "func");
+      lua_pushvalue(L, -3);
+      lua_rawset(L, -3);
+      break;
     }
   }
-  return 1;  /* return table */
+  return 1;                     /* return table */
 }
-    
 
-static int getlocal (lua_State *L) {
+
+static int
+getlocal(lua_State * L)
+{
   lua_Debug ar;
   const char *name;
-  if (!lua_getstack(L, luaL_checkint(L, 1), &ar))  /* level out of range? */
+  if (!lua_getstack(L, luaL_checkint(L, 1), &ar))       /* level out of range? */
     return luaL_argerror(L, 1, "level out of range");
   name = lua_getlocal(L, &ar, luaL_checkint(L, 2));
   if (name) {
     lua_pushstring(L, name);
     lua_pushvalue(L, -2);
     return 2;
-  }
-  else {
+  } else {
     lua_pushnil(L);
     return 1;
   }
 }
 
 
-static int setlocal (lua_State *L) {
+static int
+setlocal(lua_State * L)
+{
   lua_Debug ar;
-  if (!lua_getstack(L, luaL_checkint(L, 1), &ar))  /* level out of range? */
+  if (!lua_getstack(L, luaL_checkint(L, 1), &ar))       /* level out of range? */
     return luaL_argerror(L, 1, "level out of range");
   luaL_checkany(L, 3);
   lua_pushstring(L, lua_setlocal(L, &ar, luaL_checkint(L, 2)));
@@ -108,25 +116,33 @@ static int setlocal (lua_State *L) {
 }
 
 
-static int auxupvalue (lua_State *L, int get) {
+static int
+auxupvalue(lua_State * L, int get)
+{
   const char *name;
   int n = luaL_checkint(L, 2);
   luaL_checktype(L, 1, LUA_TFUNCTION);
-  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
+  if (lua_iscfunction(L, 1))
+    return 0;                   /* cannot touch C upvalues from Lua */
   name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
-  if (name == NULL) return 0;
+  if (name == NULL)
+    return 0;
   lua_pushstring(L, name);
-  lua_insert(L, -(get+1));
+  lua_insert(L, -(get + 1));
   return get + 1;
 }
 
 
-static int getupvalue (lua_State *L) {
+static int
+getupvalue(lua_State * L)
+{
   return auxupvalue(L, 1);
 }
 
 
-static int setupvalue (lua_State *L) {
+static int
+setupvalue(lua_State * L)
+{
   luaL_checkany(L, 3);
   return auxupvalue(L, 0);
 }
@@ -136,50 +152,63 @@ static int setupvalue (lua_State *L) {
 static const char KEY_HOOK = 'h';
 
 
-static void hookf (lua_State *L, lua_Debug *ar) {
-  static const char *const hooknames[] =
-    {"call", "return", "line", "count", "tail return"};
+static void
+hookf(lua_State * L, lua_Debug * ar)
+{
+  static const char *const hooknames[] = { "call", "return", "line", "count", "tail return" };
   lua_pushlightuserdata(L, &KEY_HOOK);
   lua_rawget(L, LUA_REGISTRYINDEX);
   if (lua_isfunction(L, -1)) {
     lua_pushstring(L, hooknames[(int)ar->event]);
     if (ar->currentline >= 0)
-      lua_pushnumber(L, (lua_Number)ar->currentline);
-    else lua_pushnil(L);
+      lua_pushnumber(L, (lua_Number) ar->currentline);
+    else
+      lua_pushnil(L);
     lua_assert(lua_getinfo(L, "lS", ar));
     lua_call(L, 2, 0);
-  }
-  else
-    lua_pop(L, 1);  /* pop result from gettable */
+  } else
+    lua_pop(L, 1);              /* pop result from gettable */
 }
 
 
-static int makemask (const char *smask, int count) {
+static int
+makemask(const char *smask, int count)
+{
   int mask = 0;
-  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
-  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
-  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
-  if (count > 0) mask |= LUA_MASKCOUNT;
+  if (strchr(smask, 'c'))
+    mask |= LUA_MASKCALL;
+  if (strchr(smask, 'r'))
+    mask |= LUA_MASKRET;
+  if (strchr(smask, 'l'))
+    mask |= LUA_MASKLINE;
+  if (count > 0)
+    mask |= LUA_MASKCOUNT;
   return mask;
 }
 
 
-static char *unmakemask (int mask, char *smask) {
+static char *
+unmakemask(int mask, char *smask)
+{
   int i = 0;
-  if (mask & LUA_MASKCALL) smask[i++] = 'c';
-  if (mask & LUA_MASKRET) smask[i++] = 'r';
-  if (mask & LUA_MASKLINE) smask[i++] = 'l';
+  if (mask & LUA_MASKCALL)
+    smask[i++] = 'c';
+  if (mask & LUA_MASKRET)
+    smask[i++] = 'r';
+  if (mask & LUA_MASKLINE)
+    smask[i++] = 'l';
   smask[i] = '\0';
   return smask;
 }
 
 
-static int sethook (lua_State *L) {
+static int
+sethook(lua_State * L)
+{
   if (lua_isnoneornil(L, 1)) {
     lua_settop(L, 1);
-    lua_sethook(L, NULL, 0, 0);  /* turn off hooks */
-  }
-  else {
+    lua_sethook(L, NULL, 0, 0); /* turn off hooks */
+  } else {
     const char *smask = luaL_checkstring(L, 2);
     int count = luaL_optint(L, 3, 0);
     luaL_checktype(L, 1, LUA_TFUNCTION);
@@ -187,16 +216,18 @@ static int sethook (lua_State *L) {
   }
   lua_pushlightuserdata(L, &KEY_HOOK);
   lua_pushvalue(L, 1);
-  lua_rawset(L, LUA_REGISTRYINDEX);  /* set new hook */
+  lua_rawset(L, LUA_REGISTRYINDEX);     /* set new hook */
   return 0;
 }
 
 
-static int gethook (lua_State *L) {
+static int
+gethook(lua_State * L)
+{
   char buff[5];
   int mask = lua_gethookmask(L);
   lua_Hook hook = lua_gethook(L);
-  if (hook != NULL && hook != hookf)  /* external hook? */
+  if (hook != NULL && hook != hookf)    /* external hook? */
     lua_pushliteral(L, "external hook");
   else {
     lua_pushlightuserdata(L, &KEY_HOOK);
@@ -208,39 +239,44 @@ static int gethook (lua_State *L) {
 }
 
 
-static int debug (lua_State *L) {
+static int
+debug(lua_State * L)
+{
   for (;;) {
     char buffer[250];
     fputs("lua_debug> ", stderr);
-    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
-        strcmp(buffer, "cont\n") == 0)
+    if (fgets(buffer, sizeof(buffer), stdin) == 0 || strcmp(buffer, "cont\n") == 0)
       return 0;
     lua_dostring(L, buffer);
-    lua_settop(L, 0);  /* remove eventual returns */
+    lua_settop(L, 0);           /* remove eventual returns */
   }
 }
 
 
-#define LEVELS1        12      /* size of the first part of the stack */
-#define LEVELS2        10      /* size of the second part of the stack */
+#define LEVELS1        12              /* size of the first part of the stack */
+#define LEVELS2        10              /* size of the second part of the stack */
 
-static int errorfb (lua_State *L) {
-  int level = 1;  /* skip level 0 (it's this function) */
-  int firstpart = 1;  /* still before eventual `...' */
+static int
+errorfb(lua_State * L)
+{
+  int level = 1;                       /* skip level 0 (it's this function) */
+  int firstpart = 1;                   /* still before eventual `...' */
   lua_Debug ar;
   if (lua_gettop(L) == 0)
     lua_pushliteral(L, "");
-  else if (!lua_isstring(L, 1)) return 1;  /* no string message */
-  else lua_pushliteral(L, "\n");
+  else if (!lua_isstring(L, 1))
+    return 1;                   /* no string message */
+  else
+    lua_pushliteral(L, "\n");
   lua_pushliteral(L, "stack traceback:");
   while (lua_getstack(L, level++, &ar)) {
     if (level > LEVELS1 && firstpart) {
       /* no more than `LEVELS2' more levels? */
-      if (!lua_getstack(L, level+LEVELS2, &ar))
-        level--;  /* keep going */
+      if (!lua_getstack(L, level + LEVELS2, &ar))
+        level--;                /* keep going */
       else {
         lua_pushliteral(L, "\n\t...");  /* too many levels */
-        while (lua_getstack(L, level+LEVELS2, &ar))  /* find last levels */
+        while (lua_getstack(L, level + LEVELS2, &ar))   /* find last levels */
           level++;
       }
       firstpart = 0;
@@ -252,20 +288,19 @@ static int errorfb (lua_State *L) {
     if (ar.currentline > 0)
       lua_pushfstring(L, "%d:", ar.currentline);
     switch (*ar.namewhat) {
-      case 'g':  /* global */ 
-      case 'l':  /* local */
-      case 'f':  /* field */
-      case 'm':  /* method */
-        lua_pushfstring(L, " in function `%s'", ar.name);
-        break;
-      default: {
-        if (*ar.what == 'm')  /* main? */
+    case 'g':                  /* global */
+    case 'l':                  /* local */
+    case 'f':                  /* field */
+    case 'm':                  /* method */
+      lua_pushfstring(L, " in function `%s'", ar.name);
+      break;
+    default:{
+        if (*ar.what == 'm')    /* main? */
           lua_pushfstring(L, " in main chunk");
         else if (*ar.what == 'C' || *ar.what == 't')
-          lua_pushliteral(L, " ?");  /* C function or tail call */
+          lua_pushliteral(L, " ?");     /* C function or tail call */
         else
-          lua_pushfstring(L, " in function <%s:%d>",
-                             ar.short_src, ar.linedefined);
+          lua_pushfstring(L, " in function <%s:%d>", ar.short_src, ar.linedefined);
       }
     }
     lua_concat(L, lua_gettop(L));
@@ -289,11 +324,12 @@ static const luaL_reg dblib[] = {
 };
 
 
-LUALIB_API int luaopen_debug (lua_State *L) {
+LUALIB_API int
+luaopen_debug(lua_State * L)
+{
   luaL_openlib(L, LUA_DBLIBNAME, dblib, 0);
   lua_pushliteral(L, "_TRACEBACK");
   lua_pushcfunction(L, errorfb);
   lua_settable(L, LUA_GLOBALSINDEX);
   return 1;
 }
-
index f894851..ad498d2 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: ldebug.c,v 1.150 2003/03/19 21:24:04 roberto Exp $
 ** Debug Interface
 
 
 
-static const char *getfuncname (CallInfo *ci, const char **name);
+static const char *getfuncname(CallInfo * ci, const char **name);
 
 
 #define isLua(ci)      (!((ci)->state & CI_C))
 
 
-static int currentpc (CallInfo *ci) {
-  if (!isLua(ci)) return -1;  /* function is not a Lua function? */
+static int
+currentpc(CallInfo * ci)
+{
+  if (!isLua(ci))
+    return -1;                  /* function is not a Lua function? */
   if (ci->state & CI_HASFRAME)  /* function has a frame? */
-    ci->u.l.savedpc = *ci->u.l.pc;  /* use `pc' from there */
+    ci->u.l.savedpc = *ci->u.l.pc;      /* use `pc' from there */
   /* function's pc is saved */
   return pcRel(ci->u.l.savedpc, ci_func(ci)->l.p);
 }
 
 
-static int currentline (CallInfo *ci) {
+static int
+currentline(CallInfo * ci)
+{
   int pc = currentpc(ci);
   if (pc < 0)
-    return -1;  /* only active lua functions have current-line information */
+    return -1;                  /* only active lua functions have current-line information */
   else
     return getline(ci_func(ci)->l.p, pc);
 }
 
 
-void luaG_inithooks (lua_State *L) {
+void
+luaG_inithooks(lua_State * L)
+{
   CallInfo *ci;
-  for (ci = L->ci; ci != L->base_ci; ci--)  /* update all `savedpc's */
+  for (ci = L->ci; ci != L->base_ci; ci--)      /* update all `savedpc's */
     currentpc(ci);
   L->hookinit = 1;
 }
@@ -62,8 +70,10 @@ void luaG_inithooks (lua_State *L) {
 /*
 ** this function can be called asynchronous (e.g. during a signal)
 */
-LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
-  if (func == NULL || mask == 0) {  /* turn off hooks? */
+LUA_API int
+lua_sethook(lua_State * L, lua_Hook func, int mask, int count)
+{
+  if (func == NULL || mask == 0) {      /* turn off hooks? */
     mask = 0;
     func = NULL;
   }
@@ -76,36 +86,44 @@ LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
 }
 
 
-LUA_API lua_Hook lua_gethook (lua_State *L) {
+LUA_API lua_Hook
+lua_gethook(lua_State * L)
+{
   return L->hook;
 }
 
 
-LUA_API int lua_gethookmask (lua_State *L) {
+LUA_API int
+lua_gethookmask(lua_State * L)
+{
   return L->hookmask;
 }
 
 
-LUA_API int lua_gethookcount (lua_State *L) {
+LUA_API int
+lua_gethookcount(lua_State * L)
+{
   return L->basehookcount;
 }
 
 
-LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
+LUA_API int
+lua_getstack(lua_State * L, int level, lua_Debug * ar)
+{
   int status;
   CallInfo *ci;
   lua_lock(L);
   for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
     level--;
-    if (!(ci->state & CI_C))  /* Lua function? */
-      level -= ci->u.l.tailcalls;  /* skip lost tail calls */
+    if (!(ci->state & CI_C))    /* Lua function? */
+      level -= ci->u.l.tailcalls;       /* skip lost tail calls */
   }
-  if (level > 0 || ci == L->base_ci) status = 0;  /* there is no such level */
-  else if (level < 0) {  /* level is of a lost tail call */
+  if (level > 0 || ci == L->base_ci)
+    status = 0;                 /* there is no such level */
+  else if (level < 0) {         /* level is of a lost tail call */
     status = 1;
     ar->i_ci = 0;
-  }
-  else {
+  } else {
     status = 1;
     ar->i_ci = ci - L->base_ci;
   }
@@ -114,12 +132,16 @@ LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
 }
 
 
-static Proto *getluaproto (CallInfo *ci) {
+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) {
+LUA_API const char *
+lua_getlocal(lua_State * L, const lua_Debug * ar, int n)
+{
   const char *name;
   CallInfo *ci;
   Proto *fp;
@@ -127,17 +149,19 @@ LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
   name = NULL;
   ci = L->base_ci + ar->i_ci;
   fp = getluaproto(ci);
-  if (fp) {  /* is a Lua function? */
+  if (fp) {                     /* is a Lua function? */
     name = luaF_getlocalname(fp, n, currentpc(ci));
     if (name)
-      luaA_pushobject(L, ci->base+(n-1));  /* push value */
+      luaA_pushobject(L, ci->base + (n - 1));   /* push value */
   }
   lua_unlock(L);
   return name;
 }
 
 
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
+LUA_API const char *
+lua_setlocal(lua_State * L, const lua_Debug * ar, int n)
+{
   const char *name;
   CallInfo *ci;
   Proto *fp;
@@ -145,27 +169,28 @@ LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
   name = NULL;
   ci = L->base_ci + ar->i_ci;
   fp = getluaproto(ci);
-  L->top--;  /* pop new value */
-  if (fp) {  /* is a Lua function? */
+  L->top--;                     /* pop new value */
+  if (fp) {                     /* is a Lua function? */
     name = luaF_getlocalname(fp, n, currentpc(ci));
-    if (!name || name[0] == '(')  /* `(' starts private locals */
+    if (!name || name[0] == '(')        /* `(' starts private locals */
       name = NULL;
     else
-      setobjs2s(ci->base+(n-1), L->top);
+      setobjs2s(ci->base + (n - 1), L->top);
   }
   lua_unlock(L);
   return name;
 }
 
 
-static void funcinfo (lua_Debug *ar, StkId func) {
+static void
+funcinfo(lua_Debug * ar, StkId func)
+{
   Closure *cl = clvalue(func);
   if (cl->c.isC) {
     ar->source = "=[C]";
     ar->linedefined = -1;
     ar->what = "C";
-  }
-  else {
+  } else {
     ar->source = getstr(cl->l.p->source);
     ar->linedefined = cl->l.p->lineDefined;
     ar->what = (ar->linedefined == 0) ? "main" : "Lua";
@@ -174,7 +199,9 @@ static void funcinfo (lua_Debug *ar, StkId func) {
 }
 
 
-static const char *travglobals (lua_State *L, const TObject *o) {
+static const char *
+travglobals(lua_State * L, const TObject * o)
+{
   Table *g = hvalue(gt(L));
   int i = sizenode(g);
   while (i--) {
@@ -186,7 +213,9 @@ static const char *travglobals (lua_State *L, const TObject *o) {
 }
 
 
-static void info_tailcall (lua_State *L, lua_Debug *ar) {
+static void
+info_tailcall(lua_State * L, lua_Debug * ar)
+{
   ar->name = ar->namewhat = "";
   ar->what = "tail";
   ar->linedefined = ar->currentline = -1;
@@ -197,45 +226,50 @@ static void info_tailcall (lua_State *L, lua_Debug *ar) {
 }
 
 
-static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
-                    StkId f, CallInfo *ci) {
+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 */
           if ((ar->name = travglobals(L, f)) != NULL)
             ar->namewhat = "global";
-          else ar->namewhat = "";  /* not found */
+          else
+            ar->namewhat = "";  /* not found */
         }
         break;
       }
-      case 'f': {
+    case 'f':{
         setobj2s(L->top, f);
         break;
       }
-      default: status = 0;  /* invalid option */
+    default:
+      status = 0;               /* invalid option */
     }
   }
   return status;
 }
 
 
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
+LUA_API int
+lua_getinfo(lua_State * L, const char *what, lua_Debug * ar)
+{
   int status = 1;
   lua_lock(L);
   if (*what == '>') {
@@ -243,16 +277,15 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
     if (!ttisfunction(f))
       luaG_runerror(L, "value for `lua_getinfo' is not a function");
     status = auxgetinfo(L, what + 1, ar, f, NULL);
-    L->top--;  /* pop function */
-  }
-  else if (ar->i_ci != 0) {  /* no tail call? */
+    L->top--;                   /* pop function */
+  } else if (ar->i_ci != 0) {   /* no tail call? */
     CallInfo *ci = L->base_ci + ar->i_ci;
     lua_assert(ttisfunction(ci->base - 1));
     status = auxgetinfo(L, what, ar, ci->base - 1, ci);
-  }
-  else
+  } else
     info_tailcall(L, ar);
-  if (strchr(what, 'f')) incr_top(L);
+  if (strchr(what, 'f'))
+    incr_top(L);
   lua_unlock(L);
   return status;
 }
@@ -272,39 +305,49 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
 
 
 
-static int precheck (const Proto *pt) {
+static int
+precheck(const Proto * pt)
+{
   check(pt->maxstacksize <= MAXSTACK);
   check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);
-  lua_assert(pt->numparams+pt->is_vararg <= pt->maxstacksize);
-  check(GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
+  lua_assert(pt->numparams + pt->is_vararg <= pt->maxstacksize);
+  check(GET_OPCODE(pt->code[pt->sizecode - 1]) == OP_RETURN);
   return 1;
 }
 
 
-static int checkopenop (const Proto *pt, int pc) {
-  Instruction i = pt->code[pc+1];
+static int
+checkopenop(const Proto * pt, int pc)
+{
+  Instruction i = pt->code[pc + 1];
   switch (GET_OPCODE(i)) {
-    case OP_CALL:
-    case OP_TAILCALL:
-    case OP_RETURN: {
+  case OP_CALL:
+  case OP_TAILCALL:
+  case OP_RETURN:{
       check(GETARG_B(i) == 0);
       return 1;
     }
-    case OP_SETLISTO: return 1;
-    default: return 0;  /* invalid instruction after an open call */
+  case OP_SETLISTO:
+    return 1;
+  default:
+    return 0;                   /* invalid instruction after an open call */
   }
 }
 
 
-static int checkRK (const Proto *pt, int r) {
-  return (r < pt->maxstacksize || (r >= MAXSTACK && r-MAXSTACK < pt->sizek));
+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) {
+static Instruction
+luaG_symbexec(const Proto * pt, int lastpc, int reg)
+{
   int pc;
-  int last;  /* stores position of last instruction that changed `reg' */
-  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
+  int last;                            /* stores position of last instruction that changed `reg' */
+  last = pt->sizecode - 1;      /* points to final return (a `neutral' instruction) */
   check(precheck(pt));
   for (pc = 0; pc < lastpc; pc++) {
     const Instruction i = pt->code[pc];
@@ -314,115 +357,120 @@ static Instruction 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)) {
           checkreg(pt, b);
-        }
-        else if (testOpMode(op, OpModeBrk))
+        } else if (testOpMode(op, OpModeBrk))
           check(checkRK(pt, b));
         if (testOpMode(op, OpModeCrk))
           check(checkRK(pt, c));
         break;
       }
-      case iABx: {
+    case iABx:{
         b = GETARG_Bx(i);
-        if (testOpMode(op, OpModeK)) check(b < pt->sizek);
+        if (testOpMode(op, OpModeK))
+          check(b < pt->sizek);
         break;
       }
-      case iAsBx: {
+    case iAsBx:{
         b = GETARG_sBx(i);
         break;
       }
     }
     if (testOpMode(op, OpModesetA)) {
-      if (a == reg) last = pc;  /* change register `a' */
+      if (a == reg)
+        last = pc;              /* change register `a' */
     }
     if (testOpMode(op, OpModeT)) {
-      check(pc+2 < pt->sizecode);  /* check skip */
-      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);
+      check(pc + 2 < pt->sizecode);     /* check skip */
+      check(GET_OPCODE(pt->code[pc + 1]) == OP_JMP);
     }
     switch (op) {
-      case OP_LOADBOOL: {
-        check(c == 0 || pc+2 < pt->sizecode);  /* check its jump */
+    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' */
+          last = pc;            /* set registers from `a' to `b' */
         break;
       }
-      case OP_GETUPVAL:
-      case OP_SETUPVAL: {
+    case OP_GETUPVAL:
+    case OP_SETUPVAL:{
         check(b < pt->nups);
         break;
       }
-      case OP_GETGLOBAL:
-      case OP_SETGLOBAL: {
+    case OP_GETGLOBAL:
+    case OP_SETGLOBAL:{
         check(ttisstring(&pt->k[b]));
         break;
       }
-      case OP_SELF: {
-        checkreg(pt, a+1);
-        if (reg == a+1) last = pc;
+    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;
       }
-      case OP_TFORLOOP:
-        checkreg(pt, a+c+5);
-        if (reg >= a) last = pc;  /* affect all registers above base */
-        /* go through */
-      case OP_FORLOOP:
-        checkreg(pt, a+2);
-        /* go through */
-      case OP_JMP: {
-        int dest = pc+1+b;
-       check(0 <= dest && dest < pt->sizecode);
+    case OP_TFORLOOP:
+      checkreg(pt, a + c + 5);
+      if (reg >= a)
+        last = pc;              /* affect all registers above base */
+      /* go through */
+    case OP_FORLOOP:
+      checkreg(pt, a + 2);
+      /* go through */
+    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'? */
         if (reg != NO_REG && pc < dest && dest <= lastpc)
-          pc += b;  /* do the jump */
+          pc += b;              /* do the jump */
         break;
       }
-      case OP_CALL:
-      case OP_TAILCALL: {
+    case OP_CALL:
+    case OP_TAILCALL:{
         if (b != 0) {
-          checkreg(pt, a+b-1);
+          checkreg(pt, a + b - 1);
         }
-        c--;  /* c = num. returns */
+        c--;                    /* c = num. returns */
         if (c == LUA_MULTRET) {
           check(checkopenop(pt, pc));
-        }
-        else if (c != 0)
-          checkreg(pt, a+c-1);
-        if (reg >= a) last = pc;  /* affect all registers above base */
+        } else if (c != 0)
+          checkreg(pt, a + c - 1);
+        if (reg >= a)
+          last = pc;            /* affect all registers above base */
         break;
       }
-      case OP_RETURN: {
-        b--;  /* b = num. returns */
-        if (b > 0) checkreg(pt, a+b-1);
+    case OP_RETURN:{
+        b--;                    /* b = num. returns */
+        if (b > 0)
+          checkreg(pt, a + b - 1);
         break;
       }
-      case OP_SETLIST: {
-        checkreg(pt, a + (b&(LFIELDS_PER_FLUSH-1)) + 1);
+    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;
         check(pc + nup < pt->sizecode);
-        for (; nup>0; nup--) {
-          OpCode op1 = GET_OPCODE(pt->code[pc+nup]);
+        for (; nup > 0; nup--) {
+          OpCode op1 = GET_OPCODE(pt->code[pc + nup]);
           check(op1 == OP_GETUPVAL || op1 == OP_MOVE);
         }
         break;
       }
-      default: break;
+    default:
+      break;
     }
   }
   return pt->code[last];
@@ -435,12 +483,16 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) {
 /* }====================================================== */
 
 
-int luaG_checkcode (const Proto *pt) {
+int
+luaG_checkcode(const Proto * pt)
+{
   return luaG_symbexec(pt, pt->sizecode, NO_REG);
 }
 
 
-static const char *kname (Proto *p, int c) {
+static const char *
+kname(Proto * p, int c)
+{
   c = c - MAXSTACK;
   if (c >= 0 && ttisstring(&p->k[c]))
     return svalue(&p->k[c]);
@@ -449,98 +501,113 @@ static const char *kname (Proto *p, int c) {
 }
 
 
-static const char *getobjname (CallInfo *ci, int stackpos, const char **name) {
-  if (isLua(ci)) {  /* a Lua function? */
+static const char *
+getobjname(CallInfo * ci, int stackpos, const char **name)
+{
+  if (isLua(ci)) {              /* a Lua function? */
     Proto *p = ci_func(ci)->l.p;
     int pc = currentpc(ci);
     Instruction i;
-    *name = luaF_getlocalname(p, stackpos+1, pc);
-    if (*name)  /* is a local? */
+    *name = luaF_getlocalname(p, stackpos + 1, pc);
+    if (*name)                  /* is a local? */
       return "local";
-    i = luaG_symbexec(p, pc, stackpos);  /* try symbolic execution */
+    i = luaG_symbexec(p, pc, stackpos); /* try symbolic execution */
     lua_assert(pc != -1);
     switch (GET_OPCODE(i)) {
-      case OP_GETGLOBAL: {
-        int g = GETARG_Bx(i);  /* global index */
+    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' */
+        int b = GETARG_B(i);           /* move from `b' to `a' */
         if (b < a)
-          return getobjname(ci, b, name);  /* get name for `b' */
+          return getobjname(ci, b, name);       /* get name for `b' */
         break;
       }
-      case OP_GETTABLE: {
-        int k = GETARG_C(i);  /* key index */
+    case OP_GETTABLE:{
+        int k = GETARG_C(i);           /* key index */
         *name = kname(p, k);
         return "field";
       }
-      case OP_SELF: {
-        int k = GETARG_C(i);  /* key index */
+    case OP_SELF:{
+        int k = GETARG_C(i);           /* key index */
         *name = kname(p, k);
         return "method";
       }
-      default: break;
+    default:
+      break;
     }
   }
-  return NULL;  /* no useful name found */
+  return NULL;                  /* no useful name found */
 }
 
 
-static const char *getfuncname (CallInfo *ci, const char **name) {
+static const char *
+getfuncname(CallInfo * ci, const char **name)
+{
   Instruction i;
   if ((isLua(ci) && ci->u.l.tailcalls > 0) || !isLua(ci - 1))
-    return NULL;  /* calling function is not Lua (or is unknown) */
-  ci--;  /* calling function */
+    return NULL;                /* calling function is not Lua (or is unknown) */
+  ci--;                         /* calling function */
   i = ci_func(ci)->l.p->code[currentpc(ci)];
   if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL)
     return getobjname(ci, GETARG_A(i), name);
   else
-    return NULL;  /* no useful name can be found */
+    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) {
+static int
+isinstack(CallInfo * ci, const TObject * o)
+{
   StkId p;
   for (p = ci->base; p < ci->top; p++)
-    if (o == p) return 1;
+    if (o == p)
+      return 1;
   return 0;
 }
 
 
-void luaG_typeerror (lua_State *L, const TObject *o, const char *op) {
+void
+luaG_typeerror(lua_State * L, const TObject * o, const char *op)
+{
   const char *name = NULL;
   const char *t = luaT_typenames[ttype(o)];
-  const char *kind = (isinstack(L->ci, o)) ?
-                         getobjname(L->ci, o - L->base, &name) : NULL;
+  const char *kind = (isinstack(L->ci, o)) ? getobjname(L->ci, o - L->base, &name) : NULL;
   if (kind)
-    luaG_runerror(L, "attempt to %s %s `%s' (a %s value)",
-                op, kind, name, t);
+    luaG_runerror(L, "attempt to %s %s `%s' (a %s value)", op, kind, name, t);
   else
     luaG_runerror(L, "attempt to %s a %s value", op, t);
 }
 
 
-void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
-  if (ttisstring(p1)) p1 = p2;
+void
+luaG_concaterror(lua_State * L, StkId p1, StkId p2)
+{
+  if (ttisstring(p1))
+    p1 = p2;
   lua_assert(!ttisstring(p1));
   luaG_typeerror(L, p1, "concatenate");
 }
 
 
-void luaG_aritherror (lua_State *L, const TObject *p1, const TObject *p2) {
+void
+luaG_aritherror(lua_State * L, const TObject * p1, const TObject * p2)
+{
   TObject temp;
   if (luaV_tonumber(p1, &temp) == NULL)
-    p2 = p1;  /* first operand is wrong */
+    p2 = p1;                    /* first operand is wrong */
   luaG_typeerror(L, p2, "perform arithmetic on");
 }
 
 
-int luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2) {
+int
+luaG_ordererror(lua_State * L, const TObject * p1, const TObject * p2)
+{
   const char *t1 = luaT_typenames[ttype(p1)];
   const char *t2 = luaT_typenames[ttype(p2)];
   if (t1[2] == t2[2])
@@ -550,10 +617,12 @@ int luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2) {
 }
 
 
-static void addinfo (lua_State *L, const char *msg) {
+static void
+addinfo(lua_State * L, const char *msg)
+{
   CallInfo *ci = L->ci;
-  if (isLua(ci)) {  /* is Lua code? */
-    char buff[LUA_IDSIZE];  /* add file:line information */
+  if (isLua(ci)) {              /* is Lua code? */
+    char buff[LUA_IDSIZE];             /* add file:line information */
     int line = currentline(ci);
     luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);
     luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
@@ -561,24 +630,28 @@ static void addinfo (lua_State *L, const char *msg) {
 }
 
 
-void luaG_errormsg (lua_State *L) {
-  if (L->errfunc != 0) {  /* is there an error handling function? */
+void
+luaG_errormsg(lua_State * L)
+{
+  if (L->errfunc != 0) {        /* is there an error handling function? */
     StkId errfunc = restorestack(L, L->errfunc);
-    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
-    setobjs2s(L->top, L->top - 1);  /* move argument */
-    setobjs2s(L->top - 1, errfunc);  /* push function */
+    if (!ttisfunction(errfunc))
+      luaD_throw(L, LUA_ERRERR);
+    setobjs2s(L->top, L->top - 1);      /* move argument */
+    setobjs2s(L->top - 1, errfunc);     /* push function */
     incr_top(L);
-    luaD_call(L, L->top - 2, 1);  /* call it */
+    luaD_call(L, L->top - 2, 1);        /* call it */
   }
   luaD_throw(L, LUA_ERRRUN);
 }
 
 
-void luaG_runerror (lua_State *L, const char *fmt, ...) {
+void
+luaG_runerror(lua_State * L, const char *fmt, ...)
+{
   va_list argp;
   va_start(argp, fmt);
   addinfo(L, luaO_pushvfstring(L, fmt, argp));
   va_end(argp);
   luaG_errormsg(L);
 }
-
index da1d10e..bb78fa6 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: ldebug.h,v 1.32 2002/11/18 11:01:55 roberto Exp $
 ** Auxiliary functions from Debug Interface module
 #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));
-void luaG_aritherror (lua_State *L, const TObject *p1, const TObject *p2) __attribute__((noreturn));
-int luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2) __attribute__((noreturn));
-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);
+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));
+void luaG_aritherror(lua_State * L, const TObject * p1, const TObject * p2) __attribute__ ((noreturn));
+int luaG_ordererror(lua_State * L, const TObject * p1, const TObject * p2) __attribute__ ((noreturn));
+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
index a6d344c..67e548b 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: ldo.c,v 1.217a 2003/04/03 13:35:34 roberto Exp $
 ** Stack and Call structure of Lua
 struct lua_longjmp {
   struct lua_longjmp *previous;
   jmp_buf b;
-  volatile int status;  /* error code */
+  volatile int status;                 /* error code */
 };
 
 
-static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
+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: {
-      setobjs2s(oldtop, L->top - 1);  /* error message on current top */
+  case LUA_ERRSYNTAX:
+  case LUA_ERRRUN:{
+      setobjs2s(oldtop, L->top - 1);    /* error message on current top */
       break;
     }
   }
@@ -67,35 +70,40 @@ static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
 }
 
 
-void luaD_throw (lua_State *L, int errcode) {
+void
+luaD_throw(lua_State * L, int errcode)
+{
   if (L->errorJmp) {
     L->errorJmp->status = errcode;
     longjmp(L->errorJmp->b, 1);
-  }
-  else {
+  } else {
     G(L)->panic(L);
     exit(EXIT_FAILURE);
   }
 }
 
 
-int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
+int
+luaD_rawrunprotected(lua_State * L, Pfunc f, void *ud)
+{
   struct lua_longjmp lj;
   lj.status = 0;
-  lj.previous = L->errorJmp;  /* chain new error handler */
+  lj.previous = L->errorJmp;    /* chain new error handler */
   L->errorJmp = &lj;
   if (setjmp(lj.b) == 0)
-    (*f)(L, ud);
-  L->errorJmp = lj.previous;  /* restore old error handler */
+    (*f) (L, ud);
+  L->errorJmp = lj.previous;    /* restore old error handler */
   return lj.status;
 }
 
 
-static void restore_stack_limit (lua_State *L) {
-  L->stack_last = L->stack+L->stacksize-1;
-  if (L->size_ci > LUA_MAXCALLS) {  /* there was an overflow? */
+static void
+restore_stack_limit(lua_State * L)
+{
+  L->stack_last = L->stack + L->stacksize - 1;
+  if (L->size_ci > LUA_MAXCALLS) {      /* there was an overflow? */
     int inuse = (L->ci - L->base_ci);
-    if (inuse + 1 < LUA_MAXCALLS)  /* can `undo' overflow? */
+    if (inuse + 1 < LUA_MAXCALLS)       /* can `undo' overflow? */
       luaD_reallocCI(L, LUA_MAXCALLS);
   }
 }
@@ -103,7 +111,9 @@ static void restore_stack_limit (lua_State *L) {
 /* }====================================================== */
 
 
-static void correctstack (lua_State *L, TObject *oldstack) {
+static void
+correctstack(lua_State * L, TObject * oldstack)
+{
   CallInfo *ci;
   GCObject *up;
   L->top = (L->top - oldstack) + L->stack;
@@ -117,16 +127,20 @@ static void correctstack (lua_State *L, TObject *oldstack) {
 }
 
 
-void luaD_reallocstack (lua_State *L, int newsize) {
+void
+luaD_reallocstack(lua_State * L, int newsize)
+{
   TObject *oldstack = L->stack;
   luaM_reallocvector(L, L->stack, L->stacksize, newsize, TObject);
   L->stacksize = newsize;
-  L->stack_last = L->stack+newsize-1-EXTRA_STACK;
+  L->stack_last = L->stack + newsize - 1 - EXTRA_STACK;
   correctstack(L, oldstack);
 }
 
 
-void luaD_reallocCI (lua_State *L, int newsize) {
+void
+luaD_reallocCI(lua_State * L, int newsize)
+{
   CallInfo *oldci = L->base_ci;
   luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
   L->size_ci = cast(unsigned short, newsize);
@@ -135,26 +149,32 @@ void luaD_reallocCI (lua_State *L, int newsize) {
 }
 
 
-void luaD_growstack (lua_State *L, int n) {
-  if (n <= L->stacksize)  /* double size is enough? */
-    luaD_reallocstack(L, 2*L->stacksize);
+void
+luaD_growstack(lua_State * L, int n)
+{
+  if (n <= L->stacksize)        /* double size is enough? */
+    luaD_reallocstack(L, 2 * L->stacksize);
   else
     luaD_reallocstack(L, L->stacksize + n + EXTRA_STACK);
 }
 
 
-static void luaD_growCI (lua_State *L) {
-  if (L->size_ci > LUA_MAXCALLS)  /* overflow while handling overflow? */
+static void
+luaD_growCI(lua_State * L)
+{
+  if (L->size_ci > LUA_MAXCALLS)        /* overflow while handling overflow? */
     luaD_throw(L, LUA_ERRERR);
   else {
-    luaD_reallocCI(L, 2*L->size_ci);
+    luaD_reallocCI(L, 2 * L->size_ci);
     if (L->size_ci > LUA_MAXCALLS)
       luaG_runerror(L, "stack overflow");
   }
 }
 
 
-void luaD_callhook (lua_State *L, int event, int line) {
+void
+luaD_callhook(lua_State * L, int event, int line)
+{
   lua_Hook hook = L->hook;
   if (hook && L->allowhook) {
     ptrdiff_t top = savestack(L, L->top);
@@ -163,14 +183,14 @@ void luaD_callhook (lua_State *L, int event, int line) {
     ar.event = event;
     ar.currentline = line;
     if (event == LUA_HOOKTAILRET)
-      ar.i_ci = 0;  /* tail call; no debug information about it */
+      ar.i_ci = 0;              /* tail call; no debug information about it */
     else
       ar.i_ci = L->ci - L->base_ci;
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
+    luaD_checkstack(L, LUA_MINSTACK);   /* ensure minimum stack size */
     L->ci->top = L->top + LUA_MINSTACK;
-    L->allowhook = 0;  /* cannot call hooks inside a hook */
+    L->allowhook = 0;           /* cannot call hooks inside a hook */
     lua_unlock(L);
-    (*hook)(L, &ar);
+    (*hook) (L, &ar);
     lua_lock(L);
     lua_assert(!L->allowhook);
     L->allowhook = 1;
@@ -180,59 +200,68 @@ void luaD_callhook (lua_State *L, int event, int line) {
 }
 
 
-static void adjust_varargs (lua_State *L, int nfixargs, StkId base) {
+static void
+adjust_varargs(lua_State * L, int nfixargs, StkId base)
+{
   int i;
   Table *htab;
   TObject nname;
-  int actual = L->top - base;  /* actual number of arguments */
+  int actual = L->top - base;          /* actual number of arguments */
   if (actual < nfixargs) {
     luaD_checkstack(L, nfixargs - actual);
     for (; actual < nfixargs; ++actual)
       setnilvalue(L->top++);
   }
-  actual -= nfixargs;  /* number of extra arguments */
-  htab = luaH_new(L, actual, 1);  /* create `arg' table */
-  for (i=0; i<actual; i++)  /* put extra arguments into `arg' table */
-    setobj2n(luaH_setnum(L, htab, i+1), L->top - actual + i);
+  actual -= nfixargs;           /* number of extra arguments */
+  htab = luaH_new(L, actual, 1);        /* create `arg' table */
+  for (i = 0; i < actual; i++)  /* put extra arguments into `arg' table */
+    setobj2n(luaH_setnum(L, htab, i + 1), L->top - actual + i);
   /* store counter in field `n' */
   setsvalue(&nname, luaS_newliteral(L, "n"));
   setnvalue(luaH_set(L, htab, &nname), cast(lua_Number, actual));
-  L->top -= actual;  /* remove extra elements from the stack */
+  L->top -= actual;             /* remove extra elements from the stack */
   sethvalue(L->top, htab);
   incr_top(L);
 }
 
 
-static StkId tryfuncTM (lua_State *L, StkId func) {
+static StkId
+tryfuncTM(lua_State * L, StkId func)
+{
   const TObject *tm = luaT_gettmbyobj(L, func, TM_CALL);
   StkId p;
   ptrdiff_t funcr = savestack(L, func);
   if (!ttisfunction(tm))
     luaG_typeerror(L, func, "call");
   /* Open a hole inside the stack at `func' */
-  for (p = L->top; p > func; p--) setobjs2s(p, p-1);
+  for (p = L->top; p > func; p--)
+    setobjs2s(p, p - 1);
   incr_top(L);
-  func = restorestack(L, funcr);  /* previous call may change stack */
-  setobj2s(func, tm);  /* tag method is the new function to be called */
+  func = restorestack(L, funcr);        /* previous call may change stack */
+  setobj2s(func, tm);           /* tag method is the new function to be called */
   return func;
 }
 
 
-StkId luaD_precall (lua_State *L, StkId func) {
+StkId
+luaD_precall(lua_State * L, StkId func)
+{
   LClosure *cl;
   ptrdiff_t funcr = savestack(L, func);
-  if (!ttisfunction(func)) /* `func' is not a function? */
+  if (!ttisfunction(func))      /* `func' is not a function? */
     func = tryfuncTM(L, func);  /* check the `function' tag method */
-  if (L->ci + 1 == L->end_ci) luaD_growCI(L);
-  else condhardstacktests(luaD_reallocCI(L, L->size_ci));
+  if (L->ci + 1 == L->end_ci)
+    luaD_growCI(L);
+  else
+    condhardstacktests(luaD_reallocCI(L, L->size_ci));
   cl = &clvalue(func)->l;
-  if (!cl->isC) {  /* Lua function? prepare its call */
+  if (!cl->isC) {               /* Lua function? prepare its call */
     CallInfo *ci;
     Proto *p = cl->p;
-    if (p->is_vararg)  /* varargs? */
-      adjust_varargs(L, p->numparams, func+1);
+    if (p->is_vararg)           /* varargs? */
+      adjust_varargs(L, p->numparams, func + 1);
     luaD_checkstack(L, p->maxstacksize);
-    ci = ++L->ci;  /* now `enter' new function */
+    ci = ++L->ci;               /* now `enter' new function */
     L->base = L->ci->base = restorestack(L, funcr) + 1;
     ci->top = L->base + p->maxstacksize;
     ci->u.l.savedpc = p->code;  /* starting point */
@@ -242,46 +271,49 @@ StkId luaD_precall (lua_State *L, StkId func) {
       setnilvalue(L->top++);
     L->top = ci->top;
     return NULL;
-  }
-  else {  /* if is a C function, call it */
+  } else {                      /* if is a C function, call it */
     CallInfo *ci;
     int n;
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    ci = ++L->ci;  /* now `enter' new function */
+    luaD_checkstack(L, LUA_MINSTACK);   /* ensure minimum stack size */
+    ci = ++L->ci;               /* now `enter' new function */
     L->base = L->ci->base = restorestack(L, funcr) + 1;
     ci->top = L->top + LUA_MINSTACK;
-    ci->state = CI_C;  /* a C function */
+    ci->state = CI_C;           /* a C function */
     if (L->hookmask & LUA_MASKCALL)
       luaD_callhook(L, LUA_HOOKCALL, -1);
     lua_unlock(L);
 #ifdef LUA_COMPATUPVALUES
     lua_pushupvalues(L);
 #endif
-    n = (*clvalue(L->base - 1)->c.f)(L);  /* do the actual call */
+    n = (*clvalue(L->base - 1)->c.f) (L);       /* do the actual call */
     lua_lock(L);
     return L->top - n;
   }
 }
 
 
-static StkId callrethooks (lua_State *L, StkId firstResult) {
-  ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */
+static StkId
+callrethooks(lua_State * L, StkId firstResult)
+{
+  ptrdiff_t fr = savestack(L, firstResult);     /* next call may change stack */
   luaD_callhook(L, LUA_HOOKRET, -1);
-  if (!(L->ci->state & CI_C)) {  /* Lua function? */
-    while (L->ci->u.l.tailcalls--)  /* call hook for eventual tail calls */
+  if (!(L->ci->state & CI_C)) { /* Lua function? */
+    while (L->ci->u.l.tailcalls--)      /* call hook for eventual tail calls */
       luaD_callhook(L, LUA_HOOKTAILRET, -1);
   }
   return restorestack(L, fr);
 }
 
 
-void luaD_poscall (lua_State *L, int wanted, StkId firstResult) { 
+void
+luaD_poscall(lua_State * L, int wanted, StkId firstResult)
+{
   StkId res;
   if (L->hookmask & LUA_MASKRET)
     firstResult = callrethooks(L, firstResult);
-  res = L->base - 1;  /* res == final position of 1st result */
+  res = L->base - 1;            /* res == final position of 1st result */
   L->ci--;
-  L->base = L->ci->base;  /* restore base */
+  L->base = L->ci->base;        /* restore base */
   /* move results to correct place */
   while (wanted != 0 && firstResult < L->top) {
     setobjs2s(res++, firstResult++);
@@ -298,56 +330,60 @@ void luaD_poscall (lua_State *L, int wanted, StkId firstResult) {
 ** The arguments are on the stack, right after the function.
 ** When returns, all the results are on the stack, starting at the original
 ** function position.
-*/ 
-void luaD_call (lua_State *L, StkId func, int nResults) {
+*/
+void
+luaD_call(lua_State * L, StkId func, int nResults)
+{
   StkId firstResult;
   lua_assert(!(L->ci->state & CI_CALLING));
   if (++L->nCcalls >= LUA_MAXCCALLS) {
     if (L->nCcalls == LUA_MAXCCALLS)
       luaG_runerror(L, "C stack overflow");
-    else if (L->nCcalls >= (LUA_MAXCCALLS + (LUA_MAXCCALLS>>3)))
-      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
+    else if (L->nCcalls >= (LUA_MAXCCALLS + (LUA_MAXCCALLS >> 3)))
+      luaD_throw(L, LUA_ERRERR);        /* error while handing stack error */
   }
   firstResult = luaD_precall(L, func);
-  if (firstResult == NULL)  /* is a Lua function? */
-    firstResult = luaV_execute(L);  /* call it */
+  if (firstResult == NULL)      /* is a Lua function? */
+    firstResult = luaV_execute(L);      /* call it */
   luaD_poscall(L, nResults, firstResult);
   L->nCcalls--;
   luaC_checkGC(L);
 }
 
 
-static void resume (lua_State *L, void *ud) {
+static void
+resume(lua_State * L, void *ud)
+{
   StkId firstResult;
   int nargs = *cast(int *, ud);
   CallInfo *ci = L->ci;
-  if (ci == L->base_ci) {  /* no activation record? */
+  if (ci == L->base_ci) {       /* no activation record? */
     lua_assert(nargs < L->top - L->base);
-    luaD_precall(L, L->top - (nargs + 1));  /* start coroutine */
-  }
-  else {  /* inside a yield */
+    luaD_precall(L, L->top - (nargs + 1));      /* start coroutine */
+  } else {                      /* inside a yield */
     lua_assert(ci->state & CI_YIELD);
-    if (ci->state & CI_C) {  /* `common' yield? */
+    if (ci->state & CI_C) {     /* `common' yield? */
       /* finish interrupted execution of `OP_CALL' */
       int nresults;
-      lua_assert((ci-1)->state & CI_SAVEDPC);
-      lua_assert(GET_OPCODE(*((ci-1)->u.l.savedpc - 1)) == OP_CALL ||
-                 GET_OPCODE(*((ci-1)->u.l.savedpc - 1)) == OP_TAILCALL);
-      nresults = GETARG_C(*((ci-1)->u.l.savedpc - 1)) - 1;
-      luaD_poscall(L, nresults, L->top - nargs);  /* complete it */
-      if (nresults >= 0) L->top = L->ci->top;
-    }
-    else {  /* yielded inside a hook: just continue its execution */
+      lua_assert((ci - 1)->state & CI_SAVEDPC);
+      lua_assert(GET_OPCODE(*((ci - 1)->u.l.savedpc - 1)) == OP_CALL || GET_OPCODE(*((ci - 1)->u.l.savedpc - 1)) == OP_TAILCALL);
+      nresults = GETARG_C(*((ci - 1)->u.l.savedpc - 1)) - 1;
+      luaD_poscall(L, nresults, L->top - nargs);        /* complete it */
+      if (nresults >= 0)
+        L->top = L->ci->top;
+    } else {                    /* yielded inside a hook: just continue its execution */
       ci->state &= ~CI_YIELD;
     }
   }
   firstResult = luaV_execute(L);
-  if (firstResult != NULL)   /* return? */
+  if (firstResult != NULL)      /* return? */
     luaD_poscall(L, LUA_MULTRET, firstResult);  /* finalize this coroutine */
 }
 
 
-static int resume_error (lua_State *L, const char *msg) {
+static int
+resume_error(lua_State * L, const char *msg)
+{
   L->top = L->ci->base;
   setsvalue2s(L->top, luaS_new(L, msg));
   incr_top(L);
@@ -356,24 +392,25 @@ static int resume_error (lua_State *L, const char *msg) {
 }
 
 
-LUA_API int lua_resume (lua_State *L, int nargs) {
+LUA_API int
+lua_resume(lua_State * L, int nargs)
+{
   int status;
   lu_byte old_allowhooks;
   lua_lock(L);
   if (L->ci == L->base_ci) {
     if (nargs >= L->top - L->base)
       return resume_error(L, "cannot resume dead coroutine");
-  }
-  else if (!(L->ci->state & CI_YIELD))  /* not inside a yield? */
+  } else if (!(L->ci->state & CI_YIELD))        /* not inside a yield? */
     return resume_error(L, "cannot resume non-suspended coroutine");
   old_allowhooks = L->allowhook;
   lua_assert(L->errfunc == 0 && L->nCcalls == 0);
   status = luaD_rawrunprotected(L, resume, &nargs);
-  if (status != 0) {  /* error? */
-    L->ci = L->base_ci;  /* go back to initial level */
+  if (status != 0) {            /* error? */
+    L->ci = L->base_ci;         /* go back to initial level */
     L->base = L->ci->base;
     L->nCcalls = 0;
-    luaF_close(L, L->base);  /* close eventual pending closures */
+    luaF_close(L, L->base);     /* close eventual pending closures */
     seterrorobj(L, status, L->base);
     L->allowhook = old_allowhooks;
     restore_stack_limit(L);
@@ -383,30 +420,33 @@ LUA_API int lua_resume (lua_State *L, int nargs) {
 }
 
 
-LUA_API int lua_yield (lua_State *L, int nresults) {
+LUA_API int
+lua_yield(lua_State * L, int nresults)
+{
   CallInfo *ci;
   lua_lock(L);
   ci = L->ci;
   if (L->nCcalls > 0)
     luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
-  if (ci->state & CI_C) {  /* usual yield */
-    if ((ci-1)->state & CI_C)
+  if (ci->state & CI_C) {       /* usual yield */
+    if ((ci - 1)->state & CI_C)
       luaG_runerror(L, "cannot yield a C function");
     if (L->top - nresults > L->base) {  /* is there garbage in the stack? */
       int i;
-      for (i=0; i<nresults; i++)  /* move down results */
+      for (i = 0; i < nresults; i++)    /* move down results */
         setobjs2s(L->base + i, L->top - nresults + i);
       L->top = L->base + nresults;
     }
-  } /* else it's an yield inside a hook: nothing to do */
+  }                             /* else it's an yield inside a hook: nothing to do */
   ci->state |= CI_YIELD;
   lua_unlock(L);
   return -1;
 }
 
 
-int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                ptrdiff_t old_top, ptrdiff_t ef) {
+int
+luaD_pcall(lua_State * L, Pfunc func, void *u, ptrdiff_t old_top, ptrdiff_t ef)
+{
   int status;
   unsigned short oldnCcalls = L->nCcalls;
   ptrdiff_t old_ci = saveci(L, L->ci);
@@ -414,9 +454,9 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u,
   ptrdiff_t old_errfunc = L->errfunc;
   L->errfunc = ef;
   status = luaD_rawrunprotected(L, func, u);
-  if (status != 0) {  /* an error occurred? */
+  if (status != 0) {            /* an error occurred? */
     StkId oldtop = restorestack(L, old_top);
-    luaF_close(L, oldtop);  /* close eventual pending closures */
+    luaF_close(L, oldtop);      /* close eventual pending closures */
     seterrorobj(L, status, oldtop);
     L->nCcalls = oldnCcalls;
     L->ci = restoreci(L, old_ci);
@@ -433,13 +473,15 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u,
 /*
 ** Execute a protected parser.
 */
-struct SParser {  /* data to `f_parser' */
+struct SParser {                       /* data to `f_parser' */
   ZIO *z;
-  Mbuffer buff;  /* buffer to be used by the scanner */
+  Mbuffer buff;                        /* buffer to be used by the scanner */
   int bin;
 };
 
-static void f_parser (lua_State *L, void *ud) {
+static void
+f_parser(lua_State * L, void *ud)
+{
   struct SParser *p;
   Proto *tf;
   Closure *cl;
@@ -453,19 +495,20 @@ static void f_parser (lua_State *L, void *ud) {
 }
 
 
-int luaD_protectedparser (lua_State *L, ZIO *z, int bin) {
+int
+luaD_protectedparser(lua_State * L, ZIO * z, int bin)
+{
   struct SParser p;
   int status;
-  ptrdiff_t oldtopr = savestack(L, L->top);  /* save current top */
-  p.z = z; p.bin = bin;
+  ptrdiff_t oldtopr = savestack(L, L->top);     /* save current top */
+  p.z = z;
+  p.bin = bin;
   luaZ_initbuffer(L, &p.buff);
   status = luaD_rawrunprotected(L, f_parser, &p);
   luaZ_freebuffer(L, &p.buff);
-  if (status != 0) {  /* error? */
+  if (status != 0) {            /* error? */
     StkId oldtop = restorestack(L, oldtopr);
     seterrorobj(L, status, oldtop);
   }
   return status;
 }
-
-
index dd275d6..6d10698 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: ldo.h,v 1.56 2002/12/04 17:29:32 roberto Exp $
 ** Stack and Call structure of Lua
 #include "lstate.h"
 #include "lzio.h"
 
-#include "defs.h" /* ARM_NOWARN_ALIGN */
+#include "defs.h"               /* ARM_NOWARN_ALIGN */
 
 /*
 ** macro to control inclusion of some hard tests on stack reallocation
-*/ 
+*/
 #ifndef HARDSTACKTESTS
 #define condhardstacktests(x)  { /* empty */ }
 #else
 
 
 /* type of protected functions, to be ran by `runprotected' */
-typedef void (*Pfunc) (lua_State *L, void *ud);
-
-void luaD_resetprotection (lua_State *L);
-int luaD_protectedparser (lua_State *L, ZIO *z, int bin);
-void luaD_callhook (lua_State *L, int event, int line);
-StkId luaD_precall (lua_State *L, StkId func);
-void luaD_call (lua_State *L, StkId func, int nResults);
-int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                ptrdiff_t oldtop, ptrdiff_t ef);
-void luaD_poscall (lua_State *L, int wanted, StkId firstResult);
-void luaD_reallocCI (lua_State *L, int newsize);
-void luaD_reallocstack (lua_State *L, int newsize);
-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);
+typedef void (*Pfunc) (lua_State * L, void *ud);
+
+void luaD_resetprotection(lua_State * L);
+int luaD_protectedparser(lua_State * L, ZIO * z, int bin);
+void luaD_callhook(lua_State * L, int event, int line);
+StkId luaD_precall(lua_State * L, StkId func);
+void luaD_call(lua_State * L, StkId func, int nResults);
+int luaD_pcall(lua_State * L, Pfunc func, void *u, ptrdiff_t oldtop, ptrdiff_t ef);
+void luaD_poscall(lua_State * L, int wanted, StkId firstResult);
+void luaD_reallocCI(lua_State * L, int newsize);
+void luaD_reallocstack(lua_State * L, int newsize);
+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
index 5757364..0258957 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: ldump.c,v 1.4 2003/02/11 23:52:12 lhf Exp $
 ** save bytecodes
 #define DumpLiteral(s,D)       DumpBlock("" s,(sizeof(s))-1,D)
 
 typedef struct {
lua_State* L;
- lua_Chunkwriter write;
void* data;
 lua_State *L;
 lua_Chunkwriter write;
 void *data;
 } DumpState;
 
-static void DumpBlock(const void* b, size_t size, DumpState* D)
+static void
+DumpBlock(const void *b, size_t size, DumpState * D)
 {
- lua_unlock(D->L);
(*D->write)(D->L,b,size,D->data);
- lua_lock(D->L);
 lua_unlock(D->L);
 (*D->write) (D->L, b, size, D->data);
 lua_lock(D->L);
 }
 
-static void DumpByte(int y, DumpState* D)
+static void
+DumpByte(int y, DumpState * D)
 {
char x=(char)y;
DumpBlock(&x,sizeof(x),D);
 char x = (char)y;
 DumpBlock(&x, sizeof(x), D);
 }
 
-static void DumpInt(int x, DumpState* D)
+static void
+DumpInt(int x, DumpState * D)
 {
DumpBlock(&x,sizeof(x),D);
 DumpBlock(&x, sizeof(x), D);
 }
 
-static void DumpSize(size_t x, DumpState* D)
+static void
+DumpSize(size_t x, DumpState * D)
 {
DumpBlock(&x,sizeof(x),D);
 DumpBlock(&x, sizeof(x), D);
 }
 
-static void DumpNumber(lua_Number x, DumpState* D)
+static void
+DumpNumber(lua_Number x, DumpState * D)
 {
DumpBlock(&x,sizeof(x),D);
 DumpBlock(&x, sizeof(x), D);
 }
 
-static void DumpString(TString* s, DumpState* D)
+static void
+DumpString(TString * s, DumpState * D)
 {
- if (s==NULL || getstr(s)==NULL)
-  DumpSize(0,D);
- else
- {
-  size_t size=s->tsv.len+1;            /* include trailing '\0' */
-  DumpSize(size,D);
-  DumpBlock(getstr(s),size,D);
- }
+  if (s == NULL || getstr(s) == NULL)
+    DumpSize(0, D);
+  else {
+    size_t size = s->tsv.len + 1;      /* include trailing '\0' */
+    DumpSize(size, D);
+    DumpBlock(getstr(s), size, D);
+  }
 }
 
-static void DumpCode(const Proto* f, DumpState* D)
+static void
+DumpCode(const Proto * f, DumpState * D)
 {
DumpInt(f->sizecode,D);
DumpVector(f->code,f->sizecode,sizeof(*f->code),D);
 DumpInt(f->sizecode, D);
 DumpVector(f->code, f->sizecode, sizeof(*f->code), D);
 }
 
-static void DumpLocals(const Proto* f, DumpState* D)
+static void
+DumpLocals(const Proto * f, DumpState * D)
 {
- int i,n=f->sizelocvars;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
-  DumpString(f->locvars[i].varname,D);
-  DumpInt(f->locvars[i].startpc,D);
-  DumpInt(f->locvars[i].endpc,D);
- }
+  int i, n = f->sizelocvars;
+  DumpInt(n, D);
+  for (i = 0; i < n; i++) {
+    DumpString(f->locvars[i].varname, D);
+    DumpInt(f->locvars[i].startpc, D);
+    DumpInt(f->locvars[i].endpc, D);
+  }
 }
 
-static void DumpLines(const Proto* f, DumpState* D)
+static void
+DumpLines(const Proto * f, DumpState * D)
 {
DumpInt(f->sizelineinfo,D);
DumpVector(f->lineinfo,f->sizelineinfo,sizeof(*f->lineinfo),D);
 DumpInt(f->sizelineinfo, D);
 DumpVector(f->lineinfo, f->sizelineinfo, sizeof(*f->lineinfo), D);
 }
 
-static void DumpUpvalues(const Proto* f, DumpState* D)
+static void
+DumpUpvalues(const Proto * f, DumpState * D)
 {
- int i,n=f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
+  int i, n = f->sizeupvalues;
+  DumpInt(n, D);
+  for (i = 0; i < n; i++)
+    DumpString(f->upvalues[i], D);
 }
 
-static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
+static void DumpFunction(const Proto * f, const TString * p, DumpState * D);
 
-static void DumpConstants(const Proto* f, DumpState* D)
+static void
+DumpConstants(const Proto * f, DumpState * D)
 {
- int i,n;
- DumpInt(n=f->sizek,D);
- for (i=0; i<n; i++)
- {
-  const TObject* o= &f->k[i];
-  DumpByte(ttype(o),D);
-  switch (ttype(o))
-  {
-   case LUA_TNUMBER:
-       DumpNumber(nvalue(o),D);
-       break;
-   case LUA_TSTRING:
-       DumpString(tsvalue(o),D);
-       break;
-   case LUA_TNIL:
-       break;
-   default:
-       lua_assert(0);                  /* cannot happen */
-       break;
+  int i, n;
+  DumpInt(n = f->sizek, D);
+  for (i = 0; i < n; i++) {
+    const TObject *o = &f->k[i];
+    DumpByte(ttype(o), D);
+    switch (ttype(o)) {
+    case LUA_TNUMBER:
+      DumpNumber(nvalue(o), D);
+      break;
+    case LUA_TSTRING:
+      DumpString(tsvalue(o), D);
+      break;
+    case LUA_TNIL:
+      break;
+    default:
+      lua_assert(0);            /* cannot happen */
+      break;
+    }
   }
- }
- DumpInt(n=f->sizep,D);
for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
+  DumpInt(n = f->sizep, D);
+  for (i = 0; i < n; i++)
   DumpFunction(f->p[i], f->source, D);
 }
 
-static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
+static void
+DumpFunction(const Proto * f, const TString * p, DumpState * D)
 {
DumpString((f->source==p) ? NULL : f->source,D);
DumpInt(f->lineDefined,D);
DumpByte(f->nups,D);
DumpByte(f->numparams,D);
DumpByte(f->is_vararg,D);
DumpByte(f->maxstacksize,D);
DumpLines(f,D);
DumpLocals(f,D);
DumpUpvalues(f,D);
DumpConstants(f,D);
DumpCode(f,D);
 DumpString((f->source == p) ? NULL : f->source, D);
 DumpInt(f->lineDefined, D);
 DumpByte(f->nups, D);
 DumpByte(f->numparams, D);
 DumpByte(f->is_vararg, D);
 DumpByte(f->maxstacksize, D);
 DumpLines(f, D);
 DumpLocals(f, D);
 DumpUpvalues(f, D);
 DumpConstants(f, D);
 DumpCode(f, D);
 }
 
-static void DumpHeader(DumpState* D)
+static void
+DumpHeader(DumpState * D)
 {
DumpLiteral(LUA_SIGNATURE,D);
DumpByte(VERSION,D);
DumpByte(luaU_endianness(),D);
DumpByte(sizeof(int),D);
DumpByte(sizeof(size_t),D);
DumpByte(sizeof(Instruction),D);
DumpByte(SIZE_OP,D);
DumpByte(SIZE_A,D);
DumpByte(SIZE_B,D);
DumpByte(SIZE_C,D);
DumpByte(sizeof(lua_Number),D);
DumpNumber(TEST_NUMBER,D);
 DumpLiteral(LUA_SIGNATURE, D);
 DumpByte(VERSION, D);
 DumpByte(luaU_endianness(), D);
 DumpByte(sizeof(int), D);
 DumpByte(sizeof(size_t), D);
 DumpByte(sizeof(Instruction), D);
 DumpByte(SIZE_OP, D);
 DumpByte(SIZE_A, D);
 DumpByte(SIZE_B, D);
 DumpByte(SIZE_C, D);
 DumpByte(sizeof(lua_Number), D);
 DumpNumber(TEST_NUMBER, D);
 }
 
 /*
 ** dump function as precompiled chunk
 */
-void luaU_dump (lua_State* L, const Proto* Main, lua_Chunkwriter w, void* data)
+void
+luaU_dump(lua_State * L, const Proto * Main, lua_Chunkwriter w, void *data)
 {
- DumpState D;
D.L=L;
D.write=w;
D.data=data;
- DumpHeader(&D);
DumpFunction(Main,NULL,&D);
 DumpState D;
 D.L = L;
 D.write = w;
 D.data = data;
 DumpHeader(&D);
 DumpFunction(Main, NULL, &D);
 }
-
index 31044fa..cae9520 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lfunc.c,v 1.67 2003/03/18 12:50:04 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
@@ -26,7 +27,9 @@
 
 
 
-Closure *luaF_newCclosure (lua_State *L, int nelems) {
+Closure *
+luaF_newCclosure(lua_State * L, int nelems)
+{
   Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
   luaC_link(L, valtogco(c), LUA_TFUNCTION);
   c->c.isC = 1;
@@ -35,7 +38,9 @@ Closure *luaF_newCclosure (lua_State *L, int nelems) {
 }
 
 
-Closure *luaF_newLclosure (lua_State *L, int nelems, TObject *e) {
+Closure *
+luaF_newLclosure(lua_State * L, int nelems, TObject * e)
+{
   Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
   luaC_link(L, valtogco(c), LUA_TFUNCTION);
   c->l.isC = 0;
@@ -45,36 +50,43 @@ Closure *luaF_newLclosure (lua_State *L, int nelems, TObject *e) {
 }
 
 
-UpVal *luaF_findupval (lua_State *L, StkId level) {
+UpVal *
+luaF_findupval(lua_State * L, StkId level)
+{
   GCObject **pp = &L->openupval;
   UpVal *p;
   UpVal *v;
   while ((p = ngcotouv(*pp)) != NULL && p->v >= level) {
-    if (p->v == level) return p;
+    if (p->v == level)
+      return p;
     pp = &p->next;
   }
-  v = luaM_new(L, UpVal);  /* not found: create a new one */
+  v = luaM_new(L, UpVal);       /* not found: create a new one */
   v->tt = LUA_TUPVAL;
-  v->marked = 1;  /* open upvalues should not be collected */
-  v->v = level;  /* current value lives in the stack */
-  v->next = *pp;  /* chain it in the proper position */
+  v->marked = 1;                /* open upvalues should not be collected */
+  v->v = level;                 /* current value lives in the stack */
+  v->next = *pp;                /* chain it in the proper position */
   *pp = valtogco(v);
   return v;
 }
 
 
-void luaF_close (lua_State *L, StkId level) {
+void
+luaF_close(lua_State * L, StkId level)
+{
   UpVal *p;
   while ((p = ngcotouv(L->openupval)) != NULL && p->v >= level) {
-    setobj(&p->value, p->v);  /* save current value (write barrier) */
-    p->v = &p->value;  /* now current value lives here */
-    L->openupval = p->next;  /* remove from `open' list */
+    setobj(&p->value, p->v);    /* save current value (write barrier) */
+    p->v = &p->value;           /* now current value lives here */
+    L->openupval = p->next;     /* remove from `open' list */
     luaC_link(L, valtogco(p), LUA_TUPVAL);
   }
 }
 
 
-Proto *luaF_newproto (lua_State *L) {
+Proto *
+luaF_newproto(lua_State * L)
+{
   Proto *f = luaM_new(L, Proto);
   luaC_link(L, valtogco(f), LUA_TPROTO);
   f->k = NULL;
@@ -99,7 +111,9 @@ Proto *luaF_newproto (lua_State *L) {
 }
 
 
-void luaF_freeproto (lua_State *L, Proto *f) {
+void
+luaF_freeproto(lua_State * L, Proto * f)
+{
   luaM_freearray(L, f->code, f->sizecode, Instruction);
   luaM_freearray(L, f->p, f->sizep, Proto *);
   luaM_freearray(L, f->k, f->sizek, TObject);
@@ -110,9 +124,10 @@ void luaF_freeproto (lua_State *L, Proto *f) {
 }
 
 
-void luaF_freeclosure (lua_State *L, Closure *c) {
-  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
-                          sizeLclosure(c->l.nupvalues);
+void
+luaF_freeclosure(lua_State * L, Closure * c)
+{
+  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) : sizeLclosure(c->l.nupvalues);
   luaM_free(L, c, size);
 }
 
@@ -121,15 +136,16 @@ void luaF_freeclosure (lua_State *L, Closure *c) {
 ** Look for n-th local variable at line `line' in function `func'.
 ** Returns NULL if not found.
 */
-const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
+const char *
+luaF_getlocalname(const Proto * f, int local_number, int pc)
+{
   int i;
-  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
-    if (pc < f->locvars[i].endpc) {  /* is variable active? */
+  for (i = 0; i < f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
+    if (pc < f->locvars[i].endpc) {     /* is variable active? */
       local_number--;
       if (local_number == 0)
         return getstr(f->locvars[i].varname);
     }
   }
-  return NULL;  /* not found */
+  return NULL;                  /* not found */
 }
-
index 5d53250..263d5f6 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lfunc.h,v 1.21 2003/03/18 12:50:04 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 #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);
-UpVal *luaF_findupval (lua_State *L, StkId level);
-void luaF_close (lua_State *L, StkId level);
-void luaF_freeproto (lua_State *L, Proto *f);
-void luaF_freeclosure (lua_State *L, Closure *c);
+Proto *luaF_newproto(lua_State * L);
+Closure *luaF_newCclosure(lua_State * L, int nelems);
+Closure *luaF_newLclosure(lua_State * L, int nelems, TObject * e);
+UpVal *luaF_findupval(lua_State * L, StkId level);
+void luaF_close(lua_State * L, StkId level);
+void luaF_freeproto(lua_State * L, Proto * f);
+void luaF_freeclosure(lua_State * L, Closure * c);
 
-const char *luaF_getlocalname (const Proto *func, int local_number, int pc);
+const char *luaF_getlocalname(const Proto * func, int local_number, int pc);
 
 
 #endif
index 5e036d3..b801666 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lgc.c,v 1.171a 2003/04/03 13:35:34 roberto Exp $
 ** Garbage Collector
 
 
 typedef struct GCState {
-  GCObject *tmark;  /* list of marked objects to be traversed */
-  GCObject *wk;  /* list of traversed key-weak tables (to be cleared) */
-  GCObject *wv;  /* list of traversed value-weak tables */
-  GCObject *wkv;  /* list of traversed key-value weak tables */
+  GCObject *tmark;                     /* list of marked objects to be traversed */
+  GCObject *wk;                        /* list of traversed key-weak tables (to be cleared) */
+  GCObject *wv;                        /* list of traversed value-weak tables */
+  GCObject *wkv;                       /* list of traversed key-value weak tables */
   global_State *g;
 } GCState;
 
@@ -67,68 +68,74 @@ typedef struct GCState {
 
 
 
-static void reallymarkobject (GCState *st, GCObject *o) {
+static void
+reallymarkobject(GCState * st, GCObject * o)
+{
   lua_assert(!ismarked(o));
-  setbit(o->gch.marked, 0);  /* mark object */
+  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;
     }
-    default: lua_assert(o->gch.tt == LUA_TSTRING);
+  default:
+    lua_assert(o->gch.tt == LUA_TSTRING);
   }
 }
 
 
-static void marktmu (GCState *st) {
+static void
+marktmu(GCState * st)
+{
   GCObject *u;
   for (u = st->g->tmudata; u; u = u->gch.next) {
-    unmark(u);  /* may be marked, if left from previous GC */
+    unmark(u);                  /* may be marked, if left from previous GC */
     reallymarkobject(st, u);
   }
 }
 
 
 /* move `dead' udata that need finalization to list `tmudata' */
-size_t luaC_separateudata (lua_State *L) {
+size_t
+luaC_separateudata(lua_State * L)
+{
   size_t deadmem = 0;
   GCObject **p = &G(L)->rootudata;
   GCObject *curr;
-  GCObject *collected = NULL;  /* to collect udata with gc event */
+  GCObject *collected = NULL;          /* to collect udata with gc event */
   GCObject **lastcollected = &collected;
   while ((curr = *p) != NULL) {
     lua_assert(curr->gch.tt == LUA_TUSERDATA);
     if (ismarked(curr) || isfinalized(gcotou(curr)))
-      p = &curr->gch.next;  /* don't bother with them */
+      p = &curr->gch.next;      /* don't bother with them */
 
     else if (fasttm(L, gcotou(curr)->uv.metatable, TM_GC) == NULL) {
-      markfinalized(gcotou(curr));  /* don't need finalization */
+      markfinalized(gcotou(curr));      /* don't need finalization */
       p = &curr->gch.next;
-    }
-    else {  /* must call its gc method */
+    } else {                    /* must call its gc method */
       deadmem += sizeudata(gcotou(curr)->uv.len);
       *p = curr->gch.next;
-      curr->gch.next = NULL;  /* link `curr' at the end of `collected' list */
+      curr->gch.next = NULL;    /* link `curr' at the end of `collected' list */
       *lastcollected = curr;
       lastcollected = &curr->gch.next;
     }
@@ -140,14 +147,18 @@ size_t luaC_separateudata (lua_State *L) {
 }
 
 
-static void removekey (Node *n) {
-  setnilvalue(gval(n));  /* remove corresponding value ... */
+static void
+removekey(Node * n)
+{
+  setnilvalue(gval(n));         /* remove corresponding value ... */
   if (iscollectable(gkey(n)))
-    setttype(gkey(n), LUA_TNONE);  /* dead key; remove it */
+    setttype(gkey(n), LUA_TNONE);       /* dead key; remove it */
 }
 
 
-static void traversetable (GCState *st, Table *h) {
+static void
+traversetable(GCState * st, Table * h)
+{
   int i;
   int weakkey = 0;
   int weakvalue = 0;
@@ -155,18 +166,15 @@ static void traversetable (GCState *st, Table *h) {
   markvalue(st, h->metatable);
   lua_assert(h->lsizenode || h->node == st->g->dummynode);
   mode = gfasttm(st->g, h->metatable, TM_MODE);
-  if (mode && ttisstring(mode)) {  /* is there a weak mode? */
+  if (mode && ttisstring(mode)) {       /* is there a weak mode? */
     weakkey = (strchr(svalue(mode), 'k') != NULL);
     weakvalue = (strchr(svalue(mode), 'v') != NULL);
-    if (weakkey || weakvalue) {  /* is really weak? */
+    if (weakkey || weakvalue) { /* is really weak? */
       GCObject **weaklist;
-      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
-      h->marked |= cast(lu_byte, (weakkey << KEYWEAKBIT) |
-                                 (weakvalue << VALUEWEAKBIT));
-      weaklist = (weakkey && weakvalue) ? &st->wkv :
-                              (weakkey) ? &st->wk :
-                                          &st->wv;
-      h->gclist = *weaklist;  /* must be cleared after GC, ... */
+      h->marked &= ~(KEYWEAK | VALUEWEAK);      /* clear bits */
+      h->marked |= cast(lu_byte, (weakkey << KEYWEAKBIT) | (weakvalue << VALUEWEAKBIT));
+      weaklist = (weakkey && weakvalue) ? &st->wkv : (weakkey) ? &st->wk : &st->wv;
+      h->gclist = *weaklist;    /* must be cleared after GC, ... */
       *weaklist = valtogco(h);  /* ... so put in the appropriate list */
     }
   }
@@ -187,36 +195,39 @@ static void traversetable (GCState *st, Table *h) {
 }
 
 
-static void traverseproto (GCState *st, Proto *f) {
+static void
+traverseproto(GCState * st, Proto * f)
+{
   int i;
   stringmark(f->source);
-  for (i=0; i<f->sizek; i++) {  /* mark literal strings */
-    if (ttisstring(f->k+i))
-      stringmark(tsvalue(f->k+i));
+  for (i = 0; i < f->sizek; i++) {      /* mark literal strings */
+    if (ttisstring(f->k + i))
+      stringmark(tsvalue(f->k + i));
   }
-  for (i=0; i<f->sizeupvalues; i++)  /* mark upvalue names */
+  for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */
     stringmark(f->upvalues[i]);
-  for (i=0; i<f->sizep; i++)  /* mark nested protos */
+  for (i = 0; i < f->sizep; i++)        /* mark nested protos */
     markvalue(st, f->p[i]);
-  for (i=0; i<f->sizelocvars; i++)  /* mark local-variable names */
+  for (i = 0; i < f->sizelocvars; i++)  /* mark local-variable names */
     stringmark(f->locvars[i].varname);
   lua_assert(luaG_checkcode(f));
 }
 
 
 
-static void traverseclosure (GCState *st, Closure *cl) {
+static void
+traverseclosure(GCState * st, Closure * cl)
+{
   if (cl->c.isC) {
     int i;
-    for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
+    for (i = 0; i < cl->c.nupvalues; i++)       /* mark its upvalues */
       markobject(st, &cl->c.upvalue[i]);
-  }
-  else {
+  } else {
     int i;
     lua_assert(cl->l.nupvalues == cl->l.p->nups);
     markvalue(st, hvalue(&cl->l.g));
     markvalue(st, cl->l.p);
-    for (i=0; i<cl->l.nupvalues; i++) {  /* mark its upvalues */
+    for (i = 0; i < cl->l.nupvalues; i++) {     /* mark its upvalues */
       UpVal *u = cl->l.upvals[i];
       if (!u->marked) {
         markobject(st, &u->value);
@@ -227,19 +238,25 @@ static void traverseclosure (GCState *st, Closure *cl) {
 }
 
 
-static void checkstacksizes (lua_State *L, StkId max) {
-  int used = L->ci - L->base_ci;  /* number of `ci' in use */
-  if (4*used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
-    luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
-  else condhardstacktests(luaD_reallocCI(L, L->size_ci));
-  used = max - L->stack;  /* part of stack in use */
-  if (4*used < L->stacksize && 2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
-    luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
-  else condhardstacktests(luaD_reallocstack(L, L->stacksize));
+static void
+checkstacksizes(lua_State * L, StkId max)
+{
+  int used = L->ci - L->base_ci;       /* number of `ci' in use */
+  if (4 * used < L->size_ci && 2 * BASIC_CI_SIZE < L->size_ci)
+    luaD_reallocCI(L, L->size_ci / 2);  /* still big enough... */
+  else
+    condhardstacktests(luaD_reallocCI(L, L->size_ci));
+  used = max - L->stack;        /* part of stack in use */
+  if (4 * used < L->stacksize && 2 * (BASIC_STACK_SIZE + EXTRA_STACK) < L->stacksize)
+    luaD_reallocstack(L, L->stacksize / 2);     /* still big enough... */
+  else
+    condhardstacktests(luaD_reallocstack(L, L->stacksize));
 }
 
 
-static void traversestack (GCState *st, lua_State *L1) {
+static void
+traversestack(GCState * st, lua_State * L1)
+{
   StkId o, lim;
   CallInfo *ci;
   markobject(st, gt(L1));
@@ -258,42 +275,47 @@ static void traversestack (GCState *st, lua_State *L1) {
 }
 
 
-static void propagatemarks (GCState *st) {
-  while (st->tmark) {  /* traverse marked objects */
+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);
         break;
       }
-      default: lua_assert(0);
+    default:
+      lua_assert(0);
     }
   }
 }
 
 
-static int valismarked (const TObject *o) {
+static int
+valismarked(const TObject * o)
+{
   if (ttisstring(o))
-    stringmark(tsvalue(o));  /* strings are `values', so are never weak */
+    stringmark(tsvalue(o));     /* strings are `values', so are never weak */
   return !iscollectable(o) || testbit(o->value.gc->gch.marked, 0);
 }
 
@@ -301,15 +323,17 @@ static int valismarked (const TObject *o) {
 /*
 ** clear collected keys from weaktables
 */
-static void cleartablekeys (GCObject *l) {
+static void
+cleartablekeys(GCObject * l)
+{
   while (l) {
     Table *h = gcotoh(l);
     int i = sizenode(h);
     lua_assert(h->marked & KEYWEAK);
     while (i--) {
       Node *n = gnode(h, i);
-      if (!valismarked(gkey(n)))  /* key was collected? */
-        removekey(n);  /* remove entry from table */
+      if (!valismarked(gkey(n)))        /* key was collected? */
+        removekey(n);           /* remove entry from table */
     }
     l = h->gclist;
   }
@@ -319,60 +343,74 @@ static void cleartablekeys (GCObject *l) {
 /*
 ** clear collected values from weaktables
 */
-static void cleartablevalues (GCObject *l) {
+static void
+cleartablevalues(GCObject * l)
+{
   while (l) {
     Table *h = gcotoh(l);
     int i = h->sizearray;
     lua_assert(h->marked & VALUEWEAK);
     while (i--) {
       TObject *o = &h->array[i];
-      if (!valismarked(o))  /* value was collected? */
-        setnilvalue(o);  /* remove value */
+      if (!valismarked(o))      /* value was collected? */
+        setnilvalue(o);         /* remove value */
     }
     i = sizenode(h);
     while (i--) {
       Node *n = gnode(h, i);
-      if (!valismarked(gval(n)))  /* value was collected? */
-        removekey(n);  /* remove entry from table */
+      if (!valismarked(gval(n)))        /* value was collected? */
+        removekey(n);           /* remove entry from table */
     }
     l = h->gclist;
   }
 }
 
 
-static void freeobj (lua_State *L, GCObject *o) {
+static void
+freeobj(lua_State * L, GCObject * o)
+{
   switch (o->gch.tt) {
-    case LUA_TPROTO: luaF_freeproto(L, gcotop(o)); break;
-    case LUA_TFUNCTION: luaF_freeclosure(L, gcotocl(o)); break;
-    case LUA_TUPVAL: luaM_freelem(L, gcotouv(o)); break;
-    case LUA_TTABLE: luaH_free(L, gcotoh(o)); break;
-    case LUA_TTHREAD: {
+  case LUA_TPROTO:
+    luaF_freeproto(L, gcotop(o));
+    break;
+  case LUA_TFUNCTION:
+    luaF_freeclosure(L, gcotocl(o));
+    break;
+  case LUA_TUPVAL:
+    luaM_freelem(L, gcotouv(o));
+    break;
+  case LUA_TTABLE:
+    luaH_free(L, gcotoh(o));
+    break;
+  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;
     }
-    default: lua_assert(0);
+  default:
+    lua_assert(0);
   }
 }
 
 
-static int sweeplist (lua_State *L, GCObject **p, int limit) {
+static int
+sweeplist(lua_State * L, GCObject ** p, int limit)
+{
   GCObject *curr;
-  int count = 0;  /* number of collected items */
+  int count = 0;                       /* number of collected items */
   while ((curr = *p) != NULL) {
     if (curr->gch.marked > limit) {
       unmark(curr);
       p = &curr->gch.next;
-    }
-    else {
+    } else {
       count++;
       *p = curr->gch.next;
       freeobj(L, curr);
@@ -382,61 +420,71 @@ static int sweeplist (lua_State *L, GCObject **p, int limit) {
 }
 
 
-static void sweepstrings (lua_State *L, int all) {
+static void
+sweepstrings(lua_State * L, int all)
+{
   int i;
-  for (i=0; i<G(L)->strt.size; i++) {  /* for each list */
+  for (i = 0; i < G(L)->strt.size; i++) {       /* for each list */
     G(L)->strt.nuse -= sweeplist(L, &G(L)->strt.hash[i], all);
   }
 }
 
 
-static void checkSizes (lua_State *L, size_t deadmem) {
+static void
+checkSizes(lua_State * L, size_t deadmem)
+{
   /* check size of string hash */
-  if (G(L)->strt.nuse < cast(ls_nstr, G(L)->strt.size/4) &&
-      G(L)->strt.size > MINSTRTABSIZE*2)
-    luaS_resize(L, G(L)->strt.size/2);  /* table is too big */
+  if (G(L)->strt.nuse < cast(ls_nstr, G(L)->strt.size / 4) && G(L)->strt.size > MINSTRTABSIZE * 2)
+    luaS_resize(L, G(L)->strt.size / 2);        /* table is too big */
   /* check size of buffer */
-  if (luaZ_sizebuffer(&G(L)->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
+  if (luaZ_sizebuffer(&G(L)->buff) > LUA_MINBUFFER * 2) {       /* buffer too big? */
     size_t newsize = luaZ_sizebuffer(&G(L)->buff) / 2;
     luaZ_resizebuffer(L, &G(L)->buff, newsize);
   }
-  G(L)->GCthreshold = 2*G(L)->nblocks - deadmem;  /* new threshold */
+  G(L)->GCthreshold = 2 * G(L)->nblocks - deadmem;      /* new threshold */
 }
 
 
-static void do1gcTM (lua_State *L, Udata *udata) {
+static void
+do1gcTM(lua_State * L, Udata * udata)
+{
   const TObject *tm = fasttm(L, udata->uv.metatable, TM_GC);
   if (tm != NULL) {
     setobj2s(L->top, tm);
-    setuvalue(L->top+1, udata);
+    setuvalue(L->top + 1, udata);
     L->top += 2;
     luaD_call(L, L->top - 2, 0);
   }
 }
 
 
-void luaC_callGCTM (lua_State *L) {
+void
+luaC_callGCTM(lua_State * L)
+{
   lu_byte oldah = L->allowhook;
-  L->allowhook = 0;  /* stop debug hooks during GC tag methods */
-  L->top++;  /* reserve space to keep udata while runs its gc method */
+  L->allowhook = 0;             /* stop debug hooks during GC tag methods */
+  L->top++;                     /* reserve space to keep udata while runs its gc method */
   while (G(L)->tmudata != NULL) {
     GCObject *o = G(L)->tmudata;
     Udata *udata = gcotou(o);
-    G(L)->tmudata = udata->uv.next;  /* remove udata from `tmudata' */
-    udata->uv.next = G(L)->rootudata;  /* return it to `root' list */
+    G(L)->tmudata = udata->uv.next;     /* remove udata from `tmudata' */
+    udata->uv.next = G(L)->rootudata;   /* return it to `root' list */
     G(L)->rootudata = o;
-    setuvalue(L->top - 1, udata);  /* keep a reference to it */
+    setuvalue(L->top - 1, udata);       /* keep a reference to it */
     unmark(o);
     markfinalized(udata);
     do1gcTM(L, udata);
   }
   L->top--;
-  L->allowhook = oldah;  /* restore hooks */
+  L->allowhook = oldah;         /* restore hooks */
 }
 
 
-void luaC_sweep (lua_State *L, int all) {
-  if (all) all = 256;  /* larger than any mark */
+void
+luaC_sweep(lua_State * L, int all)
+{
+  if (all)
+    all = 256;                  /* larger than any mark */
   sweeplist(L, &G(L)->rootudata, all);
   sweepstrings(L, all);
   sweeplist(L, &G(L)->rootgc, all);
@@ -444,17 +492,21 @@ void luaC_sweep (lua_State *L, int all) {
 
 
 /* mark root set */
-static void markroot (GCState *st, lua_State *L) {
+static void
+markroot(GCState * st, lua_State * L)
+{
   global_State *g = st->g;
   markobject(st, defaultmeta(L));
   markobject(st, registry(L));
   traversestack(st, g->mainthread);
-  if (L != g->mainthread)  /* another thread is running? */
-    markvalue(st, L);  /* cannot collect it */
+  if (L != g->mainthread)       /* another thread is running? */
+    markvalue(st, L);           /* cannot collect it */
 }
 
 
-static size_t mark (lua_State *L) {
+static size_t
+mark(lua_State * L)
+{
   size_t deadmem;
   GCState st;
   GCObject *wkv;
@@ -462,15 +514,15 @@ static size_t mark (lua_State *L) {
   st.tmark = NULL;
   st.wkv = st.wk = st.wv = NULL;
   markroot(&st, L);
-  propagatemarks(&st);  /* mark all reachable objects */
+  propagatemarks(&st);          /* mark all reachable objects */
   cleartablevalues(st.wkv);
   cleartablevalues(st.wv);
-  wkv = st.wkv;  /* keys must be cleared after preserving udata */
+  wkv = st.wkv;                 /* keys must be cleared after preserving udata */
   st.wkv = NULL;
   st.wv = NULL;
-  deadmem = luaC_separateudata(L);  /* separate userdata to be preserved */
-  marktmu(&st);  /* mark `preserved' userdata */
-  propagatemarks(&st);  /* remark, to propagate `preserveness' */
+  deadmem = luaC_separateudata(L);      /* separate userdata to be preserved */
+  marktmu(&st);                 /* mark `preserved' userdata */
+  propagatemarks(&st);          /* remark, to propagate `preserveness' */
   cleartablekeys(wkv);
   /* `propagatemarks' may resuscitate some weak tables; clear them too */
   cleartablekeys(st.wk);
@@ -481,7 +533,9 @@ static size_t mark (lua_State *L) {
 }
 
 
-void luaC_collectgarbage (lua_State *L) {
+void
+luaC_collectgarbage(lua_State * L)
+{
   size_t deadmem = mark(L);
   luaC_sweep(L, 0);
   checkSizes(L, deadmem);
@@ -489,10 +543,11 @@ void luaC_collectgarbage (lua_State *L) {
 }
 
 
-void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
+void
+luaC_link(lua_State * L, GCObject * o, lu_byte tt)
+{
   o->gch.next = G(L)->rootgc;
   G(L)->rootgc = o;
   o->gch.marked = 0;
   o->gch.tt = tt;
 }
-
index 3f4d748..d3ad6a5 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lgc.h,v 1.19a 2003/02/28 19:45:15 roberto Exp $
 ** Garbage Collector
        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);
+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
index 7e42467..013b06a 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: liolib.c,v 2.39a 2003/03/19 21:16:12 roberto Exp $
 ** Standard I/O (and system) library
@@ -50,7 +51,7 @@
 
 
 
-static int io_exit (lua_State *L) __attribute__((noreturn));
+static int io_exit(lua_State * L) __attribute__ ((noreturn));
 
 /*
 ** {======================================================
@@ -70,12 +71,13 @@ static int io_exit (lua_State *L) __attribute__((noreturn));
 #define IO_OUTPUT              "_output"
 
 
-static int pushresult (lua_State *L, int i, const char *filename) {
+static int
+pushresult(lua_State * L, int i, const char *filename)
+{
   if (i) {
     lua_pushboolean(L, 1);
     return 1;
-  }
-  else {
+  } else {
     lua_pushnil(L);
     if (filename)
       lua_pushfstring(L, "%s: %s", filename, strerror(errno));
@@ -87,16 +89,22 @@ static int pushresult (lua_State *L, int i, const char *filename) {
 }
 
 
-static FILE **topfile (lua_State *L, int findex) {
-  FILE **f = (FILE **)luaL_checkudata(L, findex, FILEHANDLE);
-  if (f == NULL) luaL_argerror(L, findex, "bad file");
+static FILE **
+topfile(lua_State * L, int findex)
+{
+  FILE **f = (FILE **) luaL_checkudata(L, findex, FILEHANDLE);
+  if (f == NULL)
+    luaL_argerror(L, findex, "bad file");
   return f;
 }
 
 
-static int io_type (lua_State *L) {
-  FILE **f = (FILE **)luaL_checkudata(L, 1, FILEHANDLE);
-  if (f == NULL) lua_pushnil(L);
+static int
+io_type(lua_State * L)
+{
+  FILE **f = (FILE **) luaL_checkudata(L, 1, FILEHANDLE);
+  if (f == NULL)
+    lua_pushnil(L);
   else if (*f == NULL)
     lua_pushliteral(L, "closed file");
   else
@@ -105,7 +113,9 @@ static int io_type (lua_State *L) {
 }
 
 
-static FILE *tofile (lua_State *L, int findex) {
+static FILE *
+tofile(lua_State * L, int findex)
+{
   FILE **f = topfile(L, findex);
   if (*f == NULL)
     luaL_error(L, "attempt to use a closed file");
@@ -119,9 +129,11 @@ static FILE *tofile (lua_State *L, int findex) {
 ** before opening the actual file; so, if there is a memory error, the
 ** file is not left opened.
 */
-static FILE **newfile (lua_State *L) {
-  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
-  *pf = NULL;  /* file handle is currently `closed' */
+static FILE **
+newfile(lua_State * L)
+{
+  FILE **pf = (FILE **) lua_newuserdata(L, sizeof(FILE *));
+  *pf = NULL;                   /* file handle is currently `closed' */
   luaL_getmetatable(L, FILEHANDLE);
   lua_setmetatable(L, -2);
   return pf;
@@ -132,33 +144,38 @@ static FILE **newfile (lua_State *L) {
 ** assumes that top of the stack is the `io' library, and next is
 ** the `io' metatable
 */
-static void registerfile (lua_State *L, FILE *f, const char *name,
-                                                 const char *impname) {
+static void
+registerfile(lua_State * L, FILE * f, const char *name, const char *impname)
+{
   lua_pushstring(L, name);
   *newfile(L) = f;
   if (impname) {
     lua_pushstring(L, impname);
     lua_pushvalue(L, -2);
-    lua_settable(L, -6);  /* metatable[impname] = file */
+    lua_settable(L, -6);        /* metatable[impname] = file */
   }
-  lua_settable(L, -3);  /* io[name] = file */
+  lua_settable(L, -3);          /* io[name] = file */
 }
 
 
-static int aux_close (lua_State *L) {
+static int
+aux_close(lua_State * L)
+{
   FILE *f = tofile(L, 1);
   if (f == stdin || f == stdout || f == stderr)
-    return 0;  /* file cannot be closed */
+    return 0;                   /* file cannot be closed */
   else {
     int ok = (pclose(f) != -1) || (fclose(f) == 0);
     if (ok)
-      *(FILE **)lua_touserdata(L, 1) = NULL;  /* mark file as closed */
+      *(FILE **) lua_touserdata(L, 1) = NULL;   /* mark file as closed */
     return ok;
   }
 }
 
 
-static int io_close (lua_State *L) {
+static int
+io_close(lua_State * L)
+{
   if (lua_isnone(L, 1) && lua_type(L, lua_upvalueindex(1)) == LUA_TTABLE) {
     lua_pushstring(L, IO_OUTPUT);
     lua_rawget(L, lua_upvalueindex(1));
@@ -167,15 +184,19 @@ static int io_close (lua_State *L) {
 }
 
 
-static int io_gc (lua_State *L) {
+static int
+io_gc(lua_State * L)
+{
   FILE **f = topfile(L, 1);
-  if (*f != NULL)  /* ignore closed files */
+  if (*f != NULL)               /* ignore closed files */
     aux_close(L);
   return 0;
 }
 
 
-static int io_tostring (lua_State *L) {
+static int
+io_tostring(lua_State * L)
+{
   char buff[128];
   FILE **f = topfile(L, 1);
   if (*f == NULL)
@@ -187,7 +208,9 @@ static int io_tostring (lua_State *L) {
 }
 
 
-static int io_open (lua_State *L) {
+static int
+io_open(lua_State * L)
+{
   const char *filename = luaL_checkstring(L, 1);
   const char *mode = luaL_optstring(L, 2, "r");
   FILE **pf = newfile(L);
@@ -196,7 +219,9 @@ static int io_open (lua_State *L) {
 }
 
 
-static int io_popen (lua_State *L) {
+static int
+io_popen(lua_State * L)
+{
 #if !USE_POPEN
   luaL_error(L, "`popen' not supported");
   return 0;
@@ -210,21 +235,27 @@ static int io_popen (lua_State *L) {
 }
 
 
-static int io_tmpfile (lua_State *L) {
+static int
+io_tmpfile(lua_State * L)
+{
   FILE **pf = newfile(L);
   *pf = tmpfile();
   return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
 }
 
 
-static FILE *getiofile (lua_State *L, const char *name) {
+static FILE *
+getiofile(lua_State * L, const char *name)
+{
   lua_pushstring(L, name);
   lua_rawget(L, lua_upvalueindex(1));
   return tofile(L, -1);
 }
 
 
-static int g_iofile (lua_State *L, const char *name, const char *mode) {
+static int
+g_iofile(lua_State * L, const char *name, const char *mode)
+{
   if (!lua_isnoneornil(L, 1)) {
     const char *filename = lua_tostring(L, 1);
     lua_pushstring(L, name);
@@ -235,9 +266,8 @@ static int g_iofile (lua_State *L, const char *name, const char *mode) {
         lua_pushfstring(L, "%s: %s", filename, strerror(errno));
         luaL_argerror(L, 1, lua_tostring(L, -1));
       }
-    }
-    else {
-      tofile(L, 1);  /* check that it's a valid file handle */
+    } else {
+      tofile(L, 1);             /* check that it's a valid file handle */
       lua_pushvalue(L, 1);
     }
     lua_rawset(L, lua_upvalueindex(1));
@@ -249,46 +279,55 @@ static int g_iofile (lua_State *L, const char *name, const char *mode) {
 }
 
 
-static int io_input (lua_State *L) {
+static int
+io_input(lua_State * L)
+{
   return g_iofile(L, IO_INPUT, "r");
 }
 
 
-static int io_output (lua_State *L) {
+static int
+io_output(lua_State * L)
+{
   return g_iofile(L, IO_OUTPUT, "w");
 }
 
 
-static int io_readline (lua_State *L);
+static int io_readline(lua_State * L);
 
 
-static void aux_lines (lua_State *L, int idx, int close) {
+static void
+aux_lines(lua_State * L, int idx, int close)
+{
   lua_pushliteral(L, FILEHANDLE);
   lua_rawget(L, LUA_REGISTRYINDEX);
   lua_pushvalue(L, idx);
-  lua_pushboolean(L, close);  /* close/not close file when finished */
+  lua_pushboolean(L, close);    /* close/not close file when finished */
   lua_pushcclosure(L, io_readline, 3);
 }
 
 
-static int f_lines (lua_State *L) {
-  tofile(L, 1);  /* check that it's a valid file handle */
+static int
+f_lines(lua_State * L)
+{
+  tofile(L, 1);                 /* check that it's a valid file handle */
   aux_lines(L, 1, 0);
   return 1;
 }
 
 
-static int io_lines (lua_State *L) {
+static int
+io_lines(lua_State * L)
+{
   if (lua_isnoneornil(L, 1)) {  /* no arguments? */
     lua_pushstring(L, IO_INPUT);
-    lua_rawget(L, lua_upvalueindex(1));  /* will iterate over default input */
+    lua_rawget(L, lua_upvalueindex(1)); /* will iterate over default input */
     return f_lines(L);
-  }
-  else {
+  } else {
     const char *filename = luaL_checkstring(L, 1);
     FILE **pf = newfile(L);
     *pf = fopen(filename, "r");
-    luaL_argcheck(L, *pf, 1,  strerror(errno));
+    luaL_argcheck(L, *pf, 1, strerror(errno));
     aux_lines(L, lua_gettop(L), 1);
     return 1;
   }
@@ -302,17 +341,21 @@ static int io_lines (lua_State *L) {
 */
 
 
-static int read_number (lua_State *L, FILE *f) {
+static int
+read_number(lua_State * L, FILE * f)
+{
   lua_Number d;
   if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
     lua_pushnumber(L, d);
     return 1;
-  }
-  else return 0;  /* read fails */
+  } else
+    return 0;                   /* read fails */
 }
 
 
-static int test_eof (lua_State *L, FILE *f) {
+static int
+test_eof(lua_State * L, FILE * f)
+{
   int c = getc(f);
   ungetc(c, f);
   lua_pushlstring(L, NULL, 0);
@@ -320,112 +363,124 @@ static int test_eof (lua_State *L, FILE *f) {
 }
 
 
-static int read_line (lua_State *L, FILE *f) {
+static int
+read_line(lua_State * L, FILE * f)
+{
   luaL_Buffer b;
   luaL_buffinit(L, &b);
   for (;;) {
     size_t l;
     char *p = luaL_prepbuffer(&b);
-    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
-      luaL_pushresult(&b);  /* close buffer */
-      return (lua_strlen(L, -1) > 0);  /* check whether read something */
+    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */
+      luaL_pushresult(&b);      /* close buffer */
+      return (lua_strlen(L, -1) > 0);   /* check whether read something */
     }
     l = strlen(p);
-    if (p[l-1] != '\n')
+    if (p[l - 1] != '\n')
       luaL_addsize(&b, l);
     else {
       luaL_addsize(&b, l - 1);  /* do not include `eol' */
-      luaL_pushresult(&b);  /* close buffer */
-      return 1;  /* read at least an `eol' */
+      luaL_pushresult(&b);      /* close buffer */
+      return 1;                 /* read at least an `eol' */
     }
   }
 }
 
 
-static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t rlen;  /* how much to read */
-  size_t nr;  /* number of chars actually read */
+static int
+read_chars(lua_State * L, FILE * f, size_t n)
+{
+  size_t rlen;                         /* how much to read */
+  size_t nr;                           /* number of chars actually read */
   luaL_Buffer b;
   luaL_buffinit(L, &b);
-  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
+  rlen = LUAL_BUFFERSIZE;       /* try to read that much each time */
   do {
     char *p = luaL_prepbuffer(&b);
-    if (rlen > n) rlen = n;  /* cannot read more than asked */
+    if (rlen > n)
+      rlen = n;                 /* cannot read more than asked */
     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 */
-  luaL_pushresult(&b);  /* close buffer */
+    n -= nr;                    /* still have to read `n' chars */
+  } 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) {
+static int
+g_read(lua_State * L, FILE * f, int first)
+{
   int nargs = lua_gettop(L) - 1;
   int success;
   int n;
-  if (nargs == 0) {  /* no arguments? */
+  if (nargs == 0) {             /* no arguments? */
     success = read_line(L, f);
-    n = first+1;  /* to return 1 result */
-  }
-  else {  /* ensure stack space for all results and for auxlib's buffer */
-    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
+    n = first + 1;              /* to return 1 result */
+  } else {                      /* ensure stack space for all results and for auxlib's buffer */
+    luaL_checkstack(L, nargs + LUA_MINSTACK, "too many arguments");
     success = 1;
     for (n = first; nargs-- && success; n++) {
       if (lua_type(L, n) == LUA_TNUMBER) {
         size_t l = lua_tonumber(L, n);
         success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
-      }
-      else {
+      } else {
         const char *p = lua_tostring(L, n);
         luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
         switch (p[1]) {
-          case 'n':  /* number */
-            success = read_number(L, f);
-            break;
-          case 'l':  /* line */
-            success = read_line(L, f);
-            break;
-          case 'a':  /* file */
-            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
-            success = 1; /* always success */
-            break;
-          case 'w':  /* word */
-            return luaL_error(L, "obsolete option `*w' to `read'");
-          default:
-            return luaL_argerror(L, n, "invalid format");
+        case 'n':              /* number */
+          success = read_number(L, f);
+          break;
+        case 'l':              /* line */
+          success = read_line(L, f);
+          break;
+        case 'a':              /* file */
+          read_chars(L, f, ~((size_t) 0));      /* read MAX_SIZE_T chars */
+          success = 1;          /* always success */
+          break;
+        case 'w':              /* word */
+          return luaL_error(L, "obsolete option `*w' to `read'");
+        default:
+          return luaL_argerror(L, n, "invalid format");
         }
       }
     }
   }
   if (!success) {
-    lua_pop(L, 1);  /* remove last result */
-    lua_pushnil(L);  /* push nil instead */
+    lua_pop(L, 1);              /* remove last result */
+    lua_pushnil(L);             /* push nil instead */
   }
   return n - first;
 }
 
 
-static int io_read (lua_State *L) {
+static int
+io_read(lua_State * L)
+{
   return g_read(L, getiofile(L, IO_INPUT), 1);
 }
 
 
-static int f_read (lua_State *L) {
+static int
+f_read(lua_State * L)
+{
   return g_read(L, tofile(L, 1), 2);
 }
 
 
-static int io_readline (lua_State *L) {
-  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(2));
-  if (f == NULL)  /* file is already closed? */
+static int
+io_readline(lua_State * L)
+{
+  FILE *f = *(FILE **) lua_touserdata(L, lua_upvalueindex(2));
+  if (f == NULL)                /* file is already closed? */
     luaL_error(L, "file is already closed");
-  if (read_line(L, f)) return 1;
-  else {  /* EOF */
-    if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
+  if (read_line(L, f))
+    return 1;
+  else {                        /* EOF */
+    if (lua_toboolean(L, lua_upvalueindex(3))) {        /* generator created file? */
       lua_settop(L, 0);
       lua_pushvalue(L, lua_upvalueindex(2));
-      aux_close(L);  /* close it */
+      aux_close(L);             /* close it */
     }
     return 0;
   }
@@ -434,16 +489,16 @@ static int io_readline (lua_State *L) {
 /* }====================================================== */
 
 
-static int g_write (lua_State *L, FILE *f, int arg) {
+static int
+g_write(lua_State * L, FILE * f, int arg)
+{
   int nargs = lua_gettop(L) - 1;
   int status = 1;
   for (; nargs--; arg++) {
     if (lua_type(L, arg) == LUA_TNUMBER) {
       /* optimization: could be done exactly as for strings */
-      status = status &&
-          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
-    }
-    else {
+      status = status && fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
+    } else {
       size_t l;
       const char *s = luaL_checklstring(L, arg, &l);
       status = status && (fwrite(s, sizeof(char), l, f) == l);
@@ -453,26 +508,32 @@ static int g_write (lua_State *L, FILE *f, int arg) {
 }
 
 
-static int io_write (lua_State *L) {
+static int
+io_write(lua_State * L)
+{
   return g_write(L, getiofile(L, IO_OUTPUT), 1);
 }
 
 
-static int f_write (lua_State *L) {
+static int
+f_write(lua_State * L)
+{
   return g_write(L, tofile(L, 1), 2);
 }
 
 
-static int f_seek (lua_State *L) {
-  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
-  static const char *const modenames[] = {"set", "cur", "end", NULL};
+static int
+f_seek(lua_State * L)
+{
+  static const int mode[] = { SEEK_SET, SEEK_CUR, SEEK_END };
+  static const char *const modenames[] = { "set", "cur", "end", NULL };
   FILE *f = tofile(L, 1);
   int op = luaL_findstring(luaL_optstring(L, 2, "cur"), modenames);
   long offset = luaL_optlong(L, 3, 0);
   luaL_argcheck(L, op != -1, 2, "invalid mode");
   op = fseek(f, offset, mode[op]);
   if (op)
-    return pushresult(L, 0, NULL);  /* error */
+    return pushresult(L, 0, NULL);      /* error */
   else {
     lua_pushnumber(L, ftell(f));
     return 1;
@@ -480,12 +541,16 @@ static int f_seek (lua_State *L) {
 }
 
 
-static int io_flush (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) {
+static int
+f_flush(lua_State * L)
+{
   return pushresult(L, fflush(tofile(L, 1)) == 0, NULL);
 }
 
@@ -519,12 +584,14 @@ static const luaL_reg flib[] = {
 };
 
 
-static void createmeta (lua_State *L) {
-  luaL_newmetatable(L, FILEHANDLE);  /* create new metatable for file handles */
+static void
+createmeta(lua_State * L)
+{
+  luaL_newmetatable(L, FILEHANDLE);     /* create new metatable for file handles */
   /* file methods */
   lua_pushliteral(L, "__index");
-  lua_pushvalue(L, -2);  /* push metatable */
-  lua_rawset(L, -3);  /* metatable.__index = metatable */
+  lua_pushvalue(L, -2);         /* push metatable */
+  lua_rawset(L, -3);            /* metatable.__index = metatable */
   luaL_openlib(L, NULL, flib, 0);
 }
 
@@ -537,19 +604,25 @@ static void createmeta (lua_State *L) {
 ** =======================================================
 */
 
-static int io_execute (lua_State *L) {
+static int
+io_execute(lua_State * L)
+{
   lua_pushnumber(L, system(luaL_checkstring(L, 1)));
   return 1;
 }
 
 
-static int io_remove (lua_State *L) {
+static int
+io_remove(lua_State * L)
+{
   const char *filename = luaL_checkstring(L, 1);
   return pushresult(L, remove(filename) == 0, filename);
 }
 
 
-static int io_rename (lua_State *L) {
+static int
+io_rename(lua_State * L)
+{
   const char *fromname = luaL_checkstring(L, 1);
   const char *toname = luaL_checkstring(L, 2);
   return pushresult(L, rename(fromname, toname) == 0, fromname);
@@ -557,12 +630,14 @@ static int io_rename (lua_State *L) {
 
 
 #if !USE_TMPNAME
-static int io_tmpname (lua_State *L) __attribute__((noreturn));
+static int io_tmpname(lua_State * L) __attribute__ ((noreturn));
 #else
-static int io_tmpname (lua_State *L);
+static int io_tmpname(lua_State * L);
 #endif
 
-static int io_tmpname (lua_State *L) {
+static int
+io_tmpname(lua_State * L)
+{
 #if !USE_TMPNAME
   luaL_error(L, "`tmpname' not supported");
 #else
@@ -575,14 +650,18 @@ static int io_tmpname (lua_State *L) {
 }
 
 
-static int io_getenv (lua_State *L) {
-  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
+static int
+io_getenv(lua_State * L)
+{
+  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));    /* if NULL push nil */
   return 1;
 }
 
 
-static int io_clock (lua_State *L) {
-  lua_pushnumber(L, clock()/(lua_Number)CLOCKS_PER_SEC);
+static int
+io_clock(lua_State * L)
+{
+  lua_pushnumber(L, clock() / (lua_Number) CLOCKS_PER_SEC);
   return 1;
 }
 
@@ -595,19 +674,25 @@ static int io_clock (lua_State *L) {
 ** =======================================================
 */
 
-static void setfield (lua_State *L, const char *key, int value) {
+static void
+setfield(lua_State * L, const char *key, int value)
+{
   lua_pushstring(L, key);
   lua_pushnumber(L, value);
   lua_rawset(L, -3);
 }
 
-static void setboolfield (lua_State *L, const char *key, int value) {
+static void
+setboolfield(lua_State * L, const char *key, int value)
+{
   lua_pushstring(L, key);
   lua_pushboolean(L, value);
   lua_rawset(L, -3);
 }
 
-static int getboolfield (lua_State *L, const char *key) {
+static int
+getboolfield(lua_State * L, const char *key)
+{
   int res;
   lua_pushstring(L, key);
   lua_gettable(L, -2);
@@ -617,7 +702,9 @@ static int getboolfield (lua_State *L, const char *key) {
 }
 
 
-static int getfield (lua_State *L, const char *key, int d) {
+static int
+getfield(lua_State * L, const char *key, int d)
+{
   int res;
   lua_pushstring(L, key);
   lua_gettable(L, -2);
@@ -633,19 +720,20 @@ static int getfield (lua_State *L, const char *key, int d) {
 }
 
 
-static int io_date (lua_State *L) {
+static int
+io_date(lua_State * L)
+{
   const char *s = luaL_optstring(L, 1, "%c");
   time_t t = luaL_optnumber(L, 2, -1);
   struct tm *stm;
-  if (t == (time_t)(-1))  /* no time given? */
-    t = time(NULL);  /* use current time */
-  if (*s == '!') {  /* UTC? */
+  if (t == (time_t) (-1))       /* no time given? */
+    t = time(NULL);             /* use current time */
+  if (*s == '!') {              /* UTC? */
     stm = gmtime(&t);
-    s++;  /* skip `!' */
-  }
-  else
+    s++;                        /* skip `!' */
+  } else
     stm = localtime(&t);
-  if (stm == NULL)  /* invalid date? */
+  if (stm == NULL)              /* invalid date? */
     lua_pushnil(L);
   else if (strcmp(s, "*t") == 0) {
     lua_newtable(L);
@@ -653,13 +741,12 @@ static int io_date (lua_State *L) {
     setfield(L, "min", stm->tm_min);
     setfield(L, "hour", stm->tm_hour);
     setfield(L, "day", stm->tm_mday);
-    setfield(L, "month", stm->tm_mon+1);
-    setfield(L, "year", stm->tm_year+1900);
-    setfield(L, "wday", stm->tm_wday+1);
-    setfield(L, "yday", stm->tm_yday+1);
+    setfield(L, "month", stm->tm_mon + 1);
+    setfield(L, "year", stm->tm_year + 1900);
+    setfield(L, "wday", stm->tm_wday + 1);
+    setfield(L, "yday", stm->tm_yday + 1);
     setboolfield(L, "isdst", stm->tm_isdst);
-  }
-  else {
+  } else {
     char b[256];
     if (strftime(b, sizeof(b), s, stm))
       lua_pushstring(L, b);
@@ -670,14 +757,16 @@ static int io_date (lua_State *L) {
 }
 
 
-static int io_time (lua_State *L) {
-  if (lua_isnoneornil(L, 1))  /* called without args? */
-    lua_pushnumber(L, time(NULL));  /* return current time */
+static int
+io_time(lua_State * L)
+{
+  if (lua_isnoneornil(L, 1))    /* called without args? */
+    lua_pushnumber(L, time(NULL));      /* return current time */
   else {
     time_t t;
     struct tm ts;
     luaL_checktype(L, 1, LUA_TTABLE);
-    lua_settop(L, 1);  /* make sure table is at the top */
+    lua_settop(L, 1);           /* make sure table is at the top */
     ts.tm_sec = getfield(L, "sec", 0);
     ts.tm_min = getfield(L, "min", 0);
     ts.tm_hour = getfield(L, "hour", 12);
@@ -686,7 +775,7 @@ static int io_time (lua_State *L) {
     ts.tm_year = getfield(L, "year", -2) - 1900;
     ts.tm_isdst = getboolfield(L, "isdst");
     t = mktime(&ts);
-    if (t == (time_t)(-1))
+    if (t == (time_t) (-1))
       lua_pushnil(L);
     else
       lua_pushnumber(L, t);
@@ -695,20 +784,25 @@ static int io_time (lua_State *L) {
 }
 
 
-static int io_difftime (lua_State *L) {
-  lua_pushnumber(L, difftime(luaL_checknumber(L, 1),
-                             luaL_optnumber(L, 2, 0)));
+static int
+io_difftime(lua_State * L)
+{
+  lua_pushnumber(L, difftime(luaL_checknumber(L, 1), luaL_optnumber(L, 2, 0)));
   return 1;
 }
 
 /* }====================================================== */
 
 
-static int io_setloc (lua_State *L) {
-  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
-                      LC_NUMERIC, LC_TIME};
-  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
-     "numeric", "time", NULL};
+static int
+io_setloc(lua_State * L)
+{
+  static const int cat[] = { LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
+    LC_NUMERIC, LC_TIME
+  };
+  static const char *const catnames[] = { "all", "collate", "ctype", "monetary",
+    "numeric", "time", NULL
+  };
   const char *l = lua_tostring(L, 1);
   int op = luaL_findstring(luaL_optstring(L, 2, "all"), catnames);
   luaL_argcheck(L, l || lua_isnoneornil(L, 1), 1, "string expected");
@@ -718,22 +812,24 @@ static int io_setloc (lua_State *L) {
 }
 
 
-static int io_exit (lua_State *L) {
+static int
+io_exit(lua_State * L)
+{
   exit(luaL_optint(L, 1, EXIT_SUCCESS));
 }
 
 static const luaL_reg syslib[] = {
-  {"clock",     io_clock},
-  {"date",      io_date},
-  {"difftime",  io_difftime},
-  {"execute",   io_execute},
-  {"exit",      io_exit},
-  {"getenv",    io_getenv},
-  {"remove",    io_remove},
-  {"rename",    io_rename},
+  {"clock", io_clock},
+  {"date", io_date},
+  {"difftime", io_difftime},
+  {"execute", io_execute},
+  {"exit", io_exit},
+  {"getenv", io_getenv},
+  {"remove", io_remove},
+  {"rename", io_rename},
   {"setlocale", io_setloc},
-  {"time",      io_time},
-  {"tmpname",   io_tmpname},
+  {"time", io_time},
+  {"tmpname", io_tmpname},
   {NULL, NULL}
 };
 
@@ -741,7 +837,9 @@ static const luaL_reg syslib[] = {
 
 
 
-LUALIB_API int luaopen_io (lua_State *L) {
+LUALIB_API int
+luaopen_io(lua_State * L)
+{
   luaL_openlib(L, LUA_OSLIBNAME, syslib, 0);
   createmeta(L);
   lua_pushvalue(L, -1);
@@ -752,4 +850,3 @@ LUALIB_API int luaopen_io (lua_State *L) {
   registerfile(L, stderr, "stderr", NULL);
   return 1;
 }
-
index 4e0e5c2..768ea98 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: llex.c,v 1.119 2003/03/24 12:39:34 roberto Exp $
 ** Lexical Analyzer
 
 #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));
+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",
-    "end", "false", "for", "function", "if",
-    "in", "local", "nil", "not", "or", "repeat",
-    "return", "then", "true", "until", "while", "*name",
-    "..", "...", "==", ">=", "<=", "~=",
-    "*number", "*string", "<eof>"
+static const char *const token2string[] = {
+  "and", "break", "do", "else", "elseif",
+  "end", "false", "for", "function", "if",
+  "in", "local", "nil", "not", "or", "repeat",
+  "return", "then", "true", "until", "while", "*name",
+  "..", "...", "==", ">=", "<=", "~=",
+  "*number", "*string", "<eof>"
 };
 
 
-void luaX_init (lua_State *L) {
+void
+luaX_init(lua_State * L)
+{
   int i;
-  for (i=0; i<NUM_RESERVED; i++) {
+  for (i = 0; i < NUM_RESERVED; i++) {
     TString *ts = luaS_new(L, token2string[i]);
-    luaS_fix(ts);  /* reserved words are never collected */
-    lua_assert(strlen(token2string[i])+1 <= TOKEN_LEN);
-    ts->tsv.reserved = cast(lu_byte, i+1);  /* reserved word */
+    luaS_fix(ts);               /* reserved words are never collected */
+    lua_assert(strlen(token2string[i]) + 1 <= TOKEN_LEN);
+    ts->tsv.reserved = cast(lu_byte, i + 1);    /* reserved word */
   }
 }
 
@@ -53,7 +56,9 @@ void luaX_init (lua_State *L) {
 #define MAXSRC          80
 
 
-void luaX_checklimit (LexState *ls, int val, int limit, const char *msg) {
+void
+luaX_checklimit(LexState * ls, int val, int limit, const char *msg)
+{
   if (val > limit) {
     msg = luaO_pushfstring(ls->L, "too many %s (limit=%d)", msg, limit);
     luaX_syntaxerror(ls, msg);
@@ -61,49 +66,58 @@ void luaX_checklimit (LexState *ls, int val, int limit, const char *msg) {
 }
 
 
-void luaX_errorline (LexState *ls, const char *s, const char *token, int line) {
+void
+luaX_errorline(LexState * ls, const char *s, const char *token, int line)
+{
   lua_State *L = ls->L;
   char buff[MAXSRC];
   luaO_chunkid(buff, getstr(ls->source), MAXSRC);
-  luaO_pushfstring(L, "%s:%d: %s near `%s'", buff, line, s, token); 
+  luaO_pushfstring(L, "%s:%d: %s near `%s'", buff, line, s, token);
   luaD_throw(L, LUA_ERRSYNTAX);
 }
 
 
-static void luaX_error (LexState *ls, const char *s, const char *token) {
+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) {
+void
+luaX_syntaxerror(LexState * ls, const char *msg)
+{
   const char *lasttoken;
   switch (ls->t.token) {
-    case TK_NAME:
-      lasttoken = getstr(ls->t.seminfo.ts);
-      break;
-    case TK_STRING:
-    case TK_NUMBER:
-      lasttoken = luaZ_buffer(ls->buff);
-      break;
-    default:
-      lasttoken = luaX_token2str(ls, ls->t.token);
-      break;
+  case TK_NAME:
+    lasttoken = getstr(ls->t.seminfo.ts);
+    break;
+  case TK_STRING:
+  case TK_NUMBER:
+    lasttoken = luaZ_buffer(ls->buff);
+    break;
+  default:
+    lasttoken = luaX_token2str(ls, ls->t.token);
+    break;
   }
   luaX_error(ls, msg, lasttoken);
 }
 
 
-const char *luaX_token2str (LexState *ls, int token) {
+const char *
+luaX_token2str(LexState * ls, int token)
+{
   if (token < FIRST_RESERVED) {
     lua_assert(token == (unsigned char)token);
     return luaO_pushfstring(ls->L, "%c", token);
-  }
-  else
-    return token2string[token-FIRST_RESERVED];
+  } else
+    return token2string[token - FIRST_RESERVED];
 }
 
 
-static void luaX_lexerror (LexState *ls, const char *s, int token) {
+static void
+luaX_lexerror(LexState * ls, const char *s, int token)
+{
   if (token == TK_EOS)
     luaX_error(ls, s, luaX_token2str(ls, token));
   else
@@ -111,24 +125,28 @@ static void luaX_lexerror (LexState *ls, const char *s, int token) {
 }
 
 
-static void inclinenumber (LexState *LS) {
-  next(LS);  /* skip `\n' */
+static void
+inclinenumber(LexState * LS)
+{
+  next(LS);                     /* skip `\n' */
   ++LS->linenumber;
   luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk");
 }
 
 
-void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) {
+void
+luaX_setinput(lua_State * L, LexState * LS, ZIO * z, TString * source)
+{
   LS->L = L;
-  LS->lookahead.token = TK_EOS;  /* no look-ahead token */
+  LS->lookahead.token = TK_EOS; /* no look-ahead token */
   LS->z = z;
   LS->fs = NULL;
   LS->linenumber = 1;
   LS->lastline = 1;
   LS->source = source;
-  next(LS);  /* read first char */
+  next(LS);                     /* read first char */
   if (LS->current == '#') {
-    do {  /* skip first line */
+    do {                        /* skip first line */
       next(LS);
     } while (LS->current != '\n' && LS->current != EOZ);
   }
@@ -160,7 +178,9 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) {
 #define save_and_next(LS, l)  (save(LS, LS->current, l), next(LS))
 
 
-static size_t readname (LexState *LS) {
+static size_t
+readname(LexState * LS)
+{
   size_t l = 0;
   checkbuffer(LS, l);
   do {
@@ -168,15 +188,18 @@ static size_t readname (LexState *LS) {
     save_and_next(LS, l);
   } while (isalnum(LS->current) || LS->current == '_');
   save(LS, '\0', l);
-  return l-1;
+  return l - 1;
 }
 
 
 /* LUA_NUMBER */
-static void read_numeral (LexState *LS, int comma, SemInfo *seminfo) {
+static void
+read_numeral(LexState * LS, int comma, SemInfo * seminfo)
+{
   size_t l = 0;
   checkbuffer(LS, l);
-  if (comma) save(LS, '.', l);
+  if (comma)
+    save(LS, '.', l);
   while (isdigit(LS->current)) {
     checkbuffer(LS, l);
     save_and_next(LS, l);
@@ -186,9 +209,7 @@ static void read_numeral (LexState *LS, int comma, SemInfo *seminfo) {
     if (LS->current == '.') {
       save_and_next(LS, l);
       save(LS, '\0', l);
-      luaX_lexerror(LS,
-                 "ambiguous syntax (decimal point x string concatenation)",
-                 TK_NUMBER);
+      luaX_lexerror(LS, "ambiguous syntax (decimal point x string concatenation)", TK_NUMBER);
     }
   }
   while (isdigit(LS->current)) {
@@ -196,9 +217,9 @@ static void read_numeral (LexState *LS, int comma, SemInfo *seminfo) {
     save_and_next(LS, l);
   }
   if (LS->current == 'e' || LS->current == 'E') {
-    save_and_next(LS, l);  /* read `E' */
+    save_and_next(LS, l);       /* read `E' */
     if (LS->current == '+' || LS->current == '-')
-      save_and_next(LS, l);  /* optional exponent sign */
+      save_and_next(LS, l);     /* optional exponent sign */
     while (isdigit(LS->current)) {
       checkbuffer(LS, l);
       save_and_next(LS, l);
@@ -210,206 +231,253 @@ static void read_numeral (LexState *LS, int comma, SemInfo *seminfo) {
 }
 
 
-static void read_long_string (LexState *LS, SemInfo *seminfo) {
+static void
+read_long_string(LexState * LS, SemInfo * seminfo)
+{
   int cont = 0;
   size_t l = 0;
   checkbuffer(LS, l);
-  save(LS, '[', l);  /* save first `[' */
-  save_and_next(LS, l);  /* pass the second `[' */
-  if (LS->current == '\n')  /* string starts with a newline? */
-    inclinenumber(LS);  /* skip it */
+  save(LS, '[', l);             /* save first `[' */
+  save_and_next(LS, l);         /* pass the second `[' */
+  if (LS->current == '\n')      /* string starts with a newline? */
+    inclinenumber(LS);          /* skip it */
   for (;;) {
     checkbuffer(LS, l);
     switch (LS->current) {
-      case EOZ:
-        save(LS, '\0', l);
-        luaX_lexerror(LS, (seminfo) ? "unfinished long string" :
-                                   "unfinished long comment", TK_EOS);
-        break;  /* to avoid warnings */
-      case '[':
-        save_and_next(LS, l);
-        if (LS->current == '[') {
-          cont++;
-          save_and_next(LS, l);
-        }
-        continue;
-      case ']':
+    case EOZ:
+      save(LS, '\0', l);
+      luaX_lexerror(LS, (seminfo) ? "unfinished long string" : "unfinished long comment", TK_EOS);
+      break;                    /* to avoid warnings */
+    case '[':
+      save_and_next(LS, l);
+      if (LS->current == '[') {
+        cont++;
         save_and_next(LS, l);
-        if (LS->current == ']') {
-          if (cont == 0) goto endloop;
-          cont--;
-          save_and_next(LS, l);
-        }
-        continue;
-      case '\n':
-        save(LS, '\n', l);
-        inclinenumber(LS);
-        if (!seminfo) l = 0;  /* reset buffer to avoid wasting space */
-        continue;
-      default:
+      }
+      continue;
+    case ']':
+      save_and_next(LS, l);
+      if (LS->current == ']') {
+        if (cont == 0)
+          goto endloop;
+        cont--;
         save_and_next(LS, l);
+      }
+      continue;
+    case '\n':
+      save(LS, '\n', l);
+      inclinenumber(LS);
+      if (!seminfo)
+        l = 0;                  /* reset buffer to avoid wasting space */
+      continue;
+    default:
+      save_and_next(LS, l);
     }
-  } endloop:
-  save_and_next(LS, l);  /* skip the second `]' */
+  }
+endloop:
+  save_and_next(LS, l);         /* skip the second `]' */
   save(LS, '\0', l);
   if (seminfo)
     seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 2, l - 5);
 }
 
 
-static void read_string (LexState *LS, int del, SemInfo *seminfo) {
+static void
+read_string(LexState * LS, int del, SemInfo * seminfo)
+{
   size_t l = 0;
   checkbuffer(LS, l);
   save_and_next(LS, l);
   while (LS->current != del) {
     checkbuffer(LS, l);
     switch (LS->current) {
-      case EOZ:
-        save(LS, '\0', l);
-        luaX_lexerror(LS, "unfinished string", TK_EOS);
-        break;  /* to avoid warnings */
+    case EOZ:
+      save(LS, '\0', l);
+      luaX_lexerror(LS, "unfinished string", TK_EOS);
+      break;                    /* to avoid warnings */
+    case '\n':
+      save(LS, '\0', l);
+      luaX_lexerror(LS, "unfinished string", TK_STRING);
+      break;                    /* to avoid warnings */
+    case '\\':
+      next(LS);                 /* do not save the `\' */
+      switch (LS->current) {
+      case 'a':
+        save(LS, '\a', l);
+        next(LS);
+        break;
+      case 'b':
+        save(LS, '\b', l);
+        next(LS);
+        break;
+      case 'f':
+        save(LS, '\f', l);
+        next(LS);
+        break;
+      case 'n':
+        save(LS, '\n', l);
+        next(LS);
+        break;
+      case 'r':
+        save(LS, '\r', l);
+        next(LS);
+        break;
+      case 't':
+        save(LS, '\t', l);
+        next(LS);
+        break;
+      case 'v':
+        save(LS, '\v', l);
+        next(LS);
+        break;
       case '\n':
-        save(LS, '\0', l);
-        luaX_lexerror(LS, "unfinished string", TK_STRING);
-        break;  /* to avoid warnings */
-      case '\\':
-        next(LS);  /* do not save the `\' */
-        switch (LS->current) {
-          case 'a': save(LS, '\a', l); next(LS); break;
-          case 'b': save(LS, '\b', l); next(LS); break;
-          case 'f': save(LS, '\f', l); next(LS); break;
-          case 'n': save(LS, '\n', l); next(LS); break;
-          case 'r': save(LS, '\r', l); next(LS); break;
-          case 't': save(LS, '\t', l); next(LS); break;
-          case 'v': save(LS, '\v', l); next(LS); break;
-          case '\n': save(LS, '\n', l); inclinenumber(LS); break;
-          case EOZ: break;  /* will raise an error next loop */
-          default: {
-            if (!isdigit(LS->current))
-              save_and_next(LS, l);  /* handles \\, \", \', and \? */
-            else {  /* \xxx */
-              int c = 0;
-              int i = 0;
-              do {
-                c = 10*c + (LS->current-'0');
-                next(LS);
-              } while (++i<3 && isdigit(LS->current));
-              if (c > UCHAR_MAX) {
-                save(LS, '\0', l);
-                luaX_lexerror(LS, "escape sequence too large", TK_STRING);
-              }
-              save(LS, c, l);
+        save(LS, '\n', l);
+        inclinenumber(LS);
+        break;
+      case EOZ:
+        break;                  /* will raise an error next loop */
+      default:{
+          if (!isdigit(LS->current))
+            save_and_next(LS, l);       /* handles \\, \", \', and \? */
+          else {                /* \xxx */
+            int c = 0;
+            int i = 0;
+            do {
+              c = 10 * c + (LS->current - '0');
+              next(LS);
+            } while (++i < 3 && isdigit(LS->current));
+            if (c > UCHAR_MAX) {
+              save(LS, '\0', l);
+              luaX_lexerror(LS, "escape sequence too large", TK_STRING);
             }
+            save(LS, c, l);
           }
         }
-        break;
-      default:
-        save_and_next(LS, l);
+      }
+      break;
+    default:
+      save_and_next(LS, l);
     }
   }
-  save_and_next(LS, l);  /* skip delimiter */
+  save_and_next(LS, l);         /* skip delimiter */
   save(LS, '\0', l);
   seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 1, l - 3);
 }
 
 
-int luaX_lex (LexState *LS, SemInfo *seminfo) {
+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 '-';
+        if (LS->current != '-')
+          return '-';
         /* else is a comment */
         next(LS);
         if (LS->current == '[' && (next(LS), LS->current == '['))
-          read_long_string(LS, NULL);  /* long comment */
-        else  /* short comment */
+          read_long_string(LS, NULL);   /* long comment */
+        else                    /* short comment */
           while (LS->current != '\n' && LS->current != EOZ)
             next(LS);
         continue;
       }
-      case '[': {
+    case '[':{
         next(LS);
-        if (LS->current != '[') return '[';
+        if (LS->current != '[')
+          return '[';
         else {
           read_long_string(LS, seminfo);
           return TK_STRING;
         }
       }
-      case '=': {
+    case '=':{
         next(LS);
-        if (LS->current != '=') return '=';
-        else { next(LS); return TK_EQ; }
+        if (LS->current != '=')
+          return '=';
+        else {
+          next(LS);
+          return TK_EQ;
+        }
       }
-      case '<': {
+    case '<':{
         next(LS);
-        if (LS->current != '=') return '<';
-        else { next(LS); return TK_LE; }
+        if (LS->current != '=')
+          return '<';
+        else {
+          next(LS);
+          return TK_LE;
+        }
       }
-      case '>': {
+    case '>':{
         next(LS);
-        if (LS->current != '=') return '>';
-        else { next(LS); return TK_GE; }
+        if (LS->current != '=')
+          return '>';
+        else {
+          next(LS);
+          return TK_GE;
+        }
       }
-      case '~': {
+    case '~':{
         next(LS);
-        if (LS->current != '=') return '~';
-        else { next(LS); return TK_NE; }
+        if (LS->current != '=')
+          return '~';
+        else {
+          next(LS);
+          return TK_NE;
+        }
       }
-      case '"':
-      case '\'': {
+    case '"':
+    case '\'':{
         read_string(LS, LS->current, seminfo);
         return TK_STRING;
       }
-      case '.': {
+    case '.':{
         next(LS);
         if (LS->current == '.') {
           next(LS);
           if (LS->current == '.') {
             next(LS);
-            return TK_DOTS;   /* ... */
-          }
-          else return TK_CONCAT;   /* .. */
-        }
-        else if (!isdigit(LS->current)) return '.';
+            return TK_DOTS;     /* ... */
+          } else
+            return TK_CONCAT;   /* .. */
+        } else if (!isdigit(LS->current))
+          return '.';
         else {
           read_numeral(LS, 1, seminfo);
           return TK_NUMBER;
         }
       }
-      case EOZ: {
+    case EOZ:{
         return TK_EOS;
       }
-      default: {
+    default:{
         if (isspace(LS->current)) {
           next(LS);
           continue;
-        }
-        else if (isdigit(LS->current)) {
+        } else if (isdigit(LS->current)) {
           read_numeral(LS, 0, seminfo);
           return TK_NUMBER;
-        }
-        else if (isalpha(LS->current) || LS->current == '_') {
+        } else if (isalpha(LS->current) || LS->current == '_') {
           /* identifier or reserved word */
           size_t l = readname(LS);
           TString *ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff), l);
-          if (ts->tsv.reserved > 0)  /* reserved word? */
+          if (ts->tsv.reserved > 0)     /* reserved word? */
             return ts->tsv.reserved - 1 + FIRST_RESERVED;
           seminfo->ts = ts;
           return TK_NAME;
-        }
-        else {
+        } else {
           int c = LS->current;
           if (iscntrl(c))
-            luaX_error(LS, "invalid control char",
-                           luaO_pushfstring(LS->L, "char(%d)", c));
+            luaX_error(LS, "invalid control char", luaO_pushfstring(LS->L, "char(%d)", c));
           next(LS);
-          return c;  /* single-char tokens (+ - / ...) */
+          return c;             /* single-char tokens (+ - / ...) */
         }
       }
     }
index 00afa91..fa22f01 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: llex.h,v 1.47 2003/02/28 17:19:47 roberto Exp $
 ** Lexical Analyzer
@@ -39,7 +40,7 @@ enum RESERVED {
 typedef union {
   lua_Number r;
   TString *ts;
-} SemInfo;  /* semantics information */
+} SemInfo;                             /* semantics information */
 
 
 typedef struct Token {
@@ -49,27 +50,27 @@ typedef struct Token {
 
 
 typedef struct LexState {
-  int current;  /* current character (charint) */
-  int linenumber;  /* input line counter */
-  int lastline;  /* line of last token `consumed' */
-  Token t;  /* current token */
-  Token lookahead;  /* look ahead token */
-  struct FuncState *fs;  /* `FuncState' is private to the parser */
+  int current;                         /* current character (charint) */
+  int linenumber;                      /* input line counter */
+  int lastline;                        /* line of last token `consumed' */
+  Token t;                             /* current token */
+  Token lookahead;                     /* look ahead token */
+  struct FuncState *fs;                /* `FuncState' is private to the parser */
   struct lua_State *L;
-  ZIO *z;  /* input stream */
-  Mbuffer *buff;  /* buffer for tokens */
-  TString *source;  /* current source name */
-  int nestlevel;  /* level of nested non-terminals */
+  ZIO *z;                              /* input stream */
+  Mbuffer *buff;                       /* buffer for tokens */
+  TString *source;                     /* current source name */
+  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);
-void luaX_checklimit (LexState *ls, int val, int limit, const char *msg);
-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);
+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);
+void luaX_checklimit(LexState * ls, int val, int limit, const char *msg);
+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
index d3f2ea0..5b38c61 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: llimits.h,v 1.52 2003/02/20 19:33:23 roberto Exp $
 ** Limits, basic types, and some other `installation-dependent' definitions
 
 
 #include "lua.h"
-#include "defs.h" /* ARM_NOWARN_ALIGN */
+#include "defs.h"               /* ARM_NOWARN_ALIGN */
 
 
 /*
 ** try to find number of bits in an integer
 */
 #ifndef BITS_INT
+
 /* avoid overflows in comparison */
 #if INT_MAX-20 < 32760
 #define        BITS_INT        16
 #else
 #if INT_MAX > 2147483640L
+
 /* machine has at least 32 bits */
 #define BITS_INT       32
 #else
 
 /* an unsigned integer to hold hash values */
 typedef unsigned long int lu_hash;
+
 /* its signed equivalent */
 typedef int ls_hash;
 
 /* an unsigned integer big enough to count the total memory used by Lua; */
+
 /* it should be at least as large as size_t */
 typedef unsigned long lu_mem;
 
@@ -63,7 +68,7 @@ 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) */
+#define MAX_INT (INT_MAX-2)     /* maximum value of an int (-2 for safety) */
 
 /*
 ** conversion of pointer to integer
@@ -76,7 +81,11 @@ typedef unsigned char lu_byte;
 
 /* type to ensure maximum alignment */
 #ifndef LUSER_ALIGNMENT_T
-typedef union { double u; void *s; long l; } L_Umaxalign;
+typedef union {
+  double u;
+  void *s;
+  long l;
+} L_Umaxalign;
 #else
 typedef LUSER_ALIGNMENT_T L_Umaxalign;
 #endif
@@ -91,7 +100,7 @@ typedef LUA_UACNUMBER l_uacNumber;
 
 
 #ifndef lua_assert
-#define lua_assert(c)          /* empty */
+#define lua_assert(c)           /* empty */
 #endif
 
 
@@ -101,7 +110,7 @@ typedef LUA_UACNUMBER l_uacNumber;
 
 
 #ifndef UNUSED
-#define UNUSED(x)      ((void)(x))     /* to avoid warnings */
+#define UNUSED(x)      ((void)(x))     /* to avoid warnings */
 #endif
 
 
@@ -149,7 +158,7 @@ typedef unsigned long Instruction;
 
 /* maximum number of variables declared in a function */
 #ifndef MAXVARS
-#define MAXVARS 200           /* arbitrary limit (<MAXSTACK) */
+#define MAXVARS 200             /* arbitrary limit (<MAXSTACK) */
 #endif
 
 
index e210473..ac3a869 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lmathlib.c,v 1.56 2003/03/11 12:30:37 roberto Exp $
 ** Standard mathematical library
 #endif
 
 
-static int math_abs (lua_State *L) {
+static int
+math_abs(lua_State * L)
+{
   lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_sin (lua_State *L) {
+static int
+math_sin(lua_State * L)
+{
   lua_pushnumber(L, sin(TORAD(luaL_checknumber(L, 1))));
   return 1;
 }
 
-static int math_cos (lua_State *L) {
+static int
+math_cos(lua_State * L)
+{
   lua_pushnumber(L, cos(TORAD(luaL_checknumber(L, 1))));
   return 1;
 }
 
-static int math_tan (lua_State *L) {
+static int
+math_tan(lua_State * L)
+{
   lua_pushnumber(L, tan(TORAD(luaL_checknumber(L, 1))));
   return 1;
 }
 
-static int math_asin (lua_State *L) {
+static int
+math_asin(lua_State * L)
+{
   lua_pushnumber(L, FROMRAD(asin(luaL_checknumber(L, 1))));
   return 1;
 }
 
-static int math_acos (lua_State *L) {
+static int
+math_acos(lua_State * L)
+{
   lua_pushnumber(L, FROMRAD(acos(luaL_checknumber(L, 1))));
   return 1;
 }
 
-static int math_atan (lua_State *L) {
+static int
+math_atan(lua_State * L)
+{
   lua_pushnumber(L, FROMRAD(atan(luaL_checknumber(L, 1))));
   return 1;
 }
 
-static int math_atan2 (lua_State *L) {
+static int
+math_atan2(lua_State * L)
+{
   lua_pushnumber(L, FROMRAD(atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2))));
   return 1;
 }
 
-static int math_ceil (lua_State *L) {
+static int
+math_ceil(lua_State * L)
+{
   lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_floor (lua_State *L) {
+static int
+math_floor(lua_State * L)
+{
   lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_mod (lua_State *L) {
+static int
+math_mod(lua_State * L)
+{
   lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
   return 1;
 }
 
-static int math_sqrt (lua_State *L) {
+static int
+math_sqrt(lua_State * L)
+{
   lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_pow (lua_State *L) {
+static int
+math_pow(lua_State * L)
+{
   lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
   return 1;
 }
 
-static int math_log (lua_State *L) {
+static int
+math_log(lua_State * L)
+{
   lua_pushnumber(L, log(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_log10 (lua_State *L) {
+static int
+math_log10(lua_State * L)
+{
   lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_exp (lua_State *L) {
+static int
+math_exp(lua_State * L)
+{
   lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
   return 1;
 }
 
-static int math_deg (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
+static int
+math_deg(lua_State * L)
+{
+  lua_pushnumber(L, luaL_checknumber(L, 1) / RADIANS_PER_DEGREE);
   return 1;
 }
 
-static int math_rad (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
+static int
+math_rad(lua_State * L)
+{
+  lua_pushnumber(L, luaL_checknumber(L, 1) * RADIANS_PER_DEGREE);
   return 1;
 }
 
-static int math_frexp (lua_State *L) {
+static int
+math_frexp(lua_State * L)
+{
   int e;
   lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
   lua_pushnumber(L, e);
   return 2;
 }
 
-static int math_ldexp (lua_State *L) {
+static int
+math_ldexp(lua_State * L)
+{
   lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
   return 1;
 }
 
 
 
-static int math_min (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
+static int
+math_min(lua_State * L)
+{
+  int n = lua_gettop(L);               /* number of arguments */
   lua_Number dmin = luaL_checknumber(L, 1);
   int i;
-  for (i=2; i<=n; i++) {
+  for (i = 2; i <= n; i++) {
     lua_Number d = luaL_checknumber(L, i);
     if (d < dmin)
       dmin = d;
@@ -153,11 +196,13 @@ static int math_min (lua_State *L) {
 }
 
 
-static int math_max (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
+static int
+math_max(lua_State * L)
+{
+  int n = lua_gettop(L);               /* number of arguments */
   lua_Number dmax = luaL_checknumber(L, 1);
   int i;
-  for (i=2; i<=n; i++) {
+  for (i = 2; i <= n; i++) {
     lua_Number d = luaL_checknumber(L, i);
     if (d > dmax)
       dmax = d;
@@ -167,64 +212,69 @@ static int math_max (lua_State *L) {
 }
 
 
-static int math_random (lua_State *L) {
+static int
+math_random(lua_State * L)
+{
   /* the `%' avoids the (rare) case of r==1, and is needed also because on
      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 */
-      lua_pushnumber(L, r);  /* Number between 0 and 1 */
+  lua_Number r = (lua_Number) (rand() % RAND_MAX) / (lua_Number) RAND_MAX;
+  switch (lua_gettop(L)) {      /* check number of 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' */
+      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");
-      lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
+      luaL_argcheck(L, l <= u, 2, "interval is empty");
+      lua_pushnumber(L, floor(r * (u - l + 1)) + l);    /* int between `l' and `u' */
       break;
     }
-    default: return luaL_error(L, "wrong number of arguments");
+  default:
+    return luaL_error(L, "wrong number of arguments");
   }
   return 1;
 }
 
 
-static int math_randomseed (lua_State *L) {
+static int
+math_randomseed(lua_State * L)
+{
   srand(luaL_checkint(L, 1));
   return 0;
 }
 
 
 static const luaL_reg mathlib[] = {
-  {"abs",   math_abs},
-  {"sin",   math_sin},
-  {"cos",   math_cos},
-  {"tan",   math_tan},
-  {"asin",  math_asin},
-  {"acos",  math_acos},
-  {"atan",  math_atan},
+  {"abs", math_abs},
+  {"sin", math_sin},
+  {"cos", math_cos},
+  {"tan", math_tan},
+  {"asin", math_asin},
+  {"acos", math_acos},
+  {"atan", math_atan},
   {"atan2", math_atan2},
-  {"ceil",  math_ceil},
+  {"ceil", math_ceil},
   {"floor", math_floor},
-  {"mod",   math_mod},
+  {"mod", math_mod},
   {"frexp", math_frexp},
   {"ldexp", math_ldexp},
-  {"sqrt",  math_sqrt},
-  {"min",   math_min},
-  {"max",   math_max},
-  {"log",   math_log},
+  {"sqrt", math_sqrt},
+  {"min", math_min},
+  {"max", math_max},
+  {"log", math_log},
   {"log10", math_log10},
-  {"exp",   math_exp},
-  {"deg",   math_deg},
-  {"pow",   math_pow},
-  {"rad",   math_rad},
-  {"random",     math_random},
+  {"exp", math_exp},
+  {"deg", math_deg},
+  {"pow", math_pow},
+  {"rad", math_rad},
+  {"random", math_random},
   {"randomseed", math_randomseed},
   {NULL, NULL}
 };
@@ -233,7 +283,9 @@ static const luaL_reg mathlib[] = {
 /*
 ** Open math library
 */
-LUALIB_API int luaopen_math (lua_State *L) {
+LUALIB_API int
+luaopen_math(lua_State * L)
+{
   luaL_openlib(L, LUA_MATHLIBNAME, mathlib, 0);
   lua_pushliteral(L, "pi");
   lua_pushnumber(L, PI);
@@ -243,4 +295,3 @@ LUALIB_API int luaopen_math (lua_State *L) {
   lua_settable(L, LUA_GLOBALSINDEX);
   return 1;
 }
-
index f977770..60b41f9 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lmem.c,v 1.61 2002/12/04 17:38:31 roberto Exp $
 ** Interface to Memory Manager
 #define MINSIZEARRAY   4
 
 
-void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
-                    int limit, const char *errormsg) {
+void *
+luaM_growaux(lua_State * L, void *block, int *size, int size_elems, int limit, const char *errormsg)
+{
   void *newblock;
-  int newsize = (*size)*2;
+  int newsize = (*size) * 2;
   if (newsize < MINSIZEARRAY)
-    newsize = MINSIZEARRAY;  /* minimum size */
-  else if (*size >= limit/2) {  /* cannot double it? */
-    if (*size < limit - MINSIZEARRAY)  /* try something smaller... */
-      newsize = limit;  /* still have at least MINSIZEARRAY free places */
-    else luaG_runerror(L, errormsg);
+    newsize = MINSIZEARRAY;     /* minimum size */
+  else if (*size >= limit / 2) {        /* cannot double it? */
+    if (*size < limit - MINSIZEARRAY)   /* try something smaller... */
+      newsize = limit;          /* still have at least MINSIZEARRAY free places */
+    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));
-  *size = newsize;  /* update only when everything else is OK */
+                          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;
 }
 
@@ -62,23 +64,25 @@ void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
 /*
 ** generic allocation routine.
 */
-void *luaM_realloc (lua_State *L, void *block, lu_mem oldsize, lu_mem size) {
+void *
+luaM_realloc(lua_State * L, void *block, lu_mem oldsize, lu_mem size)
+{
   lua_assert((oldsize == 0) == (block == NULL));
   if (size == 0) {
     if (block != NULL) {
       l_free(block, oldsize);
       block = NULL;
-    }
-    else return NULL;  /* avoid `nblocks' computations when oldsize==size==0 */
-  }
-  else if (size >= MAX_SIZET)
+    } else
+      return NULL;              /* avoid `nblocks' computations when oldsize==size==0 */
+  } else if (size >= MAX_SIZET)
     luaG_runerror(L, "memory allocation error: block too big");
   else {
     block = l_realloc(block, oldsize, size);
     if (block == NULL) {
       if (L)
         luaD_throw(L, LUA_ERRMEM);
-      else return NULL;  /* error before creating state! */
+      else
+        return NULL;            /* error before creating state! */
     }
   }
   if (L) {
@@ -88,4 +92,3 @@ void *luaM_realloc (lua_State *L, void *block, lu_mem oldsize, lu_mem size) {
   }
   return block;
 }
-
index 1bb4fde..581fce9 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lmem.h,v 1.26 2002/05/01 20:40:42 roberto Exp $
 ** Interface to Memory Manager
 #define MEMERRMSG      "not enough memory"
 
 
-void *luaM_realloc (lua_State *L, void *oldblock, lu_mem oldsize, lu_mem size);
+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);
+void *luaM_growaux(lua_State * L, void *block, int *size, int size_elem, int limit, const char *errormsg);
 
 #define luaM_free(L, b, s)     luaM_realloc(L, (b), (s), 0)
 #define luaM_freelem(L, b)     luaM_realloc(L, (b), sizeof(*(b)), 0)
@@ -41,4 +41,3 @@ void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem,
 
 
 #endif
-
index 99a876b..6a68e83 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: loadlib.c,v 1.4 2003/04/07 20:11:53 roberto Exp $
 ** Dynamic library loader for Lua
@@ -36,6 +37,7 @@
 
 #ifdef USE_DLOPEN
 #define LOADLIB
+
 /*
 * This is an implementation of loadlib based on the dlfcn interface.
 * The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
 
 #include <dlfcn.h>
 
-static int loadlib(lua_State *L)
+static int
+loadlib(lua_State * L)
 {
- const char *path=luaL_checkstring(L,1);
- const char *init=luaL_checkstring(L,2);
- void *lib=dlopen(path,RTLD_NOW);
- if (lib!=NULL)
- {
-  lua_CFunction f=(lua_CFunction) dlsym(lib,init);
-  if (f!=NULL)
-  {
-   lua_pushlightuserdata(L,lib);
-   lua_pushcclosure(L,f,1);
-   return 1;
+  const char *path = luaL_checkstring(L, 1);
+  const char *init = luaL_checkstring(L, 2);
+  void *lib = dlopen(path, RTLD_NOW);
+  if (lib != NULL) {
+    lua_CFunction f = (lua_CFunction) dlsym(lib, init);
+    if (f != NULL) {
+      lua_pushlightuserdata(L, lib);
+      lua_pushcclosure(L, f, 1);
+      return 1;
+    }
   }
- }
- /* else return appropriate error messages */
lua_pushnil(L);
lua_pushstring(L,dlerror());
- lua_pushstring(L,(lib!=NULL) ? "init" : "open");
if (lib!=NULL) dlclose(lib);
- return 3;
+  /* else return appropriate error messages */
+  lua_pushnil(L);
 lua_pushstring(L, dlerror());
 lua_pushstring(L, (lib != NULL) ? "init" : "open");
+  if (lib != NULL)
   dlclose(lib);
 return 3;
 }
 
 #endif
@@ -86,43 +88,44 @@ static int loadlib(lua_State *L)
 
 #if USE_DLL
 #define LOADLIB
+
 /*
 * This is an implementation of loadlib for Windows using native functions.
 */
 
 #include <windows.h>
 
-static void pusherror(lua_State *L)
+static void
+pusherror(lua_State * L)
 {
- int error=GetLastError();
- char buffer[128];
- if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
-       0, error, 0, buffer, sizeof(buffer), 0))
-  lua_pushstring(L,buffer);
- else
-  lua_pushfstring(L,"system error %d\n",error);
+  int error = GetLastError();
+  char buffer[128];
+  if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, 0, error, 0, buffer, sizeof(buffer), 0))
+    lua_pushstring(L, buffer);
+  else
+    lua_pushfstring(L, "system error %d\n", error);
 }
 
-static int loadlib(lua_State *L)
+static int
+loadlib(lua_State * L)
 {
- const char *path=luaL_checkstring(L,1);
- const char *init=luaL_checkstring(L,2);
- HINSTANCE lib=LoadLibrary(path);
- if (lib!=NULL)
- {
-  lua_CFunction f=(lua_CFunction) GetProcAddress(lib,init);
-  if (f!=NULL)
-  {
-   lua_pushlightuserdata(L,lib);
-   lua_pushcclosure(L,f,1);
-   return 1;
+  const char *path = luaL_checkstring(L, 1);
+  const char *init = luaL_checkstring(L, 2);
+  HINSTANCE lib = LoadLibrary(path);
+  if (lib != NULL) {
+    lua_CFunction f = (lua_CFunction) GetProcAddress(lib, init);
+    if (f != NULL) {
+      lua_pushlightuserdata(L, lib);
+      lua_pushcclosure(L, f, 1);
+      return 1;
+    }
   }
- }
lua_pushnil(L);
pusherror(L);
- lua_pushstring(L,(lib!=NULL) ? "init" : "open");
if (lib!=NULL) FreeLibrary(lib);
- return 3;
+  lua_pushnil(L);
 pusherror(L);
 lua_pushstring(L, (lib != NULL) ? "init" : "open");
+  if (lib != NULL)
   FreeLibrary(lib);
 return 3;
 }
 
 #endif
@@ -130,6 +133,7 @@ static int loadlib(lua_State *L)
 
 
 #ifndef LOADLIB
+
 /* Fallback for other systems */
 
 /*
@@ -163,19 +167,21 @@ static int loadlib(lua_State *L)
 #define LOADLIB        "`loadlib' not supported"
 #endif
 
-static int loadlib(lua_State *L)
+static int
+loadlib(lua_State * L)
 {
- lua_pushnil(L);
lua_pushliteral(L,LOADLIB);
lua_pushliteral(L,"absent");
- return 3;
 lua_pushnil(L);
 lua_pushliteral(L, LOADLIB);
 lua_pushliteral(L, "absent");
 return 3;
 }
 #endif
 
-LUALIB_API int luaopen_loadlib (lua_State *L)
+LUALIB_API int
+luaopen_loadlib(lua_State * L)
 {
lua_register(L,"loadlib",loadlib);
- return 0;
 lua_register(L, "loadlib", loadlib);
 return 0;
 }
 
 /*
@@ -188,7 +194,7 @@ LUALIB_API int luaopen_loadlib (lua_State *L)
 * There is also an emulation package available.
 * http://www.faqs.org/faqs/aix-faq/part4/section-21.html
 *
-* HPUX 
+* HPUX
 * HPUX 11 has dlfcn. For HPUX 10 use shl_*.
 * http://www.geda.seul.org/mailinglist/geda-dev37/msg00094.html
 * http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html
index 44506de..9875965 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lobject.c,v 1.97 2003/04/03 13:35:34 roberto Exp $
 ** Some generic functions over Lua objects
 #endif
 
 
-const TObject luaO_nilobject = {LUA_TNIL, {NULL}};
+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)
 */
-int luaO_int2fb (unsigned int x) {
-  int m = 0;  /* mantissa */
-  while (x >= (1<<3)) {
-    x = (x+1) >> 1;
+int
+luaO_int2fb(unsigned int x)
+{
+  int m = 0;                           /* mantissa */
+  while (x >= (1 << 3)) {
+    x = (x + 1) >> 1;
     m++;
   }
   return (m << 3) | cast(int, x);
@@ -73,9 +76,13 @@ int luaO_log2 (unsigned int x) {
 /* *INDENT-ON* */
 
 
-int luaO_rawequalObj (const TObject *t1, const TObject *t2) {
-  if (ttype(t1) != ttype(t2)) return 0;
-  else switch (ttype(t1)) {
+int
+luaO_rawequalObj(const TObject * t1, const TObject * t2)
+{
+  if (ttype(t1) != ttype(t2))
+    return 0;
+  else
+    switch (ttype(t1)) {
     case LUA_TNIL:
       return 1;
     case LUA_TNUMBER:
@@ -87,72 +94,85 @@ int luaO_rawequalObj (const TObject *t1, const TObject *t2) {
     default:
       lua_assert(iscollectable(t1));
       return gcvalue(t1) == gcvalue(t2);
-  }
+    }
 }
 
 
-int luaO_str2d (const char *s, lua_Number *result) {
+int
+luaO_str2d(const char *s, lua_Number * result)
+{
   char *endptr;
   lua_Number res = lua_str2number(s, &endptr);
-  if (endptr == s) return 0;  /* no conversion */
-  while (isspace((unsigned char)(*endptr))) endptr++;
-  if (*endptr != '\0') return 0;  /* invalid trailing characters? */
+  if (endptr == s)
+    return 0;                   /* no conversion */
+  while (isspace((unsigned char)(*endptr)))
+    endptr++;
+  if (*endptr != '\0')
+    return 0;                   /* invalid trailing characters? */
   *result = res;
   return 1;
 }
 
 
 
-static void pushstr (lua_State *L, const char *str) {
+static void
+pushstr(lua_State * L, const char *str)
+{
   setsvalue2s(L->top, luaS_new(L, 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) {
+const char *
+luaO_pushvfstring(lua_State * L, const char *fmt, va_list argp)
+{
   int n = 1;
   pushstr(L, "");
   for (;;) {
     const char *e = strchr(fmt, '%');
-    if (e == NULL) break;
-    setsvalue2s(L->top, luaS_newlstr(L, fmt, e-fmt));
+    if (e == NULL)
+      break;
+    setsvalue2s(L->top, luaS_newlstr(L, fmt, e - fmt));
     incr_top(L);
-    switch (*(e+1)) {
-      case 's':
-        pushstr(L, va_arg(argp, char *));
-        break;
-      case 'c': {
+    switch (*(e + 1)) {
+    case 's':
+      pushstr(L, va_arg(argp, char *));
+      break;
+    case 'c':{
         char buff[2];
         buff[0] = cast(char, va_arg(argp, int));
         buff[1] = '\0';
         pushstr(L, buff);
         break;
       }
-      case 'd':
-        setnvalue(L->top, cast(lua_Number, va_arg(argp, int)));
-        incr_top(L);
-        break;
-      case 'f':
-        setnvalue(L->top, cast(lua_Number, va_arg(argp, l_uacNumber)));
-        incr_top(L);
-        break;
-      case '%':
-        pushstr(L, "%");
-        break;
-      default: lua_assert(0);
+    case 'd':
+      setnvalue(L->top, cast(lua_Number, va_arg(argp, int)));
+      incr_top(L);
+      break;
+    case 'f':
+      setnvalue(L->top, cast(lua_Number, va_arg(argp, l_uacNumber)));
+      incr_top(L);
+      break;
+    case '%':
+      pushstr(L, "%");
+      break;
+    default:
+      lua_assert(0);
     }
     n += 2;
-    fmt = e+2;
+    fmt = e + 2;
   }
   pushstr(L, fmt);
-  luaV_concat(L, n+1, L->top - L->base - 1);
+  luaV_concat(L, n + 1, L->top - L->base - 1);
   L->top -= n;
   return svalue(L->top - 1);
 }
 
 
-const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
+const char *
+luaO_pushfstring(lua_State * L, const char *fmt, ...)
+{
   const char *msg;
   va_list argp;
   va_start(argp, fmt);
@@ -162,34 +182,34 @@ const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
 }
 
 
-void luaO_chunkid (char *out, const char *source, int bufflen) {
+void
+luaO_chunkid(char *out, const char *source, int bufflen)
+{
   if (*source == '=') {
-    strncpy(out, source+1, bufflen);  /* remove first char */
-    out[bufflen-1] = '\0';  /* ensures null termination */
-  }
-  else {  /* out = "source", or "...source" */
+    strncpy(out, source + 1, bufflen);  /* remove first char */
+    out[bufflen - 1] = '\0';    /* ensures null termination */
+  } else {                      /* out = "source", or "...source" */
     if (*source == '@') {
       int l;
-      source++;  /* skip the `@' */
+      source++;                 /* skip the `@' */
       bufflen -= sizeof(" `...' ");
       l = strlen(source);
       strcpy(out, "");
-      if (l>bufflen) {
-        source += (l-bufflen);  /* get last part of file name */
+      if (l > bufflen) {
+        source += (l - bufflen);        /* get last part of file name */
         strcat(out, "...");
       }
       strcat(out, source);
-    }
-    else {  /* out = [string "string"] */
-      int len = strcspn(source, "\n");  /* stop at first newline */
+    } else {                    /* out = [string "string"] */
+      int len = strcspn(source, "\n"); /* stop at first newline */
       bufflen -= sizeof(" [string \"...\"] ");
-      if (len > bufflen) len = bufflen;
+      if (len > bufflen)
+        len = bufflen;
       strcpy(out, "[string \"");
-      if (source[len] != '\0') {  /* must truncate? */
+      if (source[len] != '\0') {        /* must truncate? */
         strncat(out, source, len);
         strcat(out, "...");
-      }
-      else
+      } else
         strcat(out, source);
       strcat(out, "\"]");
     }
index f9428b4..a4ac402 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 ** $Id: lobject.h,v 1.159 2003/03/18 12:50:04 roberto Exp $
 ** Type definitions for Lua objects
@@ -152,13 +153,17 @@ typedef struct lua_TObject {
 
 /* from stack to (same) stack */
 #define setobjs2s      setobj
+
 /* to stack (not from same stack) */
 #define setobj2s       setobj
 #define setsvalue2s    setsvalue
+
 /* from table to same table */
 #define setobjt2t      setobj
+
 /* to table */
 #define setobj2t       setobj
+
 /* to new object */
 #define setobj2n       setobj
 #define setsvalue2n    setsvalue
@@ -170,14 +175,14 @@ typedef struct lua_TObject {
 
 
 
-typedef TObject *StkId;  /* index to stack elements */
+typedef TObject *StkId;                /* index to stack elements */
 
 
 /*
 ** String headers for string table
 */
 typedef union TString {
-  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
+  L_Umaxalign dummy;                   /* ensures maximum alignment for strings */
   struct {
     CommonHeader;
     lu_byte reserved;
@@ -193,7 +198,7 @@ typedef union TString {
 
 
 typedef union Udata {
-  L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
+  L_Umaxalign dummy;                   /* ensures maximum alignment for `local' udata */
   struct {
     CommonHeader;
     struct Table *metatable;
@@ -209,22 +214,22 @@ typedef union Udata {
 */
 typedef struct Proto {
   CommonHeader;
-  TObject *k;  /* constants used by the function */
+  TObject *k;                          /* constants used by the function */
   Instruction *code;
-  struct Proto **p;  /* functions defined inside the function */
-  int *lineinfo;  /* map from opcodes to source lines */
-  struct LocVar *locvars;  /* information about local variables */
-  TString **upvalues;  /* upvalue names */
-  TString  *source;
+  struct Proto **p;                    /* functions defined inside the function */
+  int *lineinfo;                       /* map from opcodes to source lines */
+  struct LocVar *locvars;              /* information about local variables */
+  TString **upvalues;                  /* upvalue names */
+  TString *source;
   int sizeupvalues;
-  int sizek;  /* size of `k' */
+  int sizek;                           /* size of `k' */
   int sizecode;
   int sizelineinfo;
-  int sizep;  /* size of `p' */
+  int sizep;                           /* size of `p' */
   int sizelocvars;
   int lineDefined;
   GCObject *gclist;
-  lu_byte nups;  /* number of upvalues */
+  lu_byte nups;                        /* number of upvalues */
   lu_byte numparams;
   lu_byte is_vararg;
   lu_byte maxstacksize;
@@ -233,8 +238,8 @@ typedef struct Proto {
 
 typedef struct LocVar {
   TString *varname;
-  int startpc;  /* first point where variable is active */
-  int endpc;    /* first point where variable is dead */
+  int startpc;                         /* first point where variable is active */
+  int endpc;                           /* first point where variable is dead */
 } LocVar;
 
 
@@ -245,8 +250,8 @@ typedef struct LocVar {
 
 typedef struct UpVal {
   CommonHeader;
-  TObject *v;  /* points to stack or to its own value */
-  TObject value;  /* the value (when closed) */
+  TObject *v;                          /* points to stack or to its own value */
+  TObject value;                       /* the value (when closed) */
 } UpVal;
 
 
@@ -267,7 +272,7 @@ typedef struct CClosure {
 typedef struct LClosure {
   ClosureHeader;
   struct Proto *p;
-  TObject g;  /* global table for this closure */
+  TObject g;                           /* global table for this closure */
   UpVal *upvals[1];
 } LClosure;
 
@@ -289,20 +294,20 @@ typedef union Closure {
 typedef struct Node {
   TObject i_key;
   TObject i_val;
-  struct Node *next;  /* for chaining */
+  struct Node *next;                   /* for chaining */
 } Node;
 
 
 typedef struct Table {
   CommonHeader;
-  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */ 
-  lu_byte lsizenode;  /* log2 of size of `node' array */
+  lu_byte flags;                       /* 1<<p means tagmethod(p) is not present */
+  lu_byte lsizenode;                   /* log2 of size of `node' array */
   struct Table *metatable;
-  TObject *array;  /* array part */
+  TObject *array;                      /* array part */
   Node *node;
-  Node *firstfree;  /* this position is free; all positions after it are full */
+  Node *firstfree;                     /* this position is free; all positions after it are full */
   GCObject *gclist;
-  int sizearray;  /* size of `array' array */
+  int sizearray;                       /* size of `array' array */
 } Table;