src/third_party/skia/third_party/lua/doc/manual.html - cobalt - Git at Google

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>

 <head>
 <title>Lua 5.2 Reference Manual</title>
 <link rel="stylesheet" type="text/css" href="lua.css">
 <link rel="stylesheet" type="text/css" href="manual.css">
 <META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
 </head>

 <body>

 <hr>
 <h1>
 <a href="http://www.lua.org/"><img src="logo.gif" alt="" border="0"></a>
 Lua 5.2 Reference Manual
 </h1>

 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
 <p>
 <small>
 Copyright &copy; 2011&ndash;2013 Lua.org, PUC-Rio.
 Freely available under the terms of the
 <a href="http://www.lua.org/license.html">Lua license</a>.
 </small>
 <hr>
 <p>

 <a href="contents.html#contents">contents</A>
 &middot;
 <a href="contents.html#index">index</A>

 <!-- ====================================================================== -->
 <p>

 <!-- $Id: manual.of,v 1.103 2013/03/14 18:51:56 roberto Exp $ -->


 <h1>1 &ndash; <a name="1">Introduction</a></h1>

 <p>
 Lua is an extension programming language designed to support
 general procedural programming with data description
 facilities.
 It also offers good support for object-oriented programming,
 functional programming, and data-driven programming.
 Lua is intended to be used as a powerful, lightweight,
 embeddable scripting language for any program that needs one.
 Lua is implemented as a library, written in <em>clean C</em>,
 the common subset of Standard&nbsp;C and C++.


 <p>
 Being an extension language, Lua has no notion of a "main" program:
 it only works <em>embedded</em> in a host client,
 called the <em>embedding program</em> or simply the <em>host</em>.
 The host program can invoke functions to execute a piece of Lua code,
 can write and read Lua variables,
 and can register C&nbsp;functions to be called by Lua code.
 Through the use of C&nbsp;functions, Lua can be augmented to cope with
 a wide range of different domains,
 thus creating customized programming languages sharing a syntactical framework.
 The Lua distribution includes a sample host program called <code>lua</code>,
 which uses the Lua library to offer a complete, standalone Lua interpreter,
 for interactive or batch use.


 <p>
 Lua is free software,
 and is provided as usual with no guarantees,
 as stated in its license.
 The implementation described in this manual is available
 at Lua's official web site, <code>www.lua.org</code>.


 <p>
 Like any other reference manual,
 this document is dry in places.
 For a discussion of the decisions behind the design of Lua,
 see the technical papers available at Lua's web site.
 For a detailed introduction to programming in Lua,
 see Roberto's book, <em>Programming in Lua</em>.


 <h1>2 &ndash; <a name="2">Basic Concepts</a></h1>

 <p>
 This section describes the basic concepts of the language.


 <h2>2.1 &ndash; <a name="2.1">Values and Types</a></h2>

 <p>
 Lua is a <em>dynamically typed language</em>.
 This means that
 variables do not have types; only values do.
 There are no type definitions in the language.
 All values carry their own type.


 <p>
 All values in Lua are <em>first-class values</em>.
 This means that all values can be stored in variables,
 passed as arguments to other functions, and returned as results.


 <p>
 There are eight basic types in Lua:
 <em>nil</em>, <em>boolean</em>, <em>number</em>,
 <em>string</em>, <em>function</em>, <em>userdata</em>,
 <em>thread</em>, and <em>table</em>.
 <em>Nil</em> is the type of the value <b>nil</b>,
 whose main property is to be different from any other value;
 it usually represents the absence of a useful value.
 <em>Boolean</em> is the type of the values <b>false</b> and <b>true</b>.
 Both <b>nil</b> and <b>false</b> make a condition false;
 any other value makes it true.
 <em>Number</em> represents real (double-precision floating-point) numbers.
 Operations on numbers follow the same rules of
 the underlying C&nbsp;implementation,
 which, in turn, usually follows the IEEE 754 standard.
 (It is easy to build Lua interpreters that use other
 internal representations for numbers,
 such as single-precision floats or long integers;
 see file <code>luaconf.h</code>.)
 <em>String</em> represents immutable sequences of bytes.

 Lua is 8-bit clean:
 strings can contain any 8-bit value,
 including embedded zeros ('<code>\0</code>').


 <p>
 Lua can call (and manipulate) functions written in Lua and
 functions written in C
 (see <a href="#3.4.9">&sect;3.4.9</a>).


 <p>
 The type <em>userdata</em> is provided to allow arbitrary C&nbsp;data to
 be stored in Lua variables.
 A userdata value is a pointer to a block of raw memory.
 There are two kinds of userdata:
 full userdata, where the block of memory is managed by Lua,
 and light userdata, where the block of memory is managed by the host.
 Userdata has no predefined operations in Lua,
 except assignment and identity test.
 By using <em>metatables</em>,
 the programmer can define operations for full userdata values
 (see <a href="#2.4">&sect;2.4</a>).
 Userdata values cannot be created or modified in Lua,
 only through the C&nbsp;API.
 This guarantees the integrity of data owned by the host program.


 <p>
 The type <em>thread</em> represents independent threads of execution
 and it is used to implement coroutines (see <a href="#2.6">&sect;2.6</a>).
 Do not confuse Lua threads with operating-system threads.
 Lua supports coroutines on all systems,
 even those that do not support threads.


 <p>
 The type <em>table</em> implements associative arrays,
 that is, arrays that can be indexed not only with numbers,
 but with any Lua value except <b>nil</b> and NaN
 (<em>Not a Number</em>, a special numeric value used to represent
 undefined or unrepresentable results, such as <code>0/0</code>).
 Tables can be <em>heterogeneous</em>;
 that is, they can contain values of all types (except <b>nil</b>).
 Any key with value <b>nil</b> is not considered part of the table.
 Conversely, any key that is not part of a table has
 an associated value <b>nil</b>.


 <p>
 Tables are the sole data structuring mechanism in Lua;
 they can be used to represent ordinary arrays, sequences,
 symbol tables, sets, records, graphs, trees, etc.
 To represent records, Lua uses the field name as an index.
 The language supports this representation by
 providing <code>a.name</code> as syntactic sugar for <code>a["name"]</code>.
 There are several convenient ways to create tables in Lua
 (see <a href="#3.4.8">&sect;3.4.8</a>).


 <p>
 We use the term <em>sequence</em> to denote a table where
 the set of all positive numeric keys is equal to <em>{1..n}</em>
 for some integer <em>n</em>,
 which is called the length of the sequence (see <a href="#3.4.6">&sect;3.4.6</a>).


 <p>
 Like indices,
 the values of table fields can be of any type.
 In particular,
 because functions are first-class values,
 table fields can contain functions.
 Thus tables can also carry <em>methods</em> (see <a href="#3.4.10">&sect;3.4.10</a>).


 <p>
 The indexing of tables follows
 the definition of raw equality in the language.
 The expressions <code>a[i]</code> and <code>a[j]</code>
 denote the same table element
 if and only if <code>i</code> and <code>j</code> are raw equal
 (that is, equal without metamethods).


 <p>
 Tables, functions, threads, and (full) userdata values are <em>objects</em>:
 variables do not actually <em>contain</em> these values,
 only <em>references</em> to them.
 Assignment, parameter passing, and function returns
 always manipulate references to such values;
 these operations do not imply any kind of copy.


 <p>
 The library function <a href="#pdf-type"><code>type</code></a> returns a string describing the type
 of a given value (see <a href="#6.1">&sect;6.1</a>).


 <h2>2.2 &ndash; <a name="2.2">Environments and the Global Environment</a></h2>

 <p>
 As will be discussed in <a href="#3.2">&sect;3.2</a> and <a href="#3.3.3">&sect;3.3.3</a>,
 any reference to a global name <code>var</code> is syntactically translated
 to <code>_ENV.var</code>.
 Moreover, every chunk is compiled in the scope of
 an external local variable called <code>_ENV</code> (see <a href="#3.3.2">&sect;3.3.2</a>),
 so <code>_ENV</code> itself is never a global name in a chunk.


 <p>
 Despite the existence of this external <code>_ENV</code> variable and
 the translation of global names,
 <code>_ENV</code> is a completely regular name.
 In particular,
 you can define new variables and parameters with that name.
 Each reference to a global name uses the <code>_ENV</code> that is
 visible at that point in the program,
 following the usual visibility rules of Lua (see <a href="#3.5">&sect;3.5</a>).


 <p>
 Any table used as the value of <code>_ENV</code> is called an <em>environment</em>.


 <p>
 Lua keeps a distinguished environment called the <em>global environment</em>.
 This value is kept at a special index in the C registry (see <a href="#4.5">&sect;4.5</a>).
 In Lua, the variable <a href="#pdf-_G"><code>_G</code></a> is initialized with this same value.


 <p>
 When Lua compiles a chunk,
 it initializes the value of its <code>_ENV</code> upvalue
 with the global environment (see <a href="#pdf-load"><code>load</code></a>).
 Therefore, by default,
 global variables in Lua code refer to entries in the global environment.
 Moreover, all standard libraries are loaded in the global environment
 and several functions there operate on that environment.
 You can use <a href="#pdf-load"><code>load</code></a> (or <a href="#pdf-loadfile"><code>loadfile</code></a>)
 to load a chunk with a different environment.
 (In C, you have to load the chunk and then change the value
 of its first upvalue.)


 <p>
 If you change the global environment in the registry
 (through C code or the debug library),
 all chunks loaded after the change will get the new environment.
 Previously loaded chunks are not affected, however,
 as each has its own reference to the environment in its <code>_ENV</code> variable.
 Moreover, the variable <a href="#pdf-_G"><code>_G</code></a>
 (which is stored in the original global environment)
 is never updated by Lua.


 <h2>2.3 &ndash; <a name="2.3">Error Handling</a></h2>

 <p>
 Because Lua is an embedded extension language,
 all Lua actions start from C&nbsp;code in the host program
 calling a function from the Lua library (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
 Whenever an error occurs during
 the compilation or execution of a Lua chunk,
 control returns to the host,
 which can take appropriate measures
 (such as printing an error message).


 <p>
 Lua code can explicitly generate an error by calling the
 <a href="#pdf-error"><code>error</code></a> function.
 If you need to catch errors in Lua,
 you can use <a href="#pdf-pcall"><code>pcall</code></a> or <a href="#pdf-xpcall"><code>xpcall</code></a>
 to call a given function in <em>protected mode</em>.


 <p>
 Whenever there is an error,
 an <em>error object</em> (also called an <em>error message</em>)
 is propagated with information about the error.
 Lua itself only generates errors where the error object is a string,
 but programs may generate errors with
 any value for the error object.


 <p>
 When you use <a href="#pdf-xpcall"><code>xpcall</code></a> or <a href="#lua_pcall"><code>lua_pcall</code></a>,
 you may give a <em>message handler</em>
 to be called in case of errors.
 This function is called with the original error message
 and returns a new error message.
 It is called before the error unwinds the stack,
 so that it can gather more information about the error,
 for instance by inspecting the stack and creating a stack traceback.
 This message handler is still protected by the protected call;
 so, an error inside the message handler
 will call the message handler again.
 If this loop goes on, Lua breaks it and returns an appropriate message.


 <h2>2.4 &ndash; <a name="2.4">Metatables and Metamethods</a></h2>

 <p>
 Every value in Lua can have a <em>metatable</em>.
 This <em>metatable</em> is an ordinary Lua table
 that defines the behavior of the original value
 under certain special operations.
 You can change several aspects of the behavior
 of operations over a value by setting specific fields in its metatable.
 For instance, when a non-numeric value is the operand of an addition,
 Lua checks for a function in the field "<code>__add</code>" of the value's metatable.
 If it finds one,
 Lua calls this function to perform the addition.


 <p>
 The keys in a metatable are derived from the <em>event</em> names;
 the corresponding values are called <em>metamethods</em>.
 In the previous example, the event is <code>"add"</code>
 and the metamethod is the function that performs the addition.


 <p>
 You can query the metatable of any value
 using the <a href="#pdf-getmetatable"><code>getmetatable</code></a> function.


 <p>
 You can replace the metatable of tables
 using the <a href="#pdf-setmetatable"><code>setmetatable</code></a> function.
 You cannot change the metatable of other types from Lua
 (except by using the debug library);
 you must use the C&nbsp;API for that.


 <p>
 Tables and full userdata have individual metatables
 (although multiple tables and userdata can share their metatables).
 Values of all other types share one single metatable per type;
 that is, there is one single metatable for all numbers,
 one for all strings, etc.
 By default, a value has no metatable,
 but the string library sets a metatable for the string type (see <a href="#6.4">&sect;6.4</a>).


 <p>
 A metatable controls how an object behaves in arithmetic operations,
 order comparisons, concatenation, length operation, and indexing.
 A metatable also can define a function to be called
 when a userdata or a table is garbage collected.
 When Lua performs one of these operations over a value,
 it checks whether this value has a metatable with the corresponding event.
 If so, the value associated with that key (the metamethod)
 controls how Lua will perform the operation.


 <p>
 Metatables control the operations listed next.
 Each operation is identified by its corresponding name.
 The key for each operation is a string with its name prefixed by
 two underscores, '<code>__</code>';
 for instance, the key for operation "add" is the
 string "<code>__add</code>".


 <p>
 The semantics of these operations is better explained by a Lua function
 describing how the interpreter executes the operation.
 The code shown here in Lua is only illustrative;
 the real behavior is hard coded in the interpreter
 and it is much more efficient than this simulation.
 All functions used in these descriptions
 (<a href="#pdf-rawget"><code>rawget</code></a>, <a href="#pdf-tonumber"><code>tonumber</code></a>, etc.)
 are described in <a href="#6.1">&sect;6.1</a>.
 In particular, to retrieve the metamethod of a given object,
 we use the expression

 <pre>
      metatable(obj)[event]
 </pre><p>
 This should be read as

 <pre>
      rawget(getmetatable(obj) or {}, event)
 </pre><p>
 This means that the access to a metamethod does not invoke other metamethods,
 and access to objects with no metatables does not fail
 (it simply results in <b>nil</b>).


 <p>
 For the unary <code>-</code> and <code>#</code> operators,
 the metamethod is called with a dummy second argument.
 This extra argument is only to simplify Lua's internals;
 it may be removed in future versions and therefore it is not present
 in the following code.
 (For most uses this extra argument is irrelevant.)


 <ul>

 <li><b>"add": </b>
 the <code>+</code> operation.


 <p>
 The function <code>getbinhandler</code> below defines how Lua chooses a handler
 for a binary operation.
 First, Lua tries the first operand.
 If its type does not define a handler for the operation,
 then Lua tries the second operand.

 <pre>
      function getbinhandler (op1, op2, event)
        return metatable(op1)[event] or metatable(op2)[event]
      end
 </pre><p>
 By using this function,
 the behavior of the <code>op1 + op2</code> is

 <pre>
      function add_event (op1, op2)
        local o1, o2 = tonumber(op1), tonumber(op2)
        if o1 and o2 then  -- both operands are numeric?
          return o1 + o2   -- '+' here is the primitive 'add'
        else  -- at least one of the operands is not numeric
          local h = getbinhandler(op1, op2, "__add")
          if h then
            -- call the handler with both operands
            return (h(op1, op2))
          else  -- no handler available: default behavior
            error(&middot;&middot;&middot;)
          end
        end
      end
 </pre><p>
 </li>

 <li><b>"sub": </b>
 the <code>-</code> operation.

 Behavior similar to the "add" operation.
 </li>

 <li><b>"mul": </b>
 the <code>*</code> operation.

 Behavior similar to the "add" operation.
 </li>

 <li><b>"div": </b>
 the <code>/</code> operation.

 Behavior similar to the "add" operation.
 </li>

 <li><b>"mod": </b>
 the <code>%</code> operation.

 Behavior similar to the "add" operation,
 with the operation
 <code>o1 - floor(o1/o2)*o2</code> as the primitive operation.
 </li>

 <li><b>"pow": </b>
 the <code>^</code> (exponentiation) operation.

 Behavior similar to the "add" operation,
 with the function <code>pow</code> (from the C&nbsp;math library)
 as the primitive operation.
 </li>

 <li><b>"unm": </b>
 the unary <code>-</code> operation.


 <pre>
      function unm_event (op)
        local o = tonumber(op)
        if o then  -- operand is numeric?
          return -o  -- '-' here is the primitive 'unm'
        else  -- the operand is not numeric.
          -- Try to get a handler from the operand
          local h = metatable(op).__unm
          if h then
            -- call the handler with the operand
            return (h(op))
          else  -- no handler available: default behavior
            error(&middot;&middot;&middot;)
          end
        end
      end
 </pre><p>
 </li>

 <li><b>"concat": </b>
 the <code>..</code> (concatenation) operation.


 <pre>
      function concat_event (op1, op2)
        if (type(op1) == "string" or type(op1) == "number") and
           (type(op2) == "string" or type(op2) == "number") then
          return op1 .. op2  -- primitive string concatenation
        else
          local h = getbinhandler(op1, op2, "__concat")
          if h then
            return (h(op1, op2))
          else
            error(&middot;&middot;&middot;)
          end
        end
      end
 </pre><p>
 </li>

 <li><b>"len": </b>
 the <code>#</code> operation.


 <pre>
      function len_event (op)
        if type(op) == "string" then
          return strlen(op)      -- primitive string length
        else
          local h = metatable(op).__len
          if h then
            return (h(op))       -- call handler with the operand
          elseif type(op) == "table" then
            return #op              -- primitive table length
          else  -- no handler available: error
            error(&middot;&middot;&middot;)
          end
        end
      end
 </pre><p>
 See <a href="#3.4.6">&sect;3.4.6</a> for a description of the length of a table.
 </li>

 <li><b>"eq": </b>
 the <code>==</code> operation.

 The function <code>getequalhandler</code> defines how Lua chooses a metamethod
 for equality.
 A metamethod is selected only when both values
 being compared have the same type
 and the same metamethod for the selected operation,
 and the values are either tables or full userdata.

 <pre>
      function getequalhandler (op1, op2)
        if type(op1) ~= type(op2) or
           (type(op1) ~= "table" and type(op1) ~= "userdata") then
          return nil     -- different values
        end
        local mm1 = metatable(op1).__eq
        local mm2 = metatable(op2).__eq
        if mm1 == mm2 then return mm1 else return nil end
      end
 </pre><p>
 The "eq" event is defined as follows:

 <pre>
      function eq_event (op1, op2)
        if op1 == op2 then   -- primitive equal?
          return true   -- values are equal
        end
        -- try metamethod
        local h = getequalhandler(op1, op2)
        if h then
          return not not h(op1, op2)
        else
          return false
        end
      end
 </pre><p>
 Note that the result is always a boolean.
 </li>

 <li><b>"lt": </b>
 the <code>&lt;</code> operation.


 <pre>
      function lt_event (op1, op2)
        if type(op1) == "number" and type(op2) == "number" then
          return op1 &lt; op2   -- numeric comparison
        elseif type(op1) == "string" and type(op2) == "string" then
          return op1 &lt; op2   -- lexicographic comparison
        else
          local h = getbinhandler(op1, op2, "__lt")
          if h then
            return not not h(op1, op2)
          else
            error(&middot;&middot;&middot;)
          end
        end
      end
 </pre><p>
 Note that the result is always a boolean.
 </li>

 <li><b>"le": </b>
 the <code>&lt;=</code> operation.


 <pre>
      function le_event (op1, op2)
        if type(op1) == "number" and type(op2) == "number" then
          return op1 &lt;= op2   -- numeric comparison
        elseif type(op1) == "string" and type(op2) == "string" then
          return op1 &lt;= op2   -- lexicographic comparison
        else
          local h = getbinhandler(op1, op2, "__le")
          if h then
            return not not h(op1, op2)
          else
            h = getbinhandler(op1, op2, "__lt")
            if h then
              return not h(op2, op1)
            else
              error(&middot;&middot;&middot;)
            end
          end
        end
      end
 </pre><p>
 Note that, in the absence of a "le" metamethod,
 Lua tries the "lt", assuming that <code>a &lt;= b</code> is
 equivalent to <code>not (b &lt; a)</code>.


 <p>
 As with the other comparison operators,
 the result is always a boolean.
 </li>

 <li><b>"index": </b>
 The indexing access <code>table[key]</code>.
 Note that the metamethod is tried only
 when <code>key</code> is not present in <code>table</code>.
 (When <code>table</code> is not a table,
 no key is ever present,
 so the metamethod is always tried.)


 <pre>
      function gettable_event (table, key)
        local h
        if type(table) == "table" then
          local v = rawget(table, key)
          -- if key is present, return raw value
          if v ~= nil then return v end
          h = metatable(table).__index
          if h == nil then return nil end
        else
          h = metatable(table).__index
          if h == nil then
            error(&middot;&middot;&middot;)
          end
        end
        if type(h) == "function" then
          return (h(table, key))     -- call the handler
        else return h[key]           -- or repeat operation on it
        end
      end
 </pre><p>
 </li>

 <li><b>"newindex": </b>
 The indexing assignment <code>table[key] = value</code>.
 Note that the metamethod is tried only
 when <code>key</code> is not present in <code>table</code>.


 <pre>
      function settable_event (table, key, value)
        local h
        if type(table) == "table" then
          local v = rawget(table, key)
          -- if key is present, do raw assignment
          if v ~= nil then rawset(table, key, value); return end
          h = metatable(table).__newindex
          if h == nil then rawset(table, key, value); return end
        else
          h = metatable(table).__newindex
          if h == nil then
            error(&middot;&middot;&middot;)
          end
        end
        if type(h) == "function" then
          h(table, key,value)           -- call the handler
        else h[key] = value             -- or repeat operation on it
        end
      end
 </pre><p>
 </li>

 <li><b>"call": </b>
 called when Lua calls a value.


 <pre>
      function function_event (func, ...)
        if type(func) == "function" then
          return func(...)   -- primitive call
        else
          local h = metatable(func).__call
          if h then
            return h(func, ...)
          else
            error(&middot;&middot;&middot;)
          end
        end
      end
 </pre><p>
 </li>

 </ul>


 <h2>2.5 &ndash; <a name="2.5">Garbage Collection</a></h2>

 <p>
 Lua performs automatic memory management.
 This means that
 you have to worry neither about allocating memory for new objects
 nor about freeing it when the objects are no longer needed.
 Lua manages memory automatically by running
 a <em>garbage collector</em> to collect all <em>dead objects</em>
 (that is, objects that are no longer accessible from Lua).
 All memory used by Lua is subject to automatic management:
 strings, tables, userdata, functions, threads, internal structures, etc.


 <p>
 Lua implements an incremental mark-and-sweep collector.
 It uses two numbers to control its garbage-collection cycles:
 the <em>garbage-collector pause</em> and
 the <em>garbage-collector step multiplier</em>.
 Both use percentage points as units
 (e.g., a value of 100 means an internal value of 1).


 <p>
 The garbage-collector pause
 controls how long the collector waits before starting a new cycle.
 Larger values make the collector less aggressive.
 Values smaller than 100 mean the collector will not wait to
 start a new cycle.
 A value of 200 means that the collector waits for the total memory in use
 to double before starting a new cycle.


 <p>
 The garbage-collector step multiplier
 controls the relative speed of the collector relative to
 memory allocation.
 Larger values make the collector more aggressive but also increase
 the size of each incremental step.
 Values smaller than 100 make the collector too slow and
 can result in the collector never finishing a cycle.
 The default is 200,
 which means that the collector runs at "twice"
 the speed of memory allocation.


 <p>
 If you set the step multiplier to a very large number
 (larger than 10% of the maximum number of
 bytes that the program may use),
 the collector behaves like a stop-the-world collector.
 If you then set the pause to 200,
 the collector behaves as in old Lua versions,
 doing a complete collection every time Lua doubles its
 memory usage.


 <p>
 You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
 or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
 You can also use these functions to control
 the collector directly (e.g., stop and restart it).


 <p>
 As an experimental feature in Lua 5.2,
 you can change the collector's operation mode
 from incremental to <em>generational</em>.
 A <em>generational collector</em> assumes that most objects die young,
 and therefore it traverses only young (recently created) objects.
 This behavior can reduce the time used by the collector,
 but also increases memory usage (as old dead objects may accumulate).
 To mitigate this second problem,
 from time to time the generational collector performs a full collection.
 Remember that this is an experimental feature;
 you are welcome to try it,
 but check your gains.


 <h3>2.5.1 &ndash; <a name="2.5.1">Garbage-Collection Metamethods</a></h3>

 <p>
 You can set garbage-collector metamethods for tables
 and, using the C&nbsp;API,
 for full userdata (see <a href="#2.4">&sect;2.4</a>).
 These metamethods are also called <em>finalizers</em>.
 Finalizers allow you to coordinate Lua's garbage collection
 with external resource management
 (such as closing files, network or database connections,
 or freeing your own memory).


 <p>
 For an object (table or userdata) to be finalized when collected,
 you must <em>mark</em> it for finalization.

 You mark an object for finalization when you set its metatable
 and the metatable has a field indexed by the string "<code>__gc</code>".
 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.
 However, after an object is marked,
 you can freely change the <code>__gc</code> field of its metatable.


 <p>
 When a marked object becomes garbage,
 it is not collected immediately by the garbage collector.
 Instead, Lua puts it in a list.
 After the collection,
 Lua does the equivalent of the following function
 for each object in that list:

 <pre>
      function gc_event (obj)
        local h = metatable(obj).__gc
        if type(h) == "function" then
          h(obj)
        end
      end
 </pre>

 <p>
 At the end of each garbage-collection cycle,
 the finalizers for objects are called in
 the reverse order that they were marked for collection,
 among those collected in that cycle;
 that is, the first finalizer to be called is the one associated
 with the object marked last in the program.
 The execution of each finalizer may occur at any point during
 the execution of the regular code.


 <p>
 Because the object being collected must still be used by the finalizer,
 it (and other objects accessible only through it)
 must be <em>resurrected</em> by Lua.
 Usually, this resurrection is transient,
 and the object memory is freed in the next garbage-collection cycle.
 However, if the finalizer stores the object in some global place
 (e.g., a global variable),
 then there is a permanent resurrection.
 In any case,
 the object memory is freed only when it becomes completely inaccessible;
 its finalizer will never be called twice.


 <p>
 When you close a state (see <a href="#lua_close"><code>lua_close</code></a>),
 Lua calls the finalizers of all objects marked for finalization,
 following the reverse order that they were marked.
 If any finalizer marks new objects for collection during that phase,
 these new objects will not be finalized.


 <h3>2.5.2 &ndash; <a name="2.5.2">Weak Tables</a></h3>

 <p>
 A <em>weak table</em> is a table whose elements are
 <em>weak references</em>.
 A weak reference is ignored by the garbage collector.
 In other words,
 if the only references to an object are weak references,
 then the garbage collector will collect that object.


 <p>
 A weak table can have weak keys, weak values, or both.
 A table with weak keys allows the collection of its keys,
 but prevents the collection of its values.
 A table with both weak keys and weak values allows the collection of
 both keys and values.
 In any case, if either the key or the value is collected,
 the whole pair is removed from the table.
 The weakness of a table is controlled by the
 <code>__mode</code> field of its metatable.
 If the <code>__mode</code> field is a string containing the character&nbsp;'<code>k</code>',
 the keys in the table are weak.
 If <code>__mode</code> contains '<code>v</code>',
 the values in the table are weak.


 <p>
 A table with weak keys and strong values
 is also called an <em>ephemeron table</em>.
 In an ephemeron table,
 a value is considered reachable only if its key is reachable.
 In particular,
 if the only reference to a key comes through its value,
 the pair is removed.


 <p>
 Any change in the weakness of a table may take effect only
 at the next collect cycle.
 In particular, if you change the weakness to a stronger mode,
 Lua may still collect some items from that table
 before the change takes effect.


 <p>
 Only objects that have an explicit construction
 are removed from weak tables.
 Values, such as numbers and light C functions,
 are not subject to garbage collection,
 and therefore are not removed from weak tables
 (unless its associated value is collected).
 Although strings are subject to garbage collection,
 they do not have an explicit construction,
 and therefore are not removed from weak tables.


 <p>
 Resurrected objects
 (that is, objects being finalized
 and objects accessible only through objects being finalized)
 have a special behavior in weak tables.
 They are removed from weak values before running their finalizers,
 but are removed from weak keys only in the next collection
 after running their finalizers, when such objects are actually freed.
 This behavior allows the finalizer to access properties
 associated with the object through weak tables.


 <p>
 If a weak table is among the resurrected objects in a collection cycle,
 it may not be properly cleared until the next cycle.


 <h2>2.6 &ndash; <a name="2.6">Coroutines</a></h2>

 <p>
 Lua supports coroutines,
 also called <em>collaborative multithreading</em>.
 A coroutine in Lua represents an independent thread of execution.
 Unlike threads in multithread systems, however,
 a coroutine only suspends its execution by explicitly calling
 a yield function.


 <p>
 You create a coroutine by calling <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>.
 Its sole argument is a function
 that is the main function of the coroutine.
 The <code>create</code> function only creates a new coroutine and
 returns a handle to it (an object of type <em>thread</em>);
 it does not start the coroutine.


 <p>
 You execute a coroutine by calling <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
 When you first call <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
 passing as its first argument
 a thread returned by <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
 the coroutine starts its execution,
 at the first line of its main function.
 Extra arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> are passed on
 to the coroutine main function.
 After the coroutine starts running,
 it runs until it terminates or <em>yields</em>.


 <p>
 A coroutine can terminate its execution in two ways:
 normally, when its main function returns
 (explicitly or implicitly, after the last instruction);
 and abnormally, if there is an unprotected error.
 In the first case, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>true</b>,
 plus any values returned by the coroutine main function.
 In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>false</b>
 plus an error message.


 <p>
 A coroutine yields by calling <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
 When a coroutine yields,
 the corresponding <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns immediately,
 even if the yield happens inside nested function calls
 (that is, not in the main function,
 but in a function directly or indirectly called by the main function).
 In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also returns <b>true</b>,
 plus any values passed to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>.
 The next time you resume the same coroutine,
 it continues its execution from the point where it yielded,
 with the call to <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> returning any extra
 arguments passed to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.


 <p>
 Like <a href="#pdf-coroutine.create"><code>coroutine.create</code></a>,
 the <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> function also creates a coroutine,
 but instead of returning the coroutine itself,
 it returns a function that, when called, resumes the coroutine.
 Any arguments passed to this function
 go as extra arguments to <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>.
 <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> returns all the values returned by <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
 except the first one (the boolean error code).
 Unlike <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>,
 <a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> does not catch errors;
 any error is propagated to the caller.


 <p>
 As an example of how coroutines work,
 consider the following code:

 <pre>
      function foo (a)
        print("foo", a)
        return coroutine.yield(2*a)
      end

      co = coroutine.create(function (a,b)
            print("co-body", a, b)
            local r = foo(a+1)
            print("co-body", r)
            local r, s = coroutine.yield(a+b, a-b)
            print("co-body", r, s)
            return b, "end"
      end)

      print("main", coroutine.resume(co, 1, 10))
      print("main", coroutine.resume(co, "r"))
      print("main", coroutine.resume(co, "x", "y"))
      print("main", coroutine.resume(co, "x", "y"))
 </pre><p>
 When you run it, it produces the following output:

 <pre>
      co-body 1       10
      foo     2
      main    true    4
      co-body r
      main    true    11      -9
      co-body x       y
      main    true    10      end
      main    false   cannot resume dead coroutine
 </pre>

 <p>
 You can also create and manipulate coroutines through the C API:
 see functions <a href="#lua_newthread"><code>lua_newthread</code></a>, <a href="#lua_resume"><code>lua_resume</code></a>,
 and <a href="#lua_yield"><code>lua_yield</code></a>.


 <h1>3 &ndash; <a name="3">The Language</a></h1>

 <p>
 This section describes the lexis, the syntax, and the semantics of Lua.
 In other words,
 this section describes
 which tokens are valid,
 how they can be combined,
 and what their combinations mean.


 <p>
 Language constructs will be explained using the usual extended BNF notation,
 in which
 {<em>a</em>}&nbsp;means&nbsp;0 or more <em>a</em>'s, and
 [<em>a</em>]&nbsp;means an optional <em>a</em>.
 Non-terminals are shown like non-terminal,
 keywords are shown like <b>kword</b>,
 and other terminal symbols are shown like &lsquo;<b>=</b>&rsquo;.
 The complete syntax of Lua can be found in <a href="#9">&sect;9</a>
 at the end of this manual.


 <h2>3.1 &ndash; <a name="3.1">Lexical Conventions</a></h2>

 <p>
 Lua is a free-form language.
 It ignores spaces (including new lines) and comments
 between lexical elements (tokens),
 except as delimiters between names and keywords.


 <p>
 <em>Names</em>
 (also called <em>identifiers</em>)
 in Lua can be any string of letters,
 digits, and underscores,
 not beginning with a digit.
 Identifiers are used to name variables, table fields, and labels.


 <p>
 The following <em>keywords</em> are reserved
 and cannot be used as names:


 <pre>
      and       break     do        else      elseif    end
      false     for       function  goto      if        in
      local     nil       not       or        repeat    return
      then      true      until     while
 </pre>

 <p>
 Lua is a case-sensitive language:
 <code>and</code> is a reserved word, but <code>And</code> and <code>AND</code>
 are two different, valid names.
 As a convention, names starting with an underscore followed by
 uppercase letters (such as <a href="#pdf-_VERSION"><code>_VERSION</code></a>)
 are reserved for variables used by Lua.


 <p>
 The following strings denote other tokens:

 <pre>
      +     -     *     /     %     ^     #
      ==    ~=    &lt;=    &gt;=    &lt;     &gt;     =
      (     )     {     }     [     ]     ::
      ;     :     ,     .     ..    ...
 </pre>

 <p>
 <em>Literal strings</em>
 can be delimited by matching single or double quotes,
 and can contain the following C-like escape sequences:
 '<code>\a</code>' (bell),
 '<code>\b</code>' (backspace),
 '<code>\f</code>' (form feed),
 '<code>\n</code>' (newline),
 '<code>\r</code>' (carriage return),
 '<code>\t</code>' (horizontal tab),
 '<code>\v</code>' (vertical tab),
 '<code>\\</code>' (backslash),
 '<code>\"</code>' (quotation mark [double quote]),
 and '<code>\'</code>' (apostrophe [single quote]).
 A backslash followed by a real newline
 results in a newline in the string.
 The escape sequence '<code>\z</code>' skips the following span
 of white-space characters,
 including line breaks;
 it is particularly useful to break and indent a long literal string
 into multiple lines without adding the newlines and spaces
 into the string contents.


 <p>
 A byte in a literal string can also be specified by its numerical value.
 This can be done with the escape sequence <code>\x<em>XX</em></code>,
 where <em>XX</em> is a sequence of exactly two hexadecimal digits,
 or with the escape sequence <code>\<em>ddd</em></code>,
 where <em>ddd</em> is a sequence of up to three decimal digits.
 (Note that if a decimal escape is to be followed by a digit,
 it must be expressed using exactly three digits.)
 Strings in Lua can contain any 8-bit value, including embedded zeros,
 which can be specified as '<code>\0</code>'.


 <p>
 Literal strings can also be defined using a long format
 enclosed by <em>long brackets</em>.
 We define an <em>opening long bracket of level <em>n</em></em> as an opening
 square bracket followed by <em>n</em> equal signs followed by another
 opening square bracket.
 So, an opening long bracket of level&nbsp;0 is written as <code>[[</code>,
 an opening long bracket of level&nbsp;1 is written as <code>[=[</code>,
 and so on.
 A <em>closing long bracket</em> is defined similarly;
 for instance, a closing long bracket of level&nbsp;4 is written as <code>]====]</code>.
 A <em>long literal</em> starts with an opening long bracket of any level and
 ends at the first closing long bracket of the same level.
 It can contain any text except a closing bracket of the proper level.
 Literals in this bracketed form can run for several lines,
 do not interpret any escape sequences,
 and ignore long brackets of any other level.
 Any kind of end-of-line sequence
 (carriage return, newline, carriage return followed by newline,
 or newline followed by carriage return)
 is converted to a simple newline.


 <p>
 Any byte in a literal string not
 explicitly affected by the previous rules represents itself.
 However, Lua opens files for parsing in text mode,
 and the system file functions may have problems with
 some control characters.
 So, it is safer to represent
 non-text data as a quoted literal with
 explicit escape sequences for non-text characters.


 <p>
 For convenience,
 when the opening long bracket is immediately followed by a newline,
 the newline is not included in the string.
 As an example, in a system using ASCII
 (in which '<code>a</code>' is coded as&nbsp;97,
 newline is coded as&nbsp;10, and '<code>1</code>' is coded as&nbsp;49),
 the five literal strings below denote the same string:

 <pre>
      a = 'alo\n123"'
      a = "alo\n123\""
      a = '\97lo\10\04923"'
      a = [[alo
      123"]]
      a = [==[
      alo
      123"]==]
 </pre>

 <p>
 A <em>numerical constant</em> can be written with an optional fractional part
 and an optional decimal exponent,
 marked by a letter '<code>e</code>' or '<code>E</code>'.
 Lua also accepts hexadecimal constants,
 which start with <code>0x</code> or <code>0X</code>.
 Hexadecimal constants also accept an optional fractional part
 plus an optional binary exponent,
 marked by a letter '<code>p</code>' or '<code>P</code>'.
 Examples of valid numerical constants are

 <pre>
      3     3.0     3.1416     314.16e-2     0.31416E1
      0xff  0x0.1E  0xA23p-4   0X1.921FB54442D18P+1
 </pre>

 <p>
 A <em>comment</em> starts with a double hyphen (<code>--</code>)
 anywhere outside a string.
 If the text immediately after <code>--</code> is not an opening long bracket,
 the comment is a <em>short comment</em>,
 which runs until the end of the line.
 Otherwise, it is a <em>long comment</em>,
 which runs until the corresponding closing long bracket.
 Long comments are frequently used to disable code temporarily.


 <h2>3.2 &ndash; <a name="3.2">Variables</a></h2>

 <p>
 Variables are places that store values.
 There are three kinds of variables in Lua:
 global variables, local variables, and table fields.


 <p>
 A single name can denote a global variable or a local variable
 (or a function's formal parameter,
 which is a particular kind of local variable):

 <pre>
 	var ::= Name
 </pre><p>
 Name denotes identifiers, as defined in <a href="#3.1">&sect;3.1</a>.


 <p>
 Any variable name is assumed to be global unless explicitly declared
 as a local (see <a href="#3.3.7">&sect;3.3.7</a>).
 Local variables are <em>lexically scoped</em>:
 local variables can be freely accessed by functions
 defined inside their scope (see <a href="#3.5">&sect;3.5</a>).


 <p>
 Before the first assignment to a variable, its value is <b>nil</b>.


 <p>
 Square brackets are used to index a table:

 <pre>
 	var ::= prefixexp &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo;
 </pre><p>
 The meaning of accesses to table fields can be changed via metatables.
 An access to an indexed variable <code>t[i]</code> is equivalent to
 a call <code>gettable_event(t,i)</code>.
 (See <a href="#2.4">&sect;2.4</a> for a complete description of the
 <code>gettable_event</code> function.
 This function is not defined or callable in Lua.
 We use it here only for explanatory purposes.)


 <p>
 The syntax <code>var.Name</code> is just syntactic sugar for
 <code>var["Name"]</code>:

 <pre>
 	var ::= prefixexp &lsquo;<b>.</b>&rsquo; Name
 </pre>

 <p>
 An access to a global variable <code>x</code>
 is equivalent to <code>_ENV.x</code>.
 Due to the way that chunks are compiled,
 <code>_ENV</code> is never a global name (see <a href="#2.2">&sect;2.2</a>).


 <h2>3.3 &ndash; <a name="3.3">Statements</a></h2>

 <p>
 Lua supports an almost conventional set of statements,
 similar to those in Pascal or C.
 This set includes
 assignments, control structures, function calls,
 and variable declarations.


 <h3>3.3.1 &ndash; <a name="3.3.1">Blocks</a></h3>

 <p>
 A block is a list of statements,
 which are executed sequentially:

 <pre>
 	block ::= {stat}
 </pre><p>
 Lua has <em>empty statements</em>
 that allow you to separate statements with semicolons,
 start a block with a semicolon
 or write two semicolons in sequence:

 <pre>
 	stat ::= &lsquo;<b>;</b>&rsquo;
 </pre>

 <p>
 Function calls and assignments
 can start with an open parenthesis.
 This possibility leads to an ambiguity in Lua's grammar.
 Consider the following fragment:

 <pre>
      a = b + c
      (print or io.write)('done')
 </pre><p>
 The grammar could see it in two ways:

 <pre>
      a = b + c(print or io.write)('done')

      a = b + c; (print or io.write)('done')
 </pre><p>
 The current parser always sees such constructions
 in the first way,
 interpreting the open parenthesis
 as the start of the arguments to a call.
 To avoid this ambiguity,
 it is a good practice to always precede with a semicolon
 statements that start with a parenthesis:

 <pre>
      ;(print or io.write)('done')
 </pre>

 <p>
 A block can be explicitly delimited to produce a single statement:

 <pre>
 	stat ::= <b>do</b> block <b>end</b>
 </pre><p>
 Explicit blocks are useful
 to control the scope of variable declarations.
 Explicit blocks are also sometimes used to
 add a <b>return</b> statement in the middle
 of another block (see <a href="#3.3.4">&sect;3.3.4</a>).


 <h3>3.3.2 &ndash; <a name="3.3.2">Chunks</a></h3>

 <p>
 The unit of compilation of Lua is called a <em>chunk</em>.
 Syntactically,
 a chunk is simply a block:

 <pre>
 	chunk ::= block
 </pre>

 <p>
 Lua handles a chunk as the body of an anonymous function
 with a variable number of arguments
 (see <a href="#3.4.10">&sect;3.4.10</a>).
 As such, chunks can define local variables,
 receive arguments, and return values.
 Moreover, such anonymous function is compiled as in the
 scope of an external local variable called <code>_ENV</code> (see <a href="#2.2">&sect;2.2</a>).
 The resulting function always has <code>_ENV</code> as its only upvalue,
 even if it does not use that variable.


 <p>
 A chunk can be stored in a file or in a string inside the host program.
 To execute a chunk,
 Lua first precompiles the chunk into instructions for a virtual machine,
 and then it executes the compiled code
 with an interpreter for the virtual machine.


 <p>
 Chunks can also be precompiled into binary form;
 see program <code>luac</code> for details.
 Programs in source and compiled forms are interchangeable;
 Lua automatically detects the file type and acts accordingly.


 <h3>3.3.3 &ndash; <a name="3.3.3">Assignment</a></h3>

 <p>
 Lua allows multiple assignments.
 Therefore, the syntax for assignment
 defines a list of variables on the left side
 and a list of expressions on the right side.
 The elements in both lists are separated by commas:

 <pre>
 	stat ::= varlist &lsquo;<b>=</b>&rsquo; explist
 	varlist ::= var {&lsquo;<b>,</b>&rsquo; var}
 	explist ::= exp {&lsquo;<b>,</b>&rsquo; exp}
 </pre><p>
 Expressions are discussed in <a href="#3.4">&sect;3.4</a>.


 <p>
 Before the assignment,
 the list of values is <em>adjusted</em> to the length of
 the list of variables.
 If there are more values than needed,
 the excess values are thrown away.
 If there are fewer values than needed,
 the list is extended with as many  <b>nil</b>'s as needed.
 If the list of expressions ends with a function call,
 then all values returned by that call enter the list of values,
 before the adjustment
 (except when the call is enclosed in parentheses; see <a href="#3.4">&sect;3.4</a>).


 <p>
 The assignment statement first evaluates all its expressions
 and only then are the assignments performed.
 Thus the code

 <pre>
      i = 3
      i, a[i] = i+1, 20
 </pre><p>
 sets <code>a[3]</code> to 20, without affecting <code>a[4]</code>
 because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
 before it is assigned&nbsp;4.
 Similarly, the line

 <pre>
      x, y = y, x
 </pre><p>
 exchanges the values of <code>x</code> and <code>y</code>,
 and

 <pre>
      x, y, z = y, z, x
 </pre><p>
 cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.


 <p>
 The meaning of assignments to global variables
 and table fields can be changed via metatables.
 An assignment to an indexed variable <code>t[i] = val</code> is equivalent to
 <code>settable_event(t,i,val)</code>.
 (See <a href="#2.4">&sect;2.4</a> for a complete description of the
 <code>settable_event</code> function.
 This function is not defined or callable in Lua.
 We use it here only for explanatory purposes.)


 <p>
 An assignment to a global variable <code>x = val</code>
 is equivalent to the assignment
 <code>_ENV.x = val</code> (see <a href="#2.2">&sect;2.2</a>).


 <h3>3.3.4 &ndash; <a name="3.3.4">Control Structures</a></h3><p>
 The control structures
 <b>if</b>, <b>while</b>, and <b>repeat</b> have the usual meaning and
 familiar syntax:


 <pre>
 	stat ::= <b>while</b> exp <b>do</b> block <b>end</b>
 	stat ::= <b>repeat</b> block <b>until</b> exp
 	stat ::= <b>if</b> exp <b>then</b> block {<b>elseif</b> exp <b>then</b> block} [<b>else</b> block] <b>end</b>
 </pre><p>
 Lua also has a <b>for</b> statement, in two flavors (see <a href="#3.3.5">&sect;3.3.5</a>).


 <p>
 The condition expression of a
 control structure can return any value.
 Both <b>false</b> and <b>nil</b> are considered false.
 All values different from <b>nil</b> and <b>false</b> are considered true
 (in particular, the number 0 and the empty string are also true).


 <p>
 In the <b>repeat</b>&ndash;<b>until</b> loop,
 the inner block does not end at the <b>until</b> keyword,
 but only after the condition.
 So, the condition can refer to local variables
 declared inside the loop block.


 <p>
 The <b>goto</b> statement transfers the program control to a label.
 For syntactical reasons,
 labels in Lua are considered statements too:


 <pre>
 	stat ::= <b>goto</b> Name
 	stat ::= label
 	label ::= &lsquo;<b>::</b>&rsquo; Name &lsquo;<b>::</b>&rsquo;
 </pre>

 <p>
 A label is visible in the entire block where it is defined,
 except
 inside nested blocks where a label with the same name is defined and
 inside nested functions.
 A goto may jump to any visible label as long as it does not
 enter into the scope of a local variable.


 <p>
 Labels and empty statements are called <em>void statements</em>,
 as they perform no actions.


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


 <pre>
 	stat ::= <b>break</b>
 </pre><p>
 A <b>break</b> ends the innermost enclosing loop.


 <p>
 The <b>return</b> statement is used to return values
 from a function or a chunk (which is a function in disguise).

 Functions can return more than one value,
 so the syntax for the <b>return</b> statement is

 <pre>
 	stat ::= <b>return</b> [explist] [&lsquo;<b>;</b>&rsquo;]
 </pre>

 <p>
 The <b>return</b> statement can only be written
 as the last statement of a block.
 If it is really necessary to <b>return</b> in the middle of a block,
 then an explicit inner block can be used,
 as in the idiom <code>do return end</code>,
 because now <b>return</b> is the last statement in its (inner) block.


 <h3>3.3.5 &ndash; <a name="3.3.5">For Statement</a></h3>

 <p>

 The <b>for</b> statement has two forms:
 one numeric and one generic.


 <p>
 The numeric <b>for</b> loop repeats a block of code while a
 control variable runs through an arithmetic progression.
 It has the following syntax:

 <pre>
 	stat ::= <b>for</b> Name &lsquo;<b>=</b>&rsquo; exp &lsquo;<b>,</b>&rsquo; exp [&lsquo;<b>,</b>&rsquo; exp] <b>do</b> block <b>end</b>
 </pre><p>
 The <em>block</em> is repeated for <em>name</em> starting at the value of
 the first <em>exp</em>, until it passes the second <em>exp</em> by steps of the
 third <em>exp</em>.
 More precisely, a <b>for</b> statement like

 <pre>
      for v = <em>e1</em>, <em>e2</em>, <em>e3</em> do <em>block</em> end
 </pre><p>
 is equivalent to the code:

 <pre>
      do
        local <em>var</em>, <em>limit</em>, <em>step</em> = tonumber(<em>e1</em>), tonumber(<em>e2</em>), tonumber(<em>e3</em>)
        if not (<em>var</em> and <em>limit</em> and <em>step</em>) then error() end
        while (<em>step</em> &gt; 0 and <em>var</em> &lt;= <em>limit</em>) or (<em>step</em> &lt;= 0 and <em>var</em> &gt;= <em>limit</em>) do
          local v = <em>var</em>
          <em>block</em>
          <em>var</em> = <em>var</em> + <em>step</em>
        end
      end
 </pre><p>
 Note the following:

 <ul>

 <li>
 All three control expressions are evaluated only once,
 before the loop starts.
 They must all result in numbers.
 </li>

 <li>
 <code><em>var</em></code>, <code><em>limit</em></code>, and <code><em>step</em></code> are invisible variables.
 The names shown here are for explanatory purposes only.
 </li>

 <li>
 If the third expression (the step) is absent,
 then a step of&nbsp;1 is used.
 </li>

 <li>
 You can use <b>break</b> to exit a <b>for</b> loop.
 </li>

 <li>
 The loop variable <code>v</code> is local to the loop;
 you cannot use its value after the <b>for</b> ends or is broken.
 If you need this value,
 assign it to another variable before breaking or exiting the loop.
 </li>

 </ul>

 <p>
 The generic <b>for</b> statement works over functions,
 called <em>iterators</em>.
 On each iteration, the iterator function is called to produce a new value,
 stopping when this new value is <b>nil</b>.
 The generic <b>for</b> loop has the following syntax:

 <pre>
 	stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
 	namelist ::= Name {&lsquo;<b>,</b>&rsquo; Name}
 </pre><p>
 A <b>for</b> statement like

 <pre>
      for <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> in <em>explist</em> do <em>block</em> end
 </pre><p>
 is equivalent to the code:

 <pre>
      do
        local <em>f</em>, <em>s</em>, <em>var</em> = <em>explist</em>
        while true do
          local <em>var_1</em>, &middot;&middot;&middot;, <em>var_n</em> = <em>f</em>(<em>s</em>, <em>var</em>)
          if <em>var_1</em> == nil then break end
          <em>var</em> = <em>var_1</em>
          <em>block</em>
        end
      end
 </pre><p>
 Note the following:

 <ul>

 <li>
 <code><em>explist</em></code> is evaluated only once.
 Its results are an <em>iterator</em> function,
 a <em>state</em>,
 and an initial value for the first <em>iterator variable</em>.
 </li>

 <li>
 <code><em>f</em></code>, <code><em>s</em></code>, and <code><em>var</em></code> are invisible variables.
 The names are here for explanatory purposes only.
 </li>

 <li>
 You can use <b>break</b> to exit a <b>for</b> loop.
 </li>

 <li>
 The loop variables <code><em>var_i</em></code> are local to the loop;
 you cannot use their values after the <b>for</b> ends.
 If you need these values,
 then assign them to other variables before breaking or exiting the loop.
 </li>

 </ul>


 <h3>3.3.6 &ndash; <a name="3.3.6">Function Calls as Statements</a></h3><p>
 To allow possible side-effects,
 function calls can be executed as statements:

 <pre>
 	stat ::= functioncall
 </pre><p>
 In this case, all returned values are thrown away.
 Function calls are explained in <a href="#3.4.9">&sect;3.4.9</a>.


 <h3>3.3.7 &ndash; <a name="3.3.7">Local Declarations</a></h3><p>
 Local variables can be declared anywhere inside a block.
 The declaration can include an initial assignment:

 <pre>
 	stat ::= <b>local</b> namelist [&lsquo;<b>=</b>&rsquo; explist]
 </pre><p>
 If present, an initial assignment has the same semantics
 of a multiple assignment (see <a href="#3.3.3">&sect;3.3.3</a>).
 Otherwise, all variables are initialized with <b>nil</b>.


 <p>
 A chunk is also a block (see <a href="#3.3.2">&sect;3.3.2</a>),
 and so local variables can be declared in a chunk outside any explicit block.


 <p>
 The visibility rules for local variables are explained in <a href="#3.5">&sect;3.5</a>.


 <h2>3.4 &ndash; <a name="3.4">Expressions</a></h2>

 <p>
 The basic expressions in Lua are the following:

 <pre>
 	exp ::= prefixexp
 	exp ::= <b>nil</b> | <b>false</b> | <b>true</b>
 	exp ::= Number
 	exp ::= String
 	exp ::= functiondef
 	exp ::= tableconstructor
 	exp ::= &lsquo;<b>...</b>&rsquo;
 	exp ::= exp binop exp
 	exp ::= unop exp
 	prefixexp ::= var | functioncall | &lsquo;<b>(</b>&rsquo; exp &lsquo;<b>)</b>&rsquo;
 </pre>

 <p>
 Numbers and literal strings are explained in <a href="#3.1">&sect;3.1</a>;
 variables are explained in <a href="#3.2">&sect;3.2</a>;
 function definitions are explained in <a href="#3.4.10">&sect;3.4.10</a>;
 function calls are explained in <a href="#3.4.9">&sect;3.4.9</a>;
 table constructors are explained in <a href="#3.4.8">&sect;3.4.8</a>.
 Vararg expressions,
 denoted by three dots ('<code>...</code>'), can only be used when
 directly inside a vararg function;
 they are explained in <a href="#3.4.10">&sect;3.4.10</a>.


 <p>
 Binary operators comprise arithmetic operators (see <a href="#3.4.1">&sect;3.4.1</a>),
 relational operators (see <a href="#3.4.3">&sect;3.4.3</a>), logical operators (see <a href="#3.4.4">&sect;3.4.4</a>),
 and the concatenation operator (see <a href="#3.4.5">&sect;3.4.5</a>).
 Unary operators comprise the unary minus (see <a href="#3.4.1">&sect;3.4.1</a>),
 the unary <b>not</b> (see <a href="#3.4.4">&sect;3.4.4</a>),
 and the unary <em>length operator</em> (see <a href="#3.4.6">&sect;3.4.6</a>).


 <p>
 Both function calls and vararg expressions can result in multiple values.
 If a function call is used as a statement (see <a href="#3.3.6">&sect;3.3.6</a>),
 then its return list is adjusted to zero elements,
 thus discarding all returned values.
 If an expression is used as the last (or the only) element
 of a list of expressions,
 then no adjustment is made
 (unless the expression is enclosed in parentheses).
 In all other contexts,
 Lua adjusts the result list to one element,
 either discarding all values except the first one
 or adding a single <b>nil</b> if there are no values.


 <p>
 Here are some examples:

 <pre>
      f()                -- adjusted to 0 results
      g(f(), x)          -- f() is adjusted to 1 result
      g(x, f())          -- g gets x plus all results from f()
      a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
      a,b = ...          -- a gets the first vararg parameter, b gets
                         -- the second (both a and b can get nil if there
                         -- is no corresponding vararg parameter)

      a,b,c = x, f()     -- f() is adjusted to 2 results
      a,b,c = f()        -- f() is adjusted to 3 results
      return f()         -- returns all results from f()
      return ...         -- returns all received vararg parameters
      return x,y,f()     -- returns x, y, and all results from f()
      {f()}              -- creates a list with all results from f()
      {...}              -- creates a list with all vararg parameters
      {f(), nil}         -- f() is adjusted to 1 result
 </pre>

 <p>
 Any expression enclosed in parentheses always results in only one value.
 Thus,
 <code>(f(x,y,z))</code> is always a single value,
 even if <code>f</code> returns several values.
 (The value of <code>(f(x,y,z))</code> is the first value returned by <code>f</code>
 or <b>nil</b> if <code>f</code> does not return any values.)


 <h3>3.4.1 &ndash; <a name="3.4.1">Arithmetic Operators</a></h3><p>
 Lua supports the usual arithmetic operators:
 the binary <code>+</code> (addition),
 <code>-</code> (subtraction), <code>*</code> (multiplication),
 <code>/</code> (division), <code>%</code> (modulo), and <code>^</code> (exponentiation);
 and unary <code>-</code> (mathematical negation).
 If the operands are numbers, or strings that can be converted to
 numbers (see <a href="#3.4.2">&sect;3.4.2</a>),
 then all operations have the usual meaning.
 Exponentiation works for any exponent.
 For instance, <code>x^(-0.5)</code> computes the inverse of the square root of <code>x</code>.
 Modulo is defined as

 <pre>
      a % b == a - math.floor(a/b)*b
 </pre><p>
 That is, it is the remainder of a division that rounds
 the quotient towards minus infinity.


 <h3>3.4.2 &ndash; <a name="3.4.2">Coercion</a></h3>

 <p>
 Lua provides automatic conversion between
 string and number values at run time.
 Any arithmetic operation applied to a string tries to convert
 this string to a number, following the rules of the Lua lexer.
 (The string may have leading and trailing spaces and a sign.)
 Conversely, whenever a number is used where a string is expected,
 the number is converted to a string, in a reasonable format.
 For complete control over how numbers are converted to strings,
 use the <code>format</code> function from the string library
 (see <a href="#pdf-string.format"><code>string.format</code></a>).


 <h3>3.4.3 &ndash; <a name="3.4.3">Relational Operators</a></h3><p>
 The relational operators in Lua are

 <pre>
      ==    ~=    &lt;     &gt;     &lt;=    &gt;=
 </pre><p>
 These operators always result in <b>false</b> or <b>true</b>.


 <p>
 Equality (<code>==</code>) first compares the type of its operands.
 If the types are different, then the result is <b>false</b>.
 Otherwise, the values of the operands are compared.
 Numbers and strings are compared in the usual way.
 Tables, userdata, and threads
 are compared by reference:
 two objects are considered equal only if they are the same object.
 Every time you create a new object
 (a table, userdata, or thread),
 this new object is different from any previously existing object.
 Closures with the same reference are always equal.
 Closures with any detectable difference
 (different behavior, different definition) are always different.


 <p>
 You can change the way that Lua compares tables and userdata
 by using the "eq" metamethod (see <a href="#2.4">&sect;2.4</a>).


 <p>
 The conversion rules of <a href="#3.4.2">&sect;3.4.2</a>
 do not apply to equality comparisons.
 Thus, <code>"0"==0</code> evaluates to <b>false</b>,
 and <code>t[0]</code> and <code>t["0"]</code> denote different
 entries in a table.


 <p>
 The operator <code>~=</code> is exactly the negation of equality (<code>==</code>).


 <p>
 The order operators work as follows.
 If both arguments are numbers, then they are compared as such.
 Otherwise, if both arguments are strings,
 then their values are compared according to the current locale.
 Otherwise, Lua tries to call the "lt" or the "le"
 metamethod (see <a href="#2.4">&sect;2.4</a>).
 A comparison <code>a &gt; b</code> is translated to <code>b &lt; a</code>
 and <code>a &gt;= b</code> is translated to <code>b &lt;= a</code>.


 <h3>3.4.4 &ndash; <a name="3.4.4">Logical Operators</a></h3><p>
 The logical operators in Lua are
 <b>and</b>, <b>or</b>, and <b>not</b>.
 Like the control structures (see <a href="#3.3.4">&sect;3.3.4</a>),
 all logical operators consider both <b>false</b> and <b>nil</b> as false
 and anything else as true.


 <p>
 The negation operator <b>not</b> always returns <b>false</b> or <b>true</b>.
 The conjunction operator <b>and</b> returns its first argument
 if this value is <b>false</b> or <b>nil</b>;
 otherwise, <b>and</b> returns its second argument.
 The disjunction operator <b>or</b> returns its first argument
 if this value is different from <b>nil</b> and <b>false</b>;
 otherwise, <b>or</b> returns its second argument.
 Both <b>and</b> and <b>or</b> use short-cut evaluation;
 that is,
 the second operand is evaluated only if necessary.
 Here are some examples:

 <pre>
      10 or 20            --&gt; 10
      10 or error()       --&gt; 10
      nil or "a"          --&gt; "a"
      nil and 10          --&gt; nil
      false and error()   --&gt; false
      false and nil       --&gt; false
      false or nil        --&gt; nil
      10 and 20           --&gt; 20
 </pre><p>
 (In this manual,
 <code>--&gt;</code> indicates the result of the preceding expression.)


 <h3>3.4.5 &ndash; <a name="3.4.5">Concatenation</a></h3><p>
 The string concatenation operator in Lua is
 denoted by two dots ('<code>..</code>').
 If both operands are strings or numbers, then they are converted to
 strings according to the rules mentioned in <a href="#3.4.2">&sect;3.4.2</a>.
 Otherwise, the <code>__concat</code> metamethod is called (see <a href="#2.4">&sect;2.4</a>).


 <h3>3.4.6 &ndash; <a name="3.4.6">The Length Operator</a></h3>

 <p>
 The length operator is denoted by the unary prefix operator <code>#</code>.
 The length of a string is its number of bytes
 (that is, the usual meaning of string length when each
 character is one byte).


 <p>
 A program can modify the behavior of the length operator for
 any value but strings through the <code>__len</code> metamethod (see <a href="#2.4">&sect;2.4</a>).


 <p>
 Unless a <code>__len</code> metamethod is given,
 the length of a table <code>t</code> is only defined if the
 table is a <em>sequence</em>,
 that is,
 the set of its positive numeric keys is equal to <em>{1..n}</em>
 for some integer <em>n</em>.
 In that case, <em>n</em> is its length.
 Note that a table like

 <pre>
      {10, 20, nil, 40}
 </pre><p>
 is not a sequence, because it has the key <code>4</code>
 but does not have the key <code>3</code>.
 (So, there is no <em>n</em> such that the set <em>{1..n}</em> is equal
 to the set of positive numeric keys of that table.)
 Note, however, that non-numeric keys do not interfere
 with whether a table is a sequence.


 <h3>3.4.7 &ndash; <a name="3.4.7">Precedence</a></h3><p>
 Operator precedence in Lua follows the table below,
 from lower to higher priority:

 <pre>
      or
      and
      &lt;     &gt;     &lt;=    &gt;=    ~=    ==
      ..
      +     -
      *     /     %
      not   #     - (unary)
      ^
 </pre><p>
 As usual,
 you can use parentheses to change the precedences of an expression.
 The concatenation ('<code>..</code>') and exponentiation ('<code>^</code>')
 operators are right associative.
 All other binary operators are left associative.


 <h3>3.4.8 &ndash; <a name="3.4.8">Table Constructors</a></h3><p>
 Table constructors are expressions that create tables.
 Every time a constructor is evaluated, a new table is created.
 A constructor can be used to create an empty table
 or to create a table and initialize some of its fields.
 The general syntax for constructors is

 <pre>
 	tableconstructor ::= &lsquo;<b>{</b>&rsquo; [fieldlist] &lsquo;<b>}</b>&rsquo;
 	fieldlist ::= field {fieldsep field} [fieldsep]
 	field ::= &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo; &lsquo;<b>=</b>&rsquo; exp | Name &lsquo;<b>=</b>&rsquo; exp | exp
 	fieldsep ::= &lsquo;<b>,</b>&rsquo; | &lsquo;<b>;</b>&rsquo;
 </pre>

 <p>
 Each field of the form <code>[exp1] = exp2</code> adds to the new table an entry
 with key <code>exp1</code> and value <code>exp2</code>.
 A field of the form <code>name = exp</code> is equivalent to
 <code>["name"] = exp</code>.
 Finally, fields of the form <code>exp</code> are equivalent to
 <code>[i] = exp</code>, where <code>i</code> are consecutive numerical integers,
 starting with 1.
 Fields in the other formats do not affect this counting.
 For example,

 <pre>
      a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
 </pre><p>
 is equivalent to

 <pre>
      do
        local t = {}
        t[f(1)] = g
        t[1] = "x"         -- 1st exp
        t[2] = "y"         -- 2nd exp
        t.x = 1            -- t["x"] = 1
        t[3] = f(x)        -- 3rd exp
        t[30] = 23
        t[4] = 45          -- 4th exp
        a = t
      end
 </pre>

 <p>
 If the last field in the list has the form <code>exp</code>
 and the expression is a function call or a vararg expression,
 then all values returned by this expression enter the list consecutively
 (see <a href="#3.4.9">&sect;3.4.9</a>).


 <p>
 The field list can have an optional trailing separator,
 as a convenience for machine-generated code.


 <h3>3.4.9 &ndash; <a name="3.4.9">Function Calls</a></h3><p>
 A function call in Lua has the following syntax:

 <pre>
 	functioncall ::= prefixexp args
 </pre><p>
 In a function call,
 first prefixexp and args are evaluated.
 If the value of prefixexp has type <em>function</em>,
 then this function is called
 with the given arguments.
 Otherwise, the prefixexp "call" metamethod is called,
 having as first parameter the value of prefixexp,
 followed by the original call arguments
 (see <a href="#2.4">&sect;2.4</a>).


 <p>
 The form

 <pre>
 	functioncall ::= prefixexp &lsquo;<b>:</b>&rsquo; Name args
 </pre><p>
 can be used to call "methods".
 A call <code>v:name(<em>args</em>)</code>
 is syntactic sugar for <code>v.name(v,<em>args</em>)</code>,
 except that <code>v</code> is evaluated only once.


 <p>
 Arguments have the following syntax:

 <pre>
 	args ::= &lsquo;<b>(</b>&rsquo; [explist] &lsquo;<b>)</b>&rsquo;
 	args ::= tableconstructor
 	args ::= String
 </pre><p>
 All argument expressions are evaluated before the call.
 A call of the form <code>f{<em>fields</em>}</code> is
 syntactic sugar for <code>f({<em>fields</em>})</code>;
 that is, the argument list is a single new table.
 A call of the form <code>f'<em>string</em>'</code>
 (or <code>f"<em>string</em>"</code> or <code>f[[<em>string</em>]]</code>)
 is syntactic sugar for <code>f('<em>string</em>')</code>;
 that is, the argument list is a single literal string.


 <p>
 A call of the form <code>return <em>functioncall</em></code> is called
 a <em>tail call</em>.
 Lua implements <em>proper tail calls</em>
 (or <em>proper tail recursion</em>):
 in a tail call,
 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.
 However, a tail call erases any debug information about the
 calling function.
 Note that a tail call only happens with a particular syntax,
 where the <b>return</b> has one single function call as argument;
 this syntax makes the calling function return exactly
 the returns of the called function.
 So, none of the following examples are tail calls:

 <pre>
      return (f(x))        -- results adjusted to 1
      return 2 * f(x)
      return x, f(x)       -- additional results
      f(x); return         -- results discarded
      return x or f(x)     -- results adjusted to 1
 </pre>


 <h3>3.4.10 &ndash; <a name="3.4.10">Function Definitions</a></h3>

 <p>
 The syntax for function definition is

 <pre>
 	functiondef ::= <b>function</b> funcbody
 	funcbody ::= &lsquo;<b>(</b>&rsquo; [parlist] &lsquo;<b>)</b>&rsquo; block <b>end</b>
 </pre>

 <p>
 The following syntactic sugar simplifies function definitions:

 <pre>
 	stat ::= <b>function</b> funcname funcbody
 	stat ::= <b>local</b> <b>function</b> Name funcbody
 	funcname ::= Name {&lsquo;<b>.</b>&rsquo; Name} [&lsquo;<b>:</b>&rsquo; Name]
 </pre><p>
 The statement

 <pre>
      function f () <em>body</em> end
 </pre><p>
 translates to

 <pre>
      f = function () <em>body</em> end
 </pre><p>
 The statement

 <pre>
      function t.a.b.c.f () <em>body</em> end
 </pre><p>
 translates to

 <pre>
      t.a.b.c.f = function () <em>body</em> end
 </pre><p>
 The statement

 <pre>
      local function f () <em>body</em> end
 </pre><p>
 translates to

 <pre>
      local f; f = function () <em>body</em> end
 </pre><p>
 not to

 <pre>
      local f = function () <em>body</em> end
 </pre><p>
 (This only makes a difference when the body of the function
 contains references to <code>f</code>.)


 <p>
 A function definition is an executable expression,
 whose value has type <em>function</em>.
 When Lua precompiles a chunk,
 all its function bodies are precompiled too.
 Then, whenever Lua executes the function definition,
 the function is <em>instantiated</em> (or <em>closed</em>).
 This function instance (or <em>closure</em>)
 is the final value of the expression.


 <p>
 Parameters act as local variables that are
 initialized with the argument values:

 <pre>
 	parlist ::= namelist [&lsquo;<b>,</b>&rsquo; &lsquo;<b>...</b>&rsquo;] | &lsquo;<b>...</b>&rsquo;
 </pre><p>
 When a function is called,
 the list of arguments is adjusted to
 the length of the list of parameters,
 unless the function is a <em>vararg function</em>,
 which is indicated by three dots ('<code>...</code>')
 at the end of its parameter list.
 A vararg function does not adjust its argument 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,
 similar to a function with multiple results.
 If a vararg expression is used inside another expression
 or in the middle of a list of expressions,
 then its return list is adjusted to one element.
 If the expression is used as the last element of a list of expressions,
 then no adjustment is made
 (unless that last expression is enclosed in parentheses).


 <p>
 As an example, consider the following definitions:

 <pre>
      function f(a, b) end
      function g(a, b, ...) end
      function r() return 1,2,3 end
 </pre><p>
 Then, we have the following mapping from arguments to parameters and
 to the vararg expression:

 <pre>
      CALL            PARAMETERS

      f(3)             a=3, b=nil
      f(3, 4)          a=3, b=4
      f(3, 4, 5)       a=3, b=4
      f(r(), 10)       a=1, b=10
      f(r())           a=1, b=2

      g(3)             a=3, b=nil, ... --&gt;  (nothing)
      g(3, 4)          a=3, b=4,   ... --&gt;  (nothing)
      g(3, 4, 5, 8)    a=3, b=4,   ... --&gt;  5  8
      g(5, r())        a=5, b=1,   ... --&gt;  2  3
 </pre>

 <p>
 Results are returned using the <b>return</b> statement (see <a href="#3.3.4">&sect;3.3.4</a>).
 If control reaches the end of a function
 without encountering a <b>return</b> statement,
 then the function returns with no results.


 <p>

 There is a system-dependent limit on the number of values
 that a function may return.
 This limit is guaranteed to be larger than 1000.


 <p>
 The <em>colon</em> syntax
 is used for defining <em>methods</em>,
 that is, functions that have an implicit extra parameter <code>self</code>.
 Thus, the statement

 <pre>
      function t.a.b.c:f (<em>params</em>) <em>body</em> end
 </pre><p>
 is syntactic sugar for

 <pre>
      t.a.b.c.f = function (self, <em>params</em>) <em>body</em> end
 </pre>


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

 <p>

 Lua is a lexically scoped language.
 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>
      x = 10                -- global variable
      do                    -- new block
        local x = x         -- new 'x', with value 10
        print(x)            --&gt; 10
        x = x+1
        do                  -- another block
          local x = x+1     -- another 'x'
          print(x)          --&gt; 12
        end
        print(x)            --&gt; 11
      end
      print(x)              --&gt; 10  (the global one)
 </pre>

 <p>
 Notice that, in a declaration like <code>local x = x</code>,
 the new <code>x</code> being declared is not in scope yet,
 and so the second <code>x</code> refers to the outside variable.


 <p>
 Because of the lexical scoping rules,
 local variables can be freely accessed by functions
 defined inside their scope.
 A local variable used by an inner function is called
 an <em>upvalue</em>, or <em>external local variable</em>,
 inside the inner function.


 <p>
 Notice that each execution of a <b>local</b> statement
 defines new local variables.
 Consider the following example:

 <pre>
      a = {}
      local x = 20
      for i=1,10 do
        local y = 0
        a[i] = function () y=y+1; return x+y end
      end
 </pre><p>
 The loop creates ten closures
 (that is, ten instances of the anonymous function).
 Each of these closures uses a different <code>y</code> variable,
 while all of them share the same <code>x</code>.


 <h1>4 &ndash; <a name="4">The Application Program Interface</a></h1>

 <p>

 This section describes the C&nbsp;API for Lua, that is,
 the set of C&nbsp;functions available to the host program to communicate
 with Lua.
 All API functions and related types and constants
 are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.


 <p>
 Even when we use the term "function",
 any facility in the API may be provided as a macro instead.
 Except where stated otherwise,
 all such macros use each of their arguments exactly once
 (except for the first argument, which is always a Lua state),
 and so do not generate any hidden side-effects.


 <p>
 As in most C&nbsp;libraries,
 the Lua API functions do not check their arguments for validity or consistency.
 However, you can change this behavior by compiling Lua
 with the macro <a name="pdf-LUA_USE_APICHECK"><code>LUA_USE_APICHECK</code></a> defined.


 <h2>4.1 &ndash; <a name="4.1">The Stack</a></h2>

 <p>
 Lua uses a <em>virtual stack</em> to pass values to and from C.
 Each element in this stack represents a Lua value
 (<b>nil</b>, number, string, etc.).


 <p>
 Whenever Lua calls C, the called function gets a new stack,
 which is independent of previous stacks and of stacks of
 C&nbsp;functions that are still active.
 This stack initially contains any arguments to the C&nbsp;function
 and it is where the C&nbsp;function pushes its results
 to be returned to the caller (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>).


 <p>
 For convenience,
 most query operations in the API do not follow a strict stack discipline.
 Instead, they can refer to any element in the stack
 by using an <em>index</em>:
 A positive index represents an absolute stack position
 (starting at&nbsp;1);
 a negative index represents an offset relative to the top of the stack.
 More specifically, if the stack has <em>n</em> elements,
 then index&nbsp;1 represents the first element
 (that is, the element that was pushed onto the stack first)
 and
 index&nbsp;<em>n</em> represents the last element;
 index&nbsp;-1 also represents the last element
 (that is, the element at the&nbsp;top)
 and index <em>-n</em> represents the first element.


 <h2>4.2 &ndash; <a name="4.2">Stack Size</a></h2>

 <p>
 When you interact with the Lua API,
 you are responsible for ensuring consistency.
 In particular,
 <em>you are responsible for controlling stack overflow</em>.
 You can use the function <a href="#lua_checkstack"><code>lua_checkstack</code></a>
 to ensure that the stack has extra slots when pushing new elements.


 <p>
 Whenever Lua calls C,
 it ensures that the stack has at least <a name="pdf-LUA_MINSTACK"><code>LUA_MINSTACK</code></a> extra slots.
 <code>LUA_MINSTACK</code> is defined as 20,
 so that usually you do not have to worry about stack space
 unless your code has loops pushing elements onto the stack.


 <p>
 When you call a Lua function
 without a fixed number of results (see <a href="#lua_call"><code>lua_call</code></a>),
 Lua ensures that the stack has enough size for all results,
 but it does not ensure any extra space.
 So, before pushing anything in the stack after such a call
 you should use <a href="#lua_checkstack"><code>lua_checkstack</code></a>.


 <h2>4.3 &ndash; <a name="4.3">Valid and Acceptable Indices</a></h2>

 <p>
 Any function in the API that receives stack indices
 works only with <em>valid indices</em> or <em>acceptable indices</em>.


 <p>
 A <em>valid index</em> is an index that refers to a
 real position within the stack, that is,
 its position lies between&nbsp;1 and the stack top
 (<code>1 &le; abs(index) &le; top</code>).

 Usually, functions that can modify the value at an index
 require valid indices.


 <p>
 Unless otherwise noted,
 any function that accepts valid indices also accepts <em>pseudo-indices</em>,
 which represent some Lua values that are accessible to C&nbsp;code
 but which are not in the stack.
 Pseudo-indices are used to access the registry
 and the upvalues of a C&nbsp;function (see <a href="#4.4">&sect;4.4</a>).


 <p>
 Functions that do not need a specific stack position,
 but only a value in the stack (e.g., query functions),
 can be called with acceptable indices.
 An <em>acceptable index</em> can be any valid index,
 including the pseudo-indices,
 but it also can be any positive index after the stack top
 within the space allocated for the stack,
 that is, indices up to the stack size.
 (Note that 0 is never an acceptable index.)
 Except when noted otherwise,
 functions in the API work with acceptable indices.


 <p>
 Acceptable indices serve to avoid extra tests
 against the stack top when querying the stack.
 For instance, a C&nbsp;function can query its third argument
 without the need to first check whether there is a third argument,
 that is, without the need to check whether 3 is a valid index.


 <p>
 For functions that can be called with acceptable indices,
 any non-valid index is treated as if it
 contains a value of a virtual type <a name="pdf-LUA_TNONE"><code>LUA_TNONE</code></a>,
 which behaves like a nil value.


 <h2>4.4 &ndash; <a name="4.4">C Closures</a></h2>

 <p>
 When a C&nbsp;function is created,
 it is possible to associate some values with it,
 thus creating a <em>C&nbsp;closure</em>
 (see <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a>);
 these values are called <em>upvalues</em> and are
 accessible to the function whenever it is called.


 <p>
 Whenever a C&nbsp;function is called,
 its upvalues are located at specific pseudo-indices.
 These pseudo-indices are produced by the macro
 <a href="#lua_upvalueindex"><code>lua_upvalueindex</code></a>.
 The first value associated with a function is at position
 <code>lua_upvalueindex(1)</code>, and so on.
 Any access to <code>lua_upvalueindex(<em>n</em>)</code>,
 where <em>n</em> is greater than the number of upvalues of the
 current function (but not greater than 256),
 produces an acceptable but invalid index.


 <h2>4.5 &ndash; <a name="4.5">Registry</a></h2>

 <p>
 Lua provides a <em>registry</em>,
 a predefined table that can be used by any C&nbsp;code to
 store whatever Lua values it needs to store.
 The registry table is always located at pseudo-index
 <a name="pdf-LUA_REGISTRYINDEX"><code>LUA_REGISTRYINDEX</code></a>,
 which is a valid index.
 Any C&nbsp;library can store data into this table,
 but it should take care to choose keys
 that are different from those used
 by other libraries, to avoid collisions.
 Typically, you should use as key a string containing your library name,
 or a light userdata with the address of a C&nbsp;object in your code,
 or any Lua object created by your code.
 As with global names,
 string keys starting with an underscore followed by
 uppercase letters are reserved for Lua.


 <p>
 The integer keys in the registry are used by the reference mechanism,
 implemented by the auxiliary library,
 and by some predefined values.
 Therefore, integer keys should not be used for other purposes.


 <p>
 When you create a new Lua state,
 its registry comes with some predefined values.
 These predefined values are indexed with integer keys
 defined as constants in <code>lua.h</code>.
 The following constants are defined:

 <ul>
 <li><b><a name="pdf-LUA_RIDX_MAINTHREAD"><code>LUA_RIDX_MAINTHREAD</code></a>: </b> At this index the registry has
 the main thread of the state.
 (The main thread is the one created together with the state.)
 </li>

 <li><b><a name="pdf-LUA_RIDX_GLOBALS"><code>LUA_RIDX_GLOBALS</code></a>: </b> At this index the registry has
 the global environment.
 </li>
 </ul>


 <h2>4.6 &ndash; <a name="4.6">Error Handling in C</a></h2>

 <p>
 Internally, Lua uses the C <code>longjmp</code> facility to handle errors.
 (You can also choose to use exceptions if you compile Lua as C++;
 search for <code>LUAI_THROW</code> in the source code.)
 When Lua faces any error
 (such as a memory allocation error, type errors, syntax errors,
 and runtime errors)
 it <em>raises</em> an error;
 that is, it does a long jump.
 A <em>protected environment</em> uses <code>setjmp</code>
 to set a recovery point;
 any error jumps to the most recent active recovery point.


 <p>
 If an error happens outside any protected environment,
 Lua calls a <em>panic function</em> (see <a href="#lua_atpanic"><code>lua_atpanic</code></a>)
 and then calls <code>abort</code>,
 thus exiting the host application.
 Your panic function can avoid this exit by
 never returning
 (e.g., doing a long jump to your own recovery point outside Lua).


 <p>
 The panic function runs as if it were a message handler (see <a href="#2.3">&sect;2.3</a>);
 in particular, the error message is at the top of the stack.
 However, there is no guarantees about stack space.
 To push anything on the stack,
 the panic function should first check the available space (see <a href="#4.2">&sect;4.2</a>).


 <p>
 Most functions in the API can throw an error,
 for instance due to a memory allocation error.
 The documentation for each function indicates whether
 it can throw errors.


 <p>
 Inside a C&nbsp;function you can throw an error by calling <a href="#lua_error"><code>lua_error</code></a>.


 <h2>4.7 &ndash; <a name="4.7">Handling Yields in C</a></h2>

 <p>
 Internally, Lua uses the C <code>longjmp</code> facility to yield a coroutine.
 Therefore, if a function <code>foo</code> calls an API function
 and this API function yields
 (directly or indirectly by calling another function that yields),
 Lua cannot return to <code>foo</code> any more,
 because the <code>longjmp</code> removes its frame from the C stack.


 <p>
 To avoid this kind of problem,
 Lua raises an error whenever it tries to yield across an API call,
 except for three functions:
 <a href="#lua_yieldk"><code>lua_yieldk</code></a>, <a href="#lua_callk"><code>lua_callk</code></a>, and <a href="#lua_pcallk"><code>lua_pcallk</code></a>.
 All those functions receive a <em>continuation function</em>
 (as a parameter called <code>k</code>) to continue execution after a yield.


 <p>
 We need to set some terminology to explain continuations.
 We have a C function called from Lua which we will call
 the <em>original function</em>.
 This original function then calls one of those three functions in the C API,
 which we will call the <em>callee function</em>,
 that then yields the current thread.
 (This can happen when the callee function is <a href="#lua_yieldk"><code>lua_yieldk</code></a>,
 or when the callee function is either <a href="#lua_callk"><code>lua_callk</code></a> or <a href="#lua_pcallk"><code>lua_pcallk</code></a>
 and the function called by them yields.)


 <p>
 Suppose the running thread yields while executing the callee function.
 After the thread resumes,
 it eventually will finish running the callee function.
 However,
 the callee function cannot return to the original function,
 because its frame in the C stack was destroyed by the yield.
 Instead, Lua calls a <em>continuation function</em>,
 which was given as an argument to the callee function.
 As the name implies,
 the continuation function should continue the task
 of the original function.


 <p>
 Lua treats the continuation function as if it were the original function.
 The continuation function receives the same Lua stack
 from the original function,
 in the same state it would be if the callee function had returned.
 (For instance,
 after a <a href="#lua_callk"><code>lua_callk</code></a> the function and its arguments are
 removed from the stack and replaced by the results from the call.)
 It also has the same upvalues.
 Whatever it returns is handled by Lua as if it were the return
 of the original function.


 <p>
 The only difference in the Lua state between the original function
 and its continuation is the result of a call to <a href="#lua_getctx"><code>lua_getctx</code></a>.


 <h2>4.8 &ndash; <a name="4.8">Functions and Types</a></h2>

 <p>
 Here we list all functions and types from the C&nbsp;API in
 alphabetical order.
 Each function has an indicator like this:
 <span class="apii">[-o, +p, <em>x</em>]</span>


 <p>
 The first field, <code>o</code>,
 is how many elements the function pops from the stack.
 The second field, <code>p</code>,
 is how many elements the function pushes onto the stack.
 (Any function always pushes its results after popping its arguments.)
 A field in the form <code>x|y</code> means the function can push (or pop)
 <code>x</code> or <code>y</code> elements,
 depending on the situation;
 an interrogation mark '<code>?</code>' means that
 we cannot know how many elements the function pops/pushes
 by looking only at its arguments
 (e.g., they may depend on what is on the stack).
 The third field, <code>x</code>,
 tells whether the function may throw errors:
 '<code>-</code>' means the function never throws any error;
 '<code>e</code>' means the function may throw errors;
 '<code>v</code>' means the function may throw an error on purpose.


 <hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_absindex (lua_State *L, int idx);</pre>

 <p>
 Converts the acceptable index <code>idx</code> into an absolute index
 (that is, one that does not depend on the stack top).


 <hr><h3><a name="lua_Alloc"><code>lua_Alloc</code></a></h3>
 <pre>typedef void * (*lua_Alloc) (void *ud,
                              void *ptr,
                              size_t osize,
                              size_t nsize);</pre>

 <p>
 The type of the memory-allocation function used by Lua states.
 The allocator function must provide a
 functionality similar to <code>realloc</code>,
 but not exactly the same.
 Its arguments are
 <code>ud</code>, an opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>;
 <code>ptr</code>, a pointer to the block being allocated/reallocated/freed;
 <code>osize</code>, the original size of the block or some code about what
 is being allocated;
 <code>nsize</code>, the new size of the block.


 <p>
 When <code>ptr</code> is not <code>NULL</code>,
 <code>osize</code> is the size of the block pointed by <code>ptr</code>,
 that is, the size given when it was allocated or reallocated.


 <p>
 When <code>ptr</code> is <code>NULL</code>,
 <code>osize</code> encodes the kind of object that Lua is allocating.
 <code>osize</code> is any of
 <a href="#pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, <a href="#pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, <a href="#pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>,
 <a href="#pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, or <a href="#pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a> when (and only when)
 Lua is creating a new object of that type.
 When <code>osize</code> is some other value,
 Lua is allocating memory for something else.


 <p>
 Lua assumes the following behavior from the allocator function:


 <p>
 When <code>nsize</code> is zero,
 the allocator should behave like <code>free</code>
 and return <code>NULL</code>.


 <p>
 When <code>nsize</code> is not zero,
 the allocator should behave like <code>realloc</code>.
 The allocator returns <code>NULL</code>
 if and only if it cannot fulfill the request.
 Lua assumes that the allocator never fails when
 <code>osize &gt;= nsize</code>.


 <p>
 Here is a simple implementation for the allocator function.
 It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.

 <pre>
      static void *l_alloc (void *ud, void *ptr, size_t osize,
                                                 size_t nsize) {
        (void)ud;  (void)osize;  /* not used */
        if (nsize == 0) {
          free(ptr);
          return NULL;
        }
        else
          return realloc(ptr, nsize);
      }
 </pre><p>
 Note that Standard&nbsp;C ensures
 that <code>free(NULL)</code> has no effect and that
 <code>realloc(NULL, size)</code> is equivalent to <code>malloc(size)</code>.
 This code assumes that <code>realloc</code> does not fail when shrinking a block.
 (Although Standard&nbsp;C does not ensure this behavior,
 it seems to be a safe assumption.)


 <hr><h3><a name="lua_arith"><code>lua_arith</code></a></h3><p>
 <span class="apii">[-(2|1), +1, <em>e</em>]</span>
 <pre>void lua_arith (lua_State *L, int op);</pre>

 <p>
 Performs an arithmetic operation over the two values
 (or one, in the case of negation)
 at the top of the stack,
 with the value at the top being the second operand,
 pops these values, and pushes the result of the operation.
 The function follows the semantics of the corresponding Lua operator
 (that is, it may call metamethods).


 <p>
 The value of <code>op</code> must be one of the following constants:

 <ul>

 <li><b><a name="pdf-LUA_OPADD"><code>LUA_OPADD</code></a>: </b> performs addition (<code>+</code>)</li>
 <li><b><a name="pdf-LUA_OPSUB"><code>LUA_OPSUB</code></a>: </b> performs subtraction (<code>-</code>)</li>
 <li><b><a name="pdf-LUA_OPMUL"><code>LUA_OPMUL</code></a>: </b> performs multiplication (<code>*</code>)</li>
 <li><b><a name="pdf-LUA_OPDIV"><code>LUA_OPDIV</code></a>: </b> performs division (<code>/</code>)</li>
 <li><b><a name="pdf-LUA_OPMOD"><code>LUA_OPMOD</code></a>: </b> performs modulo (<code>%</code>)</li>
 <li><b><a name="pdf-LUA_OPPOW"><code>LUA_OPPOW</code></a>: </b> performs exponentiation (<code>^</code>)</li>
 <li><b><a name="pdf-LUA_OPUNM"><code>LUA_OPUNM</code></a>: </b> performs mathematical negation (unary <code>-</code>)</li>

 </ul>


 <hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);</pre>

 <p>
 Sets a new panic function and returns the old one (see <a href="#4.6">&sect;4.6</a>).


 <hr><h3><a name="lua_call"><code>lua_call</code></a></h3><p>
 <span class="apii">[-(nargs+1), +nresults, <em>e</em>]</span>
 <pre>void lua_call (lua_State *L, int nargs, int nresults);</pre>

 <p>
 Calls a function.


 <p>
 To call a function you must use the following protocol:
 first, the function to be called is pushed onto the stack;
 then, the arguments to the function are pushed
 in direct order;
 that is, the first argument is pushed first.
 Finally you call <a href="#lua_call"><code>lua_call</code></a>;
 <code>nargs</code> is the number of arguments that you pushed onto the stack.
 All arguments and the function value are popped from the stack
 when the function is called.
 The function results are pushed onto the stack when the function returns.
 The number of results is adjusted to <code>nresults</code>,
 unless <code>nresults</code> is <a name="pdf-LUA_MULTRET"><code>LUA_MULTRET</code></a>.
 In this case, all results from the function are pushed.
 Lua takes care that the returned values fit into the stack space.
 The function results are pushed onto the stack in direct order
 (the first result is pushed first),
 so that after the call the last result is on the top of the stack.


 <p>
 Any error inside the called function is propagated upwards
 (with a <code>longjmp</code>).


 <p>
 The following example shows how the host program can do the
 equivalent to this Lua code:

 <pre>
      a = f("how", t.x, 14)
 </pre><p>
 Here it is in&nbsp;C:

 <pre>
      lua_getglobal(L, "f");                  /* function to be called */
      lua_pushstring(L, "how");                        /* 1st argument */
      lua_getglobal(L, "t");                    /* table to be indexed */
      lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
      lua_remove(L, -2);                  /* remove 't' from the stack */
      lua_pushinteger(L, 14);                          /* 3rd argument */
      lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
      lua_setglobal(L, "a");                         /* set global 'a' */
 </pre><p>
 Note that the code above is "balanced":
 at its end, the stack is back to its original configuration.
 This is considered good programming practice.


 <hr><h3><a name="lua_callk"><code>lua_callk</code></a></h3><p>
 <span class="apii">[-(nargs + 1), +nresults, <em>e</em>]</span>
 <pre>void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
                 lua_CFunction k);</pre>

 <p>
 This function behaves exactly like <a href="#lua_call"><code>lua_call</code></a>,
 but allows the called function to yield (see <a href="#4.7">&sect;4.7</a>).


 <hr><h3><a name="lua_CFunction"><code>lua_CFunction</code></a></h3>
 <pre>typedef int (*lua_CFunction) (lua_State *L);</pre>

 <p>
 Type for C&nbsp;functions.


 <p>
 In order to communicate properly with Lua,
 a C&nbsp;function must use the following protocol,
 which defines the way parameters and results are passed:
 a C&nbsp;function receives its arguments from Lua in its stack
 in direct order (the first argument is pushed first).
 So, when the function starts,
 <code>lua_gettop(L)</code> returns the number of arguments received by the function.
 The first argument (if any) is at index 1
 and its last argument is at index <code>lua_gettop(L)</code>.
 To return values to Lua, a C&nbsp;function just pushes them onto the stack,
 in direct order (the first result is pushed first),
 and returns the number of results.
 Any other value in the stack below the results will be properly
 discarded by Lua.
 Like a Lua function, a C&nbsp;function called by Lua can also return
 many results.


 <p>
 As an example, the following function receives a variable number
 of numerical arguments and returns their average and sum:

 <pre>
      static int foo (lua_State *L) {
        int n = lua_gettop(L);    /* number of arguments */
        lua_Number sum = 0;
        int i;
        for (i = 1; i &lt;= n; i++) {
          if (!lua_isnumber(L, i)) {
            lua_pushstring(L, "incorrect argument");
            lua_error(L);
          }
          sum += lua_tonumber(L, i);
        }
        lua_pushnumber(L, sum/n);        /* first result */
        lua_pushnumber(L, sum);         /* second result */
        return 2;                   /* number of results */
      }
 </pre>


 <hr><h3><a name="lua_checkstack"><code>lua_checkstack</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_checkstack (lua_State *L, int extra);</pre>

 <p>
 Ensures that there are at least <code>extra</code> free stack slots in the stack.
 It returns false if it cannot fulfill the request,
 because it would cause the stack to be larger than a fixed maximum size
 (typically at least a few thousand elements) or
 because it cannot allocate memory for the new stack size.
 This function never shrinks the stack;
 if the stack is already larger than the new size,
 it is left unchanged.


 <hr><h3><a name="lua_close"><code>lua_close</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>void lua_close (lua_State *L);</pre>

 <p>
 Destroys all objects in the given Lua state
 (calling the corresponding garbage-collection metamethods, if any)
 and frees all dynamic memory used by this state.
 On several platforms, you may not need to call this function,
 because all resources are naturally released when the host program ends.
 On the other hand, long-running programs that create multiple states,
 such as daemons or web servers,
 might need to close states as soon as they are not needed.


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

 <p>
 Compares two Lua values.
 Returns 1 if the value at index <code>index1</code> satisfies <code>op</code>
 when compared with the value at index <code>index2</code>,
 following the semantics of the corresponding Lua operator
 (that is, it may call metamethods).
 Otherwise returns&nbsp;0.
 Also returns&nbsp;0 if any of the indices is non valid.


 <p>
 The value of <code>op</code> must be one of the following constants:

 <ul>

 <li><b><a name="pdf-LUA_OPEQ"><code>LUA_OPEQ</code></a>: </b> compares for equality (<code>==</code>)</li>
 <li><b><a name="pdf-LUA_OPLT"><code>LUA_OPLT</code></a>: </b> compares for less than (<code>&lt;</code>)</li>
 <li><b><a name="pdf-LUA_OPLE"><code>LUA_OPLE</code></a>: </b> compares for less or equal (<code>&lt;=</code>)</li>

 </ul>


 <hr><h3><a name="lua_concat"><code>lua_concat</code></a></h3><p>
 <span class="apii">[-n, +1, <em>e</em>]</span>
 <pre>void lua_concat (lua_State *L, int n);</pre>

 <p>
 Concatenates the <code>n</code> values at the top of the stack,
 pops them, and leaves the result at the top.
 If <code>n</code>&nbsp;is&nbsp;1, the result is the single value on the stack
 (that is, the function does nothing);
 if <code>n</code> is 0, the result is the empty string.
 Concatenation is performed following the usual semantics of Lua
 (see <a href="#3.4.5">&sect;3.4.5</a>).


 <hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre>

 <p>
 Moves the element at index <code>fromidx</code>
 into the valid index <code>toidx</code>
 without shifting any element
 (therefore replacing the value at that position).


 <hr><h3><a name="lua_createtable"><code>lua_createtable</code></a></h3><p>
 <span class="apii">[-0, +1, <em>e</em>]</span>
 <pre>void lua_createtable (lua_State *L, int narr, int nrec);</pre>

 <p>
 Creates a new empty table and pushes it onto the stack.
 Parameter <code>narr</code> is a hint for how many elements the table
 will have as a sequence;
 parameter <code>nrec</code> is a hint for how many other elements
 the table will have.
 Lua may use these hints to preallocate memory for the new table.
 This pre-allocation is useful for performance when you know in advance
 how many elements the table will have.
 Otherwise you can use the function <a href="#lua_newtable"><code>lua_newtable</code></a>.


 <hr><h3><a name="lua_dump"><code>lua_dump</code></a></h3><p>
 <span class="apii">[-0, +0, <em>e</em>]</span>
 <pre>int lua_dump (lua_State *L, lua_Writer writer, void *data);</pre>

 <p>
 Dumps a function as a binary chunk.
 Receives a Lua function on the top of the stack
 and produces a binary chunk that,
 if loaded again,
 results in a function equivalent to the one dumped.
 As it produces parts of the chunk,
 <a href="#lua_dump"><code>lua_dump</code></a> calls function <code>writer</code> (see <a href="#lua_Writer"><code>lua_Writer</code></a>)
 with the given <code>data</code>
 to write them.


 <p>
 The value returned is the error code returned by the last
 call to the writer;
 0&nbsp;means no errors.


 <p>
 This function does not pop the Lua function from the stack.


 <hr><h3><a name="lua_error"><code>lua_error</code></a></h3><p>
 <span class="apii">[-1, +0, <em>v</em>]</span>
 <pre>int lua_error (lua_State *L);</pre>

 <p>
 Generates a Lua error.
 The error message (which can actually be a Lua value of any type)
 must be on the stack top.
 This function does a long jump,
 and therefore never returns
 (see <a href="#luaL_error"><code>luaL_error</code></a>).


 <hr><h3><a name="lua_gc"><code>lua_gc</code></a></h3><p>
 <span class="apii">[-0, +0, <em>e</em>]</span>
 <pre>int lua_gc (lua_State *L, int what, int data);</pre>

 <p>
 Controls the garbage collector.


 <p>
 This function performs several tasks,
 according to the value of the parameter <code>what</code>:

 <ul>

 <li><b><code>LUA_GCSTOP</code>: </b>
 stops the garbage collector.
 </li>

 <li><b><code>LUA_GCRESTART</code>: </b>
 restarts the garbage collector.
 </li>

 <li><b><code>LUA_GCCOLLECT</code>: </b>
 performs a full garbage-collection cycle.
 </li>

 <li><b><code>LUA_GCCOUNT</code>: </b>
 returns the current amount of memory (in Kbytes) in use by Lua.
 </li>

 <li><b><code>LUA_GCCOUNTB</code>: </b>
 returns the remainder of dividing the current amount of bytes of
 memory in use by Lua by 1024.
 </li>

 <li><b><code>LUA_GCSTEP</code>: </b>
 performs an incremental step of garbage collection.
 The step "size" is controlled by <code>data</code>
 (larger values mean more steps) in a non-specified way.
 If you want to control the step size
 you must experimentally tune the value of <code>data</code>.
 The function returns 1 if the step finished a
 garbage-collection cycle.
 </li>

 <li><b><code>LUA_GCSETPAUSE</code>: </b>
 sets <code>data</code> as the new value
 for the <em>pause</em> of the collector (see <a href="#2.5">&sect;2.5</a>).
 The function returns the previous value of the pause.
 </li>

 <li><b><code>LUA_GCSETSTEPMUL</code>: </b>
 sets <code>data</code> as the new value for the <em>step multiplier</em> of
 the collector (see <a href="#2.5">&sect;2.5</a>).
 The function returns the previous value of the step multiplier.
 </li>

 <li><b><code>LUA_GCISRUNNING</code>: </b>
 returns a boolean that tells whether the collector is running
 (i.e., not stopped).
 </li>

 <li><b><code>LUA_GCGEN</code>: </b>
 changes the collector to generational mode
 (see <a href="#2.5">&sect;2.5</a>).
 </li>

 <li><b><code>LUA_GCINC</code>: </b>
 changes the collector to incremental mode.
 This is the default mode.
 </li>

 </ul>

 <p>
 For more details about these options,
 see <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>.


 <hr><h3><a name="lua_getallocf"><code>lua_getallocf</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>lua_Alloc lua_getallocf (lua_State *L, void **ud);</pre>

 <p>
 Returns the memory-allocation function of a given state.
 If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
 opaque pointer passed to <a href="#lua_newstate"><code>lua_newstate</code></a>.


 <hr><h3><a name="lua_getctx"><code>lua_getctx</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_getctx (lua_State *L, int *ctx);</pre>

 <p>
 This function is called by a continuation function (see <a href="#4.7">&sect;4.7</a>)
 to retrieve the status of the thread and a context information.


 <p>
 When called in the original function,
 <a href="#lua_getctx"><code>lua_getctx</code></a> always returns <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>
 and does not change the value of its argument <code>ctx</code>.
 When called inside a continuation function,
 <a href="#lua_getctx"><code>lua_getctx</code></a> returns <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> and sets
 the value of <code>ctx</code> to be the context information
 (the value passed as the <code>ctx</code> argument
 to the callee together with the continuation function).


 <p>
 When the callee is <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
 Lua may also call its continuation function
 to handle errors during the call.
 That is, upon an error in the function called by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
 Lua may not return to the original function
 but instead may call the continuation function.
 In that case, a call to <a href="#lua_getctx"><code>lua_getctx</code></a> will return the error code
 (the value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>);
 the value of <code>ctx</code> will be set to the context information,
 as in the case of a yield.


 <hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p>
 <span class="apii">[-0, +1, <em>e</em>]</span>
 <pre>void lua_getfield (lua_State *L, int index, const char *k);</pre>

 <p>
 Pushes onto the stack the value <code>t[k]</code>,
 where <code>t</code> is the value at the given index.
 As in Lua, this function may trigger a metamethod
 for the "index" event (see <a href="#2.4">&sect;2.4</a>).


 <hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p>
 <span class="apii">[-0, +1, <em>e</em>]</span>
 <pre>void lua_getglobal (lua_State *L, const char *name);</pre>

 <p>
 Pushes onto the stack the value of the global <code>name</code>.


 <hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p>
 <span class="apii">[-0, +(0|1), &ndash;]</span>
 <pre>int lua_getmetatable (lua_State *L, int index);</pre>

 <p>
 Pushes onto the stack the metatable of the value at the given index.
 If the value does not have a metatable,
 the function returns&nbsp;0 and pushes nothing on the stack.


 <hr><h3><a name="lua_gettable"><code>lua_gettable</code></a></h3><p>
 <span class="apii">[-1, +1, <em>e</em>]</span>
 <pre>void lua_gettable (lua_State *L, int index);</pre>

 <p>
 Pushes onto the stack the value <code>t[k]</code>,
 where <code>t</code> is the value at the given index
 and <code>k</code> is the value at the top of the stack.


 <p>
 This function pops the key from the stack
 (putting the resulting value in its place).
 As in Lua, this function may trigger a metamethod
 for the "index" event (see <a href="#2.4">&sect;2.4</a>).


 <hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_gettop (lua_State *L);</pre>

 <p>
 Returns the index of the top element in the stack.
 Because indices start at&nbsp;1,
 this result is equal to the number of elements in the stack
 (and so 0&nbsp;means an empty stack).


 <hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p>
 <span class="apii">[-0, +1, &ndash;]</span>
 <pre>void lua_getuservalue (lua_State *L, int index);</pre>

 <p>
 Pushes onto the stack the Lua value associated with the userdata
 at the given index.
 This Lua value must be a table or <b>nil</b>.


 <hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p>
 <span class="apii">[-1, +1, &ndash;]</span>
 <pre>void lua_insert (lua_State *L, int index);</pre>

 <p>
 Moves the top element into the given valid index,
 shifting up the elements above this index to open space.
 This function cannot be called with a pseudo-index,
 because a pseudo-index is not an actual stack position.


 <hr><h3><a name="lua_Integer"><code>lua_Integer</code></a></h3>
 <pre>typedef ptrdiff_t lua_Integer;</pre>

 <p>
 The type used by the Lua API to represent signed integral values.


 <p>
 By default it is a <code>ptrdiff_t</code>,
 which is usually the largest signed integral type the machine handles
 "comfortably".


 <hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isboolean (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a boolean,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_iscfunction (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a C&nbsp;function,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isfunction (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a function
 (either C or Lua), and 0&nbsp;otherwise.


 <hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_islightuserdata (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a light userdata,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isnil (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is <b>nil</b>,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isnone (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the given index is not valid,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isnoneornil (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the given index is not valid
 or if the value at this index is <b>nil</b>,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isnumber (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a number
 or a string convertible to a number,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isstring (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a string
 or a number (which is always convertible to a string),
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_istable (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a table,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isthread (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a thread,
 and 0&nbsp;otherwise.


 <hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p>
 <span class="apii">[-0, +0, &ndash;]</span>
 <pre>int lua_isuserdata (lua_State *L, int index);</pre>

 <p>
 Returns 1 if the value at the given index is a userdata
 (either full or light), and 0&nbsp;otherwise.


 <hr><h3><a name="lua_len"><code>lua_len</code></a></h3><p>
 <span class="apii">[-0, +1, <em>e</em>]</span>
 <pre>void lua_len (lua_State *L, int index);</pre>

 <p>
 Returns the "length" of the value at the given index;
 it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">&sect;3.4.6</a>).
 The result is pushed on the stack.


 <hr><h3><a name="lua_load"><code>lua_load</code></a></h3><p>
 <span class="apii">[-0, +1, &ndash;]</span>
 <pre>int lua_load (lua_State *L,
               lua_Reader reader,
               void *data,
               const char *source,
               const char *mode);</pre>

 <p>
 Loads a Lua chunk (without running it).
 If there are no errors,
 <code>lua_load</code> pushes the compiled chunk as a Lua
 function on top of the stack.
 Otherwise, it pushes an error message.


 <p>
 The return values of <code>lua_load</code> are:

 <ul>

 <li><b><a href="#pdf-LUA_OK"><code>LUA_OK</code></a>: </b> no errors;</li>

 <li><b><a name="pdf-LUA_ERRSYNTAX"><code>LUA_ERRSYNTAX</code></a>: </b>
 syntax error during precompilation;</li>

 <li><b><a href="#pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b>
 memory allocation error;</li>

 <li><b><a href="#pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b>
 error while running a <code>__gc</code> metamethod.
 (This error has no relation with the chunk being loaded.
 It is generated by the garbage collector.)
 </li>

 </ul>

 <p>
 The <code>lua_load</code> function uses a user-supplied <code>reader</code> function
 to read the chunk (see <a href="#lua_Reader"><code>lua_Reader</code></a>).
 The <code>data</code> argument is an opaque value passed to the reader function.


 <p>
 The <code>source</code> argument gives a name to the chunk,
 which is used for error messages and in debug information (see <a href="#4.9">&sect;4.9</a>).


 <p>
 <code>lua_load</code> automatically detects whether the chunk is text or binary
 and loads it accordingly (see program <code>luac</code>).
 The string <code>mode</code> works as in function <a href="#pdf-load"><code>load</code></a>,
 with the addition that