[hedgewars] lua 5.2
Tom Callaway
spot at fedoraproject.org
Sun May 19 21:18:18 UTC 2013
commit ce1555e47cf9e341b0f503b1ead65eb5bf674ffb
Author: Tom Callaway <spot at fedoraproject.org>
Date: Sun May 19 17:17:51 2013 -0400
lua 5.2
hedgewars-0.9.18-lua-5.2.patch | 2736 ++++++++++++++++++++++++++++++++++++++++
hedgewars.spec | 10 +-
2 files changed, 2744 insertions(+), 2 deletions(-)
---
diff --git a/hedgewars-0.9.18-lua-5.2.patch b/hedgewars-0.9.18-lua-5.2.patch
new file mode 100644
index 0000000..39bde6f
--- /dev/null
+++ b/hedgewars-0.9.18-lua-5.2.patch
@@ -0,0 +1,2736 @@
+diff -up hedgewars-src-0.9.18/cmake_modules/FindLua.cmake.lua-52 hedgewars-src-0.9.18/cmake_modules/FindLua.cmake
+--- hedgewars-src-0.9.18/cmake_modules/FindLua.cmake.lua-52 2012-11-02 13:41:54.000000000 -0400
++++ hedgewars-src-0.9.18/cmake_modules/FindLua.cmake 2013-05-19 17:12:39.488053196 -0400
+@@ -17,12 +17,12 @@ else (ANDROID)
+ SET(LUA_DEFAULT lua)
+ ELSE(APPLE)
+ #locate the system's lua library
+- FIND_LIBRARY(LUA_DEFAULT NAMES lua51 lua5.1 lua-5.1 lua PATHS /lib /usr/lib /usr/local/lib /usr/pkg/lib)
++ FIND_LIBRARY(LUA_DEFAULT NAMES lua52 lua5.2 lua-5.2 lua51 lua5.1 lua-5.1 lua PATHS /lib /usr/lib /usr/local/lib /usr/pkg/lib)
+ IF(${LUA_DEFAULT} MATCHES "LUA_DEFAULT-NOTFOUND")
+ set(LUA_DEFAULT lua)
+ ELSE()
+ set(LUA_FOUND true)
+- message(STATUS "LibLua 5.1 found at ${LUA_DEFAULT}")
++ message(STATUS "LibLua found at ${LUA_DEFAULT}")
+ #remove the path (fpc doesn't like it - why?)
+ GET_FILENAME_COMPONENT(LUA_DEFAULT ${LUA_DEFAULT} NAME)
+ ENDIF()
+diff -up hedgewars-src-0.9.18/hedgewars/LuaPas.pas.lua-52 hedgewars-src-0.9.18/hedgewars/LuaPas.pas
+--- hedgewars-src-0.9.18/hedgewars/LuaPas.pas.lua-52 2012-11-02 13:41:54.000000000 -0400
++++ hedgewars-src-0.9.18/hedgewars/LuaPas.pas 2013-05-19 17:12:39.489053196 -0400
+@@ -3,1066 +3,911 @@
+
+ unit LuaPas;
+
+-(*
+- * A complete Pascal wrapper for Lua 5.1 DLL module.
+- *
+- * Created by Geo Massar, 2006
+- * Distributed as free/open source.
+- *)
+-
+-interface
+-uses uConsts;
+-{.$DEFINE LUA_GETHOOK}
+-
+-type
+-{$IFNDEF PAS2C}
+- size_t = Cardinal;
+-{$ENDIF}
+- Psize_t = ^size_t;
+- PPointer = ^Pointer;
+-
+- lua_State = record end;
+- Plua_State = ^lua_State;
+-
+-{$DEFINE LuaLibName:= cLuaLibrary}
+-
+-
+-(*****************************************************************************)
+-(* luaconfig.h *)
+-(*****************************************************************************)
+-
+-(*
+-** $Id: luaconf.h,v 1.81 2006/02/10 17:44:06 roberto Exp $
+-** Configuration file for Lua
+-** See Copyright Notice in lua.h
+-*)
+-
+-(*
+-** {==================================================================
+-@@ LUA_NUMBER is the type of numbers in Lua.
+-** CHANGE the following definitions only if you want to build Lua
+-** with a number type different from double. You may also need to
+-** change lua_number2int & lua_number2integer.
+-** ===================================================================
+-*)
+-type
+- LUA_NUMBER_ = Double; // ending underscore is needed in Pascal
+- LUA_INTEGER_ = PtrInt;
+-
+-(*
+-@@ LUA_IDSIZE gives the maximum size for the description of the source
+-@* of a function in debug information.
+-** CHANGE it if you want a different size.
+-*)
+-const
+- LUA_IDSIZE = 60;
+-
+-(*
+-@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+-*)
+-const
+- LUAL_BUFFERSIZE = 1024;
+-
+-(*
+-@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
+-@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
+-** CHANGE them if you want different prompts. (You can also change the
+-** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
+-*)
+-const
+- LUA_PROMPT = '> ';
+- LUA_PROMPT2 = '>> ';
+-
+-(*
+-@@ lua_readline defines how to show a prompt and then read a line from
+-@* the standard input.
+-@@ lua_saveline defines how to "save" a read line in a "history".
+-@@ lua_freeline defines how to free a line read by lua_readline.
+-** CHANGE them if you want to improve this functionality (e.g., by using
+-** GNU readline and history facilities).
+-*)
+-{function lua_readline(L : Plua_State;
+-var b : PChar; p : PChar): Boolean;}
+-
+-procedure lua_saveline(L : Plua_State; idx : LongInt);
+-
+-procedure lua_freeline(L : Plua_State; b : PChar);
+-
+-(*
+-@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
+-@* is, whether we're running lua interactively).
+-** CHANGE it if you have a better definition for non-POSIX/non-Windows
+-** systems.
+-*/
+-#include <io.h>
+-#include <stdio.h>
+-#define lua_stdin_is_tty() _isatty(_fileno(stdin))
+-*)
+-const
+- lua_stdin_is_tty = TRUE;
+-
+-(*****************************************************************************)
+-(* lua.h *)
+-(*****************************************************************************)
+-
+-(*
+-** $Id: lua.h,v 1.216 2006/01/10 12:50:13 roberto Exp $
+-** Lua - An Extensible Extension Language
++(******************************************************************************
++ * *
++ * File: lua52.pas *
++ * *
++ * Authors: TeCGraf (C headers + actual Lua libraries) *
++ * Lavergne Thomas (original translation to Pascal) *
++ * Bram Kuijvenhoven (update to Lua 5.1.1 for FreePascal) *
++ * Egor Skriptunoff (update to Lua 5.2.1 for FreePascal) *
++ * Vladimir Klimov (Delphi compatibility) *
++ * *
++ * Description: Basic Lua library *
++ * Lua auxiliary library *
++ * Standard Lua libraries *
++ * This is 3-in-1 replacement for FPC modules lua.pas,lauxlib.pas,lualib.pas *
++ * *
++ ******************************************************************************)
++
++(*
++** $Id: lua.h,v 1.283 2012/04/20 13:18:26 roberto Exp $
++** $Id: lauxlib.h,v 1.120 2011/11/29 15:55:08 roberto Exp $
++** $Id: lualib.h,v 1.43 2011/12/08 12:11:37 roberto Exp $
++** Lua - A Scripting Language
+ ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+ ** See Copyright Notice at the end of this file
+ *)
+-
+-const
+- LUA_VERSION = 'Lua 5.1';
+- LUA_VERSION_NUM = 501;
+- LUA_COPYRIGHT = 'Copyright (C) 1994-2006 Tecgraf, PUC-Rio';
+- LUA_AUTHORS = 'R. Ierusalimschy, L. H. de Figueiredo & W. Celes';
+-
+- (* mark for precompiled code (`<esc>Lua') *)
+- //LUA_SIGNATURE = #27'Lua';
+-
+- (* option for multiple returns in `lua_pcall' and `lua_call' *)
+- LUA_MULTRET = -1;
+-
+- (*
+- ** pseudo-indices
+- *)
+- LUA_REGISTRYINDEX = -10000;
+- LUA_ENVIRONINDEX = -10001;
+- LUA_GLOBALSINDEX = -10002;
+-
+-function lua_upvalueindex(idx : LongInt) : LongInt; // a marco
+-
+-const
+- (* thread status; 0 is OK *)
+- LUA_YIELD_ = 1; // Note: the ending underscore is needed in Pascal
+- LUA_ERRRUN = 2;
+- LUA_ERRSYNTAX = 3;
+- LUA_ERRMEM = 4;
+- LUA_ERRERR = 5;
+-
+-type
+- lua_CFunction = function(L : Plua_State) : LongInt; cdecl;
+-
+- (*
+- ** functions that read/write blocks when loading/dumping Lua chunks
+- *)
+- lua_Reader = function (L : Plua_State; ud : Pointer; sz : Psize_t) : PChar; cdecl;
+- lua_Writer = function (L : Plua_State; const p : Pointer; sz : size_t; ud : Pointer) : LongInt; cdecl;
+-
+- (*
+- ** prototype for memory-allocation functions
+- *)
+- lua_Alloc = function (ud, ptr : Pointer; osize, nsize : size_t) : Pointer; cdecl;
+-
+-const
+- (*
+- ** basic types
+- *)
+- LUA_TNONE = -1;
+- LUA_TNIL = 0;
+- LUA_TBOOLEAN = 1;
+- LUA_TLIGHTUSERDATA = 2;
+- LUA_TNUMBER = 3;
+- LUA_TSTRING = 4;
+- LUA_TTABLE = 5;
+- LUA_TFUNCTION = 6;
+- LUA_TUSERDATA = 7;
+- LUA_TTHREAD = 8;
+-
+- (* minimum Lua stack available to a C function *)
+- LUA_MINSTACK = 20;
+-
+-type
+- (* type of numbers in Lua *)
+- lua_Number = LUA_NUMBER_;
+-
+- (* type for integer functions *)
+- lua_Integer = LUA_INTEGER_;
+-
+-(*
+-** state manipulation
+-*)
+-function lua_newstate(f : lua_Alloc; ud : Pointer) : Plua_State;
+- cdecl; external LuaLibName;
+-
+-procedure lua_close(L: Plua_State);
+- cdecl; external LuaLibName;
+-function lua_newthread(L : Plua_State) : Plua_State;
+- cdecl; external LuaLibName;
+-
+-function lua_atpanic(L : Plua_State; panicf : lua_CFunction) : lua_CFunction;
+- cdecl; external LuaLibName;
+-
+-
+-(*
+-** basic stack manipulation
+-*)
+-function lua_gettop(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-procedure lua_settop(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushvalue(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_remove(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_insert(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_replace(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-function lua_checkstack(L : Plua_State; sz : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-procedure lua_xmove(src, dest : Plua_State; n : LongInt);
+- cdecl; external LuaLibName;
+-
+-
+-(*
+-** access functions (stack -> C)
+-*)
+-function lua_isnumber(L : Plua_State; idx : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_isstring(L : Plua_State; idx : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_iscfunction(L : Plua_State; idx : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_isuserdata(L : Plua_State; idx : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_type(L : Plua_State; idx : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_typename(L : Plua_State; tp : LongInt) : PChar;
+- cdecl; external LuaLibName;
+-
+-
+-function lua_equal(L : Plua_State; idx1, idx2 : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_rawequal(L : Plua_State; idx1, idx2 : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_lessthan(L : Plua_State; idx1, idx2 : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_tonumber(L : Plua_State; idx : LongInt) : lua_Number;
+- cdecl; external LuaLibName;
+-
+-function lua_tointeger(L : Plua_State; idx : LongInt) : lua_Integer;
+- cdecl; external LuaLibName;
+-
+-function lua_toboolean(L : Plua_State; idx : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-
+-function lua_tolstring(L : Plua_State; idx : LongInt; len : Psize_t) : PChar;
+- cdecl; external LuaLibName;
+-
+-function lua_objlen(L : Plua_State; idx : LongInt) : size_t;
+- cdecl; external LuaLibName;
+-
+-function lua_tocfunction(L : Plua_State; idx : LongInt) : lua_CFunction;
+- cdecl; external LuaLibName;
+-
+-function lua_touserdata(L : Plua_State; idx : LongInt) : Pointer;
+- cdecl; external LuaLibName;
+-
+-function lua_tothread(L : Plua_State; idx : LongInt) : Plua_State;
+- cdecl; external LuaLibName;
+-
+-function lua_topointer(L : Plua_State; idx : LongInt) : Pointer;
+- cdecl; external LuaLibName;
+-
+-
+-(*
+-** push functions (C -> stack)
+-*)
+-procedure lua_pushnil(L : Plua_State);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushnumber(L : Plua_State; n : lua_Number);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushinteger(L : Plua_State; n : lua_Integer);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushlstring(L : Plua_State; const s : PChar; ls : size_t);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushstring(L : Plua_State; const s : PChar);
+- cdecl; external LuaLibName;
+-
+-
+-function lua_pushvfstring(L : Plua_State;
+- const fmt : PChar; argp : Pointer) : PChar;
+- cdecl; external LuaLibName;
+-
+-function lua_pushfstring(L : Plua_State; const fmt : PChar) : PChar; varargs;
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushcclosure(L : Plua_State; fn : lua_CFunction; n : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushboolean(L : Plua_State; b : LongBool);
+- cdecl; external LuaLibName;
+-
+-procedure lua_pushlightuserdata(L : Plua_State; p : Pointer);
+- cdecl; external LuaLibName;
+-
+-function lua_pushthread(L : Plua_state) : Cardinal;
+- cdecl; external LuaLibName;
+-
+-
+-(*
+-** get functions (Lua -> stack)
+-*)
+-procedure lua_gettable(L : Plua_State ; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_getfield(L : Plua_State; idx : LongInt; k : PChar);
+- cdecl; external LuaLibName;
+-
+-procedure lua_rawget(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_rawgeti(L : Plua_State; idx, n : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_createtable(L : Plua_State; narr, nrec : LongInt);
+- cdecl; external LuaLibName;
+-
+-function lua_newuserdata(L : Plua_State; sz : size_t) : Pointer;
+- cdecl; external LuaLibName;
+-
+-function lua_getmetatable(L : Plua_State; objindex : LongInt) : LongBool;
+- cdecl; external LuaLibName;
+-
+-procedure lua_getfenv(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-
+ (*
+-** set functions (stack -> Lua)
++** Translated to pascal by Lavergne Thomas
++** Notes :
++** - Pointers type was prefixed with 'P'
++** - lua_upvalueindex constant was transformed to function
++** - Some compatibility function was isolated because with it you must have
++** lualib.
++** - LUA_VERSION was suffixed by '_' for avoiding name collision.
++** Bug reports :
++** - thomas.lavergne at laposte.net
++** In french or in english
++*)
++(*
++** Updated to Lua 5.1.1 by Bram Kuijvenhoven (bram at kuijvenhoven dot net),
++** Hexis BV (http://www.hexis.nl), the Netherlands
++** Notes:
++** - Only tested with FPC (FreePascal Compiler)
++** - Using LuaBinaries styled DLL/SO names, which include version names
++** - LUA_YIELD was suffixed by '_' for avoiding name collision
++*)
++(*
++** Updated to Lua 5.2.1 by Egor Skriptunoff
++** Notes:
++** - Only tested with FPC (FreePascal Compiler)
++** - Functions dealing with luaL_Reg were overloaded to accept pointer
++** or open array parameter. In any case, do not forget to terminate
++** your array with "sentinel".
++** - All floating-point exceptions were forcibly disabled in Windows
++** to overcome well-known bug
++** Bug reports:
++** - egor.skriptunoff at gmail.com
++** In russian or in english
++*)
++(*
++** Delphi compatibility by Vladimir Klimov
++** Notes:
++** - fixed luaL_error syntax
++** - PChar replaced with PAnsiChar, String with AnsiString due to since
++** D2009 both PChar and String are unicode
++** Bug reports:
++** - wintarif at narod.ru
++** russian or english
+ *)
+-procedure lua_settable(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_setfield(L : Plua_State; idx : LongInt; const k : PChar);
+- cdecl; external LuaLibName;
+-
+-procedure lua_rawset(L : Plua_State; idx : LongInt);
+- cdecl; external LuaLibName;
+-
+-procedure lua_rawseti(L : Plua_State; idx , n: LongInt);
+- cdecl; external LuaLibName;
+-
+-function lua_setmetatable(L : Plua_State; objindex : LongInt): LongBool;
+- cdecl; external LuaLibName;
+-
+-function lua_setfenv(L : Plua_State; idx : LongInt): LongBool;
+- cdecl; external LuaLibName;
+
+-(*
+-** `load' and `call' functions (load and run Lua code)
+-*)
+-procedure lua_call(L : Plua_State; nargs, nresults : LongInt);
+- cdecl; external LuaLibName;
+-
+-function lua_pcall(L : Plua_State; nargs, nresults, errfunc : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_cpcall(L : Plua_State; func : lua_CFunction; ud : Pointer) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_load(L : Plua_State; reader : lua_Reader; dt : Pointer; const chunkname : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-
+
+-function lua_dump(L : Plua_State; writer : lua_Writer; data: Pointer) : LongInt;
+- cdecl; external LuaLibName;
++//--------------------------
++// What was not translated:
++//--------------------------
++// macro
++// #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
++
++// Generic Buffer manipulation functions and macros were not translated.
++// They are not required in Pascal programs due to powerful String type.
++// luaL_addchar, luaL_addsize, luaL_buffinit, luaL_prepbuffsize,
++// luaL_addlstring, luaL_addstring, luaL_addvalue, luaL_pushresult,
++// luaL_pushresultsize, luaL_buffinitsize, luaL_prepbuffer
++
++// Functions defined with LUA_COMPAT_MODULE are deprecated.
++// They were translated but commented intentionally.
++// Uncomment them if you really need.
++// luaL_pushmodule, luaL_openlib, luaL_register
+
+
+-(*
+-** coroutine functions
+-*)
+-function lua_yield(L : Plua_State; nresults : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_resume(L : Plua_State; narg : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_status(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
++interface
+
+-(*
+-** garbage-collection functions and options
+-*)
+ const
+- LUA_GCSTOP = 0;
+- LUA_GCRESTART = 1;
+- LUA_GCCOLLECT = 2;
+- LUA_GCCOUNT = 3;
+- LUA_GCCOUNTB = 4;
+- LUA_GCSTEP = 5;
+- LUA_GCSETPAUSE = 6;
+- LUA_GCSETSTEPMUL = 7;
+-
+-function lua_gc(L : Plua_State; what, data : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-
+-(*
+-** miscellaneous functions
+-*)
+-function lua_error(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_next(L : Plua_State; idx : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-
+-procedure lua_concat(L : Plua_State; n : LongInt);
+- cdecl; external LuaLibName;
+-
+-function lua_getallocf(L : Plua_State; ud : PPointer) : lua_Alloc;
+- cdecl; external LuaLibName;
+-
+-procedure lua_setallocf(L : Plua_State; f : lua_Alloc; ud : Pointer);
+- cdecl; external LuaLibName;
+-
+-(*
+-** ===============================================================
+-** some useful macros
+-** ===============================================================
+-*)
+-procedure lua_pop(L : Plua_State; n : LongInt);
+-
+-procedure lua_newtable(L : Plua_State);
+-
+-procedure lua_register(L : Plua_State; n : PChar; f : lua_CFunction);
+-
+-procedure lua_pushcfunction(L : Plua_State; f : lua_CFunction);
+-
+-function lua_strlen(L : Plua_State; idx : LongInt) : LongInt;
+-
+-function lua_isfunction(L : Plua_State; n : LongInt) : Boolean;
+-function lua_istable(L : Plua_State; n : LongInt) : Boolean;
+-function lua_islightuserdata(L : Plua_State; n : LongInt) : Boolean;
+-function lua_isnil(L : Plua_State; n : LongInt) : Boolean;
+-function lua_isboolean(L : Plua_State; n : LongInt) : Boolean;
+-function lua_isthread(L : Plua_State; n : LongInt) : Boolean;
+-function lua_isnone(L : Plua_State; n : LongInt) : Boolean;
+-function lua_isnoneornil(L : Plua_State; n : LongInt) : Boolean;
+-
+-procedure lua_pushliteral(L : Plua_State; s : PChar);
+-
+-procedure lua_setglobal(L : Plua_State; s : PChar);
+-procedure lua_getglobal(L : Plua_State; s : PChar);
+-
+-function lua_tostring(L : Plua_State; idx : LongInt) : AnsiString;
+-
+-
+-(*
+-** compatibility macros and functions
+-*)
+-function lua_open : Plua_State;
+-
+-procedure lua_getregistry(L : Plua_State);
+-
+-function lua_getgccount(L : Plua_State) : LongInt;
+-
+-type
+- lua_Chuckreader = lua_Reader;
+- lua_Chuckwriter = lua_Writer;
+-
+-(* ====================================================================== *)
+-
+-(*
+-** {======================================================================
+-** Debug API
+-** =======================================================================
+-*)
++{$IFDEF MSWINDOWS}
++ LUA_LIB_NAME = 'lua52.dll';
++{$ELSE}
++ LUA_LIB_NAME = 'liblua-5.2.so';
++{$ENDIF}
+
+-(*
+-** Event codes
+-*)
+ const
+- LUA_HOOKCALL = 0;
+- LUA_HOOKRET = 1;
+- LUA_HOOKLINE = 2;
+- LUA_HOOKCOUNT = 3;
+- LUA_HOOKTAILRET = 4;
+-
+-
+-(*
+-** Event masks
+-*)
+- LUA_MASKCALL = 1 shl LUA_HOOKCALL;
+- LUA_MASKRET = 1 shl LUA_HOOKRET;
+- LUA_MASKLINE = 1 shl LUA_HOOKLINE;
+- LUA_MASKCOUNT = 1 shl LUA_HOOKCOUNT;
++ LUA_VERSION_MAJOR = '5';
++ LUA_VERSION_MINOR = '2';
++ LUA_VERSION_NUM = 502;
++ LUA_VERSION_RELEASE = '1';
++ LUA_VERSION_ = 'Lua 5.2'; // LUA_VERSION was suffixed by '_' for avoiding name collision
++ LUA_RELEASE = 'Lua 5.2.1';
++ LUA_COPYRIGHT = 'Lua 5.2.1 Copyright (C) 1994-2012 Lua.org, PUC-Rio';
++ LUA_AUTHORS = 'R. Ierusalimschy, L. H. de Figueiredo, W. Celes';
++ LUA_SIGNATURE = #27'Lua'; // mark for precompiled code '<esc>Lua'
++ LUA_MULTRET = -1; // option for multiple returns in 'lua_pcall' and 'lua_call'
++
++ // pseudo-indices
++ LUA_REGISTRYINDEX = -1001000;
++
++function lua_upvalueindex(I: Integer): Integer;
++
++// thread status
++const
++ LUA_OK = 0;
++ LUA_YIELD_ = 1; // LUA_YIELD was suffixed by '_' for avoiding name collision
++ LUA_ERRRUN = 2;
++ LUA_ERRSYNTAX = 3;
++ LUA_ERRMEM = 4;
++ LUA_ERRGCMM = 5;
++ LUA_ERRERR = 6;
++ LUA_ERRFILE = LUA_ERRERR + 1; // extra error code for `luaL_load'
+
+ type
+- lua_Debug = packed record
+- event : LongInt;
+- name : PChar; (* (n) *)
+- namewhat : PChar; (* (n) `global', `local', `field', `method' *)
+- what : PChar; (* (S) `Lua', `C', `main', `tail' *)
+- source : PChar; (* (S) *)
+- currentline : LongInt; (* (l) *)
+- nups : LongInt; (* (u) number of upvalues *)
+- linedefined : LongInt; (* (S) *)
+- short_src : array [0..LUA_IDSIZE-1] of Char; (* (S) *)
+- (* private part *)
+- i_ci : LongInt; (* active function *)
+- end;
+- Plua_Debug = ^lua_Debug;
+-
+- (* Functions to be called by the debuger in specific events *)
+- lua_Hook = procedure (L : Plua_State; ar : Plua_Debug); cdecl;
+-
+-
+-function lua_getstack(L : Plua_State; level : LongInt; ar : Plua_Debug) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_getinfo(L : Plua_State; const what : PChar; ar: Plua_Debug): LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_getlocal(L : Plua_State; ar : Plua_Debug; n : LongInt) : PChar;
+- cdecl; external LuaLibName;
+-
+-function lua_setlocal(L : Plua_State; ar : Plua_Debug; n : LongInt) : PChar;
+- cdecl; external LuaLibName;
+-
+-function lua_getupvalue(L : Plua_State; funcindex, n : LongInt) : PChar;
+- cdecl; external LuaLibName;
+-
+-function lua_setupvalue(L : Plua_State; funcindex, n : LongInt) : PChar;
+- cdecl; external LuaLibName;
+-
+-function lua_sethook(L : Plua_State; func : lua_Hook; mask, count: LongInt): LongInt;
+- cdecl; external LuaLibName;
+-
+-{$IFDEF LUA_GETHOOK}
+-function lua_gethook(L : Plua_State) : lua_Hook;
+- cdecl; external LuaLibName;
++ // Type of Numbers in Lua
++{$IFDEF FPC}
++ lua_Integer = PtrInt;
++ lua_Unsigned = PtrUInt;
++{$ELSE} // Delphi
++ {$IF CompilerVersion < 20.0}
++ lua_Integer = Integer;
++ lua_Unsigned = Cardinal;
++ {$ELSE}
++ lua_Integer = NativeInt;
++ lua_Unsigned = NativeUInt;
++ {$IFEND}
+ {$ENDIF}
++ lua_Number = Double;
+
+-function lua_gethookmask(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function lua_gethookcount(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-
+-(*****************************************************************************)
+-(* lualib.h *)
+-(*****************************************************************************)
+-
+-(*
+-** $Id: lualib.h,v 1.36 2005/12/27 17:12:00 roberto Exp $
+-** Lua standard libraries
+-** See Copyright Notice at the end of this file
+-*)
+-
+-const
+- (* Key to file-handle type *)
+- LUA_FILEHANDLE = 'FILE*';
+-
+- LUA_COLIBNAME = 'coroutine';
+- LUA_TABLIBNAME = 'table';
+- LUA_IOLIBNAME = 'io';
+- LUA_OSLIBNAME = 'os';
+- LUA_STRLIBNAME = 'string';
+- LUA_MATHLIBNAME = 'math';
+- LUA_DBLIBNAME = 'debug';
+- LUA_LOADLIBNAME = 'package';
++ Plua_Number = ^lua_Number;
+
+-function luaopen_base(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
++ size_t = Cardinal;
++ Psize_t = ^size_t;
+
+-function luaopen_table(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaopen_io(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaopen_os(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaopen_string(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaopen_math(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaopen_debug(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaopen_package(L : Plua_State) : LongInt;
+- cdecl; external LuaLibName;
+-
+-procedure luaL_openlibs(L : Plua_State);
+- cdecl; external LuaLibName;
+-
+-procedure lua_assert(x : Boolean); // a macro
+-
+-
+-(*****************************************************************************)
+-(* lauxlib.h *)
+-(*****************************************************************************)
+-
+-(*
+-** $Id: lauxlib.h,v 1.87 2005/12/29 15:32:11 roberto Exp $
+-** Auxiliary functions for building Lua libraries
+-** See Copyright Notice at the end of this file.
+-*)
++ Plua_State = Pointer;
+
+-// not compatibility with the behavior of setn/getn in Lua 5.0
+-function luaL_getn(L : Plua_State; idx : LongInt) : LongInt;
+-procedure luaL_setn(L : Plua_State; i, j : LongInt);
++ lua_CFunction = function(L: Plua_State): Integer; cdecl;
++
++ // functions that read/write blocks when loading/dumping Lua chunks
++ lua_Reader = function(L: Plua_State; ud: Pointer; sz: Psize_t): PAnsiChar; cdecl;
++ lua_Writer = function(L: Plua_State; const 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;
++
++// state manipulation
++function lua_newstate(f: lua_Alloc; ud: Pointer): Plua_state; cdecl;
++procedure lua_close(L: Plua_State); cdecl;
++function lua_newthread(L: Plua_State): Plua_State; cdecl;
++function lua_atpanic(L: Plua_State; panicf: lua_CFunction): lua_CFunction; cdecl;
++function lua_version(L: Plua_State): Plua_Number; cdecl;
++
++// basic stack manipulation
++function lua_absindex(L: Plua_State; idx: Integer): Integer; cdecl;
++function lua_gettop(L: Plua_State): Integer; cdecl;
++procedure lua_settop(L: Plua_State; idx: Integer); cdecl;
++procedure lua_pushvalue(L: Plua_State; Idx: Integer); cdecl;
++procedure lua_remove(L: Plua_State; idx: Integer); cdecl;
++procedure lua_insert(L: Plua_State; idx: Integer); cdecl;
++procedure lua_replace(L: Plua_State; idx: Integer); cdecl;
++procedure lua_copy(L: Plua_State; fromidx, toidx: Integer); cdecl;
++function lua_checkstack(L: Plua_State; sz: Integer): LongBool; cdecl;
++procedure lua_xmove(from, to_: Plua_State; n: Integer); cdecl;
++
++// access functions (stack -> C)
++function lua_isnumber(L: Plua_State; idx: Integer): LongBool; cdecl;
++function lua_isstring(L: Plua_State; idx: Integer): LongBool; cdecl;
++function lua_iscfunction(L: Plua_State; idx: Integer): LongBool; cdecl;
++function lua_isuserdata(L: Plua_State; idx: Integer): LongBool; cdecl;
++function lua_type(L: Plua_State; idx: Integer): Integer; cdecl;
++function lua_typename(L: Plua_State; tp: Integer): PAnsiChar; cdecl;
++function lua_tonumberx(L: Plua_State; idx: Integer; isnum: PInteger): lua_Number; cdecl;
++function lua_tointegerx(L: Plua_State; idx: Integer; isnum: PInteger): lua_Integer; cdecl;
++function lua_tounsignedx(L: Plua_State; idx: Integer; isnum: PInteger): lua_Unsigned; cdecl;
++function lua_toboolean(L: Plua_State; idx: Integer): LongBool; cdecl;
++function lua_tolstring(L: Plua_State; idx: Integer; len: Psize_t): PAnsiChar; cdecl;
++function lua_rawlen(L: Plua_State; idx: Integer): size_t; cdecl;
++function lua_tocfunction(L: Plua_State; idx: Integer): lua_CFunction; cdecl;
++function lua_touserdata(L: Plua_State; idx: Integer): Pointer; cdecl;
++function lua_tothread(L: Plua_State; idx: Integer): Plua_State; cdecl;
++function lua_topointer(L: Plua_State; idx: Integer): Pointer; cdecl;
++
++// Arithmetic functions
++const
++ LUA_OPADD = 0; (* ORDER TM *)
++ LUA_OPSUB = 1;
++ LUA_OPMUL = 2;
++ LUA_OPDIV = 3;
++ LUA_OPMOD = 4;
++ LUA_OPPOW = 5;
++ LUA_OPUNM = 6;
++procedure lua_arith(L: Plua_State; op: Integer); cdecl;
++
++// Comparison functions
++const
++ LUA_OPEQ = 0;
++ LUA_OPLT = 1;
++ LUA_OPLE = 2;
++function lua_rawequal(L: Plua_State; idx1, idx2: Integer): LongBool; cdecl;
++function lua_compare(L: Plua_State; idx1, idx2, op: Integer): LongBool; cdecl;
++
++// push functions (C -> stack)
++procedure lua_pushnil(L: Plua_State); cdecl;
++procedure lua_pushnumber(L: Plua_State; n: lua_Number); cdecl;
++procedure lua_pushinteger(L: Plua_State; n: lua_Integer); cdecl;
++procedure lua_pushunsigned(L: Plua_State; n: lua_Unsigned); cdecl;
++procedure lua_pushlstring(L: Plua_State; const s: PAnsiChar; l_: size_t); cdecl;
++procedure lua_pushstring(L: Plua_State; const s: PAnsiChar); cdecl; overload;
++procedure lua_pushstring(L: Plua_State; const s: AnsiString); overload; // added for Pascal
++function lua_pushvfstring(L: Plua_State; const fmt: PAnsiChar; argp: Pointer): PAnsiChar; cdecl;
++function lua_pushfstring(L: Plua_State; const fmt: PAnsiChar): PAnsiChar; cdecl; varargs;
++procedure lua_pushcclosure(L: Plua_State; fn: lua_CFunction; n: Integer); cdecl;
++procedure lua_pushboolean(L: Plua_State; b: LongBool); cdecl;
++procedure lua_pushlightuserdata(L: Plua_State; p: Pointer); cdecl;
++procedure lua_pushthread(L: Plua_State); cdecl;
++
++// get functions (Lua -> stack)
++procedure lua_getglobal(L: Plua_State; const var_: PAnsiChar); cdecl;
++procedure lua_gettable(L: Plua_State; idx: Integer); cdecl;
++procedure lua_getfield(L: Plua_state; idx: Integer; k: PAnsiChar); cdecl;
++procedure lua_rawget(L: Plua_State; idx: Integer); cdecl;
++procedure lua_rawgeti(L: Plua_State; idx, n: Integer); cdecl;
++procedure lua_rawgetp(L: Plua_State; idx: Integer; p: Pointer); cdecl;
++procedure lua_createtable(L: Plua_State; narr, nrec: Integer); cdecl;
++function lua_newuserdata(L: Plua_State; sz: size_t): Pointer; cdecl;
++function lua_getmetatable(L: Plua_State; objindex: Integer): Integer; cdecl;
++procedure lua_getuservalue(L: Plua_State; idx: Integer); cdecl;
++
++// set functions (stack -> Lua)
++procedure lua_setglobal(L: Plua_State; const var_: PAnsiChar); cdecl;
++procedure lua_settable(L: Plua_State; idx: Integer); cdecl;
++procedure lua_setfield(L: Plua_State; idx: Integer; k: PAnsiChar); cdecl;
++procedure lua_rawset(L: Plua_State; idx: Integer); cdecl;
++procedure lua_rawseti(L: Plua_State; idx, n: Integer); cdecl;
++procedure lua_rawsetp(L: Plua_State; idx: Integer; p: Pointer); cdecl;
++function lua_setmetatable(L: Plua_State; objindex: Integer): Integer; cdecl;
++procedure lua_setuservalue(L: Plua_State; idx: Integer); cdecl;
++
++// 'load' and 'call' functions (load and run Lua code)
++procedure lua_callk(L: Plua_State; nargs, nresults, ctx: Integer; k: lua_CFunction); cdecl;
++procedure lua_call(L: Plua_State; nargs, nresults: Integer);
++function lua_getctx(L: Plua_State; ctx: PInteger): Integer; cdecl;
++function lua_pcallk(L: Plua_State; nargs, nresults, errfunc, ctx: Integer; k: lua_CFunction): Integer; cdecl;
++function lua_pcall(L: Plua_State; nargs, nresults, errf: Integer): Integer;
++function lua_load(L: Plua_State; reader: lua_Reader; dt: Pointer; const chunkname, mode: PAnsiChar): Integer; cdecl;
++function lua_dump(L: Plua_State; writer: lua_Writer; data: Pointer): Integer; cdecl;
++
++// coroutine functions
++function lua_yieldk(L: Plua_State; nresults, ctx: Integer; k: lua_CFunction): Integer; cdecl;
++function lua_yield(L: Plua_State; nresults: Integer): Integer;
++function lua_resume(L, from: Plua_State; narg: Integer): Integer; cdecl;
++function lua_status(L: Plua_State): Integer; cdecl;
++
++// garbage-collection function and options
++const
++ LUA_GCSTOP = 0;
++ LUA_GCRESTART = 1;
++ LUA_GCCOLLECT = 2;
++ LUA_GCCOUNT = 3;
++ LUA_GCCOUNTB = 4;
++ LUA_GCSTEP = 5;
++ LUA_GCSETPAUSE = 6;
++ LUA_GCSETSTEPMUL = 7;
++ LUA_GCSETMAJORINC = 8;
++ LUA_GCISRUNNING = 9;
++ LUA_GCGEN = 10;
++ LUA_GCINC = 11;
++function lua_gc(L: Plua_State; what, data: Integer): Integer; cdecl;
++
++// miscellaneous functions
++function lua_error(L: Plua_State): Integer; cdecl;
++function lua_next(L: Plua_State; idx: Integer): Integer; cdecl;
++procedure lua_concat(L: Plua_State; n: Integer); cdecl;
++procedure lua_len(L: Plua_State; idx: Integer); cdecl;
++function lua_getallocf(L: Plua_State; ud: PPointer): lua_Alloc; cdecl;
++procedure lua_setallocf(L: Plua_State; f: lua_Alloc; ud: Pointer); cdecl;
++
++// some useful macros
++function lua_tonumber(L: Plua_State; idx: Integer): lua_Number;
++function lua_tointeger(L: Plua_State; idx: Integer): lua_Integer;
++function lua_tounsigned(L: Plua_State; idx: Integer): lua_Unsigned;
++procedure lua_pop(L: Plua_State; n: Integer);
++procedure lua_newtable(L: Plua_state);
++procedure lua_register(L: Plua_State; const n: PAnsiChar; f: lua_CFunction);
++procedure lua_pushcfunction(L: Plua_State; f: lua_CFunction);
++function lua_isfunction(L: Plua_State; n: Integer): Boolean;
++function lua_istable(L: Plua_State; n: Integer): Boolean;
++function lua_islightuserdata(L: Plua_State; n: Integer): Boolean;
++function lua_isnil(L: Plua_State; n: Integer): Boolean;
++function lua_isboolean(L: Plua_State; n: Integer): Boolean;
++function lua_isthread(L: Plua_State; n: Integer): Boolean;
++function lua_isnone(L: Plua_State; n: Integer): Boolean;
++function lua_isnoneornil(L: Plua_State; n: Integer): Boolean;
++procedure lua_pushliteral(L: Plua_State; s: PAnsiChar);
++procedure lua_pushglobaltable(L: Plua_State);
++function lua_tostring(L: Plua_State; i: Integer): PAnsiChar;
++
++// Debug API
++const
++ // Event codes
++ LUA_HOOKCALL = 0;
++ LUA_HOOKRET = 1;
++ LUA_HOOKLINE = 2;
++ LUA_HOOKCOUNT = 3;
++ LUA_HOOKTAILCALL = 4;
++
++ // Event masks
++ LUA_MASKCALL = 1 shl Ord(LUA_HOOKCALL);
++ LUA_MASKRET = 1 shl Ord(LUA_HOOKRET);
++ LUA_MASKLINE = 1 shl Ord(LUA_HOOKLINE);
++ LUA_MASKCOUNT = 1 shl Ord(LUA_HOOKCOUNT);
+
+-const
+- LUA_ERRFILE = LUA_ERRERR + 1;
++ LUA_IDSIZE = 60;
+
+ type
+- luaL_Reg = packed record
+- name : PChar;
+- func : lua_CFunction;
+- end;
+- PluaL_Reg = ^luaL_Reg;
+-
+-
+-procedure luaL_openlib(L : Plua_State; const libname : PChar; const lr : PluaL_Reg; nup : LongInt);
+- cdecl; external LuaLibName;
+-procedure luaL_register(L : Plua_State; const libname : PChar; const lr : PluaL_Reg);
+- cdecl; external LuaLibName;
+-function luaL_getmetafield(L : Plua_State; obj : LongInt; const e : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-function luaL_callmeta(L : Plua_State; obj : LongInt; const e : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-function luaL_typerror(L : Plua_State; narg : LongInt; const tname : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-function luaL_argerror(L : Plua_State; numarg : LongInt; const extramsg : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-function luaL_checklstring(L : Plua_State; numArg : LongInt; ls : Psize_t) : PChar;
+- cdecl; external LuaLibName;
+-function luaL_optlstring(L : Plua_State; numArg : LongInt; const def: PChar; ls: Psize_t) : PChar;
+- cdecl; external LuaLibName;
+-function luaL_checknumber(L : Plua_State; numArg : LongInt) : lua_Number;
+- cdecl; external LuaLibName;
+-function luaL_optnumber(L : Plua_State; nArg : LongInt; def : lua_Number) : lua_Number;
+- cdecl; external LuaLibName;
+-
+-function luaL_checkinteger(L : Plua_State; numArg : LongInt) : lua_Integer;
+- cdecl; external LuaLibName;
+-function luaL_optinteger(L : Plua_State; nArg : LongInt; def : lua_Integer) : lua_Integer;
+- cdecl; external LuaLibName;
+-
+-procedure luaL_checkstack(L : Plua_State; sz : LongInt; const msg : PChar);
+- cdecl; external LuaLibName;
+-procedure luaL_checktype(L : Plua_State; narg, t : LongInt);
+- cdecl; external LuaLibName;
+-procedure luaL_checkany(L : Plua_State; narg : LongInt);
+- cdecl; external LuaLibName;
+-
+-function luaL_newmetatable(L : Plua_State; const tname : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-function luaL_checkudata(L : Plua_State; ud : LongInt; const tname : PChar) : Pointer;
+- cdecl; external LuaLibName;
+-
+-procedure luaL_where(L : Plua_State; lvl : LongInt);
+- cdecl; external LuaLibName;
+-function luaL_error(L : Plua_State; const fmt : PChar) : LongInt; varargs;
+- cdecl; external LuaLibName;
+-
+-function luaL_checkoption(L : Plua_State; narg : LongInt; const def : PChar; const lst : array of PChar) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaL_ref(L : Plua_State; t : LongInt) : LongInt;
+- cdecl; external LuaLibName;
+-procedure luaL_unref(L : Plua_State; t, ref : LongInt);
+- cdecl; external LuaLibName;
+-
+-function luaL_loadfile(L : Plua_State; const filename : PChar) : LongInt;
+- cdecl; external LuaLibName;
+-function luaL_loadbuffer(L : Plua_State; const buff : PChar; sz : size_t; const name: PChar) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaL_loadstring(L : Plua_State; const s : Pchar) : LongInt;
+- cdecl; external LuaLibName;
+-
+-function luaL_newstate : Plua_State;
+- cdecl; external LuaLibName;
+-
+-function luaL_gsub(L : Plua_State; const s, p, r : PChar) : PChar;
+- cdecl; external LuaLibName;
+-
+-function luaL_findtable(L : Plua_State; idx : LongInt; const fname : PChar; szhint : LongInt) : PChar;
+- cdecl; external LuaLibName;
+-
+-
+-(*
+-** ===============================================================
+-** some useful macros
+-** ===============================================================
+-*)
+-
+-function luaL_argcheck(L : Plua_State; cond : Boolean; numarg : LongInt; extramsg : PChar): LongInt;
+-function luaL_checkstring(L : Plua_State; n : LongInt) : PChar;
+-function luaL_optstring(L : Plua_State; n : LongInt; d : PChar) : PChar;
+-function luaL_checkint(L : Plua_State; n : LongInt) : lua_Integer;
+-function luaL_optint(L : Plua_State; n : LongInt; d : lua_Integer): lua_Integer;
+-function luaL_checklong(L : Plua_State; n : LongInt) : lua_Integer;
+-function luaL_optlong(L : Plua_State; n : LongInt; d : lua_Integer) : lua_Integer;
+-
+-function luaL_typename(L : Plua_State; idx : LongInt) : PChar;
+-
+-function luaL_dofile(L : Plua_State; fn : PChar) : LongInt;
+-
+-function luaL_dostring(L : Plua_State; s : PChar) : LongInt;
+-
+-procedure luaL_getmetatable(L : Plua_State; n : PChar);
+-
+-(* not implemented yet
+-#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+-*)
+-
+-(*
+-** {======================================================
+-** Generic Buffer manipulation
+-** =======================================================
+-*)
++ lua_Debug = record (* activation record *)
++ event: Integer;
++ name: PAnsiChar; (* (n) *)
++ namewhat: PAnsiChar; (* (n) `global', `local', `field', `method' *)
++ what: PAnsiChar; (* (S) `Lua', `C', `main', `tail'*)
++ source: PAnsiChar; (* (S) *)
++ currentline: Integer; (* (l) *)
++ linedefined: Integer; (* (S) *)
++ lastlinedefined: Integer; (* (S) *)
++ nups: Byte; (* (u) number of upvalues *)
++ nparams: Byte; (* (u) number of parameters *)
++ isvararg: ByteBool; (* (u) *)
++ istailcall: ByteBool; (* (t) *)
++ short_src: array[0..LUA_IDSIZE - 1] of Char; (* (S) *)
++ (* private part *)
++ i_ci: Pointer; (* active function *) // ptr to struct CallInfo
++ end;
++ Plua_Debug = ^lua_Debug;
++
++ // Functions to be called by the debugger in specific events
++ lua_Hook = procedure(L: Plua_State; ar: Plua_Debug); cdecl;
++
++function lua_getstack(L: Plua_State; level: Integer; ar: Plua_Debug): Integer; cdecl;
++function lua_getinfo(L: Plua_State; const what: PAnsiChar; ar: Plua_Debug): Integer; cdecl;
++function lua_getlocal(L: Plua_State; const ar: Plua_Debug; n: Integer): PAnsiChar; cdecl;
++function lua_setlocal(L: Plua_State; const ar: Plua_Debug; n: Integer): PAnsiChar; cdecl;
++function lua_getupvalue(L: Plua_State; funcindex, n: Integer): PAnsiChar; cdecl;
++function lua_setupvalue(L: Plua_State; funcindex, n: Integer): PAnsiChar; cdecl;
++function lua_upvalueid(L: Plua_State; funcindex, n: Integer): Pointer; cdecl;
++procedure lua_upvaluejoin(L: Plua_State; funcindex1, n1, funcindex2, n2: Integer); cdecl;
++function lua_sethook(L: Plua_State; func: lua_Hook; mask: Integer; count: Integer): Integer; cdecl;
++function lua_gethook(L: Plua_State): lua_Hook; cdecl;
++function lua_gethookmask(L: Plua_State): Integer; cdecl;
++function lua_gethookcount(L: Plua_State): Integer; cdecl;
++
++// pre-defined references
++const
++ LUA_NOREF = -2;
++ LUA_REFNIL = -1;
++
++// compatibility with ref system
++procedure lua_unref(L: Plua_State; ref: Integer);
++procedure lua_getref(L: Plua_State; ref: Integer);
+
+ type
+- luaL_Buffer = packed record
+- p : PChar; (* current position in buffer *)
+- lvl : LongInt; (* number of strings in the stack (level) *)
+- L : Plua_State;
+- buffer : array [0..LUAL_BUFFERSIZE-1] of Char;
+- end;
+- PluaL_Buffer = ^luaL_Buffer;
+-
+-procedure luaL_addchar(B : PluaL_Buffer; c : Char);
+-
+-(* compatibility only *)
+-procedure luaL_putchar(B : PluaL_Buffer; c : Char);
+-
+-procedure luaL_addsize(B : PluaL_Buffer; n : LongInt);
+-
+-procedure luaL_buffinit(L : Plua_State; B : PluaL_Buffer);
+- cdecl; external LuaLibName;
+-function luaL_prepbuffer(B : PluaL_Buffer) : PChar;
+- cdecl; external LuaLibName;
+-procedure luaL_addlstring(B : PluaL_Buffer; const s : PChar; ls : size_t);
+- cdecl; external LuaLibName;
+-procedure luaL_addstring(B : PluaL_Buffer; const s : PChar);
+- cdecl; external LuaLibName;
+-procedure luaL_addvalue(B : PluaL_Buffer);
+- cdecl; external LuaLibName;
+-procedure luaL_pushresult(B : PluaL_Buffer);
+- cdecl; external LuaLibName;
+-
+-(* ====================================================== *)
+-
+-
+-(* compatibility with ref system *)
+-
+-(* pre-defined references *)
+-const
+- LUA_NOREF = -2;
+- LUA_REFNIL = -1;
+-
+-function lua_ref(L : Plua_State; lock : Boolean) : LongInt;
+-
+-procedure lua_unref(L : Plua_State; ref : LongInt);
+-
+-procedure lua_getref(L : Plua_State; ref : LongInt);
+-
+-
+-(******************************************************************************)
+-(******************************************************************************)
+-(******************************************************************************)
++ luaL_Reg = record
++ name: PAnsiChar;
++ func: lua_CFunction;
++ end;
++ PluaL_Reg = ^luaL_Reg;
++
++procedure luaL_checkversion_(L: Plua_State; ver: lua_Number); cdecl;
++procedure luaL_checkversion(L: Plua_State);
++function luaL_getmetafield(L: Plua_State; obj: Integer; const e: PAnsiChar): Integer; cdecl;
++function luaL_callmeta(L: Plua_State; obj: Integer; const e: PAnsiChar): Integer; cdecl;
++function luaL_tolstring(L: Plua_State; idx: Integer; len: Psize_t): PAnsiChar; cdecl;
++function luaL_argerror(L: Plua_State; numarg: Integer; const extramsg: PAnsiChar): Integer; cdecl;
++function luaL_checklstring(L: Plua_State; numArg: Integer; l_: Psize_t): PAnsiChar; cdecl;
++function luaL_optlstring(L: Plua_State; numArg: Integer; const def: PAnsiChar; l_: Psize_t): PAnsiChar; cdecl;
++function luaL_checknumber(L: Plua_State; numArg: Integer): lua_Number; cdecl;
++function luaL_optnumber(L: Plua_State; nArg: Integer; def: lua_Number): lua_Number; cdecl;
++function luaL_checkinteger(L: Plua_State; numArg: Integer): lua_Integer; cdecl;
++function luaL_optinteger(L: Plua_State; nArg: Integer; def: lua_Integer): lua_Integer; cdecl;
++function luaL_checkunsigned(L: Plua_State; numArg: Integer): lua_Unsigned; cdecl;
++function luaL_optunsigned(L: Plua_State; numArg: Integer; def: lua_Unsigned): lua_Unsigned; cdecl;
++procedure luaL_checkstack(L: Plua_State; sz: Integer; const msg: PAnsiChar); cdecl;
++procedure luaL_checktype(L: Plua_State; narg, t: Integer); cdecl;
++procedure luaL_checkany(L: Plua_State; narg: Integer); cdecl;
++function luaL_newmetatable(L: Plua_State; const tname: PAnsiChar): Integer; cdecl;
++procedure luaL_setmetatable(L: Plua_State; const tname: PAnsiChar); cdecl;
++function luaL_testudata(L: Plua_State; ud: Integer; const tname: PAnsiChar): Pointer; cdecl;
++function luaL_checkudata(L: Plua_State; ud: Integer; const tname: PAnsiChar): Pointer; cdecl;
++procedure luaL_where(L: Plua_State; lvl: Integer); cdecl;
++function luaL_error(L: Plua_State; const fmt: PAnsiChar): Integer; cdecl; varargs;
++function luaL_checkoption(L: Plua_State; narg: Integer; def: PAnsiChar; lst: PPAnsiChar): Integer; cdecl;
++function luaL_fileresult(L: Plua_State; stat: Integer; const fname: PAnsiChar): Integer; cdecl;
++function luaL_execresult(L: Plua_State; stat: Integer): Integer; cdecl;
++function luaL_ref(L: Plua_State; t: Integer): Integer; cdecl;
++procedure luaL_unref(L: Plua_State; t, ref: Integer); cdecl;
++function luaL_loadfilex(L: Plua_State; const filename, mode: PAnsiChar): Integer; cdecl;
++function luaL_loadfile(L: Plua_State; const filename: PAnsiChar): Integer;
++function luaL_loadbufferx(L: Plua_State; const buff: PAnsiChar; sz: size_t; const name, mode: PAnsiChar): Integer; cdecl;
++function luaL_loadstring(L: Plua_State; const s: PAnsiChar): Integer; cdecl;
++function luaL_newstate: Plua_State; cdecl;
++function luaL_len(L: Plua_State; idx: Integer): Integer; cdecl;
++function luaL_gsub(L: Plua_State; const s, p, r: PAnsiChar): PAnsiChar; cdecl;
++procedure luaL_setfuncs(L: Plua_State; lr: array of luaL_Reg; nup: Integer); overload;
++procedure luaL_setfuncs(L: Plua_State; lr: PluaL_Reg; nup: Integer); cdecl; overload;
++function luaL_getsubtable(L: Plua_State; idx: Integer; const fname: PAnsiChar): Integer; cdecl;
++procedure luaL_traceback(L, L1: Plua_State; msg: PAnsiChar; level: Integer); cdecl;
++procedure luaL_requiref(L: Plua_State; const modname: PAnsiChar; openf: lua_CFunction; glb: LongBool); cdecl;
++
++// some useful macros
++procedure luaL_newlibtable(L: Plua_State; lr: array of luaL_Reg); overload;
++procedure luaL_newlibtable(L: Plua_State; lr: PluaL_Reg); overload;
++procedure luaL_newlib(L: Plua_State; lr: array of luaL_Reg); overload;
++procedure luaL_newlib(L: Plua_State; lr: PluaL_Reg); overload;
++procedure luaL_argcheck(L: Plua_State; cond: Boolean; numarg: Integer; extramsg: PAnsiChar);
++function luaL_checkstring(L: Plua_State; n: Integer): PAnsiChar;
++function luaL_optstring(L: Plua_State; n: Integer; d: PAnsiChar): PAnsiChar;
++function luaL_checkint(L: Plua_State; n: Integer): Integer;
++function luaL_optint(L: Plua_State; n, d: Integer): Integer;
++function luaL_checklong(L: Plua_State; n: Integer): LongInt;
++function luaL_optlong(L: Plua_State; n: Integer; d: LongInt): LongInt;
++function luaL_typename(L: Plua_State; i: Integer): PAnsiChar;
++function luaL_dofile(L: Plua_State; const filename: PAnsiChar): Integer;
++function luaL_dostring(L: Plua_State; const str: PAnsiChar): Integer;
++procedure luaL_getmetatable(L: Plua_State; tname: PAnsiChar);
++function luaL_loadbuffer(L: Plua_State; const buff: PAnsiChar; size: size_t; const name: PAnsiChar): Integer;
++
++const
++ LUA_COLIBNAME = 'coroutine';
++ LUA_TABLIBNAME = 'table';
++ LUA_IOLIBNAME = 'io';
++ LUA_OSLIBNAME = 'os';
++ LUA_STRLINAME = 'string';
++ LUA_BITLIBNAME = 'bit32';
++ LUA_MATHLIBNAME = 'math';
++ LUA_DBLIBNAME = 'debug';
++ LUA_LOADLIBNAME = 'package';
++
++function luaopen_base(L: Plua_State): LongBool; cdecl;
++function luaopen_coroutine(L: Plua_State): LongBool; cdecl;
++function luaopen_table(L: Plua_State): LongBool; cdecl;
++function luaopen_io(L: Plua_State): LongBool; cdecl;
++function luaopen_os(L: Plua_State): LongBool; cdecl;
++function luaopen_string(L: Plua_State): LongBool; cdecl;
++function luaopen_bit32(L: Plua_State): LongBool; cdecl;
++function luaopen_math(L: Plua_State): LongBool; cdecl;
++function luaopen_debug(L: Plua_State): LongBool; cdecl;
++function luaopen_package(L: Plua_State): LongBool; cdecl;
++
++// open all previous libraries
++procedure luaL_openlibs(L: Plua_State); cdecl;
++
++(* deprecated functions *)
++procedure luaL_pushmodule(L: Plua_State; modname: PAnsiChar; sizehint: Integer); cdecl; deprecated;
++procedure luaL_openlib(L: Plua_State; const libname: PAnsiChar; lr: PluaL_Reg; nup: Integer); cdecl ; overload; deprecated;
++procedure luaL_openlib(L: Plua_State; const libname: PAnsiChar; lr: array of luaL_Reg; nup: Integer); overload; deprecated;
++procedure luaL_register(L: Plua_State; const libname: PAnsiChar; lr: PluaL_Reg); cdecl; overload; deprecated;
++procedure luaL_register(L: Plua_State; const libname: PAnsiChar; lr: array of luaL_Reg); overload; deprecated;
++(* end of deprecated functions *)
+
+ implementation
+
+-uses
+- SysUtils;
++(* deprecated functions *)
++procedure luaL_pushmodule(L: Plua_State; modname: PAnsiChar; sizehint: Integer); cdecl; external LUA_LIB_NAME;
++procedure luaL_openlib(L: Plua_State; const libname: PAnsiChar; lr: PluaL_Reg; nup: Integer); cdecl; external LUA_LIB_NAME;
+
+-(*****************************************************************************)
+-(* luaconfig.h *)
+-(*****************************************************************************)
+-{
+-function lua_readline(L : Plua_State;
+-var
+- b : PChar; p : PChar): Boolean;
+-var
+- s : AnsiString;
++procedure luaL_openlib(L: Plua_State; const libname: PAnsiChar; lr: array of luaL_Reg; nup: Integer);
+ begin
+- Write(p); // show prompt
+- ReadLn(s); // get line
+- b := PChar(s); // and return it
+- lua_readline := (b[0] <> #4); // test for ctrl-D
++ luaL_openlib(L, libname, @lr, nup);
+ end;
+-}
+-procedure lua_saveline(L : Plua_State; idx : LongInt);
++
++procedure luaL_register(L: Plua_State; const libname: PAnsiChar; lr: array of luaL_Reg);
+ begin
++ luaL_openlib(L, libname, @lr, 0);
+ end;
+
+-procedure lua_freeline(L : Plua_State; b : PChar);
++procedure luaL_register(L: Plua_State; const libname: PAnsiChar; lr: PluaL_Reg); cdecl;
+ begin
++ luaL_openlib(L, libname, lr, 0);
+ end;
++(* end of deprecated functions *)
+
++function lua_upvalueindex(I: Integer): Integer;
++begin
++ Result := LUA_REGISTRYINDEX - i;
++end;
+
+-(*****************************************************************************)
+-(* lua.h *)
+-(*****************************************************************************)
++function lua_newstate(f: lua_Alloc; ud: Pointer): Plua_State; cdecl; external LUA_LIB_NAME;
++procedure lua_close(L: Plua_State); cdecl; external LUA_LIB_NAME;
++function lua_newthread(L: Plua_State): Plua_State; cdecl; external LUA_LIB_NAME;
++function lua_atpanic(L: Plua_State; panicf: lua_CFunction): lua_CFunction; cdecl; external LUA_LIB_NAME;
++function lua_version(L: Plua_State): Plua_Number; cdecl; external LUA_LIB_NAME;
++function lua_absindex(L: Plua_State; idx: Integer): Integer; cdecl; external LUA_LIB_NAME;
++function lua_gettop(L: Plua_State): Integer; cdecl; external LUA_LIB_NAME;
++procedure lua_settop(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_pushvalue(L: Plua_State; Idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_remove(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_insert(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_replace(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_copy(L: Plua_State; fromidx, toidx: Integer); cdecl; external LUA_LIB_NAME;
++function lua_checkstack(L: Plua_State; sz: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++procedure lua_xmove(from, to_: Plua_State; n: Integer); cdecl; external LUA_LIB_NAME;
++function lua_isnumber(L: Plua_State; idx: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++function lua_isstring(L: Plua_State; idx: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++function lua_iscfunction(L: Plua_State; idx: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++function lua_isuserdata(L: Plua_State; idx: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++function lua_type(L: Plua_State; idx: Integer): Integer; cdecl; external LUA_LIB_NAME;
++function lua_typename(L: Plua_State; tp: Integer): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_tonumberx(L: Plua_State; idx: Integer; isnum: PInteger): lua_Number; cdecl; external LUA_LIB_NAME;
++function lua_tointegerx(L: Plua_State; idx: Integer; isnum: PInteger): lua_Integer; cdecl; external LUA_LIB_NAME;
++function lua_tounsignedx(L: Plua_State; idx: Integer; isnum: PInteger): lua_Unsigned; cdecl; external LUA_LIB_NAME;
++procedure lua_arith(L: Plua_State; op: Integer); cdecl; external LUA_LIB_NAME;
++function lua_rawequal(L: Plua_State; idx1, idx2: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++function lua_compare(L: Plua_State; idx1, idx2, op: Integer): LongBool; cdecl; external LUA_LIB_NAME;
+
+-function lua_upvalueindex(idx : LongInt) : LongInt;
++function lua_tonumber(L: Plua_State; idx: Integer): lua_Number;
+ begin
+-lua_upvalueindex := LUA_GLOBALSINDEX - idx;
++ Result := lua_tonumberx(L, idx, nil);
+ end;
+
+-procedure lua_pop(L : Plua_State; n : LongInt);
++function lua_tointeger(L: Plua_State; idx: Integer): lua_Integer;
+ begin
+-lua_settop(L, -n - 1);
++ Result := lua_tointegerx(L, idx, nil);
+ end;
+
+-procedure lua_newtable(L : Plua_State);
++function lua_tounsigned(L: Plua_State; idx: Integer): lua_Unsigned;
+ begin
+-lua_createtable(L, 0, 0);
++ Result := lua_tounsignedx(L, idx, nil);
+ end;
+
+-procedure lua_register(L : Plua_State; n : PChar; f : lua_CFunction);
++function lua_toboolean(L: Plua_State; idx: Integer): LongBool; cdecl; external LUA_LIB_NAME;
++function lua_tolstring(L: Plua_State; idx: Integer; len: Psize_t): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_rawlen(L: Plua_State; idx: Integer): size_t; cdecl; external LUA_LIB_NAME;
++function lua_tocfunction(L: Plua_State; idx: Integer): lua_CFunction; cdecl; external LUA_LIB_NAME;
++function lua_touserdata(L: Plua_State; idx: Integer): Pointer; cdecl; external LUA_LIB_NAME;
++function lua_tothread(L: Plua_State; idx: Integer): Plua_State; cdecl; external LUA_LIB_NAME;
++function lua_topointer(L: Plua_State; idx: Integer): Pointer; cdecl; external LUA_LIB_NAME;
++procedure lua_pushnil(L: Plua_State); cdecl; external LUA_LIB_NAME;
++procedure lua_pushnumber(L: Plua_State; n: lua_Number); cdecl; external LUA_LIB_NAME;
++procedure lua_pushinteger(L: Plua_State; n: lua_Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_pushunsigned(L: Plua_State; n: lua_Unsigned); cdecl; external LUA_LIB_NAME;
++procedure lua_pushlstring(L: Plua_State; const s: PAnsiChar; l_: size_t); cdecl; external LUA_LIB_NAME;
++procedure lua_pushstring(L: Plua_State; const s: PAnsiChar); cdecl; external LUA_LIB_NAME;
++
++procedure lua_pushstring(L: Plua_State; const s: AnsiString);
+ begin
+-lua_pushcfunction(L, f);
+-lua_setglobal(L, n);
++ lua_pushlstring(L, PAnsiChar(s), Length(s));
+ end;
+
+-procedure lua_pushcfunction(L : Plua_State; f : lua_CFunction);
++function lua_pushvfstring(L: Plua_State; const fmt: PAnsiChar; argp: Pointer): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_pushfstring(L: Plua_State; const fmt: PAnsiChar): PAnsiChar; cdecl; varargs; external LUA_LIB_NAME;
++procedure lua_pushcclosure(L: Plua_State; fn: lua_CFunction; n: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_pushboolean(L: Plua_State; b: LongBool); cdecl; external LUA_LIB_NAME;
++procedure lua_pushlightuserdata(L: Plua_State; p: Pointer); cdecl; external LUA_LIB_NAME;
++procedure lua_pushthread(L: Plua_State); cdecl; external LUA_LIB_NAME;
++procedure lua_getglobal(L: Plua_State; const var_: PAnsiChar); cdecl; external LUA_LIB_NAME;
++procedure lua_gettable(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_getfield(L: Plua_state; idx: Integer; k: PAnsiChar); cdecl; external LUA_LIB_NAME;
++procedure lua_rawget(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_rawgeti(L: Plua_State; idx, n: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_rawgetp(L: Plua_State; idx: Integer; p: Pointer); cdecl; external LUA_LIB_NAME;
++procedure lua_createtable(L: Plua_State; narr, nrec: Integer); cdecl; external LUA_LIB_NAME;
++function lua_newuserdata(L: Plua_State; sz: size_t): Pointer; cdecl; external LUA_LIB_NAME;
++function lua_getmetatable(L: Plua_State; objindex: Integer): Integer; cdecl; external LUA_LIB_NAME;
++procedure lua_getuservalue(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_setglobal(L: Plua_State; const var_: PAnsiChar); cdecl; external LUA_LIB_NAME;
++procedure lua_settable(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_setfield(L: Plua_State; idx: Integer; k: PAnsiChar); cdecl; external LUA_LIB_NAME;
++procedure lua_rawset(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_rawseti(L: Plua_State; idx, n: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_rawsetp(L: Plua_State; idx: Integer; p: Pointer); cdecl; external LUA_LIB_NAME;
++function lua_setmetatable(L: Plua_State; objindex: Integer): Integer; cdecl; external LUA_LIB_NAME;
++procedure lua_setuservalue(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_callk(L: Plua_State; nargs, nresults, ctx: Integer; k: lua_CFunction); cdecl; external LUA_LIB_NAME;
++function lua_getctx(L: Plua_State; ctx: PInteger): Integer; cdecl; external LUA_LIB_NAME;
++function lua_pcallk(L: Plua_State; nargs, nresults, errfunc, ctx: Integer; k: lua_CFunction): Integer; cdecl; external LUA_LIB_NAME;
++function lua_load(L: Plua_State; reader: lua_Reader; dt: Pointer; const chunkname, mode: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function lua_dump(L: Plua_State; writer: lua_Writer; data: Pointer): Integer; cdecl; external LUA_LIB_NAME;
++function lua_yieldk(L: Plua_State; nresults, ctx: Integer; k: lua_CFunction): Integer; cdecl; external LUA_LIB_NAME;
++
++procedure lua_call(L: Plua_State; nargs, nresults: Integer);
+ begin
+- lua_pushcclosure(L, f, 0);
++ lua_callk(L, nargs, nresults, 0, nil);
+ end;
+
+-function lua_strlen(L : Plua_State; idx : LongInt) : LongInt;
++function lua_pcall(L: Plua_State; nargs, nresults, errf: Integer): Integer;
+ begin
+- lua_strlen := lua_objlen(L, idx);
++ Result := lua_pcallk(L, nargs, nresults, errf, 0, nil);
+ end;
+
+-function lua_isfunction(L : Plua_State; n : LongInt) : Boolean;
++function lua_yield(L: Plua_State; nresults: Integer): Integer;
+ begin
+- lua_isfunction := lua_type(L, n) = LUA_TFUNCTION;
++ Result := lua_yieldk(L, nresults, 0, nil);
+ end;
+
+-function lua_istable(L : Plua_State; n : LongInt) : Boolean;
++function lua_resume(L, from: Plua_State; narg: Integer): Integer; cdecl; external LUA_LIB_NAME;
++function lua_status(L: Plua_State): Integer; cdecl; external LUA_LIB_NAME;
++function lua_gc(L: Plua_State; what, data: Integer): Integer; cdecl; external LUA_LIB_NAME;
++function lua_error(L: Plua_State): Integer; cdecl; external LUA_LIB_NAME;
++function lua_next(L: Plua_State; idx: Integer): Integer; cdecl; external LUA_LIB_NAME;
++procedure lua_concat(L: Plua_State; n: Integer); cdecl; external LUA_LIB_NAME;
++procedure lua_len(L: Plua_State; idx: Integer); cdecl; external LUA_LIB_NAME;
++function lua_getallocf(L: Plua_State; ud: PPointer): lua_Alloc; cdecl; external LUA_LIB_NAME;
++procedure lua_setallocf(L: Plua_State; f: lua_Alloc; ud: Pointer); cdecl; external LUA_LIB_NAME;
++
++procedure lua_pop(L: Plua_State; n: Integer);
+ begin
+- lua_istable := lua_type(L, n) = LUA_TTABLE;
++ lua_settop(L, - n - 1);
+ end;
+
+-function lua_islightuserdata(L : Plua_State; n : LongInt) : Boolean;
++procedure lua_newtable(L: Plua_State);
+ begin
+- lua_islightuserdata := lua_type(L, n) = LUA_TLIGHTUSERDATA;
++ lua_createtable(L, 0, 0);
+ end;
+
+-function lua_isnil(L : Plua_State; n : LongInt) : Boolean;
++procedure lua_register(L: Plua_State; const n: PAnsiChar; f: lua_CFunction);
+ begin
+- lua_isnil := lua_type(L, n) = LUA_TNIL;
++ lua_pushcfunction(L, f);
++ lua_setglobal(L, n);
+ end;
+
+-function lua_isboolean(L : Plua_State; n : LongInt) : Boolean;
++procedure lua_pushcfunction(L: Plua_State; f: lua_CFunction);
+ begin
+- lua_isboolean := lua_type(L, n) = LUA_TBOOLEAN;
++ lua_pushcclosure(L, f, 0);
+ end;
+
+-function lua_isthread(L : Plua_State; n : LongInt) : Boolean;
++function lua_isfunction(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_isthread := lua_type(L, n) = LUA_TTHREAD;
++ Result := lua_type(L, n) = LUA_TFUNCTION;
+ end;
+
+-function lua_isnone(L : Plua_State; n : LongInt) : Boolean;
++function lua_istable(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_isnone := lua_type(L, n) = LUA_TNONE;
++ Result := lua_type(L, n) = LUA_TTABLE;
+ end;
+
+-function lua_isnoneornil(L : Plua_State; n : LongInt) : Boolean;
++function lua_islightuserdata(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_isnoneornil := lua_type(L, n) <= 0;
++ Result := lua_type(L, n) = LUA_TLIGHTUSERDATA;
+ end;
+
+-procedure lua_pushliteral(L : Plua_State; s : PChar);
++function lua_isnil(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_pushlstring(L, s, StrLen(s));
++ Result := lua_type(L, n) = LUA_TNIL;
+ end;
+
+-procedure lua_setglobal(L : Plua_State; s : PChar);
++function lua_isboolean(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_setfield(L, LUA_GLOBALSINDEX, s);
++ Result := lua_type(L, n) = LUA_TBOOLEAN;
+ end;
+
+-procedure lua_getglobal(L: Plua_State; s: PChar);
++function lua_isthread(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_getfield(L, LUA_GLOBALSINDEX, s);
++ Result := lua_type(L, n) = LUA_TTHREAD;
+ end;
+
+-function lua_tostring(L : Plua_State; idx : LongInt) : AnsiString;
++function lua_isnone(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_tostring := StrPas(lua_tolstring(L, idx, nil));
++ Result := lua_type(L, n) = LUA_TNONE;
+ end;
+
+-function lua_open : Plua_State;
++function lua_isnoneornil(L: Plua_State; n: Integer): Boolean;
+ begin
+- lua_open := luaL_newstate;
++ Result := lua_type(L, n) <= 0;
+ end;
+
+-procedure lua_getregistry(L : Plua_State);
++procedure lua_pushliteral(L: Plua_State; s: PAnsiChar);
+ begin
+- lua_pushvalue(L, LUA_REGISTRYINDEX);
++ lua_pushlstring(L, s, Length(s));
+ end;
+
+-function lua_getgccount(L : Plua_State) : LongInt;
++procedure lua_pushglobaltable(L: Plua_State);
+ begin
+- lua_getgccount := lua_gc(L, LUA_GCCOUNT, 0);
++ lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
+ end;
+
++function lua_tostring(L: Plua_State; i: Integer): PAnsiChar;
++begin
++ Result := lua_tolstring(L, i, nil);
++end;
+
+-(*****************************************************************************)
+-(* lualib.h *)
+-(*****************************************************************************)
++function lua_getstack(L: Plua_State; level: Integer; ar: Plua_Debug): Integer; cdecl; external LUA_LIB_NAME;
++function lua_getinfo(L: Plua_State; const what: PAnsiChar; ar: Plua_Debug): Integer; cdecl; external LUA_LIB_NAME;
++function lua_getlocal(L: Plua_State; const ar: Plua_Debug; n: Integer): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_setlocal(L: Plua_State; const ar: Plua_Debug; n: Integer): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_getupvalue(L: Plua_State; funcindex, n: Integer): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_setupvalue(L: Plua_State; funcindex, n: Integer): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function lua_upvalueid(L: Plua_State; funcindex, n: Integer): Pointer; cdecl; external LUA_LIB_NAME;
++procedure lua_upvaluejoin(L: Plua_State; funcindex1, n1, funcindex2, n2: Integer); cdecl; external LUA_LIB_NAME;
++function lua_sethook(L: Plua_State; func: lua_Hook; mask: Integer; count: Integer): Integer; cdecl; external LUA_LIB_NAME;
++function lua_gethook(L: Plua_State): lua_Hook; cdecl; external LUA_LIB_NAME;
++function lua_gethookmask(L: Plua_State): Integer; cdecl; external LUA_LIB_NAME;
++function lua_gethookcount(L: Plua_State): Integer; cdecl; external LUA_LIB_NAME;
+
+-procedure lua_assert(x : Boolean);
++procedure lua_unref(L: Plua_State; ref: Integer);
+ begin
++ luaL_unref(L, LUA_REGISTRYINDEX, ref);
+ end;
+
++procedure lua_getref(L: Plua_State; ref: Integer);
++begin
++ lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
++end;
+
+-(*****************************************************************************)
+-(* lauxlib.h n *)
+-(*****************************************************************************)
++procedure luaL_traceback(L, L1: Plua_State; msg: PAnsiChar; level: Integer); cdecl; external LUA_LIB_NAME;
++function luaL_argerror(L: Plua_State; numarg: Integer; const extramsg: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++procedure luaL_where(L: Plua_State; lvl: Integer); cdecl; external LUA_LIB_NAME;
++function luaL_newmetatable(L: Plua_State; const tname: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++procedure luaL_setmetatable(L: Plua_State; const tname: PAnsiChar); cdecl; external LUA_LIB_NAME;
++function luaL_testudata(L: Plua_State; ud: Integer; const tname: PAnsiChar): Pointer; cdecl; external LUA_LIB_NAME;
++function luaL_checkudata(L: Plua_State; ud: Integer; const tname: PAnsiChar): Pointer; cdecl; external LUA_LIB_NAME;
++function luaL_error(L: Plua_State; const fmt: PAnsiChar): Integer; cdecl; varargs; external LUA_LIB_NAME;
++function luaL_checkoption(L: Plua_State; narg: Integer; def: PAnsiChar; lst: PPAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++procedure luaL_checkstack(L: Plua_State; sz: Integer; const msg: PAnsiChar); cdecl; external LUA_LIB_NAME;
++procedure luaL_checktype(L: Plua_State; narg, t: Integer); cdecl; external LUA_LIB_NAME;
++procedure luaL_checkany(L: Plua_State; narg: Integer); cdecl; external LUA_LIB_NAME;
++function luaL_checklstring(L: Plua_State; numArg: Integer; l_: Psize_t): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function luaL_optlstring(L: Plua_State; numArg: Integer; const def: PAnsiChar; l_: Psize_t): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function luaL_checknumber(L: Plua_State; numArg: Integer): lua_Number; cdecl; external LUA_LIB_NAME;
++function luaL_optnumber(L: Plua_State; nArg: Integer; def: lua_Number): lua_Number; cdecl; external LUA_LIB_NAME;
++function luaL_checkinteger(L: Plua_State; numArg: Integer): lua_Integer; cdecl; external LUA_LIB_NAME;
++function luaL_optinteger(L: Plua_State; nArg: Integer; def: lua_Integer): lua_Integer; cdecl; external LUA_LIB_NAME;
++function luaL_checkunsigned(L: Plua_State; numArg: Integer): lua_Unsigned; cdecl; external LUA_LIB_NAME;
++function luaL_optunsigned(L: Plua_State; numArg: Integer; def: lua_Unsigned): lua_Unsigned; cdecl; external LUA_LIB_NAME;
+
+-function luaL_getn(L : Plua_State; idx : LongInt) : LongInt;
++procedure luaL_argcheck(L: Plua_State; cond: Boolean; numarg: Integer; extramsg: PAnsiChar);
+ begin
+- luaL_getn := lua_objlen(L, idx);
++ if not cond then
++ luaL_argerror(L, numarg, extramsg);
+ end;
+
+-procedure luaL_setn(L : plua_State; i, j : LongInt);
++function luaL_checkstring(L: Plua_State; n: Integer): PAnsiChar;
+ begin
+- (* no op *)
++ Result := luaL_checklstring(L, n, nil);
+ end;
+
+-function luaL_argcheck(L : Plua_State; cond : Boolean; numarg : LongInt; extramsg : PChar): LongInt;
++function luaL_optstring(L: Plua_State; n: Integer; d: PAnsiChar): PAnsiChar;
+ begin
+- if not cond then
+- luaL_argcheck := luaL_argerror(L, numarg, extramsg)
+- else
+- luaL_argcheck := 0;
++ Result := luaL_optlstring(L, n, d, nil);
+ end;
+
+-function luaL_checkstring(L : Plua_State; n : LongInt) : PChar;
++function luaL_checkint(L: Plua_State; n: Integer): Integer;
+ begin
+- luaL_checkstring := luaL_checklstring(L, n, nil);
++ Result := luaL_checkinteger(L, n);
+ end;
+
+-function luaL_optstring(L : Plua_State; n : LongInt; d : PChar) : PChar;
++function luaL_checklong(L: Plua_State; n: Integer): LongInt;
+ begin
+- luaL_optstring := luaL_optlstring(L, n, d, nil);
++ Result := luaL_checkinteger(L, n);
+ end;
+
+-function luaL_checkint(L : Plua_State; n : LongInt) : lua_Integer;
++function luaL_optint(L: Plua_State; n, d: Integer): Integer;
+ begin
+- luaL_checkint := luaL_checkinteger(L, n);
++ Result := luaL_optinteger(L, n, d);
+ end;
+
+-function luaL_optint(L : Plua_State; n : LongInt; d : lua_Integer): lua_Integer;
++function luaL_optlong(L: Plua_State; n: Integer; d: LongInt): LongInt;
+ begin
+- luaL_optint := luaL_optinteger(L, n, d);
++ Result := luaL_optinteger(L, n, d);
+ end;
+
+-function luaL_checklong(L : Plua_State; n : LongInt) : lua_Integer;
++function luaL_typename(L: Plua_State; i: Integer): PAnsiChar;
+ begin
+- luaL_checklong := luaL_checkinteger(L, n);
++ Result := lua_typename(L, lua_type(L, i));
+ end;
+
+-function luaL_optlong(L : Plua_State; n : LongInt; d : lua_Integer) : lua_Integer;
++function luaL_dofile(L: Plua_State; const filename: PAnsiChar): Integer;
+ begin
+- luaL_optlong := luaL_optinteger(L, n, d);
++ Result := luaL_loadfile(L, filename);
++ if Result = 0 then
++ Result := lua_pcall(L, 0, LUA_MULTRET, 0);
+ end;
+
+-function luaL_typename(L : Plua_State; idx : LongInt) : PChar;
++function luaL_dostring(L: Plua_State; const str: PAnsiChar): Integer;
+ begin
+- luaL_typename := lua_typename( L, lua_type(L, idx) );
++ Result := luaL_loadstring(L, str);
++ if Result = 0 then
++ Result := lua_pcall(L, 0, LUA_MULTRET, 0);
+ end;
+
+-function luaL_dofile(L : Plua_State; fn : PChar) : LongInt;
++procedure luaL_getmetatable(L: Plua_State; tname: PAnsiChar);
+ begin
+- luaL_dofile := luaL_loadfile(L, fn);
+- if luaL_dofile = 0 then
+- luaL_dofile := lua_pcall(L, 0, 0, 0);
++ lua_getfield(L, LUA_REGISTRYINDEX, tname);
+ end;
+
+-function luaL_dostring(L : Plua_State; s : PChar) : LongInt;
++function luaL_fileresult(L: Plua_State; stat: Integer; const fname: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_execresult(L: Plua_State; stat: Integer): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_ref(L: Plua_State; t: Integer): Integer; cdecl; external LUA_LIB_NAME;
++procedure luaL_unref(L: Plua_State; t, ref: Integer); cdecl; external LUA_LIB_NAME;
++function luaL_loadfilex(L: Plua_State; const filename, mode: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_loadbufferx(L: Plua_State; const buff: PAnsiChar; sz: size_t; const name, mode: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++
++function luaL_loadfile(L: Plua_State; const filename: PAnsiChar): Integer;
+ begin
+- luaL_dostring := luaL_loadstring(L, s);
+- if luaL_dostring = 0 then
+- luaL_dostring := lua_pcall(L, 0, 0, 0);
++ Result := luaL_loadfilex(L, filename, nil);
+ end;
+
+-procedure luaL_getmetatable(L : Plua_State; n : PChar);
++function luaL_loadbuffer(L: Plua_State; const buff: PAnsiChar; size: size_t; const name: PAnsiChar): Integer;
+ begin
+- lua_getfield(L, LUA_REGISTRYINDEX, n);
++ Result := luaL_loadbufferx(L, buff, size, name, nil);
+ end;
+
+-procedure luaL_addchar(B : PluaL_Buffer; c : Char);
++function luaL_loadstring(L: Plua_State; const s: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_getmetafield(L: Plua_State; obj: Integer; const e: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_callmeta(L: Plua_State; obj: Integer; const e: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_tolstring(L: Plua_State; idx: Integer; len: Psize_t): PAnsiChar; cdecl; external LUA_LIB_NAME;
++procedure luaL_requiref(L: Plua_State; const modname: PAnsiChar; openf: lua_CFunction; glb: LongBool); cdecl; external LUA_LIB_NAME;
++procedure luaL_setfuncs(L: Plua_State; lr: PluaL_Reg; nup: Integer); cdecl; external LUA_LIB_NAME;
++
++procedure luaL_setfuncs(L: Plua_State; lr: array of luaL_Reg; nup: Integer);
+ begin
+- if not(B^.p < B^.buffer + LUAL_BUFFERSIZE) then
+- luaL_prepbuffer(B);
+- (B^.p^) := c;
+- Inc(B^.p);
++ luaL_setfuncs(L, @lr, nup);
+ end;
+
+-procedure luaL_putchar(B : PluaL_Buffer; c : Char);
++procedure luaL_newlibtable(L: Plua_State; lr: array of luaL_Reg);
+ begin
+- luaL_addchar(B, c);
++ lua_createtable(L, 0, High(lr));
+ end;
+
+-procedure luaL_addsize(B : PluaL_Buffer; n : LongInt);
++procedure luaL_newlibtable(L: Plua_State; lr: PluaL_Reg);
++var
++ n: Integer;
+ begin
+- Inc(B^.p, n);
++ n := 0;
++ while lr^.name <> nil do begin
++ inc(n);
++ inc(lr);
++ end;
++ lua_createtable(L, 0, n);
+ end;
+
+-function lua_ref(L : Plua_State; lock : Boolean) : LongInt;
++procedure luaL_newlib(L: Plua_State; lr: array of luaL_Reg);
+ begin
+- if lock then
+- lua_ref := luaL_ref(L, LUA_REGISTRYINDEX)
+- else
+- begin
+- lua_pushstring(L, _P'unlocked references are obsolete');
+- lua_error(L);
+- lua_ref := 0;
+- end;
++ luaL_newlibtable(L, lr);
++ luaL_setfuncs(L, @lr, 0);
+ end;
+
+-procedure lua_unref(L : Plua_State; ref : LongInt);
++procedure luaL_newlib(L: Plua_State; lr: PluaL_Reg);
+ begin
+- luaL_unref(L, LUA_REGISTRYINDEX, ref);
++ luaL_newlibtable(L, lr);
++ luaL_setfuncs(L, lr, 0);
+ end;
+
+-procedure lua_getref(L : Plua_State; ref : LongInt);
++function luaL_gsub(L: Plua_State; const s, p, r: PAnsiChar): PAnsiChar; cdecl; external LUA_LIB_NAME;
++function luaL_getsubtable(L: Plua_State; idx: Integer; const fname: PAnsiChar): Integer; cdecl; external LUA_LIB_NAME;
++function luaL_newstate: Plua_State; cdecl; external LUA_LIB_NAME;
++function luaL_len(L: Plua_State; idx: Integer): Integer; cdecl; external LUA_LIB_NAME;
++procedure luaL_checkversion_(L: Plua_State; ver: lua_Number); cdecl; external LUA_LIB_NAME;
++
++procedure luaL_checkversion(L: Plua_State);
+ begin
+- lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
++ luaL_checkversion_(L, LUA_VERSION_NUM);
+ end;
+
++function luaopen_base(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_coroutine(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_table(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_io(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_os(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_string(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_bit32(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_math(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_debug(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++function luaopen_package(L: Plua_State): LongBool; cdecl; external LUA_LIB_NAME;
++procedure luaL_openlibs(L: Plua_State); cdecl; external LUA_LIB_NAME;
++
++initialization
++{$IFDEF MSWINDOWS}
++ Set8087CW($133F); // disable all floating-point exceptions
++{$ENDIF}
+
+ (******************************************************************************
+-* Original copyright for the lua source and headers:
+-* 1994-2004 Tecgraf, PUC-Rio.
+-* www.lua.org.
+-*
++* 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
+diff -up hedgewars-src-0.9.18/hedgewars/uScript.pas.lua-52 hedgewars-src-0.9.18/hedgewars/uScript.pas
+--- hedgewars-src-0.9.18/hedgewars/uScript.pas.lua-52 2012-11-02 13:41:54.000000000 -0400
++++ hedgewars-src-0.9.18/hedgewars/uScript.pas 2013-05-19 17:13:54.451050517 -0400
+@@ -115,7 +115,7 @@ begin
+ lua_pushnil(L);
+ end
+ else
+- lua_pushinteger(L, lua_tointeger(L, 2) and lua_tointeger(L, 1));
++ lua_pushinteger(L, lua_tointegerx(L, 2, NIL) and lua_tointegerx(L, 1, NIL));
+ lc_band := 1;
+ end;
+
+@@ -127,7 +127,7 @@ begin
+ lua_pushnil(L);
+ end
+ else
+- lua_pushinteger(L, lua_tointeger(L, 2) or lua_tointeger(L, 1));
++ lua_pushinteger(L, lua_tointegerx(L, 2, NIL) or lua_tointegerx(L, 1, NIL));
+ lc_bor := 1;
+ end;
+
+@@ -139,7 +139,7 @@ begin
+ lua_pushnil(L);
+ end
+ else
+- lua_pushinteger(L, not lua_tointeger(L, 1));
++ lua_pushinteger(L, not lua_tointegerx(L, 1, NIL));
+ lc_bnot := 1;
+ end;
+
+@@ -151,7 +151,7 @@ begin
+ lua_pushnil(L);
+ end
+ else
+- lua_pushinteger(L, lua_tointeger(L, 1) div lua_tointeger(L, 2));
++ lua_pushinteger(L, lua_tointegerx(L, 1, NIL) div lua_tointegerx(L, 2, NIL));
+ lc_div := 1;
+ end;
+
+@@ -169,7 +169,7 @@ begin
+ if lua_gettop(L) <> 1 then
+ LuaError('Lua: Wrong number of parameters passed to SetInputMask!')
+ else
+- InputMask:= lua_tointeger(L, 1);
++ InputMask:= lua_tointegerx(L, 1, NIL);
+ lc_setinputmask:= 0
+ end;
+
+@@ -208,7 +208,7 @@ function lc_showmission(L : Plua_State)
+ begin
+ if lua_gettop(L) = 5 then
+ begin
+- ShowMission(lua_tostring(L, 1), lua_tostring(L, 2), lua_tostring(L, 3), lua_tointeger(L, 4), lua_tointeger(L, 5));
++ ShowMission(lua_tostring(L, 1), lua_tostring(L, 2), lua_tostring(L, 3), lua_tointegerx(L, 4, NIL), lua_tointegerx(L, 5, NIL));
+ end
+ else
+ LuaError('Lua: Wrong number of parameters passed to ShowMission!');
+@@ -228,7 +228,7 @@ begin
+ AddCaption(lua_tostring(L, 1), cWhiteColor, capgrpMessage)
+ else if lua_gettop(L) = 3 then
+ begin
+- AddCaption(lua_tostring(L, 1), lua_tointeger(L, 2) shr 8, TCapGroup(lua_tointeger(L, 3)));
++ AddCaption(lua_tostring(L, 1), lua_tointegerx(L, 2, NIL) shr 8, TCapGroup(lua_tointegerx(L, 3, NIL)));
+ end
+ else
+ LuaError('Lua: Wrong number of parameters passed to AddCaption!');
+@@ -267,7 +267,7 @@ begin
+ end
+ else
+ begin
+- gear := SpawnFakeCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2),
++ gear := SpawnFakeCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL),
+ HealthCrate, lua_toboolean(L, 3), lua_toboolean(L, 4));
+ lua_pushinteger(L, gear^.uid);
+ end;
+@@ -284,7 +284,7 @@ begin
+ end
+ else
+ begin
+- gear := SpawnFakeCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2),
++ gear := SpawnFakeCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL),
+ AmmoCrate, lua_toboolean(L, 3), lua_toboolean(L, 4));
+ lua_pushinteger(L, gear^.uid);
+ end;
+@@ -301,7 +301,7 @@ begin
+ end
+ else
+ begin
+- gear := SpawnFakeCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2),
++ gear := SpawnFakeCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL),
+ UtilityCrate, lua_toboolean(L, 3), lua_toboolean(L, 4));
+ lua_pushinteger(L, gear^.uid);
+ end;
+@@ -320,10 +320,10 @@ begin
+ else
+ begin
+ if lua_gettop(L) = 3 then
+- health:= lua_tointeger(L, 3)
++ health:= lua_tointegerx(L, 3, NIL)
+ else
+ health:= cHealthCaseAmount;
+- gear := SpawnCustomCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2), HealthCrate, health, 0);
++ gear := SpawnCustomCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL), HealthCrate, health, 0);
+ if gear <> nil then
+ lua_pushinteger(L, gear^.uid)
+ else
+@@ -343,8 +343,8 @@ begin
+ else
+ begin
+ if (lua_gettop(L) = 3) then
+- gear := SpawnCustomCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2), AmmoCrate, lua_tointeger(L, 3), 0)
+- else gear := SpawnCustomCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2), AmmoCrate, lua_tointeger(L, 3), lua_tointeger(L, 4));
++ gear := SpawnCustomCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL), AmmoCrate, lua_tointegerx(L, 3, NIL), 0)
++ else gear := SpawnCustomCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL), AmmoCrate, lua_tointegerx(L, 3, NIL), lua_tointegerx(L, 4, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.uid)
+ else
+@@ -364,8 +364,8 @@ begin
+ else
+ begin
+ if (lua_gettop(L) = 3) then
+- gear := SpawnCustomCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2), UtilityCrate, lua_tointeger(L, 3), 0)
+- else gear := SpawnCustomCrateAt(lua_tointeger(L, 1), lua_tointeger(L, 2), UtilityCrate, lua_tointeger(L, 3), lua_tointeger(L, 4));
++ gear := SpawnCustomCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL), UtilityCrate, lua_tointegerx(L, 3, NIL), 0)
++ else gear := SpawnCustomCrateAt(lua_tointegerx(L, 1, NIL), lua_tointegerx(L, 2, NIL), UtilityCrate, lua_tointegerx(L, 3, NIL), lua_tointegerx(L, 4, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.uid)
+ else
+@@ -387,13 +387,13 @@ begin
+ end
+ else
+ begin
+- x:= lua_tointeger(L, 1);
+- y:= lua_tointeger(L, 2);
+- gt:= TGearType(lua_tointeger(L, 3));
+- s:= lua_tointeger(L, 4);
+- dx:= int2hwFloat(lua_tointeger(L, 5)) / 1000000;
+- dy:= int2hwFloat(lua_tointeger(L, 6)) / 1000000;
+- t:= lua_tointeger(L, 7);
++ x:= lua_tointegerx(L, 1, NIL);
++ y:= lua_tointegerx(L, 2, NIL);
++ gt:= TGearType(lua_tointegerx(L, 3, NIL));
++ s:= lua_tointegerx(L, 4, NIL);
++ dx:= int2hwFloat(lua_tointegerx(L, 5, NIL)) / 1000000;
++ dy:= int2hwFloat(lua_tointegerx(L, 6, NIL)) / 1000000;
++ t:= lua_tointegerx(L, 7, NIL);
+
+ gear:= AddGear(x, y, gt, s, dx, dy, t);
+ lastGearByUID:= gear;
+@@ -411,7 +411,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ gear^.Message:= gear^.Message or gmDelete;
+ end;
+@@ -431,10 +431,10 @@ begin
+ end
+ else
+ begin
+- x:= lua_tointeger(L, 1);
+- y:= lua_tointeger(L, 2);
+- vgt:= TVisualGearType(lua_tointeger(L, 3));
+- s:= lua_tointeger(L, 4);
++ x:= lua_tointegerx(L, 1, NIL);
++ y:= lua_tointegerx(L, 2, NIL);
++ vgt:= TVisualGearType(lua_tointegerx(L, 3, NIL));
++ s:= lua_tointegerx(L, 4, NIL);
+ c:= lua_toboolean(L, 5);
+
+ vg:= AddVisualGear(x, y, vgt, s, c);
+@@ -458,7 +458,7 @@ begin
+ end
+ else
+ begin
+- vg:= VisualGearByUID(lua_tointeger(L, 1));
++ vg:= VisualGearByUID(lua_tointegerx(L, 1, NIL));
+ if vg <> nil then
+ DeleteVisualGear(vg);
+ end;
+@@ -476,7 +476,7 @@ begin
+ end
+ else
+ begin
+- vg:= VisualGearByUID(lua_tointeger(L, 1));
++ vg:= VisualGearByUID(lua_tointegerx(L, 1, NIL));
+ if vg <> nil then
+ begin
+ lua_pushinteger(L, round(vg^.X));
+@@ -509,20 +509,20 @@ begin
+ end
+ else
+ begin
+- vg:= VisualGearByUID(lua_tointeger(L, 1));
++ vg:= VisualGearByUID(lua_tointegerx(L, 1, NIL));
+ if vg <> nil then
+ begin
+- vg^.X:= lua_tointeger(L, 2);
+- vg^.Y:= lua_tointeger(L, 3);
+- vg^.dX:= lua_tonumber(L, 4);
+- vg^.dY:= lua_tonumber(L, 5);
+- vg^.Angle:= lua_tonumber(L, 6);
+- vg^.Frame:= lua_tointeger(L, 7);
+- if lua_tointeger(L, 8) <> 0 then
+- vg^.FrameTicks:= lua_tointeger(L, 8); // find a better way to do this. maybe need to break all these up.
+- vg^.State:= lua_tointeger(L, 9);
+- vg^.Timer:= lua_tointeger(L, 10);
+- vg^.Tint:= lua_tointeger(L, 11);
++ vg^.X:= lua_tointegerx(L, 2, NIL);
++ vg^.Y:= lua_tointegerx(L, 3, NIL);
++ vg^.dX:= lua_tonumberx(L, 4, NIL);
++ vg^.dY:= lua_tonumberx(L, 5, NIL);
++ vg^.Angle:= lua_tonumberx(L, 6, NIL);
++ vg^.Frame:= lua_tointegerx(L, 7, NIL);
++ if lua_tointegerx(L, 8, NIL) <> 0 then
++ vg^.FrameTicks:= lua_tointegerx(L, 8, NIL); // find a better way to do this. maybe need to break all these up.
++ vg^.State:= lua_tointegerx(L, 9, NIL);
++ vg^.Timer:= lua_tointegerx(L, 10, NIL);
++ vg^.Tint:= lua_tointegerx(L, 11, NIL);
+ end
+ end;
+ lc_setvisualgearvalues:= 0;
+@@ -553,7 +553,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, ord(gear^.Kind))
+ else
+@@ -572,7 +572,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.message)
+ else
+@@ -591,7 +591,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, hwRound(gear^.elasticity * _10000))
+ else
+@@ -607,9 +607,9 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetGearMessage!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+- gear^.message:= lua_tointeger(L, 2);
++ gear^.message:= lua_tointegerx(L, 2, NIL);
+ end;
+ lc_setgearmessage:= 0
+ end;
+@@ -624,7 +624,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.Pos)
+ else
+@@ -640,9 +640,9 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetGearPos!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+- gear^.Pos:= lua_tointeger(L, 2);
++ gear^.Pos:= lua_tointegerx(L, 2, NIL);
+ end;
+ lc_setgearpos:= 0
+ end;
+@@ -657,7 +657,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.CollisionMask)
+ else
+@@ -673,9 +673,9 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetGearCollisionMask!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+- gear^.CollisionMask:= lua_tointeger(L, 2);
++ gear^.CollisionMask:= lua_tointegerx(L, 2, NIL);
+ end;
+ lc_setgearcollisionmask:= 0
+ end;
+@@ -687,7 +687,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to GetHogLevel!')
+ else
+ begin
+- gear := GearByUID(lua_tointeger(L, 1));
++ gear := GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ lua_pushinteger(L, gear^.Hedgehog^.BotLevel)
+ else
+@@ -703,9 +703,9 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetHogLevel!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+- gear^.Hedgehog^.BotLevel:= lua_tointeger(L, 2);
++ gear^.Hedgehog^.BotLevel:= lua_tointegerx(L, 2, NIL);
+ end;
+ lc_sethoglevel:= 0
+ end;
+@@ -720,7 +720,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ begin
+ lua_pushinteger(L, gear^.Hedgehog^.Team^.Clan^.ClanIndex)
+@@ -738,7 +738,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to GetClanColor!');
+ lua_pushnil(L); // return value on stack (nil)
+ end
+- else lua_pushinteger(L, ClansArray[lua_tointeger(L, 1)]^.Color shl 8 or $FF);
++ else lua_pushinteger(L, ClansArray[lua_tointegerx(L, 1, NIL)]^.Color shl 8 or $FF);
+ lc_getclancolor:= 1
+ end;
+
+@@ -754,8 +754,8 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetClanColor!')
+ else
+ begin
+- clan := ClansArray[lua_tointeger(L, 1)];
+- clan^.Color:= lua_tointeger(L, 2) shr 8;
++ clan := ClansArray[lua_tointegerx(L, 1, NIL)];
++ clan^.Color:= lua_tointegerx(L, 2, NIL) shr 8;
+ for i:= 0 to Pred(clan^.TeamsNumber) do
+ begin
+ team:= clan^.Teams[i];
+@@ -802,7 +802,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ begin
+ lua_pushstring(L, str2pchar(gear^.Hedgehog^.Team^.TeamName))
+@@ -823,7 +823,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ begin
+ lua_pushstring(L, str2pchar(gear^.Hedgehog^.Name))
+@@ -845,7 +845,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+
+ hogName:= lua_tostring(L, 2);
+@@ -868,7 +868,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.Timer)
+ else
+@@ -887,7 +887,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.Health)
+ else
+@@ -906,7 +906,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, hwRound(gear^.X))
+ else
+@@ -925,7 +925,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, hwRound(gear^.Y))
+ else
+@@ -943,8 +943,8 @@ begin
+ end
+ else
+ begin
+- gears:= GearByUID(lua_tointeger(L, 1));
+- geard:= GearByUID(lua_tointeger(L, 2));
++ gears:= GearByUID(lua_tointegerx(L, 1, NIL));
++ geard:= GearByUID(lua_tointegerx(L, 2, NIL));
+ if (gears <> nil) and (geard <> nil) then
+ begin
+ geard^.X:= gears^.X;
+@@ -963,7 +963,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to FollowGear!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then FollowGear:= gear
+ end;
+ lc_followgear:= 0
+@@ -975,13 +975,13 @@ var gear : PGear;
+ s : LongWord;
+ begin
+ if lua_gettop(L) = 4 then
+- s:= lua_tointeger(L, 4)
++ s:= lua_tointegerx(L, 4, NIL)
+ else
+ s:= 0;
+
+ if (lua_gettop(L) = 4) or (lua_gettop(L) = 3) then
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+ vgear:= AddVisualGear(0, 0, vgtSpeechBubble, s, true);
+@@ -989,7 +989,7 @@ begin
+ begin
+ vgear^.Text:= lua_tostring(L, 2);
+ vgear^.Hedgehog:= gear^.Hedgehog;
+- vgear^.FrameTicks:= lua_tointeger(L, 3);
++ vgear^.FrameTicks:= lua_tointegerx(L, 3, NIL);
+ if (vgear^.FrameTicks < 1) or (vgear^.FrameTicks > 3) then
+ vgear^.FrameTicks:= 1;
+ lua_pushinteger(L, vgear^.Uid)
+@@ -1009,7 +1009,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SwitchHog!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ // should we allow this when there is no current hedgehog? might do some odd(er) things to turn sequence.
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) and (CurrentHedgehog <> nil) then
+ begin
+@@ -1040,16 +1040,16 @@ begin
+
+ if lua_gettop(L) = 3 then
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Hedgehog <> nil) then
+- AddAmmoAmount(gear^.Hedgehog^, TAmmoType(lua_tointeger(L, 2)), lua_tointeger(L,3) );
++ AddAmmoAmount(gear^.Hedgehog^, TAmmoType(lua_tointegerx(L, 2, NIL)), lua_tointegerx(L,3,NIL) );
+ end else
+
+ if lua_gettop(L) = 2 then
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Hedgehog <> nil) then
+- AddAmmo(gear^.Hedgehog^, TAmmoType(lua_tointeger(L, 2)));
++ AddAmmo(gear^.Hedgehog^, TAmmoType(lua_tointegerx(L, 2, NIL)));
+ end else
+ begin
+ LuaError('Lua: Wrong number of parameters passed to AddAmmo!');
+@@ -1064,12 +1064,12 @@ var gear : PGear;
+ begin
+ if (lua_gettop(L) = 3) or (lua_gettop(L) = 2) then
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Hedgehog <> nil) then
+ if lua_gettop(L) = 2 then
+- AddAmmo(gear^.Hedgehog^, TAmmoType(lua_tointeger(L, 2)))
++ AddAmmo(gear^.Hedgehog^, TAmmoType(lua_tointegerx(L, 2, NIL)))
+ else
+- SetAmmo(gear^.Hedgehog^, TAmmoType(lua_tointeger(L, 2)), lua_tointeger(L, 3))
++ SetAmmo(gear^.Hedgehog^, TAmmoType(lua_tointegerx(L, 2, NIL)), lua_tointegerx(L, 3, NIL))
+ end
+ else LuaError('Lua: Wrong number of parameters passed to AddAmmo!');
+ lc_addammo:= 0
+@@ -1081,10 +1081,10 @@ var gear : PGear;
+ begin
+ if (lua_gettop(L) = 2) then
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Hedgehog <> nil) then
+ begin
+- ammo:= GetAmmoEntry(gear^.Hedgehog^, TAmmoType(lua_tointeger(L, 2)));
++ ammo:= GetAmmoEntry(gear^.Hedgehog^, TAmmoType(lua_tointegerx(L, 2, NIL)));
+ if ammo^.AmmoType = amNothing then
+ lua_pushinteger(L, 0)
+ else
+@@ -1109,10 +1109,10 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+- gear^.Health:= lua_tointeger(L, 2);
++ gear^.Health:= lua_tointegerx(L, 2, NIL);
+
+ if (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ begin
+@@ -1135,8 +1135,8 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
+- if gear <> nil then gear^.Timer:= lua_tointeger(L, 2)
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
++ if gear <> nil then gear^.Timer:= lua_tointegerx(L, 2, NIL)
+ end;
+ lc_settimer:= 0
+ end;
+@@ -1147,9 +1147,9 @@ begin
+ if lua_gettop(L) <> 3 then
+ LuaError('Lua: Wrong number of parameters passed to SetEffect!')
+ else begin
+- gear := GearByUID(lua_tointeger(L, 1));
++ gear := GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Hedgehog <> nil) then
+- gear^.Hedgehog^.Effects[THogEffect(lua_tointeger(L, 2))]:= lua_tointeger(L, 3);
++ gear^.Hedgehog^.Effects[THogEffect(lua_tointegerx(L, 2, NIL))]:= lua_tointegerx(L, 3, NIL);
+ end;
+ lc_seteffect := 0;
+ end;
+@@ -1162,9 +1162,9 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Hedgehog <> nil) then
+- lua_pushinteger(L, gear^.Hedgehog^.Effects[THogEffect(lua_tointeger(L, 2))])
++ lua_pushinteger(L, gear^.Hedgehog^.Effects[THogEffect(lua_tointegerx(L, 2, NIL))])
+ else
+ lua_pushinteger(L, 0)
+ end;
+@@ -1180,10 +1180,10 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+- gear^.State:= lua_tointeger(L, 2);
++ gear^.State:= lua_tointegerx(L, 2, NIL);
+ SetAllToActive;
+ end
+ end;
+@@ -1199,7 +1199,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.State)
+ else
+@@ -1218,7 +1218,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.Tag)
+ else
+@@ -1236,10 +1236,10 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+- gear^.Tag:= lua_tointeger(L, 2);
++ gear^.Tag:= lua_tointegerx(L, 2, NIL);
+ SetAllToActive;
+ end
+ end;
+@@ -1264,10 +1264,10 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to FindPlace!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ fall:= lua_toboolean(L, 2);
+- left:= lua_tointeger(L, 3);
+- right:= lua_tointeger(L, 4);
++ left:= lua_tointegerx(L, 3, NIL);
++ right:= lua_tointegerx(L, 4, NIL);
+ if lua_gettop(L) = 5 then
+ tryhard:= lua_toboolean(L, 5);
+ if gear <> nil then
+@@ -1284,12 +1284,12 @@ function lc_playsound(L : Plua_State) :
+ var gear: PGear;
+ begin
+ if lua_gettop(L) = 1 then
+- PlaySound(TSound(lua_tointeger(L, 1)))
++ PlaySound(TSound(lua_tointegerx(L, 1, NIL)))
+ else if lua_gettop(L) = 2 then
+ begin
+- gear:= GearByUID(lua_tointeger(L, 2));
++ gear:= GearByUID(lua_tointegerx(L, 2, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+- AddVoice(TSound(lua_tointeger(L, 1)),gear^.Hedgehog^.Team^.Voicepack)
++ AddVoice(TSound(lua_tointegerx(L, 1, NIL)),gear^.Hedgehog^.Team^.Voicepack)
+ end
+ else LuaError('Lua: Wrong number of parameters passed to PlaySound!');
+ lc_playsound:= 0;
+@@ -1345,7 +1345,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ gear^.dX.isNegative:= lua_toboolean(L, 2);
+ end;
+@@ -1363,7 +1363,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+ lua_pushinteger(L, hwRound(gear^.X));
+@@ -1387,12 +1387,12 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetGearPosition!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+ col:= gear^.CollisionIndex >= 0;
+- x:= lua_tointeger(L, 2);
+- y:= lua_tointeger(L, 3);
++ x:= lua_tointegerx(L, 2, NIL);
++ y:= lua_tointegerx(L, 3, NIL);
+ if col then
+ DeleteCI(gear);
+ gear^.X:= int2hwfloat(x);
+@@ -1416,7 +1416,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+ lua_pushinteger(L, gear^.Target.X);
+@@ -1438,11 +1438,11 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetGearTarget!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+- gear^.Target.X:= lua_tointeger(L, 2);
+- gear^.Target.Y:= lua_tointeger(L, 3)
++ gear^.Target.X:= lua_tointegerx(L, 2, NIL);
++ gear^.Target.Y:= lua_tointegerx(L, 3, NIL)
+ end
+ end;
+ lc_setgeartarget:= 0
+@@ -1460,7 +1460,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+ t:= hwRound(gear^.dX * 1000000);
+@@ -1480,11 +1480,11 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetGearVelocity!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ begin
+- gear^.dX:= int2hwFloat(lua_tointeger(L, 2)) / 1000000;
+- gear^.dY:= int2hwFloat(lua_tointeger(L, 3)) / 1000000;
++ gear^.dX:= int2hwFloat(lua_tointegerx(L, 2, NIL)) / 1000000;
++ gear^.dY:= int2hwFloat(lua_tointegerx(L, 3, NIL)) / 1000000;
+ SetAllToActive;
+ end
+ end;
+@@ -1497,7 +1497,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetZoom!')
+ else
+ begin
+- ZoomValue:= lua_tonumber(L, 1);
++ ZoomValue:= lua_tonumberx(L, 1, NIL);
+ if ZoomValue < cMaxZoomLevel then
+ ZoomValue:= cMaxZoomLevel;
+ if ZoomValue > cMinZoomLevel then
+@@ -1525,9 +1525,9 @@ begin
+ if (np < 4) or (np > 5) then
+ LuaError('Lua: Wrong number of parameters passed to SetAmmo!')
+ else if np = 4 then
+- ScriptSetAmmo(TAmmoType(lua_tointeger(L, 1)), lua_tointeger(L, 2), lua_tointeger(L, 3), lua_tointeger(L, 4), 1)
++ ScriptSetAmmo(TAmmoType(lua_tointegerx(L, 1, NIL)), lua_tointegerx(L, 2, NIL), lua_tointegerx(L, 3, NIL), lua_tointegerx(L, 4, NIL), 1)
+ else
+- ScriptSetAmmo(TAmmoType(lua_tointeger(L, 1)), lua_tointeger(L, 2), lua_tointeger(L, 3), lua_tointeger(L, 4), lua_tointeger(L, 5));
++ ScriptSetAmmo(TAmmoType(lua_tointegerx(L, 1, NIL)), lua_tointegerx(L, 2, NIL), lua_tointegerx(L, 3, NIL), lua_tointegerx(L, 4, NIL), lua_tointegerx(L, 5, NIL));
+ lc_setammo:= 0
+ end;
+
+@@ -1557,7 +1557,7 @@ begin
+ end
+ else
+ begin
+- m:= lua_tointeger(L, 1);
++ m:= lua_tointegerx(L, 1, NIL);
+ if (m > 0) then
+ lua_pushinteger(L, GetRandom(m))
+ else
+@@ -1575,7 +1575,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to SetWind!')
+ else
+ begin
+- cWindSpeed:= int2hwfloat(lua_tointeger(L, 1)) / 100 * cMaxWindSpeed;
++ cWindSpeed:= int2hwfloat(lua_tointegerx(L, 1, NIL)) / 100 * cMaxWindSpeed;
+ cWindSpeedf:= SignAs(cWindSpeed,cWindSpeed).QWordValue / SignAs(_1,_1).QWordValue;
+ if cWindSpeed.isNegative then
+ CWindSpeedf := -cWindSpeedf;
+@@ -1630,7 +1630,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if gear <> nil then
+ lua_pushinteger(L, gear^.Radius)
+ else
+@@ -1645,7 +1645,7 @@ begin
+ if lua_gettop(L) <> 1 then
+ LuaError('Lua: Wrong number of parameters passed to GetHogHat!')
+ else begin
+- gear := GearByUID(lua_tointeger(L, 1));
++ gear := GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ lua_pushstring(L, str2pchar(gear^.Hedgehog^.Hat))
+ else
+@@ -1665,7 +1665,7 @@ begin
+ end
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ if (gear <> nil) and (gear^.Kind = gtHedgehog) and (gear^.Hedgehog <> nil) then
+ hat:= lua_tostring(L, 2);
+ gear^.Hedgehog^.Hat:= hat;
+@@ -1684,9 +1684,9 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to PlaceGirder!')
+ else
+ TryPlaceOnLand(
+- lua_tointeger(L, 1) - SpritesData[sprAmGirder].Width div 2,
+- lua_tointeger(L, 2) - SpritesData[sprAmGirder].Height div 2,
+- sprAmGirder, lua_tointeger(L, 3), true, false);
++ lua_tointegerx(L, 1, NIL) - SpritesData[sprAmGirder].Width div 2,
++ lua_tointegerx(L, 2, NIL) - SpritesData[sprAmGirder].Height div 2,
++ sprAmGirder, lua_tointegerx(L, 3, NIL), true, false);
+ lc_placegirder:= 0
+ end;
+
+@@ -1726,7 +1726,7 @@ begin
+ LuaError('Lua: Wrong number of parameters passed to HideHog!')
+ else
+ begin
+- gear:= GearByUID(lua_tointeger(L, 1));
++ gear:= GearByUID(lua_tointegerx(L, 1, NIL));
+ hiddenHedgehogs[hiddenHedgehogsNumber]:=gear^.hedgehog;
+ inc(hiddenHedgehogsNumber);
+ HideHog(gear^.hedgehog);
+@@ -1745,7 +1745,7 @@ begin
+ i := 0;
+ while (i < hiddenHedgehogsNumber) do
+ begin
+- if hiddenHedgehogs[i]^.gearHidden^.uid = LongWord(lua_tointeger(L, 1)) then
++ if hiddenHedgehogs[i]^.gearHidden^.uid = LongWord(lua_tointegerx(L, 1, NIL)) then
+ begin
+ hog := hiddenHedgehogs[i];
+ RestoreHog(hog);
+@@ -1773,10 +1773,10 @@ begin
+ else
+ begin
+ rtn:= TestRectancleForObstacle(
+- lua_tointeger(L, 1),
+- lua_tointeger(L, 2),
+- lua_tointeger(L, 3),
+- lua_tointeger(L, 4),
++ lua_tointegerx(L, 1, NIL),
++ lua_tointegerx(L, 2, NIL),
++ lua_tointegerx(L, 3, NIL),
++ lua_tointegerx(L, 4, NIL),
+ lua_toboolean(L, 5)
+ );
+ lua_pushboolean(L, rtn);
+@@ -1825,7 +1825,7 @@ end;
+ function ScriptGetInteger(name : shortstring) : LongInt;
+ begin
+ lua_getglobal(luaState, Str2PChar(name));
+- ScriptGetInteger:= lua_tointeger(luaState, -1);
++ ScriptGetInteger:= lua_tointegerx(luaState, -1, NIL);
+ lua_pop(luaState, 1);
+ end;
+
+@@ -1966,7 +1966,7 @@ if not FileExists(s) then
+ if not FileExists(s) then
+ exit;
+
+-ret:= luaL_loadfile(luaState, Str2PChar(s));
++ret:= luaL_loadfilex(luaState, Str2PChar(s), NIL);
+ if ret <> 0 then
+ begin
+ LuaError('Lua: Failed to load ' + name + '(error ' + IntToStr(ret) + ')');
+@@ -1976,7 +1976,7 @@ else
+ begin
+ WriteLnToConsole('Lua: ' + name + ' loaded');
+ // call the script file
+- lua_pcall(luaState, 0, 0, 0);
++ lua_pcallk(luaState, 0, 0, 0, 0, NIL);
+ ScriptLoaded:= true
+ end
+ end;
+@@ -2013,7 +2013,7 @@ if not ScriptLoaded or (not ScriptExists
+ exit;
+ SetGlobals;
+ lua_getglobal(luaState, Str2PChar(fname));
+-if lua_pcall(luaState, 0, 0, 0) <> 0 then
++if lua_pcallk(luaState, 0, 0, 0, 0, NIL) <> 0 then
+ begin
+ LuaError('Lua: Error while calling ' + fname + ': ' + lua_tostring(luaState, -1));
+ lua_pop(luaState, 1)
+@@ -2030,7 +2030,7 @@ if not ScriptExists('ParseCommandOverrid
+ lua_getglobal(luaState, Str2PChar('ParseCommandOverride'));
+ lua_pushstring(luaState, Str2PChar(key));
+ lua_pushstring(luaState, Str2PChar(value));
+-if lua_pcall(luaState, 2, 1, 0) <> 0 then
++if lua_pcallk(luaState, 2, 1, 0, 0, NIL) <> 0 then
+ begin
+ LuaError('Lua: Error while calling ParseCommandOverride: ' + lua_tostring(luaState, -1));
+ lua_pop(luaState, 1)
+@@ -2069,14 +2069,14 @@ lua_pushinteger(luaState, par2);
+ lua_pushinteger(luaState, par3);
+ lua_pushinteger(luaState, par4);
+ ScriptCall:= 0;
+-if lua_pcall(luaState, 4, 1, 0) <> 0 then
++if lua_pcallk(luaState, 4, 1, 0, 0, NIL) <> 0 then
+ begin
+ LuaError('Lua: Error while calling ' + fname + ': ' + lua_tostring(luaState, -1));
+ lua_pop(luaState, 1)
+ end
+ else
+ begin
+- ScriptCall:= lua_tointeger(luaState, -1);
++ ScriptCall:= lua_tointegerx(luaState, -1, NIL);
+ lua_pop(luaState, 1)
+ end;
+ GetGlobals;
+@@ -2184,8 +2184,8 @@ var at : TGearType;
+ cg : TCapGroup;
+ begin
+ // initialize lua
+-luaState:= lua_open;
+-TryDo(luaState <> nil, 'lua_open failed', true);
++luaState:= luaL_newstate;
++TryDo(luaState <> nil, 'luaL_newstate failed', true);
+
+ // open internal libraries
+ luaopen_base(luaState);
diff --git a/hedgewars.spec b/hedgewars.spec
index 23c8891..dd61514 100644
--- a/hedgewars.spec
+++ b/hedgewars.spec
@@ -1,6 +1,6 @@
Name: hedgewars
Version: 0.9.18
-Release: 6%{?dist}
+Release: 7%{?dist}
Summary: 2D tankbattle game with the tanks replaced by hedgehogs
Group: Amusements/Games
License: GPL+
@@ -16,9 +16,11 @@ Patch0: hedgewars-compiler-opts.patch
# avoid the same issue. The original patch is available from:
# https://launchpadlibrarian.net/85736468/hedgewars_0.9.17-1~maverick0.1.debdiff
Patch1: hedgewars-no-bytestring.patch
+# Lua 5.2
+Patch2: hedgewars-0.9.18-lua-5.2.patch
BuildRequires: fpc qt4-devel SDL_mixer-devel SDL_net-devel SDL_image-devel
BuildRequires: SDL_ttf-devel openssl-devel cmake desktop-file-utils
-BuildRequires: libpng-devel
+BuildRequires: libpng-devel lua-devel
Requires: dejavu-sans-fonts wqy-zenhei-fonts hicolor-icon-theme
# https://bugzilla.redhat.com/show_bug.cgi?id=520400
# no fpc on s390(x)
@@ -55,6 +57,7 @@ A standalone server that can be used for LAN play or a private internet server.
%setup -q -n %{name}-src-%{version}
%patch0 -p1
%patch1 -p1
+%patch2 -p1 -b .lua-52
# Make sure that we don't use bundled libraries
rm -r misc/libfreetype misc/libtremor misc/libopenalbridge
@@ -116,6 +119,9 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || :
%changelog
+* Wed May 15 2013 Tom Callaway <spot at fedoraproject.org> - 0.9.18-7
+- rebuild for new lua
+
* Sat Mar 23 2013 Bruno Wolff III <bruno at wolff.to> - 0.9.18-6
- Rebuild for ghc-dataenc soname bump
More information about the scm-commits
mailing list