@scinorandex/sparse 0.0.1

package/src/parser.ts

@@ -0,0 +1,207 @@
+import { Slex, Token } from "@scinorandex/slex";
+import { generateStates } from "./generator";
+import { Production } from "./grammarParser";
+import { Stack } from "./utils/Stack";
+import { Result } from "./utils/Result";
+
+export type TableAction = { type: "shift" | "reduce" | "goto"; value: number };
+
+export class TableState {
+  public readonly actions: Map<string, TableAction>;
+
+  constructor() {
+    this.actions = new Map();
+  }
+
+  public getTerminalAction(terminal: string): TableAction | undefined {
+    return this.actions.get(`[${terminal}]`);
+  }
+
+  public getVariableAction(variable: string): TableAction | undefined {
+    return this.actions.get(variable);
+  }
+}
+
+export type LR1StackSymbol<TokenType, Metadata, Node> =
+  | { type: "token"; token: Token<TokenType, Metadata> }
+  | { type: "node"; node: Node };
+
+export class Sparse<TokenType, Metadata, Node> {
+  public constructor(
+    public readonly options: {
+      productions: Production[];
+      states: TableState[];
+      toStringifiedTokenType: (tokenType: TokenType) => string;
+    }
+  ) {}
+
+  public static tryFromProductions<TokenType, Metadata, Node>(options: {
+    productions: Production[];
+    toStringifiedTokenType: (tokenType: TokenType) => string;
+  }): Result<Sparse<TokenType, Metadata, Node>> {
+    const statesResult = generateStates(options.productions);
+    if (statesResult.success === false) return statesResult;
+    const states = statesResult.value;
+
+    const sparse = new Sparse<TokenType, Metadata, Node>({
+      productions: options.productions,
+      states: states.toStates(),
+      toStringifiedTokenType: options.toStringifiedTokenType,
+    });
+
+    return { success: true, value: sparse };
+  }
+
+  public static fromProductions<TokenType, Metadata, Node>(options: {
+    productions: Production[];
+    toStringifiedTokenType: (tokenType: TokenType) => string;
+  }) {
+    const result = Sparse.tryFromProductions<TokenType, Metadata, Node>(options);
+    if (result.success === false)
+      throw new Error(`Encountered error "${result.reason}" at ${result.token.line}:${result.token.column}`);
+    return result.value;
+  }
+
+  public generate(
+    lexer: ReturnType<Slex<TokenType, Metadata>["generate"]>,
+    options: {
+      reducer: (input: LR1StackSymbol<TokenType, Metadata, Node>[], productionIndex: number) => Node;
+      recover?: ParserRecoveryFunction<TokenType, Metadata, Node>;
+    }
+  ) {
+    return new LR1Parser<TokenType, Metadata, Node>(this.options, options.reducer, options.recover ?? null, lexer);
+  }
+}
+
+export type ParserRecoveryFunction<TokenType, Metadata, Node> = (options: {
+  lexer: ReturnType<Slex<TokenType, Metadata>["generate"]>;
+  statesStack: Stack<number>;
+  symbolsStack: Stack<LR1StackSymbol<TokenType, Metadata, Node>>;
+  isSafe: () => boolean;
+  addError: (reason: string) => void;
+  crash: (reason: string) => { success: false; reason: string };
+  finish: (options?: { newToken: Token<TokenType, Metadata> }) => {
+    success: true;
+    token?: Token<TokenType, Metadata>;
+  };
+  states: TableState[];
+}) => { success: true; token?: Token<TokenType, Metadata> } | { success: false; reason: string };
+
+export type ParserError<TokenType, Metadata> = { token: Token<TokenType, Metadata>; message: string };
+export type ParserResult<TokenType, Metadata, Node> = {
+  result: Node | null;
+  errors: ParserError<TokenType, Metadata>[];
+};
+
+class LR1Parser<TokenType, Metadata, Node> {
+  statesStack: Stack<number> = new Stack([0]);
+  symbolsStack: Stack<LR1StackSymbol<TokenType, Metadata, Node>> = new Stack();
+  exceptions: ParserError<TokenType, Metadata>[] = [];
+
+  public constructor(
+    public readonly options: {
+      productions: Production[];
+      states: TableState[];
+      toStringifiedTokenType: (tokenType: TokenType) => string;
+    },
+    public readonly reducer: (input: LR1StackSymbol<TokenType, Metadata, Node>[], productionIndex: number) => Node,
+    public readonly recover: ParserRecoveryFunction<TokenType, Metadata, Node> | null,
+    public readonly lexer: ReturnType<Slex<TokenType, Metadata>["generate"]>
+  ) {}
+
+  public parse(): ParserResult<TokenType, Metadata, Node> {
+    const { productions, states, toStringifiedTokenType } = this.options;
+
+    while (true) {
+      let currentState = this.statesStack.peek();
+      let token = this.lexer.peekNextToken();
+      let action = states[currentState].getTerminalAction(toStringifiedTokenType(token.type));
+
+      if (action == null) {
+        if (this.recover === null)
+          throw new LR1ParserGraveError(
+            `Invalid syntax. Expected ${[...states[currentState].actions.keys()].join(
+              ","
+            )} but got ${toStringifiedTokenType(token.type)}`,
+            token
+          );
+
+        const recoveryResult = this.recover({
+          lexer: this.lexer,
+          states,
+          statesStack: this.statesStack,
+          symbolsStack: this.symbolsStack,
+          addError: (reason: string) => this.exceptions.push({ message: reason, token: this.lexer.peekNextToken() }),
+          crash: (reason: string) => ({ success: false, reason }),
+          finish: (options?: { newToken: Token<TokenType, Metadata> }) => ({ success: true, token: options?.newToken }),
+          isSafe: () =>
+            states[this.statesStack.peek()].actions.has(`[${toStringifiedTokenType(this.lexer.peekNextToken().type)}]`),
+        });
+
+        if (recoveryResult.success === false) throw new LR1ParserGraveError(recoveryResult.reason, token);
+
+        token = recoveryResult.token ?? this.lexer.peekNextToken();
+        currentState = this.statesStack.peek();
+        action = states[currentState].getTerminalAction(toStringifiedTokenType(token.type));
+      }
+
+      const fixedAction = action as TableAction;
+      if (fixedAction.type === "shift") {
+        // add current token to the stack and push the next state
+        token = this.lexer.getNextToken();
+        this.statesStack.push(fixedAction.value);
+        this.symbolsStack.push({ type: "token", token: token });
+      }
+
+      // handle reductions
+      else if (fixedAction.type === "reduce") {
+        if (fixedAction.value === 0) break;
+        const production = productions[fixedAction.value];
+
+        // pop the stack and reduce by this production
+        const popped: LR1StackSymbol<TokenType, Metadata, Node>[] = [];
+        for (let i = 0; i < production.rhs.length; i++) {
+          popped.unshift(this.symbolsStack.pop());
+          this.statesStack.pop();
+        }
+
+        // try to perform the reduction
+        try {
+          this.symbolsStack.push({ type: "node", node: this.reducer(popped, fixedAction.value) });
+        } catch (err) {
+          const input = JSON.stringify(popped, null, 2);
+          throw new LR1ParserGraveError(
+            `Error while performing reduction for production: ${fixedAction.value}. Reduction input: ${input}`,
+            token
+          );
+        }
+
+        // get the top node and figure out what state to add to state stack
+        const topNode = this.statesStack.peek();
+        const gotoAction = states[topNode].getVariableAction(production.lhs.lexeme);
+
+        if (gotoAction == undefined)
+          throw new LR1ParserGraveError(
+            `No GOTO action for for state: ${topNode} and production: ${production.lhs}. Actions: Reduce by production ${fixedAction.value}`,
+            token
+          );
+        else if (gotoAction.type !== "goto")
+          throw new LR1ParserGraveError(
+            `Expected GOTO action for state: ${topNode} and production: ${production.lhs}. Actions: Reduce by production ${fixedAction.value}. Received: ${gotoAction.type}`,
+            token
+          );
+
+        this.statesStack.push(gotoAction.value);
+      }
+    }
+
+    const top = this.symbolsStack.peek();
+    return { result: top.type === "node" ? top.node : null, errors: this.exceptions };
+  }
+}
+
+export class LR1ParserGraveError<TokenType, Metadata> extends Error {
+  constructor(public readonly reason: string, public readonly currentToken: Token<TokenType, Metadata>, err?: Error) {
+    super(reason);
+  }
+}

package/src/tableParser.ts

@@ -0,0 +1,69 @@
+import { Slex } from "@scinorandex/slex";
+import { TableAction, TableState } from "./parser";
+
+type TableTokenMetadata = {};
+export enum TableTokenType {
+  PRODUCTION_NAME,
+  TOKEN_NAME,
+  COMMA,
+  EQUALS,
+  SHIFT_ACTION,
+  REDUCE_ACTION,
+  GOTO_ACTION,
+  EOF,
+}
+
+export const tableLexerGenerator = new Slex<TableTokenType, TableTokenMetadata>({
+  EOF_TYPE: TableTokenType.EOF,
+  isHigherPrecedence: () => false,
+});
+
+tableLexerGenerator.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"
+);
+tableLexerGenerator.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"
+);
+tableLexerGenerator.addRule("letter", "${lowercase} | ${uppercase}");
+tableLexerGenerator.addRule("digit", "0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9");
+tableLexerGenerator.addRule("alphanumeric", "${letter} | ${digit}");
+tableLexerGenerator.addRule("identifier", "(${letter} | ${digit} | $_)*");
+tableLexerGenerator.addRule("comma", "$,", TableTokenType.COMMA);
+tableLexerGenerator.addRule("equals", "$=", TableTokenType.EQUALS);
+tableLexerGenerator.addRule("production_name", "$< ${identifier} $>", TableTokenType.PRODUCTION_NAME);
+tableLexerGenerator.addRule("token_name", "$[ ${identifier} $]", TableTokenType.TOKEN_NAME);
+tableLexerGenerator.addRule("shift_action", "s(${digit})*", TableTokenType.SHIFT_ACTION);
+tableLexerGenerator.addRule("reduce_action", "r(${digit})*", TableTokenType.REDUCE_ACTION);
+tableLexerGenerator.addRule("goto_action", "${digit}(${digit})*", TableTokenType.GOTO_ACTION);
+
+export const buildStates = (grammar: string) =>
+  grammar.split("\n").map((line) => {
+    const lexer = tableLexerGenerator.generate(line, () => ({}));
+    const state = new TableState();
+
+    const expect = (type: TableTokenType) => {
+      const token = lexer.peekNextToken();
+      if (token.type !== type) throw new Error(`Expected ${TableTokenType[type]}, got ${TableTokenType[token.type]}`);
+      lexer.getNextToken();
+    };
+
+    while (lexer.hasNextToken()) {
+      const token = lexer.getNextToken();
+      expect(TableTokenType.EQUALS);
+      const value = lexer.getNextToken();
+
+      const setting: TableAction =
+        token.type === TableTokenType.PRODUCTION_NAME
+          ? { type: "goto", value: parseInt(value.lexeme) }
+          : value.type === TableTokenType.REDUCE_ACTION
+          ? { type: "reduce", value: parseInt(value.lexeme.substring(1)) }
+          : { type: "shift", value: parseInt(value.lexeme.substring(1)) };
+
+      state.actions.set(token.lexeme, setting);
+      if (lexer.peekNextToken().type == TableTokenType.COMMA) lexer.getNextToken();
+    }
+
+    return state;
+  });

package/src/utils/Result.ts

@@ -0,0 +1,3 @@
+import { GrammarToken } from "src/grammarParser";
+
+export type Result<T> = { success: true; value: T } | { success: false; reason: string; token: GrammarToken };

package/src/utils/Stack.ts

@@ -0,0 +1,23 @@
+export class Stack<T> {
+  private items: T[] = [];
+
+  public push(item: T) {
+    this.items.push(item);
+  }
+
+  public pop(): T {
+    const item = this.items.pop();
+    if (item === undefined) throw new Error("Stack is empty");
+    return item;
+  }
+
+  public peek(): T {
+    const ret = this.items[this.items.length - 1];
+    if (ret === undefined) throw new Error("Stack is empty");
+    return ret;
+  }
+
+  constructor(items: T[] = []) {
+    this.items = items;
+  }
+}

package/src/utils/errorWindowBuilder.ts

@@ -0,0 +1,23 @@
+import type { GrammarToken } from "src/grammarParser";
+
+export const buildErrorWindow = (file: string, token: GrammarToken) => {
+  const lines = file.split("\n");
+
+  const length = Math.max(`${token.line}`.length, `${token.column}`.length);
+  let second = "",
+    third = "";
+
+  for (let i = 0; i < token.column + length + 3; i++) {
+    second += " ";
+    third += "-";
+  }
+  second += "|";
+  third += "┘";
+
+  let window = `${token.line.toString().padStart(length)} | ${
+    lines.length <= token.line - 1 ? "" : lines[token.line - 1]
+  }\n${second}\n${third}\n`;
+
+  if (token.line < lines.length) window += `${(token.line + 1).toString().padStart(length)} | ${lines[token.line]}\n`;
+  return window;
+};

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "commonjs",
+    "lib": ["dom", "es6", "es2021", "esnext.asynciterable"],
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "moduleResolution": "node",
+    "removeComments": true,
+    "noImplicitAny": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "declaration": true
+  },
+  "exclude": ["node_modules"],
+  "include": ["./src/**/*.ts"]
+}