string TgTypeParser::parseMessage(const Message::Ptr& object) const {
if (!object) {
return "";
}
string result;
result += '{';
appendToJson(result, "message_id", object->messageId);
appendToJson(result, "from", parseUser(object->from));
appendToJson(result, "date", object->date);
appendToJson(result, "chat", parseChat(object->chat));
appendToJson(result, "forward_from", parseUser(object->forwardFrom));
appendToJson(result, "forward_date", object->forwardDate);
appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
appendToJson(result, "text", object->text);
appendToJson(result, "audio", parseAudio(object->audio));
appendToJson(result, "document", parseDocument(object->document));
appendToJson(result, "photo", parseArray(&TgTypeParser::parsePhotoSize, object->photo));
appendToJson(result, "sticker", parseSticker(object->sticker));
appendToJson(result, "video", parseVideo(object->video));
appendToJson(result, "contact", parseContact(object->contact));
appendToJson(result, "location", parseLocation(object->location));
appendToJson(result, "new_chat_participant", parseUser(object->newChatParticipant));
appendToJson(result, "left_chat_participant", parseUser(object->leftChatParticipant));
appendToJson(result, "new_chat_title", object->newChatTitle);
appendToJson(result, "new_chat_photo", parseArray(&TgTypeParser::parsePhotoSize, object->newChatPhoto));
appendToJson(result, "delete_chat_photo", object->deleteChatPhoto);
appendToJson(result, "group_chat_created", object->groupChatCreated);
appendToJson(result, "caption", object->caption);
result.erase(result.length() - 1);
result += '}';
return result;
}
//-------------------------------------------------------
void coTParser::parseValue()
{
switch (m_currentToken.m_type)
{
case coTLexer::EToken_RAW_IDENTIFIER:
case coTLexer::EToken_NUMERIC_LITERAL:
case coTLexer::EToken_STRING_LITERAL:
case coTLexer::EToken_TRUE:
case coTLexer::EToken_FALSE:
{
coTSemanticAnalyzer::Value val;
val.m_value = m_currentToken;
m_semanticAnalyzer->onValue(val);
consumeToken();
}
break;
case coTLexer::EToken_LBRACK:
{
parseArray();
}
break;
case coTLexer::EToken_LBRACE:
{
parseSet();
}
break;
default:
{
coFAIL();
}
break;
}
}
QVariant parse()
{
LOG_AS("JSONParser");
if(atEnd()) return QVariant();
QChar c = peek();
if(c == '{')
{
return parseObject();
}
else if(c == '[')
{
return parseArray();
}
else if(c == '\"')
{
return parseString();
}
else if(c == '-' || c.isDigit())
{
return parseNumber();
}
else
{
return parseKeyword();
}
}
// FREE OPERATORS
JsonEntity* JsonParser::fromString( const std::string& rawJson )
{
for( int i=0; i < rawJson.length(); i++ )
{
if( rawJson[i] == '[' )
{
i = parseArray( rawJson, i );
}
else if( rawJson[i] == 't' || rawJson[i] == 'f' )
{
i = parseBool( rawJson, i );
}
else if( rawJson[i] == '{' )
{
i = parseObject( rawJson, i );
}
else if( rawJson[i] == '-' || ( rawJson[i] >= '0' && rawJson[i] <= '9' ) )
{
i = parseNumber( rawJson, i );
}
else if( rawJson[i] == '"' )
{
i = parseString( rawJson, i );
}
}
}
void JsonParser::parseArray( JsonScanner & scanner, std::vector<JsonValue *> * values ) {
static std::string name( "" );
JsonToken token;
try {
token = scanner.getNextToken();
}
catch ( const std::exception & e ) {
throw;
}
JsonValue * value;
try {
value = parseValue( scanner, token, name );
} catch( const std::exception & e ) {
throw;
}
values->push_back( value );
try {
token = scanner.getNextToken();
} catch( const std::exception & e ) {
throw;
}
if( token.getType() == JsonTypes::COMMA ) {
try {
parseArray( scanner, values );
} catch( std::exception & e ) {
throw;
}
} else if ( token.getType() == JsonTypes::CLOSE_BRACKET ) {
} else {
throw ArrayParsingException();
}
}
QString PHPSerializeFormatter::getFormatted()
{
//todo implement this
switch (getType(rawValue))
{
case Null:
return "NULL";
case Integer:
case Double:
return parseDecimal(rawValue);
case Boolean:
return (parseDecimal(rawValue) == "1")? "true" : "false";
case String:
return parseString(rawValue);
case Array:
return parseArray(rawValue);
case Object:
return parseObject(rawValue);
case Invalid:
default:
return "Invalid or corrupted serialize string";
}
}
static bool parseImpl(const char* json, int length, tinyjson_token_type type, Impl* impl) {
impl->type = type;
if (type == MYJSON_TOKEN_STRING || type == MYJSON_TOKEN_LITERAL) {
impl->value.str = json;
impl->value.len = length;
return true;
}
int ntokens = tinyjson_parse_err(json, length, 0, 0);
if (ntokens == -1)
return false;
if (ntokens == 0)
return true;
std::vector<tinyjson_token> tokens(ntokens);
tinyjson_parse(json, length, &tokens[0], ntokens);
switch (type) {
case MYJSON_TOKEN_OBJECT:
return parseObject(json, &tokens[0], ntokens, impl);
case MYJSON_TOKEN_ARRAY:
return parseArray(json, &tokens[0], ntokens, impl);
case MYJSON_TOKEN_STRING:
case MYJSON_TOKEN_LITERAL:
break;
}
return false;
}
void DataValue::parse(const ustring &text, DataType type, void *value) {
switch(type) {
case data_int:
case data_combo:
case data_flags:
case data_comboEx:
*(int *)value = atoi(text.c_str());
break;
case data_str:
if(text[0] == '"')
((ustring*)value)->assign(text, 1, text.length() - 2);
else if(text[0] == '#')
parseStrList(text, value);
else
*(ustring*)value = text;
break;
case data_stock:
case data_element:
if(text[0] == '"')
((ustring*)value)->assign(text, 1, text.length() - 2);
else
*(ustring*)value = text;
break;
case data_real:
*(double *)value = atof(text.c_str());
break;
case data_data: {
int i;
static const int dtypes[] = { data_int, data_str, data_real };
for(int t = 0; t < 3; t++)
if(strncmp(text.c_str(), dataNames[dtypes[t]], i = strlen(dataNames[dtypes[t]])) == 0) {
ustring s = ustring(text, i+1, text.length() - i - 2);
switch(t) {
case 0: *(TData*)value = atoi(s.c_str()); break;
case 1: *(TData*)value = s; break;
case 2: *(TData*)value = atof(s.c_str()); break;
}
}
break;
}
case data_list:
parseStrList(text, value);
break;
case data_pixbuf:
parsePixbuf(text, value);
break;
case data_array:
parseArray(text, value);
break;
case data_color:
((TypeColor*)value)->set(text);
break;
case data_font:
parseFont(text, value);
break;
default:
;
}
}
void ScriptHandler::declareDim()
{
current_script = next_script;
char *buf = current_script;
if (current_array_variable){
current_array_variable->next = new ArrayVariable();
current_array_variable = current_array_variable->next;
}
else{
root_array_variable = new ArrayVariable();
current_array_variable = root_array_variable;
}
ArrayVariable array;
current_array_variable->no = parseArray( &buf, array );
int dim = 1;
current_array_variable->num_dim = array.num_dim;
for ( int i=0 ; i<array.num_dim ; i++ ){
current_array_variable->dim[i] = array.dim[i]+1;
dim *= (array.dim[i]+1);
}
current_array_variable->data = new int[dim];
memset( current_array_variable->data, 0, sizeof(int) * dim );
next_script = buf;
}
Base *Reader::parseExpression()
{
skipWhitespace();
auto c = current();
if(c == kObjectBegin) {
return parseObject();
} else if(c == kArrayBegin) {
return parseArray();
} else if(c == kStringBegin) {
return parseString();
} else if(is_number(c, true)) {
return parseNumber();
} else if(borrow(gTrueString->length())->isEqual(gTrueString)) {
fastForward(gTrueString->length() - 1);
return Number::True();
} else if(borrow(gFalseString->length())->isEqual(gFalseString)) {
fastForward(gFalseString->length() - 1);
return Number::False();
} else if(borrow(gNullString->length())->isEqual(gNullString)) {
fastForward(gNullString->length() - 1);
return Null::shared();
} else {
fail(String::Builder() << "unexpected '" << c << "'.");
}
return nullptr;
}
CCObject *CCJson::parseValue(Json *pJsonValue) {
if (!pJsonValue) {return NULL;}
CCObject *object = NULL;
switch (pJsonValue->type) {
case Json_False:
object = CCBool::create(false);
break;
case Json_True:
object = CCBool::create(true);
break;
case Json_NULL:
object = NULL;
break;
case Json_Number:
object = CCFloat::create(pJsonValue->valueFloat);
break;
case Json_String:
if (pJsonValue->valueString) {
object = CCString::create(pJsonValue->valueString);
}
break;
case Json_Array:
object = parseArray(pJsonValue);
break;
case Json_Object:
object = parseObject(pJsonValue->child);
break;
default:
object = NULL;
break;
}
return object;
}
void ScriptHandler::declareDim()
{
current_script = next_script;
const char* buf = current_script;
array_ref arr = parseArray(&buf);
arrays.insert(std::make_pair(arr.first, ArrayVariable(this, arr.second)));
next_script = buf;
}
inline bool ArduinoJson::Internals::JsonParser<TReader, TWriter>::parseArrayTo(
JsonVariant *destination) {
JsonArray &array = parseArray();
if (!array.success()) return false;
*destination = array;
return true;
}
static Result parseAny (String::CharPointerType& t, var& result)
{
t = t.findEndOfWhitespace();
auto t2 = t;
switch (t2.getAndAdvance())
{
case '{': t = t2; return parseObject (t, result);
case '[': t = t2; return parseArray (t, result);
case '"': t = t2; return parseString ('"', t, result);
case '\'': t = t2; return parseString ('\'', t, result);
case '-':
t2 = t2.findEndOfWhitespace();
if (! CharacterFunctions::isDigit (*t2))
break;
t = t2;
return parseNumber (t, result, true);
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
return parseNumber (t, result, false);
case 't': // "true"
if (t2.getAndAdvance() == 'r' && t2.getAndAdvance() == 'u' && t2.getAndAdvance() == 'e')
{
t = t2;
result = var (true);
return Result::ok();
}
break;
case 'f': // "false"
if (t2.getAndAdvance() == 'a' && t2.getAndAdvance() == 'l'
&& t2.getAndAdvance() == 's' && t2.getAndAdvance() == 'e')
{
t = t2;
result = var (false);
return Result::ok();
}
break;
case 'n': // "null"
if (t2.getAndAdvance() == 'u' && t2.getAndAdvance() == 'l' && t2.getAndAdvance() == 'l')
{
t = t2;
result = var();
return Result::ok();
}
break;
default:
break;
}
return createFail ("Syntax error", &t);
}
inline static JSONValue parseValue(const char* string)
{
JSONValue value;
//Parsing Bools
if (strcmp(string, "true") == 0)
{
value = true;
}
else if (strcmp(string, "false") == 0)
{
value = false;
}
//Parsing strings
else if (string[0] == '\"')
{
int valStringLen = strlen(string) - 1;
char* valueString = new char[valStringLen];
memcpy(valueString, string + 1, valStringLen);
valueString[valStringLen - 1] = '\0';
value = valueString;
}
//Parsing Objects
else if (string[0] == '{')
{
value = parseObject(string);
}
//Parsing Arrays
else if(string[0] == '[')
{
value = parseArray(string);
}
//Parsing null
else if (strcmp(string, "null") == 0)
{
value = 0;
}
//Parsing numbers
else if (strstr(string, "."))
{
float *floatVal = new float;
*floatVal = (float)atof(string);
value = *floatVal;
}
else
{
int* intVal = new int;
*intVal = atoi(string);
value = *intVal;
}
return value;
}
/**
* Parse a simple value, an array or an object.
* @param in Input stream.
* @param t Last token.
*/
void Parser::parseValue(io::InStream& in, token_t t) throw(json::Exception) {
switch(t) {
case LBRACE: m.beginObject(); parseObject(in); return;
case LBRACK: m.beginArray(); parseArray(in); return;
case _NULL: m.onNull(); return;
case TRUE: { m.onValue(true); return; }
case FALSE: { m.onValue(false); return; }
case INT: { int i; text >> i; m.onValue(i); return; }
case FLOAT: { double d; text >> d; m.onValue(d); return; }
case STRING: { m.onValue(text); return; }
default: error("unexpected symbol");
}
}
dynamic parseValue(Input& in) {
in.skipWhitespace();
return *in == '[' ? parseArray(in) :
*in == '{' ? parseObject(in) :
*in == '\"' ? parseString(in) :
(*in == '-' || (*in >= '0' && *in <= '9')) ? parseNumber(in) :
in.consume("true") ? true :
in.consume("false") ? false :
in.consume("null") ? nullptr :
in.consume("Infinity") ? std::numeric_limits<double>::infinity() :
in.consume("NaN") ? std::numeric_limits<double>::quiet_NaN() :
in.error("expected json value");
}
static Result parseObjectOrArray (String::CharPointerType t, var& result)
{
t = t.findEndOfWhitespace();
switch (t.getAndAdvance())
{
case 0: result = var::null; return Result::ok();
case '{': return parseObject (t, result);
case '[': return parseArray (t, result);
}
return createFail ("Expected '{' or '['", &t);
}
JsonValue * JsonParser::parseValue( JsonScanner & scanner,
const JsonToken & token, const std::string & name ) {
int iValue;
double rValue;
bool bValue;
std::vector<JsonValue *> * values;
std::vector<JsonValue *> * members;
switch( token.getType() ) {
case JsonTypes::INTEGER:
iValue = atoi( token.getToken().c_str() );
return new JsonValue( name, iValue );
break;
case JsonTypes::REAL:
rValue = atof( token.getToken().c_str() );
return new JsonValue( name, rValue );
break;
case JsonTypes::BOOLEAN:
bValue = token.getToken() == "true" ? true : false;
return new JsonValue( name, bValue );
break;
case JsonTypes::STRING:
return new JsonValue( name, token.getToken() );
break;
case JsonTypes::OPEN_BRACKET:
values = new std::vector<JsonValue *>();
try {
parseArray( scanner, values );
} catch( const std::exception & e ) {
delete values;
throw;
}
return new JsonValue( name, values );
break;
case JsonTypes::NULLTYPE:
break;
case JsonTypes::OPEN_BRACE:
members = new std::vector<JsonValue *>();
try {
parseMembers( scanner, members );
} catch( const std::exception & e ) {
delete members;
throw;
}
return new JsonValue( name, new JsonObject( members ) );
break;
default:
throw ValueParsingException();
break;
}
}
//-----------------------------------------------------------------------------
// Parser core - when encountering text, process appropriately.
const char* JSON::parseValue(const char* buff, const char** perror)
{
if (perror)
*perror = 0;
if (!buff)
return NULL; // Fail on null.
if (!strncmp(buff,"null",4))
{
Type = JSON_Null;
return buff+4;
}
if (!strncmp(buff,"false",5))
{
Type = JSON_Bool;
Value = "false";
dValue = 0.;
return buff+5;
}
if (!strncmp(buff,"true",4))
{
Type = JSON_Bool;
Value = "true";
dValue = 1.;
return buff + 4;
}
if (*buff=='\"')
{
return parseString(buff, perror);
}
if (*buff=='-' || (*buff>='0' && *buff<='9'))
{
return parseNumber(buff);
}
if (*buff=='[')
{
return parseArray(buff, perror);
}
if (*buff=='{')
{
return parseObject(buff, perror);
}
return AssignError(perror, "Syntax Error: Invalid syntax");
}
/**
parse response from slave. There are two connections between proxy and slave, one to transfer
slave to master data, the other for proxy to query slave and get responses. This function
deals with the latter situation.
**/
void parseReadData(aeEventLoop *el, int fd, int mask, struct WData *wdata){
int index = 0;
int flag = 0;
struct WData *processData = wdata;
if(buf_slave_answer.len > 0){
if(buf_slave_answer.len + wdata->len < MAX_READ * 2){
struct WData merge_buf_cmd;
flag = 1;
merge_buf_cmd.len=buf_slave_answer.len + wdata->len ;
merge_buf_cmd.data=(char*) calloc(merge_buf_cmd.len, sizeof(char));
strncpy(merge_buf_cmd.data, buf_slave_answer.data, buf_slave_answer.len);
strncpy(merge_buf_cmd.data + buf_slave_answer.len, wdata->data , wdata->len );
processData = &merge_buf_cmd;
}
buf_slave_answer.len=0;
}
while(index >= 0 && index < processData->len){
if(processData->data[index] == '*'){
index = parseArray(processData, index);
}
else if(processData->data[index] == '$'){
index = parseBulkString(processData, index);
}
else if(processData->data[index] == '-' || processData->data[index] == '+' || processData->data[index] == ':'){
index = parseSimple(processData, index);
}
else{
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "query data unexpected index %d, total %d at line %d in file %s, data %s", index, processData->len, __LINE__, __FILE__, processData->data);
printf("query data unexpected index %d, total %d\n", index, processData->len);
int i;
for(i = 0; i < index; i++)
printf("%c", processData->data[i]);
printf("\n index %d\n", processData->data[index]);
for(i = index + 1; i < processData->len; i++){
printf("%c", processData->data[i]);
}
printf(" end\n");
break;
}
}
if(flag){
free(processData->data);
}
}
Value load(std::istream& ss) {
// Parse a JSON entity, using the inputstream ss
parseWhitespace(ss);
switch (ss.peek()) {
case '{': return parseObject(ss);
case '[': return parseArray(ss);
case '"': return parseString(ss);
case 't': return parseTrue(ss);
case 'f': return parseFalse(ss);
case 'n': return parseNull(ss);
case '-': return parseNumber(ss);
default:
if(isdigit(ss.peek())) {
return parseNumber(ss);
} else {
throw ParseError(std::string("unexpected token: '")+char(ss.peek())+"'");
}
}
}
void ScriptHandler::readVariable( bool reread_flag )
{
end_status = END_NONE;
current_variable.type = VAR_NONE;
if ( reread_flag ) next_script = current_script;
current_script = next_script;
char *buf = current_script;
SKIP_SPACE(buf);
bool ptr_flag = false;
if ( *buf == 'i' || *buf == 's' ){
ptr_flag = true;
buf++;
}
if ( *buf == '%' ){
buf++;
current_variable.var_no = parseInt(&buf);
if (current_variable.var_no < 0 ||
current_variable.var_no >= VARIABLE_RANGE)
current_variable.var_no = VARIABLE_RANGE;
current_variable.type = VAR_INT;
}
else if ( *buf == '?' ){
ArrayVariable av;
current_variable.var_no = parseArray( &buf, av );
current_variable.type = VAR_ARRAY;
current_variable.array = av;
}
else if ( *buf == '$' ){
buf++;
current_variable.var_no = parseInt(&buf);
if (current_variable.var_no < 0 ||
current_variable.var_no >= VARIABLE_RANGE)
current_variable.var_no = VARIABLE_RANGE;
current_variable.type = VAR_STR;
}
if (ptr_flag) current_variable.type |= VAR_PTR;
next_script = checkComma(buf);
}
dynamic parseValue(Input& in) {
RecursionGuard guard(in);
in.skipWhitespace();
return *in == '[' ? parseArray(in) :
*in == '{' ? parseObject(in) :
*in == '\"' ? parseString(in) :
(*in == '-' || (*in >= '0' && *in <= '9')) ? parseNumber(in) :
in.consume("true") ? true :
in.consume("false") ? false :
in.consume("null") ? nullptr :
in.consume("Infinity") ?
(in.getOpts().parse_numbers_as_strings ? (dynamic)"Infinity" :
(dynamic)std::numeric_limits<double>::infinity()) :
in.consume("NaN") ?
(in.getOpts().parse_numbers_as_strings ? (dynamic)"NaN" :
(dynamic)std::numeric_limits<double>::quiet_NaN()) :
in.error("expected json value");
}
// Parser core - when encountering text, process appropriately.
const char*
aJsonClass::parseValue(aJsonObject *item, const char *value)
{
if (!value)
return NULL; // Fail on null.
if (!strncmp(value, "null", 4))
{
item->type = aJson_NULL;
return value + 4;
}
if (!strncmp(value, "false", 5))
{
item->type = aJson_False;
item->value.valuebool = 0;
return value + 5;
}
if (!strncmp(value, "true", 4))
{
item->type = aJson_True;
item->value.valuebool = 1;
return value + 4;
}
if (*value == '\"')
{
return parseString(item, value);
}
if (*value == '-' || (*value >= '0' && *value <= '9'))
{
return parseNumber(item, value);
}
if (*value == '[')
{
return parseArray(item, value);
}
if (*value == '{')
{
return parseObject(item, value);
}
return 0; // failure.
}
Var Var::parse(const std::string& val, std::string::size_type& pos)
{
// { -> an Object==DynamicStruct
// [ -> an array
// '/" -> a string (strip '/")
// other: also treat as string
skipWhiteSpace(val, pos);
if (pos < val.size())
{
switch (val[pos])
{
case '{':
return parseObject(val, pos);
case '[':
return parseArray(val, pos);
default:
return parseString(val, pos);
}
}
std::string empty;
return empty;
}
Object Parser::parse(const std::string & str)
{
if(str == "null")
return Object(Object::Null);
if(str == "true" || str == "false")
return Object(Object::Bool, str);
if(str[0] == '"')
return Object(Object::String, str.substr(1, str.length() - 2));
if((str[0] >= 48 && str[0] <= 57) || str[0] == '-')
return Object(Object::Number, str);
if(str[0] == '[')
return parseArray(str);
if(str[0] == '{')
return parseHash(str);
throw Error((boost::format("Не удалось распознать тип: `%1%'") % str).str());
return Object();
}
JSValue LiteralParser::parseExpression()
{
StackGuard guard(this);
if (!guard.isSafe())
return abortParse();
switch (m_lexer.currentToken().type) {
case TokLBracket:
return parseArray();
case TokLBrace:
return parseObject();
case TokString: {
Lexer::LiteralParserToken stringToken = m_lexer.currentToken();
m_lexer.next();
return jsString(m_exec, UString(stringToken.start + 1, stringToken.end - stringToken.start - 2));
}
case TokNumber: {
Lexer::LiteralParserToken numberToken = m_lexer.currentToken();
m_lexer.next();
return jsNumber(m_exec, UString(numberToken.start, numberToken.end - numberToken.start).toDouble());
}
default:
return JSValue();
}
}
void json_value::deserialize(std::stringstream &input, memory_pool &pool)
{
assert(m_type == JSON_UNINIT);
input >> std::ws;
char c = input.peek();
switch(c)
{
case '{':
m_type = JSON_OBJECT;
parseObject(input, pool);
break;
case '[':
m_type = JSON_ARRAY;
parseArray(input, pool);
break;
case '"':
m_type = JSON_STRING;
parseString(input, pool);
break;
case 't':
case 'f':
m_type = JSON_BOOL;
parseBool(input);
break;
case 'n':
m_type = JSON_NULL;
parseNull(input);
break;
default:
m_type = JSON_NUMBER;
parseNumber(input);
break;
}
}
int ScriptHandler::parseInt(const char** buf)
{
int ret = 0;
SKIP_SPACE(*buf);
if (**buf == '%') {
(*buf)++;
current_variable.var_no = parseInt(buf);
current_variable.type = VAR_INT;
return getVariableData(current_variable.var_no).get_num();
}
else if (**buf == '?') {
array_ref arr = parseArray(buf);
current_variable.var_no = arr.first;
current_variable.array = arr.second;
current_variable.type = VAR_ARRAY;
ArrayVariable::iterator i = arrays.find(arr.first);
if (i != arrays.end()) {
if (arr.second.size() < i->second.dimensions())
arr.second.push_back(0);
return i->second.getValue(arr.second);
}
return 0;
}
else {
char ch;
pstring alias_buf;
int alias_no = 0;
bool direct_num_flag = false;
bool num_alias_flag = false;
bool hex_num_flag = (*buf)[0] == '0' && (*buf)[1] == 'x';
if (hex_num_flag) *buf += 2;
const char* buf_start = *buf;
while (1) {
ch = **buf;
if (hex_num_flag && isaxdigit(ch)) {
alias_no *= 16;
if (isadigit(ch)) alias_no += ch - '0';
else if (isupper(ch)) alias_no += ch - 'A' + 10;
else alias_no += ch - 'a' + 10;
}
else if (isadigit(ch)) {
if (!num_alias_flag) direct_num_flag = true;
if (direct_num_flag)
alias_no = alias_no * 10 + ch - '0';
else
alias_buf += ch;
}
else if (isalpha(ch) || ch == '_') {
if (ch >= 'A' && ch <= 'Z') ch += 'a' - 'A';
if (hex_num_flag || direct_num_flag) break;
num_alias_flag = true;
alias_buf += ch;
}
else break;
(*buf)++;
}
if (*buf - buf_start == 0) {
current_variable.type = VAR_NONE;
return 0;
}
/* ---------------------------------------- */
/* Solve num aliases */
if (num_alias_flag) {
numalias_t::iterator a = num_aliases.find(alias_buf);
if (a == num_aliases.end()) {
printf("can't find num alias for %s... assume 0.\n",
(const char*) alias_buf);
current_variable.type = VAR_NONE;
*buf = buf_start;
return 0;
}
else {
alias_no = a->second;
}
}
current_variable.type = VAR_INT | VAR_CONST;
ret = alias_no;
}
SKIP_SPACE(*buf);
return ret;
}
