¿Cómo manejar las excepciones de C++ al llamar a funciones desde Lua?

Question

Tengo una función de C++ en funcionamiento a la que puedo llamar desde Lua. Para demostrar mi problema aquí es un ejemplo:

int PushHello(lua_State *L){ 
    string str("Hello"); 
    lua_pushlstring(L, str.data(), str.length()); 
    return 1; 
} 

Nota: Yo sé que no tengo que usar variable de cadena allí, pero está ahí para demostrar el problema.

Aquí están mis dos problemas:

1. Cuando llamo a esta función desde Lua constructor de cadena puede producir una excepción. ¿Es eso un problema? ¿Lo manejará Lua y desenrollará correctamente la pila Lua? No lo creo. ¿Cómo puedo resolver eso? ¿Debo agregar try/catch a todo este código y convertir la excepción a lua_error? ¿No hay una mejor solución?

2. Otro problema que probablemente he resuelto al compilar Lua como C++ es cuando lua_pushlstring() llama a lua_error() cadena destructor no se llamaría si se usara longjmp. ¿El problema se resuelve compilando como C++ y lanzando excepciones en lugar de usar longjmp?

Para aclarar, posible solución que puedo ver a un problema 1 sería la siguiente:

int PushHello(lua_State *L){ 
    string str; 
    try{ 
     str.assign("Hello"); 
    catch(exception &e){ 
     luaL_error(L, e.what()); 
    } 
    lua_pushlstring(L, str.data(), str.length()); 
    return 1; 
} 

Pero eso es muy feo y propenso a errores como try/catch tendría que ser añadido a muchos lugares. Se podría hacer como una macro y poner cada comando que pueda arrojar, pero eso no sería mucho mejor.

Answer 1

He encontrado una solución razonable. La pregunta es si es correcto. En lugar de exportar (o llamar a través de lua_cpcall) la función original int PushHello(lua_State *L) se exporta/llama un contenedor int SafeFunction<PushHello>(lua_State *L).El contenedor se ve así:

template<lua_CFunction func> 
int SafeFunction(lua_State *L){ 
    int result = 0; 
    try{ 
     result = func(L); 
    } 
    // transform exception with description into lua_error 
    catch(exception &e){ 
     luaL_error(L, e.what()); 
    } 
    // rethrow lua error - C++ Lua throws lua_longjmp* 
    catch(lua_longjmp*){ 
     throw; 
    } 
    // any other exception as lua_error with no description 
    catch(...){ 
     luaL_error(L, "Unknown error"); 
    } 

    return result; 
} 

¿Qué opina sobre eso? ¿Ves algún problema?

Answer 2

No utilizaría lua_error para denotar un error que ocurra fuera de la funcionalidad lua. lua_error se usaría si está agregando funciones lua adicionales que se pueden invocar dentro de los límites de lua. Entonces lua_error sería apropiado si se produce un error al ejecutar esa función.

También este es un duplicado de Stack unwinding in C++ when using Lua

Editar

Si usted está preocupado por el destructor cadena que se llama por qué no hacer esto:

try 
{ 
    string str("Hello"); 
    lua_pushlstring(L, str.data(), str.length()); 
} 
catch (exception& e) 
{ 
    luaL_error(L, e.what()); 
} 

me di cuenta que es una sutil cambie a lo que sugirió, pero hay una diferencia. Si se lanza una excepción, cualquier cosa en la pila dentro del try{} se destruirá. Solo asegúrate de que todo lo que quieras destruir esté dentro de ese intento.

Answer 3

Si compila Lua como C++, entonces usarán excepciones de C++ como errores, mientras que si compila como C, usarán longjmp/setjmp. Esto básicamente significa que no hay gran problema arrojando tal excepción.

Answer 4

Lua no detectará la excepción de C++. Si no lo captas, se pasará por la pila de llamadas hasta que sea capturado por algún otro bloque de código o provoque la falla del programa (excepción no controlada). Si las funciones que expone a Lua llaman a funciones que pueden arrojar excepciones, debe manejarlas en esa función.

Answer 5

Juraj Blaho la respuesta es genial. Sin embargo, tiene un inconveniente: para cada función que exporta con int SafeFunction<PushHello>(lua_State *L), el compilador generará una copia de todo el código de la plantilla, como si fuera una macro. Cuando se exportan numerosas funciones pequeñas, esto será un desperdicio de espacio.

Usted puede evitar el problema mediante la definición de una función común static realizar todo el trabajo, y la función template simplemente llama a esa función común:

static int SafeFunctionCommon(lua_State *L, lua_CFunction func){ 
    int result = 0; 
    try{ 
     result = func(L); 
    } 
    // transform exception with description into lua_error 
    catch(exception &e){ 
     luaL_error(L, e.what()); 
    } 
    // rethrow lua error - C++ Lua throws lua_longjmp* 
    catch(lua_longjmp*){ 
     throw; 
    } 
    // any other exception as lua_error with no description 
    catch(...){ 
     luaL_error(L, "Unknown error"); 
    } 

    return result; 
} 

template<lua_CFunction func> 
int SafeFunction(lua_State *L){ 
    return SafeFunctionCommon(L, func); 
}