grammar-well 1.1.2 → 1.1.3

package/build/utility/lr.js

@@ -1,130 +1,130 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LRStack = exports.CanonicalCollection = void 0;
-const parser_1 = require("../parser/parser");
-const general_1 = require("./general");
-class CanonicalCollection {
-    grammar;
-    rules = new general_1.Collection();
-    states = Object.create(null);
-    symbols = new general_1.SymbolCollection();
-    constructor(grammar) {
-        this.grammar = grammar;
-        const augmented = { name: Symbol(), symbols: [grammar.start] };
-        grammar.rules[augmented.name] = [augmented];
-        this.addState([{ rule: augmented, dot: 0 }]);
-    }
-    addState(seed) {
-        const id = this.encodeStateItems(seed);
-        if (id in this.states)
-            return this.states[id];
-        const state = new State(this, seed);
-        this.states[id] = state;
-        for (const q in state.queue) {
-            this.addState(state.queue[q]);
-        }
-        state.queue = {};
-    }
-    encodeRule(rule, dot) {
-        return this.rules.encode(rule) + '.' + dot;
-    }
-    encodeStateItems(seed) {
-        return Array.from(new Set(seed)).map(v => this.encodeRule(v.rule, v.dot)).sort().join();
-    }
-}
-exports.CanonicalCollection = CanonicalCollection;
-class State {
-    collection;
-    isFinal = false;
-    outputs = {
-        goto: {},
-        action: {}
-    };
-    queue = {};
-    actions = new Map();
-    goto = new Map();
-    reduce;
-    constructor(collection, items) {
-        this.collection = collection;
-        const visited = new Set();
-        for (const item of items) {
-            this.closure(item.rule, item.dot, visited);
-        }
-        if (this.isFinal) {
-            if (items.length == 1 && visited.size < 1) {
-                this.reduce = items[0].rule;
-            }
-            else {
-                throw 'Conflict Detected';
-            }
-        }
-        for (const k in this.outputs.goto) {
-            const seed = this.outputs.goto[k];
-            const stateId = this.collection.encodeStateItems(seed);
-            this.queue[stateId] = seed;
-            this.goto.set(this.collection.symbols.decode(k), stateId);
-        }
-        for (const k in this.outputs.action) {
-            const seed = this.outputs.action[k];
-            const stateId = this.collection.encodeStateItems(seed);
-            this.queue[stateId] = seed;
-            this.actions.set(this.collection.symbols.decode(k), stateId);
-        }
-    }
-    closure(rule, dot, visited) {
-        const isFinal = rule.symbols.length == dot;
-        this.isFinal = isFinal || this.isFinal;
-        const { [dot]: symbol } = rule.symbols;
-        if (isFinal || visited.has(symbol))
-            return;
-        visited.add(symbol);
-        const stateItem = { rule, dot: dot + 1 };
-        if (parser_1.ParserUtility.SymbolIsTerminal(symbol)) {
-            const id = this.collection.symbols.encode(symbol);
-            this.outputs.action[id] = this.outputs.action[id] || [];
-            this.outputs.action[id].push(stateItem);
-        }
-        else {
-            const id = this.collection.symbols.encode(symbol);
-            this.outputs.goto[id] = this.outputs.goto[id] || [];
-            this.outputs.goto[id].push(stateItem);
-            for (const rule of this.collection.grammar.rules[symbol]) {
-                this.closure(rule, 0, visited);
-            }
-        }
-    }
-}
-class LRStack {
-    stack = [];
-    get current() {
-        return this.stack[this.stack.length - 1];
-    }
-    get previous() {
-        return this.stack[this.stack.length - 2];
-    }
-    shift(state) {
-        this.current.state = state;
-    }
-    reduce(rule) {
-        const n = new LRStackItem();
-        const l = rule.symbols.length;
-        n.children = this.stack.splice(l * -1, l);
-        n.children.forEach(v => delete v.state);
-        n.rule = rule;
-        n.symbol = rule.name;
-        this.stack.push(n);
-    }
-    add(symbol) {
-        this.stack.push(new LRStackItem());
-        this.current.symbol = symbol;
-    }
-}
-exports.LRStack = LRStack;
-class LRStackItem {
-    children = [];
-    state;
-    symbol;
-    rule;
-    value;
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRStack = exports.CanonicalCollection = void 0;
+const parser_1 = require("../parser/parser");
+const general_1 = require("./general");
+class CanonicalCollection {
+    grammar;
+    rules = new general_1.Collection();
+    states = Object.create(null);
+    symbols = new general_1.SymbolCollection();
+    constructor(grammar) {
+        this.grammar = grammar;
+        const augmented = { name: Symbol(), symbols: [grammar.start] };
+        grammar.rules[augmented.name] = [augmented];
+        this.addState([{ rule: augmented, dot: 0 }]);
+    }
+    addState(seed) {
+        const id = this.encodeStateItems(seed);
+        if (id in this.states)
+            return this.states[id];
+        const state = new State(this, seed);
+        this.states[id] = state;
+        for (const q in state.queue) {
+            this.addState(state.queue[q]);
+        }
+        state.queue = {};
+    }
+    encodeRule(rule, dot) {
+        return this.rules.encode(rule) + '.' + dot;
+    }
+    encodeStateItems(seed) {
+        return Array.from(new Set(seed)).map(v => this.encodeRule(v.rule, v.dot)).sort().join();
+    }
+}
+exports.CanonicalCollection = CanonicalCollection;
+class State {
+    collection;
+    isFinal = false;
+    outputs = {
+        goto: {},
+        action: {}
+    };
+    queue = {};
+    actions = new Map();
+    goto = new Map();
+    reduce;
+    constructor(collection, items) {
+        this.collection = collection;
+        const visited = new Set();
+        for (const item of items) {
+            this.closure(item.rule, item.dot, visited);
+        }
+        if (this.isFinal) {
+            if (items.length == 1 && visited.size < 1) {
+                this.reduce = items[0].rule;
+            }
+            else {
+                throw 'Conflict Detected';
+            }
+        }
+        for (const k in this.outputs.goto) {
+            const seed = this.outputs.goto[k];
+            const stateId = this.collection.encodeStateItems(seed);
+            this.queue[stateId] = seed;
+            this.goto.set(this.collection.symbols.decode(k), stateId);
+        }
+        for (const k in this.outputs.action) {
+            const seed = this.outputs.action[k];
+            const stateId = this.collection.encodeStateItems(seed);
+            this.queue[stateId] = seed;
+            this.actions.set(this.collection.symbols.decode(k), stateId);
+        }
+    }
+    closure(rule, dot, visited) {
+        const isFinal = rule.symbols.length == dot;
+        this.isFinal = isFinal || this.isFinal;
+        const { [dot]: symbol } = rule.symbols;
+        if (isFinal || visited.has(symbol))
+            return;
+        visited.add(symbol);
+        const stateItem = { rule, dot: dot + 1 };
+        if (parser_1.ParserUtility.SymbolIsTerminal(symbol)) {
+            const id = this.collection.symbols.encode(symbol);
+            this.outputs.action[id] = this.outputs.action[id] || [];
+            this.outputs.action[id].push(stateItem);
+        }
+        else {
+            const id = this.collection.symbols.encode(symbol);
+            this.outputs.goto[id] = this.outputs.goto[id] || [];
+            this.outputs.goto[id].push(stateItem);
+            for (const rule of this.collection.grammar.rules[symbol]) {
+                this.closure(rule, 0, visited);
+            }
+        }
+    }
+}
+class LRStack {
+    stack = [];
+    get current() {
+        return this.stack[this.stack.length - 1];
+    }
+    get previous() {
+        return this.stack[this.stack.length - 2];
+    }
+    shift(state) {
+        this.current.state = state;
+    }
+    reduce(rule) {
+        const n = new LRStackItem();
+        const l = rule.symbols.length;
+        n.children = this.stack.splice(l * -1, l);
+        n.children.forEach(v => delete v.state);
+        n.rule = rule;
+        n.symbol = rule.name;
+        this.stack.push(n);
+    }
+    add(symbol) {
+        this.stack.push(new LRStackItem());
+        this.current.symbol = symbol;
+    }
+}
+exports.LRStack = LRStack;
+class LRStackItem {
+    children = [];
+    state;
+    symbol;
+    rule;
+    value;
+}
 //# sourceMappingURL=lr.js.map

package/build/utility/text-format.d.ts

@@ -1,11 +1,11 @@
-import { TokenBuffer } from "../lexers/token-buffer";
-import { GrammarRule, GrammarRuleSymbol, LexerToken } from "../typings";
-export declare class TextFormatter {
-    static UnexpectedToken(queue: TokenBuffer, expected: (GrammarRule & {
-        index?: number;
-    })[]): string;
-    static LexerTokenShort(token: LexerToken): string;
-    static LexerTokenError(lexer: TokenBuffer): string;
-    static GrammarRuleSymbol(symbol: GrammarRuleSymbol, short?: boolean, error?: boolean): string;
-    static GrammarRule(rule: GrammarRule, withCursorAt?: number): string;
-}
+import { TokenBuffer } from "../lexers/token-buffer";
+import { GrammarRule, GrammarRuleSymbol, LexerToken } from "../typings";
+export declare class TextFormatter {
+    static UnexpectedToken(queue: TokenBuffer, expected: (GrammarRule & {
+        index?: number;
+    })[]): string;
+    static LexerTokenShort(token: LexerToken): string;
+    static LexerTokenError(lexer: TokenBuffer): string;
+    static GrammarRuleSymbol(symbol: GrammarRuleSymbol, short?: boolean, error?: boolean): string;
+    static GrammarRule(rule: GrammarRule, withCursorAt?: number): string;
+}

package/build/utility/text-format.js

@@ -1,84 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextFormatter = void 0;
-class TextFormatter {
-    static UnexpectedToken(queue, expected) {
-        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) {
-        if (token.type)
-            return `[${token.type}] ${JSON.stringify(token.value)}`;
-        return `${JSON.stringify(token.value)}`;
-    }
-    static LexerTokenError(lexer) {
-        let i = 0;
-        let token;
-        let string = lexer.peek(i).value;
-        let lines = 0;
-        const { line, column, offset } = lexer;
-        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, short, error) {
-        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, withCursorAt) {
-        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;
-    }
-}
-exports.TextFormatter = TextFormatter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextFormatter = void 0;
+class TextFormatter {
+    static UnexpectedToken(queue, expected) {
+        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) {
+        if (token.type)
+            return `[${token.type}] ${JSON.stringify(token.value)}`;
+        return `${JSON.stringify(token.value)}`;
+    }
+    static LexerTokenError(lexer) {
+        let i = 0;
+        let token;
+        let string = lexer.peek(i).value;
+        let lines = 0;
+        const { line, column, offset } = lexer;
+        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, short, error) {
+        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, withCursorAt) {
+        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;
+    }
+}
+exports.TextFormatter = TextFormatter;
 //# sourceMappingURL=text-format.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grammar-well",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Cross-platform Parser written in TypeScript",
   "main": "build/index.js",
   "scripts": {

package/src/compiler/generator.ts

@@ -187,6 +187,7 @@ export class Generator {
                 type: JSON.stringify(rule.type),
                 tag: JSON.stringify(rule.tag),
                 pop: JSON.stringify(rule.pop),
+                highlight: JSON.stringify(rule.highlight),
                 set: JSON.stringify(rule.set),
                 inset: JSON.stringify(rule.inset),
                 goto: JSON.stringify(rule.goto),

package/src/compiler/outputs/typescript.ts

@@ -56,8 +56,9 @@ interface LexerStateMatchRule {
     when: string | RegExp
     type?: string;
     pop?: number | 'all';
+    highlight?: string;
     inset?: number;
-    goto?: string;
+    goto?: string; 
     set?: string;
 }
 

package/src/grammars/gwell.gwell

@@ -3,9 +3,9 @@ lexer: {{
 
     start ->
         - import: string, js, ws, comment, l_scolon, l_star
-        - when: /lexer(?![a-zA-Z\d_])/ tag: "T_WORD" goto: lexer
-        - when: /grammar(?![a-zA-Z\d_])/ tag: "T_WORD" goto: grammar
-        - when: /config(?![a-zA-Z\d_])/ tag: "T_WORD" goto: config
+        - when: /lexer(?![a-zA-Z\d_])/ tag: "T_WORD" goto: lexer highlight: "type"
+        - when: /grammar(?![a-zA-Z\d_])/ tag: "T_WORD" goto: grammar highlight: "type"
+        - when: /config(?![a-zA-Z\d_])/ tag: "T_WORD" goto: config highlight: "type"
         - import: kv
     config ->
         - import: ws, l_colon
@@ -57,21 +57,21 @@ lexer: {{
         - when: /\/\/[^\n]*/ tag: "T_JSBODY"
         - when: /\/\*.*\*\// tag: "T_JSBODY"
     string ->
-        - when: /"(?:[^"\\\r\n]|\\.)*"/ tag: "T_STRING"
+        - when: /"(?:[^"\\\r\n]|\\.)*"/ tag: "T_STRING" highlight: "string"
     string2 ->
-        - when: /'(?:[^'\\\r\n]|\\.)*'/ tag: "T_STRING"
+        - when: /'(?:[^'\\\r\n]|\\.)*'/ tag: "T_STRING" highlight: "string"
     string3 ->
-        - when: /`(?:[^`\\]|\\.)*`/ tag: "T_STRING"
+        - when: /`(?:[^`\\]|\\.)*`/ tag: "T_STRING" highlight: "string"
     regex ->
-        - when: /\/(?:[^\/\\\r\n]|\\.)+\// tag: "T_REGEX"
+        - when: /\/(?:[^\/\\\r\n]|\\.)+\// tag: "T_REGEX" highlight: "regexp"
     integer ->
-        - when: /\d+/ tag: "T_INTEGER"
+        - when: /\d+/ tag: "T_INTEGER" highlight: "number"
     word ->
         - when: /[a-zA-Z_][a-zA-Z_\d]*/ tag: "T_WORD"
     ws ->
         - when: /\s+/ tag: "T_WS"
     l_colon ->
-        - when: ":" tag: "L_COLON"
+        - when: ":" tag: "L_COLON" highlight: "keyword"
     l_scolon ->
         - when: ";" tag: "L_SCOLON"
     l_qmark ->
@@ -83,7 +83,7 @@ lexer: {{
     l_comma ->
         - when: "," tag: "L_COMMA"
     l_pipe ->
-        - when: "|" tag: "L_PIPE"
+        - when: "|" tag: "L_PIPE" highlight: "keyword"
     l_parenl ->
         - when: "(" tag: "L_PARENL"
     l_parenr ->
@@ -93,15 +93,15 @@ lexer: {{
     l_templater ->
         - when: "}}" tag: "L_TEMPLATER"
     l_arrow ->
-        - when: "->" tag: "L_ARROW"
+        - when: "->" tag: "L_ARROW" highlight: "keyword"
     l_dsign ->
         - when: "$" tag: "L_DSIGN"
     l_dash ->
         - when: "-" tag: "L_DASH"
     comment ->
-        - when: /\/\/[^\n]*/ tag: "T_COMMENT"
+        - when: /\/\/[^\n]*/ tag: "T_COMMENT" highlight: "comment"
     commentmulti ->
-        - when: /\/\*.*\*\// tag: "T_COMMENT"
+        - when: /\/\*.*\*\// tag: "T_COMMENT" highlight: "comment"
 
 }}
 
@@ -162,6 +162,7 @@ grammar: {{
         | K_POP : {{ { pop: 1 } }}
         | K_POP _ L_COLON _ T_INTEGER : {{ { pop: parseInt($4) } }}
         | K_POP _ L_COLON _ K_ALL : {{ { pop: "all" } }}
+        | K_HIGHLIGHT _ L_COLON _ T_STRING : {{ { highlight: $4 } }}
         | K_INSET : {{ { inset: 1 } }}
         | K_INSET _ L_COLON _ T_INTEGER : {{ { inset: parseInt($4) } }}
         | K_SET _ L_COLON _ T_WORD : {{ { set: $4 } }}
@@ -257,6 +258,7 @@ grammar: {{
     K_TYPE -> "type"
     K_WHEN -> "when"
     K_POP -> "pop"
+    K_HIGHLIGHT -> "highlight"
     K_INSET -> "inset"
     K_SET -> "set"
     K_GOTO -> "goto"