occam-custom-grammars 5.0.1228 → 5.0.1229

package/lib/utilities/vocabulary.js

@@ -16,31 +16,23 @@ _export(exports, {
         return validateVocabulary;
     }
 });
-var _occamlexers = require("occam-lexers");
-var _occamgrammars = require("occam-grammars");
 var _necessary = require("necessary");
 var _query = require("../utilities/query");
+var _nominal = require("../utilities/nominal");
 var _constants = require("../constants");
-var errorNodesQuery = (0, _query.nodesQuery)("//error"), expressionNodesQuery = (0, _query.nodesQuery)("//expression");
-var nominalLexer = _occamlexers.CommonLexer.fromNothing(_occamgrammars.NominalLexer), customGrammarVocabularyLexer = _occamgrammars.CustomGrammarVocabularyLexer.fromNothing(), customGrammarVocabularyParser = _occamgrammars.CustomGrammarVocabularyParser.fromNothing();
+var _grammar = require("../utilities/grammar");
 var first = _necessary.arrayUtilities.first, second = _necessary.arrayUtilities.second;
+var expressionNodesQuery = (0, _query.nodesQuery)("//expression");
 function validateVocabulary(vocabulary) {
     if (vocabulary === null || vocabulary === _constants.EMPTY_STRING) {
         return;
     }
-    var content = vocabulary, tokens = customGrammarVocabularyLexer.tokenise(content), node = customGrammarVocabularyParser.parse(tokens);
-    if (node === null) {
-        throw new Error("The vocabulary cannot be parsed.");
-    }
-    var errorNodes = errorNodesQuery(node), errorNodesLength = errorNodes.length;
-    if (errorNodesLength > 0) {
-        throw new Error("The vocabulary contains errors.");
-    }
+    var content = vocabulary, tokens = _grammar.customGrammarVocabularyLexer.tokenise(content), node = _grammar.customGrammarVocabularyParser.parse(tokens);
     var expressionNodes = expressionNodesQuery(node);
     expressionNodes.forEach(function(expressionNode) {
-        var content = contentFromExpressionNode(expressionNode), tokens = nominalLexer.tokenise(content), tokensLength = tokens.length;
+        var content = contentFromExpressionNode(expressionNode), tokens = _nominal.nominalLexer.tokenise(content), tokensLength = tokens.length;
         if (tokensLength > 1) {
-            throw new Error("Tokenising '".concat(content, "' results in more than one token."));
+            throw new Error("Tokenising the '".concat(content, "' content results in more than one token."));
         }
         var firstToken = first(tokens), token = firstToken, type = token.getType();
         if (type !== _constants.UNASSIGNED_TYPE) {
@@ -55,7 +47,7 @@ function expressionsFromVocabulary(vocabulary, expressions) {
     if (vocabulary === null || vocabulary === _constants.EMPTY_STRING) {
         return;
     }
-    var content = vocabulary, tokens = customGrammarVocabularyLexer.tokenise(content), node = customGrammarVocabularyParser.parse(tokens), expressionNodes = expressionNodesQuery(node);
+    var content = vocabulary, tokens = _grammar.customGrammarVocabularyLexer.tokenise(content), node = _grammar.customGrammarVocabularyParser.parse(tokens), expressionNodes = expressionNodesQuery(node);
     expressionNodes.forEach(function(expressionNode) {
         var content = contentFromExpressionNode(expressionNode), expression = content; ///
         expressions.push(expression);
@@ -66,4 +58,4 @@ function contentFromExpressionNode(expressionNode) {
     return content;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-custom-grammars",
   "author": "James Smith",
-  "version": "5.0.1228",
+  "version": "5.0.1229",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-custom-grammars",
   "description": "Occam's custom grammars.",
@@ -14,7 +14,7 @@
     "occam-grammar-utilities": "^8.0.345",
     "occam-grammars": "^1.3.311",
     "occam-lexers": "^23.1.1",
-    "occam-parsers": "^23.1.1",
+    "occam-parsers": "^23.1.3",
     "occam-query": "^4.1.109"
   },
   "devDependencies": {

package/src/constants.js

@@ -3,4 +3,6 @@
 export const EMPTY_STRING = "";
 export const VERTICAL_BAR = "|";
 export const UNASSIGNED_TYPE = "unassigned";
+export const STUFF_RULE_NAME = "stuff";
+export const NONSENSE_RULE_NAME = "nonsense";
 export const UNDERSCORE_CHARACTER = "_";

package/src/customGrammar/combined.js

@@ -6,7 +6,9 @@ import { eliminateLeftRecursion } from "occam-grammar-utilities";
 
 import defaultCustomGrammar from "../customGrammar/default";
 
+import { validateBNF } from "../utilities/bnf";
 import { EMPTY_STRING, VERTICAL_BAR } from "../constants";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 import { validateVocabulary, expressionsFromVocabulary } from "../utilities/vocabulary";
 import { TYPE_VOCABULARY_NAME, SYMBOL_VOCABULARY_NAME } from "../vocabularyNames";
 
@@ -45,7 +47,7 @@ export default class CombinedCustomGrammar {
       customGrammars = [ defaultCustomGrammar, ...customGrammars ]; ///
     }
 
-    const rules = rulesFromCustomGrammarsAndDefaultBNF(customGrammars),
+    const rules = rulesFromCustomGrammars(customGrammars),
           entries = entriesFromCustomGrammars(customGrammars),
           combinedCustomGrammar = new CombinedCustomGrammar(rules, entries);
 
@@ -57,7 +59,7 @@ export default class CombinedCustomGrammar {
       customGrammars = [ defaultCustomGrammar, ...customGrammars ]; ///
     }
 
-    const rules = rulesFromCustomGrammarsAndDefaultBNF(customGrammars),
+    const rules = rulesFromCustomGrammars(customGrammars),
           entries = entriesFromCustomGrammars(customGrammars),
           combinedCustomGrammar = new CombinedCustomGrammar(rules, entries);
     
@@ -65,9 +67,13 @@ export default class CombinedCustomGrammar {
   }
 }
 
-function rulesFromCustomGrammarsAndDefaultBNF(customGrammars) {
-  const bnfs = customGrammars.map((customGrammar) => {
-          const bnf = customGrammar.getBNF();
+function rulesFromCustomGrammars(customGrammars) {
+  const ruleNames = [
+          TERM_RULE_NAME,
+          STATEMENT_RULE_NAME,
+        ],
+        bnfs = ruleNames.map((ruleName) => {
+          const bnf = bnfFromCustomGrammars(customGrammars, ruleName);
 
           return bnf;
         }),
@@ -93,6 +99,25 @@ function entriesFromCustomGrammars(customGrammars) {
   return entries;
 }
 
+function bnfFromCustomGrammars(customGrammars, ruleName) {
+  const bnfs = [];
+
+  backwardsForEach(customGrammars, (customGrammar) => {
+    const bnf = customGrammar.getBNF(ruleName),
+          customGrammarDefaultCustomGrammar = customGrammar.isDefaultCustomGrammar();
+
+    if (!customGrammarDefaultCustomGrammar) {
+      validateBNF(bnf, ruleName);
+    }
+
+    bnfs.push(bnf);
+  });
+
+  const bnf = bnfs.join(EMPTY_STRING);
+
+  return bnf;
+}
+
 function entryFromCustomGrammars(customGrammars, vocabularyName) {
   const expressions = [];
 

package/src/customGrammar.js

@@ -34,34 +34,12 @@ export default class CustomGrammar {
     return this.symbolVocabulary;
   }
 
-  getBNF(ruleName = null) {
+  getBNF(ruleName) {
     let bnf;
 
     switch (ruleName) {
       case TERM_RULE_NAME: bnf = this.termBNF; break;
       case STATEMENT_RULE_NAME: bnf = this.statementBNF; break;
-
-      default: {
-        const ruleNames = [
-                TERM_RULE_NAME,
-                STATEMENT_RULE_NAME
-              ],
-              combinedBNF = ruleNames.reduce((combinedBNF, ruleName) => {
-                const bnf = this.getBNF(ruleName);
-
-                if (bnf !== EMPTY_STRING) {
-                  combinedBNF = `${combinedBNF}
-            
-${bnf}`;
-                }
-
-                return combinedBNF;
-              }, EMPTY_STRING);
-
-        bnf = combinedBNF;  ///
-
-        break;
-      }
     }
 
     return bnf;

package/src/example/customGrammar/userDefined1.js

@@ -5,7 +5,11 @@ import { CustomGrammar } from "../../index"; ///
 import { USER_DEFINED_CUSTOM_GRAMMAR_NAME_1 } from "../grammarNames";
 
 const name = USER_DEFINED_CUSTOM_GRAMMAR_NAME_1,
-      termBNF = "",
+      termBNF = `
+
+        term  ::=  [type] "stuff" ;
+        
+      `,
       statementBNF = "",
       typeVocabulary = "",
       symbolVocabulary = "",

package/src/example/view.js

@@ -132,16 +132,16 @@ class View extends Element {
               Custom grammar
             </SubHeading>
             <NameSelect onChange={changeHandler} />
-            <SubHeading>
-              BNF
-            </SubHeading>
-            <RuleNameSelect onChange={changeHandler} />
-            <BNFTextarea onKeyUp={keyUpHandler} />
             <SubHeading>
               Vocabulary
             </SubHeading>
             <VocabularyNameSelect onChange={changeHandler} />
             <VocabularyTextarea onKeyUp={keyUpHandler} />
+            <SubHeading>
+              BNF
+            </SubHeading>
+            <RuleNameSelect onChange={changeHandler} />
+            <BNFTextarea onKeyUp={keyUpHandler} />
             <SubHeading>
               Start rule
             </SubHeading>

package/src/typesMap.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { nominalParser } from "./utilities/nominal";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+import { STUFF_RULE_NAME, NONSENSE_RULE_NAME } from "./constants";
+
+const { first } = arrayUtilities;
+
+const ruleMap = nominalParser.getRuleMap(),
+      stuffRule = ruleMap[STUFF_RULE_NAME],
+      nonsenseRule = ruleMap[NONSENSE_RULE_NAME],
+      stuffTypes = typesFromRule(stuffRule),
+      nonsenseTypes = typesFromRule(nonsenseRule),
+      termTypes = stuffTypes, ///
+      statementTypes = nonsenseTypes,
+      typesMap = {
+        [TERM_RULE_NAME]: termTypes,
+        [STATEMENT_RULE_NAME]: statementTypes
+      };
+
+export default typesMap;
+
+function typesFromRule(rule) {
+  let parts;
+
+  const definitions = rule.getDefinitions(),
+        firstDDefinition = first(definitions),
+        definition = firstDDefinition;  ///
+
+  parts = definition.getParts();
+
+  const firstPart = first(parts),
+        oneOrMorePartsPart = firstPart, ///
+        part = oneOrMorePartsPart.getPart(),
+        choiceOrPartsPart = part; ///
+
+  parts = choiceOrPartsPart.getParts();
+
+  const types = parts.map((part) => {
+    const significantTokenTypePart = part,  ///
+          significantTokenType = significantTokenTypePart.getSignificantTokenType(),
+          type = significantTokenType;  ///
+
+    return type;
+  });
+
+  return types;
+}

package/src/utilities/bnf.js

@@ -1,12 +1,88 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
 
-import { EMPTY_STRING } from "../constants";
+import typesMap from "../typesMap";
 
-export function validateBNf(buf) {
-  if ((buf === null) || (buf === EMPTY_STRING)) {
+import { nodesQuery } from "../utilities/query";
+import { nominalLexer } from "../utilities/nominal";
+import { EMPTY_STRING, UNDERSCORE_CHARACTER } from "../constants";
+import { customGrammarBNFLexer, customGrammarBNFParser } from "../utilities/grammar";
+
+const { first, second } = arrayUtilities;
+
+const stringLiteralTerminalNodesQuery = nodesQuery("//stringLiteral/@*!"),
+      significantTokenTypeTerminalNodesQuery = nodesQuery("//significantTokenType/@*!");
+
+export function validateBNF(bnf, ruleName) {
+  if ((bnf === null) || (bnf === EMPTY_STRING)) {
     return;
   }
 
+  const content = bnf,
+        tokens = customGrammarBNFLexer.tokenise(content),
+        node = customGrammarBNFParser.parse(tokens);
+
+  const types = typesMap[ruleName],
+        significantTokenTypeTerminalNodes = significantTokenTypeTerminalNodesQuery(node);
+
+  significantTokenTypeTerminalNodes.forEach((significantTokenTypeTerminalNode) => {
+    const type = typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode),
+          typesIncludeType = types.includes(type);
+
+    if (!typesIncludeType) {
+      throw new Error(`The '${type}' type is not included in the '${ruleName}' rule's types.`)
+    }
+  });
+
+  const stringLiteralTerminalNodes = stringLiteralTerminalNodesQuery(node);
+
+  stringLiteralTerminalNodes.forEach((stringLiteralTerminalNode) => {
+    const content = contentFromStringLiteralTerminalNode(stringLiteralTerminalNode);
+
+    if (content === UNDERSCORE_CHARACTER) {
+      throw new Error(`The "${content}" string literal cannot be an underscore.`);
+    }
+
+    const tokens = nominalLexer.tokenise(content),
+          tokensLength = tokens.length;
+
+    if (tokensLength !== 1) {
+      throw new Error(`Tokenising the "${content}" string literal does not result in a single token.`);
+    }
+
+    const firstToken = first(tokens),
+          token = firstToken, ///
+          type = token.getType(),
+          typesIncludeType = types.includes(type);
+
+    if (!typesIncludeType) {
+      throw new Error(`The "${content}" string literal's token's '${type}' type is not included in the '${ruleName}' rule's types.`)
+    }
+  });
+}
+
+function contentFromStringLiteralTerminalNode(stringLiteralTerminalNode) {
+  let content;
+
+  content = stringLiteralTerminalNode.getContent();
+
+  const matches = content.match(/"([^"]+)"/),
+        secondMatch = second(matches);
+
+  content = secondMatch; ///
+
+  return content;
+}
+
+function typeFromSignificantTokenTypeTerminalNode(significantTokenTypeTerminalNode) {
+  let type;
+
+  const content = significantTokenTypeTerminalNode.getContent(),
+        matches = content.match(/\[([^\]]+)\]/),
+        secondMatch = second(matches);
+
+  type = secondMatch; ///
 
+  return type;
 }

package/src/utilities/grammar.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { CustomGrammarBNFLexer, CustomGrammarBNFParser } from "occam-grammars";
+import { CustomGrammarVocabularyLexer, CustomGrammarVocabularyParser } from "occam-grammars";
+
+export const customGrammarBNFLexer = CustomGrammarBNFLexer.fromNothing();
+
+export const customGrammarBNFParser = CustomGrammarBNFParser.fromNothing();
+
+export const customGrammarVocabularyLexer = CustomGrammarVocabularyLexer.fromNothing();
+
+export const customGrammarVocabularyParser = CustomGrammarVocabularyParser.fromNothing();

package/src/utilities/nominal.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { CommonLexer } from "occam-lexers";
+import { CommonParser } from "occam-parsers";
+import { NominalLexer, NominalParser } from "occam-grammars";
+
+export const nominalLexer = CommonLexer.fromNothing(NominalLexer);
+
+export const nominalParser = CommonParser.fromNothing(NominalParser);

package/src/utilities/vocabulary.js

@@ -1,22 +1,16 @@
 "use strict";
 
-import { CommonLexer } from "occam-lexers";
-import { NominalLexer } from "occam-grammars";
 import { arrayUtilities } from "necessary";
-import { CustomGrammarVocabularyLexer, CustomGrammarVocabularyParser } from "occam-grammars";
 
 import { nodesQuery } from "../utilities/query";
+import { nominalLexer } from "../utilities/nominal";
 import { EMPTY_STRING, UNASSIGNED_TYPE, UNDERSCORE_CHARACTER } from "../constants";
-
-const errorNodesQuery = nodesQuery("//error"),
-      expressionNodesQuery = nodesQuery("//expression")
-
-const nominalLexer = CommonLexer.fromNothing(NominalLexer),
-      customGrammarVocabularyLexer = CustomGrammarVocabularyLexer.fromNothing(),
-      customGrammarVocabularyParser = CustomGrammarVocabularyParser.fromNothing();
+import { customGrammarVocabularyLexer, customGrammarVocabularyParser } from "../utilities/grammar"
 
 const { first, second } = arrayUtilities;
 
+const expressionNodesQuery = nodesQuery("//expression")
+
 export function validateVocabulary(vocabulary) {
   if ((vocabulary === null) || (vocabulary === EMPTY_STRING)) {
     return;
@@ -26,17 +20,6 @@ export function validateVocabulary(vocabulary) {
         tokens = customGrammarVocabularyLexer.tokenise(content),
         node = customGrammarVocabularyParser.parse(tokens);
 
-  if (node === null) {
-    throw new Error("The vocabulary cannot be parsed.");
-  }
-
-  const errorNodes = errorNodesQuery(node),
-        errorNodesLength = errorNodes.length;
-
-  if (errorNodesLength > 0) {
-    throw new Error("The vocabulary contains errors.");
-  }
-
   const expressionNodes = expressionNodesQuery(node);
 
   expressionNodes.forEach((expressionNode) => {
@@ -45,7 +28,7 @@ export function validateVocabulary(vocabulary) {
           tokensLength = tokens.length;
 
     if (tokensLength > 1) {
-      throw new Error(`Tokenising '${content}' results in more than one token.`);
+      throw new Error(`Tokenising the '${content}' content results in more than one token.`);
     }
 
     const firstToken = first(tokens),