DelphiLua/Lua.API.pas

{
  Header for Lua 5.2.1 Binaries DLL
    http://luabinaries.sourceforge.net/

  Delphi conversion by M. van Renswoude, April 2014:

  This software is provided 'as-is', without any express or implied
  warranty. In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

     1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.

     2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.

     3. This notice may not be removed or altered from any source
     distribution.
}
unit Lua.API;

interface
uses
  System.SysUtils;


const
  LUA_VERSION_MAJOR   = '5';
  LUA_VERSION_MINOR	  = '2';
  LUA_VERSION_NUM	    = 502;
  LUA_VERSION_RELEASE = '1';

  LUA_VERSION_  = 'Lua ' + LUA_VERSION_MAJOR + '.' + LUA_VERSION_MINOR;
  LUA_RELEASE   = LUA_VERSION_ + '.' + LUA_VERSION_RELEASE;
  LUA_COPYRIGHT = LUA_RELEASE + '  Copyright (C) 1994-2012 Lua.org, PUC-Rio';
  LUA_AUTHORS   = 'R. Ierusalimschy, L. H. de Figueiredo, W. Celes';


  { mark for precompiled code ('<esc>Lua') }
  LUA_SIGNATURE	= #33'Lua';

  { option for multiple returns in 'lua_pcall' and 'lua_call' }
  LUA_MULTRET = -1;


  { reserve some space for error handling }
  LUAI_MAXSTACK	= 1000000;
  LUAI_FIRSTPSEUDOIDX	= (-LUAI_MAXSTACK - 1000);

  { pseudo-indices }
  LUA_REGISTRYINDEX = LUAI_FIRSTPSEUDOIDX;

  function lua_upvalueindex(idx: Integer): Integer; inline;

const
  { thread status }
  LUA_OK        = 0;
  LUA_YIELD_    = 1;
  LUA_ERRRUN	  = 2;
  LUA_ERRSYNTAX = 3;
  LUA_ERRMEM	  = 4;
  LUA_ERRGCMM	  = 5;
  LUA_ERRERR	  = 6;


type
  size_t = NativeUint;
  psize_t = ^size_t;

  lua_State = type Pointer;

  lua_CFunction = function(L: lua_State): Integer; cdecl;

  { functions that read/write blocks when loading/dumping Lua chunks }
  lua_Reader = function(L: lua_State; ud: Pointer; var sz: size_t): PAnsiChar; cdecl;
  lua_Writer = function(L: lua_State; p: Pointer; sz: size_t; ud: Pointer): Integer; 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;

  LUA_NUMTAGS = 9;

  { minimum Lua stack available to a C function }
  LUA_MINSTACK = 20;


  { predefined values in the registry }
  LUA_RIDX_MAINTHREAD = 1;
  LUA_RIDX_GLOBALS = 2;
  LUA_RIDX_LAST = LUA_RIDX_GLOBALS;


type
  { type of numbers in Lua }
  lua_Number = type Double;

  { type for integer functions }
  lua_Integer = type Integer;

  { unsigned integer type }
  lua_Unsigned = type Cardinal;


var
  { state manipulation }
  lua_newstate: function(f: lua_Alloc; ud: Pointer): lua_State; cdecl;
  lua_close: procedure(L: lua_State); cdecl;
  lua_newthread: function(L: lua_State): lua_State; cdecl;

  lua_atpanic: function(L: lua_State; panicf: lua_CFunction): lua_CFunction; cdecl;
  lua_version: function(L: lua_State): lua_Number; cdecl;

  { basic stack manipulation }
  lua_absindex: function(L: lua_State; idx: Integer): Integer; cdecl;
  lua_gettop: function(L: lua_State): Integer; cdecl;

  lua_settop: procedure(L: lua_State; idx: Integer); cdecl;
  lua_pushvalue: procedure(L: lua_State; idx: Integer); cdecl;
  lua_remove: procedure(L: lua_State; idx: Integer); cdecl;
  lua_insert: procedure(L: lua_State; idx: Integer); cdecl;
  lua_replace: procedure(L: lua_State; idx: Integer); cdecl;
  lua_copy: procedure(L: lua_State; fromidx, toidx: Integer); cdecl;
  lua_checkstack: function(L: lua_State; sz: Integer): Integer; cdecl;

  lua_xmove: procedure(from: lua_State; _to: lua_State; n: Integer); cdecl;

  { access functions (stack -> C) }
  lua_isnumber: function (L: lua_State; idx: Integer): Integer; cdecl;
  lua_isstring: function (L: lua_State; idx: Integer): Integer; cdecl;
  lua_iscfunction: function (L: lua_State; idx: Integer): Integer; cdecl;
  lua_isuserdata: function (L: lua_State; idx: Integer): Integer; cdecl;
  lua_type: function (L: lua_State; idx: Integer): Integer; cdecl;
  lua_typename: function (L: lua_State; tp: Integer): PAnsiChar; cdecl;
  lua_tonumberx: function (L: lua_State; idx: Integer; isnum: PInteger): lua_Number; cdecl;
  lua_tointegerx: function (L: lua_State; idx: Integer; isnum: PInteger): lua_Integer; cdecl;
  lua_tounsignedx: function (L: lua_State; idx: Integer; isnum: PInteger): lua_Unsigned; cdecl;
  lua_toboolean: function (L: lua_State; idx: Integer): Integer; cdecl;
  lua_tolstring: function(L: lua_State; idx: Integer; len: psize_t): PAnsiChar; cdecl;
  lua_rawlen: function (L: lua_State; idx: Integer): size_t; cdecl;
  lua_tocfunction: function (L: lua_State; idx: Integer): lua_CFunction; cdecl;
  lua_touserdata: function (L: lua_State; idx: Integer): Pointer; cdecl;
  lua_tothread: function (L: lua_State; idx: Integer): lua_State; cdecl;
  lua_topointer: function (L: lua_State; idx: Integer): Pointer; cdecl;


const
  { Comparison and arithmetic functions }
  LUA_OPADD = 0; { ORDER TM }
  LUA_OPSUB = 1;
  LUA_OPMUL = 2;
  LUA_OPDIV = 3;
  LUA_OPMOD = 4;
  LUA_OPPOW = 5;
  LUA_OPUNM = 6;


var
  lua_arith: procedure(L: lua_State; op: Integer); cdecl;


const
  LUA_OPEQ = 0;
  LUA_OPLT = 1;
  LUA_OPLE = 2;


var
  lua_rawequal: function(L: lua_State; idx1, idx2: Integer): Integer; cdecl;
  lua_compare: function(L: lua_State; idx1, idx2, op: Integer): Integer; cdecl;


  { push functions (C -> stack) }
  lua_pushnil: procedure(L: lua_State); cdecl;
  lua_pushnumber: procedure(L: lua_State; n: lua_Number); cdecl;
  lua_pushinteger: procedure(L: lua_State; n: lua_Integer); cdecl;
  lua_pushunsigned: procedure(L: lua_State; n: lua_Unsigned); cdecl;
  lua_pushlstring: function (L: lua_State; s: PAnsiChar; l_: size_t): PAnsiChar; cdecl;
  lua_pushstring: function (L: lua_State; s: PAnsiChar): PAnsiChar; cdecl;
  lua_pushvfstring: function (L: lua_State; fmt: PAnsiChar; argp: Pointer): PAnsiChar; cdecl;
  lua_pushfstring: function (L: lua_State; fmt: PAnsiChar; argp: Pointer): PAnsiChar; cdecl;
  lua_pushcclosure: procedure(L: lua_State; fn: lua_CFunction; n: Integer); cdecl;
  lua_pushboolean: procedure(L: lua_State; b: Integer); cdecl;
  lua_pushlightuserdata: procedure(L: lua_State; p: Pointer); cdecl;
  lua_pushthread: function (L: lua_State): Integer; cdecl;

  { get functions (Lua -> stack) }
  lua_getglobal: procedure(L: lua_State; value: PAnsiChar); cdecl;
  lua_gettable: procedure(L: lua_State; idx: Integer); cdecl;
  lua_getfield: procedure(L: lua_State; idx: Integer; k: PAnsiChar); cdecl;
  lua_rawget: procedure(L: lua_State; idx: Integer); cdecl;
  lua_rawgeti: procedure(L: lua_State; idx, n: Integer); cdecl;
  lua_rawgetp: procedure(L: lua_State; idx: Integer; p: Pointer); cdecl;
  lua_createtable: procedure(L: lua_State; narr: Integer; nrec: Integer); cdecl;
  lua_newuserdata: procedure(L: lua_State; sz: size_t); cdecl;
  lua_getmetatable: function(L: lua_State; objindex: Integer): Integer; cdecl;
  lua_getuservalue: procedure(L: lua_State; idx: Integer); cdecl;

  { set functions (stack -> Lua) }
  lua_setglobal: procedure(L: lua_State; value: PAnsiChar); cdecl;
  lua_settable: procedure(L: lua_State; idx: Integer); cdecl;
  lua_setfield: procedure(L: lua_State; idx: Integer; k: PAnsiChar); cdecl;
  lua_rawset: procedure(L: lua_State; idx: Integer); cdecl;
  lua_rawseti: procedure(L: lua_State; idx, n: Integer); cdecl;
  lua_rawsetp: procedure(L: lua_State; idx: Integer; p: Pointer); cdecl;
  lua_setmetatable: function(L: lua_State; objindex: Integer): Integer; cdecl;
  lua_setuservalue: procedure(L: lua_State; idx: Integer); cdecl;


  { 'load' and 'call' functions (load and run Lua code) }
  lua_callk: procedure(L: lua_State; nargs, nresults, ctx: Integer; k: lua_CFunction); cdecl;
  lua_getctx: function(L: lua_State; var ctx: Integer): Integer; cdecl;
  lua_pcallk: function(L: lua_State; nargs, nresults, errfunc, ctx: Integer; k: lua_CFunction): Integer; cdecl;

  lua_load: function(L: lua_State; reader: lua_Reader; dt: Pointer; chunkname, mode: PAnsiChar): Integer; cdecl;
  lua_dump: function(L: lua_State; writer: lua_Writer; data: Pointer): Integer; cdecl;


  procedure lua_call(L: lua_State; nargs, nresults: Integer); inline;
  function lua_pcall(L: lua_State; nargs, nresults, errfunc: Integer): Integer; inline;


var
  { coroutine functions }
  lua_yieldk: function(L: lua_State; nresults, ctx: Integer; k: lua_CFunction): Integer; cdecl;
  lua_resume: function(L, from: lua_State; nargs: Integer): Integer; cdecl;
  lua_status: function(L: lua_State): Integer; cdecl;

  function lua_yield(L: lua_State; nresults: Integer): Integer; inline;


const
  { garbage-collection function and options }
  LUA_GCSTOP = 0;
  LUA_GCRESTART = 1;
  LUA_GCCOLLECT = 2;
  LUA_GCCOUNT = 3;
  LUA_GCCOUNTB = 4;
  LUA_GCSTEP = 5;
  LUA_GCSETPAUSE = 6;
  LUA_GCSETSTEPMU = 7;
  LUA_GCSETMAJORIN = 8;
  LUA_GCISRUNNING = 9;
  LUA_GCGEN = 0;
  LUA_GCINC = 1;

var
  lua_gc: function(L: lua_State; what, data: Integer): Integer; cdecl;


var
  { miscellaneous functions }
  lua_error: function(L: lua_State): Integer; cdecl;
  lua_next: function(L: lua_State; idx: Integer): Integer; cdecl;

  lua_concat: procedure(L: lua_State; n: Integer); cdecl;
  lua_len: procedure(L: lua_State; idx: Integer); cdecl;

  lua_getallocf: function(L: lua_State; ud: Pointer): lua_Alloc; cdecl;
  lua_setallocf: procedure(L: lua_State; f: lua_Alloc; ud: Pointer); cdecl;


  { some useful macros }
  function lua_tonumber(L: lua_State; idx: Integer): lua_Number; inline;
  function lua_tointeger(L: lua_State; idx: Integer): lua_Integer; inline;
  function lua_tounsigned(L: lua_State; idx: Integer): lua_Unsigned; inline;

  procedure lua_pop(L: lua_State; n: Integer); inline;
  procedure lua_newtable(L: lua_State); inline;
  procedure lua_register(L: lua_State; name: PAnsiChar; f: lua_CFunction); inline;
  procedure lua_pushcfunction(L: lua_State; f: lua_CFunction); inline;

  function lua_isfunction(L: lua_State; n: Integer): Boolean; inline;
  function lua_istable(L: lua_State; n: Integer): Boolean; inline;
  function lua_islightuserdata(L: lua_State; n: Integer): Boolean; inline;
  function lua_isnil(L: lua_State; n: Integer): Boolean; inline;
  function lua_isboolean(L: lua_State; n: Integer): Boolean; inline;
  function lua_isthread(L: lua_State; n: Integer): Boolean; inline;
  function lua_isnone(L: lua_State; n: Integer): Boolean; inline;
  function lua_isnoneornil(L: lua_State; n: Integer): Boolean; inline;
  function lua_pushliteral(L: lua_State; const s: AnsiString): PAnsiChar; inline;

  procedure lua_pushglobaltable(L: lua_State); inline;
  function lua_tostring(L: lua_State; idx: Integer): PAnsiChar; inline;


const
  {======================================================================
   Debug API
  =======================================================================}

  { Event codes }
  LUA_HOOKCALL  = 0;
  LUA_HOOKRET = 1;
  LUA_HOOKLINE  = 2;
  LUA_HOOKCOUNT = 3;
  LUA_HOOKTAILCALL = 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);


const
  LUA_IDSIZE = 60;


type
  lua_Debug = record
    event: Integer;
    name: PAnsiChar;
    namewhat: PAnsiChar; // 'global', 'local', 'field', 'method'
    what: PAnsiChar; // 'Lua', 'C', 'main', 'tail'
    source: PAnsiChar;
    currentline: Integer;
    linedefined: Integer;
    lastlinedefined: Integer;
    nups: Byte;
    nparams: Byte;
    isvararg: Byte;
    istailcall: Byte;
    short_src: array[0..LUA_IDSIZE - 1] of AnsiChar;
    i_ci: Integer;
  end;

  { Functions to be called by the debugger in specific events }
  lua_Hook = procedure(L: lua_State; var ar: lua_Debug); cdecl;


var
  lua_getstack: function(L: lua_State; level: Integer; var ar: lua_Debug): Integer; cdecl;
  lua_getinfo: function(L: lua_State; what: PAnsiChar; var ar: lua_Debug): Integer; cdecl;

  lua_getlocal: function(L: lua_State; var ar: lua_Debug; n: Integer): PAnsiChar; cdecl;
  lua_setlocal: function(L: lua_State; var ar: lua_Debug; n: Integer): PAnsiChar; cdecl;
  lua_getupvalue: function(L: lua_State; funcindex, n: Integer): PAnsiChar; cdecl;
  lua_setupvalue: function(L: lua_State; funcindex, n: Integer): PAnsiChar; cdecl;

  lua_upvalueid: function(L: lua_State; fidx, n: Integer): Pointer; cdecl;
  lua_upvaluejoin: procedure(L: lua_State; fidx1, n1, fidx2, n2: Integer);

  lua_sethook: function(L: lua_State; func: lua_Hook; mask, count: Integer): Integer; cdecl;
  lua_gethook: function(L: lua_State): lua_Hook; cdecl;
  lua_gethookmask: function(L: lua_State): Integer; cdecl;
  lua_gethookcount: function(L: lua_State): Integer; cdecl;

  {====================================================================== }


const
  LUA_COLIBNAME = 'coroutine';
  LUA_TABLIBNAME = 'table';
  LUA_IOLIBNAME = 'io';
  LUA_OSLIBNAME = 'os';
  LUA_STRLIBNAME = 'string';
  LUA_BITLIBNAME = 'bit32';
  LUA_MATHLIBNAME = 'math';
  LUA_DBLIBNAME = 'debug';
  LUA_LOADLIBNAME = 'package';


var
  { lualib }
  luaopen_base: function(L: lua_State): Integer; cdecl;
  luaopen_coroutine: function(L: lua_State): Integer; cdecl;
  luaopen_table: function(L: lua_State): Integer; cdecl;
  luaopen_io: function(L: lua_State): Integer; cdecl;
  luaopen_os: function(L: lua_State): Integer; cdecl;
  luaopen_string: function(L: lua_State): Integer; cdecl;
  luaopen_bit32: function(L: lua_State): Integer; cdecl;
  luaopen_math: function(L: lua_State): Integer; cdecl;
  luaopen_debug: function(L: lua_State): Integer; cdecl;
  luaopen_package: function(L: lua_State): Integer; cdecl;

  { open all previous libraries }
  luaL_openlibs: procedure(L: lua_State); cdecl;
  luaL_requiref: procedure(L: lua_State; modname: PAnsiChar; openf: lua_CFunction; glb: Integer); cdecl;



type
  luaL_Reg = record
    name: PAnsiChar;
    func: lua_CFunction;
  end;
  PluaL_Reg = ^luaL_Reg;

var
  luaL_setfuncs: procedure(L: lua_State; luaL_Reg: PluaL_Reg; nup: Integer); cdecl;

  procedure luaL_where(L: lua_State; level: Integer);
  function luaL_error(L: lua_State; fmt: PAnsiChar; argp: Pointer): Integer;



const
  DefaultLuaLibName = 'lua' + LUA_VERSION_MAJOR + LUA_VERSION_MINOR + '.dll';

  procedure LoadLuaLib(const AFileName: string = DefaultLuaLibName);
  procedure UnloadLuaLib;

  function LuaLibLoaded: Boolean;

  function DefaultLuaAlloc(ud, ptr: Pointer; osize, nsize: size_t): Pointer; cdecl;


implementation
uses
  System.Generics.Collections,
  Winapi.Windows;

var
  LuaLibHandle: THandle;
  LuaFunctions: TList<PPointer>;


function DefaultLuaAlloc(ud, ptr: Pointer; osize, nsize: size_t): Pointer;
begin
  if (nsize = 0) then
  begin
    FreeMemory(ptr);
    Result := nil;
  end else
    Result := ReallocMemory(ptr, nsize);
end;


procedure LoadLuaLib(const AFileName: string = DefaultLuaLibName);

  procedure Load(var AVariable: Pointer; const AName: string);
  begin
    AVariable := GetProcAddress(LuaLibHandle, PChar(AName));
    LuaFunctions.Add(@AVariable);
  end;


begin
  UnloadLuaLib;

  LuaLibHandle := SafeLoadLibrary(AFileName);
  if LuaLibHandle = 0 then
    RaiseLastOSError;

  if not Assigned(LuaFunctions) then
    LuaFunctions := TList<PPointer>.Create();

  Load(@lua_newstate, 'lua_newstate');
  Load(@lua_close, 'lua_close');
  Load(@lua_newthread, 'lua_newthread');

  Load(@lua_atpanic, 'lua_atpanic');
  Load(@lua_version, 'lua_version');

  Load(@lua_absindex, 'lua_absindex');
  Load(@lua_gettop, 'lua_gettop');
  Load(@lua_settop, 'lua_settop');
  Load(@lua_pushvalue, 'lua_pushvalue');
  Load(@lua_remove, 'lua_remove');
  Load(@lua_insert, 'lua_insert');
  Load(@lua_replace, 'lua_replace');
  Load(@lua_copy, 'lua_copy');
  Load(@lua_checkstack, 'lua_checkstack');
  Load(@lua_xmove, 'lua_xmove');

  Load(@lua_isnumber, 'lua_isnumber');
  Load(@lua_isstring, 'lua_isstring');
  Load(@lua_iscfunction, 'lua_iscfunction');
  Load(@lua_isuserdata, 'lua_isuserdata');
  Load(@lua_type, 'lua_type');
  Load(@lua_typename, 'lua_typename');
  Load(@lua_tonumberx, 'lua_tonumberx');
  Load(@lua_tointegerx, 'lua_tointegerx');
  Load(@lua_tounsignedx, 'lua_tounsignedx');
  Load(@lua_toboolean, 'lua_toboolean');
  Load(@lua_tolstring, 'lua_tolstring');
  Load(@lua_rawlen, 'lua_rawlen');
  Load(@lua_tocfunction, 'lua_tocfunction');
  Load(@lua_touserdata, 'lua_touserdata');
  Load(@lua_tothread, 'lua_tothread');
  Load(@lua_topointer, 'lua_topointer');

  Load(@lua_arith, 'lua_arith');
  Load(@lua_rawequal, 'lua_rawequal');
  Load(@lua_compare, 'lua_compare');

  Load(@lua_pushnil, 'lua_pushnil');
  Load(@lua_pushnumber, 'lua_pushnumber');
  Load(@lua_pushinteger, 'lua_pushinteger');
  Load(@lua_pushunsigned, 'lua_pushunsigned');
  Load(@lua_pushlstring, 'lua_pushlstring');
  Load(@lua_pushstring, 'lua_pushstring');
  Load(@lua_pushvfstring, 'lua_pushvfstring');
  Load(@lua_pushfstring, 'lua_pushfstring');
  Load(@lua_pushcclosure, 'lua_pushcclosure');
  Load(@lua_pushboolean, 'lua_pushboolean');
  Load(@lua_pushlightuserdata, 'lua_pushlightuserdata');
  Load(@lua_pushthread, 'lua_pushthread');

  Load(@lua_getglobal, 'lua_getglobal');
  Load(@lua_gettable, 'lua_gettable');
  Load(@lua_getfield, 'lua_getfield');
  Load(@lua_rawget, 'lua_rawget');
  Load(@lua_rawgeti, 'lua_rawgeti');
  Load(@lua_rawgetp, 'lua_rawgetp');
  Load(@lua_newuserdata, 'lua_newuserdata');
  Load(@lua_getmetatable, 'lua_getmetatable');
  Load(@lua_getuservalue, 'lua_getuservalue');

  Load(@lua_createtable, 'lua_createtable');
  Load(@lua_setglobal, 'lua_setglobal');
  Load(@lua_settable, 'lua_settable');
  Load(@lua_setfield, 'lua_setfield');

  Load(@lua_rawset, 'lua_rawset');
  Load(@lua_rawseti, 'lua_rawseti');
  Load(@lua_rawsetp, 'lua_rawsetp');
  Load(@lua_setmetatable, 'lua_setmetatable');
  Load(@lua_setuservalue, 'lua_setuservalue');

  Load(@lua_callk, 'lua_callk');
  Load(@lua_getctx, 'lua_getctx');
  Load(@lua_pcallk, 'lua_pcallk');

  Load(@lua_yieldk, 'lua_yieldk');
  Load(@lua_resume, 'lua_resume');
  Load(@lua_status, 'lua_status');

  Load(@lua_gc, 'lua_gc');

  Load(@lua_load, 'lua_load');
  Load(@lua_dump, 'lua_dump');

  Load(@lua_error, 'lua_error');
  Load(@lua_next, 'lua_next');

  Load(@lua_concat, 'lua_concat');
  Load(@lua_len, 'lua_len');

  Load(@lua_getallocf, 'lua_getallocf');
  Load(@lua_setallocf, 'lua_setallocf');


  Load(@lua_getstack, 'lua_getstack');
  Load(@lua_getinfo, 'lua_getinfo');

  Load(@lua_getlocal, 'lua_getlocal');
  Load(@lua_setlocal, 'lua_setlocal');
  Load(@lua_getupvalue, 'lua_getupvalue');
  Load(@lua_setupvalue, 'lua_setupvalue');

  Load(@lua_upvalueid, 'lua_upvalueid');
  Load(@lua_upvaluejoin, 'lua_upvaluejoin');

  Load(@lua_sethook, 'lua_sethook');
  Load(@lua_gethook, 'lua_gethook');
  Load(@lua_gethookmask, 'lua_gethookmask');
  Load(@lua_gethookcount, 'lua_gethookcount');

  Load(@luaopen_base, 'luaopen_base');
  Load(@luaopen_coroutine, 'luaopen_coroutine');
  Load(@luaopen_table, 'luaopen_table');
  Load(@luaopen_io, 'luaopen_io');
  Load(@luaopen_os, 'luaopen_os');
  Load(@luaopen_string, 'luaopen_string');
  Load(@luaopen_bit32, 'luaopen_bit32');
  Load(@luaopen_math, 'luaopen_math');
  Load(@luaopen_debug, 'luaopen_debug');
  Load(@luaopen_package, 'luaopen_package');

  Load(@luaL_openlibs, 'luaL_openlibs');
  Load(@luaL_requiref, 'luaL_requiref');

  Load(@luaL_setfuncs, 'luaL_setfuncs');
end;


procedure UnloadLuaLib;
var
  variable: PPointer;

begin
  if Assigned(LuaFunctions) then
  begin
    for variable in LuaFunctions do
      variable^ := nil;
  end;

  if LuaLibLoaded then
  begin
    FreeLibrary(LuaLibHandle);
    LuaLibHandle := 0;
  end;
end;


function LuaLibLoaded: Boolean;
begin
  Result := (LuaLibHandle <> 0);
end;


{ Macros }
function lua_upvalueindex(idx: Integer): Integer;
begin
  Result := (LUA_REGISTRYINDEX - idx);
end;

procedure lua_call(L: lua_State; nargs, nresults: Integer);
begin
  lua_callk(L, nargs, nresults, 0, nil);
end;

function lua_pcall(L: lua_State; nargs, nresults, errfunc: Integer): Integer;
begin
  Result := lua_pcallk(L, nargs, nresults, errfunc, 0, nil);
end;

function lua_yield(L: lua_State; nresults: Integer): Integer;
begin
  Result := lua_yieldk(L, nresults, 0, nil);
end;

function lua_tonumber(L: lua_State; idx: Integer): lua_Number;
begin
  Result := lua_tonumberx(L, idx, nil);
end;

function lua_tointeger(L: lua_State; idx: Integer): lua_Integer;
begin
  Result := lua_tointegerx(L, idx, nil);
end;

function lua_tounsigned(L: lua_State; idx: Integer): lua_Unsigned;
begin
  Result := lua_tounsignedx(L, idx, nil);
end;

procedure lua_pop(L: lua_State; n: Integer);
begin
  lua_settop(L, -(n) - 1);
end;

procedure lua_newtable(L: lua_State); inline;
begin
  lua_createtable(L, 0, 0);
end;

procedure lua_register(L: lua_State; name: PAnsiChar; f: lua_CFunction); inline;
begin
  lua_pushcfunction(L, f);
  lua_setglobal(L, name);
end;

procedure lua_pushcfunction(L: lua_State; f: lua_CFunction);
begin
  lua_pushcclosure(L, f, 0);
end;

function lua_isfunction(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TFUNCTION;
end;

function lua_istable(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TTABLE;
end;

function lua_islightuserdata(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TLIGHTUSERDATA;
end;

function lua_isnil(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TNIL;
end;

function lua_isboolean(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TBOOLEAN;
end;

function lua_isthread(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TTHREAD;
end;

function lua_isnone(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) = LUA_TNONE;
end;

function lua_isnoneornil(L: lua_State; n: Integer): Boolean;
begin
  Result := lua_type(L, n) <= 0;
end;

function lua_pushliteral(L: lua_State; const s: AnsiString): PAnsiChar;
begin
  Result := lua_pushlstring(L, PAnsiChar(s), Length(s));
end;

procedure lua_pushglobaltable(L: lua_State);
begin
  lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
end;

function lua_tostring(L: lua_State; idx: Integer): PAnsiChar;
begin
  Result := lua_tolstring(L, idx, nil);
end;

procedure luaL_where(L: lua_State; level: Integer);
var
  ar: lua_Debug;
  msg: AnsiString;

begin
  if (lua_getstack(L, level, ar) <> 0) then // check function at level
  begin
    lua_getinfo(L, 'Sl', ar);  // get info about it
    if (ar.currentline > 0) then // is there info?
    begin
      msg := AnsiString(Format('%s:%d: ', [ar.short_src, ar.currentline]));
      lua_pushlstring(L, PAnsiChar(msg), Length(msg));
      exit
    end;
  end;
  lua_pushliteral(L, '');  // else, no information available...
end;

function luaL_error(L: lua_State; fmt: PAnsiChar; argp: Pointer): Integer;
begin
  luaL_where(L, 1);
  lua_pushvfstring(L, fmt, argp);
  lua_concat(L, 2);
  Result := lua_error(L);
end;


initialization
finalization
  UnloadLuaLib;
  FreeAndNil(LuaFunctions);

end.