Function parse_case_expr

src/cypher/cypher.c:1264–1311

Parse CASE WHEN ... THEN ... [ELSE ...] END */

/* Parse CASE WHEN ... THEN ... [ELSE ...] END */
static cbm_case_expr_t *parse_case_expr(parser_t *p) {
    /* CASE already consumed */
    cbm_case_expr_t *kase = calloc(CBM_ALLOC_ONE, sizeof(cbm_case_expr_t));
    if (!kase) {
        return NULL;
    }
    int bcap = CYP_INIT_CAP4;
    kase->branches = malloc(bcap * sizeof(cbm_case_branch_t));
    if (!kase->branches) {
        free(kase);
        return NULL;
    }

    while (check(p, TOK_WHEN)) {
        advance(p);
        cbm_expr_t *when = parse_or_expr(p);
        if (!expect(p, TOK_THEN)) {
            expr_free(when);
            break;
        }
        const char *then_val = parse_value_literal(p);
        if (kase->branch_count >= bcap) {
            int new_bcap = bcap * PAIR_LEN;
            void *tmp = realloc(kase->branches, new_bcap * sizeof(cbm_case_branch_t));
            if (!tmp) {
                expr_free(when);
                safe_str_free(&then_val);
                for (int i = 0; i < kase->branch_count; i++) {
                    expr_free(kase->branches[i].when_expr);
                    safe_str_free(&kase->branches[i].then_val);
                }
                free(kase->branches);
                free(kase);
                return NULL;
            }
            kase->branches = tmp;
            bcap = new_bcap;
        }
        kase->branches[kase->branch_count++] =
            (cbm_case_branch_t){.when_expr = when, .then_val = then_val};
    }

    if (match(p, TOK_ELSE)) {
        kase->else_val = parse_value_literal(p);
    }
    expect(p, TOK_END);
    return kase;
}

/* Parse a single RETURN/WITH item (aggregate, string func, CASE, or plain var.prop).
 * Returns 0 on success, -1 on error. */