In this short tutorial I'll show how to run Lua programs from C and C++ and howto expose functions to them. It's easy!

This article will present an introductory example of calling lua functions from C. If you want to extend and customize the capabilities of a C application without requiring a full recompilation, then using a embedded scripting language is the way to go.

Update: The code in this post has been updated for Lua 5.2.4. I haven'tchecked if the Lua 5.3 C API is backwards-compatible with 5.2. All the codehere is available on GitHub.

The first program will just create a Lua state object and exit. It will be ahybrid between C and C++. Since the two languages must include different files,we need to discern between them by checking for the existence of the__cplusplus macro.

Notice that I'm being explicit about which version of Lua I'm using in thecode. If you trust that the Lua developers care about compatibility, you canjust #include <lua.hpp> and so on directly.

The purpose of the program is just to make sure that we can compile, link andrun it without errors.

Intro to ECS and basic principles Part 2. Implementing the basics Part 3. Controlling entities in Lua by calling C functions. If you haven't read the first part of the tutorial, I suggest you to read it, so you have a clear idea what's going on.
Lua can't call arbitrary C functions - they have to be bound to something in the Lua namespace first. (This is intentional to prevent breaking out of sandboxes in embedded applications.).

You need to let the compiler know where it can find the include files and theLua shared library. The include files are usually located in/usr/local/include and the library files in /usr/local/lib. Search yoursystem directories if needed. To compile the above program, pass thedirectories with -I and -L, respectively.

You may swap out g++ with llvm-g++, or just c++, depending on yourcompiler. If you're using a C compiler, use gcc or llvm-gcc — butremember to rename the file to first.c.

Now try to run the program to make sure it doesn't segfault:

This one worked just fine.

Executing Lua programs from a host

The next step is to execute Lua programs from your C or C++ code. We'll createthe Lua state object as above, load a file from disk and execute it.

Put this into runlua.cpp or runlua.c:

You can reuse the compilation arguments from above:

Running Lua programs

Let's test this with some Lua programs. The first one prints the Lua versionand exits.

You may want to double-check that it works by running lua hello.lua. It maynot be important for this trivial program, but can become important when youtry more advanced ones.

Now try it with runlua:

You can even run bytecode-compiled programs:

We should also check that the error handling works. Put some garbage in a filecalled error.lua, for example

Running it produces

Calling C functions from Lua

It gets very interesting when Lua programs call back to your C or C++functions. We'll create a function called howdy that prints its inputarguments and returns the integer 123.

To be on the safe side, we'll declare C linkage for the function in the C++version of the program. This has to do with name mangling,but in this case, it really doesn't matter: Lua just receives a pointer to afunction, and that's that. But if you start using dynamic loading of sharedlibraries through dlopen and dlsym, this will be an issue. So let's do itcorrect from the start.

Copy the above program into a file called callback.cpp and add the howdyfunction.

We have to pass the address of this function to Lua along with a name. Put thefollowing line somewhere between the call to lua_newstate andluaL_loadfile:

Create a test program called callback.lua

Compile and test it

I told you it was easy!

What next?

Read the Lua C APIReference. You've learned enough now to get going with it. Did you see mynote about clearing the stack in howdy? You may want to investigate that.

Find out how to integrate Lua closures with your C functions.

If you want to hide or catch console output from Lua, you need to figure thatout as well. I once did it by trapping io.write(); I copied its code fromlualib.c and changed io_write to point to my own function. There isprobably a better way to do it, though. Doing so is useful for things like gameprogramming.

Use RAIIor smart pointers to manage resources like lua_State.

I also strongly recommend to try out LuaJIT.Calling into your functions there is even easier, using LuaJIT's foreignfunction library. I'll write a blog post on how todo that as well. In short, just create ordinary C functions, compile as ashared library, copy their signatures into pure Lua source code and hook themup with LuaJIT's FFIlibrary.

LuaJIT runs between 10-20 and up to 135 times faster than interpreted Lua, soit's definitely worth it.

This is Part 1b of my Integrating Lua into C++ Tutorial series.

Now that we have everything set up, let’s start!

Running a simple Lua-code from c++

First off, let’s try doing something simple. Let’s try running a Lua code from a string.

This should print out:

Hello World!

Congratulations! Samsung frp otg. You have run your first Lua-code in c++! As you can see, you don’t really need all these fancy ‘.lua’ files to run Lua-code. You can just use strings for the trivial stuffs.

You might be wondering what the code snippet above is doing.

sol::state state;

This line creates a lua state to be used in the codebase. Any functions or variables you define would ‘live in’ the state that it’s created in.

state.open_libraries(sol::lib::base, sol::lib::package);

This line loads up the default libraries that gives you certain functionalities of the Lua language. This includes I/O and other important functionalities. For our test case, we load up these libraries in order to run Lua’s print function.

If you are intending to create a sandbox for your game, you might not want to load up these libraries as you would essentially be giving your players too much power. You wouldn’t really want to give your modders functionalities to access I/O as it could lead to a security risk.

state.do_string('print('Hello World!')');

This line would run the Lua code snippet from a string. As you might guess, looking at the code, this line would print “Hello World!” to the console window.

Now let’s try running the same code snippet from a ‘.lua’ file.

In the default directory of your project, create a ‘scripts’ folder to store all your scripts.

Create a file ‘HelloWorld.lua’ in the script folder and add this code inside:

Now try running this code in c++:

This should also print out:

Hello World!

state.do_file('scripts/HelloWorld.lua');

You might notice the slight change of code here. Instead of do_script, we used do_file, to indicate that we want to run the code from a ‘.lua’ file instead of a string.

Accessing Lua variables from c++

In this part of the tutorial, we will be covering on how to access lua variables in c++ code.

Accessing lua variables from c++ is fairly simple.

Here we have a numeric lua variable named ‘luaNum’. As you can see, in the snippet code above, we are able to both set and get the value just like a normal variable in c++ just by knowing the lua variable’s name.

If nothing goes wrong, you’ll see:

printing in Lua: 3
printing in c++: 3

state['luaNum'] = 3;

This line defines a numeric lua value with the variable name of “luaNum”. As stat

Calling C Function From Lua