occam-parsers 23.0.52 → 23.0.54

package/src/node/bnf/terminalSymbol.js

@@ -12,7 +12,7 @@ const { first, second } = arrayUtilities;
 export default class TerminalSymbolBNFNode extends NonTerminalNode {
   regularExpression = /^"((?:\\.|[^"\\])*)"$/;
 
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const content = this.getContent(),
           terminalSymbolPart = TerminalSymbolPart.fromContent(content);
 

package/src/node/bnf/wildcard.js

@@ -4,7 +4,7 @@ import WildcardPart from "../../part/terminal/wildcard";
 import NonTerminalNode from "../../node/nonTerminal";
 
 export default class WildcardBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const wildcardPart = WildcardPart.fromNothing();
 
     return wildcardPart;

package/src/part/nonTerminal/choiceOfParts.js

@@ -6,8 +6,8 @@ import { parsePart } from "../../utilities/parse";
 import { ChoiceOfPartsPartType } from "../../partTypes";
 
 export default class ChoiceOfPartsPart extends NonTerminalPart {
-  constructor(type, lookAhead, partChoices) {
-    super(type, lookAhead);
+  constructor(type, callAhead, partChoices) {
+    super(type, callAhead);
     
     this.partChoices = partChoices;
   }
@@ -92,8 +92,8 @@ export default class ChoiceOfPartsPart extends NonTerminalPart {
 
   static fromPartChoices(partChoices) {
     const type = ChoiceOfPartsPartType,
-          lookAhead = false,
-          choiceOfPartsPart = new ChoiceOfPartsPart(type, lookAhead, partChoices);
+          callAhead = false,
+          choiceOfPartsPart = new ChoiceOfPartsPart(type, callAhead, partChoices);
 
     return choiceOfPartsPart;
   }

package/src/part/nonTerminal/oneOrMoreParts.js

@@ -10,8 +10,8 @@ import { parseZeroOrMorePartsPart } from "./zeroOrMoreParts";
 const { plus } = specialSymbols;
 
 export default class OneOrMorePartsPart extends NonTerminalPart {
-  constructor(type, lookAhead, part) {
-    super(type, lookAhead);
+  constructor(type, callAhead, part) {
+    super(type, callAhead);
 
     this.part = part;
   }
@@ -48,8 +48,8 @@ export default class OneOrMorePartsPart extends NonTerminalPart {
 
   static fromPart(part) {
     const type = OneOrMorePartsPartType,
-          lookAhead = false,
-          oneOrMorePartsPart = new OneOrMorePartsPart(type, lookAhead, part);
+          callAhead = false,
+          oneOrMorePartsPart = new OneOrMorePartsPart(type, callAhead, part);
 
     return oneOrMorePartsPart;
   }

package/src/part/nonTerminal/optionalPart.js

@@ -10,8 +10,8 @@ import { OptionalPartPartType } from "../../partTypes";
 const { questionMark } = specialSymbols;
 
 export default class OptionalPartPart extends NonTerminalPart {
-  constructor(type, lookAhead, part) {
-    super(type, lookAhead);
+  constructor(type, callAhead, part) {
+    super(type, callAhead);
 
     this.part = part;
   }
@@ -48,8 +48,8 @@ export default class OptionalPartPart extends NonTerminalPart {
 
   static fromPart(part) {
     const type = OptionalPartPartType,
-          lookAhead = false,
-          optionalPartPart = new OptionalPartPart(type, lookAhead, part);
+          callAhead = false,
+          optionalPartPart = new OptionalPartPart(type, callAhead, part);
 
     return optionalPartPart;
   }

package/src/part/nonTerminal/ruleName.js

@@ -10,8 +10,8 @@ import { RuleNamePartType } from "../../partTypes";
 const { ellipsis } = specialSymbols;
 
 export default class RuleNamePart extends NonTerminalPart {
-  constructor(type, lookAhead, ruleName) {
-    super(type, lookAhead);
+  constructor(type, callAAhead, ruleName) {
+    super(type, callAAhead);
 
     this.ruleName = ruleName;
   }
@@ -46,26 +46,26 @@ export default class RuleNamePart extends NonTerminalPart {
   }
 
   asString() {
-    const lookAhead = this.isLookAhead(),
-          lookAheadString = lookAhead ?
+    const callAAhead = this.isCallAhead(),
+          callAAheadString = callAAhead ?
                               ellipsis :
                                 EMPTY_STRING,
-          string = `${this.ruleName}${lookAheadString}`;
+          string = `${this.ruleName}${callAAheadString}`;
 
     return string;
   }
 
   static fromRuleName(ruleName) {
     const type = RuleNamePartType,
-          lookAhead = false,
-          ruleNamePart = new RuleNamePart(type, lookAhead, ruleName);
+          callAAhead = false,
+          ruleNamePart = new RuleNamePart(type, callAAhead, ruleName);
 
     return ruleNamePart;
   }
 
-  static fromLookAheadAndRuleName(lookAhead, ruleName) {
+  static fromCallAheadAndRuleName(callAAhead, ruleName) {
     const type = RuleNamePartType,
-          ruleNamePart = new RuleNamePart(type, lookAhead, ruleName);
+          ruleNamePart = new RuleNamePart(type, callAAhead, ruleName);
 
     return ruleNamePart;
   }

package/src/part/nonTerminal/sequenceOfParts.js

@@ -6,8 +6,8 @@ import { parseParts } from "../../utilities/parse";
 import { SequenceOfPartsPartType } from "../../partTypes";
 
 export default class SequenceOfPartsPart extends NonTerminalPart {
-  constructor(type, lookAhead, parts) {
-    super(type, lookAhead);
+  constructor(type, callAhead, parts) {
+    super(type, callAhead);
 
     this.parts = parts;
   }
@@ -64,8 +64,8 @@ export default class SequenceOfPartsPart extends NonTerminalPart {
 
   static fromParts(parts) {
     const type = SequenceOfPartsPartType,
-          lookAhead = false,
-          sequenceOfPartsPart = new SequenceOfPartsPart(type, lookAhead, parts);
+          callAhead = false,
+          sequenceOfPartsPart = new SequenceOfPartsPart(type, callAhead, parts);
 
     return sequenceOfPartsPart;
   }

package/src/part/nonTerminal/zeroOrMoreParts.js

@@ -10,8 +10,8 @@ import { ZeroOrMorePartsPartType } from "../../partTypes";
 const { asterisk } = specialSymbols;
 
 export default class ZeroOrMorePartsPart extends NonTerminalPart {
-  constructor(type, lookAhead, part) {
-    super(type, lookAhead);
+  constructor(type, callAhead, part) {
+    super(type, callAhead);
 
     this.part = part;
   }
@@ -48,8 +48,8 @@ export default class ZeroOrMorePartsPart extends NonTerminalPart {
 
   static fromPart(part) {
     const type = ZeroOrMorePartsPartType,
-          lookAhead = false,
-          zeroOrMorePartsPart = new ZeroOrMorePartsPart(type, lookAhead, part);
+          callAhead = false,
+          zeroOrMorePartsPart = new ZeroOrMorePartsPart(type, callAhead, part);
 
     return zeroOrMorePartsPart;
   }

package/src/part/nonTerminal.js

@@ -1,17 +1,17 @@
 "use strict";
 
 export default class NonTerminalPart {
-  constructor(type, lookAhead) {
+  constructor(type, callAhead) {
     this.type = type;
-    this.lookAhead = lookAhead;
+    this.callAhead = callAhead;
   }
   
   getType() {
     return this.type;
   }
 
-  isLookAhead() {
-    return this.lookAhead;
+  isCallAhead() {
+    return this.callAhead;
   }
 
   isNonTerminalPart() {

package/src/part/terminal.js

@@ -1,10 +1,10 @@
 "use strict";
 
 export default class TerminalPart {
-  isLookAhead() {
-    const lookAhead = false;
+  isCallAhead() {
+    const callAhead = false;
 
-    return lookAhead;
+    return callAhead;
   }
 
   isNonTerminalPart() {

package/src/rule/callAheadModifier.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import Rule from "../rule";
+import CallAheadModifierBNFNode from "../node/bnf/callAheadModifier";
+import CallAheadModifierRuleDefinition from "../definition/callAheadModifierRule";
+
+import { callAheadModifierRuleName } from "../ruleNames";
+
+export default class CallAheadModifierRule extends Rule {
+  static fromNothing() {
+    const name = callAheadModifierRuleName, ///
+          callAheadModifierRuleDefinition = CallAheadModifierRuleDefinition.fromNothing(),
+          opacity = null,
+          definitions = [
+            callAheadModifierRuleDefinition
+          ],
+          NonTerminalNode = CallAheadModifierBNFNode,  ///
+          callAheadModifierRule = new CallAheadModifierRule(name, opacity, definitions, NonTerminalNode);
+
+    return callAheadModifierRule;
+  }
+}

package/src/rule.js

@@ -4,7 +4,7 @@ import { EMPTY_STRING } from "./constants";
 import { specialSymbols } from "occam-lexers";
 import { paddingFromPaddingLength } from "./utilities/string";
 
-const { opaque : opaqueSpecialSymbol , semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
+const { opaque: opaqueSpecialSymbol, semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
 
 export default class Rule {
   constructor(name, opacity, definitions, NonTerminalNode) {
@@ -46,6 +46,15 @@ export default class Rule {
     this.NonTerminalNode = NonTerminalNode;
   }
 
+  createNonTerminalNode() {
+    const opacity = this.opacity,
+          ruleName = this.name, ///
+          childNodes = [],
+          nonTerminalNode = this.NonTerminalNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity);
+
+    return nonTerminalNode;
+  }
+
   isOpaque() {
     const opaque = (this.opacity === opaqueSpecialSymbol);
 
@@ -64,24 +73,19 @@ export default class Rule {
     const savedPrecedence = state.getSavedPrecedence();
 
     parsed = this.definitions.some((definition) => {
-      let node,
-          nonTerminalNode;
-
-      const ruleName = this.name,
-            opacity = this.opacity,
-            childNodes = [];
-
-      nonTerminalNode = this.NonTerminalNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity);
+      let parsed;
 
-      const precedence = definition.getPrecedence();
+      let nonTerminalNode = this.createNonTerminalNode(),
+          node = nonTerminalNode; ///
 
-      node = nonTerminalNode; ///
+      const precedence = definition.getPrecedence(),
+            childNodes = nonTerminalNode.getChildNodes();
 
       nodes.push(node);
 
       state.setPrecedence(precedence);
 
-      const parsed = definition.parse(childNodes, state, () => {
+      callback = () => {  ///
         let parsed;
 
         parsed = true;
@@ -137,12 +141,14 @@ export default class Rule {
         }
 
         return parsed;
-      }, callAhead);
+      };
 
-      if (!parsed) {
-        nodes.pop();
+      parsed = definition.parse(childNodes, state, callback, callAhead);
 
+      if (!parsed) {
         state.resetPrecedence(savedPrecedence);
+
+        nodes.pop();
       }
 
       return parsed;

package/src/ruleNames.js

@@ -21,7 +21,7 @@ export const nonTerminalPartRuleName = "nonTerminalPart";
 export const sequenceOfPartsRuleName = "sequenceOfParts";
 export const opacityModifierRuleName = "opacityModifier";
 export const noWhitespacePartRuleName = "noWhitespace";
-export const lookAheadModifierRuleName = "lookAheadModifier";
+export const CallAheadModifierRuleName = "callAheadModifier";
 export const regularExpressionRuleName = "regularExpression";
 export const optionalQuantifierRuleName = "optionalQuantifier";
 export const startOfContentPartRuleName = "startOfContent";

package/src/utilities/bnf.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import { ruleNameRuleName, quantifierRuleName, lookAheadModifierRuleName } from "../ruleNames";
+import { ruleNameRuleName, quantifierRuleName, callAheadModifierRuleName } from "../ruleNames";
 
 const { first } = arrayUtilities;
 
@@ -53,20 +53,20 @@ export function isNodeQuantifierNode(node) {
   return nodeQuantifierNode;
 }
 
-export function isNodeLookAheadModifierNode(node) {
-  let nodeLookAheadModifierNode = false;
+export function isNodeCallAheadModifierNode(node) {
+  let nodeCallAheadModifierNode = false;
 
   const nodeNonTerminalNode = node.isNonTerminalNode();
 
   if (nodeNonTerminalNode) {
     const nonTerminalNode = node, ///
           ruleName = nonTerminalNode.getRuleName(),
-          ruleNameLookAheadModifierRuleName = (ruleName === lookAheadModifierRuleName);
+          ruleNameCallAheadModifierRuleName = (ruleName === callAheadModifierRuleName);
 
-    nodeLookAheadModifierNode = ruleNameLookAheadModifierRuleName;  ///
+    nodeCallAheadModifierNode = ruleNameCallAheadModifierRuleName;  ///
   }
 
-  return nodeLookAheadModifierNode;
+  return nodeCallAheadModifierNode;
 
 }
 

package/src/utilities/parse.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-const { push } = arrayUtilities;
+const { push, clear } = arrayUtilities;
 
 export function parsePart(part, nodes, state, callback, callAhead) {
   let parsed;
@@ -37,44 +37,54 @@ function parsePartOfParts(index, parts, nodes, state, callback, callAhead) {
                callback() :
                  true;
   } else {
-    const part = parts[index];
+    const part = parts[index],
+          partCallAhead = (callAhead === null) ?
+                            part.isCallAhead() :
+                              true;
 
     index++;
 
-    if (callAhead === null) {
-      const partLookAhead = part.isLookAhead();
+    parsed = partCallAhead ?
+               parsePartWithCallAhead(part, index, parts, nodes, state, callback, callAhead) :
+                 parsePartWithoutCallAhead(part, index, parts, nodes, state, callback, callAhead);
+  }
+
+  return parsed;
+}
+
+function parsePartWithCallAhead(part, index, parts, nodes, state, callback, callAhead) {
+  let parsed;
+
+  const partNodes = [];
 
-      if (partLookAhead) {
-        let partNodes;
+  callAhead = () => { ///
+    let parsed;
 
-        parsed = part.parse(nodes, state, callback, () => {
-          partNodes = [];
+    clear(partNodes);
 
-          const nodes = partNodes,  ///
-                parsed = parsePartOfParts(index, parts, nodes, state, callback, callAhead);
+    const nodes = partNodes;  ///
 
-          return parsed;
-        });
+    parsed = parsePartOfParts(index, parts, nodes, state, callback, callAhead);
 
-        if (parsed) {
-          push(nodes, partNodes);
-        }
-      } else {
-        parsed = part.parse(nodes, state, callback, callAhead);
+    return parsed;
+  };
 
-        if (parsed) {
-          parsed = parsePartOfParts(index, parts, nodes, state, callback, callAhead);
-        }
-      }
-    } else {
-      parsed = part.parse(nodes, state, callback, () => {
-        let parsed;
+  parsed = part.parse(nodes, state, callback, callAhead);
+
+  if (parsed) {
+    push(nodes, partNodes);
+  }
+
+  return parsed;
+}
+
+function parsePartWithoutCallAhead(part, index, parts, nodes, state, callback, callAhead) {
+  let parsed;
 
-        parsed = parsePartOfParts(index, parts, nodes, state, callback, callAhead);
+  parsed = part.parse(nodes, state, callback, callAhead);
 
-        return parsed;
-      });
-    }
+  if (parsed) {
+    parsed = parsePartOfParts(index, parts, nodes, state, callback, callAhead);
   }
 
   return parsed;

package/src/node/bnf/lookAheadModifier.js

@@ -1,7 +0,0 @@
-"use strict";
-
-import NonTerminalNode from "../../node/nonTerminal";
-
-export default class LookAheadModifierBNFNode extends NonTerminalNode {
-  static fromRuleNameChildNodesAndLookAhead(ruleName, childNode, opacity) { return NonTerminalNode.fromRuleNameChildNodesAndLookAhead(LookAheadModifierBNFNode, ruleName, childNode, opacity); }
-}

package/src/rule/lookAheadModifier.js

@@ -1,22 +0,0 @@
-"use strict";
-
-import Rule from "../rule";
-import LookAheadModifierBNFNode from "../node/bnf/lookAheadModifier";
-import LookAheadModifierRuleDefinition from "../definition/lookAheadModifierRule";
-
-import { lookAheadModifierRuleName } from "../ruleNames";
-
-export default class LookAheadModifierRule extends Rule {
-  static fromNothing() {
-    const name = lookAheadModifierRuleName, ///
-          lookAheadModifierRuleDefinition = LookAheadModifierRuleDefinition.fromNothing(),
-          opacity = null,
-          definitions = [
-            lookAheadModifierRuleDefinition
-          ],
-          NonTerminalNode = LookAheadModifierBNFNode,  ///
-          lookAheadModifierRule = new LookAheadModifierRule(name, opacity, definitions, NonTerminalNode);
-
-    return lookAheadModifierRule;
-  }
-}