/* * Copyright (C) 2023 Linux Studio Plugins Project * (C) 2023 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 29 янв. 2023 г. * * 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 #include #include namespace lsp { namespace sfz { PullParser::PullParser() { pIn = NULL; nWFlags = 0; sCurrent.type = EVENT_NONE; sSample.type = EVENT_NONE; nUnget = 0; } PullParser::~PullParser() { close(); } status_t PullParser::open(const char *path) { if (pIn != NULL) return STATUS_OPENED; io::InFileStream *ifs = new io::InFileStream(); if (ifs == NULL) return STATUS_NO_MEM; status_t res = ifs->open(path); if (res == STATUS_OK) res = wrap(ifs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ifs->close(); delete ifs; } return res; } status_t PullParser::open(const LSPString *path) { if (pIn != NULL) return STATUS_OPENED; io::InFileStream *ifs = new io::InFileStream(); if (ifs == NULL) return STATUS_NO_MEM; status_t res = ifs->open(path); if (res == STATUS_OK) res = wrap(ifs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ifs->close(); delete ifs; } return res; } status_t PullParser::open(const io::Path *path) { if (pIn != NULL) return STATUS_OPENED; io::InFileStream *ifs = new io::InFileStream(); if (ifs == NULL) return STATUS_NO_MEM; status_t res = ifs->open(path); if (res == STATUS_OK) res = wrap(ifs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ifs->close(); delete ifs; } return res; } status_t PullParser::wrap(const char *str) { return wrap(str, strlen(str)); } status_t PullParser::wrap(const void *buf, size_t len) { if (pIn != NULL) return STATUS_OPENED; io::InMemoryStream *ifs = new io::InMemoryStream(buf, len); if (ifs == NULL) return STATUS_NO_MEM; status_t res = wrap(ifs, WRAP_CLOSE | WRAP_DELETE); if (res != STATUS_OK) { ifs->close(); delete ifs; } return res; } status_t PullParser::wrap(const LSPString *str) { if (pIn != NULL) return STATUS_OPENED; return wrap(str->get_utf8()); } status_t PullParser::wrap(io::IInStream *is, size_t flags) { if (pIn != NULL) return STATUS_OPENED; pIn = is; nWFlags = flags; sCurrent.type = EVENT_NONE; sUnget.truncate(); nUnget = 0; return STATUS_OK; } status_t PullParser::close() { status_t res = STATUS_OK; if (pIn == NULL) return res; if (nWFlags & WRAP_CLOSE) res = pIn->close(); if (nWFlags & WRAP_DELETE) delete pIn; pIn = NULL; sCurrent.type = EVENT_NONE; sUnget.truncate(); nUnget = 0; return res; } const event_t *PullParser::current() const { return &sCurrent; } status_t PullParser::next(event_t *event) { if (pIn == NULL) return STATUS_CLOSED; // Read the next event status_t res = read_next_event(&sCurrent); if (res != STATUS_OK) return res; // Return event data if operation was successful if (event != NULL) { LSPString name, value; if (!name.set(&sCurrent.name)) return STATUS_NO_MEM; if (!value.set(&sCurrent.value)) return STATUS_NO_MEM; // Commit changes event->type = sCurrent.type; event->name.swap(&name); event->value.swap(&value); event->blob.wrap(sCurrent.blob, 0); } return STATUS_OK; } bool PullParser::is_identifier(lsp_wchar_t ch, bool first) { if ((ch >= 'a') && (ch <= 'z')) return true; if ((ch >= 'A') && (ch <= 'Z')) return true; if (ch == '_') return true; if ((!first) && (ch >= '0') && (ch <= '9')) return true; return false; } bool PullParser::is_space(lsp_wchar_t ch) { switch (ch) { case '\n': case '\r': case '\t': case '\v': case ' ': return true; default: break; } return false; } void PullParser::trim_right(LSPString *value) { ssize_t index = ssize_t(value->length()) - 1; for (; index >= 0; --index) { if (!is_space(value->char_at(index))) break; } value->set_length((index >= 0) ? index + 1 : 0); } lsp_swchar_t PullParser::get_char() { if (nUnget < sUnget.length()) { lsp_wchar_t ch = sUnget.char_at(nUnget++); if (nUnget >= sUnget.length()) { sUnget.truncate(); nUnget = 0; } return ch; } return lsp_swchar_t(pIn->read_byte()); } status_t PullParser::peek_pending_event(event_t *ev) { if (sSample.type != EVENT_NONE) { ev->type = sSample.type; ev->name.take(&sSample.name); ev->value.take(sSample.value); ev->blob.take(sSample.blob); sSample.type = EVENT_NONE; return STATUS_OK; } return STATUS_EOF; } status_t PullParser::read_next_event(event_t *ev) { lsp_swchar_t ch; while ((ch = get_char()) >= 0) { switch (ch) { case '<': return set_error(read_header(ev)); case '/': return set_error(read_comment(ev)); case '#': return set_error(read_preprocessor(ev)); default: { if (is_space(ch)) break; status_t res = read_opcode(ch, ev); if (res == STATUS_SKIP) // Special case? break; return set_error(res); } } } // Check if there is pending event if (ch == -STATUS_EOF) return set_error(peek_pending_event(ev)); return set_error(-ch); } status_t PullParser::read_header(event_t *ev) { lsp_swchar_t ch; LSPString header; // If there is pending event, return it first status_t res = peek_pending_event(ev); if (res == STATUS_OK) return (sUnget.append('<')) ? STATUS_OK : STATUS_NO_MEM; while ((ch = get_char()) >= 0) { if (ch == '>') { ev->type = EVENT_HEADER; ev->name.swap(&header); ev->value.clear(); ev->blob.close(); // Special case: trigger pending event on '' header if (ev->name.equals_ascii(HDR_SAMPLE)) sSample.type = EVENT_SAMPLE; return STATUS_OK; } else if (!is_identifier(ch, header.is_empty())) return STATUS_CORRUPTED; if (!header.append(ch)) return STATUS_NO_MEM; } return (ch == -STATUS_EOF) ? STATUS_CORRUPTED : -ch; } status_t PullParser::read_opcode_name(lsp_swchar_t ch, LSPString *name) { if (!is_identifier(ch, true)) return STATUS_CORRUPTED; if (!name->append(ch)) return STATUS_NO_MEM; while ((ch = get_char()) >= 0) { if (ch == '=') return STATUS_OK; else if ((ch != '$') && (!is_identifier(ch, name->is_empty()))) return STATUS_CORRUPTED; if (!name->append(ch)) return STATUS_NO_MEM; } return (ch == -STATUS_EOF) ? STATUS_CORRUPTED : -ch; } status_t PullParser::read_opcode_value(LSPString *value) { lsp_swchar_t ch; while ((ch = get_char()) >= 0) { switch (ch) { case '<': // header? case '/': // comment? nUnget = 0; sUnget.clear(); if (!sUnget.append(ch)) return STATUS_NO_MEM; return STATUS_OK; default: if (is_space(ch)) return STATUS_OK; if (!value->append(ch)) return STATUS_NO_MEM; break; } } return (ch == -STATUS_EOF) ? STATUS_OK : -ch; } status_t PullParser::read_string_opcode(LSPString *value) { lsp_swchar_t ch; while ((ch = get_char()) >= 0) { if (ch == '=') { // Special case from SFZ specification: // Long names and names with blank spaces and other special characters // (excepting the = character) are allowed in the sample definition. // sample=some file name.ext opcode2= <- we are here if (!value->append(ch)) return STATUS_NO_MEM; // Look for the first space character from the end ssize_t index = ssize_t(value->length()) - 2; for (; index >= 0; --index) { ch = value->char_at(index); if (is_space(ch)) break; } // Fill the unget buffer if (!sUnget.set(value, (index >= 0) ? index + 1 : 0)) return STATUS_NO_MEM; nUnget = 0; // Trim the value from the right value->set_length((index >= 0) ? index : 0); trim_right(value); return STATUS_OK; } else if (ch == '\n') { trim_right(value); return STATUS_OK; } if (!value->append(ch)) return STATUS_NO_MEM; } return (ch == -STATUS_EOF) ? STATUS_OK : -ch; } status_t PullParser::read_sample_data(io::IOutStream *os) { lsp_swchar_t ch; status_t res; // The decoding algorithm is as follows: // Loop while there is an input byte b1 // if b1 is the end marker $24, stop reading // if b1 is ‘\r’ ($0D) or ‘\n’ ($0A), discard it // if b1 is the escape character ‘=’ ($3D), // extract the next byte b2, and compute the next output byte as (b2+$C0)%256 // otherwise, compute the next output byte as (b1+$D6)%256 while ((ch = get_char()) >= 0) { switch (ch) { // If the character is the end marker 0x24, stop reading case '$': return STATUS_OK; // If the character is ‘\r’ (0x0D) or ‘\n’ (0x0A), discard it case '\n': case '\r': break; // If the character is the escape character ‘=’ case '=': // Extract the next byte and compute the next output byte as (value + 0xC0)&0xff if ((ch = get_char()) < 0) return (ch == -STATUS_EOF) ? STATUS_CORRUPTED : -ch; if ((res = os->write_byte((ch + 0xc0) & 0xff)) != STATUS_OK) return res; break; // Otherwise, compute the next output byte as (value + 0xD6)&0xff default: if ((res = os->write_byte((ch + 0xd6) & 0xff)) != STATUS_OK) return res; break; } } return (ch == -STATUS_EOF) ? STATUS_CORRUPTED : -ch; } bool PullParser::is_string_opcode(const LSPString *name) { ssize_t first, last; // sorted list of parameter names static const char *names[] = { "default_path", "delay_filter", "filter_type", "global_label", "group_label", "image", "master_label", "region_label", "sample", "script", "static_filter", "sw_label", "vendor_specific" }; // sorted list of parameter prefixes static const char *prefixes[] = { "label_cc", "label_key" }; // Perform binary search by full match first = 0; last = sizeof(names) / sizeof(names[0]) - 1; while (first <= last) { ssize_t mid = (first + last) / 2; const char *text = names[mid]; ssize_t res = name->compare_to_ascii(text); if (res == 0) return true; if (res < 0) last = mid - 1; else first = mid + 1; } // Perform binary search by prefx match first = 0; last = sizeof(prefixes) / sizeof(prefixes[0]) - 1; while (first <= last) { ssize_t mid = (first + last) / 2; const char *text = prefixes[mid]; if (name->starts_with_ascii(text)) return true; if (name->compare_to_ascii(text) < 0) last = mid - 1; else first = mid + 1; } return false; } status_t PullParser::read_opcode(lsp_wchar_t ch, event_t *ev) { status_t res; LSPString name, value; if ((res = read_opcode_name(ch, &name)) != STATUS_OK) return res; if (is_string_opcode(&name)) { if ((res = read_string_opcode(&value)) != STATUS_OK) return res; } else if (sSample.type == EVENT_SAMPLE) { // Special case: the header is pending if ((is_string_opcode(&name)) || (name.equals_ascii("name"))) { if ((res = read_string_opcode(&value)) != STATUS_OK) return res; sSample.name.swap(&value); return STATUS_SKIP; } else if (name.equals_ascii("data")) { io::OutMemoryStream os; if ((res = read_sample_data(&os)) != STATUS_OK) return res; sSample.blob.take(&os); return STATUS_SKIP; } else if ((res = read_opcode_value(&value)) != STATUS_OK) return res; } else { if ((res = read_opcode_value(&value)) != STATUS_OK) return res; } // Commit the result ev->type = EVENT_OPCODE; ev->name.swap(&name); ev->value.swap(&value); ev->blob.close(); return STATUS_OK; } status_t PullParser::read_comment(event_t *ev) { lsp_swchar_t ch; if ((ch = get_char()) < 0) return -ch; if (ch != '/') return STATUS_CORRUPTED; // Read the entire string until end of line LSPString text; while ((ch = get_char()) >= 0) { if (ch == '\n') { // Patch for Windows line endings if (text.last() == '\r') text.remove_last(); break; } if (!text.append(ch)) return STATUS_NO_MEM; } ev->type = EVENT_COMMENT; ev->name.clear(); ev->value.swap(&text); ev->blob.close(); return STATUS_OK; } status_t PullParser::expect_string(const char *text) { // Read the expected string from the file lsp_swchar_t ch; for (const char *p=text; *p != '\0'; ++p) { if ((ch = get_char()) < 0) return (ch == -STATUS_EOF) ? STATUS_CORRUPTED : -ch; if (ch != *p) return STATUS_CORRUPTED; } return STATUS_OK; } status_t PullParser::expect_char(lsp_swchar_t expected) { lsp_swchar_t ch; while ((ch = get_char()) >= 0) { if (ch == expected) return STATUS_OK; if (!is_space(ch)) return STATUS_CORRUPTED; } return (ch == -STATUS_EOF) ? STATUS_CORRUPTED : -ch; } status_t PullParser::read_variable_name(LSPString *value) { lsp_swchar_t ch; if (!value->append('$')) return STATUS_NO_MEM; while ((ch = get_char()) >= 0) { if (is_space(ch)) break; if (!is_identifier(ch, value->length() == 1)) return STATUS_CORRUPTED; if (!value->append(ch)) return STATUS_NO_MEM; } if ((ch < 0) && (ch != -STATUS_EOF)) return -ch; // The variable name should be of at least 1 character after '$' sign return (value->length() >= 2) ? STATUS_OK : STATUS_CORRUPTED; } status_t PullParser::read_variable_value(LSPString *value) { lsp_swchar_t ch; // Read first character while ((ch = get_char()) >= 0) { if (!is_space(ch)) break; } if (ch < 0) return (ch != -STATUS_EOF) ? -ch : STATUS_OK; if (!value->append(ch)) return STATUS_NO_MEM; // Read the last variable definition size_t slashes = 0; while ((ch = get_char()) >= 0) { switch (ch) { case '<': // header? nUnget = 0; sUnget.clear(); if (!sUnget.append(ch)) return STATUS_NO_MEM; return STATUS_OK; case '/': // possible comment? if ((++slashes) >= 2) { nUnget = 0; sUnget.clear(); if (!sUnget.append_ascii("//", 2)) return STATUS_NO_MEM; return STATUS_OK; } if (!value->append(ch)) return STATUS_NO_MEM; break; default: slashes = 0; if (is_space(ch)) return STATUS_OK; if (!value->append(ch)) return STATUS_NO_MEM; break; } } return (ch == -STATUS_EOF) ? STATUS_OK : -ch; } status_t PullParser::read_define(event_t *ev) { status_t res; if ((res = expect_string("efine")) != STATUS_OK) // 'd' already was read return res; if ((res = expect_char('$')) != STATUS_OK) return res; // Read the variable name LSPString name; if ((res = read_variable_name(&name)) != STATUS_OK) return res; // Read the variable value LSPString value; if ((res = read_variable_value(&value)) != STATUS_OK) return res; // Commit the result ev->type = EVENT_DEFINE; ev->name.swap(&name); ev->value.swap(&value); ev->blob.close(); return STATUS_OK; } status_t PullParser::read_include(event_t *ev) { status_t res; if ((res = expect_string("nclude")) != STATUS_OK) // 'i' already was read return res; if ((res = expect_char('\"')) != STATUS_OK) return res; // Read the entire string until the end quote occurs lsp_swchar_t ch; LSPString text; while (true) { if ((ch = get_char()) < 0) return (ch == -STATUS_EOF) ? -STATUS_CORRUPTED : -ch; if (ch == '\"') break; if (!text.append(ch)) return STATUS_NO_MEM; } // Commit the result ev->type = EVENT_INCLUDE; ev->name.swap(&text); ev->value.clear(); ev->blob.close(); return STATUS_OK; } status_t PullParser::read_preprocessor(event_t *ev) { lsp_swchar_t ch = get_char(); switch (ch) { case 'd': return read_define(ev); case 'i': return read_include(ev); default: break; } return ((ch < 0) && (ch != -STATUS_EOF)) ? -ch : STATUS_CORRUPTED; } status_t PullParser::set_error(status_t code) { if (code != STATUS_OK) { sCurrent.type = EVENT_NONE; sCurrent.name.truncate(); sCurrent.value.truncate(); } return code; } } /* namespace sfz */ } /* namespace lsp */