Code, create, and learn together Code, collaborate, compile, run, share, and deploy Lua and more online from your browser Sign up to code in Lua Explore Multiplayer Collaborate in real-time with your friends. Compile lua online Language: Ada Assembly Bash C# C (gcc) C (clang) C (vc) C (gcc) C (clang) C (vc) Client Side Clojure Common Lisp D Elixir Erlang F# Fortran Go Haskell Java Javascript Kotlin Lua MySql Node.js Ocaml Octave Objective-C Oracle Pascal Perl Php PostgreSQL Prolog Python Python 3 R Rust Ruby Scala Scheme Sql Server Swift Tcl.

This project is useful in any environment where Lua code is accepted, with the powerful option of simply declaring any existing API using TypeScript declaration files. Type Safety Static types can ease the mental burden of writing programs, by automatically tracking information the programmer would otherwise have to track mentally in some fashion. Universal-transpiler is a source-to-source compiler that translates a small subset of several programming languages into several others. It is also able to translate several metasyntax notations, such as EBNF and ABNF. Universal-transpiler was written as an experimental “proof-of-concept,” so it can only translate relatively simple programs.

This is the second installment of the notes I am taking while fighting with Lua and C++ to get along. If you have not yet, you may want to read my first post about Running a Lua 5.2 script from C++. Mostly, I have been studying the code from the Lua-User Wiki Sample Code and the Lua 5.2 Reference Manual.

Last post was not complicated at all, right? Actually, it does not demonstrate the real power of embedding Lua in your C++ program. I hope that with this example I convince you into further studying and using Lua for your applications.

Our goal is twofold. Firstly, we will pass some arguments from the host (C++ program) to a Lua script. Secondly, we will recover in the host some return values from the same script. Yes, return values. Plural because Lua can return more than one argument!

Lua script

The Lua script is just a parrot displaying all the variables we pass through a global sequence called “arg”, and a dispenser of variables of different Lua types. It looks like this:

Now we have to make a C++ program to pass the information to Lua, execute the script, and recover the information returned from it.

C++ program

As in the previous tutorial, I will give you the whole enchilada and then we will discuss the different pieces in more detail.

As you can see, the basic structure of the previous tutorial is preserved. We open the Lua state, load libraries, work on the Lua virtual machine, and close the Lua state. The output of the program is:

The details

The keen reader would have noticed that we drop the luaL_dofile() “function” — actually it is a macro — for running the script. Instead we load the script into the Lua stack (more about Lua stack bellow) using luaL_loadfile() and run it using lua_pcall(). This is just to show how the luaL_dofile macro works. It is defined as:

according to the Lua reference manual. So there is, essentially, nothing new there.

I think it is time we introduce the Lua stack. The Lua stack serves as a bridge between the host and Lua. The host can place values in the stack that will be visible to the Lua virtual machine, and the Lua virtual machine can place values in the stack that will be visible by the host. It sounds primitive but it is effective. The next piece of code uses it intensively:

It is responsible for the creation of the “arg” global table that will be passed to Lua as input argument. The table will be a sequence and will have two elements:

The code can be separated in three parts:

Creation of the table
Population of the table
Appellation of the table

The first part is accomplished by the lua_createtable() function. This function creates an unnamed table and stores it as the top value of the stack. Its definition is

where the narr and nrec arguments are our estimation of the number of elements as a sequence and number of non-sequential elements, respectively. Since our table has only two sequential elements, we choose 2 and 0 as our narr and nrec arguments.

Lua To Lua C Converter

Next we populate the table with our desired values. For that purpose we push to the stack two values using the lua_push*() set of functions. The first pushed valued is the table index in which we want to store some value. The second pushed value is the actual value we want to store in the table. Then, with lua_settable(lua_state, -3) we we perform in the table, t, stored as the third value in the stack — that is what -3 means — the operation:

where v and k are the top and second element of the stack. Therefore, this code:

just sets the index 1 of our unnamed table to the value 49. Notice that it also pops the index and value stored in the stack, leaving the table as the top value of the stack.

The last thing we have to do is name the table we have created and populated. This is accomplished by the lua_setglobal() sentence, which pops the top of the stack — our table — and sets it as a global table under the given name — in our case “arg”. Lua will be able to see this table from the script.

Once our script has run, the Lua return values are accessed from C++ via the stack. Notice that Lua pushes first the first return value, and last the last one. Thus, popping from the stack recovers the return values in inverse order compared to the return statement in Lua.

The piece of code that makes use of the returned values is large because it has all the verbose system attached. Essentially, it only consists in four operations:

Get the stack top position using lua_gettop()
Get the type of the value stored in a certain stack position using lua_type()
Convert a stack value into a C++ value using the set of lua_to*() functions
Pop values from the stack using lua_pop()

which are quite self-explanatory.

And that is it!

This covers the basics of sharing data between the host program and Lua. For instance, you can play with the program changing the Lua script and seeing how the output changes according to that. Remember that you do not need to recompile to see the effects!

~~Stay tuned for the next episode, which will be something related to calling C++ functions from Lua.~~ Read the next tutorial!

Introduction

LuaSQL is a simple interface from Lua to a number of database management systems.It includes a set of drivers to some popular databases(currently PostgreSQL, ODBC, MySQL, SQLite, Oracle, and ADO; Interbase and Sybase are in our plans).LuaSQL defines a simple object-oriented API.All drivers should implement this common API,but each one is free to offer extensions.

LuaSQL defines one single global variable,a table called luasql.This table is used to store the initialization methods of theloaded drivers.These methods are used to create anenvironment objectwhich is used to create aconnection object.A connection object can execute SQL statements and eventuallycreate acursor objectwhich is used to retrieve data.

LuaSQL is free software and uses the samelicenseas Lua 5.1.

Compiling

LuaSQL is distributed as a set of C source files:a pair of common source and header files (luasql.h and luasql.c);and one source file for each driver.Each driver should be compiled with the luasql.c file to generate a library.This library can be linked to the application or dynamically loaded. The initialization function is luaopen_luasqldrivername and it is a Luaopen-library compatible function.

Installation

Since version 2.3, all LuaSQL drivers follow the package model of Lua 5.2.All drivers should be 'installed' in your package.cpath into afolder called luasql.

In order to use LuaSQL with ADO, make

Lua To Lua C Converter Online