WebSVN – NedoOS – Diff – /tools/src/sjasmplus/sjasm/lua_sjasm.cpp

 /*
-** Lua binding: sjasm
-** Generated automatically by tolua++-1.0.92 on 11/06/08 00:50:38.
-*/
+  SjASMPlus Z80 Cross Compiler - modified - lua scripting module
+  Copyright (c) 2006 Sjoerd Mastijn (original SW)
+  Copyright (c) 2022 Peter Ped Helcmanovsky (lua scripting module)
+  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
-#ifndef __cplusplus
+  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,
-#include "stdlib.h"
+  subject to the following restrictions:
-#endif
+. 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
-#include "string.h"
+         not required.
+. Altered source versions must be plainly marked as such, and must not be
-#include "tolua++.h"
+         misrepresented as being the original software.
-/* Exported function */
+. This notice may not be removed or altered from any source distribution.
+*/
-TOLUA_API int  tolua_sjasm_open (lua_State* tolua_S);
+// lua_sjasm.cpp
 #include "sjdefs.h"
-using namespace Options;
-/* function to register type */
+#ifdef USE_LUA
-static void tolua_reg_types (lua_State* tolua_S)
-{
+#include "lua.hpp"
- tolua_usertype(tolua_S,"TCHAR");
+#include "LuaBridge/LuaBridge.h"
-}
+static lua_State *LUA = nullptr;
-/* function: DefineTable.Get */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_get_define00
+static const char* lua_err_prefix = "[LUA] ";
-static int tolua_sjasm_sj_get_define00(lua_State* tolua_S)
-{
+// extra lua script inserting interface (sj.something) entry functions
-#ifndef TOLUA_RELEASE
+// for functions with optional arguments, like error and warning
- tolua_Error tolua_err;
+// (as LuaBridge2.6 doesn't offer that type of binding as far as I can tell)
- if (
+// Sidestepping LuaBridge write-protection by "rawset" the end point into it
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
+static const char* binding_script_name = "lua_sjasm.cpp";
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
+static constexpr int binding_script_line = __LINE__;
- )
+static const std::string lua_impl_init_bindings_script = R"BINDING_LUA(
-  goto tolua_lerror;
+rawset(sj,"error",function(m,v)sj.error_i(m or "no message",v)end)
- else
+rawset(sj,"warning",function(m,v)sj.warning_i(m or "no message",v)end)
-#endif
+rawset(sj,"insert_define",function(n,v)return sj.insert_define_i(n,v)end)
- {
+rawset(sj,"exit",function(e)return sj.exit_i(e or 1)end)
-  char* tolua_var_1 = ((char*)  tolua_tostring(tolua_S,1,0));
+rawset(sj,"set_device",function(i,t)return sj.set_device_i(i or "NONE",t or 0)end)
-  {
+rawset(zx,"trdimage_create",function(n,l)return zx.trdimage_create_i(n,l)end)
-   char* tolua_ret = (char*)  DefineTable.Get(tolua_var_1);
+rawset(zx,"trdimage_add_file",function(t,f,s,l,a,r)return zx.trdimage_add_file_i(t,f,s,l,a or -1,r or false)end)
-   tolua_pushstring(tolua_S,(const char*)tolua_ret);
+)BINDING_LUA";
-  }
- }
+static void lua_impl_fatalError(lua_State *L) {
- return 1;
+        Error((char *)lua_tostring(L, -1), NULL, FATAL);
-#ifndef TOLUA_RELEASE
+}
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'get_define'.",&tolua_err);
+static std::vector<TextFilePos> scripts_origin;
- return 0;
-#endif
+static char internal_script_name[LINEMAX];
-}
-#endif //#ifndef TOLUA_DISABLE
+static const char* lua_impl_get_script_name(const TextFilePos & srcPos) {
+        sprintf(internal_script_name, "script %u", uint32_t(scripts_origin.size()));
-/* function: DefineTable.Replace */
+        scripts_origin.push_back(srcPos);
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_insert_define00
+        return internal_script_name;
-static int tolua_sjasm_sj_insert_define00(lua_State* tolua_S)
+}
-{
-#ifndef TOLUA_RELEASE
+static bool isInlinedScript(TextFilePos & errorPos, const char* script_name) {
- tolua_Error tolua_err;
+        // return false when the script is external (real file name)
- if (
+        if (script_name != strstr(script_name, "[string \"script ")) return false;
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
+        // inlined script, find it's origin and add line number to that
-     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+        int scriptNumber = atoi(script_name + 16);
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
+        if (scriptNumber < 0 || int(scripts_origin.size()) <= scriptNumber) return false;
- )
+        errorPos = scripts_origin.at(scriptNumber);
-  goto tolua_lerror;
+        return true;
- else
+}
-#endif
- {
+// adds current source position in lua script + full stack depth onto sourcePosStack
-  char* tolua_var_2 = ((char*)  tolua_tostring(tolua_S,1,0));
+// = makes calls to Error/Warning API to display more precise error lines in lua scripts
-  char* tolua_var_3 = ((char*)  tolua_tostring(tolua_S,2,0));
+static int addLuaSourcePositions() {
-  {
+        // find all *known* inlined/standalone script names and line numbers on the lua stack
-   bool tolua_ret = (bool)  DefineTable.Replace(tolua_var_2,tolua_var_3);
+        assert(LUA);
-   tolua_pushboolean(tolua_S,(bool)tolua_ret);
+        lua_Debug ar;
-  }
+        source_positions_t luaPosTemp;
- }
+        luaPosTemp.reserve(16);
- return 1;
+        int level = 1;                  // level 0 is "C" space, ignore that always
-#ifndef TOLUA_RELEASE
+        while (lua_getstack(LUA, level, &ar)) {                 // as long lua stack level are available
- tolua_lerror:
+                if (!lua_getinfo(LUA, "Sl", &ar)) break;        // not enough info about current level
- tolua_error(tolua_S,"#ferror in function 'insert_define'.",&tolua_err);
- return 0;
+                //assert(level || !strcmp("[C]", ar.short_src));        //TODO: verify if ever upgrading to newer lua
-#endif
+                //if (!strcmp("[C]", ar.short_src)) { ++level; continue; }
-}
-#endif //#ifndef TOLUA_DISABLE
+                TextFilePos levelErrorPos;
+                if (isInlinedScript(levelErrorPos, ar.short_src)) {
-/* function: LuaGetLabel */
+                        levelErrorPos.line += ar.currentline;
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_get_label00
+                } else {
-static int tolua_sjasm_sj_get_label00(lua_State* tolua_S)
+                        levelErrorPos.newFile(ArchiveFilename(ar.short_src));
-{
+                        levelErrorPos.line = ar.currentline;
-#ifndef TOLUA_RELEASE
+                }
- tolua_Error tolua_err;
+                luaPosTemp.push_back(levelErrorPos);
- if (
+                ++level;
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
+        }
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
+        // add all lua positions in reversed order to sourcePosStack (hide binding script if anything else is available)
-  goto tolua_lerror;
+        bool hide_binding = (2 <= luaPosTemp.size()) && !strcmp(binding_script_name, luaPosTemp[0].filename);
- else
+        source_positions_t::iterator stop = hide_binding ? luaPosTemp.begin() + 1 : luaPosTemp.begin();
-#endif
+        source_positions_t::iterator i = luaPosTemp.end();
- {
+        while (i-- != stop) sourcePosStack.push_back(*i);
-  char* tolua_var_4 = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
+        return luaPosTemp.end() - stop;
-   int tolua_ret = (int)  LuaGetLabel(tolua_var_4);
+}
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
+static void removeLuaSourcePositions(int to_remove) {
- }
+        while (to_remove--) sourcePosStack.pop_back();  // restore sourcePosStack to original state
- return 1;
+}
-#ifndef TOLUA_RELEASE
- tolua_lerror:
+// skips file+line_number info (but will adjust global LuaStartPos data for Error output)
- tolua_error(tolua_S,"#ferror in function 'get_label'.",&tolua_err);
+static TextFilePos lua_impl_splitLuaErrorMessage(const char*& LuaError) {
- return 0;
+        TextFilePos luaErrorPos("?");
-#endif
+        if (!sourcePosStack.empty()) luaErrorPos = sourcePosStack.back();
-}
+        if (nullptr == LuaError) return luaErrorPos;
-#endif //#ifndef TOLUA_DISABLE
+        const char* colonPos = strchr(LuaError, ':');
-/* function: LabelTable.Insert */
+        const char* colon2Pos = nullptr != colonPos ? strchr(colonPos+1, ':') : nullptr;
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_insert_label00
+        if (nullptr == colonPos || nullptr == colon2Pos) return luaErrorPos;    // error, format not recognized
-static int tolua_sjasm_sj_insert_label00(lua_State* tolua_S)
-{
+        int lineNumber = atoi(colonPos + 1);
-#ifndef TOLUA_RELEASE
+        if (isInlinedScript(luaErrorPos, LuaError)) {
- tolua_Error tolua_err;
+                luaErrorPos.line += lineNumber;
- if (
+        } else {
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
+                // standalone script, use file name and line number as is (if provided by lua error)
-     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+                STRNCPY(internal_script_name, LINEMAX, LuaError, colonPos - LuaError);
-     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
+                luaErrorPos.newFile(ArchiveFilename(internal_script_name));
-     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
+                luaErrorPos.line = lineNumber;
-     !tolua_isnoobj(tolua_S,5,&tolua_err)
+        }
- )
-  goto tolua_lerror;
+        // advance beyond filename and line in LuaError pointer
- else
+        LuaError = colon2Pos + 1;
-#endif
+        while (White(*LuaError)) ++LuaError;
- {
+        return luaErrorPos;
-  char* tolua_var_5 = ((char*)  tolua_tostring(tolua_S,1,0));
+}
-  unsigned int tolua_var_6 = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
-  bool tolua_var_7 = ((bool)  tolua_toboolean(tolua_S,3,false));
+static void lua_impl_showLoadError(const EStatus type) {
-  bool tolua_var_8 = ((bool)  tolua_toboolean(tolua_S,4,false));
+        const char *msgp = lua_tostring(LUA, -1);
-  bool tolua_var_9 = ((bool)  tolua_toboolean(tolua_S,5,false));
+        sourcePosStack.push_back(lua_impl_splitLuaErrorMessage(msgp));
-  {
+        Error(msgp, nullptr, type);
-   bool tolua_ret = (bool)  LabelTable.Insert(tolua_var_5,tolua_var_6,tolua_var_7,tolua_var_8,tolua_var_9);
+        sourcePosStack.pop_back();
-   tolua_pushboolean(tolua_S,(bool)tolua_ret);
+        lua_pop(LUA, 1);
-  }
+}
- }
- return 1;
+static aint lua_sj_calc(const char *str) {
-#ifndef TOLUA_RELEASE
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'insert_label'.",&tolua_err);
+        // substitute defines + macro_args in the `str` first (preserve original global variables)
- return 0;
+        char* const oldSubstitutedLine = substitutedLine;
-#endif
+        const int oldComlin = comlin;
-}
+        comlin = 0;
-#endif //#ifndef TOLUA_DISABLE
+        char* tmp = nullptr, * tmp2 = nullptr;
+        if (sline[0]) {
-/* get function: CurAddress */
+                tmp = STRDUP(sline);
-#ifndef TOLUA_DISABLE_tolua_get_sj_unsigned_current_address
+                if (nullptr == tmp) ErrorOOM();
-static int tolua_get_sj_unsigned_current_address(lua_State* tolua_S)
+        }
-{
+        if (sline2[0]) {
-  tolua_pushnumber(tolua_S,(lua_Number)CurAddress);
+                tmp2 = STRDUP(sline2);
- return 1;
+                if (nullptr == tmp2) ErrorOOM();
-}
+        }
-#endif //#ifndef TOLUA_DISABLE
+        // non-const copy of input string for ReplaceDefine argument
+        //TODO: v2.x, rewrite whole parser of sjasmplus to start with const input to avoid such copies
-/* get function: WarningCount */
+        char* luaInput = STRDUP(str ? str : "");
-#ifndef TOLUA_DISABLE_tolua_get_sj_warning_count
+        char* substitutedStr = ReplaceDefine(luaInput);
-static int tolua_get_sj_warning_count(lua_State* tolua_S)
-{
+        // evaluate the expression
-  tolua_pushnumber(tolua_S,(lua_Number)WarningCount);
+        aint val;
- return 1;
+        int parseResult = ParseExpression(substitutedStr, val);
-}
+        free(luaInput);
-#endif //#ifndef TOLUA_DISABLE
+        // restore any global values affected by substitution
-/* get function: ErrorCount */
+        sline[0] = 0;
-#ifndef TOLUA_DISABLE_tolua_get_sj_error_count
+        if (tmp) {
-static int tolua_get_sj_error_count(lua_State* tolua_S)
+                STRCPY(sline, LINEMAX2, tmp);
-{
+                free(tmp);
-  tolua_pushnumber(tolua_S,(lua_Number)ErrorCount);
+        }
- return 1;
+        sline2[0] = 0;
-}
+        if (tmp2) {
-#endif //#ifndef TOLUA_DISABLE
+                STRCPY(sline2, LINEMAX2, tmp2);
+                free(tmp2);
-/* function: LuaShellExec */
+        }
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_shellexec00
+        substitutedLine = oldSubstitutedLine;
-static int tolua_sjasm_sj_shellexec00(lua_State* tolua_S)
+        comlin = oldComlin;
-{
-#ifndef TOLUA_RELEASE
+        removeLuaSourcePositions(positionsAdded);
- tolua_Error tolua_err;
+        return parseResult ? val : 0;
- if (
+}
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
+static void parse_line(const char* str, bool parseLabels) {
- )
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
-  goto tolua_lerror;
- else
+        // preserve current actual line which will be parsed next
-#endif
+        char *oldLine = STRDUP(line);
- {
+        if (nullptr == oldLine) ErrorOOM();
-  char* command = ((char*)  tolua_tostring(tolua_S,1,0));
+        char *oldEolComment = eolComment;
-  {
+        // inject new line from Lua call and assemble it
+        STRCPY(line, LINEMAX, str ? str : "");
+        eolComment = nullptr;
+        ParseLineSafe(parseLabels);
+        // restore the original line
+        STRCPY(line, LINEMAX, oldLine);
+        eolComment = oldEolComment;
+        free(oldLine);
+        removeLuaSourcePositions(positionsAdded);
+}
+static void lua_sj_parse_line(const char *str) {
+        parse_line(str, true);
+}
+static void lua_sj_parse_code(const char *str) {
+        parse_line(str, false);
+}
+static void lua_sj_error(const char* message, const char* value = nullptr) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        Error(message, value, ALL);
+        removeLuaSourcePositions(positionsAdded);
+}
+static void lua_sj_warning(const char* message, const char* value = nullptr) {
+        int positionsAdded = addLuaSourcePositions();                   // add known script positions to sourcePosStack vector
+        Warning(message, value, W_ALL);
+        removeLuaSourcePositions(positionsAdded);
+}
+static const char* lua_sj_get_define(const char* name, bool macro_args = false) {
+        const char* macro_res = (macro_args && macrolabp) ? MacroDefineTable.getverv(name) : nullptr;
+        return macro_res ? macro_res : DefineTable.Get(name);
+}
+static bool lua_sj_insert_define(const char* name, const char* value) {
+        // wrapper to resolve member-function call (without std::function wrapping lambda, just to KISS)
+        char* lua_name = const_cast<char*>(name);               //TODO v2.x avoid const_cast like this
+        char* id = name ? GetID(lua_name) : nullptr;
+        if (nullptr == id) return false;
+        return DefineTable.Replace(id, value ? value : "");
+}
+static int lua_sj_get_label(const char *name) {
+        if (nullptr == name) return -1;
+        aint val;
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        char* n = const_cast<char*>(name);      //TODO try to get rid of const_cast, LuaBridge requires const char* to understand it as lua string
+        if (!GetLabelValue(n, val)) val = -1;
+        removeLuaSourcePositions(positionsAdded);
+        return val;
+}
+static bool lua_sj_insert_label(const char *name, int address) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        std::unique_ptr<char[]> fullName(ValidateLabel(name, false, false));
+        removeLuaSourcePositions(positionsAdded);
+        if (nullptr == fullName.get()) return false;
+        return LabelTable.Insert(name, address);
+}
+static void lua_sj_shellexec(const char *command) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
-   LuaShellExec(command);
+        LuaShellExec(command);
+        removeLuaSourcePositions(positionsAdded);
+}
+static bool lua_sj_set_page(aint n) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        if (!DeviceID) Warning("sj.set_page: only allowed in real device emulation mode (See DEVICE)");
+        bool result = DeviceID && dirPageImpl("sj.set_page", n);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+static bool lua_sj_set_slot(aint n) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        bool result = false;
+        if (!DeviceID) {
+                Warning("sj.set_slot: only allowed in real device emulation mode (See DEVICE)");
+        } else {
+                n = Device->SlotNumberFromPreciseAddress(n);
+                result = Device->SetSlot(n);
+                if (!result) {
+                        char buf[LINEMAX];
+                        SPRINTF1(buf, LINEMAX, "sj.set_slot: Slot number must be in range 0..%u", Device->SlotsCount - 1);
+                        Error(buf);
+                }
+        }
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+static bool lua_sj_set_device(const char* id, const aint ramtop = 0) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        // refresh source position of first DEVICE directive (to make global-device detection work correctly)
+        if (1 == ++deviceDirectivesCount) {
+                assert(!sourcePosStack.empty());
+                globalDeviceSourcePos = sourcePosStack.back();
+        }
+        // check for nullptr id??
+        bool result = SetDevice(id, ramtop);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'shellexec'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: TRD_SaveEmpty */
-#ifndef TOLUA_DISABLE_tolua_sjasm_zx_trdimage_create00
-static int tolua_sjasm_zx_trdimage_create00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* fname = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   int tolua_ret = (int)  TRD_SaveEmpty(fname, nullptr);
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'trdimage_create'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: TRD_AddFile */
-#ifndef TOLUA_DISABLE_tolua_sjasm_zx_trdimage_add_file00
-static int tolua_sjasm_zx_trdimage_add_file00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
-     !tolua_isboolean(tolua_S,6,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,7,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* fname = ((char*)  tolua_tostring(tolua_S,1,0));
-  char* fhobname = ((char*)  tolua_tostring(tolua_S,2,0));
-  int start = ((int)  tolua_tonumber(tolua_S,3,0));
-  int length = ((int)  tolua_tonumber(tolua_S,4,0));
-  int autostart = ((int)  tolua_tonumber(tolua_S,5,0));
-  bool replace = ((int)  tolua_toboolean(tolua_S,6,0));
-  {
-   int tolua_ret = (int)  TRD_AddFile(fname,fhobname,start,length,autostart,replace,false);
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'trdimage_add_file'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: SaveSNA_ZX */
-#ifndef TOLUA_DISABLE_tolua_sjasm_zx_save_snapshot_sna12800
-static int tolua_sjasm_zx_save_snapshot_sna12800(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* fname = ((char*)  tolua_tostring(tolua_S,1,0));
-  unsigned short start = ((unsigned short)  tolua_tonumber(tolua_S,2,0));
-  {
-   int tolua_ret = (int)  SaveSNA_ZX(fname,start);
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'save_snapshot_sna128'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* get function: CurrentDirectory */
-#ifndef TOLUA_DISABLE_tolua_get_sj_current_path
-static int tolua_get_sj_current_path(lua_State* tolua_S)
-{
-  tolua_pushstring(tolua_S,(const char*)CurrentDirectory);
- return 1;
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: ExitASM */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_exit00
-static int tolua_sjasm_sj_exit00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  int p = ((int)  tolua_tonumber(tolua_S,1,1));
-  {
-   ExitASM(p);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'exit'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: Error */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_error00
-static int tolua_sjasm_sj_error00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isstring(tolua_S,2,1,&tolua_err) ||
-     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,4,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* tolua_var_9 = ((char*)  tolua_tostring(tolua_S,1,0));
-  char* tolua_var_10 = ((char*)  tolua_tostring(tolua_S,2,0));
-  EStatus tolua_var_11 = ((EStatus) tolua_tovalue(tolua_S,3,ALL));
-  {
-   Error(tolua_var_9, tolua_var_10, tolua_var_11);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'error'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: Warning */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_warning00
-static int tolua_sjasm_sj_warning00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isstring(tolua_S,2,1,&tolua_err) ||
-     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,4,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* tolua_var_12 = ((char*)  tolua_tostring(tolua_S,1,0));
-  char* tolua_var_13 = ((char*)  tolua_tostring(tolua_S,2,0));
-  EWStatus tolua_var_14 = ((EWStatus) tolua_tovalue(tolua_S,3,W_ALL));
-  {
-   Warning(tolua_var_12, tolua_var_13, tolua_var_14);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'warning'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: FileExists */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_file_exists00
-static int tolua_sjasm_sj_file_exists00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* filename = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   bool tolua_ret = (bool)  FileExists(filename);
-   tolua_pushboolean(tolua_S,(bool)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'file_exists'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: GetPath */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_get_path00
-static int tolua_sjasm_sj_get_path00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isusertype(tolua_S,2,"TCHAR",0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* fname = ((char*)  tolua_tostring(tolua_S,1,0));
-  TCHAR* filenamebegin = ((TCHAR*)  tolua_tousertype(tolua_S,2,0));
-  {
-   char* tolua_ret = (char*)  GetPath(fname,&filenamebegin);
-   tolua_pushstring(tolua_S,(const char*)tolua_ret);
-   tolua_pushusertype(tolua_S,(void*)filenamebegin,"TCHAR");
-  }
- }
- return 2;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'get_path'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: SetDevice */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_set_device00
-static int tolua_sjasm_sj_set_device00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* id = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   bool tolua_ret = (bool)  SetDevice(id);
-   tolua_pushboolean(tolua_S,(bool)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'set_device'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: GetDeviceName */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_get_device00
-static int tolua_sjasm_sj_get_device00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnoobj(tolua_S,1,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  {
-   char* tolua_ret = (char*)  GetDeviceName();
-   tolua_pushstring(tolua_S,(const char*)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'get_device'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaSetPage */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_set_page00
-static int tolua_sjasm_sj_set_page00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  unsigned int n = ((unsigned int)  tolua_tonumber(tolua_S,1,0));
-  {
-   bool tolua_ret = (bool)  LuaSetPage(n);
-   tolua_pushboolean(tolua_S,(bool)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'set_page'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaSetSlot */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_set_slot00
-static int tolua_sjasm_sj_set_slot00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  unsigned int n = ((unsigned int)  tolua_tonumber(tolua_S,1,0));
-  {
-   bool tolua_ret = (bool)  LuaSetSlot(n);
-   tolua_pushboolean(tolua_S,(bool)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'set_slot'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: MemGetByte */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_get_byte00
-static int tolua_sjasm_sj_get_byte00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  unsigned int address = ((unsigned int)  tolua_tonumber(tolua_S,1,0));
-  {
-   unsigned char tolua_ret = (unsigned char)  MemGetByte(address);
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'get_byte'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: MemGetWord */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_get_word00
-static int tolua_sjasm_sj_get_word00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  unsigned int address = ((unsigned int)  tolua_tonumber(tolua_S,1,0));
-  {
-   lua_Number tolua_ret = 0xFFFF & MemGetWord(address);
-   tolua_pushnumber(tolua_S, tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'get_word'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: EmitByte */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_add_byte00
-static int tolua_sjasm_sj_add_byte00(lua_State* tolua_S)
+static void lua_sj_add_byte(int byte) {
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  unsigned char byte = ((unsigned char)  tolua_tonumber(tolua_S,1,0));
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
-  {
-   EmitByte(byte);
+        EmitByte(byte);
+        removeLuaSourcePositions(positionsAdded);
+}
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'add_byte'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: EmitWord */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_add_word00
-static int tolua_sjasm_sj_add_word00(lua_State* tolua_S)
+static void lua_sj_add_word(int word) {
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  unsigned int word = ((unsigned int)  tolua_tonumber(tolua_S,1,0));
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
-  {
-   EmitWord(word);
+        EmitWord(word);
+        removeLuaSourcePositions(positionsAdded);
+}
+static unsigned char lua_sj_get_byte(unsigned int address) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        auto result = MemGetByte(address);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+static unsigned int lua_sj_get_word(unsigned int address) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        auto result = MemGetWord(address);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+static bool lua_zx_trdimage_create(const char* trdname, const char* label = nullptr) {
+        // setup label to truncated 8 char array padded with spaces
+        char l8[9] = "        ";
+        char* l8_ptr = l8;
+        while (label && *label && (l8_ptr - l8) < 8) *l8_ptr++ = *label++;
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        bool result = TRD_SaveEmpty(trdname, l8);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+bool lua_zx_trdimage_add_file(const char* trd, const char* file, int start, int length, int autostart = -1, bool replace = false) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        bool result = nullptr != trd && nullptr != file && TRD_AddFile(trd, file, start, length, autostart, replace, false);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+static bool lua_zx_save_snapshot_sna(const char* fname, word start) {
+        int positionsAdded = addLuaSourcePositions();   // add known script positions to sourcePosStack vector
+        bool result = SaveSNA_ZX(fname, start);
+        removeLuaSourcePositions(positionsAdded);
+        return result;
+}
+static void lua_impl_init() {
+        assert(nullptr == LUA);
+        scripts_origin.reserve(64);
+        // initialise Lua (regular Lua, without sjasmplus bindings/extensions)
+        LUA = luaL_newstate();
+        lua_atpanic(LUA, (lua_CFunction)lua_impl_fatalError);
+        // for manual testing of lua_atpanic handler
+//      { lua_error(LUA); }
+//      { lua_pushstring(LUA, "testing at panic handler"); lua_error(LUA); }
+        luaL_openlibs(LUA);
+        // initialise sjasmplus bindings/extensions
+        luabridge::getGlobalNamespace(LUA)
+                .addFunction("_c", lua_sj_calc)
+                .addFunction("_pl", lua_sj_parse_line)
+                .addFunction("_pc", lua_sj_parse_code)
+                .beginNamespace("sj")
+                        .addProperty("current_address", &CurAddress, false)     // read-only
+                        .addProperty("warning_count", &WarningCount, false)     // read-only
+                        .addProperty("error_count", &ErrorCount, false) // read-only
+                        // internal functions which are lua-wrapped to enable optional arguments
+                        .addFunction("error_i", lua_sj_error)
+                        .addFunction("warning_i", lua_sj_warning)
+                        .addFunction("insert_define_i", lua_sj_insert_define)
+                        .addFunction("exit_i", ExitASM)
+                        .addFunction("set_device_i", lua_sj_set_device)
+                        // remaining public functions with all arguments mandatory (boolean args seems to default to false?)
+                        .addFunction("get_define", lua_sj_get_define)
+                        .addFunction("get_label", lua_sj_get_label)
+                        .addFunction("insert_label", lua_sj_insert_label)
+                        .addFunction("shellexec", lua_sj_shellexec)
+                        .addFunction("calc", lua_sj_calc)
+                        .addFunction("parse_line", lua_sj_parse_line)
+                        .addFunction("parse_code", lua_sj_parse_code)
+                        .addFunction("add_byte", lua_sj_add_byte)
+                        .addFunction("add_word", lua_sj_add_word)
+                        .addFunction("get_byte", lua_sj_get_byte)
+                        .addFunction("get_word", lua_sj_get_word)
+                        .addFunction("get_device", GetDeviceName)               // no error/warning, can be called directly
+                        .addFunction("set_page", lua_sj_set_page)
+                        .addFunction("set_slot", lua_sj_set_slot)
+                        // MMU API will be not added, it is too dynamic, and _pc("MMU ...") works
+                        .addFunction("file_exists", FileExists)
+                .endNamespace()
+                .beginNamespace("zx")
+                        .addFunction("trdimage_create_i", lua_zx_trdimage_create)
+                        .addFunction("trdimage_add_file_i", lua_zx_trdimage_add_file)
+                        .addFunction("save_snapshot_sna", lua_zx_save_snapshot_sna)
+                .endNamespace();
+                TextFilePos binding_script_pos(binding_script_name, binding_script_line);
+                if (luaL_loadbuffer(LUA, lua_impl_init_bindings_script.c_str(), lua_impl_init_bindings_script.size(), lua_impl_get_script_name(binding_script_pos))
+                        || lua_pcall(LUA, 0, LUA_MULTRET, 0)) {
+                        lua_impl_showLoadError(FATAL);                          // unreachable (I hope) // manual testing: damage binding script
+                }
+}
+void dirENDLUA() {
+        Error("[ENDLUA] End of lua script without script");
+}
+void dirLUA() {
+        // lazy init of Lua scripting upon first hit of LUA directive
+        if (nullptr == LUA) lua_impl_init();
+        assert(LUA);
+        constexpr size_t luaBufferSize = 32768;
+        char* id, * buff = nullptr, * bp = nullptr;
+        int passToExec = LASTPASS;
+        if ((id = GetID(lp)) && strlen(id) > 0) {
+                if (cmphstr(id, "pass1")) {
+                        passToExec = 1;
+                } else if (cmphstr(id, "pass2")) {
+                        passToExec = 2;
+                } else if (cmphstr(id, "pass3")) {
+                        passToExec = LASTPASS;
+                } else if (cmphstr(id, "allpass")) {
+                        passToExec = -1;
+                } else {
+                        Error("[LUA] Syntax error", id);
+                }
+        }
+        const EStatus errorType = (1 == passToExec || 2 == passToExec) ? EARLY : PASS3;
+        const bool execute = (-1 == passToExec) || (passToExec == pass);
+        // remember warning suppression also from block start
+        bool showWarning = !suppressedById(W_LUA_MC_PASS);
+        assert(!sourcePosStack.empty());
+        TextFilePos luaStartPos = sourcePosStack.back();        // position of LUA directive (not ENDLUA)
+        if (execute) {
+                buff = new char[luaBufferSize];
+                bp = buff;
+        }
+        ListFile();
+        while (1) {
+                if (!ReadLine(false)) {
+                        Error("[LUA] Unexpected end of lua script");
+                        break;
+                }
+                lp = line;
+                SkipBlanks(lp);
+                const int isEndLua = cmphstr(lp, "endlua");
+                const size_t lineLen = isEndLua ? (lp - 6 - line) : strlen(line);
+                if (execute) {
+                        if (luaBufferSize < (bp - buff) + lineLen + 4) {
+                                ErrorInt("[LUA] Maximum byte-size of Lua script is", luaBufferSize-4, FATAL);
+                        }
+                        memcpy(bp, line, lineLen);
+                        bp += lineLen;
+                        *bp++ = '\n';
+                }
+                if (isEndLua) {         // eat also any trailing eol-type of comment
+                        skipEmitMessagePos = sourcePosStack.back();
+                        ++CompiledCurrentLine;
+                        lp = ReplaceDefine(lp);         // skip any empty substitutions and comments
+                        substitutedLine = line;         // override substituted listing for ENDLUA
+                        // take into account also warning suppression used at end of block
+                        showWarning = showWarning && !suppressedById(W_LUA_MC_PASS);
+                        break;
+                }
+                ListFile(true);
+        }
+        if (execute) {
+                extraErrorWarningPrefix = lua_err_prefix;
+                *bp = 0;
+                DidEmitByte();                  // reset the flag before running lua script
+                if (luaL_loadbuffer(LUA, buff, bp-buff, lua_impl_get_script_name(luaStartPos)) || lua_pcall(LUA, 0, LUA_MULTRET, 0)) {
+                        lua_impl_showLoadError(errorType);
+                }
+                extraErrorWarningPrefix = nullptr;
+                delete[] buff;
+                if (DidEmitByte() && (-1 != passToExec) && showWarning) {
+                        const EWStatus warningType = (1 == passToExec || 2 == passToExec) ? W_EARLY : W_PASS3;
+                        WarningById(W_LUA_MC_PASS, nullptr, warningType);
+                }
+        }
+        ++CompiledCurrentLine;
+        substitutedLine = line;         // override substituted list line for ENDLUA
+}
+void dirINCLUDELUA() {
+        // lazy init of Lua scripting upon first hit of INCLUDELUA directive
+        if (nullptr == LUA) lua_impl_init();
+        assert(LUA);
+        if (1 != pass) {
+                SkipToEol(lp);          // skip till EOL (colon), to avoid parsing file name
+                return;
+        }
+        std::unique_ptr<char[]> fnaam(GetFileName(lp));
+        EDelimiterType dt = GetDelimiterOfLastFileName();
+        char* fullpath = GetPath(fnaam.get(), NULL, DT_ANGLE == dt);
+        if (!fullpath[0]) {
+                Error("[INCLUDELUA] File doesn't exist", fnaam.get(), EARLY);
+        } else {
+                extraErrorWarningPrefix = lua_err_prefix;
+                fileNameFull = ArchiveFilename(fullpath);       // get const pointer into archive
+                if (luaL_dofile(LUA, fileNameFull)) {
+                        lua_impl_showLoadError(EARLY);
+                }
+                extraErrorWarningPrefix = nullptr;
+        }
+        free(fullpath);
+}
+#endif //USE_LUA
+////////////////////////////////////////////////////////////////////////////////////////////
+// close LUA engine and release everything related
+void lua_impl_close() {
+        #ifdef USE_LUA
+                // if Lua was used and initialised, release everything
+                if (LUA) lua_close(LUA);
+        #endif //USE_LUA
+        // do nothing when Lua is compile-time disabled
+}
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'add_word'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaCalculate */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_calc00
-static int tolua_sjasm_sj_calc00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* str = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   lua_Number tolua_ret = LuaCalculate(str);
-   tolua_pushnumber(tolua_S, tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'calc'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaParseLine */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_parse_line00
-static int tolua_sjasm_sj_parse_line00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* str = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   LuaParseLine(str);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'parse_line'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaParseCode */
-#ifndef TOLUA_DISABLE_tolua_sjasm_sj_parse_code00
-static int tolua_sjasm_sj_parse_code00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* str = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   LuaParseCode(str);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'parse_code'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaCalculate */
-#ifndef TOLUA_DISABLE_tolua_sjasm__c00
-static int tolua_sjasm__c00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* str = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   lua_Number tolua_ret = LuaCalculate(str);
-   tolua_pushnumber(tolua_S, tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function '_c'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaParseLine */
-#ifndef TOLUA_DISABLE_tolua_sjasm__pl00
-static int tolua_sjasm__pl00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* str = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   LuaParseLine(str);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function '_pl'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* function: LuaParseCode */
-#ifndef TOLUA_DISABLE_tolua_sjasm__pc00
-static int tolua_sjasm__pc00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  char* str = ((char*)  tolua_tostring(tolua_S,1,0));
-  {
-   LuaParseCode(str);
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function '_pc'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-/* Open function */
-TOLUA_API int tolua_sjasm_open (lua_State* tolua_S)
-{
- tolua_open(tolua_S);
- tolua_reg_types(tolua_S);
- tolua_module(tolua_S,NULL,0);
- tolua_beginmodule(tolua_S,NULL);
-  tolua_module(tolua_S,"sj",0);
-  tolua_beginmodule(tolua_S,"sj");
-   tolua_function(tolua_S,"get_define",tolua_sjasm_sj_get_define00);
-   tolua_function(tolua_S,"insert_define",tolua_sjasm_sj_insert_define00);
-   tolua_function(tolua_S,"get_label",tolua_sjasm_sj_get_label00);
-   tolua_function(tolua_S,"insert_label",tolua_sjasm_sj_insert_label00);
-  tolua_endmodule(tolua_S);
-  tolua_module(tolua_S,"sj",1);
-  tolua_beginmodule(tolua_S,"sj");
-   tolua_variable(tolua_S,"current_address",tolua_get_sj_unsigned_current_address,NULL);
-   tolua_variable(tolua_S,"warning_count",tolua_get_sj_warning_count,NULL);
-   tolua_variable(tolua_S,"error_count",tolua_get_sj_error_count,NULL);
-   tolua_function(tolua_S,"shellexec",tolua_sjasm_sj_shellexec00);
-  tolua_endmodule(tolua_S);
-  tolua_module(tolua_S,"zx",0);
-  tolua_beginmodule(tolua_S,"zx");
-   tolua_function(tolua_S,"trdimage_create",tolua_sjasm_zx_trdimage_create00);
-   tolua_function(tolua_S,"trdimage_add_file",tolua_sjasm_zx_trdimage_add_file00);
-   tolua_function(tolua_S,"save_snapshot_sna128",tolua_sjasm_zx_save_snapshot_sna12800);
-  tolua_endmodule(tolua_S);
-  tolua_module(tolua_S,"sj",1);
-  tolua_beginmodule(tolua_S,"sj");
-   tolua_variable(tolua_S,"current_path",tolua_get_sj_current_path,NULL);
-   tolua_function(tolua_S,"exit",tolua_sjasm_sj_exit00);
-  tolua_endmodule(tolua_S);
-  tolua_module(tolua_S,"sj",0);
-  tolua_beginmodule(tolua_S,"sj");
-   tolua_function(tolua_S,"error",tolua_sjasm_sj_error00);
-   tolua_function(tolua_S,"warning",tolua_sjasm_sj_warning00);
-   tolua_function(tolua_S,"file_exists",tolua_sjasm_sj_file_exists00);
-   tolua_function(tolua_S,"get_path",tolua_sjasm_sj_get_path00);
-   tolua_function(tolua_S,"set_device",tolua_sjasm_sj_set_device00);
-   tolua_function(tolua_S,"get_device",tolua_sjasm_sj_get_device00);
-   tolua_function(tolua_S,"set_page",tolua_sjasm_sj_set_page00);
-   tolua_function(tolua_S,"set_slot",tolua_sjasm_sj_set_slot00);
-   tolua_function(tolua_S,"get_byte",tolua_sjasm_sj_get_byte00);
-   tolua_function(tolua_S,"get_word",tolua_sjasm_sj_get_word00);
-   tolua_function(tolua_S,"add_byte",tolua_sjasm_sj_add_byte00);
-   tolua_function(tolua_S,"add_word",tolua_sjasm_sj_add_word00);
-   tolua_function(tolua_S,"calc",tolua_sjasm_sj_calc00);
-   tolua_function(tolua_S,"parse_line",tolua_sjasm_sj_parse_line00);
-   tolua_function(tolua_S,"parse_code",tolua_sjasm_sj_parse_code00);
-  tolua_endmodule(tolua_S);
-  tolua_function(tolua_S,"_c",tolua_sjasm__c00);
-  tolua_function(tolua_S,"_pl",tolua_sjasm__pl00);
-  tolua_function(tolua_S,"_pc",tolua_sjasm__pc00);
-  { /* begin embedded lua code */"tolua: embedded Lua code 1");
-   lua_settop(tolua_S, top);
-  } /* end of embedded lua code */
-  { /* begin embedded lua code */
-   int top = lua_gettop(tolua_S);
-   static unsigned char B[] = {
-, 72,101,120, 32,118, 48, 46, 51, 10, 72,101,120, 32, 99,
-,110,118,101,114,115,105,111,110, 32,108,105, 98, 32,102,
-,114, 32,108,117, 97, 46, 10, 80, 97,114,116, 32,111,102,
-, 76,117, 97, 66,105,116, 40,104,116,116,112, 58, 47, 47,
-,117, 97,102,111,114,103,101, 46,110,101,116, 47,112,114,
-,106,101, 99,116,115, 47, 98,105,116, 47, 41, 46, 10, 85,
-,100,101,114, 32,116,104,101, 32, 77, 73, 84, 32,108,105,
-,101,110,115,101, 46, 10, 99,111,112,121,114,105,103,104,
-, 40, 99, 41, 32, 50, 48, 48, 54, 32,104, 97,110,122,104,
-,111, 32, 40, 97, 98,114, 97,115,104, 95,104, 97,110, 64,
-,111,116,109, 97,105,108, 46, 99,111,109, 41, 10,100,111,
-,108,111, 99, 97,108, 32,102,117,110, 99,116,105,111,110,
-,116,111, 95,104,101,120, 40,110, 41, 10,105,102, 40,116,
-,112,101, 40,110, 41, 32,126, 61, 32, 34,110,117,109, 98,
-,114, 34, 41, 32,116,104,101,110, 10,101,114,114,111,114,
-, 34,110,111,110, 45,110,117,109, 98,101,114, 32,116,121,
-,101, 32,112, 97,115,115,101,100, 32,105,110, 46, 34, 41,
-,101,110,100, 10,105,102, 40,110, 32, 45, 32,109, 97,116,
-, 46,102,108,111,111,114, 40,110, 41, 32, 62, 32, 48, 41,
-,116,104,101,110, 10,101,114,114,111,114, 40, 34,116,114,
-,105,110,103, 32,116,111, 32, 97,112,112,108,121, 32, 98,
-,116,119,105,115,101, 32,111,112,101,114, 97,116,105,111,
-, 32,111,110, 32,110,111,110, 45,105,110,116,101,103,101,
-, 33, 34, 41, 10,101,110,100, 10,105,102, 40,110, 32, 60,
-, 48, 41, 32,116,104,101,110, 10,110, 32, 61, 32, 98,105,
-, 46,116,111, 98,105,116,115, 40, 98,105,116, 46, 98,110,
-,116, 40,109, 97,116,104, 46, 97, 98,115, 40,110, 41, 41,
-, 43, 32, 49, 41, 10,110, 32, 61, 32, 98,105,116, 46,116,
-,110,117,109, 98, 40,110, 41, 10,101,110,100, 10,104,101,
-, 95,116, 98,108, 32, 61, 32,123, 39, 65, 39, 44, 32, 39,
-, 39, 44, 32, 39, 67, 39, 44, 32, 39, 68, 39, 44, 32, 39,
-, 39, 44, 32, 39, 70, 39,125, 10,104,101,120, 95,115,116,
-, 32, 61, 32, 34, 34, 10,119,104,105,108,101, 40,110, 32,
-, 61, 32, 48, 41, 32,100,111, 10,108, 97,115,116, 32, 61,
-,109, 97,116,104, 46,109,111,100, 40,110, 44, 32, 49, 54,
-, 10,105,102, 40,108, 97,115,116, 32, 60, 32, 49, 48, 41,
-,116,104,101,110, 10,104,101,120, 95,115,116,114, 32, 61,
-,116,111,115,116,114,105,110,103, 40,108, 97,115,116, 41,
-, 46, 46, 32,104,101,120, 95,115,116,114, 10,101,108,115,
-, 10,104,101,120, 95,115,116,114, 32, 61, 32,104,101,120,
-,116, 98,108, 91,108, 97,115,116, 45, 49, 48, 43, 49, 93,
-, 46, 46, 32,104,101,120, 95,115,116,114, 10,101,110,100,
-,110, 32, 61, 32,109, 97,116,104, 46,102,108,111,111,114,
-,110, 47, 49, 54, 41, 10,101,110,100, 10,105,102, 40,104,
-,120, 95,115,116,114, 32, 61, 61, 32, 34, 34, 41, 32,116,
-,101,110, 10,104,101,120, 95,115,116,114, 32, 61, 32, 34,
-, 34, 10,101,110,100, 10,114,101,116,117,114,110, 32, 34,
-,120, 34, 32, 46, 46, 32,104,101,120, 95,115,116,114, 10,
-,110,100, 10,108,111, 99, 97,108, 32,102,117,110, 99,116,
-,111,110, 32,116,111, 95,100,101, 99, 40,104,101,120, 41,
-,105,102, 40,116,121,112,101, 40,104,101,120, 41, 32,126,
-, 32, 34,115,116,114,105,110,103, 34, 41, 32,116,104,101,
-, 10,101,114,114,111,114, 40, 34,110,111,110, 45,115,116,
-,105,110,103, 32,116,121,112,101, 32,112, 97,115,115,101,
-, 32,105,110, 46, 34, 41, 10,101,110,100, 10,104,101, 97,
-, 32, 61, 32,115,116,114,105,110,103, 46,115,117, 98, 40,
-,101,120, 44, 32, 49, 44, 32, 50, 41, 10,105,102, 40, 32,
-,101, 97,100, 32,126, 61, 32, 34, 48,120, 34, 32, 97,110,
-, 32,104,101, 97,100, 32,126, 61, 32, 34, 48, 88, 34, 41,
-,116,104,101,110, 10,101,114,114,111,114, 40, 34,119,114,
-,110,103, 32,104,101,120, 32,102,111,114,109, 97,116, 44,
-,115,104,111,117,108,100, 32,108,101, 97,100, 32, 98,121,
-, 48,120, 32,111,114, 32, 48, 88, 46, 34, 41, 10,101,110,
-, 10,118, 32, 61, 32,116,111,110,117,109, 98,101,114, 40,
-,116,114,105,110,103, 46,115,117, 98, 40,104,101,120, 44,
-, 51, 41, 44, 32, 49, 54, 41, 10,114,101,116,117,114,110,
-,118, 59, 10,101,110,100, 10,104,101,120, 32, 61, 32,123,
-,116,111, 95,100,101, 99, 32, 61, 32,116,111, 95,100,101,
-, 44, 10,116,111, 95,104,101,120, 32, 61, 32,116,111, 95,
-,101,120, 44, 10,125, 10,101,110,100, 10,100, 32, 61, 32,
-, 51, 52, 49, 54, 56, 56, 10,104, 32, 61, 32,116,111, 95,
-,101,120, 40,100, 41, 10,112,114,105,110,116, 40,104, 41,
-,112,114,105,110,116, 40,116,111, 95,100,101, 99, 40,104,
-, 41, 10,102,111,114, 32,105, 32, 61, 32, 49, 44, 32, 49,
-, 48, 48, 48, 48, 32,100,111, 10,104, 32, 61, 32,104,101,
-, 46,116,111, 95,104,101,120, 40,105, 41, 10,100, 32, 61,
-,104,101,120, 46,116,111, 95,100,101, 99, 40,104, 41, 10,
-,102, 40,100, 32,126, 61, 32,105, 41, 32,116,104,101,110,
-,101,114,114,111,114, 40, 34,102, 97,105,108,101,100, 32,
-, 32, 46, 46, 32,105, 32, 46, 46, 32, 34, 44, 32, 34, 32,
-, 46, 32,104, 41, 10,101,110,100, 10,101,110,100, 10,32
-   };
-   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 2");
-   lua_settop(tolua_S, top);
-  } /* end of embedded lua code */
- tolua_endmodule(tolua_S);
- return 1;
-}
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
- TOLUA_API int luaopen_sjasm (lua_State* tolua_S) {
- return tolua_sjasm_open(tolua_S);
-}
-#endif
+//eof lua_sjasm.cpp

Subversion Repositories NedoOS

(root)/tools/src/sjasmplus/sjasm/lua_sjasm.cpp – Rev 539 → 1537