update backcall operator syntax, fix issue #31.

5 files changed, 134 insertions, 15 deletions

diff --git a/spec/inputs/backcall.mp b/spec/inputs/backcall.mp
index a648b16..0d52f3f 100644
--- a/spec/inputs/backcall.mp
+++ b/spec/inputs/backcall.mp
@@ -2,9 +2,9 @@
 {"abc", 123, 998} |> foreach print
 
 {1,2,3}
-        |> map((x)-> x * 2)
-        |> filter((x)-> x > 4)
-        |> reduce(0, (a,b)-> a + b)
+        |> map (x)-> x * 2
+        |> filter (x)-> x > 4
+        |> reduce 0, (a,b)-> a + b
         |> print
 
 [i |> tostring for i = 0,10] |> table.concat(",") |> print
@@ -36,6 +36,28 @@ arr[3] |> f 1, 2, _, 4, 5
 
 a = {"1","2","3"} |> table.concat("") |> tonumber |> f1(1, 2, 3, _) |> f2(1, _, 3)
 
+readFile "example.txt"
+        |> extract _, language, {}
+        |> parse _, language
+        |> emit
+        |> render
+        |> print
+
+123 |> not func! |> f
+
+do
+        _1 = list{"abc","xyz","123"}\map"#"\value!
+                |> -func!
+                |> abc 123, _, "x"
+
+        global _2,_3,_4 = 1,2,3
+                |> f
+
+        local _5 = v |> f1 1
+                                        |> f2 2
+                                        |> f3 3
+                                        |> f4 4
+
 do
         (x)<- map {1,2,3}
         x * 2
diff --git a/src/MoonP/moon_ast.h b/src/MoonP/moon_ast.h
index d00d855..2f5123b 100644
--- a/src/MoonP/moon_ast.h
+++ b/src/MoonP/moon_ast.h
@@ -701,6 +701,12 @@ AST_END(unless_line)
 AST_LEAF(BreakLoop)
 AST_END(BreakLoop)
 
+AST_NODE(BackcallBody)
+        ast_ptr<true, Seperator_t> sep;
+        ast_list<true, unary_exp_t> values;
+        AST_MEMBER(BackcallBody, &sep, &values)
+AST_END(BackcallBody)
+
 AST_NODE(statement_appendix)
         ast_sel<true, if_line_t, unless_line_t, CompInner_t> item;
         AST_MEMBER(statement_appendix, &item)
@@ -712,7 +718,7 @@ AST_END(statement_sep)
 AST_NODE(Statement)
         ast_sel<true, Import_t, While_t, Repeat_t, For_t, ForEach_t,
                 Return_t, Local_t, Global_t, Export_t, Macro_t, BreakLoop_t,
-                Label_t, Goto_t, Backcall_t, LocalAttrib_t, ExpListAssign_t> content;
+                Label_t, Goto_t, Backcall_t, LocalAttrib_t, BackcallBody_t, ExpListAssign_t> content;
         ast_ptr<false, statement_appendix_t> appendix;
         ast_ptr<false, statement_sep_t> needSep;
         AST_MEMBER(Statement, &content, &appendix, &needSep)
diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index 73bbd60..11d4ed8 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.5.2"sv;
+const std::string_view version = "0.6.0"sv;
 const std::string_view extension = "mp"sv;
 
 class MoonCompilerImpl {
@@ -429,7 +429,7 @@ private:
                 return result;
         }
 
-        Value_t* singleValueFrom(ast_node* item) const {
+        unary_exp_t* singleUnaryExpFrom(ast_node* item) const {
                 Exp_t* exp = nullptr;
                 switch (item->getId()) {
                         case id<Exp_t>():
@@ -451,8 +451,8 @@ private:
                         }
                         case id<unary_exp_t>(): {
                                 auto unary = static_cast<unary_exp_t*>(item);
-                                if (unary->ops.empty() && unary->expos.size() == 1) {
-                                        return static_cast<Value_t*>(unary->expos.back());
+                                if (unary->expos.size() == 1) {
+                                        return unary;
                                 }
                                 return nullptr;
                         }
@@ -463,13 +463,21 @@ private:
                 BREAK_IF(!exp->opValues.empty());
                 BREAK_IF(exp->backcalls.size() != 1);
                 auto unary = static_cast<unary_exp_t*>(exp->backcalls.back());
-                BREAK_IF(!unary->ops.empty());
                 BREAK_IF(unary->expos.size() != 1);
-                return static_cast<Value_t*>(unary->expos.back());
+                return unary;
                 BLOCK_END
                 return nullptr;
         }
 
+        Value_t* singleValueFrom(ast_node* item) const {
+                if (auto unary = singleUnaryExpFrom(item)) {
+                        if (unary->ops.empty()) {
+                                return static_cast<Value_t*>(unary->expos.back());
+                        }
+                }
+                return nullptr;
+        }
+
         ast_ptr<false, Exp_t> newExp(Value_t* value, ast_node* x) {
                 auto unary = x->new_ptr<unary_exp_t>();
                 unary->expos.push_back(value);
@@ -522,6 +530,60 @@ private:
                 return stmts.empty() ? nullptr : static_cast<Statement_t*>(stmts.back());
         }
 
+        Exp_t* lastExpFromAssign(ast_node* action) {
+                switch (action->getId()) {
+                        case id<Update_t>(): {
+                                auto update = static_cast<Update_t*>(action);
+                                return update->value;
+                        }
+                        case id<Assign_t>(): {
+                                auto assign = static_cast<Assign_t*>(action);
+                                return ast_cast<Exp_t>(assign->values.back());
+                        }
+                }
+                return nullptr;
+        }
+
+        Exp_t* lastExpFromStatement(Statement_t* stmt) {
+                if (!stmt->content) return nullptr;
+                switch (stmt->content->getId()) {
+                        case id<ExpListAssign_t>(): {
+                                auto expListAssign = static_cast<ExpListAssign_t*>(stmt->content.get());
+                                if (auto action = expListAssign->action.get()) {
+                                        return lastExpFromAssign(action);
+                                } else {
+                                        return static_cast<Exp_t*>(expListAssign->expList->exprs.back());
+                                }
+                        }
+                        case id<Export_t>(): {
+                                auto exportNode = static_cast<Export_t*>(stmt->content.get());
+                                if (auto action = exportNode->assign.get()) {
+                                        return lastExpFromAssign(action);
+                                } else {
+                                        switch (exportNode->target->getId()) {
+                                                case id<Exp_t>(): return exportNode->target.to<Exp_t>();
+                                                case id<ExpList_t>(): return static_cast<Exp_t*>(exportNode->target.to<ExpList_t>()->exprs.back());
+                                        }
+                                }
+                        }
+                        case id<Local_t>(): {
+                                if (auto localValues = static_cast<Local_t*>(stmt->content.get())->item.as<local_values_t>()) {
+                                        if (auto expList = localValues->valueList.as<ExpListLow_t>()) {
+                                                return static_cast<Exp_t*>(expList->exprs.back());
+                                        }
+                                }
+                        }
+                        case id<Global_t>(): {
+                                if (auto globalValues = static_cast<Global_t*>(stmt->content.get())->item.as<global_values_t>()) {
+                                        if (auto expList = globalValues->valueList.as<ExpListLow_t>()) {
+                                                return static_cast<Exp_t*>(expList->exprs.back());
+                                        }
+                                }
+                        }
+                }
+                return nullptr;
+        }
+
         template <class T>
         ast_ptr<false, T> toAst(std::string_view codes, ast_node* parent) {
                 auto res = _parser.parse<T>(s(codes));
@@ -812,6 +874,7 @@ private:
                         case id<Label_t>(): transformLabel(static_cast<Label_t*>(content), out); break;
                         case id<Goto_t>(): transformGoto(static_cast<Goto_t*>(content), out); break;
                         case id<LocalAttrib_t>(): transformLocalAttrib(static_cast<LocalAttrib_t*>(content), out); break;
+                        case id<BackcallBody_t>(): throw std::logic_error(_info.errorMessage("backcall chain must be following a value"sv, x)); break;
                         case id<ExpListAssign_t>(): {
                                 auto expListAssign = static_cast<ExpListAssign_t*>(content);
                                 if (expListAssign->action) {
@@ -1692,7 +1755,10 @@ private:
                         auto begin = values.begin(); begin++;
                         for (auto it = begin; it != values.end(); ++it) {
                                 auto unary = static_cast<unary_exp_t*>(*it);
-                                auto value = singleValueFrom(unary);
+                                auto value = static_cast<Value_t*>(singleUnaryExpFrom(unary) ? unary->expos.back() : nullptr);
+                                if (values.back() == *it && !unary->ops.empty() && usage == ExpUsage::Common) {
+                                        throw std::logic_error(_info.errorMessage("expression list is not supported here"sv, x));
+                                }
                                 if (!value) throw std::logic_error(_info.errorMessage("backcall operator must be followed by chain value"sv, *it));
                                 if (auto chainValue = value->item.as<ChainValue_t>()) {
                                         if (isChainValueCall(chainValue)) {
@@ -1936,7 +2002,29 @@ private:
                 for (auto it = nodes.begin(); it != nodes.end(); ++it) {
                         auto node = *it;
                         auto stmt = static_cast<Statement_t*>(node);
-                        if (auto backcall = stmt->content.as<Backcall_t>()) {
+                        if (auto backcallBody = stmt->content.as<BackcallBody_t>()) {
+                                auto x = stmt;
+                                bool cond = false;
+                                BLOCK_START
+                                BREAK_IF(it == nodes.begin());
+                                auto last = it; --last;
+                                auto lst = static_cast<Statement_t*>(*last);
+                                auto exp = lastExpFromStatement(lst);
+                                BREAK_IF(!exp);
+                                for (auto val : backcallBody->values.objects()) {
+                                        exp->backcalls.push_back(val);
+                                }
+                                cond = true;
+                                BLOCK_END
+                                if (!cond) throw std::logic_error(_info.errorMessage("backcall chain must be following a value"sv, x));
+                                stmt->content.set(nullptr);
+                                auto next = it; ++next;
+                                BLOCK_START
+                                BREAK_IF(next == nodes.end());
+                                BREAK_IF(!static_cast<Statement_t*>(*next)->content.as<BackcallBody_t>());
+                                throw std::logic_error(_info.errorMessage("indent mismatch in backcall chain"sv, *next));
+                                BLOCK_END
+                        } else if (auto backcall = stmt->content.as<Backcall_t>()) {
                                 auto x = *nodes.begin();
                                 auto newBlock = x->new_ptr<Block_t>();
                                 if (it != nodes.begin()) {
diff --git a/src/MoonP/moon_parser.cpp b/src/MoonP/moon_parser.cpp
index 63ffec7..f15492f 100644
--- a/src/MoonP/moon_parser.cpp
+++ b/src/MoonP/moon_parser.cpp
@@ -319,7 +319,7 @@ MoonParser::MoonParser() {
         unary_exp = *(Space >> unary_operator) >> expo_exp;
 
         BackcallOperator = expr("|>");
-        backcall_value = White >> BackcallOperator >> *SpaceBreak >> unary_exp;
+        backcall_value = Space >> BackcallOperator >> *SpaceBreak >> unary_exp;
         backcall_exp = unary_exp >> *backcall_value;
 
         BinaryOperator =
@@ -522,6 +522,8 @@ MoonParser::MoonParser() {
         fn_arrow_back = expr('<') >> set("-=");
         Backcall = -FnArgsDef >> Space >> fn_arrow_back >> Space >> ChainValue;
 
+        BackcallBody = Seperator >> Space >> BackcallOperator >> unary_exp >> *(+SpaceBreak >> CheckIndent >> Space >> BackcallOperator >> unary_exp);
+
         ExpList = Seperator >> Exp >> *(sym(',') >> Exp);
         ExpListLow = Seperator >> Exp >> *(Space >> set(",;") >> Exp);
 
@@ -562,14 +564,14 @@ MoonParser::MoonParser() {
                 Import | While | Repeat | For | ForEach |
                 Return | Local | Global | Export | Macro |
                 Space >> BreakLoop | Label | Goto | Backcall |
-                LocalAttrib | ExpListAssign
+                LocalAttrib | BackcallBody | ExpListAssign
         ) >> Space >>
         -statement_appendix >> -statement_sep;
 
         Body = Space >> Break >> *EmptyLine >> InBlock | Statement;
 
         empty_line_stop = Space >> and_(Stop);
-        Line = CheckIndent >> Statement | empty_line_stop;
+        Line = CheckIndent >> Statement | and_(Space >> BackcallOperator) >> Advance >> ensure(Statement, PopIndent) | empty_line_stop;
         Block = Seperator >> Line >> *(+Break >> Line);
 
         Shebang = expr("#!") >> *(not_(Stop) >> Any);
diff --git a/src/MoonP/moon_parser.h b/src/MoonP/moon_parser.h
index f036a7c..bee3c9c 100644
--- a/src/MoonP/moon_parser.h
+++ b/src/MoonP/moon_parser.h
@@ -209,6 +209,7 @@ private:
         AST_RULE(Goto)
         AST_RULE(fn_arrow_back)
         AST_RULE(Backcall)
+        AST_RULE(BackcallBody)
         AST_RULE(ExpListLow)
         AST_RULE(ExpList)
         AST_RULE(Return)