Lua Ffi Custom C Functions

Posted on 15-07-2021 by admin

Lua Ffi Custom C Functions
Lua Ffi Custom C Functions Free
Lua Ffi Custom C Functions Download
Lua Ffi Custom C Functions Cheat
Lua Ffi Custom C Functions List

The FFI library allows calling external C functions and using C data structures from pure Lua code. The FFI library largely obviates the need to write tedious manual Lua/C bindings in C. No need to learn a separate binding language — it parses plain C declarations! These can be cut-n-pasted from C header files or reference manuals. Extending Lua to C using the LuaJIT FFI library The runtime Lua environment hosted by the Stingray engine is powered by the LuaJIT library. LuaJIT offers a very fast script interpreter and just-in-time compiler, in addition to several extensions to the base Lua API. One of these additional modules is its FFI library, which aims to allow easy access to C functions and data structures from Lua. He created a shared object (.so) file containing a single, simple C function. Then for each FFI he wrote a bit of code to call this function many times, measuring how long it took. For the C “FFI” he used standard dynamic linking, not dlopen. This distinction is important, since it really makes a difference in the benchmark.

wiki

Lua can be embedded and extended[1] with code or applications written in other languages. Code and values in another language can be exposed to Lua and vice-versa. The following lists low and high level solutions for binding between Lua and other languages.

Lua C API

The most direct method to bind to Lua is with the Lua C API. The C API consists of two parts: the basic API (lua.h) provides the primitive functions for all interactions between C and Lua, while the auxiliary library (lauxlib.h) provides higher-level functions for some common tasks.[2]

[The Lua 5.1 Reference Manual: The Application Program Interface] (5.1) describes Lua's native C API for calling Lua from C and vice-versa.

See also Lua book [PIL2]. Or read about the C API online in the 1st edition of PIL: [PIL1 - The C API]

Enabling API checking

By default, the Lua C API does almost no sanity checking of arguments passed to it. Passing incorrect stack indexes, for example, can result in segfaults or random data corruption. You should always enable API checking in any debug build. You can do this by compiling with the option -DLUA_USE_APICHECK. luaconf.h uses this C macro to define luai_apicheck to call assert() in various places (you can also edit this definition to do something possibly more useful).

Example

Some examples of using the C API can be found by examining the source code of Lua's own standard libraries (src/*lib.c}. For example, the math library (math.*) is implemented in the file src/lmathlib.c. The basic form of this file is outlined below. First we import various headers, including the C API (lua.h) and the axillary library (lauxlib.h):

Then various Lua functions implemented in C are defined. These all have the same signature, and arguments are passed via Lua's own stack. For example, the sin function is defined as follows. luaL_check_number() is used to check the correct type of the sin function argument. lua_pushnumber() is used to return the sine calculated. Note, the return value of the math_sin() function is the number of values returned (lua functions can return many values).

These functions are registered into Lua by building a table of function pointers and names and then calling luaL_register(). Constants pi and huge are set separately. This registration code is placed in a function named luaopen_math(), which can be called statically (e.g. from linit.c) or dynamically (via Lua's shared library loading mechanism via require).

Binding C/C++ with Lua

C

[LuaAutoC] (5.2) - Automatically wrap C functions and structs at runtime.
[LuaNativeObjects] (5.1) - A C bindings generator written in Lua. It turns C structs into objects.
[luapi] (5.0) - a C API over the official Lua API.
[CaLua] (5.0) - A way to bind C functions and structures to Lua, and work with C pointers, arrays and functions in Lua. (uses x86 assembly)

C Foreign Function Interfaces (FFI)

[Alien] (5.1) - a foreign function interface (FFI) for Lua. An [FFI] lets Lua code call C functions directly without having to write C 'glue', so you can use Alien to write C extensions purely in Lua. (Wraps libffi)
[C/Invoke for Lua] (5.1) - Use [C/Invoke] from Lua to call C libraries (DLLs, .so files) directly, like Microsoft's P/Invoke and Python's ctypes. (Similar to Alien)
[The LuaJIT FFI] allows calling external C functions and using C data structures from Lua code. It parses plain C declarations and supports C99 plus some GCC/MSVC/C++ extensions.
[luaffi] (5.1) - an implementation of LuaJIT FFI for Lua.

C Inline

[lua-tcc] (5.1) - Simple interface to TCC, a fast runtime C compiler by Fabrice Bellard, it allows a Lua script to compile C code and register it at runtime as Lua-callable C funcions. Intentionally limited to avoid TCC's bug with multi-environments, that would be too tempting in Lua.
[Luatcc] (5.1) - another, more complete, Lua binding for libtcc, which is the core library of the [Tiny C Compiler]. It allows compiling and loading C code directly from Lua, includes the ability to load C modules directly from C source.
InlineCee provides a similar approach, invoking other compilers out-of-process.

C++

Various C++ or C++ template bindings have been developed to simplify the process in C++:

[CppLua] (5.0 & 5.1) - a C++ wrapper of the Lua API; handles class member functions.
[LuaCppInterface] (5.2) - a C++ wrapper of the Lua API. Uses TMP to make calling/passing functions, handling coroutines and filling tables easy and type-safe.
[sol] (5.2) - a C++11 easy to use and type safe wrapper of the Lua API.
[Diluculum] (5.1) - A library that intends to make the coexistence of C++ and Lua more harmonious.
[Tomaka17's lua wrapper] (5.2) - Simple bindings for Lua using C++11 supporting class and function registration, custom member functions, multiple return values, tables and more.
[Luabind] (5.1 & [5.2]) - a template-based binding of C++ classes and functions which uses the Boost library. The library seems to be abandoned by the [original authors], but some more or less actively maintained [forks] exist, e.g. [3] or [4].
[LuaBridge] (5.1 & 5.2) - lightweight, dependency-free, template-based library for exporting C++ classes/functions to Lua environments.
[SLB] (5.2) - Simple Lua Binder, a cross platform, small, easy to integrate, template-based library. Very similar to Luabind or boost-python but SLB doesn't require boost or any other dependency.
[Luna] (4.0), LunaWrapper (5.1) and LunaFive(5.2) - clean, template-based method of binding a C++ class to Lua. See also [LTN5] and SimplerCppBinding.
[MLuaBind] (5.1) - a template-based binding of C++ classes and functions which uses the Loki library.
[MultiScript] (5.1) - a simple library that demonstrates Lua independent C++ interface to bind C++ classes and functions.
[OOLua] (5.1, 5.2 & 5.3 work2) - Cross platform template generator binding which has no dependencies.
[Selene] (5.2) - Dead simple and intuitive C++11 bindings supporting class registration and functions.
[Sweet Lua] (5.1) - a template-based binding of C++ classes and functions. (MSVC)
[lux] - emits functions at compile time via C++ templates and argument overloading
[dub] - Creates bindings to Lua by using Doxygen to parse C++ headers. Supports many advanced features (namespaces, type casting, natural public member read/write, template resolution, etc).
[nlua] - 'namespace lua' binding of C/C++ functions, table-like usage, templated based (no boost)
[LuaWrapper] - A single header library that provides type-safe and intuitive functions such as luaW_to<T> and luaW_push<T> for arbitrary types, to make managing C++ classes with Lua simple.
[luna-gen] - Automatic lua binding-code generator. Fully-featured, fast compilation and execution speed, human-readable output codes, and no boost dependency.
[Lutok] - Lightweight C++ API for Lua. Lutok provides provides thin C++ wrappers around the Lua C API to ease the interaction between C++ and Lua. These wrappers make intensive use of RAII to prevent resource leakage, expose C++-friendly data types, report errors by means of exceptions and ensure that the Lua stack is always left untouched in the face of errors. The library also provides a small subset of miscellaneous utility functions built on top of the wrappers.
[lualite] - Very lightweight library for creating Lua bindings. Boost is not a dependency.
[integral] - C++ library with no dependencies for creating Lua bindings.
[lua-intf] (5.1 & 5.2) - Pure C++11 API and binding for Lua (headers only), supports lua stack API, a higher level API that can refer lua object just like a C++ class object, and can also export C++ class and functions for lua script. The export binding supports custom C++ type, multiple return values, C++ shared pointer, in/out arguments, and can also make argument optional or with default value. The new version also comes with an optional Qt data type mapping (QString, QVariant, QByteArray, etc...).
[LuaState] (5.1 & 5.2) - C++11 template library (clang, gcc and VS 12) no boost. Made to be really easy to use and as fast as possible. Lambda based bindings from Lua to C++.

See also:

DoItYourselfCppBinding - provides a few simple code fragments for helping Lua and C++ work together
LuaGenPlusPlus - luagen++, a C++ header file to generate efficient sequences of Lua C API calls at compile-time via template metaprogramming techniques
CppStreamChunkReader - lua_load chunk reader for any C++ std::istream (function)
[A comparison of LuaBind, SWIG, OOLua, and toLua++] - One developer's attempt to find a good binding framework for use in a memory-constrained environment.

Calling Lua from C/C++

These frameworks and articles are one-way bindings: to call Lua functions from C/C++ passing arguments and getting return values.

[A Generic Call Function] (5.0) - from PiL uses a format string to call a global function with a variable number of arguments.
[LuaGenericCall] (5.1) - uses code snippets and printf/scanf like format strings to support many types and features.
[LuaClassBasedCall] (5.1) - uses code snippets along with C++ constructor overloads and templates, supports nearly all C++ types.
[lua_icxx] (5.1) - embeds a Lua interpreter in a C++ application, using an OO API. See also SimpleLuaIcxxExample.
SimpleLuaApiExample - example using the C API: the C program loads/runs a Lua script file, sets Lua variables and retrieves return value.
CppLuaDataPassing - another more advanced example using regular C API to run a Lua script file with arguments.
GettingValuesFromLua - explanation of how to get return values from lua_dostring.
CallingLuaFromCpp - example to use the Luna binding (see above) to call Lua from C++.

Embedding Lua in C++

These frameworks are a little broader than the previous ones: they allow your C++ program full interaction with a Lua interpreter, but leave the task of extending Lua to other binding systems (SWIG, tolua++, and others).

[lua_icxx]: (pronounced 'lua-ix') Lua interpreter for C++; call Lua functions and User Data (class) methods, use tables, create function sandboxes, use multiple return values, evaluate expressions and scripts, and more. The missing link for use of bindings like SWIG and tolua++.

Automatic binding generators