parser kernel: when parseError() produces a return value (i.e. return value is NOT undefined) while executing a parse error recovery, exit the parse process with that value anyway, even when the parse itself would otherwise be recoverable.

In other words: whn your custom `parseError()` handler DOES NOT check the `hash.recoverable` flag AND produces a non-`undefined` return value, you will always have the `parse()` call terminate the parse and return said return value to the caller.

(This change also 'beautifies'/'shortens' the `yylloc` dump sections in any `yydebug()` debug lines.)

Author: GerHobbelt

lib/jison-parser-kernel.js

@@ -165,7 +165,11 @@ function parse(input, parseParams) {
                     } else {
                         re1 = new XRegExp('  \"([\\p{Alphabetic}_][\\p{Alphabetic}\\p{Number}_. ]*)\": ', 'g');
                     }
-                    js = JSON.stringify(obj, null, 2).replace(re1, '  $1: ').replace(/[\n\s]+/g, ' ');
+                    js = JSON.stringify(obj, null, 2)
+                    .replace(re1, '  $1: ')
+                    .replace(/[\n\s]+/g, ' ')
+                    // shorten yylloc object dumps too:
+                    .replace(/\{ first_line: (\d+), first_column: (\d+), last_line: (\d+), last_column: (\d+)/g, '{L/C: ($1,$2)..($3,$4)');
                 } catch (ex) {
                     js = String(obj);
                 }
@@ -233,8 +237,7 @@ function parse(input, parseParams) {
                 hash.extra_error_attributes = args;
             }
 
-            var r = this.parseError(str, hash, this.JisonParserError);
-            return r;
+            return this.parseError(str, hash, this.JisonParserError);
         };
     }
 
@@ -885,16 +888,18 @@ function parse(input, parseParams) {
                         // invoke the parser's cleanup API!
                         recoveringErrorInfo = this.shallowCopyErrorInfo(p);
 
+                        if (yydebug) yydebug('error recovery rule detected: ', { error_rule_depth: error_rule_depth, error: p.errStr, error_hash: p });
+
                         r = this.parseError(p.errStr, p, this.JisonParserError);
+                        if (typeof r !== 'undefined') {
+                            retval = r;
+                            break;
+                        }
 
-                        if (yydebug) yydebug('error recovery rule detected: ', { error_rule_depth: error_rule_depth, error: p.errStr, error_hash: p });
                         // Protect against overly blunt userland `parseError` code which *sets*
                         // the `recoverable` flag without properly checking first:
                         // we always terminate the parse when there's no recovery rule available anyhow!
                         if (!p.recoverable || error_rule_depth < 0) {
-                            if (typeof r !== 'undefined') {
-                                retval = r;
-                            }
                             break;
                         } else {
                             // TODO: allow parseError callback to edit symbol and or state at the start of the error recovery process...
@@ -1470,13 +1475,12 @@ function parse(input, parseParams) {
         else if (lexer && typeof lexer.JisonLexerError === 'function' && ex instanceof lexer.JisonLexerError) {
             throw ex;
         }
-        else {
-            p = this.constructParseErrorInfo('Parsing aborted due to exception.', ex, null, false);
-            retval = false;
-            r = this.parseError(p.errStr, p, this.JisonParserError);
-            if (typeof r !== 'undefined') {
-                retval = r;
-            }
+
+        p = this.constructParseErrorInfo('Parsing aborted due to exception.', ex, null, false);
+        retval = false;
+        r = this.parseError(p.errStr, p, this.JisonParserError);
+        if (typeof r !== 'undefined') {
+            retval = r;
         }
     } finally {
         retval = this.cleanupAfterParse(retval, true, true);