@maniascript/api/dist/antlr/DocParser.d.ts

Maniascript API generator

import * as antlr from "antlr4ng";
import { Token } from "antlr4ng";
import { DocParserVisitor } from "./DocParserVisitor.js";
export declare class DocParser extends antlr.Parser {
    static readonly SINGLE_LINE_COMMENT = 1;
    static readonly MULTI_LINES_DOC_COMMENT = 2;
    static readonly MULTI_LINES_COMMENT = 3;
    static readonly ARRAY_IGNORE = 4;
    static readonly TEMPLATE_IGNORE = 5;
    static readonly KEYWORD_STRUCT = 6;
    static readonly KEYWORD_CLASS = 7;
    static readonly KEYWORD_PUBLIC = 8;
    static readonly KEYWORD_ENUM = 9;
    static readonly KEYWORD_CONST = 10;
    static readonly KEYWORD_ARRAY = 11;
    static readonly KEYWORD_RESERVED = 12;
    static readonly KEYWORD_UNUSED = 13;
    static readonly KEYWORD_NAMESPACE = 14;
    static readonly TYPE_BOOLEAN = 15;
    static readonly TYPE_IDENT = 16;
    static readonly TYPE_INT2 = 17;
    static readonly TYPE_INT3 = 18;
    static readonly TYPE_INTEGER = 19;
    static readonly TYPE_REAL = 20;
    static readonly TYPE_TEXT = 21;
    static readonly TYPE_VEC2 = 22;
    static readonly TYPE_VEC3 = 23;
    static readonly TYPE_VOID = 24;
    static readonly OPERATOR_COLON = 25;
    static readonly OPERATOR_DOUBLECOLON = 26;
    static readonly OPERATOR_COMMA = 27;
    static readonly OPERATOR_ASSIGN = 28;
    static readonly OPERATOR_SEMICOLON = 29;
    static readonly OPERATOR_OPEN_BRACE = 30;
    static readonly OPERATOR_CLOSE_BRACE = 31;
    static readonly OPERATOR_OPEN_ANGLE = 32;
    static readonly OPERATOR_CLOSE_ANGLE = 33;
    static readonly OPERATOR_OPEN_PAREN = 34;
    static readonly OPERATOR_CLOSE_PAREN = 35;
    static readonly OPERATOR_OPEN_BRACKET = 36;
    static readonly OPERATOR_CLOSE_BRACKET = 37;
    static readonly OPERATOR_POINTER = 38;
    static readonly LITERAL_REAL = 39;
    static readonly IDENTIFIER = 40;
    static readonly WHITESPACE = 41;
    static readonly LINE_TERMINATOR = 42;
    static readonly RULE_program = 0;
    static readonly RULE_typeDeclaration = 1;
    static readonly RULE_classDeclaration = 2;
    static readonly RULE_namespaceDeclaration = 3;
    static readonly RULE_memberDeclarationList = 4;
    static readonly RULE_variableDeclaration = 5;
    static readonly RULE_functionDeclaration = 6;
    static readonly RULE_functionParameterList = 7;
    static readonly RULE_functionParameter = 8;
    static readonly RULE_enumDeclaration = 9;
    static readonly RULE_enumValueList = 10;
    static readonly RULE_enumValue = 11;
    static readonly RULE_type = 12;
    static readonly RULE_typeArray = 13;
    static readonly RULE_typeArrayValue = 14;
    static readonly RULE_typeClass = 15;
    static readonly RULE_typeEnum = 16;
    static readonly RULE_typeLiteral = 17;
    static readonly literalNames: (string | null)[];
    static readonly symbolicNames: (string | null)[];
    static readonly ruleNames: string[];
    get grammarFileName(): string;
    get literalNames(): (string | null)[];
    get symbolicNames(): (string | null)[];
    get ruleNames(): string[];
    get serializedATN(): number[];
    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException;
    constructor(input: antlr.TokenStream);
    program(): ProgramContext;
    typeDeclaration(): TypeDeclarationContext;
    classDeclaration(): ClassDeclarationContext;
    namespaceDeclaration(): NamespaceDeclarationContext;
    memberDeclarationList(): MemberDeclarationListContext;
    variableDeclaration(): VariableDeclarationContext;
    functionDeclaration(): FunctionDeclarationContext;
    functionParameterList(): FunctionParameterListContext;
    functionParameter(): FunctionParameterContext;
    enumDeclaration(): EnumDeclarationContext;
    enumValueList(): EnumValueListContext;
    enumValue(): EnumValueContext;
    type_(): TypeContext;
    typeArray(): TypeArrayContext;
    typeArrayValue(): TypeArrayValueContext;
    typeClass(): TypeClassContext;
    typeEnum(): TypeEnumContext;
    typeLiteral(): TypeLiteralContext;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): antlr.ATN;
    private static readonly vocabulary;
    get vocabulary(): antlr.Vocabulary;
    private static readonly decisionsToDFA;
}
export declare class ProgramContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    EOF(): antlr.TerminalNode;
    typeDeclaration(): TypeDeclarationContext[];
    typeDeclaration(i: number): TypeDeclarationContext | null;
    classDeclaration(): ClassDeclarationContext[];
    classDeclaration(i: number): ClassDeclarationContext | null;
    namespaceDeclaration(): NamespaceDeclarationContext[];
    namespaceDeclaration(i: number): NamespaceDeclarationContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeDeclarationContext extends antlr.ParserRuleContext {
    _content?: MemberDeclarationListContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    typeLiteral(): TypeLiteralContext;
    OPERATOR_OPEN_BRACE(): antlr.TerminalNode;
    OPERATOR_CLOSE_BRACE(): antlr.TerminalNode;
    OPERATOR_SEMICOLON(): antlr.TerminalNode;
    KEYWORD_CLASS(): antlr.TerminalNode | null;
    KEYWORD_STRUCT(): antlr.TerminalNode | null;
    memberDeclarationList(): MemberDeclarationListContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class ClassDeclarationContext extends antlr.ParserRuleContext {
    _name?: Token | null;
    _parent?: Token | null;
    _content?: MemberDeclarationListContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    KEYWORD_CLASS(): antlr.TerminalNode | null;
    OPERATOR_OPEN_BRACE(): antlr.TerminalNode;
    KEYWORD_PUBLIC(): antlr.TerminalNode[];
    KEYWORD_PUBLIC(i: number): antlr.TerminalNode | null;
    OPERATOR_COLON(): antlr.TerminalNode[];
    OPERATOR_COLON(i: number): antlr.TerminalNode | null;
    OPERATOR_CLOSE_BRACE(): antlr.TerminalNode;
    OPERATOR_SEMICOLON(): antlr.TerminalNode;
    IDENTIFIER(): antlr.TerminalNode[];
    IDENTIFIER(i: number): antlr.TerminalNode | null;
    memberDeclarationList(): MemberDeclarationListContext | null;
    KEYWORD_STRUCT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class NamespaceDeclarationContext extends antlr.ParserRuleContext {
    _name?: Token | null;
    _content?: MemberDeclarationListContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    KEYWORD_NAMESPACE(): antlr.TerminalNode;
    OPERATOR_OPEN_BRACE(): antlr.TerminalNode;
    OPERATOR_CLOSE_BRACE(): antlr.TerminalNode;
    OPERATOR_SEMICOLON(): antlr.TerminalNode;
    IDENTIFIER(): antlr.TerminalNode;
    memberDeclarationList(): MemberDeclarationListContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class MemberDeclarationListContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    variableDeclaration(): VariableDeclarationContext[];
    variableDeclaration(i: number): VariableDeclarationContext | null;
    functionDeclaration(): FunctionDeclarationContext[];
    functionDeclaration(i: number): FunctionDeclarationContext | null;
    enumDeclaration(): EnumDeclarationContext[];
    enumDeclaration(i: number): EnumDeclarationContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class VariableDeclarationContext extends antlr.ParserRuleContext {
    _isConst?: Token | null;
    _variableType?: TypeContext;
    _name?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    OPERATOR_SEMICOLON(): antlr.TerminalNode;
    type(): TypeContext;
    IDENTIFIER(): antlr.TerminalNode | null;
    OPERATOR_ASSIGN(): antlr.TerminalNode | null;
    LITERAL_REAL(): antlr.TerminalNode | null;
    KEYWORD_CONST(): antlr.TerminalNode | null;
    TYPE_TEXT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class FunctionDeclarationContext extends antlr.ParserRuleContext {
    _functionType?: TypeContext;
    _name?: Token | null;
    _parameters?: FunctionParameterListContext;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    OPERATOR_OPEN_PAREN(): antlr.TerminalNode;
    OPERATOR_CLOSE_PAREN(): antlr.TerminalNode;
    OPERATOR_SEMICOLON(): antlr.TerminalNode;
    type(): TypeContext;
    IDENTIFIER(): antlr.TerminalNode;
    functionParameterList(): FunctionParameterListContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class FunctionParameterListContext extends antlr.ParserRuleContext {
    _functionParameter?: FunctionParameterContext;
    _parameters: FunctionParameterContext[];
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    functionParameter(): FunctionParameterContext[];
    functionParameter(i: number): FunctionParameterContext | null;
    OPERATOR_COMMA(): antlr.TerminalNode[];
    OPERATOR_COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class FunctionParameterContext extends antlr.ParserRuleContext {
    _parameterType?: TypeContext;
    _name?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    type(): TypeContext;
    IDENTIFIER(): antlr.TerminalNode[];
    IDENTIFIER(i: number): antlr.TerminalNode | null;
    TYPE_TEXT(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class EnumDeclarationContext extends antlr.ParserRuleContext {
    _name?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    KEYWORD_ENUM(): antlr.TerminalNode;
    OPERATOR_OPEN_BRACE(): antlr.TerminalNode;
    enumValueList(): EnumValueListContext;
    OPERATOR_CLOSE_BRACE(): antlr.TerminalNode;
    OPERATOR_SEMICOLON(): antlr.TerminalNode;
    IDENTIFIER(): antlr.TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class EnumValueListContext extends antlr.ParserRuleContext {
    _enumValue?: EnumValueContext;
    _values: EnumValueContext[];
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    enumValue(): EnumValueContext[];
    enumValue(i: number): EnumValueContext | null;
    OPERATOR_COMMA(): antlr.TerminalNode[];
    OPERATOR_COMMA(i: number): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class EnumValueContext extends antlr.ParserRuleContext {
    _name?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    IDENTIFIER(): antlr.TerminalNode[];
    IDENTIFIER(i: number): antlr.TerminalNode | null;
    KEYWORD_RESERVED(): antlr.TerminalNode | null;
    KEYWORD_UNUSED(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeContext extends antlr.ParserRuleContext {
    _isValueConst?: Token | null;
    _isPointer?: Token | null;
    _isPointerConst?: Token | null;
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    typeLiteral(): TypeLiteralContext | null;
    KEYWORD_CONST(): antlr.TerminalNode[];
    KEYWORD_CONST(i: number): antlr.TerminalNode | null;
    typeClass(): TypeClassContext | null;
    OPERATOR_POINTER(): antlr.TerminalNode | null;
    typeEnum(): TypeEnumContext | null;
    typeArray(): TypeArrayContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeArrayContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    KEYWORD_ARRAY(): antlr.TerminalNode | null;
    OPERATOR_OPEN_ANGLE(): antlr.TerminalNode | null;
    type(): TypeContext | null;
    OPERATOR_CLOSE_ANGLE(): antlr.TerminalNode | null;
    typeArrayValue(): TypeArrayValueContext | null;
    OPERATOR_OPEN_BRACKET(): antlr.TerminalNode | null;
    OPERATOR_CLOSE_BRACKET(): antlr.TerminalNode | null;
    TYPE_VOID(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeArrayValueContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    typeLiteral(): TypeLiteralContext | null;
    typeClass(): TypeClassContext | null;
    typeEnum(): TypeEnumContext | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeClassContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    IDENTIFIER(): antlr.TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeEnumContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    IDENTIFIER(): antlr.TerminalNode[];
    IDENTIFIER(i: number): antlr.TerminalNode | null;
    OPERATOR_DOUBLECOLON(): antlr.TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}
export declare class TypeLiteralContext extends antlr.ParserRuleContext {
    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
    TYPE_BOOLEAN(): antlr.TerminalNode | null;
    TYPE_IDENT(): antlr.TerminalNode | null;
    TYPE_INT2(): antlr.TerminalNode | null;
    TYPE_INT3(): antlr.TerminalNode | null;
    TYPE_INTEGER(): antlr.TerminalNode | null;
    TYPE_REAL(): antlr.TerminalNode | null;
    TYPE_TEXT(): antlr.TerminalNode | null;
    TYPE_VEC2(): antlr.TerminalNode | null;
    TYPE_VEC3(): antlr.TerminalNode | null;
    TYPE_VOID(): antlr.TerminalNode | null;
    get ruleIndex(): number;
    accept<Result>(visitor: DocParserVisitor<Result>): Result | null;
}