1.lua

print("Hallo von Lua!")

1.c

#include "lua50/lua.h"
#include "lua50/lualib.h"
#include "lua50/lauxlib.h"

/*
   Ceci n'est pas de la programmation Lua à proprement parler, mais son
   Interaction de l'interpréteur Lua et un exécutable C.

   Cette pratique permet d'intégrer (embedding) l'interpréteur, exactement
   comme de grosses applications le font (Far Cry, etc...) lorsqu'elles
   ont besoin d'interfacer du code utilisateur par des scripts triviaux.
*/

int main(int argc, char* argv[])
{
  lua_State* L = lua_open();
  luaopen_base(L);
  luaopen_io(L);

  lua_dofile(L,"1.lua");

  lua_close(L);
  return 0;
}

/*
Compiler/Exécuter avec
  $ gcc -Wall -s -o 1 1.c -llua50 -llualib50 
  $ ./1
  Hallo von Lua!

 Ce qui se passe, c'est que l'interpréteur Lua est intégré dans l' exécutable,
 en étant linké é la compilation.

 Lua permet la précompilation de code Lua en bytecode:
 $ luac -s -o hello.bytecode 1.lua
 Ce bytecode est également interprétable par "notre" exécutable:
 $ ./1 hello.bytecode
  Hallo von Lua!
 112 octets le fichier. C'est mieux que le meilleur des assembleurs.

*/

Exposer une fonction

#include "lua50/lua.h"
#include "lua50/lualib.h"
#include "lua50/lauxlib.h"

/*
  Ceci est une transposition en C du code C++ de http://csl.sublevel3.org/lua/

  Consiste é écrire une fonction C et l' appeler depuis un script
  Lua. Pour celé il faut enregistrer la fonction dans l'environnnement Lua
  avec lua_register().

  Additionnellement, une fonction récupére les erreurs retournées par
  l'interprétation du script.

  Pour différencier ce que dit l'exécutable et le script, un '>' précéde les
  messages de l' exécutable.
*/

/* La fonction prend x arguments et retourne un nombre avec lua_pushnumber() */
int ma_function(lua_State *L)
{
  int argc, n;
  argc = lua_gettop(L);

  printf("> ma_function() appelée avec %d arguments\n", argc);

  for (n=1; n<=argc; ++n )
    printf("> argument %d: %s\n", n, lua_tostring(L, n) );

  lua_pushnumber(L, 123); // return value
  return 1; // number of return values
}

void report_errors(lua_State *L, int status) {
  if ( status!=0 ) {
    printf("%s\n", lua_tostring(L, -1) );
    lua_pop(L, 1); // remove error message
  }
}

int main(int argc, char* argv[])
{
   int n;
   const char* file;

   if (argc<2)
   {
    puts("usage: ./2 [FICHIER.LUA]");
    return 1;
   }

   // exécute chaque fichier passé en argument
   for (n=1; n<argc; ++n ) {
      file = argv[n];

      lua_State* L = lua_open();
      luaopen_io(L); // provides io.*
      luaopen_base(L);
      luaopen_table(L);
      luaopen_string(L);
      luaopen_math(L);
      luaopen_loadlib(L);
 
      // Enregistre la fonction en lui passant le pointeur de fonction
      // la partie entre guillemets apparaitra dans le script.
      lua_register(L, "ma_function", ma_function);

      printf("> Chargement de %s\n", file);
      int s = luaL_loadfile(L, file);

      // Execute programme Lua
      if ( s==0 ) s = lua_pcall(L, 0, LUA_MULTRET, 0);

      report_errors(L, s);
      // terminato
      lua_close(L);
  }
 
  return 0;
}

/*
 Compilation:
 $ gcc -Wall -s -o 2 2.c -llua50 -llualib50 

 Le script 2.lua:
  io.write("Running ", _VERSION, "\n")
  a = ma_function(1, 2, 3, "abc", "def")
  io.write("ma_function() a returné ", a, "\n"

 Ce script commence par écrire la version de l'interpréteur lua.
 Ensuite il déclare une fonction (LA fonction C) l' appelle en
 lui passant 5 arguments.
 Enfin il affiche ce qu'a retourné la fonction.

 Exécution:
 $ ./2 2.lua
 > Chargement de 2.lua
 2.lua:4: `)' expected (to close `(' at line 3) near `<eof>'

 L'erreur du scirpt est récupérée. La corriger, puis

 $ ./2 2.lua
 > Chargement de 2.lua
 Running Lua 5.0.2
 > ma_function() appelee avec 5 arguments
 > argument 1: 1
 > argument 2: 2
 > argument 3: 3
 > argument 4: abc
 > argument 5: def
 ma_function() returned 123

*/

2.lua

io.write("Running ", _VERSION, "\n")
a = ma_function(1, 2, 3, "abc", "def")
io.write("ma_function() returned ", a, "\n")