pegisland/dist/src/ParseTree.d.ts

General PEG-based parser supporting island grammars with lake symbols

import { Lake } from './ParsingExpression';
import { Position } from './Position';
export declare class Range {
    readonly start: Position;
    readonly end: Position;
    constructor(start: Position, end: Position);
}
export interface IParseTree {
    readonly range: Range;
    readonly childNodes: IParseTree[];
    parentNode: IParseTree;
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
declare abstract class ParseTree implements IParseTree {
    #private;
    childNodes: IParseTree[];
    range: Range;
    readonly id: number;
    parentNode: IParseTree;
    constructor(childNodes: IParseTree[], range: Range);
    abstract accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export interface IParseTreeVisitor<ArgsType extends Array<unknown> = [], ReturnType = void> {
    visitNonterminal(node: NodeNonterminal, ...args: ArgsType): ReturnType;
    visitTerminal(node: NodeTerminal, ...args: ArgsType): ReturnType;
    visitLake(node: NodeLake, ...args: ArgsType): ReturnType;
    visitZeroOrMore(node: NodeZeroOrMore, ...args: ArgsType): ReturnType;
    visitOneOrMore(node: NodeOneOrMore, ...args: ArgsType): ReturnType;
    visitOptional(node: NodeOptional, ...args: ArgsType): ReturnType;
    visitOrderedChoice(node: NodeOrderedChoice, ...arg: ArgsType): ReturnType;
    visitSequence(node: NodeSequence, ...args: ArgsType): ReturnType;
    visitAnd(node: NodeAnd, ...args: ArgsType): ReturnType;
    visitNot(node: NodeNot, ...args: ArgsType): ReturnType;
    visitGrouping(node: NodeGrouping, ...args: ArgsType): ReturnType;
    visitRewriting(node: NodeRewriting, ...args: ArgsType): ReturnType;
}
export declare class DefaultParseTreeVisitor implements IParseTreeVisitor {
    visitNonterminal(_node: NodeNonterminal): void;
    visitTerminal(_node: NodeTerminal): void;
    visitLake(_node: NodeLake): void;
    visitZeroOrMore(_node: NodeZeroOrMore): void;
    visitOneOrMore(_node: NodeOneOrMore): void;
    visitOptional(_node: NodeOptional): void;
    visitOrderedChoice(_node: NodeOrderedChoice): void;
    visitSequence(_node: NodeSequence): void;
    visitAnd(_node: NodeAnd): void;
    visitNot(_node: NodeNot): void;
    visitGrouping(_node: NodeGrouping): void;
    visitRewriting(_node: NodeRewriting): void;
}
export declare class NodeTerminal extends ParseTree {
    pattern: RegExp;
    text: string;
    constructor(range: Range, pattern: RegExp, text: string);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeNonterminal extends ParseTree {
    symbol: string;
    constructor(symbol: string, range: Range, childNode: IParseTree);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeZeroOrMore extends ParseTree {
    constructor(range: Range, childNodes: IParseTree[]);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeOneOrMore extends ParseTree {
    constructor(range: Range, childNodes: IParseTree[]);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeOptional extends ParseTree {
    constructor(range: Range, childNodes: IParseTree[]);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeAnd extends ParseTree {
    constructor(range: Range, childNode: IParseTree);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeNot extends ParseTree {
    constructor(range: Range);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeSequence extends ParseTree {
    constructor(range: Range, childNodes: IParseTree[]);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeOrderedChoice extends ParseTree {
    index: number;
    constructor(range: Range, childNode: IParseTree, index: number);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeGrouping extends ParseTree {
    constructor(range: Range, childNode: IParseTree);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare class NodeLake extends ParseTree {
    pe: Lake;
    constructor(range: Range, childNodes: IParseTree[], pe: Lake);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
declare class Rewriting {
}
export declare class NodeRewriting extends ParseTree {
    spec: Rewriting;
    constructor(range: Range, childNode: IParseTree, spec: Rewriting);
    accept<ArgsType extends unknown[] = [], ReturnType = void>(visitor: IParseTreeVisitor<ArgsType, ReturnType>, ...arg: ArgsType): ReturnType;
}
export declare function traverseNonterminals(parseTree: IParseTree, func: (node: NodeNonterminal) => void): void;
export {};
//# sourceMappingURL=ParseTree.d.ts.map