bool EvaluatePOET::match_lookahead(POETCode* r1, POETCode* cur_filter) { #ifdef DEBUG_LOOKAHEAD std::cerr << "trying to match " << r1->toString() << " with lookahead:" << cur_filter->toString() << "\n"; #endif POETCode* r1_first = get_head(r1); switch (cur_filter->get_enum()) { case SRC_STRING: case SRC_ICONST: return (cur_filter == r1_first); case SRC_CVAR: /* a code template token */ return (r1_first->get_enum() == SRC_CVAR && static_cast<CodeVar*>(r1_first)->get_entry() == static_cast<CodeVar*>(cur_filter)->get_entry()); case SRC_TYPE: return (match_Type(r1_first, static_cast<POETType*>(cur_filter), MATCH_AST_PATTERN)); case SRC_TUPLE: /*QY: multiple lookahead tokens*/ { POETTuple* tuple = static_cast<POETTuple*>(cur_filter); for (unsigned i = 0; i < tuple->size(); ++i) { if (!match_lookahead(r1_first, tuple->get_entry(i))) return false; r1_first = NextToken(r1); } return true; } case SRC_OP: { POETParseList* parse = dynamic_cast<POETParseList*>(cur_filter); if (parse != 0) return parse->match_lookahead(this,r1); } default: std::cerr << "Unexpected: " << cur_filter->toString() << "\n"; assert(0); } return false; }
void set_code_xform_parameters( Entry e, POETCode* par) { POETCode* p = e.get_param(); if (p == 0) e.set_param(par); else { if (p != par && !match_AST(p, par, MATCH_AST_EQ)) { std::cerr << "par=" << par << "; p = " << p << "\n"; SYM_DIFF_DEFINED(par->get_className() + ":" + par->toString(OUTPUT_VAR_VAL), p->get_className() + ":" + p->toString(OUTPUT_VAR_VAL)); } return; } switch (par->get_enum()) { case SRC_LVAR: static_cast<LocalVar*>(par)->get_entry().set_code(ASTFactory::inst()->new_iconst(0)); break; case SRC_TUPLE: { POETTuple* vec = static_cast<POETTuple*>(par); for (unsigned i = 0; i < vec->size(); ++i) { LocalVar* cur_par = dynamic_cast<LocalVar*>(vec->get_entry(i)); assert (cur_par != 0); cur_par->get_entry().set_code(ASTFactory::inst()->new_iconst(i) ); } break; } default: assert(false); } }
bool ExamineParseFunctionResult() { if (res != 0 && res != EMPTY) { POETTuple* vec = dynamic_cast<POETTuple*>(res); if (vec == 0 || vec->size() != 2) EXIT("ERROR: Parsing function must return a (code, rest-of-input) pair : " + res->toString() + "\n"); POETCode*res1 = vec->get_entry(1); POETCode*res0 = vec->get_entry(0); if (res1 != 0 && res1 != EMPTY && fullmatch == 0) { return false; } r1 = res1; res = res0; return true; } return false; }
POETCode_ext_delegate(POETCode_ext* e, std::ostream& _out) : out(_out) { SgNode* input = (SgNode*)e->get_content(); POETCode* children = e->get_children(); POETTuple* t = dynamic_cast<POETTuple*>(children); AstInterface::AstList c = AstInterface::GetChildrenList(input); if (t == 0) { assert(c.size() == 1); SgNode* cur = (SgNode*)(c[0]); if (POETAstInterface::find_Ast2POET(cur) != children) repl[cur] = children; } else { int i=0; for (AstInterface::AstList::const_iterator p = c.begin(); p != c.end(); ++p,++i) { SgNode* cur = (SgNode*)(*p); POETCode *cur2 = t->get_entry(i); if (POETAstInterface::find_Ast2POET(cur) != cur2) repl[cur] = cur2; } } }
void CodeVar:: set_attr() { if (attr != 0) { POETTuple * attrTuple = dynamic_cast<POETTuple*>(attr); if (attrTuple == 0) { LocalVar* var = entry.get_attr(0); assert (var != 0); var->get_entry().set_code(attr); } else { unsigned size = attrTuple->size(); for (unsigned i = 0; i < size; ++i) { LocalVar* var = entry.get_attr(i); assert(var != 0); var->get_entry().set_code(attrTuple->get_entry(i)); } } } }
void POETAstInterface::unparse(POETCode_ext* n, std::ostream& out, int align) { static SgUnparse_Info info; static Unparser* roseUnparser = 0; static POETCode* linebreak=ASTFactory::inst()->new_string("\n"); static POETCode* comma=ASTFactory::inst()->new_string(","); static bool template_only=false; static POETCode* left_over = 0; SgNode * input = (SgNode*)n->get_content(); POETCode* res = POETAstInterface::find_Ast2POET(input); if (res == n) { if (template_only && input->variantT() == V_SgFunctionDeclaration) { left_over = LIST(n,left_over); } else { std::string res = input->unparseToCompleteString(); out << res; } } else { if (roseUnparser == 0) { /* QY/2013: copied from the global unparseFile to use a different ostream and delegate*/ bool UseAutoKeyword = false; bool generateLineDirectives = true; bool useOverloadedOperators = false; bool num = false; bool _this = true; bool caststring = false; bool _debug = false; bool _class = false; bool _forced_transformation_format = false; bool _unparse_includes = false; Unparser_Opt roseOptions( UseAutoKeyword, generateLineDirectives, useOverloadedOperators, num, _this, caststring, _debug, _class, _forced_transformation_format, _unparse_includes ); roseUnparser = new Unparser(&out, "", roseOptions); } switch (input->variantT()) { case V_SgSourceFile: { SgSourceFile* f = isSgSourceFile(input); info.set_current_scope(f->get_globalScope()); template_only = true; code_gen(out, n->get_children(), 0, 0, align); template_only = false; if (left_over != 0) { code_gen(out, left_over, 0, 0, align); left_over = 0; } break; } case V_SgFunctionDeclaration: if (template_only) { left_over = LIST(n, left_over); break; } case V_SgTemplateInstantiationFunctionDecl: { SgFunctionDeclaration* d = isSgFunctionDeclaration(input); roseUnparser->u_exprStmt->unparseAttachedPreprocessingInfo(d,info,PreprocessingInfo::before); POETCode_ext_delegate repl(n, out); roseUnparser->repl = &repl; roseUnparser->u_exprStmt->unparseFuncDeclStmt(d, info); break; } case V_SgFunctionDefinition: { SgStatement* d = isSgStatement(input); POETCode_ext_delegate repl(n, out); roseUnparser->repl = &repl; roseUnparser->u_exprStmt->unparseStatement(d, info); assert(n->get_children() != n); out << "{"; code_gen(out, linebreak, 0, 0, align + 2); code_gen(out, n->get_children(), 0, linebreak, align+2); code_gen(out, linebreak, 0, 0, align); out << "}"; break; } case V_SgPragmaDeclaration: { out << "#pragma "; POETTuple* c = dynamic_cast<POETTuple*>(n->get_children()); assert(c != 0); code_gen(out, c->get_entry(0)); roseUnparser->cur << " "; roseUnparser->cur.insert_newline(1,align); code_gen(out, c->get_entry(1), 0, 0, align); break; } case V_SgForStatement: { out << "for (" ; POETTuple* c = dynamic_cast<POETTuple*>(n->get_children()); assert(c != 0); code_gen(out, c->get_entry(0)); code_gen(out, c->get_entry(1)); out << ";"; code_gen(out, c->get_entry(2)); out << ")"; break; } case V_SgExprStatement: code_gen(out, n->get_children(), 0, 0, align); out << ";"; break; case V_SgTemplateInstantiationMemberFunctionDecl: break; default: std::cerr << "Unsupported unparsing for : " << input->class_name() << input->unparseToString() << "\n"; //assert(0); } } }