grammar-well 1.3.2 → 2.0.0

package/src/compiler/outputs/typescript.ts

@@ -1,18 +0,0 @@
-import { Generator } from "../generator/generator";
-
-export function TypescriptFormat(generator: Generator, exportName: string) {
-    return `// Generated automatically by Grammar-Well, version ${generator.state.version} 
-// https://github.com/0x6563/grammar-well
-import type { LanguageDefinition } from 'grammar-well';
-
-${generator.serializeHead()}
-
-function ${exportName}(): LanguageDefinition {
-    ${generator.serializeBody()}
-    return ${generator.serializeLanguage(1)}
-}
-
-export default ${exportName};
-
-`;
-}

package/src/parser/parser.ts

@@ -1,77 +0,0 @@
-import { CharacterLexer } from "../lexers/character-lexer";
-import { StatefulLexer } from "../lexers/stateful-lexer";
-import { TokenBuffer } from "../lexers/token-buffer";
-import { GrammarRule, GrammarRuleSymbol, LanguageDefinition, LexerToken, ParserAlgorithm } from "../typings";
-import { CYK } from "./algorithms/cyk";
-import { Earley } from "./algorithms/earley";
-import { LRK } from "./algorithms/lrk/algorithm";
-
-const ParserRegistry: { [key: string]: ParserAlgorithm } = {
-    earley: Earley,
-    cyk: CYK,
-    lr0: LRK
-}
-
-export function Parse(language: LanguageDefinition, input: string, options?: ParserOptions) {
-    const i = new Parser(language, options);
-    return i.run(input);
-}
-
-export class Parser {
-
-    constructor(private language: LanguageDefinition, private options: ParserOptions = { algorithm: 'earley', parserOptions: {} }) { }
-
-    run(input: string): { results: any[] } {
-        const tokenQueue = this.getTokenQueue();
-        tokenQueue.feed(input);
-        if (typeof this.options.algorithm == 'function')
-            return this.options.algorithm({ ...this.language, tokens: tokenQueue, utility: ParserUtility }, this.options.parserOptions);
-        return ParserRegistry[this.options.algorithm]({ ...this.language, tokens: tokenQueue, utility: ParserUtility }, this.options.parserOptions);
-    }
-
-    private getTokenQueue() {
-        const { lexer } = this.language;
-        if (!lexer) {
-            return new TokenBuffer(new CharacterLexer());
-        } else if ("feed" in lexer && typeof lexer.feed == 'function') {
-            return new TokenBuffer(lexer);
-        } else if ('states' in lexer) {
-            return new TokenBuffer(new StatefulLexer(lexer));
-        }
-    }
-}
-
-
-export abstract class ParserUtility {
-
-    static SymbolMatchesToken(symbol: GrammarRuleSymbol, token: LexerToken) {
-        if (typeof symbol === 'string')
-            throw 'Attempted to match token against non-terminal';
-        if (typeof symbol == 'function')
-            return symbol(token);
-        if (!symbol)
-            return
-        if ("test" in symbol)
-            return symbol.test(token.value);
-        if ("token" in symbol)
-            return symbol.token === token.type || token.tag?.has(symbol.token);
-        if ("literal" in symbol)
-            return symbol.literal === token.value;
-    }
-
-    static SymbolIsTerminal(symbol: GrammarRuleSymbol) {
-        return typeof symbol != 'string';
-    }
-
-    static PostProcess(rule: GrammarRule, data: any, meta?: any) {
-        if (rule.postprocess) {
-            return rule.postprocess({ rule, data, meta });
-        }
-        return data;
-    }
-}
-
-interface ParserOptions {
-    algorithm: (keyof typeof ParserRegistry) | ParserAlgorithm,
-    parserOptions?: any;
-}

package/src/typings.ts

@@ -1,248 +0,0 @@
-import { TokenBuffer } from "./lexers/token-buffer";
-import { ParserUtility } from "./parser/parser";
-
-export interface Dictionary<T> {
-    [key: string]: T;
-}
-
-export interface CompileOptions {
-    version?: string;
-    noscript?: boolean;
-    basedir?: string;
-    resolver?: ImportResolverConstructor;
-    resolverInstance?: ImportResolver;
-    exportName?: string;
-    template?: TemplateFormat;
-    overrides?: Dictionary<string>;
-}
-
-export type TemplateFormat = '_default' | 'object' | 'json' | 'js' | 'javascript' | 'module' | 'esmodule' | 'esm' | 'ts' | 'typescript'
-
-export interface GrammarBuilderContext {
-    alreadyCompiled: Set<string>;
-    resolver: ImportResolver;
-    uuids: Dictionary<number>;
-}
-
-
-export interface ImportResolver {
-    path(path: string): string;
-    body(path: string): Promise<string>;
-}
-
-export interface ImportResolverConstructor {
-    new(basePath: string): ImportResolver;
-}
-
-export type PostProcessor = (payload: PostProcessorPayload) => any;
-
-interface PostProcessorPayload {
-    data: any[];
-    rule: GrammarRule;
-    meta: any;
-}
-
-export type JavascriptDirective = { body: GrammarTypeJS; } | { head: GrammarTypeJS }
-
-export interface ImportDirective {
-    import: string;
-    path?: boolean;
-    alias?: string;
-}
-
-export interface ConfigDirective {
-    config: Dictionary<any>;
-}
-
-export interface GrammarDirective {
-    grammar: {
-        config?: Dictionary<any>;
-        rules: GrammarBuilderRule[];
-    }
-}
-
-export interface LexerDirective {
-    lexer: {
-        start?: string,
-        states: LexerStateDefinition[];
-    };
-}
-
-export interface GrammarBuilderRule {
-    name: string;
-    expressions: GrammarBuilderExpression[];
-    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
-}
-
-export interface GrammarBuilderExpression {
-    symbols: GrammarBuilderSymbol[];
-    postprocess?: GrammarTypeJS | GrammarTypeBuiltIn | GrammarTypeTemplate;
-}
-
-export type GrammarBuilderSymbol = GrammarTypeRule | GrammarTypeRegex | GrammarTypeToken | GrammarTypeLiteral | GrammarBuilderSymbolRepeat | GrammarBuilderSymbolSubexpression;
-
-export interface GrammarBuilderSymbolSubexpression {
-    subexpression: GrammarBuilderExpression[];
-}
-
-export interface GrammarBuilderSymbolRepeat {
-    expression: GrammarBuilderSymbol;
-    repeat: "+" | "*" | "?";
-}
-
-export interface GrammarTypeRule {
-    rule: string;
-}
-
-export interface GrammarTypeRegex {
-    regex: string;
-    flags?: string
-}
-
-export interface GrammarTypeToken {
-    token: string;
-}
-
-export interface GrammarTypeLiteral {
-    literal: string;
-    insensitive?: boolean;
-}
-
-export type GrammarTypeBuiltIn = { builtin: string };
-export type GrammarTypeTemplate = { template: string };
-export type GrammarTypeJS = { js: string };
-
-
-export type ParserAlgorithm = ((language: LanguageDefinition & { tokens: TokenBuffer; utility: ParserUtility }, options?: any) => { results: any[], info?: any });
-
-export type LanguageDirective = (JavascriptDirective | ImportDirective | ConfigDirective | GrammarDirective | LexerDirective);
-
-type GrammarRuleSymbolFunction = (data: LexerToken) => boolean;
-
-export interface GrammarRule {
-    name: string;
-    symbols: GrammarRuleSymbol[];
-    postprocess?: PostProcessor;
-}
-
-export type GrammarRuleSymbol = string | RegExp | GrammarTypeLiteral | GrammarTypeToken | GrammarRuleSymbolFunction;
-
-export interface GeneratorGrammarRule {
-    name: string;
-    symbols: GeneratorGrammarSymbol[];
-    postprocess?: GrammarTypeTemplate | GrammarTypeBuiltIn | GrammarTypeJS;
-}
-
-export type GeneratorGrammarSymbol = { alias?: string } & (GrammarTypeRule | GrammarTypeRegex | GrammarTypeLiteral | GrammarTypeToken);
-
-export interface LanguageDefinition {
-    lexer?: Lexer | LexerConfig;
-    grammar: {
-        start: string;
-        rules: Dictionary<GrammarRule[]>;
-    }
-    lr?: {
-        k: number;
-        table: Dictionary<LRState>;
-    }
-
-}
-
-export interface LRState {
-    actions: Next[];
-    goto: { [key: string]: string };
-    reduce?: GrammarRule;
-    isFinal: boolean;
-}
-
-type Next = { symbol: GrammarRuleSymbol, next: string };
-
-
-export interface TQRestorePoint {
-    historyIndex: number;
-    offset: number;
-}
-
-export interface Lexer {
-    next(): LexerToken | undefined;
-    feed(chunk?: string, state?: ReturnType<Lexer['state']>): void;
-    state(): any;
-    flush?(): void;
-}
-
-export interface LexerToken {
-    type?: string | undefined;
-    tag?: Set<string>;
-    value: string;
-    offset: number;
-    line: number;
-    column: number;
-}
-
-export interface LexerStatus {
-    index: number;
-    line: number;
-    column: number;
-    state: string;
-}
-
-export interface LexerStateDefinition {
-    name: string;
-    unmatched?: string;
-    default?: string;
-    rules: (LexerStateImportRule | LexerStateMatchRule)[];
-}
-
-export interface LexerStateImportRule {
-    import: string[]
-}
-
-export interface LexerStateMatchRule {
-    when: string | RegExp
-    type?: string;
-    tag?: string[];
-    pop?: number | 'all';
-    before?: boolean;
-    highlight?: string;
-    open?: string;
-    close?: string;
-    embed?: string;
-    unembed?: boolean;
-    inset?: number;
-    goto?: string;
-    set?: string;
-}
-
-export interface ResolvedStateDefinition {
-    name: string;
-    unmatched?: string;
-    rules: LexerStateMatchRule[];
-}
-
-export interface CompiledStateDefinition {
-    regexp: RegExp;
-    unmatched?: LexerStateMatchRule;
-    rules: LexerStateMatchRule[];
-}
-
-export interface LexerConfig {
-    start?: string
-    states: Dictionary<LexerStateDefinition>;
-}
-
-export interface GeneratorState {
-    version: string;
-    config: Dictionary<string>;
-    head: string[];
-    body: string[];
-    lexer?: LexerConfig;
-    grammar: {
-        start: string;
-        config: {
-            postprocessorDefault?: GrammarTypeJS | GrammarTypeTemplate;
-            postprocessorOverride?: GrammarTypeJS | GrammarTypeTemplate;
-        }
-        rules: Dictionary<GeneratorGrammarRule[]>,
-        uuids: { [key: string]: number }
-    }
-}

package/testing.ts

@@ -1,18 +0,0 @@
-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');
-}