/*
* Copyright (C) 2023 Linux Studio Plugins Project
* (C) 2023 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 16 сент. 2019 г.
*
* 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
namespace lsp
{
namespace expr
{
typedef struct bareword_t {
const char *text;
token_t token;
} bareword_t;
static const bareword_t barewords[] =
{
{ "abs", TT_ABS },
{ "acos", TT_ACOS },
{ "add", TT_ADDSYM },
{ "and", TT_AND },
{ "arccos", TT_ACOS },
{ "arcsin", TT_ASIN },
{ "arctg", TT_ATAN },
{ "asin", TT_ASIN },
{ "atan", TT_ATAN },
{ "band", TT_BAND },
{ "bnot", TT_BNOT },
{ "bool", TT_BOOL },
{ "bor", TT_BOR },
{ "bxor", TT_BXOR },
{ "cmp", TT_CMP },
{ "cos", TT_COS },
{ "db", TT_DB },
{ "deg", TT_DEG },
{ "div", TT_DIV },
{ "e", TT_E },
{ "eq", TT_EQ },
{ "ex", TT_EX },
{ "exp", TT_EXP },
{ "false", TT_FALSE },
{ "float", TT_FLOAT },
{ "fmod", TT_FMOD },
{ "fp", TT_FLOAT },
{ "ge", TT_GREATER_EQ },
{ "gt", TT_GREATER },
{ "iadd", TT_IADD },
{ "icmp", TT_ICMP },
{ "idiv", TT_IDIV },
{ "ie", TT_IEQ },
{ "ieq", TT_IEQ },
{ "ige", TT_IGREATER_EQ },
{ "igt", TT_IGREATER },
{ "ile", TT_ILESS_EQ },
{ "ilt", TT_ILESS },
{ "imod", TT_IMOD },
{ "imul", TT_IMUL },
{ "ine", TT_INOT_EQ },
{ "inge", TT_ILESS },
{ "ingt", TT_ILESS_EQ },
{ "inle", TT_IGREATER },
{ "inlt", TT_IGREATER_EQ },
{ "int", TT_INT },
{ "isub", TT_ISUB },
{ "lc", TT_SLWR },
{ "le", TT_LESS_EQ },
{ "lg", TT_LOGD },
{ "ln", TT_LOGE },
{ "log", TT_LOGE },
{ "log10", TT_LOGD },
{ "log2", TT_LOG2 },
{ "logb", TT_LOG2 },
{ "logd", TT_LOGD },
{ "loge", TT_LOGE },
{ "lt", TT_LESS },
{ "mod", TT_IMOD },
{ "mul", TT_MUL },
{ "ne", TT_NOT_EQ },
{ "nge", TT_LESS },
{ "ngt", TT_LESS_EQ },
{ "nle", TT_GREATER },
{ "nlt", TT_GREATER_EQ },
{ "not", TT_NOT },
{ "null", TT_NULL },
{ "or", TT_OR },
{ "pi", TT_PI },
{ "pow", TT_POW },
{ "rad", TT_RAD },
{ "sc", TT_SCAT },
{ "scat", TT_SCAT },
{ "sin", TT_SIN },
{ "sl", TT_SLEN },
{ "slen", TT_SLEN },
{ "slwr", TT_SLWR },
{ "sqrt", TT_SQRT },
{ "sr", TT_SREP },
{ "srep", TT_SREP },
{ "srev", TT_SREV },
{ "str", TT_STR },
{ "sub", TT_SUBSYM },
{ "supr", TT_SUPR },
{ "tan", TT_TAN },
{ "tg", TT_TAN },
{ "true", TT_TRUE },
{ "uc", TT_SUPR },
{ "undef", TT_UNDEF },
{ "xor", TT_XOR }
};
Tokenizer::Tokenizer(io::IInSequence *in)
{
pIn = in;
cCurrent = -1;
enToken = TT_UNKNOWN;
nError = STATUS_OK;
fValue = 0;
iValue = 0;
nUnget = 0;
}
Tokenizer::~Tokenizer()
{
pIn = NULL;
}
lsp_swchar_t Tokenizer::lookup()
{
if (cCurrent < 0)
cCurrent = pIn->read();
return cCurrent;
}
token_t Tokenizer::set_error(status_t code)
{
nError = code;
return enToken = TT_ERROR;
}
token_t Tokenizer::commit(token_t token)
{
if (cCurrent < 0)
return set_error(STATUS_BAD_STATE);
if (!sValue.append(cCurrent))
return set_error(STATUS_NO_MEM);
enToken = token;
cCurrent = -1;
return token;
}
lsp_swchar_t Tokenizer::commit_lookup(token_t token)
{
token_t x = commit(token);
return (x != TT_ERROR) ? lookup() : -1;
}
lsp_swchar_t Tokenizer::skip_whitespace()
{
if (cCurrent < 0)
cCurrent = pIn->read();
while (true)
{
// Skip whitespace
switch (cCurrent)
{
case ' ':
case '\t':
case '\n':
case '\r':
cCurrent = pIn->read();
continue;
default:
return cCurrent;
}
}
}
bool Tokenizer::is_identifier_first(lsp_wchar_t ch)
{
if ((ch >= 'a') && (ch <= 'z'))
return true;
if ((ch >= 'A') && (ch <= 'Z'))
return true;
return ch == '_';
}
bool Tokenizer::is_hex(lsp_wchar_t ch)
{
if ((ch >= '0') && (ch <= '9'))
return true;
if ((ch >= 'a') && (ch <= 'f'))
return true;
if ((ch >= 'A') && (ch <= 'F'))
return true;
return false;
}
bool Tokenizer::is_identifier_next(lsp_wchar_t ch)
{
if ((ch >= 'a') && (ch <= 'z'))
return true;
if ((ch >= 'A') && (ch <= 'Z'))
return true;
if ((ch >= '0') && (ch <= '9'))
return true;
return ch == '_';
}
bool Tokenizer::parse_digit(int *digit, lsp_wchar_t ch, int radix)
{
int res;
if ((ch >= '0') && (ch <= '9'))
res = ch - '0';
else if ((ch >= 'a') && (ch <= 'f'))
res = ch - 'a' + 10;
else if ((ch >= 'A') && (ch <= 'F'))
res = ch - 'A' + 10;
else if (ch == '_')
res = -1;
else
return false;
if (res >= radix)
return false;
*digit = res;
return true;
}
token_t Tokenizer::lookup_identifier(token_t type)
{
if (cCurrent < 0)
cCurrent = pIn->read();
if (!is_identifier_first(cCurrent))
return enToken;
sValue.clear();
do
{
// Append character
if (!sValue.append(cCurrent))
return set_error(STATUS_NO_MEM);
// Read next character
if ((cCurrent = pIn->read()) < 0)
{
if (cCurrent == -STATUS_EOF)
break;
return set_error(-cCurrent);
}
} while (is_identifier_next(cCurrent));
return enToken = type;
}
token_t Tokenizer::lookup_string()
{
sValue.clear();
while (cCurrent == '\'')
{
bool protector = false;
bool scan = true;
// Parse string
do
{
// Read character
if ((cCurrent = pIn->read()) < 0)
return set_error(-cCurrent);
if (protector)
{
switch (cCurrent)
{
case '\\':
if (!sValue.append('\\'))
return set_error(STATUS_NO_MEM);
break;
case 'n':
if (!sValue.append('\n'))
return set_error(STATUS_NO_MEM);
break;
case 't':
if (!sValue.append('\t'))
return set_error(STATUS_NO_MEM);
break;
case 'r':
if (!sValue.append('\r'))
return set_error(STATUS_NO_MEM);
break;
case '\'':
if (!sValue.append('\''))
return set_error(STATUS_NO_MEM);
break;
default:
if (!sValue.append('\\'))
return set_error(STATUS_NO_MEM);
if (!sValue.append(cCurrent))
return set_error(STATUS_NO_MEM);
break;
}
protector = false;
}
else
{
switch (cCurrent)
{
case '\\':
protector = true;
break;
case '\'':
scan = false;
cCurrent = -1;
break;
default:
if (!sValue.append(cCurrent))
return set_error(STATUS_NO_MEM);
break;
}
}
} while (scan);
// Skip whitespace after string
skip_whitespace();
}
return enToken = TT_STRING;
}
token_t Tokenizer::lookup_color()
{
if (cCurrent < 0)
cCurrent = pIn->read();
if (!is_hex(cCurrent))
return enToken;
do {
// Append character
if (!sValue.append(cCurrent))
return set_error(STATUS_NO_MEM);
// Read next character
if ((cCurrent = pIn->read()) < 0)
{
if (cCurrent == -STATUS_EOF)
break;
return set_error(-cCurrent);
}
} while (is_hex(cCurrent));
return enToken = TT_COLOR;
}
token_t Tokenizer::lookup_number()
{
enum flags_t
{
F_NEGATIVE = 1 << 0,
F_SIGN = 1 << 1,
F_INT = 1 << 2,
F_DOT = 1 << 3,
F_FRAC = 1 << 4,
F_EXP = 1 << 5,
F_ESIGN = 1 << 6,
F_ENEGATIVE = 1 << 7
};
lsp_swchar_t c = lookup();
size_t flags = 0;
int radix = 10;
int digit = 0;
ssize_t ivalue = 0;
double ifrac = 0;
double ifpow = 1.0;
double rradix = 0.1;
ssize_t iexp = 0;
// Has sign?
if (c == '-')
{
flags |= F_NEGATIVE | F_SIGN;
c = commit_lookup(TT_UNKNOWN);
}
else if (c == '+')
{
flags |= F_SIGN;
c = commit_lookup(TT_UNKNOWN);
}
// Has prefix ?
if (c == '0')
{
c = commit_lookup(TT_UNKNOWN);
switch (c)
{
case 'b': // binary
case 'B':
radix = 2;
rradix = 0.5;
c = commit_lookup(TT_UNKNOWN);
break;
case 'o': // octal
case 'O':
radix = 8;
rradix = 0.125;
c = commit_lookup(TT_UNKNOWN);
break;
case 'd': // decimal
case 'D':
// radix = 10; // assigned above
// rradix = 0.1; // assigned above
c = commit_lookup(TT_UNKNOWN);
break;
case 'x': // hexadecimal
case 'X':
radix = 16;
rradix = 0.0625;
c = commit_lookup(TT_UNKNOWN);
break;
default:
flags |= F_INT;
break;
}
}
// Read the integer part
while (parse_digit(&digit, c, radix))
{
if (digit < 0) // Skip separator
{
if (!(flags & F_INT)) // Allow separators only after the first digit
return commit(TT_UNKNOWN);
}
else
{
ivalue = ivalue*radix + digit;
flags |= F_INT;
}
c = commit_lookup(TT_IVALUE);
}
// Has a fraction part?
if (c == '.')
{
flags |= F_DOT;
c = commit_lookup(TT_FVALUE);
while (parse_digit(&digit, c, radix))
{
if (digit < 0) // Skip separator
{
if (!(flags & F_FRAC)) // Allow separators only after the first digit
return commit(TT_UNKNOWN);
}
else
{
ifpow *= rradix;
ifrac += digit * ifpow;
flags |= F_FRAC;
}
c = commit_lookup(TT_FVALUE);
}
}
// Is there at least INT or FRAC part defined?
if ((flags & (F_INT | F_FRAC)) == 0)
{
if ((flags & (F_SIGN | F_DOT)) == F_SIGN)
return enToken = (flags & F_NEGATIVE) ? TT_SUB : TT_ADD;
return enToken = TT_UNKNOWN;
}
// Has an exponent part?
if ((c == 'e') || (c == 'E') || (c == 'p') || (c == 'P'))
{
c = commit_lookup(TT_FVALUE);
// Has sign?
if (c == '-')
{
flags |= F_ENEGATIVE | F_ESIGN;
c = commit_lookup(TT_UNKNOWN);
}
else if (c == '+')
{
flags |= F_ESIGN;
c = commit_lookup(TT_UNKNOWN);
}
// Parse exponent
while (parse_digit(&digit, c, radix))
{
if (digit < 0) // Skip separator
{
if (!(flags & F_EXP)) // Allow separators only after the first digit
return commit(TT_UNKNOWN);
}
else
{
iexp = iexp*radix + digit;
flags |= F_EXP;
}
c = commit_lookup(TT_FVALUE);
}
// Analyze post-condition: if exponent sign is defined,
// the exponent value also should be defined
if ((flags & (F_ESIGN | F_EXP)) == F_ESIGN)
return enToken = TT_UNKNOWN;
else if (flags & F_ENEGATIVE)
iexp = -iexp;
}
// Now analyze parsing state
if ((flags & (F_INT | F_FRAC | F_EXP | F_DOT)) == F_INT)
{
iValue = (flags & F_NEGATIVE) ? -ivalue : ivalue;
return enToken = TT_IVALUE;
}
// Form the floating-point value
double fv = (double(ivalue) + ifrac) * pow(radix, iexp);
fValue = (flags & F_NEGATIVE) ? -fv : fv;
return enToken = TT_FVALUE;
}
token_t Tokenizer::decode_bareword()
{
const char *text = sValue.get_utf8();
ssize_t first = 0, last = sizeof(barewords)/sizeof(bareword_t) - 1;
while (first <= last)
{
ssize_t center = (first + last) >> 1;
const bareword_t *bw = &barewords[center];
int cmp = ::strcasecmp(text, bw->text);
if (cmp < 0)
last = center - 1;
else if (cmp > 0)
first = center + 1;
else
{
enToken = bw->token;
break;
}
}
return enToken;
}
token_t Tokenizer::get_token(size_t flags)
{
// Pre-checks
if (!(flags & TF_GET))
return enToken;
else if (nUnget > 0)
{
--nUnget;
return enToken;
}
// Skip whitespaces
lsp_swchar_t c = skip_whitespace();
if (c < 0)
{
enToken = (c == -STATUS_EOF) ? TT_EOF : TT_ERROR;
nError = -c;
return enToken;
}
sValue.set_length(0);
// Now analyze first character
switch (c)
{
// Non-alpha
case '(': // TT_LBRACE
return commit(TT_LBRACE);
case ')': // TT_RBRACE
return commit(TT_RBRACE);
case '[': // TT_LQBRACE
return commit(TT_LQBRACE);
case ']': // TT_RQBRACE
return commit(TT_RQBRACE);
case '{': // TT_LCBRACE
return commit(TT_LCBRACE);
case '}': // TT_RCBRACE
return commit(TT_RCBRACE);
case '#': // TT_SHARP
if (!(flags & TF_COLOR))
return commit(TT_SHARP);
commit_lookup(TT_SHARP);
return lookup_color();
case '@': // TT_AT
if (!(flags & TF_COLOR))
return commit(TT_AT);
commit_lookup(TT_AT);
return lookup_color();
case '*': // TT_MUL, TT_POW
{
commit(TT_MUL);
if ((c = lookup()) == '*') // Accept both variants: ^ and ^^
commit(TT_POW);
return enToken;
}
case '/': // TT_DIV
return commit(TT_DIV);
case '%': // TT_MOD
return commit(TT_IMOD);
case '~': // TT_BNOT
return commit(TT_BNOT);
case '?': // TT_QUESTION
return commit(TT_QUESTION);
case '&': // TT_AND
c = commit_lookup(TT_AND);
if (c == '&') // Accept both variants: & and &&
commit(TT_AND);
return enToken;
case '|': // TT_OR
c = commit_lookup(TT_OR);
if (c == '|') // Accept both variants: | and ||
commit(TT_OR);
return enToken;
case '!': // TT_NOT, TT_NOT_EQ
c = commit_lookup(TT_NOT);
if (c == '=') // Check for !=
commit(TT_NOT_EQ);
return enToken;
case '^': // TT_XOR
c = commit_lookup(TT_XOR);
if (c == '^') // Accept both variants: ^ and ^^
commit(TT_XOR);
return enToken;
case '<': // TT_LESS, TT_LESS_EQ, TT_NOT_EQ, TT_CMP
c = commit_lookup(TT_LESS);
if (c == '=') // <=
{
c = commit_lookup(TT_LESS_EQ);
if (c == '>')
commit(TT_CMP);
}
else if (c == '>') // <>
commit(TT_NOT_EQ);
return enToken;
case '>': // TT_GREATER, TT_GREATER_EQ
c = commit_lookup(TT_GREATER);
if (c == '=') // Check for >=
commit(TT_GREATER_EQ);
return enToken;
case '=': // TT_EQ
c = commit_lookup(TT_EQ);
if (c == '=') // Accept both variants: = and ==
commit(TT_EQ);
return enToken;
case ';': // TT_SEMICOLON
return commit(TT_SEMICOLON);
case ',': // TT_COMMA
return commit(TT_COMMA);
case ':': // TT_COLON, TT_IDENTIFIER
{
commit(TT_COLON);
return lookup_identifier(TT_IDENTIFIER);
}
case '\'': // TT_STRING
return lookup_string();
// Defaults
default: // TT_VALUE
{
// Test character
if (flags & TF_XSIGN)
{
if (c == '+')
return commit(TT_ADD);
else if (c == '-')
return commit(TT_SUB);
}
if (!is_identifier_first(c))
return lookup_number();
if (lookup_identifier(TT_BAREWORD) != TT_BAREWORD)
return enToken;
// Do not decode barewords if flags require keyword to exclude
return (flags & TF_XKEYWORDS) ? enToken : decode_bareword();
}
}
return enToken = TT_UNKNOWN;
}
} /* namespace expr */
} /* namespace lsp */