bool STG_StartParsing(const char* inname, const char* outname) {
g_allocNodes.resize(128);
g_inname = inname;
bool done = false;
while(!done) {
NextToken();
if(STG_TOK_EOF == g_nextToken) done = true;
if(STG_TOK_STRUCT == g_nextToken) {
if(g_root) {
printf("STG_StartParsing: multiple top-level structs in '%s', abort.\n", inname);
return false;
}
if(!(g_root = ParseStruct())) return false;
}
}
// add proxy name for root
assert("" == g_root->name);
g_root->name = "state";
STG_ComputeChildIndices(g_root);
STG_WriteStateDesc(g_root, outname);
FreeNodes();
return true;
}
/**
* parse every possible value. this method parses every possible value (defined by the xmlrpc standard)
* and returns it. This is done by calling the special functions ParsePrimitive(), ParseArray()
* and ParseStruct().
* @param p XmlParser holding the xml document
* @return the parsed Value
*/
Value XmlRpcParser::Parse(XmlParser& p) {
Value v;
p.PassTag("value");
if(p.Tag("struct")) {
v=ParseStruct(p);
p.PassEnd(); //struct
}
else if(p.Tag("array")) {
v=ParseArray(p);
p.PassEnd(); //array
}
else
v=ParsePrimitive(p);
p.PassEnd(); //value
return Value(v);
}
static StateDescNode* ParseStruct(void) {
StateDescNode* node = AllocNode();
NextToken();
if(!ExpectToken(STG_TOK_IDENT)) return NULL;
node->typeName = yystgtext;
node->vartype = SFT_STRUCT;
NextToken();
if(!ExpectToken(STG_TOK_LBRACE)) return NULL;
StateDescNode* child = NULL;
StateDescNode* lastChild = NULL;
bool done = false;
while(!done) {
child = NULL;
NextToken();
if(STG_TOK_VARTYPE == g_nextToken) {
child = AllocNode();
child->vartype = stg_fieldType;
NextToken();
if(!ExpectToken(STG_TOK_IDENT)) return NULL;
child->name = yystgtext;
NextToken();
if(!ExpectToken(STG_TOK_SEMICOL)) return NULL;
} else if(STG_TOK_STRUCT == g_nextToken) {
if(!(child = ParseStruct())) return NULL;
} else if(STG_TOK_RBRACE == g_nextToken) {
NextToken();
if(STG_TOK_IDENT == g_nextToken) {
node->name = yystgtext;
NextToken();
}
if(!ExpectToken(STG_TOK_SEMICOL)) return NULL;
done = true;
}
if(child) {
if(!node->children) node->children = child;
if(lastChild) lastChild->siblings = child;
lastChild = child;
child->parent = node;
node->numChildren++;
}
}
return node;
}
SymbolType * Parser :: ParseType(bool param){
Token *token = scan.Get();
SymbolType *type = nullptr;
bool Const = false;
if ( token->Value =="typedef"){
scan.Next();
type = ParseType();
token = scan.Get();
type = new TypedefSymbol(type, token->Value);
symStack->add_symbol(type);
scan.Next();
return type;
}
while(token->Value == "const"){
Const = true;
token = scan.GetNext();
// ParseDeclaration();
}
if (token->Value == "double"){
token = new Token("float", _FLOAT, "float", "float", token->num, token->line);
}
if(token->Value == "struct")
type = ParseStruct(param);
else {
type = dynamic_cast<SymbolType*>(symStack->find_type(token->Value));
errorIf(type == nullptr, "Unknown type", token);
}
while(isEq(scan.GetNext(), _OPERATION, "*")){
type = new PointerSymbol(type);
token = scan.Get();
}
if(Const){
type = new ConstSymbolType(type);
}
return type;
}
Term*
Parser::ParseTermBase()
{
Token t = lexer->Get();
int n = 0;
double d = 0.0;
switch (t.type()) {
case Token::IntLiteral: {
if (dump_tokens)
Print("%s", t.symbol().data());
char nstr[256], *p = nstr;
for (int i = 0; i < (int) t.symbol().length(); i++)
if (t.symbol()[i] != '_')
*p++ = t.symbol()[i];
*p++ = '\0';
// handle hex notation:
if (nstr[1] == 'x')
n = xtol(nstr+2);
else
n = atol(nstr);
return new(__FILE__, __LINE__) TermNumber(n);
}
case Token::FloatLiteral: {
if (dump_tokens)
Print("%s", t.symbol().data());
char nstr[256], *p = nstr;
for (int i = 0; i < (int) t.symbol().length(); i++)
if (t.symbol()[i] != '_')
*p++ = t.symbol()[i];
*p++ = '\0';
d = atof(nstr);
return new(__FILE__, __LINE__) TermNumber(d);
}
case Token::StringLiteral:
if (dump_tokens)
Print("%s", t.symbol().data());
return new(__FILE__, __LINE__) TermText(t.symbol()(1, t.symbol().length()-2));
case Token::AlphaIdent:
if (dump_tokens)
Print("%s", t.symbol().data());
return new(__FILE__, __LINE__) TermText(t.symbol());
case Token::Keyword:
if (dump_tokens)
Print("%s", t.symbol().data());
switch (t.key()) {
case KEY_FALSE: return new(__FILE__, __LINE__) TermBool(0);
case KEY_TRUE: return new(__FILE__, __LINE__) TermBool(1);
case KEY_MINUS: {
Token next = lexer->Get();
if (next.type() == Token::IntLiteral) {
if (dump_tokens)
Print("%s", next.symbol().data());
char nstr[256], *p = nstr;
for (int i = 0; i < (int) next.symbol().length(); i++)
if (next.symbol()[i] != '_')
*p++ = next.symbol()[i];
*p++ = '\0';
n = -1 * atol(nstr);
return new(__FILE__, __LINE__) TermNumber(n);
}
else if (next.type() == Token::FloatLiteral) {
if (dump_tokens)
Print("%s", next.symbol().data());
char nstr[256], *p = nstr;
for (int i = 0; i < (int) next.symbol().length(); i++)
if (next.symbol()[i] != '_')
*p++ = next.symbol()[i];
*p++ = '\0';
d = -1.0 * atof(nstr);
return new(__FILE__, __LINE__) TermNumber(d);
}
else {
lexer->PutBack();
return error("(Parse) illegal token '-': number expected", next);
}
}
break;
default:
lexer->PutBack();
return 0;
}
case Token::LParen: return ParseArray();
case Token::LBrace: return ParseStruct();
case Token::CharLiteral:
return error("(Parse) illegal token ", t);
default:
lexer->PutBack();
return 0;
}
}
