tekBlueprint

<expression>          → <block> EOF
                      | <ternary-expression> EOF

<or-expression>       → <and-expression> ("||" <and-expression>)*

<and-expression>      → <equality-expression> ("&&" <equality-expression>)*

<ternary-expression>  → <or-expression> ("?" <or-expression> ":" <ternary-expression>)?

<equality-expression> → <relational-expression> (("==" | "!=") <relational-expression>)*

<relational-expression> → <additive-expression> (("<" | ">" | "<=" | ">=") <additive-expression>)?

<additive-expression>   → <multiplicative-expression> (("+" | "-") <multiplicative-expression>)*

<multiplicative-expression> → <unary-expression> (("*" | "/" | "%") <unary-expression>)*

<unary-expression>  → ("-" | "!") <unary-expression>
                    | <if-else-expression>

<if-else-expression> → <member-access>
                     | "if" "(" <expression-inner> ")" <block> ("else" (<block> | <if-else-expression>))?

<member-access>     → <primary> ("." <member-segment>)*

<grouped-expression>→ "(" <expression-inner> ")"

<primary>           → <grouped-expression>
                    | <function-call>
                    | <ref-expression>
                    | <number>
                    | <string-literal>
                    | "true" | "false"
                    | "null"
                    | <identifier>

<ref-expression>    → "ref" <string-literal>

<member-segment>    → <identifier> ("(" [<expression-inner> ("," <expression-inner>)*] ")")?

<function-call>     → <identifier> "(" [<expression-inner> ("," <expression-inner>)*] ")"

<block>             → "{" (<block-item>+ | <expression-inner>) "}"

<block-item>        → <if-else-expression> ";"?
                    | "return" <expression-inner> ";"
                    | <expression-inner> ";"

<expression-inner>  → <ternary-expression>

<number>            → <digit>+ ["." <digit>+ ] ([eE] [-|+] <digit>+)?
<string-literal>    → '"' <chars> '"' | '\'' <chars> '\''
<identifier>        → [a-zA-Z_] [a-zA-Z0-9_]*

// Simple arithmetic expression
2 * x + y / 3.14

// Conditional logic with ternary operator
status == "active" ? price * discount : price

// Block with if/else and early return
{
    if (count > 0) {
        return total / count;
    } else {
        return 0;
    }
}

// Condition chain via else if
if (level == "high") {
    priority = 1;
} else if (level == "medium") {
    priority = 2;
} else {
    priority = 3;
}

// Function call with object field access
statistics.probeBytesPerSecond * duration / 1024.0

// Safe casting -- returns default value on type mismatch
double d = value.toDouble(0.0);    // 0.0 if the value is not numeric
String s = value.toString("");      // "" if the value is null or void

// Strict access -- throws exception on type mismatch
int i = value.asInt32();            // error if type is not INT*
boolean b = value.asBoolean();      // error if type is not BOOL

// Pseudocode of optimization orchestrator
Node optimize(Node ast, OptimizationOptions options) {
    Node current = ast;
    for (int i = 0; i < options.maxPasses; i++) {
        Node previous = deepCopy(current);

        // Apply all enabled passes sequentially
        for (OptimizationPass pass : options.enabledPasses) {
            current = pass.optimize(current);
        }

        // Check structural equality -- if tree hasn't changed, exit
        if (AstComparator.equals(previous, current)) {
            break;
        }
    }
    return current;
}

// VM structure (based on ExpressionVm.java)
class ExpressionVm {
    byte[] tags;              // instruction opcodes (0–28)
    int[] operands;           // operand for each instruction
    double[] constants;       // numeric constant pool
    String[] strings;         // string literal pool
    Object[] objects;         // object pool (for ref expressions)

    String[] varNames;        // variable name table → index for LOAD_VAR
    String[] fnNames;         // function name table → index for CALL_FN

    double[] stack = new double[128];  // value stack
    byte[] types = new byte[128];      // stack element types

    // Inline cache: reuses resolved variables on repeated calls with the same context
    ExpressionContext cachedCtx;
    double[] cachedVarValues;
    byte[] cachedVarTypes;
}

// Compiler pseudocode (based on ExpressionVm.Compiler)
class Compiler {
    List<Integer> tags;       // opcode sequence
    List<Integer> operands;   // operands
    Map<Double, Integer> constantPool;     // number pool → index
    Map<String, Integer> stringPool;       // string pool → index
    Map<ObjectValue, Integer> objectPool;  // object (ref) pool → index
    Map<String, Integer> varPool;          // variable names → index
    Map<String, Integer> fnPool;           // function names → index

    void emit(Node node) {
        if (node instanceof NumberNode nn) {
            tags.add(PUSH_DOUBLE);
            operands.add(getConstantIndex(nn.getValue()));
        } else if (node instanceof VariableNode vn) {
            tags.add(LOAD_VAR);
            operands.add(getVarIndex(vn.getName()));
        } else if (node instanceof BinaryOpNode bin) {
            emit(bin.getLeft());
            emit(bin.getRight());
            tags.add(mapToOpcode(bin.getOp()));  // ADD, SUB, EQ, etc.
            operands.add(0);
        } else if (node instanceof TernaryNode tern) {
            emitTernary(tern);
        } else if (node instanceof FunctionCallNode fc) {
            for (var arg : fc.getArguments()) emit(arg);
            int fnIdx = getFnIndex(fc.getName());
            tags.add(CALL_FN);
            operands.add((fnIdx << 16) | (fc.getArguments().length & 0xFFFF));
        } else if (node instanceof ReturnNode rn) {
            emit(rn.getExpression());
            tags.add(RETURN_VALUE);
            operands.add(0);
        }
        // ... remaining nodes: BooleanNode→PUSH_BOOL, StringNode→PUSH_STRING,
        //     NullNode→PUSH_NULL, RefNode→PUSH_OBJ, IfElseNode, BlockNode, SwitchNode
    }

    void emitTernary(TernaryNode tern) {
        emit(tern.getCondition());
        int branchIdx = operands.size();
        tags.add(TERNARY_BRANCH);
        operands.add(-1);          // placeholder
        emit(tern.getTrueBranch());
        int jumpIdx = operands.size();
        tags.add(JUMP);
        operands.add(-1);          // placeholder
        int falseStart = tags.size();
        operands.set(branchIdx, falseStart);  // patch branch target
        emit(tern.getFalseBranch());
        operands.set(jumpIdx, tags.size());   // patch jump to end
    }
}

// Pseudocode (based on ExpressionVm.execute)
ExpressionValue execute(ExpressionContext ctx) {
    if (cacheValid && ctx == cachedCtx) {
        // Same context object -- reuse resolved variables, skip HashMap lookup
        varValues = cachedVarValues;
        varTypes = cachedVarTypes;
    } else {
        // Resolve all variables once via HashMap → array
        for (int i = 0; i < varNames.length; i++) {
            ExpressionValue v = ctx.getVariable(varNames[i]);
            switch (v.getType()) {
                case BOOL:
                    varValues[i] = v.asBoolean() ? 1.0 : 0.0;
                    varTypes[i] = T_BOOL;
                    break;
                case STRING:
                    int sIdx = indexOfString(v.asString());
                    if (sIdx < 0) sIdx = addDynamicString(v.asString());
                    varValues[i] = (double) sIdx;
                    varTypes[i] = T_STRING;
                    break;
                // ... NULL, VOID, OBJECT -- similar mapping to stack type + pool index
                default:
                    varValues[i] = v.toDouble();
                    varTypes[i] = T_DOUBLE;
            }
        }
        cachedCtx = ctx;
        cachedVarValues = varValues;
        cachedVarTypes = varTypes;
        cacheValid = true;
    }
}

// Pseudocode (based on ExpressionVm.execute)
ExpressionValue execute(ExpressionContext ctx) {
    int sp = 0;   // stack pointer
    int pc = 0;   // program counter

    while (pc < tags.length) {
        switch (tags[pc]) {
            case PUSH_DOUBLE:
                stack[sp] = constants[operands[pc]];
                types[sp] = T_DOUBLE;
                sp++;
                pc++;
                break;

            case LOAD_VAR: {
                int vi = operands[pc];  // variable index in resolved array
                stack[sp] = varValues[vi];
                types[sp] = varTypes[vi];
                sp++;
                pc++;
                break;
            }

            case ADD: {
                int tb = --sp, ta = --sp;
                if (types[tb] == T_STRING && types[ta] == T_STRING) {
                    // String concatenation via string pool indices with deduplication
                    String concat = getStringAt((int) stack[ta]) + getStringAt((int) stack[tb]);
                    int idx = indexOfString(concat);
                    if (idx < 0) idx = addDynamicString(concat);
                    stack[sp] = (double) idx;
                    types[sp] = T_STRING;
                } else {
                    stack[sp] = stack[ta] + stack[tb];
                    types[sp] = T_DOUBLE;
                }
                sp++;
                pc++;
                break;
            }

            // ... SUB, MUL, DIV, MOD -- same pattern: pop two operands → operation → push result
            // ... EQ, NEQ, LT, GT, LTE, GTE -- comparison with type awareness (NULL, VOID, strings, objects)
            // ... AND, OR, NOT, NEG -- logical operations

            case TERNARY_BRANCH: {
                --sp;  // pop condition
                if (stack[sp] == 0.0) {
                    pc = operands[pc];  // jump to else-branch
                } else {
                    pc++;               // fall through to then-branch
                }
                break;
            }

            case JUMP:
                pc = operands[pc];
                break;

            case CALL_FN: {
                int encoded = operands[pc];
                int fnIdx = encoded >>> 16;
                int argCount = encoded & 0xFFFF;
                // Pop arguments from stack in reverse order (LIFO)
                ExpressionValue[] args = new ExpressionValue[argCount];
                for (int i = argCount - 1; i >= 0; i--) {
                    int idx = --sp;
                    args[i] = toFormulaValue(stack[idx], types[idx]);
                }
                ExpressionValue result = ctx.findFunction(fnNames[fnIdx]).call(args);
                // Map result to stack type (BOOL→1.0/0.0, STRING→pool index, etc.)
                pushResult(result, sp);  // see ExpressionVm.java:551-583
                pc++;
                break;
            }

            case RETURN_VALUE: {
                ExpressionValue ret = toFormulaValue(stack[sp - 1], types[sp - 1]);
                ctx.setReturn(ret);  // set return value for early block exit
                return ret;
            }
        }
    }
    // If execution reaches the end without RETURN -- return top stack element
    return toFormulaValue(stack[sp - 1], types[sp - 1]);
}