1.1 --- a/src/lua/Makefile.am	Sat Mar 03 11:04:56 2012 -0600
     1.2 +++ b/src/lua/Makefile.am	Sat Mar 03 11:07:39 2012 -0600
     1.3 @@ -1,56 +1,56 @@
     1.4  noinst_LIBRARIES = libgblua.a
     1.5  
     1.6  libgblua_a_SOURCES = \
     1.7 -	src/lapi.c	\
     1.8 -	src/lapi.h	\
     1.9 -	src/lauxlib.c	\
    1.10 -	src/lauxlib.h	\
    1.11 -	src/lbaselib.c	\
    1.12 -	src/lcode.c	\
    1.13 -	src/lcode.h	\
    1.14 -	src/ldblib.c	\
    1.15 -	src/ldebug.c	\
    1.16 -	src/ldebug.h	\
    1.17 -	src/ldo.c	\
    1.18 -	src/ldo.h	\
    1.19 -	src/ldump.c	\
    1.20 -	src/lfunc.c	\
    1.21 -	src/lfunc.h	\
    1.22 -	src/lgc.c	\
    1.23 -	src/lgc.h	\
    1.24 -	src/linit.c	\
    1.25 -	src/liolib.c	\
    1.26 -	src/llex.c	\
    1.27 -	src/llex.h	\
    1.28 -	src/llimit.h	\
    1.29 -	src/lmathlib.c	\
    1.30 -	src/lmem.c	\
    1.31 -	src/lmem.h	\
    1.32 -	src/loadlib.c	\
    1.33 -	src/lobject.c	\
    1.34 -	src/lobject.h	\
    1.35 -	src/lopcodes.c	\
    1.36 -	src/lopcodes.h	\
    1.37 -	src/loslib.c	\
    1.38 -	src/lparser.c	\
    1.39 -	src/lparser.h	\
    1.40 -	src/lstate.c	\
    1.41 -	src/lstate.h	\
    1.42 -	src/lstring.c	\
    1.43 -	src/lstring.h	\
    1.44 -	src/lstrlib.c	\
    1.45 -	src/ltable.c	\
    1.46 -	src/ltable.h	\
    1.47 -	src/ltablib.c	\
    1.48 -	src/ltm.c	\
    1.49 -	src/ltm.h	\
    1.50 -	src/lua.h	\
    1.51 -	src/luaconf.h	\
    1.52 -	src/lualib.h	\
    1.53 -	src/lundump.c	\
    1.54 -	src/lundump.h	\
    1.55 -	src/lvm.c	\
    1.56 -	src/lvm.h	\
    1.57 -	src/lzio.c	\
    1.58 -	src/lzio.h	\
    1.59 -	src/print.c
    1.60 +	lapi.c  	\
    1.61 +	lapi.h  	\
    1.62 +	lauxlib.c	\
    1.63 +	lauxlib.h	\
    1.64 +	lbaselib.c	\
    1.65 +	lcode.c 	\
    1.66 +	lcode.h 	\
    1.67 +	ldblib.c	\
    1.68 +	ldebug.c	\
    1.69 +	ldebug.h	\
    1.70 +	ldo.c   	\
    1.71 +	ldo.h   	\
    1.72 +	ldump.c 	\
    1.73 +	lfunc.c 	\
    1.74 +	lfunc.h  	\
    1.75 +	lgc.c   	\
    1.76 +	lgc.h   	\
    1.77 +	linit.c  	\
    1.78 +	liolib.c	\
    1.79 +	llex.c  	\
    1.80 +	llex.h  	\
    1.81 +	llimit.h	\
    1.82 +	lmathlib.c	\
    1.83 +	lmem.c          \
    1.84 +	lmem.h   	\
    1.85 +	loadlib.c	\
    1.86 +	lobject.c	\
    1.87 +	lobject.h	\
    1.88 +	lopcodes.c	\
    1.89 +	lopcodes.h	\
    1.90 +	loslib.c	\
    1.91 +	lparser.c	\
    1.92 +	lparser.h	\
    1.93 +	lstate.c	\
    1.94 +	lstate.h	\
    1.95 +	lstring.c	\
    1.96 +	lstring.h	\
    1.97 +	lstrlib.c	\
    1.98 +	ltable.c	\
    1.99 +	ltable.h	\
   1.100 +	ltablib.c	\
   1.101 +	ltm.c   	\
   1.102 +	ltm.h   	\
   1.103 +	lua.h   	\
   1.104 +	luaconf.h	\
   1.105 +	lualib.h	\
   1.106 +	lundump.c	\
   1.107 +	lundump.h	\
   1.108 +	lvm.c   	\
   1.109 +	lvm.h   	\
   1.110 +	lzio.c   	\
   1.111 +	lzio.h  	\
   1.112 +	print.c

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/src/lua/lapi.c	Sat Mar 03 11:07:39 2012 -0600
     2.3 @@ -0,0 +1,1087 @@
     2.4 +/*
     2.5 +** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $
     2.6 +** Lua API
     2.7 +** See Copyright Notice in lua.h
     2.8 +*/
     2.9 +
    2.10 +
    2.11 +#include <assert.h>
    2.12 +#include <math.h>
    2.13 +#include <stdarg.h>
    2.14 +#include <string.h>
    2.15 +
    2.16 +#define lapi_c
    2.17 +#define LUA_CORE
    2.18 +
    2.19 +#include "lua.h"
    2.20 +
    2.21 +#include "lapi.h"
    2.22 +#include "ldebug.h"
    2.23 +#include "ldo.h"
    2.24 +#include "lfunc.h"
    2.25 +#include "lgc.h"
    2.26 +#include "lmem.h"
    2.27 +#include "lobject.h"
    2.28 +#include "lstate.h"
    2.29 +#include "lstring.h"
    2.30 +#include "ltable.h"
    2.31 +#include "ltm.h"
    2.32 +#include "lundump.h"
    2.33 +#include "lvm.h"
    2.34 +
    2.35 +
    2.36 +
    2.37 +const char lua_ident[] =
    2.38 +  "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n"
    2.39 +  "$Authors: " LUA_AUTHORS " $\n"
    2.40 +  "$URL: www.lua.org $\n";
    2.41 +
    2.42 +
    2.43 +
    2.44 +#define api_checknelems(L, n)	api_check(L, (n) <= (L->top - L->base))
    2.45 +
    2.46 +#define api_checkvalidindex(L, i)	api_check(L, (i) != luaO_nilobject)
    2.47 +
    2.48 +#define api_incr_top(L)   {api_check(L, L->top < L->ci->top); L->top++;}
    2.49 +
    2.50 +
    2.51 +
    2.52 +static TValue *index2adr (lua_State *L, int idx) {
    2.53 +  if (idx > 0) {
    2.54 +    TValue *o = L->base + (idx - 1);
    2.55 +    api_check(L, idx <= L->ci->top - L->base);
    2.56 +    if (o >= L->top) return cast(TValue *, luaO_nilobject);
    2.57 +    else return o;
    2.58 +  }
    2.59 +  else if (idx > LUA_REGISTRYINDEX) {
    2.60 +    api_check(L, idx != 0 && -idx <= L->top - L->base);
    2.61 +    return L->top + idx;
    2.62 +  }
    2.63 +  else switch (idx) {  /* pseudo-indices */
    2.64 +    case LUA_REGISTRYINDEX: return registry(L);
    2.65 +    case LUA_ENVIRONINDEX: {
    2.66 +      Closure *func = curr_func(L);
    2.67 +      sethvalue(L, &L->env, func->c.env);
    2.68 +      return &L->env;
    2.69 +    }
    2.70 +    case LUA_GLOBALSINDEX: return gt(L);
    2.71 +    default: {
    2.72 +      Closure *func = curr_func(L);
    2.73 +      idx = LUA_GLOBALSINDEX - idx;
    2.74 +      return (idx <= func->c.nupvalues)
    2.75 +                ? &func->c.upvalue[idx-1]
    2.76 +                : cast(TValue *, luaO_nilobject);
    2.77 +    }
    2.78 +  }
    2.79 +}
    2.80 +
    2.81 +
    2.82 +static Table *getcurrenv (lua_State *L) {
    2.83 +  if (L->ci == L->base_ci)  /* no enclosing function? */
    2.84 +    return hvalue(gt(L));  /* use global table as environment */
    2.85 +  else {
    2.86 +    Closure *func = curr_func(L);
    2.87 +    return func->c.env;
    2.88 +  }
    2.89 +}
    2.90 +
    2.91 +
    2.92 +void luaA_pushobject (lua_State *L, const TValue *o) {
    2.93 +  setobj2s(L, L->top, o);
    2.94 +  api_incr_top(L);
    2.95 +}
    2.96 +
    2.97 +
    2.98 +LUA_API int lua_checkstack (lua_State *L, int size) {
    2.99 +  int res = 1;
   2.100 +  lua_lock(L);
   2.101 +  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
   2.102 +    res = 0;  /* stack overflow */
   2.103 +  else if (size > 0) {
   2.104 +    luaD_checkstack(L, size);
   2.105 +    if (L->ci->top < L->top + size)
   2.106 +      L->ci->top = L->top + size;
   2.107 +  }
   2.108 +  lua_unlock(L);
   2.109 +  return res;
   2.110 +}
   2.111 +
   2.112 +
   2.113 +LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
   2.114 +  int i;
   2.115 +  if (from == to) return;
   2.116 +  lua_lock(to);
   2.117 +  api_checknelems(from, n);
   2.118 +  api_check(from, G(from) == G(to));
   2.119 +  api_check(from, to->ci->top - to->top >= n);
   2.120 +  from->top -= n;
   2.121 +  for (i = 0; i < n; i++) {
   2.122 +    setobj2s(to, to->top++, from->top + i);
   2.123 +  }
   2.124 +  lua_unlock(to);
   2.125 +}
   2.126 +
   2.127 +
   2.128 +LUA_API void lua_setlevel (lua_State *from, lua_State *to) {
   2.129 +  to->nCcalls = from->nCcalls;
   2.130 +}
   2.131 +
   2.132 +
   2.133 +LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
   2.134 +  lua_CFunction old;
   2.135 +  lua_lock(L);
   2.136 +  old = G(L)->panic;
   2.137 +  G(L)->panic = panicf;
   2.138 +  lua_unlock(L);
   2.139 +  return old;
   2.140 +}
   2.141 +
   2.142 +
   2.143 +LUA_API lua_State *lua_newthread (lua_State *L) {
   2.144 +  lua_State *L1;
   2.145 +  lua_lock(L);
   2.146 +  luaC_checkGC(L);
   2.147 +  L1 = luaE_newthread(L);
   2.148 +  setthvalue(L, L->top, L1);
   2.149 +  api_incr_top(L);
   2.150 +  lua_unlock(L);
   2.151 +  luai_userstatethread(L, L1);
   2.152 +  return L1;
   2.153 +}
   2.154 +
   2.155 +
   2.156 +
   2.157 +/*
   2.158 +** basic stack manipulation
   2.159 +*/
   2.160 +
   2.161 +
   2.162 +LUA_API int lua_gettop (lua_State *L) {
   2.163 +  return cast_int(L->top - L->base);
   2.164 +}
   2.165 +
   2.166 +
   2.167 +LUA_API void lua_settop (lua_State *L, int idx) {
   2.168 +  lua_lock(L);
   2.169 +  if (idx >= 0) {
   2.170 +    api_check(L, idx <= L->stack_last - L->base);
   2.171 +    while (L->top < L->base + idx)
   2.172 +      setnilvalue(L->top++);
   2.173 +    L->top = L->base + idx;
   2.174 +  }
   2.175 +  else {
   2.176 +    api_check(L, -(idx+1) <= (L->top - L->base));
   2.177 +    L->top += idx+1;  /* `subtract' index (index is negative) */
   2.178 +  }
   2.179 +  lua_unlock(L);
   2.180 +}
   2.181 +
   2.182 +
   2.183 +LUA_API void lua_remove (lua_State *L, int idx) {
   2.184 +  StkId p;
   2.185 +  lua_lock(L);
   2.186 +  p = index2adr(L, idx);
   2.187 +  api_checkvalidindex(L, p);
   2.188 +  while (++p < L->top) setobjs2s(L, p-1, p);
   2.189 +  L->top--;
   2.190 +  lua_unlock(L);
   2.191 +}
   2.192 +
   2.193 +
   2.194 +LUA_API void lua_insert (lua_State *L, int idx) {
   2.195 +  StkId p;
   2.196 +  StkId q;
   2.197 +  lua_lock(L);
   2.198 +  p = index2adr(L, idx);
   2.199 +  api_checkvalidindex(L, p);
   2.200 +  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
   2.201 +  setobjs2s(L, p, L->top);
   2.202 +  lua_unlock(L);
   2.203 +}
   2.204 +
   2.205 +
   2.206 +LUA_API void lua_replace (lua_State *L, int idx) {
   2.207 +  StkId o;
   2.208 +  lua_lock(L);
   2.209 +  /* explicit test for incompatible code */
   2.210 +  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
   2.211 +    luaG_runerror(L, "no calling environment");
   2.212 +  api_checknelems(L, 1);
   2.213 +  o = index2adr(L, idx);
   2.214 +  api_checkvalidindex(L, o);
   2.215 +  if (idx == LUA_ENVIRONINDEX) {
   2.216 +    Closure *func = curr_func(L);
   2.217 +    api_check(L, ttistable(L->top - 1)); 
   2.218 +    func->c.env = hvalue(L->top - 1);
   2.219 +    luaC_barrier(L, func, L->top - 1);
   2.220 +  }
   2.221 +  else {
   2.222 +    setobj(L, o, L->top - 1);
   2.223 +    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */
   2.224 +      luaC_barrier(L, curr_func(L), L->top - 1);
   2.225 +  }
   2.226 +  L->top--;
   2.227 +  lua_unlock(L);
   2.228 +}
   2.229 +
   2.230 +
   2.231 +LUA_API void lua_pushvalue (lua_State *L, int idx) {
   2.232 +  lua_lock(L);
   2.233 +  setobj2s(L, L->top, index2adr(L, idx));
   2.234 +  api_incr_top(L);
   2.235 +  lua_unlock(L);
   2.236 +}
   2.237 +
   2.238 +
   2.239 +
   2.240 +/*
   2.241 +** access functions (stack -> C)
   2.242 +*/
   2.243 +
   2.244 +
   2.245 +LUA_API int lua_type (lua_State *L, int idx) {
   2.246 +  StkId o = index2adr(L, idx);
   2.247 +  return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);
   2.248 +}
   2.249 +
   2.250 +
   2.251 +LUA_API const char *lua_typename (lua_State *L, int t) {
   2.252 +  UNUSED(L);
   2.253 +  return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
   2.254 +}
   2.255 +
   2.256 +
   2.257 +LUA_API int lua_iscfunction (lua_State *L, int idx) {
   2.258 +  StkId o = index2adr(L, idx);
   2.259 +  return iscfunction(o);
   2.260 +}
   2.261 +
   2.262 +
   2.263 +LUA_API int lua_isnumber (lua_State *L, int idx) {
   2.264 +  TValue n;
   2.265 +  const TValue *o = index2adr(L, idx);
   2.266 +  return tonumber(o, &n);
   2.267 +}
   2.268 +
   2.269 +
   2.270 +LUA_API int lua_isstring (lua_State *L, int idx) {
   2.271 +  int t = lua_type(L, idx);
   2.272 +  return (t == LUA_TSTRING || t == LUA_TNUMBER);
   2.273 +}
   2.274 +
   2.275 +
   2.276 +LUA_API int lua_isuserdata (lua_State *L, int idx) {
   2.277 +  const TValue *o = index2adr(L, idx);
   2.278 +  return (ttisuserdata(o) || ttislightuserdata(o));
   2.279 +}
   2.280 +
   2.281 +
   2.282 +LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
   2.283 +  StkId o1 = index2adr(L, index1);
   2.284 +  StkId o2 = index2adr(L, index2);
   2.285 +  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
   2.286 +         : luaO_rawequalObj(o1, o2);
   2.287 +}
   2.288 +
   2.289 +
   2.290 +LUA_API int lua_equal (lua_State *L, int index1, int index2) {
   2.291 +  StkId o1, o2;
   2.292 +  int i;
   2.293 +  lua_lock(L);  /* may call tag method */
   2.294 +  o1 = index2adr(L, index1);
   2.295 +  o2 = index2adr(L, index2);
   2.296 +  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
   2.297 +  lua_unlock(L);
   2.298 +  return i;
   2.299 +}
   2.300 +
   2.301 +
   2.302 +LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
   2.303 +  StkId o1, o2;
   2.304 +  int i;
   2.305 +  lua_lock(L);  /* may call tag method */
   2.306 +  o1 = index2adr(L, index1);
   2.307 +  o2 = index2adr(L, index2);
   2.308 +  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
   2.309 +       : luaV_lessthan(L, o1, o2);
   2.310 +  lua_unlock(L);
   2.311 +  return i;
   2.312 +}
   2.313 +
   2.314 +
   2.315 +
   2.316 +LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
   2.317 +  TValue n;
   2.318 +  const TValue *o = index2adr(L, idx);
   2.319 +  if (tonumber(o, &n))
   2.320 +    return nvalue(o);
   2.321 +  else
   2.322 +    return 0;
   2.323 +}
   2.324 +
   2.325 +
   2.326 +LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
   2.327 +  TValue n;
   2.328 +  const TValue *o = index2adr(L, idx);
   2.329 +  if (tonumber(o, &n)) {
   2.330 +    lua_Integer res;
   2.331 +    lua_Number num = nvalue(o);
   2.332 +    lua_number2integer(res, num);
   2.333 +    return res;
   2.334 +  }
   2.335 +  else
   2.336 +    return 0;
   2.337 +}
   2.338 +
   2.339 +
   2.340 +LUA_API int lua_toboolean (lua_State *L, int idx) {
   2.341 +  const TValue *o = index2adr(L, idx);
   2.342 +  return !l_isfalse(o);
   2.343 +}
   2.344 +
   2.345 +
   2.346 +LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
   2.347 +  StkId o = index2adr(L, idx);
   2.348 +  if (!ttisstring(o)) {
   2.349 +    lua_lock(L);  /* `luaV_tostring' may create a new string */
   2.350 +    if (!luaV_tostring(L, o)) {  /* conversion failed? */
   2.351 +      if (len != NULL) *len = 0;
   2.352 +      lua_unlock(L);
   2.353 +      return NULL;
   2.354 +    }
   2.355 +    luaC_checkGC(L);
   2.356 +    o = index2adr(L, idx);  /* previous call may reallocate the stack */
   2.357 +    lua_unlock(L);
   2.358 +  }
   2.359 +  if (len != NULL) *len = tsvalue(o)->len;
   2.360 +  return svalue(o);
   2.361 +}
   2.362 +
   2.363 +
   2.364 +LUA_API size_t lua_objlen (lua_State *L, int idx) {
   2.365 +  StkId o = index2adr(L, idx);
   2.366 +  switch (ttype(o)) {
   2.367 +    case LUA_TSTRING: return tsvalue(o)->len;
   2.368 +    case LUA_TUSERDATA: return uvalue(o)->len;
   2.369 +    case LUA_TTABLE: return luaH_getn(hvalue(o));
   2.370 +    case LUA_TNUMBER: {
   2.371 +      size_t l;
   2.372 +      lua_lock(L);  /* `luaV_tostring' may create a new string */
   2.373 +      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
   2.374 +      lua_unlock(L);
   2.375 +      return l;
   2.376 +    }
   2.377 +    default: return 0;
   2.378 +  }
   2.379 +}
   2.380 +
   2.381 +
   2.382 +LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
   2.383 +  StkId o = index2adr(L, idx);
   2.384 +  return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
   2.385 +}
   2.386 +
   2.387 +
   2.388 +LUA_API void *lua_touserdata (lua_State *L, int idx) {
   2.389 +  StkId o = index2adr(L, idx);
   2.390 +  switch (ttype(o)) {
   2.391 +    case LUA_TUSERDATA: return (rawuvalue(o) + 1);
   2.392 +    case LUA_TLIGHTUSERDATA: return pvalue(o);
   2.393 +    default: return NULL;
   2.394 +  }
   2.395 +}
   2.396 +
   2.397 +
   2.398 +LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
   2.399 +  StkId o = index2adr(L, idx);
   2.400 +  return (!ttisthread(o)) ? NULL : thvalue(o);
   2.401 +}
   2.402 +
   2.403 +
   2.404 +LUA_API const void *lua_topointer (lua_State *L, int idx) {
   2.405 +  StkId o = index2adr(L, idx);
   2.406 +  switch (ttype(o)) {
   2.407 +    case LUA_TTABLE: return hvalue(o);
   2.408 +    case LUA_TFUNCTION: return clvalue(o);
   2.409 +    case LUA_TTHREAD: return thvalue(o);
   2.410 +    case LUA_TUSERDATA:
   2.411 +    case LUA_TLIGHTUSERDATA:
   2.412 +      return lua_touserdata(L, idx);
   2.413 +    default: return NULL;
   2.414 +  }
   2.415 +}
   2.416 +
   2.417 +
   2.418 +
   2.419 +/*
   2.420 +** push functions (C -> stack)
   2.421 +*/
   2.422 +
   2.423 +
   2.424 +LUA_API void lua_pushnil (lua_State *L) {
   2.425 +  lua_lock(L);
   2.426 +  setnilvalue(L->top);
   2.427 +  api_incr_top(L);
   2.428 +  lua_unlock(L);
   2.429 +}
   2.430 +
   2.431 +
   2.432 +LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
   2.433 +  lua_lock(L);
   2.434 +  setnvalue(L->top, n);
   2.435 +  api_incr_top(L);
   2.436 +  lua_unlock(L);
   2.437 +}
   2.438 +
   2.439 +
   2.440 +LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
   2.441 +  lua_lock(L);
   2.442 +  setnvalue(L->top, cast_num(n));
   2.443 +  api_incr_top(L);
   2.444 +  lua_unlock(L);
   2.445 +}
   2.446 +
   2.447 +
   2.448 +LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
   2.449 +  lua_lock(L);
   2.450 +  luaC_checkGC(L);
   2.451 +  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
   2.452 +  api_incr_top(L);
   2.453 +  lua_unlock(L);
   2.454 +}
   2.455 +
   2.456 +
   2.457 +LUA_API void lua_pushstring (lua_State *L, const char *s) {
   2.458 +  if (s == NULL)
   2.459 +    lua_pushnil(L);
   2.460 +  else
   2.461 +    lua_pushlstring(L, s, strlen(s));
   2.462 +}
   2.463 +
   2.464 +
   2.465 +LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
   2.466 +                                      va_list argp) {
   2.467 +  const char *ret;
   2.468 +  lua_lock(L);
   2.469 +  luaC_checkGC(L);
   2.470 +  ret = luaO_pushvfstring(L, fmt, argp);
   2.471 +  lua_unlock(L);
   2.472 +  return ret;
   2.473 +}
   2.474 +
   2.475 +
   2.476 +LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
   2.477 +  const char *ret;
   2.478 +  va_list argp;
   2.479 +  lua_lock(L);
   2.480 +  luaC_checkGC(L);
   2.481 +  va_start(argp, fmt);
   2.482 +  ret = luaO_pushvfstring(L, fmt, argp);
   2.483 +  va_end(argp);
   2.484 +  lua_unlock(L);
   2.485 +  return ret;
   2.486 +}
   2.487 +
   2.488 +
   2.489 +LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
   2.490 +  Closure *cl;
   2.491 +  lua_lock(L);
   2.492 +  luaC_checkGC(L);
   2.493 +  api_checknelems(L, n);
   2.494 +  cl = luaF_newCclosure(L, n, getcurrenv(L));
   2.495 +  cl->c.f = fn;
   2.496 +  L->top -= n;
   2.497 +  while (n--)
   2.498 +    setobj2n(L, &cl->c.upvalue[n], L->top+n);
   2.499 +  setclvalue(L, L->top, cl);
   2.500 +  lua_assert(iswhite(obj2gco(cl)));
   2.501 +  api_incr_top(L);
   2.502 +  lua_unlock(L);
   2.503 +}
   2.504 +
   2.505 +
   2.506 +LUA_API void lua_pushboolean (lua_State *L, int b) {
   2.507 +  lua_lock(L);
   2.508 +  setbvalue(L->top, (b != 0));  /* ensure that true is 1 */
   2.509 +  api_incr_top(L);
   2.510 +  lua_unlock(L);
   2.511 +}
   2.512 +
   2.513 +
   2.514 +LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
   2.515 +  lua_lock(L);
   2.516 +  setpvalue(L->top, p);
   2.517 +  api_incr_top(L);
   2.518 +  lua_unlock(L);
   2.519 +}
   2.520 +
   2.521 +
   2.522 +LUA_API int lua_pushthread (lua_State *L) {
   2.523 +  lua_lock(L);
   2.524 +  setthvalue(L, L->top, L);
   2.525 +  api_incr_top(L);
   2.526 +  lua_unlock(L);
   2.527 +  return (G(L)->mainthread == L);
   2.528 +}
   2.529 +
   2.530 +
   2.531 +
   2.532 +/*
   2.533 +** get functions (Lua -> stack)
   2.534 +*/
   2.535 +
   2.536 +
   2.537 +LUA_API void lua_gettable (lua_State *L, int idx) {
   2.538 +  StkId t;
   2.539 +  lua_lock(L);
   2.540 +  t = index2adr(L, idx);
   2.541 +  api_checkvalidindex(L, t);
   2.542 +  luaV_gettable(L, t, L->top - 1, L->top - 1);
   2.543 +  lua_unlock(L);
   2.544 +}
   2.545 +
   2.546 +
   2.547 +LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
   2.548 +  StkId t;
   2.549 +  TValue key;
   2.550 +  lua_lock(L);
   2.551 +  t = index2adr(L, idx);
   2.552 +  api_checkvalidindex(L, t);
   2.553 +  setsvalue(L, &key, luaS_new(L, k));
   2.554 +  luaV_gettable(L, t, &key, L->top);
   2.555 +  api_incr_top(L);
   2.556 +  lua_unlock(L);
   2.557 +}
   2.558 +
   2.559 +
   2.560 +LUA_API void lua_rawget (lua_State *L, int idx) {
   2.561 +  StkId t;
   2.562 +  lua_lock(L);
   2.563 +  t = index2adr(L, idx);
   2.564 +  api_check(L, ttistable(t));
   2.565 +  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
   2.566 +  lua_unlock(L);
   2.567 +}
   2.568 +
   2.569 +
   2.570 +LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
   2.571 +  StkId o;
   2.572 +  lua_lock(L);
   2.573 +  o = index2adr(L, idx);
   2.574 +  api_check(L, ttistable(o));
   2.575 +  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
   2.576 +  api_incr_top(L);
   2.577 +  lua_unlock(L);
   2.578 +}
   2.579 +
   2.580 +
   2.581 +LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
   2.582 +  lua_lock(L);
   2.583 +  luaC_checkGC(L);
   2.584 +  sethvalue(L, L->top, luaH_new(L, narray, nrec));
   2.585 +  api_incr_top(L);
   2.586 +  lua_unlock(L);
   2.587 +}
   2.588 +
   2.589 +
   2.590 +LUA_API int lua_getmetatable (lua_State *L, int objindex) {
   2.591 +  const TValue *obj;
   2.592 +  Table *mt = NULL;
   2.593 +  int res;
   2.594 +  lua_lock(L);
   2.595 +  obj = index2adr(L, objindex);
   2.596 +  switch (ttype(obj)) {
   2.597 +    case LUA_TTABLE:
   2.598 +      mt = hvalue(obj)->metatable;
   2.599 +      break;
   2.600 +    case LUA_TUSERDATA:
   2.601 +      mt = uvalue(obj)->metatable;
   2.602 +      break;
   2.603 +    default:
   2.604 +      mt = G(L)->mt[ttype(obj)];
   2.605 +      break;
   2.606 +  }
   2.607 +  if (mt == NULL)
   2.608 +    res = 0;
   2.609 +  else {
   2.610 +    sethvalue(L, L->top, mt);
   2.611 +    api_incr_top(L);
   2.612 +    res = 1;
   2.613 +  }
   2.614 +  lua_unlock(L);
   2.615 +  return res;
   2.616 +}
   2.617 +
   2.618 +
   2.619 +LUA_API void lua_getfenv (lua_State *L, int idx) {
   2.620 +  StkId o;
   2.621 +  lua_lock(L);
   2.622 +  o = index2adr(L, idx);
   2.623 +  api_checkvalidindex(L, o);
   2.624 +  switch (ttype(o)) {
   2.625 +    case LUA_TFUNCTION:
   2.626 +      sethvalue(L, L->top, clvalue(o)->c.env);
   2.627 +      break;
   2.628 +    case LUA_TUSERDATA:
   2.629 +      sethvalue(L, L->top, uvalue(o)->env);
   2.630 +      break;
   2.631 +    case LUA_TTHREAD:
   2.632 +      setobj2s(L, L->top,  gt(thvalue(o)));
   2.633 +      break;
   2.634 +    default:
   2.635 +      setnilvalue(L->top);
   2.636 +      break;
   2.637 +  }
   2.638 +  api_incr_top(L);
   2.639 +  lua_unlock(L);
   2.640 +}
   2.641 +
   2.642 +
   2.643 +/*
   2.644 +** set functions (stack -> Lua)
   2.645 +*/
   2.646 +
   2.647 +
   2.648 +LUA_API void lua_settable (lua_State *L, int idx) {
   2.649 +  StkId t;
   2.650 +  lua_lock(L);
   2.651 +  api_checknelems(L, 2);
   2.652 +  t = index2adr(L, idx);
   2.653 +  api_checkvalidindex(L, t);
   2.654 +  luaV_settable(L, t, L->top - 2, L->top - 1);
   2.655 +  L->top -= 2;  /* pop index and value */
   2.656 +  lua_unlock(L);
   2.657 +}
   2.658 +
   2.659 +
   2.660 +LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
   2.661 +  StkId t;
   2.662 +  TValue key;
   2.663 +  lua_lock(L);
   2.664 +  api_checknelems(L, 1);
   2.665 +  t = index2adr(L, idx);
   2.666 +  api_checkvalidindex(L, t);
   2.667 +  setsvalue(L, &key, luaS_new(L, k));
   2.668 +  luaV_settable(L, t, &key, L->top - 1);
   2.669 +  L->top--;  /* pop value */
   2.670 +  lua_unlock(L);
   2.671 +}
   2.672 +
   2.673 +
   2.674 +LUA_API void lua_rawset (lua_State *L, int idx) {
   2.675 +  StkId t;
   2.676 +  lua_lock(L);
   2.677 +  api_checknelems(L, 2);
   2.678 +  t = index2adr(L, idx);
   2.679 +  api_check(L, ttistable(t));
   2.680 +  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
   2.681 +  luaC_barriert(L, hvalue(t), L->top-1);
   2.682 +  L->top -= 2;
   2.683 +  lua_unlock(L);
   2.684 +}
   2.685 +
   2.686 +
   2.687 +LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
   2.688 +  StkId o;
   2.689 +  lua_lock(L);
   2.690 +  api_checknelems(L, 1);
   2.691 +  o = index2adr(L, idx);
   2.692 +  api_check(L, ttistable(o));
   2.693 +  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
   2.694 +  luaC_barriert(L, hvalue(o), L->top-1);
   2.695 +  L->top--;
   2.696 +  lua_unlock(L);
   2.697 +}
   2.698 +
   2.699 +
   2.700 +LUA_API int lua_setmetatable (lua_State *L, int objindex) {
   2.701 +  TValue *obj;
   2.702 +  Table *mt;
   2.703 +  lua_lock(L);
   2.704 +  api_checknelems(L, 1);
   2.705 +  obj = index2adr(L, objindex);
   2.706 +  api_checkvalidindex(L, obj);
   2.707 +  if (ttisnil(L->top - 1))
   2.708 +    mt = NULL;
   2.709 +  else {
   2.710 +    api_check(L, ttistable(L->top - 1));
   2.711 +    mt = hvalue(L->top - 1);
   2.712 +  }
   2.713 +  switch (ttype(obj)) {
   2.714 +    case LUA_TTABLE: {
   2.715 +      hvalue(obj)->metatable = mt;
   2.716 +      if (mt)
   2.717 +        luaC_objbarriert(L, hvalue(obj), mt);
   2.718 +      break;
   2.719 +    }
   2.720 +    case LUA_TUSERDATA: {
   2.721 +      uvalue(obj)->metatable = mt;
   2.722 +      if (mt)
   2.723 +        luaC_objbarrier(L, rawuvalue(obj), mt);
   2.724 +      break;
   2.725 +    }
   2.726 +    default: {
   2.727 +      G(L)->mt[ttype(obj)] = mt;
   2.728 +      break;
   2.729 +    }
   2.730 +  }
   2.731 +  L->top--;
   2.732 +  lua_unlock(L);
   2.733 +  return 1;
   2.734 +}
   2.735 +
   2.736 +
   2.737 +LUA_API int lua_setfenv (lua_State *L, int idx) {
   2.738 +  StkId o;
   2.739 +  int res = 1;
   2.740 +  lua_lock(L);
   2.741 +  api_checknelems(L, 1);
   2.742 +  o = index2adr(L, idx);
   2.743 +  api_checkvalidindex(L, o);
   2.744 +  api_check(L, ttistable(L->top - 1));
   2.745 +  switch (ttype(o)) {
   2.746 +    case LUA_TFUNCTION:
   2.747 +      clvalue(o)->c.env = hvalue(L->top - 1);
   2.748 +      break;
   2.749 +    case LUA_TUSERDATA:
   2.750 +      uvalue(o)->env = hvalue(L->top - 1);
   2.751 +      break;
   2.752 +    case LUA_TTHREAD:
   2.753 +      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
   2.754 +      break;
   2.755 +    default:
   2.756 +      res = 0;
   2.757 +      break;
   2.758 +  }
   2.759 +  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
   2.760 +  L->top--;
   2.761 +  lua_unlock(L);
   2.762 +  return res;
   2.763 +}
   2.764 +
   2.765 +
   2.766 +/*
   2.767 +** `load' and `call' functions (run Lua code)
   2.768 +*/
   2.769 +
   2.770 +
   2.771 +#define adjustresults(L,nres) \
   2.772 +    { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }
   2.773 +
   2.774 +
   2.775 +#define checkresults(L,na,nr) \
   2.776 +     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))
   2.777 +	
   2.778 +
   2.779 +LUA_API void lua_call (lua_State *L, int nargs, int nresults) {
   2.780 +  StkId func;
   2.781 +  lua_lock(L);
   2.782 +  api_checknelems(L, nargs+1);
   2.783 +  checkresults(L, nargs, nresults);
   2.784 +  func = L->top - (nargs+1);
   2.785 +  luaD_call(L, func, nresults);
   2.786 +  adjustresults(L, nresults);
   2.787 +  lua_unlock(L);
   2.788 +}
   2.789 +
   2.790 +
   2.791 +
   2.792 +/*
   2.793 +** Execute a protected call.
   2.794 +*/
   2.795 +struct CallS {  /* data to `f_call' */
   2.796 +  StkId func;
   2.797 +  int nresults;
   2.798 +};
   2.799 +
   2.800 +
   2.801 +static void f_call (lua_State *L, void *ud) {
   2.802 +  struct CallS *c = cast(struct CallS *, ud);
   2.803 +  luaD_call(L, c->func, c->nresults);
   2.804 +}
   2.805 +
   2.806 +
   2.807 +
   2.808 +LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {
   2.809 +  struct CallS c;
   2.810 +  int status;
   2.811 +  ptrdiff_t func;
   2.812 +  lua_lock(L);
   2.813 +  api_checknelems(L, nargs+1);
   2.814 +  checkresults(L, nargs, nresults);
   2.815 +  if (errfunc == 0)
   2.816 +    func = 0;
   2.817 +  else {
   2.818 +    StkId o = index2adr(L, errfunc);
   2.819 +    api_checkvalidindex(L, o);
   2.820 +    func = savestack(L, o);
   2.821 +  }
   2.822 +  c.func = L->top - (nargs+1);  /* function to be called */
   2.823 +  c.nresults = nresults;
   2.824 +  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
   2.825 +  adjustresults(L, nresults);
   2.826 +  lua_unlock(L);
   2.827 +  return status;
   2.828 +}
   2.829 +
   2.830 +
   2.831 +/*
   2.832 +** Execute a protected C call.
   2.833 +*/
   2.834 +struct CCallS {  /* data to `f_Ccall' */
   2.835 +  lua_CFunction func;
   2.836 +  void *ud;
   2.837 +};
   2.838 +
   2.839 +
   2.840 +static void f_Ccall (lua_State *L, void *ud) {
   2.841 +  struct CCallS *c = cast(struct CCallS *, ud);
   2.842 +  Closure *cl;
   2.843 +  cl = luaF_newCclosure(L, 0, getcurrenv(L));
   2.844 +  cl->c.f = c->func;
   2.845 +  setclvalue(L, L->top, cl);  /* push function */
   2.846 +  api_incr_top(L);
   2.847 +  setpvalue(L->top, c->ud);  /* push only argument */
   2.848 +  api_incr_top(L);
   2.849 +  luaD_call(L, L->top - 2, 0);
   2.850 +}
   2.851 +
   2.852 +
   2.853 +LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {
   2.854 +  struct CCallS c;
   2.855 +  int status;
   2.856 +  lua_lock(L);
   2.857 +  c.func = func;
   2.858 +  c.ud = ud;
   2.859 +  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
   2.860 +  lua_unlock(L);
   2.861 +  return status;
   2.862 +}
   2.863 +
   2.864 +
   2.865 +LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
   2.866 +                      const char *chunkname) {
   2.867 +  ZIO z;
   2.868 +  int status;
   2.869 +  lua_lock(L);
   2.870 +  if (!chunkname) chunkname = "?";
   2.871 +  luaZ_init(L, &z, reader, data);
   2.872 +  status = luaD_protectedparser(L, &z, chunkname);
   2.873 +  lua_unlock(L);
   2.874 +  return status;
   2.875 +}
   2.876 +
   2.877 +
   2.878 +LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
   2.879 +  int status;
   2.880 +  TValue *o;
   2.881 +  lua_lock(L);
   2.882 +  api_checknelems(L, 1);
   2.883 +  o = L->top - 1;
   2.884 +  if (isLfunction(o))
   2.885 +    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
   2.886 +  else
   2.887 +    status = 1;
   2.888 +  lua_unlock(L);
   2.889 +  return status;
   2.890 +}
   2.891 +
   2.892 +
   2.893 +LUA_API int  lua_status (lua_State *L) {
   2.894 +  return L->status;
   2.895 +}
   2.896 +
   2.897 +
   2.898 +/*
   2.899 +** Garbage-collection function
   2.900 +*/
   2.901 +
   2.902 +LUA_API int lua_gc (lua_State *L, int what, int data) {
   2.903 +  int res = 0;
   2.904 +  global_State *g;
   2.905 +  lua_lock(L);
   2.906 +  g = G(L);
   2.907 +  switch (what) {
   2.908 +    case LUA_GCSTOP: {
   2.909 +      g->GCthreshold = MAX_LUMEM;
   2.910 +      break;
   2.911 +    }
   2.912 +    case LUA_GCRESTART: {
   2.913 +      g->GCthreshold = g->totalbytes;
   2.914 +      break;
   2.915 +    }
   2.916 +    case LUA_GCCOLLECT: {
   2.917 +      luaC_fullgc(L);
   2.918 +      break;
   2.919 +    }
   2.920 +    case LUA_GCCOUNT: {
   2.921 +      /* GC values are expressed in Kbytes: #bytes/2^10 */
   2.922 +      res = cast_int(g->totalbytes >> 10);
   2.923 +      break;
   2.924 +    }
   2.925 +    case LUA_GCCOUNTB: {
   2.926 +      res = cast_int(g->totalbytes & 0x3ff);
   2.927 +      break;
   2.928 +    }
   2.929 +    case LUA_GCSTEP: {
   2.930 +      lu_mem a = (cast(lu_mem, data) << 10);
   2.931 +      if (a <= g->totalbytes)
   2.932 +        g->GCthreshold = g->totalbytes - a;
   2.933 +      else
   2.934 +        g->GCthreshold = 0;
   2.935 +      while (g->GCthreshold <= g->totalbytes) {
   2.936 +        luaC_step(L);
   2.937 +        if (g->gcstate == GCSpause) {  /* end of cycle? */
   2.938 +          res = 1;  /* signal it */
   2.939 +          break;
   2.940 +        }
   2.941 +      }
   2.942 +      break;
   2.943 +    }
   2.944 +    case LUA_GCSETPAUSE: {
   2.945 +      res = g->gcpause;
   2.946 +      g->gcpause = data;
   2.947 +      break;
   2.948 +    }
   2.949 +    case LUA_GCSETSTEPMUL: {
   2.950 +      res = g->gcstepmul;
   2.951 +      g->gcstepmul = data;
   2.952 +      break;
   2.953 +    }
   2.954 +    default: res = -1;  /* invalid option */
   2.955 +  }
   2.956 +  lua_unlock(L);
   2.957 +  return res;
   2.958 +}
   2.959 +
   2.960 +
   2.961 +
   2.962 +/*
   2.963 +** miscellaneous functions
   2.964 +*/
   2.965 +
   2.966 +
   2.967 +LUA_API int lua_error (lua_State *L) {
   2.968 +  lua_lock(L);
   2.969 +  api_checknelems(L, 1);
   2.970 +  luaG_errormsg(L);
   2.971 +  lua_unlock(L);
   2.972 +  return 0;  /* to avoid warnings */
   2.973 +}
   2.974 +
   2.975 +
   2.976 +LUA_API int lua_next (lua_State *L, int idx) {
   2.977 +  StkId t;
   2.978 +  int more;
   2.979 +  lua_lock(L);
   2.980 +  t = index2adr(L, idx);
   2.981 +  api_check(L, ttistable(t));
   2.982 +  more = luaH_next(L, hvalue(t), L->top - 1);
   2.983 +  if (more) {
   2.984 +    api_incr_top(L);
   2.985 +  }
   2.986 +  else  /* no more elements */
   2.987 +    L->top -= 1;  /* remove key */
   2.988 +  lua_unlock(L);
   2.989 +  return more;
   2.990 +}
   2.991 +
   2.992 +
   2.993 +LUA_API void lua_concat (lua_State *L, int n) {
   2.994 +  lua_lock(L);
   2.995 +  api_checknelems(L, n);
   2.996 +  if (n >= 2) {
   2.997 +    luaC_checkGC(L);
   2.998 +    luaV_concat(L, n, cast_int(L->top - L->base) - 1);
   2.999 +    L->top -= (n-1);
  2.1000 +  }
  2.1001 +  else if (n == 0) {  /* push empty string */
  2.1002 +    setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
  2.1003 +    api_incr_top(L);
  2.1004 +  }
  2.1005 +  /* else n == 1; nothing to do */
  2.1006 +  lua_unlock(L);
  2.1007 +}
  2.1008 +
  2.1009 +
  2.1010 +LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
  2.1011 +  lua_Alloc f;
  2.1012 +  lua_lock(L);
  2.1013 +  if (ud) *ud = G(L)->ud;
  2.1014 +  f = G(L)->frealloc;
  2.1015 +  lua_unlock(L);
  2.1016 +  return f;
  2.1017 +}
  2.1018 +
  2.1019 +
  2.1020 +LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
  2.1021 +  lua_lock(L);
  2.1022 +  G(L)->ud = ud;
  2.1023 +  G(L)->frealloc = f;
  2.1024 +  lua_unlock(L);
  2.1025 +}
  2.1026 +
  2.1027 +
  2.1028 +LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
  2.1029 +  Udata *u;
  2.1030 +  lua_lock(L);
  2.1031 +  luaC_checkGC(L);
  2.1032 +  u = luaS_newudata(L, size, getcurrenv(L));
  2.1033 +  setuvalue(L, L->top, u);
  2.1034 +  api_incr_top(L);
  2.1035 +  lua_unlock(L);
  2.1036 +  return u + 1;
  2.1037 +}
  2.1038 +
  2.1039 +
  2.1040 +
  2.1041 +
  2.1042 +static const char *aux_upvalue (StkId fi, int n, TValue **val) {
  2.1043 +  Closure *f;
  2.1044 +  if (!ttisfunction(fi)) return NULL;
  2.1045 +  f = clvalue(fi);
  2.1046 +  if (f->c.isC) {
  2.1047 +    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;
  2.1048 +    *val = &f->c.upvalue[n-1];
  2.1049 +    return "";
  2.1050 +  }
  2.1051 +  else {
  2.1052 +    Proto *p = f->l.p;
  2.1053 +    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
  2.1054 +    *val = f->l.upvals[n-1]->v;
  2.1055 +    return getstr(p->upvalues[n-1]);
  2.1056 +  }
  2.1057 +}
  2.1058 +
  2.1059 +
  2.1060 +LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
  2.1061 +  const char *name;
  2.1062 +  TValue *val;
  2.1063 +  lua_lock(L);
  2.1064 +  name = aux_upvalue(index2adr(L, funcindex), n, &val);
  2.1065 +  if (name) {
  2.1066 +    setobj2s(L, L->top, val);
  2.1067 +    api_incr_top(L);
  2.1068 +  }
  2.1069 +  lua_unlock(L);
  2.1070 +  return name;
  2.1071 +}
  2.1072 +
  2.1073 +
  2.1074 +LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
  2.1075 +  const char *name;
  2.1076 +  TValue *val;
  2.1077 +  StkId fi;
  2.1078 +  lua_lock(L);
  2.1079 +  fi = index2adr(L, funcindex);
  2.1080 +  api_checknelems(L, 1);
  2.1081 +  name = aux_upvalue(fi, n, &val);
  2.1082 +  if (name) {
  2.1083 +    L->top--;
  2.1084 +    setobj(L, val, L->top);
  2.1085 +    luaC_barrier(L, clvalue(fi), L->top);
  2.1086 +  }
  2.1087 +  lua_unlock(L);
  2.1088 +  return name;
  2.1089 +}
  2.1090 +

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/src/lua/lapi.h	Sat Mar 03 11:07:39 2012 -0600
     3.3 @@ -0,0 +1,16 @@
     3.4 +/*
     3.5 +** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
     3.6 +** Auxiliary functions from Lua API
     3.7 +** See Copyright Notice in lua.h
     3.8 +*/
     3.9 +
    3.10 +#ifndef lapi_h
    3.11 +#define lapi_h
    3.12 +
    3.13 +
    3.14 +#include "lobject.h"
    3.15 +
    3.16 +
    3.17 +LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
    3.18 +
    3.19 +#endif

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/src/lua/lauxlib.c	Sat Mar 03 11:07:39 2012 -0600
     4.3 @@ -0,0 +1,652 @@
     4.4 +/*
     4.5 +** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $
     4.6 +** Auxiliary functions for building Lua libraries
     4.7 +** See Copyright Notice in lua.h
     4.8 +*/
     4.9 +
    4.10 +
    4.11 +#include <ctype.h>
    4.12 +#include <errno.h>
    4.13 +#include <stdarg.h>
    4.14 +#include <stdio.h>
    4.15 +#include <stdlib.h>
    4.16 +#include <string.h>
    4.17 +
    4.18 +
    4.19 +/* This file uses only the official API of Lua.
    4.20 +** Any function declared here could be written as an application function.
    4.21 +*/
    4.22 +
    4.23 +#define lauxlib_c
    4.24 +#define LUA_LIB
    4.25 +
    4.26 +#include "lua.h"
    4.27 +
    4.28 +#include "lauxlib.h"
    4.29 +
    4.30 +
    4.31 +#define FREELIST_REF	0	/* free list of references */
    4.32 +
    4.33 +
    4.34 +/* convert a stack index to positive */
    4.35 +#define abs_index(L, i)		((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
    4.36 +					lua_gettop(L) + (i) + 1)
    4.37 +
    4.38 +
    4.39 +/*
    4.40 +** {======================================================
    4.41 +** Error-report functions
    4.42 +** =======================================================
    4.43 +*/
    4.44 +
    4.45 +
    4.46 +LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
    4.47 +  lua_Debug ar;
    4.48 +  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
    4.49 +    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
    4.50 +  lua_getinfo(L, "n", &ar);
    4.51 +  if (strcmp(ar.namewhat, "method") == 0) {
    4.52 +    narg--;  /* do not count `self' */
    4.53 +    if (narg == 0)  /* error is in the self argument itself? */
    4.54 +      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
    4.55 +                           ar.name, extramsg);
    4.56 +  }
    4.57 +  if (ar.name == NULL)
    4.58 +    ar.name = "?";
    4.59 +  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
    4.60 +                        narg, ar.name, extramsg);
    4.61 +}
    4.62 +
    4.63 +
    4.64 +LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
    4.65 +  const char *msg = lua_pushfstring(L, "%s expected, got %s",
    4.66 +                                    tname, luaL_typename(L, narg));
    4.67 +  return luaL_argerror(L, narg, msg);
    4.68 +}
    4.69 +
    4.70 +
    4.71 +static void tag_error (lua_State *L, int narg, int tag) {
    4.72 +  luaL_typerror(L, narg, lua_typename(L, tag));
    4.73 +}
    4.74 +
    4.75 +
    4.76 +LUALIB_API void luaL_where (lua_State *L, int level) {
    4.77 +  lua_Debug ar;
    4.78 +  if (lua_getstack(L, level, &ar)) {  /* check function at level */
    4.79 +    lua_getinfo(L, "Sl", &ar);  /* get info about it */
    4.80 +    if (ar.currentline > 0) {  /* is there info? */
    4.81 +      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
    4.82 +      return;
    4.83 +    }
    4.84 +  }
    4.85 +  lua_pushliteral(L, "");  /* else, no information available... */
    4.86 +}
    4.87 +
    4.88 +
    4.89 +LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
    4.90 +  va_list argp;
    4.91 +  va_start(argp, fmt);
    4.92 +  luaL_where(L, 1);
    4.93 +  lua_pushvfstring(L, fmt, argp);
    4.94 +  va_end(argp);
    4.95 +  lua_concat(L, 2);
    4.96 +  return lua_error(L);
    4.97 +}
    4.98 +
    4.99 +/* }====================================================== */
   4.100 +
   4.101 +
   4.102 +LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
   4.103 +                                 const char *const lst[]) {
   4.104 +  const char *name = (def) ? luaL_optstring(L, narg, def) :
   4.105 +                             luaL_checkstring(L, narg);
   4.106 +  int i;
   4.107 +  for (i=0; lst[i]; i++)
   4.108 +    if (strcmp(lst[i], name) == 0)
   4.109 +      return i;
   4.110 +  return luaL_argerror(L, narg,
   4.111 +                       lua_pushfstring(L, "invalid option " LUA_QS, name));
   4.112 +}
   4.113 +
   4.114 +
   4.115 +LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
   4.116 +  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
   4.117 +  if (!lua_isnil(L, -1))  /* name already in use? */
   4.118 +    return 0;  /* leave previous value on top, but return 0 */
   4.119 +  lua_pop(L, 1);
   4.120 +  lua_newtable(L);  /* create metatable */
   4.121 +  lua_pushvalue(L, -1);
   4.122 +  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
   4.123 +  return 1;
   4.124 +}
   4.125 +
   4.126 +
   4.127 +LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
   4.128 +  void *p = lua_touserdata(L, ud);
   4.129 +  if (p != NULL) {  /* value is a userdata? */
   4.130 +    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
   4.131 +      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
   4.132 +      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
   4.133 +        lua_pop(L, 2);  /* remove both metatables */
   4.134 +        return p;
   4.135 +      }
   4.136 +    }
   4.137 +  }
   4.138 +  luaL_typerror(L, ud, tname);  /* else error */
   4.139 +  return NULL;  /* to avoid warnings */
   4.140 +}
   4.141 +
   4.142 +
   4.143 +LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
   4.144 +  if (!lua_checkstack(L, space))
   4.145 +    luaL_error(L, "stack overflow (%s)", mes);
   4.146 +}
   4.147 +
   4.148 +
   4.149 +LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
   4.150 +  if (lua_type(L, narg) != t)
   4.151 +    tag_error(L, narg, t);
   4.152 +}
   4.153 +
   4.154 +
   4.155 +LUALIB_API void luaL_checkany (lua_State *L, int narg) {
   4.156 +  if (lua_type(L, narg) == LUA_TNONE)
   4.157 +    luaL_argerror(L, narg, "value expected");
   4.158 +}
   4.159 +
   4.160 +
   4.161 +LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
   4.162 +  const char *s = lua_tolstring(L, narg, len);
   4.163 +  if (!s) tag_error(L, narg, LUA_TSTRING);
   4.164 +  return s;
   4.165 +}
   4.166 +
   4.167 +
   4.168 +LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
   4.169 +                                        const char *def, size_t *len) {
   4.170 +  if (lua_isnoneornil(L, narg)) {
   4.171 +    if (len)
   4.172 +      *len = (def ? strlen(def) : 0);
   4.173 +    return def;
   4.174 +  }
   4.175 +  else return luaL_checklstring(L, narg, len);
   4.176 +}
   4.177 +
   4.178 +
   4.179 +LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
   4.180 +  lua_Number d = lua_tonumber(L, narg);
   4.181 +  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
   4.182 +    tag_error(L, narg, LUA_TNUMBER);
   4.183 +  return d;
   4.184 +}
   4.185 +
   4.186 +
   4.187 +LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
   4.188 +  return luaL_opt(L, luaL_checknumber, narg, def);
   4.189 +}
   4.190 +
   4.191 +
   4.192 +LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
   4.193 +  lua_Integer d = lua_tointeger(L, narg);
   4.194 +  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
   4.195 +    tag_error(L, narg, LUA_TNUMBER);
   4.196 +  return d;
   4.197 +}
   4.198 +
   4.199 +
   4.200 +LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
   4.201 +                                                      lua_Integer def) {
   4.202 +  return luaL_opt(L, luaL_checkinteger, narg, def);
   4.203 +}
   4.204 +
   4.205 +
   4.206 +LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
   4.207 +  if (!lua_getmetatable(L, obj))  /* no metatable? */
   4.208 +    return 0;
   4.209 +  lua_pushstring(L, event);
   4.210 +  lua_rawget(L, -2);
   4.211 +  if (lua_isnil(L, -1)) {
   4.212 +    lua_pop(L, 2);  /* remove metatable and metafield */
   4.213 +    return 0;
   4.214 +  }
   4.215 +  else {
   4.216 +    lua_remove(L, -2);  /* remove only metatable */
   4.217 +    return 1;
   4.218 +  }
   4.219 +}
   4.220 +
   4.221 +
   4.222 +LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
   4.223 +  obj = abs_index(L, obj);
   4.224 +  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
   4.225 +    return 0;
   4.226 +  lua_pushvalue(L, obj);
   4.227 +  lua_call(L, 1, 1);
   4.228 +  return 1;
   4.229 +}
   4.230 +
   4.231 +
   4.232 +LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
   4.233 +                                const luaL_Reg *l) {
   4.234 +  luaI_openlib(L, libname, l, 0);
   4.235 +}
   4.236 +
   4.237 +
   4.238 +static int libsize (const luaL_Reg *l) {
   4.239 +  int size = 0;
   4.240 +  for (; l->name; l++) size++;
   4.241 +  return size;
   4.242 +}
   4.243 +
   4.244 +
   4.245 +LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
   4.246 +                              const luaL_Reg *l, int nup) {
   4.247 +  if (libname) {
   4.248 +    int size = libsize(l);
   4.249 +    /* check whether lib already exists */
   4.250 +    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
   4.251 +    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
   4.252 +    if (!lua_istable(L, -1)) {  /* not found? */
   4.253 +      lua_pop(L, 1);  /* remove previous result */
   4.254 +      /* try global variable (and create one if it does not exist) */
   4.255 +      if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
   4.256 +        luaL_error(L, "name conflict for module " LUA_QS, libname);
   4.257 +      lua_pushvalue(L, -1);
   4.258 +      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */
   4.259 +    }
   4.260 +    lua_remove(L, -2);  /* remove _LOADED table */
   4.261 +    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
   4.262 +  }
   4.263 +  for (; l->name; l++) {
   4.264 +    int i;
   4.265 +    for (i=0; i<nup; i++)  /* copy upvalues to the top */
   4.266 +      lua_pushvalue(L, -nup);
   4.267 +    lua_pushcclosure(L, l->func, nup);
   4.268 +    lua_setfield(L, -(nup+2), l->name);
   4.269 +  }
   4.270 +  lua_pop(L, nup);  /* remove upvalues */
   4.271 +}
   4.272 +
   4.273 +
   4.274 +
   4.275 +/*
   4.276 +** {======================================================
   4.277 +** getn-setn: size for arrays
   4.278 +** =======================================================
   4.279 +*/
   4.280 +
   4.281 +#if defined(LUA_COMPAT_GETN)
   4.282 +
   4.283 +static int checkint (lua_State *L, int topop) {
   4.284 +  int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;
   4.285 +  lua_pop(L, topop);
   4.286 +  return n;
   4.287 +}
   4.288 +
   4.289 +
   4.290 +static void getsizes (lua_State *L) {
   4.291 +  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");
   4.292 +  if (lua_isnil(L, -1)) {  /* no `size' table? */
   4.293 +    lua_pop(L, 1);  /* remove nil */
   4.294 +    lua_newtable(L);  /* create it */
   4.295 +    lua_pushvalue(L, -1);  /* `size' will be its own metatable */
   4.296 +    lua_setmetatable(L, -2);
   4.297 +    lua_pushliteral(L, "kv");
   4.298 +    lua_setfield(L, -2, "__mode");  /* metatable(N).__mode = "kv" */
   4.299 +    lua_pushvalue(L, -1);
   4.300 +    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");  /* store in register */
   4.301 +  }
   4.302 +}
   4.303 +
   4.304 +
   4.305 +LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
   4.306 +  t = abs_index(L, t);
   4.307 +  lua_pushliteral(L, "n");
   4.308 +  lua_rawget(L, t);
   4.309 +  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */
   4.310 +    lua_pushliteral(L, "n");  /* use it */
   4.311 +    lua_pushinteger(L, n);
   4.312 +    lua_rawset(L, t);
   4.313 +  }
   4.314 +  else {  /* use `sizes' */
   4.315 +    getsizes(L);
   4.316 +    lua_pushvalue(L, t);
   4.317 +    lua_pushinteger(L, n);
   4.318 +    lua_rawset(L, -3);  /* sizes[t] = n */
   4.319 +    lua_pop(L, 1);  /* remove `sizes' */
   4.320 +  }
   4.321 +}
   4.322 +
   4.323 +
   4.324 +LUALIB_API int luaL_getn (lua_State *L, int t) {
   4.325 +  int n;
   4.326 +  t = abs_index(L, t);
   4.327 +  lua_pushliteral(L, "n");  /* try t.n */
   4.328 +  lua_rawget(L, t);
   4.329 +  if ((n = checkint(L, 1)) >= 0) return n;
   4.330 +  getsizes(L);  /* else try sizes[t] */
   4.331 +  lua_pushvalue(L, t);
   4.332 +  lua_rawget(L, -2);
   4.333 +  if ((n = checkint(L, 2)) >= 0) return n;
   4.334 +  return (int)lua_objlen(L, t);
   4.335 +}
   4.336 +
   4.337 +#endif
   4.338 +
   4.339 +/* }====================================================== */
   4.340 +
   4.341 +
   4.342 +
   4.343 +LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
   4.344 +                                                               const char *r) {
   4.345 +  const char *wild;
   4.346 +  size_t l = strlen(p);
   4.347 +  luaL_Buffer b;
   4.348 +  luaL_buffinit(L, &b);
   4.349 +  while ((wild = strstr(s, p)) != NULL) {
   4.350 +    luaL_addlstring(&b, s, wild - s);  /* push prefix */
   4.351 +    luaL_addstring(&b, r);  /* push replacement in place of pattern */
   4.352 +    s = wild + l;  /* continue after `p' */
   4.353 +  }
   4.354 +  luaL_addstring(&b, s);  /* push last suffix */
   4.355 +  luaL_pushresult(&b);
   4.356 +  return lua_tostring(L, -1);
   4.357 +}
   4.358 +
   4.359 +
   4.360 +LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
   4.361 +                                       const char *fname, int szhint) {
   4.362 +  const char *e;
   4.363 +  lua_pushvalue(L, idx);
   4.364 +  do {
   4.365 +    e = strchr(fname, '.');
   4.366 +    if (e == NULL) e = fname + strlen(fname);
   4.367 +    lua_pushlstring(L, fname, e - fname);
   4.368 +    lua_rawget(L, -2);
   4.369 +    if (lua_isnil(L, -1)) {  /* no such field? */
   4.370 +      lua_pop(L, 1);  /* remove this nil */
   4.371 +      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
   4.372 +      lua_pushlstring(L, fname, e - fname);
   4.373 +      lua_pushvalue(L, -2);
   4.374 +      lua_settable(L, -4);  /* set new table into field */
   4.375 +    }
   4.376 +    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
   4.377 +      lua_pop(L, 2);  /* remove table and value */
   4.378 +      return fname;  /* return problematic part of the name */
   4.379 +    }
   4.380 +    lua_remove(L, -2);  /* remove previous table */
   4.381 +    fname = e + 1;
   4.382 +  } while (*e == '.');
   4.383 +  return NULL;
   4.384 +}
   4.385 +
   4.386 +
   4.387 +
   4.388 +/*
   4.389 +** {======================================================
   4.390 +** Generic Buffer manipulation
   4.391 +** =======================================================
   4.392 +*/
   4.393 +
   4.394 +
   4.395 +#define bufflen(B)	((B)->p - (B)->buffer)
   4.396 +#define bufffree(B)	((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
   4.397 +
   4.398 +#define LIMIT	(LUA_MINSTACK/2)
   4.399 +
   4.400 +
   4.401 +static int emptybuffer (luaL_Buffer *B) {
   4.402 +  size_t l = bufflen(B);
   4.403 +  if (l == 0) return 0;  /* put nothing on stack */
   4.404 +  else {
   4.405 +    lua_pushlstring(B->L, B->buffer, l);
   4.406 +    B->p = B->buffer;
   4.407 +    B->lvl++;
   4.408 +    return 1;
   4.409 +  }
   4.410 +}
   4.411 +
   4.412 +
   4.413 +static void adjuststack (luaL_Buffer *B) {
   4.414 +  if (B->lvl > 1) {
   4.415 +    lua_State *L = B->L;
   4.416 +    int toget = 1;  /* number of levels to concat */
   4.417 +    size_t toplen = lua_strlen(L, -1);
   4.418 +    do {
   4.419 +      size_t l = lua_strlen(L, -(toget+1));
   4.420 +      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
   4.421 +        toplen += l;
   4.422 +        toget++;
   4.423 +      }
   4.424 +      else break;
   4.425 +    } while (toget < B->lvl);
   4.426 +    lua_concat(L, toget);
   4.427 +    B->lvl = B->lvl - toget + 1;
   4.428 +  }
   4.429 +}
   4.430 +
   4.431 +
   4.432 +LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
   4.433 +  if (emptybuffer(B))
   4.434 +    adjuststack(B);
   4.435 +  return B->buffer;
   4.436 +}
   4.437 +
   4.438 +
   4.439 +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
   4.440 +  while (l--)
   4.441 +    luaL_addchar(B, *s++);
   4.442 +}
   4.443 +
   4.444 +
   4.445 +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
   4.446 +  luaL_addlstring(B, s, strlen(s));
   4.447 +}
   4.448 +
   4.449 +
   4.450 +LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
   4.451 +  emptybuffer(B);
   4.452 +  lua_concat(B->L, B->lvl);
   4.453 +  B->lvl = 1;
   4.454 +}
   4.455 +
   4.456 +
   4.457 +LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
   4.458 +  lua_State *L = B->L;
   4.459 +  size_t vl;
   4.460 +  const char *s = lua_tolstring(L, -1, &vl);
   4.461 +  if (vl <= bufffree(B)) {  /* fit into buffer? */
   4.462 +    memcpy(B->p, s, vl);  /* put it there */
   4.463 +    B->p += vl;
   4.464 +    lua_pop(L, 1);  /* remove from stack */
   4.465 +  }
   4.466 +  else {
   4.467 +    if (emptybuffer(B))
   4.468 +      lua_insert(L, -2);  /* put buffer before new value */
   4.469 +    B->lvl++;  /* add new value into B stack */
   4.470 +    adjuststack(B);
   4.471 +  }
   4.472 +}
   4.473 +
   4.474 +
   4.475 +LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
   4.476 +  B->L = L;
   4.477 +  B->p = B->buffer;
   4.478 +  B->lvl = 0;
   4.479 +}
   4.480 +
   4.481 +/* }====================================================== */
   4.482 +
   4.483 +
   4.484 +LUALIB_API int luaL_ref (lua_State *L, int t) {
   4.485 +  int ref;
   4.486 +  t = abs_index(L, t);
   4.487 +  if (lua_isnil(L, -1)) {
   4.488 +    lua_pop(L, 1);  /* remove from stack */
   4.489 +    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
   4.490 +  }
   4.491 +  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
   4.492 +  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
   4.493 +  lua_pop(L, 1);  /* remove it from stack */
   4.494 +  if (ref != 0) {  /* any free element? */
   4.495 +    lua_rawgeti(L, t, ref);  /* remove it from list */
   4.496 +    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
   4.497 +  }
   4.498 +  else {  /* no free elements */
   4.499 +    ref = (int)lua_objlen(L, t);
   4.500 +    ref++;  /* create new reference */
   4.501 +  }
   4.502 +  lua_rawseti(L, t, ref);
   4.503 +  return ref;
   4.504 +}
   4.505 +
   4.506 +
   4.507 +LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
   4.508 +  if (ref >= 0) {
   4.509 +    t = abs_index(L, t);
   4.510 +    lua_rawgeti(L, t, FREELIST_REF);
   4.511 +    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
   4.512 +    lua_pushinteger(L, ref);
   4.513 +    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
   4.514 +  }
   4.515 +}
   4.516 +
   4.517 +
   4.518 +
   4.519 +/*
   4.520 +** {======================================================
   4.521 +** Load functions
   4.522 +** =======================================================
   4.523 +*/
   4.524 +
   4.525 +typedef struct LoadF {
   4.526 +  int extraline;
   4.527 +  FILE *f;
   4.528 +  char buff[LUAL_BUFFERSIZE];
   4.529 +} LoadF;
   4.530 +
   4.531 +
   4.532 +static const char *getF (lua_State *L, void *ud, size_t *size) {
   4.533 +  LoadF *lf = (LoadF *)ud;
   4.534 +  (void)L;
   4.535 +  if (lf->extraline) {
   4.536 +    lf->extraline = 0;
   4.537 +    *size = 1;
   4.538 +    return "\n";
   4.539 +  }
   4.540 +  if (feof(lf->f)) return NULL;
   4.541 +  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
   4.542 +  return (*size > 0) ? lf->buff : NULL;
   4.543 +}
   4.544 +
   4.545 +
   4.546 +static int errfile (lua_State *L, const char *what, int fnameindex) {
   4.547 +  const char *serr = strerror(errno);
   4.548 +  const char *filename = lua_tostring(L, fnameindex) + 1;
   4.549 +  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
   4.550 +  lua_remove(L, fnameindex);
   4.551 +  return LUA_ERRFILE;
   4.552 +}
   4.553 +
   4.554 +
   4.555 +LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
   4.556 +  LoadF lf;
   4.557 +  int status, readstatus;
   4.558 +  int c;
   4.559 +  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
   4.560 +  lf.extraline = 0;
   4.561 +  if (filename == NULL) {
   4.562 +    lua_pushliteral(L, "=stdin");
   4.563 +    lf.f = stdin;
   4.564 +  }
   4.565 +  else {
   4.566 +    lua_pushfstring(L, "@%s", filename);
   4.567 +    lf.f = fopen(filename, "r");
   4.568 +    if (lf.f == NULL) return errfile(L, "open", fnameindex);
   4.569 +  }
   4.570 +  c = getc(lf.f);
   4.571 +  if (c == '#') {  /* Unix exec. file? */
   4.572 +    lf.extraline = 1;
   4.573 +    while ((c = getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */
   4.574 +    if (c == '\n') c = getc(lf.f);
   4.575 +  }
   4.576 +  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
   4.577 +    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
   4.578 +    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
   4.579 +    /* skip eventual `#!...' */
   4.580 +   while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
   4.581 +    lf.extraline = 0;
   4.582 +  }
   4.583 +  ungetc(c, lf.f);
   4.584 +  status = lua_load(L, getF, &lf, lua_tostring(L, -1));
   4.585 +  readstatus = ferror(lf.f);
   4.586 +  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
   4.587 +  if (readstatus) {
   4.588 +    lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
   4.589 +    return errfile(L, "read", fnameindex);
   4.590 +  }
   4.591 +  lua_remove(L, fnameindex);
   4.592 +  return status;
   4.593 +}
   4.594 +
   4.595 +
   4.596 +typedef struct LoadS {
   4.597 +  const char *s;
   4.598 +  size_t size;
   4.599 +} LoadS;
   4.600 +
   4.601 +
   4.602 +static const char *getS (lua_State *L, void *ud, size_t *size) {
   4.603 +  LoadS *ls = (LoadS *)ud;
   4.604 +  (void)L;
   4.605 +  if (ls->size == 0) return NULL;
   4.606 +  *size = ls->size;
   4.607 +  ls->size = 0;
   4.608 +  return ls->s;
   4.609 +}
   4.610 +
   4.611 +
   4.612 +LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
   4.613 +                                const char *name) {
   4.614 +  LoadS ls;
   4.615 +  ls.s = buff;
   4.616 +  ls.size = size;
   4.617 +  return lua_load(L, getS, &ls, name);
   4.618 +}
   4.619 +
   4.620 +
   4.621 +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {
   4.622 +  return luaL_loadbuffer(L, s, strlen(s), s);
   4.623 +}
   4.624 +
   4.625 +
   4.626 +
   4.627 +/* }====================================================== */
   4.628 +
   4.629 +
   4.630 +static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
   4.631 +  (void)ud;
   4.632 +  (void)osize;
   4.633 +  if (nsize == 0) {
   4.634 +    free(ptr);
   4.635 +    return NULL;
   4.636 +  }
   4.637 +  else
   4.638 +    return realloc(ptr, nsize);
   4.639 +}
   4.640 +
   4.641 +
   4.642 +static int panic (lua_State *L) {
   4.643 +  (void)L;  /* to avoid warnings */
   4.644 +  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
   4.645 +                   lua_tostring(L, -1));
   4.646 +  return 0;
   4.647 +}
   4.648 +
   4.649 +
   4.650 +LUALIB_API lua_State *luaL_newstate (void) {
   4.651 +  lua_State *L = lua_newstate(l_alloc, NULL);
   4.652 +  if (L) lua_atpanic(L, &panic);
   4.653 +  return L;
   4.654 +}
   4.655 +

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/src/lua/lauxlib.h	Sat Mar 03 11:07:39 2012 -0600
     5.3 @@ -0,0 +1,174 @@
     5.4 +/*
     5.5 +** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
     5.6 +** Auxiliary functions for building Lua libraries
     5.7 +** See Copyright Notice in lua.h
     5.8 +*/
     5.9 +
    5.10 +
    5.11 +#ifndef lauxlib_h
    5.12 +#define lauxlib_h
    5.13 +
    5.14 +
    5.15 +#include <stddef.h>
    5.16 +#include <stdio.h>
    5.17 +
    5.18 +#include "lua.h"
    5.19 +
    5.20 +
    5.21 +#if defined(LUA_COMPAT_GETN)
    5.22 +LUALIB_API int (luaL_getn) (lua_State *L, int t);
    5.23 +LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
    5.24 +#else
    5.25 +#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
    5.26 +#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
    5.27 +#endif
    5.28 +
    5.29 +#if defined(LUA_COMPAT_OPENLIB)
    5.30 +#define luaI_openlib	luaL_openlib
    5.31 +#endif
    5.32 +
    5.33 +
    5.34 +/* extra error code for `luaL_load' */
    5.35 +#define LUA_ERRFILE     (LUA_ERRERR+1)
    5.36 +
    5.37 +
    5.38 +typedef struct luaL_Reg {
    5.39 +  const char *name;
    5.40 +  lua_CFunction func;
    5.41 +} luaL_Reg;
    5.42 +
    5.43 +
    5.44 +
    5.45 +LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
    5.46 +                                const luaL_Reg *l, int nup);
    5.47 +LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
    5.48 +                                const luaL_Reg *l);
    5.49 +LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
    5.50 +LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
    5.51 +LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
    5.52 +LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
    5.53 +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
    5.54 +                                                          size_t *l);
    5.55 +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
    5.56 +                                          const char *def, size_t *l);
    5.57 +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
    5.58 +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
    5.59 +
    5.60 +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
    5.61 +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
    5.62 +                                          lua_Integer def);
    5.63 +
    5.64 +LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
    5.65 +LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
    5.66 +LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
    5.67 +
    5.68 +LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
    5.69 +LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
    5.70 +
    5.71 +LUALIB_API void (luaL_where) (lua_State *L, int lvl);
    5.72 +LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
    5.73 +
    5.74 +LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
    5.75 +                                   const char *const lst[]);
    5.76 +
    5.77 +LUALIB_API int (luaL_ref) (lua_State *L, int t);
    5.78 +LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
    5.79 +
    5.80 +LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
    5.81 +LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
    5.82 +                                  const char *name);
    5.83 +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
    5.84 +
    5.85 +LUALIB_API lua_State *(luaL_newstate) (void);
    5.86 +
    5.87 +
    5.88 +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
    5.89 +                                                  const char *r);
    5.90 +
    5.91 +LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
    5.92 +                                         const char *fname, int szhint);
    5.93 +
    5.94 +
    5.95 +
    5.96 +
    5.97 +/*
    5.98 +** ===============================================================
    5.99 +** some useful macros
   5.100 +** ===============================================================
   5.101 +*/
   5.102 +
   5.103 +#define luaL_argcheck(L, cond,numarg,extramsg)	\
   5.104 +		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
   5.105 +#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
   5.106 +#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
   5.107 +#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
   5.108 +#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
   5.109 +#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
   5.110 +#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
   5.111 +
   5.112 +#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
   5.113 +
   5.114 +#define luaL_dofile(L, fn) \
   5.115 +	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
   5.116 +
   5.117 +#define luaL_dostring(L, s) \
   5.118 +	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
   5.119 +
   5.120 +#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
   5.121 +
   5.122 +#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
   5.123 +
   5.124 +/*
   5.125 +** {======================================================
   5.126 +** Generic Buffer manipulation
   5.127 +** =======================================================
   5.128 +*/
   5.129 +
   5.130 +
   5.131 +
   5.132 +typedef struct luaL_Buffer {
   5.133 +  char *p;			/* current position in buffer */
   5.134 +  int lvl;  /* number of strings in the stack (level) */
   5.135 +  lua_State *L;
   5.136 +  char buffer[LUAL_BUFFERSIZE];
   5.137 +} luaL_Buffer;
   5.138 +
   5.139 +#define luaL_addchar(B,c) \
   5.140 +  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
   5.141 +   (*(B)->p++ = (char)(c)))
   5.142 +
   5.143 +/* compatibility only */
   5.144 +#define luaL_putchar(B,c)	luaL_addchar(B,c)
   5.145 +
   5.146 +#define luaL_addsize(B,n)	((B)->p += (n))
   5.147 +
   5.148 +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
   5.149 +LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
   5.150 +LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
   5.151 +LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
   5.152 +LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
   5.153 +LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
   5.154 +
   5.155 +
   5.156 +/* }====================================================== */
   5.157 +
   5.158 +
   5.159 +/* compatibility with ref system */
   5.160 +
   5.161 +/* pre-defined references */
   5.162 +#define LUA_NOREF       (-2)
   5.163 +#define LUA_REFNIL      (-1)
   5.164 +
   5.165 +#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
   5.166 +      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
   5.167 +
   5.168 +#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
   5.169 +
   5.170 +#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
   5.171 +
   5.172 +
   5.173 +#define luaL_reg	luaL_Reg
   5.174 +
   5.175 +#endif
   5.176 +
   5.177 +

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/src/lua/lbaselib.c	Sat Mar 03 11:07:39 2012 -0600
     6.3 @@ -0,0 +1,653 @@
     6.4 +/*
     6.5 +** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
     6.6 +** Basic library
     6.7 +** See Copyright Notice in lua.h
     6.8 +*/
     6.9 +
    6.10 +
    6.11 +
    6.12 +#include <ctype.h>
    6.13 +#include <stdio.h>
    6.14 +#include <stdlib.h>
    6.15 +#include <string.h>
    6.16 +
    6.17 +#define lbaselib_c
    6.18 +#define LUA_LIB
    6.19 +
    6.20 +#include "lua.h"
    6.21 +
    6.22 +#include "lauxlib.h"
    6.23 +#include "lualib.h"
    6.24 +
    6.25 +
    6.26 +
    6.27 +
    6.28 +/*
    6.29 +** If your system does not support `stdout', you can just remove this function.
    6.30 +** If you need, you can define your own `print' function, following this
    6.31 +** model but changing `fputs' to put the strings at a proper place
    6.32 +** (a console window or a log file, for instance).
    6.33 +*/
    6.34 +static int luaB_print (lua_State *L) {
    6.35 +  int n = lua_gettop(L);  /* number of arguments */
    6.36 +  int i;
    6.37 +  lua_getglobal(L, "tostring");
    6.38 +  for (i=1; i<=n; i++) {
    6.39 +    const char *s;
    6.40 +    lua_pushvalue(L, -1);  /* function to be called */
    6.41 +    lua_pushvalue(L, i);   /* value to print */
    6.42 +    lua_call(L, 1, 1);
    6.43 +    s = lua_tostring(L, -1);  /* get result */
    6.44 +    if (s == NULL)
    6.45 +      return luaL_error(L, LUA_QL("tostring") " must return a string to "
    6.46 +                           LUA_QL("print"));
    6.47 +    if (i>1) fputs("\t", stdout);
    6.48 +    fputs(s, stdout);
    6.49 +    lua_pop(L, 1);  /* pop result */
    6.50 +  }
    6.51 +  fputs("\n", stdout);
    6.52 +  return 0;
    6.53 +}
    6.54 +
    6.55 +
    6.56 +static int luaB_tonumber (lua_State *L) {
    6.57 +  int base = luaL_optint(L, 2, 10);
    6.58 +  if (base == 10) {  /* standard conversion */
    6.59 +    luaL_checkany(L, 1);
    6.60 +    if (lua_isnumber(L, 1)) {
    6.61 +      lua_pushnumber(L, lua_tonumber(L, 1));
    6.62 +      return 1;
    6.63 +    }
    6.64 +  }
    6.65 +  else {
    6.66 +    const char *s1 = luaL_checkstring(L, 1);
    6.67 +    char *s2;
    6.68 +    unsigned long n;
    6.69 +    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
    6.70 +    n = strtoul(s1, &s2, base);
    6.71 +    if (s1 != s2) {  /* at least one valid digit? */
    6.72 +      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
    6.73 +      if (*s2 == '\0') {  /* no invalid trailing characters? */
    6.74 +        lua_pushnumber(L, (lua_Number)n);
    6.75 +        return 1;
    6.76 +      }
    6.77 +    }
    6.78 +  }
    6.79 +  lua_pushnil(L);  /* else not a number */
    6.80 +  return 1;
    6.81 +}
    6.82 +
    6.83 +
    6.84 +static int luaB_error (lua_State *L) {
    6.85 +  int level = luaL_optint(L, 2, 1);
    6.86 +  lua_settop(L, 1);
    6.87 +  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
    6.88 +    luaL_where(L, level);
    6.89 +    lua_pushvalue(L, 1);
    6.90 +    lua_concat(L, 2);
    6.91 +  }
    6.92 +  return lua_error(L);
    6.93 +}
    6.94 +
    6.95 +
    6.96 +static int luaB_getmetatable (lua_State *L) {
    6.97 +  luaL_checkany(L, 1);
    6.98 +  if (!lua_getmetatable(L, 1)) {
    6.99 +    lua_pushnil(L);
   6.100 +    return 1;  /* no metatable */
   6.101 +  }
   6.102 +  luaL_getmetafield(L, 1, "__metatable");
   6.103 +  return 1;  /* returns either __metatable field (if present) or metatable */
   6.104 +}
   6.105 +
   6.106 +
   6.107 +static int luaB_setmetatable (lua_State *L) {
   6.108 +  int t = lua_type(L, 2);
   6.109 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.110 +  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
   6.111 +                    "nil or table expected");
   6.112 +  if (luaL_getmetafield(L, 1, "__metatable"))
   6.113 +    luaL_error(L, "cannot change a protected metatable");
   6.114 +  lua_settop(L, 2);
   6.115 +  lua_setmetatable(L, 1);
   6.116 +  return 1;
   6.117 +}
   6.118 +
   6.119 +
   6.120 +static void getfunc (lua_State *L, int opt) {
   6.121 +  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
   6.122 +  else {
   6.123 +    lua_Debug ar;
   6.124 +    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
   6.125 +    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
   6.126 +    if (lua_getstack(L, level, &ar) == 0)
   6.127 +      luaL_argerror(L, 1, "invalid level");
   6.128 +    lua_getinfo(L, "f", &ar);
   6.129 +    if (lua_isnil(L, -1))
   6.130 +      luaL_error(L, "no function environment for tail call at level %d",
   6.131 +                    level);
   6.132 +  }
   6.133 +}
   6.134 +
   6.135 +
   6.136 +static int luaB_getfenv (lua_State *L) {
   6.137 +  getfunc(L, 1);
   6.138 +  if (lua_iscfunction(L, -1))  /* is a C function? */
   6.139 +    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
   6.140 +  else
   6.141 +    lua_getfenv(L, -1);
   6.142 +  return 1;
   6.143 +}
   6.144 +
   6.145 +
   6.146 +static int luaB_setfenv (lua_State *L) {
   6.147 +  luaL_checktype(L, 2, LUA_TTABLE);
   6.148 +  getfunc(L, 0);
   6.149 +  lua_pushvalue(L, 2);
   6.150 +  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
   6.151 +    /* change environment of current thread */
   6.152 +    lua_pushthread(L);
   6.153 +    lua_insert(L, -2);
   6.154 +    lua_setfenv(L, -2);
   6.155 +    return 0;
   6.156 +  }
   6.157 +  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
   6.158 +    luaL_error(L,
   6.159 +          LUA_QL("setfenv") " cannot change environment of given object");
   6.160 +  return 1;
   6.161 +}
   6.162 +
   6.163 +
   6.164 +static int luaB_rawequal (lua_State *L) {
   6.165 +  luaL_checkany(L, 1);
   6.166 +  luaL_checkany(L, 2);
   6.167 +  lua_pushboolean(L, lua_rawequal(L, 1, 2));
   6.168 +  return 1;
   6.169 +}
   6.170 +
   6.171 +
   6.172 +static int luaB_rawget (lua_State *L) {
   6.173 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.174 +  luaL_checkany(L, 2);
   6.175 +  lua_settop(L, 2);
   6.176 +  lua_rawget(L, 1);
   6.177 +  return 1;
   6.178 +}
   6.179 +
   6.180 +static int luaB_rawset (lua_State *L) {
   6.181 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.182 +  luaL_checkany(L, 2);
   6.183 +  luaL_checkany(L, 3);
   6.184 +  lua_settop(L, 3);
   6.185 +  lua_rawset(L, 1);
   6.186 +  return 1;
   6.187 +}
   6.188 +
   6.189 +
   6.190 +static int luaB_gcinfo (lua_State *L) {
   6.191 +  lua_pushinteger(L, lua_getgccount(L));
   6.192 +  return 1;
   6.193 +}
   6.194 +
   6.195 +
   6.196 +static int luaB_collectgarbage (lua_State *L) {
   6.197 +  static const char *const opts[] = {"stop", "restart", "collect",
   6.198 +    "count", "step", "setpause", "setstepmul", NULL};
   6.199 +  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
   6.200 +    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
   6.201 +  int o = luaL_checkoption(L, 1, "collect", opts);
   6.202 +  int ex = luaL_optint(L, 2, 0);
   6.203 +  int res = lua_gc(L, optsnum[o], ex);
   6.204 +  switch (optsnum[o]) {
   6.205 +    case LUA_GCCOUNT: {
   6.206 +      int b = lua_gc(L, LUA_GCCOUNTB, 0);
   6.207 +      lua_pushnumber(L, res + ((lua_Number)b/1024));
   6.208 +      return 1;
   6.209 +    }
   6.210 +    case LUA_GCSTEP: {
   6.211 +      lua_pushboolean(L, res);
   6.212 +      return 1;
   6.213 +    }
   6.214 +    default: {
   6.215 +      lua_pushnumber(L, res);
   6.216 +      return 1;
   6.217 +    }
   6.218 +  }
   6.219 +}
   6.220 +
   6.221 +
   6.222 +static int luaB_type (lua_State *L) {
   6.223 +  luaL_checkany(L, 1);
   6.224 +  lua_pushstring(L, luaL_typename(L, 1));
   6.225 +  return 1;
   6.226 +}
   6.227 +
   6.228 +
   6.229 +static int luaB_next (lua_State *L) {
   6.230 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.231 +  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
   6.232 +  if (lua_next(L, 1))
   6.233 +    return 2;
   6.234 +  else {
   6.235 +    lua_pushnil(L);
   6.236 +    return 1;
   6.237 +  }
   6.238 +}
   6.239 +
   6.240 +
   6.241 +static int luaB_pairs (lua_State *L) {
   6.242 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.243 +  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
   6.244 +  lua_pushvalue(L, 1);  /* state, */
   6.245 +  lua_pushnil(L);  /* and initial value */
   6.246 +  return 3;
   6.247 +}
   6.248 +
   6.249 +
   6.250 +static int ipairsaux (lua_State *L) {
   6.251 +  int i = luaL_checkint(L, 2);
   6.252 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.253 +  i++;  /* next value */
   6.254 +  lua_pushinteger(L, i);
   6.255 +  lua_rawgeti(L, 1, i);
   6.256 +  return (lua_isnil(L, -1)) ? 0 : 2;
   6.257 +}
   6.258 +
   6.259 +
   6.260 +static int luaB_ipairs (lua_State *L) {
   6.261 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.262 +  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
   6.263 +  lua_pushvalue(L, 1);  /* state, */
   6.264 +  lua_pushinteger(L, 0);  /* and initial value */
   6.265 +  return 3;
   6.266 +}
   6.267 +
   6.268 +
   6.269 +static int load_aux (lua_State *L, int status) {
   6.270 +  if (status == 0)  /* OK? */
   6.271 +    return 1;
   6.272 +  else {
   6.273 +    lua_pushnil(L);
   6.274 +    lua_insert(L, -2);  /* put before error message */
   6.275 +    return 2;  /* return nil plus error message */
   6.276 +  }
   6.277 +}
   6.278 +
   6.279 +
   6.280 +static int luaB_loadstring (lua_State *L) {
   6.281 +  size_t l;
   6.282 +  const char *s = luaL_checklstring(L, 1, &l);
   6.283 +  const char *chunkname = luaL_optstring(L, 2, s);
   6.284 +  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
   6.285 +}
   6.286 +
   6.287 +
   6.288 +static int luaB_loadfile (lua_State *L) {
   6.289 +  const char *fname = luaL_optstring(L, 1, NULL);
   6.290 +  return load_aux(L, luaL_loadfile(L, fname));
   6.291 +}
   6.292 +
   6.293 +
   6.294 +/*
   6.295 +** Reader for generic `load' function: `lua_load' uses the
   6.296 +** stack for internal stuff, so the reader cannot change the
   6.297 +** stack top. Instead, it keeps its resulting string in a
   6.298 +** reserved slot inside the stack.
   6.299 +*/
   6.300 +static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
   6.301 +  (void)ud;  /* to avoid warnings */
   6.302 +  luaL_checkstack(L, 2, "too many nested functions");
   6.303 +  lua_pushvalue(L, 1);  /* get function */
   6.304 +  lua_call(L, 0, 1);  /* call it */
   6.305 +  if (lua_isnil(L, -1)) {
   6.306 +    *size = 0;
   6.307 +    return NULL;
   6.308 +  }
   6.309 +  else if (lua_isstring(L, -1)) {
   6.310 +    lua_replace(L, 3);  /* save string in a reserved stack slot */
   6.311 +    return lua_tolstring(L, 3, size);
   6.312 +  }
   6.313 +  else luaL_error(L, "reader function must return a string");
   6.314 +  return NULL;  /* to avoid warnings */
   6.315 +}
   6.316 +
   6.317 +
   6.318 +static int luaB_load (lua_State *L) {
   6.319 +  int status;
   6.320 +  const char *cname = luaL_optstring(L, 2, "=(load)");
   6.321 +  luaL_checktype(L, 1, LUA_TFUNCTION);
   6.322 +  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
   6.323 +  status = lua_load(L, generic_reader, NULL, cname);
   6.324 +  return load_aux(L, status);
   6.325 +}
   6.326 +
   6.327 +
   6.328 +static int luaB_dofile (lua_State *L) {
   6.329 +  const char *fname = luaL_optstring(L, 1, NULL);
   6.330 +  int n = lua_gettop(L);
   6.331 +  if (luaL_loadfile(L, fname) != 0) lua_error(L);
   6.332 +  lua_call(L, 0, LUA_MULTRET);
   6.333 +  return lua_gettop(L) - n;
   6.334 +}
   6.335 +
   6.336 +
   6.337 +static int luaB_assert (lua_State *L) {
   6.338 +  luaL_checkany(L, 1);
   6.339 +  if (!lua_toboolean(L, 1))
   6.340 +    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
   6.341 +  return lua_gettop(L);
   6.342 +}
   6.343 +
   6.344 +
   6.345 +static int luaB_unpack (lua_State *L) {
   6.346 +  int i, e, n;
   6.347 +  luaL_checktype(L, 1, LUA_TTABLE);
   6.348 +  i = luaL_optint(L, 2, 1);
   6.349 +  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
   6.350 +  if (i > e) return 0;  /* empty range */
   6.351 +  n = e - i + 1;  /* number of elements */
   6.352 +  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
   6.353 +    return luaL_error(L, "too many results to unpack");
   6.354 +  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
   6.355 +  while (i++ < e)  /* push arg[i + 1...e] */
   6.356 +    lua_rawgeti(L, 1, i);
   6.357 +  return n;
   6.358 +}
   6.359 +
   6.360 +
   6.361 +static int luaB_select (lua_State *L) {
   6.362 +  int n = lua_gettop(L);
   6.363 +  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
   6.364 +    lua_pushinteger(L, n-1);
   6.365 +    return 1;
   6.366 +  }
   6.367 +  else {
   6.368 +    int i = luaL_checkint(L, 1);
   6.369 +    if (i < 0) i = n + i;
   6.370 +    else if (i > n) i = n;
   6.371 +    luaL_argcheck(L, 1 <= i, 1, "index out of range");
   6.372 +    return n - i;
   6.373 +  }
   6.374 +}
   6.375 +
   6.376 +
   6.377 +static int luaB_pcall (lua_State *L) {
   6.378 +  int status;
   6.379 +  luaL_checkany(L, 1);
   6.380 +  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
   6.381 +  lua_pushboolean(L, (status == 0));
   6.382 +  lua_insert(L, 1);
   6.383 +  return lua_gettop(L);  /* return status + all results */
   6.384 +}
   6.385 +
   6.386 +
   6.387 +static int luaB_xpcall (lua_State *L) {
   6.388 +  int status;
   6.389 +  luaL_checkany(L, 2);
   6.390 +  lua_settop(L, 2);
   6.391 +  lua_insert(L, 1);  /* put error function under function to be called */
   6.392 +  status = lua_pcall(L, 0, LUA_MULTRET, 1);
   6.393 +  lua_pushboolean(L, (status == 0));
   6.394 +  lua_replace(L, 1);
   6.395 +  return lua_gettop(L);  /* return status + all results */
   6.396 +}
   6.397 +
   6.398 +
   6.399 +static int luaB_tostring (lua_State *L) {
   6.400 +  luaL_checkany(L, 1);
   6.401 +  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
   6.402 +    return 1;  /* use its value */
   6.403 +  switch (lua_type(L, 1)) {
   6.404 +    case LUA_TNUMBER:
   6.405 +      lua_pushstring(L, lua_tostring(L, 1));
   6.406 +      break;
   6.407 +    case LUA_TSTRING:
   6.408 +      lua_pushvalue(L, 1);
   6.409 +      break;
   6.410 +    case LUA_TBOOLEAN:
   6.411 +      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
   6.412 +      break;
   6.413 +    case LUA_TNIL:
   6.414 +      lua_pushliteral(L, "nil");
   6.415 +      break;
   6.416 +    default:
   6.417 +      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
   6.418 +      break;
   6.419 +  }
   6.420 +  return 1;
   6.421 +}
   6.422 +
   6.423 +
   6.424 +static int luaB_newproxy (lua_State *L) {
   6.425 +  lua_settop(L, 1);
   6.426 +  lua_newuserdata(L, 0);  /* create proxy */
   6.427 +  if (lua_toboolean(L, 1) == 0)
   6.428 +    return 1;  /* no metatable */
   6.429 +  else if (lua_isboolean(L, 1)) {
   6.430 +    lua_newtable(L);  /* create a new metatable `m' ... */
   6.431 +    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
   6.432 +    lua_pushboolean(L, 1);
   6.433 +    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
   6.434 +  }
   6.435 +  else {
   6.436 +    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
   6.437 +    if (lua_getmetatable(L, 1)) {
   6.438 +      lua_rawget(L, lua_upvalueindex(1));
   6.439 +      validproxy = lua_toboolean(L, -1);
   6.440 +      lua_pop(L, 1);  /* remove value */
   6.441 +    }
   6.442 +    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
   6.443 +    lua_getmetatable(L, 1);  /* metatable is valid; get it */
   6.444 +  }
   6.445 +  lua_setmetatable(L, 2);
   6.446 +  return 1;
   6.447 +}
   6.448 +
   6.449 +
   6.450 +static const luaL_Reg base_funcs[] = {
   6.451 +  {"assert", luaB_assert},
   6.452 +  {"collectgarbage", luaB_collectgarbage},
   6.453 +  {"dofile", luaB_dofile},
   6.454 +  {"error", luaB_error},
   6.455 +  {"gcinfo", luaB_gcinfo},
   6.456 +  {"getfenv", luaB_getfenv},
   6.457 +  {"getmetatable", luaB_getmetatable},
   6.458 +  {"loadfile", luaB_loadfile},
   6.459 +  {"load", luaB_load},
   6.460 +  {"loadstring", luaB_loadstring},
   6.461 +  {"next", luaB_next},
   6.462 +  {"pcall", luaB_pcall},
   6.463 +  {"print", luaB_print},
   6.464 +  {"rawequal", luaB_rawequal},
   6.465 +  {"rawget", luaB_rawget},
   6.466 +  {"rawset", luaB_rawset},
   6.467 +  {"select", luaB_select},
   6.468 +  {"setfenv", luaB_setfenv},
   6.469 +  {"setmetatable", luaB_setmetatable},
   6.470 +  {"tonumber", luaB_tonumber},
   6.471 +  {"tostring", luaB_tostring},
   6.472 +  {"type", luaB_type},
   6.473 +  {"unpack", luaB_unpack},
   6.474 +  {"xpcall", luaB_xpcall},
   6.475 +  {NULL, NULL}
   6.476 +};
   6.477 +
   6.478 +
   6.479 +/*
   6.480 +** {======================================================
   6.481 +** Coroutine library
   6.482 +** =======================================================
   6.483 +*/
   6.484 +
   6.485 +#define CO_RUN	0	/* running */
   6.486 +#define CO_SUS	1	/* suspended */
   6.487 +#define CO_NOR	2	/* 'normal' (it resumed another coroutine) */
   6.488 +#define CO_DEAD	3
   6.489 +
   6.490 +static const char *const statnames[] =
   6.491 +    {"running", "suspended", "normal", "dead"};
   6.492 +
   6.493 +static int costatus (lua_State *L, lua_State *co) {
   6.494 +  if (L == co) return CO_RUN;
   6.495 +  switch (lua_status(co)) {
   6.496 +    case LUA_YIELD:
   6.497 +      return CO_SUS;
   6.498 +    case 0: {
   6.499 +      lua_Debug ar;
   6.500 +      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
   6.501 +        return CO_NOR;  /* it is running */
   6.502 +      else if (lua_gettop(co) == 0)
   6.503 +          return CO_DEAD;
   6.504 +      else
   6.505 +        return CO_SUS;  /* initial state */
   6.506 +    }
   6.507 +    default:  /* some error occured */
   6.508 +      return CO_DEAD;
   6.509 +  }
   6.510 +}
   6.511 +
   6.512 +
   6.513 +static int luaB_costatus (lua_State *L) {
   6.514 +  lua_State *co = lua_tothread(L, 1);
   6.515 +  luaL_argcheck(L, co, 1, "coroutine expected");
   6.516 +  lua_pushstring(L, statnames[costatus(L, co)]);
   6.517 +  return 1;
   6.518 +}
   6.519 +
   6.520 +
   6.521 +static int auxresume (lua_State *L, lua_State *co, int narg) {
   6.522 +  int status = costatus(L, co);
   6.523 +  if (!lua_checkstack(co, narg))
   6.524 +    luaL_error(L, "too many arguments to resume");
   6.525 +  if (status != CO_SUS) {
   6.526 +    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
   6.527 +    return -1;  /* error flag */
   6.528 +  }
   6.529 +  lua_xmove(L, co, narg);
   6.530 +  lua_setlevel(L, co);
   6.531 +  status = lua_resume(co, narg);
   6.532 +  if (status == 0 || status == LUA_YIELD) {
   6.533 +    int nres = lua_gettop(co);
   6.534 +    if (!lua_checkstack(L, nres + 1))
   6.535 +      luaL_error(L, "too many results to resume");
   6.536 +    lua_xmove(co, L, nres);  /* move yielded values */
   6.537 +    return nres;
   6.538 +  }
   6.539 +  else {
   6.540 +    lua_xmove(co, L, 1);  /* move error message */
   6.541 +    return -1;  /* error flag */
   6.542 +  }
   6.543 +}
   6.544 +
   6.545 +
   6.546 +static int luaB_coresume (lua_State *L) {
   6.547 +  lua_State *co = lua_tothread(L, 1);
   6.548 +  int r;
   6.549 +  luaL_argcheck(L, co, 1, "coroutine expected");
   6.550 +  r = auxresume(L, co, lua_gettop(L) - 1);
   6.551 +  if (r < 0) {
   6.552 +    lua_pushboolean(L, 0);
   6.553 +    lua_insert(L, -2);
   6.554 +    return 2;  /* return false + error message */
   6.555 +  }
   6.556 +  else {
   6.557 +    lua_pushboolean(L, 1);
   6.558 +    lua_insert(L, -(r + 1));
   6.559 +    return r + 1;  /* return true + `resume' returns */
   6.560 +  }
   6.561 +}
   6.562 +
   6.563 +
   6.564 +static int luaB_auxwrap (lua_State *L) {
   6.565 +  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
   6.566 +  int r = auxresume(L, co, lua_gettop(L));
   6.567 +  if (r < 0) {
   6.568 +    if (lua_isstring(L, -1)) {  /* error object is a string? */
   6.569 +      luaL_where(L, 1);  /* add extra info */
   6.570 +      lua_insert(L, -2);
   6.571 +      lua_concat(L, 2);
   6.572 +    }
   6.573 +    lua_error(L);  /* propagate error */
   6.574 +  }
   6.575 +  return r;
   6.576 +}
   6.577 +
   6.578 +
   6.579 +static int luaB_cocreate (lua_State *L) {
   6.580 +  lua_State *NL = lua_newthread(L);
   6.581 +  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
   6.582 +    "Lua function expected");
   6.583 +  lua_pushvalue(L, 1);  /* move function to top */
   6.584 +  lua_xmove(L, NL, 1);  /* move function from L to NL */
   6.585 +  return 1;
   6.586 +}
   6.587 +
   6.588 +
   6.589 +static int luaB_cowrap (lua_State *L) {
   6.590 +  luaB_cocreate(L);
   6.591 +  lua_pushcclosure(L, luaB_auxwrap, 1);
   6.592 +  return 1;
   6.593 +}
   6.594 +
   6.595 +
   6.596 +static int luaB_yield (lua_State *L) {
   6.597 +  return lua_yield(L, lua_gettop(L));
   6.598 +}
   6.599 +
   6.600 +
   6.601 +static int luaB_corunning (lua_State *L) {
   6.602 +  if (lua_pushthread(L))
   6.603 +    lua_pushnil(L);  /* main thread is not a coroutine */
   6.604 +  return 1;
   6.605 +}
   6.606 +
   6.607 +
   6.608 +static const luaL_Reg co_funcs[] = {
   6.609 +  {"create", luaB_cocreate},
   6.610 +  {"resume", luaB_coresume},
   6.611 +  {"running", luaB_corunning},
   6.612 +  {"status", luaB_costatus},
   6.613 +  {"wrap", luaB_cowrap},
   6.614 +  {"yield", luaB_yield},
   6.615 +  {NULL, NULL}
   6.616 +};
   6.617 +
   6.618 +/* }====================================================== */
   6.619 +
   6.620 +
   6.621 +static void auxopen (lua_State *L, const char *name,
   6.622 +                     lua_CFunction f, lua_CFunction u) {
   6.623 +  lua_pushcfunction(L, u);
   6.624 +  lua_pushcclosure(L, f, 1);
   6.625 +  lua_setfield(L, -2, name);
   6.626 +}
   6.627 +
   6.628 +
   6.629 +static void base_open (lua_State *L) {
   6.630 +  /* set global _G */
   6.631 +  lua_pushvalue(L, LUA_GLOBALSINDEX);
   6.632 +  lua_setglobal(L, "_G");
   6.633 +  /* open lib into global table */
   6.634 +  luaL_register(L, "_G", base_funcs);
   6.635 +  lua_pushliteral(L, LUA_VERSION);
   6.636 +  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
   6.637 +  /* `ipairs' and `pairs' need auxliliary functions as upvalues */
   6.638 +  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
   6.639 +  auxopen(L, "pairs", luaB_pairs, luaB_next);
   6.640 +  /* `newproxy' needs a weaktable as upvalue */
   6.641 +  lua_createtable(L, 0, 1);  /* new table `w' */
   6.642 +  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
   6.643 +  lua_setmetatable(L, -2);
   6.644 +  lua_pushliteral(L, "kv");
   6.645 +  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
   6.646 +  lua_pushcclosure(L, luaB_newproxy, 1);
   6.647 +  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
   6.648 +}
   6.649 +
   6.650 +
   6.651 +LUALIB_API int luaopen_base (lua_State *L) {
   6.652 +  base_open(L);
   6.653 +  luaL_register(L, LUA_COLIBNAME, co_funcs);
   6.654 +  return 2;
   6.655 +}
   6.656 +

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/lua/lcode.c	Sat Mar 03 11:07:39 2012 -0600
     7.3 @@ -0,0 +1,839 @@
     7.4 +/*
     7.5 +** $Id: lcode.c,v 2.25.1.3 2007/12/28 15:32:23 roberto Exp $
     7.6 +** Code generator for Lua
     7.7 +** See Copyright Notice in lua.h
     7.8 +*/
     7.9 +
    7.10 +
    7.11 +#include <stdlib.h>
    7.12 +
    7.13 +#define lcode_c
    7.14 +#define LUA_CORE
    7.15 +
    7.16 +#include "lua.h"
    7.17 +
    7.18 +#include "lcode.h"
    7.19 +#include "ldebug.h"
    7.20 +#include "ldo.h"
    7.21 +#include "lgc.h"
    7.22 +#include "llex.h"
    7.23 +#include "lmem.h"
    7.24 +#include "lobject.h"
    7.25 +#include "lopcodes.h"
    7.26 +#include "lparser.h"
    7.27 +#include "ltable.h"
    7.28 +
    7.29 +
    7.30 +#define hasjumps(e)	((e)->t != (e)->f)
    7.31 +
    7.32 +
    7.33 +static int isnumeral(expdesc *e) {
    7.34 +  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
    7.35 +}
    7.36 +
    7.37 +
    7.38 +void luaK_nil (FuncState *fs, int from, int n) {
    7.39 +  Instruction *previous;
    7.40 +  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
    7.41 +    if (fs->pc == 0) {  /* function start? */
    7.42 +      if (from >= fs->nactvar)
    7.43 +        return;  /* positions are already clean */
    7.44 +    }
    7.45 +    else {
    7.46 +      previous = &fs->f->code[fs->pc-1];
    7.47 +      if (GET_OPCODE(*previous) == OP_LOADNIL) {
    7.48 +        int pfrom = GETARG_A(*previous);
    7.49 +        int pto = GETARG_B(*previous);
    7.50 +        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
    7.51 +          if (from+n-1 > pto)
    7.52 +            SETARG_B(*previous, from+n-1);
    7.53 +          return;
    7.54 +        }
    7.55 +      }
    7.56 +    }
    7.57 +  }
    7.58 +  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
    7.59 +}
    7.60 +
    7.61 +
    7.62 +int luaK_jump (FuncState *fs) {
    7.63 +  int jpc = fs->jpc;  /* save list of jumps to here */
    7.64 +  int j;
    7.65 +  fs->jpc = NO_JUMP;
    7.66 +  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
    7.67 +  luaK_concat(fs, &j, jpc);  /* keep them on hold */
    7.68 +  return j;
    7.69 +}
    7.70 +
    7.71 +
    7.72 +void luaK_ret (FuncState *fs, int first, int nret) {
    7.73 +  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
    7.74 +}
    7.75 +
    7.76 +
    7.77 +static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
    7.78 +  luaK_codeABC(fs, op, A, B, C);
    7.79 +  return luaK_jump(fs);
    7.80 +}
    7.81 +
    7.82 +
    7.83 +static void fixjump (FuncState *fs, int pc, int dest) {
    7.84 +  Instruction *jmp = &fs->f->code[pc];
    7.85 +  int offset = dest-(pc+1);
    7.86 +  lua_assert(dest != NO_JUMP);
    7.87 +  if (abs(offset) > MAXARG_sBx)
    7.88 +    luaX_syntaxerror(fs->ls, "control structure too long");
    7.89 +  SETARG_sBx(*jmp, offset);
    7.90 +}
    7.91 +
    7.92 +
    7.93 +/*
    7.94 +** returns current `pc' and marks it as a jump target (to avoid wrong
    7.95 +** optimizations with consecutive instructions not in the same basic block).
    7.96 +*/
    7.97 +int luaK_getlabel (FuncState *fs) {
    7.98 +  fs->lasttarget = fs->pc;
    7.99 +  return fs->pc;
   7.100 +}
   7.101 +
   7.102 +
   7.103 +static int getjump (FuncState *fs, int pc) {
   7.104 +  int offset = GETARG_sBx(fs->f->code[pc]);
   7.105 +  if (offset == NO_JUMP)  /* point to itself represents end of list */
   7.106 +    return NO_JUMP;  /* end of list */
   7.107 +  else
   7.108 +    return (pc+1)+offset;  /* turn offset into absolute position */
   7.109 +}
   7.110 +
   7.111 +
   7.112 +static Instruction *getjumpcontrol (FuncState *fs, int pc) {
   7.113 +  Instruction *pi = &fs->f->code[pc];
   7.114 +  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
   7.115 +    return pi-1;
   7.116 +  else
   7.117 +    return pi;
   7.118 +}
   7.119 +
   7.120 +
   7.121 +/*
   7.122 +** check whether list has any jump that do not produce a value
   7.123 +** (or produce an inverted value)
   7.124 +*/
   7.125 +static int need_value (FuncState *fs, int list) {
   7.126 +  for (; list != NO_JUMP; list = getjump(fs, list)) {
   7.127 +    Instruction i = *getjumpcontrol(fs, list);
   7.128 +    if (GET_OPCODE(i) != OP_TESTSET) return 1;
   7.129 +  }
   7.130 +  return 0;  /* not found */
   7.131 +}
   7.132 +
   7.133 +
   7.134 +static int patchtestreg (FuncState *fs, int node, int reg) {
   7.135 +  Instruction *i = getjumpcontrol(fs, node);
   7.136 +  if (GET_OPCODE(*i) != OP_TESTSET)
   7.137 +    return 0;  /* cannot patch other instructions */
   7.138 +  if (reg != NO_REG && reg != GETARG_B(*i))
   7.139 +    SETARG_A(*i, reg);
   7.140 +  else  /* no register to put value or register already has the value */
   7.141 +    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
   7.142 +
   7.143 +  return 1;
   7.144 +}
   7.145 +
   7.146 +
   7.147 +static void removevalues (FuncState *fs, int list) {
   7.148 +  for (; list != NO_JUMP; list = getjump(fs, list))
   7.149 +      patchtestreg(fs, list, NO_REG);
   7.150 +}
   7.151 +
   7.152 +
   7.153 +static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
   7.154 +                          int dtarget) {
   7.155 +  while (list != NO_JUMP) {
   7.156 +    int next = getjump(fs, list);
   7.157 +    if (patchtestreg(fs, list, reg))
   7.158 +      fixjump(fs, list, vtarget);
   7.159 +    else
   7.160 +      fixjump(fs, list, dtarget);  /* jump to default target */
   7.161 +    list = next;
   7.162 +  }
   7.163 +}
   7.164 +
   7.165 +
   7.166 +static void dischargejpc (FuncState *fs) {
   7.167 +  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
   7.168 +  fs->jpc = NO_JUMP;
   7.169 +}
   7.170 +
   7.171 +
   7.172 +void luaK_patchlist (FuncState *fs, int list, int target) {
   7.173 +  if (target == fs->pc)
   7.174 +    luaK_patchtohere(fs, list);
   7.175 +  else {
   7.176 +    lua_assert(target < fs->pc);
   7.177 +    patchlistaux(fs, list, target, NO_REG, target);
   7.178 +  }
   7.179 +}
   7.180 +
   7.181 +
   7.182 +void luaK_patchtohere (FuncState *fs, int list) {
   7.183 +  luaK_getlabel(fs);
   7.184 +  luaK_concat(fs, &fs->jpc, list);
   7.185 +}
   7.186 +
   7.187 +
   7.188 +void luaK_concat (FuncState *fs, int *l1, int l2) {
   7.189 +  if (l2 == NO_JUMP) return;
   7.190 +  else if (*l1 == NO_JUMP)
   7.191 +    *l1 = l2;
   7.192 +  else {
   7.193 +    int list = *l1;
   7.194 +    int next;
   7.195 +    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
   7.196 +      list = next;
   7.197 +    fixjump(fs, list, l2);
   7.198 +  }
   7.199 +}
   7.200 +
   7.201 +
   7.202 +void luaK_checkstack (FuncState *fs, int n) {
   7.203 +  int newstack = fs->freereg + n;
   7.204 +  if (newstack > fs->f->maxstacksize) {
   7.205 +    if (newstack >= MAXSTACK)
   7.206 +      luaX_syntaxerror(fs->ls, "function or expression too complex");
   7.207 +    fs->f->maxstacksize = cast_byte(newstack);
   7.208 +  }
   7.209 +}
   7.210 +
   7.211 +
   7.212 +void luaK_reserveregs (FuncState *fs, int n) {
   7.213 +  luaK_checkstack(fs, n);
   7.214 +  fs->freereg += n;
   7.215 +}
   7.216 +
   7.217 +
   7.218 +static void freereg (FuncState *fs, int reg) {
   7.219 +  if (!ISK(reg) && reg >= fs->nactvar) {
   7.220 +    fs->freereg--;
   7.221 +    lua_assert(reg == fs->freereg);
   7.222 +  }
   7.223 +}
   7.224 +
   7.225 +
   7.226 +static void freeexp (FuncState *fs, expdesc *e) {
   7.227 +  if (e->k == VNONRELOC)
   7.228 +    freereg(fs, e->u.s.info);
   7.229 +}
   7.230 +
   7.231 +
   7.232 +static int addk (FuncState *fs, TValue *k, TValue *v) {
   7.233 +  lua_State *L = fs->L;
   7.234 +  TValue *idx = luaH_set(L, fs->h, k);
   7.235 +  Proto *f = fs->f;
   7.236 +  int oldsize = f->sizek;
   7.237 +  if (ttisnumber(idx)) {
   7.238 +    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
   7.239 +    return cast_int(nvalue(idx));
   7.240 +  }
   7.241 +  else {  /* constant not found; create a new entry */
   7.242 +    setnvalue(idx, cast_num(fs->nk));
   7.243 +    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
   7.244 +                    MAXARG_Bx, "constant table overflow");
   7.245 +    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
   7.246 +    setobj(L, &f->k[fs->nk], v);
   7.247 +    luaC_barrier(L, f, v);
   7.248 +    return fs->nk++;
   7.249 +  }
   7.250 +}
   7.251 +
   7.252 +
   7.253 +int luaK_stringK (FuncState *fs, TString *s) {
   7.254 +  TValue o;
   7.255 +  setsvalue(fs->L, &o, s);
   7.256 +  return addk(fs, &o, &o);
   7.257 +}
   7.258 +
   7.259 +
   7.260 +int luaK_numberK (FuncState *fs, lua_Number r) {
   7.261 +  TValue o;
   7.262 +  setnvalue(&o, r);
   7.263 +  return addk(fs, &o, &o);
   7.264 +}
   7.265 +
   7.266 +
   7.267 +static int boolK (FuncState *fs, int b) {
   7.268 +  TValue o;
   7.269 +  setbvalue(&o, b);
   7.270 +  return addk(fs, &o, &o);
   7.271 +}
   7.272 +
   7.273 +
   7.274 +static int nilK (FuncState *fs) {
   7.275 +  TValue k, v;
   7.276 +  setnilvalue(&v);
   7.277 +  /* cannot use nil as key; instead use table itself to represent nil */
   7.278 +  sethvalue(fs->L, &k, fs->h);
   7.279 +  return addk(fs, &k, &v);
   7.280 +}
   7.281 +
   7.282 +
   7.283 +void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
   7.284 +  if (e->k == VCALL) {  /* expression is an open function call? */
   7.285 +    SETARG_C(getcode(fs, e), nresults+1);
   7.286 +  }
   7.287 +  else if (e->k == VVARARG) {
   7.288 +    SETARG_B(getcode(fs, e), nresults+1);
   7.289 +    SETARG_A(getcode(fs, e), fs->freereg);
   7.290 +    luaK_reserveregs(fs, 1);
   7.291 +  }
   7.292 +}
   7.293 +
   7.294 +
   7.295 +void luaK_setoneret (FuncState *fs, expdesc *e) {
   7.296 +  if (e->k == VCALL) {  /* expression is an open function call? */
   7.297 +    e->k = VNONRELOC;
   7.298 +    e->u.s.info = GETARG_A(getcode(fs, e));
   7.299 +  }
   7.300 +  else if (e->k == VVARARG) {
   7.301 +    SETARG_B(getcode(fs, e), 2);
   7.302 +    e->k = VRELOCABLE;  /* can relocate its simple result */
   7.303 +  }
   7.304 +}
   7.305 +
   7.306 +
   7.307 +void luaK_dischargevars (FuncState *fs, expdesc *e) {
   7.308 +  switch (e->k) {
   7.309 +    case VLOCAL: {
   7.310 +      e->k = VNONRELOC;
   7.311 +      break;
   7.312 +    }
   7.313 +    case VUPVAL: {
   7.314 +      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
   7.315 +      e->k = VRELOCABLE;
   7.316 +      break;
   7.317 +    }
   7.318 +    case VGLOBAL: {
   7.319 +      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
   7.320 +      e->k = VRELOCABLE;
   7.321 +      break;
   7.322 +    }
   7.323 +    case VINDEXED: {
   7.324 +      freereg(fs, e->u.s.aux);
   7.325 +      freereg(fs, e->u.s.info);
   7.326 +      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
   7.327 +      e->k = VRELOCABLE;
   7.328 +      break;
   7.329 +    }
   7.330 +    case VVARARG:
   7.331 +    case VCALL: {
   7.332 +      luaK_setoneret(fs, e);
   7.333 +      break;
   7.334 +    }
   7.335 +    default: break;  /* there is one value available (somewhere) */
   7.336 +  }
   7.337 +}
   7.338 +
   7.339 +
   7.340 +static int code_label (FuncState *fs, int A, int b, int jump) {
   7.341 +  luaK_getlabel(fs);  /* those instructions may be jump targets */
   7.342 +  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
   7.343 +}
   7.344 +
   7.345 +
   7.346 +static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
   7.347 +  luaK_dischargevars(fs, e);
   7.348 +  switch (e->k) {
   7.349 +    case VNIL: {
   7.350 +      luaK_nil(fs, reg, 1);
   7.351 +      break;
   7.352 +    }
   7.353 +    case VFALSE:  case VTRUE: {
   7.354 +      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
   7.355 +      break;
   7.356 +    }
   7.357 +    case VK: {
   7.358 +      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
   7.359 +      break;
   7.360 +    }
   7.361 +    case VKNUM: {
   7.362 +      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
   7.363 +      break;
   7.364 +    }
   7.365 +    case VRELOCABLE: {
   7.366 +      Instruction *pc = &getcode(fs, e);
   7.367 +      SETARG_A(*pc, reg);
   7.368 +      break;
   7.369 +    }
   7.370 +    case VNONRELOC: {
   7.371 +      if (reg != e->u.s.info)
   7.372 +        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
   7.373 +      break;
   7.374 +    }
   7.375 +    default: {
   7.376 +      lua_assert(e->k == VVOID || e->k == VJMP);
   7.377 +      return;  /* nothing to do... */
   7.378 +    }
   7.379 +  }
   7.380 +  e->u.s.info = reg;
   7.381 +  e->k = VNONRELOC;
   7.382 +}
   7.383 +
   7.384 +
   7.385 +static void discharge2anyreg (FuncState *fs, expdesc *e) {
   7.386 +  if (e->k != VNONRELOC) {
   7.387 +    luaK_reserveregs(fs, 1);
   7.388 +    discharge2reg(fs, e, fs->freereg-1);
   7.389 +  }
   7.390 +}
   7.391 +
   7.392 +
   7.393 +static void exp2reg (FuncState *fs, expdesc *e, int reg) {
   7.394 +  discharge2reg(fs, e, reg);
   7.395 +  if (e->k == VJMP)
   7.396 +    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
   7.397 +  if (hasjumps(e)) {
   7.398 +    int final;  /* position after whole expression */
   7.399 +    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
   7.400 +    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
   7.401 +    if (need_value(fs, e->t) || need_value(fs, e->f)) {
   7.402 +      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
   7.403 +      p_f = code_label(fs, reg, 0, 1);
   7.404 +      p_t = code_label(fs, reg, 1, 0);
   7.405 +      luaK_patchtohere(fs, fj);
   7.406 +    }
   7.407 +    final = luaK_getlabel(fs);
   7.408 +    patchlistaux(fs, e->f, final, reg, p_f);
   7.409 +    patchlistaux(fs, e->t, final, reg, p_t);
   7.410 +  }
   7.411 +  e->f = e->t = NO_JUMP;
   7.412 +  e->u.s.info = reg;
   7.413 +  e->k = VNONRELOC;
   7.414 +}
   7.415 +
   7.416 +
   7.417 +void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
   7.418 +  luaK_dischargevars(fs, e);
   7.419 +  freeexp(fs, e);
   7.420 +  luaK_reserveregs(fs, 1);
   7.421 +  exp2reg(fs, e, fs->freereg - 1);
   7.422 +}
   7.423 +
   7.424 +
   7.425 +int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
   7.426 +  luaK_dischargevars(fs, e);
   7.427 +  if (e->k == VNONRELOC) {
   7.428 +    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
   7.429 +    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
   7.430 +      exp2reg(fs, e, e->u.s.info);  /* put value on it */
   7.431 +      return e->u.s.info;
   7.432 +    }
   7.433 +  }
   7.434 +  luaK_exp2nextreg(fs, e);  /* default */
   7.435 +  return e->u.s.info;
   7.436 +}
   7.437 +
   7.438 +
   7.439 +void luaK_exp2val (FuncState *fs, expdesc *e) {
   7.440 +  if (hasjumps(e))
   7.441 +    luaK_exp2anyreg(fs, e);
   7.442 +  else
   7.443 +    luaK_dischargevars(fs, e);
   7.444 +}
   7.445 +
   7.446 +
   7.447 +int luaK_exp2RK (FuncState *fs, expdesc *e) {
   7.448 +  luaK_exp2val(fs, e);
   7.449 +  switch (e->k) {
   7.450 +    case VKNUM:
   7.451 +    case VTRUE:
   7.452 +    case VFALSE:
   7.453 +    case VNIL: {
   7.454 +      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
   7.455 +        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
   7.456 +                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
   7.457 +                                        boolK(fs, (e->k == VTRUE));
   7.458 +        e->k = VK;
   7.459 +        return RKASK(e->u.s.info);
   7.460 +      }
   7.461 +      else break;
   7.462 +    }
   7.463 +    case VK: {
   7.464 +      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
   7.465 +        return RKASK(e->u.s.info);
   7.466 +      else break;
   7.467 +    }
   7.468 +    default: break;
   7.469 +  }
   7.470 +  /* not a constant in the right range: put it in a register */
   7.471 +  return luaK_exp2anyreg(fs, e);
   7.472 +}
   7.473 +
   7.474 +
   7.475 +void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
   7.476 +  switch (var->k) {
   7.477 +    case VLOCAL: {
   7.478 +      freeexp(fs, ex);
   7.479 +      exp2reg(fs, ex, var->u.s.info);
   7.480 +      return;
   7.481 +    }
   7.482 +    case VUPVAL: {
   7.483 +      int e = luaK_exp2anyreg(fs, ex);
   7.484 +      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
   7.485 +      break;
   7.486 +    }
   7.487 +    case VGLOBAL: {
   7.488 +      int e = luaK_exp2anyreg(fs, ex);
   7.489 +      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
   7.490 +      break;
   7.491 +    }
   7.492 +    case VINDEXED: {
   7.493 +      int e = luaK_exp2RK(fs, ex);
   7.494 +      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
   7.495 +      break;
   7.496 +    }
   7.497 +    default: {
   7.498 +      lua_assert(0);  /* invalid var kind to store */
   7.499 +      break;
   7.500 +    }
   7.501 +  }
   7.502 +  freeexp(fs, ex);
   7.503 +}
   7.504 +
   7.505 +
   7.506 +void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
   7.507 +  int func;
   7.508 +  luaK_exp2anyreg(fs, e);
   7.509 +  freeexp(fs, e);
   7.510 +  func = fs->freereg;
   7.511 +  luaK_reserveregs(fs, 2);
   7.512 +  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
   7.513 +  freeexp(fs, key);
   7.514 +  e->u.s.info = func;
   7.515 +  e->k = VNONRELOC;
   7.516 +}
   7.517 +
   7.518 +
   7.519 +static void invertjump (FuncState *fs, expdesc *e) {
   7.520 +  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
   7.521 +  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
   7.522 +                                           GET_OPCODE(*pc) != OP_TEST);
   7.523 +  SETARG_A(*pc, !(GETARG_A(*pc)));
   7.524 +}
   7.525 +
   7.526 +
   7.527 +static int jumponcond (FuncState *fs, expdesc *e, int cond) {
   7.528 +  if (e->k == VRELOCABLE) {
   7.529 +    Instruction ie = getcode(fs, e);
   7.530 +    if (GET_OPCODE(ie) == OP_NOT) {
   7.531 +      fs->pc--;  /* remove previous OP_NOT */
   7.532 +      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
   7.533 +    }
   7.534 +    /* else go through */
   7.535 +  }
   7.536 +  discharge2anyreg(fs, e);
   7.537 +  freeexp(fs, e);
   7.538 +  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
   7.539 +}
   7.540 +
   7.541 +
   7.542 +void luaK_goiftrue (FuncState *fs, expdesc *e) {
   7.543 +  int pc;  /* pc of last jump */
   7.544 +  luaK_dischargevars(fs, e);
   7.545 +  switch (e->k) {
   7.546 +    case VK: case VKNUM: case VTRUE: {
   7.547 +      pc = NO_JUMP;  /* always true; do nothing */
   7.548 +      break;
   7.549 +    }
   7.550 +    case VFALSE: {
   7.551 +      pc = luaK_jump(fs);  /* always jump */
   7.552 +      break;
   7.553 +    }
   7.554 +    case VJMP: {
   7.555 +      invertjump(fs, e);
   7.556 +      pc = e->u.s.info;
   7.557 +      break;
   7.558 +    }
   7.559 +    default: {
   7.560 +      pc = jumponcond(fs, e, 0);
   7.561 +      break;
   7.562 +    }
   7.563 +  }
   7.564 +  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
   7.565 +  luaK_patchtohere(fs, e->t);
   7.566 +  e->t = NO_JUMP;
   7.567 +}
   7.568 +
   7.569 +
   7.570 +static void luaK_goiffalse (FuncState *fs, expdesc *e) {
   7.571 +  int pc;  /* pc of last jump */
   7.572 +  luaK_dischargevars(fs, e);
   7.573 +  switch (e->k) {
   7.574 +    case VNIL: case VFALSE: {
   7.575 +      pc = NO_JUMP;  /* always false; do nothing */
   7.576 +      break;
   7.577 +    }
   7.578 +    case VTRUE: {
   7.579 +      pc = luaK_jump(fs);  /* always jump */
   7.580 +      break;
   7.581 +    }
   7.582 +    case VJMP: {
   7.583 +      pc = e->u.s.info;
   7.584 +      break;
   7.585 +    }
   7.586 +    default: {
   7.587 +      pc = jumponcond(fs, e, 1);
   7.588 +      break;
   7.589 +    }
   7.590 +  }
   7.591 +  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
   7.592 +  luaK_patchtohere(fs, e->f);
   7.593 +  e->f = NO_JUMP;
   7.594 +}
   7.595 +
   7.596 +
   7.597 +static void codenot (FuncState *fs, expdesc *e) {
   7.598 +  luaK_dischargevars(fs, e);
   7.599 +  switch (e->k) {
   7.600 +    case VNIL: case VFALSE: {
   7.601 +      e->k = VTRUE;
   7.602 +      break;
   7.603 +    }
   7.604 +    case VK: case VKNUM: case VTRUE: {
   7.605 +      e->k = VFALSE;
   7.606 +      break;
   7.607 +    }
   7.608 +    case VJMP: {
   7.609 +      invertjump(fs, e);
   7.610 +      break;
   7.611 +    }
   7.612 +    case VRELOCABLE:
   7.613 +    case VNONRELOC: {
   7.614 +      discharge2anyreg(fs, e);
   7.615 +      freeexp(fs, e);
   7.616 +      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
   7.617 +      e->k = VRELOCABLE;
   7.618 +      break;
   7.619 +    }
   7.620 +    default: {
   7.621 +      lua_assert(0);  /* cannot happen */
   7.622 +      break;
   7.623 +    }
   7.624 +  }
   7.625 +  /* interchange true and false lists */
   7.626 +  { int temp = e->f; e->f = e->t; e->t = temp; }
   7.627 +  removevalues(fs, e->f);
   7.628 +  removevalues(fs, e->t);
   7.629 +}
   7.630 +
   7.631 +
   7.632 +void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
   7.633 +  t->u.s.aux = luaK_exp2RK(fs, k);
   7.634 +  t->k = VINDEXED;
   7.635 +}
   7.636 +
   7.637 +
   7.638 +static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
   7.639 +  lua_Number v1, v2, r;
   7.640 +  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
   7.641 +  v1 = e1->u.nval;
   7.642 +  v2 = e2->u.nval;
   7.643 +  switch (op) {
   7.644 +    case OP_ADD: r = luai_numadd(v1, v2); break;
   7.645 +    case OP_SUB: r = luai_numsub(v1, v2); break;
   7.646 +    case OP_MUL: r = luai_nummul(v1, v2); break;
   7.647 +    case OP_DIV:
   7.648 +      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
   7.649 +      r = luai_numdiv(v1, v2); break;
   7.650 +    case OP_MOD:
   7.651 +      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
   7.652 +      r = luai_nummod(v1, v2); break;
   7.653 +    case OP_POW: r = luai_numpow(v1, v2); break;
   7.654 +    case OP_UNM: r = luai_numunm(v1); break;
   7.655 +    case OP_LEN: return 0;  /* no constant folding for 'len' */
   7.656 +    default: lua_assert(0); r = 0; break;
   7.657 +  }
   7.658 +  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */
   7.659 +  e1->u.nval = r;
   7.660 +  return 1;
   7.661 +}
   7.662 +
   7.663 +
   7.664 +static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
   7.665 +  if (constfolding(op, e1, e2))
   7.666 +    return;
   7.667 +  else {
   7.668 +    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
   7.669 +    int o1 = luaK_exp2RK(fs, e1);
   7.670 +    if (o1 > o2) {
   7.671 +      freeexp(fs, e1);
   7.672 +      freeexp(fs, e2);
   7.673 +    }
   7.674 +    else {
   7.675 +      freeexp(fs, e2);
   7.676 +      freeexp(fs, e1);
   7.677 +    }
   7.678 +    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
   7.679 +    e1->k = VRELOCABLE;
   7.680 +  }
   7.681 +}
   7.682 +
   7.683 +
   7.684 +static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
   7.685 +                                                          expdesc *e2) {
   7.686 +  int o1 = luaK_exp2RK(fs, e1);
   7.687 +  int o2 = luaK_exp2RK(fs, e2);
   7.688 +  freeexp(fs, e2);
   7.689 +  freeexp(fs, e1);
   7.690 +  if (cond == 0 && op != OP_EQ) {
   7.691 +    int temp;  /* exchange args to replace by `<' or `<=' */
   7.692 +    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
   7.693 +    cond = 1;
   7.694 +  }
   7.695 +  e1->u.s.info = condjump(fs, op, cond, o1, o2);
   7.696 +  e1->k = VJMP;
   7.697 +}
   7.698 +
   7.699 +
   7.700 +void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
   7.701 +  expdesc e2;
   7.702 +  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
   7.703 +  switch (op) {
   7.704 +    case OPR_MINUS: {
   7.705 +      if (!isnumeral(e))
   7.706 +        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
   7.707 +      codearith(fs, OP_UNM, e, &e2);
   7.708 +      break;
   7.709 +    }
   7.710 +    case OPR_NOT: codenot(fs, e); break;
   7.711 +    case OPR_LEN: {
   7.712 +      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
   7.713 +      codearith(fs, OP_LEN, e, &e2);
   7.714 +      break;
   7.715 +    }
   7.716 +    default: lua_assert(0);
   7.717 +  }
   7.718 +}
   7.719 +
   7.720 +
   7.721 +void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
   7.722 +  switch (op) {
   7.723 +    case OPR_AND: {
   7.724 +      luaK_goiftrue(fs, v);
   7.725 +      break;
   7.726 +    }
   7.727 +    case OPR_OR: {
   7.728 +      luaK_goiffalse(fs, v);
   7.729 +      break;
   7.730 +    }
   7.731 +    case OPR_CONCAT: {
   7.732 +      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
   7.733 +      break;
   7.734 +    }
   7.735 +    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
   7.736 +    case OPR_MOD: case OPR_POW: {
   7.737 +      if (!isnumeral(v)) luaK_exp2RK(fs, v);
   7.738 +      break;
   7.739 +    }
   7.740 +    default: {
   7.741 +      luaK_exp2RK(fs, v);
   7.742 +      break;
   7.743 +    }
   7.744 +  }
   7.745 +}
   7.746 +
   7.747 +
   7.748 +void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
   7.749 +  switch (op) {
   7.750 +    case OPR_AND: {
   7.751 +      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
   7.752 +      luaK_dischargevars(fs, e2);
   7.753 +      luaK_concat(fs, &e2->f, e1->f);
   7.754 +      *e1 = *e2;
   7.755 +      break;
   7.756 +    }
   7.757 +    case OPR_OR: {
   7.758 +      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
   7.759 +      luaK_dischargevars(fs, e2);
   7.760 +      luaK_concat(fs, &e2->t, e1->t);
   7.761 +      *e1 = *e2;
   7.762 +      break;
   7.763 +    }
   7.764 +    case OPR_CONCAT: {
   7.765 +      luaK_exp2val(fs, e2);
   7.766 +      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
   7.767 +        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
   7.768 +        freeexp(fs, e1);
   7.769 +        SETARG_B(getcode(fs, e2), e1->u.s.info);
   7.770 +        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
   7.771 +      }
   7.772 +      else {
   7.773 +        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
   7.774 +        codearith(fs, OP_CONCAT, e1, e2);
   7.775 +      }
   7.776 +      break;
   7.777 +    }
   7.778 +    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
   7.779 +    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
   7.780 +    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
   7.781 +    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
   7.782 +    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
   7.783 +    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
   7.784 +    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
   7.785 +    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
   7.786 +    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
   7.787 +    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
   7.788 +    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
   7.789 +    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
   7.790 +    default: lua_assert(0);
   7.791 +  }
   7.792 +}
   7.793 +
   7.794 +
   7.795 +void luaK_fixline (FuncState *fs, int line) {
   7.796 +  fs->f->lineinfo[fs->pc - 1] = line;
   7.797 +}
   7.798 +
   7.799 +
   7.800 +static int luaK_code (FuncState *fs, Instruction i, int line) {
   7.801 +  Proto *f = fs->f;
   7.802 +  dischargejpc(fs);  /* `pc' will change */
   7.803 +  /* put new instruction in code array */
   7.804 +  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
   7.805 +                  MAX_INT, "code size overflow");
   7.806 +  f->code[fs->pc] = i;
   7.807 +  /* save corresponding line information */
   7.808 +  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
   7.809 +                  MAX_INT, "code size overflow");
   7.810 +  f->lineinfo[fs->pc] = line;
   7.811 +  return fs->pc++;
   7.812 +}
   7.813 +
   7.814 +
   7.815 +int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
   7.816 +  lua_assert(getOpMode(o) == iABC);
   7.817 +  lua_assert(getBMode(o) != OpArgN || b == 0);
   7.818 +  lua_assert(getCMode(o) != OpArgN || c == 0);
   7.819 +  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
   7.820 +}
   7.821 +
   7.822 +
   7.823 +int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
   7.824 +  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
   7.825 +  lua_assert(getCMode(o) == OpArgN);
   7.826 +  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
   7.827 +}
   7.828 +
   7.829 +
   7.830 +void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
   7.831 +  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
   7.832 +  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
   7.833 +  lua_assert(tostore != 0);
   7.834 +  if (c <= MAXARG_C)
   7.835 +    luaK_codeABC(fs, OP_SETLIST, base, b, c);
   7.836 +  else {
   7.837 +    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
   7.838 +    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
   7.839 +  }
   7.840 +  fs->freereg = base + 1;  /* free registers with list values */
   7.841 +}
   7.842 +

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/lua/lcode.h	Sat Mar 03 11:07:39 2012 -0600
     8.3 @@ -0,0 +1,76 @@
     8.4 +/*
     8.5 +** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
     8.6 +** Code generator for Lua
     8.7 +** See Copyright Notice in lua.h
     8.8 +*/
     8.9 +
    8.10 +#ifndef lcode_h
    8.11 +#define lcode_h
    8.12 +
    8.13 +#include "llex.h"
    8.14 +#include "lobject.h"
    8.15 +#include "lopcodes.h"
    8.16 +#include "lparser.h"
    8.17 +
    8.18 +
    8.19 +/*
    8.20 +** Marks the end of a patch list. It is an invalid value both as an absolute
    8.21 +** address, and as a list link (would link an element to itself).
    8.22 +*/
    8.23 +#define NO_JUMP (-1)
    8.24 +
    8.25 +
    8.26 +/*
    8.27 +** grep "ORDER OPR" if you change these enums
    8.28 +*/
    8.29 +typedef enum BinOpr {
    8.30 +  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
    8.31 +  OPR_CONCAT,
    8.32 +  OPR_NE, OPR_EQ,
    8.33 +  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
    8.34 +  OPR_AND, OPR_OR,
    8.35 +  OPR_NOBINOPR
    8.36 +} BinOpr;
    8.37 +
    8.38 +
    8.39 +typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
    8.40 +
    8.41 +
    8.42 +#define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])
    8.43 +
    8.44 +#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
    8.45 +
    8.46 +#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
    8.47 +
    8.48 +LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
    8.49 +LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
    8.50 +LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
    8.51 +LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
    8.52 +LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
    8.53 +LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
    8.54 +LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
    8.55 +LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
    8.56 +LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
    8.57 +LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
    8.58 +LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
    8.59 +LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
    8.60 +LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
    8.61 +LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
    8.62 +LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
    8.63 +LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
    8.64 +LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
    8.65 +LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
    8.66 +LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
    8.67 +LUAI_FUNC int luaK_jump (FuncState *fs);
    8.68 +LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
    8.69 +LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
    8.70 +LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
    8.71 +LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
    8.72 +LUAI_FUNC int luaK_getlabel (FuncState *fs);
    8.73 +LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
    8.74 +LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
    8.75 +LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
    8.76 +LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
    8.77 +
    8.78 +
    8.79 +#endif