lua_newtable

void lua_newtable (lua_State *L);

創建一個空 table ，并將之壓入堆棧。 它等價于 lua_createtable(L, 0, 0) 。

lua_gettop

int lua_gettop (lua_State *L);

返回棧頂元素的索引。 因為索引是從 1 開始編號的， 所以這個結果等于堆棧上的元素個數（因此返回 0 表示堆棧為空）。

luaL_newmetatable

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

如果注冊表中已經有Key為tname的數據則返回0. 否則創建一個新表作為userdata的metatable，并在注冊表中注冊它然后返回1. 不過兩種情況都會把注冊表中tname相關的值壓入堆棧。

luaL_checkudata

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

Checks whether the function argument narg is a userdata of the type tname (see luaL_newmetatable).

lua_pushstring

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

把指針 s 指向的以零結尾的字符串壓棧。 Lua 對這個字符串做一次內存拷貝（或是復用一個拷貝）， 因此 s 處的內存在函數返回后，可以釋放掉或是重用于其它用途。 字符串中不能包含有零字符；第一個碰到的零字符會認為是字符串的結束。

lua_pushlstring

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

把指針 s 指向的長度為 len 的字符串壓棧。 Lua 對這個字符串做一次內存拷貝（或是復用一個拷貝）， 因此 s 處的內存在函數返回后，可以釋放掉或是重用于其它用途。 字符串內可以保存有零字符。

lua_pushvalue

void lua_pushvalue (lua_State *L, int index);

把堆棧上給定有效處索引處的元素作一個拷貝壓棧。

lua_settable

void lua_settable (lua_State *L, int index);

作一個等價于 t[k] = v 的操作， 這里 t 是一個給定有效索引 index 處的值， v 指棧頂的值， 而 k 是棧頂之下的那個值。

這個函數會把鍵和值都從堆棧中彈出。 和在 Lua 中一樣，這個函數可能觸發 "newindex" 事件的元方法 （參見 §2.8）。

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_setmetatable

int lua_setmetatable (lua_State *L, int index);

把一個 table 彈出堆棧，并將其設為給定索引處的值的 metatable 。

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_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_touserdata

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

如果給定索引處的值是一個完整的 userdata ，函數返回內存塊的地址。 如果值是一個 light userdata ，那么就返回它表示的指針。 否則，返回 NULL 。

Lua調用C++類要點：

1.       為此類建立一個全局表，表名為類名tbClass；

lua_newtable(L);

int methods = lua_gettop(L);

lua_pushstring(L, T::className);

lua_pushvalue(L, methods);

lua_settable(L, LUA_GLOBALSINDEX);

2．注冊一個key為T::className的metatable，并制定其中的一些成員，用于之后生成的userdata。

// 這個表用于userdata(T的對象)的metatable

          luaL_newmetatable(L, T::className);

          int metatable = lua_gettop(L);

         // metatable["__index"] = tbClass

         lua_pushliteral(L, "__index");

         lua_pushvalue(L, methods);

         lua_settable(L, metatable);

// metatable["__tostring"] = tostring_T

         lua_pushliteral(L, "__tostring");

         lua_pushcfunction(L, tostring_T);

         lua_settable(L, metatable);

     // metatable["__gc"] = gc_T

         lua_pushliteral(L, "__gc");

         lua_pushcfunction(L, gc_T);

         lua_settable(L, metatable);

3． 為此表指定成員，每個成員的key為類的成員函數名，Value為一個帶有閉包的統一函數。比如tbClass[FunName] = thunk，之后可以根據閉包得到具體是調用到哪個函數。閉包中有函數名和相應函數的組合結構(以lightuserdata的形式賦給閉包)。這些類成員函數參數都必須包括lua_State，因為它需要的參數都會在lua堆棧中。

// 為tbClass填充成員函數

         for (RegType *l = T::methods; l->name; l++)

         {

              /* edited by Snaily: shouldn't it be const RegType *l ... ? */

              lua_pushstring(L, l->name);

// 把(函數名,函數地址)pair以lightuserdata的形式作為C closure的upvalue入棧

              lua_pushlightuserdata(L, (void*)l);

// 把一個新的C closure 壓入堆棧。為upvalue的個數，并指定回調函數統一為thunk    lua_pushcclosure(L, thunk, 1);         

// tbClass[FunName] = Function

lua_settable(L, methods);

         }

4．創建C對象給腳本使用b = Account.new(Account, 30); new是tbClass下的一個函數(另外指定的，不會掉到thunk，這一句會調用到C的一個函數，里面會生成一個C對象，然后創建一個userdata 用于關聯到這個新生成的C對象。最后為這個userdata綁定上我們上面注冊為T::classname的metatable。因為定制了metatable的__index成員，所以當userdata找不到的成員會去調用__index，因為之前我們把__index綁定到tbClass，所以也會調用到tbClass的相應成員。

     // 創建一個新的T對象，并創建一個基于userdataType的userdata，其中保護了指向T對象的指針

     static int new_T(lua_State *L)

     {

         lua_remove(L, 1);   // use classname:new(), instead of classname.new()

         T *obj = new T(L); // call constructor for T objects

         userdataType *ud =

              static_cast<userdataType*>(lua_newuserdata(L, sizeof(userdataType)));

         ud->pT = obj; // store pointer to object in userdata

         luaL_getmetatable(L, T::className); // lookup metatable in Lua registry

         lua_setmetatable(L, -2);

         return 1; // userdata containing pointer to T object

     }

5． 當腳本中指定函數被調用的時候，比如b:deposit(50.30)的時候，b是userdata，它的metatable的__index和tbClass綁定(見4)，所以會調用到tbClass的相應成員，就是之前關聯的thunk：這個時候L的堆棧里面有這個函數的兩個參數，一個是b本身，一個是50.30。b是userdata，可以根據它取出對象的指針。見第4步。另外函數被調用的時候，它相關的upvalue也可以取得到，見步驟3。有了對象指針和相應的函數，調用也不為難了，記住參數50.30是保存在堆棧中傳給類的成員函數來取得。

// 所有成員函數都會調用到這里，然后根據upvalue來執行具體的成員函數

     static int thunk(lua_State *L)

     {

         // stack has userdata, followed by method args

         T *obj = check(L, 1); // the object pointer from the table at index 0.

         lua_remove(L, 1); // remove self so member function args start at index 1

         // get member function from upvalue

         RegType *l = static_cast<RegType*>(lua_touserdata(L, lua_upvalueindex(1)));

         return (obj->*(l->mfunc))(L); // call member function

     }

     // 根據指定位置narg獲得對象指針,這個userdata是在new_T的時候創建的

     static T *check(lua_State *L, int narg)

     {

         void *pUserData = luaL_checkudata(L, narg, T::className);   

         userdataType *ud = static_cast<userdataType*>(pUserData);    // 這個是函數的upvalue

         if(!ud)

              luaL_typerror(L, narg, T::className);

         return ud->pT;

     }