Allow more than one instruction

peglib.h

@@ -2467,9 +2467,7 @@ inline size_t parse_literal(const char *s, size_t n, SemanticValues &vs,
 }
 
 inline const std::vector<size_t> &SemanticValues::source_line_index() const {
-  if (!c_) {
+  if (!c_) { std::vector<size_t>(); }
-    std::vector<size_t>();
-  }
   if (c_->source_line_index.empty()) {
     for (size_t pos = 0; pos < c_->l; pos++) {
       if (c_->s[pos] == '\n') { c_->source_line_index.push_back(pos); }
@@ -3058,14 +3056,16 @@ private:
   struct Instruction {
     std::string type;
     std::any data;
+    std::string_view sv;
   };
 
   struct Data {
     std::shared_ptr<Grammar> grammar;
     std::string start;
     const char *start_pos = nullptr;
-    std::vector<std::pair<std::string, const char *>> duplicates;
+    std::vector<std::pair<std::string, const char *>> duplicates_of_definition;
-    std::map<std::string, Instruction> instructions;
+    std::vector<std::pair<std::string, const char *>> duplicates_of_instruction;
+    std::map<std::string, std::vector<Instruction>> instructions;
     std::set<std::string_view> captures;
     bool enablePackratParsing = true;
 
@@ -3194,10 +3194,14 @@ private:
     ~g["COMMA"] <= seq(chr(','), g["Spacing"]);
 
     // Instruction grammars
-    g["Instruction"] <= seq(g["BeginBlacket"],
+    g["Instruction"] <=
-                            cho(cho(g["PrecedenceClimbing"]),
+        seq(g["BeginBlacket"],
-                                cho(g["ErrorMessage"]), cho(g["NoAstOpt"])),
+            opt(seq(g["InstructionItem"], zom(seq(g["InstructionItemSeparator"],
+                                                  g["InstructionItem"])))),
             g["EndBlacket"]);
+    g["InstructionItem"] <=
+        cho(g["PrecedenceClimbing"], g["ErrorMessage"], g["NoAstOpt"]);
+    ~g["InstructionItemSeparator"] <= seq(chr(';'), g["Spacing"]);
 
     ~g["SpacesZom"] <= zom(g["Space"]);
     ~g["SpacesOom"] <= oom(g["Space"]);
@@ -3245,16 +3249,34 @@ private:
 
       std::vector<std::string> params;
       std::shared_ptr<Ope> ope;
+      auto has_instructions = false;
+
       if (is_macro) {
         params = std::any_cast<std::vector<std::string>>(vs[2]);
         ope = std::any_cast<std::shared_ptr<Ope>>(vs[4]);
         if (vs.size() == 6) {
-          data.instructions[name] = std::any_cast<Instruction>(vs[5]);
+          has_instructions = true;
         }
       } else {
         ope = std::any_cast<std::shared_ptr<Ope>>(vs[3]);
         if (vs.size() == 5) {
-          data.instructions[name] = std::any_cast<Instruction>(vs[4]);
+          has_instructions = true;
+        }
+      }
+
+      if (has_instructions) {
+        auto index = is_macro ? 5 : 4;
+        std::set<std::string> types;
+        for (const auto &instruction :
+             std::any_cast<std::vector<Instruction>>(vs[index])) {
+          const auto &type = instruction.type;
+          if (types.find(type) == types.end()) {
+            data.instructions[name].push_back(instruction);
+            types.insert(instruction.type);
+          } else {
+            // data.duplicates_of_instruction.emplace_back(type, vs.sv().data());
+            data.duplicates_of_instruction.emplace_back(type, instruction.sv.data());
+          }
         }
       }
 
@@ -3273,7 +3295,7 @@ private:
           data.start_pos = vs.sv().data();
         }
       } else {
-        data.duplicates.emplace_back(name, vs.sv().data());
+        data.duplicates_of_definition.emplace_back(name, vs.sv().data());
       }
     };
 
@@ -3548,6 +3570,7 @@ private:
       Instruction instruction;
       instruction.type = "precedence";
       instruction.data = binOpeInfo;
+      instruction.sv = vs.sv();
       return instruction;
     };
     g["PrecedenceInfo"] = [](const SemanticValues &vs) {
@@ -3560,14 +3583,20 @@ private:
       Instruction instruction;
       instruction.type = "message";
       instruction.data = std::any_cast<std::string>(vs[0]);
+      instruction.sv = vs.sv();
       return instruction;
     };
 
-    g["NoAstOpt"] = [](const SemanticValues & /*vs*/) {
+    g["NoAstOpt"] = [](const SemanticValues & vs) {
       Instruction instruction;
       instruction.type = "no_ast_opt";
+      instruction.sv = vs.sv();
       return instruction;
     };
+
+    g["Instruction"] = [](const SemanticValues &vs) {
+      return vs.transform<Instruction>();
+    };
   }
 
   bool apply_precedence_instruction(Definition &rule,
@@ -3662,14 +3691,28 @@ private:
     }
 
     // Check duplicated definitions
-    auto ret = data.duplicates.empty();
+    auto ret = true;
 
-    for (const auto &[name, ptr] : data.duplicates) {
+    if (!data.duplicates_of_definition.empty()) {
+      for (const auto &[name, ptr] : data.duplicates_of_definition) {
         if (log) {
           auto line = line_info(s, ptr);
-        log(line.first, line.second, "'" + name + "' is already defined.");
+          log(line.first, line.second, "The definition '" + name + "' is already defined.");
         }
       }
+      ret = false;
+    }
+
+    // Check duplicated instructions
+    if (!data.duplicates_of_instruction.empty()) {
+      for (const auto &[type, ptr] : data.duplicates_of_instruction) {
+        if (log) {
+          auto line = line_info(s, ptr);
+          log(line.first, line.second, "The instruction '" + type + "' is already defined.");
+        }
+      }
+      ret = false;
+    }
 
     // Set root definition
     auto &start_rule = grammar[data.start];
@@ -3778,9 +3821,10 @@ private:
     }
 
     // Apply instructions
-    for (const auto &[name, instruction] : data.instructions) {
+    for (const auto &[name, instructions] : data.instructions) {
       auto &rule = grammar[name];
 
+      for (const auto& instruction: instructions) {
         if (instruction.type == "precedence") {
           const auto &info =
               std::any_cast<PrecedenceClimbing::BinOpeInfo>(instruction.data);
@@ -3794,6 +3838,7 @@ private:
           rule.no_ast_opt = true;
         }
       }
+    }
 
     // Set root definition
     start = data.start;