-- Definition of the Lua function that will be called from the C++ code:

function Add (a, b)
    print("[Lua] Called Add(" .. a .. ", " .. b .. ")")
    return a + b
end

// The Lua-provided function will be called in main():

#include <iostream>
#include <format>

extern "C"
{
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
}

int main (int argc, char* argv[])
{    
    const auto L = luaL_newstate();
    
    // Opening (only) the basic Lua library (for print() in the Lua script).
    // (See comment on the next section for more details on this.)
    luaL_requiref(L, "_G", luaopen_base, 1);
    lua_pop(L, 1);
    
    // Load & Run the Lua code:
    //
    // Note: Loading alone won't make any globals or functions from a Lua file available;
    //       we must first also execute the loaded chunk (Lua has helper to combine these steps).
    //
    // Again: I left out any checks of the results; recommended only for demonstration purposes!
    luaL_loadfile(L, argv[1]);       // Load (argument = filepath).
    lua_pcall(L, 0, LUA_MULTRET, 0); // Run loaded chunk.
    
    // Find (and push onto the stack) the Lua function that should be called later:
    const char* LuaFunctionName = "Add";
    int type = lua_getglobal(L, LuaFunctionName);

    // Check and call the function (maybe):
    if (lua_isnoneornil(L, -1))
    {
        std::cout << std::format("Nothing with the name '{0}' was found!", LuaFunctionName) << std::endl;
    }
    else if (lua_isfunction(L, -1))
    {
        // Define the argument values:
        double FirstValue  = 2.4;
        double SecondValue = 3.1;
        
        // Push the values as Lua numbers on the stack, so that the Lua function can pop it as
        // its parameters 'a' and 'b' (pay attention to the order, it's a stack, after all!).
        lua_pushnumber(L, FirstValue);
        lua_pushnumber(L, SecondValue);
        
        // Call the Lua function: 2 Parameters, 1 Return Value expected, 0 (error) message handler:
        int ParamCount  = 2;
        int RetValCount = 1;

        if (lua_pcall(L, ParamCount, RetValCount, 0) == LUA_OK)
        {
            std::cout << std::format("[C++] Called Lua function '{0}({1}, {2})' -> Return Value: {3}",\
                "Add", FirstValue, SecondValue, (double)lua_tonumber(L, -1)) << std::endl;
            
            lua_pop(L, RetValCount); // Keep the stack tidy: Pop all returned values from the stack again.
        }
        else
        {
            std::string em = lua_tostring(L, -1);
            std::cout << em << std::endl;
        }
    }
    else
    {
        std::cout << std::format("Something with the name '{0}' was found, but it's not a Lua function, but of type '{1}'!",\
            LuaFunctionName, lua_typename(L, type)) << std::endl;
    }

    lua_close(L);

    return 0;
}

-- Lua script that calls the C++-provided function:

arguments = { 1, 2, 3 }
result    = Sum(arguments[1], arguments[2], arguments[3])

print("[Lua] Calling a C++ function with these arguments: (" .. table.concat(arguments, ", ") .. ")")
print("[Lua] The result of the C++ function call is: " .. result)

// The C++ program that defines the function for the Lua code
// (and also invokes the Lua script which then calls that function...)

#include <iostream>

extern "C"
{
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
}

//------------------------------
// Definition of the C++ function that can be called from the Lua script:

int CppSumFunction (lua_State* L)
{
    // Get the index of the top of the stack (which is also the current size of the stack and
    // the number of arguments passed to the function (remember that Lua starts counting with 1!).
    int NumberOfArguments = lua_gettop(L);
    
    double sum = 0;
    
    // Get every argument from the stack and add it to the sum:
    // (Once more: Remember that Lua starts counting [its stack elements] with 1!)
    for (int i = 1; i <= NumberOfArguments; i++)
    {
        // Imagine that we start with a fresh/empty stack, using the absolute index
        // (i.e. from the bottom, so using 1, 2, etc. is correct):
        sum += lua_tonumber(L, i); 
    }
    
    // Push the return value(s) onto the stack:
    // The count of pushes must match the number of returned values by this function!
    lua_pushnumber(L, sum); 
    
    std::cout << "[C++] Host function has been called (by Lua)" << std::endl;
    
    // The return value of the function must be the amount of actual return values
    // that will be pushed onto the stack for Lua (= number of arguments passed back to Lua):
    return 1; // In this case it was 1: The value of 'sum'.
}

//------------------------------
// Setting up the Lua state and invoking the Lua script (provided as an filepath argument):

int main (int argc, char* argv[])
{    
    const auto L = luaL_newstate();
    
    // Open (specific) Lua libraries, so that a Lua script can use functions
    // like print() or table-related functions.
    // 
    // Note: One reason to be so specific (instead of simply calling luaL_openlibs()),
    // is to reduce the possible attack vector/surface by preventing that a user script can
    // do or call things that we don't want it (e.g. access to the filesystem).
    // 
    // Things have changed with Lua 5.1 and many of the older tips I found on the internet
    // didn't work anymore with Lua 5.4.7.
    // This post was helpful: https://stackoverflow.com/a/57190353
    
    luaL_requiref(L, "_G", luaopen_base, 1);            // Lua's Basic Library.
    lua_pop(L, 1);
    
    luaL_requiref(L, LUA_TABLIBNAME, luaopen_table, 1); // Lua's Table library.
    lua_pop(L, 1);
    
    // Register the C++ function with Lua (under a different name for Lua):
    lua_register(L, "Sum", CppSumFunction);
    
    // Call the Lua code (first argument to main = filepath to the script):
    luaL_dofile (L, argv[1]);

    lua_close(L);
	
	return 0;
}