void IdentifierToken::Parse(std::string &line)
{
char buf[256], *p = buf;
int i, n;
for (i =0; (p == buf || p - buf -1 < sizeof(buf)) && p-buf < line.size() && IsSymbolChar(line.c_str() + i);)
{
n = UTF8::CharSpan(line.c_str() + i);
for (int j=0; j < n && i < line.size(); j++)
*p++ = line[i++];
}
*p = 0;
SetChars(line.substr(0, i));
line.erase(0, i);
id = buf;
if (keywordTable)
{
KeywordHash::const_iterator it ;
if (caseInsensitive)
{
p = buf;
while (*p)
*p = toupper(*p), p++;
std::string id1 = buf;
it = keywordTable->find(id1);
}
else
{
it = keywordTable->find(id);
}
if (it != keywordTable->end())
keyValue = it->second;
}
}
void AsmMain::CheckAssign(std::string &line, PreProcessor &pp)
{
int npos = line.find_first_not_of(" \t\r\n\v");
if (npos != std::string::npos)
{
if (line[npos] == '%')
{
npos = line.find_first_not_of(" \t\r\b\v", npos + 1);
bool caseInsensitive = false;
bool assign = false;
if (npos != std::string::npos)
{
if (line.size() - 7 > npos && line.substr(npos,6) == "assign" && isspace(line[npos+6]))
{
assign = true;
}
else if (line.size() - 8 > npos && line.substr(npos, 7) == "iassign" && isspace(line[npos+7]))
{
assign = true;
caseInsensitive = true;
}
}
if (assign)
{
std::string name;
int value = 0;
npos = line.find_first_not_of(" \t\r\b\v", npos+6 + (caseInsensitive ? 1 : 0));
if (npos == std::string::npos || !IsSymbolStartChar(line.c_str() + npos))
{
Errors::Error("Expected identifier");
}
else
{
int npos1 = npos;
while (npos1 != line.size() && IsSymbolChar(line.c_str() + npos1))
{
int n = UTF8::CharSpan(line.c_str() + npos);
while (n && npos1 < line.size())
npos1 ++,n--;
}
name = line.substr(npos, npos1-npos);
if (!isspace(line[npos1]))
{
Errors::Error("Invalid arguments to %assign");
}
else
{
npos = line.find_first_not_of(" \t\r\n\v", npos1);
if (npos == std::string::npos)
{
Errors::Error("Expected expression");
}
else
{
ppExpr e(false);
value = e.Eval(line.substr(npos));
pp.Assign(name, value, caseInsensitive);
}
}
}
line = "";
}
}
}
}
AString ADVBPatterns::ParsePattern(const AString& _line, PATTERN& pattern, const AString& user)
{
const ADVBConfig& config = ADVBConfig::Get();
ADataList& list = pattern.list;
AString& errors = pattern.errors;
AString line = config.ReplaceTerms(user, _line);
TERM *term;
uint_t i;
pattern.exclude = false;
pattern.enabled = true;
pattern.scorebased = false;
pattern.pri = 0;
pattern.user = user;
pattern.pattern = line;
if (pattern.user.Valid()) {
pattern.pri = (int)config.GetUserConfigItem(pattern.user, "pri");
}
list.DeleteList();
list.SetDestructor(&__DeleteTerm);
i = 0;
while (IsWhiteSpace(line[i])) i++;
if (line[i] == '#') {
pattern.enabled = false;
i++;
}
else if (line[i] == ';') {
return errors;
}
while (IsWhiteSpace(line[i])) i++;
if (line[i]) {
while (line[i] && errors.Empty()) {
if (!IsSymbolStart(line[i])) {
errors.printf("Character '%c' (at %u) is not a legal field start character (term %u)", line[i], i, list.Count() + 1);
break;
}
uint_t fieldstart = i++;
while (IsSymbolChar(line[i])) i++;
AString field = line.Mid(fieldstart, i - fieldstart).ToLower();
while (IsWhiteSpace(line[i])) i++;
if (field == "exclude") {
pattern.exclude = true;
continue;
}
const FIELD *fieldptr = (const FIELD *)ADVBProg::fieldhash.Read(field);
if (!fieldptr) {
uint_t nfields;
const FIELD *fields = ADVBProg::GetFields(nfields);
errors.printf("'%s' (at %u) is not a valid search field (term %u), valid search fields are: ", field.str(), fieldstart, list.Count() + 1);
for (i = 0; i < nfields; i++) {
const FIELD& field = fields[i];
if (i) errors.printf(", ");
errors.printf("'%s'", field.name);
}
break;
}
uint_t opstart = i;
const char *str = line.str() + i;
bool isassign = fieldptr->assignable;
uint_t j;
uint_t opindex = 0, opcode = Operator_EQ;
for (j = 0; j < NUMBEROF(operators); j++) {
if (((isassign == operators[j].assign) ||
(isassign && !operators[j].assign)) &&
(operators[j].fieldtypes & (1U << fieldptr->type)) &&
(strncmp(str, operators[j].str, operators[j].len) == 0)) {
i += operators[j].len;
opindex = j;
opcode = operators[j].opcode;
break;
}
}
while (IsWhiteSpace(line[i])) i++;
AString value;
bool implicitvalue = false;
if (j == NUMBEROF(operators)) {
if (!line[i] || IsSymbolStart(line[i])) {
if (fieldptr->assignable) {
switch (fieldptr->type) {
case FieldType_string:
break;
case FieldType_date:
value = "now";
break;
default:
value = "1";
break;
}
opcode = Operator_Assign;
}
else opcode = Operator_NE;
for (j = 0; j < NUMBEROF(operators); j++) {
if ((opcode == operators[j].opcode) &&
((isassign == operators[j].assign) ||
(isassign && !operators[j].assign)) &&
(operators[j].fieldtypes & (1U << fieldptr->type))) {
opindex = j;
break;
}
}
implicitvalue = true;
}
else {
errors.printf("Symbols at %u do not represent a legal operator (term %u), legal operators for the field '%s' are: ", opstart, list.Count() + 1, field.str());
bool flag = false;
for (j = 0; j < NUMBEROF(operators); j++) {
if (((isassign == operators[j].assign) ||
(isassign && !operators[j].assign)) &&
(operators[j].fieldtypes & (1U << fieldptr->type))) {
if (flag) errors.printf(", ");
errors.printf("'%s'", operators[j].str);
flag = true;
}
}
break;
}
}
if (!implicitvalue) {
char quote = 0;
if (IsQuoteChar(line[i])) quote = line[i++];
uint_t valuestart = i;
while (line[i] && ((!quote && !IsWhiteSpace(line[i])) || (quote && (line[i] != quote)))) {
if (line[i] == '\\') i++;
i++;
}
value = line.Mid(valuestart, i - valuestart).DeEscapify();
if (quote && (line[i] == quote)) i++;
while (IsWhiteSpace(line[i])) i++;
}
bool orflag = false;
if ((line.Mid(i, 2).ToLower() == "or") && IsWhiteSpace(line[i + 2])) {
orflag = true;
i += 2;
while (IsWhiteSpace(line[i])) i++;
}
else if ((line[i] == '|') && IsWhiteSpace(line[i + 1])) {
orflag = true;
i += 1;
while (IsWhiteSpace(line[i])) i++;
}
if ((term = new TERM) != NULL) {
term->data.start = fieldstart;
term->data.length = i - fieldstart;
term->data.field = fieldptr - ADVBProg::fields;
term->data.opcode = opcode;
term->data.opindex = opindex;
term->data.value = value;
term->data.orflag = (orflag && !RANGE(opcode, Operator_First_Assignable, Operator_Last_Assignable));
term->field = fieldptr;
term->datetype = DateType_none;
switch (term->field->type) {
case FieldType_string:
#if DVBDATVERSION > 1
if (fieldptr->offset == ADVBProg::GetTagsDataOffset()) {
value = "|" + value + "|";
}
#endif
if ((opcode & ~Operator_Inverted) == Operator_Regex) {
AString regexerrors;
AString rvalue;
rvalue = ParseRegex(value, regexerrors);
if (regexerrors.Valid()) {
errors.printf("Regex error in value '%s' (term %u): %s", value.str(), list.Count() + 1, regexerrors.str());
}
value = rvalue;
}
term->value.str = value.Steal();
break;
case FieldType_date: {
ADateTime dt;
uint_t specified;
dt.StrToDate(value, ADateTime::Time_Relative_Local, &specified);
//debug("Value '%s', specified %u\n", value.str(), specified);
if (!specified) {
errors.printf("Failed to parse date '%s' (term %u)", value.str(), list.Count() + 1);
break;
}
else if (((specified == ADateTime::Specified_Day) && (stricmp(term->field->name, "on") == 0)) ||
(stricmp(term->field->name, "day") == 0)) {
//debug("Date from '%s' is '%s' (week day only)\n", value.str(), dt.DateToStr().str());
term->value.u64 = dt.GetWeekDay();
term->datetype = DateType_weekday;
}
else if (specified & ADateTime::Specified_Day) {
specified |= ADateTime::Specified_Date;
}
if (term->datetype == DateType_none) {
specified &= ADateTime::Specified_Date | ADateTime::Specified_Time;
if (specified == (ADateTime::Specified_Date | ADateTime::Specified_Time)) {
//debug("Date from '%s' is '%s' (full date and time)\n", value.str(), dt.DateToStr().str());
term->value.u64 = (uint64_t)dt;
term->datetype = DateType_fulldate;
}
else if (specified == ADateTime::Specified_Date) {
//debug("Date from '%s' is '%s' (date only)\n", value.str(), dt.DateToStr().str());
term->value.u64 = dt.GetDays();
term->datetype = DateType_date;
}
else if (specified == ADateTime::Specified_Time) {
//debug("Date from '%s' is '%s' (time only)\n", value.str(), dt.DateToStr().str());
term->value.u64 = dt.GetMS();
term->datetype = DateType_time;
}
else {
errors.printf("Unknown date specifier '%s' (term %u)", value.str(), list.Count() + 1);
}
}
break;
}
case FieldType_span:
case FieldType_age: {
ADateTime dt;
//ADateTime::EnableDebugStrToDate(true);
term->value.u64 = (uint64_t)ADateTime(value, ADateTime::Time_Absolute);
//ADateTime::EnableDebugStrToDate(false);
break;
}
case FieldType_uint32_t:
case FieldType_external_uint32_t:
term->value.u32 = (uint32_t)value;
break;
case FieldType_sint32_t:
case FieldType_external_sint32_t:
term->value.s32 = (sint32_t)value;
break;
case FieldType_uint16_t:
term->value.u16 = (uint16_t)value;
break;
case FieldType_sint16_t:
term->value.s16 = (sint16_t)value;
break;
case FieldType_uint8_t:
term->value.u8 = (uint8_t)(uint16_t)value;
break;
case FieldType_sint8_t:
term->value.s8 = (sint8_t)(sint16_t)value;
break;
case FieldType_flag...FieldType_lastflag:
term->value.u8 = ((uint32_t)value != 0);
//debug("Setting test of flag to %u\n", (uint_t)term->value.u8);
break;
case FieldType_prog: {
ADVBProg *prog;
if ((prog = new ADVBProg) != NULL) {
if (prog->Base64Decode(value)) {
term->value.prog = prog;
}
else {
errors.printf("Failed to decode base64 programme ('%s') for %s at %u (term %u)", value.str(), field.str(), fieldstart, list.Count() + 1);
delete prog;
}
}
else {
errors.printf("Failed to allocate memory for base64 programme ('%s') for %s at %u (term %u)", value.str(), field.str(), fieldstart, list.Count() + 1);
}
break;
}
default:
errors.printf("Unknown field '%s' type (%u) (term %u)", field.str(), (uint_t)term->field->type, list.Count() + 1);
break;
}
//debug("term: field {name '%s', type %u, assignable %u, offset %u} type %u dateflags %u value '%s'\n", term->field->name, (uint_t)term->field->type, (uint_t)term->field->assignable, term->field->offset, (uint_t)term->data.opcode, (uint_t)term->dateflags, term->value.str);
if (errors.Empty()) {
pattern.scorebased |= (term->field->offset == ADVBProg::GetScoreDataOffset());
list.Add((uptr_t)term);
}
else {
__DeleteTerm((uptr_t)term, NULL);
break;
}
}
}
}
int NumericToken::GetNumber(const char **ptr)
{
char buf[256];
char *p = buf ;
int radix = 10;
int floatradix = 0;
bool hasdot = false;
bool floating = false;
if (!isdigit(**ptr) && **ptr != '.')
return INT_MIN;
if (**ptr == '.' && !isdigit(*(*ptr + 1)))
return INT_MIN;
if (**ptr == '0')
{
(*ptr)++;
if (**ptr == 'x' || **ptr == 'X')
{
(*ptr)++;
radix = 16;
}
else
radix = 8;
}
else if (**ptr == '$')
{
radix = 16;
(*ptr)++;
}
while (Radix36(**ptr) < radix || Radix36(**ptr) < 16)
{
*p++ = **ptr;
(*ptr)++;
}
if (**ptr == '.')
{
hasdot = true;
if (radix == 8)
radix = 10;
*p++ = **ptr;
(*ptr)++;
while (Radix36(**ptr) < radix)
{
*p++ = **ptr;
(*ptr)++;
}
}
if ((**ptr == 'e' || **ptr == 'E') && radix != 16)
radix = floatradix = 10;
else if ((**ptr == 'p' || **ptr == 'P') && radix == 16)
{
floatradix = 2;
}
else if (radix == 16 && hasdot)
{
Errors::Error("Invalid floating point constant");
}
if (floatradix)
{
*p++ = **ptr;
(*ptr)++;
if (**ptr == '-' || **ptr == '+')
{
*p++ = **ptr;
(*ptr)++;
}
while (Radix36(**ptr) < 10)
{
*p++ = **ptr;
(*ptr)++;
}
}
*p = 0;
if (!floatradix && radix != 16)
{
char *q = buf;
if (**ptr == 'H' || **ptr == 'h')
{
radix = 16;
(*ptr)++;
while (*q)
if (Radix36(*q++) >= 16)
return INT_MIN;
}
}
p = buf;
/* at this point the next char is any qualifier after the number*/
if (hasdot || floatradix)
{
if (floatradix == 0)
floatradix = radix;
GetFloating(floatValue, floatradix, &p);
floating = true;
}
else
{
if (Radix36(*p) < radix)
intValue = GetBase(radix, &p);
else
{
intValue = 0;
}
}
if (!floating)
{
type = t_int;
if (**ptr == 'i')
{
if (!ansi && (*ptr)[1] == '6' && (*ptr)[2] == '4')
{
(*ptr)++;
(*ptr)++;
(*ptr)++;
type = t_longlongint;
}
}
else if (**ptr == 'U' || **ptr == 'u')
{
(*ptr)++;
type = t_unsignedint;
if (**ptr == 'i')
{
if (!ansi && (*ptr)[1] == '6' && (*ptr)[2] == '4')
{
(*ptr)++;
(*ptr)++;
(*ptr)++;
type = t_unsignedlonglongint;
}
}
else if (**ptr == 'L' || **ptr == 'l')
{
(*ptr)++;
type = t_unsignedlongint;
if (c99 && (**ptr == 'L' || **ptr == 'l'))
{
type = t_unsignedlonglongint;
(*ptr)++;
}
}
}
else if (**ptr == 'L' || **ptr == 'l')
{
type = t_longint;
(*ptr)++;
if (c99 && (**ptr == 'L' || **ptr == 'l'))
{
type = t_longlongint;
(*ptr)++;
if (**ptr == 'U' || **ptr == 'u')
{
type = t_unsignedlonglongint;
(*ptr)++;
}
}
else if (**ptr == 'U' || **ptr == 'u')
{
type = t_unsignedlongint;
(*ptr)++;
}
}
if (type == t_int) /* no qualifiers */
{
if (intValue > INT_MAX)
{
type = t_unsignedint;
if (radix == 10 || (L_UINT)intValue > UINT_MAX)
{
type = t_longint;
if (intValue > LONG_MAX)
{
type = t_unsignedlongint;
if (radix == 10 || (L_UINT)intValue > ULONG_MAX)
{
if (radix == 10)
{
type = t_longlongint;
}
else
type = t_unsignedlonglongint;
}
}
}
}
}
}
else
{
if (**ptr == 'F' || **ptr == 'f')
{
type = t_float;
(*ptr)++;
floatValue.Truncate(FLT_MANT_DIG, FLT_MAX_EXP, FLT_MIN_EXP);
}
else if (**ptr == 'L' || **ptr == 'l')
{
type = t_longdouble;
(*ptr)++;
floatValue.Truncate(LDBL_MANT_DIG, LDBL_MAX_EXP, LDBL_MIN_EXP);
} else
{
type = t_double;
floatValue.Truncate(DBL_MANT_DIG, DBL_MAX_EXP, DBL_MIN_EXP);
}
parsedAsFloat = true;
}
if (IsSymbolChar(*ptr))
{
Errors::Error("Invalid constant value");
while (**ptr && IsSymbolChar(*ptr))
{
int n = UTF8::CharSpan(*ptr);
for (int i=0; i < n && **ptr; i++)
(*ptr++);
}
}
return type;
}
