1 files changed, 130 insertions, 60 deletions

diff --git a/src/yuescript/yue_parser.cpp b/src/yuescript/yue_parser.cpp
index ceb1f7c..1942e23 100644
--- a/src/yuescript/yue_parser.cpp
+++ b/src/yuescript/yue_parser.cpp
@@ -67,24 +67,28 @@ YueParser::YueParser() {
         num_char = range('0', '9') >> *(range('0', '9') | '_' >> and_(range('0', '9')));
         num_char_hex = range('0', '9') | range('a', 'f') | range('A', 'F');
         num_lit = num_char_hex >> *(num_char_hex | '_' >> and_(num_char_hex));
+        num_bin_lit = set("01") >> *(set("01") | '_' >> and_(set("01")));
         Num =
-                "0x" >> (
-                        +num_lit >> (
-                                '.' >> +num_lit >> -num_expo_hex |
-                                num_expo_hex |
-                                lj_num |
-                                true_()
-                        ) | (
-                                '.' >> +num_lit >> -num_expo_hex
-                        )
+                '0' >> (
+                        set("xX") >> (
+                                num_lit >> (
+                                        '.' >> num_lit >> -num_expo_hex |
+                                        num_expo_hex |
+                                        lj_num |
+                                        true_()
+                                ) | (
+                                        '.' >> num_lit >> -num_expo_hex
+                                )
+                        ) |
+                        set("bB") >> num_bin_lit
                 ) |
-                +num_char >> (
-                        '.' >> +num_char >> -num_expo |
+                num_char >> (
+                        '.' >> num_char >> -num_expo |
                         num_expo |
                         lj_num |
                         true_()
                 ) |
-                '.' >> +num_char >> -num_expo;
+                '.' >> num_char >> -num_expo;
 
         cut = false_();
         Seperator = true_();
@@ -114,8 +118,8 @@ YueParser::YueParser() {
                 return false;
         });
 
-        if_assignment_syntax_error = pl::user(true_(), [](const item_t& item) {
-                throw ParserError("use := for if-assignment expression"sv, item.begin);
+        assignment_expression_syntax_error = pl::user(true_(), [](const item_t& item) {
+                throw ParserError("use := for assignment expression"sv, item.begin);
                 return false;
         });
 
@@ -158,6 +162,13 @@ YueParser::YueParser() {
                 ) \
         )
 
+        #define disable_until_rule(patt) ( \
+                disable_until >> ( \
+                        (patt) >> enable_until | \
+                        enable_until >> cut \
+                ) \
+        )
+
         #define body_with(str) ( \
                 key(str) >> space >> (in_block | Statement) | \
                 in_block | \
@@ -321,7 +332,7 @@ YueParser::YueParser() {
                 Exp;
         import_tab_list = import_tab_item >> *(space >> ',' >> space >> import_tab_item);
         import_tab_line = (
-                push_indent_match >> (space >> import_tab_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> import_tab_list, pop_indent)
         ) | space;
         import_tab_lines = space_break >> import_tab_line >> *(-(space >> ',') >> space_break >> import_tab_line) >> -(space >> ',');
         import_tab_key_value = key_value | ':' >> MacroName | MacroNamePair | ImportAllMacro;
@@ -338,7 +349,9 @@ YueParser::YueParser() {
 
         ImportAs = ImportLiteral >> -(space >> key("as") >> space >> (ImportTabLit | Variable | ImportAllMacro));
 
-        Import = key("import") >> space >> (ImportAs | ImportFrom) | FromImport;
+        ImportGlobal = Seperator >> UnicodeName >> *('.' >> UnicodeName) >> -(space >> key("as") >> space >> Variable);
+
+        Import = key("import") >> space >> (ImportAs | ImportFrom | ImportGlobal) | FromImport;
 
         Label = "::" >> LabelName >> "::";
 
@@ -346,11 +359,13 @@ YueParser::YueParser() {
 
         ShortTabAppending = "[]" >> space >> Assign;
 
-        BreakLoop = (expr("break") | "continue") >> not_alpha_num;
+        Break = key("break");
+        Continue = key("continue");
+        BreakLoop = (Break >> -(space >> Exp) | Continue) >> not_alpha_num;
 
         Return = key("return") >> -(space >> (TableBlock | ExpListLow));
 
-        with_exp = ExpList >> -(space >> Assign);
+        with_exp = ExpList >> -(space >> (':' >> Assign | and_('=') >> assignment_expression_syntax_error));
 
         With = key("with") >> -ExistentialOp >> space >> disable_do_chain_arg_table_block_rule(with_exp) >> space >> body_with("do");
         SwitchCase = key("when") >> space >> disable_chain_rule(disable_arg_table_block_rule(SwitchList)) >> space >> body_with("then");
@@ -366,7 +381,8 @@ YueParser::YueParser() {
                 and_(SimpleTable | TableLit) >> Exp |
                 exp_not_tab >> *(space >> ',' >> space >> exp_not_tab)
         );
-        Switch = key("switch") >> space >> Exp >>
+        Switch = key("switch") >> space >>
+                Exp >> -(space >> Assignment) >>
                 space >> Seperator >> (
                         SwitchCase >> space >> (
                                 switch_block |
@@ -375,20 +391,26 @@ YueParser::YueParser() {
                         +space_break >> advance_match >> space >> SwitchCase >> switch_block >> pop_indent
                 );
 
-        Assignment = -(',' >> space >> ExpList >> space) >> (':' >> Assign | and_('=') >> if_assignment_syntax_error);
+        Assignment = -(',' >> space >> ExpList >> space) >> (':' >> Assign | and_('=') >> assignment_expression_syntax_error);
         IfCond = disable_chain_rule(disable_arg_table_block_rule(Exp >> -(space >> Assignment)));
         if_else_if = -(line_break >> *space_break >> check_indent_match) >> space >> key("elseif") >> space >> IfCond >> space >> body_with("then");
         if_else = -(line_break >> *space_break >> check_indent_match) >> space >> key("else") >> space >> body;
         IfType = (expr("if") | "unless") >> not_alpha_num;
         If = IfType >> space >> IfCond >> space >> opt_body_with("then") >> *if_else_if >> -if_else;
 
-        WhileType = (expr("while") | "until") >> not_alpha_num;
-        While = WhileType >> space >> disable_do_chain_arg_table_block_rule(Exp >> -(space >> Assignment)) >> space >> opt_body_with("do");
-        Repeat = key("repeat") >> space >> Body >> line_break >> *space_break >> check_indent_match >> space >> key("until") >> space >> Exp;
+        WhileType = (expr("while") | pl::user("until", [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                return st->noUntilStack.empty() || !st->noUntilStack.back();
+        })) >> not_alpha_num;
+        While = key(WhileType) >> space >> disable_do_chain_arg_table_block_rule(Exp >> -(space >> Assignment)) >> space >> opt_body_with("do");
+        Repeat = key("repeat") >> space >> (
+                in_block >> line_break >> *space_break >> check_indent_match |
+                disable_until_rule(Statement)
+        ) >> space >> key("until") >> space >> Exp;
 
         for_key = pl::user(key("for"), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noForStack.empty() || !st->noForStack.top();
+                return st->noForStack.empty() || !st->noForStack.back();
         });
         ForStepValue = ',' >> space >> Exp;
         for_args = Variable >> space >> '=' >> space >> Exp >> space >> ',' >> space >> Exp >> space >> -ForStepValue;
@@ -402,18 +424,18 @@ YueParser::YueParser() {
 
         Do = pl::user(key("do"), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noDoStack.empty() || !st->noDoStack.top();
+                return st->noDoStack.empty() || !st->noDoStack.back();
         }) >> space >> Body;
 
         disable_do = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.push(true);
+                st->noDoStack.push_back(true);
                 return true;
         });
 
         enable_do = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.pop();
+                st->noDoStack.pop_back();
                 return true;
         });
 
@@ -431,46 +453,58 @@ YueParser::YueParser() {
 
         disable_do_chain_arg_table_block = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.push(true);
-                st->noChainBlockStack.push(true);
-                st->noTableBlockStack.push(true);
+                st->noDoStack.push_back(true);
+                st->noChainBlockStack.push_back(true);
+                st->noTableBlockStack.push_back(true);
                 return true;
         });
 
         enable_do_chain_arg_table_block = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noDoStack.pop();
-                st->noChainBlockStack.pop();
-                st->noTableBlockStack.pop();
+                st->noDoStack.pop_back();
+                st->noChainBlockStack.pop_back();
+                st->noTableBlockStack.pop_back();
                 return true;
         });
 
         disable_arg_table_block = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noTableBlockStack.push(true);
+                st->noTableBlockStack.push_back(true);
                 return true;
         });
 
         enable_arg_table_block = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noTableBlockStack.pop();
+                st->noTableBlockStack.pop_back();
                 return true;
         });
 
         disable_for = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noForStack.push(true);
+                st->noForStack.push_back(true);
                 return true;
         });
 
         enable_for = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noForStack.pop();
+                st->noForStack.pop_back();
+                return true;
+        });
+
+        disable_until = pl::user(true_(), [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                st->noUntilStack.push_back(true);
+                return true;
+        });
+
+        enable_until = pl::user(true_(), [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                st->noUntilStack.pop_back();
                 return true;
         });
 
         CatchBlock = line_break >> *space_break >> check_indent_match >> space >> key("catch") >> space >> Variable >> space >> in_block;
-        Try = key("try") >> space >> (in_block | Exp) >> -CatchBlock;
+        Try = key("try") >> -ExistentialOp >> space >> (in_block | Exp) >> -CatchBlock;
 
         list_value =
                 and_(
@@ -557,20 +591,20 @@ YueParser::YueParser() {
 
         disable_chain = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noChainBlockStack.push(true);
+                st->noChainBlockStack.push_back(true);
                 return true;
         });
 
         enable_chain = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                st->noChainBlockStack.pop();
+                st->noChainBlockStack.pop_back();
                 return true;
         });
 
         chain_line = check_indent_match >> space >> (chain_dot_chain | colon_chain) >> -InvokeArgs;
         chain_block = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noChainBlockStack.empty() || !st->noChainBlockStack.top();
+                return st->noChainBlockStack.empty() || !st->noChainBlockStack.back();
         }) >> +space_break >> advance_match >> ensure(
                 chain_line >> *(+space_break >> chain_line), pop_indent);
         ChainValue =
@@ -607,7 +641,15 @@ YueParser::YueParser() {
         DoubleStringInner = +(not_("#{") >> double_string_plain);
         DoubleStringContent = DoubleStringInner | interp;
         DoubleString = '"' >> Seperator >> *DoubleStringContent >> '"';
-        String = DoubleString | SingleString | LuaString;
+
+        YAMLIndent = +set(" \t");
+        YAMLLineInner = +('\\' >> set("\"\\#") | not_("#{" | stop) >> any_char);
+        YAMLLineContent = YAMLLineInner | interp;
+        YAMLLine = check_indent_match >> YAMLIndent >> +(YAMLLineContent) |
+                advance_match >> YAMLIndent >> ensure(+YAMLLineContent, pop_indent);
+        YAMLMultiline = '|' >> space >> Seperator >> +(*set(" \t") >> line_break) >> advance_match >> ensure(YAMLLine >> *(+(*set(" \t") >> line_break) >> YAMLLine), pop_indent);
+
+        String = DoubleString | SingleString | LuaString | YAMLMultiline;
 
         lua_string_open = '[' >> *expr('=') >> '[';
         lua_string_close = ']' >> *expr('=') >> ']';
@@ -635,7 +677,7 @@ YueParser::YueParser() {
         fn_args_value_list = Exp >> *(space >> ',' >> space >> Exp);
 
         fn_args_lit_line = (
-                push_indent_match >> (space >> fn_args_value_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> fn_args_value_list, pop_indent)
         ) | (
                 space
         );
@@ -677,7 +719,8 @@ YueParser::YueParser() {
         chain_with_colon = +chain_item >> -colon_chain;
         chain_items = chain_with_colon | colon_chain;
 
-        index = '[' >> not_('[') >> space >> Exp >> space >> ']';
+        index = '[' >> not_('[') >> space >> (ReversedIndex >> and_(space >> ']') | Exp) >> space >> ']';
+        ReversedIndex = '#' >> space >> -('-' >> space >> Exp);
         chain_item =
                 Invoke >> -ExistentialOp |
                 DotChainItem >> -ExistentialOp |
@@ -734,7 +777,7 @@ YueParser::YueParser() {
 
         table_block_inner = Seperator >> key_value_line >> *(+space_break >> key_value_line);
         TableBlock = +space_break >> advance_match >> ensure(table_block_inner, pop_indent);
-        TableBlockIndent = '*' >> Seperator >> disable_arg_table_block_rule(
+        TableBlockIndent = ('*' | '-' >> space_one) >> Seperator >> disable_arg_table_block_rule(
                 space >> key_value_list >> -(space >> ',') >>
                 -(+space_break >> advance_match >> space >> ensure(key_value_list >> -(space >> ',') >> *(+space_break >> key_value_line), pop_indent)));
 
@@ -755,7 +798,7 @@ YueParser::YueParser() {
 
         GlobalValues = NameList >> -(space >> '=' >> space >> (TableBlock | ExpListLow));
         GlobalOp = expr('*') | '^';
-        Global = key("global") >> space >> (ClassDecl | GlobalOp | GlobalValues);
+        Global = key("global") >> space >> (-(ConstAttrib >> space) >> ClassDecl | GlobalOp | -(ConstAttrib >> space) >> GlobalValues);
 
         ExportDefault = key("default");
 
@@ -837,24 +880,24 @@ YueParser::YueParser() {
         key_value_line = check_indent_match >> space >> (
                 key_value_list >> -(space >> ',') |
                 TableBlockIndent |
-                '*' >> space >> (SpreadExp | Exp | TableBlock)
+                ('*' | '-' >> space_one) >> space >> (SpreadExp | Exp | TableBlock)
         );
 
         fn_arg_def_list = FnArgDef >> *(space >> ',' >> space >> FnArgDef);
 
         fn_arg_def_lit_line = (
-                push_indent_match >> (space >> fn_arg_def_list >> pop_indent | pop_indent)
+                push_indent_match >> ensure(space >> fn_arg_def_list, pop_indent)
         ) | (
                 space
         );
 
         fn_arg_def_lit_lines = fn_arg_def_lit_line >> *(-(space >> ',') >> space_break >> fn_arg_def_lit_line);
 
-        FnArgDef = (Variable | SelfItem >> -ExistentialOp) >> -(space >> '=' >> space >> Exp);
+        FnArgDef = (Variable | SelfItem >> -ExistentialOp) >> -(space >> '`' >> space >> Name) >> -(space >> '=' >> space >> Exp);
 
         FnArgDefList = Seperator >> (
-                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg) |
-                white >> VarArg
+                fn_arg_def_lit_lines >> -(-(space >> ',') >> white >> VarArg >> -(space >> '`' >> space >> Name)) |
+                white >> VarArg >> -(space >> '`' >> space >> Name)
         );
 
         OuterVarShadow = key("using") >> space >> (NameList | key("nil"));
@@ -883,6 +926,7 @@ YueParser::YueParser() {
 
         FnArrowBack = '<' >> set("-=");
         Backcall = -(FnArgsDef >> space) >> FnArrowBack >> space >> ChainValue;
+        SubBackcall = FnArrowBack >> space >> ChainValue;
 
         PipeBody = Seperator >>
                 pipe_operator >> space >> UnaryExp >>
@@ -896,7 +940,7 @@ YueParser::YueParser() {
 
         arg_table_block = pl::user(true_(), [](const item_t& item) {
                 State* st = reinterpret_cast<State*>(item.user_data);
-                return st->noTableBlockStack.empty() || !st->noTableBlockStack.top();
+                return st->noTableBlockStack.empty() || !st->noTableBlockStack.back();
         }) >> TableBlock;
 
         invoke_args_with_table =
@@ -936,11 +980,11 @@ YueParser::YueParser() {
 
         SimpleValue =
                 TableLit | ConstValue | If | Switch | Try | With |
-                ClassDecl | ForEach | For | While | Do |
+                ClassDecl | ForEach | For | While | Repeat | Do |
                 UnaryValue | TblComprehension | Comprehension |
                 FunLit | Num | VarArg;
 
-        ExpListAssign = ExpList >> -(space >> (Update | Assign)) >> not_(space >> '=');
+        ExpListAssign = ExpList >> -(space >> (Update | Assign | SubBackcall)) >> not_(space >> '=');
 
         IfLine = IfType >> space >> IfCond;
         WhileLine = WhileType >> space >> Exp;
@@ -997,11 +1041,16 @@ YueParser::YueParser() {
                 empty_line_break |
                 advance_match >> ensure(space >> (indentation_error | Statement), pop_indent)
         );
-        Block = Seperator >> line >> *(+line_break >> line);
+        Block = Seperator >> (pl::user(true_(), [](const item_t& item) {
+                State* st = reinterpret_cast<State*>(item.user_data);
+                return st->lax;
+        }) >> lax_line >> *(+line_break >> lax_line) | line >> *(+line_break >> line));
 
         shebang = "#!" >> *(not_(stop) >> any_char);
         BlockEnd = Block >> white >> stop;
         File = -shebang >> -Block >> white >> stop;
+
+        lax_line = advance_match >> ensure(*(not_(stop) >> any()), pop_indent) | line >> and_(stop) | check_indent_match >> *(not_(stop) >> any());
 }
 // clang-format on
 
@@ -1031,7 +1080,7 @@ bool YueParser::startWith(std::string_view codes, rule& r) {
         return true;
 }
 
-ParseInfo YueParser::parse(std::string_view codes, rule& r) {
+ParseInfo YueParser::parse(std::string_view codes, rule& r, bool lax) {
         ParseInfo res;
         if (codes.substr(0, 3) == "\xEF\xBB\xBF"sv) {
                 codes = codes.substr(3);
@@ -1049,6 +1098,7 @@ ParseInfo YueParser::parse(std::string_view codes, rule& r) {
         error_list errors;
         try {
                 State state;
+                state.lax = lax;
                 res.node.set(::yue::parse(*(res.codes), r, errors, &state));
                 if (state.exportCount > 0) {
                         int index = 0;
@@ -1086,19 +1136,21 @@ ParseInfo YueParser::parse(std::string_view codes, rule& r) {
         return res;
 }
 
-ParseInfo YueParser::parse(std::string_view astName, std::string_view codes) {
+ParseInfo YueParser::parse(std::string_view astName, std::string_view codes, bool lax) {
         auto it = _rules.find(astName);
         if (it != _rules.end()) {
-                return parse(codes, *it->second);
+                return parse(codes, *it->second, lax);
         }
-        return {};
+        ParseInfo info{};
+        info.error = ParseInfo::Error{"invalid rule: "s + std::string{astName}, 1, 1};
+        return info;
 }
 
 bool YueParser::match(std::string_view astName, std::string_view codes) {
         auto it = _rules.find(astName);
         if (it != _rules.end()) {
                 auto rEnd = rule(*it->second >> eof());
-                return parse(codes, rEnd).node;
+                return parse(codes, rEnd, false).node;
         }
         return false;
 }
@@ -1134,6 +1186,24 @@ void trim(std::string& str) {
         str.erase(0, str.find_first_not_of(" \t\r\n"));
         str.erase(str.find_last_not_of(" \t\r\n") + 1);
 }
+
+std::string toLuaDoubleString(const std::string& input) {
+        std::string luaStr = "\"";
+        for (char c : input) {
+                switch (c) {
+                        case '\"': luaStr += "\\\""; break;
+                        case '\\': luaStr += "\\\\"; break;
+                        case '\n': luaStr += "\\n"; break;
+                        case '\r': luaStr += "\\r"; break;
+                        case '\t': luaStr += "\\t"; break;
+                        default:
+                                luaStr += c;
+                                break;
+                }
+        }
+        luaStr += "\"";
+        return luaStr;
+}
 } // namespace Utils
 
 std::string ParseInfo::errorMessage(std::string_view msg, int errLine, int errCol, int lineOffset) const {