# Lua version and release.

V= 5.4

# Targets start here.

all:	$(PLAT)

For installation instructions, license details, and

further information about Lua, see doc/readme.html.

<P>

<SMALL>

Freely available under the terms of the

<A HREF="http://www.lua.org/license.html">Lua license</A>.

</SMALL>

<A HREF="manual.html#lua_callk">lua_callk</A><BR>

<A HREF="manual.html#lua_checkstack">lua_checkstack</A><BR>

<A HREF="manual.html#lua_close">lua_close</A><BR>

<A HREF="manual.html#lua_compare">lua_compare</A><BR>

<A HREF="manual.html#lua_concat">lua_concat</A><BR>

<A HREF="manual.html#lua_copy">lua_copy</A><BR>

<P CLASS="footer">

Last update:

</P>

<!--

-->

</BODY>

<P>

<SMALL>

Freely available under the terms of the

<a href="http://www.lua.org/license.html">Lua license</a>.

</SMALL>

Both <b>nil</b> and <b>false</b> make a condition false;

they are collectively called <em>false values</em>.

Any other value makes a condition true.

<p>

You can change several aspects of the behavior

of a value by setting specific fields in its metatable.

For instance, when a non-numeric value is the operand of an addition,

If it finds one,

Lua calls this function to perform the addition.

you must <em>mark</em> it for finalization.

You mark an object for finalization when you set its metatable

Note that if you set a metatable without a <code>__gc</code> field

and later create that field in the metatable,

the object will not be marked for finalization.

<p>

it is good practice to restrict each finalizer

to the minimum necessary to properly release

its associated resource.

<p>

Thus the code

<pre>

<p>

An assignment to a global name <code>x = val</code>

is equivalent to the assignment

<code>_ENV.x = val</code> (see <a href="#2.2">&sect;2.2</a>).

If there is any error while running a closing method,

that error is handled like an error in the regular code

where the variable was defined.

After an error,

the other pending closing methods will still be called.

<p>

<p>

The length operator applied on a table

returns a border in that table.

that satisfies the following condition:

<pre>

</pre><p>

In words,

<p>

and therefore it is not a sequence.

(The <b>nil</b> at index 4 is called a <em>hole</em>.)

The table <code>{nil, 20, 30, nil, nil, 60, nil}</code>

so it is not a sequence, too.

The table <code>{}</code> is a sequence with border 0.

<p>

<p>

The computation of the length of a table

has a guaranteed worst time of <em>O(log n)</em>,

<p>

<hr><h3><a name="lua_compare"><code>lua_compare</code></a></h3><p>

<span class="apii">[-0, +0, <em>e</em>]</span>

<pre>int lua_compare (lua_State *L, int index1, int index2, int op);</pre>

see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.

<p>

Pops <code>n</code> elements from the stack.

Resets a thread, cleaning its call stack and closing all pending

to-be-closed variables.

Returns a status code:

or an error status otherwise.

In case of error,

<p>

Marks the given index in the stack as a

Like a to-be-closed variable in Lua,

when it goes out of scope.

Here, in the context of a C function,

to go out of scope means that the running function returns to Lua,

<p>

This function should not be called for an index

<p>

by the time the <code>__close</code> metamethod runs,

the C stack was already unwound,

so that any automatic C variable declared in the calling function

<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part

of this structure, for later use.

To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information,

<p>

<p>

Each character in the string <code>what</code>

selects some fields of the structure <code>ar</code> to be filled or

<ul>

</li>

<li><b>'<code>S</code>': </b>

<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>;

</li>

<li><b>'<code>t</code>': </b> fills in the field <code>istailcall</code>;

</li>

<code>nups</code>, <code>nparams</code>, and <code>isvararg</code>;

</li>

<li><b>'<code>L</code>': </b>

If this option is given together with option '<code>f</code>',

its table is pushed after the function.

This is the only option that can raise a memory error.

</li>

<hr><h3><a name="luaL_addgsub"><code>luaL_addgsub</code></a></h3><p>

<pre>const void luaL_addgsub (luaL_Buffer *B, const char *s,

                         const char *p, const char *r);</pre>

<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p>

<pre>void luaL_addvalue (luaL_Buffer *B);</pre>

<p>

<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p>

<pre>void luaL_buffinit (lua_State *L, luaL_Buffer *B);</pre>

<p>

<hr><h3><a name="luaL_buffsub"><code>luaL_buffsub</code></a></h3><p>

<pre>void luaL_buffsub (luaL_Buffer *B, int n);</pre>

<p>

These values are popped from the stack after the registration.

and some of these options.

<p>

<p>

<hr><h3><a name="pdf-error"><code>error (message [, level])</code></a></h3>

This function never returns.

<p>

You may however modify existing fields.

In particular, you may set existing fields to nil.

instead, <code>pcall</code> catches the error

and returns a status code.

Its first result is the status code (a boolean),

In such case, <code>pcall</code> also returns all results from the call,

after this first result.

In case of any error, <code>pcall</code> returns <b>false</b> plus the error object.

closes all its pending to-be-closed variables

and puts the coroutine in a dead state.

The given coroutine must be dead or suspended.

returns <b>false</b> plus the error object;

otherwise returns <b>true</b>.

<p>

The default for <code>co</code> is the running coroutine.

<p>

Returns the running coroutine plus a boolean,

A third, optional numeric argument <code>init</code> specifies

where to start the search;

its default value is 1 and can be negative.

turns off the pattern matching facilities,

so the function does a plain "find substring" operation,

with no characters in <code>pattern</code> being considered magic.

which must be a string.

The format string follows the same rules as the ISO&nbsp;C function <code>sprintf</code>.

The only differences are that the conversion specifiers and modifiers

and that there is an extra specifier, <code>q</code>.

<p>

     "a string with \"quotes\" and \

      new line"

</pre><p>

<p>

If <code>comp</code> is given,

then it must be a function that receives two list elements

and returns true when the first element must come

If <code>comp</code> is not given,

then the standard Lua operator <code>&lt;</code> is used instead.

<p>

<p>

The sort algorithm is not stable:

may have their relative positions changed by the sort.

<p>

Returns a boolean,

they are compared as unsigned integers.

<P CLASS="footer">

Last update:

</P>

<!--

-->

</body></html>

<OL>

<LI>

Open a terminal window and move to

The <TT>Makefile</TT> there controls both the build process and the installation process.

<P>

<LI>

<A HREF="http://www.lua.org/license.html">this</A>.

<BLOCKQUOTE STYLE="padding-bottom: 0em">

<P>

Permission is hereby granted, free of charge, to any person obtaining a copy

<P CLASS="footer">

Last update:

</P>

<!--

-->

</BODY>

	$(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)

test:

clean:

	$(RM) $(ALL_T) $(ALL_O)

	@echo "PLAT= $(PLAT)"

	@echo "CC= $(CC)"

	@echo "CFLAGS= $(CFLAGS)"

	@echo "LIBS= $(LIBS)"

	@echo "AR= $(AR)"

	@echo "RANLIB= $(RANLIB)"

	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_C89" CC="gcc -std=c89"

	@echo ''

	@echo '*** C89 does not guarantee 64-bit integers for Lua.'

	@echo ''

FreeBSD NetBSD OpenBSD freebsd:

/*

** '!ttisnil(o)' implies 'o != &G(L)->nilvalue', so it is not needed.

** However, it covers the most common cases in a faster way.

*/

#define isupvalue(i)		((i) < LUA_REGISTRYINDEX)

static TValue *index2value (lua_State *L, int idx) {

  CallInfo *ci = L->ci;

  if (idx > 0) {

  else {  /* upvalues */

    idx = LUA_REGISTRYINDEX - idx;

    api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");

      CClosure *func = clCvalue(s2v(ci->func));

    }

  }

}

  CallInfo *ci = L->ci;

  if (idx > 0) {

    StkId o = ci->func + idx;

    return o;

  }

  else {    /* non-positive index */

LUA_API void lua_settop (lua_State *L, int idx) {

  CallInfo *ci;

  ptrdiff_t diff;  /* difference for new top */

  lua_lock(L);

  ci = L->ci;

    api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");

    diff = idx + 1;  /* will "subtract" index (as it is negative) */

  }

  lua_unlock(L);

}

** Note that we move(copy) only the value inside the stack.

** (We do not move additional fields that may exist.)

*/

  for (; from < to; from++, to--) {

    TValue temp;

    setobj(L, &temp, s2v(from));

}

  switch (ttype(o)) {

    case LUA_TUSERDATA: return getudatamem(uvalue(o));

    case LUA_TLIGHTUSERDATA: return pvalue(o);

*/

  const TValue *slot;

  TString *str = luaS_new(L, k);

  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {

}

LUA_API int lua_getglobal (lua_State *L, const char *name) {

  lua_lock(L);

}

}

  if (isempty(val))  /* avoid copying empty items to the stack */

    setnilvalue(s2v(L->top));

  else

LUA_API void lua_setglobal (lua_State *L, const char *name) {

  lua_lock(L);  /* unlock done in 'auxsetstr' */

}

static void aux_rawset (lua_State *L, int idx, TValue *key, int n) {

  Table *t;

  lua_lock(L);

  api_checknelems(L, n);

  t = gettable(L, idx);

  invalidateTMcache(t);

  luaC_barrierback(L, obj2gco(t), s2v(L->top - 1));

  L->top -= n;

    LClosure *f = clLvalue(s2v(L->top - 1));  /* get newly created function */

    if (f->nupvalues >= 1) {  /* does it have an upvalue? */

      /* get global table from registry */

      /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */

      setobj(L, f->upvals[0]->v, gt);

      luaC_barrier(L, f->upvals[0], gt);

LUA_API int lua_gc (lua_State *L, int what, ...) {

  va_list argp;

  int res = 0;

  lua_lock(L);

  va_start(argp, what);

  switch (what) {

    case LUA_GCSTOP: {

      break;

    }

    case LUA_GCRESTART: {

      luaE_setdebt(g, 0);

      break;

    }

    case LUA_GCCOLLECT: {

    case LUA_GCSTEP: {

      int data = va_arg(argp, int);

      l_mem debt = 1;  /* =1 to signal that it did an actual step */

      if (data == 0) {

        luaE_setdebt(g, 0);  /* do a basic step */

        luaC_step(L);

        luaE_setdebt(g, debt);

        luaC_checkGC(L);

      }

      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */

        res = 1;  /* signal it */

      break;

      break;

    }

    case LUA_GCISRUNNING: {

      break;

    }

    case LUA_GCGEN: {

  lua_lock(L);

  o = index2stack(L, idx);

  nresults = L->ci->nresults;

  luaF_newtbcupval(L, o);  /* create new to-be-closed upvalue */

  if (!hastocloseCfunc(nresults))  /* function not marked yet? */

    L->ci->nresults = codeNresults(nresults);  /* mark it */

#define hastocloseCfunc(n)	((n) < LUA_MULTRET)

#define codeNresults(n)		(-(n) - 3)

#endif

}

  const char *msg;

  const char *typearg;  /* name for the type of the actual argument */

  if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)

** but without 'msg'.)

*/

LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {

    if (msg)

      luaL_error(L, "stack overflow (%s)", msg);

    else

LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {

    tag_error(L, arg, t);

}

LUALIB_API void luaL_checkany (lua_State *L, int arg) {

    luaL_argerror(L, arg, "value expected");

}

LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {

  const char *s = lua_tolstring(L, arg, len);

  return s;

}

LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {

  int isnum;

  lua_Number d = lua_tonumberx(L, arg, &isnum);

    tag_error(L, arg, LUA_TNUMBER);

  return d;

}

LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {

  int isnum;

  lua_Integer d = lua_tointegerx(L, arg, &isnum);

    interror(L, arg);

  }

  return d;

  lua_Alloc allocf = lua_getallocf(L, &ud);

  UBox *box = (UBox *)lua_touserdata(L, idx);

  void *temp = allocf(ud, box->box, box->bsize, newsize);

    lua_pushliteral(L, "not enough memory");

    lua_error(L);  /* raise a memory error */

  }

/*

** Compute new size for buffer 'B', enough to accommodate extra 'sz'

** bytes.

*/

static size_t newbuffsize (luaL_Buffer *B, size_t sz) {

  size_t newsize = B->size * 2;  /* double buffer size */

    return luaL_error(B->L, "buffer too large");

  if (newsize < B->n + sz)  /* double is not big enough? */

    newsize = B->n + sz;

/*

** Returns a pointer to a free area with at least 'sz' bytes in buffer

*/

static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) {

  if (B->size - B->n >= sz)  /* enough space? */

    return B->b + B->n;

  else {

    if (buffonstack(B))  /* buffer already has a box? */

      newbuff = (char *)resizebox(L, boxidx, newsize);  /* resize it */

    else {  /* no box yet */

      newbox(L);  /* create a new box */

      lua_toclose(L, boxidx);

      newbuff = (char *)resizebox(L, boxidx, newsize);

      memcpy(newbuff, B->b, B->n * sizeof(char));  /* copy original content */

LUALIB_API void luaL_pushresult (luaL_Buffer *B) {

  lua_State *L = B->L;

  lua_pushlstring(L, B->b, B->n);

}

  B->b = B->init.b;

  B->n = 0;

  B->size = LUAL_BUFFERSIZE;

}

** =======================================================

*/

LUALIB_API int luaL_ref (lua_State *L, int t) {

  int ref;

  if (lua_isnil(L, -1)) {

    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */

  }

  t = lua_absindex(L, t);

  if (ref != 0) {  /* any free element? */

    lua_rawgeti(L, t, ref);  /* remove it from list */

    lua_rawseti(L, t, freelist);  /* (t[freelist] = t[ref]) */

  if (ref >= 0) {

    t = lua_absindex(L, t);

    lua_rawgeti(L, t, freelist);

    lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */

    lua_pushinteger(L, ref);

    lua_rawseti(L, t, freelist);  /* t[freelist] = ref */

  int isnum;

  lua_len(L, idx);

  l = lua_tointegerx(L, -1, &isnum);

    luaL_error(L, "object length is not an integer");

  lua_pop(L, 1);  /* remove object */

  return l;

LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {

  if (luaL_callmeta(L, idx, "__tostring")) {  /* metafield? */

    if (!lua_isstring(L, -1))

      luaL_error(L, "'__tostring' must return a string");

LUALIB_API lua_State *luaL_newstate (void) {

  lua_State *L = lua_newstate(l_alloc, NULL);

    lua_atpanic(L, &panic);

    lua_setwarnf(L, warnfoff, L);  /* default is warnings off */

  }

#include <stddef.h>

#include <stdio.h>

#include "lua.h"

LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);

                                     const char *p, const char *r);

LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s,

                                    const char *p, const char *r);

  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))

#define luaL_argcheck(L, cond,arg,extramsg)	\

#define luaL_argexpected(L,cond,arg,tname)	\

#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))

#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))

#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)

/* push the value used to represent failure/error */

#define luaL_pushfail(L)	lua_pushnil(L)

/*

** {======================================================

** Generic Buffer manipulation

** =======================================================

  int t = lua_type(L, 2);

  luaL_checktype(L, 1, LUA_TTABLE);

  luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");

    return luaL_error(L, "cannot change a protected metatable");

  lua_settop(L, 2);

  lua_setmetatable(L, 1);

static int pushmode (lua_State *L, int oldmode) {

  return 1;

}

static int luaB_collectgarbage (lua_State *L) {

  static const char *const opts[] = {"stop", "restart", "collect",

    "count", "step", "setpause", "setstepmul",

    case LUA_GCCOUNT: {

      int k = lua_gc(L, o);

      int b = lua_gc(L, LUA_GCCOUNTB);

      lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));

      return 1;

    }

    case LUA_GCSTEP: {

      int step = (int)luaL_optinteger(L, 2, 0);

      int res = lua_gc(L, o, step);

      lua_pushboolean(L, res);

      return 1;

    }

    case LUA_GCSETSTEPMUL: {

      int p = (int)luaL_optinteger(L, 2, 0);

      int previous = lua_gc(L, o, p);

      lua_pushinteger(L, previous);

      return 1;

    }

    case LUA_GCISRUNNING: {

      int res = lua_gc(L, o);

      lua_pushboolean(L, res);

      return 1;

    }

    }

    default: {

      int res = lua_gc(L, o);

      lua_pushinteger(L, res);

      return 1;

    }

  }

}

}

static int luaB_pairs (lua_State *L) {

  luaL_checkany(L, 1);

  if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) {  /* no metamethod? */

  }

  else {

    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */

  }

  return 3;

}

** Traversal function for 'ipairs'

*/

static int ipairsaux (lua_State *L) {

  lua_pushinteger(L, i);

  return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;

}

static int load_aux (lua_State *L, int status, int envidx) {

    if (envidx != 0) {  /* 'env' parameter? */

      lua_pushvalue(L, envidx);  /* environment for loaded function */

      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */

    *size = 0;

    return NULL;

  }

    luaL_error(L, "reader function must return a string");

  lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */

  return lua_tolstring(L, RESERVEDSLOT, size);

static int luaB_dofile (lua_State *L) {

  const char *fname = luaL_optstring(L, 1, NULL);

  lua_settop(L, 1);

    return lua_error(L);

  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);

  return dofilecont(L, 0, 0);

static int luaB_assert (lua_State *L) {

    return lua_gettop(L);  /* return all arguments */

  else {  /* error */

    luaL_checkany(L, 1);  /* there must be a condition */

** ignored).

*/

static int finishpcall (lua_State *L, int status, lua_KContext extra) {

    lua_pushboolean(L, 0);  /* first result (false) */

    lua_pushvalue(L, -2);  /* error message */

    return 2;  /* return false, msg */

#include "lprefix.h"

#include <limits.h>

#include <math.h>

#include <stdlib.h>

}

/* limit for difference between lines in relative line info. */

#define LIMLINEDIFF	0x80

static void savelineinfo (FuncState *fs, Proto *f, int line) {

  int linedif = line - fs->previousline;

  int pc = fs->pc - 1;  /* last instruction coded */

    luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo,

                    f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines");

    f->abslineinfo[fs->nabslineinfo].pc = pc;

    f->abslineinfo[fs->nabslineinfo++].line = line;

    linedif = ABSLINEINFO;  /* signal that there is absolute information */

  }

  luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte,

                  MAX_INT, "opcodes");

** and try to reuse constants. Because some values should not be used

** as keys (nil cannot be a key, integer keys can collapse with float

** keys), the caller must provide a useful 'key' for indexing the cache.

*/

static int addk (FuncState *fs, TValue *key, TValue *v) {

  lua_State *L = fs->ls->L;

  Proto *f = fs->f;

  int k, oldsize;

  if (ttisinteger(idx)) {  /* is there an index there? */

    k = cast_int(ivalue(idx));

  k = fs->nk;

  /* numerical value does not need GC barrier;

     table has no metatable, so it does not need to invalidate cache */

  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");

  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);

  setobj(L, &f->k[k], v);

/*

** Add an integer to list of constants and return its index.

*/

static int luaK_intK (FuncState *fs, lua_Integer n) {

  setivalue(&o, n);

}

/*

*/

static int luaK_numberK (FuncState *fs, lua_Number r) {

  TValue o;

  setfltvalue(&o, r);

}

      break;

    }

    case VLOCAL: {  /* already in a register */

      e->k = VNONRELOC;  /* becomes a non-relocatable value */

      break;

    }

  switch (var->k) {

    case VLOCAL: {

      freeexp(fs, ex);

      return;

    }

    case VUPVAL: {

  }

  else {

    /* register index of the table */

    if (isKstr(fs, k)) {

      t->u.ind.idx = k->u.info;  /* literal string */

      t->k = VINDEXSTR;

    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:

    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */

      lua_Integer i;

    }

    case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */

      return (nvalue(v2) != 0);

*/

static int auxresume (lua_State *L, lua_State *co, int narg) {

  int status, nres;

    lua_pushliteral(L, "too many arguments to resume");

    return -1;  /* error flag */

  }

  lua_xmove(L, co, narg);

  status = lua_resume(co, L, narg, &nres);

      lua_pop(co, nres);  /* remove results anyway */

      lua_pushliteral(L, "too many results to resume");

      return -1;  /* error flag */

  lua_State *co = getco(L);

  int r;

  r = auxresume(L, co, lua_gettop(L) - 1);

    lua_pushboolean(L, 0);

    lua_insert(L, -2);

    return 2;  /* return false + error message */

static int luaB_auxwrap (lua_State *L) {

  lua_State *co = lua_tothread(L, lua_upvalueindex(1));

  int r = auxresume(L, co, lua_gettop(L));

    int stat = lua_status(co);

    if (stat != LUA_ERRMEM &&  /* not a memory error and ... */

        lua_type(L, -1) == LUA_TSTRING) {  /* ... error object is a string? */

      luaL_where(L, 1);  /* add extra info, if available */

      }

      else {

        lua_pushboolean(L, 0);

        return 2;

      }

    }

** checked.

*/

static void checkstack (lua_State *L, lua_State *L1, int n) {

    luaL_error(L, "stack overflow");

}

  lua_State *L1 = getthread(L, &arg);

  const char *options = luaL_optstring(L, arg+2, "flnSrtu");

  checkstack(L, L1, 3);

  if (lua_isfunction(L, arg + 1)) {  /* info about a function? */

    options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */

    lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */

    lua_Debug ar;

    const char *name;

    int level = (int)luaL_checkinteger(L, arg + 1);

      return luaL_argerror(L, arg+1, "level out of range");

    checkstack(L, L1, 1);

    name = lua_getlocal(L1, &ar, nvar);

  lua_Debug ar;

  int level = (int)luaL_checkinteger(L, arg + 1);

  int nvar = (int)luaL_checkinteger(L, arg + 2);

    return luaL_argerror(L, arg+1, "level out of range");

  luaL_checkany(L, arg+3);

  lua_settop(L, arg+3);

  }

  if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) {

    /* table just created; initialize it */

    lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */

    lua_pushvalue(L, -1);

    lua_setmetatable(L, -2);  /* metatable(hooktable) = hooktable */

  for (;;) {

    char buffer[250];

    lua_writestringerror("%s", "lua_debug> ");

        strcmp(buffer, "cont\n") == 0)

      return 0;

    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||

#define noLuaClosure(f)		((f) == NULL || (f)->c.tt == LUA_VCCL)

static int currentpc (CallInfo *ci) {