Initial

resources/app/node_modules/peggy/lib/compiler/index.js

@@ -0,0 +1,170 @@
+"use strict";
+
+const addImportedRules = require("./passes/add-imported-rules");
+const fixLibraryNumbers = require("./passes/fix-library-numbers");
+const generateBytecode = require("./passes/generate-bytecode");
+const generateJS = require("./passes/generate-js");
+const inferenceMatchResult = require("./passes/inference-match-result");
+const removeProxyRules = require("./passes/remove-proxy-rules");
+const mergeCharacterClasses = require("./passes/merge-character-classes");
+const reportDuplicateImports = require("./passes/report-duplicate-imports");
+const reportDuplicateLabels = require("./passes/report-duplicate-labels");
+const reportDuplicateRules = require("./passes/report-duplicate-rules");
+const reportInfiniteRecursion = require("./passes/report-infinite-recursion");
+const reportInfiniteRepetition = require("./passes/report-infinite-repetition");
+const reportUndefinedRules = require("./passes/report-undefined-rules");
+const reportIncorrectPlucking = require("./passes/report-incorrect-plucking");
+const Session = require("./session");
+const visitor = require("./visitor");
+const { base64 } = require("./utils");
+
+function processOptions(options, defaults) {
+  const processedOptions = {};
+
+  Object.keys(options).forEach(name => {
+    processedOptions[name] = options[name];
+  });
+
+  Object.keys(defaults).forEach(name => {
+    if (!Object.prototype.hasOwnProperty.call(processedOptions, name)) {
+      processedOptions[name] = defaults[name];
+    }
+  });
+
+  return processedOptions;
+}
+
+function isSourceMapCapable(target) {
+  if (typeof target === "string") {
+    return target.length > 0;
+  }
+  return target && (typeof target.offset === "function");
+}
+
+const compiler = {
+  // AST node visitor builder. Useful mainly for plugins which manipulate the
+  // AST.
+  visitor,
+
+  // Compiler passes.
+  //
+  // Each pass is a function that is passed the AST. It can perform checks on it
+  // or modify it as needed. If the pass encounters a semantic error, it throws
+  // |peg.GrammarError|.
+  passes: {
+    prepare: [
+      addImportedRules,
+      reportInfiniteRecursion,
+    ],
+    check: [
+      reportUndefinedRules,
+      reportDuplicateRules,
+      reportDuplicateLabels,
+      reportInfiniteRepetition,
+      reportIncorrectPlucking,
+      reportDuplicateImports,
+    ],
+    transform: [
+      fixLibraryNumbers,
+      removeProxyRules,
+      mergeCharacterClasses,
+      inferenceMatchResult,
+    ],
+    generate: [
+      generateBytecode,
+      generateJS,
+    ],
+  },
+
+  // Generates a parser from a specified grammar AST. Throws |peg.GrammarError|
+  // if the AST contains a semantic error. Note that not all errors are detected
+  // during the generation and some may protrude to the generated parser and
+  // cause its malfunction.
+  compile(ast, passes, options) {
+    options = options !== undefined ? options : {};
+
+    options = processOptions(options, {
+      allowedStartRules: [ast.rules[0].name],
+      cache: false,
+      dependencies: {},
+      exportVar: null,
+      format: "bare",
+      output: "parser",
+      trace: false,
+    });
+
+    if (!Array.isArray(options.allowedStartRules)) {
+      throw new Error("allowedStartRules must be an array");
+    }
+    if (options.allowedStartRules.length === 0) {
+      throw new Error("Must have at least one start rule");
+    }
+    const allRules = ast.rules.map(r => r.name);
+    // "*" means all rules are start rules.  "*" is not a valid rule name.
+    if (options.allowedStartRules.some(r => r === "*")) {
+      options.allowedStartRules = allRules;
+    } else {
+      for (const rule of options.allowedStartRules) {
+        if (allRules.indexOf(rule) === -1) {
+          throw new Error(`Unknown start rule "${rule}"`);
+        }
+      }
+    }
+    // Due to https://github.com/mozilla/source-map/issues/444
+    // grammarSource is required
+    if (((options.output === "source-and-map")
+         || (options.output === "source-with-inline-map"))
+        && !isSourceMapCapable(options.grammarSource)) {
+      throw new Error("Must provide grammarSource (as a string or GrammarLocation) in order to generate source maps");
+    }
+
+    const session = new Session(options);
+    Object.keys(passes).forEach(stage => {
+      session.stage = stage;
+      session.info(`Process stage ${stage}`);
+
+      passes[stage].forEach(pass => {
+        session.info(`Process pass ${stage}.${pass.name}`);
+
+        pass(ast, options, session);
+      });
+
+      // Collect all errors by stage
+      session.checkErrors();
+    });
+
+    switch (options.output) {
+      case "parser":
+        // eslint-disable-next-line no-eval -- Required
+        return eval(ast.code.toString());
+
+      case "source":
+        return ast.code.toString();
+
+      case "source-and-map":
+        return ast.code;
+
+      case "source-with-inline-map": {
+        if (typeof TextEncoder === "undefined") {
+          throw new Error("TextEncoder is not supported by this platform");
+        }
+        const sourceMap = ast.code.toStringWithSourceMap();
+        const encoder = new TextEncoder();
+        const b64 = base64(
+          encoder.encode(JSON.stringify(sourceMap.map.toJSON()))
+        );
+        return sourceMap.code + `\
+//\x23 sourceMappingURL=data:application/json;charset=utf-8;base64,${b64}
+`;
+      }
+
+      case "ast":
+        return ast;
+
+      default:
+        throw new Error("Invalid output format: " + options.output + ".");
+    }
+  },
+};
+
+module.exports = compiler;