occam-parsers 23.0.146 → 23.0.148

package/src/rule/bnf/startOfContentPart.js

@@ -1,21 +1,19 @@
 "use strict";
 
 import Rule from "../../rule";
-import StartOfContentPartBNFNode from "../../node/bnf/startOfContentPart";
 import StartOfContentPartDefinition from "../../definition/startOfContentPart";
 
-import { startOfContentPartRuleName } from "../../ruleNames";
+import { START_OF_CONTENT_PART_RULE_NAME } from "../../ruleNames";
 
 export default class StartOfContentPartBNFRule extends Rule {
   static fromNothing() {
     const startOfContentPartDefinition = StartOfContentPartDefinition.fromNothing(),
-          name = startOfContentPartRuleName,  ///
+          name = START_OF_CONTENT_PART_RULE_NAME,  ///
           opacity = null,
           definitions = [
             startOfContentPartDefinition
           ],
-          NonTerminalNode = StartOfContentPartBNFNode,  ///
-          startOfContentPartRule = new StartOfContentPartBNFRule(name, opacity, definitions, NonTerminalNode);
+          startOfContentPartRule = new StartOfContentPartBNFRule(name, opacity, definitions);
 
     return startOfContentPartRule;
   }

package/src/rule/bnf/terminalPart.js

@@ -2,29 +2,54 @@
 
 import Rule from "../../rule";
 import RuleNameDefinition from "../../definition/ruleName";
-import TerminalPartBNFNode from "../../node/bnf/part/terminal";
-
-import { epsilonRuleName,
-         wildcardRuleName,
-         endOfLineRuleName,
-         terminalPartRuleName,
-         terminalSymbolRuleName,
-         noWhitespacePartRuleName,
-         regularExpressionRuleName,
-         startOfContentPartRuleName,
-         significantTokenTypeRuleName } from "../../ruleNames";
+
+import { EPSILON_RULE_NAME,
+         WILDCARD_RULE_NAME,
+         END_OF_LINE_RULE_NAME,
+         TERMINAL_PART_RULE_NAME,
+         TERMINAL_SYMBOL_RULE_NAME,
+         NO_WHITESPACE_PART_RULE_NAME,
+         REGULAR_EXPRESSION_RULE_NAME,
+         START_OF_CONTENT_PART_RULE_NAME,
+         SIGNIFICANT_TOKEN_TYPE_RULE_NAME } from "../../ruleNames";
 
 export default class TerminalPartBNFRule extends Rule {
   static fromNothing() {
-    const name = terminalPartRuleName,
-          epsilonRuleNameDefinition = RuleNameDefinition.fromRuleName(epsilonRuleName),
-          wildcardRuleNameDefinition = RuleNameDefinition.fromRuleName(wildcardRuleName),
-          endOfLineRuleNameDefinition = RuleNameDefinition.fromRuleName(endOfLineRuleName),
-          terminalSymbolRuleNameDefinition = RuleNameDefinition.fromRuleName(terminalSymbolRuleName),
-          noWhitespacePartRuleNameDefinition = RuleNameDefinition.fromRuleName(noWhitespacePartRuleName),
-          regularExpressionRuleNameDefinition = RuleNameDefinition.fromRuleName(regularExpressionRuleName),
-          startOfContentPartRuleNameDefinition = RuleNameDefinition.fromRuleName(startOfContentPartRuleName),
-          significantTokenTypeRuleNameDefinition = RuleNameDefinition.fromRuleName(significantTokenTypeRuleName),
+    let ruleName;
+
+    const name = TERMINAL_PART_RULE_NAME;
+
+    ruleName = EPSILON_RULE_NAME;
+
+    const epsilonRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = WILDCARD_RULE_NAME;
+
+    const wildcardRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = END_OF_LINE_RULE_NAME;
+
+    const endOfLineRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = TERMINAL_SYMBOL_RULE_NAME;
+
+    const terminalSymbolRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = NO_WHITESPACE_PART_RULE_NAME;
+
+    const noWhitespacePartRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = REGULAR_EXPRESSION_RULE_NAME;
+
+    const regularExpressionRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = START_OF_CONTENT_PART_RULE_NAME;
+
+    const startOfContentPartRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName);
+
+    ruleName = SIGNIFICANT_TOKEN_TYPE_RULE_NAME;
+
+    const significantTokenTypeRuleNameDefinition = RuleNameDefinition.fromRuleName(ruleName),
           opacity = null,
           definitions = [
             significantTokenTypeRuleNameDefinition,
@@ -36,8 +61,7 @@ export default class TerminalPartBNFRule extends Rule {
             noWhitespacePartRuleNameDefinition,
             startOfContentPartRuleNameDefinition
           ],
-          NonTerminalNode = TerminalPartBNFNode,  ///
-          terminalPartRule = new TerminalPartBNFRule(name, opacity, definitions, NonTerminalNode);
+          terminalPartRule = new TerminalPartBNFRule(name, opacity, definitions);
 
     return terminalPartRule;
   }

package/src/rule/bnf/terminalSymbol.js

@@ -3,10 +3,9 @@
 import { types } from "occam-lexers";
 
 import Rule from "../../rule";
-import TerminalSymbolBNFNode from "../../node/bnf/terminalSymbol";
 import SignificantTokenTypeDefinition from "../../definition/significantTokenType";
 
-import { terminalSymbolRuleName } from "../../ruleNames";
+import { TERMINAL_SYMBOL_RULE_NAME } from "../../ruleNames";
 
 const { stringLiteralType } = types;
 
@@ -14,13 +13,12 @@ export default class TerminalSymbolBNFRule extends Rule {
   static fromNothing() {
     const significantTokenType = stringLiteralType,  ///
           stringLiteralSignificantTokenTypeDefinition = SignificantTokenTypeDefinition.fromSignificantTokenType(significantTokenType),
-          name = terminalSymbolRuleName,  ///
+          name = TERMINAL_SYMBOL_RULE_NAME,  ///
           opacity = null,
           definitions = [
             stringLiteralSignificantTokenTypeDefinition
           ],
-          NonTerminalNode = TerminalSymbolBNFNode,  ///
-          terminalSymbolRule = new TerminalSymbolBNFRule(name, opacity, definitions, NonTerminalNode);
+          terminalSymbolRule = new TerminalSymbolBNFRule(name, opacity, definitions);
 
     return terminalSymbolRule;
   }

package/src/rule/bnf/wildcard.js

@@ -3,10 +3,9 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import WildcardBNFNode from "../../node/bnf/wildcard";
 import TerminalSymbolDefinition from "../../definition/terminalSymbol";
 
-import { wildcardRuleName } from "../../ruleNames";
+import { WILDCARD_RULE_NAME } from "../../ruleNames";
 
 const { wildcard } = specialSymbols;
 
@@ -14,13 +13,12 @@ export default class WildcardBNFRule extends Rule {
   static fromNothing() {
     const content = wildcard, ///
           wildcardTerminalSymbolDefinition = TerminalSymbolDefinition.fromContent(content),
-          name = wildcardRuleName,  ///
+          name = WILDCARD_RULE_NAME,  ///
           opacity = null,
           definitions = [
             wildcardTerminalSymbolDefinition
           ],
-          NonTerminalNode = WildcardBNFNode,  ///
-          wildcardRule = new WildcardBNFRule(name, opacity, definitions, NonTerminalNode);
+          wildcardRule = new WildcardBNFRule(name, opacity, definitions);
 
     return wildcardRule;
   }

package/src/rule/bnf/zeroOrMoreQuantifier.js

@@ -3,24 +3,22 @@
 import { specialSymbols } from "occam-lexers";
 
 import Rule from "../../rule";
-import QuantifierBNFNode from "../../node/bnf/quantifier";
 import QuantifierRuleDefinition from "../../definition/quantifierRule";
 
-import { zeroOrMoreQuantifierRuleName } from "../../ruleNames";
+import { ZERO_OR_MORE_QUANTIFIER_RULE_NAME } from "../../ruleNames";
 
 const { asterisk } = specialSymbols;
 
 export default class ZeroOrMoreQuantifierBNFRule extends Rule {
   static fromNothing() {
-    const name = zeroOrMoreQuantifierRuleName,  ///
+    const name = ZERO_OR_MORE_QUANTIFIER_RULE_NAME,  ///
           specialSymbol = asterisk, ///
           zeroOrMoreQuantifierRuleDefinition = QuantifierRuleDefinition.fromSpecialSymbol(specialSymbol),
           opacity = null,
           definitions = [
             zeroOrMoreQuantifierRuleDefinition
           ],
-          NonTerminalNode = QuantifierBNFNode, ///
-          zeroOrMoreQuantifierRule = new ZeroOrMoreQuantifierBNFRule(name, opacity, definitions, NonTerminalNode);
+          zeroOrMoreQuantifierRule = new ZeroOrMoreQuantifierBNFRule(name, opacity, definitions);
 
     return zeroOrMoreQuantifierRule;
   }

package/src/rule.js

@@ -10,11 +10,10 @@ const { clear } = arrayUtilities,
       { opaque: opaqueSpecialSymbol, semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
 
 export default class Rule {
-  constructor(name, opacity, definitions, NonTerminalNode) {
+  constructor(name, opacity, definitions) {
     this.name = name;
     this.opacity = opacity;
     this.definitions = definitions;
-    this.NonTerminalNode = NonTerminalNode;
   }
 
   getName() {
@@ -29,10 +28,6 @@ export default class Rule {
     return this.definitions;
   }
 
-  getNonTerminalNode() {
-    return this.NonTerminalNode;
-  }
-
   setName(name) {
     this.name = name;
   }
@@ -45,10 +40,6 @@ export default class Rule {
     this.definitions = definitions;
   }
 
-  setNonTerminalNode(NonTerminalNode) {
-    this.NonTerminalNode = NonTerminalNode;
-  }
-
   isOpaque() {
     const opaque = (this.opacity === opaqueSpecialSymbol);
 
@@ -73,7 +64,8 @@ export default class Rule {
     const opacity = this.opacity,
           ruleName = this.name, ///
           childNodes = [],
-          nonTerminalNode = this.NonTerminalNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity),
+          NonTerminalNode = state.NonTerminalNodeFromRuleName(ruleName),
+          nonTerminalNode = NonTerminalNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity),
           savedPrecedence = state.getSavedPrecedence();
 
     let node = nonTerminalNode; ///
@@ -102,7 +94,7 @@ export default class Rule {
           node.setChildNodesParentNode();
         }
 
-        const rewrittenNonTerminalNode = nonTerminalNode.rewrite();
+        const rewrittenNonTerminalNode = nonTerminalNode.rewrite(state);
 
         if (rewrittenNonTerminalNode !== null) {
           if (parsed) {
@@ -217,10 +209,8 @@ ${this.name}${opacityString}${padding} ::= ${definitionsString}${semicolonString
     return string;
   }
 
-  static fromNameOpacityDefinitionsAndNonTerminalNode(Class, name, opacity, definitions, NonTerminalNode) {
-    if (NonTerminalNode === undefined) {
-      NonTerminalNode = definitions;  ///
-
+  static fromNameOpacityAndDefinitions(Class, name, opacity, definitions) {
+    if (definitions === undefined) {
       definitions = opacity;  ///
 
       opacity = name; ///
@@ -230,7 +220,7 @@ ${this.name}${opacityString}${padding} ::= ${definitionsString}${semicolonString
       Class = Rule; ///
     }
 
-    const rule = new Class(name, opacity, definitions, NonTerminalNode);
+    const rule = new Class(name, opacity, definitions);
 
     return rule;
   }

package/src/ruleNames.js

@@ -1,30 +1,30 @@
 "use strict";
 
-export const nameRuleName = "name";
-export const partRuleName = "part";
-export const ruleRuleName = "rule";
-export const errorRuleName = "error";
-export const epsilonRuleName = "epsilon";
-export const ruleNameRuleName = "ruleName";
-export const documentRuleName = "document";
-export const wildcardRuleName = "wildcard";
-export const endOfLineRuleName = "endOfLine";
-export const definitionRuleName = "definition";
-export const precedenceRuleName = "precedence";
-export const quantifierRuleName = "quantifier";
-export const partChoiceRuleName = "partChoice";
-export const definitionsRuleName = "definitions";
-export const terminalPartRuleName = "terminalPart";
-export const choiceOfPartsRuleName = "choiceOfParts";
-export const terminalSymbolRuleName = "terminalSymbol";
-export const nonTerminalPartRuleName = "nonTerminalPart";
-export const sequenceOfPartsRuleName = "sequenceOfParts";
-export const opacityModifierRuleName = "opacityModifier";
-export const noWhitespacePartRuleName = "noWhitespace";
-export const CallAheadModifierRuleName = "callAheadModifier";
-export const regularExpressionRuleName = "regularExpression";
-export const optionalQuantifierRuleName = "optionalQuantifier";
-export const startOfContentPartRuleName = "startOfContent";
-export const oneOrMoreQuantifierRuleName = "oneOrMoreQuantifier";
-export const zeroOrMoreQuantifierRuleName = "zeroOrMoreQuantifier";
-export const significantTokenTypeRuleName = "significantTokenType";
+export const NAME_RULE_NAME = "name";
+export const PART_RULE_NAME = "part";
+export const RULE_RULE_NAME = "rule";
+export const ERROR_RULE_NAME = "error";
+export const EPSILON_RULE_NAME = "epsilon";
+export const DOCUMENT_RULE_NAME = "document";
+export const WILDCARD_RULE_NAME = "wildcard";
+export const RULE_NAME_RULE_NAME = "ruleName";
+export const DEFINITION_RULE_NAME = "definition";
+export const PRECEDENCE_RULE_NAME = "precedence";
+export const QUANTIFIER_RULE_NAME = "quantifier";
+export const END_OF_LINE_RULE_NAME = "endOfLine";
+export const PART_CHOICE_RULE_NAME = "partChoice";
+export const DEFINITIONS_RULE_NAME = "definitions";
+export const TERMINAL_PART_RULE_NAME = "terminalPart";
+export const CHOICE_OF_PARTS_RULE_NAME = "choiceOfParts";
+export const TERMINAL_SYMBOL_RULE_NAME = "terminalSymbol";
+export const OPACITY_MODIFIER_RULE_NAME = "opacityModifier";
+export const NON_TERMINAL_PART_RULE_NAME = "nonTerminalPart";
+export const SEQUENCE_OF_PARTS_RULE_NAME = "sequenceOfParts";
+export const NO_WHITESPACE_PART_RULE_NAME = "noWhitespace";
+export const REGULAR_EXPRESSION_RULE_NAME = "regularExpression";
+export const CALL_AHEAD_MODIFIER_RULE_NAME = "callAheadModifier";
+export const OPTIONAL_QUANTIFIER_RULE_NAME = "optionalQuantifier";
+export const START_OF_CONTENT_PART_RULE_NAME = "startOfContent";
+export const SIGNIFICANT_TOKEN_TYPE_RULE_NAME = "significantTokenType";
+export const ONE_OR_MORE_QUANTIFIER_RULE_NAME = "oneOrMoreQuantifier";
+export const ZERO_OR_MORE_QUANTIFIER_RULE_NAME = "zeroOrMoreQuantifier";

package/src/state.js

@@ -1,12 +1,14 @@
 "use strict";
 
 export default class State {
-  constructor(index, tokens, ruleMap, precedence, startOfContent) {
+  constructor(index, tokens, ruleMap, precedence, startOfContent, NonTerminalNodeMap, defaultNonTerminalNode) {
 		this.index = index;
     this.tokens = tokens;
     this.ruleMap = ruleMap;
     this.precedence = precedence;
     this.startOfContent = startOfContent;
+    this.NonTerminalNodeMap = NonTerminalNodeMap;
+    this.defaultNonTerminalNode = defaultNonTerminalNode;
   }
 
   getIndex() {
@@ -29,6 +31,14 @@ export default class State {
     return this.startOfContent;
   }
 
+  getNonTerminalNode() {
+    return this.NonTerminalNodeMap;
+  }
+
+  getDefaultNonTerminalNode() {
+    return this.defaultNonTerminalNode;
+  }
+
   setIndex(index) {
     this.index = index;
   }
@@ -124,10 +134,16 @@ export default class State {
     this.precedence = savedPrecedence;  ///
   }
 
-  static fromTokensRuleMapAndStartOfContent(tokens, ruleMap, startOfContent) {
+  NonTerminalNodeFromRuleName(ruleName) {
+    const NonTerminalNode = this.NonTerminalNodeMap[ruleName] || this.defaultNonTerminalNode;
+
+    return NonTerminalNode;
+  }
+
+  static fromTokensRuleMapStartOfContentNonTerminalNodeMapAndDefaultNonTerminalNode(tokens, ruleMap, startOfContent, NonTerminalNodeMap, defaultNonTerminalNode) {
     const index = 0,
           precedence = null,
-					state = new State(index, tokens, ruleMap, precedence, startOfContent);
+					state = new State(index, tokens, ruleMap, precedence, startOfContent, NonTerminalNodeMap, defaultNonTerminalNode);
 
     return state;
   }

package/src/utilities/bnf.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import { ruleNameRuleName, quantifierRuleName, callAheadModifierRuleName } from "../ruleNames";
+import { RULE_NAME_RULE_NAME, QUANTIFIER_RULE_NAME, CALL_AHEAD_MODIFIER_RULE_NAME } from "../ruleNames";
 
 const { first } = arrayUtilities;
 
@@ -31,7 +31,7 @@ export function isNodeRuleNameNode(node) {
     const nonTerminalNode = node, ///
           nonTerminalNodeRuleName = nonTerminalNode.getRuleName();
 
-    nodeRuleNameNode = (nonTerminalNodeRuleName === ruleNameRuleName);
+    nodeRuleNameNode = (nonTerminalNodeRuleName === RULE_NAME_RULE_NAME);
   }
 
   return nodeRuleNameNode;
@@ -45,7 +45,7 @@ export function isNodeQuantifierNode(node) {
   if (nodeNonTerminalNode) {
     const nonTerminalNode = node, ///
           ruleName = nonTerminalNode.getRuleName(),
-          ruleNameQuantifierRuleName = (ruleName === quantifierRuleName);
+          ruleNameQuantifierRuleName = (ruleName === QUANTIFIER_RULE_NAME);
 
     nodeQuantifierNode = ruleNameQuantifierRuleName;  ///
   }
@@ -61,7 +61,7 @@ export function isNodeCallAheadModifierNode(node) {
   if (nodeNonTerminalNode) {
     const nonTerminalNode = node, ///
           ruleName = nonTerminalNode.getRuleName(),
-          ruleNameCallAheadModifierRuleName = (ruleName === callAheadModifierRuleName);
+          ruleNameCallAheadModifierRuleName = (ruleName === CALL_AHEAD_MODIFIER_RULE_NAME);
 
     nodeCallAheadModifierNode = ruleNameCallAheadModifierRuleName;  ///
   }