@parser-generator/grammar-interpreter/lib/types/interp.d.ts

A Parser Generator that supports LL,SLR,LR1,LALR

import { NonTerminal, Production, TokenPro, IGrammar, ParsingTable, SymbolTraits } from "@parser-generator/definition";
import { FirstTable, FollowTable } from "@parser-generator/core";
import { CommonAbstractRegexpLexer } from "@parser-generator/definition";
/*************************************** Lexical Analysis  ****************************************/
export declare enum Tag {
    BLANK = "BLANK",
    CRLF = "CRLF",
    EOF = "EOF",
    NIL = "NIL",
    HEAD = "HEAD",
    SCRIPT = "SCRIPT",
    STRING = "STRING",
    STRING_SINGLE_QUOTES = "STRING_SINGLE_QUOTES",
    STRING_DOUBLE_QUOTES = "STRING_DOUBLE_QUOTES",
    NUMBER = "NUMBER",
    WORD = "WORD",
    SINGLE = "SINGLE",
    ID = "ID",
    KEYWORD = "KEYWORD",
    ASSOC = "ASSOC"
}
declare abstract class Token {
    protected _lineNo: number;
    protected _colNo: number;
    protected _tag: Tag;
    constructor(tag: Tag);
    setPos(lineNo: number, colNo: number): void;
    get lineNo(): number;
    get colNo(): number;
    get tag(): Tag;
    abstract get value(): Object;
    toString(): string;
}
export declare class GrammarLexer extends CommonAbstractRegexpLexer<Token, Tag> {
    private lineNo;
    private colNo;
    private reserves;
    private eofToken;
    constructor(text: string);
    protected getEOF(): Token;
    protected createToken(lexeme: string, type: Tag, match: RegExpExecArray): Token | undefined;
    protected onMatchFaild(text: string, lastIndex: number): void;
}
/*************************************** AST ****************************************/
declare abstract class ASTree {
    abstract accpet(visitor: IVisitor): void;
}
export declare class ProgramNode extends ASTree {
    grammarNode: GrammarNode;
    private blocks;
    traits: SymbolTraits;
    constructor(gNode: GrammarNode, paNode: PrecAssocNode | undefined, blocks: ASTree[]);
    accpet(visitor: IVisitor): void;
}
declare class ScriptNode extends ASTree {
    script: string;
    constructor(t: Token);
    accpet(visitor: IVisitor): void;
}
declare class PrecAssocNode extends ASTree {
    children: PrecassocItemNode[];
    constructor(children: PrecassocItemNode[]);
    accpet(visitor: IVisitor): void;
}
declare class PrecassocItemNode extends ASTree {
    symbol: Token;
    leftAssoc: boolean;
    prec: number;
    constructor(tokens: (Token | undefined)[]);
    accpet(visitor: IVisitor): void;
}
declare class Env {
    private syms;
    private rsyms;
    private prods;
    private rprods;
    constructor();
    registerSym(varName: string, sym: TokenPro | NonTerminal): void;
    getSym(varName: string): TokenPro | NonTerminal;
    hasSym(varName: string): boolean;
    getSymVarName(sym: TokenPro | NonTerminal): string | undefined;
    registerProd(prod: Production, varName: string): void;
    getProdVarName(prod: Production): string;
    getProd(varName: string): Production;
}
declare class GrammarNode extends ASTree {
    private _env;
    get env(): Env;
    private prodNodes;
    private ntNodes;
    private tpNodes;
    nts: NonTerminal[];
    startSym: NonTerminal;
    prodNodeGroups: any;
    constructor(tNodes: TokenProNode[], ntNodes: NonTerminalNode[], prodNodes: ProductionNode[]);
    accpet(visitor: IVisitor): void;
}
declare class TokenProNode extends ASTree {
    token: Token;
    varName: string;
    constructor(token: Token);
    accpet(visitor: IVisitor): void;
}
declare type RawSymbol = {
    symToken: Token;
    action: Token | undefined;
};
declare class ProductionNode extends ASTree {
    preAction: Token | undefined;
    postAction: Token | undefined;
    left: Token;
    rawBody: RawSymbol[];
    varName: string;
    ntVarName: string;
    pid: number | undefined;
    env: Env;
    constructor(nt: Token, body: Token[]);
    accpet(visitor: IVisitor): void;
}
declare class NonTerminalNode extends ASTree {
    _varName: string;
    token: Token;
    prods: ProductionNode[];
    constructor(token: Token, prods: ProductionNode[]);
    get varName(): string;
    accpet(visitor: IVisitor): void;
}
export declare function parse(lexer: GrammarLexer): ProgramNode;
/*************************************** Semantic Analysis ****************************************/
interface IVisitor {
    visitProgramNode(node: ProgramNode): void;
    visitScriptNode(node: ScriptNode): void;
    visitGrammarNode(node: GrammarNode): void;
    visitTokenProNode(node: TokenProNode): void;
    visitNonterminalNode(node: NonTerminalNode): void;
    visitProductionNode(node: ProductionNode): void;
    visitPrecAssocNode(node: PrecAssocNode): void;
}
export declare type EvalContext = {
    parser: ParserType;
};
export declare class EvalVisitor implements IVisitor {
    private traits;
    private nts;
    private startSym;
    private prods;
    private env;
    private context;
    constructor(context: EvalContext);
    private _grammar;
    get grammar(): IGrammar;
    visitProgramNode(node: ProgramNode): void;
    visitScriptNode(node: ScriptNode): void;
    visitGrammarNode(node: GrammarNode): void;
    visitTokenProNode(node: TokenProNode): void;
    visitNonterminalNode(node: NonTerminalNode): void;
    visitProductionNode(node: ProductionNode): void;
    visitPrecAssocNode(node: PrecAssocNode): void;
}
export declare type CodegenContext = {
    firstTable?: FirstTable;
    followTable?: FollowTable;
    lrTable?: ParsingTable;
    parser: "LL" | "SLR" | "LR1" | "LALR";
};
export declare class TSCodegenVisitor implements IVisitor {
    private _code;
    private context;
    constructor(context: CodegenContext);
    private emit;
    private emitln;
    get code(): string;
    visitProgramNode(node: ProgramNode): void;
    visitScriptNode(node: ScriptNode): void;
    visitGrammarNode(node: GrammarNode): void;
    visitTokenProNode(node: TokenProNode): void;
    visitNonterminalNode(node: NonTerminalNode): void;
    visitProductionNode(node: ProductionNode): void;
    visitPrecAssocNode(node: PrecAssocNode): void;
}
/***************************************  ****************************************/
export declare type ParserType = "LL" | "SLR" | "LR1" | "LALR";
export declare type LangType = "TS" | "JS";
export declare type ParserGenConfig = {
    parser: ParserType;
    lang: LangType;
};
export declare function genParser(rawGrammar: string, { parser, lang }: ParserGenConfig): {
    code: string;
    grammar: IGrammar;
    firstTable: FirstTable;
    followTable: FollowTable;
    lrTable: ParsingTable | undefined;
    lrAutomata: import("@parser-generator/core").StateSet | undefined;
};
export {};
//# sourceMappingURL=interp.d.ts.map