extend macro feature to support compiling Moonscript to other Lua dialect like teal.

add examples for how to write MoonPlus codes that compile to teal.
fix C++ macro to build without MoonPlus macro feature or built-in Lua.
add support for passing arguments from command line to compiler that can be accessed or altered by "require('moonp').options".

1 files changed, 160 insertions, 38 deletions

diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index debc43a..f24441f 100644
--- a/src/MoonP/moon_compiler.cpp
+++ b/src/MoonP/moon_compiler.cpp
@@ -53,7 +53,7 @@ inline std::string s(std::string_view sv) {
         return std::string(sv);
 }
 
-const std::string_view version = "0.4.18"sv;
+const std::string_view version = "0.4.19"sv;
 const std::string_view extension = "mp"sv;
 
 class MoonCompilerImpl {
@@ -89,10 +89,17 @@ public:
         }
 #endif // MOONP_NO_MACRO
 
-        std::tuple<std::string,std::string,GlobalVars> compile(std::string_view codes, const MoonConfig& config) {
+        CompileInfo compile(std::string_view codes, const MoonConfig& config) {
                 _config = config;
+#ifndef MOONP_NO_MACRO
+                if (L) passOptions();
+#endif // MOONP_NO_MACRO
                 _info = _parser.parse<File_t>(codes);
-                GlobalVars globals;
+                std::unique_ptr<GlobalVars> globals;
+                std::unique_ptr<Options> options;
+                if (!config.options.empty()) {
+                        options = std::make_unique<Options>(config.options);
+                }
                 DEFER(clear());
                 if (_info.node) {
                         try {
@@ -104,19 +111,39 @@ public:
                                         nullptr, true);
                                 popScope();
                                 if (config.lintGlobalVariable) {
-                                        globals = std::make_unique<std::list<GlobalVar>>();
+                                        globals = std::make_unique<GlobalVars>();
                                         for (const auto& var : _globals) {
                                                 int line,col;
                                                 std::tie(line,col) = var.second;
                                                 globals->push_back({var.first, line, col});
                                         }
                                 }
-                                return {std::move(out.back()), Empty, std::move(globals)};
+#ifndef MOONP_NO_MACRO
+                                if (L) {
+                                        int top = lua_gettop(L);
+                                        DEFER(lua_settop(L, top));
+                                        if (!options) {
+                                                options = std::make_unique<Options>();
+                                        }
+                                        pushMoonp("options"sv);
+                                        lua_pushnil(L); // options startKey
+                                        while (lua_next(L, -2) != 0) { // options key value
+                                                size_t len = 0;
+                                                auto pstr = lua_tolstring(L, -2, &len);
+                                                std::string key{pstr, len};
+                                                pstr = lua_tolstring(L, -1, &len);
+                                                std::string value{pstr, len};
+                                                (*options)[key] = value;
+                                                lua_pop(L, 1); // options key
+                                        }
+                                }
+#endif // MOONP_NO_MACRO
+                                return {std::move(out.back()), Empty, std::move(globals), std::move(options)};
                         } catch (const std::logic_error& error) {
-                                return {Empty, error.what(), std::move(globals)};
+                                return {Empty, error.what(), std::move(globals), std::move(options)};
                         }
                 } else {
-                        return {Empty, std::move(_info.error), std::move(globals)};
+                        return {Empty, std::move(_info.error), std::move(globals), std::move(options)};
                 }
         }
 
@@ -2150,6 +2177,17 @@ private:
         }
 
 #ifndef MOONP_NO_MACRO
+        void passOptions() {
+                if (!_config.options.empty()) {
+                        pushMoonp("options"sv); // options
+                        for (const auto& option : _config.options) {
+                                lua_pushlstring(L, option.second.c_str(), option.second.size());
+                                lua_setfield(L, -2, option.first.c_str());
+                        }
+                        lua_pop(L, 1);
+                }
+        }
+
         void pushCurrentModule() {
                 if (_useModule) {
                         lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
@@ -2165,6 +2203,7 @@ private:
                         if (_luaOpen) {
                                 _luaOpen(static_cast<void*>(L));
                         }
+                        passOptions();
                         _stateOwner = true;
                 }
                 lua_pushliteral(L, MOONP_MODULE); // MOONP_MODULE
@@ -2314,7 +2353,7 @@ private:
                 out.push_back(Empty);
         }
 #else
-        void transformMacro(Macro_t* macro, str_list& out, bool exporting) {
+        void transformMacro(Macro_t* macro, str_list&, bool) {
                 throw std::logic_error(_info.errorMessage("macro feature not supported"sv, macro));
         }
 #endif // MOONP_NO_MACRO
@@ -3023,16 +3062,67 @@ private:
         }
 
 #ifndef MOONP_NO_MACRO
-        std::pair<std::string,std::string> expandMacroStr(ChainValue_t* chainValue) {
+        std::tuple<std::string,std::string,str_list> expandMacroStr(ChainValue_t* chainValue) {
                 const auto& chainList = chainValue->items.objects();
                 auto x = ast_to<Callable_t>(chainList.front())->item.to<MacroName_t>();
-                auto macroName = _parser.toString(x->name);
-                if (!_useModule) {
+                auto macroName = x->name ? _parser.toString(x->name) : Empty;
+                if (!macroName.empty() && !_useModule) {
                         throw std::logic_error(_info.errorMessage("can not resolve macro"sv, x));
                 }
                 pushCurrentModule(); // cur
                 int top = lua_gettop(L) - 1;
                 DEFER(lua_settop(L, top));
+                if (macroName.empty()) {
+                        lua_pop(L, 1); // empty
+                        auto item = *(++chainList.begin());
+                        const node_container* args = nullptr;
+                        if (auto invoke = ast_cast<Invoke_t>(item)) {
+                                args = &invoke->args.objects();
+                        } else {
+                                args = &ast_to<InvokeArgs_t>(item)->args.objects();
+                        }
+                        if (args->size() != 1) {
+                                throw std::logic_error(_info.errorMessage("in-place macro must be followed by a compile time function"sv, x));
+                        }
+                        auto fcodes = _parser.toString(args->back());
+                        Utils::trim(fcodes);
+                        pushMoonp("loadstring"sv); // loadstring
+                        lua_pushlstring(L, fcodes.c_str(), fcodes.size()); // loadstring codes
+                        lua_pushliteral(L, "=(macro in-place)"); // loadstring codes chunk
+                        pushOptions(args->back()->m_begin.m_line - 1); // loadstring codes chunk options
+                        if (lua_pcall(L, 3, 2, 0) != 0) { // loadstring(codes,chunk,options), f err
+                                std::string err = lua_tostring(L, -1);
+                                throw std::logic_error(_info.errorMessage(s("fail to load macro codes\n"sv) + err, x));
+                        } // f err
+                        if (lua_isnil(L, -2) != 0) { // f == nil, f err
+                                std::string err = lua_tostring(L, -1);
+                                throw std::logic_error(_info.errorMessage(s("fail to load macro codes, at (macro in-place): "sv) + err, x));
+                        }
+                        lua_pop(L, 1); // f
+                        pushMoonp("pcall"sv); // f pcall
+                        lua_insert(L, -2); // pcall f
+                        if (lua_pcall(L, 1, 2, 0) != 0) { // f(), success macroFunc
+                                std::string err = lua_tostring(L, -1);
+                                throw std::logic_error(_info.errorMessage(s("fail to generate macro function\n"sv) + err, x));
+                        } // success res
+                        if (lua_toboolean(L, -2) == 0) {
+                                std::string err = lua_tostring(L, -1);
+                                throw std::logic_error(_info.errorMessage(s("fail to generate macro function\n"sv) + err, x));
+                        } // true macroFunc
+                        lua_remove(L, -2); // macroFunc
+                        pushMoonp("pcall"sv); // macroFunc pcall
+                        lua_insert(L, -2); // pcall macroFunc
+                        bool success = lua_pcall(L, 1, 2, 0) == 0;
+                        if (!success) { // err
+                                std::string err = lua_tostring(L, -1);
+                                throw std::logic_error(_info.errorMessage(s("fail to expand macro: "sv) + err, x));
+                        } // success err
+                        if (lua_toboolean(L, -2) == 0) {
+                                std::string err = lua_tostring(L, -1);
+                                throw std::logic_error(_info.errorMessage(s("fail to expand macro: "sv) + err, x));
+                        }
+                        return {s("block"sv), Empty, {}};
+                }
                 lua_pushlstring(L, macroName.c_str(), macroName.size()); // cur macroName
                 lua_rawget(L, -2); // cur[macroName], cur macro
                 if (lua_istable(L, -1) == 0) {
@@ -3060,9 +3150,7 @@ private:
                                 BREAK_IF(!chainValue);
                                 BREAK_IF(!isMacroChain(chainValue));
                                 BREAK_IF(chainValue->items.size() != 2);
-                                std::string type, codes;
-                                std::tie(type, codes) = expandMacroStr(chainValue);
-                                str = codes;
+                                str = std::get<1>(expandMacroStr(chainValue));
                                 BLOCK_END
                                 if (str.empty()) {
                                         // exp is reassembled due to backcall expressions
@@ -3092,30 +3180,55 @@ private:
                         Utils::replace(str, "\r\n"sv, "\n"sv);
                         lua_pushlstring(L, str.c_str(), str.size());
                 } // cur macro pcall func args...
-                bool success = lua_pcall(L, static_cast<int>(args->size()) + 1, 2, 0) == 0;
+                bool success = lua_pcall(L, static_cast<int>(args->size()) + 1, 3, 0) == 0;
                 if (!success) { // cur macro err
                         std::string err = lua_tostring(L, -1);
                         throw std::logic_error(_info.errorMessage(s("fail to expand macro: "sv) + err, x));
-                } // cur macro success res
-                if (lua_toboolean(L, -2) == 0) {
-                        std::string err = lua_tostring(L, -1);
+                } // cur macro success res option
+                if (lua_toboolean(L, -3) == 0) {
+                        std::string err = lua_tostring(L, -2);
                         throw std::logic_error(_info.errorMessage(s("fail to expand macro: "sv) + err, x));
                 }
-                lua_remove(L, -2); // cur macro res
-                if (lua_isstring(L, -1) == 0) {
+                lua_remove(L, -3); // cur macro res option
+                if (lua_isstring(L, -2) == 0) {
                         throw std::logic_error(_info.errorMessage(s("macro function must return string with expanded codes"sv), x));
-                } // cur macro codes
-                lua_rawgeti(L, -2, 2); // cur macro codes type
+                } // cur macro codes option
+                lua_rawgeti(L, -3, 2); // cur macro codes option type
                 std::string type = lua_tostring(L, -1);
+                lua_pop(L, 1); // cur macro codes option
+                str_list localVars;
+                if (lua_isnil(L, -1) == 0) {
+                        if (lua_istable(L, -1) == 0) {
+                                throw std::logic_error(_info.errorMessage(s("macro function must return expanded codes followed by a config table"sv), x));
+                        }
+                        if (type == "expr"sv || type == "block"sv) {
+                                throw std::logic_error(_info.errorMessage(s("expr or block macro is not accepting config table"sv), x));
+                        }
+                        for (int i = 0; i < static_cast<int>(lua_objlen(L, -1)); i++) {
+                                lua_rawgeti(L, -1, i + 1); // cur macro codes option item
+                                size_t len = 0;
+                                if (lua_isstring(L, -1) == 0) {
+                                        throw std::logic_error(_info.errorMessage(s("macro config table must contains strings"sv), x));
+                                }
+                                auto name = lua_tolstring(L, -1, &len);
+                                if (_parser.match<Variable_t>({name, len})) {
+                                        localVars.push_back(std::string(name, len));
+                                } else {
+                                        throw std::logic_error(_info.errorMessage(s("macro config table must contains names for local variables, got \""sv) + std::string(name, len) + '"', x));
+                                }
+                                lua_pop(L, 1);
+                        }
+                } // cur macro codes option
                 std::string codes = lua_tostring(L, -2);
-                return {type, codes};
+                return {type, codes, std::move(localVars)};
         }
 
-        std::tuple<ast_ptr<false,ast_node>, std::unique_ptr<input>, std::string> expandMacro(ChainValue_t* chainValue, ExpUsage usage, bool allowBlockMacroReturn) {
+        std::tuple<ast_ptr<false,ast_node>, std::unique_ptr<input>, std::string, str_list> expandMacro(ChainValue_t* chainValue, ExpUsage usage, bool allowBlockMacroReturn) {
                 auto x = ast_to<Callable_t>(chainValue->items.front())->item.to<MacroName_t>();
                 const auto& chainList = chainValue->items.objects();
                 std::string type, codes;
-                std::tie(type, codes) = expandMacroStr(chainValue);
+                str_list localVars;
+                std::tie(type, codes, localVars) = expandMacroStr(chainValue);
                 std::string targetType(usage != ExpUsage::Common || chainList.size() > 2 ? "expr"sv : "block"sv);
                 if (type == "lua"sv) {
                         if (!allowBlockMacroReturn && targetType != "block"sv) {
@@ -3128,19 +3241,19 @@ private:
                                 std::string err = lua_tostring(L, -1);
                                 throw std::logic_error(_info.errorMessage(err, x));
                         }
-                        return {nullptr, nullptr, std::move(codes)};
+                        return {nullptr, nullptr, std::move(codes), std::move(localVars)};
                 } else if (type == "text"sv) {
                         if (!allowBlockMacroReturn && targetType != "block"sv) {
                                 throw std::logic_error(_info.errorMessage("text macro can only be placed where block macro is allowed"sv, x));
                         }
-                        return {nullptr, nullptr, std::move(codes)};
+                        return {nullptr, nullptr, std::move(codes), std::move(localVars)};
                 } else if (!allowBlockMacroReturn && type != targetType) {
                         throw std::logic_error(_info.errorMessage(s("macro type mismatch, "sv) + targetType + s(" expected, got "sv) + type, x));
                 }
                 ParseInfo info;
                 if (usage == ExpUsage::Common) {
                         if (codes.empty()) {
-                                return {x->new_ptr<Block_t>().get(), std::move(info.codes), Empty};
+                                return {x->new_ptr<Block_t>().get(), std::move(info.codes), Empty, std::move(localVars)};
                         }
                         if (type == "expr"sv) {
                                 info = _parser.parse<Exp_t>(codes);
@@ -3202,7 +3315,7 @@ private:
                                 info.node.set(exp);
                         }
                 }
-                return {info.node, std::move(info.codes), Empty};
+                return {info.node, std::move(info.codes), Empty, std::move(localVars)};
         }
 #endif // MOONP_NO_MACRO
 
@@ -3212,10 +3325,11 @@ private:
                         ast_ptr<false,ast_node> node;
                         std::unique_ptr<input> codes;
                         std::string luaCodes;
-                        std::tie(node, codes, luaCodes) = expandMacro(chainValue, usage, allowBlockMacroReturn);
+                        str_list localVars;
+                        std::tie(node, codes, luaCodes, localVars) = expandMacro(chainValue, usage, allowBlockMacroReturn);
                         Utils::replace(luaCodes, "\r\n"sv, "\n"sv);
                         Utils::trim(luaCodes);
-                        if (!node && !codes) {
+                        if (!node) {
                                 if (!luaCodes.empty()) {
                                         if (_config.reserveLineNumber) {
                                                 luaCodes.insert(0, nll(chainValue).substr(1));
@@ -3223,6 +3337,11 @@ private:
                                         luaCodes.append(nlr(chainValue));
                                 }
                                 out.push_back(luaCodes);
+                                if (!localVars.empty()) {
+                                        for (const auto& var : localVars) {
+                                                addToScope(var);
+                                        }
+                                }
                                 return;
                         }
                         if (usage == ExpUsage::Common || (usage == ExpUsage::Return && node.is<Block_t>())) {
@@ -3254,6 +3373,7 @@ private:
                         }
                         return;
 #else
+                        (void)allowBlockMacroReturn;
                         throw std::logic_error(_info.errorMessage("macro feature not supported"sv, chainValue));
 #endif // MOONP_NO_MACRO
                 }
@@ -4983,11 +5103,9 @@ private:
                                         config.lintGlobalVariable = false;
                                         config.reserveLineNumber = false;
                                         config.implicitReturnRoot = _config.implicitReturnRoot;
-                                        std::string codes, err;
-                                        GlobalVars globals;
-                                        std::tie(codes, err, globals) = compiler.compile(text, config);
-                                        if (codes.empty() && !err.empty()) {
-                                                throw std::logic_error(_info.errorMessage(s("fail to compile module '"sv) + moduleName + s("\': "sv) + err, x));
+                                        auto result = compiler.compile(text, config);
+                                        if (result.codes.empty() && !result.error.empty()) {
+                                                throw std::logic_error(_info.errorMessage(s("fail to compile module '"sv) + moduleName + s("\': "sv) + result.error, x));
                                         }
                                         lua_pop(L, 1); // cur
                                 }
@@ -5325,12 +5443,16 @@ MoonCompiler::MoonCompiler(void* sharedState,
 #ifndef MOONP_NO_MACRO
 _compiler(std::make_unique<MoonCompilerImpl>(static_cast<lua_State*>(sharedState), luaOpen, sameModule)) {}
 #else
-_compiler(std::make_unique<MoonCompilerImpl>()) {}
+_compiler(std::make_unique<MoonCompilerImpl>()) {
+        (void)sharedState;
+        (void)luaOpen;
+        (void)sameModule;
+}
 #endif // MOONP_NO_MACRO
 
 MoonCompiler::~MoonCompiler() {}
 
-std::tuple<std::string,std::string,GlobalVars> MoonCompiler::compile(std::string_view codes, const MoonConfig& config) {
+CompileInfo MoonCompiler::compile(std::string_view codes, const MoonConfig& config) {
         return _compiler->compile(codes, config);
 }