Working on error output

Author: ratmice

lrlex/src/lib/ctbuilder.rs

@@ -545,6 +545,7 @@ where
                         .collect::<HashMap<_, _>>();
                     closure_lexerdef.set_rule_ids(&owned_map);
                     yacc_header.mark_used(&"test_files".to_string());
+                    let grammar = rtpb.grammar();
                     let test_glob = yacc_header.get("test_files");
                     let mut err_str = None;
                     let add_error_line = |err_str: &mut Option<String>, line| {
@@ -575,13 +576,15 @@ where
                                             let l: LRNonStreamingLexer<LexerTypesT> =
                                                 closure_lexerdef.lexer(&input);
                                             let errs = rtpb.parse_map(&l, &|_| (), &|_, _| ()).1;
-                                            if errs.len() > 1 {
+                                            if !errs.is_empty() {
                                                 add_error_line(&mut err_str, format!("While parsing {}:", path.display()));
                                                 for e in errs {
-                                                    add_error_line(&mut err_str, format!("\t{}", e));
+                                                    let e_pp = e.pp(&l, &|t| grammar.token_epp(t));
+                                                    let e_lines = e_pp.split("\n");
+                                                    for e in e_lines {
+                                                        add_error_line(&mut err_str, format!("\t{}", e));
+                                                    }
                                                 }
-                                            } else if !errs.is_empty() {
-                                                add_error_line(&mut err_str, format!("parsing {}: {}", path.display(), errs[0]));
                                             }
                                         }
                                     }

lrpar/cttests/src/grmtools_section.test

@@ -1,5 +1,9 @@
 grammar: |
-    %grmtools{yacckind: Grmtools}
+    %grmtools{
+        yacckind: Grmtools,
+        recoverer: RecoveryKind::CPCTPlus,
+        test_files: ["*.input_grmtools_section"]
+    }
     %token MAGIC IDENT NUM STRING
     %epp MAGIC "%grmtools"
     %%
@@ -164,3 +168,6 @@ lexer: |
     : ':'
     \"(\\.|[^"\\])*\" 'STRING'
     \p{Pattern_White_Space} ;
+extra_files:
+  test.input_grmtools_section: |
+    %grmtools{yacckind: Grmtools, !b, !a}

lrpar/src/lib/parser.rs

@@ -1037,6 +1037,10 @@ where
             param,
         )
     }
+
+    pub fn grammar(&self) -> &YaccGrammar<StorageT> {
+        self.grm
+    }
 }
 
 /// After a parse error is encountered, the parser attempts to find a way of recovering. Each entry

nimbleparse/src/main.rs

@@ -495,7 +495,7 @@ impl fmt::Display for NimbleparseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Self::Source { src_path, errs } => {
-                writeln!(f, "While parsing: {}", src_path.display())?;
+                writeln!(f, "While parsing {}:", src_path.display())?;
                 for e in errs {
                     writeln!(f, "{}", e)?
                 }