grammar-well 1.1.0

package/src/utility/text-format.ts

@@ -0,0 +1,84 @@
+import { TokenBuffer } from "../lexers/token-buffer";
+import { GrammarRule, GrammarRuleSymbol, LexerToken } from "../typings";
+
+export class TextFormatter {
+
+    static UnexpectedToken(queue: TokenBuffer, expected: (GrammarRule & { index?: number })[]) {
+        const token = queue.active;
+        const tokenDisplay = TextFormatter.LexerTokenShort(token);
+        const lines = [];
+        lines.push('Unexpected token: ' + tokenDisplay + ' at line: ' + token.line + ' column: ' + token.column);
+        if (expected.length === 0) {
+            lines.push('End of input was expected.');
+        } else {
+            lines.push('Instead, I was expecting to see one of the following:\n');
+            for (const ex of expected) {
+                const nextSymbol = ex.symbols[ex.index];
+                const symbolDisplay = TextFormatter.GrammarRuleSymbol(nextSymbol, false, true);
+                lines.push('A ' + symbolDisplay + ' based on:');
+                lines.push(TextFormatter.GrammarRule(ex, ex.index));
+            }
+            lines.push("");
+            return lines.join("\n");
+        }
+    }
+
+    static LexerTokenShort(token: LexerToken) {
+        if (token.type)
+            return `[${token.type}] ${JSON.stringify(token.value)}`;
+        return `${JSON.stringify(token.value)}`;
+    }
+
+    static LexerTokenError(lexer: TokenBuffer) {
+        let i = 0;
+        let token;
+        let string = lexer.peek(i).value;
+        let lines = 0;
+        const { line, column, offset } = lexer;
+
+        // eslint-disable-next-line no-cond-assign
+        while (token = lexer.peek(--i)) {
+            if (token.value == '\n') {
+                lines++;
+                string = `${(line + 2 - lines)} ${string}`;
+            }
+            string = token.value + string;
+            if (lines >= 2)
+                break;
+        }
+        string = `${line + 2 - (lines + 1)} ${string}`;
+
+        const n = string.lastIndexOf('\n');
+        const pad = (string.length - n);
+        string += '\n' + '^'.padStart(pad - 1);
+        if (typeof column != 'undefined' && typeof line != 'undefined')
+            return `Syntax error at line ${line + 1} col ${column + 1}:\n\n${string}\n`;
+        return `Syntax error at index ${offset}:\n\n${string}\n`;
+    }
+
+    static GrammarRuleSymbol(symbol: GrammarRuleSymbol, short?: boolean, error?: boolean) {
+        if (typeof symbol === 'string') {
+            return symbol;
+        } else if (typeof symbol === 'function') {
+            return short ? `<${symbol.toString()}>` : `token matching ${symbol.toString()}`;
+        } else {
+            if ("literal" in symbol) {
+                return JSON.stringify(symbol.literal);
+            } else if (symbol instanceof RegExp) {
+                return short ? symbol.toString() : `character matching ${symbol.toString()}`;
+            } else if ("token" in symbol) {
+                return short ? `%${symbol.token}` : `${symbol.token} token`;
+            } else if (error) {
+                return 'Unknown symbol type: ' + JSON.stringify(symbol);
+            }
+        }
+    }
+
+    static GrammarRule(rule: GrammarRule, withCursorAt?: number) {
+        let symbolSequence = rule.symbols.slice(0, withCursorAt).map(v => TextFormatter.GrammarRuleSymbol(v, true, true)).join(' ');
+        if (typeof withCursorAt !== "undefined") {
+            symbolSequence += " ● " + rule.symbols.slice(withCursorAt).map(v => TextFormatter.GrammarRuleSymbol(v, true, true)).join(' ');
+        }
+        return rule.name + " → " + symbolSequence;
+    }
+}

package/testing.ts

@@ -0,0 +1,18 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { AsyncRun, BuildTest } from './tests/system/testbed';
+(async () => {
+    const options: any = {};
+    const grammar = Read('./tests/samples/grammars/lr.gwell');
+    const input = "aabb";
+    options.algorithm = 'lr0';
+    const execution = await AsyncRun(() => BuildTest(grammar, input, options));
+    console.log(execution);
+
+})()
+
+function Read(path) {
+    return readFileSync(path, 'utf-8');
+}
+function Write(path, body) {
+    return writeFileSync(path, typeof body == 'string' ? body : JSON.stringify(body, null, 2), 'utf-8');
+}