/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 1 мая 2020 г. * * 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 config { Serializer::Serializer() { pOut = NULL; nWFlags = 0; } Serializer::~Serializer() { do_close(); } status_t Serializer::write_key(const LSPString *key) { ssize_t idx = -1; // Validate key for (size_t i=0, n=key->length(); iat(i); if (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || ((ch >= '0') && (ch <= '9')) || (ch == '_')) continue; else if (ch == '/') { if (idx < 0) { if (i != 0) return STATUS_INVALID_VALUE; idx = i; } continue; } return STATUS_INVALID_VALUE; } // Write key status_t res = pOut->write(key); if (res == STATUS_OK) res = pOut->write_ascii(" = "); return res; } status_t Serializer::write_uint(uint64_t v, size_t flags) { status_t res; char tmp[64]; ::snprintf(tmp, sizeof(tmp), "%llu", (unsigned long long)v); tmp[sizeof(tmp)-1] = '\0'; if (flags & SF_QUOTED) { if ((res = pOut->write('\"')) != STATUS_OK) return res; if ((res = pOut->write_ascii(tmp)) != STATUS_OK) return res; res = pOut->write_ascii("\"\n"); } else { if ((res = pOut->write_ascii(tmp)) != STATUS_OK) return res; res = pOut->write('\n'); } return res; } status_t Serializer::write_int(int64_t v, size_t flags) { status_t res; char tmp[64]; snprintf(tmp, sizeof(tmp), "%lld", (long long)v); tmp[sizeof(tmp)-1] = '\0'; if (flags & SF_QUOTED) { if ((res = pOut->write('\"')) != STATUS_OK) return res; if ((res = pOut->write_ascii(tmp)) != STATUS_OK) return res; res = pOut->write_ascii("\"\n"); } else { if ((res = pOut->write_ascii(tmp)) != STATUS_OK) return res; res = pOut->write('\n'); } return res; } status_t Serializer::write_float(double v, size_t flags) { // Save and update locale SET_LOCALE_SCOPED(LC_NUMERIC, "C"); status_t res; char tmp[64]; const char *fmt = "%f"; // Analyze format if (flags & SF_DECIBELS) { switch (flags & SF_PREC_MASK) { case SF_PREC_SHORT: fmt = "%.1f db"; break; case SF_PREC_LONG: fmt = "%.4f db"; break; case SF_PREC_SCI: fmt = "%e db"; break; default: fmt = "%.2f db"; break; } } else { switch (flags & SF_PREC_MASK) { case SF_PREC_SHORT: fmt = "%.2f"; break; case SF_PREC_LONG: fmt = "%.10f"; break; case SF_PREC_SCI: fmt = "%e"; break; default: fmt = "%.5f"; break; } } ::snprintf(tmp, sizeof(tmp), fmt, v); tmp[sizeof(tmp)-1] = '\0'; // Write value if (flags & SF_QUOTED) { if ((res = pOut->write('\"')) != STATUS_OK) return res; if ((res = pOut->write_ascii(tmp)) != STATUS_OK) return res; res = pOut->write_ascii("\"\n"); } else { if ((res = pOut->write_ascii(tmp)) != STATUS_OK) return res; res = pOut->write('\n'); } return res; } status_t Serializer::write_bool(bool v, size_t flags) { status_t res; // Write value if (flags & SF_QUOTED) { if ((res = pOut->write('\"')) != STATUS_OK) return res; if ((res = pOut->write_ascii((v) ? "true" : "false")) != STATUS_OK) return res; res = pOut->write_ascii("\"\n"); } else { if ((res = pOut->write_ascii((v) ? "true" : "false")) != STATUS_OK) return res; res = pOut->write('\n'); } return res; } status_t Serializer::open(const char *path, const char *charset) { if (pOut != NULL) return STATUS_BAD_STATE; else if (path == NULL) return STATUS_BAD_ARGUMENTS; io::OutFileStream *ofs = new io::OutFileStream(); if (ofs == NULL) return STATUS_NO_MEM; status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE); if (res == STATUS_OK) { res = wrap(ofs, WRAP_CLOSE | WRAP_DELETE, charset); if (res == STATUS_OK) return res; ofs->close(); } delete ofs; return res; } status_t Serializer::open(const LSPString *path, const char *charset) { if (pOut != NULL) return STATUS_BAD_STATE; else if (path == NULL) return STATUS_BAD_ARGUMENTS; io::OutFileStream *ofs = new io::OutFileStream(); if (ofs == NULL) return STATUS_NO_MEM; status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE); if (res == STATUS_OK) { res = wrap(ofs, WRAP_CLOSE | WRAP_DELETE, charset); if (res == STATUS_OK) return res; ofs->close(); } delete ofs; return res; } status_t Serializer::open(const io::Path *path, const char *charset) { if (pOut != NULL) return STATUS_BAD_STATE; else if (path == NULL) return STATUS_BAD_ARGUMENTS; io::OutFileStream *ofs = new io::OutFileStream(); if (ofs == NULL) return STATUS_NO_MEM; status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE); if (res == STATUS_OK) { res = wrap(ofs, WRAP_CLOSE | WRAP_DELETE, charset); if (res == STATUS_OK) return res; ofs->close(); } delete ofs; return res; } status_t Serializer::wrap(LSPString *str) { if (pOut != NULL) return STATUS_BAD_STATE; else if (str == NULL) return STATUS_BAD_ARGUMENTS; io::OutStringSequence *seq = new io::OutStringSequence(str, false); if (seq == NULL) return STATUS_NO_MEM; status_t res = wrap(seq, WRAP_CLOSE | WRAP_DELETE); if (res == STATUS_OK) return res; seq->close(); delete seq; return res; } status_t Serializer::wrap(io::IOutStream *os, size_t flags, const char *charset) { if (pOut != NULL) return STATUS_BAD_STATE; else if (os == NULL) return STATUS_BAD_ARGUMENTS; io::OutSequence *seq = new io::OutSequence(); if (seq == NULL) return STATUS_NO_MEM; status_t res = seq->wrap(os, flags, charset); if (res == STATUS_OK) { if ((res = wrap(seq, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK) return res; seq->close(); } delete seq; return res; } status_t Serializer::wrap(io::IOutSequence *seq, size_t flags) { if (pOut != NULL) return STATUS_BAD_STATE; else if (seq == NULL) return STATUS_BAD_ARGUMENTS; pOut = seq; nWFlags = flags; return STATUS_OK; } status_t Serializer::do_close() { if (pOut == NULL) return STATUS_OK; // Close handles status_t res = STATUS_OK; if (nWFlags & WRAP_CLOSE) res = update_status(res, pOut->close()); if (nWFlags & WRAP_DELETE) delete pOut; pOut = NULL; return res; } status_t Serializer::close() { return do_close(); } status_t Serializer::write_comment(const LSPString *v) { if (pOut == NULL) return STATUS_CLOSED; status_t res; size_t first = 0; while (true) { if ((res = pOut->write_ascii("# ")) != STATUS_OK) return res; ssize_t split = v->index_of(first, '\n'); if (split < 0) { if ((res = pOut->write(v, first)) == STATUS_OK) res = pOut->write('\n'); return res; } else { if ((res = pOut->write(v, first, split)) != STATUS_OK) return res; if ((res = pOut->write('\n')) != STATUS_OK) return res; first = split + 1; } } } status_t Serializer::write_escaped(const LSPString *key, size_t flags) { status_t res = STATUS_OK; if (flags & SF_QUOTED) { if ((res = pOut->write('\"')) != STATUS_OK) return res; } size_t first = 0, last = 0, len = key->length(); while (last < len) { // Analyze character lsp_wchar_t ch = key->char_at(last); switch (ch) { case '\n': ch = 'n'; break; case '\r': ch = 'r'; break; case '\t': ch = 't'; break; case '\"': case '\\': break; case '#': case ' ': if (!(flags & SF_QUOTED)) break; ++last; continue; default: ++last; continue; } // Emit characters in queue if (first < last) { if ((res = pOut->write(key, first, last)) != STATUS_OK) return res; } // Emit escaped character if ((res = pOut->write('\\')) != STATUS_OK) return res; if ((res = pOut->write(ch)) != STATUS_OK) return res; first = ++last; } // Write tail if (first < last) res = pOut->write(key, first, last); if (flags & SF_QUOTED) { if ((res = pOut->write('\"')) != STATUS_OK) return res; } return res; } status_t Serializer::write_comment(const char *v) { LSPString tmp; if (!tmp.set_utf8(v)) return STATUS_NO_MEM; return write_comment(&tmp); } status_t Serializer::writeln() { return (pOut != NULL) ? pOut->write('\n') : STATUS_CLOSED; } status_t Serializer::write(const char *key, const value_t *v, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write(&tmp, v, flags); } status_t Serializer::write(const LSPString *key, const value_t *v, size_t flags) { switch (flags & SF_TYPE_MASK) { case SF_TYPE_I32: return write_i32(key, v->i32, flags); case SF_TYPE_U32: return write_u32(key, v->u32, flags); case SF_TYPE_I64: return write_i64(key, v->i64, flags); case SF_TYPE_U64: return write_u64(key, v->u64, flags); case SF_TYPE_F32: return write_f32(key, v->f32, flags); case SF_TYPE_F64: return write_f64(key, v->f64, flags); case SF_TYPE_BOOL: return write_bool(key, v->bval, flags); case SF_TYPE_STR: return write_string(key, v->str, flags); case SF_TYPE_BLOB: return write_blob(key, &v->blob, flags); default: break; } return STATUS_BAD_TYPE; } status_t Serializer::write(const config::param_t * param) { if (param == NULL) return STATUS_BAD_ARGUMENTS; return write(*param); } status_t Serializer::write(const config::param_t & param) { if (param.flags & SF_COMMENT) { status_t res = write_comment(¶m.comment); if (res != STATUS_OK) return res; } return write(¶m.name, ¶m.v, param.flags); } status_t Serializer::write_i32(const char *key, int32_t value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_i32(&tmp, value, flags); } status_t Serializer::write_i32(const LSPString *key, int32_t value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("i32:")) != STATUS_OK) return res; } return write_int(value, flags); } status_t Serializer::write_u32(const char *key, uint32_t value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_u32(&tmp, value, flags); } status_t Serializer::write_u32(const LSPString *key, uint32_t value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("u32:")) != STATUS_OK) return res; } return write_uint(value, flags); } status_t Serializer::write_f32(const char *key, float value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_f32(&tmp, value, flags); } status_t Serializer::write_f32(const LSPString *key, float value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("f32:")) != STATUS_OK) return res; } return write_float(value, flags); } status_t Serializer::write_i64(const char *key, int64_t value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_i64(&tmp, value, flags); } status_t Serializer::write_i64(const LSPString *key, int64_t value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("i64:")) != STATUS_OK) return res; } return write_int(value, flags); } status_t Serializer::write_u64(const char *key, uint64_t value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_u64(&tmp, value, flags); } status_t Serializer::write_u64(const LSPString *key, uint64_t value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("u64:")) != STATUS_OK) return res; } return write_uint(value, flags); } status_t Serializer::write_f64(const char *key, double value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_f64(&tmp, value, flags); } status_t Serializer::write_f64(const LSPString *key, double value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("f64:")) != STATUS_OK) return res; } return write_float(value, flags); } status_t Serializer::write_bool(const char *key, bool value, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_bool(&tmp, value, flags); } status_t Serializer::write_bool(const LSPString *key, bool value, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("bool:")) != STATUS_OK) return res; } return write_bool(value, flags); } status_t Serializer::write_string_impl(const LSPString *key, const LSPString *v, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if (flags & SF_TYPE_SET) { if ((res = pOut->write_ascii("str:")) != STATUS_OK) return res; } if ((res = write_escaped(v, flags)) != STATUS_OK) return res; return pOut->write('\n'); } status_t Serializer::write_string(const LSPString *key, const LSPString *v, size_t flags) { return write_string_impl(key, v, flags); } status_t Serializer::write_string(const LSPString *key, const char *v, size_t flags) { LSPString tmp; if (!tmp.set_utf8(v)) return STATUS_NO_MEM; return write_string_impl(key, &tmp, flags); } status_t Serializer::write_string(const char *key, const LSPString *v, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_string_impl(&tmp, v, flags); } status_t Serializer::write_string(const char *key, const char *v, size_t flags) { LSPString tmp1, tmp2; if ((!tmp1.set_utf8(key)) || (!tmp2.set_utf8(v))) return STATUS_NO_MEM; return write_string_impl(&tmp1, &tmp2, flags); } status_t Serializer::write_blob(const LSPString *key, const blob_t *v, size_t flags) { if (pOut == NULL) return STATUS_CLOSED; status_t res = write_key(key); if (res != STATUS_OK) return res; if ((res = pOut->write_ascii("blob:")) != STATUS_OK) return res; if ((res = pOut->write('\"')) != STATUS_OK) return res; // Write blob data LSPString tmp; if (v->ctype != NULL) { if (!tmp.set_utf8(v->ctype)) return STATUS_NO_MEM; } if (!tmp.append(':')) return STATUS_NO_MEM; if (!tmp.fmt_append_ascii("%llu:", (unsigned long long)v->length)) return STATUS_NO_MEM; if ((res = write_escaped(&tmp, 0)) != STATUS_OK) return res; if (!tmp.set_utf8(v->data)) return STATUS_NO_MEM; if ((res = write_escaped(&tmp, 0)) != STATUS_OK) return res; res = pOut->write_ascii("\"\n"); return res; } status_t Serializer::write_blob(const char *key, const blob_t *v, size_t flags) { LSPString tmp; if (!tmp.set_utf8(key)) return STATUS_NO_MEM; return write_blob(&tmp, v, flags); } } /* namespace config */ } /* namespace lsp */