/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 18 сент. 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include namespace lsp { namespace expr { void parse_destroy(expr_t *expr) { if (expr == NULL) return; expr->eval = NULL; switch (expr->type) { case ET_VALUE: if (expr->value.type == VT_STRING) { delete expr->value.v_str; expr->value.v_str = NULL; } break; case ET_RESOLVE: if (expr->resolve.items != NULL) { for (size_t i=0, n=expr->resolve.count; iresolve.items[i]); ::free(expr->resolve.items); expr->resolve.items = NULL; } if (expr->resolve.name != NULL) { delete expr->resolve.name; expr->resolve.name = NULL; } break; case ET_CALL: if (expr->call.items != NULL) { for (size_t i=0, n=expr->call.count; icall.items[i]); ::free(expr->call.items); expr->call.items = NULL; } if (expr->call.name != NULL) { delete expr->call.name; expr->call.name = NULL; } break; case ET_CALC: parse_destroy(expr->calc.left); expr->calc.left = NULL; parse_destroy(expr->calc.right); expr->calc.right = NULL; parse_destroy(expr->calc.cond); expr->calc.cond = NULL; break; default: break; } // Free the expression ::free(expr); } expr_t *parse_create_expr() { return reinterpret_cast(::malloc(sizeof(expr_t))); } void drop_indexes(lltl::parray *indexes) { for (size_t i=0, n=indexes->size(); iuget(i)); indexes->flush(); } status_t parse_identifier(expr_t **expr, Tokenizer *t, size_t flags) { // Get identifier expr_t *bind = NULL; token_t tok = t->get_token(flags); if ((tok != TT_IDENTIFIER) && (!(flags & TF_BAREWORD))) return STATUS_BAD_TOKEN; LSPString *id = t->text_value()->clone(); if (id == NULL) return STATUS_NO_MEM; // Lookup for indexes lltl::parray indexes; while ((tok = t->get_token(TF_GET | TF_XSIGN)) == TT_LQBRACE) { // Brace, analyze next token tok = t->get_token(TF_GET); if (tok == TT_BAREWORD) { // Store the bareword LSPString *name = t->text_value()->clone(); if (name == NULL) { drop_indexes(&indexes); delete id; return STATUS_NO_MEM; } // Next token should be TT_RQBRACE tok = t->get_token(TF_GET); if (tok != TT_RQBRACE) { drop_indexes(&indexes); delete id; return STATUS_BAD_TOKEN; } // Create new expression bind = parse_create_expr(); if (bind == NULL) { drop_indexes(&indexes); delete name; delete id; return STATUS_NO_MEM; } // Simple variable get bind->eval = eval_resolve; bind->type = ET_RESOLVE; bind->resolve.name = name; bind->resolve.count = 0; bind->resolve.items = NULL; } else { // Parse the expression in square brackets status_t res = parse_expression(&bind, t, TF_NONE); // Token already has been taken if (res != STATUS_OK) { drop_indexes(&indexes); delete id; return res; } // Next token should be TT_RQBRACE tok = t->get_token(TF_NONE); if (tok != TT_RQBRACE) { parse_destroy(bind); drop_indexes(&indexes); delete id; return STATUS_BAD_TOKEN; } } // Add binding to list of indexes if (!indexes.add(bind)) { parse_destroy(bind); drop_indexes(&indexes); delete id; return STATUS_NO_MEM; } } // while // Create expression bind = parse_create_expr(); if (bind == NULL) { drop_indexes(&indexes); delete id; return STATUS_NO_MEM; } bind->eval = eval_resolve; bind->type = ET_RESOLVE; bind->resolve.name = id; bind->resolve.count = indexes.size(); bind->resolve.items = indexes.release(); *expr = bind; return STATUS_OK; } status_t parse_call(expr_t **expr, Tokenizer *t, size_t flags) { // Get identifier token_t tok = t->get_token(flags); if (tok != TT_BAREWORD) return STATUS_BAD_TOKEN; // Get function name LSPString *id = t->text_value()->clone(); if (id == NULL) return STATUS_NO_MEM; lsp_finally { if (id != NULL) delete id; }; // Require opening brace tok = t->get_token(TF_GET); if (tok != TT_LBRACE) return (tok == TT_EOF) ? STATUS_EOF : STATUS_BAD_TOKEN; // Parse list of arguments expr_t *bind = NULL; lltl::parray args; lsp_finally { for (size_t i=0, n=args.size(); iget_token(TF_NONE); switch (tok) { case TT_COMMA: case TT_RBRACE: if (!args.add(bind)) { parse_destroy(bind); return STATUS_NO_MEM; } bind = NULL; break; case TT_EOF: return STATUS_EOF; default: return STATUS_BAD_TOKEN; } } while (tok != TT_RBRACE); // Get next token for caller t->get_token(TF_GET); // Create resulting expression bind = parse_create_expr(); if (bind == NULL) return STATUS_NO_MEM; bind->eval = eval_call; bind->type = ET_CALL; bind->call.name = release_ptr(id); bind->call.count = args.size(); bind->call.items = args.release(); *expr = bind; return STATUS_OK; } status_t parse_primary(expr_t **expr, Tokenizer *t, size_t flags) { token_t tok = t->get_token(flags); switch (tok) { case TT_IDENTIFIER: return parse_identifier(expr, t, TF_NONE); case TT_IVALUE: { expr_t *bind = parse_create_expr(); if (bind == NULL) return STATUS_NO_MEM; ssize_t ivalue = t->int_value(); bind->eval = eval_value; bind->type = ET_VALUE; if (t->get_token(TF_GET | TF_XSIGN) == TT_DB) { bind->value.type = VT_FLOAT; bind->value.v_float = exp(ivalue * M_LN10 * 0.05); t->get_token(TF_GET | TF_XSIGN); } else { bind->value.type = VT_INT; bind->value.v_int = ivalue; } *expr = bind; break; } case TT_FVALUE: { expr_t *bind = parse_create_expr(); if (bind == NULL) return STATUS_NO_MEM; double fvalue = t->float_value(); bind->eval = eval_value; bind->type = ET_VALUE; bind->value.type = VT_FLOAT; if (t->get_token(TF_GET | TF_XSIGN) == TT_DB) { bind->value.v_float = exp(fvalue * M_LN10 * 0.05); t->get_token(TF_GET | TF_XSIGN); } else bind->value.v_float = fvalue; *expr = bind; break; } case TT_STRING: case TT_TRUE: case TT_FALSE: case TT_PI: case TT_E: case TT_NULL: case TT_UNDEF: { expr_t *bind = parse_create_expr(); if (bind == NULL) return STATUS_NO_MEM; bind->eval = eval_value; bind->type = ET_VALUE; switch (tok) { case TT_STRING: bind->value.type = VT_STRING; bind->value.v_str = t->text_value()->clone(); if (bind->value.v_str != NULL) break; ::free(bind); return STATUS_NO_MEM; case TT_TRUE: bind->value.type = VT_BOOL; bind->value.v_bool = true; break; case TT_FALSE: bind->value.type = VT_BOOL; bind->value.v_bool = false; break; case TT_PI: bind->value.type = VT_FLOAT; bind->value.v_float = M_PI; break; case TT_E: bind->value.type = VT_FLOAT; bind->value.v_float = M_E; break; case TT_NULL: bind->value.type = VT_NULL; break; case TT_UNDEF: bind->value.type = VT_UNDEF; break; default: break; } *expr = bind; t->get_token(TF_GET | TF_XSIGN); return STATUS_OK; } case TT_LBRACE: { expr_t *bind = NULL; status_t res = parse_expression(&bind, t, TF_GET); if (res != STATUS_OK) return res; tok = t->get_token(TF_NONE); if (tok == TT_RBRACE) { t->get_token(TF_GET | TF_XSIGN); *expr = bind; return res; } parse_destroy(bind); return STATUS_BAD_TOKEN; } case TT_EOF: return STATUS_EOF; default: return STATUS_BAD_TOKEN; } return STATUS_OK; } status_t parse_func(expr_t **expr, Tokenizer *t, size_t flags) { // Check token token_t func = t->get_token(flags); // Parse right part status_t res; expr_t *right = NULL; switch (func) { case TT_EX: case TT_DB: case TT_SUPR: case TT_SLWR: case TT_SLEN: case TT_SREV: case TT_INT: case TT_FLOAT: case TT_BOOL: case TT_STR: case TT_SIN: case TT_COS: case TT_TAN: case TT_ASIN: case TT_ACOS: case TT_ATAN: case TT_LOGE: case TT_LOGD: case TT_LOG2: case TT_EXP: case TT_SQRT: case TT_RAD: case TT_DEG: case TT_ABS: { // Check that LBRACE is present token_t tok = t->get_token(TF_GET); if (tok == TT_EOF) return STATUS_EOF; if (tok == TT_LBRACE) { // Parse sub-expression res = parse_expression(&right, t, TF_GET); if (res == STATUS_OK) { // Require right brace tok = t->get_token(TF_NONE); if (tok != TT_RBRACE) return (tok == TT_EOF) ? STATUS_EOF : STATUS_BAD_TOKEN; // Force to get next token t->get_token(TF_GET); } } else res = parse_func(&right, t, TF_NONE); break; } case TT_BAREWORD: return parse_call(expr, t, TF_NONE); default: return parse_primary(expr, t, TF_NONE); } if (res != STATUS_OK) return res; // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(right); return STATUS_NO_MEM; } switch (func) { case TT_EX: bind->eval = eval_exists; break; case TT_DB: bind->eval = eval_db; break; case TT_SUPR: bind->eval = eval_strupper; break; case TT_SLWR: bind->eval = eval_strlower; break; case TT_SLEN: bind->eval = eval_strlen; break; case TT_SREV: bind->eval = eval_strrev; break; case TT_INT: bind->eval = eval_int_cast; break; case TT_FLOAT: bind->eval = eval_float_cast; break; case TT_BOOL: bind->eval = eval_bool_cast; break; case TT_STR: bind->eval = eval_string_cast; break; case TT_SIN: bind->eval = eval_sin; break; case TT_COS: bind->eval = eval_cos; break; case TT_TAN: bind->eval = eval_tan; break; case TT_ASIN: bind->eval = eval_asin; break; case TT_ACOS: bind->eval = eval_acos; break; case TT_ATAN: bind->eval = eval_atan; break; case TT_LOGE: bind->eval = eval_loge; break; case TT_LOGD: bind->eval = eval_logd; break; case TT_LOG2: bind->eval = eval_log2; break; case TT_EXP: bind->eval = eval_exp; break; case TT_SQRT: bind->eval = eval_sqrt; break; case TT_RAD: bind->eval = eval_rad; break; case TT_DEG: bind->eval = eval_deg; break; case TT_ABS: bind->eval = eval_abs; break; default: bind->eval = NULL; break; } bind->type = ET_CALC; bind->calc.left = right; bind->calc.right = NULL; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_sign(expr_t **expr, Tokenizer *t, size_t flags) { // Check token token_t tok = t->get_token(flags); // Parse right part status_t res; expr_t *right = NULL; switch(tok) { case TT_ADD: case TT_SUB: if ((res = parse_sign(&right, t, TF_GET)) != STATUS_OK) return res; break; default: return parse_func(expr, t, TF_NONE); } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(right); return STATUS_NO_MEM; } switch (tok) { case TT_ADD: bind->eval = eval_psign; break; case TT_SUB: bind->eval = eval_nsign; break; default: bind->eval = NULL; break; } bind->type = ET_CALC; bind->calc.left = right; bind->calc.right = NULL; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_not(expr_t **expr, Tokenizer *t, size_t flags) { // Check token token_t tok = t->get_token(flags); // Parse right part status_t res; expr_t *right = NULL; switch (tok) { case TT_NOT: case TT_BNOT: if ((res = parse_not(&right, t, TF_GET)) != STATUS_OK) return res; break; default: return parse_sign(expr, t, TF_NONE); } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(right); return STATUS_NO_MEM; } bind->eval = (tok == TT_NOT) ? eval_not : eval_neg; bind->type = ET_CALC; bind->calc.left = right; bind->calc.right = NULL; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_power(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_not(&left, t, flags); if (res != STATUS_OK) return res; while (true) { // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_POW) { *expr = left; return STATUS_OK; } // Parse right part res = parse_not(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_power; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; left = bind; } } status_t parse_muldiv(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_power(&left, t, flags); if (res != STATUS_OK) return res; while (true) { // Check token token_t tok = t->get_token(TF_NONE); switch (tok) { case TT_MUL: case TT_DIV: case TT_IMUL: case TT_IDIV: case TT_FMOD: case TT_IMOD: break; default: *expr = left; return res; } // Parse right part res = parse_power(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } switch (tok) { case TT_MUL: bind->eval = eval_mul; break; case TT_DIV: bind->eval = eval_div; break; case TT_IMUL: bind->eval = eval_imul; break; case TT_IDIV: bind->eval = eval_idiv; break; case TT_FMOD: bind->eval = eval_fmod; break; case TT_IMOD: bind->eval = eval_imod; break; default: bind->eval = NULL; break; } bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; // Update left expression left = bind; } } status_t parse_addsub(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_muldiv(&left, t, flags); if (res != STATUS_OK) return res; // Parse right part while (true) { // Check token token_t tok = t->get_token(TF_NONE); switch (tok) { case TT_ADD: case TT_SUB: case TT_ADDSYM: case TT_SUBSYM: case TT_IADD: case TT_ISUB: break; default: *expr = left; return res; } // Parse right expression res = parse_muldiv(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } switch (tok) { case TT_ADD: bind->eval = eval_add; break; case TT_SUB: bind->eval = eval_sub; break; case TT_ADDSYM: bind->eval = eval_add; break; case TT_SUBSYM: bind->eval = eval_sub; break; case TT_IADD: bind->eval = eval_iadd; break; case TT_ISUB: bind->eval = eval_isub; break; default: bind->eval = NULL; break; } bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; // Update left expression left = bind; } } status_t parse_strrep(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_addsub(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_SREP) { *expr = left; return res; } // Parse right part res = parse_addsub(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->type = ET_CALC; bind->eval = eval_strrep; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_strcat(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_strrep(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_SCAT) { *expr = left; return res; } // Parse right part res = parse_strcat(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->type = ET_CALC; bind->eval = eval_strcat; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_cmp_rel(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_strcat(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); switch (tok) { case TT_LESS: case TT_GREATER: case TT_LESS_EQ: case TT_GREATER_EQ: case TT_ILESS: case TT_IGREATER: case TT_ILESS_EQ: case TT_IGREATER_EQ: break; default: *expr = left; return res; } // Parse right part res = parse_cmp_rel(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } switch (tok) { case TT_LESS: bind->eval = eval_cmp_lt; break; case TT_GREATER: bind->eval = eval_cmp_gt; break; case TT_LESS_EQ: bind->eval = eval_cmp_le; break; case TT_GREATER_EQ: bind->eval = eval_cmp_ge; break; case TT_ILESS: bind->eval = eval_icmp_lt; break; case TT_IGREATER: bind->eval = eval_icmp_gt; break; case TT_ILESS_EQ: bind->eval = eval_icmp_le; break; case TT_IGREATER_EQ: bind->eval = eval_icmp_ge; break; default: bind->eval = NULL; break; } bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_cmp_eq(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_cmp_rel(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); switch (tok) { case TT_NOT_EQ: case TT_EQ: case TT_CMP: case TT_INOT_EQ: case TT_IEQ: case TT_ICMP: break; default: *expr = left; return res; } // Parse right part res = parse_cmp_eq(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } switch (tok) { case TT_NOT_EQ: bind->eval = eval_cmp_ne; break; case TT_EQ: bind->eval = eval_cmp_eq; break; case TT_CMP: bind->eval = eval_cmp; break; case TT_INOT_EQ: bind->eval = eval_icmp_ne; break; case TT_IEQ: bind->eval = eval_icmp_eq; break; case TT_ICMP: bind->eval = eval_icmp; break; default: bind->eval = NULL; break; } bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_bit_and(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_cmp_eq(&left, t, flags); if (res != STATUS_OK) return res; // Check token while (true) { token_t tok = t->get_token(TF_NONE); if (tok != TT_BAND) { *expr = left; return STATUS_OK; } // Parse right part res = parse_cmp_eq(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_bit_and; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; // Store left left = bind; } return STATUS_OK; } status_t parse_bit_xor(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_bit_and(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_BXOR) { *expr = left; return STATUS_OK; } // Parse right part res = parse_bit_xor(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_bit_xor; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_bit_or(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_bit_xor(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_BOR) { *expr = left; return STATUS_OK; } // Parse right part res = parse_bit_or(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_bit_or; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_and(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_bit_or(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_AND) { *expr = left; return STATUS_OK; } // Parse right part res = parse_and(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_and; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_xor(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_and(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_XOR) { *expr = left; return res; } // Parse right part res = parse_xor(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_xor; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_or(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *left = NULL, *right = NULL; // Parse left part status_t res = parse_xor(&left, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_OR) { *expr = left; return STATUS_OK; } // Parse right part res = parse_or(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_or; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = NULL; *expr = bind; return STATUS_OK; } status_t parse_ternary(expr_t **expr, Tokenizer *t, size_t flags) { expr_t *cond = NULL, *left = NULL, *right = NULL; // Parse condition part status_t res = parse_or(&cond, t, flags); if (res != STATUS_OK) return res; // Check token token_t tok = t->get_token(TF_NONE); if (tok != TT_QUESTION) { *expr = cond; return res; } // Parse left part res = parse_ternary(&left, t, TF_GET); if (res != STATUS_OK) { parse_destroy(cond); return res; } // Check token tok = t->get_token(TF_NONE); if (tok != TT_COLON) { parse_destroy(cond); return res; } // Parse right part res = parse_ternary(&right, t, TF_GET); if (res != STATUS_OK) { parse_destroy(cond); parse_destroy(left); return res; } // Create binding between left and right expr_t *bind = parse_create_expr(); if (bind == NULL) { parse_destroy(cond); parse_destroy(left); parse_destroy(right); return STATUS_NO_MEM; } bind->eval = eval_ternary; bind->type = ET_CALC; bind->calc.left = left; bind->calc.right = right; bind->calc.cond = cond; *expr = bind; return STATUS_OK; } status_t parse_expression(expr_t **expr, Tokenizer *t, size_t flags) { return parse_ternary(expr, t, flags); } } /* namespace expr */ } /* namespace lsp */