DetunerPlugin::~DetunerPlugin()
{
removeAllParameters(true);
delete Pars;
if(buf) delete [] buf;
if(win) delete [] win;
}
void parameterizedHeaderField::copyFrom(const component& other)
{
headerField::copyFrom(other);
const parameterizedHeaderField& source = dynamic_cast<const parameterizedHeaderField&>(other);
removeAllParameters();
for (std::vector <ref <parameter> >::const_iterator i = source.m_params.begin() ;
i != source.m_params.end() ; ++i)
{
appendParameter((*i)->clone().dynamicCast <parameter>());
}
}
LadspaPlugin::~LadspaPlugin ()
{
if (ptrPlug && ptrPlug->cleanup)
ptrPlug->cleanup (plugin);
ptrPlug = 0;
removeAllParameters (true);
if (ptrLibrary)
PlatformUtilities::freeDynamicLibrary (ptrLibrary);
ptrLibrary = 0;
if (params) delete[] params;
if (normalized) delete[] normalized;
}
DssiPlugin::~DssiPlugin ()
{
osc.stopListening ();
if (ptrPlug && ladspa && ladspa->cleanup)
ladspa->cleanup (plugin);
ptrPlug = 0;
removeAllParameters (true);
if (ptrLibrary)
PlatformUtilities::freeDynamicLibrary (ptrLibrary);
ptrLibrary = 0;
if (params) delete[] params;
if (normalized) delete[] normalized;
}
GwenParameterInterface::~GwenParameterInterface()
{
removeAllParameters();
delete m_paramInternalData;
}
void parameterizedHeaderField::parse(const string& buffer, const string::size_type position,
const string::size_type end, string::size_type* newPosition)
{
const string::value_type* const pend = buffer.data() + end;
const string::value_type* const pstart = buffer.data() + position;
const string::value_type* p = pstart;
// Skip non-significant whitespaces
string::size_type valueStart = position;
while (p < pend && parserHelpers::isSpace(*p))
{
++p;
++valueStart;
}
// Advance up to ';', if any
string::size_type valueLength = 0;
while (p < pend && *p != ';') // FIXME: support ";" inside quoted or RFC-2047-encoded text
{
++p;
++valueLength;
}
// Trim whitespaces at the end of the value
while (valueLength > 0 && parserHelpers::isSpace(buffer[valueStart + valueLength - 1]))
--valueLength;
// Parse value
getValue()->parse(buffer, valueStart, valueStart + valueLength);
// Reset parameters
removeAllParameters();
// If there is one or more parameters following...
if (p < pend)
{
std::map <string, paramInfo> params;
while (*p == ';')
{
// Skip ';'
++p;
while (p < pend && parserHelpers::isSpace(*p)) ++p;
const string::size_type attrStart = position + (p - pstart);
while (p < pend && !(*p == ';' || *p == '='))
++p;
if (p >= pend || *p == ';')
{
// Hmmmm... we didn't found an '=' sign.
// This parameter may not be valid so try to advance
// to the next one, if there is one.
while (p < pend && *p != ';')
++p;
}
else
{
// Extract the attribute name
string::size_type attrEnd = position + (p - pstart);
while (attrEnd != attrStart && parserHelpers::isSpace(buffer[attrEnd - 1]))
--attrEnd;
// Skip '='
++p;
// Skip white-spaces between '=' and the value
while (p < pend && parserHelpers::isSpace(*p)) ++p;
// Extract the value
string value;
// -- this is a quoted-string
if (*p == '"')
{
// Skip '"'
++p;
// Extract quoted-string
bool escape = false;
bool stop = false;
std::ostringstream ss;
string::size_type start = position + (p - pstart);
for ( ; p < pend && !stop ; ++p)
{
if (escape)
{
escape = false;
start = position + (p - pstart);
}
else
{
switch (*p)
{
case '"':
{
ss << string(buffer.begin() + start,
buffer.begin() + position + (p - pstart));
stop = true;
break;
}
case '\\':
{
ss << string(buffer.begin() + start,
buffer.begin() + position + (p - pstart));
escape = true;
break;
}
}
}
}
if (!stop)
{
ss << string(buffer.begin() + start,
buffer.begin() + position + (p - pstart));
}
value = ss.str();
}
// -- the value is a simple token
else
{
const string::size_type valStart = position + (p - pstart);
while (p < pend && *p != ';')
++p;
string::size_type valEnd = position + (p - pstart);
while (valEnd != valStart && parserHelpers::isSpace(buffer[valEnd - 1]))
--valEnd;
value = string(buffer.begin() + valStart,
buffer.begin() + valEnd);
}
// Don't allow ill-formed parameters
if (attrStart != attrEnd && value.length())
{
string name(buffer.begin() + attrStart, buffer.begin() + attrEnd);
// Check for RFC-2231 extended parameters
bool extended = false;
bool encoded = false;
if (name[name.length() - 1] == '*')
{
name.erase(name.end() - 1, name.end());
extended = true;
encoded = true;
}
// Check for RFC-2231 multi-section parameters
const string::size_type star = name.find_last_of('*');
if (star != string::npos)
{
bool allDigits = true;
for (string::size_type i = star + 1 ; allDigits && (i < name.length()) ; ++i)
allDigits = parserHelpers::isDigit(name[i]);
if (allDigits)
{
name.erase(name.begin() + star, name.end());
extended = true;
}
// NOTE: we ignore section number, and we suppose that
// the sequence is correct (ie. the sections appear
// in order: param*0, param*1...)
}
// Add/replace/modify the parameter
const std::map <string, paramInfo>::iterator it = params.find(name);
if (it != params.end())
{
paramInfo& info = (*it).second;
// An extended parameter replaces a normal one
if (!info.extended)
{
info.extended = extended;
info.value.clear();
info.start = attrStart;
}
// Append a new section for a multi-section parameter
parameter::valueChunk chunk;
chunk.encoded = encoded;
chunk.data = value;
info.value.push_back(chunk);
info.end = position + (p - pstart);
}
else
{
parameter::valueChunk chunk;
chunk.encoded = encoded;
chunk.data = value;
paramInfo info;
info.extended = extended;
info.value.push_back(chunk);
info.start = attrStart;
info.end = position + (p - pstart);
// Insert a new parameter
params.insert(std::map <string, paramInfo>::value_type(name, info));
}
}
// Skip white-spaces after this parameter
while (p < pend && parserHelpers::isSpace(*p)) ++p;
}
}
for (std::map <string, paramInfo>::const_iterator it = params.begin() ;
it != params.end() ; ++it)
{
const paramInfo& info = (*it).second;
// Append this parameter to the list
ref <parameter> param = vmime::create <parameter>((*it).first);
param->parse(info.value);
param->setParsedBounds(info.start, info.end);
appendParameter(param);
}
}
if (newPosition)
*newPosition = end;
}
parameterizedHeaderField::~parameterizedHeaderField()
{
removeAllParameters();
}
