Shulou(Shulou.com)06/02 Report--

This article mainly introduces the relevant knowledge of "what are the common functions of Lua". The editor shows you the operation process through an actual case, and the operation method is simple, fast and practical. I hope this article "what are the common functions of Lua" can help you solve the problem.

Lua is a lightweight and compact scripting language written in the standard C language and open in source code. It is designed to be embedded in the application so as to provide flexible extension and customization for the application.

Lua_pushnil

Void lua_pushnil (lua_State * L)

Put a nil on the stack.

Lua_pushnumber

Void lua_pushnumber (lua_State * L, lua_Number n)

Stack a number n.

Lua_pushstring

Void lua_pushstring (lua_State * L, const char * s)

Stack a zero-ending string pointed to by the pointer s. Lua makes a memory copy (or reuse a copy) of the string, so when the memory function at s returns, it can be released or reused for other purposes. A string cannot contain zero characters; the first zero character encountered is considered the end of the string.

Lua_pushthread

Int lua_pushthread (lua_State * L)

Stack the threads provided in L. Returns 1 if this thread is the main thread of the current state machine.

Lua_pushvalue

Void lua_pushvalue (lua_State * L, int index)

Make a copy of the element at a given valid index on the stack.

Lua_pushvfstring

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

Is equivalent to lua_pushfstring, but receives parameters with va_list instead of a variable number of actual parameters.

Lua_rawequal

Int lua_rawequal (lua_State * L, int index1, int index2)

Returns 1 if the values at the two indexes index1 and index2 are simply equal (without calling the meta-method). Otherwise, 0 is returned. Returns 0 if any of the indexes are invalid.

Lua_rawget

Void lua_rawget (lua_State * L, int index)

Similar to lua_gettable, but with a direct access (without triggering meta-methods).

Lua_rawgeti

Void lua_rawgeti (lua_State * L, int index, int n)

Stack the value of t [n], where t is a value at a given index index. This is a direct access; that is, it does not trigger meta-methods.

Lua_rawset

Void lua_rawset (lua_State * L, int index)

Similar to lua_settable, but with a direct assignment (without triggering meta-methods).

Lua_rawseti

Void lua_rawseti (lua_State * L, int index, int n)

Equivalent to t [n] = v, where t refers to a value at a given index index, and v is the value at the top of the stack.

Function will pop this value off the stack. The assignment operation is straightforward; that is, the meta-method is not triggered.

Lua_Reader

Typedef const char * (* lua_Reader) (lua_State * L, void * data, size_t * size)

The reader function used by lua_load. Every time it needs a new chunk, lua_load calls the reader, passing in a parameter data each time. The reader needs to return a pointer to a block of memory containing the new chunk and set the size to the size of that block of memory. The memory block must exist until the next function is called. The reader can indicate the end of the chunk by returning a NULL. The reader may return multiple blocks, each of which can have any size greater than zero.

Lua_register

Void lua_register (lua_State * L, const char * name, lua_CFunction f)

Set the C function f to the global variable name. It is defined by a macro:

# define lua_register (LMagnef)\ (lua_pushcfunction (L, f), lua_setglobal (LMagne))

Lua_remove

Void lua_remove (lua_State * L, int index)

Remove an element from a given valid index and remove all elements from the index to fill the gap. This function cannot be called with a pseudo index because the pseudo index does not point to the location on the real stack.

Lua_replace

Void lua_replace (lua_State * L, int index)

Move the top element of the stack to the given location (and pop up the top element of the stack) without moving any elements (so the value at that location is overwritten).

Lua_resume

Int lua_resume (lua_State * L, int narg)

Starts or continues a coroutine in a given thread.

To start a coroutine, first create a new thread (see lua_newthread); then press the main function and several parameters on the stack of the new thread; and finally call lua_resume to set the narg to the number of arguments. This call will return when the coroutine is suspended or after it finishes running. When the function returns, there are all the values passed to lua_yield in the stack, or all the return values of the main function. Lua_resume returns LUA_YIELD if coroutine is switched, and 0 when coroutine finishes running without any errors. Return the error code if there is an error (see lua_pcall). In the event of an error, the stack is not expanded, so you can use debug API to handle it. The error message is placed at the top of the stack. To continue running a coroutine, you push the return value that needs to be passed to yield as a result onto the stack, and then call lua_resume.

Lua_setallocf

Void lua_setallocf (lua_State * L, lua_Alloc f, void * ud)

Replace the allocator function of the specified state machine with f with pointer ud.

Lua_setfenv

Int lua_setfenv (lua_State * L, int index)

A new environment that pops a table off the stack and sets it to the value at the specified index. If the value at the specified index is neither a function nor a thread or userdata, lua_setfenv returns 0, otherwise 1.

Lua_setfield

Void lua_setfield (lua_State * L, int index, const char * k)

Do an operation equivalent to t [k] = v, where t is the value at the given valid index index, and v is the value at the top of the stack.

This function will pop this value off the stack. As in Lua, this function may trigger a meta-method of a "newindex" event (see §2.8).

Lua_setglobal

Void lua_setglobal (lua_State * L, const char * name)

Pop up a value from the stack and set it to the global variable name. It is defined by a macro:

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

Lua_setmetatable

Int lua_setmetatable (lua_State * L, int index)

Pops a table off the stack and sets it to the metatable of the value at the given index.

Lua_settable

Void lua_settable (lua_State * L, int index)

Do an operation equivalent to t [k] = v, where t is the value at a given valid index index, v is the value at the top of the stack, and k is the value below the top of the stack.

This function pops the key and value off the stack. As in Lua, this function may trigger the meta-method of the "newindex" event (see §2.8).

Lua_settop

Void lua_settop (lua_State * L, int index)

Parameter allows you to pass in any acceptable index as well as 0. It will set the top of the stack to this index. If the top of the new stack is larger than the original, the new elements beyond the stack will be filled with nil. If index is 0, remove all elements on the stack.

Lua_State

Typedef struct lua_State lua_State

An opaque structure that holds the state of the entire Lua interpreter. The Lua library is completely reentrant: it doesn't have any global variables. (translation note: in terms of C grammar, this is not always the case. For example, a static global variable dummynode_ is used in the implementation of table, but this does not affect reentrancy when used correctly. It's just that in case you mistakenly link to the lua library and accidentally have two lua library implementation code in the same process space, multiple dummynode_ addresses can cause some problems. ) all the information is stored in this structure.

The pointer to this state machine must be passed to each library function as the first parameter. The exception is lua_newstate, which creates a Lua state machine from scratch.

Lua_status

Int lua_status (lua_State * L)

Returns the state of thread L.

The normal thread state is 0. When the thread finishes execution or an error occurs, the status value is the error code. If the thread is suspended, the status is LUA_YIELD.

Lua_toboolean

Int lua_toboolean (lua_State * L, int index)

Converts the Lua value at the specified index to a boolean value in C (0 or 1). As with all tests done in Lua, lua_toboolean returns any value that is different from false and nil as 1; otherwise, it returns 0. If called with an invalid index, it will also return 0. If you want to receive only the real boolean value, you need to use lua_isboolean to test the type of the value. )

Lua_tocfunction

Lua_CFunction lua_tocfunction (lua_State * L, int index)

Converts the Lua value at a given index to a C function. This value must be a C function; if not, return NULL.

Lua_tointeger

Lua_Integer lua_tointeger (lua_State * L, int idx)

Converts the Lua value at a given index to a signed integer type such as lua_Integer. The Lua value must be a number or a string that can be converted to a number (see §2.2.1); otherwise, lua_tointeger returns 0.

If the number is not an integer, the way to truncate the decimal part is not clearly defined.

Lua_tolstring

Const char * lua_tolstring (lua_State * L, int index, size_t * len)

Converts the Lua value at a given index to a C string. If len is not NULL, it also sets the string length to * len. The Lua value must be a string or a number; otherwise, it returns NULL. If the value is a number, lua_tolstring also converts the actual type of that value in the stack to a string. When traversing a table, lua_tolstring is applied to the key, and this transformation may cause lua_next to make a mistake. )

Lua_tolstring returns the string in the Lua state machine to align the pointer. This string always guarantees that the last character (required by C) is zero ('\ 0'), and it allows multiple such zeros in the string. Because garbage collection can occur in Lua, there is no guarantee that the pointer returned by lua_tolstring will remain valid after the corresponding value is removed from the stack.

Lua_tonumber

Lua_Number lua_tonumber (lua_State * L, int index)

Converts the Lua value at a given index to a C type such as lua_Number (see lua_Number). The Lua value must be a number or a string that can be converted to a number (see §2.2.1); otherwise, lua_tonumber returns 0.

Lua_topointer

Const void * lua_topointer (lua_State * L, int index)

Converts the value at a given index to a normal C pointer (void*). This value can be a userdata, table, thread or a function; otherwise, lua_topointer returns NULL. Different objects have different pointers. There is no way to turn the pointer back to the original type.

This function is usually used only to generate debug information.

Lua_tostring

Const char * lua_tostring (lua_State * L, int index)

Equivalent to lua_tolstring, and the parameter len is set to NULL.

Lua_tothread

Lua_State * lua_tothread (lua_State * L, int index)

Converts the value at a given index to a Lua thread represented by lua_State*. This value must be a thread; otherwise the function returns NULL.

Lua_touserdata

Void * lua_touserdata (lua_State * L, int index)

If the value at the given index is a complete userdata, the function returns the address of the memory block. If the value is a light userdata, the pointer it represents is returned. Otherwise, return NULL.

Lua_type

Int lua_type (lua_State * L, int index)

Returns the type of the value at the given index, or LUA_TNONE when the index is invalid (that is, an index that points to an empty position on the stack). The type returned by lua_type is a number of constants defined in lua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD, LUA_TLIGHTUSERDATA.

Lua_typename

Const char * lua_typename (lua_State * L, int tp)

Returns the name of the type represented by tp, which tp must be one of the values that lua_type may return.

Lua_Writer

Typedef int (lua_Writer) (lua_State L, const void p, size_t sz, void ud)

The writer function used by lua_dump. Every time lua_dump produces a new chunk, it invokes the writer. Pass in the cache to write to (p) and its size (sz), as well as the parameter data for lua_dump.

The writer returns an error code: 0 indicates no error; all other values indicate an error and causes lua_dump to stop calling the writer again.

Lua_xmove

Void lua_xmove (lua_State * from, lua_State * to, int n)

Pass values from different threads under the same global state machine.

This function pops n values from the from stack and pushes them into the to stack.

Lua_yield

Int lua_yield (lua_State * L, int nresults)

Cut out a coroutine.

This function can only be called in the return expression of a C function. As follows:

Return lua_yield (L, nresults)

When a C function calls lua_yield like this, the running coroutine is suspended from the run, and the call to lua_resume that starts the coroutine returns. The parameter nresults refers to the number of results that need to be returned in the stack, and these return values are passed to lua_resume.

3.8-debugging Interfac

Lua has no built-in debugging facilities. Instead, some function interfaces and hooks are provided. Using these interfaces, you can make different types of debuggers, performance analyzers, or other tools that require "internal information" from the interpreter.

Lua_Debug

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 upvalue / int linedefined; / (S) / int lastlinedefined; / (S) / char short_ SRC [Lua _ IDSIZE] / (s) / / Private part * / other domains} lua_Debug

A structure that carries all kinds of information about functions in an activity. Lua_getstack only fills in the private parts of this structure, which will be used later. If you call lua_getinfo, you can fill in the fields in the lua_Debug that have useful information.

Each domain in lua_Debug has the following meanings:

Source: if the function is defined in a string, source is the string. If the function is defined in a file, source is a file name that starts with'@'. Short_src: a "printable version" of source for error messages. Linedefined: the line number at the beginning of the function definition. Lastlinedefined: the line number at the end of the function definition. What: a string "Lua" if the function is a Lua function, "C" if it is a C function, "main" if it is the body of a chunk, and "tail" if it is a function with a tail call. In other cases, Lua has no other information about the function. Currentline: the line on which a given function is executing. When the line number information is not available, currentline is set to-1. Name: a reasonable name for a given function. Because functions in Lua are also values, they don't have fixed names: some functions may be values of global compound variables, others may simply be stored in a table. The lua_getinfo function checks that the function is called in this way to find a suitable name. If it cannot find a name, name is set to NULL. Namewhat: a solid name domain. The value of namewhat can be "global", "local", "method", "field", "upvalue", or "" (empty string). It depends on how the function is called. (Lua uses an empty string to indicate that none of the other options match) nups: the number of upvalue of the function. Lua_gethook

Lua_Hook lua_gethook (lua_State * L)

Returns the current hook function.

Lua_gethookcount

Int lua_gethookcount (lua_State * L)

Returns the current hook count.

Lua_gethookmask

Int lua_gethookmask (lua_State * L)

Returns the current hook mask (mask).

Lua_getinfo

Int lua_getinfo (lua_State * L, const char * what, lua_Debug * ar)

Returns information about a specified function or function call.

When used to get information about a function call, the parameter ar must be a valid record of activity. This record can be a parameter obtained from a previous call to lua_getstack or by a hook (see lua_Hook).

To get information about a function, you can push the function onto the stack and start the what string with the character'>'. In this case, lua_getinfo pops the function from the top of the stack. For example, to know in which line the function f is defined, you can write the following code:

Lua_Debug ar; lua_getfield (L, LUA_GLOBALSINDEX, "f"); / * take the global variable'f'* / lua_getinfo (L, "> S", & ar); printf ("% d\ n", ar.linedefined)

Each character in the what string filters out some fields in the structure ar structure to populate or push a value onto the stack:

Name and namewhat fields are populated; slots: source, short_src,linedefined,lastlinedefined, and what fields are populated; currentline fields are populated; nups fields are populated; functions are pushed into the stack at the specified level while running; (translation note: generally used to obtain information in function calls, and the level is provided by private parts in ar. If used to get a static function, the specified function is pushed back onto the stack directly, but this usually doesn't make much sense. ) 'Lock: push a table into the stack, and the integer index in this table is used to describe which lines in the function are valid rows. A valid line refers to a line with actual code, that is, a line where you can place a breakpoint. Invalid lines include blank lines and lines with only comments. )

An error in this function returns 0 (for example, there is an invalid option in what).

Lua_getlocal

Const char * lua_getlocal (lua_State * L, lua_Debug * ar, int n)

Gets information about a local variable from a given activity record. The parameter ar must be a valid active record. This record can be a parameter obtained from a previous call to lua_getstack or by a hook (see lua_Hook). Index n is used to select which local variable to review (1 represents the first parameter or the first active local variable, and so on, until the last local variable). Lua_getlocal pushes the value of the variable onto the stack and returns its name.

Variables that begin with'('(positive parentheses) refer to internal variables (loop control variables, temporary variables, C function local variables).

Returns NULL (nothing is pressed) when the index is greater than the number of local variables.

Lua_getstack

Int lua_getstack (lua_State * L, int level, lua_Debug * ar)

Gets information about the runtime stack of the interpreter.

This function fills in part of the lua_Debug structure with the activity record of the function at a given level that is running. Level 0 represents the currently running function, and the function at level 1 is the one that invokes the level n function. Lua_getstack returns 1 if there are no errors, and 0 when the level passed in by the call is greater than the stack depth.

Lua_getupvalue

Const char * lua_getupvalue (lua_State * L, int funcindex, int n)

Get the upvalue information of a closure. For the Lua function, upvalue is the external local variable that the function needs to use, so these variables are included in the closure. Lua_getupvalue gets the nth upvalue, pushes the value of this upvalue into the stack, and returns its name. The funcindex points to the location of the closure on the stack. Because upvalue is valid throughout the function, they have no special order. Therefore, they are numbered alphabetically. )

When the index number is larger than the number of upvalue, it returns NULL (and nothing is pressed) for the C function, which uses the empty string "" to represent the names of all upvalue.

Lua_Hook

Typedef void (* lua_Hook) (lua_State * L, lua_Debug * ar)

The type of hook function used for debugging.

Whenever the hook is called, the event field in its parameter ar is set to the event that triggers the hook. Lua defines these events as the following constants: LUA_HOOKCALL,LUA_HOOKRET, LUA_HOOKTAILRET,LUA_HOOKLINE, andLUA_HOOKCOUNT. In addition, for the line event, the currentline domain is also set. To get other fields in ar, the hook must call lua_getinfo. For return events, the normal value of event may be LUA_HOOKRET or LUA_HOOKTAILRET. In the latter case, Lua simulates a return event for the tail call to a function; calling lua_getinfo has no effect on this simulated return event.

When Lua runs inside a hook, it blocks other calls to the hook. That is, if Lua is called back into a hook function to execute a function or a chunk, this execution will not trigger any hooks.

Lua_sethook

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

Set up a debug hook function.

The parameter f is a hook function. Mask specifies which events will be called: it consists of the following set of bit constants LUA_MASKCALL,LUA_MASKRET, LUA_MASKLINE, and LUA_MASKCOUNT. The parameter count makes sense only if LUA_MASKCOUNT is included in the mask. For each event, the case in which the hook is called is explained as follows:

Call hook: called when the interpreter calls a function. The hook will be called after Lua enters a new function and before the function takes parameters. Return hook: called when the interpreter returns from a function. The hook will be called the moment before Lua leaves the function. You do not have access to the values returned by the function. (translation note: the original (You have no access to the values to be returned by the function) so. However, the term "no right to access" is open to question. In some cases you can access some local variables named (* temporary), and the last (* temporary) variable in the index refers to the return value. However, because Lua makes some optimizations for special cases, such as directly returning a named local variable, then the corresponding (* temporary) variable cannot be found. In essence, the return value must exist in the local variable at the moment, and you can access it, but you can't determine which one it is. As for other local variables in the function body at this time, it is not guaranteed to be valid. From the moment you enter the return hook, you have actually exited the internal operation of the function, and the part of the local variable space occupied by the return value may be changed due to the reuse of them by the hook itself. Line hook: called when the interpreter is ready to start executing a new line of code, or when it jumps into that line of code (even if it jumps within the same line). This event occurs only when Lua executes a Lua function. Count hook: called after each count instruction executed by the interpreter. This event occurs only when Lua executes a Lua function. )

Hooks can be masked by setting mask to zero.

Lua_setlocal

Const char * lua_setlocal (lua_State * L, lua_Debug * ar, int n)

Sets the value of a local variable in a given activity record. The parameter ar is the same as in n and lua_getlocal (see lua_getlocal). Lua_setlocal assigns the value at the top of the stack to the variable and then returns the name of the variable. It pops the value off the top of the stack.

Returns NULL (nothing pops up) when the index is greater than the number of local variables.

Lua_setupvalue

Const char * lua_setupvalue (lua_State * L, int funcindex, int n)

Sets the value of upvalue for closure. It pops up the value at the top of the stack and assigns it to upvalue and returns the name of upvalue. The parameter funcindex is the same as in n and lua_getupvalue (see lua_getupvalue).

Returns NULL (nothing pops up) when the index is greater than the number of upvalue.

This is the end of the introduction on "what are the common functions of Lua". Thank you for reading. If you want to know more about the industry, you can follow the industry information channel. The editor will update different knowledge points for you every day.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.