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; } }