Implemented basis for Lua scripting and registering FSX variables - incomplete and crashes on shutdown

.gitignore

@@ -0,0 +1,5 @@
+__history
+*.local
+*.dcu
+*.exe
+*.identcache

G940LEDControl/DelphiLua/Lua.API.pas

@@ -0,0 +1,767 @@
+{
+  Header for Lua 5.2.1 Binaries DLL
+    http://luabinaries.sourceforge.net/
+
+  Delphi conversion by M. van Renswoude, April 2014:
+
+  This software is provided 'as-is', without any express or implied
+  warranty. In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+     1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+
+     2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+
+     3. This notice may not be removed or altered from any source
+     distribution.
+}
+unit Lua.API;
+
+interface
+uses
+  System.SysUtils;
+
+
+const
+  LUA_VERSION_MAJOR   = '5';
+  LUA_VERSION_MINOR	  = '2';
+  LUA_VERSION_NUM	    = 502;
+  LUA_VERSION_RELEASE = '1';
+
+  LUA_VERSION_  = 'Lua ' + LUA_VERSION_MAJOR + '.' + LUA_VERSION_MINOR;
+  LUA_RELEASE   = LUA_VERSION_ + '.' + LUA_VERSION_RELEASE;
+  LUA_COPYRIGHT = LUA_RELEASE + '  Copyright (C) 1994-2012 Lua.org, PUC-Rio';
+  LUA_AUTHORS   = 'R. Ierusalimschy, L. H. de Figueiredo, W. Celes';
+
+
+  { mark for precompiled code ('<esc>Lua') }
+  LUA_SIGNATURE	= #33'Lua';
+
+  { option for multiple returns in 'lua_pcall' and 'lua_call' }
+  LUA_MULTRET = -1;
+
+
  { reserve some space for error handling }
+  LUAI_MAXSTACK	= 1000000;
+  LUAI_FIRSTPSEUDOIDX	= (-LUAI_MAXSTACK - 1000);
+
+  { pseudo-indices }
+  LUA_REGISTRYINDEX = LUAI_FIRSTPSEUDOIDX;
+
+  function lua_upvalueindex(idx: Integer): Integer; inline;
+
+const
+  { thread status }
+  LUA_OK        = 0;
+  LUA_YIELD_    = 1;
+  LUA_ERRRUN	  = 2;
+  LUA_ERRSYNTAX = 3;
+  LUA_ERRMEM	  = 4;
+  LUA_ERRGCMM	  = 5;
+  LUA_ERRERR	  = 6;
+
+
+type
+  size_t = NativeUint;
+  psize_t = ^size_t;
+
+  lua_State = type Pointer;
+
  lua_CFunction = function(L: lua_State): Integer; cdecl;
+
+  { functions that read/write blocks when loading/dumping Lua chunks }
+  lua_Reader = function(L: lua_State; ud: Pointer; var sz: size_t): PAnsiChar; cdecl;
+  lua_Writer = function(L: lua_State; p: Pointer; sz: size_t; ud: Pointer): Integer; cdecl;
+
+  { prototype for memory-allocation functions }
+  lua_Alloc = function(ud, ptr: Pointer; osize, nsize: size_t): Pointer; cdecl;
+
+const
+  { basic types }
+  LUA_TNONE = (-1);
+
+  LUA_TNIL = 0;
+  LUA_TBOOLEAN = 1;
+  LUA_TLIGHTUSERDATA = 2;
+  LUA_TNUMBER = 3;
+  LUA_TSTRING	= 4;
+  LUA_TTABLE = 5;
+  LUA_TFUNCTION = 6;
+  LUA_TUSERDATA = 7;
+  LUA_TTHREAD = 8;
+
+  LUA_NUMTAGS = 9;
+
+  { minimum Lua stack available to a C function }
+  LUA_MINSTACK = 20;
+
+
+  { predefined values in the registry }
+  LUA_RIDX_MAINTHREAD = 1;
+  LUA_RIDX_GLOBALS = 2;
+  LUA_RIDX_LAST = LUA_RIDX_GLOBALS;
+
+
+type
+  { type of numbers in Lua }
+  lua_Number = type Double;
+
+  { type for integer functions }
+  lua_Integer = type Integer;
+
+  { unsigned integer type }
+  lua_Unsigned = type Cardinal;
+
+
+var
+  { state manipulation }
+  lua_newstate: function(f: lua_Alloc; ud: Pointer): lua_State; cdecl;
+  lua_close: procedure(L: lua_State); cdecl;
+  lua_newthread: function(L: lua_State): lua_State; cdecl;
+
+  lua_atpanic: function(L: lua_State; panicf: lua_CFunction): lua_CFunction; cdecl;
+  lua_version: function(L: lua_State): lua_Number; cdecl;
+
+  { basic stack manipulation }
+  lua_absindex: function(L: lua_State; idx: Integer): Integer; cdecl;
+  lua_gettop: function(L: lua_State): Integer; cdecl;
+
+  lua_settop: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_pushvalue: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_remove: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_insert: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_replace: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_copy: procedure(L: lua_State; fromidx, toidx: Integer); cdecl;
+  lua_checkstack: function(L: lua_State; sz: Integer): Integer; cdecl;
+
+  lua_xmove: procedure(from: lua_State; _to: lua_State; n: Integer); cdecl;
+
+  { access functions (stack -> C) }
+  lua_isnumber: function (L: lua_State; idx: Integer): Integer; cdecl;
+  lua_isstring: function (L: lua_State; idx: Integer): Integer; cdecl;
+  lua_iscfunction: function (L: lua_State; idx: Integer): Integer; cdecl;
+  lua_isuserdata: function (L: lua_State; idx: Integer): Integer; cdecl;
+  lua_type: function (L: lua_State; idx: Integer): Integer; cdecl;
+  lua_typename: function (L: lua_State; tp: Integer): PAnsiChar; cdecl;
+  lua_tonumberx: function (L: lua_State; idx: Integer; isnum: PInteger): lua_Number; cdecl;
+  lua_tointegerx: function (L: lua_State; idx: Integer; isnum: PInteger): lua_Integer; cdecl;
+  lua_tounsignedx: function (L: lua_State; idx: Integer; isnum: PInteger): lua_Unsigned; cdecl;
+  lua_toboolean: function (L: lua_State; idx: Integer): Integer; cdecl;
+  lua_tolstring: function(L: lua_State; idx: Integer; len: psize_t): PAnsiChar; cdecl;
+  lua_rawlen: function (L: lua_State; idx: Integer): size_t; cdecl;
+  lua_tocfunction: function (L: lua_State; idx: Integer): lua_CFunction; cdecl;
+  lua_touserdata: function (L: lua_State; idx: Integer): Pointer; cdecl;
+  lua_tothread: function (L: lua_State; idx: Integer): lua_State; cdecl;
+  lua_topointer: function (L: lua_State; idx: Integer): Pointer; cdecl;
+
+
+const
+  { Comparison and arithmetic functions }
+  LUA_OPADD = 0; { ORDER TM }
+  LUA_OPSUB = 1;
+  LUA_OPMUL = 2;
+  LUA_OPDIV = 3;
+  LUA_OPMOD = 4;
+  LUA_OPPOW = 5;
+  LUA_OPUNM = 6;
+
+
+var
+  lua_arith: procedure(L: lua_State; op: Integer); cdecl;
+
+
+const
+  LUA_OPEQ = 0;
+  LUA_OPLT = 1;
+  LUA_OPLE = 2;
+
+
+var
+  lua_rawequal: function(L: lua_State; idx1, idx2: Integer): Integer; cdecl;
+  lua_compare: function(L: lua_State; idx1, idx2, op: Integer): Integer; cdecl;
+
+
+  { push functions (C -> stack) }
+  lua_pushnil: procedure(L: lua_State); cdecl;
+  lua_pushnumber: procedure(L: lua_State; n: lua_Number); cdecl;
+  lua_pushinteger: procedure(L: lua_State; n: lua_Integer); cdecl;
+  lua_pushunsigned: procedure(L: lua_State; n: lua_Unsigned); cdecl;
+  lua_pushlstring: function (L: lua_State; s: PAnsiChar; l_: size_t): PAnsiChar; cdecl;
+  lua_pushstring: function (L: lua_State; s: PAnsiChar): PAnsiChar; cdecl;
+  lua_pushvfstring: function (L: lua_State; fmt: PAnsiChar; argp: Pointer): PAnsiChar; cdecl;
+  lua_pushfstring: function (L: lua_State; fmt: PAnsiChar; argp: Pointer): PAnsiChar; cdecl;
+  lua_pushcclosure: procedure(L: lua_State; fn: lua_CFunction; n: Integer); cdecl;
+  lua_pushboolean: procedure(L: lua_State; b: Integer); cdecl;
+  lua_pushlightuserdata: procedure(L: lua_State; p: Pointer); cdecl;
+  lua_pushthread: function (L: lua_State): Integer; cdecl;
+
+  { get functions (Lua -> stack) }
+  lua_getglobal: procedure(L: lua_State; value: PAnsiChar); cdecl;
+  lua_gettable: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_getfield: procedure(L: lua_State; idx: Integer; k: PAnsiChar); cdecl;
+  lua_rawget: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_rawgeti: procedure(L: lua_State; idx, n: Integer); cdecl;
+  lua_rawgetp: procedure(L: lua_State; idx: Integer; p: Pointer); cdecl;
+  lua_createtable: procedure(L: lua_State; narr: Integer; nrec: Integer); cdecl;
+  lua_newuserdata: procedure(L: lua_State; sz: size_t); cdecl;
+  lua_getmetatable: function(L: lua_State; objindex: Integer): Integer; cdecl;
+  lua_getuservalue: procedure(L: lua_State; idx: Integer); cdecl;
+
+  { set functions (stack -> Lua) }
+  lua_setglobal: procedure(L: lua_State; value: PAnsiChar); cdecl;
+  lua_settable: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_setfield: procedure(L: lua_State; idx: Integer; k: PAnsiChar); cdecl;
+  lua_rawset: procedure(L: lua_State; idx: Integer); cdecl;
+  lua_rawseti: procedure(L: lua_State; idx, n: Integer); cdecl;
+  lua_rawsetp: procedure(L: lua_State; idx: Integer; p: Pointer); cdecl;
+  lua_setmetatable: function(L: lua_State; objindex: Integer): Integer; cdecl;
+  lua_setuservalue: procedure(L: lua_State; idx: Integer); cdecl;
+
+
+  { 'load' and 'call' functions (load and run Lua code) }
+  lua_callk: procedure(L: lua_State; nargs, nresults, ctx: Integer; k: lua_CFunction); cdecl;
+  lua_getctx: function(L: lua_State; var ctx: Integer): Integer; cdecl;
+  lua_pcallk: function(L: lua_State; nargs, nresults, errfunc, ctx: Integer; k: lua_CFunction): Integer; cdecl;
+
+  lua_load: function(L: lua_State; reader: lua_Reader; dt: Pointer; chunkname, mode: PAnsiChar): Integer; cdecl;
+  lua_dump: function(L: lua_State; writer: lua_Writer; data: Pointer): Integer; cdecl;
+
+
+  procedure lua_call(L: lua_State; nargs, nresults: Integer); inline;
+  function lua_pcall(L: lua_State; nargs, nresults, errfunc: Integer): Integer; inline;
+
+
+var
+  { coroutine functions }
+  lua_yieldk: function(L: lua_State; nresults, ctx: Integer; k: lua_CFunction): Integer; cdecl;
+  lua_resume: function(L, from: lua_State; nargs: Integer): Integer; cdecl;
+  lua_status: function(L: lua_State): Integer; cdecl;
+
+  function lua_yield(L: lua_State; nresults: Integer): Integer; inline;
+
+
+const
+  { garbage-collection function and options }
+  LUA_GCSTOP = 0;
+  LUA_GCRESTART = 1;
+  LUA_GCCOLLECT = 2;
+  LUA_GCCOUNT = 3;
+  LUA_GCCOUNTB = 4;
+  LUA_GCSTEP = 5;
+  LUA_GCSETPAUSE = 6;
+  LUA_GCSETSTEPMU = 7;
+  LUA_GCSETMAJORIN = 8;
+  LUA_GCISRUNNING = 9;
+  LUA_GCGEN = 0;
+  LUA_GCINC = 1;
+
+var
+  lua_gc: function(L: lua_State; what, data: Integer): Integer; cdecl;
+
+
+var
+  { miscellaneous functions }
+  lua_error: function(L: lua_State): Integer; cdecl;
+  lua_next: function(L: lua_State; idx: Integer): Integer; cdecl;
+
+  lua_concat: procedure(L: lua_State; n: Integer); cdecl;
+  lua_len: procedure(L: lua_State; idx: Integer); cdecl;
+
+  lua_getallocf: function(L: lua_State; ud: Pointer): lua_Alloc; cdecl;
+  lua_setallocf: procedure(L: lua_State; f: lua_Alloc; ud: Pointer); cdecl;
+
+
+  { some useful macros }
+  function lua_tonumber(L: lua_State; idx: Integer): lua_Number; inline;
+  function lua_tointeger(L: lua_State; idx: Integer): lua_Integer; inline;
+  function lua_tounsigned(L: lua_State; idx: Integer): lua_Unsigned; inline;
+
+  procedure lua_pop(L: lua_State; n: Integer); inline;
+  procedure lua_newtable(L: lua_State); inline;
+  procedure lua_register(L: lua_State; name: PAnsiChar; f: lua_CFunction); inline;
+  procedure lua_pushcfunction(L: lua_State; f: lua_CFunction); inline;
+
+  function lua_isfunction(L: lua_State; n: Integer): Boolean; inline;
+  function lua_istable(L: lua_State; n: Integer): Boolean; inline;
+  function lua_islightuserdata(L: lua_State; n: Integer): Boolean; inline;
+  function lua_isnil(L: lua_State; n: Integer): Boolean; inline;
+  function lua_isboolean(L: lua_State; n: Integer): Boolean; inline;
+  function lua_isthread(L: lua_State; n: Integer): Boolean; inline;
+  function lua_isnone(L: lua_State; n: Integer): Boolean; inline;
+  function lua_isnoneornil(L: lua_State; n: Integer): Boolean; inline;
+  function lua_pushliteral(L: lua_State; const s: AnsiString): PAnsiChar; inline;
+
+  procedure lua_pushglobaltable(L: lua_State); inline;
+  function lua_tostring(L: lua_State; idx: Integer): PAnsiChar; inline;
+
+
+const
+  {======================================================================
+   Debug API
+  =======================================================================}
+
+  { Event codes }
+  LUA_HOOKCALL  = 0;
+  LUA_HOOKRET = 1;
+  LUA_HOOKLINE  = 2;
+  LUA_HOOKCOUNT = 3;
+  LUA_HOOKTAILCALL = 4;
+
+
+  { Event masks }
+  LUA_MASKCALL = (1 shl LUA_HOOKCALL);
+  LUA_MASKRET = (1 shl LUA_HOOKRET);
+  LUA_MASKLINE =  (1 shl LUA_HOOKLINE);
+  LUA_MASKCOUNT = (1 shl LUA_HOOKCOUNT);
+
+
+const
+  LUA_IDSIZE = 60;
+
+
+type
+  lua_Debug = record
+    event: Integer;
+    name: PAnsiChar;
+    namewhat: PAnsiChar; // 'global', 'local', 'field', 'method'
+    what: PAnsiChar; // 'Lua', 'C', 'main', 'tail'
+    source: PAnsiChar;
+    currentline: Integer;
+    linedefined: Integer;
+    lastlinedefined: Integer;
+    nups: Byte;
+    nparams: Byte;
+    isvararg: Byte;
+    istailcall: Byte;
+    short_src: array[0..LUA_IDSIZE - 1] of AnsiChar;
+    //struct CallInfo *i_ci;  /* active function */
+  end;
+
+  { Functions to be called by the debugger in specific events }
+  lua_Hook = procedure(L: lua_State; var ar: lua_Debug); cdecl;
+
+
+var
+  lua_getstack: function(L: lua_State; level: Integer; var ar: lua_Debug): Integer; cdecl;
+  lua_getinfo: function(L: lua_State; what: PAnsiChar; var ar: lua_Debug): Integer; cdecl;
+
+  lua_getlocal: function(L: lua_State; var ar: lua_Debug; n: Integer): PAnsiChar; cdecl;
+  lua_setlocal: function(L: lua_State; var ar: lua_Debug; n: Integer): PAnsiChar; cdecl;
+  lua_getupvalue: function(L: lua_State; funcindex, n: Integer): PAnsiChar; cdecl;
+  lua_setupvalue: function(L: lua_State; funcindex, n: Integer): PAnsiChar; cdecl;
+
+  lua_upvalueid: function(L: lua_State; fidx, n: Integer): Pointer; cdecl;
+  lua_upvaluejoin: procedure(L: lua_State; fidx1, n1, fidx2, n2: Integer);
+
+  lua_sethook: function(L: lua_State; func: lua_Hook; mask, count: Integer): Integer; cdecl;
+  lua_gethook: function(L: lua_State): lua_Hook; cdecl;
+  lua_gethookmask: function(L: lua_State): Integer; cdecl;
+  lua_gethookcount: function(L: lua_State): Integer; cdecl;
+
+  {====================================================================== }
+
+
+const
+  LUA_COLIBNAME = 'coroutine';
+  LUA_TABLIBNAME = 'table';
+  LUA_IOLIBNAME = 'io';
+  LUA_OSLIBNAME = 'os';
+  LUA_STRLIBNAME = 'string';
+  LUA_BITLIBNAME = 'bit32';
+  LUA_MATHLIBNAME = 'math';
+  LUA_DBLIBNAME = 'debug';
+  LUA_LOADLIBNAME = 'package';
+
+
+var
+  { lualib }
+  luaopen_base: function(L: lua_State): Integer; cdecl;
+  luaopen_coroutine: function(L: lua_State): Integer; cdecl;
+  luaopen_table: function(L: lua_State): Integer; cdecl;
+  luaopen_io: function(L: lua_State): Integer; cdecl;
+  luaopen_os: function(L: lua_State): Integer; cdecl;
+  luaopen_string: function(L: lua_State): Integer; cdecl;
+  luaopen_bit32: function(L: lua_State): Integer; cdecl;
+  luaopen_math: function(L: lua_State): Integer; cdecl;
+  luaopen_debug: function(L: lua_State): Integer; cdecl;
+  luaopen_package: function(L: lua_State): Integer; cdecl;
+
+  { open all previous libraries }
+  luaL_openlibs: procedure(L: lua_State); cdecl;
+  luaL_requiref: procedure(L: lua_State; modname: PAnsiChar; openf: lua_CFunction; glb: Integer); cdecl;
+
+
+
+type
+  luaL_Reg = record
+    name: PAnsiChar;
+    func: lua_CFunction;
+  end;
+  PluaL_Reg = ^luaL_Reg;
+
+var
+  luaL_setfuncs: procedure(L: lua_State; luaL_Reg: PluaL_Reg; nup: Integer); cdecl;
+
+  procedure luaL_where(L: lua_State; level: Integer);
+  function luaL_error(L: lua_State; fmt: PAnsiChar; argp: Pointer): Integer;
+
+
+
+const
+  DefaultLuaLibName = 'lua' + LUA_VERSION_MAJOR + LUA_VERSION_MINOR + '.dll';
+
+  procedure LoadLuaLib(const AFileName: string = DefaultLuaLibName);
+  procedure UnloadLuaLib;
+
+  function LuaLibLoaded: Boolean;
+
+  function DefaultLuaAlloc(ud, ptr: Pointer; osize, nsize: size_t): Pointer; cdecl;
+
+
+implementation
+uses
+  System.Generics.Collections,
+  Winapi.Windows;
+
+var
+  LuaLibHandle: THandle;
+  LuaFunctions: TList<PPointer>;
+
+
+function DefaultLuaAlloc(ud, ptr: Pointer; osize, nsize: size_t): Pointer;
+begin
+  if (nsize = 0) then
+  begin
+    FreeMemory(ptr);
+    Result := nil;
+  end else
+    Result := ReallocMemory(ptr, nsize);
+end;
+
+
+procedure LoadLuaLib(const AFileName: string = DefaultLuaLibName);
+
+  procedure Load(var AVariable: Pointer; const AName: string);
+  begin
+    AVariable := GetProcAddress(LuaLibHandle, PChar(AName));
+    LuaFunctions.Add(@AVariable);
+  end;
+
+
+begin
+  UnloadLuaLib;
+
+  LuaLibHandle := SafeLoadLibrary(AFileName);
+  if LuaLibHandle = 0 then
+    RaiseLastOSError;
+
+  if not Assigned(LuaFunctions) then
+    LuaFunctions := TList<PPointer>.Create();
+
+  Load(@lua_newstate, 'lua_newstate');
+  Load(@lua_close, 'lua_close');
+  Load(@lua_newthread, 'lua_newthread');
+
+  Load(@lua_atpanic, 'lua_atpanic');
+  Load(@lua_version, 'lua_version');
+
+  Load(@lua_absindex, 'lua_absindex');
+  Load(@lua_gettop, 'lua_gettop');
+  Load(@lua_settop, 'lua_settop');
+  Load(@lua_pushvalue, 'lua_pushvalue');
+  Load(@lua_remove, 'lua_remove');
+  Load(@lua_insert, 'lua_insert');
+  Load(@lua_replace, 'lua_replace');
+  Load(@lua_copy, 'lua_copy');
+  Load(@lua_checkstack, 'lua_checkstack');
+  Load(@lua_xmove, 'lua_xmove');
+
+  Load(@lua_isnumber, 'lua_isnumber');
+  Load(@lua_isstring, 'lua_isstring');
+  Load(@lua_iscfunction, 'lua_iscfunction');
+  Load(@lua_isuserdata, 'lua_isuserdata');
+  Load(@lua_type, 'lua_type');
+  Load(@lua_typename, 'lua_typename');
+  Load(@lua_tonumberx, 'lua_tonumberx');
+  Load(@lua_tointegerx, 'lua_tointegerx');
+  Load(@lua_tounsignedx, 'lua_tounsignedx');
+  Load(@lua_toboolean, 'lua_toboolean');
+  Load(@lua_tolstring, 'lua_tolstring');
+  Load(@lua_rawlen, 'lua_rawlen');
+  Load(@lua_tocfunction, 'lua_tocfunction');
+  Load(@lua_touserdata, 'lua_touserdata');
+  Load(@lua_tothread, 'lua_tothread');
+  Load(@lua_topointer, 'lua_topointer');
+
+  Load(@lua_arith, 'lua_arith');
+  Load(@lua_rawequal, 'lua_rawequal');
+  Load(@lua_compare, 'lua_compare');
+
+  Load(@lua_pushnil, 'lua_pushnil');
+  Load(@lua_pushnumber, 'lua_pushnumber');
+  Load(@lua_pushinteger, 'lua_pushinteger');
+  Load(@lua_pushunsigned, 'lua_pushunsigned');
+  Load(@lua_pushlstring, 'lua_pushlstring');
+  Load(@lua_pushstring, 'lua_pushstring');
+  Load(@lua_pushvfstring, 'lua_pushvfstring');
+  Load(@lua_pushfstring, 'lua_pushfstring');
+  Load(@lua_pushcclosure, 'lua_pushcclosure');
+  Load(@lua_pushboolean, 'lua_pushboolean');
+  Load(@lua_pushlightuserdata, 'lua_pushlightuserdata');
+  Load(@lua_pushthread, 'lua_pushthread');
+
+  Load(@lua_getglobal, 'lua_getglobal');
+  Load(@lua_gettable, 'lua_gettable');
+  Load(@lua_getfield, 'lua_getfield');
+  Load(@lua_rawget, 'lua_rawget');
+  Load(@lua_rawgeti, 'lua_rawgeti');
+  Load(@lua_rawgetp, 'lua_rawgetp');
+  Load(@lua_newuserdata, 'lua_newuserdata');
+  Load(@lua_getmetatable, 'lua_getmetatable');
+  Load(@lua_getuservalue, 'lua_getuservalue');
+
+  Load(@lua_createtable, 'lua_createtable');
+  Load(@lua_setglobal, 'lua_setglobal');
+  Load(@lua_settable, 'lua_settable');
+  Load(@lua_setfield, 'lua_setfield');
+
+  Load(@lua_rawset, 'lua_rawset');
+  Load(@lua_rawseti, 'lua_rawseti');
+  Load(@lua_rawsetp, 'lua_rawsetp');
+  Load(@lua_setmetatable, 'lua_setmetatable');
+  Load(@lua_setuservalue, 'lua_setuservalue');
+
+  Load(@lua_callk, 'lua_callk');
+  Load(@lua_getctx, 'lua_getctx');
+  Load(@lua_pcallk, 'lua_pcallk');
+
+  Load(@lua_yieldk, 'lua_yieldk');
+  Load(@lua_resume, 'lua_resume');
+  Load(@lua_status, 'lua_status');
+
+  Load(@lua_gc, 'lua_gc');
+
+  Load(@lua_load, 'lua_load');
+  Load(@lua_dump, 'lua_dump');
+
+  Load(@lua_error, 'lua_error');
+  Load(@lua_next, 'lua_next');
+
+  Load(@lua_concat, 'lua_concat');
+  Load(@lua_len, 'lua_len');
+
+  Load(@lua_getallocf, 'lua_getallocf');
+  Load(@lua_setallocf, 'lua_setallocf');
+
+
+  Load(@lua_getstack, 'lua_getstack');
+  Load(@lua_getinfo, 'lua_getinfo');
+
+  Load(@lua_getlocal, 'lua_getlocal');
+  Load(@lua_setlocal, 'lua_setlocal');
+  Load(@lua_getupvalue, 'lua_getupvalue');
+  Load(@lua_setupvalue, 'lua_setupvalue');
+
+  Load(@lua_upvalueid, 'lua_upvalueid');
+  Load(@lua_upvaluejoin, 'lua_upvaluejoin');
+
+  Load(@lua_sethook, 'lua_sethook');
+  Load(@lua_gethook, 'lua_gethook');
+  Load(@lua_gethookmask, 'lua_gethookmask');
+  Load(@lua_gethookcount, 'lua_gethookcount');
+
+  Load(@luaopen_base, 'luaopen_base');
+  Load(@luaopen_coroutine, 'luaopen_coroutine');
+  Load(@luaopen_table, 'luaopen_table');
+  Load(@luaopen_io, 'luaopen_io');
+  Load(@luaopen_os, 'luaopen_os');
+  Load(@luaopen_string, 'luaopen_string');
+  Load(@luaopen_bit32, 'luaopen_bit32');
+  Load(@luaopen_math, 'luaopen_math');
+  Load(@luaopen_debug, 'luaopen_debug');
+  Load(@luaopen_package, 'luaopen_package');
+
+  Load(@luaL_openlibs, 'luaL_openlibs');
+  Load(@luaL_requiref, 'luaL_requiref');
+
+  Load(@luaL_setfuncs, 'luaL_setfuncs');
+end;
+
+
+procedure UnloadLuaLib;
+var
+  variable: PPointer;
+
+begin
+  if Assigned(LuaFunctions) then
+  begin
+    for variable in LuaFunctions do
+      variable^ := nil;
+  end;
+
+  if LuaLibLoaded then
+  begin
+    FreeLibrary(LuaLibHandle);
+    LuaLibHandle := 0;
+  end;
+end;
+
+
+function LuaLibLoaded: Boolean;
+begin
+  Result := (LuaLibHandle <> 0);
+end;
+
+
+{ Macros }
+function lua_upvalueindex(idx: Integer): Integer;
+begin
+  Result := (LUA_REGISTRYINDEX - idx);
+end;
+
+procedure lua_call(L: lua_State; nargs, nresults: Integer);
+begin
+  lua_callk(L, nargs, nresults, 0, nil);
+end;
+
+function lua_pcall(L: lua_State; nargs, nresults, errfunc: Integer): Integer;
+begin
+  Result := lua_pcallk(L, nargs, nresults, errfunc, 0, nil);
+end;
+
+function lua_yield(L: lua_State; nresults: Integer): Integer;
+begin
+  Result := lua_yieldk(L, nresults, 0, nil);
+end;
+
+function lua_tonumber(L: lua_State; idx: Integer): lua_Number;
+begin
+  Result := lua_tonumberx(L, idx, nil);
+end;
+
+function lua_tointeger(L: lua_State; idx: Integer): lua_Integer;
+begin
+  Result := lua_tointegerx(L, idx, nil);
+end;
+
+function lua_tounsigned(L: lua_State; idx: Integer): lua_Unsigned;
+begin
+  Result := lua_tounsignedx(L, idx, nil);
+end;
+
+procedure lua_pop(L: lua_State; n: Integer);
+begin
+  lua_settop(L, -(n) - 1);
+end;
+
+procedure lua_newtable(L: lua_State); inline;
+begin
+  lua_createtable(L, 0, 0);
+end;
+
+procedure lua_register(L: lua_State; name: PAnsiChar; f: lua_CFunction); inline;
+begin
+  lua_pushcfunction(L, f);
+  lua_setglobal(L, name);
+end;
+
+procedure lua_pushcfunction(L: lua_State; f: lua_CFunction);
+begin
+  lua_pushcclosure(L, f, 0);
+end;
+
+function lua_isfunction(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TFUNCTION;
+end;
+
+function lua_istable(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TTABLE;
+end;
+
+function lua_islightuserdata(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TLIGHTUSERDATA;
+end;
+
+function lua_isnil(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TNIL;
+end;
+
+function lua_isboolean(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TBOOLEAN;
+end;
+
+function lua_isthread(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TTHREAD;
+end;
+
+function lua_isnone(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) = LUA_TNONE;
+end;
+
+function lua_isnoneornil(L: lua_State; n: Integer): Boolean;
+begin
+  Result := lua_type(L, n) <= 0;
+end;
+
+function lua_pushliteral(L: lua_State; const s: AnsiString): PAnsiChar;
+begin
+  Result := lua_pushlstring(L, PAnsiChar(s), Length(s));
+end;
+
+procedure lua_pushglobaltable(L: lua_State);
+begin
+  lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS);
+end;
+
+function lua_tostring(L: lua_State; idx: Integer): PAnsiChar;
+begin
+  Result := lua_tolstring(L, idx, nil);
+end;
+
+procedure luaL_where(L: lua_State; level: Integer);
+var
+  ar: lua_Debug;
+  msg: AnsiString;
+
+begin
+  if (lua_getstack(L, level, ar) <> 0) then // check function at level
+  begin
+    lua_getinfo(L, 'Sl', ar);  // get info about it
+    if (ar.currentline > 0) then // is there info?
+    begin
+      msg := AnsiString(Format('%s:%d: ', [ar.short_src, ar.currentline]));
+      lua_pushlstring(L, PAnsiChar(msg), Length(msg));
+      exit
+    end;
+  end;
+  lua_pushliteral(L, '');  // else, no information available...
+end;
+
+function luaL_error(L: lua_State; fmt: PAnsiChar; argp: Pointer): Integer;
+begin
+  luaL_where(L, 1);
+  lua_pushvfstring(L, fmt, argp);
+  lua_concat(L, 2);
+  Result := lua_error(L);
+end;
+
+
+initialization
+finalization
+  UnloadLuaLib;
+  FreeAndNil(LuaFunctions);
+
+end.

G940LEDControl/DelphiLua/readme.txt

@@ -0,0 +1 @@
+Source: https://git.x2software.net/delphi/delphilua

G940LEDControl/Forms/MainFrm.dfm

@@ -375,6 +375,10 @@ object MainForm: TMainForm
     object tsConfiguration: TTabSheet
       Caption = ' Configuration '
       ImageIndex = 2
+      ExplicitLeft = 0
+      ExplicitTop = 0
+      ExplicitWidth = 0
+      ExplicitHeight = 0
       DesignSize = (
         442
         452)
@@ -529,6 +533,10 @@ object MainForm: TMainForm
     object tsAbout: TTabSheet
       Caption = 'About'
       ImageIndex = 1
+      ExplicitLeft = 0
+      ExplicitTop = 0
+      ExplicitWidth = 0
+      ExplicitHeight = 0
       object lblVersionCaption: TLabel
         Left = 16
         Top = 67

G940LEDControl/Forms/MainFrm.pas

@@ -225,6 +225,7 @@ type
 implementation
 uses
   System.SysUtils,
+  System.Types,
   System.Win.ComObj,
   Vcl.Dialogs,
   Vcl.Graphics,
@@ -241,6 +242,7 @@ uses
   ButtonFunctionFrm,
   ConfigConversion,
   FSXAutoLaunch,
+  FSXLEDFunctionProvider,
   FSXLEDFunctionProviderIntf,
   FSXResources,
   FSXSimConnectStateMonitor,
@@ -248,6 +250,7 @@ uses
   LEDColorIntf,
   LEDFunctionIntf,
   LEDFunctionRegistry,
+  StaticLEDFunction,
   StaticResources;
 
 
@@ -258,6 +261,9 @@ const
   DefaultProfileName = 'Default';
   ProfilePostfixModified = ' (modified)';
 
+  ScriptsPath = 'Scripts\';
+  FSXScriptsPath = ScriptsPath + 'FSX\';
+
   UserDataPath = 'G940LEDControl\';
   FilenameProfiles = UserDataPath + 'Profiles.xml';
   FilenameSettings = UserDataPath + 'Settings.xml';
@@ -302,6 +308,7 @@ procedure TMainForm.FormCreate(Sender: TObject);
 
 var
   worker: IOmniWorker;
+  scriptPaths: TStringDynArray;
 
 begin
   FLog := TX2GlobalLog.Category('UI');
@@ -316,6 +323,16 @@ begin
 
   SetFSXState(TextFSXDisconnected, False);
 
+
+  TLEDFunctionRegistry.Register(TStaticLEDFunctionProvider.Create);
+
+  SetLength(scriptPaths, 2);
+  scriptPaths[0] := App.Path + FSXScriptsPath;
+  scriptPaths[1] := App.UserPath + UserDataPath + FSXScriptsPath;
+
+  TLEDFunctionRegistry.Register(TFSXLEDFunctionProvider.Create(scriptPaths));
+
+
   FEventMonitor := TOmniEventMonitor.Create(Self);
 
   Log.Info('Starting G940 LED state consumer thread');

G940LEDControl/G940LEDControl.dpr

@@ -38,7 +38,10 @@ uses
   FSXLEDFunctionProviderIntf in 'Units\FSXLEDFunctionProviderIntf.pas',
   SimBaseDocumentXMLBinding in 'Units\SimBaseDocumentXMLBinding.pas',
   FSXAutoLaunch in 'Units\FSXAutoLaunch.pas',
-  ControlIntf in 'Units\ControlIntf.pas';
+  ControlIntf in 'Units\ControlIntf.pas',
+  Lua.API in 'DelphiLua\Lua.API.pas',
+  Lua in 'DelphiLua\Lua.pas',
+  LuaLEDFunctionProvider in 'Units\LuaLEDFunctionProvider.pas';
 
 {$R *.res}
 
@@ -65,7 +68,6 @@ begin
   Application.ShowMainForm := not isRestarting;
   Application.Title := 'G940 LED Control';
   Application.CreateForm(TMainForm, MainForm);
-
   if isRestarting then
     MainForm.Visible := True;
 

G940LEDControl/G940LEDControl.dproj

@@ -8,7 +8,7 @@
 			<FrameworkType>VCL</FrameworkType>
 			<ProjectVersion>13.4</ProjectVersion>
 			<Base>True</Base>
-			<Config Condition="'$(Config)'==''">Release</Config>
+			<Config Condition="'$(Config)'==''">Debug</Config>
 			<Platform Condition="'$(Platform)'==''">Win32</Platform>
 			<TargetedPlatforms>1</TargetedPlatforms>
 			<AppType>Application</AppType>
@@ -142,6 +142,9 @@
 			<DCCReference Include="Units\SimBaseDocumentXMLBinding.pas"/>
 			<DCCReference Include="Units\FSXAutoLaunch.pas"/>
 			<DCCReference Include="Units\ControlIntf.pas"/>
+			<DCCReference Include="DelphiLua\Lua.API.pas"/>
+			<DCCReference Include="DelphiLua\Lua.pas"/>
+			<DCCReference Include="Units\LuaLEDFunctionProvider.pas"/>
 			<BuildConfiguration Include="Debug">
 				<Key>Cfg_2</Key>
 				<CfgParent>Base</CfgParent>

G940LEDControl/Units/FSXLEDFunction.pas

@@ -1,6 +1,7 @@
 unit FSXLEDFunction;
 
 interface
+  (*
 uses
   FSXLEDFunctionProvider,
   LEDFunction,
@@ -337,9 +338,11 @@ type
 
     function GetWorkerClass: TCustomLEDMultiStateFunctionWorkerClass; override;
   end;
+  *)
 
 
 implementation
+(*
 uses
   FSXLEDFunctionWorker,
   FSXResources,
@@ -1086,6 +1089,6 @@ end;
 function TFSXATCVisibilityFunction.GetWorkerClass: TCustomLEDMultiStateFunctionWorkerClass;
 begin
   Result := TFSXATCVisibilityFunctionWorker;
-end;
+end;*)
 
 end.

G940LEDControl/Units/FSXLEDFunctionProvider.pas

@@ -4,79 +4,74 @@ interface
 uses
   Generics.Collections,
   System.SyncObjs,
+  System.Types,
 
   X2Log.Intf,
+  Lua,
 
   FSXLEDFunctionProviderIntf,
   FSXSimConnectIntf,
   LEDFunction,
   LEDFunctionIntf,
-  LEDStateIntf;
+  LEDStateIntf,
+  LuaLEDFunctionProvider;
 
 
 type
-  TCustomFSXFunction = class;
+  TFSXLEDFunctionWorker = class;
-  TCustomFSXFunctionList = TObjectList<TCustomFSXFunction>;
 
 
-  TFSXLEDFunctionProvider = class(TCustomLEDFunctionProvider, IFSXLEDFunctionProvider, IFSXSimConnectObserver)
+  TFSXLEDFunctionProvider = class(TCustomLuaLEDFunctionProvider, IFSXLEDFunctionProvider, IFSXSimConnectObserver)
   private
     FSimConnect: TInterfacedObject;
     FSimConnectLock: TCriticalSection;
     FProfileMenuSimConnect: IFSXSimConnectProfileMenu;
+    FScriptSimConnect: TObject;
   protected
-    procedure RegisterFunctions; override;
-
     function GetUID: string; override;
-  protected
+    function CreateLuaLEDFunction(AInfo: ILuaTable; AOnSetup: ILuaFunction): TCustomLuaLEDFunction; override;
+
+    procedure InitInterpreter; override;
+    procedure SetupWorker(AWorker: TFSXLEDFunctionWorker; AOnSetup: ILuaFunction);
+
     { IFSXSimConnectObserver }
     procedure ObserveDestroy(Sender: IFSXSimConnect);
 
     { IFSXLEDFunctionProvider }
     procedure SetProfileMenu(AEnabled: Boolean; ACascaded: Boolean);
   public
-    constructor Create;
+    constructor Create(const AScriptFolders: TStringDynArray);
     destructor Destroy; override;
 
     function GetSimConnect: IFSXSimConnect;
   end;
 
 
-  TCustomFSXFunction = class(TCustomMultiStateLEDFunction)
+  TFSXLEDFunction = class(TCustomLuaLEDFunction)
   private
     FProvider: TFSXLEDFunctionProvider;
-    FDisplayName: string;
-    FUID: string;
   protected
+    function GetDefaultCategoryName: string; override;
+
+    function GetWorkerClass: TCustomLEDMultiStateFunctionWorkerClass; override;
     procedure InitializeWorker(AWorker: TCustomLEDMultiStateFunctionWorker); override;
 
     property Provider: TFSXLEDFunctionProvider read FProvider;
-  protected
-    function GetCategoryName: string; override;
-    function GetDisplayName: string; override;
-    function GetUID: string; override;
   public
-    constructor Create(AProvider: TFSXLEDFunctionProvider; const ADisplayName, AUID: string);
+    constructor Create(AProvider: TFSXLEDFunctionProvider; AInfo: ILuaTable; AOnSetup: ILuaFunction);
   end;
 
 
-  TCustomFSXFunctionClass = class of TCustomFSXFunction;
+  TFSXLEDFunctionWorker = class(TCustomLuaLEDFunctionWorker)
-
-
-  TCustomFSXFunctionWorker = class(TCustomLEDMultiStateFunctionWorker)
   private
     FDataHandler: IFSXSimConnectDataHandler;
-    FDefinitionID: Cardinal;
+    FDefinitionID: TList<Cardinal>;
-    FSimConnect: IFSXSimConnect;
   protected
-    procedure RegisterVariables(ADefinition: IFSXSimConnectDefinition); virtual; abstract;
-
-    procedure SetSimConnect(const Value: IFSXSimConnect); virtual;
-
     property DataHandler: IFSXSimConnectDataHandler read FDataHandler;
-    property DefinitionID: Cardinal read FDefinitionID;
+    property DefinitionID: TList<Cardinal> read FDefinitionID;
-    property SimConnect: IFSXSimConnect read FSimConnect write SetSimConnect;
   protected
+    procedure AddDefinition(ADefinition: IFSXSimConnectDefinition);
+
     procedure HandleData(AData: Pointer); virtual; abstract;
   public
     constructor Create(const AProviderUID, AFunctionUID: string; AStates: ILEDMultiStateFunction; ASettings: ILEDFunctionWorkerSettings; const APreviousState: string = ''); override;
@@ -86,6 +81,7 @@ type
 
 implementation
 uses
+  System.Classes,
   System.SysUtils,
 
   X2Log.Global,
@@ -100,37 +96,88 @@ uses
 type
   TCustomFSXFunctionWorkerDataHandler = class(TInterfacedObject, IFSXSimConnectDataHandler)
   private
-    FWorker: TCustomFSXFunctionWorker;
+    FWorker: TFSXLEDFunctionWorker;
   protected
     { IFSXSimConnectDataHandler }
     procedure HandleData(AData: Pointer);
 
-    property Worker: TCustomFSXFunctionWorker read FWorker;
+    property Worker: TFSXLEDFunctionWorker read FWorker;
   public
-    constructor Create(AWorker: TCustomFSXFunctionWorker);
+    constructor Create(AWorker: TFSXLEDFunctionWorker);
   end;
 
 
+  TLuaSimConnect = class(TPersistent)
+  private
+    FProvider: TFSXLEDFunctionProvider;
+  protected
+    property Provider: TFSXLEDFunctionProvider read FProvider;
+  public
+    constructor Create(AProvider: TFSXLEDFunctionProvider);
+  published
+    procedure Monitor(Context: ILuaContext);
+  end;
+
+
+type
+  TLuaSimConnectType = record
+    TypeName: string;
+    Units: string;
+    DataType: SIMCONNECT_DATAType;
+  end;
+
+const
+  LuaSimConnectTypes: array[0..4] of TLuaSimConnectType =
+                      (
+                        ( TypeName: 'Bool'; Units: FSX_UNIT_BOOL; DataType: SIMCONNECT_DATAType_INT32 ),
+                        ( TypeName: 'Percent'; Units: FSX_UNIT_PERCENT; DataType: SIMCONNECT_DATAType_FLOAT64 ),
+                        ( TypeName: 'Integer'; Units: FSX_UNIT_NUMBER; DataType: SIMCONNECT_DATAType_INT32 ),
+                        ( TypeName: 'Float'; Units: FSX_UNIT_NUMBER; DataType: SIMCONNECT_DATAType_FLOAT64 ),
+                        ( TypeName: 'Mask'; Units: FSX_UNIT_MASK; DataType: SIMCONNECT_DATATYPE_INT32 )
+                      );
+
+
+function GetUnits(const AType: string; out AUnits: string; out ADataType: SIMCONNECT_DATAType): Boolean;
+var
+  typeIndex: Integer;
+
+begin
+  for typeIndex := Low(LuaSimConnectTypes) to High(LuaSimConnectTypes) do
+    if SameText(AType, LuaSimConnectTypes[typeIndex].TypeName) then
+    begin
+      AUnits := LuaSimConnectTypes[typeIndex].Units;
+      ADataType := LuaSimConnectTypes[typeIndex].DataType;
+      Exit(True);
+    end;
+
+  Result := False;
+end;
+
 
 { TFSXLEDFunctionProvider }
-constructor TFSXLEDFunctionProvider.Create;
+constructor TFSXLEDFunctionProvider.Create(const AScriptFolders: TStringDynArray);
 begin
-  inherited Create;
-
   FSimConnectLock := TCriticalSection.Create;
+  FScriptSimConnect := TLuaSimConnect.Create(Self);
+
+  inherited Create(AScriptFolders);
 end;
 
 
 destructor TFSXLEDFunctionProvider.Destroy;
 begin
+  FreeAndNil(FScriptSimConnect);
   FreeAndNil(FSimConnectLock);
 
   inherited Destroy;
 end;
 
 
+(*
 procedure TFSXLEDFunctionProvider.RegisterFunctions;
 begin
+  inherited RegisterFunctions;
+
   { Systems }
   RegisterFunction(TFSXBatteryMasterFunction.Create(        Self, FSXFunctionDisplayNameBatteryMaster,          FSXFunctionUIDBatteryMaster));
   RegisterFunction(TFSXDeIceFunction.Create(                Self, FSXFunctionDisplayNameDeIce,                  FSXFunctionUIDDeIce));
@@ -193,6 +240,36 @@ begin
   { ATC }
   RegisterFunction(TFSXATCVisibilityFunction.Create(FSXProviderUID));
 end;
+*)
+
+function TFSXLEDFunctionProvider.CreateLuaLEDFunction(AInfo: ILuaTable; AOnSetup: ILuaFunction): TCustomLuaLEDFunction;
+begin
+  Result := TFSXLEDFunction.Create(Self, AInfo, AOnSetup);
+end;
+
+
+procedure TFSXLEDFunctionProvider.InitInterpreter;
+var
+  simConnectType: ILuaTable;
+  typeIndex: Integer;
+
+begin
+  inherited InitInterpreter;
+
+  Interpreter.RegisterFunctions(FScriptSimConnect, 'SimConnect');
+
+  simConnectType := TLuaTable.Create;
+  for typeIndex := Low(LuaSimConnectTypes) to High(LuaSimConnectTypes) do
+    simConnectType.SetValue(LuaSimConnectTypes[typeIndex].TypeName, LuaSimConnectTypes[typeIndex].TypeName);
+
+  Interpreter.SetGlobalVariable('SimConnectType', simConnectType);
+end;
+
+
+procedure TFSXLEDFunctionProvider.SetupWorker(AWorker: TFSXLEDFunctionWorker; AOnSetup: ILuaFunction);
+begin
+  AOnSetup.Call([AWorker.UID]);
+end;
 
 
 function TFSXLEDFunctionProvider.GetUID: string;
@@ -245,81 +322,80 @@ end;
 
 
 
-{ TCustomFSXFunction }
+{ TFSXLEDFunction }
-constructor TCustomFSXFunction.Create(AProvider: TFSXLEDFunctionProvider; const ADisplayName, AUID: string);
+constructor TFSXLEDFunction.Create(AProvider: TFSXLEDFunctionProvider; AInfo: ILuaTable; AOnSetup: ILuaFunction);
 begin
-  inherited Create(AProvider.GetUID);
+  inherited Create(AProvider, AInfo, AOnSetup);
 
   FProvider := AProvider;
-  FDisplayName := ADisplayName;
-  FUID := AUID;
 end;
 
 
-procedure TCustomFSXFunction.InitializeWorker(AWorker: TCustomLEDMultiStateFunctionWorker);
+function TFSXLEDFunction.GetDefaultCategoryName: string;
-begin
-  (AWorker as TCustomFSXFunctionWorker).SimConnect := Provider.GetSimConnect;
-end;
-
-
-function TCustomFSXFunction.GetCategoryName: string;
 begin
   Result := FSXCategory;
 end;
 
 
-function TCustomFSXFunction.GetDisplayName: string;
+function TFSXLEDFunction.GetWorkerClass: TCustomLEDMultiStateFunctionWorkerClass;
 begin
-  Result := FDisplayName;
+  Result := TFSXLEDFunctionWorker;
 end;
 
 
-function TCustomFSXFunction.GetUID: string;
+procedure TFSXLEDFunction.InitializeWorker(AWorker: TCustomLEDMultiStateFunctionWorker);
+var
+  worker: TFSXLEDFunctionWorker;
+
 begin
-  Result := FUID;
+  worker := (AWorker as TFSXLEDFunctionWorker);
+  worker.Provider := Provider;
+
+  Provider.SetupWorker(worker, Setup);
 end;
 
 
-{ TCustomFSXFunctionWorker }
+{ TFSXLEDFunctionWorker }
-constructor TCustomFSXFunctionWorker.Create(const AProviderUID, AFunctionUID: string; AStates: ILEDMultiStateFunction; ASettings: ILEDFunctionWorkerSettings; const APreviousState: string);
+constructor TFSXLEDFunctionWorker.Create(const AProviderUID, AFunctionUID: string; AStates: ILEDMultiStateFunction; ASettings: ILEDFunctionWorkerSettings; const APreviousState: string);
 begin
   { We can't pass ourselves as the Data Handler, as it would keep a reference to
     this worker from the SimConnect interface. That'd mean the worker never
     gets destroyed, and SimConnect never shuts down. Hence this proxy class. }
   FDataHandler := TCustomFSXFunctionWorkerDataHandler.Create(Self);
+  FDefinitionID := TList<Cardinal>.Create;
 
   inherited Create(AProviderUID, AFunctionUID, AStates, ASettings, APreviousState);
 end;
 
 
-destructor TCustomFSXFunctionWorker.Destroy;
+destructor TFSXLEDFunctionWorker.Destroy;
+var
+  simConnect: IFSXSimConnect;
+  id: Cardinal;
+
 begin
-  if DefinitionID <> 0 then
+  if Assigned(Provider) and (DefinitionID.Count > 0) then
-    SimConnect.RemoveDefinition(DefinitionID, DataHandler);
+  begin
+    simConnect := (Provider as TFSXLEDFunctionProvider).GetSimConnect;
+
+    for id in DefinitionID do
+      simConnect.RemoveDefinition(id, DataHandler);
+  end;
+
+  FreeAndNil(FDefinitionID);
 
   inherited Destroy;
 end;
 
 
-procedure TCustomFSXFunctionWorker.SetSimConnect(const Value: IFSXSimConnect);
+procedure TFSXLEDFunctionWorker.AddDefinition(ADefinition: IFSXSimConnectDefinition);
-var
-  definition: IFSXSimConnectDefinition;
-
 begin
-  FSimConnect := Value;
+  DefinitionID.Add((Provider as TFSXLEDFunctionProvider).GetSimConnect.AddDefinition(ADefinition, DataHandler));
-
-  if Assigned(SimConnect) then
-  begin
-    definition := SimConnect.CreateDefinition;
-    RegisterVariables(definition);
-
-    FDefinitionID := SimConnect.AddDefinition(definition, DataHandler);
-  end;
 end;
 
 
 { TCustomFSXFunctionWorkerDataHandler }
-constructor TCustomFSXFunctionWorkerDataHandler.Create(AWorker: TCustomFSXFunctionWorker);
+constructor TCustomFSXFunctionWorkerDataHandler.Create(AWorker: TFSXLEDFunctionWorker);
 begin
   inherited Create;
 
@@ -333,7 +409,65 @@ begin
 end;
 
 
-initialization
+{ TLuaSimConnect }
-  TLEDFunctionRegistry.Register(TFSXLEDFunctionProvider.Create);
+constructor TLuaSimConnect.Create(AProvider: TFSXLEDFunctionProvider);
+begin
+  inherited Create;
+
+  FProvider := AProvider;
+end;
+
+
+procedure TLuaSimConnect.Monitor(Context: ILuaContext);
+var
+  workerID: string;
+  variables: ILuaTable;
+  onData: ILuaFunction;
+  worker: TCustomLuaLEDFunctionWorker;
+  definition: IFSXSimConnectDefinition;
+  variable: TLuaKeyValuePair;
+  info: ILuaTable;
+  units: string;
+  dataType: SIMCONNECT_DATAType;
+
+begin
+  if Context.Parameters.Count < 3 then
+    raise ELuaScriptError.Create('Not enough parameters for SimConnect.Monitor');
+
+  if Context.Parameters[0].VariableType <> VariableString then
+    raise ELuaScriptError.Create('Context expected for SimConnect.Monitor parameter 1');
+
+  if Context.Parameters[1].VariableType <> VariableTable then
+    raise ELuaScriptError.Create('Table expected for SimConnect.Monitor parameter 2');
+
+  if Context.Parameters[2].VariableType <> VariableFunction then
+    raise ELuaScriptError.Create('Function expected for SimConnect.Monitor parameter 3');
+
+  workerID := Context.Parameters[0].AsString;
+  variables := Context.Parameters[1].AsTable;
+  onData := Context.Parameters[2].AsFunction;
+
+  worker := Provider.FindWorker(workerID);
+  if not Assigned(worker) then
+    raise ELuaScriptError.Create('Context expected for SimConnect.Monitor parameter 1');
+
+  definition := Provider.GetSimConnect.CreateDefinition;
+
+  for variable in variables do
+  begin
+    if variable.Value.VariableType = VariableTable then
+    begin
+      info := variable.Value.AsTable;
+      if info.HasValue('variable') and
+         info.HasValue('type') and
+         GetUnits(info.GetValue('type').AsString, units, dataType) then
+      begin
+        definition.AddVariable(info.GetValue('variable').AsString, units, dataType);
+      end;
+    end;
+  end;
+
+  (worker as TFSXLEDFunctionWorker).AddDefinition(definition);
+end;
 
 end.

G940LEDControl/Units/FSXLEDFunctionWorker.pas

@@ -1,6 +1,7 @@
 unit FSXLEDFunctionWorker;
 
 interface
+(*
 uses
   OtlTaskControl,
 
@@ -268,9 +269,10 @@ type
     constructor Create(const AProviderUID: string; const AFunctionUID: string; AStates: ILEDMultiStateFunction; ASettings: ILEDFunctionWorkerSettings; const APreviousState: string = ''); override;
     destructor Destroy; override;
   end;
-
+*)
 
 implementation
+(*
 uses
   System.Math,
   System.StrUtils,
@@ -1181,6 +1183,6 @@ begin
     FVisible := visible;
     FOnStateChanged(visible);
   end;
-end;
+end;*)
 
 end.

G940LEDControl/Units/LuaLEDFunctionProvider.pas

@@ -0,0 +1,332 @@
+unit LuaLEDFunctionProvider;
+
+interface
+uses
+  System.Generics.Collections,
+  System.SysUtils,
+  System.Types,
+
+  LEDFunction,
+  LEDFunctionIntf,
+  LEDStateIntf,
+  Lua;
+
+type
+  ELuaScriptError = class(Exception);
+
+  TCustomLuaLEDFunctionWorker = class;
+
+
+  TCustomLuaLEDFunction = class(TCustomMultiStateLEDFunction)
+  private
+    FCategoryName: string;
+    FDisplayName: string;
+    FUID: string;
+    FScriptStates: ILuaTable;
+    FSetup: ILuaFunction;
+  protected
+    procedure RegisterStates; override;
+
+    function GetDefaultCategoryName: string; virtual;
+
+    { ILEDFunction }
+    function GetCategoryName: string; override;
+    function GetDisplayName: string; override;
+    function GetUID: string; override;
+
+    property ScriptStates: ILuaTable read FScriptStates;
+    property Setup: ILuaFunction read FSetup;
+  public
+    constructor Create(AProvider: ILEDFunctionProvider; AInfo: ILuaTable; ASetup: ILuaFunction);
+  end;
+
+
+  TCustomLuaLEDFunctionProvider = class(TCustomLEDFunctionProvider)
+  private
+    FInterpreter: TLua;
+    FScriptFolders: TStringDynArray;
+    FWorkers: TDictionary<string, TCustomLuaLEDFunctionWorker>;
+  protected
+    function CreateLuaLEDFunction(AInfo: ILuaTable; ASetup: ILuaFunction): TCustomLuaLEDFunction; virtual; abstract;
+
+    procedure InitInterpreter; virtual;
+    procedure RegisterFunctions; override;
+
+    procedure RegisterWorker(AWorker: TCustomLuaLEDFunctionWorker);
+    procedure UnregisterWorker(AWorker: TCustomLuaLEDFunctionWorker);
+    function FindWorker(const AUID: string): TCustomLuaLEDFunctionWorker;
+
+    property Interpreter: TLua read FInterpreter;
+    property ScriptFolders: TStringDynArray read FScriptFolders;
+    property Workers: TDictionary<string, TCustomLuaLEDFunctionWorker> read FWorkers;
+  public
+    constructor Create(const AScriptFolders: TStringDynArray);
+    destructor Destroy; override;
+  end;
+
+
+  TCustomLuaLEDFunctionWorker = class(TCustomLEDMultiStateFunctionWorker)
+  private
+    FProvider: TCustomLuaLEDFunctionProvider;
+    FUID: string;
+
+    procedure SetProvider(const Value: TCustomLuaLEDFunctionProvider);
+  protected
+    property Provider: TCustomLuaLEDFunctionProvider read FProvider write SetProvider;
+  public
+    constructor Create(const AProviderUID, AFunctionUID: string; AStates: ILEDMultiStateFunction; ASettings: ILEDFunctionWorkerSettings; const APreviousState: string = ''); override;
+    destructor Destroy; override;
+
+    property UID: string read FUID;
+  end;
+
+
+implementation
+uses
+  System.IOUtils,
+
+  LEDColorIntf,
+  LEDState;
+
+
+const
+  LuaLEDColors: array[TLEDColor] of string =
+                (
+                  'Off', 'Green', 'Amber', 'Red',
+                  'FlashingGreenFast', 'FlashingGreenNormal',
+                  'FlashingAmberFast', 'FlashingAmberNormal',
+                  'FlashingRedFast', 'FlashingRedNormal'
+                );
+
+function GetLEDColor(const AValue: string; ADefault: TLEDColor = lcOff): TLEDColor;
+var
+  color: TLEDColor;
+
+begin
+  for color := Low(TLEDColor) to High(TLEDColor) do
+    if SameText(AValue, LuaLEDColors[color]) then
+      exit(color);
+
+  Result := ADefault;
+end;
+
+
+
+{ TCustomLuaLEDFunctionProvider }
+constructor TCustomLuaLEDFunctionProvider.Create(const AScriptFolders: TStringDynArray);
+begin
+  FWorkers := TDictionary<string, TCustomLuaLEDFunctionWorker>.Create;
+  FInterpreter := TLua.Create;
+  FScriptFolders := AScriptFolders;
+
+  InitInterpreter;
+
+  inherited Create;
+end;
+
+
+destructor TCustomLuaLEDFunctionProvider.Destroy;
+begin
+  FreeAndNil(FInterpreter);
+  FreeAndNil(FWorkers);
+
+  inherited Destroy;
+end;
+
+
+procedure TCustomLuaLEDFunctionProvider.InitInterpreter;
+var
+  table: ILuaTable;
+  color: TLEDColor;
+
+begin
+  Interpreter.RegisterFunction('RegisterFunction',
+    procedure(Context: ILuaContext)
+    var
+      info: ILuaTable;
+      setup: ILuaFunction;
+
+    begin
+      if Context.Parameters.Count < 2 then
+        raise ELuaScriptError.Create('Not enough parameters for RegisterFunction');
+
+      if Context.Parameters[0].VariableType <> VariableTable then
+        raise ELuaScriptError.Create('Table expected for RegisterFunction parameter 1');
+
+      if Context.Parameters[1].VariableType <> VariableFunction then
+        raise ELuaScriptError.Create('Function expected for RegisterFunction parameter 2');
+
+      info := Context.Parameters[0].AsTable;
+      setup := Context.Parameters[1].AsFunction;
+
+      if not info.HasValue('uid') then
+        raise ELuaScriptError.Create('"uid" value is required for RegisterFunction parameter 1');
+
+      RegisterFunction(CreateLuaLEDFunction(info, setup));
+    end);
+
+  table := TLuaTable.Create;
+  for color := Low(TLEDColor) to High(TLEDColor) do
+    table.SetValue(LuaLEDColors[color], LuaLEDColors[color]);
+
+  Interpreter.SetGlobalVariable('LEDColor', table);
+
+  // #ToDo1 -oMvR: 28-5-2017: SetState
+end;
+
+
+procedure TCustomLuaLEDFunctionProvider.RegisterFunctions;
+var
+  scriptFolder: string;
+  scriptFile: string;
+
+begin
+  for scriptFolder in ScriptFolders do
+    if TDirectory.Exists(scriptFolder) then
+      for scriptFile in TDirectory.GetFiles(ScriptFolder, '*.lua') do
+      try
+        Interpreter.LoadFromFile(scriptFile);
+      except
+        on E:Exception do
+          Exception.RaiseOuterException(ELuaScriptError.CreateFmt('Error while loading script %s: %s', [scriptFile, E.Message]));
+      end;
+end;
+
+
+procedure TCustomLuaLEDFunctionProvider.RegisterWorker(AWorker: TCustomLuaLEDFunctionWorker);
+begin
+  Workers.Add(AWorker.UID, AWorker);
+end;
+
+
+procedure TCustomLuaLEDFunctionProvider.UnregisterWorker(AWorker: TCustomLuaLEDFunctionWorker);
+begin
+  Workers.Remove(AWorker.UID);
+end;
+
+
+function TCustomLuaLEDFunctionProvider.FindWorker(const AUID: string): TCustomLuaLEDFunctionWorker;
+begin
+  if not Workers.TryGetValue(AUID, Result) then
+    Result := nil;
+end;
+
+
+
+{ TCustomLuaLEDFunction }
+constructor TCustomLuaLEDFunction.Create(AProvider: ILEDFunctionProvider; AInfo: ILuaTable; ASetup: ILuaFunction);
+begin
+  FCategoryName := GetDefaultCategoryName;
+  FDisplayName := 'Unknown function';
+  FSetup := ASetup;
+
+  FUID := AInfo.GetValue('uid').AsString;
+
+  if AInfo.HasValue('category') then
+    FCategoryName := AInfo.GetValue('category').AsString;
+
+  if AInfo.HasValue('displayName') then
+    FDisplayName := AInfo.GetValue('displayName').AsString;
+
+  FScriptStates := nil;
+  if AInfo.HasValue('states') then
+    FScriptStates := AInfo.GetValue('states').AsTable;
+
+  // #ToDo1 -oMvR: 28-5-2017: application filter?
+
+  inherited Create(AProvider.GetUID);
+end;
+
+
+function TCustomLuaLEDFunction.GetCategoryName: string;
+begin
+  Result := FCategoryName;
+end;
+
+
+function TCustomLuaLEDFunction.GetDisplayName: string;
+begin
+  Result := FDisplayName;
+end;
+
+
+function TCustomLuaLEDFunction.GetUID: string;
+begin
+  Result := FUID;
+end;
+
+
+procedure TCustomLuaLEDFunction.RegisterStates;
+var
+  state: TLuaKeyValuePair;
+  displayName: string;
+  defaultColor: TLEDColor;
+  info: ILuaTable;
+
+begin
+  if not Assigned(ScriptStates) then
+    exit;
+
+  for state in ScriptStates do
+  begin
+    displayName := state.Key.AsString;
+    defaultColor := lcOff;
+
+    if state.Value.VariableType = VariableTable then
+    begin
+      info := state.Value.AsTable;
+      if info.HasValue('displayName') then
+        displayName := info.GetValue('displayName').AsString;
+
+      if info.HasValue('default') then
+        defaultColor := GetLEDColor(info.GetValue('default').AsString);
+    end;
+
+    RegisterState(TLEDState.Create(state.Key.AsString, displayName, defaultColor));
+  end;
+end;
+
+
+function TCustomLuaLEDFunction.GetDefaultCategoryName: string;
+begin
+  Result := 'Other';
+end;
+
+
+{ TCustomLuaLEDFunctionWorker }
+constructor TCustomLuaLEDFunctionWorker.Create(const AProviderUID, AFunctionUID: string; AStates: ILEDMultiStateFunction; ASettings: ILEDFunctionWorkerSettings; const APreviousState: string);
+var
+  workerGUID: TGUID;
+
+begin
+  if CreateGUID(workerGUID) <> 0 then
+    RaiseLastOSError;
+
+  FUID := GUIDToString(workerGUID);
+
+  inherited Create(AProviderUID, AFunctionUID, AStates, ASettings, APreviousState);
+end;
+
+destructor TCustomLuaLEDFunctionWorker.Destroy;
+begin
+  SetProvider(nil);
+
+  inherited Destroy;
+end;
+
+
+procedure TCustomLuaLEDFunctionWorker.SetProvider(const Value: TCustomLuaLEDFunctionProvider);
+begin
+  if Value <> FProvider then
+  begin
+    if Assigned(FProvider) then
+      FProvider.UnregisterWorker(Self);
+
+    FProvider := Value;
+
+    if Assigned(FProvider) then
+      FProvider.RegisterWorker(Self);
+  end;
+end;
+
+end.

G940LEDControl/Units/StaticLEDFunction.pas

@@ -114,8 +114,4 @@ begin
   Result := FState;
 end;
 
-
-initialization
-  TLEDFunctionRegistry.Register(TStaticLEDFunctionProvider.Create);
-
 end.

G940LEDControl/XSD/SimBaseDocument.settings.xml

@@ -1,2 +1,2 @@
 <?xml version="1.0"?>
-<DataBindingSettings xmlns="http://www.x2software.net/xsd/databinding/DataBindingSettings.xsd"><Output><OutputType>Single</OutputType><OutputSingle><FileName>F:\Development\G940\G940LEDControl\Units\SimBaseDocumentXMLBinding.pas</FileName></OutputSingle></Output></DataBindingSettings>
+<DataBindingSettings xmlns="http://www.x2software.net/xsd/databinding/DataBindingSettings.xsd"><Output><OutputType>Single</OutputType><OutputSingle><FileName>..\Units\SimBaseDocumentXMLBinding.pas</FileName></OutputSingle></Output></DataBindingSettings>

G940LEDControl/XSD/SimBaseDocument.xsd

@@ -1,6 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- edited with XMLSpy v2015 rel. 3 (x64) (http://www.altova.com) by Mark van Renswoude (UnameIT we build IT B.V.) -->
-<!-- W3C Schema generated by XMLSpy v2015 rel. 3 (x64) (http://www.altova.com) -->
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 	<xs:element name="SimBase.Document">
 		<xs:complexType>