unit LuaPas;

(*

 * A complete Pascal wrapper for Lua 5.1 DLL module.

 *

 * Created by Geo Massar, 2006

 * Distributed as free/open source.

 *)

interface

{.$DEFINE LUA_GETHOOK}

type

  size_t   = type Cardinal;

  Psize_t  = ^size_t;

  PPointer = ^Pointer;

  lua_State = record end;

  Plua_State = ^lua_State;

const

{$IFDEF UNIX}

{$ELSE}

{$ENDIF}

(*****************************************************************************)

(*                               luaconfig.h                                 *)

(*****************************************************************************)

(*

** $Id: luaconf.h,v 1.81 2006/02/10 17:44:06 roberto Exp $

** Configuration file for Lua

** See Copyright Notice in lua.h

*)

(*

** {==================================================================

@@ LUA_NUMBER is the type of numbers in Lua.

** CHANGE the following definitions only if you want to build Lua

** with a number type different from double. You may also need to

** change lua_number2int & lua_number2integer.

** ===================================================================

*)

type

  LUA_NUMBER_  = type Double;            // ending underscore is needed in Pascal

  LUA_INTEGER_ = type LongInt;

(*

@@ LUA_IDSIZE gives the maximum size for the description of the source

@* of a function in debug information.

** CHANGE it if you want a different size.

*)

const

  LUA_IDSIZE = 60;

(*

@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.

*)

const

  LUAL_BUFFERSIZE = 1024;

(*

@@ LUA_PROMPT is the default prompt used by stand-alone Lua.

@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.

** CHANGE them if you want different prompts. (You can also change the

** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)

*)

const

  LUA_PROMPT  = '> ';

  LUA_PROMPT2 = '>> ';

(*

@@ lua_readline defines how to show a prompt and then read a line from

@* the standard input.

@@ lua_saveline defines how to "save" a read line in a "history".

@@ lua_freeline defines how to free a line read by lua_readline.

** CHANGE them if you want to improve this functionality (e.g., by using

** GNU readline and history facilities).

*)

function  lua_readline(L : Plua_State; var b : PChar; p : PChar): Boolean;

procedure lua_saveline(L : Plua_State; idx : LongInt);

procedure lua_freeline(L : Plua_State; b : PChar);

(*

@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that

@* is, whether we're running lua interactively).

** CHANGE it if you have a better definition for non-POSIX/non-Windows

** systems.

*/

#include <io.h>

#include <stdio.h>

#define lua_stdin_is_tty()	_isatty(_fileno(stdin))

*)

const

  lua_stdin_is_tty = TRUE;

(*****************************************************************************)

(*                                  lua.h                                    *)

(*****************************************************************************)

(*

** $Id: lua.h,v 1.216 2006/01/10 12:50:13 roberto Exp $

** Lua - An Extensible Extension Language

** Lua.org, PUC-Rio, Brazil (http://www.lua.org)

** See Copyright Notice at the end of this file

*)

const

  LUA_VERSION     = 'Lua 5.1';

  LUA_VERSION_NUM = 501;

  LUA_COPYRIGHT   = 'Copyright (C) 1994-2006 Tecgraf, PUC-Rio';

  LUA_AUTHORS     = 'R. Ierusalimschy, L. H. de Figueiredo & W. Celes';

  (* mark for precompiled code (`<esc>Lua') *)

  LUA_SIGNATURE = #27'Lua';

  (* option for multiple returns in `lua_pcall' and `lua_call' *)

  LUA_MULTRET = -1;

  (*

  ** pseudo-indices

  *)

  LUA_REGISTRYINDEX = -10000;

  LUA_ENVIRONINDEX  = -10001;

  LUA_GLOBALSINDEX  = -10002;

function lua_upvalueindex(idx : LongInt) : LongInt;   // a marco

const

  (* thread status; 0 is OK *)

  LUA_YIELD_    = 1;     // Note: the ending underscore is needed in Pascal

  LUA_ERRRUN    = 2;

  LUA_ERRSYNTAX = 3;

  LUA_ERRMEM    = 4;

  LUA_ERRERR    = 5;

type

  lua_CFunction = function(L : Plua_State) : LongInt; cdecl;

  (*

  ** functions that read/write blocks when loading/dumping Lua chunks

  *)

  lua_Reader = function (L : Plua_State; ud : Pointer;

                         sz : Psize_t) : PChar; cdecl;

  lua_Writer = function (L : Plua_State; const p : Pointer; sz : size_t;

                         ud : Pointer) : LongInt; cdecl;

  (*

  ** prototype for memory-allocation functions

  *)

  lua_Alloc = function (ud, ptr : Pointer;

                        osize, nsize : size_t) : Pointer; cdecl;

const

  (*

  ** basic types

  *)

  LUA_TNONE          = -1;

  LUA_TNIL           = 0;

  LUA_TBOOLEAN       = 1;

  LUA_TLIGHTUSERDATA = 2;

  LUA_TNUMBER        = 3;

  LUA_TSTRING        = 4;

  LUA_TTABLE         = 5;

  LUA_TFUNCTION      = 6;

  LUA_TUSERDATA	     = 7;

  LUA_TTHREAD        = 8;

  (* minimum Lua stack available to a C function *)

  LUA_MINSTACK = 20;

type

  (* type of numbers in Lua *)

  lua_Number = LUA_NUMBER_;

  (* type for integer functions *)

  lua_Integer = LUA_INTEGER_;

(*

** state manipulation

*)

function  lua_newstate(f : lua_Alloc; ud : Pointer) : Plua_State;

procedure lua_close(L: Plua_State);

function  lua_newthread(L : Plua_State) : Plua_State;

function  lua_atpanic(L : Plua_State; panicf : lua_CFunction) : lua_CFunction;

(*

** basic stack manipulation

*)

function  lua_gettop(L : Plua_State) : LongInt;

procedure lua_settop(L : Plua_State; idx : LongInt);

procedure lua_pushvalue(L : Plua_State; idx : LongInt);

procedure lua_remove(L : Plua_State; idx : LongInt);

procedure lua_insert(L : Plua_State; idx : LongInt);

procedure lua_replace(L : Plua_State; idx : LongInt);

function  lua_checkstack(L : Plua_State; sz : LongInt) : LongBool;

procedure lua_xmove(src, dest : Plua_State; n : LongInt);

(*

** access functions (stack -> C)

*)

function lua_isnumber(L : Plua_State; idx : LongInt) : LongBool;

function lua_isstring(L : Plua_State; idx : LongInt) : LongBool;

function lua_iscfunction(L : Plua_State; idx : LongInt) : LongBool;

function lua_isuserdata(L : Plua_State; idx : LongInt) : LongBool;

function lua_type(L : Plua_State; idx : LongInt) : LongInt;

function lua_typename(L : Plua_State; tp : LongInt) : PChar;

function lua_equal(L : Plua_State; idx1, idx2 : LongInt) : LongBool;

function lua_rawequal(L : Plua_State; idx1, idx2 : LongInt) : LongBool;

function lua_lessthan(L : Plua_State; idx1, idx2 : LongInt) : LongBool;

function lua_tonumber(L : Plua_State; idx : LongInt) : lua_Number;

function lua_tointeger(L : Plua_State; idx : LongInt) : lua_Integer;

function lua_toboolean(L : Plua_State; idx : LongInt) : LongBool;

function lua_tolstring(L : Plua_State; idx : LongInt;

                       len : Psize_t) : PChar;

function lua_objlen(L : Plua_State; idx : LongInt) : size_t;

function lua_tocfunction(L : Plua_State; idx : LongInt) : lua_CFunction;

function lua_touserdata(L : Plua_State; idx : LongInt) : Pointer;

function lua_tothread(L : Plua_State; idx : LongInt) : Plua_State;

function lua_topointer(L : Plua_State; idx : LongInt) : Pointer;

(*

** push functions (C -> stack)

*)

procedure lua_pushnil(L : Plua_State);

procedure lua_pushnumber(L : Plua_State; n : lua_Number);

procedure lua_pushinteger(L : Plua_State; n : lua_Integer);

procedure lua_pushlstring(L : Plua_State; const s : PChar; ls : size_t);

procedure lua_pushstring(L : Plua_State; const s : PChar);

function  lua_pushvfstring(L : Plua_State;

                           const fmt : PChar; argp : Pointer) : PChar;

function  lua_pushfstring(L : Plua_State; const fmt : PChar) : PChar; varargs;

procedure lua_pushcclosure(L : Plua_State; fn : lua_CFunction; n : LongInt);

procedure lua_pushboolean(L : Plua_State; b : LongBool);

procedure lua_pushlightuserdata(L : Plua_State; p : Pointer);

function  lua_pushthread(L : Plua_state) : Cardinal;

(*

** get functions (Lua -> stack)

*)

procedure lua_gettable(L : Plua_State ; idx : LongInt);

procedure lua_getfield(L : Plua_State; idx : LongInt; k : PChar);

procedure lua_rawget(L : Plua_State; idx : LongInt);

procedure lua_rawgeti(L : Plua_State; idx, n : LongInt);

procedure lua_createtable(L : Plua_State; narr, nrec : LongInt);

function  lua_newuserdata(L : Plua_State; sz : size_t) : Pointer;

function  lua_getmetatable(L : Plua_State; objindex : LongInt) : LongBool;

procedure lua_getfenv(L : Plua_State; idx : LongInt);

(*

** set functions (stack -> Lua)

*)

procedure lua_settable(L : Plua_State; idx : LongInt);

procedure lua_setfield(L : Plua_State; idx : LongInt; const k : PChar);

procedure lua_rawset(L : Plua_State; idx : LongInt);

procedure lua_rawseti(L : Plua_State; idx , n: LongInt);

function lua_setmetatable(L : Plua_State; objindex : LongInt): LongBool;

function lua_setfenv(L : Plua_State; idx : LongInt): LongBool;

(*

** `load' and `call' functions (load and run Lua code)

*)

procedure lua_call(L : Plua_State; nargs, nresults : LongInt);

function  lua_pcall(L : Plua_State;

                    nargs, nresults, errfunc : LongInt) : LongInt;

function  lua_cpcall(L : Plua_State;

                     func : lua_CFunction; ud : Pointer) : LongInt;

function  lua_load(L : Plua_State; reader : lua_Reader;

                   dt : Pointer; const chunkname : PChar) : LongInt;

function lua_dump(L : Plua_State; writer : lua_Writer; data: Pointer) : LongInt;

(*

** coroutine functions

*)

function lua_yield(L : Plua_State; nresults : LongInt) : LongInt;

function lua_resume(L : Plua_State; narg : LongInt) : LongInt;

function lua_status(L : Plua_State) : LongInt;

(*

** garbage-collection functions and options

*)

const

  LUA_GCSTOP       = 0;

  LUA_GCRESTART    = 1;

  LUA_GCCOLLECT    = 2;

  LUA_GCCOUNT      = 3;

  LUA_GCCOUNTB	   = 4;

  LUA_GCSTEP       = 5;

  LUA_GCSETPAUSE   = 6;

  LUA_GCSETSTEPMUL = 7;

function lua_gc(L : Plua_State; what, data : LongInt) : LongInt;

(*

** miscellaneous functions

*)

function lua_error(L : Plua_State) : LongInt;

function lua_next(L : Plua_State; idx : LongInt) : LongInt;

procedure lua_concat(L : Plua_State; n : LongInt);

function  lua_getallocf(L : Plua_State; ud : PPointer) : lua_Alloc;

procedure lua_setallocf(L : Plua_State; f : lua_Alloc; ud : Pointer);

(*

** ===============================================================

** some useful macros

** ===============================================================

*)

procedure lua_pop(L : Plua_State; n : LongInt);

procedure lua_newtable(L : Plua_State);

procedure lua_register(L : Plua_State; n : PChar; f : lua_CFunction);

procedure lua_pushcfunction(L : Plua_State; f : lua_CFunction);

function  lua_strlen(L : Plua_State; idx : LongInt) : LongInt;

function lua_isfunction(L : Plua_State; n : LongInt) : Boolean;

function lua_istable(L : Plua_State; n : LongInt) : Boolean;

function lua_islightuserdata(L : Plua_State; n : LongInt) : Boolean;

function lua_isnil(L : Plua_State; n : LongInt) : Boolean;

function lua_isboolean(L : Plua_State; n : LongInt) : Boolean;

function lua_isthread(L : Plua_State; n : LongInt) : Boolean;

function lua_isnone(L : Plua_State; n : LongInt) : Boolean;

function lua_isnoneornil(L : Plua_State; n : LongInt) : Boolean;

procedure lua_pushliteral(L : Plua_State; s : PChar);

procedure lua_setglobal(L : Plua_State; s : PChar);

procedure lua_getglobal(L : Plua_State; s : PChar);

function lua_tostring(L : Plua_State; idx : LongInt) : PChar;

(*

** compatibility macros and functions

*)

function lua_open : Plua_State;

procedure lua_getregistry(L : Plua_State);

function lua_getgccount(L : Plua_State) : LongInt;

type

  lua_Chuckreader = type lua_Reader;

  lua_Chuckwriter = type lua_Writer;

(* ====================================================================== *)

(*

** {======================================================================

** Debug API

** =======================================================================

*)

(*

** Event codes

*)

const

  LUA_HOOKCALL    = 0;

  LUA_HOOKRET     = 1;

  LUA_HOOKLINE    = 2;

  LUA_HOOKCOUNT   = 3;

  LUA_HOOKTAILRET = 4;

(*

** Event masks

*)

  LUA_MASKCALL  = 1 shl LUA_HOOKCALL;

  LUA_MASKRET   = 1 shl LUA_HOOKRET;

  LUA_MASKLINE  = 1 shl LUA_HOOKLINE;

  LUA_MASKCOUNT = 1 shl LUA_HOOKCOUNT;

type

  lua_Debug = packed record

    event : LongInt;

    name : PChar;          (* (n) *)

    namewhat : PChar;      (* (n) `global', `local', `field', `method' *)

    what : PChar;          (* (S) `Lua', `C', `main', `tail' *)

    source : PChar;        (* (S) *)

    currentline : LongInt; (* (l) *)

    nups : LongInt;        (* (u) number of upvalues *)

    linedefined : LongInt; (* (S) *)

    short_src : array [0..LUA_IDSIZE-1] of Char; (* (S) *)

    (* private part *)

    i_ci : LongInt;        (* active function *)

  end;

  Plua_Debug = ^lua_Debug;

  (* Functions to be called by the debuger in specific events *)

  lua_Hook = procedure (L : Plua_State; ar : Plua_Debug); cdecl;

function lua_getstack(L : Plua_State; level : LongInt;

                      ar : Plua_Debug) : LongInt;

function lua_getinfo(L : Plua_State; const what : PChar;

                     ar: Plua_Debug): LongInt;

function lua_getlocal(L : Plua_State;

                      ar : Plua_Debug; n : LongInt) : PChar;

function lua_setlocal(L : Plua_State;

                      ar : Plua_Debug; n : LongInt) : PChar;

function lua_getupvalue(L : Plua_State; funcindex, n : LongInt) : PChar;

function lua_setupvalue(L : Plua_State; funcindex, n : LongInt) : PChar;

function lua_sethook(L : Plua_State; func : lua_Hook;

                     mask, count: LongInt): LongInt;

{$IFDEF LUA_GETHOOK}

function lua_gethook(L : Plua_State) : lua_Hook;

{$ENDIF}

function lua_gethookmask(L : Plua_State) : LongInt;