occam-parsers 23.0.53 → 23.0.55

package/src/definition/partRule/nonTerminal/ruleName.js

@@ -4,16 +4,16 @@ import Definition from "../../../definition";
 import RuleNamePart from "../../../part/nonTerminal/ruleName";
 import OptionalPartPart from "../../../part/nonTerminal/optionalPart";
 
-import { ruleNameRuleName, lookAheadModifierRuleName } from "../../../ruleNames";
+import { ruleNameRuleName, callAheadModifierRuleName } from "../../../ruleNames";
 
 export default class RuleNameNonTerminalPartRuleDefinition extends Definition {
   static fromNothing() {
     const ruleNameRuleNamePart = RuleNamePart.fromRuleName(ruleNameRuleName),
-          lookAheadModifierRuleNamePart = RuleNamePart.fromRuleName(lookAheadModifierRuleName),
-          optionalLookAheadRuleNamePartPart = OptionalPartPart.fromPart(lookAheadModifierRuleNamePart),
+          callAheadModifierRuleNamePart = RuleNamePart.fromRuleName(callAheadModifierRuleName),
+          optionalCallAheadRuleNamePartPart = OptionalPartPart.fromPart(callAheadModifierRuleNamePart),
           parts = [
             ruleNameRuleNamePart,
-            optionalLookAheadRuleNamePartPart
+            optionalCallAheadRuleNamePartPart
           ],
           precedence = null,
           ruleNameNonTerminalPartRuleDefinition = new RuleNameNonTerminalPartRuleDefinition(parts, precedence);

package/src/example/basic/bnf.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const bnf = `
+  
+  S   ::= A... <END_OF_LINE> ;
+  
+  A   ::= T ":" . ;
+  
+  T   ::= T_ T~* ;
+  
+  B   ::= T_ T~* B~T ;
+  
+  V   ::= . ;
+  
+  T_  ::= V ;
+  
+  T~B ::= ":" B ;
+  
+  B~T ::= ε ;
+  
+  T~  ::= B~T B~* T~B ;
+  
+  B~  ::= T~B T~* B~T ;
+
+`;
+
+export default bnf;

package/src/example/basic/entries.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const entries = [
+  {
+    "unassigned": "."
+  }
+];
+
+export default entries;

package/src/example/basic/lexer.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { CommonLexer, BasicLexer as BasicLexerBase, EndOfLineSignificantToken } from "occam-lexers";
+
+import entries from "./entries";
+
+export default class BasicLexer extends BasicLexerBase {
+  static entries = entries;
+
+  static EndOfLineToken = EndOfLineSignificantToken; ///
+
+  static fromNothing() { return CommonLexer.fromNothing(BasicLexer); }
+
+  static fromRules(rules) { return CommonLexer.fromRules(BasicLexer, rules); }
+
+  static fromEntries(entries) { return CommonLexer.fromEntries(BasicLexer, entries); }
+}

package/src/example/basic/parser.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { CommonParser, BasicParser as BasicParserBase } from "../../index";  ///
+
+import bnf from "./bnf";
+
+export default class BasicParser extends BasicParserBase {
+  static bnf = bnf;
+
+  static fromNothing() { return CommonParser.fromNothing(BasicParser); }
+
+  static fromBNF(bnf) { return CommonParser.fromBNF(BasicParser, bnf); }
+
+  static fromRules(rules) { return CommonParser.fromRules(BasicParser, rules); }
+}

package/src/example/view/basic.js

@@ -1,24 +1,26 @@
 "use strict";
 
-import { BasicLexer } from "occam-lexers";
-import { BasicParser } from "../../index";  ///
-
 import View from "../view";
+import BasicLexer from "../basic/lexer";
+import BasicParser from "../basic/parser";
 
 const { bnf } = BasicParser,
       { entries } = BasicLexer;
 
-const basicLexer = BasicLexer.fromEntries(entries),
-      basicParser = BasicParser.fromBNF(bnf);
-
 export default class BasicView extends View {
   getTokens(content) {
-    const tokens = basicLexer.tokenise(content);
+    const lexicalEntries = this.getLexicalEntries(),
+          entries = lexicalEntries, ///
+          basicLexer = BasicLexer.fromEntries(entries),
+          tokens = basicLexer.tokenise(content);
 
     return tokens;
   }
 
   getNode(tokens) {
+    const bnf = this.getBNF(),
+          basicParser = BasicParser.fromBNF(bnf);
+
     const node = basicParser.parse(tokens);
 
     return node;
@@ -28,8 +30,8 @@ export default class BasicView extends View {
     this.assignContext();
 
     const { initialContent } = this.constructor,
-          content = initialContent, ///
-          lexicalEntries = entries; ///
+          lexicalEntries = entries, ///
+          content = initialContent; ///
 
     this.setBNF(bnf);
 
@@ -40,7 +42,8 @@ export default class BasicView extends View {
     this.keyUpHandler();
   }
 
-  static initialContent = "1+2*3 . 1+2*3 .";
+  static initialContent = `f:x:y
+`;
 
   static defaultProperties = {
     className: "basic"

package/src/example/view/div/sizeable.js

@@ -6,7 +6,7 @@ import { SizeableDiv } from "easy-layout";
 
 export default withStyle(SizeableDiv)`
 
-  width: 48rem;
+  width: 36rem;
   min-width: 24rem;
   
 `;

package/src/node/bnf/callAheadModifier.js

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

package/src/node/bnf/choiceOfParts.js

@@ -7,14 +7,14 @@ import { partChoiceRuleName } from "../../ruleNames";
 import { nodesFromChildNodesAndRuleName } from "../../utilities/node";
 
 export default class ChoiceOfPartsBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const childNodes = this.getChildNodes(),
           partChoiceBNFNodes = nodesFromChildNodesAndRuleName(childNodes, partChoiceRuleName);
 
-    lookAhead = false;  ///
+    callAhead = false;  ///
 
     const partChoices = partChoiceBNFNodes.map((partChoiceBNFNode) => {
-            const partChoice = partChoiceBNFNode.generatePartChoice(lookAhead);
+            const partChoice = partChoiceBNFNode.generatePartChoice(callAhead);
 
             return partChoice;
           }),

package/src/node/bnf/definition.js

@@ -11,9 +11,9 @@ export default class DefinitionBNFNode extends NonTerminalNode {
     const childNodes = this.getChildNodes(),
           partBNFNodes = nodesFromChildNodesAndRuleName(childNodes, partRuleName),
           precedenceBNFNode = nodeFromChildNodesAndRuleName(childNodes, precedenceRuleName),
-          lookAhead = false,  ///
+          callAhead = false,  ///
           parts = partBNFNodes.map((partBNFNode) => {
-            const part = partBNFNode.generatePart(lookAhead);
+            const part = partBNFNode.generatePart(callAhead);
   
             return part;
           }),

package/src/node/bnf/endOfLine.js

@@ -4,7 +4,7 @@ import EndOfLinePart from "../../part/terminal/endOfLine";
 import NonTerminalNode from "../../node/nonTerminal";
 
 export default class EndOfLineBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const endOfLinePart = EndOfLinePart.fromNothing();
 
     return endOfLinePart;

package/src/node/bnf/epsilon.js

@@ -4,7 +4,7 @@ import EpsilonPart from "../../part/terminal/epsilon";
 import NonTerminalNode from "../../node/nonTerminal";
 
 export default class EpsilonBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const epsilonPart = EpsilonPart.fromNothing();
 
     return epsilonPart;

package/src/node/bnf/noWhitespacePart.js

@@ -4,7 +4,7 @@ import NonTerminalNode from "../../node/nonTerminal";
 import NoWhitespacePart from "../../part/terminal/noWhitespace";
 
 export default class NoWhitespacePartBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const noWhitespacePart = NoWhitespacePart.fromNothing();
 
     return noWhitespacePart;

package/src/node/bnf/part/nonTerminal.js

@@ -4,24 +4,24 @@ import { arrayUtilities } from "necessary";
 
 import NonTerminalNode from "../../../node/nonTerminal";
 
-import { lookAheadModifierRuleName } from "../../../ruleNames";
+import { callAheadModifierRuleName } from "../../../ruleNames";
 import { nodeFromChildNodesAndRuleName } from "../../../utilities/node";
 
 const { first } = arrayUtilities;
 
 export default class NonTerminalPartBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const childNodes = this.getChildNodes();
 
-    if (!lookAhead) {
-      const lookAheadModifierBNFNode = nodeFromChildNodesAndRuleName(childNodes, lookAheadModifierRuleName);
+    if (!callAhead) {
+      const callAheadModifierBNFNode = nodeFromChildNodesAndRuleName(childNodes, callAheadModifierRuleName);
 
-      lookAhead = (lookAheadModifierBNFNode !== null);
+      callAhead = (callAheadModifierBNFNode !== null);
     }
 
     const firstChildNode = first(childNodes),
           node = firstChildNode,  ///
-          part = node.generatePart(lookAhead);
+          part = node.generatePart(callAhead);
 
     return part;
   }

package/src/node/bnf/part/terminal.js

@@ -7,11 +7,11 @@ import NonTerminalNode from "../../../node/nonTerminal";
 const { first } = arrayUtilities;
 
 export default class TerminalPartBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           node = firstChildNode,  ///
-          part = node.generatePart(lookAhead);
+          part = node.generatePart(callAhead);
 
     return part;
   }

package/src/node/bnf/part.js

@@ -13,7 +13,7 @@ import { optionalQuantifierRuleName, oneOrMoreQuantifierRuleName, zeroOrMoreQuan
 const { last } = arrayUtilities;
 
 export default class PartBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const childNodes = this.getChildNodes(),
           nodes = childNodes.slice(),
           part = partFromNodes(nodes);
@@ -25,15 +25,15 @@ export default class PartBNFNode extends NonTerminalNode {
 }
 
 function partFromNodes(nodes) {
-  let part = null;
+  let part;
 
   const nodesLength = nodes.length;
 
   if (nodesLength === 1) {
     const node = nodes.pop(),
-          lookAhead = false;
+          callAhead = false;
 
-    part = node.generatePart(lookAhead);
+    part = node.generatePart(callAhead);
   } else {
     const lastNodeQuantifierNode = isLastNodeQuantifierNode(nodes);
 

package/src/node/bnf/partChoice.js

@@ -7,14 +7,14 @@ import { nodeFromChildNodesAndRuleName } from "../../utilities/node";
 import { partRuleName, precedenceRuleName } from "../../ruleNames";
 
 export default class PartChoiceBNFNode extends NonTerminalNode {
-  generatePartChoice(lookAhead) {
+  generatePartChoice(callAhead) {
     const childNodes = this.getChildNodes(),
           partBNFNode = nodeFromChildNodesAndRuleName(childNodes, partRuleName),
           precedenceBNFNode = nodeFromChildNodesAndRuleName(childNodes, precedenceRuleName);
 
-    lookAhead = false;  ///
+    callAhead = false;  ///
 
-    const part = partBNFNode.generatePart(lookAhead),
+    const part = partBNFNode.generatePart(callAhead),
           precedence = (precedenceBNFNode === null) ?
                           null :
                             precedenceBNFNode.getPrecedence(),

package/src/node/bnf/regularExpression.js

@@ -10,7 +10,7 @@ const { first, second } = arrayUtilities;
 export default class RegularExpressionBNFNode extends NonTerminalNode {
   regularExpression = /^\/((?:\\.|[^\/])*)\/$/;
 
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const regularExpression = this.getRegularExpression(),
           regularExpressionPart = RegularExpressionPart.fromRegularExpression(regularExpression);
 

package/src/node/bnf/ruleName.js

@@ -8,13 +8,13 @@ import NonTerminalNode from "../../node/nonTerminal";
 const { first } = arrayUtilities;
 
 export default class RuleNameBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           terminalNode = firstChildNode,  ///
           terminalNodeContent = terminalNode.getContent(),
           ruleName = terminalNodeContent, ///
-          ruleNamePart = RuleNamePart.fromLookAheadAndRuleName(lookAhead, ruleName);
+          ruleNamePart = RuleNamePart.fromCallAheadAndRuleName(callAhead, ruleName);
 
     return ruleNamePart;
   }

package/src/node/bnf/sequenceOfParts.js

@@ -7,14 +7,14 @@ import { partRuleName } from "../../ruleNames";
 import { nodesFromChildNodesAndRuleName } from "../../utilities/node";
 
 export default class SequenceOfPartsBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const childNodes = this.getChildNodes(),
           partBNFNodes = nodesFromChildNodesAndRuleName(childNodes, partRuleName);
 
-    lookAhead = false;  ///
+    callAhead = false;  ///
 
     const parts = partBNFNodes.map((partBNFNode) => {
-            const part = partBNFNode.generatePart(lookAhead);
+            const part = partBNFNode.generatePart(callAhead);
 
             return part;
           }),

package/src/node/bnf/significantTokenType.js

@@ -10,7 +10,7 @@ const { first, second } = arrayUtilities;
 export default class SignificantTokenTypeBNFNode extends NonTerminalNode {
   regularExpression = /^\[([^\]]+)]$/;
 
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const significantTokenType = this.getSignificantTokenType(),
           significantTokenTypePart = SignificantTokenTypePart.fromSignificantTokenType(significantTokenType);
 

package/src/node/bnf/startOfContentPart.js

@@ -4,7 +4,7 @@ import NonTerminalNode from "../../node/nonTerminal";
 import StartOfContentPart from "../../part/terminal/startOfContent";
 
 export default class StartOfContentPartBNFNode extends NonTerminalNode {
-  generatePart(lookAhead) {
+  generatePart(callAhead) {
     const startOfContentPart = StartOfContentPart.fromNothing();
 
     return startOfContentPart;

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/node/nonTerminal.js

@@ -6,11 +6,12 @@ import { specialSymbols } from "occam-lexers";
 import NonTerminalNodeParseTree from "../parseTree/nonTerminalNode";
 
 const { first, match, forwardsSome, backwardsSome } = arrayUtilities,
-      { opaque : opaqueSpecialSymbol , semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
+      { opaque: opaqueSpecialSymbol , semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
 
 export default class NonTerminalNode {
-  constructor(ruleName, childNodes, opacity, precedence) {
+  constructor(ruleName, parentNode, childNodes, opacity, precedence) {
     this.ruleName = ruleName;
+    this.parentNode = parentNode;
     this.childNodes = childNodes;
     this.opacity = opacity;
     this.precedence = precedence;
@@ -20,6 +21,10 @@ export default class NonTerminalNode {
     return this.ruleName;
   }
 
+  getParentNode() {
+    return this.parentNode;
+  }
+
   getChildNodes() {
     return this.childNodes;
   }
@@ -40,6 +45,10 @@ export default class NonTerminalNode {
     this.childNodes = childNodes;
   }
 
+  setParentNode(parentNode) {
+    this.parentNode = parentNode;
+  }
+
   setPrecedence(precedence) {
     this.precedence = precedence;
   }
@@ -130,6 +139,22 @@ export default class NonTerminalNode {
     return significantTokens;
   }
 
+  getAncestorNodes() {
+    const ancestorNodes = [];
+
+    let parentNode = this.parentNode;
+
+    while (parentNode !== null) {
+      const ancestorNode = parentNode;  ///
+
+      ancestorNodes.push(ancestorNode);
+
+      parentNode = parentNode.getParentNode();
+    }
+
+    return ancestorNodes;
+  }
+
   isUnprecedented() {
     let unprecedented = false;
 
@@ -235,14 +260,11 @@ export default class NonTerminalNode {
   clone(...remainingArguments) {
     const Class = this.constructor,
           ruleName = this.ruleName,
-          childNodes = this.childNodes.map((childNode) => {
-            childNode = childNode.clone();  ///
-
-            return childNode;
-          }),
+          parentNode = null,
+          childNodes = cloneChildNodes(this.childNodes),
           opacity = this.opacity,
           precedence = this.precedence,
-          nonTerminalNode = new Class(ruleName, childNodes, opacity, precedence, ...remainingArguments);
+          nonTerminalNode = new Class(ruleName, parentNode, childNodes, opacity, precedence, ...remainingArguments);
 
     return nonTerminalNode;
   }
@@ -258,9 +280,20 @@ export default class NonTerminalNode {
       Class = NonTerminalNode;  ///
     }
 
-    const precedence = null,
-          nonTerminalNode = new Class(ruleName, childNodes, opacity, precedence, ...remainingArguments);
+    const parentNode = null,
+          precedence = null,
+          nonTerminalNode = new Class(ruleName, parentNode, childNodes, opacity, precedence, ...remainingArguments);
 
     return nonTerminalNode;
   }
 }
+
+function cloneChildNodes(childNodes) {
+  childNodes = childNodes.map((childNode) => {  ///
+    childNode = childNode.clone();  ///
+
+    return childNode;
+  });
+
+  return childNodes;
+}

package/src/node/terminal.js

@@ -3,14 +3,27 @@
 import TerminalNodeParseTree from "../parseTree/terminalNode";
 
 export default class TerminalNode {
-  constructor(significantToken) {
+  constructor(parentNode, significantToken) {
+    this.parentNode = parentNode;
     this.significantToken = significantToken;
   }
 
+  getParentNode() {
+    return this.parentNode;
+  }
+
   getSignificantToken() {
     return this.significantToken;
   }
 
+  setParentNode(parentNode) {
+    this.parentNode = parentNode;
+  }
+
+  setSignificantToken(significantToken) {
+    this.significantToken = significantToken;
+  }
+
   isStartOfContentNode() {
     const startOfContentNode = false;
 
@@ -89,6 +102,22 @@ export default class TerminalNode {
     return significantTokens;
   }
 
+  getAncestorNodes() {
+    const ancestorNodes = [];
+
+    let parentNode = this.parentNode;
+
+    while (parentNode !== null) {
+      const ancestorNode = parentNode;  ///
+
+      ancestorNodes.push(ancestorNode);
+
+      parentNode = parentNode.getParentNode();
+    }
+
+    return ancestorNodes;
+  }
+
   isIncludedIn(node) {
     let includedIn = false;
 
@@ -131,10 +160,6 @@ export default class TerminalNode {
     return matches;
   }
 
-  setSignificantToken(significantToken) {
-    this.significantToken = significantToken;
-  }
-
   asParseTree(tokens) {
     const terminalNode = this,  ///
           terminalNodeParseTree = TerminalNodeParseTree.fromTerminalNodeAndTokens(terminalNode, tokens),
@@ -145,8 +170,9 @@ export default class TerminalNode {
 
   clone(...remainingArguments) {
     const Class = this.constructor,
+          parentNode = null,
           significantToken = this.significantToken,
-          terminalNode = new Class(significantToken, ...remainingArguments);
+          terminalNode = new Class(parentNode, significantToken, ...remainingArguments);
 
     return terminalNode;
   }
@@ -156,8 +182,9 @@ export default class TerminalNode {
       Class = TerminalNode; ///
     }
 
-    const significantToken = null,
-          terminalNode = new Class(significantToken, ...remainingArguments);
+    const parentNode = null,
+          significantToken = null,
+          terminalNode = new Class(parentNode, significantToken, ...remainingArguments);
 
     return terminalNode;
   }
@@ -169,7 +196,8 @@ export default class TerminalNode {
       Class = TerminalNode; ///
     }
 
-    const terminalNode = new Class(significantToken, ...remainingArguments);
+    const parentNode = null,
+          terminalNode = new Class(parentNode, significantToken, ...remainingArguments);
     
     return terminalNode;
   }

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