/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 19 сент. 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 { Variables::Variables() { pResolver = NULL; } Variables::Variables(Resolver *r) { pResolver = r; } Variables::~Variables() { clear(); } status_t Variables::set_int(const char *name, ssize_t value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; value_t v; v.type = VT_INT; v.v_int = value; return set(&key, &v); } status_t Variables::set_float(const char *name, double value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; value_t v; v.type = VT_FLOAT; v.v_float = value; return set(&key, &v); } status_t Variables::set_bool(const char *name, bool value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; value_t v; v.type = VT_BOOL; v.v_bool = value; return set(&key, &v); } status_t Variables::set_string(const char *name, const char *value, const char *charset) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; value_t v; if (value == NULL) { v.type = VT_NULL; v.v_str = NULL; return set(&key, &v); } status_t res = init_value_string(&v, value, charset); if (res == STATUS_OK) res = set_move(&key, &v); destroy_value(&v); return res; } status_t Variables::set_string(const char *name, const LSPString *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; value_t v; if (value == NULL) { v.type = VT_NULL; v.v_str = NULL; return set(&key, &v); } status_t res = init_value_string(&v, value); if (res == STATUS_OK) res = set_move(&key, &v); destroy_value(&v); return res; } status_t Variables::set_null(const char *name) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; value_t v; v.type = VT_NULL; v.v_int = 0; return set(&key, &v); } status_t Variables::set_int(const LSPString *name, ssize_t value) { value_t v; v.type = VT_INT; v.v_int = value; return set(name, &v); } status_t Variables::set_float(const LSPString *name, double value) { value_t v; v.type = VT_FLOAT; v.v_float = value; return set(name, &v); } status_t Variables::set_bool(const LSPString *name, bool value) { value_t v; v.type = VT_BOOL; v.v_bool = value; return set(name, &v); } status_t Variables::set_string(const LSPString *name, const char *value, const char *charset) { value_t v; if (value == NULL) { v.type = VT_NULL; v.v_str = NULL; return set(name, &v); } status_t res = init_value_string(&v, value, charset); if (res == STATUS_OK) res = set_move(name, &v); destroy_value(&v); return res; } status_t Variables::set_string(const LSPString *name, const LSPString *value) { value_t v; v.type = VT_STRING; v.v_str = const_cast(value); return set(name, &v); } status_t Variables::set_null(const LSPString *name) { value_t v; v.type = VT_NULL; v.v_int = 0; return set(name, &v); } status_t Variables::set(const char *name, const value_t *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; return set(&key, value); } status_t Variables::unset(const char *name, value_t *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; return unset(&key, value); } status_t Variables::resolve(value_t *value, const char *name, size_t num_indexes, const ssize_t *indexes) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; return resolve(value, &key, num_indexes, indexes); } status_t Variables::resolve(value_t *value, const LSPString *name, size_t num_indexes, const ssize_t *indexes) { // Need to form indexes? LSPString tmp; const LSPString *search; if (num_indexes > 0) { if (!tmp.set(name)) return STATUS_NO_MEM; for (size_t i=0; i= 0) { variable_t *var = vVars.uget(idx); int cmp = search->compare_to(&var->name); if (cmp == 0) { if (value != NULL) return copy_value(value, &var->value); return STATUS_OK; } else if (cmp > 0) ++idx; } else idx = 0; // No Resolver? if (pResolver == NULL) return STATUS_NOT_FOUND; // Resolve from underlying resolver value_t v; init_value(&v); lsp_finally { destroy_value(&v); }; status_t res = pResolver->resolve(&v, name, num_indexes, indexes); if (res != STATUS_OK) return res; // Save variable to cache res = insert_var(search, &v, idx); if ((res == STATUS_OK) && (value != NULL)) res = copy_value(value, &v); return res; } status_t Variables::call(value_t *value, const char *name, size_t num_args, const value_t *args) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; return call(value, &key, num_args, args); } status_t Variables::call(value_t *value, const LSPString *name, size_t num_args, const value_t *args) { // Lookup the cache ssize_t idx = index_of_func(name); if (idx < 0) { if (pResolver != NULL) return pResolver->call(value, name, num_args, args); return Resolver::call(value, name, num_args, args); } // Ensure than name of function matches user_func_t *func = vFunc.uget(idx); if (!name->equals(&func->name)) { if (pResolver != NULL) return pResolver->call(value, name, num_args, args); return Resolver::call(value, name, num_args, args); } // Execute function return func->func(func->context, value, num_args, args); } ssize_t Variables::index_of_var(const LSPString *name) { const variable_t *var; ssize_t first = 0, last = vVars.size() - 1, mid; if (last < 0) return -1; while (first < last) { mid = (first + last) >> 1; var = vVars.uget(mid); int cmp = name->compare_to(&var->name); if (cmp < 0) last = mid - 1; else if (cmp > 0) first = mid + 1; else return mid; } return first; } ssize_t Variables::index_of_func(const LSPString *name) { const user_func_t *f; ssize_t first = 0, last = vFunc.size() - 1, mid; if (last < 0) return -1; while (first < last) { mid = (first + last) >> 1; f = vFunc.uget(mid); int cmp = name->compare_to(&f->name); if (cmp < 0) last = mid - 1; else if (cmp > 0) first = mid + 1; else return mid; } return first; } status_t Variables::insert_var(const LSPString *name, const value_t *value, size_t idx) { variable_t *var = new variable_t; if (var == NULL) return STATUS_NO_MEM; if (!var->name.set(name)) { delete var; return STATUS_NO_MEM; } status_t res = init_value(&var->value, value); if (res == STATUS_OK) res = (vVars.insert(idx, var)) ? STATUS_OK : STATUS_NO_MEM; if (res == STATUS_OK) return res; destroy_value(&var->value); delete var; return res; } status_t Variables::insert_var_move(const LSPString *name, value_t *value, size_t idx) { variable_t *var = new variable_t; if (var == NULL) return STATUS_NO_MEM; if (!var->name.set(name)) { delete var; return STATUS_NO_MEM; } init_value_move(&var->value, value); status_t res = (vVars.insert(idx, var)) ? STATUS_OK : STATUS_NO_MEM; if (res == STATUS_OK) return res; destroy_value(&var->value); delete var; return res; } status_t Variables::insert_func(const LSPString *name, function_t func, void *context, size_t idx) { user_func_t *f = new user_func_t; if (f == NULL) return STATUS_NO_MEM; if (!f->name.set(name)) { delete f; return STATUS_NO_MEM; } f->func = func; f->context = context; if (vFunc.insert(idx, f)) return STATUS_OK; delete f; return STATUS_NO_MEM; } status_t Variables::set(const LSPString *name, const value_t *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; ssize_t idx = index_of_var(name); if (idx >= 0) { variable_t *var = vVars.uget(idx); int cmp = name->compare_to(&var->name); if (cmp == 0) return copy_value(&var->value, value); else if (cmp > 0) ++idx; } else idx = 0; // Add non-existing value return insert_var(name, value, idx); } status_t Variables::set_move(const LSPString *name, value_t *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; ssize_t idx = index_of_var(name); if (idx >= 0) { variable_t *var = vVars.uget(idx); int cmp = name->compare_to(&var->name); if (cmp == 0) { move_value(&var->value, value); return STATUS_OK; } else if (cmp > 0) ++idx; } else idx = 0; // Add non-existing value return insert_var_move(name, value, idx); } status_t Variables::unset(const LSPString *name, value_t *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; // Lookup for variable ssize_t idx = index_of_var(name); if (idx < 0) return STATUS_NOT_FOUND; variable_t *var = vVars.uget(idx); if (!name->equals(&var->name)) return STATUS_NOT_FOUND; // Need to copy value? if (value != NULL) { status_t res = copy_value(value, &var->value); if (res != STATUS_OK) return res; } // Remove stored value vVars.remove(idx); destroy_value(&var->value); delete var; return STATUS_OK; } void Variables::clear_vars() { for (size_t i=0, n=vVars.size(); ivalue); delete var; } } vVars.flush(); } void Variables::clear_func() { for (size_t i=0, n=vFunc.size(); i= 0) { user_func_t *f = vFunc.uget(idx); int cmp = name->compare_to(&f->name); if (cmp == 0) { if (!f->name.set(name)) return STATUS_NO_MEM; f->func = func; f->context = context; } else if (cmp > 0) ++idx; } else idx = 0; // Add non-existing value return insert_func(name, func, context, idx); } status_t Variables::unbind_func(const char *name) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString key; if (!key.set_utf8(name)) return STATUS_NO_MEM; return unbind_func(&key); } status_t Variables::unbind_func(const LSPString *name) { if (name == NULL) return STATUS_BAD_ARGUMENTS; // Lookup for data ssize_t idx = index_of_func(name); if (idx < 0) return STATUS_NOT_FOUND; user_func_t *func = vFunc.uget(idx); if (!name->equals(&func->name)) return STATUS_NOT_FOUND; // Remove function vFunc.remove(idx); delete func; return STATUS_OK; } } /* namespace expr */ } /* namespace lsp */