psl-parser/out/statementParser.d.ts

A parser for the Profile Scripting Language

import { Token } from './tokenizer';
export declare enum SyntaxKind {
    ASSIGNMENT = 0,
    BINARY_OPERATOR = 1,
    CATCH_STATEMENT = 2,
    DO_STATEMENT = 3,
    FOR_STATEMENT = 4,
    IDENTIFIER = 5,
    IF_STATEMENT = 6,
    NUMERIC_LITERAL = 7,
    POST_CONDITION = 8,
    QUIT_STATEMENT = 9,
    RETURN_STATEMENT = 10,
    SET_STATEMENT = 11,
    MULTIPLE_VARIABLE_SET = 12,
    STRING_LITERAL = 13,
    WHILE_STATEMENT = 14,
    TYPE_STATEMENT = 15,
    VARIABLE_DECLARATION = 16,
    TYPE_IDENTIFIER = 17
}
export interface Node {
    kind: SyntaxKind;
    parent?: Node;
}
export interface BinaryOperator extends Node {
    operator: Token[];
    left?: Node;
    right?: Node;
}
export interface MultiSet extends Node {
    variables: Expression[];
}
export interface PostCondition extends Node {
    colon: Token;
    condition?: Expression;
    expression?: Expression | MultiSet;
}
export declare type Expression = Value | BinaryOperator | PostCondition | MultiSet;
export interface Statement extends Node {
    action: Token;
    expressions: Expression[];
    block?: Node;
}
export interface Value extends Node {
    id: Token;
    unaryOperator?: Token[];
}
export declare type NumericLiteral = Value;
export interface StringLiteral extends Value {
    openQuote: Token;
    closeQuote: Token;
}
export interface Identifier extends Value {
    args?: Expression[];
    openParen?: Token;
    closeParen?: Token;
}
export interface DeclarationStatement extends Identifier {
    type: TypeIdentifier;
    staticToken?: Token;
    newToken?: Token;
    publicToken?: Token;
    literalToken?: Token;
}
export declare type TypeIdentifier = Identifier;
export declare class StatementParser {
    tokenizer: IterableIterator<Token>;
    tokens: Token[];
    previousToken: Token | undefined;
    activeToken: Token | undefined;
    constructor(arg: string | IterableIterator<Token> | Token[]);
    parseLine(): Statement[];
    parseStatement(): Statement | undefined;
    parseTypeStatement(): Statement;
    parseAssignment(getLeft: () => Expression | MultiSet | DeclarationStatement | undefined): Expression | undefined;
    parseForStatement(): Statement | undefined;
    parseSetExpression(): Expression | undefined;
    parsePostCondition(): PostCondition | undefined;
    parseSetVariables(): Expression | undefined;
    parseExpression(ignoreEquals?: boolean, includeRet?: boolean): Expression | undefined;
    parseColonSeparatedValues(rootNode: Expression): Expression;
    parseOperatorSeparatedValues(rootNode: Expression, ignoreEquals?: boolean): Expression;
    parseBinaryOperator(): BinaryOperator | undefined;
    parseUnaryOperator(includeRet?: boolean): Token[];
    parseValue(tree?: BinaryOperator, includeRet?: boolean): Value | Expression | undefined;
    parseIdentifier(): Identifier | undefined;
    parseStringLiteral(): StringLiteral | undefined;
    parseArgs(): Expression[];
    loadCommaSeparated<T>(getArg: () => T | T[] | undefined): T[];
    private next;
}
export declare function forEachChild(node: Node, f: (n: Node) => boolean): void;