perf: Simplify macro operand preprocessing

eclipse-che4z · Aug 9, 2024 · 88be6eb · 88be6eb
1 parent 911d6a3
commit 88be6eb
Show file tree

Hide file tree

Showing 19 changed files with 121 additions and 201 deletions.
diff --git a/parser_library/src/parsing/grammar/hlasmparser_multiline.g4 b/parser_library/src/parsing/grammar/hlasmparser_multiline.g4
@@ -589,44 +589,53 @@ op_rem_body_ca_var_def locals [bool pending_empty_op = false, std::vector<range>
     }
 //////////////////////////////////////// mac
 
-op_rem_body_mac returns [op_rem line, range line_range, size_t line_logical_column = 0]
+op_rem_body_mac returns [macop_preprocess_results results, range line_range, size_t line_logical_column = 0]
     :
     SPACE* EOF {$line_range = provider.get_range($ctx->getStart(), _input->LT(-1));}
     |
-    SPACE+ op_rem_body_alt_mac
+    SPACE+ op_rem_body_alt_mac[&$results]
     {
-        $line = std::move($op_rem_body_alt_mac.line);
+        if ($results.text_ranges.empty())
+            $results.total_op_range = provider.get_empty_range($op_rem_body_alt_mac.start);
+        else
+            $results.total_op_range = union_range($results.text_ranges.front(), $results.text_ranges.back());
         $line_range = provider.get_range($op_rem_body_alt_mac.ctx);
         $line_logical_column = static_cast<hlasm_plugin::parser_library::lexing::token*>($op_rem_body_alt_mac.start)->get_logical_column();
     } EOF;
 
-op_rem_body_alt_mac returns [op_rem line]
+op_rem_body_alt_mac [macop_preprocess_results* results]
     :
     (
         (
-            mac_op? comma
+            mac_preproc? comma
             {
-                if ($mac_op.ctx && $mac_op.op)
-                    $line.operands.push_back(std::move($mac_op.op));
-                $line.operands.push_back(std::make_unique<semantics::empty_operand>(provider.get_range($comma.ctx->getStart())));
+                if ($mac_preproc.ctx) {
+                   append_context_text($results->text, $mac_preproc.ctx);
+                   $results->text_ranges.push_back(provider.get_range($mac_preproc.ctx));
+                   $mac_preproc.ctx = nullptr;
+                }
+                $results->text.push_back(',');
+                $results->text_ranges.push_back(provider.get_range($comma.ctx));
             }
         )+
         {enable_continuation();}
         (
             r1=remark_o CONTINUATION
             {
-                if($r1.value) $line.remarks.push_back(std::move(*$r1.value));
+                if($r1.value) $results->remarks.push_back(std::move(*$r1.value));
             }
         )?
         {disable_continuation();}
     )*
     (
-        last_mac_op=mac_op? last_remark=remark_o
+        last_mac_op=mac_preproc? last_remark=remark_o
         {
-            if ($last_mac_op.ctx && $last_mac_op.op)
-                $line.operands.push_back(std::move($last_mac_op.op));
+            if ($last_mac_op.ctx) {
+               append_context_text($results->text, $last_mac_op.ctx);
+               $results->text_ranges.push_back(provider.get_range($last_mac_op.ctx));
+            }
             if ($last_remark.value)
-                $line.remarks.push_back(std::move(*$last_remark.value));
+                $results->remarks.push_back(std::move(*$last_remark.value));
         }
     );
     finally

diff --git a/parser_library/src/parsing/grammar/hlasmparser_singleline.g4 b/parser_library/src/parsing/grammar/hlasmparser_singleline.g4
@@ -456,33 +456,46 @@ op_rem_body_ca_var_def locals [bool pending_empty_op = true, std::vector<range>
 
 //////////////////////////////////////// mac
 
-op_rem_body_mac returns [op_rem line, range line_range, size_t line_logical_column = 0]
+op_rem_body_mac returns [macop_preprocess_results results, range line_range, size_t line_logical_column = 0]
     :
     SPACE* EOF {$line_range = provider.get_range($ctx->getStart(), _input->LT(-1));}
     |
-    SPACE+ op_rem_body_alt_mac
+    SPACE+ op_rem_body_alt_mac[&$results]
     {
-        $line = std::move($op_rem_body_alt_mac.line);
+        if ($results.text_ranges.empty())
+            $results.total_op_range = provider.get_empty_range($op_rem_body_alt_mac.start);
+        else
+            $results.total_op_range = union_range($results.text_ranges.front(), $results.text_ranges.back());
         $line_range = provider.get_range($op_rem_body_alt_mac.ctx);
         $line_logical_column = static_cast<hlasm_plugin::parser_library::lexing::token*>($op_rem_body_alt_mac.start)->get_logical_column();
     } EOF;
 
-op_rem_body_alt_mac returns [op_rem line]
+op_rem_body_alt_mac [macop_preprocess_results* results]
     :
     (
-        mac_op? COMMA
+        mac_preproc
         {
-            if ($mac_op.ctx && $mac_op.op)
-                $line.operands.push_back(std::move($mac_op.op));
-            $line.operands.push_back(std::make_unique<semantics::empty_operand>(provider.get_range($COMMA)));
+            append_context_text($results->text, $mac_preproc.ctx);
+            $results->text_ranges.push_back(provider.get_range($mac_preproc.ctx));
         }
-    )*
+    )?
     (
-        last_mac_op=mac_op? last_remark=remark_o
+        COMMA
         {
-            if ($last_mac_op.ctx && $last_mac_op.op)
-                $line.operands.push_back(std::move($last_mac_op.op));
-            if ($last_remark.value)
-                $line.remarks.push_back(std::move(*$last_remark.value));
+            $results->text.push_back(',');
+            $results->text_ranges.push_back(provider.get_range($COMMA));
         }
-    );
+        (
+        mac_preproc
+        {
+            append_context_text($results->text, $mac_preproc.ctx);
+            $results->text_ranges.push_back(provider.get_range($mac_preproc.ctx));
+        }
+        )?
+    )*
+    last_remark=remark_o
+    {
+        if ($last_remark.value)
+            $results->remarks.push_back(std::move(*$last_remark.value));
+    }
+    ;
diff --git a/parser_library/src/parsing/grammar/macro_operand_rules.g4 b/parser_library/src/parsing/grammar/macro_operand_rules.g4
@@ -16,17 +16,11 @@
 parser grammar macro_operand_rules;
 
 
-mac_op returns [operand_ptr op]
-    : mac_preproc
-    {
-        $op = std::make_unique<macro_operand_string>(get_context_text($mac_preproc.ctx),provider.get_range($mac_preproc.ctx));
-    };
-
 mac_op_o returns [operand_ptr op]
     : mac_entry?
     {
         if($mac_entry.ctx)
-            $op = std::make_unique<macro_operand_chain>(std::move($mac_entry.chain),provider.get_range($mac_entry.ctx));
+            $op = std::make_unique<macro_operand>(std::move($mac_entry.chain),provider.get_range($mac_entry.ctx));
         else
             $op = std::make_unique<semantics::empty_operand>(provider.original_range);
     };
@@ -51,7 +45,7 @@ mac_preproc
         | DOT
         | AMPERSAND
         (
-            ORDSYMBOL (ORDSYMBOL|NUM)*
+            ORDSYMBOL
             |
             LPAR
             |

diff --git a/parser_library/src/parsing/grammar/operand_field_rules.g4 b/parser_library/src/parsing/grammar/operand_field_rules.g4
@@ -196,13 +196,17 @@ op_rem_body_asm_r returns [op_rem line]
 
 //////////////////////////////////////// mac_r
 
-op_rem_body_mac_r returns [op_rem line]
+op_rem_body_mac_r returns [macop_preprocess_results results]
     :
     SPACE* EOF
     |
-    op_rem_body_alt_mac
+    op_rem_body_alt_mac[&$results]
     {
-        $line = std::move($op_rem_body_alt_mac.line);
+        auto& results = $results;
+        if (results.text_ranges.empty())
+            results.total_op_range = provider.get_empty_range($op_rem_body_alt_mac.start);
+        else
+            results.total_op_range = union_range(results.text_ranges.front(), results.text_ranges.back());
     } EOF;
 
 op_rem_body_noop_r

diff --git a/parser_library/src/parsing/parser_impl.cpp b/parser_library/src/parsing/parser_impl.cpp
@@ -99,7 +99,10 @@ struct parser_holder_impl final : parser_holder
     void lookahead_operands_and_remarks_asm() const override { get_parser().lookahead_operands_and_remarks_asm(); }
     void lookahead_operands_and_remarks_dat() const override { get_parser().lookahead_operands_and_remarks_dat(); }
 
-    semantics::op_rem op_rem_body_mac_r() const override { return std::move(get_parser().op_rem_body_mac_r()->line); }
+    semantics::macop_preprocess_results op_rem_body_mac_r() const override
+    {
+        return std::move(get_parser().op_rem_body_mac_r()->results);
+    }
     semantics::operand_list macro_ops() const override { return std::move(get_parser().macro_ops()->list); }
     semantics::op_rem op_rem_body_asm_r() const override { return std::move(get_parser().op_rem_body_asm_r()->line); }
     semantics::op_rem op_rem_body_mach_r() const override { return std::move(get_parser().op_rem_body_mach_r()->line); }
@@ -117,7 +120,7 @@ struct parser_holder_impl final : parser_holder
     mac_op_data op_rem_body_mac() const override
     {
         auto rule = get_parser().op_rem_body_mac();
-        return { std::move(rule->line), rule->line_range, rule->line_logical_column };
+        return { std::move(rule->results), rule->line_range, rule->line_logical_column };
     }
 
     operand_ptr ca_op_expr() const override { return std::move(get_parser().ca_op_expr()->op); }
@@ -418,6 +421,13 @@ void parser_impl::add_label_component(
 }
 
 std::string parser_impl::get_context_text(const antlr4::ParserRuleContext* ctx) const
+{
+    std::string result;
+    append_context_text(result, ctx);
+    return result;
+}
+
+void parser_impl::append_context_text(std::string& s, const antlr4::ParserRuleContext* ctx) const
 {
     auto start = ctx->start;
     auto stop = ctx->stop;
@@ -428,14 +438,10 @@ std::string parser_impl::get_context_text(const antlr4::ParserRuleContext* ctx)
     auto startId = start->getTokenIndex();
     auto stopId = stop->getTokenIndex();
 
-    std::string result;
-
     for (auto id = startId; id <= stopId; ++id)
         if (auto token = input.get(id);
             token->getChannel() == lexing::lexer::Channels::DEFAULT_CHANNEL && token->getType() != antlr4::Token::EOF)
-            result.append(token->getText());
-
-    return result;
+            s.append(token->getText());
 }
 
 bool parser_impl::goff() const noexcept { return hlasm_ctx->goff(); }

diff --git a/parser_library/src/parsing/parser_impl.h b/parser_library/src/parsing/parser_impl.h
@@ -168,6 +168,7 @@ class parser_impl : public antlr4::Parser
         semantics::vs_ptr s, semantics::concat_chain& chain, std::string& buffer, bool& has_variables) const;
 
     std::string get_context_text(const antlr4::ParserRuleContext* ctx) const;
+    void append_context_text(std::string& s, const antlr4::ParserRuleContext* ctx) const;
 
     bool goff() const noexcept;
 
@@ -207,7 +208,7 @@ struct parser_holder
     virtual void lookahead_operands_and_remarks_asm() const = 0;
     virtual void lookahead_operands_and_remarks_dat() const = 0;
 
-    virtual semantics::op_rem op_rem_body_mac_r() const = 0;
+    virtual semantics::macop_preprocess_results op_rem_body_mac_r() const = 0;
     virtual semantics::operand_list macro_ops() const = 0;
     virtual semantics::op_rem op_rem_body_asm_r() const = 0;
     virtual semantics::op_rem op_rem_body_mach_r() const = 0;
@@ -226,7 +227,7 @@ struct parser_holder
 
     struct mac_op_data
     {
-        semantics::op_rem operands;
+        semantics::macop_preprocess_results operands;
         range op_range;
         size_t op_logical_column;
     };

diff --git a/parser_library/src/processing/instruction_sets/ca_processor.cpp b/parser_library/src/processing/instruction_sets/ca_processor.cpp
@@ -479,8 +479,7 @@ struct AREAD_operand_visitor final : public semantics::operand_visitor
     }
     void visit(const semantics::seq_ca_operand&) override {}
     void visit(const semantics::branch_ca_operand&) override {}
-    void visit(const semantics::macro_operand_chain&) override {}
-    void visit(const semantics::macro_operand_string&) override {}
+    void visit(const semantics::macro_operand&) override {}
 };
 } // namespace
 

diff --git a/parser_library/src/processing/instruction_sets/macro_processor.cpp b/parser_library/src/processing/instruction_sets/macro_processor.cpp
@@ -298,7 +298,7 @@ std::vector<context::macro_arg> macro_processor::get_operand_args(const resolved
             continue;
         }
 
-        auto tmp = op->access_mac()->access_chain();
+        auto tmp = op->access_mac();
         assert(tmp);
 
         auto& tmp_chain = tmp->chain;

diff --git a/parser_library/src/processing/opencode_provider.cpp b/parser_library/src/processing/opencode_provider.cpp
@@ -422,29 +422,26 @@ std::shared_ptr<const context::hlasm_statement> opencode_provider::process_ordin
                     h.op_rem_body_dat();
                     break;
                 default: {
-                    auto [line, line_range, line_logical_column] = h.op_rem_body_mac();
+                    auto [reparse_data, line_range, line_logical_column] = h.op_rem_body_mac();
 
-                    if (h.error_handler->error_reported())
+                    semantics::operand_list op_list;
+                    if (!h.error_handler->error_reported() && !reparse_data.text.empty())
                     {
-                        line.operands.clear();
-                    }
-                    else if (line.operands.size())
-                    {
-                        auto [to_parse, ranges, r] = join_operands(line.operands);
-
-                        semantics::range_provider tmp_provider(
-                            r, ranges, semantics::adjusting_state::MACRO_REPARSE, h.lex->get_line_limits());
+                        semantics::range_provider tmp_provider(reparse_data.total_op_range,
+                            std::move(reparse_data.text_ranges),
+                            semantics::adjusting_state::MACRO_REPARSE,
+                            h.lex->get_line_limits());
 
-                        const auto& h_second = prepare_operand_parser(to_parse,
+                        const auto& h_second = prepare_operand_parser(reparse_data.text,
                             *m_ctx.hlasm_ctx,
                             format.form == processing_form::UNKNOWN ? &diags_filter : diags,
                             std::move(tmp_provider),
-                            r,
+                            reparse_data.total_op_range,
                             line_logical_column,
                             proc_status,
                             true);
 
-                        line.operands = h_second.macro_ops();
+                        op_list = h_second.macro_ops();
 
                         auto& c = h.parser->get_collector();
                         auto& c_s = h_second.parser->get_collector();
@@ -456,7 +453,7 @@ std::shared_ptr<const context::hlasm_statement> opencode_provider::process_ordin
                     }
 
                     h.parser->get_collector().set_operand_remark_field(
-                        std::move(line.operands), std::move(line.remarks), line_range);
+                        std::move(op_list), std::move(reparse_data.remarks), line_range);
 
                     break;
                 }

diff --git a/parser_library/src/processing/statement_analyzers/occurrence_collector.cpp b/parser_library/src/processing/statement_analyzers/occurrence_collector.cpp
@@ -93,9 +93,7 @@ void occurrence_collector::visit(const semantics::branch_ca_operand& op)
     get_occurrence(op.sequence_symbol);
 }
 
-void occurrence_collector::visit(const semantics::macro_operand_chain& op) { get_occurrence(op.chain); }
-
-void occurrence_collector::visit(const semantics::macro_operand_string&) {}
+void occurrence_collector::visit(const semantics::macro_operand& op) { get_occurrence(op.chain); }
 
 void occurrence_collector::get_occurrence(const semantics::variable_symbol& var)
 {

diff --git a/parser_library/src/processing/statement_analyzers/occurrence_collector.h b/parser_library/src/processing/statement_analyzers/occurrence_collector.h
@@ -55,8 +55,7 @@ class occurrence_collector final : public semantics::operand_visitor,
     void visit(const semantics::expr_ca_operand& op) override;
     void visit(const semantics::seq_ca_operand& op) override;
     void visit(const semantics::branch_ca_operand& op) override;
-    void visit(const semantics::macro_operand_chain& op) override;
-    void visit(const semantics::macro_operand_string& op) override;
+    void visit(const semantics::macro_operand& op) override;
 
     void get_occurrence(const semantics::variable_symbol& var);
     void get_occurrence(const semantics::seq_sym& seq);

diff --git a/parser_library/src/processing/statement_fields_parser.cpp b/parser_library/src/processing/statement_fields_parser.cpp
@@ -78,24 +78,21 @@ statement_fields_parser::parse_result statement_fields_parser::parse_operand_fie
     {
         switch (format.form)
         {
-            case processing::processing_form::MAC:
-                line = h.op_rem_body_mac_r();
+            case processing::processing_form::MAC: {
+                auto reparse_data = h.op_rem_body_mac_r();
                 literals = h.parser->get_collector().take_literals();
 
-                if (h.error_handler->error_reported())
+                line.remarks = std::move(reparse_data.remarks);
+                if (!h.error_handler->error_reported() && !reparse_data.text.empty())
                 {
-                    line.operands.clear();
-                }
-                else if (line.operands.size())
-                {
-                    auto [to_parse, ranges, r] = join_operands(line.operands);
-
                     const auto& h_second = *m_parser_singleline;
-                    h_second.prepare_parser(to_parse,
+                    h_second.prepare_parser(reparse_data.text,
                         m_hlasm_ctx,
                         &add_diag_subst,
-                        semantics::range_provider(
-                            r, std::move(ranges), semantics::adjusting_state::MACRO_REPARSE, h.lex->get_line_limits()),
+                        semantics::range_provider(reparse_data.total_op_range,
+                            std::move(reparse_data.text_ranges),
+                            semantics::adjusting_state::MACRO_REPARSE,
+                            h.lex->get_line_limits()),
                         original_range,
                         logical_column,
                         status,
@@ -105,6 +102,7 @@ statement_fields_parser::parse_result statement_fields_parser::parse_operand_fie
                     literals = h.parser->get_collector().take_literals();
                 }
                 break;
+            }
             case processing::processing_form::ASM:
                 line = h.op_rem_body_asm_r();
                 literals = h.parser->get_collector().take_literals();

diff --git a/parser_library/src/processing/statement_processors/macrodef_processor.cpp b/parser_library/src/processing/statement_processors/macrodef_processor.cpp
@@ -267,7 +267,7 @@ void macrodef_processor::process_prototype_operand(
             continue;
         }
 
-        auto tmp = op->access_mac()->access_chain();
+        auto tmp = op->access_mac();
         assert(tmp);
 
         auto& tmp_chain = tmp->chain;