NAME

-luaL_Buffer — -

type for a string buffer

SYNOPSIS

#include
-  <lauxlib.h>

-typedef struct luaL_Buffer luaL_Buffer; -

DESCRIPTION

-luaL_Buffer() type for a - string buffer. -

-A string buffer allows C code to build Lua strings piecemeal. Its pattern of use - is as follows: -

NAME

luaL_Buffer — type + for a string buffer

SYNOPSIS

#include + <lauxlib.h>

typedef struct luaL_Buffer luaL_Buffer;

DESCRIPTION

luaL_Buffer() + type for a + string + buffer.

A string buffer allows C code to build Lua strings piecemeal. Its + pattern of use is as follows:

First you declare a variable b of type - luaL_Buffer.
Then you initialize it with a call - luaL_buffinit(L, &b).
Then you add string pieces to the buffer calling any of the - luaL_add* functions.
You finish by calling - luaL_pushresult(&b). This call leaves the - final string on the top of the stack.

luaL_Buffer

Then you initialize it with a call + luaL_buffinit(L, + &b).
Then you add string pieces to the buffer calling any of the + luaL_add* + functions.
You finish by calling + luaL_pushresult(&b). + This call leaves the final string on the top of the stack.

-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 - luaL_addvalue). After calling - luaL_pushresult(3) the stack is back to its level - when the buffer was initialized, plus the final string on its top. -

SEE +
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 + luaL_addvalue). + After calling luaL_pushresult(3) the stack is back to its + level when the buffer was initialized, plus the final string on its top.
+

HISTORY

-The luaL_Buffer() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_Reg — -

type for arrays of functions to be registered by - luaL_register

SYNOPSIS

#include
-  <lauxlib.h>

-typedef struct luaL_Reg; -

DESCRIPTION

-luaL_Reg() type for arrays of functions to be - registered by luaL_register(3). - luaL_Reg is defined as: -

-typedef struct luaL_Reg { 
-        const char *name; 
-        lua_CFunction func; 
-} luaL_Reg;
-

NAME

luaL_Reg — type + for arrays of functions to be registered by luaL_register

SYNOPSIS

#include + <lauxlib.h>

typedef struct luaL_Reg;

DESCRIPTION

luaL_Reg() + type for arrays of functions to be registered by + luaL_register(3). luaL_Reg is + defined as:

typedef struct luaL_Reg {
+        const char *name;
+        lua_CFunction func;
+} luaL_Reg;

-name is the function name and - func is a pointer to the function. Any array - of luaL_Reg must end with an sentinel entry - in which both name and - func are - NULL. -

SEE +
`name` is the function name and + `func` is a pointer to the function. Any array of + `luaL_Reg` must end with an sentinel entry in which + both `name` and `func` are + `NULL`.
+

HISTORY

-The luaL_Reg() manual page was written by - Sergey Bronnikov.

luaL_register(3)

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The luaL_Reg() manual page was written by + Sergey Bronnikov.

NAME

-luaL_addchar — -

adds the character to the buffer

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_addchar(luaL_Buffer - *B, char - c); -

DESCRIPTION

-luaL_addchar() adds the character - c to the buffer - B (see - luaL_Buffer(3)). -

SEE +
+
NAME
+
`luaL_addchar` — + adds the character to the buffer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_addchar`(`luaL_Buffer + *B`, `char c`);
+
+
+
DESCRIPTION
+
`luaL_addchar`() + adds the character `c` to the buffer + `B` (see luaL_Buffer(3)).
+
+
+
SEE ALSO
-luaL_Buffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_addchar`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_addlstring — -

adds the string to the buffer

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_addlstring(luaL_Buffer - *B, const char - *s, size_t - l); -

DESCRIPTION

-luaL_addlstring() adds the string pointed to - by s with length - l to the buffer - B (see - luaL_Buffer(3)). The string may contain embedded - zeros. -

SEE +
+
NAME
+
`luaL_addlstring` — + adds the string to the buffer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_addlstring`(`luaL_Buffer + B`, `const char s`, + `size_t l`);
+
+
+
DESCRIPTION
+
`luaL_addlstring`() + adds the string pointed to by `s` with length + `l` to the buffer `B` (see + luaL_Buffer(3)). The string may contain embedded + zeros.
+
+
+
SEE ALSO
-luaL_Buffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_addlstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_addsize — -

adds to the buffer a string

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_addsize(luaL_Buffer - *B, size_t - n); -

DESCRIPTION

-luaL_addsize() adds to the buffer - B (see - luaL_Buffer(3)) a string of length - n previously copied to the buffer area (see - luaL_prepbuffer(3)). -

SEE +
+
NAME
+
`luaL_addsize` — + adds to the buffer a string
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_addsize`(`luaL_Buffer + *B`, `size_t n`);
+
+
+
DESCRIPTION
+
`luaL_addsize`() + adds to the buffer `B` (see + luaL_Buffer(3)) a string of length `n` + previously copied to the buffer area (see + luaL_prepbuffer(3)).
+
+
+
SEE ALSO
-luaL_Buffer(3), - luaL_prepbuffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_addsize`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_addstring — -

adds the zero-terminated string to the buffer

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_addstring(luaL_Buffer - *B, const char - *s); -

DESCRIPTION

-luaL_addstring() adds the zero-terminated - string pointed to by s to the buffer - B (see - luaL_Buffer(3)). The string may not contain - embedded zeros. -

SEE +
+
NAME
+
`luaL_addstring` — + adds the zero-terminated string to the buffer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_addstring`(`luaL_Buffer + B`, `const char + s`);
+
+
+
DESCRIPTION
+
`luaL_addstring`() + adds the zero-terminated string pointed to by `s` to the + buffer `B` (see luaL_Buffer(3)). The + string may not contain embedded zeros.
+
+
+
SEE ALSO
-luaL_Buffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_addstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_addvalue — -

adds the value at the top of the stack to the - buffer

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_addvalue(luaL_Buffer - *B); -

DESCRIPTION

-luaL_addvalue() adds the value at the top of - the stack to the buffer B (see - luaL_Buffer(3)). Pops the value. -

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

SEE +
+
NAME
+
`luaL_addvalue` — + adds the value at the top of the stack to the + buffer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_addvalue`(`luaL_Buffer + *B`);
+
+
+
DESCRIPTION
+
`luaL_addvalue`() + adds the value at the top of the stack to the buffer `B` + (see luaL_Buffer(3)). Pops the value.
+
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.
+
+
+
SEE ALSO
-luaL_Buffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_addvalue`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_argcheck — -

checks whether cond is true

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_argcheck(lua_State - *L, int - cond, int - narg, const char - *extramsg); -

DESCRIPTION

-luaL_argcheck() checks whether cond is true. - If not, raises an error with the following message, where func is retrieved - from the call stack: -

-bad argument #<narg> to <func> (<extramsg>)
-

NAME

luaL_argcheck — + checks whether cond is true

SYNOPSIS

#include + <lauxlib.h>

void +
+ luaL_argcheck(lua_State + *L, int cond, + int narg, + const char + *extramsg);

DESCRIPTION

luaL_argcheck() + checks whether cond is true. If not, raises an error with the following + message, where func is retrieved from the call stack:

bad argument #<narg> to <func> (<extramsg>)

SEE +

HISTORY

-The luaL_argcheck() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The luaL_argcheck() manual page was + written by Sergey Bronnikov.

NAME

-luaL_argerror — -

raises an error with the message

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_argerror(lua_State - *L, int - narg, const char - *extramsg); -

DESCRIPTION

-luaL_argerror() raises an error with the - following message, where func is retrieved from the call stack: -

-bad argument #<narg> to <func> (<extramsg>)
-

NAME

luaL_argerror — + raises an error with the message

SYNOPSIS

#include + <lauxlib.h>

int +
+ luaL_argerror(lua_State + *L, int narg, + const char + *extramsg);

DESCRIPTION

luaL_argerror() + raises an error with the following message, where func is retrieved from the + call stack:

bad argument #<narg> to <func> (<extramsg>)

-This function never returns, but it is an idiom to use it in C functions as - return luaL_argerror(args). -

SEE +
This function never returns, but it is an + idiom to use it in C functions as return + luaL_argerror(args).
+

HISTORY

-The luaL_argerror() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The luaL_argerror() manual page was + written by Sergey Bronnikov.

NAME

-luaL_buffinit — -

initializes a buffer

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_buffinit(lua_State - *L, luaL_Buffer - *B); -

DESCRIPTION

-luaL_buffinit() initializes a buffer - B. This function does not allocate any space; - the buffer must be declared as a variable (see - luaL_Buffer(3)). -

SEE +
+
NAME
+
`luaL_buffinit` — + initializes a buffer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_buffinit`(`lua_State + L`, `luaL_Buffer + B`);
+
+
+
DESCRIPTION
+
`luaL_buffinit`() + initializes a buffer `B`. This function does not + allocate any space; the buffer must be declared as a variable (see + luaL_Buffer(3)).
+
+
+
SEE ALSO
-luaL_Buffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_buffinit`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_callmeta — -

calls a metamethod

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_callmeta(lua_State - *L, int - obj, const char - *e); -

DESCRIPTION

-luaL_callmeta() calls a metamethod. -

RETURN +
+
NAME
+
`luaL_callmeta` — + calls a metamethod
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_callmeta`(`lua_State + L`, `int obj`, + `const char e`);
+
+
+
DESCRIPTION
+
`luaL_callmeta`() + calls a metamethod.
+
+
+
RETURN VALUES
-If the object at index obj has a metatable and this metatable has a field - `e`, this function calls this field and passes - the object as its only argument. In this case this function returns 1 and - pushes onto the stack the value returned by the call. If there is no metatable - or no metamethod, this function returns 0 (without pushing any value on the - stack). -
SEE +
If the object at index obj has a metatable and this metatable has + a field `e`, this function calls this field and passes + the object as its only argument. In this case this function returns 1 and + pushes onto the stack the value returned by the call. If there is no + metatable or no metamethod, this function returns 0 (without pushing any + value on the stack).
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_callmeta`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkany — -

checks whether the function has an argument of any - type

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_checkany(lua_State - *L, int - narg); -

DESCRIPTION

-luaL_checkany() checks whether the function - has an argument of any type (including nil) at - position narg. -

SEE +
+
NAME
+
`luaL_checkany` — + checks whether the function has an argument of any + type
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_checkany`(`lua_State + L`, `int narg`);
+
+
+
DESCRIPTION
+
`luaL_checkany`() + checks whether the function has an argument of any type (including + nil*) at + position `narg`.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkany`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkint — -

checks whether the function argument is a - number

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_checkint(lua_State - *L, int - narg); -

DESCRIPTION

-luaL_checkint() checks whether the function - argument narg is a number and returns this - number cast to an int. -

SEE +
+
NAME
+
`luaL_checkint` — + checks whether the function argument is a number
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_checkint`(`lua_State + L`, `int narg`);
+
+
+
DESCRIPTION
+
`luaL_checkint`() + checks whether the function argument `narg` is a number + and returns this number cast to an + int*.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkint`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkinteger — -

checks whether the function argument is a - number

SYNOPSIS

#include
-  <lauxlib.h>

-lua_Integer -
-luaL_checkinteger(lua_State - *L, int - narg); -

DESCRIPTION

-luaL_checkinteger() checks whether the - function argument narg is a number and - returns this number cast to a lua_Integer(3). -

SEE +
+
NAME
+
`luaL_checkinteger` — + checks whether the function argument is a number
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`lua_Integer` +
+ `luaL_checkinteger`(`lua_State + *L`, `int narg`);
+
+
+
DESCRIPTION
+
`luaL_checkinteger`() + checks whether the function argument `narg` is a number + and returns this number cast to a lua_Integer(3).
+
+
+
SEE ALSO
-lua_Integer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkinteger`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checklong — -

checks whether the function argument is a - number

SYNOPSIS

#include
-  <lauxlib.h>

-long -
-luaL_checklong(lua_State - *L, int - narg); -

DESCRIPTION

-luaL_checklong() checks whether the function - argument narg is a number and returns this - number cast to a long. -

SEE +
+
NAME
+
`luaL_checklong` — + checks whether the function argument is a number
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`long` +
+ `luaL_checklong`(`lua_State + *L`, `int narg`);
+
+
+
DESCRIPTION
+
`luaL_checklong`() + checks whether the function argument `narg` is a number + and returns this number cast to a long.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checklong`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checklstring — -

checks whether the function argument is a - string

SYNOPSIS

#include
-  <lauxlib.h>

-const char * -
-luaL_checklstring(lua_State - *L, int - narg, size_t - *l); -

DESCRIPTION

-luaL_checklstring() checks whether the - function argument narg is a string and - returns this string; if l is not NULL fills - *l with the string's length. -

-This function uses lua_tolstring(3) to get its - result, so all conversions and caveats of that function apply here. -

SEE +
+
NAME
+
`luaL_checklstring` — + checks whether the function argument is a string
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`const char ` +
+ `luaL_checklstring`(`lua_State + L`, `int narg`, + `size_t l`);
+
+
+
DESCRIPTION
+
`luaL_checklstring`() + checks whether the function argument `narg` is a string + and returns this string; if l is not `NULL` fills + `l` with the string's length.
+
This function uses lua_tolstring(3) to get its + result, so all conversions and caveats of that function apply here.
+
+
+
SEE ALSO
-lua_tolstring(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checklstring`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checknumber — -

checks whether the function argument narg is a number - and returns this number

SYNOPSIS

#include
-  <lauxlib.h>

-lua_Number -
-luaL_checknumber(lua_State - *L, int - narg); -

DESCRIPTION

-luaL_checknumber() checks whether the - function argument narg is a number and - returns this number. -

SEE +
+
NAME
+
`luaL_checknumber` — + checks whether the function argument narg is a number and + returns this number
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`lua_Number` +
+ `luaL_checknumber`(`lua_State + *L`, `int narg`);
+
+
+
DESCRIPTION
+
`luaL_checknumber`() + checks whether the function argument `narg` is a number + and returns this number.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checknumber`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkoption — -

checks whether the function argument is a - string

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_checkoption(lua_State - *L, int - narg, const char - *def, const char - *const lst[]); -

DESCRIPTION

-luaL_checkoption() checks whether the - function argument narg is a string and - searches for this string in the array lst - (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. -

-If def is not - NULL, the function uses def as a default - value when there is no argument narg or if - this argument is nil. -

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

SEE +
+
NAME
+
`luaL_checkoption` — + checks whether the function argument is a string
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_checkoption`(`lua_State + L`, `int narg`, + `const char def`, + `const char *const + lst[]`);
+
+
+
DESCRIPTION
+
`luaL_checkoption`() + checks whether the function argument `narg` is a string + and searches for this string in the array `lst` (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.
+
If `def` is not `NULL`, + the function uses def as a default value when there is no argument + `narg` or if this argument is + `nil`.
+
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.)
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkoption`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkstack — -

grows the stack size to specified size of - elements

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_checkstack(lua_State - *L, int - sz, const char - *msg); -

DESCRIPTION

-luaL_checkstack() grows the stack size to - top + sz elements, raising an error if the stack - cannot grow to that size. msg is an - additional text to go into the error message. -

SEE +
+
NAME
+
`luaL_checkstack` — + grows the stack size to specified size of + elements
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_checkstack`(`lua_State + L`, `int sz`, + `const char msg`);
+
+
+
DESCRIPTION
+
`luaL_checkstack`() + grows the stack size to + top + sz + elements, raising an error if the stack cannot grow to that size. + `msg` is an additional text to go into the error + message.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkstack`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkstring — -

checks whether the function argument is a string and - returns this string

SYNOPSIS

#include
-  <lauxlib.h>

-const char * -
-luaL_checkstring(lua_State - *L, int - narg); -

DESCRIPTION

-luaL_checkstring() checks whether the - function argument narg is a string and - returns this string. -

-This function uses lua_tolstring(3) to get its - result, so all conversions and caveats of that function apply here. -

SEE +
+
NAME
+
`luaL_checkstring` — + checks whether the function argument is a string and + returns this string
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`const char ` +
+ `luaL_checkstring`(`lua_State + L`, `int narg`);
+
+
+
DESCRIPTION
+
`luaL_checkstring`() + checks whether the function argument `narg` is a string + and returns this string.
+
This function uses lua_tolstring(3) to get its + result, so all conversions and caveats of that function apply here.
+
+
+
SEE ALSO
-lua_tolstring(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkstring`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checktype — -

checks whether the function argument has a certain - type

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_checktype(lua_State - *L, int - narg, int - t); -

DESCRIPTION

-luaL_checktype() checks whether the function - argument narg has type - t. See - lua_type(3) for the encoding of types for - t. -

SEE +
+
NAME
+
`luaL_checktype` — + checks whether the function argument has a certain + type
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_checktype`(`lua_State + *L`, `int narg`, + `int t`);
+
+
+
DESCRIPTION
+
`luaL_checktype`() + checks whether the function argument `narg` has type + `t`. See lua_type(3) for the encoding + of types for `t`.
+
+
+
SEE ALSO
-lua_type(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checktype`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_checkudata — -

checks whether the function argument is a userdata of - a certain type

SYNOPSIS

#include
-  <lauxlib.h>

-void * -
-luaL_checkudata(lua_State - *L, int - narg, const char - *tname); -

DESCRIPTION

-luaL_checkudata() checks whether the function - argument narg is a userdata of the type - tname (see - luaL_newmetatable(3)). -

SEE +
+
NAME
+
`luaL_checkudata` — + checks whether the function argument is a userdata of a + certain type
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void ` +
+ `luaL_checkudata`(`lua_State + L`, `int narg`, + `const char *tname`);
+
+
+
DESCRIPTION
+
`luaL_checkudata`() + checks whether the function argument `narg` is a + userdata of the type `tname` (see + luaL_newmetatable(3)).
+
+
+
SEE ALSO
-luaL_newmetatable(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_checkudata`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_dofile — -

loads and runs the given file

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_dofile(lua_State - *L, const char - *filename); -

DESCRIPTION

-luaL_dofile() loads and runs the given file. - It is defined as the following macro: -

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

NAME

luaL_dofile — + loads and runs the given file

SYNOPSIS

#include + <lauxlib.h>

int +
+ luaL_dofile(lua_State + *L, const char + *filename);

DESCRIPTION

luaL_dofile() + loads and runs the given file. It is defined as the following macro:

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

RETURN +

RETURN VALUES

-It returns 0 if there are no errors or 1 in case of errors. -

SEE +
It returns 0 if there are no errors or 1 in case of errors.
+

HISTORY

-The luaL_dofile() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The luaL_dofile() manual page was written + by Sergey Bronnikov.

NAME

-luaL_dostring — -

loads and runs the given string

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_dostring(lua_State - *L, const char - *str); -

DESCRIPTION

-luaL_dostring() loads and runs the given - string. It is defined as the following macro: -

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

NAME

luaL_dostring — + loads and runs the given string

SYNOPSIS

#include + <lauxlib.h>

int +
+ luaL_dostring(lua_State + *L, const char + *str);

DESCRIPTION

luaL_dostring() + loads and runs the given string. It is defined as the following macro:

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

RETURN +

RETURN VALUES

-It returns 0 if there are no errors or 1 in case of errors. -

SEE +
It returns 0 if there are no errors or 1 in case of errors.
+

HISTORY

-The luaL_dostring() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The luaL_dostring() manual page was + written by Sergey Bronnikov.

NAME

-luaL_error — -

raises an error

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_error(lua_State - *L, const char - *fmt, - ...); -

DESCRIPTION

-luaL_error() raises an error. The error - message format is given by fmt plus any extra - arguments, following the same rules of - lua_pushfstring(3). 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. -

-This function never returns, but it is an idiom to use it in C functions as - return luaL_error(args). -

SEE +
+
NAME
+
`luaL_error` — + raises an error
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_error`(`lua_State + L`, `const char + fmt`, `...`);
+
+
+
DESCRIPTION
+
`luaL_error`() + raises an error. The error message format is given by + `fmt` plus any extra arguments, following the same rules + of lua_pushfstring(3). 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.
+
This function never returns, but it is an + idiom to use it in C functions as return + luaL_error(args).
+
+
+
SEE ALSO
-lua_pushfstring(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_error`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_getmetafield — -

pushes onto the stack the field from the metatable of - the object at the specified index

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_getmetafield(lua_State - *L, int - obj, const char - *e); -

DESCRIPTION

-luaL_getmetafield() pushes onto the stack the - field e from the metatable of the object at - index obj. If the object does not have a - metatable, or if the metatable does not have this field, returns 0 and pushes - nothing. -

SEE +
+
NAME
+
`luaL_getmetafield` — + pushes onto the stack the field from the metatable of the + object at the specified index
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_getmetafield`(`lua_State + L`, `int obj`, + `const char e`);
+
+
+
DESCRIPTION
+
`luaL_getmetafield`() + pushes onto the stack the field `e` from the metatable + of the object at index `obj`. If the object does not + have a metatable, or if the metatable does not have this field, returns 0 + and pushes nothing.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_getmetafield`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_getmetatable — -

pushes onto the stack the metatable associated with - name in the registry

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_getmetatable(lua_State - *L, const char - *tname); -

DESCRIPTION

-luaL_getmetatable() pushes onto the stack the - metatable associated with name tname in the - registry (see luaL_newmetatable(3)). -

SEE +
+
NAME
+
`luaL_getmetatable` — + pushes onto the stack the metatable associated with name in + the registry
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_getmetatable`(`lua_State + L`, `const char + tname`);
+
+
+
DESCRIPTION
+
`luaL_getmetatable`() + pushes onto the stack the metatable associated with name + `tname` in the registry (see + luaL_newmetatable(3)).
+
+
+
SEE ALSO
-luaL_newmetatable(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_getmetatable`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_gsub — -

creates a copy of string A by replacing any - occurrence of the string B with the string C

SYNOPSIS

#include
-  <lauxlib.h>

-const char * -
-luaL_gsub(lua_State - *L, const char - *s, const char - *p, const char - *r); -

DESCRIPTION

-luaL_gsub() creates a copy of string - s by replacing any occurrence of the string - p with the string - r. Pushes the resulting string on the stack - and returns it. -

SEE +
+
NAME
+
`luaL_gsub` — + creates a copy of string A by replacing any occurrence of + the string B with the string C
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`const char ` +
+ `luaL_gsub`(`lua_State + L`, `const char s`, + `const char p`, + `const char *r`);
+
+
+
DESCRIPTION
+
`luaL_gsub`() + creates a copy of string `s` by replacing any occurrence + of the string `p` with the string + `r`. Pushes the resulting string on the stack and + returns it.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_gsub`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_loadbuffer — -

loads a buffer as a Lua chunk

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_loadbuffer(lua_State - *L, const char - *buff, size_t - sz, const char - *name); -

DESCRIPTION

-luaL_loadbuffer() loads a buffer as a Lua - chunk. This function uses lua_load(3) to load the - chunk in the buffer pointed to by buff with - size sz. -

-This function returns the same results as - lua_load(3). - name is the chunk name, used for debug - information and error messages. -

SEE +
+
NAME
+
`luaL_loadbuffer` — + loads a buffer as a Lua chunk
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_loadbuffer`(`lua_State + L`, `const char + buff`, `size_t sz`, + `const char *name`);
+
+
+
DESCRIPTION
+
`luaL_loadbuffer`() + loads a buffer as a Lua chunk. This function uses + lua_load(3) to load the chunk in the buffer pointed to by + `buff` with size `sz`.
+
This function returns the same results as + lua_load(3). `name` is the chunk name, + used for debug information and error messages.
+
+
+
SEE ALSO
-lua_load(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_loadbuffer`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_loadfile — -

loads a file as a Lua chunk

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_loadfile(lua_State - *L, const char - *filename); -

DESCRIPTION

-luaL_loadfile() loads a file as a Lua chunk. - This function uses lua_load(3) to load the chunk - in the file named filename. If filename is - NULL, then it loads from the standard - input. The first line in the file is ignored if it starts with a - #. -

-As lua_load(3), this function only loads the chunk; - it does not run it. -

RETURN +
+
NAME
+
`luaL_loadfile` — + loads a file as a Lua chunk
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_loadfile`(`lua_State + L`, `const char + filename`);
+
+
+
DESCRIPTION
+
`luaL_loadfile`() + loads a file as a Lua chunk. This function uses + lua_load(3) to load the chunk in the file named + `filename`. If filename is `NULL`, + then it loads from the standard input. The first line in the file is ignored + if it starts with a + #.
+
As lua_load(3), this function only loads the + chunk; it does not run it.
+
+
+
RETURN VALUES
-This function returns the same results as - lua_load(3), but it has an extra error code - `LUA_ERRFILE` if it cannot open/read the - file. -
SEE +
This function returns the same results as + lua_load(3), but it has an extra error code + `LUA_ERRFILE` if it cannot open/read the file.
+
+
+
SEE ALSO
-lua_load(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_loadfile`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_loadstring — -

loads a string as a Lua chunk

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_loadstring(lua_State - *L, const char - *s); -

DESCRIPTION

-luaL_loadstring() loads a string as a Lua - chunk. This function uses lua_load(3) to load the - chunk in the zero-terminated string s. -

-This function returns the same results as - lua_load(3). -

-Also as lua_load(3), this function only loads the - chunk; it does not run it. -

SEE +
+
NAME
+
`luaL_loadstring` — + loads a string as a Lua chunk
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_loadstring`(`lua_State + L`, `const char + s`);
+
+
+
DESCRIPTION
+
`luaL_loadstring`() + loads a string as a Lua chunk. This function uses + lua_load(3) to load the chunk in the zero-terminated + string `s`.
+
This function returns the same results as + lua_load(3).
+
Also as lua_load(3), this function only loads + the chunk; it does not run it.
+
+
+
SEE ALSO
-lua_load(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_loadstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_newmetatable — -

creates a new table to be used as a metatable for - userdata

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_newmetatable(lua_State - *L, const char - *tname); -

DESCRIPTION

-luaL_newmetatable() If the registry already - has the key tname, returns 0. Otherwise, - creates a new table to be used as a metatable for userdata, adds it to the - registry with key tname, and returns 1. -

-In both cases pushes onto the stack the final value associated with - tname in the registry. -

SEE +
+
NAME
+
`luaL_newmetatable` — + creates a new table to be used as a metatable for + userdata
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_newmetatable`(`lua_State + L`, `const char + tname`);
+
+
+
DESCRIPTION
+
`luaL_newmetatable`() + If the registry already has the key `tname`, returns 0. + Otherwise, creates a new table to be used as a metatable for userdata, adds + it to the registry with key `tname`, and returns 1.
+
In both cases pushes onto the stack the final value associated + with `tname` in the registry.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_newmetatable`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_newstate — -

creates a new Lua state

SYNOPSIS

#include
-  <lauxlib.h>

-lua_State * -
-luaL_newstate(void); -

DESCRIPTION

-luaL_newstate() creates a new Lua state. It - calls lua_newstate(3) with an allocator based on - the standard C realloc(3) function and then sets - a panic function (see lua_atpanic(3)) that prints - an error message to the standard error output in case of fatal errors. -

RETURN +
+
NAME
+
`luaL_newstate` — + creates a new Lua state
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`lua_State *` +
+ `luaL_newstate`(`void`);
+
+
+
DESCRIPTION
+
`luaL_newstate`() + creates a new Lua state. It calls lua_newstate(3) with an + allocator based on the standard C realloc(3) function and + then sets a panic function (see lua_atpanic(3)) that + prints an error message to the standard error output in case of fatal + errors.
+
+
+
RETURN VALUES
-Returns the new state, or `NULL` if there is a - memory allocation error. -
SEE +
Returns the new state, or `NULL` if there is + a memory allocation error.
+
+
+
SEE ALSO
-lua_atpanic(3), - lua_newstate(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_newstate`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_openlibs — -

opens all standard Lua libraries into the given - state

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_openlibs(lua_State - *L); -

DESCRIPTION

-luaL_openlibs() opens all standard Lua - libraries into the given state. -

SEE +
+
NAME
+
`luaL_openlibs` — + opens all standard Lua libraries into the given + state
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_openlibs`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`luaL_openlibs`() + opens all standard Lua libraries into the given state.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_openlibs`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_optint — -

casts a number to an int

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_optint(lua_State - *L, int - narg, int - d); -

DESCRIPTION

-luaL_optint() if the function argument - narg is a number, returns this number cast to - an int. If this argument is absent or is - nil, returns - d. Otherwise, raises an error. -

SEE +
+
NAME
+
`luaL_optint` — + casts a number to an int
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_optint`(`lua_State + *L`, `int narg`, + `int d`);
+
+
+
DESCRIPTION
+
`luaL_optint`() + if the function argument `narg` is a number, returns + this number cast to an int. If this argument is absent or is + `nil`, returns `d`. Otherwise, + raises an error.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_optint`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_optinteger — -

casts a number to a lua_Integer

SYNOPSIS

#include
-  <lauxlib.h>

-lua_Integer -
-luaL_optinteger(lua_State - *L, int - narg, - lua_Integer d); -

DESCRIPTION

-luaL_optinteger() if the function argument - narg is a number, returns this number cast to - a lua_Integer(3). If this argument is absent or - is nil, returns - d. Otherwise, raises an error. -

SEE +
+
NAME
+
`luaL_optinteger` — + casts a number to a lua_Integer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`lua_Integer` +
+ `luaL_optinteger`(`lua_State + *L`, `int narg`, + `lua_Integer d`);
+
+
+
DESCRIPTION
+
`luaL_optinteger`() + if the function argument `narg` is a number, returns + this number cast to a lua_Integer(3). If this argument is + absent or is `nil`, returns `d`. + Otherwise, raises an error.
+
+
+
SEE ALSO
-lua_Integer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_optinteger`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_optlong — -

casts a number to a long

SYNOPSIS

#include
-  <lauxlib.h>

-long -
-luaL_optlong(lua_State - *L, int - narg, long - d); -

DESCRIPTION

-luaL_optlong() if the function argument narg - is a number, returns this number cast to a long. If this argument is absent or - is nil, returns - d. Otherwise, raises an error. -

SEE +
+
NAME
+
`luaL_optlong` — + casts a number to a long
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`long` +
+ `luaL_optlong`(`lua_State + *L`, `int narg`, + `long d`);
+
+
+
DESCRIPTION
+
`luaL_optlong`() + if the function argument narg is a number, returns this number cast to a + long. If this argument is absent or is `nil`, returns + `d`. Otherwise, raises an error.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_optlong`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_optlstring — -

if the function argument is a string, returns this - string

SYNOPSIS

#include
-  <lauxlib.h>

-const char * -
-luaL_optlstring(lua_State - *L, int - narg, const char - *d, size_t - *l); -

DESCRIPTION

-luaL_optlstring() if the function argument - narg is a string, returns this string. If - this argument is absent or is nil, returns - d. Otherwise, raises an error. -

-If l is not - NULL, fills the position - *l with the results's length. -

SEE +
+
NAME
+
`luaL_optlstring` — + if the function argument is a string, returns this + string
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`const char ` +
+ `luaL_optlstring`(`lua_State + L`, `int narg`, + `const char d`, + `size_t l`);
+
+
+
DESCRIPTION
+
`luaL_optlstring`() + if the function argument `narg` is a string, returns + this string. If this argument is absent or is `nil`, + returns `d`. Otherwise, raises an error.
+
If `l` is not `NULL`, + fills the position `*l` with the results's length.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_optlstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_optnumber — -

if the function argument is a number, returns this - number

SYNOPSIS

#include
-  <lauxlib.h>

-lua_Number -
-luaL_optnumber(lua_State - *L, int - narg, lua_Number - d); -

DESCRIPTION

-luaL_optnumber() if the function argument - narg is a number, returns this number. If - this argument is absent or is nil, returns - d. Otherwise, raises an error. -

SEE +
+
NAME
+
`luaL_optnumber` — + if the function argument is a number, returns this + number
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`lua_Number` +
+ `luaL_optnumber`(`lua_State + *L`, `int narg`, + `lua_Number d`);
+
+
+
DESCRIPTION
+
`luaL_optnumber`() + if the function argument `narg` is a number, returns + this number. If this argument is absent or is `nil`, + returns `d`. Otherwise, raises an error.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_optnumber`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_optstring — -

if the function argument is a string, returns this - string

SYNOPSIS

#include
-  <lauxlib.h>

-const char * -
-luaL_optstring(lua_State - *L, int - narg, const char - *d); -

DESCRIPTION

-luaL_optstring() if the function argument - narg is a string, returns this string. If - this argument is absent or is nil, returns - d. Otherwise, raises an error. -

SEE +
+
NAME
+
`luaL_optstring` — + if the function argument is a string, returns this + string
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`const char ` +
+ `luaL_optstring`(`lua_State + L`, `int narg`, + `const char *d`);
+
+
+
DESCRIPTION
+
`luaL_optstring`() + if the function argument `narg` is a string, returns + this string. If this argument is absent or is `nil`, + returns `d`. Otherwise, raises an error.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_optstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_prepbuffer — -

prepares a buffer luaL_Buffer

SYNOPSIS

#include
-  <lauxlib.h>

-char * -
-luaL_prepbuffer(luaL_Buffer - *B); -

DESCRIPTION

-luaL_prepbuffer() returns an address to a - space of size LUAL_BUFFERSIZE where you can - copy a string to be added to buffer B (see - luaL_Buffer(3)). After copying the string into - this space you must call luaL_addsize(3) with the - size of the string to actually add it to the buffer. -

SEE +
+
NAME
+
`luaL_prepbuffer` — + prepares a buffer luaL_Buffer
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`char ` +
+ `luaL_prepbuffer`(`luaL_Buffer + B`);
+
+
+
DESCRIPTION
+
`luaL_prepbuffer`() + returns an address to a space of size + `LUAL_BUFFERSIZE` where you can copy a string to be + added to buffer `B` (see + luaL_Buffer(3)). After copying the string into this space + you must call luaL_addsize(3) with the size of the string + to actually add it to the buffer.
+
+
+
SEE ALSO
-luaL_addsize(3), - luaL_Buffer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_prepbuffer`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_pushresult — -

finishes the use of buffer

SYNOPSIS

#include
-  <luaxlib.h>

-void -
-luaL_pushresult(luaL_Buffer - *B); -

DESCRIPTION

-luaL_pushresult() finishes the use of buffer - B leaving the final string on the top of the - stack. -

SEE +
+
NAME
+
`luaL_pushresult` — + finishes the use of buffer
+
+
+
SYNOPSIS
+
`#include + <luaxlib.h>`
+
`void` +
+ `luaL_pushresult`(`luaL_Buffer + *B`);
+
+
+
DESCRIPTION
+
`luaL_pushresult`() + finishes the use of buffer `B` leaving the final string + on the top of the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_pushresult`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_ref — -

creates and returns a reference for the object at the - top of the stack and pops the object

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_ref(lua_State - *L, int - t); -

DESCRIPTION

-luaL_ref() creates and returns a - reference, in the table at index - t, for the object at the top of the stack - (and pops the object). -

-A reference is a unique integer key. As long as you do not manually add integer - keys into table t, - luaL_ref ensures the uniqueness of the key - it returns. You can retrieve an object referred by reference r by calling - lua_rawgeti(L, t, r). Function - luaL_unref(3) frees a reference and its - associated object. -

RETURN +
+
NAME
+
`luaL_ref` — creates + and returns a reference for the object at the top of the stack and pops the + object
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_ref`(`lua_State + L`, `int t`);
+
+
+
DESCRIPTION
+
`luaL_ref`() + creates and returns a + reference, + in the table at index `t`, for the object at the top of + the stack (and pops the object).
+
A reference is a unique integer key. As long + as you do not manually add integer keys into table `t`, + `luaL_ref` ensures the uniqueness of the key it + returns. You can retrieve an object referred by reference r by calling + lua_rawgeti(L, t, + r)*. Function luaL_unref(3) frees a reference and + its associated object.
+
+
+
RETURN VALUES
-If the object at the top of the stack is `nil`, - `luaL_ref returns the constant` - `LUA_REFNIL`. The constant - `LUA_NOREF` is guaranteed to be different - from any reference returned by `luaL_ref`. -
SEE +
If the object at the top of the stack is + `nil`, `luaL_ref returns the + constant` `LUA_REFNIL`. The constant + `LUA_NOREF` is guaranteed to be different from any + reference returned by `luaL_ref`.
+
+
+
SEE ALSO
-luaL_unref(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_ref`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_register — -

opens a library

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_register(lua_State - *L, const char - *libname, const - luaL_Reg *l); -

DESCRIPTION

-luaL_register() opens a library. -

-When called with libname equal to - NULL, it simply registers all functions in - the list l (see - luaL_Reg(3)) into the table on the top of the - stack. -

-When called with a non-null libname, - luaL_register 3 creates a new table t, sets - it as the value of the global variable - libname, sets it as the value of - package.loaded[libname], and registers on it all - functions in the list l. If there is a table - in package.loaded[libname] or in variable - libname, reuses this table instead of - creating a new one. -

-In any case the function leaves the table on the top of the stack. -

SEE +
+
NAME
+
`luaL_register` — + opens a library
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_register`(`lua_State + L`, `const char + libname`, `const luaL_Reg + l`);
+
+
+
DESCRIPTION
+
`luaL_register`() + opens a library.
+
When called with `libname` equal to + `NULL`, it simply registers all functions in the list + `l` (see luaL_Reg(3)) into the table + on the top of the stack.
+
When called with a non-null `libname`, + `luaL_register 3` creates a new table t, sets it as + the value of the global variable `libname`, sets it as + the value of package.loaded[libname], and registers on it + all functions in the list `l`. If there is a table in + package.loaded[libname]* or in variable + `libname`, reuses this table instead of creating a new + one.
+
In any case the function leaves the table on the top of the + stack.
+
+
+
SEE ALSO
-luaL_Reg(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_register`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_typename — -

returns the name of the type of the value

SYNOPSIS

#include
-  <lauxlib.h>

-const char * -
-luaL_typename(lua_State - *L, int - index); -

DESCRIPTION

-luaL_typename() returns the name of the type - of the value at the given index. -

SEE +
+
NAME
+
`luaL_typename` — + returns the name of the type of the value
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`const char ` +
+ `luaL_typename`(`lua_State + L`, `int index`);
+
+
+
DESCRIPTION
+
`luaL_typename`() + returns the name of the type of the value at the given index.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_typename`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_typerror — -

generates an error with a message

SYNOPSIS

#include
-  <lauxlib.h>

-int -
-luaL_typerror(lua_State - *L, int - narg, const char - *tname); -

DESCRIPTION

-luaL_typerror() generates an error with a - message like the following: -

-location: bad argument - narg to 'func' ( - tname expected, got rt) -

-where location is produced by luaL_where(3), func - is the name of the current function, and rt is the type name of the actual - argument. -

SEE +
+
NAME
+
`luaL_typerror` — + generates an error with a message
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`int` +
+ `luaL_typerror`(`lua_State + L`, `int narg`, + `const char tname`);
+
+
+
DESCRIPTION
+
`luaL_typerror`() + generates an error with a message like the following:
+
location: + bad argument `narg to` + 'func' + ( `tname` expected, got rt)
+
where location is produced by luaL_where(3), + func is the name of the current function, and rt is the type name of the + actual argument.
+
+
+
SEE ALSO
-luaL_where(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_typerror`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_unref — -

releases reference from the table

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_unref(lua_State - *L, int t, - int ref); -

DESCRIPTION

-luaL_unref() releases reference - ref from the table at index - t (see - luaL_ref(3)). The entry is removed from the - table, so that the referred object can be collected. The reference ref is also - freed to be used again. -

-If ref is LUA_NOREF or - LUA_REFNIL, - luaL_unref does nothing. -

SEE +
+
NAME
+
`luaL_unref` — + releases reference from the table
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_unref`(`lua_State + *L`, `int t`, + `int ref`);
+
+
+
DESCRIPTION
+
`luaL_unref`() + releases reference `ref` from the table at index + `t` (see luaL_ref(3)). The entry is + removed from the table, so that the referred object can be collected. The + reference ref is also freed to be used again.
+
If ref is `LUA_NOREF` or + `LUA_REFNIL`, `luaL_unref` does + nothing.
+
+
+
SEE ALSO
-luaL_ref(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_unref`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-luaL_where — -

pushes onto the stack a string identifying the - current position of the control

SYNOPSIS

#include
-  <lauxlib.h>

-void -
-luaL_where(lua_State - *L, int - lvl); -

DESCRIPTION

-luaL_where() pushes onto the stack a string - identifying the current position of the control at level - lvl in the call stack. Typically this string - has the following format: -

-chunkname:currentline: -

-Level 0 is the running function, level 1 is the function that called the running - function, etc. -

-This function is used to build a prefix for error messages. -

SEE +
+
NAME
+
`luaL_where` — + pushes onto the stack a string identifying the current + position of the control
+
+
+
SYNOPSIS
+
`#include + <lauxlib.h>`
+
`void` +
+ `luaL_where`(`lua_State + L`, `int lvl`);
+
+
+
DESCRIPTION
+
`luaL_where`() + pushes onto the stack a string identifying the current position of the + control at level `lvl` in the call stack. Typically this + string has the following format:
+
chunkname:currentline*:
+
Level 0 is the running function, level 1 is the function that + called the running function, etc.
+
This function is used to build a prefix for error messages.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_where`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_Alloc — -

the type of the memory-allocation function used by - Lua states

SYNOPSIS

#include
-  <lua.h>

-typedef void * -
-(*lua_Alloc)(void - *ud, void - *ptr, size_t - osize, size_t - nsize); -

DESCRIPTION

-The type of the memory-allocation function used by Lua states. The allocator - function must provide a functionality similar to - realloc(3), but not exactly the same. Its - arguments are ud, an opaque pointer passed to - lua_newstate(3); - ptr, a pointer to the block being - allocated/reallocated/freed; osize, the - original size of the block; nsize, the new - size of the block. ptr is - NULL if and only if - osize is zero. When - nsize is not zero and - osize is zero, the allocator should behave - like malloc(3). When - nsize and - osize are not zero, the allocator behaves - like realloc(3). Lua assumes that the allocator - never fails when osize >= - nsize. -

-Here is a simple implementation for the allocator function. It is used in the - auxiliary library by luaL_newstate(3). -

-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); 
-}
-

NAME

lua_Alloc — the + type of the memory-allocation function used by Lua states

SYNOPSIS

#include + <lua.h>

typedef void * +
+ (*lua_Alloc)(void + *ud, void *ptr, + size_t osize, + size_t nsize);

DESCRIPTION

The type of the memory-allocation function used by Lua states. The + allocator function must provide a functionality similar to + realloc(3), but not exactly the same. Its arguments are + ud, an opaque pointer passed to + lua_newstate(3); ptr, a pointer to + the block being allocated/reallocated/freed; osize, + the original size of the block; nsize, the new size of + the block. ptr is NULL if and + only if osize is zero. When + nsize is not zero and osize is + zero, the allocator should behave like malloc(3). When + nsize and osize are not zero, + the allocator behaves like realloc(3). Lua assumes that + the allocator never fails when osize >= + nsize.

Here is a simple implementation for the allocator function. It is + used in the auxiliary library by luaL_newstate(3).

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);
+}

-This code assumes that free(NULL) has no effect and - that realloc(NULL, size) is equivalent to - malloc(size). ANSI C ensures both behaviors. -

RETURN +
This code assumes that + free(NULL) has + no effect and that + realloc(NULL, + size) is equivalent to + malloc(size). + ANSI C ensures both behaviors.
+

RETURN VALUES

-When nsize is zero, the allocator must return - NULL; if - osize is not zero, it should free the block - pointed to by ptr. When - nsize is not zero, the allocator returns - NULL if and only if it cannot fill the - request. -

SEE +
When `nsize` is zero, the allocator must + return `NULL`; if `osize` is not + zero, it should free the block pointed to by `ptr`. When + `nsize` is not zero, the allocator returns + `NULL` if and only if it cannot fill the request.
+

HISTORY

-The lua_Alloc() manual page was written by - Sergey Bronnikov.

lua_newstate(3), + luaL_newstate(3)

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_Alloc() manual page was written by + Sergey Bronnikov.

NAME

-lua_CFunction — -

type for C functions

SYNOPSIS

#include
-  <lua.h>

-typedef int * -
-lua_CFunction(lua_State - *L); -

DESCRIPTION

-lua_CFunction() type for C functions. -

-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, lua_gettop(L) - 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 lua_gettop(L). 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. -

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

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

NAME

lua_CFunction — + type for C functions

SYNOPSIS

#include + <lua.h>

typedef int * +
+ lua_CFunction(lua_State + *L);

DESCRIPTION

lua_CFunction() + type for C functions.

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, + lua_gettop(L) 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 + lua_gettop(L). 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.

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

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

SEE +

HISTORY

-The lua_CFunction() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_CFunction() manual page was + written by Sergey Bronnikov.

NAME

-lua_Debug — -

structure used to carry different pieces of - information about an active function

SYNOPSIS

#include
-  <lua.h>

-typedef struct lua_Debug; -

DESCRIPTION

-lua_Debug() a structure used to carry - different pieces of information about an active function. - lua_getstack(3) fills only the private part of - this structure, for later use. To fill the other fields of - lua_Debug with useful information, call - lua_getinfo(3). -

-lua_Debug is defined as: -

-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 nups;                   /* (u) number of upvalues */ 
-        int linedefined;            /* (S) */ 
-        int lastlinedefined;        /* (S) */ 
-        char short_src[LUA_IDSIZE]; /* (S) */ 
-        /* private part */ 
-        other fields 
-} lua_Debug;
-

NAME

lua_Debug — + structure used to carry different pieces of information + about an active function

SYNOPSIS

#include + <lua.h>

typedef struct lua_Debug;

DESCRIPTION

lua_Debug() + a structure used to carry different pieces of information about an active + function. lua_getstack(3) fills only the private part of + this structure, for later use. To fill the other fields of + lua_Debug with useful information, call + lua_getinfo(3).

lua_Debug is defined as:

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 nups;                   /* (u) number of upvalues */
+        int linedefined;            /* (S) */
+        int lastlinedefined;        /* (S) */
+        char short_src[LUA_IDSIZE]; /* (S) */
+        /* private part */
+        other fields
+} lua_Debug;

-The fields of lua_Debug have the following - meaning: -

The fields of lua_Debug have the following + meaning:

source:
source:: If the function was defined in a string, then source is that string. If the function was defined in a file, then source starts with a '@' followed by the file name.
short_src:
short_src:: a "printable" version of source, to be used in error messages.
linedefined:
linedefined:: the line number where the definition of the function starts.
lastlinedefined:
lastlinedefined:: the line number where the definition of the function ends.
what:
what:: the string "Lua" if the function is a Lua function, "C" if it is a C function, "main" if it is the main part of a chunk, and "tail" if it was a function that did a tail call. In the latter case, Lua has no other information about the function.
currentline:
currentline:: the current line where the given function is executing. When no line information is available, currentline is set to -1.
name:
name:: 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 lua_getinfo(3) function - checks how the function was called to find a suitable name. If it cannot - find a name, then name is set to - NULL.
namewhat:
namewhat:: explains the name field. The value of namewhat can be "global", "local", "method", "field", "upvalue", or "" (the empty string), according to how the function was called. (Lua uses the empty string when no other option seems to apply.)
nups:
nups:: the number of upvalues of the function.

SEE +

HISTORY

-The lua_Debug() manual page was written by - Sergey Bronnikov.

lua_getinfo(3), + lua_getstack(3)

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_Debug() manual page was written by + Sergey Bronnikov.

NAME

-lua_Hook — -

type for debugging hook functions

SYNOPSIS

#include
-  <lua.h>

-typedef void * -
-lua_Hook(lua_State - *L, lua_Debug - *ar); -

DESCRIPTION

-lua_Hook() type for debugging hook functions. -

-Whenever a hook is called, its ar argument has its field event set to the - specific event that triggered the hook. Lua identifies these events with the - following constants: LUA_HOOKCALL, - LUA_HOOKRET, - LUA_HOOKTAILRET, - LUA_HOOKLINE, and - LUA_HOOKCOUNT. Moreover, for line events, - the field currentline is also set. To get the value of any other field in ar, - the hook must call lua_getinfo(3). For return - events, event can be LUA_HOOKRET, the - normal value, or LUA_HOOKTAILRET. In the - latter case, Lua is simulating a return from a function that did a tail call; - in this case, it is useless to call - lua_getinfo(3). -

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

SEE +
+
NAME
+
`lua_Hook` — type + for debugging hook functions
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`typedef void ` +
+ `lua_Hook`(`lua_State + L`, `lua_Debug + *ar`);
+
+
+
DESCRIPTION
+
`lua_Hook`() + type for debugging hook functions.
+
Whenever a hook is called, its ar argument has its field event set + to the specific event that triggered the hook. Lua identifies these events + with the following constants: `LUA_HOOKCALL`, + `LUA_HOOKRET`, + `LUA_HOOKTAILRET`, + `LUA_HOOKLINE`, and + `LUA_HOOKCOUNT`. Moreover, for line events, the field + currentline is also set. To get the value of any other field in ar, the hook + must call lua_getinfo(3). For return events, event can be + `LUA_HOOKRET`, the normal value, or + `LUA_HOOKTAILRET`. In the latter case, Lua is + simulating a return from a function that did a tail call; in this case, it + is useless to call lua_getinfo(3).
+
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.
+
+
+
SEE ALSO
-lua_getinfo(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_Hook`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_Integer — -

type to represent integral values

SYNOPSIS

#include
-  <lua.h>

-typedef ptrdiff_t lua_Integer; -

DESCRIPTION

-lua_Integer the type used by the Lua API to - represent integral values. By default it is a - ptrdiff_t, which is usually the largest - signed integral type the machine handles “comfortably”. -

SEE +
+
NAME
+
`lua_Integer` — type + to represent integral values
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`typedef ptrdiff_t lua_Integer`;
+
+
+
DESCRIPTION
+
`lua_Integer` the type used by the Lua API to + represent integral values. By default it is a + `ptrdiff_t`, which is usually the largest signed + integral type the machine handles "comfortably".
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_Integer`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_Number — -

type of numbers in Lua

SYNOPSIS

#include
-  <lua.h>

-typedef double lua_Number; -

DESCRIPTION

-The type of numbers in Lua. By default, it is double, but that can be changed in - <luaconf.h>. -

-Through the configuration file you can change Lua to operate with another type - for numbers (e.g., float or long). -

SEE +
+
NAME
+
`lua_Number` — type + of numbers in Lua
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`typedef double lua_Number`;
+
+
+
DESCRIPTION
+
The type of numbers in Lua. By default, it is double, but that can + be changed in + `<luaconf.h>`.
+
Through the configuration file you can change Lua to operate with + another type for numbers (e.g., float or long).
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_Number` manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_Reader — -

reader function used by - lua_load(3)

SYNOPSIS

#include
-  <lua.h>

-typedef const char * -
-(*lua_Reader)(lua_State - *L, void - *data, size_t - *size); -

DESCRIPTION

-The reader function lua_Reader() used by - lua_load(3). Every time it needs another piece of - the chunk, lua_load(3) calls the reader, passing - along its data parameter. The reader must return a pointer to a block of - memory with a new piece of the chunk and set size 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 NULL or set - size to zero. The reader function may return pieces of any size greater than - zero. -

SEE +
+
NAME
+
`lua_Reader` — + reader function used by + lua_load(3)
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`typedef const char ` +
+ `(lua_Reader)`(`lua_State + L`, `void data`, + `size_t *size`);
+
+
+
DESCRIPTION
+
The reader function + `lua_Reader`() + used by lua_load(3). Every time it needs another piece of + the chunk, lua_load(3) calls the reader, passing along its + data parameter. The reader must return a pointer to a block of memory with a + new piece of the chunk and set size 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 `NULL` or set size to zero. The + reader function may return pieces of any size greater than zero.
+
+
+
SEE ALSO
-lua_load(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_Reader`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_State — -

opaque structure that keeps the whole state of a Lua - interpreter

SYNOPSIS

#include
-  <lua.h>

-typedef struct lua_State lua_State; -

DESCRIPTION

-lua_State opaque structure that keeps the whole - state of a Lua interpreter. The Lua library is fully reentrant: it has no - global variables. All information about a state is kept in this structure. A - pointer to this state must be passed as the first argument to every function - in the library, except to lua_newstate(3), which - creates a Lua state from scratch. -

SEE +
+
NAME
+
`lua_State` — opaque + structure that keeps the whole state of a Lua interpreter
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`typedef struct lua_State lua_State`;
+
+
+
DESCRIPTION
+
`lua_State` opaque structure that keeps the + whole state of a Lua interpreter. The Lua library is fully reentrant: it has + no global variables. All information about a state is kept in this + structure. A pointer to this state must be passed as the first argument to + every function in the library, except to lua_newstate(3), + which creates a Lua state from scratch.
+
+
+
SEE ALSO
-lua_newstate(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_State` manual page was written by Sergey - Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_Writer — -

type of the writer function used by - lua_dump(3)

SYNOPSIS

#include
-  <lua.h>

-typedef int * -
-lua_Writer(lua_State - *L, const void* - p, size_t - sz, void* - ud); -

DESCRIPTION

-lua_Writer type of the writer function used by - lua_dump(3). Every time it produces another piece - of chunk, lua_dump(3) calls the writer, passing - along the buffer to be written (p), its size - (sz), and the data parameter supplied to - lua_dump(3). -

RETURN +
+
NAME
+
`lua_Writer` — type + of the writer function used by lua_dump(3)
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`typedef int ` +
+ `lua_Writer`(`lua_State + L`, `const void* p`, + `size_t sz`, + `void* ud`);
+
+
+
DESCRIPTION
+
`lua_Writer` type of the writer function used + by lua_dump(3). Every time it produces another piece of + chunk, lua_dump(3) calls the writer, passing along the + buffer to be written (`p`), its size + (`sz`), and the data parameter supplied to + lua_dump(3).
+
+
+
RETURN VALUES
-The writer returns an error code: 0 means no errors; any other value means an - error and stops lua_dump(3) from calling the - writer again. -
SEE +
The writer returns an error code: 0 means no errors; any other + value means an error and stops lua_dump(3) from calling + the writer again.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_Writer` manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_atpanic — -

sets a new panic function and returns the old - one

SYNOPSIS

#include
-  <lua.h>

-lua_CFunction -
-lua_atpanic(lua_State - *L, - lua_CFunction - panicf); -

DESCRIPTION

-lua_atpanic() sets a new panic function and - returns the old one. -

-If an error happens outside any protected environment, Lua calls a panic - function and then calls exit(EXIT_FAILURE), thus - exiting the host application. Your panic function can avoid this exit by never - returning (e.g., doing a long jump). -

-The panic function can access the error message at the top of the stack. -

SEE +
+
NAME
+
`lua_atpanic` — sets + a new panic function and returns the old one
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_CFunction` +
+ `lua_atpanic`(`lua_State + L`, `lua_CFunction + panicf`);
+
+
+
DESCRIPTION
+
`lua_atpanic`() + sets a new panic function and returns the old one.
+
If an error happens outside any protected + environment, Lua calls a panic function and then calls + exit(EXIT_FAILURE)*, + thus exiting the host application. Your panic function can avoid this exit + by never returning (e.g., doing a long jump).
+
The panic function can access the error message at the top of the + stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_atpanic`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_call — -

calls a function

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_call(lua_State - *L, int - nargs, int - nresults); -

DESCRIPTION

-lua_call() calls a function. -

-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 lua_call; - nargs 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 - nresults, unless nresults is LUA_MULTRET. - 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. -

-Any error inside the called function is propagated upwards (with a longjmp). -

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

-a = f("how", t.x, 14)
-

NAME

lua_call — calls a + function

SYNOPSIS

#include + <lua.h>

void +
+ lua_call(lua_State + *L, int nargs, + int nresults);

DESCRIPTION

lua_call() + calls a function.

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 lua_call; + nargs 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 nresults, + unless nresults is LUA_MULTRET. 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.

Any error inside the called function is propagated upwards (with a + longjmp).

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

a = f("how", t.x, 14)

-Here it is in C: -

-lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */ 
-lua_pushstring(L, "how");                        /* 1st argument */ 
-lua_getfield(L, LUA_GLOBALSINDEX, "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_setfield(L, LUA_GLOBALSINDEX, "a");        /* set global 'a' */
-

Here it is in C:

lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* function to be called */
+lua_pushstring(L, "how");                        /* 1st argument */
+lua_getfield(L, LUA_GLOBALSINDEX, "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_setfield(L, LUA_GLOBALSINDEX, "a");        /* set global 'a' */

-Note that the code above is "balanced": at its end, the stack is back - to its original configuration. This is considered good programming practice. -

SEE +
Note that the code above is "balanced": at its end, the + stack is back to its original configuration. This is considered good + programming practice.
+

HISTORY

-The lua_call() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_call() manual page was written by + Sergey Bronnikov.

NAME

-lua_checkstack — -

ensures that there are at least extra free stack - slots in the stack

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_checkstack(lua_State - *L, int - extra); -

DESCRIPTION

-lua_checkstack() ensures that there are at - least extra free stack slots in the stack. It returns false if it cannot grow - the stack to that size. This function never shrinks the stack; if the stack is - already larger than the new size, it is left unchanged. -

SEE +
+
NAME
+
`lua_checkstack` — + ensures that there are at least extra free stack slots in + the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_checkstack`(`lua_State + *L`, `int extra`);
+
+
+
DESCRIPTION
+
`lua_checkstack`() + ensures that there are at least extra free stack slots in the stack. It + returns false if it cannot grow the stack to that size. This function never + shrinks the stack; if the stack is already larger than the new size, it is + left unchanged.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_checkstack`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_close — -

ensures that there are at least extra free stack - slots in the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_close(lua_State - *L); -

DESCRIPTION

-lua_close() ensures that there are at least - extra free stack slots in the stack. It returns false if it cannot grow the - stack to that size. This function never shrinks the stack; if the stack is - already larger than the new size, it is left unchanged. -

SEE +
+
NAME
+
`lua_close` — + ensures that there are at least extra free stack slots in + the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_close`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_close`() + ensures that there are at least extra free stack slots in the stack. It + returns false if it cannot grow the stack to that size. This function never + shrinks the stack; if the stack is already larger than the new size, it is + left unchanged.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_close`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_concat — -

concatenates the values at the top of the stack, pops - them, and leaves the result at the top

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_concat(lua_State - *L, int - n); -

DESCRIPTION

-lua_concat() concatenates the - n values at the top of the stack, pops them, - and leaves the result at the top. Concatenation is performed following the - usual semantics of Lua. -

RETURN +
+
NAME
+
`lua_concat` — + concatenates the values at the top of the stack, pops them, + and leaves the result at the top
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_concat`(`lua_State + *L`, `int n`);
+
+
+
DESCRIPTION
+
`lua_concat`() + concatenates the `n` values at the top of the stack, + pops them, and leaves the result at the top. Concatenation is performed + following the usual semantics of Lua.
+
+
+
RETURN VALUES
-If `n` is 1, the result is the single value on - the stack (that is, the function does nothing); if - `n` is 0, the result is the empty string. -
SEE +
If `n` is 1, the result is the single value on + the stack (that is, the function does nothing); if `n` + is 0, the result is the empty string.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_concat`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_cpcall — -

calls the C function in protected mode

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_cpcall(lua_State - *L, - lua_CFunction - func, void - *ud); -

DESCRIPTION

-lua_cpcall() calls the C function - func in protected mode. - func starts with only one element in its - stack, a light userdata containing ud. -

RETURN +
+
NAME
+
`lua_cpcall` — calls + the C function in protected mode
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_cpcall`(`lua_State + L`, `lua_CFunction + func`, `void + ud`);
+
+
+
DESCRIPTION
+
`lua_cpcall`() + calls the C function `func` in protected mode. + `func` starts with only one element in its stack, a + light userdata containing `ud`.
+
+
+
RETURN VALUES
-In case of errors, `lua_cpcall`() returns the - same error codes as lua_pcall(3), plus the error - object on the top of the stack; otherwise, it returns zero, and does not - change the stack. All values returned by `func` - are discarded. -
SEE +
In case of errors, `lua_cpcall`() returns + the same error codes as lua_pcall(3), plus the error + object on the top of the stack; otherwise, it returns zero, and does not + change the stack. All values returned by `func` are + discarded.
+
+
+
SEE ALSO
-lua_pcall(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_cpcall`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_createtable — -

creates a new empty table and pushes it onto the - stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_createtable(lua_State - *L, int - narr, int - nrec); -

DESCRIPTION

-lua_createtable() creates a new empty table - and pushes it onto the stack. The new table has space pre-allocated for - narr array elements and - nrec non-array elements. This pre-allocation - is useful when you know exactly how many elements the table will have. - Otherwise you can use the function - lua_newtable(3). -

SEE +
+
NAME
+
`lua_createtable` — + creates a new empty table and pushes it onto the + stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_createtable`(`lua_State + *L`, `int narr`, + `int nrec`);
+
+
+
DESCRIPTION
+
`lua_createtable`() + creates a new empty table and pushes it onto the stack. The new table has + space pre-allocated for `narr` array elements and + `nrec` non-array elements. This pre-allocation is useful + when you know exactly how many elements the table will have. Otherwise you + can use the function lua_newtable(3).
+
+
+
SEE ALSO
-lua_newtable(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_createtable`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_dump — -

dumps a function as a binary chunk

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_dump(lua_State - *L, lua_Writer - writer, void - *data); -

DESCRIPTION

-lua_dump() 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, - lua_dump() calls function writer (see - lua_Writer(3)) with the given data to write them. -

-This function does not pop the Lua function from the stack. -

RETURN +
+
NAME
+
`lua_dump` — dumps a + function as a binary chunk
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_dump`(`lua_State + L`, `lua_Writer + writer`, `void + data`);
+
+
+
DESCRIPTION
+
`lua_dump`() + 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, + `lua_dump`() calls function writer (see + lua_Writer(3)) with the given data to write them.
+
This function does not pop the Lua function from the stack.
+
+
+
RETURN VALUES
-The value returned is the error code returned by the last call to the writer; 0 - means no errors. -
SEE +
The value returned is the error code returned by the last call to + the writer; 0 means no errors.
+
+
+
SEE ALSO
-lua_Writer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_dump`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_equal — -

compare two values for equality

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_equal(lua_State - *L, int - index1, int - index2); -

DESCRIPTION

-lua_equal() -

RETURN +
+
NAME
+
`lua_equal` — + compare two values for equality
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_equal`(`lua_State + *L`, `int index1`, + `int index2`);
+
+
+
DESCRIPTION
+
`lua_equal`()
+
+
+
RETURN VALUES
-Returns 1 if the two values in acceptable indices - `index1` and - `index2` are equal, following the semantics of - the Lua == operator (that is, may call - metamethods). Otherwise returns 0. Also returns 0 if any of the indices is non - valid. -
SEE +
Returns 1 if the two values in acceptable indices + `index1` and `index2` are equal, + following the semantics of the Lua + == operator + (that is, may call metamethods). Otherwise returns 0. Also returns 0 if any + of the indices is non valid.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_equal`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_error — -

generates a Lua error

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_error(lua_State - *L); -

DESCRIPTION

-lua_error() generates a Lua error. The error - message (which can actually be a Lua value of any type) must be on the stack - top. -

RETURN +
+
NAME
+
`lua_error` — + generates a Lua error
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_error`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_error`() + generates a Lua error. The error message (which can actually be a Lua value + of any type) must be on the stack top.
+
+
+
RETURN VALUES
-This function does a long jump, and therefore never returns. -
SEE +
This function does a long jump, and therefore never returns.
+
+
+
SEE ALSO
-luaL_error(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `luaL_error`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_gc — -

controls the garbage collector

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_gc(lua_State - *L, int - what, int - data); -

DESCRIPTION

-lua_gc() controls the garbage collector. -

-This function performs several tasks, according to the value of the parameter - what: -

NAME

lua_gc — controls + the garbage collector

SYNOPSIS

#include + <lua.h>

int +
+ lua_gc(lua_State + *L, int what, + int data);

DESCRIPTION

lua_gc() + controls the garbage collector.

This function performs several tasks, according to the value of + the parameter what:

LUA_GCSTOP:
LUA_GCSTOP:: stops the garbage collector.
LUA_GCRESTART:
LUA_GCRESTART:: restarts the garbage collector.
LUA_GCCOLLECT:
LUA_GCCOLLECT:: performs a full garbage-collection cycle.
LUA_GCCOUNT:
LUA_GCCOUNT:: returns the current amount of memory (in Kbytes) in use by Lua.
LUA_GCCOUNTB:
LUA_GCCOUNTB:: returns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.
LUA_GCSTEP:
LUA_GCSTEP:: performs an incremental step of garbage collection. The step "size" is controlled by data (larger values mean more steps) in a non-specified way. If you want to control the step size you must experimentally tune the value of data. The function returns 1 if the step finished a garbage-collection cycle.
LUA_GCSETPAUSE:
LUA_GCSETPAUSE:: sets data as the new value for the pause of the collector. The function returns the previous value of the pause.
LUA_GCSETSTEPMUL:
LUA_GCSETSTEPMUL:: sets data as the new value for the step multiplier of the collector. The function returns the previous value of the step multiplier.

SEE +

HISTORY

-The lua_gc() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getallocf — -

returns the memory-allocation function of a given - state

SYNOPSIS

#include
-  <lua.h>

-lua_Alloc -
-lua_getallocf(lua_State - *L, void - **ud); -

DESCRIPTION

-lua_getallocf() returns the memory-allocation - function of a given state. -

RETURN +
+
NAME
+
`lua_getallocf` — + returns the memory-allocation function of a given + state
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_Alloc` +
+ `lua_getallocf`(`lua_State + *L`, `void **ud`);
+
+
+
DESCRIPTION
+
`lua_getallocf`() + returns the memory-allocation function of a given state.
+
+
+
RETURN VALUES
-If `ud` is not - `NULL`, Lua stores in - `ud` the opaque pointer passed to - lua_newstate(3). -
SEE +
If `ud` is not `NULL`, + Lua stores in `ud` the opaque pointer passed to + lua_newstate(3).
+
+
+
SEE ALSO
-lua_newstate(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getallocf`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getfenv — -

pushes onto the stack the environment table of the - value at the given index

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_getfenv(lua_State - *L, int - index); -

DESCRIPTION

-lua_getfenv() pushes onto the stack the - environment table of the value at the given index. -

SEE +
+
NAME
+
`lua_getfenv` — + pushes onto the stack the environment table of the value at + the given index
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_getfenv`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_getfenv`() + pushes onto the stack the environment table of the value at the given + index.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getfenv`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getfield — -

pushes onto the stack the value t[k], where t is the - value at the given valid index

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_getfield(lua_State - *L, int - index, const - char *k); -

DESCRIPTION

-lua_getfield() pushes onto the stack the - value t[k], where t is the value at the given valid index. As in Lua, this - function may trigger a metamethod for the “index” event. -

SEE +
+
NAME
+
`lua_getfield` — + pushes onto the stack the value t[k], where t is the value + at the given valid index
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_getfield`(`lua_State + L`, `int index`, + `const char k`);
+
+
+
DESCRIPTION
+
`lua_getfield`() + pushes onto the stack the value t[k], where t is the value at the given + valid index. As in Lua, this function may trigger a metamethod for the + "index" event.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getfield`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getglobal — -

pushes onto the stack the value of the global - name

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_getglobal(lua_State - *L, const char - *name); -

DESCRIPTION

-lua_getglobal() pushes onto the stack the - value of the global name. It is defined as a macro: -

#define lua_getglobal(L,s) lua_getfield(L,
-  LUA_GLOBALSINDEX, s)

SEE +
+
NAME
+
`lua_getglobal` — + pushes onto the stack the value of the global + name
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_getglobal`(`lua_State + L`, `const char + name`);
+
+
+
DESCRIPTION
+
`lua_getglobal`() + pushes onto the stack the value of the global name. It is defined as a + macro:
+
`#define lua_getglobal(L,s) lua_getfield(L, + LUA_GLOBALSINDEX, s)`
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getglobal`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_gethook — -

returns the current hook function

SYNOPSIS

#include
-  <lua.h>

-lua_Hook -
-lua_gethook(lua_State - *L); -

DESCRIPTION

-lua_gethook() returns the current hook - function. -

RETURN +
+
NAME
+
`lua_gethook` — + returns the current hook function
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_Hook` +
+ `lua_gethook`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_gethook`() + returns the current hook function.
+
+
+
RETURN VALUES
-Returns the current hook function. -
SEE +
Returns the current hook function.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_gethook`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_gethookcount — -

returns the current hook count

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_gethookcount(lua_State - *L); -

DESCRIPTION

-lua_gethookmask() returns the current hook - count. -

RETURN +
+
NAME
+
`lua_gethookcount` — + returns the current hook count
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_gethookcount`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_gethookcount`() + returns the current hook count.
+
+
+
RETURN VALUES
-Returns the current hook count. -
SEE +
Returns the current hook count.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_gethookcount`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_gethookmask — -

returns the current hook mask

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_gethookmask(lua_State - *L); -

DESCRIPTION

-lua_gethookmask() returns the current hook - mask. -

RETURN +
+
NAME
+
`lua_gethookmask` — + returns the current hook mask
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_gethookmask`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_gethookmask`() + returns the current hook mask.
+
+
+
RETURN VALUES
-Returns the current hook mask. -
SEE +
Returns the current hook mask.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_gethookmask`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getinfo — -

returns information about a specific function or - function invocation

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_getinfo(lua_State - *L, const char - *what, lua_Debug - *ar); -

DESCRIPTION

-lua_getinfo() returns information about a - specific function or function invocation. -

-To get information about a function invocation, the parameter ar must be a valid - activation record that was filled by a previous call to lua_getstack or given - as argument to a hook (see lua_Hook(3)). -

-To get information about a function you push it onto the stack and start the - what string with the character '>'. (In that case, - lua_getinfo pops the function in the top of - the stack.) For instance, to know in which line a function - f was defined, you can write the following - code: -

-lua_Debug ar; 
-lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* get global 'f' */ 
-lua_getinfo(L, ">S", &ar); 
-printf("%d0, ar.linedefined);
-

NAME

lua_getinfo — + returns information about a specific function or function + invocation

SYNOPSIS

#include + <lua.h>

int +
+ lua_getinfo(lua_State + *L, const char + *what, lua_Debug + *ar);

DESCRIPTION

lua_getinfo() + returns information about a specific function or function invocation.

To get information about a function invocation, the parameter ar + must be a valid activation record that was filled by a previous call to + lua_getstack or given as argument to a hook (see + lua_Hook(3)).

To get information about a function you push it onto the stack and + start the what string with the character '>'. (In that case, + lua_getinfo pops the function in the top of the + stack.) For instance, to know in which line a function + f was defined, you can write the following code:

lua_Debug ar;
+lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* get global 'f' */
+lua_getinfo(L, ">S", &ar);
+printf("%d0, ar.linedefined);

-Each character in the string what selects some fields of the structure ar to be - filled or a value to be pushed on the stack: -

Each character in the string what selects some fields of the + structure ar to be filled or a value to be pushed on the stack:

'n'
'n': fills in the field name and namewhat;
'S'
'S': fills in the fields source, short_src, linedefined, lastlinedefined, and what;
'l'
'l': fills in the field currentline;
'u'
'u': fills in the field nups;
'f'
'f': pushes onto the stack the function that is running at the given level;
'L'
'L': pushes onto the stack a table whose indices are the numbers of the lines that are valid on the function. (A valid line 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.) This function returns 0 on error (for instance, an invalid option in what).

SEE +

HISTORY

-The lua_getinfo() manual page was written by - Sergey Bronnikov.

lua_Hook(3)

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_getinfo() manual page was written + by Sergey Bronnikov.

NAME

-lua_getlocal — -

gets information about a local variable of a given - activation record

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_getlocal(lua_State - *L, lua_Debug - *ar, int - n); -

DESCRIPTION

-lua_getlocal() gets information about a local - variable of a given activation record. The parameter - ar must be a valid activation record that was - filled by a previous call to lua_getstack() - or given as argument to a hook (see lua_Hook(3) - ). The index n selects which local variable - to inspect (1 is the first parameter or active local variable, and so on, - until the last active local variable). - lua_getlocal() pushes the variable's value - onto the stack and returns its name. -

-Variable names starting with '(' (open parentheses) represent internal variables - (loop control variables, temporaries, and C function locals). -

RETURN +
+
NAME
+
`lua_getlocal` — + gets information about a local variable of a given + activation record
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_getlocal`(`lua_State + L`, `lua_Debug *ar`, + `int n`);
+
+
+
DESCRIPTION
+
`lua_getlocal`() + gets information about a local variable of a given activation record. The + parameter `ar` must be a valid activation record that + was filled by a previous call to + `lua_getstack`() + or given as argument to a hook (see lua_Hook(3) ). The + index `n` selects which local variable to inspect (1 is + the first parameter or active local variable, and so on, until the last + active local variable). `lua_getlocal`() pushes the + variable's value onto the stack and returns its name.
+
Variable names starting with '(' (open parentheses) represent + internal variables (loop control variables, temporaries, and C function + locals).
+
+
+
RETURN VALUES
-Returns `NULL` (and pushes nothing) when the - index is greater than the number of active local variables. -
SEE +
Returns `NULL` (and pushes nothing) when the + index is greater than the number of active local variables.
+
+
+
SEE ALSO
-lua_Hook(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getlocal`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getmetatable — -

pushes onto the stack the metatable of the value at - the given acceptable index

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_getmetatable(lua_State - *L, int - index); -

DESCRIPTION

-lua_getmetatable() pushes onto the stack the - metatable of the value at the given acceptable index. -

RETURN +
+
NAME
+
`lua_getmetatable` — + pushes onto the stack the metatable of the value at the + given acceptable index
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_getmetatable`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_getmetatable`() + pushes onto the stack the metatable of the value at the given acceptable + index.
+
+
+
RETURN VALUES
-If the `index` is not valid, or if the value does - not have a metatable, the function returns 0 and pushes nothing on the stack. -
SEE +
If the `index` is not valid, or if the value + does not have a metatable, the function returns 0 and pushes nothing on the + stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getmetatable`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getstack — -

get information about the interpreter runtime - stack

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_getstack(lua_State - *L, int - level, lua_Debug - *ar); -

DESCRIPTION

-lua_getstack() get information about the - interpreter runtime stack. -

-This function fills parts of a lua_Debug(3) - structure with an identification of the activation record of the function - executing at a given level. Level 0 is the current running function, whereas - level n+1 is the function that has called level - n. -

RETURN +
+
NAME
+
`lua_getstack` — get + information about the interpreter runtime stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_getstack`(`lua_State + L`, `int level`, + `lua_Debug ar`);
+
+
+
DESCRIPTION
+
`lua_getstack`() + get information about the interpreter runtime stack.
+
This function fills parts of a lua_Debug(3) + structure with an identification of the activation record of the function + executing at a given level. Level 0 is the current running function, whereas + level n+1 is the function that has called level `n`.
+
+
+
RETURN VALUES
-When there are no errors, `lua_getstack`() - returns 1; when called with a level greater than the stack depth, it returns - 0. -
SEE +
When there are no errors, `lua_getstack`() + returns 1; when called with a level greater than the stack depth, it returns + 0.
+
+
+
SEE ALSO
-lua_Debug(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getstack`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_gettable — -

pushes onto the stack the value t[k], where t is the - value at the given valid index and k is the value at the top of the - stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_gettable(lua_State - *L, int - index); -

DESCRIPTION

-lua_gettable() pushes onto the stack the - value t[k], where t is the value at the given valid index and k is the value - at the top of the stack. -

-This function pops the key from the stack (putting the resulting value in its - place). As in Lua, this function may trigger a metamethod for the - “index” event. -

SEE +
+
NAME
+
`lua_gettable` — + pushes onto the stack the value t[k], where t is the value + at the given valid index and k is the value at the top of the + stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_gettable`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_gettable`() + pushes onto the stack the value t[k], where t is the value at the given + valid index and k is the value at the top of the stack.
+
This function pops the key from the stack (putting the resulting + value in its place). As in Lua, this function may trigger a metamethod for + the "index" event.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_gettable`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_gettop — -

returns the index of the top element in the - stack

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_gettop(lua_State - *L); -

DESCRIPTION

-lua_gettop() 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 (and so 0 means an empty stack). -

RETURN +
+
NAME
+
`lua_gettop` — + returns the index of the top element in the + stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_gettop`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_gettop`() + 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 (and so 0 + means an empty stack).
+
+
+
RETURN VALUES
-Returns the index of the top element in the stack. -
SEE +
Returns the index of the top element in the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_gettop`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_getupvalue — -

gets information about a closure's upvalue

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_getupvalue(lua_State - *L, int - funcindex, int - n); -

DESCRIPTION

-lua_getupvalue() 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.) lua_getupvalue() gets the index - n of an upvalue, pushes the upvalue's value - onto the stack, and returns its name. - funcindex 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.) -

RETURN +
+
NAME
+
`lua_getupvalue` — + gets information about a closure's upvalue
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_getupvalue`(`lua_State + L`, `int funcindex`, + `int n`);
+
+
+
DESCRIPTION
+
`lua_getupvalue`() + 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.) + `lua_getupvalue`() gets the index + `n` of an upvalue, pushes the upvalue's value onto the + stack, and returns its name. `funcindex` 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.)
+
+
+
RETURN VALUES
-Returns `NULL` (and pushes nothing) when the - index is greater than the number of upvalues. For C functions, this function - uses the empty string "" as a name for all upvalues. -
SEE +
Returns `NULL` (and pushes nothing) when the + index is greater than the number of upvalues. For C functions, this function + uses the empty string "" as a name for all upvalues.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_getupvalue`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_insert — -

moves the top element into the given valid index, - shifting up the elements above this index to open space

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_insert(lua_State - *L, int - index); -

DESCRIPTION

-lua_insert() moves the top element into the - given valid index, shifting up the elements above this index to open space. - Cannot be called with a pseudo-index, because a pseudo-index is not an actual - stack position. -

SEE +
+
NAME
+
`lua_insert` — moves + the top element into the given valid index, shifting up the elements above + this index to open space
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_insert`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_insert`() + moves the top element into the given valid index, shifting up the elements + above this index to open space. Cannot be called with a pseudo-index, + because a pseudo-index is not an actual stack position.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_insert`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isboolean — -

check whether a value is a boolean

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isboolean(lua_State - *L, int - index); -

DESCRIPTION

-lua_isboolean() returns 1 if the value at the - given acceptable index has type boolean, and 0 otherwise. -

RETURN +
+
NAME
+
`lua_isboolean` — + check whether a value is a boolean
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isboolean`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isboolean`() + returns 1 if the value at the given acceptable index has type boolean, and 0 + otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index has type boolean, and 0 - otherwise. -
SEE +
Returns 1 if the value at the given acceptable index has type + boolean, and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isboolean`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_iscfunction — -

check whether a value is a C function

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_iscfunction(lua_State - *L, int - index); -

DESCRIPTION

-lua_iscfunction() returns 1 if the value at - the given acceptable index is a C function, and 0 otherwise. -

RETURN +
+
NAME
+
`lua_iscfunction` — + check whether a value is a C function
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_iscfunction`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_iscfunction`() + returns 1 if the value at the given acceptable index is a C function, and 0 + otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a C function, and 0 - otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a C + function, and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_iscfunction`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isfunction — -

check whether a value is a function

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isfunction(lua_State - *L, int - index); -

DESCRIPTION

-lua_isfunction() returns 1 if the value at - the given acceptable index is a function (either C or Lua), and 0 otherwise. -

RETURN +
+
NAME
+
`lua_isfunction` — + check whether a value is a function
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isfunction`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isfunction`() + returns 1 if the value at the given acceptable index is a function (either C + or Lua), and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a function (either C or - Lua), and 0 otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a function + (either C or Lua), and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isfunction`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_islightuserdata — -

check whether a value is a light userdata

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_islightuserdata(lua_State - *L, int - index); -

DESCRIPTION

-lua_islightuserdata() returns 1 if the value - at the given acceptable index is a light userdata, and 0 otherwise. -

RETURN +
+
NAME
+
`lua_islightuserdata` — + check whether a value is a light userdata
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_islightuserdata`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_islightuserdata`() + returns 1 if the value at the given acceptable index is a light userdata, + and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a light userdata, and 0 - otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a light + userdata, and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_islightuserdata`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isnil — -

check whether a value is a nil

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isnil(lua_State - *L, int - index); -

DESCRIPTION

-lua_isnil() returns 1 if the value at the - given acceptable index is nil, and 0 otherwise. -

RETURN +
+
NAME
+
`lua_isnil` — check + whether a value is a nil
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isnil`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isnil`() + returns 1 if the value at the given acceptable index is nil, and 0 + otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is nil, and 0 otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is nil, and 0 + otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isnil`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isnone — -

check whether a value is not valid

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isnone(lua_State - *L, int - index); -

DESCRIPTION

-lua_isnone() returns 1 if the given - acceptable index is not valid, and 0 otherwise. -

RETURN +
+
NAME
+
`lua_isnone` — check + whether a value is not valid
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isnone`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isnone`() + returns 1 if the given acceptable index is not valid, and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the given acceptable index is not valid (that is, it refers to an - element outside the current stack), and 0 otherwise. -
SEE +
Returns 1 if the given acceptable index is not valid (that is, it + refers to an element outside the current stack), and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isnone`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isnoneornil — -

check whether a value is not valid or if the value is - nil

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isnoneornil(lua_State - *L, int - index); -

DESCRIPTION

-lua_isnoneornil() returns 1 if the given - acceptable index is not valid or if the value at this index is nil, and 0 - otherwise. -

RETURN +
+
NAME
+
`lua_isnoneornil` — + check whether a value is not valid or if the value is + nil
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isnoneornil`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isnoneornil`() + returns 1 if the given acceptable index is not valid or if the value at this + index is nil, and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the given acceptable index is not valid (that is, it refers to an - element outside the current stack) or if the value at this index is nil, and 0 - otherwise. -
SEE +
Returns 1 if the given acceptable index is not valid (that is, it + refers to an element outside the current stack) or if the value at this + index is nil, and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isnoneornil`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isnumber — -

check whether a value is a number

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isnumber(lua_State - *L, int - index); -

DESCRIPTION

-lua_isnumber() returns 1 if the value at the - given acceptable index is a number or a string convertible to a number, and 0 - otherwise. -

RETURN +
+
NAME
+
`lua_isnumber` — + check whether a value is a number
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isnumber`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isnumber`() + returns 1 if the value at the given acceptable index is a number or a string + convertible to a number, and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a number or a string - convertible to a number, and 0 otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a number + or a string convertible to a number, and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isnumber`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isstring — -

check whether a value is a string or a number

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isstring(lua_State - *L, int - index); -

DESCRIPTION

-lua_isstring() returns 1 if the value at the - given acceptable index is a string or a number (which is always convertible to - a string), and 0 otherwise. -

RETURN +
+
NAME
+
`lua_isstring` — + check whether a value is a string or a number
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isstring`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isstring`() + returns 1 if the value at the given acceptable index is a string or a number + (which is always convertible to a string), and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a string or a number - (which is always convertible to a string), and 0 otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a string + or a number (which is always convertible to a string), and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isstring`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_istable — -

check whether a value is a table

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_istable(lua_State - *L, int - index); -

DESCRIPTION

-lua_istable() -

RETURN +
+
NAME
+
`lua_istable` — + check whether a value is a table
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_istable`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_istable`()
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a table, and 0 - otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a table, + and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_istable`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isthread — -

check whether a value is a thread

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isthread(lua_State - *L, int - index); -

DESCRIPTION

-lua_isthread() returns 1 if the value at the - given acceptable index is a thread, and 0 otherwise. -

RETURN +
+
NAME
+
`lua_isthread` — + check whether a value is a thread
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isthread`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isthread`() + returns 1 if the value at the given acceptable index is a thread, and 0 + otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a thread, and 0 - otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a thread, + and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isthread`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_isuserdata — -

check whether a value is a userdata

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_isuserdata(lua_State - *L, int - index); -

DESCRIPTION

-lua_isuserdata() returns 1 if the value at - the given acceptable index is a userdata (either full or light), and 0 - otherwise. -

RETURN +
+
NAME
+
`lua_isuserdata` — + check whether a value is a userdata
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_isuserdata`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_isuserdata`() + returns 1 if the value at the given acceptable index is a userdata (either + full or light), and 0 otherwise.
+
+
+
RETURN VALUES
-Returns 1 if the value at the given acceptable index is a userdata (either full - or light), and 0 otherwise. -
SEE +
Returns 1 if the value at the given acceptable index is a userdata + (either full or light), and 0 otherwise.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_isuserdata`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_lessthan — -

compares two values

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_lessthan(lua_State - *L, int - index1, int - index2); -

DESCRIPTION

-lua_lessthan() -

RETURN +
+
NAME
+
`lua_lessthan` — + compares two values
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_lessthan`(`lua_State + *L`, `int index1`, + `int index2`);
+
+
+
DESCRIPTION
+
`lua_lessthan`()
+
+
+
RETURN VALUES
-Returns 1 if the value at acceptable index - `index1` is smaller than the value at - acceptable index `index2` , following the - semantics of the Lua < operator (that is, may call metamethods). Otherwise - returns 0. Also returns 0 if any of the indices is non valid. -
SEE +
Returns 1 if the value at acceptable index + `index1` is smaller than the value at acceptable index + `index2` , following the semantics of the Lua < + operator (that is, may call metamethods). Otherwise returns 0. Also returns + 0 if any of the indices is non valid.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_lessthan`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_load — -

loads a Lua chunk

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_load(lua_State - *L, lua_Reader - reader, void - *data, const - char *chunkname); -

DESCRIPTION

-lua_load() loads a Lua chunk. If there are no - errors, lua_load() pushes the compiled - chunk as a Lua function on top of the stack. Otherwise, it pushes an error - message. -

-This function only loads a chunk; it does not run it. -

-lua_load() automatically detects whether the - chunk is text or binary, and loads it accordingly, see - luac(1). -

-The lua_load() function uses a user-supplied - reader function to read the chunk, see - lua_Reader(3). The data argument is an opaque - value passed to the reader function. -

-The chunkname argument gives a name to the chunk, which is used for error - messages and in debug information. -

RETURN +
+
NAME
+
`lua_load` — loads a + Lua chunk
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_load`(`lua_State + L`, `lua_Reader + reader`, `void data`, + `const char + *chunkname`);
+
+
+
DESCRIPTION
+
`lua_load`() + loads a Lua chunk. If there are no errors, + `lua_load`() pushes the compiled chunk as a Lua + function on top of the stack. Otherwise, it pushes an error message.
+
This function only loads a chunk; it does not run it.
+
`lua_load`() + automatically detects whether the chunk is text or binary, and loads it + accordingly, see luac(1).
+
The + `lua_load`() + function uses a user-supplied reader function to read the chunk, see + lua_Reader(3). The data argument is an opaque value passed + to the reader function.
+
The chunkname argument gives a name to the chunk, which is used + for error messages and in debug information.
+
+
+
RETURN VALUES
-The return values of `lua_load`() are: -
+
The return values of `lua_load`() are:
+

-
`0`:
+
`0`:

no errors;
-
`LUA_ERRSYNTAX`:
+
`LUA_ERRSYNTAX`:

syntax error during pre-compilation;
-
`LUA_ERRMEM`:
+
`LUA_ERRMEM`:

memory allocation error.

-
SEE +
+
+
SEE ALSO
-luac(1), lua_Reader(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_load`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_newstate — -

creates a new, independent state

SYNOPSIS

#include
-  <lua.h>

-lua_State * -
-lua_newstate(lua_Alloc - f, void - *ud); -

DESCRIPTION

-lua_newstate() creates a new, independent - state. The argument f is the allocator - function; Lua does all memory allocation for this state through this function. - The second argument, ud, is an opaque pointer - that Lua simply passes to the allocator in every call. -

RETURN +
+
NAME
+
`lua_newstate` — + creates a new, independent state
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_State ` +
+ `lua_newstate`(`lua_Alloc + f`, `void ud`);
+
+
+
DESCRIPTION
+
`lua_newstate`() + creates a new, independent state. The argument `f` is + the allocator function; Lua does all memory allocation for this state + through this function. The second argument, `ud`, is an + opaque pointer that Lua simply passes to the allocator in every call.
+
+
+
RETURN VALUES
-Returns `NULL` if cannot create the state (due - to lack of memory). -
SEE +
Returns `NULL` if cannot create the state + (due to lack of memory).
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_newstate`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_newtable — -

creates a new empty table and pushes it onto the - stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_newtable(lua_State - *L); -

DESCRIPTION

-lua_newtable() creates a new empty table and - pushes it onto the stack. It is equivalent to - lua_createtable(L, 0, 0). -

SEE +
+
NAME
+
`lua_newtable` — + creates a new empty table and pushes it onto the + stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_newtable`(`lua_State + L`);
+
+
+
DESCRIPTION
+
`lua_newtable`() + creates a new empty table and pushes it onto the stack. It is equivalent to + lua_createtable(L, + 0, 0)*.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_newtable`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_newthread — -

creates a new thread

SYNOPSIS

#include
-  <lua.h>

-lua_State * -
-lua_newthread(lua_State - *L); -

DESCRIPTION

-lua_newthread() creates a new thread, pushes - it on the stack, and returns a pointer to a - lua_State(3) that represents this new thread. The - new state returned by this function shares with the original state all global - objects (such as tables), but has an independent execution stack. -

-There is no explicit function to close or to destroy a thread. Threads are - subject to garbage collection, like any Lua object. -

RETURN +
+
NAME
+
`lua_newthread` — + creates a new thread
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_State ` +
+ `lua_newthread`(`lua_State + L`);
+
+
+
DESCRIPTION
+
`lua_newthread`() + creates a new thread, pushes it on the stack, and returns a pointer to a + lua_State(3) that represents this new thread. The new + state returned by this function shares with the original state all global + objects (such as tables), but has an independent execution stack.
+
There is no explicit function to close or to destroy a thread. + Threads are subject to garbage collection, like any Lua object.
+
+
+
RETURN VALUES
-`lua_newthread`() returns a pointer to a - lua_State(3) that represents this new thread. -
SEE +
`lua_newthread`() returns a pointer to a + lua_State(3) that represents this new thread.
+
+
+
SEE ALSO
-lua_State(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_newthread`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_newuserdata — -

allocates a new block of memory with the given - size

SYNOPSIS

#include
-  <lua.h>

-void * -
-lua_newuserdata(lua_State - *L, size_t - size); -

DESCRIPTION

-lua_newuserdata() 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. -

-Userdata represent C values in Lua. A full userdata - represents a block of memory. It is an object (like a table): you must create - it, it can have its own metatable, and you can detect when it is being - collected. A full userdata is only equal to itself (under raw equality). -

-When Lua collects a full userdata with a gc metamethod, Lua calls the metamethod - and marks the userdata as finalized. When this userdata is collected again - then Lua frees its corresponding memory. -

SEE +
+
NAME
+
`lua_newuserdata` — + allocates a new block of memory with the given + size
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void ` +
+ `lua_newuserdata`(`lua_State + L`, `size_t + size`);
+
+
+
DESCRIPTION
+
`lua_newuserdata`() + 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.
+
Userdata represent C values in Lua. A + full userdata + represents a block of memory. It is an object (like a table): you must + create it, it can have its own metatable, and you can detect when it is + being collected. A full userdata is only equal to itself (under raw + equality).
+
When Lua collects a full userdata with a gc metamethod, Lua calls + the metamethod and marks the userdata as finalized. When this userdata is + collected again then Lua frees its corresponding memory.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_newuserdata`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_next — -

pops a key from the stack, and pushes a key-value - pair from the table

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_next(lua_State - *L, int - index); -

DESCRIPTION

-lua_next() 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 lua_next returns 0 (and - pushes nothing). -

-A typical traversal looks like this: -

-/* 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 - %s0, 
-         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); 
-}
-

NAME

lua_next — pops a + key from the stack, and pushes a key-value pair from the table

SYNOPSIS

#include + <lua.h>

int +
+ lua_next(lua_State + *L, int index);

DESCRIPTION

lua_next() + 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 lua_next returns 0 + (and pushes nothing).

A typical traversal looks like this:

/* 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 - %s0,
+         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);
+}

-While traversing a table, do not call - lua_tolstring(3) directly on a key, unless you - know that the key is actually a string. Recall that - lua_tolstring(3) changes the value at the given - index; this confuses the next call to - lua_next. -

SEE +
While traversing a table, do not call + lua_tolstring(3) directly on a key, unless you know that + the key is actually a string. Recall that lua_tolstring(3) + changes the value at the given index; this confuses the next call to + `lua_next`.
+

HISTORY

-The lua_next() manual page was written by - Sergey Bronnikov.

lua_tolstring(3)

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_next() manual page was written by + Sergey Bronnikov.

NAME

-lua_objlen — -

returns the length of the value

SYNOPSIS

#include
-  <lua.h>

-size_t -
-lua_objlen(lua_State - *L, int - index); -

DESCRIPTION

-lua_objlen() returns the - “length” of the value at the given acceptable index: for - strings, this is the string length; for tables, this is the result of the - length operator ('#'); for userdata, this is the size of the block of memory - allocated for the userdata; for other values, it is 0. -

SEE +
+
NAME
+
`lua_objlen` — + returns the length of the value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`size_t` +
+ `lua_objlen`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_objlen`() + returns the "length" of the value at the given acceptable index: + for strings, this is the string length; for tables, this is the result of + the length operator ('#'); for userdata, this is the size of the block of + memory allocated for the userdata; for other values, it is 0.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_objlen`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pcall — -

calls a function in protected mode

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_pcall(lua_State - *L, int - nargs, int - nresults, int - errfunc); -

DESCRIPTION

-lua_pcall() calls a function in protected - mode. -

-Both nargs and - nresults have the same meaning as in - lua_call(3). If there are no errors during the - call, lua_pcall behaves exactly like - lua_call(3). However, if there is any error, - lua_pcall catches it, pushes a single value - on the stack (the error message), and returns an error code. Like - lua_call(3), - lua_pcall always removes the function and - its arguments from the stack. -

-If errfunc is 0, then the error message - returned on the stack is exactly the original error message. Otherwise, - errfunc is the stack index of an - error handler function. (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 - lua_pcall. -

-Typically, the error handler function 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 lua_pcall, - since by then the stack has unwound. -

RETURN +
+
NAME
+
`lua_pcall` — calls + a function in protected mode
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_pcall`(`lua_State + L`, `int nargs`, + `int nresults`, + `int errfunc`);
+
+
+
DESCRIPTION
+
`lua_pcall`() + calls a function in protected mode.
+
Both `nargs` and + `nresults` have the same meaning as in + lua_call(3). If there are no errors during the call, + `lua_pcall` behaves exactly like + lua_call(3). However, if there is any error, + `lua_pcall` catches it, pushes a single value on the + stack (the error message), and returns an error code. Like + lua_call(3), `lua_pcall` always + removes the function and its arguments from the stack.
+
If `errfunc` is 0, then the error + message returned on the stack is exactly the original error message. + Otherwise, `errfunc` is the stack index of an + error handler + function*. (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 `lua_pcall`.
+
Typically, the error handler function 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 + `lua_pcall`, since by then the stack has unwound.
+
+
+
RETURN VALUES
-The `lua_pcall` function returns 0 in case of - success or one of the following error codes (defined in - `<lua.h>`): -
+
The `lua_pcall` function returns 0 in case + of success or one of the following error codes (defined in + `<lua.h>`):
+

-
`LUA_ERRRUN`:
+
`LUA_ERRRUN`:

a runtime error.
-
`LUA_ERRMEM`:
+
`LUA_ERRMEM`:

memory allocation error. For such errors, Lua does not call the error handler function.
-
`LUA_ERRERR`:
+
`LUA_ERRERR`:

error while running the error handler function.

-
SEE +
+
+
SEE ALSO
-lua_call(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pcall`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pop — -

pops n elements from the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pop(lua_State - *L, int - n); -

DESCRIPTION

-lua_pop() pops - n elements from the stack. -

SEE +
+
NAME
+
`lua_pop` — pops n + elements from the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pop`(`lua_State + *L`, `int n`);
+
+
+
DESCRIPTION
+
`lua_pop`() + pops `n` elements from the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pop`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushboolean — -

pushes a boolean value onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushboolean(lua_State - *L, int - b); -

DESCRIPTION

-lua_pushboolean() pushes a boolean value with - value b onto the stack. -

SEE +
+
NAME
+
`lua_pushboolean` — + pushes a boolean value onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushboolean`(`lua_State + *L`, `int b`);
+
+
+
DESCRIPTION
+
`lua_pushboolean`() + pushes a boolean value with value `b` onto the + stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushboolean`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushcclosure — -

pushes a new C closure onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushcclosure(lua_State - *L, - lua_CFunction - fn, int - n); -

DESCRIPTION

-lua_pushcclosure() pushes a new C closure - onto the stack. -

-When a C function is created, it is possible to associate some values with it, - thus creating a C closure; these values are then accessible to the function - whenever it is called. To associate values with a C function, first these - values should be pushed onto the stack (when there are multiple values, the - first value is pushed first). Then - lua_pushcclosure() is called to create and - push the C function onto the stack, with the argument - n telling how many values should be - associated with the function. - lua_pushcclosure() also pops these values - from the stack. -

-The maximum value for n is 255. -

SEE +
+
NAME
+
`lua_pushcclosure` — + pushes a new C closure onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushcclosure`(`lua_State + *L`, `lua_CFunction + fn`, `int n`);
+
+
+
DESCRIPTION
+
`lua_pushcclosure`() + pushes a new C closure onto the stack.
+
When a C function is created, it is + possible to associate some values with it, thus creating a C closure; these + values are then accessible to the function whenever it is called. To + associate values with a C function, first these values should be pushed onto + the stack (when there are multiple values, the first value is pushed first). + Then + `lua_pushcclosure`() + is called to create and push the C function onto the stack, with the + argument `n` telling how many values should be + associated with the function. `lua_pushcclosure`() + also pops these values from the stack.
+
The maximum value for `n` is 255.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushcclosure`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushcfunction — -

pushes a C function onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushcfunction(lua_State - *L, - lua_CFunction - f); -

DESCRIPTION

-lua_pushcfunction() 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 function that, when called, invokes the - corresponding C function. -

-Any function to be registered in Lua must follow the correct protocol to receive - its parameters and return its results (see - lua_CFunction(3)). -

-lua_pushcfunction is defined as a macro: -

-#define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
-

NAME

lua_pushcfunction — + pushes a C function onto the stack

SYNOPSIS

#include + <lua.h>

void +
+ lua_pushcfunction(lua_State + *L, lua_CFunction + f);

DESCRIPTION

lua_pushcfunction() + 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 function that, when + called, invokes the corresponding C function.

Any function to be registered in Lua must follow the correct + protocol to receive its parameters and return its results (see + lua_CFunction(3)).

lua_pushcfunction is defined as a + macro:

#define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)

SEE +

HISTORY

-The lua_pushcfunction() manual page was - written by Sergey Bronnikov.

lua_CFunction(3)

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_pushcfunction() manual page was + written by Sergey Bronnikov.

NAME

-lua_pushfstring — -

pushes onto the stack a formatted string and returns - a pointer to this string

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_pushfstring(lua_State - *L, const char - *fmt, - ...); -

DESCRIPTION

-lua_pushfstring() pushes onto the stack a - formatted string and returns a pointer to this string. It is similar to the C - function sprintf(3), but has some important - differences: +

NAME

lua_pushfstring — + pushes onto the stack a formatted string and returns a + pointer to this string

SYNOPSIS

#include + <lua.h>

const char * +
+ lua_pushfstring(lua_State + *L, const char + *fmt, ...);

DESCRIPTION

lua_pushfstring() + pushes onto the stack a formatted string and returns a pointer to this + string. It is similar to the C function sprintf(3), but + has some important differences:

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 @@ -41,22 +45,27 @@ widths, or precisions. The conversion specifiers can only be ‘%%’ (inserts a '%' in the string), ‘%s’ (inserts a zero-terminated string, with no size restrictions), - ‘%f’ (inserts a lua_Number(3)), + ‘%f’ (inserts a lua_Number(3)), ‘%p’ (inserts a pointer as a hexadecimal numeral), ‘%d’ (inserts an int), and ‘%c’ (inserts an int as a character).

SEE +

HISTORY

-The lua_pushfstring() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushinteger — -

pushes a number with value

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushinteger(lua_State - *L, lua_Integer - n); -

DESCRIPTION

-lua_pushinteger() pushes a number with value - n onto the stack. -

SEE +
+
NAME
+
`lua_pushinteger` — + pushes a number with value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushinteger`(`lua_State + *L`, `lua_Integer + n`);
+
+
+
DESCRIPTION
+
`lua_pushinteger`() + pushes a number with value `n` onto the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushinteger`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushlightuserdata — -

pushes a light userdata onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushlightuserdata(lua_State - *L, void - *p); -

DESCRIPTION

-lua_pushlightuserdata() pushes a light - userdata onto the stack. -

-Userdata represent C values in Lua. A light - userdata represents a pointer. 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. -

SEE +
+
NAME
+
`lua_pushlightuserdata` — + pushes a light userdata onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushlightuserdata`(`lua_State + L`, `void p`);
+
+
+
DESCRIPTION
+
`lua_pushlightuserdata`() + pushes a light userdata onto the stack.
+
Userdata represent C values in Lua. A + light userdata + represents a pointer. 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.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushlightuserdata`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushliteral — -

pushes the string onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushliteral(lua_State - *L, const char - *s); -

DESCRIPTION

-lua_pushliteral() pushes the string pointed - to by s onto the stack. This macro is - equivalent to lua_pushlstring(3), but can be used - only when s is a literal string. In these - cases, it automatically provides the string length. -

SEE +
+
NAME
+
`lua_pushliteral` — + pushes the string onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushliteral`(`lua_State + L`, `const char + s`);
+
+
+
DESCRIPTION
+
`lua_pushliteral`() + pushes the string pointed to by `s` onto the stack. This + macro is equivalent to lua_pushlstring(3), but can be used + only when `s` is a literal string. In these cases, it + automatically provides the string length.
+
+
+
SEE ALSO
-lua_pushlstring(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushliteral`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushlstring — -

pushes the string onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushlstring(lua_State - *L, const char - *s, size_t - len); -

DESCRIPTION

-lua_pushlstring() pushes the string pointed - to by s with size - len onto the stack. -

-Lua makes (or reuses) an internal copy of the given string, so the memory at - s can be freed or reused immediately after - the function returns. The string can contain embedded zeros. -

SEE +
+
NAME
+
`lua_pushlstring` — + pushes the string onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushlstring`(`lua_State + L`, `const char s`, + `size_t len`);
+
+
+
DESCRIPTION
+
`lua_pushlstring`() + pushes the string pointed to by `s` with size + `len` onto the stack.
+
Lua makes (or reuses) an internal copy of the given string, so the + memory at `s` can be freed or reused immediately after + the function returns. The string can contain embedded zeros.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushlstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushnil — -

pushes a nil value onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushnil(lua_State - *L); -

DESCRIPTION

-lua_pushnil() pushes a nil value onto the - stack. -

SEE +
+
NAME
+
`lua_pushnil` — + pushes a nil value onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushnil`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_pushnil`() + pushes a nil value onto the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushnil`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushnumber — -

pushes a number onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushnumber(lua_State - *L, lua_Number - n); -

DESCRIPTION

-lua_pushnumber() pushes a number with value - n onto the stack. -

SEE +
+
NAME
+
`lua_pushnumber` — + pushes a number onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushnumber`(`lua_State + *L`, `lua_Number + n`);
+
+
+
DESCRIPTION
+
`lua_pushnumber`() + pushes a number with value `n` onto the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushnumber`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushstring — -

pushes the zero-terminated string onto the - stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushstring(lua_State - *L, const char - *s); -

DESCRIPTION

-lua_pushstring() pushes the zero-terminated - string pointed to by s onto the stack. Lua - makes (or reuses) an internal copy of the given string, so the memory at - s can be freed or reused immediately after - the function returns. The string cannot contain embedded zeros; it is assumed - to end at the first zero. -

SEE +
+
NAME
+
`lua_pushstring` — + pushes the zero-terminated string onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushstring`(`lua_State + L`, `const char + s`);
+
+
+
DESCRIPTION
+
`lua_pushstring`() + pushes the zero-terminated string pointed to by `s` onto + the stack. Lua makes (or reuses) an internal copy of the given string, so + the memory at `s` can be freed or reused immediately + after the function returns. The string cannot contain embedded zeros; it is + assumed to end at the first zero.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushthread — -

pushes the thread onto the stack

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_pushthread(lua_State - *L); -

DESCRIPTION

-lua_pushthread() pushes the thread - represented by L onto the stack. Returns 1 if - this thread is the main thread of its state. -

SEE +
+
NAME
+
`lua_pushthread` — + pushes the thread onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_pushthread`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_pushthread`() + pushes the thread represented by `L` onto the stack. + Returns 1 if this thread is the main thread of its state.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushthread`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushvalue — -

pushes a copy of the element onto the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_pushvalue(lua_State - *L, int - index); -

DESCRIPTION

-lua_pushvalue() pushes a copy of the element - at the given valid index onto the stack. -

SEE +
+
NAME
+
`lua_pushvalue` — + pushes a copy of the element onto the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_pushvalue`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_pushvalue`() + pushes a copy of the element at the given valid index onto the stack.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushvalue`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_pushvfstring — -

pushes onto the stack a formatted string and returns - a pointer to this string

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_pushvfstring(lua_State - *L, const char - *fmt, va_list - argp); -

DESCRIPTION

-lua_pushvfstring() pushes onto the stack a - formatted string and returns a pointer to this string. Equivalent to - lua_pushfstring(3), except that it receives a - va_list instead of a variable number of - arguments. -

SEE +
+
NAME
+
`lua_pushvfstring` — + pushes onto the stack a formatted string and returns a + pointer to this string
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_pushvfstring`(`lua_State + L`, `const char + *fmt`, `va_list + argp`);
+
+
+
DESCRIPTION
+
`lua_pushvfstring`() + pushes onto the stack a formatted string and returns a pointer to this + string. Equivalent to lua_pushfstring(3), except that it + receives a `va_list` instead of a variable number of + arguments.
+
+
+
SEE ALSO
-lua_pushfstring(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_pushvfstring`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_rawequal — -

compare two values for equality without calling - metamethods

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_rawequal(lua_State - *L, int - index1, int - index2); -

DESCRIPTION

-lua_rawequal() returns 1 if the two values in - acceptable indices index1 and - index2 are primitively equal (that is, - without calling metamethods). Otherwise returns 0. Also returns 0 if any of - the indices are non valid. -

SEE +
+
NAME
+
`lua_rawequal` — + compare two values for equality without calling + metamethods
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_rawequal`(`lua_State + *L`, `int index1`, + `int index2`);
+
+
+
DESCRIPTION
+
`lua_rawequal`() + returns 1 if the two values in acceptable indices + `index1` and `index2` are + primitively equal (that is, without calling metamethods). Otherwise returns + 0. Also returns 0 if any of the indices are non valid.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_rawequal`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_rawget — -

pops the key from the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_rawget(lua_State - *L, int - index); -

DESCRIPTION

-lua_rawget() pops the key from the stack - (putting the resulting value in its place). As in Lua, this function may - trigger a metamethod for the “index” event. Similar to - lua_gettable(3), but does a raw access (i.e., - without metamethods). -

SEE +
+
NAME
+
`lua_rawget` — pops + the key from the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_rawget`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_rawget`() + pops the key from the stack (putting the resulting value in its place). As + in Lua, this function may trigger a metamethod for the "index" + event. Similar to lua_gettable(3), but does a raw access + (i.e., without metamethods).
+
+
+
SEE ALSO
-lua_gettable(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_rawget`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_rawgeti — -

pushes onto the stack the value t[n], where t is the - value at the given valid index

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_rawgeti(lua_State - *L, int - index, int - n); -

DESCRIPTION

-lua_rawgeti() pushes onto the stack the value - t[n], where t is the value at the given valid index. The access is raw; that - is, it does not invoke metamethods. -

SEE +
+
NAME
+
`lua_rawgeti` — + pushes onto the stack the value t[n], where t is the value + at the given valid index
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_rawgeti`(`lua_State + *L`, `int index`, + `int n`);
+
+
+
DESCRIPTION
+
`lua_rawgeti`() + pushes onto the stack the value t[n], where t is the value at the given + valid index. The access is raw; that is, it does not invoke metamethods.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_rawgeti`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_rawset — -

pops both the key and the value from the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_rawset(lua_State - *L, int - index); -

DESCRIPTION

-lua_rawset() pops both the key and the value - from the stack. As in Lua, this function may trigger a metamethod for the - "newindex" event. Similar to - lua_settable(3), but does a raw assignment (i.e., - without metamethods). -

SEE +
+
NAME
+
`lua_rawset` — pops + both the key and the value from the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_rawset`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_rawset`() + pops both the key and the value from the stack. As in Lua, this function may + trigger a metamethod for the "newindex" event. Similar to + lua_settable(3), but does a raw assignment (i.e., without + metamethods).
+
+
+
SEE ALSO
-lua_settable(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_rawset`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_rawseti — -

pops the value from the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_rawseti(lua_State - *L, int - index, int - n); -

DESCRIPTION

-lua_rawseti() does the equivalent of t[n] = - v, where t is the value at the given valid index and v is the value at the top - of the stack. -

-This function pops the value from the stack. The assignment is raw; that is, it - does not invoke metamethods. -

SEE +
+
NAME
+
`lua_rawseti` — pops + the value from the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_rawseti`(`lua_State + *L`, `int index`, + `int n`);
+
+
+
DESCRIPTION
+
`lua_rawseti`() + does the equivalent of t[n] = v, where t is the value at the given valid + index and v is the value at the top of the stack.
+
This function pops the value from the stack. The assignment is + raw; that is, it does not invoke metamethods.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_rawseti`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_register — -

sets the C function as the new value of global - name

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_register(lua_State - *L, const char - *name, - lua_CFunction - f); -

DESCRIPTION

-lua_register() sets the C function - f as the new value of global name. It is - defined as a macro: -

-#define lua_register(L,n,f) (lua_pushcfunction(L, f), lua_setglobal(L, n))
-

NAME

lua_register — + sets the C function as the new value of global + name

SYNOPSIS

#include + <lua.h>

void +
+ lua_register(lua_State + *L, const char + *name, lua_CFunction + f);

DESCRIPTION

lua_register() + sets the C function f as the new value of global name. + It is defined as a macro:

#define lua_register(L,n,f) (lua_pushcfunction(L, f), lua_setglobal(L, n))

SEE +

HISTORY

-The lua_register() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_register() manual page was written + by Sergey Bronnikov.

NAME

-lua_remove — -

removes the element at the given index

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_remove(lua_State - *L, int - index); -

DESCRIPTION

-lua_remove() removes the element at the given - valid index, shifting down the elements above this index to fill the gap. - Cannot be called with a pseudo-index, because a pseudo-index is not an actual - stack position. -

SEE +
+
NAME
+
`lua_remove` — + removes the element at the given index
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_remove`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_remove`() + removes the element at the given valid index, shifting down the elements + above this index to fill the gap. Cannot be called with a pseudo-index, + because a pseudo-index is not an actual stack position.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_remove`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_replace — -

moves the top element into the given position

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_replace(lua_State - *L, int - index); -

DESCRIPTION

-lua_replace() moves the top element into the - given position (and pops it), without shifting any element (therefore - replacing the value at the given position). -

SEE +
+
NAME
+
`lua_replace` — + moves the top element into the given position
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_replace`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_replace`() + moves the top element into the given position (and pops it), without + shifting any element (therefore replacing the value at the given + position).
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_replace`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_resume — -

starts and resumes a coroutine in a given - thread

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_resume(lua_State - *L, int - narg); -

DESCRIPTION

-lua_resume() starts and resumes a coroutine - in a given thread. -

-To start a coroutine, you first create a new thread (see - lua_newthread(3) ); then you push onto its stack - the main function plus any arguments; then you call lua_resume, with narg - 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 lua_yield(3), or all values returned by - the body function. 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. To - restart a coroutine, you put on its stack only the values to be passed as - results from yield, and then call lua_resume. -

RETURN +
+
NAME
+
`lua_resume` — + starts and resumes a coroutine in a given thread
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_resume`(`lua_State + *L`, `int narg`);
+
+
+
DESCRIPTION
+
`lua_resume`() + starts and resumes a coroutine in a given thread.
+
To start a coroutine, you first create a new thread (see + lua_newthread(3) ); then you push onto its stack the main + function plus any arguments; then you call lua_resume, with narg 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 lua_yield(3), or all values returned by the body + function. 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. To restart + a coroutine, you put on its stack only the values to be passed as results + from yield, and then call lua_resume.
+
+
+
RETURN VALUES
-`lua_resume`() returns - `LUA_YIELD` if the coroutine yields, 0 if the - coroutine finishes its execution without errors, or an error code in case of - errors (see lua_pcall(3) ). -
SEE +
`lua_resume`() returns + `LUA_YIELD` if the coroutine yields, 0 if the + coroutine finishes its execution without errors, or an error code in case of + errors (see lua_pcall(3) ).
+
+
+
SEE ALSO
-lua_newthread(3), - lua_pcall(3), - lua_yield(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_resume`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setallocf — -

changes the allocator function

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_setallocf(lua_State - *L, lua_Alloc - f, void - *ud); -

DESCRIPTION

-lua_setallocf() changes the allocator - function of a given state to f with user data - ud. -

SEE +
+
NAME
+
`lua_setallocf` — + changes the allocator function
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_setallocf`(`lua_State + L`, `lua_Alloc f`, + `void ud`);
+
+
+
DESCRIPTION
+
`lua_setallocf`() + changes the allocator function of a given state to `f` + with user data `ud`.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setallocf`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setfenv — -

pops a table from the stack and sets it as the new - environment for the value

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_setfenv(lua_State - *L, int - index); -

DESCRIPTION

-lua_setfenv() pops a table from the stack and - sets it as the new environment for the value at the given index. -

RETURN +
+
NAME
+
`lua_setfenv` — pops + a table from the stack and sets it as the new environment for the + value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_setfenv`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_setfenv`() + pops a table from the stack and sets it as the new environment for the value + at the given index.
+
+
+
RETURN VALUES
-If the value at the given index is neither a function nor a thread nor a - userdata, `lua_setfenv`() returns 0. - Otherwise it returns 1. -
SEE +
If the value at the given index is neither a function nor a thread + nor a userdata, `lua_setfenv`() returns 0. Otherwise + it returns 1.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setfenv`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setfield — -

pops the value from the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_setfield(lua_State - *L, int - index, const - char *k); -

DESCRIPTION

-lua_setfield() does the equivalent to t[k] = - v, where t is the value at the given valid index and v is the value at the top - of the stack. -

-This function pops the value from the stack. As in Lua, this function may - trigger a metamethod for the “newindex” event. -

SEE +
+
NAME
+
`lua_setfield` — + pops the value from the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_setfield`(`lua_State + L`, `int index`, + `const char k`);
+
+
+
DESCRIPTION
+
`lua_setfield`() + does the equivalent to t[k] = v, where t is the value at the given valid + index and v is the value at the top of the stack.
+
This function pops the value from the stack. As in Lua, this + function may trigger a metamethod for the "newindex" event.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setfield`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setglobal — -

pops a value from the stack and sets it as the new - value of global name

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_setglobal(lua_State - *L, const char - *name); -

DESCRIPTION

-lua_setglobal() pops a value from the stack - and sets it as the new value of global name. It is defined as a macro: -

#define lua_setglobal(L,s) lua_setfield(L,
-  LUA_GLOBALSINDEX, s)

SEE +
+
NAME
+
`lua_setglobal` — + pops a value from the stack and sets it as the new value of + global name
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_setglobal`(`lua_State + L`, `const char + name`);
+
+
+
DESCRIPTION
+
`lua_setglobal`() + pops a value from the stack and sets it as the new value of global name. It + is defined as a macro:
+
`#define lua_setglobal(L,s) lua_setfield(L, + LUA_GLOBALSINDEX, s)`
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setglobal`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_sethook — -

sets the debugging hook function

SYNOPSIS

#include
-  <fcntl.h>

-int -
-lua_sethook(lua_State - *L, lua_Hook - f, int - mask, int - count); -

DESCRIPTION

-lua_sethook() sets the debugging hook - function. -

-Argument f is the hook function. mask specifies on which events the hook will be - called: it is formed by a bitwise or of the constants - LUA_MASKCALL, - LUA_MASKRET, - LUA_MASKLINE, and - LUA_MASKCOUNT. The count argument is only - meaningful when the mask includes - LUA_MASKCOUNT. For each event, the hook is - called as explained below: +

NAME

lua_sethook — sets + the debugging hook function

SYNOPSIS

#include + <fcntl.h>

int +
+ lua_sethook(lua_State + *L, lua_Hook f, + int mask, + int count);

DESCRIPTION

lua_sethook() + sets the debugging hook function.

Argument f is the hook function. mask specifies on which events + the hook will be called: it is formed by a bitwise or of the constants + LUA_MASKCALL, LUA_MASKRET, + LUA_MASKLINE, and + LUA_MASKCOUNT. The count argument is only meaningful + when the mask includes LUA_MASKCOUNT. For each + event, the hook is called as explained below:


The call hook:
The call + hook:: 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.

The return hook:
The return + hook:: is called when the interpreter returns from a function. The hook is called just before Lua leaves the function. You have no access to the values to be returned by the function.

The line hook:
The line + hook:: 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.)

The count hook:
The count + hook:: is called after the interpreter executes every count instructions. (This event only happens while Lua is executing a Lua function.)

-A hook is disabled by setting mask to zero. -

SEE +
A hook is disabled by setting mask to zero.
+

HISTORY

-The lua_sethook() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setlocal — -

sets the value of a local variable of a given - activation record

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_setlocal(lua_State - *L, lua_Debug - *ar, int - n); -

DESCRIPTION

-lua_setlocal() sets the value of a local - variable of a given activation record. Parameters - ar and n are - as in lua_getlocal(3). - lua_setlocal() assigns the value at the top - of the stack to the variable and returns its name. It also pops the value from - the stack. -

RETURN +
+
NAME
+
`lua_setlocal` — + sets the value of a local variable of a given activation + record
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_setlocal`(`lua_State + L`, `lua_Debug *ar`, + `int n`);
+
+
+
DESCRIPTION
+
`lua_setlocal`() + sets the value of a local variable of a given activation record. Parameters + `ar` and `n` are as in + lua_getlocal(3). `lua_setlocal`() + assigns the value at the top of the stack to the variable and returns its + name. It also pops the value from the stack.
+
+
+
RETURN VALUES
-Returns `NULL` (and pops nothing) when the - index is greater than the number of active local variables. -
SEE +
Returns `NULL` (and pops nothing) when the + index is greater than the number of active local variables.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setlocal`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setmetatable — -

pops a table from the stack and sets it as the new - metatable for the value

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_setmetatable(lua_State - *L, int - index); -

DESCRIPTION

-lua_setmetatable() pops a table from the - stack and sets it as the new metatable for the value at the given acceptable - index. -

SEE +
+
NAME
+
`lua_setmetatable` — + pops a table from the stack and sets it as the new + metatable for the value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_setmetatable`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_setmetatable`() + pops a table from the stack and sets it as the new metatable for the value + at the given acceptable index.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setmetatable`() manual page was - written by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_settable — -

pops both the key and the value from the stack

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_settable(lua_State - *L, int - index); -

DESCRIPTION

-lua_settable() does the equivalent to t[k] = - v, where t is the value at the given valid index, v is the value at the top of - the stack, and k is the value just below the top. -

-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 +
+
NAME
+
`lua_settable` — + pops both the key and the value from the stack
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_settable`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_settable`() + does the equivalent to t[k] = v, where t is the value at the given valid + index, v is the value at the top of the stack, and k is the value just below + the top.
+
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 ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_settable`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_settop — -

sets the stack top to the index

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_settop(lua_State - *L, int - index); -

DESCRIPTION

-lua_settop() accepts any acceptable 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 - nil. If index is 0, then all stack elements - are removed. -

SEE +
+
NAME
+
`lua_settop` — sets + the stack top to the index
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_settop`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_settop`() + accepts any acceptable 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 `nil`. If index is 0, then all stack elements are + removed.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_settop`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_setupvalue — -

sets the value of a closure's upvalue

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_setupvalue(lua_State - *L, int - funcindex, int - n); -

DESCRIPTION

-lua_setupvalue() 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 - funcindex and - n are as in the - lua_getupvalue(3). -

RETURN +
+
NAME
+
`lua_setupvalue` — + sets the value of a closure's upvalue
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_setupvalue`(`lua_State + L`, `int funcindex`, + `int n`);
+
+
+
DESCRIPTION
+
`lua_setupvalue`() + 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 `funcindex` and + `n` are as in the + lua_getupvalue(3).
+
+
+
RETURN VALUES
-Returns `NULL` (and pops nothing) when the - index is greater than the number of upvalues. -
SEE +
Returns `NULL` (and pops nothing) when the + index is greater than the number of upvalues.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_setupvalue`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_status — -

returns the status of the thread L

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_status(lua_State - *L); -

DESCRIPTION

-lua_status() returns the status of the thread - L. -

RETURN +
+
NAME
+
`lua_status` — + returns the status of the thread L
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_status`(`lua_State + *L`);
+
+
+
DESCRIPTION
+
`lua_status`() + returns the status of the thread L.
+
+
+
RETURN VALUES
-The status can be 0 for a normal thread, an error code if the thread finished - its execution with an error, or `LUA_YIELD` - if the thread is suspended. -
SEE +
The status can be 0 for a normal thread, an error code if the + thread finished its execution with an error, or + `LUA_YIELD` if the thread is suspended.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_status`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_toboolean — -

converts the Lua value to a C boolean value

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_toboolean(lua_State - *L, int - index); -

DESCRIPTION

-lua_toboolean() converts the Lua value at the - given acceptable index to a C boolean value (0 or 1). -

RETURN +
+
NAME
+
`lua_toboolean` — + converts the Lua value to a C boolean value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_toboolean`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_toboolean`() + converts the Lua value at the given acceptable index to a C boolean value (0 + or 1).
+
+
+
RETURN VALUES
-Like all tests in Lua, `lua_toboolean`() - returns 1 for any Lua value different from false - and nil; otherwise it returns 0. It also returns - 0 when called with a non-valid index. (If you want to accept only actual - boolean values, use lua_isboolean(3) to test the - value's type.) -
SEE +
Like all tests in Lua, `lua_toboolean`() + returns 1 for any Lua value different from + false + and nil; + otherwise it returns 0. It also returns 0 when called with a non-valid + index. (If you want to accept only actual boolean values, use + lua_isboolean(3) to test the value's type.)
+
+
+
SEE ALSO
-lua_isboolean(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_toboolean`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_tocfunction — -

converts a value to a C function

SYNOPSIS

#include
-  <lua.h>

-lua_CFunction -
-lua_tocfunction(lua_State - *L, int - index); -

DESCRIPTION

-lua_tocfunction() converts a value at the - given acceptable index to a C function. -

RETURN +
+
NAME
+
`lua_tocfunction` — + converts a value to a C function
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_CFunction` +
+ `lua_tocfunction`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_tocfunction`() + converts a value at the given acceptable index to a C function.
+
+
+
RETURN VALUES
-That value must be a C function; otherwise, returns - `NULL`. -
SEE +
That value must be a C function; otherwise, returns + `NULL`.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_tocfunction`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_tointeger — -

converts the Lua value to the signed integral - type

SYNOPSIS

#include
-  <lua.h>

-lua_Integer -
-lua_tointeger(lua_State - *L, int - index); -

DESCRIPTION

-lua_tointeger() converts the Lua value at the - given acceptable index to the signed integral type - lua_Integer(3). -

RETURN +
+
NAME
+
`lua_tointeger` — + converts the Lua value to the signed integral + type
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_Integer` +
+ `lua_tointeger`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_tointeger`() + converts the Lua value at the given acceptable index to the signed integral + type lua_Integer(3).
+
+
+
RETURN VALUES
-The Lua value must be a number or a string convertible to a number; otherwise, - `lua_tointeger`() returns 0. -
-If the number is not an integer, it is truncated in some non-specified way. -
SEE +
The Lua value must be a number or a string convertible to a + number; otherwise, `lua_tointeger`() returns 0.
+
If the number is not an integer, it is truncated in some + non-specified way.
+
+
+
SEE ALSO
-lua_Integer(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_tointeger`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_tolstring — -

converts the Lua value to a C string

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_tolstring(lua_State - *L, int - index, size_t - *len); -

DESCRIPTION

-lua_tolstring() converts the Lua value at the - given acceptable index to a C string. If len - is not NULL, it also sets - *len with the string length. The Lua value - must be a string or a number; otherwise, the function returns - NULL. If the value is a number, then - lua_tolstring() also changes the actual - value in the stack to a string. (This change confuses - lua_next(3) when - lua_tolstring() is applied to keys during a - table traversal.) -

RETURN +
+
NAME
+
`lua_tolstring` — + converts the Lua value to a C string
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_tolstring`(`lua_State + L`, `int index`, + `size_t len`);
+
+
+
DESCRIPTION
+
`lua_tolstring`() + converts the Lua value at the given acceptable index to a C string. If + `len` is not `NULL`, it also sets + `len` with the string length. The Lua value must be a + string or a number; otherwise, the function returns + `NULL`. If the value is a number, then + `lua_tolstring`() also changes the actual value in the + stack to a string. (This change confuses lua_next(3) when + `lua_tolstring`() is applied to keys during a table + traversal.)
+
+
+
RETURN VALUES
-`lua_tolstring`() returns a fully aligned - pointer to a string inside the Lua state. This string always has a zero ('\0') - after its last character (as in C), but can contain other zeros in its body. - Because Lua has garbage collection, there is no guarantee that the pointer - returned by `lua_tolstring`() will be valid - after the corresponding value is removed from the stack. -
SEE +
`lua_tolstring`() returns a fully aligned + pointer to a string inside the Lua state. This string always has a zero + ('\0') after its last character (as in C), but can contain other zeros in + its body. Because Lua has garbage collection, there is no guarantee that the + pointer returned by `lua_tolstring`() will be valid + after the corresponding value is removed from the stack.
+
+
+
SEE ALSO
-lua_next(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_tolstring`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_tonumber — -

converts the Lua value to the C type - lua_Number(3)

SYNOPSIS

#include
-  <lua.h>

-lua_Number -
-lua_tonumber(lua_State - *L, int - index); -

DESCRIPTION

-lua_tonumber() converts the Lua value at the - given acceptable index to the C type - lua_Number(3). The Lua value must be a number or - a string convertible to a number; otherwise, - lua_tonumber returns 0. -

SEE +
+
NAME
+
`lua_tonumber` — + converts the Lua value to the C type + lua_Number(3)
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_Number` +
+ `lua_tonumber`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_tonumber`() + converts the Lua value at the given acceptable index to the C type + lua_Number(3). The Lua value must be a number or a string + convertible to a number; otherwise, `lua_tonumber` + returns 0.
+
+
+
SEE ALSO
-lua_Number(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_tonumber`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_topointer — -

converts the value to a generic C pointer

SYNOPSIS

#include
-  <lua.h>

-const void * -
-lua_topointer(lua_State - *L, int - index); -

DESCRIPTION

-lua_topointer() converts the value at the - given acceptable index to a generic C pointer (void*). The value can be a - userdata, a table, a thread, or a function; otherwise, - lua_topointer returns - NULL. Different objects will give different - pointers. There is no way to convert the pointer back to its original value. -

-Typically this function is used only for debug information. -

SEE +
+
NAME
+
`lua_topointer` — + converts the value to a generic C pointer
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const void ` +
+ `lua_topointer`(`lua_State + L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_topointer`() + converts the value at the given acceptable index to a generic C pointer + (void*). The value can be a userdata, a table, a thread, or a function; + otherwise, `lua_topointer` returns + `NULL`. Different objects will give different + pointers. There is no way to convert the pointer back to its original + value.
+
Typically this function is used only for debug information.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_topointer`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_tostring — -

converts the Lua value to a C string

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_tostring(lua_State - *L, int - index); -

DESCRIPTION

-lua_tostring() converts the Lua value at the - given acceptable index to a C string. -

-Equivalent to lua_tolstring(3) with len equal to - NULL. -

SEE +
+
NAME
+
`lua_tostring` — + converts the Lua value to a C string
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_tostring`(`lua_State + L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_tostring`() + converts the Lua value at the given acceptable index to a C string.
+
Equivalent to lua_tolstring(3) with len equal to + `NULL`.
+
+
+
SEE ALSO
-lua_tolstring(3) -
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_tostring`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_tothread — -

converts the value to a Lua thread

SYNOPSIS

#include
-  <lua.h>

-lua_State * -
-lua_tothread(lua_State - *L, int - index); -

DESCRIPTION

-lua_tothread() converts the value at the - given acceptable index to a Lua thread (represented as lua_State *). This - value must be a thread; otherwise, the function returns - NULL. -

RETURN +
+
NAME
+
`lua_tothread` — + converts the value to a Lua thread
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`lua_State ` +
+ `lua_tothread`(`lua_State + L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_tothread`() + converts the value at the given acceptable index to a Lua thread + (represented as lua_State ). This value must be a thread; otherwise, the + function returns `NULL`.
+
+
+
RETURN VALUES
-Returns Lua thread represented as lua_State and returns - `NULL` when value is not a thread. -
SEE +
Returns Lua thread represented as lua_State* and returns + `NULL` when value is not a thread.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_gethook`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_touserdata — -

returns address to userdata

SYNOPSIS

#include
-  <lua.h>

-void * -
-lua_touserdata(lua_State - *L, int - index); -

DESCRIPTION

-If the value at the given acceptable index is a full userdata, returns its block - address. -

RETURN +
+
NAME
+
`lua_touserdata` — + returns address to userdata
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void ` +
+ `lua_touserdata`(`lua_State + L`, `int index`);
+
+
+
DESCRIPTION
+
If the value at the given acceptable index is a full userdata, + returns its block address.
+
+
+
RETURN VALUES
-If the value is a light userdata, returns its pointer. Otherwise, returns - `NULL`. -
SEE +
If the value is a light userdata, returns its pointer. Otherwise, + returns `NULL`.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_touserdata`() manual page was written - by Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_type — -

returns the type of the value

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_type(lua_State - *L, int - index); -

DESCRIPTION

-lua_type() returns the type of the value in - the given acceptable index, or LUA_TNONE - for a non-valid index (that is, an index to an "empty" stack - position). The types returned by lua_type - are coded by the following constants defined in - <lua.h>: - LUA_TNIL, - LUA_TNUMBER, - LUA_TBOOLEAN, - LUA_TSTRING, - LUA_TTABLE, - LUA_TFUNCTION, - LUA_TUSERDATA, - LUA_TTHREAD, and - LUA_TLIGHTUSERDATA. -

SEE +
+
NAME
+
`lua_type` — returns + the type of the value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`int` +
+ `lua_type`(`lua_State + *L`, `int index`);
+
+
+
DESCRIPTION
+
`lua_type`() + returns the type of the value in the given acceptable index, or + `LUA_TNONE` for a non-valid index (that is, an index + to an "empty" stack position). The types returned by + `lua_type` are coded by the following constants + defined in `<lua.h>`: + `LUA_TNIL`, `LUA_TNUMBER`, + `LUA_TBOOLEAN`, `LUA_TSTRING`, + `LUA_TTABLE`, `LUA_TFUNCTION`, + `LUA_TUSERDATA`, `LUA_TTHREAD`, + and `LUA_TLIGHTUSERDATA`.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_type`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_typename — -

returns the name of the type encoded by the - value

SYNOPSIS

#include
-  <lua.h>

-const char * -
-lua_typename(lua_State - *L, int - tp); -

DESCRIPTION

-lua_typename() returns the name of the type - encoded by the value tp, which must be one - the values returned by lua_type(3). -

RETURN +
+
NAME
+
`lua_typename` — + returns the name of the type encoded by the + value
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`const char ` +
+ `lua_typename`(`lua_State + L`, `int tp`);
+
+
+
DESCRIPTION
+
`lua_typename`() + returns the name of the type encoded by the value `tp`, + which must be one the values returned by lua_type(3).
+
+
+
RETURN VALUES
-Returns the name of the type encoded by the value. -
SEE +
Returns the name of the type encoded by the value.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_typename`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_xmove — -

exchange values between different threads of the same - global state

SYNOPSIS

#include
-  <lua.h>

-void -
-lua_xmove(lua_State - *from, lua_State - *to, int - n); -

DESCRIPTION

-lua_xmove() exchange values between different - threads of the same global state. This function pops n values from the stack - from, and pushes them onto the stack to. -

SEE +
+
NAME
+
`lua_xmove` — + exchange values between different threads of the same + global state
+
+
+
SYNOPSIS
+
`#include + <lua.h>`
+
`void` +
+ `lua_xmove`(`lua_State + from`, `lua_State + to`, `int n`);
+
+
+
DESCRIPTION
+
`lua_xmove`() + exchange values between different threads of the same global state. This + function pops n values from the stack from, and pushes them onto the stack + to.
+
+
+
SEE ALSO
-Roberto Ierusalimschy, - Luiz Henrique de Figueiredo, and - Waldemar Celes, Lua 5.1 Reference - Manual. -
HISTORY
-The `lua_xmove`() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

NAME

-lua_yield — -

yields a coroutine

SYNOPSIS

#include
-  <lua.h>

-int -
-lua_yield(lua_State - *L, int - nresults); -

DESCRIPTION

-lua_yield() yields a coroutine. This function - should only be called as the return expression of a C function, as follows: -

-return lua_yield (L, nresults);
-

NAME

lua_yield — yields + a coroutine

SYNOPSIS

#include + <lua.h>

int +
+ lua_yield(lua_State + *L, int + nresults);

DESCRIPTION

lua_yield() + yields a coroutine. This function should only be called as the return + expression of a C function, as follows:

return lua_yield (L, nresults);

-When a C function calls lua_yield in that - way, the running coroutine suspends its execution, and the call to lua_resume - that started this coroutine returns. The parameter - nresults is the number of values from the - stack that are passed as results to - lua_resume(3). -

SEE +
When a C function calls `lua_yield` in that + way, the running coroutine suspends its execution, and the call to + lua_resume that started this coroutine returns. The parameter + `nresults` is the number of values from the stack that + are passed as results to lua_resume(3).
+

HISTORY

-The lua_yield() manual page was written by - Sergey Bronnikov.

Roberto Ierusalimschy, + Luiz Henrique de Figueiredo, and + Waldemar Celes, Lua 5.1 Reference + Manual.

+ +

HISTORY

The lua_yield() manual page was written by + Sergey Bronnikov.

Lua 5.1 C API

SEE +This function never returns, but it is an + idiom to use it in C functions as return + luaL_argerror(args). +

SEE +
This function never returns, but it is an + idiom to use it in C functions as return + luaL_argerror(args).
+