文章目錄

boolean

lua_isboolean

判斷是否爲boolean

int lua_isboolean (lua_State *L, int index);

lua_pushboolean

boolean 壓棧

void lua_pushboolean (lua_State *L, int b);

lua_toboolean

int lua_toboolean (lua_State *L, int index);

nil

lua_isnil

int lua_isnil (lua_State *L, int index);

lua_pushnil

void lua_pushnil (lua_State *L);

lua_isnone

//索引值是否有效
int lua_isnone (lua_State *L, int index);

lua_isnoneornil

int lua_isnoneornil (lua_State *L, int index);

Integer

lua_Integer

typedef … lua_Integer;
Lua中的整數類型。缺省時，這個就是long long，（通常是一個64位以二爲補碼的整數），也可以修改它爲long或int（通常是一個32位以二爲補碼的整數）。Lua定義了兩個常量：LUA_MININTEGER和LUA_MAXINTEGER來表示這個類型可以表示的最小和最大值。

lua_isinteger [-0, +0, –]

int lua_isinteger (lua_State *L, int index);
當給定索引的值是一個整數（其值是一個數字，且內部以整數儲存），時，返回1，否則返回0。

lua_pushinteger [-0, +1, –]

void lua_pushinteger (lua_State *L, lua_Integer n);
把值爲n的整數壓棧。

lua_tointeger [-0, +0, –]

lua_Integer lua_tointeger (lua_State *L, int index);
等價於調用lua_tointegerx，其參數isnum 爲NULL。

lua_tointegerx [-0, +0, –]

lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);
將給定索引處的Lua值轉換爲帶符號的整數類型lua_Integer。這個Lua值必須是一個整數，或是一個可以被轉換爲整數的數字或字符串；否則，lua_tointegerx 返回0。如果isnum不是NULL，*isnum會被設爲操作是否成功。

lua_Unsigned

typedef … lua_Unsigned;
lua_Integer 的無符號版本。

Number類型及其相關操作

lua_Number

typedef double lua_Number;
Lua 中浮點數的類型。Lua 中數字的類型。缺省是double但是你可以改成float。

lua_isnumber [-0, +0, –]

int lua_isnumber (lua_State *L, int index);
當給定索引的值是一個數字，或是一個可轉換爲數字的字符串時，返回 1 ，否則返回 0 。

lua_pushnumber [-0, +1, –]

void lua_pushnumber (lua_State *L, lua_Number n);
把一個值爲 n 的浮點數壓棧。

lua_tonumber [-0, +0, –]

lua_Number lua_tonumber (lua_State *L, int index);
等價於調用 lua_tonumberx，其參數 isnum 爲 NULL。

lua_tonumberx [-0, +0, –]

lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);
把給定索引處的Lua值轉換爲lua_Number這樣一個C類型。這個Lua值必須是一個數字或是一個可轉換爲數字的字符串；否則，lua_tonumberx返回0。如果isnum不是NULL，*isnum會被設爲操作是否成功。

lua_numbertointeger

int lua_numbertointeger (lua_Number n, lua_Integer p);
將一個Lua浮點數轉換爲一個Lua整數。這個宏假設n有對應的整數值。如果該值在Lua整數可表示範圍內，就將其轉換爲一個整數賦給p。宏的結果是一個布爾量，表示轉換是否成功。（注意. 由於圓整關係，這個範圍測試不用此宏很難做對。）該宏有可能對其參數做多次取值。
5. string類型及其相關操作

lua_isstring [-0, +0, –]

int lua_isstring (lua_State *L, int index);
當給定索引的值是一個字符串或是一個數字（數字總能轉換成字符串）時，返回1，否則返回0。

lua_pushstring [-0, +1, e]

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

將指針s指向的零結尾的字符串壓棧。因此s處的內存在函數返回後，可以釋放掉或是立刻重用於其它用途。返回內部副本的指針。如果s爲NULL，將nil壓棧並返回NULL。

lua_pushfstring [-0, +1, e]

const char *lua_pushfstring (lua_State *L, const char *fmt, …);
把一個格式化過的字符串壓棧，然後返回這個字符串的指針。它和C函數sprintf比較像，不過有一些重要的區別：你不需要爲結果分配空間：其結果是一個Lua 字符串，由Lua來關心其內存分配（同時通過垃圾收集來釋放內存）。這個轉換非常的受限。不支持符號. 寬度. 精度。轉換符只支持’%%’（插入一個字符 ‘%’），’%s’（插入一個帶零終止符的字符串，沒有長度限制）,’%f’（插入一個lua_Number），’%L’（插入一個lua_Integer），’%p’（插入一個指針或是一個十六進制數），’%d’（插入一個 int），’%c’（插入一個用int表示的單字節字符），以及’%U’（插入一個用long int 表示的UTF-8 字）。

lua_pushlstring [-0, +1, e]

const char *lua_pushlstring (lua_State *L, const char *s, size_t len);
把指針 s 指向的長度爲 len 的字符串壓棧。Lua 對這個字符串做一個內部副本（或是複用一個副本），因此s處的內存在函數返回後，可以釋放掉或是立刻重用於其它用途。字符串內可以是任意二進制數據，包括零字符。返回內部副本的指針。

lua_pushvfstring [-0, +1, e]

const char *lua_pushvfstring (lua_State *L,const char *fmt,va_list argp);
等價於 lua_pushfstring，不過是用 va_list 接收參數，而不是用可變數量的實際參數。

lua_stringtonumber [-0, +1, –]

size_t lua_stringtonumber (lua_State *L, const char *s);
將一個零結尾的字符串s轉換爲一個數字，將這個數字壓棧，並返回字符串的總長度（即長度加一）。轉換的結果可能是整數也可能是浮點數，這取決於Lua的轉換語法。這個字符串可以有前置和後置的空格以及符號。如果字符串並非一個有效的數字，返回0並不把任何東西壓棧。（注意，這個結果可以當成一個布爾量使用，爲真即轉換成功。）

lua_tolstring [-0, +0, e]

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_tostring [-0, +0, e]

const char *lua_tostring (lua_State *L, int index);
等價於調用 lua_tolstring ，其參數 len 爲 NULL 。

lua_pushliteral [-0, +1, e]

const char *lua_pushliteral (lua_State *L, const char *s);
這個宏等價於 lua_pushlstring，區別僅在於只能在 s 是一個字面量時才能用它。它會自動給出字符串的長度。
6. Function類型及其相關操作

lua_iscfunction [-0, +0, –]

int lua_iscfunction (lua_State *L, int index);
當給定索引的值是一個 C 函數時，返回 1 ，否則返回 0 。

lua_CFunction

typedef int (*lua_CFunction) (lua_State *L);
C 函數的類型。
爲了正確的和Lua通訊，C函數必須使用下列協議。這個協議定義了參數以及返回值傳遞方法：C函數通過Lua中的棧來接受參數，參數以正序入棧（第一個參數首先入棧）。因此，當函數開始的時候，lua_gettop(L)可以返回函數收到的參數個數。第一個參數（如果有的話）在索引1的地方，而最後一個參數在索引lua_gettop(L)處。當需要向Lua返回值的時候，C函數只需要把它們以正序壓到堆棧上（第一個返回值最先壓入），然後返回這些返回值的個數。在這些返回值之下的，堆棧上的東西都會被Lua丟掉。和Lua函數一樣，從Lua中調用C函數也可以有很多返回值。下面這個例子中的函數將接收若干數字參數，並返回它們的平均數與和：
static int foo (lua_State L) {
int n = lua_gettop(L); / 參數的個數 /
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); / 第一個返回值 /
lua_pushnumber(L, sum); / 第二個返回值 /
return 2; / 返回值的個數 */
}

lua_pushcfunction [-0, +1, –]

void lua_pushcfunction (lua_State *L, lua_CFunction f);
將一個C函數壓棧。這個函數接收一個C函數指針，並將一個類型爲 function 的Lua值壓棧。當這個棧頂的值被調用時，將觸發對應的C函數。註冊到Lua中的任何函數都必須遵循正確的協議來接收參數和返回值。
lua_pushcfunction 是作爲一個宏定義出現的：
#define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)

lua_tocfunction [-0, +0, –]

lua_CFunction lua_tocfunction (lua_State *L, int index);
把給定索引處的Lua值轉換爲一個C函數。這個值必須是一個C函數；如果不是就返回NULL。

lua_isfunction [-0, +0, –]

int lua_isfunction (lua_State *L, int index);
當給定索引的值是一個函數（C或Lua函數均可）時，返回1，否則返回0。
6.6. lua_KFunction
typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
延續函數的類型。
6.7. lua_pushcclosure [-n, +1, e]
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
把一個新的C閉包壓棧。當創建了一個C函數後，你可以給它關聯一些值，這就是在創建一個C閉包；接下來無論函數何時被調用，這些值都可以被這個函數訪問到。爲了將一些值關聯到一個C函數上，首先這些值需要先被壓入堆棧（如果有多個值，第一個先壓）。接下來調用lua_pushcclosure來創建出閉包並把這個C函數壓到棧上。參數n告之函數有多少個值需要關聯到函數上。lua_pushcclosure 也會把這些值從棧上彈出。n的最大值是 255。當n爲零時，這個函數將創建出一個輕量C函數，它就是一個指向C函數的指針。這種情況下，不可能拋出內存錯誤。
7. table類型及其相關操作

7.1. lua_istable [-0, +0, –]
int lua_istable (lua_State *L, int index);
當給定索引的值是一張表時，返回 1 ，否則返回 0 。
7.2. lua_newtable [-0, +1, e]
void lua_newtable (lua_State *L);
創建一張空表，並將其壓棧。它等價於lua_createtable(L, 0, 0) 。
8. userdata類型及其相關操作

8.1. lua_isuserdata [-0, +0, –]
int lua_isuserdata (lua_State *L, int index);
當給定索引的值是一個用戶數據（無論是完全的還是輕量的）時，返回1，否則返回0。
8.2. lua_newuserdata [-0, +1, e]
void *lua_newuserdata (lua_State *L, size_t size);
這個函數分配一塊指定大小的內存塊，把內存塊地址作爲一個完全用戶數據壓棧，並返回這個地址。宿主程序可以隨意使用這塊內存。
8.3. lua_touserdata [-0, +0, –]
void *lua_touserdata (lua_State *L, int index);
如果給定索引處的值是一個完全用戶數據，函數返回其內存塊的地址。如果值是一個輕量用戶數據，那麼就返回它表示的指針。否則，返回NULL。
9. lightuserdata類型及其相關操作

9.1. lua_islightuserdata [-0, +0, –]
int lua_islightuserdata (lua_State *L, int index);
當給定索引的值是一個輕量用戶數據時，返回 1 ，否則返回 0 。
9.2. lua_pushlightuserdata [-0, +1, –]
void lua_pushlightuserdata (lua_State *L, void p);
把一個輕量用戶數據壓棧。
用戶數據是保留在Lua中的C值。輕量用戶數據表示一個指針void。它是一個像數字一樣的值：你不需要專門創建它，它也沒有獨立的元表，而且也不會被收集（因爲從來不需要創建）。只要表示的C地址相同，兩個輕量用戶數據就相等。
10. thread類型及其相關操作

10.1. lua_isthread [-0, +0, –]
int lua_isthread (lua_State *L, int index);
當給定索引的值是一條線程時，返回 1 ，否則返回 0 。
10.2. lua_newthread [-0, +1, e]
lua_State *lua_newthread (lua_State *L);
創建一條新線程，並將其壓棧，並返回維護這個線程的lua_State 指針。這個函數返回的新線程共享原線程的全局環境，但是它有獨立的運行棧。沒有顯式的函數可以用來關閉或銷燬掉一個線程。線程跟其它Lua對象一樣是垃圾收集的條目之一。
10.3. lua_pushthread [-0, +1, –]
int lua_pushthread (lua_State *L);
把 L 表示的線程壓棧。如果這個線程是當前狀態機的主線程的話，返回 1 。
10.4. lua_tothread [-0, +0, –]
lua_State *lua_tothread (lua_State L, int index);
把給定索引處的值轉換爲一個Lua線程（表示爲lua_State）。這個值必須是一個線程；否則函數返回NULL。
三. 函數調用——call和pcall

lua_call [-(nargs+1), +nresults, e]
void lua_call (lua_State L, int nargs, int nresults);
調用一個函數。要調用一個函數請遵循以下協議：
首先，要調用的函數應該被壓入棧；接着，把需要傳遞給這個函數的參數按正序壓棧；這是指第一個參數首先壓棧。最後調用一下lua_call；nargs是你壓入棧的參數個數。當函數調用完畢後，所有的參數以及函數本身都會出棧。而函數的返回值這時則被壓棧。返回值的個數將被調整爲nresults個，除非nresults被設置成LUA_MULTRET。在這種情況下，所有的返回值都被壓入堆棧中。Lua會保證返回值都放入棧空間中。函數返回值將按正序壓棧（第一個返回值首先壓棧），因此在調用結束後，最後一個返回值將被放在棧頂。被調用函數內發生的錯誤將（通過longjmp）一直上拋。下面的例子中，這行 Lua 代碼等價於在宿主程序中用 C 代碼做一些工作：
a = f(“how”, t.x, 14)
這裏是 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_callk [-(nargs + 1), +nresults, e]
void lua_callk (lua_State *L,int nargs,int nresults,lua_KContext ctx,lua_KFunction k);
這個函數的行爲和lua_call完全一致，只不過它還允許被調用的函數讓出。
lua_pcall [-(nargs + 1), +(nresults|1), –]
int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);
以保護模式調用一個函數。
nargs和nresults 的含義與lua_call中的相同。如果在調用過程中沒有發生錯誤，lua_pcall的行爲和lua_call完全一致。但是，如果有錯誤發生的話，lua_pcall會捕獲它，然後把唯一的值（錯誤消息）壓棧，然後返回錯誤碼。同lua_call 一樣，lua_pcall 總是把函數本身和它的參數從棧上移除。如果msgh是0，返回在棧頂的錯誤消息就和原始錯誤消息完全一致。否則，msgh 就被當成是錯誤處理函數在棧上的索引位置。（在當前的實現裏，這個索引不能是僞索引）在發生運行時錯誤時，這個函數會被調用而參數就是錯誤消息。錯誤處理函數的返回值將被lua_pcall作爲錯誤消息返回在堆棧上。典型的用法中，錯誤處理函數被用來給錯誤消息加上更多的調試信息，比如棧跟蹤信息。這些信息在lua_pcall返回後，由於棧已經展開，所以收集不到了。
lua_pcall 函數會返回下列常數（定義在 lua.h 內）中的一個：
LUA_OK (0):成功。 LUA_ERRRUN:運行時錯誤。
LUA_ERRMEM:內存分配錯誤。對於這種錯，Lua不會調用錯誤處理函數。
LUA_ERRERR: 在運行錯誤處理函數時發生的錯誤。
LUA_ERRGCMM: 在運行 __gc 元方法時發生的錯誤。（這個錯誤和被調用的函數無關。）
lua_pcallk [-(nargs + 1), +(nresults|1), –]
int lua_pcallk (lua_State *L,int nargs, int nresults, int msgh, lua_KContext ctx,lua_KFunction k);
這個函數的行爲和 lua_pcall 完全一致，只不過它還允許被調用的函數讓出
四. 與get. set相關的函數
lua_getallocf [-0, +0, –]
lua_Alloc lua_getallocf (lua_State L, void **ud);
返回給定狀態機的內存分配器函數。如果ud不是NULL，Lua把設置內存分配函數時設置的那個指針置入ud。
lua_setallocf [-0, +0, –]
void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
把指定狀態機的分配器函數換成帶上用戶數據 ud 的 f 。
lua_getfield [-0, +1, e]
int lua_getfield (lua_State *L, int index, const char *k);
把 t[k] 的值壓棧，這裏的t是索引指向的值。在Lua中，這個函數可能觸發對應"index"事件對應的元方法。函數將返回壓入值的類型。
lua_setfield [-1, +0, e]
void lua_setfield (lua_State *L, int index, const char *k);
做一個等價於 t[k] = v 的操作，這裏t是給出的索引處的值，而v是棧頂的那個值。
這個函數將把這個值彈出棧。跟在 Lua 中一樣，這個函數可能觸發一個"newindex" 事件的元方法。
lua_getextraspace [-0, +0, –]
void *lua_getextraspace (lua_State *L);
返回一個Lua狀態機中關聯的內存塊指針。程序可以把這塊內存用於任何用途；而Lua不會使用它。每一個新線程都會攜帶一塊內存，初始化爲主線程的這塊內存的副本。
默認配置下，這塊內存的大小爲空指針的大小。不過你可以重新編譯Lua設定這塊內存不同的大小。
lua_getglobal [-0, +1, e]
int lua_getglobal (lua_State *L, const char *name);
把全局變量name裏的值壓棧，返回該值的類型。
lua_setglobal [-1, +0, e]
void lua_setglobal (lua_State *L, const char *name);
從堆棧上彈出一個值，並將其設爲全局變量 name 的新值。
lua_geti [-0, +1, e]
int lua_geti (lua_State *L, int index, lua_Integer i);
把t[i]的值壓棧，這裏的t指給定的索引指代的值。和在Lua裏一樣，這個函數可能會觸發"index"事件的元方法。返回壓入值的類型。
lua_seti [-1, +0, e]
void lua_seti (lua_State *L, int index, lua_Integer n);
做一個等價於 t[n] = v 的操作，這裏 t 是給出的索引處的值，而 v 是棧頂的那個值。
這個函數將把這個值彈出棧。跟在 Lua 中一樣，這個函數可能觸發一個 “newindex” 事件的元方法。
lua_getmetatable [-0, +(0|1), –]
int lua_getmetatable (lua_State *L, int index);
如果該索引處的值有元表，則將其元表壓棧，返回 1 。否則不會將任何東西入棧，返回 0 。
lua_setmetatable [-1, +0, –]
void lua_setmetatable (lua_State *L, int index);
把一張表彈出棧，並將其設爲給定索引處的值的元表。
lua_gettable [-1, +1, e]
int lua_gettable (lua_State *L, int index);
把t[k]的值壓棧，這裏的t是指索引指向的值，而k則是棧頂放的值。
這個函數會彈出堆棧上的鍵，把結果放在棧上相同位置。和在Lua中一樣，這個函數可能觸發對應"index"事件的元方法。返回壓入值的類型。
lua_settable [-2, +0, e]
void lua_settable (lua_State *L, int index);
做一個等價於 t[k] = v的操作，這裏 t是給出的索引處的值，v是棧頂的那個值，k是棧頂之下的值。這個函數會將鍵和值都彈出棧。跟在 Lua 中一樣，這個函數可能觸發一個 “newindex” 事件的元方法。
lua_gettop [-0, +0, –]
int lua_gettop (lua_State *L);
返回棧頂元素的索引。因爲索引是從1開始編號的，所以這個結果等於棧上的元素個數；特別指出，0表示棧爲空。
lua_settop [-?, +?, –]
void lua_settop (lua_State *L, int index);
參數允許傳入任何索引以及 0。它將把堆棧的棧頂設爲這個索引。如果新的棧頂比原來的大，超出部分的新元素將被填爲 nil。如果 index爲 0，把棧上所有元素移除。
lua_getuservalue [-0, +1, –]
int lua_getuservalue (lua_State *L, int index);
將給定索引處的用戶數據所關聯的Lua值壓棧。返回壓入值的類型。
lua_setuservalue [-1, +0, –]
void lua_setuservalue (lua_State *L, int index);
從棧上彈出一個值並將其設爲給定索引處用戶數據的關聯值。
五. 帶有Raw的相關函數
rawequal函數

1.1. lua_rawequal [-0, +0, –]
int lua_rawequal (lua_State *L, int index1, int index2);
如果索引index1與索引index2處的值本身相等（即不調用元方法），返回1。否則返回0。當任何一個索引無效時，也返回0。
2. rawget. rawset函數

2.1. lua_rawget [-1, +1, –]
int lua_rawget (lua_State *L, int index);
類似於 lua_gettable ，但是作一次直接訪問（不觸發元方法）。
2.2. lua_rawset [-2, +0, e]
void lua_rawset (lua_State *L, int index);
類似於 lua_settable ，但是是做一次直接賦值（不觸發元方法）。
3. rawgeti. rawseti函數

3.1. lua_rawgeti [-0, +1, –]
int lua_rawgeti (lua_State *L, int index, lua_Integer n);
把 t[n] 的值壓棧，這裏的 t 是指給定索引處的表。這是一次直接訪問；就是說，它不會觸發元方法。返回入棧值的類型。
3.2. lua_rawseti [-1, +0, e]
void lua_rawseti (lua_State *L, int index, lua_Integer i);
等價於t[i]=v，這裏的t是指給定索引處的表，而v是棧頂的值。這個函數會將值彈出棧。賦值是直接的；即不會觸發元方法。
4. rawgetp. rawsetp函數

4.1. lua_rawgetp [-0, +1, –]
int lua_rawgetp (lua_State *L, int index, const void *p);
把 t[k] 的值壓棧，這裏的t是指給定索引處的表，k是指針p對應的輕量用戶數據。這是一次直接訪問；就是說，它不會觸發元方法。返回入棧值的類型。
4.2. lua_rawsetp [-1, +0, e]
void lua_rawsetp (lua_State *L, int index, const void *p);
等價於 t[k] = v，這裏的 t是指給定索引處的表， k是指針 p對應的輕量用戶數據。而 v是棧頂的值。這個函數會將值彈出棧。賦值是直接的；即不會觸發元方法。
5. rawlen函數

5.1. lua_len [-0, +1, e]
void lua_len (lua_State *L, int index);
返回給定索引的值的長度。它等價於Lua中的 ‘#’ 操作符。它有可能觸發 “length” 事件對應的元方法。結果壓棧。
5.2. lua_rawlen [-0, +0, –]
size_t lua_rawlen (lua_State *L, int index);
返回給定索引處值的固有“長度”：對於字符串，它指字符串的長度；對於表；它指不觸發元方法的情況下取長度操作（’#’）應得到的值；對於用戶數據，它指爲該用戶數據分配的內存塊的大小；對於其它值，它爲 0 。
六. 對Lua棧進行簡單操作的相關函數（增刪查改）

lua_checkstack [-0, +0, –]
int lua_checkstack(lua_State *L, int n);
確保堆棧上至少有n個額外空位。如果不能把堆棧擴展到相應的尺寸，函數返回假。失敗的原因包括將把棧擴展到比固定最大尺寸還大（至少是幾千個元素）或分配內存失敗。這個函數永遠不會縮小堆棧；如果堆棧已經比需要的大了，那麼就保持原樣。
lua_close [-0, +0, –]
void lua_close (lua_State *L);
銷燬指定Lua狀態機中的所有對象（如果有垃圾收集相關的元方法的話，會調用它們），並且釋放狀態機中使用的所有動態內存。在一些平臺上，你可以不必調用這個函數，因爲當宿主程序結束的時候，所有的資源就自然被釋放掉了。另一方面，長期運行的程序，比如一個後臺程序或是一個網站服務器，會創建出多個Lua狀態機。那麼就應該在不需要時趕緊關閉它們。
lua_compare [-0, +0, e]
int lua_compare (lua_State *L, int index1, int index2, int op);
比較兩個Lua值。當索引index1處的值通過op和索引index2處的值做比較後條件滿足，函數返回1。這個函數遵循Lua對應的操作規則（即有可能觸發元方法）。反之，函數返回0。當任何一個索引無效時，函數也會返回0。
op值必須是下列常量中的一個：
LUA_OPEQ:相等比較 (==) LUA_OPLT:小於比較(<) LUA_OPLE:小於等於比較(<=)
lua_concat [-n, +1, e]
void lua_concat (lua_State *L, int n);
連接棧頂的n個值，然後將這些值出棧，並把結果放在棧頂。如果n爲1，結果就是那個值放在棧上（即，函數什麼都不做；）如果n爲0，結果是一個空串。連接依照Lua中通常語義完成。
lua_copy [-0, +0, –]
void lua_copy (lua_State *L, int fromidx, int toidx);
從索引fromidx處複製一個值到一個有效索引toidx處，覆蓋那裏的原有值。不會影響其它位置的值。
lua_createtable [-0, +1, e]
void lua_createtable (lua_State *L, int narr, int nrec);
創建一張新的空表壓棧。參數narr建議了這張表作爲序列使用時會有多少個元素；參數nrec建議了這張表可能擁有多少序列之外的元素。Lua會使用這些建議來預分配這張新表。如果你知道這張表用途的更多信息，預分配可以提高性能。否則，你可以使用函數lua_newtable 。
lua_insert [-1, +1, –]
void lua_insert (lua_State *L, int index);
把棧頂元素移動到指定的有效索引處，依次移動這個索引之上的元素。不要用僞索引來調用這個函數，因爲僞索引沒有真正指向棧上的位置。
lua_remove [-1, +0, –]
void lua_remove (lua_State *L, int index);
從給定有效索引處移除一個元素，把這個索引之上的所有元素移下來填補上這個空隙。不能用僞索引來調用這個函數，因爲僞索引並不指向真實的棧上的位置。
lua_xmove [-?, +?, –]
void lua_xmove (lua_State *from, lua_State *to, int n);
交換同一個狀態機下不同線程中的值。這個函數會從from的棧上彈出n個值，然後把它們壓入to的棧上。
lua_replace [-1, +0, –]
void lua_replace (lua_State *L, int index);
把棧頂元素放置到給定位置而不移動其它元素（因此覆蓋了那個位置處的值），然後將棧頂元素彈出。
lua_rotate [-0, +0, –]
void lua_rotate (lua_State *L, int idx, int n);
把從idx開始到棧頂的元素輪轉n個位置。對於n爲正數時，輪轉方向是向棧頂的；當n爲負數時，向棧底方向輪轉-n個位置。n的絕對值不可以比參於輪轉的切片長度大。
lua_dump [-0, +0, e]
int lua_dump (lua_State *L,lua_Writer writer,void *data,int strip);
把函數導出成二進制代碼塊。函數接收棧頂的Lua函數做參數，然後生成它的二進制代碼塊。若被導出的東西被再次加載，加載的結果就相當於原來的函數。當它在產生代碼塊的時候，lua_dump通過調用函數writer（參見lua_Writer）來寫入數據，後面的data參數會被傳入writer。如果strip爲真，二進制代碼塊將不包含該函數的調試信息。最後一次由writer的返回值將作爲這個函數的返回值返回；0表示沒有錯誤。該函數不會把Lua函數彈出堆棧。
lua_error [-1, +0, v]
int lua_error (lua_State *L);
以棧頂的值作爲錯誤對象，拋出一個Lua錯誤。這個函數將做一次長跳轉，所以一定不會返回。
lua_gc [-0, +0, e]
int lua_gc (lua_State *L, int what, int data);
控制垃圾收集器。
這個函數根據其參數 what 發起幾種不同的任務：
LUA_GCSTOP:停止垃圾收集器。 LUA_GCRESTART:重啓垃圾收集器。
LUA_GCCOLLECT:發起一次完整的垃圾收集循環。 LUA_GCCOUNT:返回Lua使用的內存總量（以K字節爲單位）。
LUA_GCCOUNTB:返回當前內存使用量除以 1024 的餘數。 LUA_GCSTEP:發起一步增量垃圾收集。
LUA_GCISRUNNING:返回收集器是否在運行（即沒有停止）。
LUA_GCSETPAUSE: 把 data 設爲垃圾收集器間歇率，並返回之前設置的值。
LUA_GCSETSTEPMUL: 把data設爲垃圾收集器步進倍率，並返回之前設置的值。
七. 與Lua進出棧相關的函數
lua_pop [-n, +0, –]
void lua_pop (lua_State *L, int n);
從棧中彈出 n 個元素。
lua_next [-1, +(2|0), e]
int lua_next (lua_State L, int index);
從棧頂彈出一個鍵，然後把索引指定的表中的一個鍵值對壓棧（彈出的鍵之後的 “下一” 對）。如果表中以無更多元素，那麼lua_next 將返回 0（什麼也不壓棧）。
典型的遍歷方法是這樣的：
/ 表放在索引 ‘t’ 處 /
lua_pushnil(L); / 第一個鍵 /
while (lua_next(L, t) != 0) {
/ 使用 ‘鍵’ （在索引 -2 處）和 ‘值’ （在索引 -1 處）/
printf("%s - %s\n",
lua_typename(L, lua_type(L, -2)),
lua_typename(L, lua_type(L, -1)));
/ 移除 ‘值’ ；保留 ‘鍵’ 做下一次迭代 */
lua_pop(L, 1);
}
在遍歷一張表的時候，不要直接對鍵調用lua_tolstring，除非你知道這個鍵一定是一個字符串。調用lua_tolstring有可能改變給定索引位置的值；這會對下一次調用lua_next造成影響。關於迭代過程中修改被迭代的表的注意事項參見 next 函數。
lua_pushglobaltable [-0, +1, –]
void lua_pushglobaltable (lua_State *L);
將全局環境壓棧。
lua_KContext
typedef … lua_KContext;
延續函數上下文參數的類型。這一定是一個數字類型。當有intptr_t時，被定義爲intptr_t，因此它也可以保存指針。否則，它被定義爲 ptrdiff_t。
lua_topointer [-0, +0, –]
const void *lua_topointer (lua_State L, int index);
把給定索引處的值轉換爲一般的C指針(void)。這個值可以是一個用戶對象，表，線程或是一個函數；否則，lua_topointer返回NULL。不同的對象有不同的指針。不存在把指針再轉回原有類型的方法。這個函數通常只用於調試信息。
lua_pushvalue [-0, +1, –]
void lua_pushvalue (lua_State *L, int index);
把棧上給定索引處的元素作一個副本壓棧。
八. Lua讀寫器函數以及加載. 註冊相關函數
lua_Reader
typedef const char * (*lua_Reader) (lua_State *L, void *data, size_t *size);
lua_load用到的讀取器函數，每次它需要一塊新的代碼塊的時候，lua_load就調用讀取器，每次都會傳入一個參數data。讀取器需要返回含有新的代碼塊的一塊內存的指針，並把size設爲這塊內存的大小。內存塊必須在下一次函數被調用之前一直存在。讀取器可以通過返回NULL或設size爲0來指示代碼塊結束。讀取器可能返回多個塊，每個塊可以有任意的大於零的尺寸。
lua_Writer
typedef int (lua_Writer) (lua_State L, const void p, size_t sz, void ud);
被lua_dump用到的寫入器函數。每次lua_dump產生了一段新的代碼塊，它都會調用寫入器。傳入要寫入的緩衝區§和它的尺寸(sz)，以及傳給lua_dump的參數data。寫入器會返回一個錯誤碼 0 表示沒有錯誤；別的值均表示一個錯誤，並且會讓lua_dump 停止再次調用寫入器。
lua_load [-0, +1, –]
int lua_load (lua_State *L,lua_Reader reader,void *data,const char *chunkname, const char *mode);
加載一段Lua代碼塊，但不運行它。如果沒有錯誤，lua_load把一個編譯好的代碼塊作爲一個Lua函數壓到棧頂。否則，壓入錯誤消息。
lua_load 的返回值可以是：
LUA_OK:沒有錯誤； LUA_ERRSYNTAX: 在預編譯時碰到語法錯誤；
LUA_ERRMEM: 內存分配錯誤； LUA_ERRGCMM: 在運行__gc 元方法時出錯了。（這個錯誤和代碼塊加載過程無關，它是由垃圾收集器引發的。）
lua_load函數使用一個用戶提供的reader函數來讀取代碼塊。data參數會被傳入reader函數。
chunkname 這個參數可以賦予代碼塊一個名字，這個名字被用於出錯信息和調試信息。
lua_load會自動檢測代碼塊是文本的還是二進制的，然後做對應的加載操作。字符串 mode的作用和函數load一致。它還可以是NULL等價於字符串"bt"。
lua_load的內部會使用棧，因此reader函數必須永遠在每次返回時保留棧的原樣。
如果返回的函數有上值，第一個上值會被設置爲保存在註冊表LUA_RIDX_GLOBALS索引處的全局環境。在加載主代碼塊時，這個上值是_ENV變量。其它上值均被初始化爲nil。
lua_register [-0, +0, e]
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_State
typedef struct lua_State lua_State;
一個不透明的結構，它指向一條線程並間接（通過該線程）引用了整個Lua解釋器的狀態。Lua庫是完全可重入的：它沒有任何全局變量。狀態機所有的信息都可以通過這個結構訪問到。這個結構的指針必須作爲第一個參數傳遞給每一個庫函數。
lua_newstate 是一個例外，這個函數會從頭創建一個 Lua 狀態機。
lua_newstate [-0, +0, –]
lua_State *lua_newstate (lua_Alloc f, void *ud);
創建一個運行在新的獨立的狀態機中的線程。如果無法創建線程或狀態機（由於內存有限）則返回 NULL。參數f是一個分配器函數；Lua將通過這個函數做狀態機內所有的內存分配操作。第二個參數ud，這個指針將在每次調用分配器時被轉入。
lua_status [-0, +0, –]
int lua_status (lua_State *L);
返回線程 L 的狀態。
正常的線程狀態是 0 （LUA_OK）。當線程用 lua_resume 執行完畢並拋出了一個錯誤時，狀態值是錯誤碼。如果線程被掛起，狀態爲 LUA_YIELD 。你只能在狀態爲 LUA_OK 的線程中調用函數。你可以延續一個狀態爲 LUA_OK 的線程（用於開始新協程）或是狀態爲 LUA_YIELD 的線程（用於延續協程）。
九. Yield及Resume相關函數
lua_isyieldable [-0, +0, –]
int lua_isyieldable (lua_State *L);
如果給定的協程可以讓出，返回 1 ，否則返回 0 。
lua_yield [-?, +?, e]
int lua_yield (lua_State *L, int nresults);
這個函數等價於調用lua_yieldk，不同的是不提供延續函數。因此，當線程被延續，線程會繼續運行調用lua_yield函數的函數。
lua_yieldk [-?, +?, e]
int lua_yieldk (lua_State *L,int nresults,lua_KContext ctx, lua_KFunction k);
讓出協程（線程）。
當C函數調用了lua_yieldk，當前運行的協程會掛起，啓動這個線程的lua_resume調用返回。參數nresults指棧上需返回給lua_resume 的返回值的個數。
當協程再次被延續時，Lua調用延續函數k繼續運行被掛起的C函數。延續函數會從前一個函數中接收到相同的棧，棧中的n個返回值被移除而壓入了從lua_resume傳入的參數。此外，延續函數還會收到傳給lua_yieldk的參數 ctx。通常，這個函數不會返回；當協程一次次延續，將從延續函數繼續運行。然而，有一個例外：當這個函數從一個逐行運行的鉤子函數中調用時，lua_yieldk不可以提供延續函數。（也就是類似lua_yield的形式），而此時，鉤子函數在調用完讓出後將立刻返回。Lua會使協程讓出，一旦協程再次被延續，觸發鉤子的函數會繼續正常運行。當一個線程處於未提供延續函數的C調用中，調用它會拋出一個錯誤。從並非用延續方式（例如：主線程）啓動的線程中調用它也會這樣。
lua_resume [-?, +?, –]
int lua_resume (lua_State *L, lua_State *from, int nargs);
在給定線程中啓動或延續一條協程。
要啓動一個協程的話，你需要把主函數以及它需要的參數壓入線程棧；然後調用lua_resume，把nargs設爲參數的個數。這次調用會在協程掛起時或是結束運行後返回。當函數返回時，堆棧中會有傳給lua_yield的所有值，或是主函數的所有返回值。
當協程讓出，lua_resume返回LUA_YIELD，若協程結束運行且沒有任何錯誤時，返回0。如果有錯則返回錯誤代碼。在發生錯誤的情況下，堆棧沒有展開，因此你可以使用調試 API來處理它。錯誤消息放在棧頂在。要延續一個協程，你需要清除上次lua_yield遺留下的所有結果，你把需要傳給 yield 作結果的值壓棧，然後調用lua_resume。參數from表示協程從哪個協程中來延續L的。如果不存在這樣一個協程，這個參數可以是NULL 。
十. 其他函數

lua_absindex [-0, +0, –]

int lua_absindex (lua_State *L, int idx);
將一個可接受的索引 idx 轉換爲絕對索引（即，一個不依賴棧頂在哪的值）。

lua_Alloc

typedef void * (*lua_Alloc) (void *ud,void *ptr,size_t osize,size_t nsize);
Lua 狀態機中使用的內存分配器函數的類型。內存分配函數必須提供一個功能類似於 realloc 但又不完全相同的函數。
它的參數有ud，一個由lua_newstate傳給它的指針；ptr，一個指向已分配出來/將被重新分配/要釋放的內存塊指針；
osize，內存塊原來的尺寸或是關於什麼將被分配出來的代碼；nsize，新內存塊的尺寸。如果ptr不是NULL，osize是ptr指向的內存塊的尺寸，即這個內存塊當初被分配或重分配的尺寸。
如果ptr是NULL，osize是Lua即將分配對象類型的編碼。當（且僅當）Lua創建一個對應類型的新對象時，osize是LUA_TSTRING，LUA_TTABLE，LUA_TFUNCTION，LUA_TUSERDATA，或LUA_TTHREAD 中的一個。若osize是其它類型，Lua將爲其它東西分配內存。
Lua假定分配器函數會遵循以下行爲：
當nsize是零時，分配器必須和free行爲類似並返回NULL。
當nsize不是零時，分配器必須和realloc行爲類似。如果分配器無法完成請求，返回NULL。Lua假定在osize>=nsize成立的條件下，分配器絕不會失敗。這裏有一個簡單的分配器函數的實現。這個實現被放在補充庫中，供luaL_newstate使用。
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);
}
注意，標準C能確保free(NULL)沒有副作用，且realloc(NULL,size)等價於malloc(size)。這段代碼假定realloc在縮小塊長度時不會失敗。（雖然標準C沒有對此行爲做出保證，但這看起來是一個安全的假定。）

lua_arith [-(2|1), +1, e]

void lua_arith(lua_State L, int op);
對棧頂的兩個值（或者一個，比如取反）做一次數學或位操作。其中，棧頂的那個值是第二個操作數。它會彈出壓入的值，並把結果放在棧頂。這個函數遵循Lua對應的操作符運算規則（即有可能觸發元方法）。
op 的值必須是下列常量中的一個：
LUA_OPADD:加法 (+) LUA_OPSUB:減法 (-)
LUA_OPMUL: 乘法 () LUA_OPDIV: 浮點除法 (/)
LUA_OPMOD: 取模 (%) LUA_OPIDIV:向下取整的除法 (//)
LUA_OPPOW:乘方 (^) LUA_OPUNM:取負(一元 -)
LUA_OPBNOT:按位取反(~) LUA_OPBAND:按位與(&)
LUA_OPBOR:按位或(|) LUA_OPBXOR:按位異或(~)
LUA_OPSHL:左移(<<) LUA_OPSHR:右移(>>)

lua_atpanic [-0, +0, –]

lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
設置一個新的 panic 函數，並返回之前設置的那個。

lua_type [-0, +0, –]

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 [-0, +0, –]

const char *lua_typename (lua_State *L, int tp);
返回tp表示的類型名，這個tp必須是lua_type可能返回的值中之一。

lua_upvalueindex [-0,+0,–]

int lua_upvalueindex (int i);
返回當前運行的函數的第 i 個上值的僞索引。

lua_version [-0, +0, v]

const lua_Number *lua_version (lua_State *L);
返回保存在Lua內核中儲存的版本數字的地址。當調用時傳入一個合法的lua_State，返回創建該狀態機時的版本地址。如果用NULL調用，返回調用者的版本地址。

zz