ohm-js 17.3.0 → 17.5.0

package/dist/ohm-extras.cjs

@@ -2567,6 +2567,7 @@ Apply.prototype.reallyEval = function (state) {
     }
     if (memoRec) {
       memoRec.failuresAtRightmostPosition = state.cloneRecordedFailures();
+      memoRec.rightmostFailureOffset = state._getRightmostFailureOffset();
     }
   }
 
@@ -5214,9 +5215,10 @@ class GrammarDecl {
 // --------------------------------------------------------------------
 
 class Builder {
-  constructor() {
+  constructor(options) {
     this.currentDecl = null;
     this.currentRuleName = null;
+    this.options = options || {};
   }
 
   newGrammar(name) {
@@ -5336,6 +5338,10 @@ class Builder {
     if (!(expr instanceof PExpr)) {
       expr = this.fromRecipe(expr);
     }
+    // For v18 compatibility, where we don't want a binding for lookahead.
+    if (this.options.eliminateLookaheads) {
+      return new Not(new Not(expr));
+    }
     return new Lookahead(expr);
   }
 
@@ -5415,8 +5421,8 @@ function namespaceHas(ns, name) {
 // `tree`, which is the concrete syntax tree of a user-written grammar.
 // The grammar will be assigned into `namespace` under the name of the grammar
 // as specified in the source.
-function buildGrammar(match, namespace, optOhmGrammarForTesting) {
-  const builder = new Builder();
+function buildGrammar(match, namespace, optOhmGrammarForTesting, options) {
+  const builder = new Builder(options);
   let decl;
   let currentRuleName;
   let currentRuleFormals;
@@ -5870,15 +5876,15 @@ const isBuffer = obj =>
   typeof obj.constructor.isBuffer === 'function' &&
   obj.constructor.isBuffer(obj);
 
-function compileAndLoad(source, namespace) {
+function compileAndLoad(source, namespace, buildOptions) {
   const m = ohmGrammar.match(source, 'Grammars');
   if (m.failed()) {
     throw grammarSyntaxError(m);
   }
-  return buildGrammar(m, namespace);
+  return buildGrammar(m, namespace, undefined, buildOptions);
 }
 
-function grammars$1(source, optNamespace) {
+function _grammars(source, optNamespace, buildOptions) {
   const ns = Object.create(optNamespace || {});
   if (typeof source !== 'string') {
     // For convenience, detect Node.js Buffer objects and automatically call toString().
@@ -5890,10 +5896,14 @@ function grammars$1(source, optNamespace) {
       );
     }
   }
-  compileAndLoad(source, ns);
+  compileAndLoad(source, ns, buildOptions);
   return ns;
 }
 
+function grammars$1(source, optNamespace) {
+  return _grammars(source, optNamespace);
+}
+
 const grammarsSource = String.raw`
   /*
     Superset of the Ohm grammar that allows examples to be embedded in comments.
@@ -6042,9 +6052,55 @@ function extractExamples(grammarsDef) {
   return semantics(matchResult).examples();
 }
 
+const isIterSibling = (refNode, n) => {
+  return (
+    n.isIteration() &&
+    n.source.startIdx === refNode.source.startIdx &&
+    n.source.endIdx === refNode.source.endIdx &&
+    n.children.length === refNode.children.length
+  );
+};
+
+function groupIterSiblings(nodes) {
+  const groups = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (!n.isIteration()) {
+      groups.push({kind: 'node', node: n});
+      continue;
+    }
+    const siblings = [n];
+    for (let j = i + 1; j < nodes.length && isIterSibling(n, nodes[j]); j++) {
+      siblings.push(nodes[j]);
+      i = j;
+    }
+    groups.push({kind: 'iter', siblings});
+  }
+  return groups;
+}
+
+function recoverSourceOrder(nodes, depth = 0) {
+  const ans = [];
+  for (const group of groupIterSiblings(nodes)) {
+    if (group.kind === 'node') {
+      ans.push(group.node);
+      continue;
+    }
+    const {siblings} = group;
+    const cousins = [];
+    const numRows = siblings[0].children.length;
+    for (let row = 0; row < numRows; row++) {
+      cousins.push(...siblings.map(sib => sib.children[row]));
+    }
+    ans.push(...recoverSourceOrder(cousins, depth + 1));
+  }
+  return ans;
+}
+
 exports.VisitorFamily = VisitorFamily;
 exports.extractExamples = extractExamples;
 exports.getLineAndColumn = getLineAndColumn;
 exports.getLineAndColumnMessage = getLineAndColumnMessage;
+exports.recoverSourceOrder = recoverSourceOrder;
 exports.semanticsForToAST = semanticsForToAST;
 exports.toAST = toAST;

package/dist/ohm-extras.js

@@ -2569,6 +2569,7 @@
       }
       if (memoRec) {
         memoRec.failuresAtRightmostPosition = state.cloneRecordedFailures();
+        memoRec.rightmostFailureOffset = state._getRightmostFailureOffset();
       }
     }
 
@@ -5216,9 +5217,10 @@
   // --------------------------------------------------------------------
 
   class Builder {
-    constructor() {
+    constructor(options) {
       this.currentDecl = null;
       this.currentRuleName = null;
+      this.options = options || {};
     }
 
     newGrammar(name) {
@@ -5338,6 +5340,10 @@
       if (!(expr instanceof PExpr)) {
         expr = this.fromRecipe(expr);
       }
+      // For v18 compatibility, where we don't want a binding for lookahead.
+      if (this.options.eliminateLookaheads) {
+        return new Not(new Not(expr));
+      }
       return new Lookahead(expr);
     }
 
@@ -5417,8 +5423,8 @@
   // `tree`, which is the concrete syntax tree of a user-written grammar.
   // The grammar will be assigned into `namespace` under the name of the grammar
   // as specified in the source.
-  function buildGrammar(match, namespace, optOhmGrammarForTesting) {
-    const builder = new Builder();
+  function buildGrammar(match, namespace, optOhmGrammarForTesting, options) {
+    const builder = new Builder(options);
     let decl;
     let currentRuleName;
     let currentRuleFormals;
@@ -5872,15 +5878,15 @@
     typeof obj.constructor.isBuffer === 'function' &&
     obj.constructor.isBuffer(obj);
 
-  function compileAndLoad(source, namespace) {
+  function compileAndLoad(source, namespace, buildOptions) {
     const m = ohmGrammar.match(source, 'Grammars');
     if (m.failed()) {
       throw grammarSyntaxError(m);
     }
-    return buildGrammar(m, namespace);
+    return buildGrammar(m, namespace, undefined, buildOptions);
   }
 
-  function grammars$1(source, optNamespace) {
+  function _grammars(source, optNamespace, buildOptions) {
     const ns = Object.create(optNamespace || {});
     if (typeof source !== 'string') {
       // For convenience, detect Node.js Buffer objects and automatically call toString().
@@ -5892,10 +5898,14 @@
         );
       }
     }
-    compileAndLoad(source, ns);
+    compileAndLoad(source, ns, buildOptions);
     return ns;
   }
 
+  function grammars$1(source, optNamespace) {
+    return _grammars(source, optNamespace);
+  }
+
   const grammarsSource = String.raw`
   /*
     Superset of the Ohm grammar that allows examples to be embedded in comments.
@@ -6044,10 +6054,56 @@
     return semantics(matchResult).examples();
   }
 
+  const isIterSibling = (refNode, n) => {
+    return (
+      n.isIteration() &&
+      n.source.startIdx === refNode.source.startIdx &&
+      n.source.endIdx === refNode.source.endIdx &&
+      n.children.length === refNode.children.length
+    );
+  };
+
+  function groupIterSiblings(nodes) {
+    const groups = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const n = nodes[i];
+      if (!n.isIteration()) {
+        groups.push({kind: 'node', node: n});
+        continue;
+      }
+      const siblings = [n];
+      for (let j = i + 1; j < nodes.length && isIterSibling(n, nodes[j]); j++) {
+        siblings.push(nodes[j]);
+        i = j;
+      }
+      groups.push({kind: 'iter', siblings});
+    }
+    return groups;
+  }
+
+  function recoverSourceOrder(nodes, depth = 0) {
+    const ans = [];
+    for (const group of groupIterSiblings(nodes)) {
+      if (group.kind === 'node') {
+        ans.push(group.node);
+        continue;
+      }
+      const {siblings} = group;
+      const cousins = [];
+      const numRows = siblings[0].children.length;
+      for (let row = 0; row < numRows; row++) {
+        cousins.push(...siblings.map(sib => sib.children[row]));
+      }
+      ans.push(...recoverSourceOrder(cousins, depth + 1));
+    }
+    return ans;
+  }
+
   exports.VisitorFamily = VisitorFamily;
   exports.extractExamples = extractExamples;
   exports.getLineAndColumn = getLineAndColumn;
   exports.getLineAndColumnMessage = getLineAndColumnMessage;
+  exports.recoverSourceOrder = recoverSourceOrder;
   exports.semanticsForToAST = semanticsForToAST;
   exports.toAST = toAST;
 

package/dist/ohm.cjs

@@ -2276,6 +2276,7 @@ Apply.prototype.reallyEval = function (state) {
     }
     if (memoRec) {
       memoRec.failuresAtRightmostPosition = state.cloneRecordedFailures();
+      memoRec.rightmostFailureOffset = state._getRightmostFailureOffset();
     }
   }
 
@@ -4949,9 +4950,10 @@ class GrammarDecl {
 // --------------------------------------------------------------------
 
 class Builder {
-  constructor() {
+  constructor(options) {
     this.currentDecl = null;
     this.currentRuleName = null;
+    this.options = options || {};
   }
 
   newGrammar(name) {
@@ -5071,6 +5073,10 @@ class Builder {
     if (!(expr instanceof PExpr)) {
       expr = this.fromRecipe(expr);
     }
+    // For v18 compatibility, where we don't want a binding for lookahead.
+    if (this.options.eliminateLookaheads) {
+      return new Not(new Not(expr));
+    }
     return new Lookahead(expr);
   }
 
@@ -5150,8 +5156,8 @@ function namespaceHas(ns, name) {
 // `tree`, which is the concrete syntax tree of a user-written grammar.
 // The grammar will be assigned into `namespace` under the name of the grammar
 // as specified in the source.
-function buildGrammar(match, namespace, optOhmGrammarForTesting) {
-  const builder = new Builder();
+function buildGrammar(match, namespace, optOhmGrammarForTesting, options) {
+  const builder = new Builder(options);
   let decl;
   let currentRuleName;
   let currentRuleFormals;
@@ -5599,7 +5605,7 @@ Object.assign(IndentationSensitive, {
 });
 
 // Generated by scripts/prebuild.js
-const version = '17.3.0';
+const version = '17.5.0';
 
 Grammar.initApplicationParser(ohmGrammar, buildGrammar);
 
@@ -5608,16 +5614,16 @@ const isBuffer = obj =>
   typeof obj.constructor.isBuffer === 'function' &&
   obj.constructor.isBuffer(obj);
 
-function compileAndLoad(source, namespace) {
+function compileAndLoad(source, namespace, buildOptions) {
   const m = ohmGrammar.match(source, 'Grammars');
   if (m.failed()) {
     throw grammarSyntaxError(m);
   }
-  return buildGrammar(m, namespace);
+  return buildGrammar(m, namespace, undefined, buildOptions);
 }
 
-function grammar(source, optNamespace) {
-  const ns = grammars(source, optNamespace);
+function _grammar(source, optNamespace, buildOptions) {
+  const ns = _grammars(source, optNamespace, buildOptions);
 
   // Ensure that the source contained no more than one grammar definition.
   const grammarNames = Object.keys(ns);
@@ -5634,7 +5640,7 @@ function grammar(source, optNamespace) {
   return ns[grammarNames[0]]; // Return the one and only grammar.
 }
 
-function grammars(source, optNamespace) {
+function _grammars(source, optNamespace, buildOptions) {
   const ns = Object.create(optNamespace || {});
   if (typeof source !== 'string') {
     // For convenience, detect Node.js Buffer objects and automatically call toString().
@@ -5646,10 +5652,18 @@ function grammars(source, optNamespace) {
       );
     }
   }
-  compileAndLoad(source, ns);
+  compileAndLoad(source, ns, buildOptions);
   return ns;
 }
 
+function grammar(source, optNamespace) {
+  return _grammar(source, optNamespace);
+}
+
+function grammars(source, optNamespace) {
+  return _grammars(source, optNamespace);
+}
+
 exports.ExperimentalIndentationSensitive = IndentationSensitive;
 exports._buildGrammar = buildGrammar;
 exports.grammar = grammar;