@scinorandex/sparse 0.0.1

package/example/math/example.ts

@@ -0,0 +1,49 @@
+import { Slex } from "@scinorandex/slex";
+import { buildProductions, buildStates, LR1StackSymbol, Sparse } from "../../src/index";
+import fs from "fs/promises";
+
+// prettier-ignore
+enum TokenType {
+  PLUS, MINUS, STAR, SLASH, NUMBER, EOF
+}
+
+type Metadata = {};
+
+const lexerGenerator = new Slex<TokenType, Metadata>({
+  EOF_TYPE: TokenType.EOF,
+  isHigherPrecedence: ({ current, next }) => false,
+});
+
+lexerGenerator.addRule("plus", "$+", TokenType.PLUS);
+lexerGenerator.addRule("minus", "$-", TokenType.MINUS);
+lexerGenerator.addRule("star", "$*", TokenType.STAR);
+lexerGenerator.addRule("forward_slash", "$/", TokenType.SLASH);
+lexerGenerator.addRule("digit", "0|1|2|3|4|5|6|7|8|9");
+lexerGenerator.addRule("float_number", "(${digit})+$.(${digit})+");
+lexerGenerator.addRule("decimal_number", "(${digit})+");
+lexerGenerator.addRule("number_literal", "${float_number}|${decimal_number}", TokenType.NUMBER);
+
+const lexer = lexerGenerator.generate(`2.4 + 3.5 * 1 / 456.789`, () => ({}));
+
+type StringifiedNode = (StringifiedNode | string)[];
+class Node {
+  constructor(public readonly nodes: LR1StackSymbol<TokenType, Metadata, Node>[]) {}
+  toObject(): StringifiedNode {
+    return this.nodes.map((node) => (node.type === "token" ? node.token.lexeme : node.node.toObject()));
+  }
+}
+
+async function main() {
+  const toStringifiedTokenType = (type: TokenType) => TokenType[type];
+  const productions = buildProductions(await fs.readFile("./example/math/grammar.txt", "utf8"));
+  const states = buildStates(await fs.readFile("./example/math/table.txt", "utf8"));
+  const parserGenerator = new Sparse<TokenType, Metadata, Node>({ productions, states, toStringifiedTokenType });
+
+  const parser = parserGenerator.generate(lexer, {
+    reducer: (input, productionIndex) => new Node(input),
+  });
+
+  console.log(parser.parse().result!.toObject());
+}
+
+main();

package/example/math/grammar.txt

@@ -0,0 +1,11 @@
+<S>: <PROGRAM>;
+<PROGRAM>: <EXPRESSION> [EOF];
+<PROGRAM>: [EOF];
+<EXPRESSION>: <TERM_EXPRESSION>;
+<TERM_EXPRESSION>: <FACTOR_EXPRESSION> [PLUS] <TERM_EXPRESSION>;
+<TERM_EXPRESSION>: <FACTOR_EXPRESSION> [MINUS] <TERM_EXPRESSION>;
+<TERM_EXPRESSION>: <FACTOR_EXPRESSION>;
+<FACTOR_EXPRESSION>: <ENDPOINT> [STAR] <FACTOR_EXPRESSION>;
+<FACTOR_EXPRESSION>: <ENDPOINT> [SLASH] <FACTOR_EXPRESSION>;
+<FACTOR_EXPRESSION>: <ENDPOINT>;
+<ENDPOINT>: [NUMBER];

package/example/math/table.txt

@@ -0,0 +1,22 @@
+[EOF]=s6, [NUMBER]=s7, <PROGRAM>=1, <EXPRESSION>=2, <TERM_EXPRESSION>=3, <FACTOR_EXPRESSION>=4, <ENDPOINT>=5
+[EOF]=r0
+[EOF]=s8
+[EOF]=r3
+[EOF]=r6, [PLUS]=s9, [MINUS]=s10
+[PLUS]=r9, [MINUS]=r9, [EOF]=r9, [STAR]=s11, [SLASH]=s12
+[EOF]=r2
+[STAR]=r10, [SLASH]=r10, [EOF]=r10, [PLUS]=r10, [MINUS]=r10
+[EOF]=r1
+[NUMBER]=s7, <TERM_EXPRESSION>=13, <FACTOR_EXPRESSION>=4, <ENDPOINT>=5
+[NUMBER]=s7, <TERM_EXPRESSION>=14, <FACTOR_EXPRESSION>=4, <ENDPOINT>=5
+[NUMBER]=s7, <FACTOR_EXPRESSION>=15, <ENDPOINT>=16
+[NUMBER]=s7, <FACTOR_EXPRESSION>=17, <ENDPOINT>=16
+[EOF]=r4
+[EOF]=r5
+[PLUS]=r7, [MINUS]=r7, [EOF]=r7
+[EOF]=r9, [PLUS]=r9, [MINUS]=r9, [STAR]=s18, [SLASH]=s19
+[PLUS]=r8, [MINUS]=r8, [EOF]=r8
+[NUMBER]=s7, <FACTOR_EXPRESSION>=20, <ENDPOINT>=16
+[NUMBER]=s7, <FACTOR_EXPRESSION>=21, <ENDPOINT>=16
+[EOF]=r7, [PLUS]=r7, [MINUS]=r7
+[EOF]=r8, [PLUS]=r8, [MINUS]=r8

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@scinorandex/sparse",
+  "version": "0.0.1",
+  "description": "Yet another parser generator",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w"
+  },
+  "bin": {
+    "sparse": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "github.com/scinscinscin/sparse"
+  },
+  "keywords": [
+    "parser",
+    "parser-generator",
+    "yacc",
+    "bison",
+    "antlr",
+    "programming-languages"
+  ],
+  "author": "scinorandex",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^22.15.19"
+  },
+  "resolutions": {},
+  "dependencies": {
+    "@scinorandex/slex": "^0.0.2",
+    "minimist": "^1.2.8"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,49 @@
+#! /usr/bin/env node
+import fs from "fs/promises";
+import { GrammarToken, tryBuildProductions } from "./grammarParser";
+import { generateStates } from "./generator";
+import minimist from "minimist";
+import path from "path";
+import { buildErrorWindow } from "./utils/errorWindowBuilder";
+
+const args = minimist(process.argv.slice(2));
+
+function checkFileExists(filepath: string) {
+  return new Promise<boolean>((resolve, reject) => {
+    fs.access(filepath, fs.constants.F_OK)
+      .then(() => resolve(true))
+      .catch(() => resolve(false));
+  });
+}
+
+async function main() {
+  if (typeof args.input !== "string" || typeof args.output !== "string") {
+    console.log("Usage: npx @scinorandex/sparse --input=<input> --output=<output>");
+    return;
+  }
+
+  const inputFile = path.resolve(args.input);
+  const outputFile = path.resolve(args.output);
+  console.log(`Reading grammar from ${inputFile} and outputting table to ${outputFile}\n`);
+
+  if (!(await checkFileExists(inputFile))) return console.log(`File ${inputFile} does not exist`);
+
+  const grammar = await fs.readFile(args.input, "utf8");
+  const productionsResult = tryBuildProductions(grammar);
+  if (productionsResult.success === false) {
+    console.log(productionsResult.reason);
+    console.log(buildErrorWindow(grammar, productionsResult.token));
+    return;
+  }
+
+  const generatorResult = generateStates(productionsResult.value);
+  if (generatorResult.success === false) {
+    console.log(generatorResult.reason);
+    console.log(buildErrorWindow(grammar, generatorResult.token));
+    return;
+  }
+
+  await fs.writeFile(outputFile, generatorResult.value.toTable(), { encoding: "utf-8" });
+}
+
+main();

package/src/generator.ts

@@ -0,0 +1,394 @@
+import { GrammarToken, Production } from "./grammarParser";
+import { TableState } from "./parser";
+import { Result } from "./utils/Result";
+
+const xContainsAllOfY = <T>(xs: Set<T>, ys: Set<T>) => [...ys].every((x) => xs.has(x));
+const EOF_STRING = "[EOF]";
+
+// Creates a list of first sets for each production
+function computeFirstSets(allProductions: Production[]): Result<Map<string, Set<string>>> {
+  // Initialize the hashmap
+  const ret = new Map<string, Set<string>>();
+  for (const production of allProductions) ret.set(production.lhs.lexeme, new Set());
+
+  // Keep iterating through all productions until no edits are made
+  let wasEdited = true;
+  while (wasEdited) {
+    wasEdited = false;
+
+    for (const production of allProductions) {
+      const toBeModified = ret.get(production.lhs.lexeme)!;
+
+      const firstRhsToken = production.rhs[0];
+      if (firstRhsToken.type === "variable") {
+        const add = ret.get(firstRhsToken.token.lexeme);
+
+        if (add == null) {
+          return {
+            success: false,
+            reason: `Variable "${firstRhsToken.token.lexeme}" doesn't have a corresponding left hand side`,
+            token: firstRhsToken.token,
+          };
+        }
+
+        // check if the hashmap of the current production already contains all the items to be added
+        // if not then add them and set wasEdited to true so we iterate one more time
+        if (!xContainsAllOfY(toBeModified, add)) {
+          wasEdited = true;
+          ret.set(production.lhs.lexeme, new Set([...toBeModified, ...add]));
+        }
+      } else if (firstRhsToken.type === "terminal") {
+        // add terminal to toBeModified and set wasEdited to true
+        if (toBeModified.has(firstRhsToken.token.lexeme) == false) {
+          wasEdited = true;
+          ret.set(production.lhs.lexeme, new Set([...toBeModified, firstRhsToken.token.lexeme]));
+        }
+      }
+    }
+  }
+
+  return { success: true, value: ret };
+}
+
+function computeFollowSets(
+  allProductions: Production[]
+): Result<{ firstSets: Map<string, Set<string>>; followSets: Map<string, Set<string>> }> {
+  const firstSetsResult = computeFirstSets(allProductions);
+  if (firstSetsResult.success === false) return firstSetsResult;
+
+  const firstSets = firstSetsResult.value;
+
+  // create a list of follow sets and add EOF to the initial production
+  const ret = new Map<string, Set<string>>();
+  for (const production of allProductions) ret.set(production.lhs.lexeme, new Set());
+  ret.get(allProductions[0].lhs.lexeme)!.add(EOF_STRING);
+
+  let wasEdited = true;
+  while (wasEdited) {
+    wasEdited = false;
+
+    for (const variable of ret.keys()) {
+      for (const currentProduction of allProductions) {
+        // check the rhs of current production for variable
+        const rhs = currentProduction.rhs;
+
+        for (let i = 0; i < rhs.length; i++) {
+          const currentRhsToken = rhs[i];
+
+          if (currentRhsToken.type === "variable" && currentRhsToken.token.lexeme === variable) {
+            if (i === rhs.length - 1) {
+              // we are at the end of rhs, so whatever is in currentProduction
+              // we need to also need to add to variable
+              const toBeAdded = ret.get(currentProduction.lhs.lexeme)!;
+              const receiver = ret.get(variable)!;
+              if (!xContainsAllOfY(receiver, toBeAdded)) {
+                wasEdited = true;
+                ret.set(variable, new Set([...toBeAdded, ...receiver]));
+              }
+            } else {
+              // not at the end of rhs, so we need to add the FIRST set of the next rhs token
+              const nextRhsToken = rhs[i + 1];
+              if (nextRhsToken.type === "terminal") {
+                // next token is a terminal, check if its in existng follow set and add if it doesn't exist
+                const existing = ret.get(variable)!;
+                if (!existing.has(nextRhsToken.token.lexeme)) {
+                  wasEdited = true;
+                  ret.set(variable, new Set([...existing, nextRhsToken.token.lexeme]));
+                }
+              } else if (nextRhsToken.type === "variable") {
+                // next token is a variable, get the first set of the variable
+                // check if it's not in the followset and add if not
+                const firstSet = firstSets.get(nextRhsToken.token.lexeme);
+                if (firstSet == null)
+                  return {
+                    success: false,
+                    reason: `Variable "${nextRhsToken.token.lexeme}" doesn't have a corresponding left hand side`,
+                    token: nextRhsToken.token,
+                  };
+
+                if (!xContainsAllOfY(ret.get(variable)!, firstSet)) {
+                  wasEdited = true;
+                  ret.set(variable, new Set([...ret.get(variable)!, ...firstSet]));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { success: true, value: { firstSets, followSets: ret } };
+}
+
+type Item = Production & { dot: number; lookahead: string[] };
+type State = { itemSet: Item[]; kernel: Item; count: number };
+
+export const generateStates = (productions: Production[]): Result<GeneratorResult> => {
+  const followSetsResult = computeFollowSets(productions);
+  if (followSetsResult.success == false) return followSetsResult;
+
+  const { firstSets, followSets } = followSetsResult.value;
+
+  // This funciton takes a token and determines what the next lookahead should be
+  // The implementation of this function ensures that the table is an LR(1) parsing table
+  const determineNextLookAhead = (
+    lhs: GrammarToken,
+    array: { type: "terminal" | "variable"; token: GrammarToken }[]
+  ): Result<string[]> => {
+    if (array.length === 0) {
+      const followSet = followSets.get(lhs.lexeme);
+      if (followSet != undefined) return { success: true, value: [...followSet] };
+
+      return {
+        success: false,
+        reason: `Variable ${lhs.lexeme} not present in computed follow sets`,
+        token: lhs,
+      };
+    } else {
+      const next = array[0];
+
+      if (next.type === "terminal") return { success: true, value: [next.token.lexeme] };
+      const testing = firstSets.get(next.token.lexeme);
+      if (testing !== undefined) return { success: true, value: [...testing] };
+
+      return {
+        success: false,
+        reason: `Variable ${next.token.lexeme} not present in computed first sets`,
+        token: next.token,
+      };
+    }
+  };
+
+  // This fnuction creates the initial item set based on the
+  // production provided. It creating the initial item and expands it
+  function generateInitialItemSet(production: Production) {
+    const initialItem = { lhs: production.lhs, rhs: production.rhs, dot: 0, lookahead: [EOF_STRING] } as Item;
+    return expandItemSet([initialItem]);
+  }
+
+  // This function expands the item sets provided to it
+  function expandItemSet(items: Item[]): Result<{ itemSet: Item[]; kernel: Item }> {
+    const itemSet: Item[] = [...items];
+
+    // Create a queue of unprocessed items and keep shifting until there are no more items left
+    const unprocesssedItems: Item[] = [...items];
+    while (unprocesssedItems.length > 0) {
+      const currentItem = unprocesssedItems.shift()!;
+
+      // Check if the symbol after the dot is a non terminal
+      const after = currentItem.rhs[currentItem.dot];
+      if (after == null) continue; // TODO: check if this should be here
+
+      if (after.type === "variable") {
+        // Find prodctions whose left hand side is the symbol after the dot
+        const newProductions = productions.filter((p) => p.lhs.lexeme === after.token.lexeme);
+
+        // Compute the lookahead for the new productions to be added to the item set
+        const rest = currentItem.rhs.slice(currentItem.dot + 1);
+
+        const lookaheadResult = determineNextLookAhead(currentItem.lhs, rest);
+        if (lookaheadResult.success === false) return lookaheadResult;
+        const lookahead = lookaheadResult.value;
+
+        for (const newProduction of newProductions) {
+          // Create the new item and check if it already exists in the item set
+          // If it doesn't exist, add it to the item set and the queue of unprocessed items
+          const newItem = { lhs: newProduction.lhs, rhs: newProduction.rhs, dot: 0, lookahead } as Item;
+          const encoding = JSON.stringify(newItem);
+
+          if (itemSet.some((i) => JSON.stringify(i) === encoding) == false) {
+            unprocesssedItems.push(newItem);
+            itemSet.push(newItem);
+          }
+        }
+      }
+    }
+
+    // Return the item set and the kernel
+    return { success: true, value: { itemSet, kernel: items[0] } };
+  }
+
+  const initialItemSetResult = generateInitialItemSet(productions[0]);
+  if (initialItemSetResult.success === false) return initialItemSetResult;
+  const initialItemSet = initialItemSetResult.value;
+
+  function generateStates(_initialState: { itemSet: Item[]; kernel: Item }): Result<{
+    states: State[];
+    GotoTable: Map<string, number>[];
+    ActionTable: Map<string, { action: "shift" | "reduce"; value: number }>[];
+  }> {
+    const initialState = { ..._initialState, count: 0 };
+    // Create a list of states to be returned and another list of states that have not been vistited
+    const states = [initialState] as State[];
+    const unprocessedStates = [initialState] as State[];
+
+    // array of maps whose keys is a variable and the value are the state to goto next
+    const GotoTable = [] as Map<string, number>[];
+    // array of maps whose keys is a terminal is a value of either to shift or reduce
+    const ActionTable = [] as Map<string, { action: "shift" | "reduce"; value: number }>[];
+
+    // While there is an unprocessed state, visit it
+    while (unprocessedStates.length > 0) {
+      const currentState = unprocessedStates.shift()!;
+      const nextStates_Goto = new Map<string, Item[]>();
+      const nextStates_Shift = new Map<string, Item[]>();
+
+      // determine transitions out of the current state by iterating
+      // through all the items in the item set of the state
+      calculateNextItem: for (const item of currentState.itemSet) {
+        // check next symbol after the dot
+        const nextSymbol = item.rhs[item.dot];
+
+        // no next symbol is available, therefore we need to create a reduction
+        if (nextSymbol == null) {
+          // Find the prodction that this item reduces to using the symbols on its right hand side
+          // TODO: check if the find can fail, honestly this might be invariant
+          const productionToReduceTo = productions
+            .map((p, i) => [p, i] as const)
+            .find(
+              ([p, _]) => JSON.stringify(p.rhs) === JSON.stringify(item.rhs) && p.lhs.lexeme === item.lhs.lexeme
+            )![1];
+
+          // for each lookahead in the item, create a new entry in the action table to reduce to the production found
+          for (const lookahead of item.lookahead) {
+            if (ActionTable[currentState.count] === undefined) ActionTable[currentState.count] = new Map();
+            ActionTable[currentState.count]!.set(lookahead, { action: "reduce", value: productionToReduceTo });
+          }
+
+          continue calculateNextItem;
+        }
+
+        // Create the next item by shifting the dot by 1 place
+        const newItem: Item = { ...item, dot: item.dot + 1 };
+
+        // Determine if we're going to create a GOTO or SHIFT based on the type of the symbol after the dot
+        if (nextSymbol.type === "variable") {
+          // Next symbol is a variable so we need to add it to the GOTO table
+          // Check if the GOTO table already has an entry for the next symbola and either push or create the array
+          if (nextStates_Goto.has(nextSymbol.token.lexeme)) nextStates_Goto.get(nextSymbol.token.lexeme)!.push(newItem);
+          else nextStates_Goto.set(nextSymbol.token.lexeme, [newItem]);
+        } else if (nextSymbol.type === "terminal") {
+          // Next symbol is a terminal so we need to add it to the SHIFT table
+          // Check if the SHIFT table already has an entry for the next symbola and either push or create the array
+          if (nextStates_Shift.has(nextSymbol.token.lexeme))
+            nextStates_Shift.get(nextSymbol.token.lexeme)!.push(newItem);
+          else nextStates_Shift.set(nextSymbol.token.lexeme, [newItem]);
+        }
+      }
+
+      // For each GOTO transition from the current state, expand  the item set that it points to
+      // and check if a state exist with the same itemset already exists
+      // If it doesn't exist, create a new state and add it to the list of states
+      // Add the existing / created state to the GOTO table
+      for (const [gotoTransition, gotoItems] of nextStates_Goto.entries()) {
+        const expandedItemsResult = expandItemSet(gotoItems);
+        if (expandedItemsResult.success === false) return expandedItemsResult;
+        const expandedItems = expandedItemsResult.value;
+
+        // check if a state exist with the same item sets
+        let existingState = states.find((s) => {
+          return (
+            s.kernel.lhs === expandedItems.kernel.lhs &&
+            s.kernel.rhs.length === expandedItems.kernel.rhs.length &&
+            JSON.stringify(s.kernel.rhs) === JSON.stringify(expandedItems.kernel.rhs) &&
+            s.kernel.lookahead.length === expandedItems.kernel.lookahead.length &&
+            JSON.stringify(s.kernel.lookahead) === JSON.stringify(expandedItems.kernel.lookahead) &&
+            JSON.stringify(s.itemSet) === JSON.stringify(expandedItems.itemSet)
+          );
+        });
+
+        if (GotoTable[currentState.count] === undefined) GotoTable[currentState.count] = new Map();
+        if (existingState == undefined) {
+          const newState: State = {
+            itemSet: expandedItems.itemSet,
+            kernel: expandedItems.kernel,
+            count: states.length,
+          };
+          states.push(newState);
+          unprocessedStates.push(newState);
+          existingState = newState;
+        }
+
+        GotoTable[currentState.count]!.set(gotoTransition, existingState.count);
+      }
+
+      // For each SHIFT transition from the current state, expand  the item set that it points to
+      // and check if a state exist with the same itemset already exists
+      // If it doesn't exist, create a new state and add it to the list of states
+      // Add the existing / created state to the SHIFT table
+      for (const [shiftTransition, shiftItems] of nextStates_Shift.entries()) {
+        const expandedItemsResult = expandItemSet(shiftItems);
+        if (expandedItemsResult.success === false) return expandedItemsResult;
+        const expandedItems = expandedItemsResult.value;
+
+        // check if a state exist with the same item sets
+        let existingState = states.find((s) => {
+          return (
+            s.kernel.lhs === expandedItems.kernel.lhs &&
+            s.kernel.rhs.length === expandedItems.kernel.rhs.length &&
+            JSON.stringify(s.kernel.rhs) === JSON.stringify(expandedItems.kernel.rhs) &&
+            s.kernel.lookahead.length === expandedItems.kernel.lookahead.length &&
+            JSON.stringify(s.kernel.lookahead) === JSON.stringify(expandedItems.kernel.lookahead) &&
+            JSON.stringify(s.itemSet) === JSON.stringify(expandedItems.itemSet)
+          );
+        });
+
+        // If there is no entry in the ActionTable for the current state, create one
+        if (ActionTable[currentState.count] === undefined) ActionTable[currentState.count] = new Map();
+
+        // If no such state exists, create a new state and add it to the list of states
+        if (existingState == undefined) {
+          const newState: State = {
+            itemSet: expandedItems.itemSet,
+            kernel: expandedItems.kernel,
+            count: states.length,
+          };
+          states.push(newState);
+          unprocessedStates.push(newState);
+          existingState = newState;
+        }
+
+        ActionTable[currentState.count]!.set(shiftTransition, { action: "shift", value: existingState.count });
+      }
+    }
+
+    // return the set of states, the GOTO table and the ACTION table
+    return { success: true, value: { states, GotoTable, ActionTable } };
+  }
+
+  const StatesResult = generateStates(initialItemSet);
+  if (StatesResult.success === false) return StatesResult;
+  const { states, ActionTable, GotoTable } = StatesResult.value;
+  return { success: true, value: new GeneratorResult(states, ActionTable, GotoTable) };
+};
+
+export class GeneratorResult {
+  constructor(
+    public readonly states: State[],
+    public readonly ActionTable: Map<string, { action: "shift" | "reduce"; value: number }>[],
+    public readonly GotoTable: Map<string, number>[]
+  ) {}
+
+  toTable(): string {
+    return this.ActionTable.map((actions, idx) => {
+      return [
+        ...[...actions.entries()].map(([k, { action, value }]) => `${k}=${action === "reduce" ? "r" : "s"}${value}`),
+        ...(this.GotoTable[idx] === undefined ? [] : [...this.GotoTable[idx].entries()].map(([k, v]) => `${k}=${v}`)),
+      ].join(", ");
+    }).join("\n");
+  }
+
+  toStates(): TableState[] {
+    return this.ActionTable.map((actions, idx) => {
+      const tableState = new TableState();
+      for (const [k, { action, value }] of actions.entries())
+        tableState.actions.set(k, { type: action === "reduce" ? "reduce" : "shift", value });
+
+      if (this.GotoTable[idx] !== undefined)
+        for (const [k, value] of this.GotoTable[idx].entries()) tableState.actions.set(k, { type: "goto", value });
+
+      return tableState;
+    });
+  }
+}

package/src/grammarParser.ts

@@ -0,0 +1,97 @@
+import { Slex, Token } from "@scinorandex/slex";
+import { Result } from "./utils/Result";
+
+export type Production = { lhs: GrammarToken; rhs: { type: "terminal" | "variable"; token: GrammarToken }[] };
+
+export type GrammarTokenMetadata = {};
+export enum GrammarTokenType {
+  PRODUCTION_NAME,
+  TOKEN_NAME,
+  COLON,
+  SEMICOLON,
+  EOF,
+}
+
+export type GrammarToken = Token<GrammarTokenType, GrammarTokenMetadata>;
+
+export const grammarLexerGenerator = new Slex<GrammarTokenType, GrammarTokenMetadata>({
+  EOF_TYPE: GrammarTokenType.EOF,
+  isHigherPrecedence: () => false,
+});
+
+grammarLexerGenerator.addRule(
+  "lowercase",
+  "a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z"
+);
+grammarLexerGenerator.addRule(
+  "uppercase",
+  "A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z"
+);
+grammarLexerGenerator.addRule("letter", "${lowercase} | ${uppercase}");
+grammarLexerGenerator.addRule("digit", "0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9");
+grammarLexerGenerator.addRule("alphanumeric", "${letter} | ${digit}");
+grammarLexerGenerator.addRule("identifier", "(${letter} | ${digit} | $_)*");
+grammarLexerGenerator.addRule("colon", "$:", GrammarTokenType.COLON);
+grammarLexerGenerator.addRule("semicolon", "$;", GrammarTokenType.SEMICOLON);
+grammarLexerGenerator.addRule("production_name", "$< ${identifier} $>", GrammarTokenType.PRODUCTION_NAME);
+grammarLexerGenerator.addRule("token_name", "$[ ${identifier} $]", GrammarTokenType.TOKEN_NAME);
+
+interface LexerInterface {
+  peekNextToken(): GrammarToken;
+  getNextToken(): GrammarToken;
+  hasNextToken(): boolean;
+}
+
+export const tryBuildProductions = (lexer: LexerInterface | string): Result<Production[]> => {
+  if (typeof lexer === "string") lexer = grammarLexerGenerator.generate(lexer, () => ({}));
+
+  const productions: Production[] = [];
+
+  const expect = (type: GrammarTokenType) => {
+    const token = lexer.peekNextToken();
+    if (token.type !== type) throw new Error(`Expected ${type}, got ${token.type}`);
+    lexer.getNextToken();
+  };
+
+  const buildProduction = (): Result<Production> => {
+    const productionLHS = lexer.getNextToken();
+    expect(GrammarTokenType.COLON);
+
+    const production: Production = { lhs: productionLHS, rhs: [] };
+
+    while (lexer.peekNextToken().type != GrammarTokenType.SEMICOLON) {
+      const productionRHS = lexer.getNextToken();
+
+      if (productionRHS.type == GrammarTokenType.PRODUCTION_NAME)
+        production.rhs.push({ type: "variable", token: productionRHS });
+      else if (productionRHS.type == GrammarTokenType.TOKEN_NAME)
+        production.rhs.push({ type: "terminal", token: productionRHS });
+      else
+        return {
+          success: false,
+          reason: `Unexpected token type: ${GrammarTokenType[productionRHS.type]}`,
+          token: productionRHS,
+        };
+    }
+
+    expect(GrammarTokenType.SEMICOLON);
+    return { success: true, value: production };
+  };
+
+  while (lexer.hasNextToken()) {
+    const result = buildProduction();
+    if (result.success === false) return result;
+    productions.push(result.value);
+  }
+
+  return { success: true, value: productions };
+};
+
+export const buildProductions = (lexer: LexerInterface | string): Production[] => {
+  const result = tryBuildProductions(lexer);
+  if (result.success === false)
+    throw new Error(
+      `Encountered error "${result.reason}" while parsing grammar at ${result.token.line}:${result.token.column}`
+    );
+  return result.value;
+};

package/src/index.ts

@@ -0,0 +1,12 @@
+export { GeneratorResult, generateStates } from "./generator";
+export { Production, buildProductions, tryBuildProductions } from "./grammarParser";
+export { Result } from "./utils/Result";
+export {
+  ParserRecoveryFunction,
+  Sparse,
+  LR1ParserGraveError,
+  LR1StackSymbol,
+  ParserResult,
+  ParserError,
+} from "./parser";
+export { buildStates } from "./tableParser";