Initial commit

Lua.Wrapper.pas

@@ -0,0 +1,750 @@
+unit Lua.Wrapper;
+
+interface
+uses
+  System.Classes,
+  System.Generics.Collections,
+  System.SysUtils,
+
+  Lua;
+
+type
+  ELuaException = class(Exception);
+  ELuaInitException = class(ELuaException);
+
+  TLuaLibrary = (Base, Coroutine, Table, IO, OS, StringLib, Bit32, Math, Debug, Package, All);
+  TLuaLibraries = set of TLuaLibrary;
+
+  TLuaDataType = (LuaNone, LuaNil, LuaNumber, LuaBoolean, LuaString, LuaTable,
+                  LuaCFunction, LuaUserData, LuaThread, LuaLightUserData);
+
+  ILuaParameter = interface
+    ['{ADA0D4FB-F0FB-4493-8FEC-6FC92C80117F}']
+    function GetAsBoolean: Boolean;
+    function GetAsInteger: Integer;
+    function GetAsNumber: Double;
+    function GetAsUserData: Pointer;
+    function GetAsString: string;
+    function GetDataType: TLuaDataType;
+    function GetIndex: Integer;
+
+    property AsBoolean: Boolean read GetAsBoolean;
+    property AsInteger: Integer read GetAsInteger;
+    property AsNumber: Double read GetAsNumber;
+    property AsUserData: Pointer read GetAsUserData;
+    property AsString: string read GetAsString;
+    property DataType: TLuaDataType read GetDataType;
+
+    property Index: Integer read GetIndex;
+  end;
+
+
+  ILuaParameters = interface
+    ['{FB611D9E-B51D-460B-B5AB-B567EF853222}']
+    function GetCount: Integer;
+    function GetItem(Index: Integer): ILuaParameter;
+    function GetState: lua_State;
+
+    function ToString: string;
+
+    property Count: Integer read GetCount;
+    property Items[Index: Integer]: ILuaParameter read GetItem; default;
+
+    property State: lua_State read GetState;
+  end;
+
+
+  ILuaResult = interface
+    ['{5CEEB16B-158E-44BE-8CAD-DC2C330A244A}']
+    function GetCount: Integer;
+
+    procedure Push(ABoolean: Boolean); overload;
+    procedure Push(AInteger: Integer); overload;
+    procedure Push(ANumber: Double); overload;
+    procedure Push(AUserData: Pointer); overload;
+    procedure Push(const AString: string); overload;
+
+    property Count: Integer read GetCount;
+  end;
+
+
+  ILuaContext = interface
+    ['{1F999593-E3D1-4195-9463-A42025AE9830}']
+    function GetParameters: ILuaParameters;
+    function GetResult: ILuaResult;
+
+    property Parameters: ILuaParameters read GetParameters;
+    property Result: ILuaResult read GetResult;
+  end;
+
+
+  TLuaFunction = reference to procedure(Context: ILuaContext);
+
+
+  TLuaRegisteredFunction = record
+    Name: string;
+    Callback: TLuaFunction;
+  end;
+
+  TLuaRegisteredFunctionDictionary = TDictionary<Integer, TLuaRegisteredFunction>;
+
+
+  TLua = class(TObject)
+  private
+    FState: lua_State;
+    FLoaded: Boolean;
+    FRegisteredFunctions: TLuaRegisteredFunctionDictionary;
+    FRegisteredFunctionCookie: Integer;
+    FAutoOpenLibraries: TLuaLibraries;
+
+    function GetHasState: Boolean;
+    function GetState: lua_State;
+    function GetRegisteredFunctions: TLuaRegisteredFunctionDictionary;
+  protected
+    function DoAlloc(APointer: Pointer; AOldSize, ANewSize: Cardinal): Pointer; virtual;
+
+    procedure DoNewState; virtual;
+    procedure DoClose; virtual;
+    procedure DoRegisterFunction(ACookie: Integer); virtual;
+
+    procedure SetAutoOpenLibraries(const Value: TLuaLibraries); virtual;
+  protected
+    procedure CheckState; virtual;
+    procedure RaiseLastLuaError; virtual;
+    procedure AfterLoad; virtual;
+
+    function GetRegisteredFunctionCookie: Integer; virtual;
+    function RunRegisteredFunction(ACookie: Integer): Integer; virtual;
+
+    property Loaded: Boolean read FLoaded write FLoaded;
+    property RegisteredFunctions: TLuaRegisteredFunctionDictionary read GetRegisteredFunctions;
+  public
+    constructor Create;
+    destructor Destroy; override;
+
+    procedure LoadFromString(const AData: string; const AChunkName: string = ''); virtual;
+    procedure LoadFromStream(AStream: TStream; AOwnership: TStreamOwnership = soReference; const AChunkName: string = ''); virtual;
+
+    procedure RegisterFunction(const AName: string; AFunction: TLuaFunction);
+
+    procedure OpenLibraries(ALibraries: TLuaLibraries); virtual;
+    procedure Call; virtual;
+
+    property HasState: Boolean read GetHasState;
+    property State: lua_State read GetState;
+
+    property AutoOpenLibraries: TLuaLibraries read FAutoOpenLibraries write SetAutoOpenLibraries default [TLuaLibrary.All];
+  end;
+
+
+implementation
+uses
+  System.Math;
+
+
+type
+  PLuaScript = ^TLuaScript;
+  TLuaScript = class(TObject)
+  private
+    FStream: TStream;
+    FStreamOwnership: TStreamOwnership;
+    FBuffer: PAnsiChar;
+  public
+    constructor Create(const AData: string); overload;
+    constructor Create(const AStream: TStream; AOwnership: TStreamOwnership = soReference); overload;
+    destructor Destroy; override;
+
+    function GetNextChunk(out ASize: Cardinal): PAnsiChar;
+  end;
+
+
+  TLuaParameters = class(TInterfacedObject, ILuaParameters)
+  private
+    FState: lua_State;
+    FCount: Integer;
+  protected
+    property State: lua_State read FState;
+  public
+    constructor Create(AState: lua_State);
+
+    function PushResultParameters: Integer;
+  public
+    { ILuaParameters }
+    function GetCount: Integer;
+    function GetItem(Index: Integer): ILuaParameter;
+    function GetState: lua_State;
+
+    function ToString: string; override;
+  end;
+
+
+  TLuaParameter = class(TInterfacedObject, ILuaParameter)
+  private
+    FState: lua_State;
+    FIndex: Integer;
+  protected
+    property State: lua_State read FState;
+  public
+    constructor Create(AState: lua_State; AIndex: Integer);
+
+    { ILuaParameter }
+    function GetAsBoolean: Boolean;
+    function GetAsInteger: Integer;
+    function GetAsNumber: Double;
+    function GetAsUserData: Pointer;
+    function GetAsString: string;
+    function GetDataType: TLuaDataType;
+    function GetIndex: Integer;
+  end;
+
+
+  TLuaResult = class(TInterfacedObject, ILuaResult)
+  private
+    FState: lua_State;
+    FCount: Integer;
+  protected
+    procedure Pushed;
+
+    property State: lua_State read FState;
+  public
+    constructor Create(AState: lua_State);
+
+    { ILuaResult }
+    function GetCount: Integer;
+
+    procedure Push(ABoolean: Boolean); overload;
+    procedure Push(AInteger: Integer); overload;
+    procedure Push(ANumber: Double); overload;
+    procedure Push(AUserData: Pointer); overload;
+    procedure Push(const AString: string); overload;
+  end;
+
+
+  TLuaContext = class(TInterfacedObject, ILuaContext)
+  private
+    FParameters: ILuaParameters;
+    FResult: ILuaResult;
+  public
+    constructor Create(AState: lua_State);
+
+    { ILuaContext }
+    function GetParameters: ILuaParameters;
+    function GetResult: ILuaResult;
+  end;
+
+
+
+{ TLuaScript }
+constructor TLuaScript.Create(const AData: string);
+begin
+  Create(TStringStream.Create(AData), soOwned);
+end;
+
+
+constructor TLuaScript.Create(const AStream: TStream; AOwnership: TStreamOwnership);
+begin
+  inherited Create;
+
+  FStream := AStream;
+  FStreamOwnership := AOwnership;
+end;
+
+
+destructor TLuaScript.Destroy;
+begin
+  if Assigned(FBuffer) then
+    FreeMem(FBuffer);
+
+  if FStreamOwnership = soOwned then
+    FreeAndNil(FStream);
+
+  inherited Destroy;
+end;
+
+
+function TLuaScript.GetNextChunk(out ASize: Cardinal): PAnsiChar;
+const
+  BufferSize = 4096;
+
+begin
+  if not Assigned(FBuffer) then
+    GetMem(FBuffer, BufferSize);
+
+  ASize := FStream.Read(FBuffer^, BufferSize);
+  if ASize > 0 then
+    Result := FBuffer
+  else
+    Result := nil;
+end;
+
+
+
+{ Callback functions }
+function LuaWrapperAlloc(ud, ptr: Pointer; osize, nsize: size_t): Pointer; cdecl;
+begin
+  Result := TLua(ud).DoAlloc(ptr, osize, nsize);
+end;
+
+
+function LuaWrapperReader(L: lua_State; ud: Pointer; var sz: size_t): PAnsiChar; cdecl;
+var
+  script: PLuaScript;
+
+begin
+  script := ud;
+  Result := script^.GetNextChunk(sz);
+end;
+
+
+function LuaWrapperFunction(L: lua_State): Integer; cdecl;
+var
+  lua: TLua;
+  cookie: Integer;
+
+begin
+  Result := 0;
+
+  lua := TLua(lua_touserdata(L, lua_upvalueindex(1)));
+  cookie := lua_tointeger(L, lua_upvalueindex(2));
+
+  if Assigned(lua) then
+    Result := lua.RunRegisteredFunction(cookie);
+end;
+
+
+function NilPAnsiChar(const AValue: string): PAnsiChar;
+begin
+  if Length(AValue) > 0 then
+    Result := PAnsiChar(AnsiString(AValue))
+  else
+    Result := nil;
+end;
+
+
+{ TLua }
+constructor TLua.Create;
+begin
+  inherited Create;
+
+  FAutoOpenLibraries := [TLuaLibrary.All];
+end;
+
+
+destructor TLua.Destroy;
+begin
+  FreeAndNil(FRegisteredFunctions);
+
+  if HasState then
+    DoClose;
+
+  inherited Destroy;
+end;
+
+
+procedure TLua.LoadFromString(const AData: string; const AChunkName: string);
+var
+  script: TLuaScript;
+
+begin
+  script := TLuaScript.Create(AData);
+  try
+    if lua_load(State, LuaWrapperReader, @script, NilPAnsiChar(AChunkName), nil) <> 0 then
+      RaiseLastLuaError;
+
+    AfterLoad;
+  finally
+    FreeAndNil(script);
+  end;
+end;
+
+
+procedure TLua.LoadFromStream(AStream: TStream; AOwnership: TStreamOwnership; const AChunkName: string);
+var
+  script: TLuaScript;
+
+begin
+  script := TLuaScript.Create(AStream, AOwnership);
+  try
+    if lua_load(State, LuaWrapperReader, @script, NilPAnsiChar(AChunkName), nil) <> 0 then
+      RaiseLastLuaError;
+
+    AfterLoad;
+  finally
+    FreeAndNil(script);
+  end;
+end;
+
+
+procedure TLua.OpenLibraries(ALibraries: TLuaLibraries);
+begin
+  if TLuaLibrary.All in ALibraries then
+    luaL_openlibs(State)
+  else
+  begin
+    if TLuaLibrary.Base in ALibraries then
+      luaopen_base(State);
+
+    if TLuaLibrary.Coroutine in ALibraries then
+      luaopen_coroutine(State);
+
+    if TLuaLibrary.Table in ALibraries then
+      luaopen_table(State);
+
+    if TLuaLibrary.IO in ALibraries then
+      luaopen_io(State);
+
+    if TLuaLibrary.OS in ALibraries then
+      luaopen_os(State);
+
+    if TLuaLibrary.StringLib in ALibraries then
+      luaopen_string(State);
+
+    if TLuaLibrary.Bit32 in ALibraries then
+      luaopen_bit32(State);
+
+    if TLuaLibrary.Math in ALibraries then
+      luaopen_math(State);
+
+    if TLuaLibrary.Debug in ALibraries then
+      luaopen_debug(State);
+
+    if TLuaLibrary.Package in ALibraries then
+      luaopen_package(State);
+  end;
+end;
+
+
+procedure TLua.Call;
+begin
+  if lua_pcall(State, 0, 0, 0) <> 0 then
+    RaiseLastLuaError;
+end;
+
+
+procedure TLua.CheckState;
+begin
+  if not LuaLibLoaded then
+    LoadLuaLib;
+
+  if not HasState then
+    DoNewState;
+end;
+
+
+procedure TLua.RaiseLastLuaError;
+begin
+  raise ELuaException.Create(string(lua_tolstring(State, -1, nil)));
+end;
+
+
+procedure TLua.AfterLoad;
+var
+  cookie: Integer;
+
+begin
+  Loaded := True;
+
+  { Register functions in the current environment }
+  for cookie in RegisteredFunctions.Keys do
+    DoRegisterFunction(cookie);
+end;
+
+
+procedure TLua.RegisterFunction(const AName: string; AFunction: TLuaFunction);
+var
+  registeredFunction: TLuaRegisteredFunction;
+  cookie: Integer;
+
+begin
+  { Since anonymous methods are basically interfaces, we need to keep a reference around }
+  registeredFunction.Name := AName;
+  registeredFunction.Callback := AFunction;
+
+  cookie := GetRegisteredFunctionCookie;
+  RegisteredFunctions.Add(cookie, registeredFunction);
+
+  { Only register functions after Load, otherwise they'll not be available in the environment }
+  if Loaded then
+    DoRegisterFunction(cookie);
+end;
+
+
+function TLua.DoAlloc(APointer: Pointer; AOldSize, ANewSize: Cardinal): Pointer;
+begin
+  Result := DefaultLuaAlloc(nil, APointer, AOldSize, ANewSize);
+end;
+
+
+procedure TLua.DoNewState;
+begin
+  FState := lua_newstate(@LuaWrapperAlloc, Pointer(Self));
+  if not HasState then
+    raise ELuaInitException.Create('Failed to initialize new state');
+
+  OpenLibraries(AutoOpenLibraries);
+end;
+
+
+procedure TLua.DoClose;
+begin
+  lua_close(FState);
+  FState := nil;
+end;
+
+
+procedure TLua.DoRegisterFunction(ACookie: Integer);
+var
+  name: string;
+
+begin
+  name := RegisteredFunctions[ACookie].Name;
+
+  lua_pushlightuserdata(State, Self);
+  lua_pushinteger(State, ACookie);
+
+  lua_pushcclosure(State, @LuaWrapperFunction, 2);
+  lua_setglobal(State, NilPAnsiChar(name));
+end;
+
+
+function TLua.GetRegisteredFunctionCookie: Integer;
+begin
+  Inc(FRegisteredFunctionCookie);
+  Result := FRegisteredFunctionCookie;
+end;
+
+
+function TLua.RunRegisteredFunction(ACookie: Integer): Integer;
+var
+  context: ILuaContext;
+
+begin
+  Result := 0;
+
+  if RegisteredFunctions.ContainsKey(ACookie) then
+  begin
+    context := TLuaContext.Create(State);
+
+    RegisteredFunctions[ACookie].Callback(context);
+    Result := context.Result.Count;
+  end;
+end;
+
+
+function TLua.GetHasState: Boolean;
+begin
+  Result := Assigned(FState);
+end;
+
+
+function TLua.GetState: lua_State;
+begin
+  CheckState;
+  Result := FState;
+end;
+
+
+function TLua.GetRegisteredFunctions: TLuaRegisteredFunctionDictionary;
+begin
+  if not Assigned(FRegisteredFunctions) then
+    FRegisteredFunctions := TLuaRegisteredFunctionDictionary.Create;
+
+  Result := FRegisteredFunctions;
+end;
+
+
+procedure TLua.SetAutoOpenLibraries(const Value: TLuaLibraries);
+begin
+  FAutoOpenLibraries := Value;
+end;
+
+
+{ TLuaParameters }
+constructor TLuaParameters.Create(AState: lua_State);
+begin
+  inherited Create;
+
+  FState := AState;
+  FCount := lua_gettop(FState);
+end;
+
+
+function TLuaParameters.PushResultParameters: Integer;
+begin
+  Result := 0;
+end;
+
+
+function TLuaParameters.GetCount: Integer;
+begin
+  Result := FCount;
+end;
+
+
+function TLuaParameters.GetItem(Index: Integer): ILuaParameter;
+begin
+  Result := TLuaParameter.Create(State, Succ(Index));
+end;
+
+
+function TLuaParameters.GetState: lua_State;
+begin
+  Result := FState;
+end;
+
+
+function TLuaParameters.ToString: string;
+var
+  parameterIndex: Integer;
+
+begin
+  Result := '';
+
+  for parameterIndex := 0 to Pred(GetCount) do
+    Result := Result + GetItem(parameterIndex).AsString;
+end;
+
+
+{ TLuaParameter }
+constructor TLuaParameter.Create(AState: lua_State; AIndex: Integer);
+begin
+  inherited Create;
+
+  FState := AState;
+  FIndex := AIndex;
+end;
+
+
+function TLuaParameter.GetAsBoolean: Boolean;
+begin
+  Result := (lua_toboolean(State, GetIndex) <> 0);
+end;
+
+
+function TLuaParameter.GetAsInteger: Integer;
+begin
+  Result := lua_tointeger(State, GetIndex);
+end;
+
+
+function TLuaParameter.GetAsNumber: Double;
+begin
+  Result := lua_tonumber(State, GetIndex);
+end;
+
+
+function TLuaParameter.GetAsUserData: Pointer;
+begin
+  Result := lua_touserdata(State, GetIndex);
+end;
+
+
+function TLuaParameter.GetAsString: string;
+begin
+  Result := string(lua_tostring(State, GetIndex));
+end;
+
+
+function TLuaParameter.GetDataType: TLuaDataType;
+begin
+  case lua_type(State, GetIndex) of
+    LUA_TNIL: Result := LuaNil;
+    LUA_TNUMBER: Result := LuaNumber;
+    LUA_TBOOLEAN: Result := LuaBoolean;
+    LUA_TSTRING: Result := LuaString;
+    LUA_TTABLE: Result := LuaTable;
+    LUA_TFUNCTION: Result := LuaCFunction;
+    LUA_TUSERDATA: Result := LuaUserData;
+    LUA_TTHREAD: Result := LuaThread;
+    LUA_TLIGHTUSERDATA: Result := LuaLightUserData;
+  else
+    Result := LuaNone;
+  end;
+end;
+
+
+function TLuaParameter.GetIndex: Integer;
+begin
+  Result := FIndex;
+end;
+
+
+{ TLuaContext }
+constructor TLuaContext.Create(AState: lua_State);
+begin
+  inherited Create;
+
+  FParameters := TLuaParameters.Create(AState);
+  FResult := TLuaResult.Create(AState);
+end;
+
+
+function TLuaContext.GetParameters: ILuaParameters;
+begin
+  Result := FParameters;
+end;
+
+
+function TLuaContext.GetResult: ILuaResult;
+begin
+  Result := FResult;
+end;
+
+
+{ TLuaResult }
+constructor TLuaResult.Create(AState: lua_State);
+begin
+  inherited Create;
+
+  FState := AState;
+end;
+
+
+function TLuaResult.GetCount: Integer;
+begin
+  Result := FCount;
+end;
+
+
+procedure TLuaResult.Push(ABoolean: Boolean);
+begin
+  lua_pushboolean(State, IfThen(ABoolean, 1, 0));
+  Pushed;
+end;
+
+
+procedure TLuaResult.Push(AInteger: Integer);
+begin
+  lua_pushinteger(State, AInteger);
+  Pushed;
+end;
+
+
+procedure TLuaResult.Push(ANumber: Double);
+begin
+  lua_pushnumber(State, ANumber);
+  Pushed;
+end;
+
+
+procedure TLuaResult.Push(AUserData: Pointer);
+begin
+  lua_pushlightuserdata(State, AUserData);
+  Pushed;
+end;
+
+
+procedure TLuaResult.Push(const AString: string);
+begin
+  lua_pushstring(State, NilPAnsiChar(AString));
+  Pushed;
+end;
+
+
+procedure TLuaResult.Pushed;
+begin
+  Inc(FCount);
+end;
+
+
+end.

Lua.pas

@@ -0,0 +1,650 @@
+{
+  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;
+
+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 = Cardinal;
+  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;
+
+
+  (*
+  /*
+  ** Comparison and arithmetic functions
+  */
+
+  #define LUA_OPADD	0	/* ORDER TM */
+  #define LUA_OPSUB	1
+  #define LUA_OPMUL	2
+  #define LUA_OPDIV	3
+  #define LUA_OPMOD	4
+  #define LUA_OPPOW	5
+  #define LUA_OPUNM	6
+
+  LUA_API void  (lua_arith) (lua_State *L, int op);
+
+  #define LUA_OPEQ	0
+  #define LUA_OPLT	1
+  #define LUA_OPLE	2
+
+  LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+  LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+  *)
+
+  { 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: array of const): PAnsiChar; cdecl;
+  lua_pushfstring: function (L: lua_State; fmt: PAnsiChar): PAnsiChar; cdecl; {$IFDEF FPC}varargs;{$ENDIF}
+  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_API void  (lua_gettable) (lua_State *L, int idx);
+  LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+  LUA_API void  (lua_rawget) (lua_State *L, int idx);
+  *)
+  lua_rawgeti: procedure(L: lua_State; idx, n: integer); cdecl;
+  (*
+  LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
+  LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+  LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+  LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+  LUA_API void  (lua_getuservalue) (lua_State *L, int idx);
+  *)
+
+  { set functions (stack -> Lua) }
+  lua_setglobal: procedure(L: lua_State; value: PAnsiChar); cdecl;
+  (*
+  LUA_API void  (lua_settable) (lua_State *L, int idx);
+  LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+  LUA_API void  (lua_rawset) (lua_State *L, int idx);
+  LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+  LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+  LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+  LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+  *)
+
+
+  { '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;
+
+
+(*
+  /*
+  ** coroutine functions
+  */
+  LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,
+                             lua_CFunction k);
+  #define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+  LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);
+  LUA_API int  (lua_status) (lua_State *L);
+
+  /*
+  ** garbage-collection function and options
+  */
+
+  #define LUA_GCSTOP		0
+  #define LUA_GCRESTART		1
+  #define LUA_GCCOLLECT		2
+  #define LUA_GCCOUNT		3
+  #define LUA_GCCOUNTB		4
+  #define LUA_GCSTEP		5
+  #define LUA_GCSETPAUSE		6
+  #define LUA_GCSETSTEPMUL	7
+  #define LUA_GCSETMAJORINC	8
+  #define LUA_GCISRUNNING		9
+  #define LUA_GCGEN		10
+  #define LUA_GCINC		11
+
+  LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+  /*
+  ** miscellaneous functions
+  */
+
+  LUA_API int   (lua_error) (lua_State *L);
+
+  LUA_API int   (lua_next) (lua_State *L, int idx);
+
+  LUA_API void  (lua_concat) (lua_State *L, int n);
+  LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+  LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+  LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+  *)
+
+
+  { 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;
+
+  (*
+  #define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+  #define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+  #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+  *)
+
+  procedure lua_pushcfunction(L: lua_State; f: lua_CFunction); inline;
+
+  (*
+  #define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+  #define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+  #define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+  #define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+  #define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+  #define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+  #define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+  #define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+  #define lua_pushliteral(L, s)	\
+    lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+    *)
+
+  procedure lua_pushglobaltable(L: lua_State); inline;
+  function lua_tostring(L: lua_State; idx: Integer): PAnsiChar; inline;
+
+  (*
+
+
+
+  /*
+  ** {======================================================================
+  ** Debug API
+  ** =======================================================================
+  */
+
+
+  /*
+  ** Event codes
+  */
+  #define LUA_HOOKCALL	0
+  #define LUA_HOOKRET	1
+  #define LUA_HOOKLINE	2
+  #define LUA_HOOKCOUNT	3
+  #define LUA_HOOKTAILCALL 4
+
+
+  /*
+  ** Event masks
+  */
+  #define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+  #define LUA_MASKRET	(1 << LUA_HOOKRET)
+  #define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+  #define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+
+  /* Functions to be called by the debugger in specific events */
+  typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+  *)
+
+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;
+    //struct CallInfo *i_ci;  /* active function */
+  end;
+
+
+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_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+  LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+  LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+  LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+  LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+  LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                                 int fidx2, int n2);
+
+  LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+  LUA_API lua_Hook (lua_gethook) (lua_State *L);
+  LUA_API int (lua_gethookmask) (lua_State *L);
+  LUA_API int (lua_gethookcount) (lua_State *L);
+  /* }====================================================================== */
+
+  #endif
+*)
+
+
+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;
+
+
+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;
+
+
+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_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_rawgeti, 'lua_rawgeti');
+  Load(@lua_setglobal, 'lua_setglobal');
+
+  Load(@lua_callk, 'lua_callk');
+  Load(@lua_getctx, 'lua_getctx');
+  Load(@lua_pcallk, 'lua_pcallk');
+
+  Load(@lua_load, 'lua_load');
+  Load(@lua_dump, 'lua_dump');
+
+  Load(@lua_getstack, 'lua_getstack');
+  Load(@lua_getinfo, 'lua_getinfo');
+
+
+  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_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_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_pushcfunction(L: lua_State; f: lua_CFunction);
+begin
+  lua_pushcclosure(L, f, 0);
+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;
+
+
+initialization
+finalization
+  UnloadLuaLib;
+  FreeAndNil(LuaFunctions);
+
+end.

LuaBinaries/include/lauxlib.h

@@ -0,0 +1,212 @@
+/*
+** $Id: lauxlib.h,v 1.120 2011/11/29 15:55:08 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
+#define luaL_checkversion(L)	luaL_checkversion_(L, LUA_VERSION_NUM)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
+LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
+                                            lua_Unsigned def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+                                               const char *mode);
+
+#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API int (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE          "FILE*"
+
+
+typedef struct luaL_Stream {
+  FILE *f;  /* stream (NULL for incompletely created streams) */
+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+                                   int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+#endif
+
+

LuaBinaries/include/lua.h

@@ -0,0 +1,439 @@
+/*
+** $Id: lua.h,v 1.283 2012/04/20 13:18:26 roberto Exp $
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR	"5"
+#define LUA_VERSION_MINOR	"2"
+#define LUA_VERSION_NUM		502
+#define LUA_VERSION_RELEASE	"1"
+
+#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2012 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE	"\033Lua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX	LUAI_FIRSTPSEUDOIDX
+#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRGCMM	5
+#define LUA_ERRERR	6
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+#define LUA_NUMTAGS		9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD	1
+#define LUA_RIDX_GLOBALS	2
+#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_absindex) (lua_State *L, int idx);
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_insert) (lua_State *L, int idx);
+LUA_API void  (lua_replace) (lua_State *L, int idx);
+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int   (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Unsigned    (lua_tounsignedx) (lua_State *L, int idx, int *isnum);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD	0	/* ORDER TM */
+#define LUA_OPSUB	1
+#define LUA_OPMUL	2
+#define LUA_OPDIV	3
+#define LUA_OPMOD	4
+#define LUA_OPPOW	5
+#define LUA_OPUNM	6
+
+LUA_API void  (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ	0
+#define LUA_OPLT	1
+#define LUA_OPLE	2
+
+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void        (lua_pushnil) (lua_State *L);
+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void        (lua_pushunsigned) (lua_State *L, lua_Unsigned n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  (lua_getglobal) (lua_State *L, const char *var);
+LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawgetp) (lua_State *L, int idx, const void *p);
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_setglobal) (lua_State *L, const char *var);
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
+                           lua_CFunction k);
+#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int   (lua_getctx) (lua_State *L, int *ctx);
+
+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+                            int ctx, lua_CFunction k);
+#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                                        const char *chunkname,
+                                        const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yieldk) (lua_State *L, int nresults, int ctx,
+                           lua_CFunction k);
+#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+LUA_API int  (lua_resume) (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCSETMAJORINC	8
+#define LUA_GCISRUNNING		9
+#define LUA_GCGEN		10
+#define LUA_GCINC		11
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_tonumber(L,i)	lua_tonumberx(L,i,NULL)
+#define lua_tointeger(L,i)	lua_tointegerx(L,i,NULL)
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,i,NULL)
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	\
+	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_pushglobaltable(L)  \
+	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                               int fidx2, int n2);
+
+LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
+  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  unsigned char nups;	/* (u) number of upvalues */
+  unsigned char nparams;/* (u) number of parameters */
+  char isvararg;        /* (u) */
+  char istailcall;	/* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  struct CallInfo *i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2012 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

LuaBinaries/include/lua.hpp

@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}

LuaBinaries/include/luaconf.h

@@ -0,0 +1,548 @@
+/*
+** $Id: luaconf.h,v 1.172 2012/05/11 14:14:42 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_WIN		/* enable goodies for regular Windows platforms */
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#endif
+
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hexa formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* does not need -ldl */
+#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#define LUA_USE_STRTODHEX	/* assume 'strtod' handles hexa formats */
+#define LUA_USE_AFORMAT		/* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG	/* assume support for long long */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionality listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#define LUA_USE_GMTIME_R
+#endif
+
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32)	/* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" ".\\?.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll;" \
+    LUA_CDIR"?52.dll;" ".\\?52.dll"
+
+#else			/* }{ */
+
+#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
+#define LUA_ROOT	"/usr/local/"
+#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR
+#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" "./?.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \
+    LUA_CDIR"lib?52.so;" "./lib?52.so"
+#endif			/* } */
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+
+/*
+@@ LUA_ENV is the name of the variable that holds the current
+@@ environment, used to access global names.
+** CHANGE it if you do not like this name.
+*/
+#define LUA_ENV		"_ENV"
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)	/* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
+#define LUA_API __declspec(dllexport)
+#else						/* }{ */
+#define LUA_API __declspec(dllimport)
+#endif						/* } */
+
+#else				/* }{ */
+
+#define LUA_API		extern
+
+#endif				/* } */
+
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+#define LUAMOD_API	LUALIB_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+@* that are not to be exported to outside modules (LUAI_DDEF for
+@* definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+    defined(__ELF__)		/* { */
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#define LUAI_DDEC	LUAI_FUNC
+#define LUAI_DDEF	/* empty */
+
+#else				/* }{ */
+#define LUAI_FUNC	extern
+#define LUAI_DDEC	extern
+#define LUAI_DDEF	/* empty */
+#endif				/* } */
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+/*
+@@ 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.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+@@ luai_writestring/luai_writeline define how 'print' prints its results.
+** They are only used in libraries and the stand-alone program. (The #if
+** avoids including 'stdio.h' everywhere.)
+*/
+#if defined(LUA_LIB) || defined(lua_c)
+#include <stdio.h>
+#define luai_writestring(s,l)	fwrite((s), sizeof(char), (l), stdout)
+#define luai_writeline()	(luai_writestring("\n", 1), fflush(stdout))
+#endif
+
+/*
+@@ luai_writestringerror defines how to print error messages.
+** (A format string with one argument is enough for Lua...)
+*/
+#define luai_writestringerror(s,p) \
+	(fprintf(stderr, (s), (p)), fflush(stderr))
+
+
+/*
+@@ LUAI_MAXSHORTLEN is the maximum length for short strings, that is,
+** strings that are internalized. (Cannot be smaller than reserved words
+** or tags for metamethods, as these strings must be internalized;
+** #("function") = 8, #("__newindex") = 10.)
+*/
+#define LUAI_MAXSHORTLEN        40
+
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_ALL controls all compatibility options.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_ALL)	/* { */
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L,f,u)  \
+	(lua_pushcfunction(L, (f)), \
+	 lua_pushlightuserdata(L,(u)), \
+	 lua_pcall(L,1,0,0))
+
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_objlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif				/* } */
+
+/* }================================================================== */
+
+
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760		/* { */
+#define LUAI_BITSINT	16
+#elif INT_MAX > 2147483640L	/* }{ */
+/* int has at least 32 bits */
+#define LUAI_BITSINT	32
+#else				/* }{ */
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif				/* } */
+
+
+/*
+@@ LUA_INT32 is an signed integer with exactly 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. Probably you do not need to change
+** this.
+*/
+#if LUAI_BITSINT >= 32		/* { */
+#define LUA_INT32	int
+#define LUAI_UMEM	size_t
+#define LUAI_MEM	ptrdiff_t
+#else				/* }{ */
+/* 16-bit ints */
+#define LUA_INT32	long
+#define LUAI_UMEM	unsigned long
+#define LUAI_MEM	long
+#endif				/* } */
+
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua to consume unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK		1000000
+#else
+#define LUAI_MAXSTACK		15000
+#endif
+
+/* reserve some space for error handling */
+#define LUAI_FIRSTPSEUDOIDX	(-LUAI_MAXSTACK - 1000)
+
+
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space.
+*/
+#define LUAL_BUFFERSIZE		BUFSIZ
+
+
+
+
+/*
+** {==================================================================
+@@ 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.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER	double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER	double
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+*/
+#define LUA_NUMBER_SCAN		"%lf"
+#define LUA_NUMBER_FMT		"%.14g"
+#define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */
+
+
+/*
+@@ lua_str2number converts a decimal numeric string to a number.
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' do both conversions. C89, however, has no function
+** to convert floating hexadecimal strings to numbers. For these
+** systems, you can leave 'lua_strx2number' undefined and Lua will
+** provide its own implementation.
+*/
+#define lua_str2number(s,p)	strtod((s), (p))
+
+#if defined(LUA_USE_STRTODHEX)
+#define lua_strx2number(s,p)	strtod((s), (p))
+#endif
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+
+/* the following operations need the math library */
+#if defined(lobject_c) || defined(lvm_c)
+#include <math.h>
+#define luai_nummod(L,a,b)	((a) - floor((a)/(b))*(b))
+#define luai_numpow(L,a,b)	(pow(a,b))
+#endif
+
+/* these are quite standard operations */
+#if defined(LUA_CORE)
+#define luai_numadd(L,a,b)	((a)+(b))
+#define luai_numsub(L,a,b)	((a)-(b))
+#define luai_nummul(L,a,b)	((a)*(b))
+#define luai_numdiv(L,a,b)	((a)/(b))
+#define luai_numunm(L,a)	(-(a))
+#define luai_numeq(a,b)		((a)==(b))
+#define luai_numlt(L,a,b)	((a)<(b))
+#define luai_numle(L,a,b)	((a)<=(b))
+#define luai_numisnan(L,a)	(!luai_numeq((a), (a)))
+#endif
+
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER	ptrdiff_t
+
+/*
+@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.
+** It must have at least 32 bits.
+*/
+#define LUA_UNSIGNED	unsigned LUA_INT32
+
+
+
+/*
+** Some tricks with doubles
+*/
+
+#if defined(LUA_CORE) && \
+    defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)	/* { */
+/*
+** The next definitions activate some tricks to speed up the
+** conversion from doubles to integer types, mainly to LUA_UNSIGNED.
+**
+@@ MS_ASMTRICK uses Microsoft assembler to avoid clashes with a
+** DirectX idiosyncrasy.
+**
+@@ LUA_IEEE754TRICK uses a trick that should work on any machine
+** using IEEE754 with a 32-bit integer type.
+**
+@@ LUA_IEEELL extends the trick to LUA_INTEGER; should only be
+** defined when LUA_INTEGER is a 32-bit integer.
+**
+@@ LUA_IEEEENDIAN is the endianness of doubles in your machine
+** (0 for little endian, 1 for big endian); if not defined, Lua will
+** check it dynamically for LUA_IEEE754TRICK (but not for LUA_NANTRICK).
+**
+@@ LUA_NANTRICK controls the use of a trick to pack all types into
+** a single double value, using NaN values to represent non-number
+** values. The trick only works on 32-bit machines (ints and pointers
+** are 32-bit values) with numbers represented as IEEE 754-2008 doubles
+** with conventional endianess (12345678 or 87654321), in CPUs that do
+** not produce signaling NaN values (all NaNs are quiet).
+*/
+
+/* Microsoft compiler on a Pentium (32 bit) ? */
+#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86)	/* { */
+
+#define MS_ASMTRICK
+#define LUA_IEEEENDIAN		0
+#define LUA_NANTRICK
+
+
+/* pentium 32 bits? */
+#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEELL
+#define LUA_IEEEENDIAN		0
+#define LUA_NANTRICK
+
+/* pentium 64 bits? */
+#elif defined(__x86_64)						/* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN		0
+
+#elif defined(__POWERPC__) || defined(__ppc__)			/* }{ */
+
+#define LUA_IEEE754TRICK
+#define LUA_IEEEENDIAN		1
+
+#else								/* }{ */
+
+/* assume IEEE754 and a 32-bit integer type */
+#define LUA_IEEE754TRICK
+
+#endif								/* } */
+
+#endif							/* } */
+
+/* }================================================================== */
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+#endif
+

LuaBinaries/include/lualib.h

@@ -0,0 +1,55 @@
+/*
+** $Id: lualib.h,v 1.43 2011/12/08 12:11:37 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+
+LUAMOD_API int (luaopen_base) (lua_State *L);
+
+#define LUA_COLIBNAME	"coroutine"
+LUAMOD_API int (luaopen_coroutine) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUAMOD_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUAMOD_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUAMOD_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUAMOD_API int (luaopen_string) (lua_State *L);
+
+#define LUA_BITLIBNAME	"bit32"
+LUAMOD_API int (luaopen_bit32) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUAMOD_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUAMOD_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUAMOD_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L);
+
+
+
+#if !defined(lua_assert)
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif

UnitTests/DelphiLuaUnitTests.dpr

@@ -0,0 +1,15 @@
+program DelphiLuaUnitTests;
+
+uses
+  DUnitTestRunner,
+  TestAPI in 'source\TestAPI.pas',
+  Lua in '..\Lua.pas',
+  Lua.Wrapper in '..\Lua.Wrapper.pas',
+  TestWrapper in 'source\TestWrapper.pas';
+
+{$R *.RES}
+
+begin
+  DUnitTestRunner.RunRegisteredTests;
+end.
+

UnitTests/DelphiLuaUnitTests.dproj

@@ -0,0 +1,161 @@
+	<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+		<PropertyGroup>
+			<ProjectGuid>{B14CC7FE-413D-4162-9B05-E421D69F64BE}</ProjectGuid>
+			<ProjectVersion>13.4</ProjectVersion>
+			<FrameworkType>None</FrameworkType>
+			<Base>True</Base>
+			<Config Condition="'$(Config)'==''">Debug</Config>
+			<Platform Condition="'$(Platform)'==''">Win32</Platform>
+			<TargetedPlatforms>1</TargetedPlatforms>
+			<AppType>Console</AppType>
+			<MainSource>DelphiLuaUnitTests.dpr</MainSource>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="('$(Platform)'=='Win64' and '$(Base)'=='true') or '$(Base_Win64)'!=''">
+			<Base_Win64>true</Base_Win64>
+			<CfgParent>Base</CfgParent>
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Base)'=='true') or '$(Base_Win32)'!=''">
+			<Base_Win32>true</Base_Win32>
+			<CfgParent>Base</CfgParent>
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
+			<Cfg_1>true</Cfg_1>
+			<CfgParent>Base</CfgParent>
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Cfg_1)'=='true') or '$(Cfg_1_Win32)'!=''">
+			<Cfg_1_Win32>true</Cfg_1_Win32>
+			<CfgParent>Cfg_1</CfgParent>
+			<Cfg_1>true</Cfg_1>
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
+			<Cfg_2>true</Cfg_2>
+			<CfgParent>Base</CfgParent>
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Cfg_2)'=='true') or '$(Cfg_2_Win32)'!=''">
+			<Cfg_2_Win32>true</Cfg_2_Win32>
+			<CfgParent>Cfg_2</CfgParent>
+			<Cfg_2>true</Cfg_2>
+			<Base>true</Base>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Base)'!=''">
+			<Manifest_File>None</Manifest_File>
+			<VerInfo_Keys>CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments=</VerInfo_Keys>
+			<VerInfo_Locale>1043</VerInfo_Locale>
+			<DCC_Namespace>System;Xml;Data;Datasnap;Web;Soap;Vcl;Vcl.Imaging;Vcl.Touch;Vcl.Samples;Vcl.Shell;$(DCC_Namespace)</DCC_Namespace>
+			<DCC_UsePackage>fmx;IndySystem;DBXInterBaseDriver;DataSnapCommon;DataSnapClient;DataSnapServer;DataSnapProviderClient;DbxCommonDriver;dbxcds;DBXOracleDriver;CustomIPTransport;dsnap;fmxase;IndyCore;inetdbxpress;IPIndyImpl;bindcompfmx;rtl;dbrtl;DbxClientDriver;bindcomp;inetdb;xmlrtl;IndyProtocols;DBXMySQLDriver;bindengine;soaprtl;DBXInformixDriver;DBXFirebirdDriver;inet;fmxobj;DBXSybaseASADriver;fmxdae;dbexpress;DataSnapIndy10ServerTransport;$(DCC_UsePackage)</DCC_UsePackage>
+			<DCC_DcuOutput>.\lib</DCC_DcuOutput>
+			<DCC_ExeOutput>.\bin</DCC_ExeOutput>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Base_Win64)'!=''">
+			<DCC_UsePackage>dxdborRS16;cxLibraryRS16;dxLayoutControlRS16;dxPScxPivotGridLnkRS16;dxCoreRS16;cxExportRS16;dxBarRS16;cxSpreadSheetRS16;cxTreeListdxBarPopupMenuRS16;TeeDB;dxDBXServerModeRS16;dxPsPrVwAdvRS16;dxPSCoreRS16;dxPScxTLLnkRS16;dxPScxGridLnkRS16;cxPageControlRS16;dxRibbonRS16;DBXSybaseASEDriver;vclimg;cxTreeListRS16;dxComnRS16;vcldb;vcldsnap;dxBarExtDBItemsRS16;DBXDb2Driver;vcl;DBXMSSQLDriver;cxDataRS16;cxBarEditItemRS16;dxDockingRS16;cxPageControldxBarPopupMenuRS16;cxSchedulerGridRS16;dxPSLnksRS16;dxBarExtItemsRS16;dxtrmdRS16;webdsnap;dxPSdxLCLnkRS16;dxorgcRS16;dxWizardControlRS16;dxPScxExtCommonRS16;dxNavBarRS16;dxPSdxDBOCLnkRS16;cxSchedulerTreeBrowserRS16;Tee;DBXOdbcDriver;dxdbtrRS16;dxPScxSSLnkRS16;cxPivotGridChartRS16;dxPScxCommonRS16;dxmdsRS16;dxPSPrVwRibbonRS16;cxGridRS16;cxEditorsRS16;cxPivotGridRS16;dxPSdxDBTVLnkRS16;dxPScxSchedulerLnkRS16;TeeUI;dxServerModeRS16;bindcompvcl;vclactnband;vclie;cxSchedulerRS16;vcltouch;websnap;VclSmp;dxTabbedMDIRS16;dxPSdxOCLnkRS16;dsnapcon;dxPSdxFCLnkRS16;dxThemeRS16;dxPScxPCProdRS16;vclx;dxFlowChartRS16;dxGDIPlusRS16;dxBarDBNavRS16;$(DCC_UsePackage)</DCC_UsePackage>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Base_Win32)'!=''">
+			<DCC_UsePackage>dxdborRS16;cxLibraryRS16;dxLayoutControlRS16;dxPScxPivotGridLnkRS16;dxCoreRS16;cxExportRS16;dxBarRS16;cxSpreadSheetRS16;cxTreeListdxBarPopupMenuRS16;TeeDB;dxDBXServerModeRS16;dxPsPrVwAdvRS16;vclib;dxPSCoreRS16;dxPScxTLLnkRS16;dxPScxGridLnkRS16;inetdbbde;cxPageControlRS16;dxRibbonRS16;DBXSybaseASEDriver;vclimg;cxTreeListRS16;fmi;dxComnRS16;vcldb;vcldsnap;dxBarExtDBItemsRS16;X2CLGL;DBXDb2Driver;vcl;CloudService;DBXMSSQLDriver;CodeSiteExpressPkg;FmxTeeUI;cxDataRS16;cxBarEditItemRS16;dxDockingRS16;cxPageControldxBarPopupMenuRS16;cxSchedulerGridRS16;dxPSLnksRS16;dxBarExtItemsRS16;dxtrmdRS16;webdsnap;X2CLMB;OmniThreadLibraryRuntimeXE2;adortl;dxPSdxLCLnkRS16;dxorgcRS16;dxWizardControlRS16;dxPScxExtCommonRS16;vcldbx;dxNavBarRS16;dxPSdxDBOCLnkRS16;cxSchedulerTreeBrowserRS16;Tee;DBXOdbcDriver;dxdbtrRS16;svnui;dxPScxSSLnkRS16;cxPivotGridChartRS16;dxPScxCommonRS16;dxmdsRS16;dxPSPrVwRibbonRS16;ibxpress;cxGridRS16;cxEditorsRS16;cxPivotGridRS16;dxPSdxDBTVLnkRS16;FMXTee;dxPScxSchedulerLnkRS16;TeeUI;dxServerModeRS16;bindcompvcl;vclactnband;vclie;cxSchedulerRS16;vcltouch;websnap;VclSmp;dxTabbedMDIRS16;DataSnapConnectors;dxPSdxOCLnkRS16;dsnapcon;dxPSdxFCLnkRS16;dxThemeRS16;dxPScxPCProdRS16;vclx;svn;dxFlowChartRS16;bdertl;VirtualTreesR;dxGDIPlusRS16;dxBarDBNavRS16;$(DCC_UsePackage)</DCC_UsePackage>
+			<DCC_Namespace>Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;$(DCC_Namespace)</DCC_Namespace>
+			<VerInfo_Locale>1033</VerInfo_Locale>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Cfg_1)'!=''">
+			<DCC_Define>DEBUG;$(DCC_Define)</DCC_Define>
+			<DCC_Optimize>false</DCC_Optimize>
+			<DCC_GenerateStackFrames>true</DCC_GenerateStackFrames>
+			<DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
+			<DCC_RemoteDebug>true</DCC_RemoteDebug>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Cfg_1_Win32)'!=''">
+			<VerInfo_Locale>1033</VerInfo_Locale>
+			<DCC_RemoteDebug>false</DCC_RemoteDebug>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Cfg_2)'!=''">
+			<DCC_LocalDebugSymbols>false</DCC_LocalDebugSymbols>
+			<DCC_Define>RELEASE;$(DCC_Define)</DCC_Define>
+			<DCC_SymbolReferenceInfo>0</DCC_SymbolReferenceInfo>
+			<DCC_DebugInformation>false</DCC_DebugInformation>
+		</PropertyGroup>
+		<PropertyGroup Condition="'$(Cfg_2_Win32)'!=''">
+			<VerInfo_Locale>1033</VerInfo_Locale>
+		</PropertyGroup>
+		<ItemGroup>
+			<DelphiCompile Include="$(MainSource)">
+				<MainSource>MainSource</MainSource>
+			</DelphiCompile>
+			<DCCReference Include="source\TestAPI.pas"/>
+			<DCCReference Include="..\Lua.pas"/>
+			<DCCReference Include="..\Lua.Wrapper.pas"/>
+			<DCCReference Include="source\TestWrapper.pas"/>
+			<BuildConfiguration Include="Release">
+				<Key>Cfg_2</Key>
+				<CfgParent>Base</CfgParent>
+			</BuildConfiguration>
+			<BuildConfiguration Include="Base">
+				<Key>Base</Key>
+			</BuildConfiguration>
+			<BuildConfiguration Include="Debug">
+				<Key>Cfg_1</Key>
+				<CfgParent>Base</CfgParent>
+			</BuildConfiguration>
+		</ItemGroup>
+		<ProjectExtensions>
+			<Borland.Personality>Delphi.Personality.12</Borland.Personality>
+			<Borland.ProjectType/>
+			<BorlandProject>
+				<Delphi.Personality>
+					<VersionInfo>
+						<VersionInfo Name="IncludeVerInfo">False</VersionInfo>
+						<VersionInfo Name="AutoIncBuild">False</VersionInfo>
+						<VersionInfo Name="MajorVer">1</VersionInfo>
+						<VersionInfo Name="MinorVer">0</VersionInfo>
+						<VersionInfo Name="Release">0</VersionInfo>
+						<VersionInfo Name="Build">0</VersionInfo>
+						<VersionInfo Name="Debug">False</VersionInfo>
+						<VersionInfo Name="PreRelease">False</VersionInfo>
+						<VersionInfo Name="Special">False</VersionInfo>
+						<VersionInfo Name="Private">False</VersionInfo>
+						<VersionInfo Name="DLL">False</VersionInfo>
+						<VersionInfo Name="Locale">1043</VersionInfo>
+						<VersionInfo Name="CodePage">1252</VersionInfo>
+					</VersionInfo>
+					<VersionInfoKeys>
+						<VersionInfoKeys Name="CompanyName"/>
+						<VersionInfoKeys Name="FileDescription"/>
+						<VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys>
+						<VersionInfoKeys Name="InternalName"/>
+						<VersionInfoKeys Name="LegalCopyright"/>
+						<VersionInfoKeys Name="LegalTrademarks"/>
+						<VersionInfoKeys Name="OriginalFilename"/>
+						<VersionInfoKeys Name="ProductName"/>
+						<VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys>
+						<VersionInfoKeys Name="Comments"/>
+					</VersionInfoKeys>
+					<Source>
+						<Source Name="MainSource">DelphiLuaUnitTests.dpr</Source>
+					</Source>
+					<Excluded_Packages>
+						<Excluded_Packages Name="F:\Components\bin\DXE2\win32\JvBDEDesign160.bpl">JVCL BDE Components</Excluded_Packages>
+					</Excluded_Packages>
+				</Delphi.Personality>
+				<Deployment/>
+				<Platforms>
+					<Platform value="Win64">False</Platform>
+					<Platform value="OSX32">False</Platform>
+					<Platform value="Win32">True</Platform>
+				</Platforms>
+				<UnitTesting>
+					<TestFramework>DUnit / Delphi Win32</TestFramework>
+					<TestRunner>GUI</TestRunner>
+					<TestProjectName/>
+					<SourceProjectName/>
+				</UnitTesting>
+			</BorlandProject>
+			<ProjectFileVersion>12</ProjectFileVersion>
+		</ProjectExtensions>
+		<Import Condition="Exists('$(BDS)\Bin\CodeGear.Delphi.Targets')" Project="$(BDS)\Bin\CodeGear.Delphi.Targets"/>
+		<Import Condition="Exists('$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj')" Project="$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj"/>
+	</Project>

UnitTests/source/TestAPI.pas

@@ -0,0 +1,128 @@
+unit TestAPI;
+
+interface
+uses
+  TestFramework;
+
+
+type
+  TTestAPI = class(TTestCase)
+  protected
+    procedure SetUp; override;
+  published
+    procedure NewStateAndClose;
+    procedure Load;
+    procedure LoadAndCall;
+  end;
+
+
+implementation
+uses
+  Classes,
+  SysUtils,
+
+  Lua;
+
+
+{ TTestAPI }
+procedure TTestAPI.SetUp;
+begin
+  inherited;
+
+  LoadLuaLib;
+end;
+
+
+procedure TTestAPI.NewStateAndClose;
+var
+  state: lua_State;
+
+begin
+  state := lua_newstate(@DefaultLuaAlloc, nil);
+  try
+    Check(Assigned(state), 'state is not assigned');
+  finally
+    lua_close(state);
+  end;
+end;
+
+
+
+type
+  PLuaScript = ^TLuaScript;
+  TLuaScript = record
+    Data: AnsiString;
+    Remaining: Integer;
+
+    constructor Create(const AData: string);
+  end;
+
+
+{ TLuaScript }
+constructor TLuaScript.Create(const AData: string);
+begin
+  Data := AnsiString(AData);
+  Remaining := Length(Data);
+end;
+
+
+function TestReaderProc(L: lua_State; ud: Pointer; var sz: size_t): PAnsiChar; cdecl;
+var
+  script: PLuaScript;
+
+begin
+  script := ud;
+  if script^.Remaining = 0 then
+  begin
+    Result := nil;
+    exit;
+  end;
+
+  sz := script^.Remaining;
+  script^.Remaining := 0;
+
+  Result := PAnsiChar(script^.Data);
+end;
+
+
+procedure TTestAPI.Load;
+var
+  state: lua_State;
+  script: TLuaScript;
+
+begin
+  state := lua_newstate(@DefaultLuaAlloc, nil);
+  try
+    script := TLuaScript.Create('print("Hello world!")');
+    CheckEquals(0, lua_load(state, @TestReaderProc, @script, nil, nil), 'lua_load result');
+  finally
+    lua_close(state);
+  end;
+end;
+
+
+procedure TTestAPI.LoadAndCall;
+var
+  state: lua_State;
+  script: TLuaScript;
+
+begin
+  state := lua_newstate(@DefaultLuaAlloc, nil);
+  try
+    luaopen_base(state);
+
+    script := TLuaScript.Create('print("Hello world!")');
+    CheckEquals(0, lua_load(state, @TestReaderProc, @script, nil, nil), 'lua_load result');
+
+    if lua_pcall(state, 0, 0, 0) <> 0 then
+      Fail(string(lua_tolstring(state, -1, nil)));
+  finally
+    lua_close(state);
+  end;
+end;
+
+
+initialization
+  RegisterTest(TTestAPI.Suite);
+
+end.

UnitTests/source/TestWrapper.pas

@@ -0,0 +1,106 @@
+unit TestWrapper;
+
+interface
+uses
+  System.SysUtils,
+
+  TestFramework,
+
+  Lua.Wrapper;
+
+
+type
+  TTestWrapper = class(TTestCase)
+  private
+    FLua: TLua;
+    FPrinted: TStringBuilder;
+  protected
+    procedure SetUp; override;
+    procedure TearDown; override;
+
+    property Lua: TLua read FLua;
+    property Printed: TStringBuilder read FPrinted;
+  published
+    procedure NewState;
+    procedure LoadAndCallFromString;
+    procedure LoadAndCallFromStream;
+
+    procedure FunctionResult;
+  end;
+
+
+implementation
+uses
+  System.Classes;
+
+
+type
+  TProtectedLua = class(TLua);
+
+
+{ TTestWrapper }
+procedure TTestWrapper.SetUp;
+begin
+  inherited;
+
+  FPrinted := TStringBuilder.Create;
+
+  FLua := TLua.Create;
+  FLua.RegisterFunction('print',
+    procedure(AContext: ILuaContext)
+    begin
+      FPrinted.Append(AContext.Parameters.ToString);
+    end);
+end;
+
+
+procedure TTestWrapper.TearDown;
+begin
+  FreeAndNil(FPrinted);
+  FreeAndNil(FLua);
+
+  inherited;
+end;
+
+
+procedure TTestWrapper.NewState;
+begin
+  TProtectedLua(Lua).CheckState;
+end;
+
+
+
+procedure TTestWrapper.LoadAndCallFromString;
+begin
+  Lua.LoadFromString('print("Hello world!")');
+  Lua.Call;
+  CheckEquals('Hello world!', Printed.ToString);
+end;
+
+
+procedure TTestWrapper.LoadAndCallFromStream;
+begin
+  Lua.LoadFromStream(TStringStream.Create('print("Hello world!")'));
+  Lua.Call;
+  CheckEquals('Hello world!', Printed.ToString);
+end;
+
+
+procedure TTestWrapper.FunctionResult;
+begin
+  Lua.RegisterFunction('myuppercase',
+    procedure(AContext: ILuaContext)
+    begin
+      AContext.Result.Push(UpperCase(AContext.Parameters[0].AsString));
+    end);
+
+  Lua.LoadFromString('print(myuppercase("Hello world!"))');
+  Lua.Call;
+  CheckEquals('HELLO WORLD!', Printed.ToString);
+end;
+
+
+initialization
+  RegisterTest(TTestWrapper.Suite);
+
+end.