Initial commit

9 years ago · b946dbcca5
14 changed files with 3073 additions and 0 deletions
--- a/Lua.Wrapper.pas
+++ b/Lua.Wrapper.pas
@ -0,0 +1,750 @@
				@@ -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.
--- a/Lua.pas
+++ b/Lua.pas
@ -0,0 +1,650 @@
				@@ -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.
--- a/LuaBinaries/include/lauxlib.h
+++ b/LuaBinaries/include/lauxlib.h
@ -0,0 +1,212 @@
				@@ -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
+
+
--- a/LuaBinaries/include/lua.h
+++ b/LuaBinaries/include/lua.h
@ -0,0 +1,439 @@
				@@ -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);