# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======

# Convenience platforms targets.

# What to install.

TO_BIN= lua luac

# 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>

<LI><A HREF="manual.html#3.4.9">3.4.9 &ndash; Table Constructors</A>

<LI><A HREF="manual.html#3.4.10">3.4.10 &ndash; Function Calls</A>

<LI><A HREF="manual.html#3.4.11">3.4.11 &ndash; Function Definitions</A>

</UL>

<LI><A HREF="manual.html#3.5">3.5 &ndash; Visibility Rules</A>

</UL>

<A HREF="manual.html#pdf-LUA_HOOKLINE">LUA_HOOKLINE</A><BR>

<A HREF="manual.html#pdf-LUA_HOOKRET">LUA_HOOKRET</A><BR>

<A HREF="manual.html#pdf-LUA_HOOKTAILCALL">LUA_HOOKTAILCALL</A><BR>

<A HREF="manual.html#pdf-LUA_MASKCALL">LUA_MASKCALL</A><BR>

<A HREF="manual.html#pdf-LUA_MASKCOUNT">LUA_MASKCOUNT</A><BR>

<A HREF="manual.html#pdf-LUA_MASKLINE">LUA_MASKLINE</A><BR>

<A HREF="manual.html#pdf-LUA_OPSHR">LUA_OPSHR</A><BR>

<A HREF="manual.html#pdf-LUA_OPSUB">LUA_OPSUB</A><BR>

<A HREF="manual.html#pdf-LUA_OPUNM">LUA_OPUNM</A><BR>

<A HREF="manual.html#pdf-LUA_REFNIL">LUA_REFNIL</A><BR>

<A HREF="manual.html#pdf-LUA_REGISTRYINDEX">LUA_REGISTRYINDEX</A><BR>

<A HREF="manual.html#pdf-LUA_RIDX_GLOBALS">LUA_RIDX_GLOBALS</A><BR>

<A HREF="manual.html#pdf-LUA_TUSERDATA">LUA_TUSERDATA</A><BR>

<A HREF="manual.html#pdf-LUA_USE_APICHECK">LUA_USE_APICHECK</A><BR>

<A HREF="manual.html#pdf-LUA_YIELD">LUA_YIELD</A><BR>

</TD>

</TR>

<P CLASS="footer">

Last update:

</P>

<!--

-->

</BODY>

.SH NAME

lua \- Lua interpreter

.SH SYNOPSIS

enter interactive mode after executing

.IR script .

.TP

require library

into global

.TP

.B \-v

show version information.

<P>

<SMALL>

Freely available under the terms of the

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

</SMALL>

<p>

Lua is implemented as a library, written in <em>clean C</em>,

The Lua distribution includes a host program called <code>lua</code>,

which uses the Lua library to offer a complete,

standalone Lua interpreter,

which start with <code>0x</code> or <code>0X</code>.

Hexadecimal constants also accept an optional fractional part

plus an optional binary exponent,

<p>

<p>

Before the assignment,

the list of values is <em>adjusted</em> to the length of

<p>

If a variable is both assigned and read

inside a multiple assignment,

before the assignment.

Thus the code

<p>

The <b>break</b> statement terminates the execution of a

<b>while</b>, <b>repeat</b>, or <b>for</b> loop,

skipping to the next statement after the loop:

table constructors are explained in <a href="#3.4.9">&sect;3.4.9</a>.

Vararg expressions,

denoted by three dots ('<code>...</code>'), can only be used when

they are explained in <a href="#3.4.11">&sect;3.4.11</a>.

and the unary <em>length operator</em> (see <a href="#3.4.7">&sect;3.4.7</a>).

<p>

in particular, <code>"1"==1</code> is false and <code>"1"&lt;1</code> raises an error

(see <a href="#3.4.4">&sect;3.4.4</a>).

These coercions exist mainly for compatibility and may be removed

<p>

If the last field in the list has the form <code>exp</code>

then all values returned by this expression enter the list consecutively

<p>

scope of a to-be-closed variable is called a <em>tail call</em>.

Lua implements <em>proper tail calls</em>

(or <em>proper tail recursion</em>):

the called function reuses the stack entry of the calling function.

Therefore, there is no limit on the number of nested tail calls that

a program can execute.

</pre><p>

When a Lua function is called,

it adjusts its list of arguments to

which is indicated by three dots ('<code>...</code>')

at the end of its parameter list.

instead, it collects all extra arguments and supplies them

to the function through a <em>vararg expression</em>,

which is also written as three dots.

The value of this expression is a list of all actual extra arguments,

<p>

<h2>3.5 &ndash; <a name="3.5">Visibility Rules</a></h2>

The scope of a local variable begins at the first statement after

its declaration and lasts until the last non-void statement

of the innermost block that includes the declaration.

Consider the following example:

<pre>

Lua's garbage collection can free or move internal memory

and then invalidate pointers to internal strings.

To allow a safe use of these pointers,

is valid while the string value at that index is not removed from the stack.

(It can be moved to another index, though.)

When the index is a pseudo-index (referring to an upvalue),

         return realloc(ptr, nsize);

     }

</pre><p>

that <code>free(NULL)</code> has no effect and that

<code>realloc(NULL,size)</code> is equivalent to <code>malloc(size)</code>.

<p>

and pushes a key–value pair from the table at the given index,

the "next" pair after the given key.

If there are no more elements in the table,

<p>

<p>

Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access

(i.e., without metamethods).

<p>

Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment

(i.e., without metamethods).

<pre>int lua_resetthread (lua_State *L);</pre>

<p>

</li>

<li><b><code>isvararg</code>: </b>

(always true for C functions).

</li>

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

<p>

(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>).

The buffer must have at least that many bytes.

<pre>

     (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))

</pre><p>

<pre>

     (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))

</pre><p>

<p>

Creates a new Lua state.

It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an

and then sets a warning function and a panic function (see <a href="#4.4">&sect;4.4</a>)

that print messages to the standard error output.

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

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

<p>

Raises a type error for the argument <code>arg</code>

This variable is only a reference to the real table;

assignments to this variable do not change the

table used by <a href="#pdf-require"><code>require</code></a>.

<p>

As such, it is only available on some platforms

(Windows, Linux, Mac OS X, Solaris, BSD,

plus other Unix systems that support the <code>dlfcn</code> standard).

This variable is only a reference to the real table;

assignments to this variable do not change the

table used by <a href="#pdf-require"><code>require</code></a>.

<p>

with the given format.

The format string cannot have the variable-length options

'<code>s</code>' or '<code>z</code>' (see <a href="#6.4.2">&sect;6.4.2</a>).

<p>

Returns the arc tangent of <code>y/x</code> (in radians),

quadrant of the result.

It also handles correctly the case of <code>x</code> being zero.

<p>

If the optional second argument <code>close</code> is true,

<li><b><code>-i</code>: </b> enter interactive mode after running <em>script</em>;</li>

<li><b><code>-l <em>mod</em></code>: </b> "require" <em>mod</em> and assign the

  result to global <em>mod</em>;</li>

<li><b><code>-v</code>: </b> print version information;</li>

<li><b><code>-E</code>: </b> ignore environment variables;</li>

<li><b><code>-W</code>: </b> turn warnings on;</li>

<li><b><code>--</code>: </b> stop handling options;</li>

<li><b><code>-</code>: </b> execute <code>stdin</code> as a file and stop handling options.</li>

</ul><p>

After handling its options, <code>lua</code> runs the given <em>script</em>.

When called without arguments,

<code>lua</code> behaves as <code>lua -v -i</code>

the script is called with arguments

<code>arg[1]</code>, &middot;&middot;&middot;, <code>arg[#arg]</code>.

Like all chunks in Lua,

<p>

<P CLASS="footer">

Last update:

</P>

<!--

-->

</body></html>

If you don't have the time or the inclination to compile Lua yourself,

get a binary from

<A HREF="http://lua-users.org/wiki/LuaBinaries">LuaBinaries</A>.

<H3>Building Lua</H3>

<P>

<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>

  The platforms currently supported are:

<P>

<P CLASS="display">

</P>

<P>

  If your platform is listed, just do "<KBD>make xxx</KBD>", where xxx

<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>

# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======

LUA_A=	liblua.a

CORE_O=	lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o lundump.o lvm.o lzio.o

generic: $(ALL)

Linux linux:	linux-noreadline

linux-noreadline:

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

  CallInfo *ci = L->ci;

  if (idx > 0) {

    else return s2v(o);

  }

  else if (!ispseudo(idx)) {  /* negative index */

  }

  else if (idx == LUA_REGISTRYINDEX)

    return &G(L)->l_registry;

  else {  /* upvalues */

    idx = LUA_REGISTRYINDEX - idx;

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

      return (idx <= func->nupvalues) ? &func->upvalue[idx-1]

                                      : &G(L)->nilvalue;

    }

    else {  /* light C function or Lua function (through a hook)?) */

      return &G(L)->nilvalue;  /* no upvalues */

    }

  }

l_sinline StkId index2stack (lua_State *L, int idx) {

  CallInfo *ci = L->ci;

  if (idx > 0) {

    return o;

  }

  else {    /* non-positive index */

    api_check(L, !ispseudo(idx), "invalid index");

  }

}

  lua_lock(L);

  ci = L->ci;

  api_check(L, n >= 0, "negative 'n'");

    res = 1;  /* yes; check is OK */

  lua_unlock(L);

  return res;

}

  lua_lock(to);

  api_checknelems(from, n);

  api_check(from, G(from) == G(to), "moving among independent states");

  for (i = 0; i < n; i++) {

  }

  lua_unlock(to);

}

LUA_API int lua_absindex (lua_State *L, int idx) {

  return (idx > 0 || ispseudo(idx))

         ? idx

}

LUA_API int lua_gettop (lua_State *L) {

}

  ptrdiff_t diff;  /* difference for new top */

  lua_lock(L);

  ci = L->ci;

  if (idx >= 0) {

    for (; diff > 0; diff--)

  }

  else {

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

  }

    lua_assert(hastocloseCfunc(ci->nresults));

  }

  lua_unlock(L);

}

  StkId level;

  lua_lock(L);

  level = index2stack(L, idx);

     "no variable to close at given level");

  setnilvalue(s2v(level));

  lua_unlock(L);

}

LUA_API void lua_rotate (lua_State *L, int idx, int n) {

  StkId p, t, m;

  lua_lock(L);

  p = index2stack(L, idx);  /* start of segment */

  api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");

  m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */

  api_check(L, isvalid(L, to), "invalid index");

  setobj(L, to, fr);

  if (isupvalue(toidx))  /* function upvalue? */

  /* LUA_REGISTRYINDEX does not need gc barrier

     (collector revisits it before finishing collection) */

  lua_unlock(L);

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

  lua_lock(L);

  api_incr_top(L);

  lua_unlock(L);

}

    api_checknelems(L, 2);  /* all other operations expect two operands */

  else {  /* for unary operations, add fake 2nd operand */

    api_checknelems(L, 1);

    api_incr_top(L);

  }

  /* first operand at top - 2, second at top - 1; result go to top - 2 */

  lua_unlock(L);

}

LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {

  if (sz != 0)

    api_incr_top(L);

  return sz;

LUA_API void lua_pushnil (lua_State *L) {

  lua_lock(L);

  api_incr_top(L);

  lua_unlock(L);

}

LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {

  lua_lock(L);

  api_incr_top(L);

  lua_unlock(L);

}

LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {

  lua_lock(L);

  api_incr_top(L);

  lua_unlock(L);

}

  TString *ts;

  lua_lock(L);

  ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);

  api_incr_top(L);

  luaC_checkGC(L);

  lua_unlock(L);

LUA_API const char *lua_pushstring (lua_State *L, const char *s) {

  lua_lock(L);

  if (s == NULL)

  else {

    TString *ts;

    ts = luaS_new(L, s);

    s = getstr(ts);  /* internal copy's address */

  }

  api_incr_top(L);

LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {

  lua_lock(L);

  if (n == 0) {

    api_incr_top(L);

  }

  else {

    api_check(L, n <= MAXUPVAL, "upvalue index too large");

    cl = luaF_newCclosure(L, n);

    cl->f = fn;

    while (n--) {

      /* does not need barrier because closure is white */

      lua_assert(iswhite(cl));

    }

    api_incr_top(L);

    luaC_checkGC(L);

  }

LUA_API void lua_pushboolean (lua_State *L, int b) {

  lua_lock(L);

  if (b)

  else

  api_incr_top(L);

  lua_unlock(L);

}

LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {

  lua_lock(L);

  api_incr_top(L);

  lua_unlock(L);

}

LUA_API int lua_pushthread (lua_State *L) {

  lua_lock(L);

  api_incr_top(L);

  lua_unlock(L);

  return (G(L)->mainthread == L);

  const TValue *slot;

  TString *str = luaS_new(L, k);

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

    api_incr_top(L);

  }

  else {

    api_incr_top(L);

  }

  lua_unlock(L);

}

  TValue *t;

  lua_lock(L);

  t = index2value(L, idx);

  }

  else

  lua_unlock(L);

}

  lua_lock(L);

  t = index2value(L, idx);

  if (luaV_fastgeti(L, t, n, slot)) {

  }

  else {

    TValue aux;

    setivalue(&aux, n);

  }

  api_incr_top(L);

  lua_unlock(L);

}

l_sinline int finishrawget (lua_State *L, const TValue *val) {

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

  else

  api_incr_top(L);

  lua_unlock(L);

}

  lua_lock(L);

  api_checknelems(L, 1);

  t = gettable(L, idx);

  return finishrawget(L, val);

}

  Table *t;

  lua_lock(L);

  t = luaH_new(L);

  api_incr_top(L);

  if (narray > 0 || nrec > 0)

    luaH_resize(L, t, narray, nrec);

      break;

  }

  if (mt != NULL) {

    api_incr_top(L);

    res = 1;

  }

  o = index2value(L, idx);

  api_check(L, ttisfulluserdata(o), "full userdata expected");

  if (n <= 0 || n > uvalue(o)->nuvalue) {

    t = LUA_TNONE;

  }

  else {

  }

  api_incr_top(L);

  lua_unlock(L);

  TString *str = luaS_new(L, k);

  api_checknelems(L, 1);

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

  }

  else {

    api_incr_top(L);

  }

  lua_unlock(L);  /* lock done by caller */

}

  lua_lock(L);

  api_checknelems(L, 2);

  t = index2value(L, idx);

  }

  else

  lua_unlock(L);

}

  api_checknelems(L, 1);

  t = index2value(L, idx);

  if (luaV_fastgeti(L, t, n, slot)) {

  }

  else {

    TValue aux;

    setivalue(&aux, n);

  }

  lua_unlock(L);

}

  lua_lock(L);

  api_checknelems(L, n);

  t = gettable(L, idx);

  invalidateTMcache(t);

  lua_unlock(L);

}

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

}

  lua_lock(L);

  api_checknelems(L, 1);

  t = gettable(L, idx);

  lua_unlock(L);

}

  lua_lock(L);

  api_checknelems(L, 1);

  obj = index2value(L, objindex);

    mt = NULL;

  else {

  }

  switch (ttype(obj)) {

    case LUA_TTABLE: {

      break;

    }

  }

  lua_unlock(L);

  return 1;

}

  if (!(cast_uint(n) - 1u < cast_uint(uvalue(o)->nuvalue)))

    res = 0;  /* 'n' not in [1, uvalue(o)->nuvalue] */

  else {

    res = 1;

  }

  lua_unlock(L);

  return res;

}

#define checkresults(L,na,nr) \

	"results from function overflow current stack size")

  api_checknelems(L, nargs+1);

  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");

  checkresults(L, nargs, nresults);

  if (k != NULL && yieldable(L)) {  /* need to prepare continuation? */

    L->ci->u.c.k = k;  /* save continuation */

    L->ci->u.c.ctx = ctx;  /* save context */

    api_check(L, ttisfunction(s2v(o)), "error handler must be a function");

    func = savestack(L, o);

  }

  if (k == NULL || !yieldable(L)) {  /* no continuation or no yieldable? */

    c.nresults = nresults;  /* do a 'conventional' protected call */

    status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);

  luaZ_init(L, &z, reader, data);

  status = luaD_protectedparser(L, &z, chunkname, mode);

  if (status == LUA_OK) {  /* no errors? */

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

      /* get global table from registry */

      const TValue *gt = getGtable(L);

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

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

    }

  }

  TValue *o;

  lua_lock(L);

  api_checknelems(L, 1);

  if (isLfunction(o))

    status = luaU_dump(L, getproto(o), writer, data, strip);

  else

LUA_API int lua_error (lua_State *L) {

  TValue *errobj;

  lua_lock(L);

  api_checknelems(L, 1);

  /* error object is the memory error message? */

  if (ttisshrstring(errobj) && eqshrstr(tsvalue(errobj), G(L)->memerrmsg))

  lua_lock(L);

  api_checknelems(L, 1);

  t = gettable(L, idx);

  if (more) {

    api_incr_top(L);

  }

  else  /* no more elements */

  lua_unlock(L);

  return more;

}

  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 */

  if (n > 0)

    luaV_concat(L, n);

  else {  /* nothing to concatenate */

    api_incr_top(L);

  }

  luaC_checkGC(L);

  TValue *t;

  lua_lock(L);

  t = index2value(L, idx);

  api_incr_top(L);

  lua_unlock(L);

}

  lua_lock(L);

  api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value");

  u = luaS_newudata(L, size, nuvalue);

  api_incr_top(L);

  luaC_checkGC(L);

  lua_unlock(L);

      Proto *p = f->p;

      if (!(cast_uint(n) - 1u  < cast_uint(p->sizeupvalues)))

        return NULL;  /* 'n' not in [1, p->sizeupvalues] */

      if (owner) *owner = obj2gco(f->upvals[n - 1]);

      name = p->upvalues[n-1].name;

      return (name == NULL) ? "(no name)" : getstr(name);

  lua_lock(L);

  name = aux_upvalue(index2value(L, funcindex), n, &val, NULL);

  if (name) {

    api_incr_top(L);

  }

  lua_unlock(L);

  api_checknelems(L, 1);

  name = aux_upvalue(fi, n, &val, &owner);

  if (name) {

    luaC_barrier(L, owner, val);

  }

  lua_unlock(L);

#include "lstate.h"

/*

** If a call returns too many multiple returns, the callee may not have

** stack space to accommodate all results. In this case, this macro

*/

#define adjustresults(L,nres) \

/* Ensure the stack has at least 'n' elements */

/*

/*

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

*/

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

  if (l_unlikely(MAX_SIZET - sz < B->n))  /* overflow in (B->n + sz)? */

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

    newsize = B->n + sz;

  return newsize;

}

** box (if existent) is not on the top of the stack. So, instead of

** calling 'luaL_addlstring', it replicates the code using -2 as the

** last argument to 'prepbuffsize', signaling that the box is (or will

** trigger an emergency GC, so we should not remove the string from the

** stack before we have the space guaranteed.)

*/

}

}

** first "valid" character of the file (after the optional BOM and

** a first-line comment).

*/

  if (c == '#') {  /* first line is a comment (Unix exec. file)? */

    do {  /* skip first line */

    } while (c != EOF && c != '\n');

    return 1;  /* there was a comment */

  }

  else return 0;  /* no comment */

    lf.f = fopen(filename, "r");

    if (lf.f == NULL) return errfile(L, "open", fnameindex);

  }

  }

  if (c != EOF)

    lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */

/*