Lua

https://www.lua.org/manual/5.3/
Admin
Lua is a powerful, efficient, lightweight, and embeddable scripting language designed for extending...
Tokens:77,341
Snippets:918
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example path string for package.searchpath

Source: https://www.lua.org/manual/5.3/manual.html

An example of a path string template used by package.searchpath to resolve module names into file paths.

```text
./?.lua;./?.lc;/usr/local/?/init.lua
```

--------------------------------

### Example C path string for package.searchers

Source: https://www.lua.org/manual/5.3/manual.html

An example of a C path string used by the third searcher in package.searchers to locate module libraries.

```text
./?.so;./?.dll;/usr/local/?/init.so
```

--------------------------------

### Vararg function examples

Source: https://www.lua.org/manual/5.3/manual.html

Example function definitions used to demonstrate parameter mapping.

```lua
     function f(a, b) end
     function g(a, b, ...) end
     function r() return 1,2,3 end
```

--------------------------------

### Logical Operators Examples

Source: https://www.lua.org/manual/5.3/manual.html

Examples demonstrating the short-circuit evaluation and return values of the 'and' and 'or' logical operators.

```lua
     10 or 20            --> 10
     10 or error()       --> 10
     nil or "a"          --> "a"
     nil and 10          --> nil
     false and error()   --> false
     false and nil       --> false
     false or nil        --> nil
     10 and 20           --> 20
```

--------------------------------

### Get function information with debug.getinfo

Source: https://www.lua.org/manual/5.3/manual.html

Examples of using debug.getinfo to retrieve function names and metadata.

```lua
debug.getinfo(1,"n").name
```

```lua
debug.getinfo(print)
```

--------------------------------

### Coroutine execution example

Source: https://www.lua.org/manual/5.3/manual.html

Demonstrates the lifecycle of a coroutine including creation, yielding, and resuming with arguments.

```lua
     function foo (a)
       print("foo", a)
       return coroutine.yield(2*a)
     end
     
     co = coroutine.create(function (a,b)
           print("co-body", a, b)
           local r = foo(a+1)
           print("co-body", r)
           local r, s = coroutine.yield(a+b, a-b)
           print("co-body", r, s)
           return b, "end"
     end)
     
     print("main", coroutine.resume(co, 1, 10))
     print("main", coroutine.resume(co, "r"))
     print("main", coroutine.resume(co, "x", "y"))
     print("main", coroutine.resume(co, "x", "y"))
```

--------------------------------

### lua_call C implementation

Source: https://www.lua.org/manual/5.3/manual.html

C code demonstrating how to call a Lua function equivalent to the provided Lua example.

```c
     lua_getglobal(L, "f");                  /* function to be called */
     lua_pushliteral(L, "how");                       /* 1st argument */
     lua_getglobal(L, "t");                    /* table to be indexed */
     lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
     lua_remove(L, -2);                  /* remove 't' from the stack */
     lua_pushinteger(L, 14);                          /* 3rd argument */
     lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
     lua_setglobal(L, "a");                         /* set global 'a' */
```

--------------------------------

### Lua Interpreter Option Execution Order

Source: https://www.lua.org/manual/5.3/manual.html

Example demonstrating how multiple -e options are processed sequentially before the script is executed.

```bash
     $ lua -e'a=1' -e 'print(a)' script.lua

```

--------------------------------

### io.popen (prog [, mode])

Source: https://www.lua.org/manual/5.3/manual.html

Starts a program in a separate process and returns a file handle for communication.

```APIDOC
## io.popen (prog [, mode])

### Description
Starts program 'prog' in a separate process. Returns a file handle to read from or write to the program based on the mode.
```

--------------------------------

### Lua Argument Table Indexing

Source: https://www.lua.org/manual/5.3/manual.html

Example showing how arguments are indexed when no script is provided.

```bash
     $ lua -e "print(arg[1])"

```

--------------------------------

### Table constructor example and equivalent code

Source: https://www.lua.org/manual/5.3/manual.html

A complex table constructor and its equivalent procedural assignment representation.

```lua
     a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }

```

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

```

--------------------------------

### lua_resume

Source: https://www.lua.org/manual/5.3/manual.html

Starts or resumes a coroutine.

```APIDOC
## int lua_resume (lua_State *L, lua_State *from, int nargs);

### Description
Starts and resumes a coroutine in the given thread L. Returns LUA_YIELD if the coroutine yields, LUA_OK if it finishes, or an error code.
```

--------------------------------

### lua_call equivalent Lua code

Source: https://www.lua.org/manual/5.3/manual.html

Example Lua code demonstrating a function call that will be replicated in C.

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

--------------------------------

### Lua Command-Line Argument Table Structure

Source: https://www.lua.org/manual/5.3/manual.html

Example of how command-line arguments are populated into the global 'arg' table.

```bash
     $ lua -la b.lua t1 t2

```

```lua
     arg = { [-2] = "lua", [-1] = "-la",
             [0] = "b.lua",
             [1] = "t1", [2] = "t2" }

```

--------------------------------

### lua_CFunction implementation example

Source: https://www.lua.org/manual/5.3/manual.html

An example C function that calculates the average and sum of numeric arguments received from Lua.

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

--------------------------------

### Expression Adjustment Examples

Source: https://www.lua.org/manual/5.3/manual.html

Demonstrates how function calls and vararg expressions are adjusted to different numbers of results depending on their context.

```lua
     f()                -- adjusted to 0 results
     g(f(), x)          -- f() is adjusted to 1 result
     g(x, f())          -- g gets x plus all results from f()
     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
     a,b = ...          -- a gets the first vararg argument, b gets
                        -- the second (both a and b can get nil if there
                        -- is no corresponding vararg argument)
     
     a,b,c = x, f()     -- f() is adjusted to 2 results
     a,b,c = f()        -- f() is adjusted to 3 results
     return f()         -- returns all results from f()
     return ...         -- returns all received vararg arguments
     return x,y,f()     -- returns x, y, and all results from f()
     {f()}              -- creates a list with all results from f()
     {...}              -- creates a list with all vararg arguments
     {f(), nil}         -- f() is adjusted to 1 result

```

--------------------------------

### coroutine.resume(co, ...)

Source: https://www.lua.org/manual/5.3/manual.html

Starts or continues the execution of a coroutine.

```APIDOC
## coroutine.resume(co, ...)

### Description
Starts or continues the execution of coroutine co. The first time it is called, it starts the coroutine. Subsequent calls resume the coroutine from where it yielded. Returns true plus any values returned by the coroutine or passed to yield, or false plus an error object if an error occurs.
```

--------------------------------

### coroutine.resume

Source: https://www.lua.org/manual/5.3/manual.html

Starts or continues the execution of a coroutine.

```APIDOC
## coroutine.resume(co [, val1, ...])

### Description
Starts or continues the execution of coroutine `co`. If the coroutine runs without errors, it returns true plus any values passed to yield or returned by the body function. If an error occurs, it returns false plus the error message.
```

--------------------------------

### Valid integer constants

Source: https://www.lua.org/manual/5.3/manual.html

Examples of valid integer constants in Lua.

```lua
     3   345   0xff   0xBEBADA

```

--------------------------------

### lua_resume

Source: https://www.lua.org/manual/5.3/manual.html

Starts or resumes a coroutine in the given thread.

```c
int lua_resume (lua_State *L, lua_State *from, int nargs);
```

--------------------------------

### Collect key-value pairs into a table using string.gmatch

Source: https://www.lua.org/manual/5.3/manual.html

This example uses pattern matching with captures to extract key=value pairs from a string and store them in a table.

```lua
t = {}
s = "from=world, to=Lua"
for k, v in string.gmatch(s, "(%w+)=(%w+)") do
  t[k] = v
end
```

--------------------------------

### Equivalent String Literal Definitions

Source: https://www.lua.org/manual/5.3/manual.html

Examples showing different ways to define the same string literal in Lua using short and long bracket formats.

```lua
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
```

--------------------------------

### Iterate over file characters with file:lines

Source: https://www.lua.org/manual/5.3/manual.html

Example of using file:lines with a format argument to iterate over all characters of a file.

```lua
     for c in file:lines(1) do _body_ end
```

--------------------------------

### Get function definition line with lua_getinfo

Source: https://www.lua.org/manual/5.3/manual.html

Example showing how to retrieve the line number where a global function 'f' is defined.

```c
     lua_Debug ar;
     lua_getglobal(L, "f");  /* get global 'f' */
     lua_getinfo(L, ">S", &ar);
     printf("%d\n", ar.linedefined);
```

--------------------------------

### luaL_buffinit

Source: https://www.lua.org/manual/5.3/manual.html

Initializes a string buffer.

```APIDOC
## void luaL_buffinit (lua_State *L, luaL_Buffer *B)

### Description
Initializes a buffer `B`. This function does not allocate any space.

### Parameters
- **L** (lua_State *) - Required - The Lua state.
- **B** (luaL_Buffer *) - Required - The buffer to initialize.
```

--------------------------------

### Non-tail call examples

Source: https://www.lua.org/manual/5.3/manual.html

Examples of function calls that do not qualify as tail calls in Lua.

```lua
     return (f(x))        -- results adjusted to 1
     return 2 * f(x)
     return x, f(x)       -- additional results
     f(x); return         -- results discarded
     return x or f(x)     -- results adjusted to 1
```

--------------------------------

### lua_newtable

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new empty table and pushes it onto the stack.

```c
void lua_newtable (lua_State *L);
```

--------------------------------

### luaL_dofile

Source: https://www.lua.org/manual/5.3/manual.html

Loads and runs the given file.

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

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

--------------------------------

### lua_getupvalue

Source: https://www.lua.org/manual/5.3/manual.html

Gets information about the n-th upvalue of a closure.

```APIDOC
## lua_getupvalue

### Description
Gets information about the `n`-th upvalue of the closure at the specified index. It pushes the upvalue's value onto the stack and returns its name.

### Signature
`const char *lua_getupvalue (lua_State *L, int funcindex, int n);`

### Parameters
- **L** (lua_State*) - The Lua state.
- **funcindex** (int) - The stack index of the closure.
- **n** (int) - The index of the upvalue.

### Returns
- **const char*** - The name of the upvalue, or `NULL` if the index is out of range.
```

--------------------------------

### luaL_dostring

Source: https://www.lua.org/manual/5.3/manual.html

Loads and runs the given string.

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

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

--------------------------------

### lua_getstack

Source: https://www.lua.org/manual/5.3/manual.html

Gets information about the interpreter runtime stack.

```APIDOC
## lua_getstack

### Description
Fills parts of a `lua_Debug` structure with an identification of the activation record of the function executing at a given level.

### Signature
`int lua_getstack (lua_State *L, int level, lua_Debug *ar);`

### Parameters
- **L** (lua_State*) - The Lua state.
- **level** (int) - The stack level (0 is the current function).
- **ar** (lua_Debug*) - The structure to fill.

### Returns
- **int** - Returns 1 on success, 0 if the level is greater than the stack depth.
```

--------------------------------

### luaL_prepbuffer

Source: https://www.lua.org/manual/5.3/manual.html

Prepares a buffer with the default size LUAL_BUFFERSIZE.

```c
char *luaL_prepbuffer (luaL_Buffer *B);
```

--------------------------------

### file:seek

Source: https://www.lua.org/manual/5.3/manual.html

Sets or gets the current file position.

```APIDOC
## file:seek ([whence [, offset]])

### Description
Sets and gets the file position, measured from the beginning of the file. The position is calculated as offset plus a base specified by whence.

### Parameters
- **whence** (string) - Optional - The base position: 'set' (beginning), 'cur' (current), or 'end' (end of file). Defaults to 'cur'.
- **offset** (number) - Optional - The byte offset from the base. Defaults to 0.

### Response
- **position** (number) - The final file position in bytes from the beginning of the file.
- **error** (string) - Returned if the operation fails.
```

--------------------------------

### luaL_dofile

Source: https://www.lua.org/manual/5.3/manual.html

Loads and runs a file.

```APIDOC
## int luaL_dofile (lua_State *L, const char *filename)

### Description
Loads and runs the given file. Returns false if there are no errors or true in case of errors.
```

--------------------------------

### lua_newtable

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new empty table.

```APIDOC
## void lua_newtable (lua_State *L);

### Description
Creates a new empty table and pushes it onto the stack.
```

--------------------------------

### lua_getinfo

Source: https://www.lua.org/manual/5.3/manual.html

Gets information about a specific function or function invocation.

```APIDOC
## lua_getinfo

### Description
Gets information about a specific function or function invocation. To get information about a function invocation, the parameter `ar` must be a valid activation record. To get information about a function, push it onto the stack and start the `what` string with '>'.

### Signature
`int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);`

### Parameters
- **L** (lua_State*) - The Lua state.
- **what** (const char*) - A string specifying which fields of the `lua_Debug` structure to fill or values to push.
- **ar** (lua_Debug*) - The activation record structure to be filled.

### Returns
- **int** - Returns 0 on error (e.g., invalid option in `what`), otherwise non-zero.
```

--------------------------------

### utf8.codes iteration

Source: https://www.lua.org/manual/5.3/manual.html

Example of using utf8.codes to iterate over all characters in a string.

```lua
     for p, c in utf8.codes(s) do _body_ end
```

--------------------------------

### Perform string substitutions with string.gsub

Source: https://www.lua.org/manual/5.3/manual.html

Demonstrates various ways to use string.gsub with string, table, and function replacements, including capture groups and limit arguments.

```lua
     x = string.gsub("hello world", "(%w+)", "%1 %1")
     --> x="hello hello world world"
     
     x = string.gsub("hello world", "%w+", "%0 %0", 1)
     --> x="hello hello world"
     
     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
     --> x="world hello Lua from"
     
     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
     --> x="home = /home/roberto, user = roberto"
     
     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
           return load(s)()
         end)
     --> x="4+5 = 9"
     
     local t = {name="lua", version="5.3"}
     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
     --> x="lua-5.3.tar.gz"
```

--------------------------------

### Ambiguous statement fragment

Source: https://www.lua.org/manual/5.3/manual.html

Example of a fragment that can be interpreted in two ways by the parser.

```lua
     a = b + c
     (print or io.write)('done')
```

--------------------------------

### package.loadlib(libname, funcname)

Source: https://www.lua.org/manual/5.3/manual.html

Dynamically links the host program with a C library and optionally retrieves a function from it.

```APIDOC
## package.loadlib(libname, funcname)

### Description
Dynamically links the host program with the C library libname. If funcname is "*", it only links the library; otherwise, it returns the specified function from the library.

### Parameters
- **libname** (string) - Required - The complete file name of the C library.
- **funcname** (string) - Required - The name of the function to retrieve, or "*" to only link the library.
```

--------------------------------

### luaL_gsub

Source: https://www.lua.org/manual/5.3/manual.html

Creates a copy of a string with pattern replacements and pushes it onto the stack.

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

--------------------------------

### Coroutine execution output

Source: https://www.lua.org/manual/5.3/manual.html

The expected output produced by running the coroutine execution example.

```text
     co-body 1       10
     foo     2
     main    true    4
     co-body r
     main    true    11      -9
     co-body x       y
     main    true    10      end
     main    false   cannot resume dead coroutine
```

--------------------------------

### Semicolon usage for disambiguation

Source: https://www.lua.org/manual/5.3/manual.html

Recommended practice to avoid ambiguity when starting a statement with a parenthesis.

```lua
     ;(print or io.write)('done')
```

--------------------------------

### luaL_newlib

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new table and registers functions from a list.

```c
void luaL_newlib (lua_State *L, const luaL_Reg l[]);
```

```c
(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
```

--------------------------------

### lua_getlocal

Source: https://www.lua.org/manual/5.3/manual.html

Gets information about a local variable of a given activation record or a given function.

```APIDOC
## lua_getlocal

### Description
Gets information about a local variable. If `ar` is a valid activation record, it pushes the variable's value onto the stack and returns its name. If `ar` is `NULL`, it inspects the function at the top of the stack.

### Signature
`const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);`

### Parameters
- **L** (lua_State*) - The Lua state.
- **ar** (const lua_Debug*) - The activation record or `NULL`.
- **n** (int) - The index of the local variable to inspect.

### Returns
- **const char*** - The name of the local variable, or `NULL` if the index is out of range.
```

--------------------------------

### io.open (filename [, mode])

Source: https://www.lua.org/manual/5.3/manual.html

Opens a file in the specified mode and returns a new file handle on success.

```APIDOC
## io.open (filename [, mode])

### Description
Opens a file in the mode specified by the mode string. Returns a file handle on success.

### Parameters
- **filename** (string) - Required - The path to the file to open.
- **mode** (string) - Optional - The mode to open the file in ('r', 'w', 'a', 'r+', 'w+', 'a+'). Can include 'b' for binary mode.
```

--------------------------------

### luaL_dostring

Source: https://www.lua.org/manual/5.3/manual.html

Loads and runs a string.

```APIDOC
## int luaL_dostring (lua_State *L, const char *str)

### Description
Loads and runs the given string. Returns false if there are no errors or true in case of errors.
```

--------------------------------

### luaL_buffinitsize

Source: https://www.lua.org/manual/5.3/manual.html

Initializes a buffer and preallocates space.

```APIDOC
## char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz)

### Description
Equivalent to the sequence `luaL_buffinit` and `luaL_prepbuffsize`.

### Parameters
- **L** (lua_State *) - Required - The Lua state.
- **B** (luaL_Buffer *) - Required - The buffer to initialize.
- **sz** (size_t) - Required - The size to preallocate.
```

--------------------------------

### Valid float constants

Source: https://www.lua.org/manual/5.3/manual.html

Examples of valid float constants in Lua, including those with exponents and hexadecimal notation.

```lua
     3.0     3.1416     314.16e-2     0.31416E1     34e1
     0x0.1E  0xA23p-4   0X1.921FB54442D18P+1

```

--------------------------------

### luaL_newlibtable

Source: https://www.lua.org/manual/5.3/manual.html

Creates a table optimized for a specific list of functions.

```c
void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);
```

--------------------------------

### luaL_buffinit

Source: https://www.lua.org/manual/5.3/manual.html

Initializes a buffer variable. Does not allocate memory.

```c
void luaL_buffinit (lua_State *L, luaL_Buffer *B);
```

--------------------------------

### luaL_buffinitsize

Source: https://www.lua.org/manual/5.3/manual.html

Initializes a buffer and preallocates space of size sz.

```c
char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);
```

--------------------------------

### lua_Alloc type and implementation

Source: https://www.lua.org/manual/5.3/manual.html

Defines the memory-allocation function type for Lua states and provides a simple implementation example.

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

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

--------------------------------

### Get upvalue identifier with lua_upvalueid

Source: https://www.lua.org/manual/5.3/manual.html

Returns a unique identifier for an upvalue to check if different closures share the same upvalue.

```c
void *lua_upvalueid (lua_State *L, int funcindex, int n);
```

--------------------------------

### Goto statement syntax

Source: https://www.lua.org/manual/5.3/manual.html

Syntax definitions for the goto statement and labels.

```Lua
	stat ::= **goto** Name
	stat ::= label
	label ::= ‘**::**’ Name ‘**::**’
```

--------------------------------

### string.pack (fmt, v1, v2, ···)

Source: https://www.lua.org/manual/5.3/manual.html

Returns a binary string containing the values v1, v2, etc. packed according to the format string fmt.

```APIDOC
## string.pack (fmt, v1, v2, ···)

### Description
Returns a binary string containing the values v1, v2, etc. packed (serialized in binary form) according to the format string fmt.
```

--------------------------------

### string.pack(fmt, v1, v2, ...)

Source: https://www.lua.org/manual/5.3/manual.html

Packs values into a binary string based on the provided format string.

```APIDOC
## string.pack(fmt, v1, v2, ...)

### Description
Returns a binary string containing the values v1, v2, etc., serialized according to the format string fmt.

### Parameters
- **fmt** (string) - Required - The format string describing the layout.
- **v1, v2, ...** (values) - Required - The values to be packed into the binary string.
```

--------------------------------

### luaL_requiref

Source: https://www.lua.org/manual/5.3/manual.html

Loads a module by calling the provided open function and storing the result in package.loaded. Optionally sets the module in the global namespace.

```c
void luaL_requiref (lua_State *L, const char *modname,
                    lua_CFunction openf, int glb);
```

--------------------------------

### Implementing lua_pcallk for yielding

Source: https://www.lua.org/manual/5.3/manual.html

Replacing lua_pcall with lua_pcallk to register the continuation function k for handling yields or errors.

```c
     int original_function (lua_State *L) {
       ...     /* code 1 */
       return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
     }
```

--------------------------------

### lua_pushlightuserdata

Source: https://www.lua.org/manual/5.3/manual.html

Pushes a light userdata (a void pointer) onto the stack. Light userdata are not garbage collected.

```c
void lua_pushlightuserdata (lua_State *L, void *p);
```

--------------------------------

### require(modname)

Source: https://www.lua.org/manual/5.3/manual.html

Loads the given module by searching through package.searchers. If the module is already loaded, it returns the cached value from package.loaded.

```APIDOC
## require(modname)

### Description
Loads the given module. The function checks package.loaded to see if the module is already loaded; if not, it iterates through package.searchers to find a loader.

### Parameters
- **modname** (string) - Required - The name of the module to load.
```

--------------------------------

### io.input ([file])

Source: https://www.lua.org/manual/5.3/manual.html

Sets or retrieves the default input file handle.

```APIDOC
## io.input ([file])

### Description
Sets the default input file to the provided filename or file handle. If called without arguments, returns the current default input file.
```

--------------------------------

### luaL_newlib

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new table and registers functions from a list.

```APIDOC
## void luaL_newlib (lua_State *L, const luaL_Reg l[]);

### Description
Creates a new table and registers there the functions in list l.
```

--------------------------------

### load (chunk [, chunkname [, mode [, env]]])

Source: https://www.lua.org/manual/5.3/manual.html

Loads a chunk of Lua code.

```APIDOC
## load (chunk [, chunkname [, mode [, env]]])

### Description
Loads a chunk from a string or a function. If there are no syntactic errors, returns the compiled chunk as a function; otherwise, returns nil plus the error message.
```

--------------------------------

### io.output ([file])

Source: https://www.lua.org/manual/5.3/manual.html

Sets or retrieves the default output file handle.

```APIDOC
## io.output ([file])

### Description
Sets the default output file to the provided file handle. If called without arguments, returns the current default output file.
```

--------------------------------

### lua_pushlightuserdata

Source: https://www.lua.org/manual/5.3/manual.html

Pushes a light userdata onto the stack.

```APIDOC
## void lua_pushlightuserdata (lua_State *L, void *p)

### Description
Pushes a light userdata onto the stack. A light userdata represents a pointer, a void*.
```

--------------------------------

### string.find (s, pattern [, init [, plain]])

Source: https://www.lua.org/manual/5.3/manual.html

Looks for the first match of pattern in the string s.

```APIDOC
## string.find (s, pattern [, init [, plain]])

### Description
Looks for the first match of pattern in the string s. If it finds a match, then find returns the indices of s where this occurrence starts and ends; otherwise, it returns nil.
```

--------------------------------

### luaL_loadfile

Source: https://www.lua.org/manual/5.3/manual.html

Loads a file as a Lua chunk, equivalent to luaL_loadfilex with mode NULL.

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

--------------------------------

### os.date()

Source: https://www.lua.org/manual/5.3/manual.html

Returns a string or a table containing date and time, formatted according to the given string format.

```APIDOC
## os.date([format [, time]])

### Description
Returns a string or a table containing date and time, formatted according to the given string format.

### Parameters
- **format** (string) - Optional - The format string for the date/time.
- **time** (number) - Optional - The time value to be formatted.
```

--------------------------------

### lua_rawgetp

Source: https://www.lua.org/manual/5.3/manual.html

Pushes onto the stack the value t[k], where t is the table at the given index and k is the pointer p represented as a light userdata. The access is raw and does not invoke the __index metamethod.

```APIDOC
## int lua_rawgetp (lua_State *L, int index, const void *p);

### Description
Pushes onto the stack the value t[k], where t is the table at the given index and k is the pointer p represented as a light userdata. The access is raw; that is, it does not invoke the __index metamethod.

### Returns
int - The type of the pushed value.
```

--------------------------------

### luaL_openlibs

Source: https://www.lua.org/manual/5.3/manual.html

Opens all standard Lua libraries into the given state.

```c
void luaL_openlibs (lua_State *L);
```

--------------------------------

### luaL_openlibs

Source: https://www.lua.org/manual/5.3/manual.html

Opens all standard Lua libraries.

```APIDOC
## void luaL_openlibs (lua_State *L);

### Description
Opens all standard Lua libraries into the given state.
```

--------------------------------

### luaL_newstate

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new Lua state.

```APIDOC
## lua_State *luaL_newstate (void);

### Description
Creates a new Lua state. It calls `lua_newstate` with an allocator based on the standard C `realloc` function and then sets a panic function that prints an error message to the standard error output in case of fatal errors. Returns the new state, or `NULL` if there is a memory allocation error.
```

--------------------------------

### Table constructor syntax

Source: https://www.lua.org/manual/5.3/manual.html

The general syntax for table constructors in Lua.

```lua
	tableconstructor ::= ‘**{**’ [fieldlist] ‘**}**’
	fieldlist ::= field {fieldsep field} [fieldsep]
	field ::= ‘**[**’ exp ‘**]**’ ‘**=**’ exp | Name ‘**=**’ exp | exp
	fieldsep ::= ‘**,**’ | ‘**;**’

```

--------------------------------

### debug.getregistry()

Source: https://www.lua.org/manual/5.3/manual.html

Returns the registry table.

```APIDOC
## debug.getregistry()

### Description
Returns the registry table.
```

--------------------------------

### lua_rawgetp

Source: https://www.lua.org/manual/5.3/manual.html

Pushes the value t[p] onto the stack where t is the table at index and p is a light userdata pointer. Access is raw and does not invoke metamethods.

```c
int lua_rawgetp (lua_State *L, int index, const void *p);
```

--------------------------------

### luaL_requiref

Source: https://www.lua.org/manual/5.3/manual.html

Loads a module by calling an open function and storing the result in package.loaded.

```APIDOC
## luaL_requiref

### Signature
void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb);

### Description
If modname is not already present in package.loaded, this function calls openf with modname as an argument and sets the result in package.loaded[modname]. If glb is true, it also stores the module in the global table under modname. A copy of the module is left on the stack.
```

--------------------------------

### package.searchpath(name, path [, sep [, rep]])

Source: https://www.lua.org/manual/5.3/manual.html

Searches for a given name in a given path using template substitution.

```APIDOC
## package.searchpath(name, path [, sep [, rep]])

### Description
Searches for the given `name` in the given `path`. A path is a string containing a sequence of templates separated by semicolons.

### Parameters
- **name** (string) - Required - The name of the module to search for.
- **path** (string) - Required - A string containing a sequence of templates separated by semicolons.
- **sep** (string) - Optional - The separator character in the module name (default is a dot).
- **rep** (string) - Optional - The replacement character for the separator (default is the system's directory separator).

### Response
- **Returns** (string) - The resulting name of the first file that it can open in read mode.
- **Returns** (nil, string) - Returns nil plus an error message if no file succeeds.
```

--------------------------------

### loadfile ([filename [, mode [, env]]])

Source: https://www.lua.org/manual/5.3/manual.html

Loads a chunk from a file.

```APIDOC
## loadfile ([filename [, mode [, env]]])

### Description
Similar to load, but gets the chunk from file filename or from the standard input if no file name is given.
```

--------------------------------

### luaL_newlibtable

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new table optimized for a list of functions.

```APIDOC
## void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);

### Description
Creates a new table with a size optimized to store all entries in the array l. Intended to be used in conjunction with luaL_setfuncs.
```

--------------------------------

### luaL_newmetatable

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new metatable in the registry for userdata.

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

--------------------------------

### lua_pushglobaltable

Source: https://www.lua.org/manual/5.3/manual.html

Pushes the global environment onto the stack.

```APIDOC
## void lua_pushglobaltable (lua_State *L)

### Description
Pushes the global environment onto the stack.
```

--------------------------------

### lua_pushvfstring

Source: https://www.lua.org/manual/5.3/manual.html

Equivalent to lua_pushfstring, but accepts a va_list for arguments.

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

--------------------------------

### Parameter list syntax

Source: https://www.lua.org/manual/5.3/manual.html

The syntax for defining function parameters, including varargs.

```lua
	parlist ::= namelist [‘**,**’ ‘**...**’] | ‘**...**’
```

--------------------------------

### luaL_newstate

Source: https://www.lua.org/manual/5.3/manual.html

Creates a new Lua state with a default allocator and panic function.

```c
lua_State *luaL_newstate (void);
```

--------------------------------

### Function definition syntax

Source: https://www.lua.org/manual/5.3/manual.html

The formal syntax for defining a function and its body.

```lua
	functiondef ::= **function** funcbody
	funcbody ::= ‘**(**’ [parlist] ‘**)**’ block **end**
```

--------------------------------

### lua_newuserdata

Source: https://www.lua.org/manual/5.3/manual.html

Allocates a new block of memory and pushes a full userdata onto the stack.

```c
void *lua_newuserdata (lua_State *L, size_t size);
```

--------------------------------

### luaL_pushresultsize

Source: https://www.lua.org/manual/5.3/manual.html

Combines luaL_addsize and luaL_pushresult.

```c
void luaL_pushresultsize (luaL_Buffer *B, size_t sz);
```

--------------------------------

### Return statement syntax

Source: https://www.lua.org/manual/5.3/manual.html

Syntax definition for the return statement.

```Lua
	stat ::= **return** [explist] [‘**;**’]
```

--------------------------------

### luaL_loadfilex

Source: https://www.lua.org/manual/5.3/manual.html

Loads a file as a Lua chunk.

```APIDOC
## int luaL_loadfilex (lua_State *L, const char *filename, const char *mode);

### Description
Loads a file as a Lua chunk. If filename is NULL, it loads from standard input. Returns the same results as lua_load, with an extra error code LUA_ERRFILE for file-related errors.
```

--------------------------------

### lua_rawgeti

Source: https://www.lua.org/manual/5.3/manual.html

Performs raw table access with an integer key.

```APIDOC
## int lua_rawgeti (lua_State *L, int index, lua_Integer n)

### Description
Pushes onto the stack the value t[n], where t is the table at the given index. The access is raw.
```

--------------------------------

### lua_pushfstring

Source: https://www.lua.org/manual/5.3/manual.html

Pushes a formatted string onto the stack.

```APIDOC
## const char *lua_pushfstring (lua_State *L, const char *fmt, ...)

### Description
Pushes onto the stack a formatted string and returns a pointer to this string. It is similar to the ISO C function sprintf.
```

--------------------------------

### luaL_loadfilex

Source: https://www.lua.org/manual/5.3/manual.html

Loads a file as a Lua chunk, supporting custom loading modes.

```c
int luaL_loadfilex (lua_State *L, const char *filename,
                                            const char *mode);
```

--------------------------------

### string.packsize (fmt)

Source: https://www.lua.org/manual/5.3/manual.html

Returns the size of a string resulting from string.pack with the given format.

```APIDOC
## string.packsize (fmt)

### Description
Returns the size of a string resulting from string.pack with the given format. The format string cannot have the variable-length options 's' or 'z'.
```

--------------------------------

### Method definition syntax

Source: https://www.lua.org/manual/5.3/manual.html

The colon syntax for defining methods with an implicit self parameter.

```lua
     function t.a.b.c:f (_params_) _body_ end
```

```lua
     t.a.b.c.f = function (self, _params_) _body_ end
```
Tokens:
Raw