/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 25 февр. 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
#include
#ifdef PLATFORM_WINDOWS
#include
#endif /* PLATFORM_WINDOWS */
namespace lsp
{
namespace expr
{
status_t format(io::IOutSequence *out, const char *fmt, const Parameters *r)
{
if ((out == NULL) || (fmt == NULL))
return STATUS_BAD_ARGUMENTS;
io::InStringSequence xfmt;
status_t res = xfmt.wrap(fmt);
if (res != STATUS_OK)
{
xfmt.close();
return res;
}
res = format(out, &xfmt, r);
if (res != STATUS_OK)
{
xfmt.close();
return res;
}
return xfmt.close();
}
status_t format(io::IOutSequence *out, const LSPString *fmt, const Parameters *r)
{
if ((out == NULL) || (fmt == NULL))
return STATUS_BAD_ARGUMENTS;
io::InStringSequence xfmt;
status_t res = xfmt.wrap(fmt);
if (res != STATUS_OK)
{
xfmt.close();
return res;
}
res = format(out, &xfmt, r);
if (res != STATUS_OK)
{
xfmt.close();
return res;
}
return xfmt.close();
}
status_t format(LSPString *out, io::IInSequence *fmt, const Parameters *r)
{
if ((out == NULL) || (fmt == NULL))
return STATUS_BAD_ARGUMENTS;
io::OutStringSequence xout;
out->set_length(0);
status_t res = xout.wrap(out, false);
if (res != STATUS_OK)
{
xout.close();
return res;
}
res = format(&xout, fmt, r);
if (res != STATUS_OK)
{
xout.close();
return res;
}
return xout.close();
}
status_t format(LSPString *out, const char *fmt, const Parameters *r)
{
if ((out == NULL) || (fmt == NULL))
return STATUS_BAD_ARGUMENTS;
io::OutStringSequence xout;
out->set_length(0);
status_t res = xout.wrap(out, false);
if (res != STATUS_OK)
{
xout.close();
return res;
}
res = format(&xout, fmt, r);
if (res != STATUS_OK)
{
xout.close();
return res;
}
return xout.close();
}
status_t format(LSPString *out, const LSPString *fmt, const Parameters *r)
{
if ((out == NULL) || (fmt == NULL))
return STATUS_BAD_ARGUMENTS;
io::OutStringSequence xout;
out->set_length(0);
status_t res = xout.wrap(out, false);
if (res != STATUS_OK)
{
xout.close();
return res;
}
res = format(&xout, fmt, r);
if (res != STATUS_OK)
{
xout.close();
return res;
}
return xout.close();
}
enum align_type_t
{
AL_NONE, // No alignment
AL_LEFT, // '<' - pad formatted value from right
AL_RIGHT, // '>' - pad formatted value from left
AL_MIDDLE, // '|' - pad formatted value from left and right
AL_FROM_LEFT, // '>|' - pad formatted value from left and right, prefer right alignment
AL_FROM_RIGHT, // '|<' - pad formatted value from left and right, prefer left alignment
AL_TO_LEFT, // '<|' - take 1/4 from left, 3/4 from right
AL_TO_RIGHT, // '|>' - take 1/4 from right, 3/4 from left
};
enum fmt_flags_t
{
F_NAME = 1 << 0,
F_INDEX = 1 << 1,
F_TYPE = 1 << 2,
F_WIDTH = 1 << 3,
F_FRAC = 1 << 4,
F_SIGN = 1 << 5,
F_LPAD = 1 << 6,
F_RPAD = 1 << 7,
F_XWIDTH = 1 << 8
};
typedef struct fmt_spec_t
{
LSPString buf; // Buffer to store full specifier
LSPString name; // Name of the parameter
size_t index; // Index of parameter
size_t flags; // Format flags
lsp_wchar_t lpad; // Padding left
lsp_wchar_t rpad; // Padding right
align_type_t align; // Alignment
lsp_wchar_t type; // Type
size_t width; // Width
size_t xwidth; // Extra width
size_t frac; // Fraction
} fmt_spec_t;
void init_spec(fmt_spec_t *spec, size_t index)
{
spec->buf.clear();
spec->name.clear();
spec->index = index;
spec->flags = 0;
spec->lpad = ' ';
spec->rpad = ' ';
spec->align = AL_NONE;
spec->type = 0;
spec->width = 0;
spec->xwidth = 0;
spec->frac = 0;
}
status_t read_specifier(io::IOutSequence *out, io::IInSequence *fmt, fmt_spec_t *spec)
{
lsp_swchar_t c;
status_t res = STATUS_OK;
// Read format specifier as string
while (true)
{
// Read next character
c = fmt->read();
if (c < 0)
{
if (c != -STATUS_EOF)
return -c;
// Format specifier has been interrupted
if ((res = out->write('{')) != STATUS_OK)
return res;
if ((res = out->write(&spec->buf)) != STATUS_OK)
return res;
return STATUS_BAD_FORMAT;
}
// End of format specifier?
if (c == '}')
break;
// Append character and repeat
if (!spec->buf.append(c))
return STATUS_NO_MEM;
}
// now parse format specifier
size_t len = spec->buf.length();
for (size_t i=0; ibuf.char_at(i++);
switch (c)
{
case '@': // Name
// Prevent from duplicate definitions
if (spec->flags & (F_NAME | F_INDEX))
{
res = STATUS_BAD_FORMAT;
break;
}
// Check first character
c = (i < len) ? spec->buf.char_at(i++) : 0;
if (Tokenizer::is_identifier_first(c))
{
// Append character
spec->flags |= F_NAME;
if (!spec->name.append(c))
{
res = STATUS_NO_MEM;
break;
}
// Check other characters
for (; i < len; ++i)
{
c = spec->buf.char_at(i);
if (!Tokenizer::is_identifier_next(c))
break;
else if (!spec->name.append(c))
{
res = STATUS_NO_MEM;
break;
}
}
}
else
res = STATUS_BAD_FORMAT;
break;
case '[': // Index
// Prevent from duplicate definitions
if (spec->flags & (F_NAME | F_INDEX))
{
res = STATUS_BAD_FORMAT;
break;
}
// Read decimal index
spec->index = 0;
for ( ; i < len; ++i)
{
c = spec->buf.char_at(i);
if ((c < '0') || (c > '9'))
break;
spec->index = spec->index * 10 + (c - '0');
spec->flags |= F_INDEX;
}
// Require final ']'
if ((spec->flags & F_INDEX) && (i < len))
{
c = spec->buf.char_at(i++);
if (c != ']')
res = STATUS_BAD_FORMAT;
}
else
res = STATUS_BAD_FORMAT;
break;
case '^': // Left padding
if ((!(spec->flags & F_LPAD)) && (i < len))
{
spec->flags |= F_LPAD;
spec->lpad = spec->buf.char_at(i++);
}
else
res = STATUS_BAD_FORMAT;
break;
case '$': // Right padding
if ((!(spec->flags & F_RPAD)) && (i < len))
{
spec->flags |= F_RPAD;
spec->rpad = spec->buf.char_at(i++);
}
else
res = STATUS_BAD_FORMAT;
break;
case '>': // Right alignment
if (spec->align == AL_NONE)
{
spec->align = AL_RIGHT;
if ((i < len) && (spec->buf.char_at(i) == '|')) // '>|'
{
spec->align = AL_FROM_LEFT;
++i;
}
}
else
res = STATUS_BAD_FORMAT;
break;
case '<': // Left alignment
if (spec->align == AL_NONE)
{
spec->align = AL_LEFT;
if ((i < len) && (spec->buf.char_at(i) == '|')) // '<|'
{
spec->align = AL_TO_LEFT;
++i;
}
}
else
res = STATUS_BAD_FORMAT;
break;
case '|': // Middle alignment
if (spec->align == AL_NONE)
{
spec->align = AL_MIDDLE;
if (i < len)
{
// Lookup additional modes
c = spec->buf.char_at(i);
if (c == '<') // '|<'
{
spec->align = AL_FROM_RIGHT;
++i;
}
else if (c == '>') // '|>'
{
spec->align = AL_TO_RIGHT;
++i;
}
}
}
else
res = STATUS_BAD_FORMAT;
break;
case ':': // Extra width
// Read extra width
for ( ; i < len; ++i)
{
c = spec->buf.char_at(i);
if ((c < '0') || (c > '9'))
break;
spec->flags |= F_XWIDTH;
spec->xwidth = spec->xwidth * 10 + (c - '0');
}
// Ensure that there is something read
if (!(spec->flags & F_XWIDTH))
res = STATUS_BAD_FORMAT;
break;
case '%': // Type specifier
// Prevent from duplicate definition
if (spec->flags & F_TYPE)
{
res = STATUS_BAD_FORMAT;
break;
}
spec->flags |= F_TYPE;
// Lookup for sign
if ((i < len) && (spec->buf.char_at(i) == '+'))
{
spec->flags |= F_SIGN;
++i;
}
// Read width
for ( ; i < len; ++i)
{
c = spec->buf.char_at(i);
if ((c < '0') || (c > '9'))
break;
spec->flags |= F_WIDTH;
spec->width = spec->width * 10 + (c - '0');
}
// Lookup for dot
if ((i < len) && (spec->buf.char_at(i) == '.'))
{
// Read fraction
while ((++i) < len)
{
c = spec->buf.char_at(i);
if ((c < '0') || (c > '9'))
break;
spec->flags |= F_FRAC;
spec->frac = spec->frac * 10 + (c - '0');
}
// Check that fraction part is present
if (!(spec->flags & F_FRAC))
{
res = STATUS_BAD_FORMAT;
break;
}
}
// Read type specifier
if (i >= len)
{
res = STATUS_BAD_FORMAT;
break;
}
c = spec->buf.char_at(i++);
switch (c)
{
case 'i': case 'd': case 'u': // decimals
case 'b': case 'o': case 'x': case 'X': // octals, binaries, hexadecimals
case 'f': case 'F': case 'e': case 'E': // floating-points
case 's': case 'S': // string
spec->type = c;
break;
case 'l': // boolean, bOOLEAN
c = (i < len) ? spec->buf.char_at(i) : 0;
if (c == 'l')
{
++i;
spec->type = 'l';
}
else if (c == 'L')
{
++i;
spec->type = 'z';
}
else
spec->type = 'l';
break;
case 'L': // BOOLEAN, Boolean
c = (i < len) ? spec->buf.char_at(i) : 0;
if (c == 'l')
{
++i;
spec->type = 'Z';
}
else if (c == 'L')
{
++i;
spec->type = 'L';
}
else
spec->type = 'L';
break;
case 't': // text, tEXT
c = (i < len) ? spec->buf.char_at(i) : 0;
if (c == 't')
{
++i;
spec->type = 't';
}
else if (c == 'T')
{
++i;
spec->type = 'y';
}
else
spec->type = 't';
break;
case 'T': // TEXT, Text
c = (i < len) ? spec->buf.char_at(i) : 0;
if (c == 't')
{
++i;
spec->type = 'Y';
}
else if (c == 'T')
{
++i;
spec->type = 'T';
}
else
spec->type = 'T';
break;
default:
// No type specifier, just width
--i;
break;
}
break;
default:
res = STATUS_BAD_FORMAT;
break;
}
// Check result
if (res == STATUS_BAD_FORMAT)
{
if ((res = out->write('{')) != STATUS_OK)
return res;
if ((res = out->write(&spec->buf)) != STATUS_OK)
return res;
if ((res = out->write('}')) != STATUS_OK)
return res;
res = STATUS_BAD_FORMAT;
break;
}
else if (res != STATUS_OK)
break;
}
return res;
}
status_t check_specials(fmt_spec_t *spec, value_t *v)
{
if (v->type == VT_NULL)
return (spec->buf.set_ascii("")) ? STATUS_SKIP : STATUS_NO_MEM;
else if (v->type == VT_UNDEF)
return (spec->buf.set_ascii("")) ? STATUS_SKIP : STATUS_NO_MEM;
return STATUS_OK;
}
status_t int_append_extra(fmt_spec_t *spec, value_t *v)
{
// Append to specified width
if (spec->flags & F_WIDTH)
{
while (spec->buf.length() < spec->width)
{
if (!spec->buf.append('0'))
return STATUS_NO_MEM;
}
}
// Append sign
if (v->v_int < 0)
{
if (!spec->buf.append('-'))
return STATUS_NO_MEM;
}
else if (spec->flags & F_SIGN)
{
if (!spec->buf.append('+'))
return STATUS_NO_MEM;
}
return STATUS_OK;
}
status_t int_to_dec(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
ssize_t x = lsp_abs(v->v_int);
do
{
lsp_swchar_t rem = x % 10;
if (!spec->buf.append(lsp_wchar_t((rem >= 0) ? '0' + rem : '0' - rem)))
return STATUS_NO_MEM;
x /= 10;
} while (x);
if ((res = int_append_extra(spec, v)) != STATUS_OK)
return res;
spec->buf.reverse();
return STATUS_OK;
}
status_t uint_to_dec(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
size_t x = size_t(v->v_int);
do
{
if (!spec->buf.append(lsp_wchar_t((x % 10) + '0')))
return STATUS_NO_MEM;
x /= 10;
} while (x);
if ((res = int_append_extra(spec, v)) != STATUS_OK)
return res;
spec->buf.reverse();
return STATUS_OK;
}
status_t int_to_bin(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
size_t x = lsp_abs(v->v_int);
do
{
if (!spec->buf.append(lsp_wchar_t((x & 1) + '0')))
return STATUS_NO_MEM;
x >>= 1;
} while (x);
if ((res = int_append_extra(spec, v)) != STATUS_OK)
return res;
spec->buf.reverse();
return STATUS_OK;
}
status_t int_to_oct(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
size_t x = v->v_int;
do
{
if (!spec->buf.append(lsp_wchar_t((x & 0x7) + '0')))
return STATUS_NO_MEM;
x >>= 3;
} while (x);
if ((res = int_append_extra(spec, v)) != STATUS_OK)
return res;
spec->buf.reverse();
return STATUS_OK;
}
static const char *hex_table = "0123456789abcdef0123456789ABCDEF";
status_t int_to_hex(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
const char *table = (spec->type == 'X') ? &hex_table[16] : hex_table;
size_t x = (v->v_int < 0) ? -v->v_int : v->v_int;
do
{
if (!spec->buf.append(table[x & 0xf]))
return STATUS_NO_MEM;
x >>= 4;
} while (x);
if ((res = int_append_extra(spec, v)) != STATUS_OK)
return res;
spec->buf.reverse();
return STATUS_OK;
}
inline bool is_float_upper(fmt_spec_t *spec)
{
return ((spec->type == 'F') || (spec->type == 'E'));
}
status_t float_to_str(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
if (isnan(v->v_float))
{
const char *text = (is_float_upper(spec)) ? "NAN" : "nan";
res = (spec->buf.set_ascii(text)) ? STATUS_OK : STATUS_NO_MEM;
}
else if (isinf(v->v_float))
{
const char *text;
if (v->v_float < 0)
{
v->v_float = INFINITY;
text = (is_float_upper(spec)) ? "-INF" : "-inf";
}
else if (spec->flags & F_SIGN)
text = (is_float_upper(spec)) ? "+INF" : "+inf";
else
text = (is_float_upper(spec)) ? "INF" : "inf";
res = (spec->buf.set_ascii(text)) ? STATUS_OK : STATUS_NO_MEM;
}
else
{
char fmt[64];
SET_LOCALE_SCOPED(LC_NUMERIC, "C");
#ifdef PLATFORM_WINDOWS
// Windows format string does not respect uppercase format letters.
// That's why we need to do some workaround work
// Initialize format specifier
bool uppercase = isupper(spec->type);
char spec_type = tolower(spec->type);
if (spec->flags & F_FRAC)
::snprintf(fmt, sizeof(fmt), "%%.%d%c", int(spec->frac), spec_type);
else
::snprintf(fmt, sizeof(fmt), "%%.6%c", spec_type);
fmt[sizeof(fmt)-1] = '\0';
// Format the floating-point value and reverse buffer
if (!spec->buf.fmt_ascii(fmt, lsp_abs(v->v_float)))
return STATUS_NO_MEM;
if (uppercase)
spec->buf.toupper();
spec->buf.reverse();
#else
// Initialize format specifier
if (spec->flags & F_FRAC)
::snprintf(fmt, sizeof(fmt), "%%.%d%c", int(spec->frac), char(spec->type));
else
::snprintf(fmt, sizeof(fmt), "%%.6%c", char(spec->type));
fmt[sizeof(fmt)-1] = '\0';
// Format the floating-point value and reverse buffer
if (!spec->buf.fmt_ascii(fmt, lsp_abs(v->v_float)))
return STATUS_NO_MEM;
spec->buf.reverse();
#endif /* PLATFORM_WINDOWS */
// Append to specified width
if (spec->flags & F_WIDTH)
{
while (spec->buf.length() < spec->width)
{
if (!spec->buf.append('0'))
return STATUS_NO_MEM;
}
}
// Append sign
if (v->v_float < 0)
{
if (!spec->buf.append('-'))
return STATUS_NO_MEM;
}
else if (spec->flags & F_SIGN)
{
if (!spec->buf.append('+'))
return STATUS_NO_MEM;
}
// Reverse again
spec->buf.reverse();
}
return res;
}
status_t text_to_str(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
if (!spec->buf.set(v->v_str))
return STATUS_NO_MEM;
// Additional modifications?
switch (spec->type)
{
case 't': spec->buf.tolower(); break;
case 'T': spec->buf.toupper(); break;
case 'y':
if (spec->buf.length() > 0)
{
spec->buf.tolower(0, 1);
if (spec->buf.length() > 1)
spec->buf.toupper(1);
}
break;
case 'Y':
if (spec->buf.length() > 0)
{
spec->buf.toupper(0, 1);
if (spec->buf.length() > 1)
spec->buf.tolower(1);
}
break;
}
return STATUS_OK;
}
status_t bool_to_str(fmt_spec_t *spec, value_t *v)
{
status_t res = check_specials(spec, v);
if (res != STATUS_OK)
return (res == STATUS_SKIP) ? STATUS_OK : res;
bool success = true;
switch (spec->type)
{
case 'l': success = spec->buf.set_ascii((v->v_bool) ? "true" : "false"); break;
case 'L': success = spec->buf.set_ascii((v->v_bool) ? "TRUE" : "FALSE"); break;
case 'z': success = spec->buf.set_ascii((v->v_bool) ? "tRUE" : "fALSE"); break;
case 'Z': success = spec->buf.set_ascii((v->v_bool) ? "True" : "False"); break;
}
return (success) ? STATUS_OK : STATUS_NO_MEM;
}
status_t emit_parameter(io::IOutSequence *out, fmt_spec_t *spec, const Parameters *r)
{
value_t v;
init_value(&v);
status_t res = STATUS_OK;
// Fetch the value if resolver is present
if (r != NULL)
{
if (spec->flags & F_NAME)
res = r->get(&spec->name, &v);
else
res = r->get(spec->index, &v);
if (res != STATUS_OK)
{
destroy_value(&v);
return res;
}
}
// Cast the value's type
spec->buf.clear();
switch (spec->type)
{
case 'i': case 'd':
res = cast_value(&v, VT_INT);
if (res == STATUS_OK)
res = int_to_dec(spec, &v);
break;
case 'u':
res = cast_value(&v, VT_INT);
if (res == STATUS_OK)
res = uint_to_dec(spec, &v);
break;
case 'b':
res = cast_value(&v, VT_INT);
if (res == STATUS_OK)
res = int_to_bin(spec, &v);
break;
case 'o':
res = cast_value(&v, VT_INT);
if (res == STATUS_OK)
res = int_to_oct(spec, &v);
break;
case 'x': case 'X':
res = cast_value(&v, VT_INT);
if (res == STATUS_OK)
res = int_to_hex(spec, &v);
break;
case 'e': case 'E':
case 'f': case 'F':
res = cast_value(&v, VT_FLOAT);
if (res == STATUS_OK)
res = float_to_str(spec, &v);
break;
case 's': case 'S': case 't': case 'T': case 'y': case 'Y':
res = cast_value(&v, VT_STRING);
if (res == STATUS_OK)
res = text_to_str(spec, &v);
break;
case 'l': case 'L': case 'z': case 'Z':
res = cast_value(&v, VT_BOOL);
if (res == STATUS_OK)
res = bool_to_str(spec, &v);
break;
default:
res = cast_value(&v, VT_STRING);
if (res == STATUS_OK)
res = text_to_str(spec, &v);
break;
}
if (res != STATUS_OK)
{
destroy_value(&v);
return res;
}
// Compute padding
ssize_t lpad = 0, rpad = 0, pad = ssize_t(lsp_max(spec->width, spec->xwidth)) - ssize_t(spec->buf.length());
if ((spec->flags & (F_WIDTH | F_XWIDTH)) && (pad > 0))
{
switch (spec->align)
{
case AL_LEFT:
rpad = pad;
break;
case AL_RIGHT:
lpad = pad;
break;
case AL_MIDDLE:
case AL_FROM_LEFT:
lpad = pad >> 1;
rpad = pad - lpad;
break;
case AL_FROM_RIGHT:
rpad = pad >> 1;
lpad = pad - rpad;
break;
case AL_TO_LEFT:
lpad = pad >> 2;
rpad = pad - lpad;
break;
case AL_TO_RIGHT:
rpad = pad >> 2;
lpad = pad - rpad;
break;
default:
break;
}
}
// Emit value
while (lpad--)
{
if ((res = out->write(spec->lpad)) != STATUS_OK)
{
destroy_value(&v);
return res;
}
}
if ((res = out->write(&spec->buf)) != STATUS_OK)
{
destroy_value(&v);
return res;
}
while (rpad--)
{
if ((res = out->write(spec->rpad)) != STATUS_OK)
{
destroy_value(&v);
return res;
}
}
destroy_value(&v);
return res;
}
status_t format(io::IOutSequence *out, io::IInSequence *fmt, const Parameters *r)
{
if ((out == NULL) || (fmt == NULL))
return STATUS_BAD_ARGUMENTS;
status_t res;
size_t index = 0;
bool protector = false;
fmt_spec_t spec;
init_spec(&spec, index);
while (true)
{
// Read character
lsp_swchar_t c = fmt->read();
if (c < 0)
return (c != -STATUS_EOF) ? -c : STATUS_OK;
switch (c)
{
case '\\':
if (protector)
{
if ((res = out->write('\\')) != STATUS_OK)
return res;
}
protector = !protector;
break;
case '{':
if (protector)
{
if ((res = out->write('{')) != STATUS_OK)
return res;
protector = false;
}
else
{
// Read specifier and format the value
res = read_specifier(out, fmt, &spec);
if (res == STATUS_OK)
{
if ((res = emit_parameter(out, &spec, r)) != STATUS_OK)
return res;
// Reset specifier
if (!(spec.flags & (F_NAME | F_INDEX)))
++index;
}
else if (res != STATUS_BAD_FORMAT)
return res;
init_spec(&spec, index);
}
break;
case '}':
protector = false;
if ((res = out->write('}')) != STATUS_OK)
return res;
break;
default:
if (protector)
{
if ((res = out->write('\\')) != STATUS_OK)
return res;
protector = false;
}
if ((res = out->write(c)) != STATUS_OK)
return res;
break;
} // c
}
}
} /* namespace expr */
} /* namespace lsp */