From b946dbcca5cd6d3ecc098bf82de28ad009c99cc1 Mon Sep 17 00:00:00 2001
From: Mark van Renswoude <mark@x2software.net>
Date: Sun, 30 Nov 2014 09:33:17 +0000
Subject: [PATCH] Initial commit

---
 Lua.Wrapper.pas                    | 750 +++++++++++++++++++++++++++++
 Lua.pas                            | 650 +++++++++++++++++++++++++
 LuaBinaries/include/lauxlib.h      | 212 ++++++++
 LuaBinaries/include/lua.h          | 439 +++++++++++++++++
 LuaBinaries/include/lua.hpp        |   9 +
 LuaBinaries/include/luaconf.h      | 548 +++++++++++++++++++++
 LuaBinaries/include/lualib.h       |  55 +++
 LuaBinaries/liblua52.a             | Bin 0 -> 93336 bytes
 LuaBinaries/lua52.dll              | Bin 0 -> 253042 bytes
 UnitTests/DelphiLuaUnitTests.dpr   |  15 +
 UnitTests/DelphiLuaUnitTests.dproj | 161 +++++++
 UnitTests/DelphiLuaUnitTests.res   | Bin 0 -> 96 bytes
 UnitTests/source/TestAPI.pas       | 128 +++++
 UnitTests/source/TestWrapper.pas   | 106 ++++
 14 files changed, 3073 insertions(+)
 create mode 100644 Lua.Wrapper.pas
 create mode 100644 Lua.pas
 create mode 100644 LuaBinaries/include/lauxlib.h
 create mode 100644 LuaBinaries/include/lua.h
 create mode 100644 LuaBinaries/include/lua.hpp
 create mode 100644 LuaBinaries/include/luaconf.h
 create mode 100644 LuaBinaries/include/lualib.h
 create mode 100644 LuaBinaries/liblua52.a
 create mode 100644 LuaBinaries/lua52.dll
 create mode 100644 UnitTests/DelphiLuaUnitTests.dpr
 create mode 100644 UnitTests/DelphiLuaUnitTests.dproj
 create mode 100644 UnitTests/DelphiLuaUnitTests.res
 create mode 100644 UnitTests/source/TestAPI.pas
 create mode 100644 UnitTests/source/TestWrapper.pas

diff --git a/Lua.Wrapper.pas b/Lua.Wrapper.pas
new file mode 100644
index 0000000..d2d5612
--- /dev/null
+++ b/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.
diff --git a/Lua.pas b/Lua.pas
new file mode 100644
index 0000000..647c2a1
--- /dev/null
+++ b/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.
diff --git a/LuaBinaries/include/lauxlib.h b/LuaBinaries/include/lauxlib.h
new file mode 100644
index 0000000..ac4d15f
--- /dev/null
+++ b/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
+
+
diff --git a/LuaBinaries/include/lua.h b/LuaBinaries/include/lua.h
new file mode 100644
index 0000000..a3a3a70
--- /dev/null
+++ b/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
diff --git a/LuaBinaries/include/lua.hpp b/LuaBinaries/include/lua.hpp
new file mode 100644
index 0000000..ec417f5
--- /dev/null
+++ b/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"
+}
diff --git a/LuaBinaries/include/luaconf.h b/LuaBinaries/include/luaconf.h
new file mode 100644
index 0000000..957f925
--- /dev/null
+++ b/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
+
diff --git a/LuaBinaries/include/lualib.h b/LuaBinaries/include/lualib.h
new file mode 100644
index 0000000..9fd126b
--- /dev/null
+++ b/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
diff --git a/LuaBinaries/liblua52.a b/LuaBinaries/liblua52.a
new file mode 100644
index 0000000000000000000000000000000000000000..df8493781101024d58003aa925c33dd3c09b351e
GIT binary patch
literal 93336
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

literal 0
HcmV?d00001

diff --git a/LuaBinaries/lua52.dll b/LuaBinaries/lua52.dll
new file mode 100644
index 0000000000000000000000000000000000000000..6f882f91ab2d7d5796794afb213ccd9e3e7cdcfc
GIT binary patch
literal 253042
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

literal 0
HcmV?d00001

diff --git a/UnitTests/DelphiLuaUnitTests.dpr b/UnitTests/DelphiLuaUnitTests.dpr
new file mode 100644
index 0000000..893f525
--- /dev/null
+++ b/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.
+
diff --git a/UnitTests/DelphiLuaUnitTests.dproj b/UnitTests/DelphiLuaUnitTests.dproj
new file mode 100644
index 0000000..cb08062
--- /dev/null
+++ b/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>
diff --git a/UnitTests/DelphiLuaUnitTests.res b/UnitTests/DelphiLuaUnitTests.res
new file mode 100644
index 0000000000000000000000000000000000000000..743599575b02e97248bade49ed2e3eabafe25a0a
GIT binary patch
literal 96
zcmZQzU|>)H;{X347|28cOhBFu5dZ(r#Sp;Y!{Epe!r;c>&k)4m3uHM0X?F%!AS)QE
O%YcEC1!e#vkO2UW7YiT&

literal 0
HcmV?d00001

diff --git a/UnitTests/source/TestAPI.pas b/UnitTests/source/TestAPI.pas
new file mode 100644
index 0000000..ed93cfd
--- /dev/null
+++ b/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.
diff --git a/UnitTests/source/TestWrapper.pas b/UnitTests/source/TestWrapper.pas
new file mode 100644
index 0000000..f4ecc46
--- /dev/null
+++ b/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.