Porting large code base -> luaL_opt* + working with the stack from rust

[bobbens]

Hello, thanks for the great project.
I'm porting a large C+Lua code base to rust, and I'm wondering if there are any macros or tricks to deal with things like luaL_optnumber to help simplify making the bindings. Using match + throwing an error seems to be a lot more work. In particular, something that would be a luaL_optnumber becomes something like:

                let n = match val {
                    Value::Number(n) => n,
                    Value::Nil => 1.,
                    _ => {
                        return Err(mlua::Error::BadArgument {
                            to: Some(String::from("number | nil")),
                            pos: 2,
                            name: Some(String::from("n")),
                            cause: Arc::new(mlua::Error::UserDataTypeMismatch),
                        })
                    }
                };

which is a bit more than the one-liner it is in C...

Also, C and rust are going to have to co-exist for a while. Is there any way to deal with Lua stack indices with mlua or do I have to resort to using the C API?

[khvzak]

luaL_optnumber and other helper functions should not be needed ideally.
You can declare types in your Rust function and mlua will take care of generating errors when args are wrong.
E.g. luaL_optnumber is Option<f64> in Rust:

let func = lua.create_function(|_lua, arg: Option<f32>| {
    dbg!(arg);
    Ok(arg)
})?;

Is there any way to deal with Lua stack indices with mlua or do I have to resort to using the C API?

You could try Lua::exec_raw which allow to work with raw Lua API.
If you more detailed example maybe I can suggest something else.

[bobbens]

You can try

value:  Either<f64, UserDataRef<Self>>

That is great, thanks! (this would also be great in the tour example, I totally missed it reading the docs)

it seems like mlua doesn't play well with lua_pcall, because when my mlua code errors, it seems to generate an error in error handling error,

Interesting, mlua should play well with pcall. Do you have an example to reproduce? error in error handling means that the Lua error handler panicked. See an example:

I can try to prepare a minimal example when I look into it more, but my error handler is below (working fine with lua_pcall from C).

int nlua_errTrace( lua_State *L )
{
   return nlua_errTraceInternal( L, 1 );
}
static int nlua_errTraceInternal( lua_State *L, int idx )
{
   /* Handle special done case. */
   const char *str = luaL_checkstring( L, idx );
   if ( strcmp( str, NLUA_DONE ) == 0 )
      return 1;

   /* str */
   /* Otherwise execute "debug.traceback( str, int )". */
   lua_getglobal( L, "debug" ); /* str, debug */
   if ( !lua_istable( L, -1 ) ) {
      lua_pop( L, 1 );
      return 1;
   }
   lua_getfield( L, -1, "traceback" ); /* str, debug, traceback */
   if ( !lua_isfunction( L, -1 ) ) {
      lua_pop( L, 2 );
      return 1;
   }
   lua_pushvalue( L, -3 );  /* str, debug, traceback, str */
   lua_pushinteger( L, 2 ); /* str, debug, traceback, str, int */
   lua_call( L, 2, 1 );     /* str, debug, ret */
   lua_remove( L, -2 );     /* str, ret */
   lua_remove( L, -2 );     /* ret */
   return 1;
}

[khvzak]

In the error handler, luaL_checkstring is seems the root cause. mlua errors are not strings (they are userdata objects with __tostring metamethod).
I would recommend to call luaL_tostring instead.

PS also there is a function luaL_traceback, which is a better way to get stack trace, rather than using debug module from C

[bobbens]

Thanks for the quick reply.

In the error handler, luaL_checkstring is seems the root cause. mlua errors are not strings (they are userdata objects with __tostring metamethod). I would recommend to call luaL_tostring instead.

I'm using luajit, so I tried with lua_tostring, and it seems to return NULL from mlua. Furthermore, the debug.traceback return value also seems to be NULL when calling lua_tostring. This happens when erroring from a rust function, but a C function works normally still.

PS also there is a function luaL_traceback, which is a better way to get stack trace, rather than using debug module from C

This sadly does not seem to be in Lua 5.1.

[khvzak]

I'm using luajit, so I tried with lua_tostring, and it seems to return NULL from mlua.

I see. You need to use this implementation: https://github.com/mlua-rs/mlua/blob/main/mlua-sys/src/lua51/compat.rs#L491
or https://github.com/lunarmodules/lua-compat-5.3/blob/master/c-api/compat-5.3.c#L873

[bobbens]

I'm using luajit, so I tried with lua_tostring, and it seems to return NULL from mlua.

I see. You need to use this implementation: https://github.com/mlua-rs/mlua/blob/main/mlua-sys/src/lua51/compat.rs#L491 or https://github.com/lunarmodules/lua-compat-5.3/blob/master/c-api/compat-5.3.c#L873

Ah, that was it! I was able to export the mlua::ffi stuff to C to get luaL_tolstring and luaL_traceback, and it now works like a charm. Thanks!