mathjslab/lib/src/MathJSLabParser.d.ts

MathJSLab - An interpreter with language syntax like MATLAB®/Octave, ISBN 978-65-00-82338-7.

import { ATN, DFA, FailedPredicateException, Parser, RuleContext, ParserRuleContext, TerminalNode, Token, TokenStream } from 'antlr4';
import * as AST from './AST';
/**
 * # MathJSLabParser
 *
 * A parser that recognizes a language syntax like MATLAB®/Octave written in TypeScript.
 *
 * ## References
 * * [MATLAB Operator Precedence](https://www.mathworks.com/help/matlab/matlab_prog/operator-precedence.html)
 * * [Octave lexer](https://github.com/gnu-octave/octave/blob/default/libinterp/parse-tree/lex.ll)
 * * [Octave parser](https://github.com/gnu-octave/octave/blob/default/libinterp/parse-tree/oct-parse.yy)
 * * [An ANTLR4 grammar for MATLAB files.](https://github.com/antlr/grammars-v4/tree/master/matlab)
 * * [mparser](https://www.mathworks.com/matlabcentral/fileexchange/32769-mparser)
 */
export default class MathJSLabParser extends Parser {
    static readonly GLOBAL = 1;
    static readonly PERSISTENT = 2;
    static readonly IF = 3;
    static readonly ENDIF = 4;
    static readonly END = 5;
    static readonly ENDRANGE = 6;
    static readonly ELSEIF = 7;
    static readonly ELSE = 8;
    static readonly SWITCH = 9;
    static readonly ENDSWITCH = 10;
    static readonly CASE = 11;
    static readonly OTHERWISE = 12;
    static readonly WHILE = 13;
    static readonly ENDWHILE = 14;
    static readonly DO = 15;
    static readonly UNTIL = 16;
    static readonly FOR = 17;
    static readonly ENDFOR = 18;
    static readonly PARFOR = 19;
    static readonly ENDPARFOR = 20;
    static readonly BREAK = 21;
    static readonly CONTINUE = 22;
    static readonly RETURN = 23;
    static readonly FUNCTION = 24;
    static readonly ENDFUNCTION = 25;
    static readonly TRY = 26;
    static readonly CATCH = 27;
    static readonly END_TRY_CATCH = 28;
    static readonly UNWIND_PROTECT = 29;
    static readonly UNWIND_PROTECT_CLEANUP = 30;
    static readonly END_UNWIND_PROTECT = 31;
    static readonly CLASSDEF = 32;
    static readonly ENDCLASSDEF = 33;
    static readonly ENUMERATION = 34;
    static readonly ENDENUMERATION = 35;
    static readonly PROPERTIES = 36;
    static readonly ENDPROPERTIES = 37;
    static readonly EVENTS = 38;
    static readonly ENDEVENTS = 39;
    static readonly METHODS = 40;
    static readonly ENDMETHODS = 41;
    static readonly WSPACE = 42;
    static readonly STRING = 43;
    static readonly ARGUMENTS = 44;
    static readonly PLUS = 45;
    static readonly MINUS = 46;
    static readonly MUL = 47;
    static readonly DIV = 48;
    static readonly EQ = 49;
    static readonly COLON = 50;
    static readonly SEMICOLON = 51;
    static readonly COMMA = 52;
    static readonly DOT = 53;
    static readonly TILDE = 54;
    static readonly EXCLAMATION = 55;
    static readonly COMMAT = 56;
    static readonly LPAREN = 57;
    static readonly RPAREN = 58;
    static readonly LBRACKET = 59;
    static readonly RBRACKET = 60;
    static readonly LCURLYBR = 61;
    static readonly RCURLYBR = 62;
    static readonly LEFTDIV = 63;
    static readonly ADD_EQ = 64;
    static readonly SUB_EQ = 65;
    static readonly MUL_EQ = 66;
    static readonly DIV_EQ = 67;
    static readonly LEFTDIV_EQ = 68;
    static readonly POW_EQ = 69;
    static readonly EMUL_EQ = 70;
    static readonly EDIV_EQ = 71;
    static readonly ELEFTDIV_EQ = 72;
    static readonly EPOW_EQ = 73;
    static readonly AND_EQ = 74;
    static readonly OR_EQ = 75;
    static readonly EXPR_AND_AND = 76;
    static readonly EXPR_OR_OR = 77;
    static readonly EXPR_AND = 78;
    static readonly EXPR_OR = 79;
    static readonly EXPR_LT = 80;
    static readonly EXPR_LE = 81;
    static readonly EXPR_EQ = 82;
    static readonly EXPR_NE = 83;
    static readonly EXPR_GE = 84;
    static readonly EXPR_GT = 85;
    static readonly EMUL = 86;
    static readonly EDIV = 87;
    static readonly ELEFTDIV = 88;
    static readonly PLUS_PLUS = 89;
    static readonly MINUS_MINUS = 90;
    static readonly POW = 91;
    static readonly EPOW = 92;
    static readonly TRANSPOSE = 93;
    static readonly HERMITIAN = 94;
    static readonly DQSTRING = 95;
    static readonly IDENTIFIER = 96;
    static readonly FLOAT_NUMBER = 97;
    static readonly NUMBER_DOT_OP = 98;
    static readonly SPACE_OR_CONTINUATION = 99;
    static readonly NEWLINE = 100;
    static readonly BLOCK_COMMENT_START = 101;
    static readonly COMMENT_LINE = 102;
    static readonly INVALID = 103;
    static readonly SINGLEQ_STRING = 104;
    static readonly SINGLEQ_NL = 105;
    static readonly SINGLEQ_SINGLEQ = 106;
    static readonly SINGLEQ_END = 107;
    static readonly DOUBLEQ_STRING = 108;
    static readonly DOUBLEQ_NL = 109;
    static readonly DOUBLEQ_DOUBLEQ = 110;
    static readonly DOUBLEQ_ESCAPE = 111;
    static readonly DOUBLEQ_ESCAPE_OTHER = 112;
    static readonly DOUBLEQ_ESCAPE_OCT = 113;
    static readonly DOUBLEQ_ESCAPE_HEX = 114;
    static readonly DOUBLEQ_ESCAPE_UNICODE = 115;
    static readonly DOUBLEQ_END = 116;
    static readonly BLOCK_COMMENT_START_AGAIN = 117;
    static readonly BLOCK_COMMENT_END = 118;
    static readonly BLOCK_COMMENT_LINE = 119;
    static readonly BLOCK_COMMENT_EOF = 120;
    static readonly SKIP_SPACE = 121;
    static readonly SKIP_COMMENT_LINE = 122;
    static readonly EXIT_AT_NEWLINE = 123;
    static readonly EXIT_AT_EOF = 124;
    static readonly UNQUOTED_STRING = 125;
    static readonly EOF: number;
    static readonly RULE_input = 0;
    static readonly RULE_global_list = 1;
    static readonly RULE_list = 2;
    static readonly RULE_statement = 3;
    static readonly RULE_word_list_cmd = 4;
    static readonly RULE_identifier = 5;
    static readonly RULE_string = 6;
    static readonly RULE_number = 7;
    static readonly RULE_end_range = 8;
    static readonly RULE_constant = 9;
    static readonly RULE_matrix = 10;
    static readonly RULE_matrix_row = 11;
    static readonly RULE_fcn_handle = 12;
    static readonly RULE_anon_fcn_handle = 13;
    static readonly RULE_primary_expr = 14;
    static readonly RULE_magic_colon = 15;
    static readonly RULE_magic_tilde = 16;
    static readonly RULE_list_element = 17;
    static readonly RULE_arg_list = 18;
    static readonly RULE_oper_expr = 19;
    static readonly RULE_power_expr = 20;
    static readonly RULE_colon_expr = 21;
    static readonly RULE_simple_expr = 22;
    static readonly RULE_expression = 23;
    static readonly RULE_command = 24;
    static readonly RULE_declaration = 25;
    static readonly RULE_declaration_element = 26;
    static readonly RULE_select_command = 27;
    static readonly RULE_if_command = 28;
    static readonly RULE_elseif_clause = 29;
    static readonly RULE_else_clause = 30;
    static readonly RULE_param_list = 31;
    static readonly RULE_param_list_elt = 32;
    static readonly RULE_return_list = 33;
    static readonly RULE_function = 34;
    static readonly RULE_arguments_block_list = 35;
    static readonly RULE_arguments_block = 36;
    static readonly RULE_args_validation_list = 37;
    static readonly RULE_arg_validation = 38;
    static readonly RULE_sep_no_nl = 39;
    static readonly RULE_nl = 40;
    static readonly RULE_sep = 41;
    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): FailedPredicateException;
    constructor(input: TokenStream);
    input(): InputContext;
    global_list(): Global_listContext;
    list(): ListContext;
    statement(): StatementContext;
    word_list_cmd(): Word_list_cmdContext;
    identifier(): IdentifierContext;
    string_(): StringContext;
    number_(): NumberContext;
    end_range(): End_rangeContext;
    constant(): ConstantContext;
    matrix(): MatrixContext;
    matrix_row(): Matrix_rowContext;
    fcn_handle(): Fcn_handleContext;
    anon_fcn_handle(): Anon_fcn_handleContext;
    primary_expr(): Primary_exprContext;
    magic_colon(): Magic_colonContext;
    magic_tilde(): Magic_tildeContext;
    list_element(): List_elementContext;
    arg_list(): Arg_listContext;
    oper_expr(): Oper_exprContext;
    oper_expr(_p: number): Oper_exprContext;
    power_expr(): Power_exprContext;
    power_expr(_p: number): Power_exprContext;
    colon_expr(): Colon_exprContext;
    simple_expr(): Simple_exprContext;
    simple_expr(_p: number): Simple_exprContext;
    expression(): ExpressionContext;
    command(): CommandContext;
    declaration(): DeclarationContext;
    declaration_element(): Declaration_elementContext;
    select_command(): Select_commandContext;
    if_command(): If_commandContext;
    elseif_clause(): Elseif_clauseContext;
    else_clause(): Else_clauseContext;
    param_list(): Param_listContext;
    param_list_elt(): Param_list_eltContext;
    return_list(): Return_listContext;
    function_(): FunctionContext;
    arguments_block_list(): Arguments_block_listContext;
    arguments_block(): Arguments_blockContext;
    args_validation_list(): Args_validation_listContext;
    arg_validation(): Arg_validationContext;
    sep_no_nl(): Sep_no_nlContext;
    nl(): NlContext;
    sep(): SepContext;
    sempred(localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private oper_expr_sempred;
    private power_expr_sempred;
    private simple_expr_sempred;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): ATN;
    static DecisionsToDFA: DFA[];
}
export declare class InputContext extends ParserRuleContext {
    node: AST.NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    EOF(): TerminalNode;
    sep(): SepContext;
    global_list(): Global_listContext;
    get ruleIndex(): number;
}
export declare class Global_listContext extends ParserRuleContext {
    node: AST.NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    statement_list(): StatementContext[];
    statement(i: number): StatementContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class ListContext extends ParserRuleContext {
    node: AST.NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    statement_list(): StatementContext[];
    statement(i: number): StatementContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class StatementContext extends ParserRuleContext {
    node: AST.NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    command(): CommandContext;
    word_list_cmd(): Word_list_cmdContext;
    get ruleIndex(): number;
}
export declare class Word_list_cmdContext extends ParserRuleContext {
    node: AST.NodeInput;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    string__list(): StringContext[];
    string_(i: number): StringContext;
    get ruleIndex(): number;
}
export declare class IdentifierContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    IDENTIFIER(): TerminalNode;
    get ruleIndex(): number;
}
export declare class StringContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    STRING(): TerminalNode;
    UNQUOTED_STRING(): TerminalNode;
    get ruleIndex(): number;
}
export declare class NumberContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    FLOAT_NUMBER(): TerminalNode;
    get ruleIndex(): number;
}
export declare class End_rangeContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ENDRANGE(): TerminalNode;
    get ruleIndex(): number;
}
export declare class ConstantContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    number_(): NumberContext;
    string_(): StringContext;
    end_range(): End_rangeContext;
    get ruleIndex(): number;
}
export declare class MatrixContext extends ParserRuleContext {
    node: AST.NodeExpr;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    matrix_row_list(): Matrix_rowContext[];
    matrix_row(i: number): Matrix_rowContext;
    nl_list(): NlContext[];
    nl(i: number): NlContext;
    SEMICOLON_list(): TerminalNode[];
    SEMICOLON(i: number): TerminalNode;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Matrix_rowContext extends ParserRuleContext {
    node: AST.NodeList | null;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    WSPACE_list(): TerminalNode[];
    WSPACE(i: number): TerminalNode;
    list_element_list(): List_elementContext[];
    list_element(i: number): List_elementContext;
    get ruleIndex(): number;
}
export declare class Fcn_handleContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMAT(): TerminalNode;
    identifier(): IdentifierContext;
    get ruleIndex(): number;
}
export declare class Anon_fcn_handleContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMAT(): TerminalNode;
    param_list(): Param_listContext;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Primary_exprContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    constant(): ConstantContext;
    fcn_handle(): Fcn_handleContext;
    matrix(): MatrixContext;
    LPAREN(): TerminalNode;
    expression(): ExpressionContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Magic_colonContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Magic_tildeContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    TILDE(): TerminalNode;
    get ruleIndex(): number;
}
export declare class List_elementContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    magic_colon(): Magic_colonContext;
    magic_tilde(): Magic_tildeContext;
    get ruleIndex(): number;
}
export declare class Arg_listContext extends ParserRuleContext {
    node: AST.NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    list_element_list(): List_elementContext[];
    list_element(i: number): List_elementContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Oper_exprContext extends ParserRuleContext {
    node: AST.NodeExpr;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    primary_expr(): Primary_exprContext;
    oper_expr_list(): Oper_exprContext[];
    oper_expr(i: number): Oper_exprContext;
    PLUS_PLUS(): TerminalNode;
    MINUS_MINUS(): TerminalNode;
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    TILDE(): TerminalNode;
    EXCLAMATION(): TerminalNode;
    MUL(): TerminalNode;
    DIV(): TerminalNode;
    LEFTDIV(): TerminalNode;
    EMUL(): TerminalNode;
    EDIV(): TerminalNode;
    ELEFTDIV(): TerminalNode;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    arg_list(): Arg_listContext;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    TRANSPOSE(): TerminalNode;
    HERMITIAN(): TerminalNode;
    DOT(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    expression(): ExpressionContext;
    power_expr(): Power_exprContext;
    POW(): TerminalNode;
    EPOW(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Power_exprContext extends ParserRuleContext {
    node: AST.NodeExpr;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    primary_expr(): Primary_exprContext;
    power_expr(): Power_exprContext;
    PLUS_PLUS(): TerminalNode;
    MINUS_MINUS(): TerminalNode;
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    TILDE(): TerminalNode;
    EXCLAMATION(): TerminalNode;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    arg_list(): Arg_listContext;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    DOT(): TerminalNode;
    IDENTIFIER(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Colon_exprContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    oper_expr_list(): Oper_exprContext[];
    oper_expr(i: number): Oper_exprContext;
    COLON_list(): TerminalNode[];
    COLON(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Simple_exprContext extends ParserRuleContext {
    node: AST.NodeExpr;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    oper_expr(): Oper_exprContext;
    colon_expr(): Colon_exprContext;
    simple_expr_list(): Simple_exprContext[];
    simple_expr(i: number): Simple_exprContext;
    EXPR_LT(): TerminalNode;
    EXPR_LE(): TerminalNode;
    EXPR_GT(): TerminalNode;
    EXPR_GE(): TerminalNode;
    EXPR_EQ(): TerminalNode;
    EXPR_NE(): TerminalNode;
    EXPR_AND(): TerminalNode;
    EXPR_OR(): TerminalNode;
    EXPR_AND_AND(): TerminalNode;
    EXPR_OR_OR(): TerminalNode;
    get ruleIndex(): number;
}
export declare class ExpressionContext extends ParserRuleContext {
    node: AST.NodeExpr;
    _op: Token;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    simple_expr(): Simple_exprContext;
    expression(): ExpressionContext;
    EQ(): TerminalNode;
    ADD_EQ(): TerminalNode;
    SUB_EQ(): TerminalNode;
    MUL_EQ(): TerminalNode;
    EMUL_EQ(): TerminalNode;
    DIV_EQ(): TerminalNode;
    EDIV_EQ(): TerminalNode;
    LEFTDIV_EQ(): TerminalNode;
    ELEFTDIV_EQ(): TerminalNode;
    POW_EQ(): TerminalNode;
    EPOW_EQ(): TerminalNode;
    AND_EQ(): TerminalNode;
    OR_EQ(): TerminalNode;
    anon_fcn_handle(): Anon_fcn_handleContext;
    get ruleIndex(): number;
}
export declare class CommandContext extends ParserRuleContext {
    node: AST.NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    declaration(): DeclarationContext;
    select_command(): Select_commandContext;
    function_(): FunctionContext;
    get ruleIndex(): number;
}
export declare class DeclarationContext extends ParserRuleContext {
    node: AST.NodeInput;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    GLOBAL(): TerminalNode;
    PERSISTENT(): TerminalNode;
    declaration_element_list(): Declaration_elementContext[];
    declaration_element(i: number): Declaration_elementContext;
    get ruleIndex(): number;
}
export declare class Declaration_elementContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Select_commandContext extends ParserRuleContext {
    node: AST.NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    if_command(): If_commandContext;
    get ruleIndex(): number;
}
export declare class If_commandContext extends ParserRuleContext {
    node: AST.NodeIf;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    IF(): TerminalNode;
    expression(): ExpressionContext;
    END(): TerminalNode;
    ENDIF(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    elseif_clause_list(): Elseif_clauseContext[];
    elseif_clause(i: number): Elseif_clauseContext;
    else_clause(): Else_clauseContext;
    get ruleIndex(): number;
}
export declare class Elseif_clauseContext extends ParserRuleContext {
    node: AST.NodeElseIf;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ELSEIF(): TerminalNode;
    expression(): ExpressionContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Else_clauseContext extends ParserRuleContext {
    node: AST.NodeElse;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ELSE(): TerminalNode;
    sep(): SepContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Param_listContext extends ParserRuleContext {
    node: AST.NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    param_list_elt_list(): Param_list_eltContext[];
    param_list_elt(i: number): Param_list_eltContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class Param_list_eltContext extends ParserRuleContext {
    node: AST.NodeExpr;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    declaration_element(): Declaration_elementContext;
    magic_tilde(): Magic_tildeContext;
    get ruleIndex(): number;
}
export declare class Return_listContext extends ParserRuleContext {
    node: AST.NodeExpr;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    LBRACKET(): TerminalNode;
    RBRACKET(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class FunctionContext extends ParserRuleContext {
    node: AST.NodeInput;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    FUNCTION(): TerminalNode;
    identifier(): IdentifierContext;
    END(): TerminalNode;
    ENDFUNCTION(): TerminalNode;
    EOF(): TerminalNode;
    return_list(): Return_listContext;
    EQ(): TerminalNode;
    param_list(): Param_listContext;
    sep(): SepContext;
    arguments_block_list(): Arguments_block_listContext;
    list(): ListContext;
    get ruleIndex(): number;
}
export declare class Arguments_block_listContext extends ParserRuleContext {
    node: AST.NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    arguments_block_list(): Arguments_blockContext[];
    arguments_block(i: number): Arguments_blockContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Arguments_blockContext extends ParserRuleContext {
    node: AST.NodeArguments;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    ARGUMENTS(): TerminalNode;
    args_validation_list(): Args_validation_listContext;
    END(): TerminalNode;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    LPAREN(): TerminalNode;
    identifier(): IdentifierContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
}
export declare class Args_validation_listContext extends ParserRuleContext {
    node: AST.NodeList;
    i: number;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    arg_validation_list(): Arg_validationContext[];
    arg_validation(i: number): Arg_validationContext;
    sep_list(): SepContext[];
    sep(i: number): SepContext;
    get ruleIndex(): number;
}
export declare class Arg_validationContext extends ParserRuleContext {
    node: AST.NodeArgumentValidation;
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    LPAREN(): TerminalNode;
    arg_list_list(): Arg_listContext[];
    arg_list(i: number): Arg_listContext;
    RPAREN(): TerminalNode;
    LCURLYBR(): TerminalNode;
    RCURLYBR(): TerminalNode;
    EQ(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
}
export declare class Sep_no_nlContext extends ParserRuleContext {
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    SEMICOLON_list(): TerminalNode[];
    SEMICOLON(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class NlContext extends ParserRuleContext {
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    NEWLINE_list(): TerminalNode[];
    NEWLINE(i: number): TerminalNode;
    get ruleIndex(): number;
}
export declare class SepContext extends ParserRuleContext {
    constructor(parser?: MathJSLabParser, parent?: ParserRuleContext, invokingState?: number);
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    SEMICOLON_list(): TerminalNode[];
    SEMICOLON(i: number): TerminalNode;
    NEWLINE_list(): TerminalNode[];
    NEWLINE(i: number): TerminalNode;
    get ruleIndex(): number;
}