Luaチュートリアル(XXI)。C言語関数の書き方のコツ

extern "C" int mapFunc(lua_State* L)
{
    // Check that the first argument passed in the Lua call code must be a table. otherwise an error will be raised.
    luaL_checktype(L,1,LUA_TTABLE);
    luaL_checktype(L,2,LUA_TFUNCTION);
    //Get the number of fields in the table, i.e. the number of elements in the array.
    int n = lua_objlen(L,1);
    //The starting index of arrays in Lua is conventionally 1, not 0 in C.
    for (int i = 1; i <= n; ++i) {
        lua_pushvalue(L,2); //Press a copy of the function (second argument) of the Lua argument onto the stack.
        lua_rawgeti(L,1,i); //push into table[i]
        lua_call(L,1,1); //calls function(table[i]) and presses the result of the function onto the stack.
        lua_rawseti(L,1,i); //table[i] = function return value, while popping the return value off the stack.
    }

    // No results returned to Lua code.
    return 0;
}

extern "C" int splitFunc(lua_State* L)
{
    const char* s = luaL_checkstring(L,1);
    const char* sep = luaL_checkstring(L,2); //separator
    const char* e;
    int i = 1;
    lua_newtable(L); //result table
    while ((e = strchr(s,*sep)) ! = NULL) {
        lua_pushlstring(L,s,e - s); //push in the substring.
        // Set the substring just pushed in to table, and assign the specified index value.
        lua_rawseti(L,-2,i++);      
        s = e + 1;
    }
    //Press in the last substring
    lua_pushstring(L,s);
    lua_rawseti(L,-2,i);
    return 1; //return table.
}

extern "C" int strUpperFunc(lua_State* L)
{
    size_t len;
    luaL_Buffer b;
    // Check if the first argument is a string, and return a pointer to the string and its length.
    const char* s = luaL_checklstring(L,1,&len);
    //Initialize Lua's internal Buffer.
    luaL_buffinit(L,&b);
    //append the processed characters in turn (luaL_addchar) to Lua's internal Buffer.
    for (int i = 0; i < len; ++i)
        luaL_addchar(&b,toupper(s[i]));
    //Press this Buffer and its contents onto the stack.
    luaL_pushresult(&b);
    return 1;
}

void registryTestFunc(lua_State* L)
{
    lua_pushstring(L,"Hello");
    lua_setfield(L,LUA_REGISTRYINDEX,"key1");
    lua_getfield(L,LUA_REGISTRYINDEX,"key1");
    printf("%s\n",lua_tostring(L,-1));
}

int main()
{
    lua_State* L = luaL_newstate();
    registryTestFunc(L);
    lua_close(L);
    return 0;
}

// function to set environment data within the module
extern "C" int setValue(lua_State* L)
{
    lua_pushstring(L,"Hello");
    lua_setfield(L,LUA_ENVIRONINDEX,"key1");
    return 0;
}

// function within the module to get the environment data
extern "C" int getValue(lua_State* L)
{
    lua_getfield(L,LUA_ENVIRONINDEX,"key1");
    printf("%s\n",lua_tostring(L,-1));
    return 0;
}

static luaL_Reg myfuncs[] = {
    {"setValue", setValue},
    {"getValue", getValue},
    {NULL, NULL}
};

extern "C" __declspec(dllexport)
int luaopen_testenv(lua_State* L)
{
    lua_newtable(L); //create a new table for the environment
    lua_replace(L,LUA_ENVIRONINDEX); //replace the new table just created and pressed onto the stack with the current module's environment table.
    luaL_register(L,"testenv",myfuncs);
    return 1;
}

extern "C" int counter(lua_State* L)
{
    //Get the value of the first upvalue.
    int val = lua_tointeger(L,lua_upvalueindex(1));
    //Press the resulting result onto the stack.
    lua_pushinteger(L,++val);
    // Assign a copy of the data at the top of the stack for later replacement operations.
    lua_pushvalue(L,-1);
    //This function replaces the data at the top of the stack with the value in upvalue(1). Also pops the top-of-stack data.
    lua_replace(L,lua_upvalueindex(1));
    // The data pressed in lua_pushinteger(L,++value) remains on the stack and is returned to Lua.
    return 1;
}

extern "C" int newCounter(lua_State* L)
{
    //Press in an upvalue with an initial value of 0. This function must be called before lua_pushcclosure.
    lua_pushinteger(L,0);
    // Push in the closure function, with argument 1 indicating the number of upvalues for the closure function. The function returns the value and the closure function is always at the top of the stack.
    lua_pushcclosure(L,counter,1);
    return 1;
}

static luaL_Reg myfuncs[] = {
    {"counter", counter},
    {"newCounter", newCounter},
    {NULL, NULL}
};

extern "C" __declspec(dllexport)
int luaopen_testupvalue(lua_State* L)
{
    luaL_register(L,"testupvalue",myfuncs);
    return 1;
}

func = testupvalue.newCounter();
print(func());
print(func());
print(func());

func = testupvalue.newCounter();
print(func());
print(func());
print(func());

--[[ The output is.
1
2
3
1
2
3
--]]