qpremake 1.5.1

package/lib/_mods/parserModules/expression_parser.d.ts

@@ -0,0 +1,143 @@
+interface I_evaluator {
+    evaluate_unary(expr: UnaryExpression): Expression;
+    evaluate_binary(expr: BinaryExpression): Expression;
+    evaluate_ternary(expr: TernaryExpression): Expression;
+    evaluate_postfix(expr: PostfixExpression): Expression;
+    evaluate_value(expr: ValueExpression): Expression;
+}
+declare class Expression {
+    operator: Token;
+    operands: Expression[];
+    constructor(operator: Token, operands: Expression[]);
+    get numOperands(): number;
+    toString(): string;
+    protected get collapsible(): boolean;
+    evaluate(evaluator: I_evaluator): [Expression, boolean];
+}
+declare class ValueExpression extends Expression {
+    constructor(val: Token);
+}
+declare class UnaryExpression extends Expression {
+    constructor(operator: Token, operand: Expression);
+}
+declare class BinaryExpression extends Expression {
+    get left(): Expression;
+    get right(): Expression;
+    constructor(operator: Token, left: Expression, right: Expression);
+}
+declare class TernaryExpression extends Expression {
+    get cond(): Expression;
+    get left(): Expression;
+    get right(): Expression;
+    constructor(operator: Token, cond: Expression, left: Expression, right: Expression);
+}
+declare class PostfixExpression extends Expression {
+    constructor(operator: Token, left: Expression);
+}
+declare enum TokenType {
+    immutable = 0,
+    value_number = 1,
+    value_string = 2,
+    equals = 3,
+    not_equals = 4,
+    lesser = 5,
+    greater = 6,
+    lesser_or_equal = 7,
+    greater_or_equal = 8,
+    negation = 9,
+    or = 10,
+    and = 11,
+    shift_left = 12,
+    shift_right = 13,
+    plus = 14,
+    minus = 15,
+    mul = 16,
+    div = 17,
+    slice_or_round_to_precision = 18,//..
+    forced_concat = 19,
+    bracket_open = 20,
+    bracket_end = 21,
+    question_mark = 22,
+    colon = 23,
+    EOF = 24
+}
+declare enum StringEncapsulation {
+    double_quote = -100,
+    single_quote = -99,
+    tick_mark = -98
+}
+declare class Token {
+    readonly type: TokenType;
+    readonly str: string;
+    immutable?: any | undefined;
+    constructor(type: TokenType, str: string, immutable?: any | undefined);
+}
+interface I_Parser {
+    pop(): Token | undefined;
+    peek(): Token | undefined;
+    assertNext(type: TokenType): void;
+    nextPrecedence(): number;
+    next(precedence: number): Expression;
+}
+interface I_ParseRule_No_Pre {
+    parse(parser: I_Parser, token: Token): Expression;
+}
+interface I_ParseRule_Has_Pre {
+    parse(parser: I_Parser, left: Expression, token: Token): Expression;
+    get precedence(): number;
+}
+declare class Parser implements I_Parser, I_evaluator {
+    private TokenDictionary;
+    private allTokens;
+    constructor();
+    addToken(str: string, type: TokenType | StringEncapsulation): void;
+    private splitAndInsert;
+    private splitStringByTokens;
+    tokenize(expr: string | (string | any)[], coerseUnknownToString?: boolean): Token[];
+    private preparse_rule;
+    private normal_rule;
+    registerUnaryRule(token: TokenType): void;
+    registerBinaryRule(token: TokenType, precedence: Precedence): void;
+    registerValueRule(token: TokenType): void;
+    registerRule(noPre: true, token: TokenType, rule: I_ParseRule_No_Pre): void;
+    registerRule(noPre: false, token: TokenType, rule: I_ParseRule_Has_Pre): void;
+    private tokens;
+    pop(expect?: TokenType): Token | undefined;
+    assertNext(type: TokenType): void;
+    peek(): Token | undefined;
+    nextPrecedence(): number;
+    private errorStr;
+    parse(expr: Parameters<typeof this["tokenize"]>[0]): Expression[];
+    next(basePrecedence?: Precedence): Expression;
+    private num_var;
+    private string_var;
+    bindVariables(num_var: number[], string_var: string[]): void;
+    evaluate_value(expr: ValueExpression): Expression;
+    evaluate_unary(expr: UnaryExpression): Expression;
+    evaluate_binary(expr: BinaryExpression): Expression;
+    evaluate_ternary(expr: TernaryExpression): Expression;
+    evaluate_postfix(expr: PostfixExpression): Expression;
+    flattenExpressions<T>(exprs: Expression[]): (string | T)[];
+}
+/**
+ * Precedence is how far the rercursive call inside a rule is allowed to go
+ * the parser will keep consuming until the next precedence is lower than the starting value
+ * so if we pass in
+ * a) next(precedence of sum) -> everything lower than sum is consumed into the return result
+ * b) next(parser.nextPrecedence()) -> everything lower than the next expression's precedence is consumed
+ * */
+declare enum Precedence {
+    min = 0,
+    immutable = 1,
+    cond_right_associative = 2,
+    cond = 3,
+    slightly_less_than_arithmetic = 4,
+    sum = 5,
+    product = 6,
+    exponent = 7,
+    bit_manip = 8,
+    prefix = 9,
+    postfix = 10
+}
+declare const DefParser: Parser;
+export default DefParser;