aboutsummaryrefslogtreecommitdiff
path: root/src/MoonP/moon_compiler.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/MoonP/moon_compiler.cpp245
1 files changed, 125 insertions, 120 deletions
diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index 4812cf4..d63b1c7 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) {
53 return std::string(sv); 53 return std::string(sv);
54} 54}
55 55
56const std::string_view version = "0.4.26"sv; 56const std::string_view version = "0.5.0"sv;
57const std::string_view extension = "mp"sv; 57const std::string_view extension = "mp"sv;
58 58
59class MoonCompilerImpl { 59class MoonCompilerImpl {
@@ -2290,7 +2290,6 @@ private:
2290 if (_scopes.size() > 1) { 2290 if (_scopes.size() > 1) {
2291 throw std::logic_error(_info.errorMessage("can not define macro outside the root block"sv, macro)); 2291 throw std::logic_error(_info.errorMessage("can not define macro outside the root block"sv, macro));
2292 } 2292 }
2293 auto type = _parser.toString(macro->type);
2294 auto macroName = _parser.toString(macro->name); 2293 auto macroName = _parser.toString(macro->name);
2295 auto argsDef = macro->macroLit->argsDef.get(); 2294 auto argsDef = macro->macroLit->argsDef.get();
2296 str_list newArgs; 2295 str_list newArgs;
@@ -2314,9 +2313,8 @@ private:
2314 newArgs.emplace_back(_parser.toString(argsDef->varArg)); 2313 newArgs.emplace_back(_parser.toString(argsDef->varArg));
2315 } 2314 }
2316 } 2315 }
2317 _buf << "fmacro = ("sv << join(newArgs, ","sv) << ")->"sv; 2316 _buf << "("sv << join(newArgs, ","sv) << ")->"sv;
2318 _buf << _parser.toString(macro->macroLit->body) << '\n'; 2317 _buf << _parser.toString(macro->macroLit->body);
2319 _buf << "{fmacro, \"" << type << "\"}"sv;
2320 auto macroCodes = clearBuf(); 2318 auto macroCodes = clearBuf();
2321 _buf << "=(macro "sv << macroName << ")"; 2319 _buf << "=(macro "sv << macroName << ")";
2322 auto chunkName = clearBuf(); 2320 auto chunkName = clearBuf();
@@ -3128,16 +3126,15 @@ private:
3128 std::string err = lua_tostring(L, -1); 3126 std::string err = lua_tostring(L, -1);
3129 throw std::logic_error(_info.errorMessage(s("failed to expand macro: "sv) + err, x)); 3127 throw std::logic_error(_info.errorMessage(s("failed to expand macro: "sv) + err, x));
3130 } 3128 }
3131 return {s("block"sv), Empty, {}}; 3129 return {Empty, Empty, {}};
3132 } 3130 }
3133 lua_pushlstring(L, macroName.c_str(), macroName.size()); // cur macroName 3131 lua_pushlstring(L, macroName.c_str(), macroName.size()); // cur macroName
3134 lua_rawget(L, -2); // cur[macroName], cur macro 3132 lua_rawget(L, -2); // cur[macroName], cur macroFunc
3135 if (lua_istable(L, -1) == 0) { 3133 if (lua_isfunction(L, -1) == 0) {
3136 throw std::logic_error(_info.errorMessage("can not resolve macro"sv, x)); 3134 throw std::logic_error(_info.errorMessage("can not resolve macro"sv, x));
3137 } 3135 } // cur macroFunc
3138 lua_rawgeti(L, -1, 1); // cur macro func 3136 pushMoonp("pcall"sv); // cur macroFunc pcall
3139 pushMoonp("pcall"sv); // cur macro func pcall 3137 lua_insert(L, -2); // cur pcall macroFunc
3140 lua_insert(L, -2); // cur macro pcall func
3141 auto item = *(++chainList.begin()); 3138 auto item = *(++chainList.begin());
3142 const node_container* args = nullptr; 3139 const node_container* args = nullptr;
3143 if (auto invoke = ast_cast<Invoke_t>(item)) { 3140 if (auto invoke = ast_cast<Invoke_t>(item)) {
@@ -3186,47 +3183,60 @@ private:
3186 Utils::trim(str); 3183 Utils::trim(str);
3187 Utils::replace(str, "\r\n"sv, "\n"sv); 3184 Utils::replace(str, "\r\n"sv, "\n"sv);
3188 lua_pushlstring(L, str.c_str(), str.size()); 3185 lua_pushlstring(L, str.c_str(), str.size());
3189 } // cur macro pcall func args... 3186 } // cur pcall macroFunc args...
3190 bool success = lua_pcall(L, static_cast<int>(args->size()) + 1, 3, 0) == 0; 3187 bool success = lua_pcall(L, static_cast<int>(args->size()) + 1, 2, 0) == 0;
3191 if (!success) { // cur macro err 3188 if (!success) { // cur err
3192 std::string err = lua_tostring(L, -1); 3189 std::string err = lua_tostring(L, -1);
3193 throw std::logic_error(_info.errorMessage(s("failed to expand macro: "sv) + err, x)); 3190 throw std::logic_error(_info.errorMessage(s("failed to expand macro: "sv) + err, x));
3194 } // cur macro success res option 3191 } // cur success res
3195 if (lua_toboolean(L, -3) == 0) { 3192 if (lua_toboolean(L, -2) == 0) {
3196 std::string err = lua_tostring(L, -2); 3193 std::string err = lua_tostring(L, -2);
3197 throw std::logic_error(_info.errorMessage(s("failed to expand macro: "sv) + err, x)); 3194 throw std::logic_error(_info.errorMessage(s("failed to expand macro: "sv) + err, x));
3198 } 3195 }
3199 lua_remove(L, -3); // cur macro res option 3196 lua_remove(L, -2); // cur res
3200 if (lua_isstring(L, -2) == 0) { 3197 if (lua_isstring(L, -1) == 0 && lua_istable(L, -1) == 0) {
3201 throw std::logic_error(_info.errorMessage(s("macro function must return string with expanded codes"sv), x)); 3198 throw std::logic_error(_info.errorMessage(s("macro function must return string or table"sv), x));
3202 } // cur macro codes option 3199 } // cur res
3203 lua_rawgeti(L, -3, 2); // cur macro codes option type 3200 std::string codes;
3204 std::string type = lua_tostring(L, -1); 3201 std::string type;
3205 lua_pop(L, 1); // cur macro codes option
3206 str_list localVars; 3202 str_list localVars;
3207 if (lua_isnil(L, -1) == 0) { 3203 if (lua_istable(L, -1) != 0) {
3208 if (lua_istable(L, -1) == 0) { 3204 lua_getfield(L, -1, "codes"); // cur res codes
3209 throw std::logic_error(_info.errorMessage(s("macro function must return expanded codes followed by a config table"sv), x)); 3205 if (lua_isstring(L, -1) != 0) {
3210 } 3206 codes = lua_tostring(L, -1);
3211 if (type == "expr"sv || type == "block"sv) { 3207 } else {
3212 throw std::logic_error(_info.errorMessage(s("expr or block macro is not accepting config table"sv), x)); 3208 throw std::logic_error(_info.errorMessage(s("macro table must contain field \"codes\" of string"sv), x));
3213 } 3209 }
3214 for (int i = 0; i < static_cast<int>(lua_objlen(L, -1)); i++) { 3210 lua_pop(L, 1); // cur res
3215 lua_rawgeti(L, -1, i + 1); // cur macro codes option item 3211 lua_getfield(L, -1, "type"); // cur res type
3216 size_t len = 0; 3212 if (lua_isstring(L, -1) != 0) {
3217 if (lua_isstring(L, -1) == 0) { 3213 type = lua_tostring(L, -1);
3218 throw std::logic_error(_info.errorMessage(s("macro config table must contains strings"sv), x)); 3214 }
3219 } 3215 if (type != "lua"sv && type != "text"sv) {
3220 auto name = lua_tolstring(L, -1, &len); 3216 throw std::logic_error(_info.errorMessage(s("macro table must contain field \"type\" of value \"lua\" or \"text\""sv), x));
3221 if (_parser.match<Variable_t>({name, len})) { 3217 }
3222 localVars.push_back(std::string(name, len)); 3218 lua_pop(L, 1); // cur res
3223 } else { 3219 lua_getfield(L, -1, "locals"); // cur res locals
3224 throw std::logic_error(_info.errorMessage(s("macro config table must contains names for local variables, got \""sv) + std::string(name, len) + '"', x)); 3220 if (lua_istable(L, -1) != 0) {
3221 for (int i = 0; i < static_cast<int>(lua_objlen(L, -1)); i++) {
3222 lua_rawgeti(L, -1, i + 1); // cur res locals item
3223 size_t len = 0;
3224 if (lua_isstring(L, -1) == 0) {
3225 throw std::logic_error(_info.errorMessage(s("macro table field \"locals\" must be a table of strings"sv), x));
3226 }
3227 auto name = lua_tolstring(L, -1, &len);
3228 if (_parser.match<Variable_t>({name, len})) {
3229 localVars.push_back(std::string(name, len));
3230 } else {
3231 throw std::logic_error(_info.errorMessage(s("macro table field \"locals\" must contain names for local variables, got \""sv) + std::string(name, len) + '"', x));
3232 }
3233 lua_pop(L, 1);
3225 } 3234 }
3226 lua_pop(L, 1);
3227 } 3235 }
3228 } // cur macro codes option 3236 lua_pop(L, 1); // cur res
3229 std::string codes = lua_tostring(L, -2); 3237 } else {
3238 codes = lua_tostring(L, -1);
3239 }
3230 return {type, codes, std::move(localVars)}; 3240 return {type, codes, std::move(localVars)};
3231 } 3241 }
3232 3242
@@ -3236,10 +3246,10 @@ private:
3236 std::string type, codes; 3246 std::string type, codes;
3237 str_list localVars; 3247 str_list localVars;
3238 std::tie(type, codes, localVars) = expandMacroStr(chainValue); 3248 std::tie(type, codes, localVars) = expandMacroStr(chainValue);
3239 std::string targetType(usage != ExpUsage::Common || chainList.size() > 2 ? "expr"sv : "block"sv); 3249 bool isBlock = (usage == ExpUsage::Common) && (chainList.size() <= 2);
3240 ParseInfo info; 3250 ParseInfo info;
3241 if (type == "lua"sv) { 3251 if (type == "lua"sv) {
3242 if (!allowBlockMacroReturn && targetType != "block"sv) { 3252 if (!allowBlockMacroReturn && !isBlock) {
3243 throw std::logic_error(_info.errorMessage("lua macro can only be placed where block macro is allowed"sv, x)); 3253 throw std::logic_error(_info.errorMessage("lua macro can only be placed where block macro is allowed"sv, x));
3244 } 3254 }
3245 auto macroChunk = s("=(macro "sv) + _parser.toString(x->name) + ')'; 3255 auto macroChunk = s("=(macro "sv) + _parser.toString(x->name) + ')';
@@ -3251,85 +3261,77 @@ private:
3251 } 3261 }
3252 return {nullptr, nullptr, std::move(codes), std::move(localVars)}; 3262 return {nullptr, nullptr, std::move(codes), std::move(localVars)};
3253 } else if (type == "text"sv) { 3263 } else if (type == "text"sv) {
3254 if (!allowBlockMacroReturn && targetType != "block"sv) {
3255 throw std::logic_error(_info.errorMessage("text macro can only be placed where block macro is allowed"sv, x));
3256 }
3257 return {nullptr, nullptr, std::move(codes), std::move(localVars)}; 3264 return {nullptr, nullptr, std::move(codes), std::move(localVars)};
3258 } else if (!allowBlockMacroReturn && type != targetType) {
3259 if (!codes.empty() && targetType == "block") {
3260 info = _parser.parse<Block_t>(codes);
3261 }
3262 if (info.node) type = "block";
3263 else throw std::logic_error(_info.errorMessage(s("macro type mismatch, "sv) + targetType + s(" expected, got "sv) + type, x));
3264 }
3265 BLOCK_START
3266 BREAK_IF(info.node);
3267 if (usage == ExpUsage::Common) {
3268 if (codes.empty()) {
3269 return {x->new_ptr<Block_t>().get(), std::move(info.codes), Empty, std::move(localVars)};
3270 }
3271 if (type == "expr"sv) {
3272 info = _parser.parse<Exp_t>(codes);
3273 } else {
3274 info = _parser.parse<Block_t>(codes);
3275 }
3276 } else if (allowBlockMacroReturn) {
3277 if (type == "expr"sv) {
3278 info = _parser.parse<Exp_t>(codes);
3279 } else {
3280 info = _parser.parse<Block_t>(codes);
3281 }
3282 } else { 3265 } else {
3283 info = _parser.parse<Exp_t>(codes); 3266 if (!codes.empty()) {
3284 } 3267 if (isBlock) {
3285 BLOCK_END 3268 info = _parser.parse<Block_t>(codes);
3286 if (!info.node) { 3269 if (!info.node) {
3287 info.error = info.error.substr(info.error.find(':') + 2); 3270 info.error = info.error.substr(info.error.find(':') + 2);
3288 throw std::logic_error(_info.errorMessage("failed to parse expanded codes: " + info.error, x)); 3271 throw std::logic_error(_info.errorMessage(s("failed to expanded macro as block: "sv) + info.error, x));
3289 } 3272 }
3290 int line = x->m_begin.m_line; 3273 } else {
3291 int col = x->m_begin.m_col; 3274 info = _parser.parse<Exp_t>(codes);
3292 info.node->traverse([&](ast_node* node) { 3275 if (!info.node && allowBlockMacroReturn) {
3293 node->m_begin.m_line = line; 3276 info = _parser.parse<Block_t>(codes);
3294 node->m_end.m_line = line; 3277 if (!info.node) {
3295 node->m_begin.m_col = col; 3278 info.error = info.error.substr(info.error.find(':') + 2);
3296 node->m_end.m_col = col; 3279 throw std::logic_error(_info.errorMessage(s("failed to expanded macro as expr or block: "sv) + info.error, x));
3297 return traversal::Continue; 3280 }
3298 }); 3281 isBlock = true;
3299 if (type == "expr"sv) { 3282 } else if (!info.node) {
3300 ast_ptr<false, Exp_t> exp; 3283 info.error = info.error.substr(info.error.find(':') + 2);
3301 exp.set(info.node); 3284 throw std::logic_error(_info.errorMessage(s("failed to expanded macro as expr: "sv) + info.error, x));
3302 if (!exp->opValues.empty() || chainList.size() > 2) { 3285 }
3303 auto paren = x->new_ptr<Parens_t>();
3304 paren->expr.set(exp);
3305 auto callable = x->new_ptr<Callable_t>();
3306 callable->item.set(paren);
3307 auto newChain = x->new_ptr<ChainValue_t>();
3308 newChain->items.push_back(callable);
3309 auto it = chainList.begin();
3310 it++; it++;
3311 for (; it != chainList.end(); ++it) {
3312 newChain->items.push_back(*it);
3313 } 3286 }
3314 auto value = x->new_ptr<Value_t>(); 3287 int line = x->m_begin.m_line;
3315 value->item.set(newChain); 3288 int col = x->m_begin.m_col;
3316 exp = newExp(value, x); 3289 info.node->traverse([&](ast_node* node) {
3317 } 3290 node->m_begin.m_line = line;
3318 if (usage == ExpUsage::Common) { 3291 node->m_end.m_line = line;
3319 auto expList = x->new_ptr<ExpList_t>(); 3292 node->m_begin.m_col = col;
3320 expList->exprs.push_back(exp); 3293 node->m_end.m_col = col;
3321 auto exps = x->new_ptr<ExpListAssign_t>(); 3294 return traversal::Continue;
3322 exps->expList.set(expList); 3295 });
3323 auto stmt = x->new_ptr<Statement_t>(); 3296 if (!isBlock) {
3324 stmt->content.set(exps); 3297 ast_ptr<false, Exp_t> exp;
3325 auto block = x->new_ptr<Block_t>(); 3298 exp.set(info.node);
3326 block->statements.push_back(stmt); 3299 if (!exp->opValues.empty() || chainList.size() > 2) {
3327 info.node.set(block); 3300 auto paren = x->new_ptr<Parens_t>();
3301 paren->expr.set(exp);
3302 auto callable = x->new_ptr<Callable_t>();
3303 callable->item.set(paren);
3304 auto newChain = x->new_ptr<ChainValue_t>();
3305 newChain->items.push_back(callable);
3306 auto it = chainList.begin();
3307 it++; it++;
3308 for (; it != chainList.end(); ++it) {
3309 newChain->items.push_back(*it);
3310 }
3311 auto value = x->new_ptr<Value_t>();
3312 value->item.set(newChain);
3313 exp = newExp(value, x);
3314 }
3315 if (usage == ExpUsage::Common) {
3316 auto expList = x->new_ptr<ExpList_t>();
3317 expList->exprs.push_back(exp);
3318 auto exps = x->new_ptr<ExpListAssign_t>();
3319 exps->expList.set(expList);
3320 auto stmt = x->new_ptr<Statement_t>();
3321 stmt->content.set(exps);
3322 auto block = x->new_ptr<Block_t>();
3323 block->statements.push_back(stmt);
3324 info.node.set(block);
3325 } else {
3326 info.node.set(exp);
3327 }
3328 }
3329 return {info.node, std::move(info.codes), Empty, std::move(localVars)};
3328 } else { 3330 } else {
3329 info.node.set(exp); 3331 if (!isBlock) throw std::logic_error(_info.errorMessage(s("failed to expanded empty macro as expr"sv), x));
3332 return {x->new_ptr<Block_t>().get(), std::move(info.codes), Empty, std::move(localVars)};
3330 } 3333 }
3331 } 3334 }
3332 return {info.node, std::move(info.codes), Empty, std::move(localVars)};
3333 } 3335 }
3334#endif // MOONP_NO_MACRO 3336#endif // MOONP_NO_MACRO
3335 3337
@@ -3345,6 +3347,9 @@ private:
3345 Utils::trim(luaCodes); 3347 Utils::trim(luaCodes);
3346 if (!node) { 3348 if (!node) {
3347 if (!luaCodes.empty()) { 3349 if (!luaCodes.empty()) {
3350 if (usage == ExpUsage::Return) {
3351 luaCodes.insert(0, "return "sv);
3352 }
3348 if (_config.reserveLineNumber) { 3353 if (_config.reserveLineNumber) {
3349 luaCodes.insert(0, nll(chainValue).substr(1)); 3354 luaCodes.insert(0, nll(chainValue).substr(1));
3350 } 3355 }
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-12-21 12:08:37 +0000