occam-verify-cli 1.0.448 → 1.0.472

package/src/node/{step.js → proofAssertion/step.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import NonTerminalNode from "../nonTerminalNode";
+import ProofAssertionNode from "../../node/proofAssertion";
 
-import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME, QUALIFICATION_RULE_NAME } from "../ruleNames";
+import { QUALIFICATION_RULE_NAME } from "../../ruleNames";
 
-export default class StepNode extends NonTerminalNode {
+export default class StepNode extends ProofAssertionNode {
   isStepNode() {
     const stepNode = true;
 
@@ -41,20 +41,6 @@ export default class StepNode extends NonTerminalNode {
     return satisfiedAssertionNode;
   }
 
-  getNonsenseNode() {
-    const ruleName = NONSENSE_RULE_NAME,
-          nonsenseNode = this.getNodeByRuleName(ruleName);
-
-    return nonsenseNode;
-  }
-
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
   getQualificationNode() {
     const ruleName = QUALIFICATION_RULE_NAME,
           qualificationNode = this.getNodeByRuleName(ruleName);
@@ -62,5 +48,5 @@ export default class StepNode extends NonTerminalNode {
     return qualificationNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/proofAssertion/supposition.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import ProofAssertionNode from "../../node/proofAssertion";
+
+import { PROCEDURE_CALL_RULE_NAME } from "../../ruleNames";
+
+export default class SuppositionNode extends ProofAssertionNode {
+  getProcedureCallNode() {
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SuppositionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/proofAssertion.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../nonTerminalNode";
+
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class ProofAssertionNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/statement.js

@@ -36,7 +36,7 @@ export default class StatementNode extends NonTerminalNode {
 
     const metavariableNode = this.getMetavariableNode();
 
-    if (metavariableName !== null) {
+    if (metavariableNode !== null) {
       metavariableName = metavariableNode.getMetavariableName();
     }
 

package/src/node/substitution/frame.js

@@ -5,44 +5,18 @@ import SubstitutionNode from "../../node/substitution";
 import { FRAME_RULE_NAME } from "../../ruleNames";
 
 export default class FrameSubstitutionNode extends SubstitutionNode {
-  getFrameNode() {
-    const firstFrameNode = this.getFirstFrameNode(),
-          frameNode = firstFrameNode; ///
-
-    return frameNode;
-  }
-
-  getMetavariableNode() {
-    const lastMetavariableNode = this.getLastMetavariableNode(),
-          metavariableNode = lastMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
-  getLastMetavariableNode() {
-    let lastMetavariableNode = null;
-
+  getTargetFrameNode() {
     const lastFrameNode = this.getLastFrameNode(),
-          singularMetavariableNode = lastFrameNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      lastMetavariableNode = singularMetavariableNode;  ///
-    }
+          targetFrameNode = lastFrameNode; ///
 
-    return lastMetavariableNode;
+    return targetFrameNode;
   }
 
-  getFirstMetavariableNode() {
-    let firstMetavariableNode = null;
-
+  getReplacementFrameNode() {
     const firstFrameNode = this.getFirstFrameNode(),
-          singularMetavariableNode = firstFrameNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      firstMetavariableNode = singularMetavariableNode;  ///
-    }
+          replacementFrameNode = firstFrameNode; ///
 
-    return firstMetavariableNode;
+    return replacementFrameNode;
   }
 
   getLastFrameNode() {

package/src/node/substitution/reference.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import SubstitutionNode from "../../node/substitution";
+
+import { REFERENCE_RULE_NAME } from "../../ruleNames";
+
+export default class ReferenceSubstitutionNode extends SubstitutionNode {
+  getTargetReferenceNode() {
+    const lastReferenceNode = this.getLastReferenceNode(),
+          targetReferenceNode = lastReferenceNode; ///
+
+    return targetReferenceNode;
+  }
+
+  getReplacementReferenceNode() {
+    const firstReferenceNode = this.getFirstReferenceNode(),
+          replacementReferenceNode = firstReferenceNode; ///
+
+    return replacementReferenceNode;
+  }
+
+  getLastReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          lastReferenceNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastReferenceNode;
+  }
+
+  getFirstReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          firstReferenceNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstReferenceNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}
+

package/src/node/substitution/statement.js

@@ -5,44 +5,18 @@ import SubstitutionNode from "../../node/substitution";
 import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class StatementSubstitutionNode extends SubstitutionNode {
-  getStatementNode() {
-    const firstStatementNode = this.getFirstStatementNode(),
-          statementNode = firstStatementNode; ///
-
-    return statementNode;
-  }
-
-  getMetavariableNode() {
-    const lastMetavariableNode = this.getLastVariableNode(),
-          metavariableNode = lastMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
-  getLastMetavariableNode() {
-    let lastMetavariableNode = null;
-
+  getTargetStatementNode() {
     const lastStatementNode = this.getLastStatementNode(),
-          singularMetavariableNode = lastStatementNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      lastMetavariableNode = singularMetavariableNode;  ///
-    }
+          targetStatementNode = lastStatementNode; ///
 
-    return lastMetavariableNode;
+    return targetStatementNode;
   }
 
-  getFirstMetavariableNode() {
-    let firstMetavariableNode = null;
-
+  getReplacementStatementNode() {
     const firstStatementNode = this.getFirstStatementNode(),
-          singularMetavariableNode = firstStatementNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      firstMetavariableNode = singularMetavariableNode;  ///
-    }
+          replacementStatementNode = firstStatementNode; ///
 
-    return firstMetavariableNode;
+    return replacementStatementNode;
   }
 
   getLastStatementNode() {

package/src/node/substitution/term.js

@@ -5,34 +5,18 @@ import SubstitutionNode from "../../node/substitution";
 import { TERM_RULE_NAME } from "../../ruleNames";
 
 export default class TermSubstitutionNode extends SubstitutionNode {
-  getTermNode() {
-    const firstTermNode = this.getFirstTermNode(),
-          termNode = firstTermNode; ///
-
-    return termNode;
-  }
-
-  getVariableNode() {
-    const lastVariableNode = this.getLastVariableNode(),
-          variableNode = lastVariableNode;  ///
-
-    return variableNode;
-  }
-
-  getLastVariableNode() {
+  getTargetTermNode() {
     const lastTermNode = this.getLastTermNode(),
-          singularVariableNode = lastTermNode.getSingularVariableNode(),
-          lastVariableNode = singularVariableNode;  ///
+          targetTermNode = lastTermNode; ///
 
-    return lastVariableNode;
+    return targetTermNode;
   }
 
-  getFirstVariableNode() {
+  getReplacementTermNode() {
     const firstTermNode = this.getFirstTermNode(),
-          singularVariableNode = firstTermNode.getSingularVariableNode(),
-          firstVariableNode = singularVariableNode;  ///
+          replacementTermNode = firstTermNode; ///
 
-    return firstVariableNode;
+    return replacementTermNode;
   }
 
   getLastTermNode() {

package/src/node/topLevelAssertion/axiom.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { AXIOM_BODY_RULE_NAME, AXIOM_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class AxiomNode extends TopLevelAssertionNode {
+  static bodyRuleName = AXIOM_BODY_RULE_NAME;
+
+  static headerRuleName = AXIOM_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(AxiomNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelAssertion/conjecture.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { CONJECTURE_BODY_RULE_NAME, CONJECTURE_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class ConjectureNode extends TopLevelAssertionNode {
+  static bodyRuleName = CONJECTURE_BODY_RULE_NAME;
+
+  static headerRuleName = CONJECTURE_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(ConjectureNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelAssertion/lemma.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { LEMMA_BODY_RULE_NAME, LEMMA_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class LemmaNode extends TopLevelAssertionNode {
+  static bodyRuleName = LEMMA_BODY_RULE_NAME;
+
+  static headerRuleName = LEMMA_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelAssertion/theorem.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { THEOREM_BODY_RULE_NAME, THEOREM_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class TheoremNode extends TopLevelAssertionNode {
+  static bodyRuleName = THEOREM_BODY_RULE_NAME;
+
+  static headerRuleName = THEOREM_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/{axiomLemmaTheoremConjecture.js → topLevelAssertion.js}

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-export default class AxiomLemmaTheoremConjectureNode extends NonTerminalNode {
+export default class TopLevelAssertionNode extends NonTerminalNode {
   getBodyNode() {
     const { bodyRuleName } = this.constructor,
           ruleName = bodyRuleName,  ///

package/src/node/topLevelMetaAssertion/metaLemma.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelMetaAssertionNode from "../../node/topLevelMetaAssertion";
+
+import { META_LEMMA_BODY_RULE_NAME, META_LEMMA_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class MetaLemmaNode extends TopLevelMetaAssertionNode {
+  static bodyRuleName = META_LEMMA_BODY_RULE_NAME;
+
+  static headerRuleName = META_LEMMA_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelMetaAssertion/metatheorem.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelMetaAssertionNode from "../../node/topLevelMetaAssertion";
+
+import { METATHEOREM_BODY_RULE_NAME, METATHEOREM_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class MetatheoremNode extends TopLevelMetaAssertionNode {
+  static bodyRuleName = METATHEOREM_BODY_RULE_NAME;
+
+  static headerRuleName = METATHEOREM_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/{metaLemmaMetaTheorem.js → topLevelMetaAssertion.js}

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-export default class MetaLemmaMetaTheoremNode extends NonTerminalNode {
+export default class TopLevelMetaAssertionNode extends NonTerminalNode {
   getBodyNode() {
     const { bodyRuleName } = this.constructor,
           ruleName = bodyRuleName,  ///

package/src/nonTerminalNodeMap.js

@@ -2,32 +2,32 @@
 
 import TermNode from "./node/term";
 import RuleNode from "./node/rule";
-import StepNode from "./node/step";
+import StepNode from "./node/proofAssertion/step";
 import TypeNode from "./node/type";
 import TypesNode from "./node/types";
 import ErrorNode from "./node/error";
 import FrameNode from "./node/frame";
-import AxiomNode from "./node/axiom";
-import LemmaNode from "./node/lemma";
+import AxiomNode from "./node/topLevelAssertion/axiom";
+import LemmaNode from "./node/topLevelAssertion/lemma";
 import ProofNode from "./node/proof";
 import LabelNode from "./node/label";
 import LabelsNode from "./node/labels";
 import SectionNode from "./node/section";
-import PremiseNode from "./node/premise";
-import TheoremNode from "./node/theorem";
+import PremiseNode from "./node/proofAssertion/premise";
+import TheoremNode from "./node/topLevelAssertion/theorem";
 import ArgumentNode from "./node/argument";
 import SubproofNode from "./node/subproof";
 import PropertyNode from "./node/property";
 import MetaTypeNode from "./node/metaType";
 import EqualityNode from "./node/equality";
 import VariableNode from "./node/variable";
-import RuleBodyNode from "./node/body/rule";
 import DocumentNode from "./node/document";
+import RuleBodyNode from "./node/body/rule";
 import StatementNode from "./node/statement";
 import ReferenceNode from "./node/reference";
 import DeductionNode from "./node/deduction";
 import JudgementNode from "./node/judgement";
-import MetaLemmaNode from "./node/metaLemma";
+import MetaLemmaNode from "./node/topLevelMetaAssertion/metaLemma";
 import ParameterNode from "./node/parameter";
 import SignatureNode from "./node/signature";
 import AxiomBodyNode from "./node/body/axiom";
@@ -35,19 +35,19 @@ import LemmaBodyNode from "./node/body/lemma";
 import DerivationNode from "./node/derivation";
 import CombinatorNode from "./node/combinator";
 import ConclusionNode from "./node/conclusion";
-import ConjectureNode from "./node/conjecture";
+import ConjectureNode from "./node/topLevelAssertion/conjecture";
 import HypothesisNode from "./node/hypothesis";
 import TypePrefixNode from "./node/typePrefix";
 import AssumptionNode from "./node/assumption";
 import RuleHeaderNode from "./node/header/rule";
-import SuppositionNode from "./node/supposition";
+import SuppositionNode from "./node/proofAssertion/supposition";
 import PlaceholderNode from "./node/placeholder";
 import ConstructorNode from "./node/constructor";
+import MetatheoremNode from "./node/topLevelMetaAssertion/metatheorem";
+import EquivalenceNode from "./node/equivalence";
 import TheoremBodyNode from "./node/body/theorem";
 import AxiomHeaderNode from "./node/header/axiom";
 import LemmaHeaderNode from "./node/header/lemma";
-import MetatheoremNode from "./node/metatheorem";
-import EquivalenceNode from "./node/equivalence";
 import EquivalencesNode from "./node/equivalences";
 import MetaArgumentNode from "./node/metaArgument";
 import MetavariableNode from "./node/metavariable";
@@ -68,13 +68,14 @@ import MetatheoremHeaderNode from "./node/header/metatheorem";
 import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
 import FrameSubstitutionNode from "./node/substitution/frame";
-import ProcedureReferenceNode from "./node/procedureReference";
 import ParenthesisedLabelNode from "./node/parenthesisedLabel";
+import ProcedureReferenceNode from "./node/procedureReference";
 import ContainedAssertionNode from "./node/assertion/contained";
 import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import VariableDeclarationNode from "./node/declaration/variable";
+import ReferenceSubstitutionNode from "./node/substitution/reference";
 import StatementSubstitutionNode from "./node/substitution/statement";
 import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
@@ -159,6 +160,7 @@ import {
   PARENTHESISED_LABELS_RULE_NAME,
   PROPERTY_DECLARATION_RULE_NAME,
   VARIABLE_DECLARATION_RULE_NAME,
+  REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
   COMBINATOR_DECLARATION_RULE_NAME,
   SIMPLE_TYPE_DECLARATION_RULE_NAME,
@@ -244,6 +246,7 @@ const NonTerminalNodeMap = {
   [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
+  [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
   [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [SIMPLE_TYPE_DECLARATION_RULE_NAME]: SimpleTypeDeclarationNode,
   [TYPE_PREFIX_DECLARATION_RULE_NAME]: TypePrefixDeclarationNode,

package/src/preamble.js

@@ -3,15 +3,15 @@
 import Type from "./element/type";
 import Term from "./element/term";
 import Rule from "./element/rule";
-import Step from "./element/step";
+import Step from "./element/proofAssertion/step";
 import Label from "./element/label";
-import Axiom from "./element/axiom";
-import Lemma from "./element/lemma";
+import Axiom from "./element/topLevelAssertion/axiom";
+import Lemma from "./element/topLevelAssertion/lemma";
 import Frame from "./element/frame";
 import Proof from "./element/proof";
 import Error from "./element/error";
-import Premise from "./element/premise";
-import Theorem from "./element/theorem";
+import Premise from "./element/proofAssertion/premise";
+import Theorem from "./element/topLevelAssertion/theorem";
 import Section from "./element/section";
 import Equality from "./element/equality";
 import MetaType from "./element/metaType";
@@ -22,19 +22,19 @@ import Parameter from "./element/parameter";
 import Reference from "./element/reference";
 import Statement from "./element/statement";
 import Judgement from "./element/judgement";
-import MetaLemma from "./element/metaLemma";
+import MetaLemma from "./element/topLevelMetaAssertion/metaLemma";
 import Deduction from "./element/deduction";
 import Signature from "./element/signature";
 import TypePrefix from "./element/typePrefix";
-import Conjecture from "./element/conjecture";
+import Conjecture from "./element/topLevelAssertion/conjecture";
 import Conclusion from "./element/conclusion";
 import Derivation from "./element/derivation";
 import Hypothesis from "./element/hypothesis";
 import Assumption from "./element/assumption";
 import Combinator from "./element/combinator";
 import Constructor from "./element/constructor";
-import Supposition from "./element/supposition";
-import Metatheorem from "./element/metatheorem";
+import Supposition from "./element/proofAssertion/supposition";
+import Metatheorem from "./element/topLevelMetaAssertion/metatheorem";
 import Equivalence from "./element/equivalence";
 import Equivalences from "./element/equivalences";
 import Metavariable from "./element/metavariable";

package/src/process/instantiate.js

@@ -1,40 +1,30 @@
 "use strict";
 
-import { ruleFromBNF } from "../utilities/bnf";
-
-const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
-      stepPlaceholderBNF = ` _ ::= step... <END_OF_LINE> ; `,
-      variablePlaceholderBNF = ` _ ::= variable... <END_OF_LINE> ; `,
-      referencePlaceholderBNF = ` _ ::= reference... <END_OF_LINE> ; `,
-      statementPlaceholderBNF = ` _ ::= statement... <END_OF_LINE> ; `,
-      combinatorPlaceholderBNF = ` _ ::= combinator... <END_OF_LINE> ; `,
-      constructorPlaceholderBNF = ` _ ::= constructor... <END_OF_LINE> ; `,
-      equivalencePlaceholderBNF = ` _ ::= equivalence... <END_OF_LINE> ; `,
-      metavariablePlaceholderBNF = ` _ ::= metavariable... <END_OF_LINE> ; `,
-      termSubstitutionPlaceholderBNF = ` _ ::= termSubstitution... <END_OF_LINE> ; `,
-      frameSubstitutionPlaceholderBNF = ` _ ::= frameSubstitution... <END_OF_LINE> ; `,
-      statementSubstitutionPlaceholderBNF = ` _ ::= statementSubstitution... <END_OF_LINE> ; `,
-      referenceSubstitutionPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
-      termPlaceholderRule = ruleFromBNF(termPlaceholderBNF),
-      stepPlaceholderRule = ruleFromBNF(stepPlaceholderBNF),
-      variablePlaceholderRule = ruleFromBNF(variablePlaceholderBNF),
-      referencePlaceholderRule = ruleFromBNF(referencePlaceholderBNF),
-      statementPlaceholderRule = ruleFromBNF(statementPlaceholderBNF),
-      combinatorPlaceholderRule = ruleFromBNF(combinatorPlaceholderBNF),
-      constructorPlaceholderRule = ruleFromBNF(constructorPlaceholderBNF),
-      equivalencePlaceholderRule = ruleFromBNF(equivalencePlaceholderBNF),
-      metavariablePlaceholderRule = ruleFromBNF(metavariablePlaceholderBNF),
-      termSubstitutionPlaceholderRule = ruleFromBNF(termSubstitutionPlaceholderBNF),
-      frameSubstitutionPlaceholderRule = ruleFromBNF(frameSubstitutionPlaceholderBNF),
-      statementSubstitutionPlaceholderRule = ruleFromBNF(statementSubstitutionPlaceholderBNF),
-      referenceSubstitutionPlaceholderRule = ruleFromBNF(referenceSubstitutionPlaceholderBNF);
+import { ruleFromRuleName } from "../utilities/bnf";
+import { TERM_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         COMBINATOR_RULE_NAME,
+         CONSTRUCTOR_RULE_NAME,
+         EQUIVALENCE_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+
+const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
+      referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
+      statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
+      combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
+      constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
+      equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
+      termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
+      frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
+      statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
+      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
 export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
 
-export function instantiateStep(string, context) { return instantiate(stepPlaceholderRule, string, context); }
-
-export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
-
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
@@ -45,8 +35,6 @@ export function instantiateConstructor(string, context) { return instantiate(con
 
 export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
 
-export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
-
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }
@@ -62,8 +50,11 @@ function instantiate(placeholderRule, string, context) {
         parser = context.getParser(),
         content = `${string}
 `,
-        tokens = lexer.tokenise(content),
-        startRule = placeholderRule;  ///
+        tokens = lexer.tokenise(content);
+
+  context.setTokens(tokens);
+
+  const startRule = placeholderRule;  ///
 
   node = parser.parse(tokens, startRule);