So you have made a program in Lua. You want to give it to people to run. You run into two problems right away: one, you don’t want to require people to install Lua to run your program, and two, you may not want them to have your source code (if it’s a commercial program). So, what to do?<\/p>\n
If we were in a language like C, we could precompile our program into a binary and distribute that. So, since Lua can very closely integrate with C, can we do that with Lua? The answer turns out to be “yes”. When you compile a C program, there are two general steps: the compiler (gcc, say) turns your source code into an object file<\/em>. This is a binary file that defines a bunch of objects, like variable declarations and functions. Then, a linker comes along and turns the object files into a program, by pulling out objects from each file (and shared files you reference, like shared libraries) and embedding them into a binary. So, if we can turn a Lua script into an object file, we can use the linker to embed it into the program.<\/p>\n One way to do this is to just make a C source file with a big string that has all your code in it. This would work but it’s a little stupid; you’d have to care about escaping quotes and things, it gets real hard real fast. It turns out that there’s an easier way:<\/p>\n Let’s say we have the following Lua code, in We can do this to make an object file out of it:<\/p>\n (Unfortunately, this is only an option with GNU ld, not Apple’s, so if you have a Mac, you’ll need something different. It’s not too hard to write a program is Lua to turn an arbitrary file to a C source file)<\/p>\n So, now you have an object file that you can link in with the rest of your program. This object file will define three file-scoped variables we can refer to:<\/p>\n\n We only care about the start and size variables, end isn’t really useful.<\/p>\n In our main program file, we need to declare the variables as extern references, just like above. Then, we can use This compiles our code (loaded from the embedded resource) and pushes it, as a function, on to the stack. We can call it with So now if we run this, it ought to say “Hello, World!”. But this is sort of pointless if we can only embed one file; most of the time we’ll have multiple modules or libraries or whatever. It would be nice if we could load things the same way in embedded mode as normal mode, too.<\/p>\n When you require a module in Lua, it uses the very flexible package loading system to find your module. There’s an array of searcher functions that take a module name and either return the module compiled as a function, or nil. Conveniently, they return exactly what The fundamental problem here is that we need to do reflection in C: we need a way to translate between the string “hello” and the variable Now we just need to register it and put it in Finally we just load the module, and So, now we can take any arbitrary Lua code, link it into a C binary, and distribute a Lua-powered application without giving up our source code. The C library can statically link Lua, and can export other functions (to tie in other libraries), so that we have an application that’s the best of both worlds: high-level garbage-collected language for all our logic, low-level language for talking to libraries, and a simple binary distribution to make it easy for users to run it.<\/p>\n
\n
\nThere are three steps to this process: first, we need to turn our Lua files into objects that a linker can put into a C program. Then, we need to tell the C program how to load the embedded objects. Finally, we need a way for Lua to know how to get them out of C, so that require<\/code> will work.<\/p>\nTurning Lua into object files<\/h2>\n
hello.lua<\/code>:<\/p>\n\nprint<\/span> "Hello, world!"<\/span><\/pre><\/div><\/div><\/div>\n\n\r\nld -r -b binary -o hello.o hello.lua\r\n<\/pre>\n
extern<\/span> char<\/span> binary_hello_lua_start[<\/span>]<\/span>;<\/span>\nextern<\/span> char<\/span> binary_hello_lua_end[<\/span>]<\/span>;<\/span>\nextern<\/span> char<\/span> binary_hello_lua_size[<\/span>]<\/span>;<\/span><\/pre><\/div><\/div><\/div>\n\nLoading embedded resources in C<\/h2>\n
luaL_loadbuffer<\/code> to compile and load the code:<\/p>\n\nlua_State *<\/span>lua =<\/span> lua_open(<\/span>)<\/span>;<\/span>\nluaL_openlibs(<\/span>lua)<\/span>;<\/span>\nluaL_loadbuffer(<\/span>lua,<\/span> binary_hello_lua_start,<\/span> (<\/span>int)<\/span>&<\/span>binary_hello_lua_size,<\/span> "hello.lua"<\/span>)<\/span>;<\/span><\/pre><\/div><\/div><\/div>\n\nlua_pcall<\/code>:<\/p>\n\nlua_pcall(<\/span>lua,<\/span> 0<\/span>,<\/span> LUA_MULTRET,<\/span> 0<\/span>)<\/span>;<\/span><\/pre><\/div><\/div><\/div>\n\nLetting Lua decide what to load<\/h2>\n
luaL_loadbuffer<\/code> does above. So, if we had a (C) function that would take a module name and either call luaL_loadbuffer<\/code> or push nil, then we could register that function in Lua, add it to package.loaders<\/code>, and then use require<\/code> normally.<\/p>\nbinary_hello_lua_start<\/code>. Unfortunately there’s no easy way to do that; we have to build a lookup table, so I’ll leave that as an exercise (since the focus here is on the actual embedding). If we just have our function assume that you’re always going to load “hello”, we can write it like this:<\/p>\n\nint<\/span> get_module(<\/span>lua_State *<\/span>lua)<\/span>{<\/span>\n const<\/span> char<\/span> *<\/span>modname =<\/span> luaL_checkstring(<\/span>lua,<\/span> 1<\/span>)<\/span>;<\/span>\n \n \/* This is just an example, in a real app we'd\n turn modname into a real resource pointer\n instead of just using hello.lua *\/<\/span>\n if<\/span>(<\/span>1<\/span> ==<\/span> 1<\/span>)<\/span>{<\/span>\n luaL_loadbuffer(<\/span>lua,<\/span> binary_hello_lua_start,<\/span> (<\/span>int<\/span>)<\/span>&<\/span>amp;<\/span>binary_hello_lua_size,<\/span> modname)<\/span>;<\/span>\n }<\/span> else<\/span> {<\/span>\n lua_pushnil(<\/span>lua)<\/span>;<\/span>\n }<\/span>\n \n return<\/span> 1<\/span>;<\/span>\n}<\/span><\/pre><\/div><\/div><\/div>\n\npackage.loaders<\/code>:<\/p>\n\nlua_register(<\/span>lua,<\/span> "get_module"<\/span>,<\/span> get_module)<\/span>;<\/span>\nluaL_dostring(<\/span>lua,<\/span> "table.insert(package.loaders, get_module)"<\/span>)<\/span>;<\/span><\/pre><\/div><\/div><\/div>\n\nrequire<\/code> will take care of the rest:<\/p>\n\nluaL_dostring(<\/span>lua,<\/span> "require 'hello'"<\/span>)<\/span>;<\/span><\/pre><\/div><\/div><\/div>\n\nWrapping up<\/h2>\n