/* * Copyright (C) 2020 Linux Studio Plugins Project * (C) 2020 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 16 сент. 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 #include #include namespace lsp { namespace expr { Expression::Expression() { pResolver = NULL; } Expression::Expression(Resolver *res) { pResolver = res; } Expression::~Expression() { destroy_all_data(); pResolver = NULL; } void Expression::destroy() { destroy_all_data(); pResolver = NULL; } void Expression::destroy_all_data() { for (size_t i=0, n=vDependencies.size(); iexpr != NULL) { parse_destroy(r->expr); r->expr = NULL; } destroy_value(&r->result); } vRoots.flush(); } status_t Expression::result(value_t *result, size_t idx) { root_t *r = vRoots.get(idx); if (r == NULL) return STATUS_BAD_ARGUMENTS; if (result == NULL) return STATUS_OK; return copy_value(result, &r->result); } status_t Expression::evaluate(value_t *result) { status_t res = STATUS_BAD_STATE; for (size_t i=0, n=vRoots.size(); iexpr != NULL) res = r->expr->eval(&r->result, r->expr, pResolver); else { set_value_undef(&r->result); res = STATUS_OK; } if (res != STATUS_OK) break; } // Store the result if ALL is OK if ((res == STATUS_OK) && (result != NULL)) res = copy_value(result, &vRoots.uget(0)->result); return res; } status_t Expression::evaluate(size_t idx, value_t *result) { root_t *r = vRoots.get(idx); if (r == NULL) return STATUS_BAD_ARGUMENTS; status_t res = STATUS_BAD_STATE; if (r->expr != NULL) res = r->expr->eval(&r->result, r->expr, pResolver); else { set_value_undef(&r->result); res = STATUS_OK; } // Store the result if ALL is OK if ((res == STATUS_OK) && (result != NULL)) *result = r->result; return res; } status_t Expression::parse(const char *expr, size_t flags) { io::InStringSequence is; status_t res = is.wrap(expr, "UTF-8"); if (res == STATUS_OK) res = parse(&is, flags); if (res == STATUS_OK) res = is.close(); else is.close(); return res; } status_t Expression::parse(const char *expr, const char *charset, size_t flags) { io::InStringSequence is; status_t res = is.wrap(expr, (charset != NULL) ? charset : "UTF-8"); if (res == STATUS_OK) res = parse(&is, flags); if (res == STATUS_OK) res = is.close(); else is.close(); return res; } status_t Expression::parse(const LSPString *expr, size_t flags) { io::InStringSequence is; status_t res = is.wrap(expr); if (res == STATUS_OK) res = parse(&is, flags); if (res == STATUS_OK) res = is.close(); else is.close(); return res; } status_t Expression::parse_regular(io::IInSequence *seq, size_t flags) { status_t res = STATUS_OK; Tokenizer t(seq); while (true) { // Allocate placeholder root_t *root = vRoots.add(); if (root == NULL) { res = STATUS_NO_MEM; break; } // Parse expression root->expr = NULL; init_value(&root->result); res = parse_expression(&root->expr, &t, TF_GET); if (res != STATUS_OK) break; // Analyze next token after expression token_t tok = t.get_token(TF_NONE); if (tok != TT_SEMICOLON) { res = t.error(); if (tok == TT_EOF) res = STATUS_OK; else if (res == STATUS_OK) res = STATUS_INVALID_VALUE; break; } else if (!(flags & FLAG_MULTIPLE)) break; } return res; } status_t Expression::prepend_string(expr_t **expr, const LSPString *str, bool force) { // Do we really need to prepend? if ((str->length() <= 0) && (!force)) return STATUS_OK; // What to do with expression? expr_t *right = parse_create_expr(); if (right == NULL) return STATUS_NO_MEM; right->type = ET_VALUE; right->eval = eval_value; status_t res = init_value_string(&right->value, str); if (res != STATUS_OK) { parse_destroy(right); return res; } // Do we need to immediately return? if (*expr == NULL) { *expr = right; return STATUS_OK; } // Need to create middle expression expr_t *middle = parse_create_expr(); if (middle == NULL) { parse_destroy(right); return STATUS_NO_MEM; } middle->type = ET_CALC; middle->eval = eval_strcat; middle->calc.left = *expr; middle->calc.right = right; middle->calc.cond = NULL; *expr = middle; return STATUS_OK; } status_t Expression::parse_substitution(expr_t **expr, Tokenizer *t) { expr_t *right = NULL; token_t tok = t->get_token(TF_GET); // Parse expression status_t res = (tok == TT_BAREWORD) ? parse_identifier(&right, t, TF_BAREWORD) : parse_expression(&right, t, TF_NONE); if (res != STATUS_OK) return res; // Analyze next token after expression tok = t->get_token(TF_NONE); if (tok != TT_RCBRACE) res = (tok == TT_EOF) ? STATUS_EOF : STATUS_BAD_TOKEN; if (res == STATUS_OK) *expr = right; return res; } status_t Expression::parse_string(io::IInSequence *seq, size_t flags) { // Create expression LSPString tmp; Tokenizer t(seq); status_t res = STATUS_OK; expr_t *expr = NULL; bool predicate = false; while (true) { lsp_swchar_t wc = seq->read(); if (predicate) { predicate = false; if (wc < 0) { res = (wc == -STATUS_EOF) ? STATUS_OK : -wc; break; } else if (wc != '{') { if (wc != '$') res = (tmp.append('$')) ? STATUS_OK : STATUS_NO_MEM; if (res == STATUS_OK) res = (tmp.append(wc)) ? STATUS_OK : STATUS_NO_MEM; if (res != STATUS_OK) break; } else // Sub-expression { // Prepend string if it is defined res = prepend_string(&expr, &tmp, false); if (res != STATUS_OK) break; tmp.clear(); // Parse expression expr_t *right = NULL; res = parse_substitution(&right, &t); if (res != STATUS_OK) break; // What to do with expression? if (expr != NULL) { expr_t *middle = parse_create_expr(); if (middle == NULL) { parse_destroy(right); res = STATUS_NO_MEM; break; } middle->type = ET_CALC; middle->eval = eval_strcat; middle->calc.left = expr; middle->calc.right = right; middle->calc.cond = NULL; expr = middle; } else expr = right; } } else { // Analyze result if (wc < 0) { res = (wc == -STATUS_EOF) ? STATUS_OK : -wc; break; } else if (wc == '$') predicate = true; else if (!tmp.append(wc)) // Append character to string { res = STATUS_NO_MEM; break; } } } // Need to prepend string? if (res == STATUS_OK) res = prepend_string(&expr, &tmp, expr == NULL); // Analyze result if (res != STATUS_OK) { parse_destroy(expr); return res; } // Allocate placeholder root_t *root = vRoots.add(); if (root == NULL) { parse_destroy(expr); res = STATUS_NO_MEM; } else { root->expr = expr; init_value_undef(&root->result); } return res; } status_t Expression::parse(io::IInSequence *seq, size_t flags) { status_t res = STATUS_OK; destroy_all_data(); if (flags & FLAG_STRING) res = parse_string(seq, flags & (~FLAG_STRING)); else res = parse_regular(seq, flags); if (res == STATUS_OK) res = post_process(); if (res != STATUS_OK) destroy_all_data(); return res; } status_t Expression::post_process() { // Scan for dependencies for (size_t i=0, n=vRoots.size(); iexpr); if (res != STATUS_OK) return res; } return STATUS_OK; } status_t Expression::add_dependency(const LSPString *str) { // Already have such dependency? for (size_t i=0, n=vDependencies.size(); iequals(str)) return STATUS_OK; } // Add new dependency LSPString *dep = str->clone(); if (dep == NULL) return STATUS_NO_MEM; if (vDependencies.add(dep)) return STATUS_OK; delete dep; return STATUS_NO_MEM; } status_t Expression::scan_dependencies(expr_t *expr) { status_t res; if (expr == NULL) return STATUS_OK; switch (expr->type) { case ET_VALUE: return STATUS_OK; case ET_CALC: { res = scan_dependencies(expr->calc.cond); if (res == STATUS_OK) res = scan_dependencies(expr->calc.left); if (res == STATUS_OK) res = scan_dependencies(expr->calc.right); return res; } case ET_RESOLVE: { res = add_dependency(expr->resolve.name); if (res != STATUS_OK) return res; for (size_t i=0; iresolve.count; ++i) { res = scan_dependencies(expr->resolve.items[i]); if (res != STATUS_OK) break; } return res; } case ET_CALL: { for (size_t i=0; icall.count; ++i) { res = scan_dependencies(expr->call.items[i]); if (res != STATUS_OK) break; } return STATUS_OK; } default: break; } return STATUS_CORRUPTED; } bool Expression::has_dependency(const LSPString *str) const { for (size_t i=0, n=vDependencies.size(); iequals(str)) return true; } return false; } bool Expression::has_dependency(const char *str) const { LSPString tmp; if (!tmp.set_utf8(str)) return false; for (size_t i=0, n=vDependencies.size(); iequals(&tmp)) return true; } return false; } } /* namespace calc */ } /* namespace lsp */