精华内容
下载资源
问答
  • Lua 常用函数

    2020-11-28 23:39:23
    lua_getallocf lua_Alloc lua_getallocf (lua...返回给定状态机的内存分配器函数。如果ud不是NULL,Lua 把调用lua_newstate时传入的那个指针放入*ud。 lua_getfenv void lua_getfenv (lua_State *L, int ind...

    本文转载于:https://blog.csdn.net/xuzhonghai/article/details/7239195

     

    lua_getallocf

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

    返回给定状态机的内存分配器函数。如果 ud 不是 NULL ,Lua 把调用lua_newstate 时传入的那个指针放入*ud 。


    lua_getfenv

    void lua_getfenv (lua_State *L, int index);

    把索引处值的环境表压入堆栈。


    lua_getfield

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

    把 t[k] 值压入堆栈,这里的 t 是指有效索引 index 指向的值。在 Lua 中,这个函数可能触发对应 "index" 事件的元方法(参见 §2.8)。


    lua_getglobal

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

    把全局变量 name 里的值压入堆栈。这个是用一个宏定义出来的:

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

    lua_getmetatable

    int lua_getmetatable (lua_State *L, int index);

    把给定索引指向的值的元表压入堆栈。如果索引无效,或是这个值没有元表,函数将返回 0 并且不会向栈上压任何东西。


    lua_gettable

    void lua_gettable (lua_State *L, int index);

    把 t[k] 值压入堆栈,这里的 t 是指有效索引 index 指向的值,而 k 则是栈顶放的值。

    这个函数会弹出堆栈上的 key (把结果放在栈上相同位置)。在 Lua 中,这个函数可能触发对应 "index" 事件的元方法(参见§2.8)。


    lua_gettop

    int lua_gettop (lua_State *L);

    返回栈顶元素的索引。因为索引是从 1 开始编号的,所以这个结果等于堆栈上的元素个数(因此返回 0 表示堆栈为空)。


    lua_insert

    void lua_insert (lua_State *L, int index);

    把栈顶元素插入指定的有效索引处,并依次移动这个索引之上的元素。不要用伪索引来调用这个函数,因为伪索引不是真正指向堆栈上的位置。


    lua_Integer

    typedef ptrdiff_t lua_Integer;

    这个类型被用于 Lua API 接收整数值。

    缺省时这个被定义为 ptrdiff_t ,这个东西通常是机器能处理的最大整数类型。


    lua_isboolean

    int lua_isboolean (lua_State *L, int index);

    当给定索引的值类型为 boolean 时,返回 1 ,否则返回 0 。


    lua_iscfunction

    int lua_iscfunction (lua_State *L, int index);

    当给定索引的值是一个 C 函数时,返回 1 ,否则返回 0 。


    lua_isfunction

    int lua_isfunction (lua_State *L, int index);

    当给定索引的值是一个函数( C 或 Lua 函数均可)时,返回 1 ,否则返回 0 。


    lua_islightuserdata

    int lua_islightuserdata (lua_State *L, int index);

    当给定索引的值是一个 light userdata 时,返回 1 ,否则返回 0 。


    lua_isnil

    int lua_isnil (lua_State *L, int index);

    当给定索引的值是 nil 时,返回 1 ,否则返回 0 。


    lua_isnumber

    int lua_isnumber (lua_State *L, int index);

    当给定索引的值是一个数字,或是一个可转换为数字的字符串时,返回 1 ,否则返回 0 。


    lua_isstring

    int lua_isstring (lua_State *L, int index);

    当给定索引的值是一个字符串或是一个数字(数字总能转换成字符串)时,返回 1 ,否则返回 0 。


    lua_istable

    int lua_istable (lua_State *L, int index);

    当给定索引的值是一个 table 时,返回 1 ,否则返回 0 。


    lua_isthread

    int lua_isthread (lua_State *L, int index);

    当给定索引的值是一个 thread 时,返回 1 ,否则返回 0 。


    lua_isuserdata

    int lua_isuserdata (lua_State *L, int index);

    当给定索引的值是一个 userdata (无论是完整的 userdata 还是 light userdata )时,返回 1 ,否则返回 0 。


    lua_lessthan

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

    如果索引 index1 处的值小于索引 index2 处的值时,返回 1 ;否则返回 0 。其语义遵循 Lua 中的< 操作符(就是说,有可能调用元方法)。如果任何一个索引无效,也会返回 0 。


    lua_load

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

    加载一个 Lua chunk 。如果没有错误, lua_load 把一个编译好的 chunk 作为一个 Lua 函数压入堆栈。否则,压入出错信息。 lua_load 的返回值可以是:

    这个函数仅仅加栽 chunk ;而不会去运行它。

    lua_load 会自动检测 chunk 是文本的还是二进制的,然后做对应的加载操作(参见程序luac)。

    lua_load 函数使用一个用户提供的reader 函数来读取 chunk (参见lua_Reader)。data 参数会被传入读取器函数。

    chunkname 这个参数可以赋予 chunk 一个名字,这个名字被用于出错信息和调试信息(参见§3.8)。


    lua_newstate

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

    创建的一个新的独立的状态机。如果创建不了(因为内存问题)返回 NULL 。参数 f 是一个分配器函数; Lua 将通过这个函数做状态机内所有的内存分配操作。第二个参数 ud ,这个指针将在每次调用分配器时被直接传入。


    lua_newtable

    void lua_newtable (lua_State *L);

    创建一个空 table ,并将之压入堆栈。它等价于 lua_createtable(L, 0, 0) 。


    lua_newthread

    lua_State *lua_newthread (lua_State *L);

    创建一个新线程,并将其压入堆栈,并返回维护这个线程的 lua_State 指针。这个函数返回的新状态机共享原有状态机中的所有对象(比如一些 table),但是它有独立的执行堆栈。

    没有显式的函数可以用来关闭或销毁掉一个线程。线程跟其它 Lua 对象一样是垃圾收集的条目之一。


    lua_newuserdata

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

    这个函数分配分配一块指定大小的内存块,把内存块地址作为一个完整的 userdata 压入堆栈,并返回这个地址。

    userdata 代表 Lua 中的 C 值。完整的 userdata 代表一块内存。它是一个对象(就像 table 那样的对象):你必须创建它,它有着自己的元表,而且它在被回收时,可以被监测到。一个完整的 userdata 只和它自己相等(在等于的原生作用下)。

    当 Lua 通过 gc 元方法回收一个完整的 userdata 时, Lua 调用这个元方法并把 userdata 标记为已终止。等到这个 userdata 再次被收集的时候,Lua 会释放掉相关的内存。


    lua_next

    int lua_next (lua_State *L, int index);

    从栈上弹出一个 key(键),然后把索引指定的表中 key-value(健值)对压入堆栈(指定 key 后面的下一 (next) 对)。如果表中以无更多元素,那么lua_next 将返回 0 (什么也不压入堆栈)。

    典型的遍历方法是这样的:

         /* table 放在索引 't' 处 */
         lua_pushnil(L);  /* 第一个 key */
         while (lua_next(L, t) != 0) {
           /* 用一下 'key' (在索引 -2 处) 和 'value' (在索引 -1 处) */
           printf("%s - %s\n",
                  lua_typename(L, lua_type(L, -2)),
                  lua_typename(L, lua_type(L, -1)));
           /* 移除 'value' ;保留 'key' 做下一次迭代 */
           lua_pop(L, 1);
         }
    

    在遍历一张表的时候,不要直接对 key 调用 lua_tolstring ,除非你知道这个 key 一定是一个字符串。调用 lua_tolstring 有可能改变给定索引位置的值;这会对下一次调用 lua_next 造成影响。


    lua_Number

    typedef double lua_Number;

    Lua 中数字的类型。确省是 double ,但是你可以在 luaconf.h 中修改它。

    通过修改配置文件你可以改变 Lua 让它操作其它数字类型(例如:float 或是 long )。


    lua_objlen

    size_t lua_objlen (lua_State *L, int index);

    返回指定的索引处的值的长度。对于 string ,那就是字符串的长度;对于 table ,是取长度操作符 ('#') 的结果;对于 userdata ,就是为其分配的内存块的尺寸;对于其它值,为 0 。


    lua_pcall

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

    以保护模式调用一个函数。

    nargs 和 nresults 的含义与 lua_call 中的相同。如果在调用过程中没有发生错误, lua_pcall 的行为和 lua_call 完全一致。但是,如果有错误发生的话, lua_pcall 会捕获它,然后把单一的值(错误信息)压入堆栈,然后返回错误码。同 lua_call 一样, lua_pcall 总是把函数本身和它的参数从栈上移除。

    如果 errfunc 是 0 ,返回在栈顶的错误信息就和原始错误信息完全一致。否则,errfunc 就被当成是错误处理函数在栈上的索引。(在当前的实现里,这个索引不能是伪索引。)在发生运行时错误时,这个函数会被调用而参数就是错误信息。错误处理函数的返回值将被lua_pcall 作为出错信息返回在堆栈上。

    典型的用法中,错误处理函数被用来在出错信息上加上更多的调试信息,比如栈跟踪信息 (stack traceback) 。这些信息在lua_pcall 返回后,因为栈已经展开 (unwound) ,所以收集不到了。

    lua_pcall 函数在调用成功时返回 0 ,否则返回以下(定义在lua.h 中的)错误代码中的一个:

    • LUA_ERRRUN: 运行时错误。
    • LUA_ERRMEM: 内存分配错误。 对于这种错,Lua 调用不了错误处理函数。
    • LUA_ERRERR: 在运行错误处理函数时发生的错误。

    lua_pop

    void lua_pop (lua_State *L, int n);

    从堆栈中弹出 n 个元素。


    lua_pushboolean

    void lua_pushboolean (lua_State *L, int b);

    把 b 作为一个 boolean 值压入堆栈。


    lua_pushcclosure

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

    把一个新的 C closure 压入堆栈。

    当创建了一个 C 函数后,你可以给它关联一些值,这样就是在创建一个 C closure (参见 §3.4);接下来无论函数何时被调用,这些值都可以被这个函数访问到。为了将一些值关联到一个 C 函数上,首先这些值需要先被压入堆栈(如果有多个值,第一个先压)。接下来调用lua_pushcclosure 来创建出 closure 并把这个 C 函数压到堆栈上。参数n 告之函数有多少个值需要关联到函数上。lua_pushcclosure 也会把这些值从栈上弹出。


    lua_pushcfunction

    void lua_pushcfunction (lua_State *L, lua_CFunction f);

    将一个 C 函数压入堆栈。这个函数接收一个 C 函数指针,并将一个类型为 function 的 Lua 值压入堆栈。当这个栈顶的值被调用时,将触发对应的 C 函数。

    注册到 Lua 中的任何函数都必须遵循正确的协议来接收参数和返回值(参见 lua_CFunction)。

    lua_pushcfunction 是作为一个宏定义出现的:

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

    lua_pushfstring

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

    把一个格式化过的字符串压入堆栈,然后返回这个字符串的指针。它和 C 函数 sprintf 比较像,不过有一些重要的区别:

    • 摸你需要为结果分配空间: 其结果是一个 Lua 字符串,由 Lua 来关心其内存分配 (同时通过垃圾收集来释放内存)。
    • 这个转换非常的受限。 不支持 flag ,宽度,或是指定精度。 它只支持下面这些: '%%' (插入一个 '%'), '%s' (插入一个带零终止符的字符串,没有长度限制), '%f' (插入一个lua_Number), '%p' (插入一个指针或是一个十六进制数), '%d' (插入一个int), '%c' (把一个int 作为一个字符插入)。

    lua_pushinteger

    void lua_pushinteger (lua_State *L, lua_Integer n);

    把 n 作为一个数字压栈。


    lua_pushlightuserdata

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

    把一个 light userdata 压栈。

    userdata 在 Lua 中表示一个 C 值。 light userdata 表示一个指针。它是一个像数字一样的值:你不需要专门创建它,它也没有独立的 metatable ,而且也不会被收集(因为从来不需要创建)。只要表示的 C 地址相同,两个 light userdata 就相等。


    lua_pushlstring

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

    把指针 s 指向的长度为 len 的字符串压栈。 Lua 对这个字符串做一次内存拷贝(或是复用一个拷贝),因此s 处的内存在函数返回后,可以释放掉或是重用于其它用途。字符串内可以保存有零字符。


    lua_pushnil

    void lua_pushnil (lua_State *L);

    把一个 nil 压栈。


    lua_pushnumber

    void lua_pushnumber (lua_State *L, lua_Number n);

    把一个数字 n 压栈。


    lua_pushstring

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

    把指针 s 指向的以零结尾的字符串压栈。 Lua 对这个字符串做一次内存拷贝(或是复用一个拷贝),因此s 处的内存在函数返回后,可以释放掉或是重用于其它用途。字符串中不能包含有零字符;第一个碰到的零字符会认为是字符串的结束。


    lua_pushthread

    int lua_pushthread (lua_State *L);

    把 L 中提供的线程压栈。如果这个线程是当前状态机的主线程的话,返回 1 。


    lua_pushvalue

    void lua_pushvalue (lua_State *L, int index);

    把堆栈上给定有效处索引处的元素作一个拷贝压栈。


    lua_pushvfstring

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

    等价于 lua_pushfstring,不过是用 va_list 接收参数,而不是用可变数量的实际参数。


    lua_rawequal

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

    如果两个索引 index1 和 index2 处的值简单地相等(不调用元方法)则返回 1 。否则返回 0 。如果任何一个索引无效也返回 0 。


    lua_rawget

    void lua_rawget (lua_State *L, int index);

    类似于 lua_gettable,但是作一次直接访问(不触发元方法)。


    lua_rawgeti

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

    把 t[n] 的值压栈,这里的 t 是指给定索引 index 处的一个值。这是一个直接访问;就是说,它不会触发元方法。


    lua_rawset

    void lua_rawset (lua_State *L, int index);

    类似于 lua_settable,但是是作一个直接赋值(不触发元方法)。


    lua_rawseti

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

    等价于 t[n] = v,这里的 t 是指给定索引 index 处的一个值,而 v 是栈顶的值。

    函数将把这个值弹出栈。赋值操作是直接的;就是说,不会触发元方法。


    lua_Reader

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

    lua_load 用到的读取器函数,每次它需要一块新的 chunk 的时候,lua_load 就调用读取器,每次都会传入一个参数data 。读取器需要返回含有新的 chunk 的一块内存的指针,并把 size 设为这块内存的大小。内存块必须在下一次函数被调用之前一直存在。读取器可以通过返回一个NULL 来指示 chunk 结束。读取器可能返回多个块,每个块可以有任意的大于零的尺寸。


    lua_register

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

    把 C 函数 f 设到全局变量 name 中。它通过一个宏定义:

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

    lua_remove

    void lua_remove (lua_State *L, int index);

    从给定有效索引处移除一个元素,把这个索引之上的所有元素移下来填补上这个空隙。不能用伪索引来调用这个函数,因为伪索引并不指向真实的栈上的位置。


    lua_replace

    void lua_replace (lua_State *L, int index);

    把栈顶元素移动到给定位置(并且把这个栈顶元素弹出),不移动任何元素(因此在那个位置处的值被覆盖掉)。


    lua_resume

    int lua_resume (lua_State *L, int narg);

    在给定线程中启动或继续一个 coroutine 。

    要启动一个 coroutine 的话,首先你要创建一个新线程(参见 lua_newthread );然后把主函数和若干参数压到新线程的堆栈上;最后调用 lua_resume ,把 narg 设为参数的个数。这次调用会在 coroutine 挂起时或是结束运行后返回。当函数返回时,堆栈中会有传给lua_yield 的所有值,或是主函数的所有返回值。如果 coroutine 切换时,lua_resume 返回LUA_YIELD ,而当 coroutine 结束运行且没有任何错误时,返回 0 。如果有错则返回错误代码(参见lua_pcall)。在发生错误的情况下,堆栈没有展开,因此你可以使用 debug API 来处理它。出错信息放在栈顶。要继续运行一个 coroutine 的话,你把需要传给yield 作结果的返回值压入堆栈,然后调用lua_resume 。


    lua_setallocf

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

    把指定状态机的分配器函数换成带上指针 ud 的 f 。


    lua_setfenv

    int lua_setfenv (lua_State *L, int index);

    从堆栈上弹出一个 table 并把它设为指定索引处值的新环境。如果指定索引处的值即不是函数又不是线程或是 userdata ,lua_setfenv 会返回 0 ,否则返回 1 。


    lua_setfield

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

    做一个等价于 t[k] = v 的操作,这里 t 是给出的有效索引index 处的值,而v 是栈顶的那个值。

    这个函数将把这个值弹出堆栈。跟在 Lua 中一样,这个函数可能触发一个 "newindex" 事件的元方法(参见§2.8)。


    lua_setglobal

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

    从堆栈上弹出一个值,并将其设到全局变量 name 中。它由一个宏定义出来:

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

    lua_setmetatable

    int lua_setmetatable (lua_State *L, int index);

    把一个 table 弹出堆栈,并将其设为给定索引处的值的 metatable 。


    lua_settable

    void lua_settable (lua_State *L, int index);

    作一个等价于 t[k] = v 的操作,这里 t 是一个给定有效索引index 处的值,v 指栈顶的值,而 k 是栈顶之下的那个值。

    这个函数会把键和值都从堆栈中弹出。和在 Lua 中一样,这个函数可能触发 "newindex" 事件的元方法(参见§2.8)。


    lua_settop

    void lua_settop (lua_State *L, int index);

    参数允许传入任何可接受的索引以及 0 。它将把堆栈的栈顶设为这个索引。如果新的栈顶比原来的大,超出部分的新元素将被填为nil 。如果index 为 0 ,把栈上所有元素移除。


    lua_State

    typedef struct lua_State lua_State;

    一个不透明的结构,它保存了整个 Lua 解释器的状态。 Lua 库是完全可重入的:它没有任何全局变量。(译注:从 C 语法上来说,也不尽然。例如,在 table 的实现中用了一个静态全局变量 dummynode_ ,但这在正确使用时并不影响可重入性。只是万一你错误链接了 lua 库,不小心在同一进程空间中存在两份 lua 库实现的代码的话,多份 dummynode_ 不同的地址会导致一些问题。)所有的信息都保存在这个结构中。

    这个状态机的指针必须作为第一个参数传递给每一个库函数。 lua_newstate 是一个例外,这个函数会从头创建一个 Lua 状态机。


    lua_status

    int lua_status (lua_State *L);

    返回线程 L 的状态。

    正常的线程状态是 0 。当线程执行完毕或发生一个错误时,状态值是错误码。如果线程被挂起,状态为 LUA_YIELD 。


    lua_toboolean

    int lua_toboolean (lua_State *L, int index);

    把指定的索引处的的 Lua 值转换为一个 C 中的 boolean 值( 0 或是 1 )。和 Lua 中做的所有测试一样,lua_toboolean 会把任何不同于false 和nil 的值当作 1 返回;否则就返回 0 。如果用一个无效索引去调用也会返回 0 。(如果你想只接收真正的 boolean 值,就需要使用lua_isboolean 来测试值的类型。)


    lua_tocfunction

    lua_CFunction lua_tocfunction (lua_State *L, int index);

    把给定索引处的 Lua 值转换为一个 C 函数。这个值必须是一个 C 函数;如果不是就返回 NULL 。


    lua_tointeger

    lua_Integer lua_tointeger (lua_State *L, int idx);

    把给定索引处的 Lua 值转换为 lua_Integer 这样一个有符号整数类型。这个 Lua 值必须是一个数字或是一个可以转换为数字的字符串(参见 §2.2.1);否则,lua_tointeger 返回 0 。

    如果数字不是一个整数,截断小数部分的方式没有被明确定义。


    lua_tolstring

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

    把给定索引处的 Lua 值转换为一个 C 字符串。如果 len 不为 NULL ,它还把字符串长度设到*len 中。这个 Lua 值必须是一个字符串或是一个数字;否则返回返回NULL 。如果值是一个数字,lua_tolstring 还会把堆栈中的那个值的实际类型转换为一个字符串。(当遍历一个表的时候,把lua_tolstring 作用在键上,这个转换有可能导致lua_next 弄错。)

    lua_tolstring 返回 Lua 状态机中字符串的以对齐指针。这个字符串总能保证 ( C 要求的)最后一个字符为零 ('\0') ,而且它允许在字符串内包含多个这样的零。因为 Lua 中可能发生垃圾收集,所以不保证lua_tolstring 返回的指针,在对应的值从堆栈中移除后依然有效。


    lua_tonumber

    lua_Number lua_tonumber (lua_State *L, int index);

    把给定索引处的 Lua 值转换为 lua_Number 这样一个 C 类型(参见 lua_Number )。这个 Lua 值必须是一个数字或是一个可转换为数字的字符串(参见 §2.2.1 );否则,lua_tonumber 返回 0 。


    lua_topointer

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

    把给定索引处的值转换为一般的 C 指针 (void*) 。这个值可以是一个 userdata ,table ,thread 或是一个 function ;否则,lua_topointer 返回NULL 。不同的对象有不同的指针。不存在把指针再转回原有类型的方法。

    这个函数通常只为产生 debug 信息用。


    lua_tostring

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

    等价于 lua_tolstring ,而参数 len 设为 NULL 。


    lua_tothread

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

    把给定索引处的值转换为一个 Lua 线程(由 lua_State* 代表)。这个值必须是一个线程;否则函数返回NULL 。


    lua_touserdata

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

    如果给定索引处的值是一个完整的 userdata ,函数返回内存块的地址。如果值是一个 light userdata ,那么就返回它表示的指针。否则,返回NULL 。


    lua_type

    int lua_type (lua_State *L, int index);

    返回给定索引处的值的类型,当索引无效时则返回 LUA_TNONE (那是指一个指向堆栈上的空位置的索引)。lua_type 返回的类型是一些个在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);

    返回 tp 表示的类型名,这个 tp 必须是 lua_type 可能返回的值中之一。


    lua_Writer

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

    由 lua_dump 用到的写入器函数。每次 lua_dump 产生了一块新的 chunk ,它都会调用写入器。传入要写入的缓存 (p) 和它的尺寸 (sz) ,还有lua_dump 的参数data 。

    写入器会返回一个错误码: 0 表示没有错误;别的值均表示一个错误,并且会让 lua_dump 停止再次调用写入器。


    lua_xmove

    void lua_xmove (lua_State *from, lua_State *to, int n);

    传递 同一个 全局状态机下不同线程中的值。

    这个函数会从 from 的堆栈中弹出 n 个值,然后把它们压入to 的堆栈中。


    lua_yield

    int lua_yield  (lua_State *L, int nresults);

    切出一个 coroutine 。

    这个函数只能在一个 C 函数的返回表达式中调用。如下:

         return lua_yield (L, nresults);
    

    当一个 C 函数这样调用 lua_yield ,正在运行中的 coroutine 将从运行中挂起,然后启动这个 coroutine 用的那次对 lua_resume 的调用就返回了。参数 nresults 指的是堆栈中需要返回的结果个数,这些返回值将被传递给lua_resume 。

    3.8 - 调试接口

    Lua 没有内建的调试设施。取而代之的是提供了一些函数接口和钩子。利用这些接口,可以做出一些不同类型的调试器,性能分析器,或是其它一些需要从解释器中取到“内部信息”的工具。


    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) upvalue 个数 */
      int linedefined;            /* (S) */
      int lastlinedefined;        /* (S) */
      char short_src[LUA_IDSIZE]; /* (S) */
      /* 私有部分 */
      其它域
    } lua_Debug;

    一个用来携带活动中函数的各种信息的结构。 lua_getstack 仅填写这个结构中的私有部分,这些部分以后会用到。调用 lua_getinfo 则可以填上 lua_Debug 中有用信息的那些域。

    lua_Debug 中的各个域有下列含义:

    • source: 如果函数是定义在一个字符串中,source 就是这个字符串。 如果函数定义在一个文件中,source 是一个以 '@' 开头的文件名。
    • short_src: 一个“可打印版本”的 source,用于出错信息。
    • linedefined: 函数定义开始处的行号。
    • lastlinedefined: 函数定义结束处的行号。
    • what: 如果函数是一个 Lua 函数,则为一个字符串 "Lua" ; 如果是一个 C 函数,则为"C"; 如果它是一个 chunk 的主体部分,则为"main"; 如果是一个作了尾调用的函数,则为 "tail" 。 别的情况下,Lua 没有关于函数的别的信息。
    • currentline: 给定函数正在执行的那一行。 当提供不了行号信息的时候,currentline 被设为 -1 。
    • name: 给定函数的一个合理的名字。 因为 Lua 中的函数也是一个值, 所以它们没有固定的名字: 一些函数可能是全局复合变量的值, 另一些可能仅仅只是被保存在一个 table 中。lua_getinfo 函数会检查函数是这样被调用的,以此来找到一个适合的名字。 如果它找不到名字,name 就被设置为NULL 。
    • namewhat: 结实 name 域。 namewhat 的值可以是"global","local""method""field","upvalue", 或是"" (空串)。 这取决于函数怎样被调用。 (Lua 用空串表示其它选项都不符合)
    • nups: 函数的 upvalue 的个数。

    lua_gethook

    lua_Hook lua_gethook (lua_State *L);

    返回当前的钩子函数。


    lua_gethookcount

    int lua_gethookcount (lua_State *L);

    返回当前钩子记数。


    lua_gethookmask

    int lua_gethookmask (lua_State *L);

    返回当前的钩子掩码 (mask) 。


    lua_getinfo

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

    返回一个指定的函数或函数调用的信息。

    当用于取得一次函数调用的信息时,参数 ar 必须是一个有效的活动的记录。这条记录可以是前一次调用lua_getstack 得到的,或是一个钩子 (参见lua_Hook)得到的参数。

    用于获取一个函数的信息时,可以把这个函数压入堆栈,然后把 what 字符串以字符 '>' 起头。(这个情况下,lua_getinfo 从栈顶上弹出函数。)例如,想知道函数f 在哪一行定义的,你可以下下列代码:

         lua_Debug ar;
         lua_getfield(L, LUA_GLOBALSINDEX, "f");  /* 取到全局变量 'f' */
         lua_getinfo(L, ">S", &ar);
         printf("%d\n", ar.linedefined);
    

    what 字符串中的每个字符都筛选出结构 ar 结构中一些域用于填充,或是把一个值压入堆栈:

    • 'n': 填充 name 及 namewhat 域;
    • 'S': 填充 source, short_srclinedefinedlastlinedefined,以及 what 域;
    • 'l': 填充 currentline 域;
    • 'u': 填充 nups 域;
    • 'f': 把正在运行中指定级别处函数压入堆栈; (译注:一般用于获取函数调用中的信息, 级别是由 ar 中的私有部分来提供。 如果用于获取静态函数,那么就直接把指定函数重新压回堆栈, 但这样做通常无甚意义。)
    • 'L': 压一个 table 入栈,这个 table 中的整数索引用于描述函数中哪些行是有效行。 (有效行指有实际代码的行, 即你可以置入断点的行。 无效行包括空行和只有注释的行。)

    这个函数出错会返回 0 (例如,what 中有一个无效选项)。


    lua_getlocal

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

    从给定活动记录中获取一个局部变量的信息。参数 ar 必须是一个有效的活动的记录。这条记录可以是前一次调用lua_getstack 得到的,或是一个钩子 (参见lua_Hook)得到的参数。索引n 用于选择要检阅哪个局部变量( 1 表示第一个参数或是激活的第一个局部变量,以此类推,直到最后一个局部变量)。 lua_getlocal 把变量的值压入堆栈并返回它的名字。

    以 '(' (正小括号)开始的变量指内部变量(循环控制变量,临时变量,C 函数局部变量)。

    当索引大于局部变量的个数时,返回 NULL (什么也不压入)。


    lua_getstack

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

    获取解释器的运行时栈的信息。

    这个函数用正在运行中的给定级别处的函数的活动记录来填写 lua_Debug 结构的一部分。 0 级表示当前运行的函数,而 n+1 级处的函数就是调用第 n 级函数的那一个。如果没有错误,lua_getstack 返回 1 ;当调用传入的级别大于堆栈深度的时候,返回 0 。


    lua_getupvalue

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

    获取一个 closure 的 upvalue 信息。(对于 Lua 函数,upvalue 是函数需要使用的外部局部变量,因此这些变量被包含在 closure 中。)lua_getupvalue 获取第n 个 upvalue ,把这个 upvalue 的值压入堆栈,并且返回它的名字。 funcindex 指向堆栈上 closure 的位置。( 因为 upvalue 在整个函数中都有效,所以它们没有特别的次序。因此,它们以字母次序来编号。)

    当索引号比 upvalue 数量大的时候,返回 NULL (而且不会压入任何东西)对于 C 函数,这个函数用空串"" 表示所有 upvalue 的名字。


    lua_Hook

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

    用于调试的钩子函数类型。

    无论何时钩子被调用,它的参数 ar 中的 event 域都被设为触发钩子的事件。 Lua 把这些事件定义为以下常量:LUA_HOOKCALLLUA_HOOKRETLUA_HOOKTAILRETLUA_HOOKLINE, andLUA_HOOKCOUNT。除此之外,对于 line 事件,currentline 域也被设置。要想获得ar 中的其他域,钩子必须调用lua_getinfo。对于返回事件,event 的正常值可能是LUA_HOOKRET,或者是LUA_HOOKTAILRET 。对于后一种情况,Lua 会对一个函数做的尾调用也模拟出一个返回事件出来;对于这个模拟的返回事件,调用lua_getinfo 没有什么作用。

    当 Lua 运行在一个钩子内部时,它将屏蔽掉其它对钩子的调用。也就是说,如果一个钩子函数内再调回 Lua 来执行一个函数或是一个 chunk ,这个执行操作不会触发任何的钩子。


    lua_sethook

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

    设置一个调试用钩子函数。

    参数 f 是钩子函数。 mask 指定在哪些事件时会调用:它由下列一组位常量构成LUA_MASKCALLLUA_MASKRET, LUA_MASKLINE,以及LUA_MASKCOUNT。参数count 只在 mask 中包含有LUA_MASKCOUNT 才有意义。对于每个事件,钩子被调用的情况解释如下:

    • call hook: 在解释器调用一个函数时被调用。 钩子将于 Lua 进入一个新函数后,函数获取参数前被调用。
    • return hook: 在解释器从一个函数中返回时调用。 钩子将于 Lua 离开函数之前的那一刻被调用。 你无权访问被函数返回出去的那些值。(译注:原文 (You have no access to the values to be returned by the function) 如此。 但“无权访问”一词值得商榷。 某些情况下你可以访问到一些被命名为 (*temporary) 的局部变量, 那些索引被排在最后的 (*temporary) 变量指的就是返回值。 但是由于 Lua 对特殊情况做了一些优化,比如直接返回一个被命名的局部变量, 那么就找不到对应的 (*temporary) 变量了。本质上,返回值一定存在于此刻的局部变量中, 并且可以访问它,只是无法确定是哪些罢了。至于这个时候函数体内的其它局部变量, 是不保证有效的。进入 return hook 的那一刻起,实际已经退出函数内部的运行环节, 返回值占用的局部变量空间以后的部分,都有可能因 hook 本身复用它们而改变。)
    • line hook: 在解释器准备开始执行新的一行代码时, 或是跳转到这行代码中时(即使在同一行内跳转)被调用。 (这个事件仅仅在 Lua 执行一个 Lua 函数时发生。)
    • count hook: 在解释器每执行 count 条指令后被调用。 (这个事件仅仅在 Lua 执行一个 Lua 函数时发生。)

    钩子可以通过设置 mask 为零屏蔽。

    lua_setlocal

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

    设置给定活动记录中的局部变量的值。参数 ar 与 n 和 lua_getlocal 中的一样(参见 lua_getlocal)。 lua_setlocal 把栈顶的值赋给变量然后返回变量的名字。它会将值从栈顶弹出。

    当索引大于局部变量的个数时,返回 NULL (什么也不弹出)。


     

    lua_setupvalue

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

    设置 closure 的 upvalue 的值。它把栈顶的值弹出并赋于 upvalue 并返回 upvalue 的名字。参数funcindex 与 n 和 lua_getupvalue 中的一样(参见 lua_getupvalue)。

    当索引大于 upvalue 的个数时,返回 NULL (什么也不弹出)。

    展开全文
  • Lua常用函数

    2021-01-04 19:41:34
    这些函数都是Lua编程语言的一部分, 点击这里了解更多. assert(value) - 检查一个值是否为非nil, 若不是则(如果在wow.exe打开调试命令)显示对话框以及输出错误调试信息 collectgarbage() - 垃圾收集器. (新增于1.10.1...

    lua库函数

    这些函数都是Lua编程语言的一部分, 点击这里了解更多.

    assert(value) - 检查一个值是否为非nil, 若不是则(如果在wow.exe打开调试命令)显示对话框以及输出错误调试信息

    collectgarbage() - 垃圾收集器. (新增于1.10.1)

    date(format, time) - 返回当前用户机器上的时间.

    error(“error message”,level) - 发生错误时,输出一条定义的错误信息.使用pcall() (见下面)捕捉错误.

    gcinfo() - 返回使用中插件内存的占用量(kb)以及当前垃圾收集器的使用量(kB).

    getfenv(function or integer) - 返回此表已获取函数的堆栈结构或者堆栈等级

    getmetatable(obj, mtable) - 获取当前的元表或者用户数据对象.

    loadstring(“Lua code”) - 分析字符串中的lua代码块并且将结果作为一个函数返回

    next(table, index) - 返回下一个key,一对表值.允许遍历整个表

    pcall(func, arg1, arg2, …) - 受保护调用. 执行函数内容,同时捕获所有的异常和错误.

    select(index, list) - 返回选择此列表中的商品数值.或者是此件物品在列表中的索引值

    setfenv(function or integer, table) - 设置此表已获取函数的堆栈结构或者堆栈等级

    setmetatable(obj, mtable) - 设置当前表的元表或者用户数据对象

    time(table) - 返回从一个unix时间值

    type(var) - 判断当前变量的类型, “number”, “string”, “table”, “function” 或者 “userdata”.

    unpack(table) - 解压一个表.返回当前表中的所有值.

    xpcall(func, err) - 返回一个布尔值指示成功执行的函数以及调用失败的错误信息.另外运行函数或者错误的返回值

    数学函数

    这些表函数同样可以参考Lua函数库(他们都是以math.开头, 详情参阅数学库了解更多信息).

    三角函数是没有参考的, 包括角度->弧度的转换.暴雪的版本使用角度.而Lua的标准数学库则使用的弧度.

    abs(value) - 返回当前数值的绝对值

    acos(value) - 返回此角度值的弧余弦值.

    asin(value) - 返回此角度值的弧正弦值

    atan(value) - 返回此角度值的弧正切值

    atan2(y, x) - 在角度中, 返回Y/X的弧正切值.

    ceil(value) - 返回一个整数, 不管小数点后面是多少, 整数部分都进1

    cos(degrees) - 返回角度的余弦值

    deg(radians) - 弧度转换角度

    exp(value) - 返回此值的指数值

    floor(value) - 返回此值的整数值

    frexp(num) - 返回当前数字小数点后的数值以及小数点后的位数

    ldexp(value, 倍数) - 输出此数值的倍数

    log(value) - 返回此值的自然对数 (以e为底数)

    log10(value) - 返回以10为底数的值

    max(value[, values…]) - 在一堆值中查找最大值

    min(value[,values…]) - 在一堆值中查找最小值

    mod(value,modulus) - 返回此值的余数

    rad(degrees) - 角度转换弧度

    random([ [lower,] upper]) - 返回一个随机数字 (可选界限为整数值)

    randomseed(seed) - 为伪随机数字生成器设定种子

    sin(degrees) - 返回当前角度的正弦值

    sqrt(value) - 返回数值的平方根值(比如100的平方根为10)

    tan(degrees) - 返回当前角度的正切值

    字符串库

    这些表函数同样可以参考Lua字符串库(他们都是以string.开头, 参考字符串库了解更多信息)

    format(formatstring[, value[, …]]) - 格式化字符串

    gsub(string,pattern,replacement[, limitCount]) - 全局替换

    strbyte(string[, index]) - 转换字符串为整数值(可以指定某个字符).

    strchar(asciiCode[, …]) - 转换整数为相对应的字符

    strfind(string, pattern[, initpos[, plain]]) - 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置.

    strlen(string) - 返回当前字符串的字符数

    strlower(string) - 将字符串的字母转换为小写格式

    strmatch(string, pattern[, initpos]) - 与strfind不同的是,macth返回的是具体值,而find返回的是此值的位置

    strrep(seed,count) - 返回一个字符串种子副本的个数

    strsub(string, index[, endIndex]) - 返回字符串指定位置的值.

    strupper(string) - 将字符串的字母转为大写格式

    tonumber(arg[, base]) - 若参数能转为数字则返回一个数值.可以指定转换的类型.默认为十进制整数

    tostring(arg) - 转换参数为字符串

    下面的字符串函数是wow独有的

    strtrim(string) - 去除字符串前后空格

    strsplit(delimiter, string) - 分割字符串

    strjoin(delimiter, string, string[, …]) - 根据定界符将字符串连接起来

    表函数

    这些表函数同样可以参考Lua表库 (他们都是以"table.开头", 查阅Table库 f了解更多信息).

    也知道, 很多表都被设计为只有数字索引, 开始于1并且没有结尾(如like {[1] = “foo”, [3] = “bar”} — [2]是不存在的所以为nil值).工作时,与任何其他表并没有差别,但很可能会产生意想不到的结果. 在编写lua中, 这个也就是通常所说的bug

    foreach(table,function) - 为表中的每个元素执行函数

    foreachi(table,function) - 为表中的每个元素执行函数, 按顺序访问(不推荐, 可以使用ipairs代替)

    getn(table) - 当作为一个聊表时, 返回当前表的大小. 现在已经废弃了, 你可以直接使用#符号.使用#(table)代替table.getn(table)

    ipairs(table) - 返回一个迭代型整数遍历表。

    pairs(table) - 返回一个迭代遍历表

    sort(table[, comp]) - 对一个数组进行排序, 还可以指定一个可选的次序函数

    tinsert(table[, pos], value) - 将一个元素插入指定的位置(默认在表的最后)

    tremove(table[, pos]) - 删除指定位置的元素(默认表最后一个)

    Bit Functions

    魔兽世界包含了Lua BitLib库(他们都是以 "bit."开头). 与C的位运算相同.位运算库并非Lua标准函数库的一部分, 但是在WoW 1.9中得到了应用

    bit.bnot(a) - 返回一个a的补充

    bit.band(w1,…) - 返回w的位与

    bit.bor(w1,…) - 返回w的位或

    bit.bxor(w1,…) - 返回w的位异或

    bit.lshift(a,b) - 返回a向左偏移到b位

    bit.rshift(a,b) - 返回a逻辑右偏移到b位

    bit.arshift(a,b) - 返回a算术偏移到b位

    bit.mod(a,b) - 返回a除以b的整数余数

    Lua是一个脚本语言, 使用这些函数来对你的数据结构进行比对是十分慢的. 除非你有一个非常大的数据库以及需要保护的RAM使用, 保存你的信息到几个或个别的变量中.

    展开全文
  • lua常用函数

    2019-09-15 15:47:19
    void lua_setglobal (lua_State *L, const char *name); Pops a value from the stack and sets it as the new value of global name. void lua_register (...
    void lua_setglobal (lua_State *L, const char *name);
    Pops a value from the stack and sets it as the new value of global name.
    
    
    void lua_register (lua_State *L,
                       const char *name,
                       lua_CFunction f);
    Sets the C function f as the new value of global name.
    
    
    
    
    void lua_settable (lua_State *L, int index);
    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 §2.8). 
    
    
    
    
    void lua_gettable (lua_State *L, int index);
    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 §2.8). 
    
    
    void lua_pop (lua_State *L, int n);
    Pops n elements from the stack. 
    
    
    
    
    lua_pushboolean
    [-0, +1, -] 
    
    
    void lua_pushboolean (lua_State *L, int b);
    Pushes a boolean value with value b onto the stack. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushcclosure
    [-n, +1, m] 
    
    
    void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
    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 (see §3.4); 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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushcfunction
    [-0, +1, m] 
    
    
    void lua_pushcfunction (lua_State *L, lua_CFunction f);
    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). 
    
    
    lua_pushcfunction is defined as a macro: 
    
    
         #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushfstring
    [-0, +1, m] 
    
    
    const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
    Pushes onto the stack a formatted string and returns a pointer to this string. It is similar to the C function sprintf, 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 garbage collection). 
    The conversion specifiers are quite restricted. There are no flags, 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), '%p' (inserts a pointer as a hexadecimal numeral), '%d' (inserts an int), and '%c' (inserts an int as a character). 
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushinteger
    [-0, +1, -] 
    
    
    void lua_pushinteger (lua_State *L, lua_Integer n);
    Pushes a number with value n onto the stack. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushlightuserdata
    [-0, +1, -] 
    
    
    void lua_pushlightuserdata (lua_State *L, void *p);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushliteral
    [-0, +1, m] 
    
    
    void lua_pushliteral (lua_State *L, const char *s);
    This macro is equivalent to lua_pushlstring, but can be used only when s is a literal string. In these cases, it automatically provides the string length. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushlstring
    [-0, +1, m] 
    
    
    void lua_pushlstring (lua_State *L, const char *s, size_t len);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushnil
    [-0, +1, -] 
    
    
    void lua_pushnil (lua_State *L);
    Pushes a nil value onto the stack. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushnumber
    [-0, +1, -] 
    
    
    void lua_pushnumber (lua_State *L, lua_Number n);
    Pushes a number with value n onto the stack. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushstring
    [-0, +1, m] 
    
    
    void lua_pushstring (lua_State *L, const char *s);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushthread
    [-0, +1, -] 
    
    
    int lua_pushthread (lua_State *L);
    Pushes the thread represented by L onto the stack. Returns 1 if this thread is the main thread of its state. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushvalue
    [-0, +1, -] 
    
    
    void lua_pushvalue (lua_State *L, int index);
    Pushes a copy of the element at the given valid index onto the stack. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_pushvfstring
    [-0, +1, m] 
    
    
    const char *lua_pushvfstring (lua_State *L,
                                  const char *fmt,
                                  va_list argp);
    Equivalent to lua_pushfstring, except that it receives a va_list instead of a variable number of arguments. 
    
    
    
    
    lua_toboolean
    [-0, +0, -] 
    
    
    int lua_toboolean (lua_State *L, int index);
    Converts the Lua value at the given acceptable index to a C boolean value (0 or 1). 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 to test the value's type.) 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_tocfunction
    [-0, +0, -] 
    
    
    lua_CFunction lua_tocfunction (lua_State *L, int index);
    Converts a value at the given acceptable index to a C function. That value must be a C function; otherwise, returns NULL. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_tointeger
    [-0, +0, -] 
    
    
    lua_Integer lua_tointeger (lua_State *L, int index);
    Converts the Lua value at the given acceptable index to the signed integral type lua_Integer. The Lua value must be a number or a string convertible to a number (see §2.2.1); otherwise, lua_tointeger returns 0. 
    
    
    If the number is not an integer, it is truncated in some non-specified way. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_tolstring
    [-0, +0, m] 
    
    
    const char *lua_tolstring (lua_State *L, int index, size_t *len);
    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 when lua_tolstring is applied to keys during a table traversal.) 
    
    
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_tonumber
    [-0, +0, -] 
    
    
    lua_Number lua_tonumber (lua_State *L, int index);
    Converts the Lua value at the given acceptable index to the C type lua_Number (see lua_Number). The Lua value must be a number or a string convertible to a number (see §2.2.1); otherwise, lua_tonumber returns 0. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_topointer
    [-0, +0, -] 
    
    
    const void *lua_topointer (lua_State *L, int index);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_tostring
    [-0, +0, m] 
    
    
    const char *lua_tostring (lua_State *L, int index);
    Equivalent to lua_tolstring with len equal to NULL. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_tothread
    [-0, +0, -] 
    
    
    lua_State *lua_tothread (lua_State *L, int index);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_touserdata
    [-0, +0, -] 
    
    
    void *lua_touserdata (lua_State *L, int index);
    If the value at the given acceptable index is a full userdata, returns its block address. If the value is a light userdata, returns its pointer. Otherwise, returns NULL. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isboolean
    [-0, +0, -] 
    
    
    int lua_isboolean (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index has type boolean, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_iscfunction
    [-0, +0, -] 
    
    
    int lua_iscfunction (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a C function, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isfunction
    [-0, +0, -] 
    
    
    int lua_isfunction (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a function (either C or Lua), and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_islightuserdata
    [-0, +0, -] 
    
    
    int lua_islightuserdata (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a light userdata, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isnil
    [-0, +0, -] 
    
    
    int lua_isnil (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is nil, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isnone
    [-0, +0, -] 
    
    
    int lua_isnone (lua_State *L, int index);
    Returns 1 if the given acceptable index is not valid (that is, it refers to an element outside the current stack), and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isnoneornil
    [-0, +0, -] 
    
    
    int lua_isnoneornil (lua_State *L, int index);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isnumber
    [-0, +0, -] 
    
    
    int lua_isnumber (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a number or a string convertible to a number, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isstring
    [-0, +0, -] 
    
    
    int lua_isstring (lua_State *L, int index);
    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. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_istable
    [-0, +0, -] 
    
    
    int lua_istable (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a table, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isthread
    [-0, +0, -] 
    
    
    int lua_isthread (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a thread, and 0 otherwise. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    lua_isuserdata
    [-0, +0, -] 
    
    
    int lua_isuserdata (lua_State *L, int index);
    Returns 1 if the value at the given acceptable index is a userdata (either full or light), and 0 otherwise. 
    
    
    
    
    int lua_checkstack (lua_State *L, int extra);
    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. 
    
    
    
    
    Function lua_open was replaced by lua_newstate to allow the user to set a memory-allocation function. You can use luaL_newstate from the standard library to create a state with a standard allocation function (based on realloc). 
    
    int lua_gettop (lua_State *L);
    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). 
    
    void lua_settop (lua_State *L, int index);
    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. 
    
    
    int luaL_loadbuffer (lua_State *L,
                         const char *buff,
                         size_t sz,
                         const char *name);
    Loads a buffer as a Lua chunk. This function uses lua_load to load the chunk in the buffer pointed to by buff with size sz. 
    
    
    This function returns the same results as lua_load. name is the chunk name, used for debug information and error messages. 
    
    
    int lua_load (lua_State *L,
                  lua_Reader reader,
                  void *data,
                  const char *chunkname);
    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. The return values of lua_load are: 
    
    
    0: no errors; 
    LUA_ERRSYNTAX: syntax error during pre-compilation; 
    LUA_ERRMEM: memory allocation error. 
    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 program luac). 
    
    
    The lua_load function uses a user-supplied reader function to read the chunk (see lua_Reader). 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 (see §3.8). 
    
    
    int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
    Calls a function in protected mode. 
    
    
    Both nargs and nresults have the same meaning as in lua_call. If there are no errors during the call, lua_pcall behaves exactly like lua_call. 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, 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. 
    
    
    The lua_pcall function returns 0 in case of success or one of the following error codes (defined in lua.h): 
    
    
    LUA_ERRRUN: a runtime error. 
    LUA_ERRMEM: memory allocation error. For such errors, Lua does not call the error handler function. 
    LUA_ERRERR: error while running the error handler function. 
    void lua_getglobal (lua_State *L, const char *name);
    Pushes onto the stack the value of the global name
    void lua_newtable (lua_State *L);
    Creates a new empty table and pushes it onto the stack. It is equivalent to lua_createtable(L, 0, 0). 
    
    
    void lua_createtable (lua_State *L, int narr, int nrec);
    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. 
    
    
    void lua_close (lua_State *L);
    Destroys all objects in the given Lua state (calling the corresponding garbage-collection metamethods, if any) and frees all dynamic memory used by this state. On several platforms, you may not need to call this function, because all resources are naturally released when the host program ends. On the other hand, long-running programs, such as a daemon or a web server, might need to release states as soon as they are not needed, to avoid growing too large. 
    
    
    
    Metatablesint luaL_dofile (lua_State *L, const char *filename);
    Loads and runs the given file. It is defined as the following macro: 
    
    
         (luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
    
    
    It returns 0 if there are no errors or 1 in case of errors. 
    
    
    luaL_loadbuffer
    [-0, +1, m] 
    
    
    int luaL_loadbuffer (lua_State *L,
                         const char *buff,
                         size_t sz,
                         const char *name);
    Loads a buffer as a Lua chunk. This function uses lua_load to load the chunk in the buffer pointed to by buff with size sz. 
    
    
    This function returns the same results as lua_load. name is the chunk name, used for debug information and error messages. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    luaL_loadfile
    [-0, +1, m] 
    
    
    int luaL_loadfile (lua_State *L, const char *filename);
    Loads a file as a Lua chunk. This function uses lua_load 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 #. 
    
    
    This function returns the same results as lua_load, but it has an extra error code LUA_ERRFILE if it cannot open/read the file. 
    
    
    As lua_load, this function only loads the chunk; it does not run it. 
    
    
    
    
    --------------------------------------------------------------------------------
    
    
    luaL_loadstring
    [-0, +1, m] 
    
    
    int luaL_loadstring (lua_State *L, const char *s);
    Loads a string as a Lua chunk. This function uses lua_load to load the chunk in the zero-terminated string s. 
    
    
    This function returns the same results as lua_load. 
    
    
    Also as lua_load, this function only loads the chunk; it does not run it. 
    
     

    转载于:https://my.oschina.net/u/3485339/blog/900350

    展开全文
  • lua 常用函数

    2016-12-06 09:22:30
    数学函数这些表函数同样可以参考Lua函数库(他们都是以math.开头, 详情参阅数学库了解更多信息). 三角函数是没有参考的, 包括角度->弧度的转换.暴雪的版本使用角度.而Lua的标准数学库则使用的弧度. •abs(value) - ...
    •assert(value) - 检查一个值是否为非nil, 若不是则(如果在wow.exe打开调试命令)显示对话框以及输出错误调试信息   
    •collectgarbage() - 垃圾收集器. (新增于1.10.1)   
    •date(format, time) - 返回当前用户机器上的时间.   
    •error("error message",level) - 发生错误时,输出一条定义的错误信息.使用pcall() (见下面)捕捉错误.   
    •gcinfo() - 返回使用中插件内存的占用量(kb)以及当前垃圾收集器的使用量(kB).   
    •getfenv(function or integer) - 返回此表已获取函数的堆栈结构或者堆栈等级   
    •getmetatable(obj, mtable) - 获取当前的元表或者用户数据对象.   
    •loadstring("Lua code") - 分析字符串中的lua代码块并且将结果作为一个函数返回   
    •next(table, index) - 返回下一个key,一对表值.允许遍历整个表   
    •pcall(func, arg1, arg2, ...) - 受保护调用. 执行函数内容,同时捕获所有的异常和错误.   
    •select(index, list) - 返回选择此列表中的商品数值.或者是此件物品在列表中的索引值   
    •setfenv(function or integer, table) - 设置此表已获取函数的堆栈结构或者堆栈等级   
    •setmetatable(obj, mtable) - 设置当前表的元表或者用户数据对象   
    •time(table) - 返回从一个unix时间值   
    •type(var) - 判断当前变量的类型, "number", "string", "table", "function" 或者 "userdata".   
    •unpack(table) - 解压一个表.返回当前表中的所有值.   
    •xpcall(func, err) - 返回一个布尔值指示成功执行的函数以及调用失败的错误信息.另外运行函数或者错误的返回值   
    
    数学函数这些表函数同样可以参考Lua函数库(他们都是以math.开头, 详情参阅数学库了解更多信息).   
    三角函数是没有参考的, 包括角度->弧度的转换.暴雪的版本使用角度.而Lua的标准数学库则使用的弧度.   
    •abs(value) - 返回当前数值的绝对值   
    •acos(value) - 返回此角度值的弧余弦值.   
    •asin(value) - 返回此角度值的弧正弦值   
    •atan(value) - 返回此角度值的弧正切值   
    •atan2(y, x) - 在角度中, 返回Y/X的弧正切值.   
    •ceil(value) - 返回一个整数, 不管小数点后面是多少, 整数部分都进1   
    •cos(degrees) - 返回角度的余弦值   
    •deg(radians) - 弧度转换角度   
    •exp(value) - 返回此值的指数值   
    •floor(value) - 返回此值的整数值   
    •frexp(num) - 返回当前数字小数点后的数值以及小数点后的位数   
    •ldexp(value, 倍数) - 输出此数值的倍数   
    •log(value) - 返回此值的自然对数 (以e为底数)   
    •log10(value) - 返回以10为底数的值   
    •max(value[, values...]) - 在一堆值中查找最大值   
    •min(value[,values...]) - 在一堆值中查找最小值   
    •mod(value,modulus) - 返回此值的余数   
    •rad(degrees) - 角度转换弧度   
    •random([ [lower,] upper]) - 返回一个随机数字 (可选界限为整数值)   
    •randomseed(seed) - 为伪随机数字生成器设定种子   
    •sin(degrees) - 返回当前角度的正弦值   
    •sqrt(value) - 返回数值的平方根值(比如100的平方根为10)   
    •tan(degrees) - 返回当前角度的正切值   
    
    字符串库这些表函数同样可以参考Lua字符串库(他们都是以string.开头, 参考字符串库了解更多信息)   
    •format(formatstring[, value[, ...]]) - 格式化字符串   
    •gsub(string,pattern,replacement[, limitCount]) - 全局替换   
    •strbyte(string[, index]) - 转换字符串为整数值(可以指定某个字符).   
    •strchar(asciiCode[, ...]) - 转换整数为相对应的字符   
    •strfind(string, pattern[, initpos[, plain]]) - 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置.   
    •strlen(string) - 返回当前字符串的字符数   
    •strlower(string) - 将字符串的字母转换为小写格式   
    •strmatch(string, pattern[, initpos]) - 与strfind不同的是,macth返回的是具体值,而find返回的是此值的位置   
    •strrep(seed,count) - 返回一个字符串种子副本的个数   
    •strsub(string, index[, endIndex]) - 返回字符串指定位置的值.   
    •strupper(string) - 将字符串的字母转为大写格式   
    •tonumber(arg[, base]) - 若参数能转为数字则返回一个数值.可以指定转换的类型.默认为十进制整数   
    •tostring(arg) - 转换参数为字符串   
    下面的字符串函数是wow独有的   
    •strtrim(string) - 去除字符串前后空格   
    •strsplit(delimiter, string) - 分割字符串   
    •strjoin(delimiter, string, string[, ...]) - 根据定界符将字符串连接起来   
    
    表函数这些表函数同样可以参考Lua表库 (他们都是以"table.开头", 查阅Table库 f了解更多信息).   
    也知道, 很多表都被设计为只有数字索引, 开始于1并且没有结尾(如like {[1] = "foo", [3] = "bar"} --- [2]是不存在的所以为nil值).工作时,与任何其他表并没有差别,但很可能会产生意想不到的结果. 在编写lua中, 这个也就是通常所说的bug   
    •foreach(table,function) - 为表中的每个元素执行函数   
    •foreachi(table,function) - 为表中的每个元素执行函数, 按顺序访问(不推荐, 可以使用ipairs代替)   
    •getn(table) - 当作为一个聊表时, 返回当前表的大小. 现在已经废弃了, 你可以直接使用#符号.使用#(table)代替table.getn(table)   
    •ipairs(table) - 返回一个迭代型整数遍历表。   
    •pairs(table) - 返回一个迭代遍历表   
    •sort(table[, comp]) - 对一个数组进行排序, 还可以指定一个可选的次序函数   
    •tinsert(table[, pos], value) - 将一个元素插入指定的位置(默认在表的最后)   
    •tremove(table[, pos]) - 删除指定位置的元素(默认表最后一个)   
    
    Bit Functions魔兽世界包含了Lua BitLib库(他们都是以 "bit."开头). 与C的位运算相同.位运算库并非Lua标准函数库的一部分, 但是在WoW 1.9中得到了应用   
    •bit.bnot(a) - 返回一个a的补充   
    •bit.band(w1,...) - 返回w的位与   
    •bit.bor(w1,...) - 返回w的位或   
    •bit.bxor(w1,...) - 返回w的位异或   
    •bit.lshift(a,b) - 返回a向左偏移到b位   
    •bit.rshift(a,b) - 返回a逻辑右偏移到b位   
    •bit.arshift(a,b) - 返回a算术偏移到b位   
    •bit.mod(a,b) - 返回a除以b的整数余数   
    Lua是一个脚本语言, 使用这些函数来对你的数据结构进行比对是十分慢的. 除非你有一个非常大的数据库以及需要保护的RAM使用, 保存你的信息到几个或个别的变量中.   
    
    笔记•所有的字符都有他们的元表设置到全局字符串表, 因此一些字符串函数可以直接写在冒号前面进行调用:   
    切换行号显示   
       1 local s = string.format(input, arg1, arg2, ...)  
       2   
       3 -- 可以写成这样  
       4 local s = input:format(arg1, arg2, ...)  -- input将作为第一个参数, 复制到代码上, 这就是冒号语法  
    •这同样可以使用在字符串上, "%d":format(arg1)不是有效的lua代码,你可以写成   
    
    切换行号显示   
       1 ("%d"):format(arg1)  
    •自从使用字符串表, 一些函数放在字符串表里也是同样可以工作的, 下面的例子是有效的:   
    切换行号显示   
       1 function string.print(a)  
       2  return print(a)  
       3 end  
       4 ("test"):print()  
    展开全文
  • LUA常用函数

    2013-08-05 09:56:20
     当没有发生错误时,将返回一个编译完成的块作为函数,否则返回nil加上错误信息,此函数的环境为全局环境  chunkname用于错误和调试信息    10、loadfile ([filename])  功能:与load类似,但装载...
  • lua参考手册和lua常用函数,学习lua很有帮助的资料,希望对大家有用
  • LUA常用函数库_带目录.pdf

    热门讨论 2014-09-04 08:17:40
    LUA常用函数库_带目录.pdf 有用 ,分享给大家
  • Lua 常用函数

    2014-01-24 10:34:49
    Lua 常用函数 一 分类: 脚本学习2012-02-07 13:56 1165人阅读 评论(0) 收藏 举报 luahooktablenullinteger活动 目录(?)[+]   http://lua-users.org/wiki/LunaFive lua_...
  • LUA常用函数大全

    千次阅读 2019-01-29 00:52:28
    &nbsp; ...返回给定状态机的内存分配器函数。如果 ud 不是 NULL ,Lua 把调用lua_newstate 时传入的那个指针放入*ud 。 lua_getfenv void lua_getfenv (lua_State *L, int index); 把索引处...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 349
精华内容 139
关键字:

lua常用函数