/* * 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 { #define INT_OP(eval_name, oper) \ status_t eval_name(value_t *value, const expr_t *expr, eval_env_t *env) \ { \ status_t res = expr->calc.left->eval(value, expr->calc.left, env); \ if (res != STATUS_OK) \ return res; \ \ cast_int(value); \ if (value->type == VT_UNDEF) \ return STATUS_OK; \ else if (value->type == VT_NULL) \ { \ value->type = VT_UNDEF; \ return STATUS_OK; \ } \ \ value_t right; \ init_value(&right); \ res = expr->calc.right->eval(&right, expr->calc.right, env); \ if (res != STATUS_OK) \ { \ destroy_value(&right); \ destroy_value(value); \ return res; \ } \ \ cast_int(&right); \ switch (right.type) \ { \ case VT_INT: value->v_int = value->v_int oper right.v_int; break; \ case VT_NULL: value->type = VT_UNDEF; break; \ case VT_UNDEF: value->type = VT_UNDEF; break; \ default: res = STATUS_BAD_TYPE; break; \ } \ \ if (res != STATUS_OK) \ destroy_value(value); \ destroy_value(&right); \ \ return res; \ } status_t eval_add(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_numeric(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_numeric(&right); switch (right.type) { case VT_INT: if (value->type == VT_INT) value->v_int = value->v_int + right.v_int; else value->v_float = value->v_float + right.v_int; break; case VT_FLOAT: if (value->type == VT_INT) value->v_float = value->v_int + right.v_float; else value->v_float = value->v_float + right.v_float; value->type = VT_FLOAT; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } status_t eval_sub(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_numeric(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_numeric(&right); switch (right.type) { case VT_INT: if (value->type == VT_INT) value->v_int = value->v_int - right.v_int; else value->v_float = value->v_float - double(right.v_int); break; case VT_FLOAT: if (value->type == VT_INT) value->v_float = double(value->v_int) - right.v_float; else value->v_float = value->v_float - right.v_float; value->type = VT_FLOAT; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } status_t eval_mul(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_numeric(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_numeric(&right); switch (right.type) { case VT_INT: if (value->type == VT_INT) value->v_int = value->v_int * right.v_int; else value->v_float = value->v_float * double(right.v_int); break; case VT_FLOAT: if (value->type == VT_INT) value->v_float = double(value->v_int) * right.v_float; else value->v_float = value->v_float * right.v_float; value->type = VT_FLOAT; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } status_t eval_div(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_numeric(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_numeric(&right); switch (right.type) { case VT_INT: if (value->type == VT_INT) { if (right.v_int != 0) value->v_int = value->v_int / right.v_int; else value->type = VT_UNDEF; } else value->v_float = value->v_float / double(right.v_int); break; case VT_FLOAT: if (value->type == VT_INT) value->v_float = double(value->v_int) / right.v_float; else value->v_float = value->v_float / right.v_float; value->type = VT_FLOAT; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } INT_OP(eval_iadd, + ); INT_OP(eval_isub, - ); INT_OP(eval_imul, * ); INT_OP(eval_idiv, / ); INT_OP(eval_bit_or, | ); INT_OP(eval_bit_and, & ); INT_OP(eval_bit_xor, ^ ); status_t eval_imod(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_int(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_int(&right); switch (right.type) { case VT_INT: if (right.v_int != 0) value->v_int = value->v_int % right.v_int; else value->type = VT_UNDEF; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } status_t eval_fmod(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_float(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_float(&right); switch (right.type) { case VT_FLOAT: value->v_float = fmod(value->v_float, right.v_float); break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } status_t eval_xor(value_t *value, const expr_t *expr, eval_env_t *env) { // Test left argument status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; value_t right; init_value(&right); res = cast_bool(value); if (res == STATUS_OK) res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } // Test right argument res = cast_bool(&right); if (res == STATUS_OK) value->v_bool = !(value->v_bool == right.v_bool); else destroy_value(value); destroy_value(&right); return res; } status_t eval_or(value_t *value, const expr_t *expr, eval_env_t *env) { // Test left argument status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; res = cast_bool(value); if (res != STATUS_OK) { destroy_value(value); return res; } else if (value->v_bool) return STATUS_OK; // Test right argument destroy_value(value); res = expr->calc.right->eval(value, expr->calc.right, env); if (res != STATUS_OK) return res; res = cast_bool(value); if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_and(value_t *value, const expr_t *expr, eval_env_t *env) { // Test left argument status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; res = cast_bool(value); if (res != STATUS_OK) { destroy_value(value); return res; } else if (!value->v_bool) return STATUS_OK; // Test right argument destroy_value(value); res = expr->calc.right->eval(value, expr->calc.right, env); if (res != STATUS_OK) return res; res = cast_bool(value); if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_cmp(value_t *value, const expr_t *expr, eval_env_t *env) { // Fetch left argument and test for UNDEF status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; // Fetch right argument and test for UNDEF value_t right; init_value(&right); lsp_finally { destroy_value(&right); }; res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(value); return res; } if (value->type == VT_UNDEF) { set_value_int(value, (right.type == VT_UNDEF) ? 0 : -1); return STATUS_OK; } else if (right.type == VT_UNDEF) { set_value_int(value, 1); return STATUS_OK; } // Prevent from NULLs if (value->type == VT_NULL) { set_value_int(value, (right.type == VT_NULL) ? 0 : -1); return STATUS_OK; } else if (right.type == VT_NULL) { set_value_int(value, 1); return STATUS_OK; } // Perform comparison matrix switch (value->type) { case VT_INT: { switch (right.type) { case VT_INT: value->v_int = (value->v_int < right.v_int) ? -1 : (value->v_int > right.v_int) ? 1 : 0; break; case VT_FLOAT: value->v_int = (double(value->v_int) < right.v_float) ? -1 : (double(value->v_int) > right.v_float) ? 1 : 0; break; case VT_BOOL: { ssize_t ivalue = (value->v_bool) ? 1 : 0; value->v_int = (value->v_int < ivalue) ? -1 : (value->v_int > ivalue) ? 1 : 0; break; } case VT_STRING: { res = cast_string(value); if (res == STATUS_OK) { ssize_t ivalue = value->v_str->compare_to(right.v_str); destroy_value(value); value->type = VT_INT; value->v_int = ivalue; } break; } default: res = STATUS_BAD_TYPE; break; } // switch (int) break; } case VT_FLOAT: { switch (right.type) { case VT_INT: value->type = VT_INT; value->v_int = (value->v_float < right.v_int) ? -1 : (value->v_float > right.v_int) ? 1 : 0; break; case VT_FLOAT: value->type = VT_INT; value->v_int = (value->v_float < right.v_float) ? -1 : (value->v_float > right.v_float) ? 1 : 0; break; case VT_BOOL: { ssize_t ivalue = (value->v_bool) ? 1 : 0; value->type = VT_INT; value->v_int = (value->v_float < ivalue) ? -1 : (value->v_float > ivalue) ? 1 : 0; break; } case VT_STRING: { res = cast_string(value); if (res == STATUS_OK) { ssize_t ivalue = value->v_str->compare_to(right.v_str); destroy_value(value); value->type = VT_INT; value->v_int = ivalue; } break; } default: res = STATUS_BAD_TYPE; break; } // switch (float) break; } case VT_BOOL: { ssize_t xvalue = (value->v_bool) ? 1 : 0; switch (right.type) { case VT_INT: value->type = VT_INT; value->v_int = (xvalue < right.v_int) ? -1 : (xvalue > right.v_int) ? 1 : 0; break; case VT_FLOAT: value->type = VT_INT; value->v_int = (xvalue < right.v_float) ? -1 : (xvalue > right.v_float) ? 1 : 0; break; case VT_BOOL: { ssize_t ivalue = (value->v_bool) ? 1 : 0; value->type = VT_INT; value->v_int = (xvalue < ivalue) ? -1 : (xvalue > ivalue) ? 1 : 0; break; } case VT_STRING: { res = cast_string(value); if (res == STATUS_OK) { ssize_t ivalue = value->v_str->compare_to(right.v_str); destroy_value(value); value->type = VT_INT; value->v_int = ivalue; } break; } default: res = STATUS_BAD_TYPE; break; } // switch (float) break; } case VT_STRING: { res = cast_string(&right); if (res == STATUS_OK) { ssize_t ivalue = value->v_str->compare_to(right.v_str); set_value_int(value, ivalue); } break; } default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_cmp_eq(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_cmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int == 0); } return res; } status_t eval_cmp_ne(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_cmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int != 0); } return res; } status_t eval_cmp_lt(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_cmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int < 0); } return res; } status_t eval_cmp_gt(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_cmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int > 0); } return res; } status_t eval_cmp_le(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_cmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int <= 0); } return res; } status_t eval_cmp_ge(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_cmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int >= 0); } return res; } status_t eval_icmp(value_t *value, const expr_t *expr, eval_env_t *env) { // Fetch left argument and test for UNDEF status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; // Fetch right argument and test for UNDEF value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_int(value); cast_int(&right); if (value->type == VT_UNDEF) { set_value_int(value, (right.type == VT_UNDEF) ? 0 : -1); destroy_value(&right); return STATUS_OK; } else if (right.type == VT_UNDEF) { set_value_int(value, 1); destroy_value(&right); return STATUS_OK; } // Prevent from NULLs if (value->type == VT_NULL) { set_value_int(value, (right.type == VT_NULL) ? 0 : -1); destroy_value(&right); return STATUS_OK; } else if (right.type == VT_NULL) { set_value_int(value, 1); destroy_value(&right); return STATUS_OK; } // Perform compare set_value_int(value, (value->v_int < right.v_int) ? -1 : (value->v_int > right.v_int) ? 1 : 0); return STATUS_OK; } status_t eval_icmp_eq(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_icmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int == 0); } return res; } status_t eval_icmp_ne(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_icmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int != 0); } return res; } status_t eval_icmp_lt(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_icmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int < 0); } return res; } status_t eval_icmp_gt(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_icmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int > 0); } return res; } status_t eval_icmp_le(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_icmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int <= 0); } return res; } status_t eval_icmp_ge(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = eval_icmp(value, expr, env); if (res != STATUS_OK) return res; if (value->type == VT_INT) { value->type = VT_BOOL; value->v_bool = (value->v_int >= 0); } return res; } status_t eval_power(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; value_t right; init_value(&right); cast_float(value); switch (value->type) { case VT_FLOAT: res = expr->calc.right->eval(&right, expr->calc.right, env); break; case VT_NULL: value->type = VT_UNDEF; return STATUS_OK; case VT_UNDEF: return STATUS_OK; default: res = STATUS_BAD_TYPE; break; } if (res == STATUS_OK) { cast_float(&right); switch (right.type) { case VT_FLOAT: value->v_float = ::pow(value->v_float, right.v_float); break; case VT_NULL: case VT_UNDEF: value->type = VT_UNDEF; break; default: res = STATUS_BAD_TYPE; break; } } destroy_value(&right); if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_neg(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; if (value->type == VT_STRING) cast_numeric(value); switch (value->type) { case VT_INT: value->v_int = ~value->v_int; break; case VT_FLOAT: value->v_float = ~ssize_t(value->v_float); break; case VT_BOOL: value->v_bool = !value->v_bool; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_not(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_bool(value); switch (value->type) { case VT_BOOL: value->v_bool = !value->v_bool; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_psign(value_t *value, const expr_t *expr, eval_env_t *env) { return expr->calc.left->eval(value, expr->calc.left, env); } status_t eval_nsign(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_numeric(value); switch (value->type) { case VT_INT: value->v_int = -value->v_int; break; case VT_FLOAT: value->v_float = -value->v_float; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_exists(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; bool exists = value->type != VT_UNDEF; destroy_value(value); value->type = VT_BOOL; value->v_bool = exists; return STATUS_OK; } status_t eval_db(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_float(value); switch (value->type) { case VT_FLOAT: value->v_float = exp(value->v_float * M_LN10 * 0.05); break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_resolve(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res; if (env == NULL) { set_value_undef(value); return STATUS_OK; } // No indexes? Do simple stuff if (expr->resolve.count <= 0) { res = env->resolve(value, expr->resolve.name, 0, NULL); if (res != STATUS_NOT_FOUND) return res; set_value_undef(value); return STATUS_OK; } // Compute index values ssize_t *indexes = reinterpret_cast(::malloc(expr->resolve.count * sizeof(ssize_t))); if (indexes == NULL) return STATUS_NO_MEM; value_t tmp; init_value(&tmp); for (size_t i=0; iresolve.count; ++i) { expr_t *e = expr->resolve.items[i]; // Evaluate and store index res = e->eval(&tmp, e, env); if (res == STATUS_OK) { res = cast_int(&tmp); if (res == STATUS_OK) indexes[i] = tmp.v_int; destroy_value(&tmp); } // All is OK? if (res != STATUS_OK) { ::free(indexes); destroy_value(&tmp); return res; } } // Now we can resolve values res = env->resolve(value, expr->resolve.name, expr->resolve.count, indexes); ::free(indexes); destroy_value(&tmp); return res; } status_t eval_call(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res; if (env == NULL) { set_value_undef(value); return STATUS_OK; } // No indexes? Do simple stuff if (expr->call.count <= 0) { res = env->call(value, expr->call.name, 0, NULL); if (res != STATUS_NOT_FOUND) return res; set_value_undef(value); return STATUS_OK; } // Initialize arguments value_t *args = reinterpret_cast(::malloc(expr->call.count * sizeof(value_t))); if (args == NULL) return STATUS_NO_MEM; lsp_finally { free(args); }; for (size_t i=0; icall.count; ++i) init_value(&args[i]); lsp_finally { for (size_t i=0; icall.count; ++i) destroy_value(&args[i]); }; // Fill arguments for (size_t i=0; icall.count; ++i) { expr_t *e = expr->call.items[i]; // Evaluate and store index res = e->eval(&args[i], e, env); if (res != STATUS_OK) return res; } // Now we can perform call res = env->call(value, expr->call.name, expr->call.count, args); if (res != STATUS_NOT_FOUND) return res; set_value_undef(value); return STATUS_OK; } status_t eval_value(value_t *value, const expr_t *expr, eval_env_t *env) { return copy_value(value, &expr->value); } status_t eval_ternary(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.cond->eval(value, expr->calc.cond, env); if (res != STATUS_OK) return res; cast_bool(value); if ((value->type) != VT_BOOL) { destroy_value(value); return STATUS_OK; } // Determine which expression to execute expr = (value->v_bool) ? expr->calc.left : expr->calc.right; destroy_value(value); return expr->eval(value, expr, env); } status_t eval_strcat(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; if ((res = cast_string_ext(value)) != STATUS_OK) { destroy_value(value); return res; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } if ((res = cast_string_ext(&right)) != STATUS_OK) { destroy_value(value); destroy_value(&right); return res; } if (!value->v_str->append(right.v_str)) { destroy_value(value); res = STATUS_NO_MEM; } destroy_value(&right); return res; } status_t eval_strrep(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; if ((res = cast_string_ext(value)) != STATUS_OK) { destroy_value(value); return res; } value_t right; init_value(&right); res = expr->calc.right->eval(&right, expr->calc.right, env); if (res != STATUS_OK) { destroy_value(&right); destroy_value(value); return res; } cast_int(&right); if ((right.type == VT_NULL) || (right.type == VT_UNDEF) || (right.v_int < 0)) { destroy_value(&right); destroy_value(value); return STATUS_OK; } // Perform string repeat LSPString tmp; tmp.swap(value->v_str); size_t x = right.v_int; while (x) { if (x & 1) { if (!value->v_str->append(&tmp)) { res = STATUS_NO_MEM; break; } } if (x >>= 1) { if (!tmp.append(&tmp)) { res = STATUS_NO_MEM; break; } } } if (res != STATUS_OK) destroy_value(value); destroy_value(&right); return res; } status_t eval_strupper(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_string(value); switch (value->type) { case VT_STRING: value->v_str->toupper(); break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_strlower(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_string(value); switch (value->type) { case VT_STRING: value->v_str->tolower(); break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_strlen(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_string(value); switch (value->type) { case VT_STRING: { const size_t len = value->v_str->length(); destroy_value(value); value->type = VT_INT; value->v_int = len; break; } case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_strrev(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_string(value); switch (value->type) { case VT_STRING: { value->v_str->reverse(); break; } case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_int_cast(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; res = cast_int(value); if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_float_cast(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; res = cast_float(value); if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_string_cast(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; res = cast_string(value); if (res != STATUS_OK) destroy_value(value); return res; } status_t eval_bool_cast(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; res = cast_bool(value); if (res != STATUS_OK) destroy_value(value); return res; } #define MATH_OP(eval_name, var, operation) \ status_t eval_name(value_t *value, const expr_t *expr, eval_env_t *env) \ { \ status_t res = expr->calc.left->eval(value, expr->calc.left, env); \ if (res != STATUS_OK) \ return res; \ \ res = cast_float(value); \ if (value->type == VT_UNDEF) \ return STATUS_OK; \ else if (value->type == VT_NULL) \ { \ value->type = VT_UNDEF; \ return STATUS_OK; \ } \ const double var = value->v_float; \ value->v_float = (operation); \ \ return res; \ } MATH_OP(eval_sin, x, sin(x)) MATH_OP(eval_cos, x, cos(x)) MATH_OP(eval_tan, x, tan(x)) MATH_OP(eval_asin, x, asin(x)) MATH_OP(eval_acos, x, acos(x)) MATH_OP(eval_atan, x, atan(x)) MATH_OP(eval_loge, x, log(x)) MATH_OP(eval_logd, x, log(x) / M_LN10) MATH_OP(eval_log2, x, log(x) / M_LN2) MATH_OP(eval_exp, x, exp(x)) MATH_OP(eval_sqrt, x, sqrt(x)) MATH_OP(eval_rad, x, (x * M_PI) / 180.0) MATH_OP(eval_deg, x, (x * 180.0) / M_PI) status_t eval_abs(value_t *value, const expr_t *expr, eval_env_t *env) { status_t res = expr->calc.left->eval(value, expr->calc.left, env); if (res != STATUS_OK) return res; cast_numeric(value); if (value->type == VT_UNDEF) return STATUS_OK; else if (value->type == VT_NULL) { value->type = VT_UNDEF; return STATUS_OK; } switch (value->type) { case VT_INT: if (value->v_int < 0) value->v_int = - value->v_int; break; case VT_FLOAT: if (value->v_float < 0) value->v_float = - value->v_float; break; case VT_NULL: value->type = VT_UNDEF; break; case VT_UNDEF: break; default: res = STATUS_BAD_TYPE; break; } if (res != STATUS_OK) destroy_value(value); return res; } } /* namespace expr */ } /* namespace lsp */