@parser-generator/definition/lib/types/syntax.d.ts

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

import { Stack } from "@light0x00/shim";
import { IToken, TableKey } from "./lexical";
/*******************************************************************************************************
符号的原型
    符号原型的作用是用于建立一种逻辑上的匹配关系.
    对于终结符而言:
        1. 值类型符号,对应于 比较值的token,比如 '==' ,没有原型, 分析过程中直接使用词素值匹配
        2. 原型类型符号,对应于 比较类型的token, 比如 NUMBER ,其原型是一个TerminalPro对象, 分析过程中使用该对象匹配
    对于非终结符:
        3. 文法中左侧符号都会对应一个NonterminalPro对象,而产生式体中出现的非终结符,比如 A->aA ,第二个
    例:
        E->E1+F1
        F->digit
    - 终结符‘+’没有原型,分析时匹配词素值.
    - 终结符 digit 的实例则不可枚举,1、2都digit,分析时不能以词素值为准,而是以原型为准,1、2的词素值不一样,但其原型一致,
        这是一种逻辑相等关系.
    - 非终结符E1的原型是E,F1的原型是F.
*******************************************************************************************************/
/**
 * 非终结符符号原型
 */
export declare class NonTerminal implements TableKey {
    private _name;
    private _prods;
    private _isStart;
    constructor(name: string, isStart?: boolean, prods?: Production[]);
    get name(): string;
    get prods(): Production[];
    set prods(ps: Production[]);
    get isStart(): boolean;
    toString(): string;
    key(): SSymbol;
}
/**
 * token原型
 */
export declare class TokenPro implements IToken {
    private name;
    constructor(name: string);
    toString(): string;
    key(): Terminal;
}
export declare const NIL: TokenPro;
export declare const EOF: TokenPro;
export declare type SSymbol = string | NonTerminal | TokenPro;
export declare type Terminal = TokenPro | string;
export declare function isNonTerminal(sym: Object): sym is NonTerminal;
export declare function isTerminal(sym: Object): sym is Terminal;
export declare type MidAction = ((stack: Stack<ASTElement>) => void);
export declare class SymbolWrapper {
    private _value;
    private _action;
    constructor(sym: SSymbol, action?: MidAction);
    get value(): string | NonTerminal | TokenPro;
    get action(): MidAction | undefined;
    isNonTerminal(): boolean;
    isTerminal(): boolean;
    isNIL(): boolean;
    toString(): string;
}
/**
 * 产生式
 */
export declare class Production {
    private _id;
    private _nt;
    private _actionBody;
    private _body;
    private _preAction;
    private _postAction;
    private _leftAssoc;
    private _prec;
    constructor(id: number, nt: NonTerminal, body: SymbolWrapper[], preAction?: PreAction, postAction?: PostAction, leftAssoc?: boolean, prec?: number);
    get id(): number;
    get head(): NonTerminal;
    get body(): SSymbol[];
    get actionBody(): SymbolWrapper[];
    get preAction(): PreAction | undefined;
    get postAction(): PostAction;
    get action(): PostAction;
    get prec(): number;
    set prec(val: number);
    get leftAssoc(): boolean;
    set leftAssoc(val: boolean);
    isEpsilon(): boolean;
    toString(): string;
}
export declare type PreAction = (stack: Stack<ASTElement>) => void;
export declare type PostAction = (eles: Array<ASTElement>, stack: Stack<ASTElement>) => ASTree;
/**
 * 文法对象的api定义
 */
export interface IGrammar {
    /**
     * 获得文法的所有非终结符
     */
    nonTerminals(): NonTerminal[];
    /**
     * 获得所有产生式
     */
    productions(): Production[];
    /**
     * 获得文法的开始符号
     */
    startNT(): NonTerminal;
}
/**
 * 符号优先级、结合性
 */
export declare class SymbolTrait {
    private _prec;
    private _leftAssoc;
    constructor(prec: number, leftAssoc: boolean);
    get prec(): number;
    get leftAssoc(): boolean;
    compareTo(other: SymbolTrait): boolean;
}
export declare type SymbolTraits = Map<SSymbol, SymbolTrait>;
export declare class Grammar implements IGrammar {
    protected nts: NonTerminal[];
    protected prods: Production[];
    protected traits: SymbolTraits;
    protected startSym: NonTerminal;
    constructor(nts: NonTerminal[], prods: Production[], startSymbol: NonTerminal, traits?: SymbolTraits);
    protected validate(): void;
    nonTerminals(): NonTerminal[];
    productions(): Production[];
    startNT(): NonTerminal;
    toString(): string;
}
/*************************************** LR相关 ****************************************/
export declare class AugmentedGrammar extends Grammar {
    protected validate(): void;
}
export declare abstract class Operation {
    abstract equals(obj: Object): boolean;
    isReduce(): this is Reduce;
    isShift(): this is Shift;
    isGoto(): this is Goto;
    isAccept(): this is Accept;
}
export declare class Shift extends Operation {
    private _nextStateId;
    constructor(nextStateId: number);
    get nextStateId(): number;
    toString(): string;
    equals(obj: Object): boolean;
    isShift(): boolean;
}
export declare class Goto extends Operation {
    private _nextStateId;
    constructor(nextStateId: number);
    get nextStateId(): number;
    toString(): string;
    equals(obj: Object): boolean;
    isGoto(): boolean;
}
export declare class Reduce extends Operation {
    private _prod;
    constructor(prod: Production);
    get prod(): Production;
    toString(): string;
    equals(obj: Object): boolean;
    isReduce(): boolean;
}
export declare class Accept extends Operation {
    constructor();
    equals(obj: Object): boolean;
    toString(): string;
    isAccept(): boolean;
}
export declare class ParsingTable {
    private parsingTable;
    get table(): Map<number, Map<SSymbol, Operation>>;
    put(state: number, symbol: SSymbol, op: Operation): void;
    has(state: number, symbol: SSymbol, op: Operation): boolean;
    get(state: number, symbol: SSymbol): Operation | undefined;
    getExpectedSymbols(state: number): SSymbol[];
    getExpectedTokens(state: number): SSymbol[];
}
/**
 * 构成ASTree节点的元素
 */
export declare type ASTElement = IToken | ASTree;
export interface ASTree {
}
//# sourceMappingURL=syntax.d.ts.map