/*
* Copyright (C) 2023 Linux Studio Plugins Project
* (C) 2023 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 23 февр. 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
namespace lsp
{
namespace sfz
{
DocumentProcessor::DocumentProcessor()
{
nScopes = -1;
pScope = NULL;
for (size_t i=0; ienType = SC_NONE;
s->enOther = OT_CUSTOM;
s->sName = NULL;
s->pPrev = NULL;
}
}
DocumentProcessor::~DocumentProcessor()
{
close();
}
status_t DocumentProcessor::open(const char *path)
{
if (nScopes >= 0)
return STATUS_OPENED;
io::Path tmp;
status_t res = tmp.set(path);
if (res == STATUS_OK)
res = open(&tmp);
return res;
}
status_t DocumentProcessor::open(const LSPString *path)
{
if (nScopes >= 0)
return STATUS_OPENED;
io::Path tmp;
status_t res = tmp.set(path);
if (res == STATUS_OK)
res = open(&tmp);
return res;
}
status_t DocumentProcessor::open(const io::Path *path)
{
if (nScopes >= 0)
return STATUS_OPENED;
// Get last name of the file path
LSPString last;
status_t res = path->get_last(&last);
if (res != STATUS_OK)
return res;
// Create and open parser
PullParser *pp = new PullParser();
if (pp == NULL)
return STATUS_NO_MEM;
lsp_finally {
if (pp != NULL)
{
pp->close();
delete pp;
}
};
if ((res = pp->open(path)) != STATUS_OK)
return res;
// Create the document entry
document_t *doc = create_document();
if (doc == NULL)
return STATUS_NO_MEM;
lsp_finally { destroy_document(doc); };
// Initialize document
if ((doc->sPath = last.clone_utf8()) == NULL)
return STATUS_NO_MEM;
if (!vTree.add(doc))
return STATUS_NO_MEM;
lsp::swap(doc->pParser, pp);
doc->nWFlags = WRAP_CLOSE | WRAP_DELETE;
doc = NULL;
// Mark processor open
nScopes = 0;
return res;
}
status_t DocumentProcessor::wrap(const char *str)
{
if (nScopes >= 0)
return STATUS_OPENED;
PullParser *pp = new PullParser();
if (pp == NULL)
return STATUS_NO_MEM;
status_t res = pp->wrap(str);
if (res != STATUS_OK)
{
pp->close();
delete pp;
return res;
}
res = wrap(pp, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
pp->close();
delete pp;
}
return res;
}
status_t DocumentProcessor::wrap(const void *buf, size_t len)
{
if (nScopes >= 0)
return STATUS_OPENED;
PullParser *pp = new PullParser();
if (pp == NULL)
return STATUS_NO_MEM;
status_t res = pp->wrap(buf, len);
if (res != STATUS_OK)
{
pp->close();
delete pp;
return res;
}
res = wrap(pp, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
pp->close();
delete pp;
}
return res;
}
status_t DocumentProcessor::wrap(const LSPString *str)
{
if (nScopes >= 0)
return STATUS_OPENED;
PullParser *pp = new PullParser();
if (pp == NULL)
return STATUS_NO_MEM;
status_t res = pp->wrap(str);
if (res != STATUS_OK)
{
pp->close();
delete pp;
return res;
}
res = wrap(pp, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
pp->close();
delete pp;
}
return res;
}
status_t DocumentProcessor::wrap(io::IInStream *is, size_t flags)
{
if (nScopes >= 0)
return STATUS_OPENED;
PullParser *pp = new PullParser();
if (pp == NULL)
return STATUS_NO_MEM;
status_t res = pp->wrap(is, flags);
if (res != STATUS_OK)
{
pp->close();
delete pp;
return res;
}
res = wrap(pp, WRAP_CLOSE | WRAP_DELETE);
if (res != STATUS_OK)
{
pp->close();
delete pp;
}
return res;
}
status_t DocumentProcessor::wrap(PullParser *parser, size_t flags)
{
if (nScopes >= 0)
return STATUS_OPENED;
document_t *doc = create_document();
if (doc == NULL)
return STATUS_NO_MEM;
lsp_finally { destroy_document(doc); };
// Initialize document
if (!vTree.add(doc))
return STATUS_NO_MEM;
doc->pParser = parser;
doc->nWFlags = flags;
doc->sPath = NULL;
doc = NULL;
// Mark processor open
nScopes = 0;
return STATUS_OK;
}
status_t DocumentProcessor::close()
{
if (nScopes < 0)
return STATUS_OK;
// Destroy documents
status_t res = STATUS_OK;
for (size_t i=vTree.size(); i > 0; )
res = update_status(res, destroy_document(vTree.uget(--i)));
vTree.flush();
// Destroy defined variables if present
drop_hash(&vVars);
// Cleanup scopes
for (size_t i=0; iname.equals_ascii(HDR_REGION))
scope = SC_REGION;
else if (ev->name.equals_ascii(HDR_GROUP))
scope = SC_GROUP;
else if (ev->name.equals_ascii(HDR_MASTER))
scope = SC_MASTER;
else if (ev->name.equals_ascii(HDR_GLOBAL))
scope = SC_GLOBAL;
else if (ev->name.equals_ascii(HDR_CONTROL))
scope = SC_CONTROL;
else
{
if (ev->name.equals_ascii(HDR_CURVE))
other = OT_CURVE;
else if (ev->name.equals_ascii(HDR_EFFECT))
other = OT_EFFECT;
else if (ev->name.equals_ascii(HDR_SAMPLE))
other = OT_SAMPLE;
else if (ev->name.equals_ascii(HDR_MIDI))
other = OT_MIDI;
}
// Switch to the desired scope
status_t res = switch_scope(handler, scope);
if (res != STATUS_OK)
return res;
// Complete the scope
pScope->enOther = other;
if ((scope == SC_OTHER) && (other == OT_CUSTOM))
{
if ((pScope->sName = ev->name.clone_utf8()) == NULL)
return STATUS_NO_MEM;
}
return STATUS_OK;
}
status_t DocumentProcessor::process_opcode(event_t *ev)
{
// We can not do anything without the scope
if (pScope == NULL)
return STATUS_CORRUPTED;
// Process the opcode and the value
char *opcode = process_value(&ev->name);
if (opcode == NULL)
return STATUS_NO_MEM;
lsp_finally { free(opcode); };
char *value = process_value(&ev->value);
if (value == NULL)
return STATUS_NO_MEM;
if (!pScope->vAllocated.add(value))
{
free(value);
return STATUS_NO_MEM;
}
// Put the opcode to the list
char *old_value = NULL;
if (!pScope->vOpcodes.put(opcode, value, &old_value))
return STATUS_NO_MEM;
return STATUS_OK;
}
status_t DocumentProcessor::process_include(IDocumentHandler *handler, event_t *ev)
{
// Obtain the name of the file
const char *fname = ev->name.get_utf8();
if (fname == NULL)
return STATUS_NO_MEM;
// Ensure that file wasn't previously present
for (size_t i=0, n=vTree.size(); isPath != NULL) ? doc->sPath : handler->root_file_name();
if (path == NULL)
continue;
if (strcmp(fname, path) == 0)
return STATUS_OVERFLOW;
}
// Now we can allocate new document
document_t *doc = create_document();
if (doc == NULL)
return STATUS_NO_MEM;
lsp_finally { destroy_document(doc); };
// Save file name
if ((doc->sPath = strdup(fname)) == NULL)
return STATUS_NO_MEM;
// Allocate parser
if ((doc->pParser = new PullParser()) == NULL)
return STATUS_NO_MEM;
doc->nWFlags = WRAP_CLOSE | WRAP_DELETE;
// Call the handler for opening the file
status_t res = handler->include(doc->pParser, doc->sPath);
if (res != STATUS_OK)
return res;
// Put the document to the tree
if (!vTree.push(doc))
return STATUS_NO_MEM;
// Return success
doc = NULL;
return STATUS_OK;
}
status_t DocumentProcessor::process_define(IDocumentHandler *handler, document_t *doc, event_t *ev)
{
const char *var_name = ev->name.get_utf8(1);
if (var_name == NULL)
return STATUS_NO_MEM;
char *var_value = ev->value.clone_utf8();
if (var_value == NULL)
return STATUS_NO_MEM;
lsp_finally {
if (var_value != NULL)
free(var_value);
};
return (vVars.put(var_name, var_value, &var_value)) ? STATUS_OK : STATUS_NO_MEM;
}
status_t DocumentProcessor::process_sample_data(IDocumentHandler *handler, event_t *ev)
{
// This should happen only for specific state
if ((pScope == NULL) || (pScope->enType != SC_OTHER) || (pScope->enOther != OT_SAMPLE))
return STATUS_CORRUPTED;
// Already exists?
if (((pScope->sName != NULL) || (pScope->sData.references()) > 0))
return STATUS_CORRUPTED;
// Bind the sample name
if ((pScope->sName = ev->name.clone_utf8()) == NULL)
return STATUS_NO_MEM;
pScope->sData.wrap(ev->blob);
return STATUS_OK;
}
status_t DocumentProcessor::main_loop(IDocumentHandler *handler)
{
// Main stuff
status_t res;
event_t ev;
while (!vTree.is_empty())
{
// Obtain the current document
document_t *doc = vTree.last();
if (doc == NULL)
return STATUS_CORRUPTED;
// Fetch next event
if ((res = doc->pParser->next(&ev)) != STATUS_OK)
{
// If not end of file, then we have troubles
if (res != STATUS_EOF)
return res;
// End of file, close current document first
res = destroy_document(doc);
if (!vTree.pop())
{
if (res == STATUS_OK)
res = STATUS_NO_MEM;
}
if (res != STATUS_OK)
return res;
// Then, continue the loop
continue;
}
// Dispatch event
switch (ev.type)
{
case EVENT_COMMENT:
res = STATUS_OK;
break;
case EVENT_HEADER:
res = process_header(handler, &ev);
break;
case EVENT_OPCODE:
res = process_opcode(&ev);
break;
case EVENT_INCLUDE:
res = process_include(handler, &ev);
break;
case EVENT_DEFINE:
res = process_define(handler, doc, &ev);
break;
case EVENT_SAMPLE:
res = process_sample_data(handler, &ev);
break;
case EVENT_NONE:
default:
res = STATUS_CORRUPTED;
break;
}
// Dispatch event
if (res != STATUS_OK)
return res;
}
return STATUS_OK;
}
status_t DocumentProcessor::process(IDocumentHandler *handler)
{
// Check status and arguments
if (handler == NULL)
return STATUS_BAD_ARGUMENTS;
if (nScopes < 0)
return STATUS_CLOSED;
// Notify handler about the start of document
status_t res = handler->begin();
if (res != STATUS_OK)
return res;
lsp_finally {
if (handler != NULL)
handler->end(res);
};
// Perform main loop and cleanup
res = main_loop(handler);
if (res == STATUS_OK)
res = switch_scope(handler, SC_NONE);
// Notify handler about end of document
status_t res2 = handler->end(res);
handler = NULL;
return (res == STATUS_OK) ? res2 : res;
}
DocumentProcessor::document_t *DocumentProcessor::create_document()
{
document_t *doc = new document_t;
doc->sPath = NULL;
doc->pParser = NULL;
doc->nWFlags = WRAP_NONE;
return doc;
}
status_t DocumentProcessor::destroy_document(document_t *document)
{
status_t res = STATUS_OK;
if (document == NULL)
return res;
// Destroy parser if present
if (document->pParser)
{
if (document->nWFlags & WRAP_CLOSE)
res = document->pParser->close();
if (document->nWFlags & WRAP_DELETE)
delete document->pParser;
document->pParser = NULL;
document->nWFlags = WRAP_NONE;
}
// Destroy path if present
if (document->sPath != NULL)
{
free(document->sPath);
document->sPath = NULL;
}
// Delete the document
delete document;
return res;
}
status_t DocumentProcessor::init_scope(scope_data_t *scope, scope_t type, scope_data_t *prev)
{
clear_scope(scope);
scope->enType = type;
scope->pPrev = prev;
if (prev == NULL)
return STATUS_OK;
// Do not copy contents from the CONTROL scope or to ANY scope
if ((prev->enType == SC_CONTROL) || (prev->enType == SC_OTHER))
return STATUS_OK;
// Copy the opcodes from the source scope
lltl::parray vk, vv;
if (!prev->vOpcodes.items(&vk, &vv))
return STATUS_NO_MEM;
for (size_t i=0, n=vk.size(); ivOpcodes.create(k, v))
{
clear_scope(scope);
return STATUS_NO_MEM;
}
}
return STATUS_OK;
}
void DocumentProcessor::clear_scope(scope_data_t *scope)
{
if (scope == NULL)
return;
scope->vOpcodes.clear();
for (size_t i=0, n=scope->vAllocated.size(); ivAllocated.uget(i);
if (str != NULL)
free(str);
}
scope->vAllocated.clear();
if (scope->sName!= NULL)
{
free(scope->sName);
scope->sName = NULL;
}
scope->sData.close();
scope->enType = SC_NONE;
scope->enOther = OT_CUSTOM;
scope->pPrev = NULL;
}
void DocumentProcessor::drop_hash(lltl::pphash *data)
{
if (data == NULL)
return;
lltl::parray vv;
data->values(&vv);
data->flush();
for (size_t i=0, n=vv.size(); iequals_ascii(HDR_CONTROL))
return SC_CONTROL;
if (header->equals_ascii(HDR_GLOBAL))
return SC_GLOBAL;
if (header->equals_ascii(HDR_MASTER))
return SC_MASTER;
if (header->equals_ascii(HDR_GROUP))
return SC_GROUP;
if (header->equals_ascii(HDR_REGION))
return SC_REGION;
return SC_OTHER;
}
status_t DocumentProcessor::dispatch_scope(IDocumentHandler *handler, scope_data_t *scope)
{
switch (scope->enType)
{
case SC_NONE:
case SC_GLOBAL:
case SC_MASTER:
case SC_GROUP:
return STATUS_OK;
default:
break;
}
// Prepare lists of opcodes
lltl::parray vk, vv;
if (!scope->vOpcodes.items(&vk, &vv))
return STATUS_NO_MEM;
if (!vk.add(static_cast(NULL)))
return STATUS_NO_MEM;
if (!vv.add(static_cast(NULL)))
return STATUS_NO_MEM;
const char **opcodes = const_cast(vk.array());
const char **values = const_cast(vv.array());
// Process main scopes
switch (scope->enType)
{
case SC_CONTROL:
return handler->control(opcodes, values);
case SC_REGION:
return handler->region(opcodes, values);
default: // SC_OTHER
break;
}
// Process sub-types of SC_OTHER scope
switch (scope->enOther)
{
case OT_SAMPLE:
return handler->sample(scope->sName, &scope->sData, opcodes, values);
case OT_MIDI:
return handler->midi(opcodes, values);
case OT_CURVE:
return handler->curve(opcodes, values);
case OT_EFFECT:
return handler->effect(opcodes, values);
default: // OT_CUSTOM
break;
}
return handler->custom_header(scope->sName, opcodes, values);
}
status_t DocumentProcessor::switch_scope(IDocumentHandler *handler, scope_t scope)
{
status_t res;
// Walk back if there is necessity
while ((pScope != NULL) && (pScope->enType >= scope))
{
// Call the dispatcher
if (pScope->enType != SC_CONTROL)
{
if ((res = dispatch_scope(handler, pScope)) != STATUS_OK)
return res;
}
// Free the scope
scope_data_t *prev = pScope->pPrev;
clear_scope(pScope);
--nScopes;
pScope = prev;
}
// Allocate new scope and link to previous
if (nScopes >= SC_TOTAL)
return STATUS_OVERFLOW;
// Special case: we're switching from SC_CONTROL scope
if ((pScope != NULL) && (pScope->enType == SC_CONTROL))
{
// Call the dispatcher
if ((res = dispatch_scope(handler, pScope)) != STATUS_OK)
return res;
}
// Check that we switched to SC_NONE scope
if (scope == SC_NONE)
return STATUS_OK;
// Allocate new scope
scope_data_t *s = &vScopes[nScopes++];
if ((res = init_scope(s, scope, pScope)) != STATUS_OK)
{
--nScopes;
clear_scope(s);
return res;
}
// Update the current scope pointer
pScope = s;
return STATUS_OK;
}
char *DocumentProcessor::process_value(const LSPString *value)
{
LSPString res;
for (size_t i=0, n=value->length(); i < n; )
{
lsp_wchar_t ch = value->char_at(i++);
if (ch == '$')
{
// Substitute variable
size_t first = i;
bool found = false;
while (i < n)
{
// New variable name?
char ch = value->char_at(i);
if (ch == '$')
break;
// Find the variable and substitute if it was found
const char *var = value->get_utf8(first, ++i);
const char *val = vVars.get(var);
if (val != NULL)
{
if (!res.append_utf8(val))
return NULL;
found = true;
break;
}
}
// No substitution was made?
if (!found)
{
if (!res.append(value, first-1, i))
return NULL;
}
}
else
{
if (!res.append(ch))
return NULL;
}
}
return res.clone_utf8();
}
} /* namespace sfz */
} /* namespace lsp */