@scinorandex/sparse 0.0.1 → 0.0.3

package/src/parser.ts

@@ -1,16 +1,16 @@
 import { Slex, Token } from "@scinorandex/slex";
 import { generateStates } from "./generator";
-import { Production } from "./grammarParser";
 import { Stack } from "./utils/Stack";
 import { Result } from "./utils/Result";
+import { Production } from "./meta/common";
 
 export type TableAction = { type: "shift" | "reduce" | "goto"; value: number };
 
 export class TableState {
   public readonly actions: Map<string, TableAction>;
 
-  constructor() {
-    this.actions = new Map();
+  constructor(actions = new Map<string, TableAction>()) {
+    this.actions = actions;
   }
 
   public getTerminalAction(terminal: string): TableAction | undefined {
@@ -20,8 +20,21 @@ export class TableState {
   public getVariableAction(variable: string): TableAction | undefined {
     return this.actions.get(variable);
   }
+
+  toJSObject() {
+    return Object.fromEntries(this.actions);
+  }
+
+  static fromJSObject(json: ReturnType<TableState["toJSObject"]>) {
+    return new TableState(new Map(Object.entries(json)));
+  }
 }
 
+type ReducerType<TokenType, Metadata, Node> = (
+  newInput: { bag: any; name: string | null },
+  oldInput: { input: LR1StackSymbol<TokenType, Metadata, Node>[]; index: number },
+) => Node;
+
 export type LR1StackSymbol<TokenType, Metadata, Node> =
   | { type: "token"; token: Token<TokenType, Metadata> }
   | { type: "node"; node: Node };
@@ -32,7 +45,7 @@ export class Sparse<TokenType, Metadata, Node> {
       productions: Production[];
       states: TableState[];
       toStringifiedTokenType: (tokenType: TokenType) => string;
-    }
+    },
   ) {}
 
   public static tryFromProductions<TokenType, Metadata, Node>(options: {
@@ -65,9 +78,9 @@ export class Sparse<TokenType, Metadata, Node> {
   public generate(
     lexer: ReturnType<Slex<TokenType, Metadata>["generate"]>,
     options: {
-      reducer: (input: LR1StackSymbol<TokenType, Metadata, Node>[], productionIndex: number) => Node;
+      reducer: ReducerType<TokenType, Metadata, Node>;
       recover?: ParserRecoveryFunction<TokenType, Metadata, Node>;
-    }
+    },
   ) {
     return new LR1Parser<TokenType, Metadata, Node>(this.options, options.reducer, options.recover ?? null, lexer);
   }
@@ -104,9 +117,9 @@ class LR1Parser<TokenType, Metadata, Node> {
       states: TableState[];
       toStringifiedTokenType: (tokenType: TokenType) => string;
     },
-    public readonly reducer: (input: LR1StackSymbol<TokenType, Metadata, Node>[], productionIndex: number) => Node,
+    public readonly reducer: ReducerType<TokenType, Metadata, Node>,
     public readonly recover: ParserRecoveryFunction<TokenType, Metadata, Node> | null,
-    public readonly lexer: ReturnType<Slex<TokenType, Metadata>["generate"]>
+    public readonly lexer: ReturnType<Slex<TokenType, Metadata>["generate"]>,
   ) {}
 
   public parse(): ParserResult<TokenType, Metadata, Node> {
@@ -121,9 +134,9 @@ class LR1Parser<TokenType, Metadata, Node> {
         if (this.recover === null)
           throw new LR1ParserGraveError(
             `Invalid syntax. Expected ${[...states[currentState].actions.keys()].join(
-              ","
+              ",",
             )} but got ${toStringifiedTokenType(token.type)}`,
-            token
+            token,
           );
 
         const recoveryResult = this.recover({
@@ -166,29 +179,46 @@ class LR1Parser<TokenType, Metadata, Node> {
         }
 
         // try to perform the reduction
+        const productionIndex = production.originalProductionIndex;
+
         try {
-          this.symbolsStack.push({ type: "node", node: this.reducer(popped, fixedAction.value) });
+          // prepare the object that you're going to send to the reducer function
+          const bag = {} as { [key: string]: Node | Token<TokenType, Metadata> };
+
+          for (let i = 0; i < production.rhs.length; i++) {
+            const rhsItem = production.rhs[i];
+            const poppedItem = popped[i];
+            if (rhsItem.name != null)
+              bag[rhsItem.name] = poppedItem.type === "token" ? poppedItem.token : poppedItem.node;
+          }
+
+          const newInput = { bag, name: production.name };
+          const oldInput = { input: popped, index: productionIndex };
+
+          const node = this.reducer(newInput, oldInput);
+          this.symbolsStack.push({ type: "node", node });
         } catch (err) {
           const input = JSON.stringify(popped, null, 2);
+          console.log(err);
           throw new LR1ParserGraveError(
-            `Error while performing reduction for production: ${fixedAction.value}. Reduction input: ${input}`,
-            token
+            `Error while performing reduction for production: ${productionIndex}. 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);
+        const gotoAction = states[topNode].getVariableAction(production.identifier);
 
         if (gotoAction == undefined)
           throw new LR1ParserGraveError(
-            `No GOTO action for for state: ${topNode} and production: ${production.lhs}. Actions: Reduce by production ${fixedAction.value}`,
-            token
+            `No GOTO action for for state: ${topNode} and production: ${production.identifier}. Actions: Reduce by production ${productionIndex}`,
+            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
+            `Expected GOTO action for state: ${topNode} and production: ${production.identifier}. Actions: Reduce by production ${productionIndex}. Received: ${gotoAction.type}`,
+            token,
           );
 
         this.statesStack.push(gotoAction.value);
@@ -201,7 +231,11 @@ class LR1Parser<TokenType, Metadata, Node> {
 }
 
 export class LR1ParserGraveError<TokenType, Metadata> extends Error {
-  constructor(public readonly reason: string, public readonly currentToken: Token<TokenType, Metadata>, err?: Error) {
+  constructor(
+    public readonly reason: string,
+    public readonly currentToken: Token<TokenType, Metadata>,
+    err?: Error,
+  ) {
     super(reason);
   }
 }

package/src/{tableParser.ts → table/handwritten.ts}

@@ -1,5 +1,5 @@
 import { Slex } from "@scinorandex/slex";
-import { TableAction, TableState } from "./parser";
+import { TableAction, TableState } from "../parser";
 
 type TableTokenMetadata = {};
 export enum TableTokenType {
@@ -20,11 +20,11 @@ export const tableLexerGenerator = new Slex<TableTokenType, TableTokenMetadata>(
 
 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"
+  "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"
+  "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");
@@ -58,8 +58,8 @@ export const buildStates = (grammar: string) =>
         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)) };
+            ? { 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();

package/src/table/selfhosted.ts

@@ -0,0 +1,67 @@
+import { GrammarToken } from "../meta/common";
+import { BaseNode, getSelfHostedParserGenerator, grammarLexerGenerator, ListNode } from "../meta/selfhosted";
+import { TableAction, TableState } from "../parser";
+import { selfhosted } from "./states";
+
+class StateNode extends BaseNode {
+  constructor(public readonly items: ListNode<ItemNode>) {
+    super();
+  }
+
+  toTableState(): TableState {
+    const state = new TableState();
+    for (const item of this.items.getItems()) {
+      const key = item.type === "terminal" ? `[${item.name.lexeme}]` : `<${item.name.lexeme}>`;
+      state.actions.set(key, item.action);
+    }
+    return state;
+  }
+}
+
+class ItemNode extends BaseNode {
+  constructor(
+    public readonly type: "terminal" | "variable",
+    public readonly name: GrammarToken,
+    public readonly action: TableAction,
+  ) {
+    super();
+  }
+}
+
+type Reducer = (bag: any) => BaseNode;
+const reducers: { [key: string]: Reducer } = {
+  program: (bag: { states: ListNode<StateNode> }) => bag.states,
+  states: (bag: { state: ListNode<ItemNode>; rest?: ListNode<StateNode> }) => {
+    if (bag.rest == null) return new ListNode<StateNode>([new StateNode(bag.state)]);
+    else return bag.rest.add(new StateNode(bag.state));
+  },
+
+  items: (bag: { item: ItemNode; rest?: ListNode<ItemNode> }) => {
+    if (bag.rest == null) return new ListNode<ItemNode>([bag.item]);
+    else return bag.rest.add(bag.item);
+  },
+
+  terminal: (bag: { name: GrammarToken; action: GrammarToken }) => {
+    const action: TableAction = {
+      type: bag.action.lexeme.startsWith("s") ? "shift" : "reduce",
+      value: parseInt(bag.action.lexeme.substring(1)),
+    };
+    return new ItemNode("terminal", bag.name, action);
+  },
+
+  variable: (bag: { name: GrammarToken; state: GrammarToken }) => {
+    const action: TableAction = { type: "goto", value: parseInt(bag.state.lexeme) };
+    return new ItemNode("variable", bag.name, action);
+  },
+};
+
+export const buildStates = (grammar: string): TableState[] => {
+  const lexer = grammarLexerGenerator.generate(grammar, () => ({}));
+  const parserGenerator = getSelfHostedParserGenerator(selfhosted as any);
+  const parser = parserGenerator.generate(lexer, {
+    reducer: ({ bag, name }) => reducers[name ?? ""](bag),
+  });
+
+  const parsingResult = (parser.parse().result as ListNode<StateNode>).getItemsReversed();
+  return parsingResult.map((state) => state.toTableState());
+};