bool CScanner::NextToken()
{
SkipWhiteSpace();
if (ErrorString != "")
return false;
// if (Pos >= SourceLength)
// return false;
_off_t OldPos = Pos;
char c = cget();
if (isdigit(c) || // Thinks a little, while reading this condition, it might be a bit unreadable.
(
(
c == '.' &&
(
(IncPos(), isdigit(cget())) || (DecPos(), false)
)
) &&
(DecPos(), true)
)
)
return ParseNumber() && OldPos != Pos;
else if (isalpha(c) || c == '_')
return ParseIdentifier() && OldPos != Pos;
else if (MatchPrefix("'"))
return ParseCharacterLiteral() && OldPos != Pos;
else if (MatchPrefix("\""))
return ParseStringLiteral() && OldPos != Pos;
else if (SymbolicTokenMapping.find(string() += c))
return ParseSymbol() && OldPos != Pos;
else if (c == 0)
return true;
else
ErrorString = "Unrecognized character at line: ";// + itoa(CurrentLine) + ", Column: " + itoa(CurrentColumn);
return false;
}
/*
================
idDict::RandomPrefix
================
*/
const char *idDict::RandomPrefix( const char *prefix, idRandom &random ) const {
int count;
const int MAX_RANDOM_KEYS = 2048;
const char *list[MAX_RANDOM_KEYS];
const idKeyValue *kv;
list[0] = "";
for( count = 0, kv = MatchPrefix( prefix ); kv && count < MAX_RANDOM_KEYS; kv = MatchPrefix( prefix, kv ) ) {
list[count++] = kv->GetValue().c_str();
}
return list[random.RandomInt( count )];
}
// RAVEN BEGIN
// abahr: added default value param
const char *idDict::RandomPrefix( const char *prefix, idRandom &random, const char* defaultValue ) const {
int count;
const int MAX_RANDOM_KEYS = 2048;
const char *list[MAX_RANDOM_KEYS];
const idKeyValue *kv;
// RAVEN BEGIN
// abahr: added defaultValue param
list[0] = defaultValue;
// RAVEN END
for ( count = 0, kv = MatchPrefix( prefix ); kv && count < MAX_RANDOM_KEYS; kv = MatchPrefix( prefix, kv ) ) {
list[count++] = kv->GetValue().c_str();
}
return list[random.RandomInt( count )];
}
bool CScanner::isNewline()
{
#define MATCH_NEWLINE MatchPrefix("\r\n") || MatchPrefix("\r") || MatchPrefix("\n")
while(MatchPrefix("\\"))
if (!MATCH_NEWLINE)
return DecPos(), false;
return MATCH_NEWLINE;
}
char CScanner::cget()
{
if (Pos < 0 || Pos > SourceLength)
return 0;
while(MatchPrefix("\\"))
if (!MATCH_NEWLINE)
{
DecPos();
break;
}
return Source[Pos];
}
String WsmUtils::getRootResourceUri(const String& resourceUri)
{
CString cstr(resourceUri.getCString());
const char* start = cstr;
const char* end = MatchPrefix(start, WSM_RESOURCEURI_PREFIX_PATTERN);
if (end)
return String(start, end - start - 1);
const int NS = WsmNamespaces::WS_CIM_SCHEMA;
return String(WsmNamespaces::supportedNamespaces[NS].extendedName);
}
bool CScanner::MatchPrefix(const string &Prefix, unsigned int Offset /*= 0*/)
{
if (Offset >= Prefix.length())
return true;
bool Result = false;
if (Source[Pos] == Prefix[Offset])
{
IncPos();
Result = MatchPrefix(Prefix, Offset + 1);
if (!Result)
DecPos();
}
return Result;
}
PEGASUS_NAMESPACE_BEGIN
const char* MatchPrefix(const char* str, const char* pat)
{
const char* p;
const char* q;
/* Now match expression to str. */
for (p = pat, q = str; *p && *q; )
{
if (*p == '*')
{
const char* r;
p++;
/* Recursively call to find the shortest match. */
for (r = q; *r; r++)
{
if (MatchPrefix(r, p))
break;
}
q = r;
}
else if (*p == *q)
{
p++;
q++;
}
else
{
/* No match */
return 0;
}
}
/* If final character of pattern is '*', then match the whole string. */
if (p[0] == '*' && p[1] == '\0')
{
/* Seek the end of string */
while (*q)
q++;
/* Complete match */
return q;
}
/* If pattern not exhausted, then mismatch */
if (*p)
{
/* No match */
return 0;
}
/* Return pointer to first non-matching character. */
return q;
}
