Separate MoonParser from MoonCompiler, make moonc compile multiple file in threads.

1 files changed, 251 insertions, 12 deletions

diff --git a/src/MoonP/moon_parser.h b/src/MoonP/moon_parser.h
index fc4ee55..933aa7a 100644
--- a/src/MoonP/moon_parser.h
+++ b/src/MoonP/moon_parser.h
@@ -9,27 +9,266 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 
 #include <string>
-#include <codecvt>
 #include <unordered_set>
 #include <stack>
 #include <algorithm>
 #include <vector>
+#include <sstream>
+#include <string_view>
+using namespace std::string_view_literals;
 #include "MoonP/ast.hpp"
-using namespace parserlib;
+#include "MoonP/moon_ast.h"
 
 namespace MoonP {
 
-struct State {
-        State() {
-                indents.push(0);
-                stringOpen = -1;
+struct ParseInfo {
+        ast_ptr<false,ast_node> node;
+        std::string error;
+        std::unique_ptr<input> input;
+        std::string errorMessage(std::string_view msg, const input_range* loc) const;
+};
+
+#define AST_RULE(type) \
+        rule type; \
+        ast<type##_t> type##_impl = type; \
+        template<> inline rule& getRule<type##_t>() { return type; }
+
+extern std::unordered_set<std::string> LuaKeywords;
+extern std::unordered_set<std::string> Keywords;
+
+class MoonParser {
+public:
+        MoonParser();
+
+        template<class AST>
+        ParseInfo parse(const std::string& codes) {
+                error_list errors;
+                auto res = parse(codes, getRule<AST>());
+                if (res.node.template is<AST>()) {
+                        return res;
+                }
+                return res;
+        }
+
+        template <class AST>
+        bool match(const std::string& codes) {
+                auto rEnd = rule(getRule<AST>() >> eof());
+                return parse(codes, rEnd).node;
+        }
+
+        std::string toString(ast_node* node);
+        std::string toString(input::iterator begin, input::iterator end);
+
+        input encode(std::string_view input);
+        std::string decode(const input& input);
+
+protected:
+        ParseInfo parse(const std::string& codes, rule& r);
+
+        struct State {
+                State() {
+                        indents.push(0);
+                        stringOpen = -1;
+                }
+                std::string buffer;
+                size_t stringOpen;
+                std::stack<int> indents;
+                std::stack<bool> doStack;
+        };
+
+private:
+        Converter _converter;
+
+        template <class T>
+        inline rule& getRule() {
+                assert(false);
+                return Cut;
         }
-        std::string buffer;
-        size_t stringOpen;
-        std::stack<int> indents;
-        std::stack<bool> doStack;
-        static std::unordered_set<std::string> luaKeywords;
-        static std::unordered_set<std::string> keywords;
+
+        rule plain_space;
+        rule Break;
+        rule Any;
+        rule White;
+        rule Stop;
+        rule Comment;
+        rule multi_line_open;
+        rule multi_line_close;
+        rule multi_line_content;
+        rule MultiLineComment;
+        rule Indent;
+        rule EscapeNewLine;
+        rule Space;
+        rule SomeSpace;
+        rule SpaceBreak;
+        rule EmptyLine;
+        rule AlphaNum;
+        rule Cut;
+        rule check_indent;
+        rule CheckIndent;
+        rule advance;
+        rule Advance;
+        rule push_indent;
+        rule PushIndent;
+        rule PreventIndent;
+        rule PopIndent;
+        rule InBlock;
+        rule ImportName;
+        rule ImportNameList;
+        rule import_literal_chain;
+        rule WithExp;
+        rule PopDo;
+        rule DisableDo;
+        rule SwitchElse;
+        rule SwitchBlock;
+        rule IfElseIf;
+        rule IfElse;
+        rule for_args;
+        rule for_in;
+        rule CompClause;
+        rule Chain;
+        rule KeyValue;
+        rule single_string_inner;
+        rule interp;
+        rule double_string_plain;
+        rule lua_string_open;
+        rule lua_string_close;
+        rule FnArgsExpList;
+        rule FnArgs;
+        rule chain_call;
+        rule chain_item;
+        rule ChainItems;
+        rule chain_dot_chain;
+        rule ColonChain;
+        rule chain_with_colon;
+        rule ChainItem;
+        rule Index;
+        rule invoke_chain;
+        rule TableValue;
+        rule table_lit_lines;
+        rule TableLitLine;
+        rule TableValueList;
+        rule TableBlockInner;
+        rule ClassLine;
+        rule KeyValueLine;
+        rule KeyValueList;
+        rule ArgLine;
+        rule ArgBlock;
+        rule invoke_args_with_table;
+        rule minus_exp;
+        rule sharp_exp;
+        rule tilde_exp;
+        rule not_exp;
+        rule empty_line_stop;
+        rule Line;
+        rule Shebang;
+
+        AST_RULE(Num)
+        AST_RULE(Name)
+        AST_RULE(Variable)
+        AST_RULE(LuaKeyword)
+        AST_RULE(self)
+        AST_RULE(self_name)
+        AST_RULE(self_class)
+        AST_RULE(self_class_name)
+        AST_RULE(SelfName)
+        AST_RULE(KeyName)
+        AST_RULE(VarArg)
+        AST_RULE(local_flag)
+        AST_RULE(Seperator)
+        AST_RULE(NameList)
+        AST_RULE(Local)
+        AST_RULE(colon_import_name)
+        AST_RULE(import_literal_inner)
+        AST_RULE(ImportLiteral)
+        AST_RULE(ImportFrom)
+        AST_RULE(ImportAs)
+        AST_RULE(Import)
+        AST_RULE(Backcall)
+        AST_RULE(ExpListLow)
+        AST_RULE(ExpList)
+        AST_RULE(Return)
+        AST_RULE(With)
+        AST_RULE(SwitchCase)
+        AST_RULE(Switch)
+        AST_RULE(IfCond)
+        AST_RULE(If)
+        AST_RULE(Unless)
+        AST_RULE(While)
+        AST_RULE(for_step_value)
+        AST_RULE(For)
+        AST_RULE(ForEach)
+        AST_RULE(Do)
+        AST_RULE(Comprehension)
+        AST_RULE(comp_value)
+        AST_RULE(TblComprehension)
+        AST_RULE(star_exp)
+        AST_RULE(CompForEach)
+        AST_RULE(CompFor)
+        AST_RULE(CompInner)
+        AST_RULE(Assign)
+        AST_RULE(update_op)
+        AST_RULE(Update)
+        AST_RULE(BinaryOperator)
+        AST_RULE(BackcallOperator)
+        AST_RULE(Assignable)
+        AST_RULE(AssignableChain)
+        AST_RULE(exp_op_value)
+        AST_RULE(Exp)
+        AST_RULE(Callable)
+        AST_RULE(ChainValue)
+        AST_RULE(simple_table)
+        AST_RULE(SimpleValue)
+        AST_RULE(Value)
+        AST_RULE(LuaStringOpen);
+        AST_RULE(LuaStringContent);
+        AST_RULE(LuaStringClose);
+        AST_RULE(LuaString)
+        AST_RULE(SingleString)
+        AST_RULE(double_string_inner)
+        AST_RULE(double_string_content)
+        AST_RULE(DoubleString)
+        AST_RULE(String)
+        AST_RULE(Parens)
+        AST_RULE(DotChainItem)
+        AST_RULE(ColonChainItem)
+        AST_RULE(default_value)
+        AST_RULE(Slice)
+        AST_RULE(Invoke)
+        AST_RULE(existential_op)
+        AST_RULE(TableLit)
+        AST_RULE(TableBlock)
+        AST_RULE(class_member_list)
+        AST_RULE(ClassBlock)
+        AST_RULE(ClassDecl)
+        AST_RULE(export_values)
+        AST_RULE(export_op)
+        AST_RULE(Export)
+        AST_RULE(variable_pair)
+        AST_RULE(normal_pair)
+        AST_RULE(FnArgDef)
+        AST_RULE(FnArgDefList)
+        AST_RULE(outer_var_shadow)
+        AST_RULE(FnArgsDef)
+        AST_RULE(fn_arrow)
+        AST_RULE(FunLit)
+        AST_RULE(NameOrDestructure)
+        AST_RULE(AssignableNameList)
+        AST_RULE(InvokeArgs)
+        AST_RULE(const_value)
+        AST_RULE(unary_exp)
+        AST_RULE(ExpListAssign)
+        AST_RULE(if_else_line)
+        AST_RULE(unless_line)
+        AST_RULE(statement_appendix)
+        AST_RULE(BreakLoop)
+        AST_RULE(Statement)
+        AST_RULE(Body)
+        AST_RULE(Block)
+        AST_RULE(File)
+};
+
+namespace Utils {
+        void replace(std::string& str, std::string_view from, std::string_view to);
 };
 
 } // namespace MoonP