ohm-js 17.4.0 → 17.5.0

package/dist/ohm-extras.cjs

@@ -5215,9 +5215,10 @@ class GrammarDecl {
 // --------------------------------------------------------------------
 
 class Builder {
-  constructor() {
+  constructor(options) {
     this.currentDecl = null;
     this.currentRuleName = null;
+    this.options = options || {};
   }
 
   newGrammar(name) {
@@ -5337,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);
   }
 
@@ -5416,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;
@@ -5871,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().
@@ -5891,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.
@@ -6043,20 +6052,6 @@ function extractExamples(grammarsDef) {
   return semantics(matchResult).examples();
 }
 
-/*
-  To find iter nodes that are derived from the same repetition expression, we
-  look for adjacent iter nodes that have the same source interval and the same
-  number of children.
-
-  A few things to note:
-  - The children of `*` and `+` nodes can't be nullable, so the associated iter
-    nodes always consume some input, and therefore consecutive nodes that have
-    the same interval must come from the same repetition expression.
-  - We *could* mistake `a? b?` for (a b)?`, if neither of them comsume any input.
-    However, for the purposes of this module, those two cases are equivalent
-    anyways, since we only care about finding the correct order of the non-iter
-    nodes, and both interpretations yield the same order.
- */
 const isIterSibling = (refNode, n) => {
   return (
     n.isIteration() &&
@@ -6066,22 +6061,32 @@ const isIterSibling = (refNode, n) => {
   );
 };
 
-function recoverSourceOrder(nodes, depth = 0) {
-  const ans = [];
+function groupIterSiblings(nodes) {
+  const groups = [];
   for (let i = 0; i < nodes.length; i++) {
     const n = nodes[i];
     if (!n.isIteration()) {
-      ans.push(n);
+      groups.push({kind: 'node', node: n});
       continue;
     }
-
-    // We found an iter node, now find its siblings.
     const siblings = [n];
-    // Find the first node that's *not* part of the current list.
     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++) {

package/dist/ohm-extras.js

@@ -5217,9 +5217,10 @@
   // --------------------------------------------------------------------
 
   class Builder {
-    constructor() {
+    constructor(options) {
       this.currentDecl = null;
       this.currentRuleName = null;
+      this.options = options || {};
     }
 
     newGrammar(name) {
@@ -5339,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);
     }
 
@@ -5418,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;
@@ -5873,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().
@@ -5893,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.
@@ -6045,20 +6054,6 @@
     return semantics(matchResult).examples();
   }
 
-  /*
-    To find iter nodes that are derived from the same repetition expression, we
-    look for adjacent iter nodes that have the same source interval and the same
-    number of children.
-
-    A few things to note:
-    - The children of `*` and `+` nodes can't be nullable, so the associated iter
-      nodes always consume some input, and therefore consecutive nodes that have
-      the same interval must come from the same repetition expression.
-    - We *could* mistake `a? b?` for (a b)?`, if neither of them comsume any input.
-      However, for the purposes of this module, those two cases are equivalent
-      anyways, since we only care about finding the correct order of the non-iter
-      nodes, and both interpretations yield the same order.
-   */
   const isIterSibling = (refNode, n) => {
     return (
       n.isIteration() &&
@@ -6068,22 +6063,32 @@
     );
   };
 
-  function recoverSourceOrder(nodes, depth = 0) {
-    const ans = [];
+  function groupIterSiblings(nodes) {
+    const groups = [];
     for (let i = 0; i < nodes.length; i++) {
       const n = nodes[i];
       if (!n.isIteration()) {
-        ans.push(n);
+        groups.push({kind: 'node', node: n});
         continue;
       }
-
-      // We found an iter node, now find its siblings.
       const siblings = [n];
-      // Find the first node that's *not* part of the current list.
       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++) {

package/dist/ohm.cjs

@@ -4950,9 +4950,10 @@ class GrammarDecl {
 // --------------------------------------------------------------------
 
 class Builder {
-  constructor() {
+  constructor(options) {
     this.currentDecl = null;
     this.currentRuleName = null;
+    this.options = options || {};
   }
 
   newGrammar(name) {
@@ -5072,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);
   }
 
@@ -5151,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;
@@ -5600,7 +5605,7 @@ Object.assign(IndentationSensitive, {
 });
 
 // Generated by scripts/prebuild.js
-const version = '17.4.0';
+const version = '17.5.0';
 
 Grammar.initApplicationParser(ohmGrammar, buildGrammar);
 
@@ -5609,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);
@@ -5635,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().
@@ -5647,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;