Mercurial Hosting > luan
changeset 418:455784e2227d
remove C documentation from manual
| author | Franklin Schmidt <fschmidt@gmail.com> |
|---|---|
| date | Thu, 30 Apr 2015 21:52:20 -0600 |
| parents | a40e99cf0b0b |
| children | 8fbb961aabd5 |
| files | website/src/manual.html.luan |
| diffstat | 1 files changed, 0 insertions(+), 4471 deletions(-) [+] |
line wrap: on
line diff
diff -r a40e99cf0b0b -r 455784e2227d website/src/manual.html.luan --- a/website/src/manual.html.luan Thu Apr 30 21:30:32 2015 -0600 +++ b/website/src/manual.html.luan Thu Apr 30 21:52:20 2015 -0600 @@ -1761,4477 +1761,6 @@ -<h1>4 – <a name="4">The Application Program Interface</a></h1> - -<p> - -This section describes the C API for Lua, that is, -the set of C 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 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 – <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 functions that are still active. -This stack initially contains any arguments to the C function -and it is where the C 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 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 1 represents the first element -(that is, the element that was pushed onto the stack first) -and -index <em>n</em> represents the last element; -index -1 also represents the last element -(that is, the element at the top) -and index <em>-n</em> represents the first element. - - - - - -<h2>4.2 – <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 enough space for pushing new elements. - - -<p> -Whenever Lua calls C, -it ensures that the stack has space for -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 space 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 – <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 1 and the stack top -(<code>1 ≤ abs(index) ≤ 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 code -but which are not in the stack. -Pseudo-indices are used to access the registry -and the upvalues of a C function (see <a href="#4.4">§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 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 – <a name="4.4">C Closures</a></h2> - -<p> -When a C function is created, -it is possible to associate some values with it, -thus creating a <em>C 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 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 – <a name="4.5">Registry</a></h2> - -<p> -Lua provides a <em>registry</em>, -a predefined table that can be used by any C 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 library can store data into this table, -but it must 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 object in your code, -or any Lua object created by your code. -As with variable 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 (see <a href="#luaL_ref"><code>luaL_ref</code></a>) -and by some predefined values. -Therefore, integer keys must 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 – <a name="4.6">Error Handling in C</a></h2> - -<p> -Internally, Lua uses the C <code>longjmp</code> facility to handle errors. -(Lua will use exceptions if you compile it as C++; -search for <code>LUAI_THROW</code> in the source code for details.) -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">§2.3</a>); -in particular, the error message is at the top of the stack. -However, there is no guarantee about stack space. -To push anything on the stack, -the panic function must first check the available space (see <a href="#4.2">§4.2</a>). - - -<p> -Most functions in the API can raise an error, -for instance due to a memory allocation error. -The documentation for each function indicates whether -it can raise errors. - - -<p> -Inside a C function you can raise an error by calling <a href="#lua_error"><code>lua_error</code></a>. - - - - - -<h2>4.7 – <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 C 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 named <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> -As an illustration, consider the following function: - -<pre> - int original_function (lua_State *L) { - ... /* code 1 */ - status = lua_pcall(L, n, m, h); /* calls Lua */ - ... /* code 2 */ - } -</pre><p> -Now we want to allow -the Lua code being run by <a href="#lua_pcall"><code>lua_pcall</code></a> to yield. -First, we can rewrite our function like here: - -<pre> - int k (lua_State *L, int status, lua_KContext ctx) { - ... /* code 2 */ - } - - int original_function (lua_State *L) { - ... /* code 1 */ - return k(L, lua_pcall(L, n, m, h), ctx); - } -</pre><p> -In the above code, -the new function <code>k</code> is a -<em>continuation function</em> (with type <a href="#lua_KFunction"><code>lua_KFunction</code></a>), -which should do all the work that the original function -was doing after calling <a href="#lua_pcall"><code>lua_pcall</code></a>. -Now, we must inform Lua that it must call <code>k</code> if the Lua code -being executed by <a href="#lua_pcall"><code>lua_pcall</code></a> gets interrupted in some way -(errors or yielding), -so we rewrite the code as here, -replacing <a href="#lua_pcall"><code>lua_pcall</code></a> by <a href="#lua_pcallk"><code>lua_pcallk</code></a>: - -<pre> - int original_function (lua_State *L) { - ... /* code 1 */ - return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1); - } -</pre><p> -Note the external, explicit call to the continuation: -Lua will call the continuation only if needed, that is, -in case of errors or resuming after a yield. -If the called function returns normally without ever yielding, -<a href="#lua_pcallk"><code>lua_pcallk</code></a> (and <a href="#lua_callk"><code>lua_callk</code></a>) will also return normally. -(Of course, instead of calling the continuation in that case, -you can do the equivalent work directly inside the original function.) - - -<p> -Besides the Lua state, -the continuation function has two other parameters: -the final status of the call plus the context value (<code>ctx</code>) that -was passed originally to <a href="#lua_pcallk"><code>lua_pcallk</code></a>. -(Lua does not use this context value; -it only passes this value from the original function to the -continuation function.) -For <a href="#lua_pcallk"><code>lua_pcallk</code></a>, -the status is the same value that would be returned by <a href="#lua_pcallk"><code>lua_pcallk</code></a>, -except that it is <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when being executed after a yield -(instead of <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>). -For <a href="#lua_yieldk"><code>lua_yieldk</code></a> and <a href="#lua_callk"><code>lua_callk</code></a>, -the status is always <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> when Lua calls the continuation. -(For these two functions, -Lua will not call the continuation in case of errors, -because they do not handle errors.) -Similarly, when using <a href="#lua_callk"><code>lua_callk</code></a>, -you should call the continuation function -with <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> as the status. -(For <a href="#lua_yieldk"><code>lua_yieldk</code></a>, there is not much point in calling -directly the continuation function, -because <a href="#lua_yieldk"><code>lua_yieldk</code></a> usually does not return.) - - -<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. - - - - - -<h2>4.8 – <a name="4.8">Functions and Types</a></h2> - -<p> -Here we list all functions and types from the C 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 raise errors: -'<code>-</code>' means the function never raises any error; -'<code>e</code>' means the function may raise errors; -'<code>v</code>' means the function may raise an error on purpose. - - - -<hr><h3><a name="lua_absindex"><code>lua_absindex</code></a></h3><p> -<span class="apii">[-0, +0, –]</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; -and <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 must behave like <code>free</code> -and return <code>NULL</code>. - - -<p> -When <code>nsize</code> is not zero, -the allocator must 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 >= 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 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 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 or bitwise operation over the two values -(or one, in the case of negations) -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 float division (<code>/</code>)</li> -<li><b><a name="pdf-LUA_OPIDIV"><code>LUA_OPIDIV</code></a>: </b> performs floor 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> -<li><b><a name="pdf-LUA_OPBNOT"><code>LUA_OPBNOT</code></a>: </b> performs bitwise negation (<code>~</code>)</li> -<li><b><a name="pdf-LUA_OPBAND"><code>LUA_OPBAND</code></a>: </b> performs bitwise and (<code>&</code>)</li> -<li><b><a name="pdf-LUA_OPBOR"><code>LUA_OPBOR</code></a>: </b> performs bitwise or (<code>|</code>)</li> -<li><b><a name="pdf-LUA_OPBXOR"><code>LUA_OPBXOR</code></a>: </b> performs bitwise exclusive or (<code>~</code>)</li> -<li><b><a name="pdf-LUA_OPSHL"><code>LUA_OPSHL</code></a>: </b> performs left shift (<code><<</code>)</li> -<li><b><a name="pdf-LUA_OPSHR"><code>LUA_OPSHR</code></a>: </b> performs right shift (<code>>></code>)</li> - -</ul> - - - - -<hr><h3><a name="lua_atpanic"><code>lua_atpanic</code></a></h3><p> -<span class="apii">[-0, +0, –]</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">§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 C: - -<pre> - lua_getglobal(L, "f"); /* function to be called */ - lua_pushliteral(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 <em>balanced</em>: -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, - lua_KContext ctx, - lua_KFunction 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">§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 functions. - - -<p> -In order to communicate properly with Lua, -a C function must use the following protocol, -which defines the way parameters and results are passed: -a C 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 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 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 their sum: - -<pre> - static int foo (lua_State *L) { - int n = lua_gettop(L); /* number of arguments */ - lua_Number sum = 0.0; - int i; - for (i = 1; i <= n; i++) { - if (!lua_isnumber(L, i)) { - lua_pushliteral(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, –]</span> -<pre>int lua_checkstack (lua_State *L, int n);</pre> - -<p> -Ensures that the stack has space for at least <code>n</code> extra slots. -It returns false if it cannot fulfill the request, -either because it would cause the stack -to be larger than a fixed maximum size -(typically at least several thousand elements) or -because it cannot allocate memory for the extra space. -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, –]</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, -will probably 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 0. -Also returns 0 if any of the indices is not 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><</code>)</li> -<li><b><a name="pdf-LUA_OPLE"><code>LUA_OPLE</code></a>: </b> compares for less or equal (<code><=</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> is 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.6">§3.4.6</a>). - - - - - -<hr><h3><a name="lua_copy"><code>lua_copy</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void lua_copy (lua_State *L, int fromidx, int toidx);</pre> - -<p> -Copies the element at index <code>fromidx</code> -into the valid index <code>toidx</code>, -replacing the value at that position. -Values at other positions are not affected. - - - - - -<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, - int strip);</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> -If <code>strip</code> is true, -the binary representation is created without debug information -about the function. - - -<p> -The value returned is the error code returned by the last -call to the writer; -0 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, -using the value at the top of the stack as the error object. -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. -</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">§2.5</a>) -and 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">§2.5</a>) -and 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> - -</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, –]</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 given when the memory-allocator function was set. - - - - - -<hr><h3><a name="lua_getfield"><code>lua_getfield</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int 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">§2.4</a>). - - -<p> -Returns the type of the pushed value. - - - - - -<hr><h3><a name="lua_getextraspace"><code>lua_getextraspace</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void *lua_getextraspace (lua_State *L);</pre> - -<p> -Returns a pointer to a raw memory area associated with the -given Lua state. -The application can use this area for any purpose; -Lua does not use it for anything. - - -<p> -Each new thread has this area initialized with a copy -of the area of the main thread. - - -<p> -By default, this area has the size of a pointer to void, -but you can recompile Lua with a different size for this area. -(See <code>LUA_EXTRASPACE</code> in <code>luaconf.h</code>.) - - - - - -<hr><h3><a name="lua_getglobal"><code>lua_getglobal</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int lua_getglobal (lua_State *L, const char *name);</pre> - -<p> -Pushes onto the stack the value of the global <code>name</code>. -Returns the type of that value. - - - - - -<hr><h3><a name="lua_geti"><code>lua_geti</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int lua_geti (lua_State *L, int index, lua_Integer i);</pre> - -<p> -Pushes onto the stack the value <code>t[i]</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">§2.4</a>). - - -<p> -Returns the type of the pushed value. - - - - - -<hr><h3><a name="lua_getmetatable"><code>lua_getmetatable</code></a></h3><p> -<span class="apii">[-0, +(0|1), –]</span> -<pre>int lua_getmetatable (lua_State *L, int index);</pre> - -<p> -If the value at the given index has a metatable, -the function pushes that metatable onto the stack and returns 1. -Otherwise, -the function returns 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>int 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, -pushing the resulting value in its place. -As in Lua, this function may trigger a metamethod -for the "index" event (see <a href="#2.4">§2.4</a>). - - -<p> -Returns the type of the pushed value. - - - - - -<hr><h3><a name="lua_gettop"><code>lua_gettop</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_gettop (lua_State *L);</pre> - -<p> -Returns the index of the top element in the stack. -Because indices start at 1, -this result is equal to the number of elements in the stack; -in particular, 0 means an empty stack. - - - - - -<hr><h3><a name="lua_getuservalue"><code>lua_getuservalue</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int lua_getuservalue (lua_State *L, int index);</pre> - -<p> -Pushes onto the stack the Lua value associated with the userdata -at the given index. - - -<p> -Returns the type of the pushed value. - - - - - -<hr><h3><a name="lua_insert"><code>lua_insert</code></a></h3><p> -<span class="apii">[-1, +1, –]</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 ... lua_Integer;</pre> - -<p> -The type of integers in Lua. - - -<p> -By default this type is <code>long long</code>, -(usually a 64-bit two-complement integer), -but that can be changed to <code>long</code> or <code>int</code> -(usually a 32-bit two-complement integer). -(See <code>LUA_INT</code> in <code>luaconf.h</code>.) - - -<p> -Lua also defines the constants -<a name="pdf-LUA_MININTEGER"><code>LUA_MININTEGER</code></a> and <a name="pdf-LUA_MAXINTEGER"><code>LUA_MAXINTEGER</code></a>, -with the minimum and the maximum values that fit in this type. - - - - - -<hr><h3><a name="lua_isboolean"><code>lua_isboolean</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_iscfunction"><code>lua_iscfunction</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_iscfunction (lua_State *L, int index);</pre> - -<p> -Returns 1 if the value at the given index is a C function, -and 0 otherwise. - - - - - -<hr><h3><a name="lua_isfunction"><code>lua_isfunction</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isinteger"><code>lua_isinteger</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_isinteger (lua_State *L, int index);</pre> - -<p> -Returns 1 if the value at the given index is an integer -(that is, the value is a number and is represented as an integer), -and 0 otherwise. - - - - - -<hr><h3><a name="lua_islightuserdata"><code>lua_islightuserdata</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isnil"><code>lua_isnil</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isnone"><code>lua_isnone</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_isnone (lua_State *L, int index);</pre> - -<p> -Returns 1 if the given index is not valid, -and 0 otherwise. - - - - - -<hr><h3><a name="lua_isnoneornil"><code>lua_isnoneornil</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isnumber"><code>lua_isnumber</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isstring"><code>lua_isstring</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_istable"><code>lua_istable</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isthread"><code>lua_isthread</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isuserdata"><code>lua_isuserdata</code></a></h3><p> -<span class="apii">[-0, +0, –]</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 otherwise. - - - - - -<hr><h3><a name="lua_isyieldable"><code>lua_isyieldable</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_isyieldable (lua_State *L);</pre> - -<p> -Returns 1 if the given coroutine can yield, -and 0 otherwise. - - - - - -<hr><h3><a name="lua_KContext"><code>lua_KContext</code></a></h3> -<pre>typedef ... lua_KContext;</pre> - -<p> -The type for continuation-function contexts. -It must be a numerical type. -This type is defined as <code>intptr_t</code> -when <code>intptr_t</code> is available, -so that it can store pointers too. -Otherwise, it is defined as <code>ptrdiff_t</code>. - - - - - -<hr><h3><a name="lua_KFunction"><code>lua_KFunction</code></a></h3> -<pre>typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);</pre> - -<p> -Type for continuation functions (see <a href="#4.7">§4.7</a>). - - - - - -<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.7">§3.4.7</a>) and -may trigger a metamethod for the "length" event (see <a href="#2.4">§2.4</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, –]</span> -<pre>int lua_load (lua_State *L, - lua_Reader reader, - void *data, - const char *chunkname, - 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>chunkname</code> argument gives a name to the chunk, -which is used for error messages and in debug information (see <a href="#4.9">§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 -a <code>NULL</code> value is equivalent to the string "<code>bt</code>". - - -<p> -<code>lua_load</code> uses the stack internally, -so the reader function must always leave the stack -unmodified when returning. - - -<p> -If the resulting function has upvalues, -its first upvalue is set to the value of the global environment -stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.5">§4.5</a>). -When loading main chunks, -this upvalue will be the <code>_ENV</code> variable (see <a href="#2.2">§2.2</a>). -Other upvalues are initialized with <b>nil</b>. - - - - - -<hr><h3><a name="lua_newstate"><code>lua_newstate</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_State *lua_newstate (lua_Alloc f, void *ud);</pre> - -<p> -Creates a new thread running in a new, independent state. -Returns <code>NULL</code> if it cannot create the thread or the state -(due to lack of memory). -The argument <code>f</code> is the allocator function; -Lua does all memory allocation for this state through this function. -The second argument, <code>ud</code>, is an opaque pointer that Lua -passes to the allocator in every call. - - - - - -<hr><h3><a name="lua_newtable"><code>lua_newtable</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void lua_newtable (lua_State *L);</pre> - -<p> -Creates a new empty table and pushes it onto the stack. -It is equivalent to <code>lua_createtable(L, 0, 0)</code>. - - - - - -<hr><h3><a name="lua_newthread"><code>lua_newthread</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>lua_State *lua_newthread (lua_State *L);</pre> - -<p> -Creates a new thread, pushes it on the stack, -and returns a pointer to a <a href="#lua_State"><code>lua_State</code></a> that represents this new thread. -The new thread returned by this function shares with the original thread -its global environment, -but has an independent execution stack. - - -<p> -There is no explicit function to close or to destroy a thread. -Threads are subject to garbage collection, -like any Lua object. - - - - - -<hr><h3><a name="lua_newuserdata"><code>lua_newuserdata</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void *lua_newuserdata (lua_State *L, size_t size);</pre> - -<p> -This function allocates a new block of memory with the given size, -pushes onto the stack a new full userdata with the block address, -and returns this address. -The host program can freely use this memory. - - - - - -<hr><h3><a name="lua_next"><code>lua_next</code></a></h3><p> -<span class="apii">[-1, +(2|0), <em>e</em>]</span> -<pre>int lua_next (lua_State *L, int index);</pre> - -<p> -Pops a key from the stack, -and pushes a key–value pair from the table at the given index -(the "next" pair after the given key). -If there are no more elements in the table, -then <a href="#lua_next"><code>lua_next</code></a> returns 0 (and pushes nothing). - - -<p> -A typical traversal looks like this: - -<pre> - /* table is in the stack at index 't' */ - lua_pushnil(L); /* first key */ - while (lua_next(L, t) != 0) { - /* uses 'key' (at index -2) and 'value' (at index -1) */ - printf("%s - %s\n", - lua_typename(L, lua_type(L, -2)), - lua_typename(L, lua_type(L, -1))); - /* removes 'value'; keeps 'key' for next iteration */ - lua_pop(L, 1); - } -</pre> - -<p> -While traversing a table, -do not call <a href="#lua_tolstring"><code>lua_tolstring</code></a> directly on a key, -unless you know that the key is actually a string. -Recall that <a href="#lua_tolstring"><code>lua_tolstring</code></a> may change -the value at the given index; -this confuses the next call to <a href="#lua_next"><code>lua_next</code></a>. - - -<p> -See function <a href="#pdf-next"><code>next</code></a> for the caveats of modifying -the table during its traversal. - - - - - -<hr><h3><a name="lua_Number"><code>lua_Number</code></a></h3> -<pre>typedef double lua_Number;</pre> - -<p> -The type of floats in Lua. - - -<p> -By default this type is double, -but that can be changed to a single float. -(See <code>LUA_REAL</code> in <code>luaconf.h</code>.) - - - - - -<hr><h3><a name="lua_numbertointeger"><code>lua_numbertointeger</code></a></h3> -<pre>int lua_numbertointeger (lua_Number n, lua_Integer *p);</pre> - -<p> -Converts a Lua float to a Lua integer. -This macro assumes that <code>n</code> has an integral value. -If that value is within the range of Lua integers, -it is converted to an integer and assigned to <code>*p</code>. -The macro results in a boolean indicating whether the -conversion was successful. -(Note that this range test can be tricky to do -correctly without this macro, -due to roundings.) - - -<p> -This macro may evaluate its arguments more than once. - - - - - -<hr><h3><a name="lua_pcall"><code>lua_pcall</code></a></h3><p> -<span class="apii">[-(nargs + 1), +(nresults|1), –]</span> -<pre>int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);</pre> - -<p> -Calls a function in protected mode. - - -<p> -Both <code>nargs</code> and <code>nresults</code> have the same meaning as -in <a href="#lua_call"><code>lua_call</code></a>. -If there are no errors during the call, -<a href="#lua_pcall"><code>lua_pcall</code></a> behaves exactly like <a href="#lua_call"><code>lua_call</code></a>. -However, if there is any error, -<a href="#lua_pcall"><code>lua_pcall</code></a> catches it, -pushes a single value on the stack (the error message), -and returns an error code. -Like <a href="#lua_call"><code>lua_call</code></a>, -<a href="#lua_pcall"><code>lua_pcall</code></a> always removes the function -and its arguments from the stack. - - -<p> -If <code>msgh</code> is 0, -then the error message returned on the stack -is exactly the original error message. -Otherwise, <code>msgh</code> is the stack index of a -<em>message handler</em>. -(In the current implementation, this index cannot be a pseudo-index.) -In case of runtime errors, -this function will be called with the error message -and its return value will be the message -returned on the stack by <a href="#lua_pcall"><code>lua_pcall</code></a>. - - -<p> -Typically, the message handler is used to add more debug -information to the error message, such as a stack traceback. -Such information cannot be gathered after the return of <a href="#lua_pcall"><code>lua_pcall</code></a>, -since by then the stack has unwound. - - -<p> -The <a href="#lua_pcall"><code>lua_pcall</code></a> function returns one of the following constants -(defined in <code>lua.h</code>): - -<ul> - -<li><b><a name="pdf-LUA_OK"><code>LUA_OK</code></a> (0): </b> -success.</li> - -<li><b><a name="pdf-LUA_ERRRUN"><code>LUA_ERRRUN</code></a>: </b> -a runtime error. -</li> - -<li><b><a name="pdf-LUA_ERRMEM"><code>LUA_ERRMEM</code></a>: </b> -memory allocation error. -For such errors, Lua does not call the message handler. -</li> - -<li><b><a name="pdf-LUA_ERRERR"><code>LUA_ERRERR</code></a>: </b> -error while running the message handler. -</li> - -<li><b><a name="pdf-LUA_ERRGCMM"><code>LUA_ERRGCMM</code></a>: </b> -error while running a <code>__gc</code> metamethod. -(This error typically has no relation with the function being called.) -</li> - -</ul> - - - - -<hr><h3><a name="lua_pcallk"><code>lua_pcallk</code></a></h3><p> -<span class="apii">[-(nargs + 1), +(nresults|1), –]</span> -<pre>int lua_pcallk (lua_State *L, - int nargs, - int nresults, - int msgh, - lua_KContext ctx, - lua_KFunction k);</pre> - -<p> -This function behaves exactly like <a href="#lua_pcall"><code>lua_pcall</code></a>, -but allows the called function to yield (see <a href="#4.7">§4.7</a>). - - - - - -<hr><h3><a name="lua_pop"><code>lua_pop</code></a></h3><p> -<span class="apii">[-n, +0, –]</span> -<pre>void lua_pop (lua_State *L, int n);</pre> - -<p> -Pops <code>n</code> elements from the stack. - - - - - -<hr><h3><a name="lua_pushboolean"><code>lua_pushboolean</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushboolean (lua_State *L, int b);</pre> - -<p> -Pushes a boolean value with value <code>b</code> onto the stack. - - - - - -<hr><h3><a name="lua_pushcclosure"><code>lua_pushcclosure</code></a></h3><p> -<span class="apii">[-n, +1, <em>e</em>]</span> -<pre>void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);</pre> - -<p> -Pushes a new C closure onto the stack. - - -<p> -When a C function is created, -it is possible to associate some values with it, -thus creating a C closure (see <a href="#4.4">§4.4</a>); -these values are then accessible to the function whenever it is called. -To associate values with a C function, -first these values must be pushed onto the stack -(when there are multiple values, the first value is pushed first). -Then <a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> -is called to create and push the C function onto the stack, -with the argument <code>n</code> telling how many values will be -associated with the function. -<a href="#lua_pushcclosure"><code>lua_pushcclosure</code></a> also pops these values from the stack. - - -<p> -The maximum value for <code>n</code> is 255. - - -<p> -When <code>n</code> is zero, -this function creates a <em>light C function</em>, -which is just a pointer to the C function. -In that case, it never raises a memory error. - - - - - -<hr><h3><a name="lua_pushcfunction"><code>lua_pushcfunction</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushcfunction (lua_State *L, lua_CFunction f);</pre> - -<p> -Pushes a C function onto the stack. -This function receives a pointer to a C function -and pushes onto the stack a Lua value of type <code>function</code> that, -when called, invokes the corresponding C function. - - -<p> -Any function to be registered in Lua must -follow the correct protocol to receive its parameters -and return its results (see <a href="#lua_CFunction"><code>lua_CFunction</code></a>). - - -<p> -<code>lua_pushcfunction</code> is defined as a macro: - -<pre> - #define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0) -</pre><p> -Note that <code>f</code> is used twice. - - - - - -<hr><h3><a name="lua_pushfstring"><code>lua_pushfstring</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *lua_pushfstring (lua_State *L, const char *fmt, ...);</pre> - -<p> -Pushes onto the stack a formatted string -and returns a pointer to this string. -It is similar to the ISO C function <code>sprintf</code>, -but has some important differences: - -<ul> - -<li> -You do not have to allocate space for the result: -the result is a Lua string and Lua takes care of memory allocation -(and deallocation, through garbage collection). -</li> - -<li> -The conversion specifiers are quite restricted. -There are no flags, widths, or precisions. -The conversion specifiers can only be -'<code>%%</code>' (inserts the character '<code>%</code>'), -'<code>%s</code>' (inserts a zero-terminated string, with no size restrictions), -'<code>%f</code>' (inserts a <a href="#lua_Number"><code>lua_Number</code></a>), -'<code>%L</code>' (inserts a <a href="#lua_Integer"><code>lua_Integer</code></a>), -'<code>%p</code>' (inserts a pointer as a hexadecimal numeral), -'<code>%d</code>' (inserts an <code>int</code>), -'<code>%c</code>' (inserts an <code>int</code> as a one-byte character), and -'<code>%U</code>' (inserts a <code>long int</code> as a UTF-8 byte sequence). -</li> - -</ul> - - - - -<hr><h3><a name="lua_pushglobaltable"><code>lua_pushglobaltable</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushglobaltable (lua_State *L);</pre> - -<p> -Pushes the global environment onto the stack. - - - - - -<hr><h3><a name="lua_pushinteger"><code>lua_pushinteger</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushinteger (lua_State *L, lua_Integer n);</pre> - -<p> -Pushes an integer with value <code>n</code> onto the stack. - - - - - -<hr><h3><a name="lua_pushlightuserdata"><code>lua_pushlightuserdata</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushlightuserdata (lua_State *L, void *p);</pre> - -<p> -Pushes a light userdata onto the stack. - - -<p> -Userdata represent C values in Lua. -A <em>light userdata</em> represents a pointer, a <code>void*</code>. -It is a value (like a number): -you do not create it, it has no individual metatable, -and it is not collected (as it was never created). -A light userdata is equal to "any" -light userdata with the same C address. - - - - - -<hr><h3><a name="lua_pushliteral"><code>lua_pushliteral</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *lua_pushliteral (lua_State *L, const char *s);</pre> - -<p> -This macro is equivalent to <a href="#lua_pushlstring"><code>lua_pushlstring</code></a>, -but can be used only when <code>s</code> is a literal string. -It automatically provides the string length. - - - - - -<hr><h3><a name="lua_pushlstring"><code>lua_pushlstring</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *lua_pushlstring (lua_State *L, const char *s, size_t len);</pre> - -<p> -Pushes the string pointed to by <code>s</code> with size <code>len</code> -onto the stack. -Lua makes (or reuses) an internal copy of the given string, -so the memory at <code>s</code> can be freed or reused immediately after -the function returns. -The string can contain any binary data, -including embedded zeros. - - -<p> -Returns a pointer to the internal copy of the string. - - - - - -<hr><h3><a name="lua_pushnil"><code>lua_pushnil</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushnil (lua_State *L);</pre> - -<p> -Pushes a nil value onto the stack. - - - - - -<hr><h3><a name="lua_pushnumber"><code>lua_pushnumber</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushnumber (lua_State *L, lua_Number n);</pre> - -<p> -Pushes a float with value <code>n</code> onto the stack. - - - - - -<hr><h3><a name="lua_pushstring"><code>lua_pushstring</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *lua_pushstring (lua_State *L, const char *s);</pre> - -<p> -Pushes the zero-terminated string pointed to by <code>s</code> -onto the stack. -Lua makes (or reuses) an internal copy of the given string, -so the memory at <code>s</code> can be freed or reused immediately after -the function returns. - - -<p> -Returns a pointer to the internal copy of the string. - - -<p> -If <code>s</code> is <code>NULL</code>, pushes <b>nil</b> and returns <code>NULL</code>. - - - - - -<hr><h3><a name="lua_pushthread"><code>lua_pushthread</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int lua_pushthread (lua_State *L);</pre> - -<p> -Pushes the thread represented by <code>L</code> onto the stack. -Returns 1 if this thread is the main thread of its state. - - - - - -<hr><h3><a name="lua_pushvalue"><code>lua_pushvalue</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>void lua_pushvalue (lua_State *L, int index);</pre> - -<p> -Pushes a copy of the element at the given index -onto the stack. - - - - - -<hr><h3><a name="lua_pushvfstring"><code>lua_pushvfstring</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *lua_pushvfstring (lua_State *L, - const char *fmt, - va_list argp);</pre> - -<p> -Equivalent to <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>, except that it receives a <code>va_list</code> -instead of a variable number of arguments. - - - - - -<hr><h3><a name="lua_rawequal"><code>lua_rawequal</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_rawequal (lua_State *L, int index1, int index2);</pre> - -<p> -Returns 1 if the two values in indices <code>index1</code> and -<code>index2</code> are primitively equal -(that is, without calling metamethods). -Otherwise returns 0. -Also returns 0 if any of the indices are not valid. - - - - - -<hr><h3><a name="lua_rawget"><code>lua_rawget</code></a></h3><p> -<span class="apii">[-1, +1, –]</span> -<pre>int lua_rawget (lua_State *L, int index);</pre> - -<p> -Similar to <a href="#lua_gettable"><code>lua_gettable</code></a>, but does a raw access -(i.e., without metamethods). - - - - - -<hr><h3><a name="lua_rawgeti"><code>lua_rawgeti</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int lua_rawgeti (lua_State *L, int index, lua_Integer n);</pre> - -<p> -Pushes onto the stack the value <code>t[n]</code>, -where <code>t</code> is the table at the given index. -The access is raw; -that is, it does not invoke metamethods. - - -<p> -Returns the type of the pushed value. - - - - - -<hr><h3><a name="lua_rawgetp"><code>lua_rawgetp</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int lua_rawgetp (lua_State *L, int index, const void *p);</pre> - -<p> -Pushes onto the stack the value <code>t[k]</code>, -where <code>t</code> is the table at the given index and -<code>k</code> is the pointer <code>p</code> represented as a light userdata. -The access is raw; -that is, it does not invoke metamethods. - - -<p> -Returns the type of the pushed value. - - - - - -<hr><h3><a name="lua_rawlen"><code>lua_rawlen</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>size_t lua_rawlen (lua_State *L, int index);</pre> - -<p> -Returns the raw "length" of the value at the given index: -for strings, this is the string length; -for tables, this is the result of the length operator ('<code>#</code>') -with no metamethods; -for userdata, this is the size of the block of memory allocated -for the userdata; -for other values, it is 0. - - - - - -<hr><h3><a name="lua_rawset"><code>lua_rawset</code></a></h3><p> -<span class="apii">[-2, +0, <em>e</em>]</span> -<pre>void lua_rawset (lua_State *L, int index);</pre> - -<p> -Similar to <a href="#lua_settable"><code>lua_settable</code></a>, but does a raw assignment -(i.e., without metamethods). - - - - - -<hr><h3><a name="lua_rawseti"><code>lua_rawseti</code></a></h3><p> -<span class="apii">[-1, +0, <em>e</em>]</span> -<pre>void lua_rawseti (lua_State *L, int index, lua_Integer i);</pre> - -<p> -Does the equivalent of <code>t[i] = v</code>, -where <code>t</code> is the table at the given index -and <code>v</code> is the value at the top of the stack. - - -<p> -This function pops the value from the stack. -The assignment is raw; -that is, it does not invoke metamethods. - - - - - -<hr><h3><a name="lua_rawsetp"><code>lua_rawsetp</code></a></h3><p> -<span class="apii">[-1, +0, <em>e</em>]</span> -<pre>void lua_rawsetp (lua_State *L, int index, const void *p);</pre> - -<p> -Does the equivalent of <code>t[k] = v</code>, -where <code>t</code> is the table at the given index, -<code>k</code> is the pointer <code>p</code> represented as a light userdata, -and <code>v</code> is the value at the top of the stack. - - -<p> -This function pops the value from the stack. -The assignment is raw; -that is, it does not invoke metamethods. - - - - - -<hr><h3><a name="lua_Reader"><code>lua_Reader</code></a></h3> -<pre>typedef const char * (*lua_Reader) (lua_State *L, - void *data, - size_t *size);</pre> - -<p> -The reader function used by <a href="#lua_load"><code>lua_load</code></a>. -Every time it needs another piece of the chunk, -<a href="#lua_load"><code>lua_load</code></a> calls the reader, -passing along its <code>data</code> parameter. -The reader must return a pointer to a block of memory -with a new piece of the chunk -and set <code>size</code> to the block size. -The block must exist until the reader function is called again. -To signal the end of the chunk, -the reader must return <code>NULL</code> or set <code>size</code> to zero. -The reader function may return pieces of any size greater than zero. - - - - - -<hr><h3><a name="lua_register"><code>lua_register</code></a></h3><p> -<span class="apii">[-0, +0, <em>e</em>]</span> -<pre>void lua_register (lua_State *L, const char *name, lua_CFunction f);</pre> - -<p> -Sets the C function <code>f</code> as the new value of global <code>name</code>. -It is defined as a macro: - -<pre> - #define lua_register(L,n,f) \ - (lua_pushcfunction(L, f), lua_setglobal(L, n)) -</pre> - - - - -<hr><h3><a name="lua_remove"><code>lua_remove</code></a></h3><p> -<span class="apii">[-1, +0, –]</span> -<pre>void lua_remove (lua_State *L, int index);</pre> - -<p> -Removes the element at the given valid index, -shifting down the elements above this index to fill the gap. -This function cannot be called with a pseudo-index, -because a pseudo-index is not an actual stack position. - - - - - -<hr><h3><a name="lua_replace"><code>lua_replace</code></a></h3><p> -<span class="apii">[-1, +0, –]</span> -<pre>void lua_replace (lua_State *L, int index);</pre> - -<p> -Moves the top element into the given valid index -without shifting any element -(therefore replacing the value at the given index), -and then pops the top element. - - - - - -<hr><h3><a name="lua_resume"><code>lua_resume</code></a></h3><p> -<span class="apii">[-?, +?, –]</span> -<pre>int lua_resume (lua_State *L, lua_State *from, int nargs);</pre> - -<p> -Starts and resumes a coroutine in a given thread. - - -<p> -To start a coroutine, -you push onto the thread stack the main function plus any arguments; -then you call <a href="#lua_resume"><code>lua_resume</code></a>, -with <code>nargs</code> being the number of arguments. -This call returns when the coroutine suspends or finishes its execution. -When it returns, the stack contains all values passed to <a href="#lua_yield"><code>lua_yield</code></a>, -or all values returned by the body function. -<a href="#lua_resume"><code>lua_resume</code></a> returns -<a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the coroutine yields, -<a href="#pdf-LUA_OK"><code>LUA_OK</code></a> if the coroutine finishes its execution -without errors, -or an error code in case of errors (see <a href="#lua_pcall"><code>lua_pcall</code></a>). - - -<p> -In case of errors, -the stack is not unwound, -so you can use the debug API over it. -The error message is on the top of the stack. - - -<p> -To resume a coroutine, -you remove any results from the last <a href="#lua_yield"><code>lua_yield</code></a>, -put on its stack only the values to -be passed as results from <code>yield</code>, -and then call <a href="#lua_resume"><code>lua_resume</code></a>. - - -<p> -The parameter <code>from</code> represents the coroutine that is resuming <code>L</code>. -If there is no such coroutine, -this parameter can be <code>NULL</code>. - - - - - -<hr><h3><a name="lua_rotate"><code>lua_rotate</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void lua_rotate (lua_State *L, int idx, int n);</pre> - -<p> -Rotates the stack elements from <code>idx</code> to the top <code>n</code> positions -in the direction of the top, for a positive <code>n</code>, -or <code>-n</code> positions in the direction of the bottom, -for a negative <code>n</code>. -The absolute value of <code>n</code> must not be greater than the size -of the slice being rotated. - - - - - -<hr><h3><a name="lua_setallocf"><code>lua_setallocf</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);</pre> - -<p> -Changes the allocator function of a given state to <code>f</code> -with user data <code>ud</code>. - - - - - -<hr><h3><a name="lua_setfield"><code>lua_setfield</code></a></h3><p> -<span class="apii">[-1, +0, <em>e</em>]</span> -<pre>void lua_setfield (lua_State *L, int index, const char *k);</pre> - -<p> -Does the equivalent to <code>t[k] = v</code>, -where <code>t</code> is the value at the given index -and <code>v</code> is the value at the top of the stack. - - -<p> -This function pops the value from the stack. -As in Lua, this function may trigger a metamethod -for the "newindex" event (see <a href="#2.4">§2.4</a>). - - - - - -<hr><h3><a name="lua_setglobal"><code>lua_setglobal</code></a></h3><p> -<span class="apii">[-1, +0, <em>e</em>]</span> -<pre>void lua_setglobal (lua_State *L, const char *name);</pre> - -<p> -Pops a value from the stack and -sets it as the new value of global <code>name</code>. - - - - - -<hr><h3><a name="lua_seti"><code>lua_seti</code></a></h3><p> -<span class="apii">[-1, +0, <em>e</em>]</span> -<pre>void lua_seti (lua_State *L, int index, lua_Integer n);</pre> - -<p> -Does the equivalent to <code>t[n] = v</code>, -where <code>t</code> is the value at the given index -and <code>v</code> is the value at the top of the stack. - - -<p> -This function pops the value from the stack. -As in Lua, this function may trigger a metamethod -for the "newindex" event (see <a href="#2.4">§2.4</a>). - - - - - -<hr><h3><a name="lua_setmetatable"><code>lua_setmetatable</code></a></h3><p> -<span class="apii">[-1, +0, –]</span> -<pre>void lua_setmetatable (lua_State *L, int index);</pre> - -<p> -Pops a table from the stack and -sets it as the new metatable for the value at the given index. - - - - - -<hr><h3><a name="lua_settable"><code>lua_settable</code></a></h3><p> -<span class="apii">[-2, +0, <em>e</em>]</span> -<pre>void lua_settable (lua_State *L, int index);</pre> - -<p> -Does the equivalent to <code>t[k] = v</code>, -where <code>t</code> is the value at the given index, -<code>v</code> is the value at the top of the stack, -and <code>k</code> is the value just below the top. - - -<p> -This function pops both the key and the value from the stack. -As in Lua, this function may trigger a metamethod -for the "newindex" event (see <a href="#2.4">§2.4</a>). - - - - - -<hr><h3><a name="lua_settop"><code>lua_settop</code></a></h3><p> -<span class="apii">[-?, +?, –]</span> -<pre>void lua_settop (lua_State *L, int index);</pre> - -<p> -Accepts any index, or 0, -and sets the stack top to this index. -If the new top is larger than the old one, -then the new elements are filled with <b>nil</b>. -If <code>index</code> is 0, then all stack elements are removed. - - - - - -<hr><h3><a name="lua_setuservalue"><code>lua_setuservalue</code></a></h3><p> -<span class="apii">[-1, +0, –]</span> -<pre>void lua_setuservalue (lua_State *L, int index);</pre> - -<p> -Pops a value from the stack and sets it as -the new value associated to the userdata at the given index. - - - - - -<hr><h3><a name="lua_State"><code>lua_State</code></a></h3> -<pre>typedef struct lua_State lua_State;</pre> - -<p> -An opaque structure that points to a thread and indirectly -(through the thread) to the whole state of a Lua interpreter. -The Lua library is fully reentrant: -it has no global variables. -All information about a state is accessible through this structure. - - -<p> -A pointer to this structure must be passed as the first argument to -every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>, -which creates a Lua state from scratch. - - - - - -<hr><h3><a name="lua_status"><code>lua_status</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_status (lua_State *L);</pre> - -<p> -Returns the status of the thread <code>L</code>. - - -<p> -The status can be 0 (<a href="#pdf-LUA_OK"><code>LUA_OK</code></a>) for a normal thread, -an error code if the thread finished the execution -of a <a href="#lua_resume"><code>lua_resume</code></a> with an error, -or <a name="pdf-LUA_YIELD"><code>LUA_YIELD</code></a> if the thread is suspended. - - -<p> -You can only call functions in threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>. -You can resume threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a> -(to start a new coroutine) or <a href="#pdf-LUA_YIELD"><code>LUA_YIELD</code></a> -(to resume a coroutine). - - - - - -<hr><h3><a name="lua_stringtonumber"><code>lua_stringtonumber</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>size_t lua_stringtonumber (lua_State *L, const char *s);</pre> - -<p> -Converts the zero-terminated string <code>s</code> to a number, -pushes that number into the stack, -and returns the total size of the string, -that is, its length plus one. -The conversion can result in an integer or a float, -according to the lexical conventions of Lua (see <a href="#3.1">§3.1</a>). -The string may have leading and trailing spaces and a sign. -If the string is not a valid numeral, -returns 0 and pushes nothing. -(Note that the result can be used as a boolean, -true if the conversion succeeds.) - - - - - -<hr><h3><a name="lua_toboolean"><code>lua_toboolean</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_toboolean (lua_State *L, int index);</pre> - -<p> -Converts the Lua value at the given index to a C boolean -value (0 or 1). -Like all tests in Lua, -<a href="#lua_toboolean"><code>lua_toboolean</code></a> returns true for any Lua value -different from <b>false</b> and <b>nil</b>; -otherwise it returns false. -(If you want to accept only actual boolean values, -use <a href="#lua_isboolean"><code>lua_isboolean</code></a> to test the value's type.) - - - - - -<hr><h3><a name="lua_tocfunction"><code>lua_tocfunction</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_CFunction lua_tocfunction (lua_State *L, int index);</pre> - -<p> -Converts a value at the given index to a C function. -That value must be a C function; -otherwise, returns <code>NULL</code>. - - - - - -<hr><h3><a name="lua_tointeger"><code>lua_tointeger</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_Integer lua_tointeger (lua_State *L, int index);</pre> - -<p> -Equivalent to <a href="#lua_tointegerx"><code>lua_tointegerx</code></a> with <code>isnum</code> equal to <code>NULL</code>. - - - - - -<hr><h3><a name="lua_tointegerx"><code>lua_tointegerx</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);</pre> - -<p> -Converts the Lua value at the given index -to the signed integral type <a href="#lua_Integer"><code>lua_Integer</code></a>. -The Lua value must be an integer, -or a number or string convertible to an integer (see <a href="#3.4.3">§3.4.3</a>); -otherwise, <code>lua_tointegerx</code> returns 0. - - -<p> -If <code>isnum</code> is not <code>NULL</code>, -its referent is assigned a boolean value that -indicates whether the operation succeeded. - - - - - -<hr><h3><a name="lua_tolstring"><code>lua_tolstring</code></a></h3><p> -<span class="apii">[-0, +0, <em>e</em>]</span> -<pre>const char *lua_tolstring (lua_State *L, int index, size_t *len);</pre> - -<p> -Converts the Lua value at the given index to a C string. -If <code>len</code> is not <code>NULL</code>, -it also sets <code>*len</code> with the string length. -The Lua value must be a string or a number; -otherwise, the function returns <code>NULL</code>. -If the value is a number, -then <code>lua_tolstring</code> also -<em>changes the actual value in the stack to a string</em>. -(This change confuses <a href="#lua_next"><code>lua_next</code></a> -when <code>lua_tolstring</code> is applied to keys during a table traversal.) - - -<p> -<code>lua_tolstring</code> returns a fully aligned pointer -to a string inside the Lua state. -This string always has a zero ('<code>\0</code>') -after its last character (as in C), -but can contain other zeros in its body. - - -<p> -Because Lua has garbage collection, -there is no guarantee that the pointer returned by <code>lua_tolstring</code> -will be valid after the corresponding Lua value is removed from the stack. - - - - - -<hr><h3><a name="lua_tonumber"><code>lua_tonumber</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_Number lua_tonumber (lua_State *L, int index);</pre> - -<p> -Equivalent to <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> with <code>isnum</code> equal to <code>NULL</code>. - - - - - -<hr><h3><a name="lua_tonumberx"><code>lua_tonumberx</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);</pre> - -<p> -Converts the Lua value at the given index -to the C type <a href="#lua_Number"><code>lua_Number</code></a> (see <a href="#lua_Number"><code>lua_Number</code></a>). -The Lua value must be a number or a string convertible to a number -(see <a href="#3.4.3">§3.4.3</a>); -otherwise, <a href="#lua_tonumberx"><code>lua_tonumberx</code></a> returns 0. - - -<p> -If <code>isnum</code> is not <code>NULL</code>, -its referent is assigned a boolean value that -indicates whether the operation succeeded. - - - - - -<hr><h3><a name="lua_topointer"><code>lua_topointer</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>const void *lua_topointer (lua_State *L, int index);</pre> - -<p> -Converts the value at the given index to a generic -C pointer (<code>void*</code>). -The value can be a userdata, a table, a thread, or a function; -otherwise, <code>lua_topointer</code> returns <code>NULL</code>. -Different objects will give different pointers. -There is no way to convert the pointer back to its original value. - - -<p> -Typically this function is used only for debug information. - - - - - -<hr><h3><a name="lua_tostring"><code>lua_tostring</code></a></h3><p> -<span class="apii">[-0, +0, <em>e</em>]</span> -<pre>const char *lua_tostring (lua_State *L, int index);</pre> - -<p> -Equivalent to <a href="#lua_tolstring"><code>lua_tolstring</code></a> with <code>len</code> equal to <code>NULL</code>. - - - - - -<hr><h3><a name="lua_tothread"><code>lua_tothread</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_State *lua_tothread (lua_State *L, int index);</pre> - -<p> -Converts the value at the given index to a Lua thread -(represented as <code>lua_State*</code>). -This value must be a thread; -otherwise, the function returns <code>NULL</code>. - - - - - -<hr><h3><a name="lua_touserdata"><code>lua_touserdata</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void *lua_touserdata (lua_State *L, int index);</pre> - -<p> -If the value at the given index is a full userdata, -returns its block address. -If the value is a light userdata, -returns its pointer. -Otherwise, returns <code>NULL</code>. - - - - - -<hr><h3><a name="lua_type"><code>lua_type</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_type (lua_State *L, int index);</pre> - -<p> -Returns the type of the value in the given valid index, -or <code>LUA_TNONE</code> for a non-valid (but acceptable) index. -The types returned by <a href="#lua_type"><code>lua_type</code></a> are coded by the following constants -defined in <code>lua.h</code>: -<a name="pdf-LUA_TNIL"><code>LUA_TNIL</code></a>, -<a name="pdf-LUA_TNUMBER"><code>LUA_TNUMBER</code></a>, -<a name="pdf-LUA_TBOOLEAN"><code>LUA_TBOOLEAN</code></a>, -<a name="pdf-LUA_TSTRING"><code>LUA_TSTRING</code></a>, -<a name="pdf-LUA_TTABLE"><code>LUA_TTABLE</code></a>, -<a name="pdf-LUA_TFUNCTION"><code>LUA_TFUNCTION</code></a>, -<a name="pdf-LUA_TUSERDATA"><code>LUA_TUSERDATA</code></a>, -<a name="pdf-LUA_TTHREAD"><code>LUA_TTHREAD</code></a>, -and -<a name="pdf-LUA_TLIGHTUSERDATA"><code>LUA_TLIGHTUSERDATA</code></a>. - - - - - -<hr><h3><a name="lua_typename"><code>lua_typename</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>const char *lua_typename (lua_State *L, int tp);</pre> - -<p> -Returns the name of the type encoded by the value <code>tp</code>, -which must be one the values returned by <a href="#lua_type"><code>lua_type</code></a>. - - - - - -<hr><h3><a name="lua_Unsigned"><code>lua_Unsigned</code></a></h3> -<pre>typedef ... lua_Unsigned;</pre> - -<p> -The unsigned version of <a href="#lua_Integer"><code>lua_Integer</code></a>. - - - - - -<hr><h3><a name="lua_upvalueindex"><code>lua_upvalueindex</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_upvalueindex (int i);</pre> - -<p> -Returns the pseudo-index that represents the <code>i</code>-th upvalue of -the running function (see <a href="#4.4">§4.4</a>). - - - - - -<hr><h3><a name="lua_version"><code>lua_version</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>const lua_Number *lua_version (lua_State *L);</pre> - -<p> -Returns the address of the version number stored in the Lua core. -When called with a valid <a href="#lua_State"><code>lua_State</code></a>, -returns the address of the version used to create that state. -When called with <code>NULL</code>, -returns the address of the version running the call. - - - - - -<hr><h3><a name="lua_Writer"><code>lua_Writer</code></a></h3> -<pre>typedef int (*lua_Writer) (lua_State *L, - const void* p, - size_t sz, - void* ud);</pre> - -<p> -The type of the writer function used by <a href="#lua_dump"><code>lua_dump</code></a>. -Every time it produces another piece of chunk, -<a href="#lua_dump"><code>lua_dump</code></a> calls the writer, -passing along the buffer to be written (<code>p</code>), -its size (<code>sz</code>), -and the <code>data</code> parameter supplied to <a href="#lua_dump"><code>lua_dump</code></a>. - - -<p> -The writer returns an error code: -0 means no errors; -any other value means an error and stops <a href="#lua_dump"><code>lua_dump</code></a> from -calling the writer again. - - - - - -<hr><h3><a name="lua_xmove"><code>lua_xmove</code></a></h3><p> -<span class="apii">[-?, +?, –]</span> -<pre>void lua_xmove (lua_State *from, lua_State *to, int n);</pre> - -<p> -Exchange values between different threads of the same state. - - -<p> -This function pops <code>n</code> values from the stack <code>from</code>, -and pushes them onto the stack <code>to</code>. - - - - - -<hr><h3><a name="lua_yield"><code>lua_yield</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>int lua_yield (lua_State *L, int nresults);</pre> - -<p> -This function is equivalent to <a href="#lua_yieldk"><code>lua_yieldk</code></a>, -but it has no continuation (see <a href="#4.7">§4.7</a>). -Therefore, when the thread resumes, -it continues the function that called -the function calling <code>lua_yield</code>. - - - - - -<hr><h3><a name="lua_yieldk"><code>lua_yieldk</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>int lua_yieldk (lua_State *L, - int nresults, - lua_KContext ctx, - lua_KFunction k);</pre> - -<p> -Yields a coroutine (thread). - - -<p> -When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a>, -the running coroutine suspends its execution, -and the call to <a href="#lua_resume"><code>lua_resume</code></a> that started this coroutine returns. -The parameter <code>nresults</code> is the number of values from the stack -that will be passed as results to <a href="#lua_resume"><code>lua_resume</code></a>. - - -<p> -When the coroutine is resumed again, -Lua calls the given continuation function <code>k</code> to continue -the execution of the C function that yielded (see <a href="#4.7">§4.7</a>). -This continuation function receives the same stack -from the previous function, -with the <code>n</code> results removed and -replaced by the arguments passed to <a href="#lua_resume"><code>lua_resume</code></a>. -Moreover, -the continuation function receives the value <code>ctx</code> -that was passed to <a href="#lua_yieldk"><code>lua_yieldk</code></a>. - - -<p> -Usually, this function does not return; -when the coroutine eventually resumes, -it continues executing the continuation function. -However, there is one special case, -which is when this function is called -from inside a line hook (see <a href="#4.9">§4.9</a>). -In that case, <code>lua_yieldk</code> should be called with no continuation -(probably in the form of <a href="#lua_yield"><code>lua_yield</code></a>), -and the hook should return immediately after the call. -Lua will yield and, -when the coroutine resumes again, -it will continue the normal execution -of the (Lua) function that triggered the hook. - - -<p> -This function can raise an error if it is called from a thread -with a pending C call with no continuation function, -or it is called from a thread that is not running inside a resume -(e.g., the main thread). - - - - - - - -<h2>4.9 – <a name="4.9">The Debug Interface</a></h2> - -<p> -Lua has no built-in debugging facilities. -Instead, it offers a special interface -by means of functions and <em>hooks</em>. -This interface allows the construction of different -kinds of debuggers, profilers, and other tools -that need "inside information" from the interpreter. - - - -<hr><h3><a name="lua_Debug"><code>lua_Debug</code></a></h3> -<pre>typedef struct lua_Debug { - int event; - const char *name; /* (n) */ - const char *namewhat; /* (n) */ - const char *what; /* (S) */ - const char *source; /* (S) */ - int currentline; /* (l) */ - int linedefined; /* (S) */ - int lastlinedefined; /* (S) */ - unsigned char nups; /* (u) number of upvalues */ - unsigned char nparams; /* (u) number of parameters */ - char isvararg; /* (u) */ - char istailcall; /* (t) */ - char short_src[LUA_IDSIZE]; /* (S) */ - /* private part */ - <em>other fields</em> -} lua_Debug;</pre> - -<p> -A structure used to carry different pieces of -information about a function or an activation record. -<a href="#lua_getstack"><code>lua_getstack</code></a> fills only the private part -of this structure, for later use. -To fill the other fields of <a href="#lua_Debug"><code>lua_Debug</code></a> with useful information, -call <a href="#lua_getinfo"><code>lua_getinfo</code></a>. - - -<p> -The fields of <a href="#lua_Debug"><code>lua_Debug</code></a> have the following meaning: - -<ul> - -<li><b><code>source</code>: </b> -the name of the chunk that created the function. -If <code>source</code> starts with a '<code>@</code>', -it means that the function was defined in a file where -the file name follows the '<code>@</code>'. -If <code>source</code> starts with a '<code>=</code>', -the remainder of its contents describe the source in a user-dependent manner. -Otherwise, -the function was defined in a string where -<code>source</code> is that string. -</li> - -<li><b><code>short_src</code>: </b> -a "printable" version of <code>source</code>, to be used in error messages. -</li> - -<li><b><code>linedefined</code>: </b> -the line number where the definition of the function starts. -</li> - -<li><b><code>lastlinedefined</code>: </b> -the line number where the definition of the function ends. -</li> - -<li><b><code>what</code>: </b> -the string <code>"Lua"</code> if the function is a Lua function, -<code>"C"</code> if it is a C function, -<code>"main"</code> if it is the main part of a chunk. -</li> - -<li><b><code>currentline</code>: </b> -the current line where the given function is executing. -When no line information is available, -<code>currentline</code> is set to -1. -</li> - -<li><b><code>name</code>: </b> -a reasonable name for the given function. -Because functions in Lua are first-class values, -they do not have a fixed name: -some functions can be the value of multiple global variables, -while others can be stored only in a table field. -The <code>lua_getinfo</code> function checks how the function was -called to find a suitable name. -If it cannot find a name, -then <code>name</code> is set to <code>NULL</code>. -</li> - -<li><b><code>namewhat</code>: </b> -explains the <code>name</code> field. -The value of <code>namewhat</code> can be -<code>"global"</code>, <code>"local"</code>, <code>"method"</code>, -<code>"field"</code>, <code>"upvalue"</code>, or <code>""</code> (the empty string), -according to how the function was called. -(Lua uses the empty string when no other option seems to apply.) -</li> - -<li><b><code>istailcall</code>: </b> -true if this function invocation was called by a tail call. -In this case, the caller of this level is not in the stack. -</li> - -<li><b><code>nups</code>: </b> -the number of upvalues of the function. -</li> - -<li><b><code>nparams</code>: </b> -the number of fixed parameters of the function -(always 0 for C functions). -</li> - -<li><b><code>isvararg</code>: </b> -true if the function is a vararg function -(always true for C functions). -</li> - -</ul> - - - - -<hr><h3><a name="lua_gethook"><code>lua_gethook</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_Hook lua_gethook (lua_State *L);</pre> - -<p> -Returns the current hook function. - - - - - -<hr><h3><a name="lua_gethookcount"><code>lua_gethookcount</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_gethookcount (lua_State *L);</pre> - -<p> -Returns the current hook count. - - - - - -<hr><h3><a name="lua_gethookmask"><code>lua_gethookmask</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_gethookmask (lua_State *L);</pre> - -<p> -Returns the current hook mask. - - - - - -<hr><h3><a name="lua_getinfo"><code>lua_getinfo</code></a></h3><p> -<span class="apii">[-(0|1), +(0|1|2), <em>e</em>]</span> -<pre>int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);</pre> - -<p> -Gets information about a specific function or function invocation. - - -<p> -To get information about a function invocation, -the parameter <code>ar</code> must be a valid activation record that was -filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or -given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>). - - -<p> -To get information about a function you push it onto the stack -and start the <code>what</code> string with the character '<code>></code>'. -(In that case, -<code>lua_getinfo</code> pops the function from the top of the stack.) -For instance, to know in which line a function <code>f</code> was defined, -you can write the following code: - -<pre> - lua_Debug ar; - lua_getglobal(L, "f"); /* get global 'f' */ - lua_getinfo(L, ">S", &ar); - printf("%d\n", ar.linedefined); -</pre> - -<p> -Each character in the string <code>what</code> -selects some fields of the structure <code>ar</code> to be filled or -a value to be pushed on the stack: - -<ul> - -<li><b>'<code>n</code>': </b> fills in the field <code>name</code> and <code>namewhat</code>; -</li> - -<li><b>'<code>S</code>': </b> -fills in the fields <code>source</code>, <code>short_src</code>, -<code>linedefined</code>, <code>lastlinedefined</code>, and <code>what</code>; -</li> - -<li><b>'<code>l</code>': </b> fills in the field <code>currentline</code>; -</li> - -<li><b>'<code>t</code>': </b> fills in the field <code>istailcall</code>; -</li> - -<li><b>'<code>u</code>': </b> fills in the fields -<code>nups</code>, <code>nparams</code>, and <code>isvararg</code>; -</li> - -<li><b>'<code>f</code>': </b> -pushes onto the stack the function that is -running at the given level; -</li> - -<li><b>'<code>L</code>': </b> -pushes onto the stack a table whose indices are the -numbers of the lines that are valid on the function. -(A <em>valid line</em> is a line with some associated code, -that is, a line where you can put a break point. -Non-valid lines include empty lines and comments.) - - -<p> -If this option is given together with option '<code>f</code>', -its table is pushed after the function. -</li> - -</ul> - -<p> -This function returns 0 on error -(for instance, an invalid option in <code>what</code>). - - - - - -<hr><h3><a name="lua_getlocal"><code>lua_getlocal</code></a></h3><p> -<span class="apii">[-0, +(0|1), –]</span> -<pre>const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);</pre> - -<p> -Gets information about a local variable of -a given activation record or a given function. - - -<p> -In the first case, -the parameter <code>ar</code> must be a valid activation record that was -filled by a previous call to <a href="#lua_getstack"><code>lua_getstack</code></a> or -given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>). -The index <code>n</code> selects which local variable to inspect; -see <a href="#pdf-debug.getlocal"><code>debug.getlocal</code></a> for details about variable indices -and names. - - -<p> -<a href="#lua_getlocal"><code>lua_getlocal</code></a> pushes the variable's value onto the stack -and returns its name. - - -<p> -In the second case, <code>ar</code> must be <code>NULL</code> and the function -to be inspected must be at the top of the stack. -In this case, only parameters of Lua functions are visible -(as there is no information about what variables are active) -and no values are pushed onto the stack. - - -<p> -Returns <code>NULL</code> (and pushes nothing) -when the index is greater than -the number of active local variables. - - - - - -<hr><h3><a name="lua_getstack"><code>lua_getstack</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>int lua_getstack (lua_State *L, int level, lua_Debug *ar);</pre> - -<p> -Gets information about the interpreter runtime stack. - - -<p> -This function fills parts of a <a href="#lua_Debug"><code>lua_Debug</code></a> structure with -an identification of the <em>activation record</em> -of the function executing at a given level. -Level 0 is the current running function, -whereas level <em>n+1</em> is the function that has called level <em>n</em> -(except for tail calls, which do not count on the stack). -When there are no errors, <a href="#lua_getstack"><code>lua_getstack</code></a> returns 1; -when called with a level greater than the stack depth, -it returns 0. - - - - - -<hr><h3><a name="lua_getupvalue"><code>lua_getupvalue</code></a></h3><p> -<span class="apii">[-0, +(0|1), –]</span> -<pre>const char *lua_getupvalue (lua_State *L, int funcindex, int n);</pre> - -<p> -Gets information about a closure's upvalue. -(For Lua functions, -upvalues are the external local variables that the function uses, -and that are consequently included in its closure.) -<a href="#lua_getupvalue"><code>lua_getupvalue</code></a> gets the index <code>n</code> of an upvalue, -pushes the upvalue's value onto the stack, -and returns its name. -<code>funcindex</code> points to the closure in the stack. -(Upvalues have no particular order, -as they are active through the whole function. -So, they are numbered in an arbitrary order.) - - -<p> -Returns <code>NULL</code> (and pushes nothing) -when the index is greater than the number of upvalues. -For C functions, this function uses the empty string <code>""</code> -as a name for all upvalues. - - - - - -<hr><h3><a name="lua_Hook"><code>lua_Hook</code></a></h3> -<pre>typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);</pre> - -<p> -Type for debugging hook functions. - - -<p> -Whenever a hook is called, its <code>ar</code> argument has its field -<code>event</code> set to the specific event that triggered the hook. -Lua identifies these events with the following constants: -<a name="pdf-LUA_HOOKCALL"><code>LUA_HOOKCALL</code></a>, <a name="pdf-LUA_HOOKRET"><code>LUA_HOOKRET</code></a>, -<a name="pdf-LUA_HOOKTAILCALL"><code>LUA_HOOKTAILCALL</code></a>, <a name="pdf-LUA_HOOKLINE"><code>LUA_HOOKLINE</code></a>, -and <a name="pdf-LUA_HOOKCOUNT"><code>LUA_HOOKCOUNT</code></a>. -Moreover, for line events, the field <code>currentline</code> is also set. -To get the value of any other field in <code>ar</code>, -the hook must call <a href="#lua_getinfo"><code>lua_getinfo</code></a>. - - -<p> -For call events, <code>event</code> can be <code>LUA_HOOKCALL</code>, -the normal value, or <code>LUA_HOOKTAILCALL</code>, for a tail call; -in this case, there will be no corresponding return event. - - -<p> -While Lua is running a hook, it disables other calls to hooks. -Therefore, if a hook calls back Lua to execute a function or a chunk, -this execution occurs without any calls to hooks. - - -<p> -Hook functions cannot have continuations, -that is, they cannot call <a href="#lua_yieldk"><code>lua_yieldk</code></a>, -<a href="#lua_pcallk"><code>lua_pcallk</code></a>, or <a href="#lua_callk"><code>lua_callk</code></a> with a non-null <code>k</code>. - - -<p> -Hook functions can yield under the following conditions: -Only count and line events can yield -and they cannot yield any value; -to yield a hook function must finish its execution -calling <a href="#lua_yield"><code>lua_yield</code></a> with <code>nresults</code> equal to zero. - - - - - -<hr><h3><a name="lua_sethook"><code>lua_sethook</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void lua_sethook (lua_State *L, lua_Hook f, int mask, int count);</pre> - -<p> -Sets the debugging hook function. - - -<p> -Argument <code>f</code> is the hook function. -<code>mask</code> specifies on which events the hook will be called: -it is formed by a bitwise or of the constants -<a name="pdf-LUA_MASKCALL"><code>LUA_MASKCALL</code></a>, -<a name="pdf-LUA_MASKRET"><code>LUA_MASKRET</code></a>, -<a name="pdf-LUA_MASKLINE"><code>LUA_MASKLINE</code></a>, -and <a name="pdf-LUA_MASKCOUNT"><code>LUA_MASKCOUNT</code></a>. -The <code>count</code> argument is only meaningful when the mask -includes <code>LUA_MASKCOUNT</code>. -For each event, the hook is called as explained below: - -<ul> - -<li><b>The call hook: </b> is called when the interpreter calls a function. -The hook is called just after Lua enters the new function, -before the function gets its arguments. -</li> - -<li><b>The return hook: </b> is called when the interpreter returns from a function. -The hook is called just before Lua leaves the function. -There is no standard way to access the values -to be returned by the function. -</li> - -<li><b>The line hook: </b> is called when the interpreter is about to -start the execution of a new line of code, -or when it jumps back in the code (even to the same line). -(This event only happens while Lua is executing a Lua function.) -</li> - -<li><b>The count hook: </b> is called after the interpreter executes every -<code>count</code> instructions. -(This event only happens while Lua is executing a Lua function.) -</li> - -</ul> - -<p> -A hook is disabled by setting <code>mask</code> to zero. - - - - - -<hr><h3><a name="lua_setlocal"><code>lua_setlocal</code></a></h3><p> -<span class="apii">[-(0|1), +0, –]</span> -<pre>const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);</pre> - -<p> -Sets the value of a local variable of a given activation record. -Parameters <code>ar</code> and <code>n</code> are as in <a href="#lua_getlocal"><code>lua_getlocal</code></a> -(see <a href="#lua_getlocal"><code>lua_getlocal</code></a>). -<a href="#lua_setlocal"><code>lua_setlocal</code></a> assigns the value at the top of the stack -to the variable and returns its name. -It also pops the value from the stack. - - -<p> -Returns <code>NULL</code> (and pops nothing) -when the index is greater than -the number of active local variables. - - - - - -<hr><h3><a name="lua_setupvalue"><code>lua_setupvalue</code></a></h3><p> -<span class="apii">[-(0|1), +0, –]</span> -<pre>const char *lua_setupvalue (lua_State *L, int funcindex, int n);</pre> - -<p> -Sets the value of a closure's upvalue. -It assigns the value at the top of the stack -to the upvalue and returns its name. -It also pops the value from the stack. -Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a> -(see <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>). - - -<p> -Returns <code>NULL</code> (and pops nothing) -when the index is greater than the number of upvalues. - - - - - -<hr><h3><a name="lua_upvalueid"><code>lua_upvalueid</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void *lua_upvalueid (lua_State *L, int funcindex, int n);</pre> - -<p> -Returns a unique identifier for the upvalue numbered <code>n</code> -from the closure at index <code>funcindex</code>. -Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>lua_getupvalue</code></a> -(see <a href="#lua_getupvalue"><code>lua_getupvalue</code></a>) -(but <code>n</code> cannot be greater than the number of upvalues). - - -<p> -These unique identifiers allow a program to check whether different -closures share upvalues. -Lua closures that share an upvalue -(that is, that access a same external local variable) -will return identical ids for those upvalue indices. - - - - - -<hr><h3><a name="lua_upvaluejoin"><code>lua_upvaluejoin</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void lua_upvaluejoin (lua_State *L, int funcindex1, int n1, - int funcindex2, int n2);</pre> - -<p> -Make the <code>n1</code>-th upvalue of the Lua closure at index <code>funcindex1</code> -refer to the <code>n2</code>-th upvalue of the Lua closure at index <code>funcindex2</code>. - - - - - - - -<h1>5 – <a name="5">The Auxiliary Library</a></h1> - -<p> - -The <em>auxiliary library</em> provides several convenient functions -to interface C with Lua. -While the basic API provides the primitive functions for all -interactions between C and Lua, -the auxiliary library provides higher-level functions for some -common tasks. - - -<p> -All functions and types from the auxiliary library -are defined in header file <code>lauxlib.h</code> and -have a prefix <code>luaL_</code>. - - -<p> -All functions in the auxiliary library are built on -top of the basic API, -and so they provide nothing that cannot be done with that API. -Nevertheless, the use of the auxiliary library ensures -more consistency to your code. - - -<p> -Several functions in the auxiliary library use internally some -extra stack slots. -When a function in the auxiliary library uses less than five slots, -it does not check the stack size; -it simply assumes that there are enough slots. - - -<p> -Several functions in the auxiliary library are used to -check C function arguments. -Because the error message is formatted for arguments -(e.g., "<code>bad argument #1</code>"), -you should not use these functions for other stack values. - - -<p> -Functions called <code>luaL_check*</code> -always raise an error if the check is not satisfied. - - - -<h2>5.1 – <a name="5.1">Functions and Types</a></h2> - -<p> -Here we list all functions and types from the auxiliary library -in alphabetical order. - - - -<hr><h3><a name="luaL_addchar"><code>luaL_addchar</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>void luaL_addchar (luaL_Buffer *B, char c);</pre> - -<p> -Adds the byte <code>c</code> to the buffer <code>B</code> -(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>). - - - - - -<hr><h3><a name="luaL_addlstring"><code>luaL_addlstring</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);</pre> - -<p> -Adds the string pointed to by <code>s</code> with length <code>l</code> to -the buffer <code>B</code> -(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>). -The string can contain embedded zeros. - - - - - -<hr><h3><a name="luaL_addsize"><code>luaL_addsize</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>void luaL_addsize (luaL_Buffer *B, size_t n);</pre> - -<p> -Adds to the buffer <code>B</code> (see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>) -a string of length <code>n</code> previously copied to the -buffer area (see <a href="#luaL_prepbuffer"><code>luaL_prepbuffer</code></a>). - - - - - -<hr><h3><a name="luaL_addstring"><code>luaL_addstring</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>void luaL_addstring (luaL_Buffer *B, const char *s);</pre> - -<p> -Adds the zero-terminated string pointed to by <code>s</code> -to the buffer <code>B</code> -(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>). - - - - - -<hr><h3><a name="luaL_addvalue"><code>luaL_addvalue</code></a></h3><p> -<span class="apii">[-1, +?, <em>e</em>]</span> -<pre>void luaL_addvalue (luaL_Buffer *B);</pre> - -<p> -Adds the value at the top of the stack -to the buffer <code>B</code> -(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>). -Pops the value. - - -<p> -This is the only function on string buffers that can (and must) -be called with an extra element on the stack, -which is the value to be added to the buffer. - - - - - -<hr><h3><a name="luaL_argcheck"><code>luaL_argcheck</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>void luaL_argcheck (lua_State *L, - int cond, - int arg, - const char *extramsg);</pre> - -<p> -Checks whether <code>cond</code> is true. -If it is not, raises an error with a standard message (see <a href="#luaL_argerror"><code>luaL_argerror</code></a>). - - - - - -<hr><h3><a name="luaL_argerror"><code>luaL_argerror</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>int luaL_argerror (lua_State *L, int arg, const char *extramsg);</pre> - -<p> -Raises an error reporting a problem with argument <code>arg</code> -of the C function that called it, -using a standard message -that includes <code>extramsg</code> as a comment: - -<pre> - bad argument #<em>arg</em> to '<em>funcname</em>' (<em>extramsg</em>) -</pre><p> -This function never returns. - - - - - -<hr><h3><a name="luaL_Buffer"><code>luaL_Buffer</code></a></h3> -<pre>typedef struct luaL_Buffer luaL_Buffer;</pre> - -<p> -Type for a <em>string buffer</em>. - - -<p> -A string buffer allows C code to build Lua strings piecemeal. -Its pattern of use is as follows: - -<ul> - -<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li> - -<li>Then initialize it with a call <code>luaL_buffinit(L, &b)</code>.</li> - -<li> -Then add string pieces to the buffer calling any of -the <code>luaL_add*</code> functions. -</li> - -<li> -Finish by calling <code>luaL_pushresult(&b)</code>. -This call leaves the final string on the top of the stack. -</li> - -</ul> - -<p> -If you know beforehand the total size of the resulting string, -you can use the buffer like this: - -<ul> - -<li>First declare a variable <code>b</code> of type <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>.</li> - -<li>Then initialize it and preallocate a space of -size <code>sz</code> with a call <code>luaL_buffinitsize(L, &b, sz)</code>.</li> - -<li>Then copy the string into that space.</li> - -<li> -Finish by calling <code>luaL_pushresultsize(&b, sz)</code>, -where <code>sz</code> is the total size of the resulting string -copied into that space. -</li> - -</ul> - -<p> -During its normal operation, -a string buffer uses a variable number of stack slots. -So, while using a buffer, you cannot assume that you know where -the top of the stack is. -You can use the stack between successive calls to buffer operations -as long as that use is balanced; -that is, -when you call a buffer operation, -the stack is at the same level -it was immediately after the previous buffer operation. -(The only exception to this rule is <a href="#luaL_addvalue"><code>luaL_addvalue</code></a>.) -After calling <a href="#luaL_pushresult"><code>luaL_pushresult</code></a> the stack is back to its -level when the buffer was initialized, -plus the final string on its top. - - - - - -<hr><h3><a name="luaL_buffinit"><code>luaL_buffinit</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void luaL_buffinit (lua_State *L, luaL_Buffer *B);</pre> - -<p> -Initializes a buffer <code>B</code>. -This function does not allocate any space; -the buffer must be declared as a variable -(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>). - - - - - -<hr><h3><a name="luaL_buffinitsize"><code>luaL_buffinitsize</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);</pre> - -<p> -Equivalent to the sequence -<a href="#luaL_buffinit"><code>luaL_buffinit</code></a>, <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a>. - - - - - -<hr><h3><a name="luaL_callmeta"><code>luaL_callmeta</code></a></h3><p> -<span class="apii">[-0, +(0|1), <em>e</em>]</span> -<pre>int luaL_callmeta (lua_State *L, int obj, const char *e);</pre> - -<p> -Calls a metamethod. - - -<p> -If the object at index <code>obj</code> has a metatable and this -metatable has a field <code>e</code>, -this function calls this field passing the object as its only argument. -In this case this function returns true and pushes onto the -stack the value returned by the call. -If there is no metatable or no metamethod, -this function returns false (without pushing any value on the stack). - - - - - -<hr><h3><a name="luaL_checkany"><code>luaL_checkany</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>void luaL_checkany (lua_State *L, int arg);</pre> - -<p> -Checks whether the function has an argument -of any type (including <b>nil</b>) at position <code>arg</code>. - - - - - -<hr><h3><a name="luaL_checkinteger"><code>luaL_checkinteger</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>lua_Integer luaL_checkinteger (lua_State *L, int arg);</pre> - -<p> -Checks whether the function argument <code>arg</code> is an integer -(or can be converted to an integer) -and returns this integer cast to a <a href="#lua_Integer"><code>lua_Integer</code></a>. - - - - - -<hr><h3><a name="luaL_checklstring"><code>luaL_checklstring</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>const char *luaL_checklstring (lua_State *L, int arg, size_t *l);</pre> - -<p> -Checks whether the function argument <code>arg</code> is a string -and returns this string; -if <code>l</code> is not <code>NULL</code> fills <code>*l</code> -with the string's length. - - -<p> -This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result, -so all conversions and caveats of that function apply here. - - - - - -<hr><h3><a name="luaL_checknumber"><code>luaL_checknumber</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>lua_Number luaL_checknumber (lua_State *L, int arg);</pre> - -<p> -Checks whether the function argument <code>arg</code> is a number -and returns this number. - - - - - -<hr><h3><a name="luaL_checkoption"><code>luaL_checkoption</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>int luaL_checkoption (lua_State *L, - int arg, - const char *def, - const char *const lst[]);</pre> - -<p> -Checks whether the function argument <code>arg</code> is a string and -searches for this string in the array <code>lst</code> -(which must be NULL-terminated). -Returns the index in the array where the string was found. -Raises an error if the argument is not a string or -if the string cannot be found. - - -<p> -If <code>def</code> is not <code>NULL</code>, -the function uses <code>def</code> as a default value when -there is no argument <code>arg</code> or when this argument is <b>nil</b>. - - -<p> -This is a useful function for mapping strings to C enums. -(The usual convention in Lua libraries is -to use strings instead of numbers to select options.) - - - - - -<hr><h3><a name="luaL_checkstack"><code>luaL_checkstack</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>void luaL_checkstack (lua_State *L, int sz, const char *msg);</pre> - -<p> -Grows the stack size to <code>top + sz</code> elements, -raising an error if the stack cannot grow to that size. -<code>msg</code> is an additional text to go into the error message -(or <code>NULL</code> for no additional text). - - - - - -<hr><h3><a name="luaL_checkstring"><code>luaL_checkstring</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>const char *luaL_checkstring (lua_State *L, int arg);</pre> - -<p> -Checks whether the function argument <code>arg</code> is a string -and returns this string. - - -<p> -This function uses <a href="#lua_tolstring"><code>lua_tolstring</code></a> to get its result, -so all conversions and caveats of that function apply here. - - - - - -<hr><h3><a name="luaL_checktype"><code>luaL_checktype</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>void luaL_checktype (lua_State *L, int arg, int t);</pre> - -<p> -Checks whether the function argument <code>arg</code> has type <code>t</code>. -See <a href="#lua_type"><code>lua_type</code></a> for the encoding of types for <code>t</code>. - - - - - -<hr><h3><a name="luaL_checkudata"><code>luaL_checkudata</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>void *luaL_checkudata (lua_State *L, int arg, const char *tname);</pre> - -<p> -Checks whether the function argument <code>arg</code> is a userdata -of the type <code>tname</code> (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>) and -returns the userdata address (see <a href="#lua_touserdata"><code>lua_touserdata</code></a>). - - - - - -<hr><h3><a name="luaL_checkversion"><code>luaL_checkversion</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void luaL_checkversion (lua_State *L);</pre> - -<p> -Checks whether the core running the call, -the core that created the Lua state, -and the code making the call are all using the same version of Lua. -Also checks whether the core running the call -and the core that created the Lua state -are using the same address space. - - - - - -<hr><h3><a name="luaL_dofile"><code>luaL_dofile</code></a></h3><p> -<span class="apii">[-0, +?, <em>e</em>]</span> -<pre>int luaL_dofile (lua_State *L, const char *filename);</pre> - -<p> -Loads and runs the given file. -It is defined as the following macro: - -<pre> - (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0)) -</pre><p> -It returns false if there are no errors -or true in case of errors. - - - - - -<hr><h3><a name="luaL_dostring"><code>luaL_dostring</code></a></h3><p> -<span class="apii">[-0, +?, –]</span> -<pre>int luaL_dostring (lua_State *L, const char *str);</pre> - -<p> -Loads and runs the given string. -It is defined as the following macro: - -<pre> - (luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0)) -</pre><p> -It returns false if there are no errors -or true in case of errors. - - - - - -<hr><h3><a name="luaL_error"><code>luaL_error</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>int luaL_error (lua_State *L, const char *fmt, ...);</pre> - -<p> -Raises an error. -The error message format is given by <code>fmt</code> -plus any extra arguments, -following the same rules of <a href="#lua_pushfstring"><code>lua_pushfstring</code></a>. -It also adds at the beginning of the message the file name and -the line number where the error occurred, -if this information is available. - - -<p> -This function never returns, -but it is an idiom to use it in C functions -as <code>return luaL_error(<em>args</em>)</code>. - - - - - -<hr><h3><a name="luaL_execresult"><code>luaL_execresult</code></a></h3><p> -<span class="apii">[-0, +3, <em>e</em>]</span> -<pre>int luaL_execresult (lua_State *L, int stat);</pre> - -<p> -This function produces the return values for -process-related functions in the standard library -(<a href="#pdf-os.execute"><code>os.execute</code></a> and <a href="#pdf-io.close"><code>io.close</code></a>). - - - - - -<hr><h3><a name="luaL_fileresult"><code>luaL_fileresult</code></a></h3><p> -<span class="apii">[-0, +(1|3), <em>e</em>]</span> -<pre>int luaL_fileresult (lua_State *L, int stat, const char *fname);</pre> - -<p> -This function produces the return values for -file-related functions in the standard library -(<a href="#pdf-io.open"><code>io.open</code></a>, <a href="#pdf-os.rename"><code>os.rename</code></a>, <a href="#pdf-file:seek"><code>file:seek</code></a>, etc.). - - - - - -<hr><h3><a name="luaL_getmetafield"><code>luaL_getmetafield</code></a></h3><p> -<span class="apii">[-0, +(0|1), <em>e</em>]</span> -<pre>int luaL_getmetafield (lua_State *L, int obj, const char *e);</pre> - -<p> -Pushes onto the stack the field <code>e</code> from the metatable -of the object at index <code>obj</code> and returns the type of pushed value. -If the object does not have a metatable, -or if the metatable does not have this field, -pushes nothing and returns <code>LUA_TNIL</code>. - - - - - -<hr><h3><a name="luaL_getmetatable"><code>luaL_getmetatable</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int luaL_getmetatable (lua_State *L, const char *tname);</pre> - -<p> -Pushes onto the stack the metatable associated with name <code>tname</code> -in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>). -If there is no metatable associated with <code>tname</code>, -returns false and pushes <b>nil</b>. - - - - - -<hr><h3><a name="luaL_getsubtable"><code>luaL_getsubtable</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int luaL_getsubtable (lua_State *L, int idx, const char *fname);</pre> - -<p> -Ensures that the value <code>t[fname]</code>, -where <code>t</code> is the value at index <code>idx</code>, -is a table, -and pushes that table onto the stack. -Returns true if it finds a previous table there -and false if it creates a new table. - - - - - -<hr><h3><a name="luaL_gsub"><code>luaL_gsub</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *luaL_gsub (lua_State *L, - const char *s, - const char *p, - const char *r);</pre> - -<p> -Creates a copy of string <code>s</code> by replacing -any occurrence of the string <code>p</code> -with the string <code>r</code>. -Pushes the resulting string on the stack and returns it. - - - - - -<hr><h3><a name="luaL_len"><code>luaL_len</code></a></h3><p> -<span class="apii">[-0, +0, <em>e</em>]</span> -<pre>lua_Integer luaL_len (lua_State *L, int index);</pre> - -<p> -Returns the "length" of the value at the given index -as a number; -it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.7">§3.4.7</a>). -Raises an error if the result of the operation is not an integer. -(This case only can happen through metamethods.) - - - - - -<hr><h3><a name="luaL_loadbuffer"><code>luaL_loadbuffer</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int luaL_loadbuffer (lua_State *L, - const char *buff, - size_t sz, - const char *name);</pre> - -<p> -Equivalent to <a href="#luaL_loadbufferx"><code>luaL_loadbufferx</code></a> with <code>mode</code> equal to <code>NULL</code>. - - - - - -<hr><h3><a name="luaL_loadbufferx"><code>luaL_loadbufferx</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int luaL_loadbufferx (lua_State *L, - const char *buff, - size_t sz, - const char *name, - const char *mode);</pre> - -<p> -Loads a buffer as a Lua chunk. -This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the -buffer pointed to by <code>buff</code> with size <code>sz</code>. - - -<p> -This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>. -<code>name</code> is the chunk name, -used for debug information and error messages. -The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>. - - - - - -<hr><h3><a name="luaL_loadfile"><code>luaL_loadfile</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int luaL_loadfile (lua_State *L, const char *filename);</pre> - -<p> -Equivalent to <a href="#luaL_loadfilex"><code>luaL_loadfilex</code></a> with <code>mode</code> equal to <code>NULL</code>. - - - - - -<hr><h3><a name="luaL_loadfilex"><code>luaL_loadfilex</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int luaL_loadfilex (lua_State *L, const char *filename, - const char *mode);</pre> - -<p> -Loads a file as a Lua chunk. -This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file -named <code>filename</code>. -If <code>filename</code> is <code>NULL</code>, -then it loads from the standard input. -The first line in the file is ignored if it starts with a <code>#</code>. - - -<p> -The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>. - - -<p> -This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>, -but it has an extra error code <a name="pdf-LUA_ERRFILE"><code>LUA_ERRFILE</code></a> -if it cannot open/read the file or the file has a wrong mode. - - -<p> -As <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk; -it does not run it. - - - - - -<hr><h3><a name="luaL_loadstring"><code>luaL_loadstring</code></a></h3><p> -<span class="apii">[-0, +1, –]</span> -<pre>int luaL_loadstring (lua_State *L, const char *s);</pre> - -<p> -Loads a string as a Lua chunk. -This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in -the zero-terminated string <code>s</code>. - - -<p> -This function returns the same results as <a href="#lua_load"><code>lua_load</code></a>. - - -<p> -Also as <a href="#lua_load"><code>lua_load</code></a>, this function only loads the chunk; -it does not run it. - - - - - -<hr><h3><a name="luaL_newlib"><code>luaL_newlib</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void luaL_newlib (lua_State *L, const luaL_Reg l[]);</pre> - -<p> -Creates a new table and registers there -the functions in list <code>l</code>. - - -<p> -It is implemented as the following macro: - -<pre> - (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) -</pre><p> -The array <code>l</code> must be the actual array, -not a pointer to it. - - - - - -<hr><h3><a name="luaL_newlibtable"><code>luaL_newlibtable</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);</pre> - -<p> -Creates a new table with a size optimized -to store all entries in the array <code>l</code> -(but does not actually store them). -It is intended to be used in conjunction with <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a> -(see <a href="#luaL_newlib"><code>luaL_newlib</code></a>). - - -<p> -It is implemented as a macro. -The array <code>l</code> must be the actual array, -not a pointer to it. - - - - - -<hr><h3><a name="luaL_newmetatable"><code>luaL_newmetatable</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>int luaL_newmetatable (lua_State *L, const char *tname);</pre> - -<p> -If the registry already has the key <code>tname</code>, -returns 0. -Otherwise, -creates a new table to be used as a metatable for userdata, -adds to this new table the pair <code>__name = tname</code>, -adds to the registry the pair <code>[tname] = new table</code>, -and returns 1. -(The entry <code>__name</code> is used by some error-reporting functions.) - - -<p> -In both cases pushes onto the stack the final value associated -with <code>tname</code> in the registry. - - - - - -<hr><h3><a name="luaL_newstate"><code>luaL_newstate</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>lua_State *luaL_newstate (void);</pre> - -<p> -Creates a new Lua state. -It calls <a href="#lua_newstate"><code>lua_newstate</code></a> with an -allocator based on the standard C <code>realloc</code> function -and then sets a panic function (see <a href="#4.6">§4.6</a>) that prints -an error message to the standard error output in case of fatal -errors. - - -<p> -Returns the new state, -or <code>NULL</code> if there is a memory allocation error. - - - - - -<hr><h3><a name="luaL_openlibs"><code>luaL_openlibs</code></a></h3><p> -<span class="apii">[-0, +0, <em>e</em>]</span> -<pre>void luaL_openlibs (lua_State *L);</pre> - -<p> -Opens all standard Lua libraries into the given state. - - - - - -<hr><h3><a name="luaL_optinteger"><code>luaL_optinteger</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>lua_Integer luaL_optinteger (lua_State *L, - int arg, - lua_Integer d);</pre> - -<p> -If the function argument <code>arg</code> is an integer -(or convertible to an integer), -returns this integer. -If this argument is absent or is <b>nil</b>, -returns <code>d</code>. -Otherwise, raises an error. - - - - - -<hr><h3><a name="luaL_optlstring"><code>luaL_optlstring</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>const char *luaL_optlstring (lua_State *L, - int arg, - const char *d, - size_t *l);</pre> - -<p> -If the function argument <code>arg</code> is a string, -returns this string. -If this argument is absent or is <b>nil</b>, -returns <code>d</code>. -Otherwise, raises an error. - - -<p> -If <code>l</code> is not <code>NULL</code>, -fills the position <code>*l</code> with the result's length. - - - - - -<hr><h3><a name="luaL_optnumber"><code>luaL_optnumber</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);</pre> - -<p> -If the function argument <code>arg</code> is a number, -returns this number. -If this argument is absent or is <b>nil</b>, -returns <code>d</code>. -Otherwise, raises an error. - - - - - -<hr><h3><a name="luaL_optstring"><code>luaL_optstring</code></a></h3><p> -<span class="apii">[-0, +0, <em>v</em>]</span> -<pre>const char *luaL_optstring (lua_State *L, - int arg, - const char *d);</pre> - -<p> -If the function argument <code>arg</code> is a string, -returns this string. -If this argument is absent or is <b>nil</b>, -returns <code>d</code>. -Otherwise, raises an error. - - - - - -<hr><h3><a name="luaL_prepbuffer"><code>luaL_prepbuffer</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>char *luaL_prepbuffer (luaL_Buffer *B);</pre> - -<p> -Equivalent to <a href="#luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a> -with the predefined size <a name="pdf-LUAL_BUFFERSIZE"><code>LUAL_BUFFERSIZE</code></a>. - - - - - -<hr><h3><a name="luaL_prepbuffsize"><code>luaL_prepbuffsize</code></a></h3><p> -<span class="apii">[-?, +?, <em>e</em>]</span> -<pre>char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);</pre> - -<p> -Returns an address to a space of size <code>sz</code> -where you can copy a string to be added to buffer <code>B</code> -(see <a href="#luaL_Buffer"><code>luaL_Buffer</code></a>). -After copying the string into this space you must call -<a href="#luaL_addsize"><code>luaL_addsize</code></a> with the size of the string to actually add -it to the buffer. - - - - - -<hr><h3><a name="luaL_pushresult"><code>luaL_pushresult</code></a></h3><p> -<span class="apii">[-?, +1, <em>e</em>]</span> -<pre>void luaL_pushresult (luaL_Buffer *B);</pre> - -<p> -Finishes the use of buffer <code>B</code> leaving the final string on -the top of the stack. - - - - - -<hr><h3><a name="luaL_pushresultsize"><code>luaL_pushresultsize</code></a></h3><p> -<span class="apii">[-?, +1, <em>e</em>]</span> -<pre>void luaL_pushresultsize (luaL_Buffer *B, size_t sz);</pre> - -<p> -Equivalent to the sequence <a href="#luaL_addsize"><code>luaL_addsize</code></a>, <a href="#luaL_pushresult"><code>luaL_pushresult</code></a>. - - - - - -<hr><h3><a name="luaL_ref"><code>luaL_ref</code></a></h3><p> -<span class="apii">[-1, +0, <em>e</em>]</span> -<pre>int luaL_ref (lua_State *L, int t);</pre> - -<p> -Creates and returns a <em>reference</em>, -in the table at index <code>t</code>, -for the object at the top of the stack (and pops the object). - - -<p> -A reference is a unique integer key. -As long as you do not manually add integer keys into table <code>t</code>, -<a href="#luaL_ref"><code>luaL_ref</code></a> ensures the uniqueness of the key it returns. -You can retrieve an object referred by reference <code>r</code> -by calling <code>lua_rawgeti(L, t, r)</code>. -Function <a href="#luaL_unref"><code>luaL_unref</code></a> frees a reference and its associated object. - - -<p> -If the object at the top of the stack is <b>nil</b>, -<a href="#luaL_ref"><code>luaL_ref</code></a> returns the constant <a name="pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>. -The constant <a name="pdf-LUA_NOREF"><code>LUA_NOREF</code></a> is guaranteed to be different -from any reference returned by <a href="#luaL_ref"><code>luaL_ref</code></a>. - - - - - -<hr><h3><a name="luaL_Reg"><code>luaL_Reg</code></a></h3> -<pre>typedef struct luaL_Reg { - const char *name; - lua_CFunction func; -} luaL_Reg;</pre> - -<p> -Type for arrays of functions to be registered by -<a href="#luaL_setfuncs"><code>luaL_setfuncs</code></a>. -<code>name</code> is the function name and <code>func</code> is a pointer to -the function. -Any array of <a href="#luaL_Reg"><code>luaL_Reg</code></a> must end with a sentinel entry -in which both <code>name</code> and <code>func</code> are <code>NULL</code>. - - - - - -<hr><h3><a name="luaL_requiref"><code>luaL_requiref</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void luaL_requiref (lua_State *L, const char *modname, - lua_CFunction openf, int glb);</pre> - -<p> -If <code>modname</code> is not already present in <a href="#pdf-package.loaded"><code>package.loaded</code></a>, -calls function <code>openf</code> with string <code>modname</code> as an argument -and sets the call result in <code>package.loaded[modname]</code>, -as if that function has been called through <a href="#pdf-require"><code>require</code></a>. - - -<p> -If <code>glb</code> is true, -also stores the module into global <code>modname</code>. - - -<p> -Leaves a copy of the module on the stack. - - - - - -<hr><h3><a name="luaL_setfuncs"><code>luaL_setfuncs</code></a></h3><p> -<span class="apii">[-nup, +0, <em>e</em>]</span> -<pre>void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);</pre> - -<p> -Registers all functions in the array <code>l</code> -(see <a href="#luaL_Reg"><code>luaL_Reg</code></a>) into the table on the top of the stack -(below optional upvalues, see next). - - -<p> -When <code>nup</code> is not zero, -all functions are created sharing <code>nup</code> upvalues, -which must be previously pushed on the stack -on top of the library table. -These values are popped from the stack after the registration. - - - - - -<hr><h3><a name="luaL_setmetatable"><code>luaL_setmetatable</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void luaL_setmetatable (lua_State *L, const char *tname);</pre> - -<p> -Sets the metatable of the object at the top of the stack -as the metatable associated with name <code>tname</code> -in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>). - - - - - -<hr><h3><a name="luaL_Stream"><code>luaL_Stream</code></a></h3> -<pre>typedef struct luaL_Stream { - FILE *f; - lua_CFunction closef; -} luaL_Stream;</pre> - -<p> -The standard representation for file handles, -which is used by the standard I/O library. - - -<p> -A file handle is implemented as a full userdata, -with a metatable called <code>LUA_FILEHANDLE</code> -(where <code>LUA_FILEHANDLE</code> is a macro with the actual metatable's name). -The metatable is created by the I/O library -(see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>). - - -<p> -This userdata must start with the structure <code>luaL_Stream</code>; -it can contain other data after this initial structure. -Field <code>f</code> points to the corresponding C stream -(or it can be <code>NULL</code> to indicate an incompletely created handle). -Field <code>closef</code> points to a Lua function -that will be called to close the stream -when the handle is closed or collected; -this function receives the file handle as its sole argument and -must return either <b>true</b> (in case of success) -or <b>nil</b> plus an error message (in case of error). -Once Lua calls this field, -the field value is changed to <code>NULL</code> -to signal that the handle is closed. - - - - - -<hr><h3><a name="luaL_testudata"><code>luaL_testudata</code></a></h3><p> -<span class="apii">[-0, +0, <em>e</em>]</span> -<pre>void *luaL_testudata (lua_State *L, int arg, const char *tname);</pre> - -<p> -This function works like <a href="#luaL_checkudata"><code>luaL_checkudata</code></a>, -except that, when the test fails, -it returns <code>NULL</code> instead of raising an error. - - - - - -<hr><h3><a name="luaL_tolstring"><code>luaL_tolstring</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>const char *luaL_tolstring (lua_State *L, int idx, size_t *len);</pre> - -<p> -Converts any Lua value at the given index to a C string -in a reasonable format. -The resulting string is pushed onto the stack and also -returned by the function. -If <code>len</code> is not <code>NULL</code>, -the function also sets <code>*len</code> with the string length. - - -<p> -If the value has a metatable with a <code>"__tostring"</code> field, -then <code>luaL_tolstring</code> calls the corresponding metamethod -with the value as argument, -and uses the result of the call as its result. - - - - - -<hr><h3><a name="luaL_traceback"><code>luaL_traceback</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void luaL_traceback (lua_State *L, lua_State *L1, const char *msg, - int level);</pre> - -<p> -Creates and pushes a traceback of the stack <code>L1</code>. -If <code>msg</code> is not <code>NULL</code> it is appended -at the beginning of the traceback. -The <code>level</code> parameter tells at which level -to start the traceback. - - - - - -<hr><h3><a name="luaL_typename"><code>luaL_typename</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>const char *luaL_typename (lua_State *L, int index);</pre> - -<p> -Returns the name of the type of the value at the given index. - - - - - -<hr><h3><a name="luaL_unref"><code>luaL_unref</code></a></h3><p> -<span class="apii">[-0, +0, –]</span> -<pre>void luaL_unref (lua_State *L, int t, int ref);</pre> - -<p> -Releases reference <code>ref</code> from the table at index <code>t</code> -(see <a href="#luaL_ref"><code>luaL_ref</code></a>). -The entry is removed from the table, -so that the referred object can be collected. -The reference <code>ref</code> is also freed to be used again. - - -<p> -If <code>ref</code> is <a href="#pdf-LUA_NOREF"><code>LUA_NOREF</code></a> or <a href="#pdf-LUA_REFNIL"><code>LUA_REFNIL</code></a>, -<a href="#luaL_unref"><code>luaL_unref</code></a> does nothing. - - - - - -<hr><h3><a name="luaL_where"><code>luaL_where</code></a></h3><p> -<span class="apii">[-0, +1, <em>e</em>]</span> -<pre>void luaL_where (lua_State *L, int lvl);</pre> - -<p> -Pushes onto the stack a string identifying the current position -of the control at level <code>lvl</code> in the call stack. -Typically this string has the following format: - -<pre> - <em>chunkname</em>:<em>currentline</em>: -</pre><p> -Level 0 is the running function, -level 1 is the function that called the running function, -etc. - - -<p> -This function is used to build a prefix for error messages. - - - - - - - <h1>6 – <a name="6">Standard Libraries</a></h1> <p>