occam-parsers 23.0.53 → 23.0.55

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

@@ -1,10 +1,13 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import { EMPTY_STRING } from "./constants";
 import { specialSymbols } from "occam-lexers";
 import { paddingFromPaddingLength } from "./utilities/string";
 
-const { opaque : opaqueSpecialSymbol , semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
+const { clear } = arrayUtilities,
+      { opaque: opaqueSpecialSymbol, semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
 
 export default class Rule {
   constructor(name, opacity, definitions, NonTerminalNode) {
@@ -61,27 +64,26 @@ export default class Rule {
   parse(nodes, state, callback, callAhead) {
     let parsed;
 
-    const savedPrecedence = state.getSavedPrecedence();
-
-    parsed = this.definitions.some((definition) => {
-      let node,
-          nonTerminalNode;
+    const opacity = this.opacity,
+          ruleName = this.name, ///
+          childNodes = [],
+          nonTerminalNode = this.NonTerminalNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity),
+          savedPrecedence = state.getSavedPrecedence();
 
-      const ruleName = this.name,
-            opacity = this.opacity,
-            childNodes = [];
+    let node = nonTerminalNode; ///
 
-      nonTerminalNode = this.NonTerminalNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity);
+    nodes.push(node);
 
-      const precedence = definition.getPrecedence();
+    parsed = this.definitions.some((definition) => {
+      let parsed;
 
-      node = nonTerminalNode; ///
+      clear(childNodes);
 
-      nodes.push(node);
+      const precedence = definition.getPrecedence();
 
       state.setPrecedence(precedence);
 
-      const parsed = definition.parse(childNodes, state, () => {
+      callback = () => {  ///
         let parsed;
 
         parsed = true;
@@ -130,24 +132,34 @@ export default class Rule {
           if (!parsed) {
             nodes.pop();
 
-            const node = nonTerminalNode; ///
+            node = nonTerminalNode; ///
 
             nodes.push(node);
           }
         }
 
         return parsed;
-      }, callAhead);
+      };
 
-      if (!parsed) {
-        nodes.pop();
+      parsed = definition.parse(childNodes, state, callback, callAhead);
 
+      if (!parsed) {
         state.resetPrecedence(savedPrecedence);
       }
 
       return parsed;
     });
 
+    if (parsed) {
+      const parentNode = node;  ///
+
+      childNodes.forEach((childNode) => {
+        childNode.setParentNode(parentNode);
+      });
+    } else {
+      nodes.pop();
+    }
+
     if (callAhead === null) {
       state.resetPrecedence(savedPrecedence);
     }

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;
-  }
-}