wie man ein lua-callback-Funktion aus einer c-Funktion

Ich habe eine C-Funktion (A) test_callback akzeptiert einen Zeiger auf eine Funktion(B) als parameter und Einen "Rückruf" B. 

//typedef int(*data_callback_t)(int i);
int test_callback(data_callback_t f)
{
    f(3);   
}


int datacallback(int a )
{
    printf("called back %d\n",a);
    return 0;
}


//example 
test_callback(datacallback); // print : called back 3

Nun, ich will wickeln test_callback so, dass Sie aufgerufen werden kann, lua, nehme an, der name ist lua_test_callback ;und auch die input-parameter an, es wäre eine lua-Funktion. Wie sollte ich dieses Ziel erreichen? 

function lua_datacallback (a )
    print "hey , this is callback in lua" ..a
end


lua_test_callback(lua_datacallback)  //expect to get "hey this is callback in lua 3 "

EDIT:

Dieser link bieten eine Möglichkeit zum speichern der callback-Funktion für die spätere Verwendung . 

//save function for later use 
callback_function = luaL_ref(L,LUA_REGISTRYINDEX);


//retrive function and call it 
lua_rawgeti(L,LUA_REGISTRYINDEX,callback_function);
//push the parameters and call it
lua_pushnumber(L, 5); // push first argument to the function
lua_pcall(L, 1, 0, 0); // call a function with one argument and no return values
InformationsquelleAutor pierrotlefou | 2010-04-22
  1. 9

    Ich bin mir nicht sicher, ob ich verstehe Ihre Frage, wenn Sie sich Fragen, was würde lua_test_callback look in C, es sollte so etwas wie dieses

    int lua_test_callback(lua_State* lua)
{
    if (lua_gettop(lua) == 1 && // make sure exactly one argument is passed
       lua_isfunction(lua, -1)) // and that argument (which is on top of the stack) is a function
    {
        lua_pushnumber(lua, 3); // push first argument to the function
        lua_pcall(lua, 1, 0, 0); // call a function with one argument and no return values
    }
    return 0; // no values are returned from this function
}

    Können Sie nicht nur wickeln test_callback Sie brauchen völlig unterschiedliche Umsetzung der Aufruf von Lua-Funktionen.

    (edit: geändert lua_call zu lua_pcall wie vorgeschlagen von Nick. Ich noch weggelassen Fehlerbehandlung für die Kürze)

    • Es ist vorzuziehen, lua_pcall, die push einen Fehler auf dem Stapel, anstatt einfach abzustürzen.
    • Schöne korrekte Beispiel. Aber in der Praxis ist es besser, verwenden Sie gängige, erprobte Schnittstelle, trotz des Schreibens eine solche lua_test_callback () - Funktionen wieder und wieder.
    InformationsquelleAutor sbk
  2. 4

    Die bequeme Art zu tun, Anrufe an verschiedene Lua-Funktionen mit verschiedenen Signaturen:

    A. Stellen Sie eine Klasse, die beibehalten wird, Lua Stand sicher und bieten eine einfache Schnittstelle. Nicht schreiben, anrufen, um Lua-Funktionen von Grund auf neu (mit jede Menge push/pop arbeiten und versichert) wieder und wieder - nur diese Klasse verwenden, interface. Dies ist sicher, schnell und bequem Ansatz.

    B. Definieren Sie push und pop Methoden, um push/pop auf die Argumente/aus dem Lua-stack:

    template<typename T> void push(T argument);
template<typename T> void get(const int index, T& return_value);

template<> void State::push(bool arg)
{
  lua_pushboolean (lua_state, arg ? 1 : 0);
}

template<> void State::push(float arg)
{
  lua_pushnumber (lua_state, arg);
}

template<> void State::push(int arg)
{
  lua_pushnumber (lua_state, arg);
}

// ...
template<> void State::get(const int index, bool& ret)
{
      if (!lua_isboolean(lua_state, index)) { ... }
      ret = lua_toboolean(lua_state, index) != 0;
}

    C. Definieren Funktionen aufrufen, Lua-Funktionen:

    // Call function that takes 1 argument and returns nothing
template <typename A1>
void call(const char * funcName, A1 arg1)
{
  lua_getfield (lua_state, LUA_GLOBALSINDEX, funcName);       // push global function f on stack
  push (arg1);                                            // push first argument on stack
  assert_call(    lua_pcall(lua_state, 1, 0, this->err_h) );      // call function taking 1 argument and getting no return value
}


// call function that takes 2 argument and returns 1 value
template <typename R1, typename A1, typename A2>
void callr1(const char * funcName, R1& res, A1 arg1, A2 arg2)
{
  lua_getfield (lua_state, LUA_GLOBALSINDEX, funcName);       // push global function f on stack
  push (arg1);                                            // push first argument on stack
  push (arg2);
  assert_call(    lua_pcall(lua_state, 2, 1, this->err_h) );      // call function taking 2 arguments and getting 1 return value
  get  (-1, res);
  lua_pop(lua_state, 1);
}

    D. Set error handler (lua_pcall nennen diese Lua-Funktion wenn Fehler)

    void setErrorHandler(const char * funcName)
{
  lua_getfield (lua_state, LUA_GLOBALSINDEX, funcName);
  this->err_h = lua_gettop(lua_state);
}
    InformationsquelleAutor topright gamedev
Schreibe einen Kommentar