void
CompassAnalyses::NoVariadicFunctions::Traversal::
visit(SgNode* node)
{
switch( node->variantT() )
{
case V_SgFunctionRefExp:
{
SgFunctionRefExp *fref = isSgFunctionRefExp(node);
ROSE_ASSERT(fref != NULL);
SgFunctionDeclaration *fdecl = fref->get_symbol()->get_declaration();
this->functionDeclarationHandler(
fdecl, fref );
} break; //case V_SgFunctionRefExp
case V_SgMemberFunctionRefExp:
{
SgMemberFunctionRefExp *fref = isSgMemberFunctionRefExp(node);
ROSE_ASSERT(fref != NULL);
SgFunctionDeclaration *fdecl = fref->get_symbol()->get_declaration();
this->functionDeclarationHandler(
fdecl, fref );
} break; //case V_SgMemberFunctionRefExp
default: break;
} //switch( node->variantT() )
return;
} //End of the visit function.
int main( int argc, char * argv[] )
{
// Build the AST used by ROSE
SgProject* project = frontend(argc,argv);
ROSE_ASSERT(project != NULL);
// Build a list of functions within the AST
Rose_STL_Container<SgNode*> functionCallList = NodeQuery::querySubTree (project,V_SgFunctionCallExp);
int functionCounter = 0;
for (Rose_STL_Container<SgNode*>::iterator i = functionCallList.begin(); i != functionCallList.end(); i++)
{
SgExpression* functionExpression = isSgFunctionCallExp(*i)->get_function();
ROSE_ASSERT(functionExpression != NULL);
SgFunctionRefExp* functionRefExp = isSgFunctionRefExp(functionExpression);
SgFunctionSymbol* functionSymbol = NULL;
if (functionRefExp != NULL)
{
// Case of non-member function
functionSymbol = functionRefExp->get_symbol();
}
else
{
// Case of member function (hidden in rhs of binary dot operator expression)
SgDotExp* dotExp = isSgDotExp(functionExpression);
ROSE_ASSERT(dotExp != NULL);
functionExpression = dotExp->get_rhs_operand();
SgMemberFunctionRefExp* memberFunctionRefExp = isSgMemberFunctionRefExp(functionExpression);
ROSE_ASSERT(memberFunctionRefExp != NULL);
functionSymbol = memberFunctionRefExp->get_symbol();
}
ROSE_ASSERT(functionSymbol != NULL);
SgFunctionDeclaration* functionDeclaration = functionSymbol->get_declaration();
ROSE_ASSERT(functionDeclaration != NULL);
// Output mapping of function calls to function declarations
printf ("Location of function call #%d at line %d resolved by overloaded function declared at line %d \n",
functionCounter++,
isSgFunctionCallExp(*i)->get_file_info()->get_line(),
functionDeclaration->get_file_info()->get_line());
}
return 0;
}
bool
checkIfNodeMaps(token_type tok, SgNode* node)
{
bool nodeMaps = false;
using namespace boost::wave;
//By definition a compiler generated node can
//not map to the token stream
SgLocatedNode* compilerGeneratedNode = isSgLocatedNode(node);
if( compilerGeneratedNode != NULL )
if(compilerGeneratedNode->get_file_info()->isCompilerGenerated() == true)
return false;
// std::cout << get_token_name(tok) << " " << std::string(tok.get_value().c_str()) << " " << node->class_name() << " " << node->get_file_info()->get_line() << std::endl;
//Mapping literal token id's
switch(token_id(tok)){
case T_PP_NUMBER:{
if(isSgValueExp(node)!=NULL)
nodeMaps=true;
break;
}
case T_CHARLIT:{
if( ( isSgCharVal(node) != NULL ) |
( isSgUnsignedCharVal(node) != NULL )
)
nodeMaps = true;
break;
}
case T_FLOATLIT:{
if( isSgFloatVal(node) != NULL )
nodeMaps = true;
break;
}
case T_INTLIT:{
if( ( isSgIntVal(node) != NULL ) ||
( isSgUnsignedIntVal(node) != NULL )
)
nodeMaps = true;
break;
}
case T_LONGINTLIT:
{
if( ( isSgLongIntVal(node) != NULL ) |
( isSgLongLongIntVal(node) != NULL ) |
( isSgUnsignedLongLongIntVal(node) != NULL )
)
nodeMaps = true;
break;
}
case T_STRINGLIT:
{
if( isSgStringVal(node) != NULL )
nodeMaps = true;
break;
}
case T_QUESTION_MARK:
{
if( isSgConditionalExp(node) != NULL )
nodeMaps = true;
break;
}
case T_FALSE:
case T_TRUE:
if( isSgBoolValExp(node) != NULL )
nodeMaps = true;
break;
default:
break;
}
//map keyword token id's
switch(token_id(tok)){
case T_ASM:
if( isSgAsmStmt(node) != NULL )
nodeMaps = true;
break;
case T_AUTO: //auto
//dont know
break;
/*case T_BOOL:
//dont think this can be mapped
break;*/
case T_BREAK:
if( isSgBreakStmt(node) != NULL )
nodeMaps = true;
break;
case T_CASE:
if( isSgCaseOptionStmt(node) != NULL )
nodeMaps = true;
break;
case T_CATCH:
if( isSgCatchOptionStmt(node) != NULL )
nodeMaps = true;
break;
/*
case T_CHAR:
//dont know
break;
*/
case boost::wave::T_CLASS:
if( isSgClassDeclaration(node) != NULL )
nodeMaps = true;
break;
case T_CONST:
// is it SgConstVolatileModifier?
//dont know
break;
case T_CONTINUE:
if( isSgContinueStmt(node) != NULL )
nodeMaps = true;
break;
//case T_DEFAULT:
//Dont know
// break;
case T_DELETE:
if( isSgDeleteExp(node) != NULL )
nodeMaps = true;
break;
case T_DO:
if( isSgDoWhileStmt(node) != NULL )
nodeMaps = true;
break;
case T_ELSE:
//dont know
break;
case T_EXPLICIT:
//dont know
break;
case T_EXPORT:
case T_EXTERN:
break;
case T_FOR:
if( isSgForStatement(node) != NULL )
nodeMaps = true;
break;
case T_FRIEND:
//dont know
break;
case T_GOTO:
if( isSgGotoStatement(node) != NULL )
nodeMaps = true;
break;
case T_IF:
//dont know how to handle this because if if-else
break;
case T_INLINE:
//dont know
break;
case T_MUTABLE:
//dont know
break;
case T_NAMESPACE:
if( ( isSgNamespaceAliasDeclarationStatement(node) != NULL ) |
(isSgNamespaceDeclarationStatement(node) != NULL )
)
nodeMaps = true;
break;
case T_NEW:
if( isSgNewExp(node) != NULL )
nodeMaps = true;
break;
case T_OPERATOR:
case T_PRIVATE:
case T_PROTECTED:
case T_PUBLIC:
case T_REGISTER:
case T_REINTERPRETCAST:
//dont know
break;
case T_RETURN:
if( isSgReturnStmt(node) != NULL )
nodeMaps = true;
break;
case T_SIZEOF:
if( isSgSizeOfOp(node) != NULL )
nodeMaps = true;
break;
case T_STATIC:
case T_STATICCAST:
//dont know
break;
case T_STRUCT:
if( isSgClassDeclaration(node) != NULL )
nodeMaps = true;
break;
case T_SWITCH:
if( isSgSwitchStatement(node) != NULL )
nodeMaps = true;
break;
//case T_TEMPLATE:
//dont know
// break;
case T_THIS:
if( isSgThisExp(node) != NULL )
nodeMaps = true;
break;
case T_THROW:
if( isSgThrowOp(node) != NULL )
nodeMaps = true;
break;
case T_TRY:
if( isSgTryStmt(node) != NULL )
nodeMaps = true;
break;
case boost::wave::T_TYPEDEF:
if( isSgTypedefDeclaration(node) != NULL )
nodeMaps = true;
break;
case T_TYPEID:
if( isSgTypeIdOp(node) != NULL )
nodeMaps = true;
break;
case T_TYPENAME:
//dont know
break;
case T_UNION:
if( isSgClassDeclaration(node) != NULL )
nodeMaps = true;
break;
case T_USING:
if( isSgUsingDeclarationStatement(node) != NULL )
nodeMaps = true;
break;
case T_VIRTUAL:
//dont know
break;
case T_VOLATILE:
//is it SgConstVolatileModifier ?
break;
case T_WHILE:
if( isSgWhileStmt(node) != NULL )
nodeMaps = true;
break;
default:
break;
}
//map operator token id's
switch(token_id(tok)){
case T_AND:
case T_ANDAND:
if( isSgAndOp(node) != NULL | isSgBitAndOp(node) != NULL )
nodeMaps = true;
break;
case T_ASSIGN:
if ( isSgAssignOp(node) != NULL | isSgAssignInitializer(node) != NULL )
nodeMaps = true;
break;
case T_ANDASSIGN:
//do not know
break;
case T_OR:
if ( isSgBitOrOp(node) != NULL || isSgOrOp(node) != NULL )
nodeMaps = true;
break;
case T_ORASSIGN:
//do not know
break;
case T_XOR:
if ( isSgBitXorOp(node) != NULL )
nodeMaps = true;
break;
case T_XORASSIGN:
if ( isSgXorAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_COMMA:
if ( isSgCommaOpExp(node) != NULL )
nodeMaps = true;
break;
case T_COLON:
//dont know
break;
case T_DIVIDE:
if ( isSgDivideOp(node) != NULL )
nodeMaps = true;
break;
case T_DIVIDEASSIGN:
if ( isSgDivAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_DOT:
if ( isSgDotExp(node) != NULL )
nodeMaps = true;
break;
case T_DOTSTAR:
if ( isSgDotExp(node) != NULL )
nodeMaps = true;
break;
case T_ELLIPSIS:
//Dont know
break;
case T_EQUAL:
if ( isSgEqualityOp(node) != NULL )
nodeMaps = true;
break;
case T_GREATER:
if ( isSgGreaterThanOp(node) != NULL )
nodeMaps = true;
break;
case T_GREATEREQUAL:
if ( isSgGreaterOrEqualOp(node) != NULL )
nodeMaps = true;
break;
case T_LEFTBRACE:
//Dont know
break;
case T_LESS:
if ( isSgLessThanOp(node) != NULL )
nodeMaps = true;
break;
case T_LESSEQUAL:
if ( isSgLessOrEqualOp(node) != NULL )
nodeMaps = true;
break;
case T_LEFTPAREN:
//Dont know
break;
case T_LEFTBRACKET:
case T_RIGHTBRACKET:
if ( isSgPntrArrRefExp(node) != NULL )
nodeMaps = true;
break;
case T_MINUS:
if ( ( isSgSubtractOp(node) != NULL ) |
( isSgMinusOp(node) != NULL ) )
nodeMaps = true;
break;
case T_MINUSASSIGN:
if ( isSgMinusAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_MINUSMINUS:
if ( isSgMinusMinusOp(node) != NULL )
nodeMaps = true;
break;
case T_PERCENT:
if ( isSgModOp(node) != NULL )
nodeMaps = true;
break;
case T_PERCENTASSIGN:
if ( isSgModAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_NOT:
if ( isSgNotOp(node) != NULL )
nodeMaps = true;
break;
case T_NOTEQUAL:
if ( isSgNotEqualOp(node) != NULL )
nodeMaps = true;
break;
case T_OROR:
if ( isSgOrOp(node) != NULL )
nodeMaps = true;
break;
case T_PLUS:
if ( isSgAddOp(node) != NULL )
nodeMaps = true;
break;
case T_PLUSASSIGN:
if ( isSgPlusAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_PLUSPLUS:
if ( isSgPlusPlusOp(node) != NULL )
nodeMaps = true;
break;
case T_ARROW:
if ( isSgArrowExp(node) != NULL )
nodeMaps = true;
break;
case T_ARROWSTAR:
if ( isSgArrowStarOp(node) != NULL )
nodeMaps = true;
break;
case T_QUESTION_MARK:
//dont know
break;
case T_RIGHTBRACE:
case T_RIGHTPAREN:
case T_COLON_COLON:
case T_SEMICOLON:
//dont know
break;
case T_SHIFTLEFT:
if ( isSgLshiftOp(node) != NULL )
nodeMaps = true;
break;
case T_SHIFTLEFTASSIGN:
if ( isSgLshiftAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_SHIFTRIGHT:
if ( isSgRshiftOp(node) != NULL )
nodeMaps = true;
break;
case T_SHIFTRIGHTASSIGN:
if ( isSgRshiftAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_STAR:
//dont know
if ( isSgMultiplyOp(node) != NULL || isSgPointerType(node) )
nodeMaps = true;
break;
case T_COMPL://~
if( isSgBitComplementOp(node) != NULL )
nodeMaps = true;
//Dont know
break;
case T_STARASSIGN:
if ( isSgMultAssignOp(node) != NULL )
nodeMaps = true;
break;
case T_POUND_POUND:
case T_POUND:
//dont know
break;
case T_AND_ALT:
case T_ANDASSIGN_ALT:
case T_OR_ALT:
case T_ORASSIGN_ALT:
case T_XOR_ALT:
case T_XORASSIGN_ALT:
case T_LEFTBRACE_ALT:
case T_LEFTBRACKET_ALT:
case T_NOT_ALT:
case T_NOTEQUAL_ALT:
case T_RIGHTBRACE_ALT:
case T_RIGHTBRACKET_ALT:
case T_COMPL_ALT:
case T_POUND_POUND_ALT:
case T_POUND_ALT:
case T_OR_TRIGRAPH:
case T_XOR_TRIGRAPH:
case T_LEFTBRACE_TRIGRAPH:
case T_LEFTBRACKET_TRIGRAPH:
case T_RIGHTBRACE_TRIGRAPH:
case T_RIGHTBRACKET_TRIGRAPH:
case T_COMPL_TRIGRAPH:
case T_POUND_POUND_TRIGRAPH:
case T_POUND_TRIGRAPH:
//dont know
break;
default:
break;
}
switch(token_id(tok)){
case T_FALSE:
case T_TRUE:
break;
case T_CHARLIT:
if(SgProject::get_verbose() >= 1)
std::cout << "char " << std::string(tok.get_value().c_str()) << std::endl;
if( isSgCharVal(node) != NULL ){
SgCharVal* charVal = isSgCharVal(node);
if(SgProject::get_verbose() >= 1)
std::cout << std::string(tok.get_value().c_str()) << std::endl;
char tmp = charVal->get_value();
if(SgProject::get_verbose() >= 1)
std::cout << "From charlit: " << tmp << std::endl;
if(("\""+std::string(&tmp)+"\"") == std::string(tok.get_value().c_str()) )
nodeMaps = true;
}
break;
case T_STRINGLIT:
{
if(SgProject::get_verbose() >= 1)
std::cout << "string " <<std::string(tok.get_value().c_str()) << std::endl;
if( isSgStringVal(node) != NULL ){
SgStringVal* stringVal = isSgStringVal(node);
if(SgProject::get_verbose() >= 1){
std::cout << std::string(tok.get_value().c_str()) << std::endl;
std::cout << "stringlit: " << stringVal->get_value() << std::endl;
}
if(("\""+stringVal->get_value()+"\"") == std::string(tok.get_value().c_str()) )
nodeMaps = true;
}
break;
}
/*case V_SgWcharVal:
if( isSgWcharVal(node) != NULL )
if( std::string(isSgWcharVal(node)->get_value()) == std::string(tok.get_value().c_str()) )
nodeMaps = true;
break;*/
default:
break;
}
if( token_id(tok) == T_IDENTIFIER ){
if( isSgInitializedName(node) != NULL ){
std::cout << "Identifier" << std::endl;
SgInitializedName* initName = isSgInitializedName(node);
std::cout << initName->get_name().getString() << " " << std::string(tok.get_value().c_str()) << std::endl;
if( initName->get_name().getString() == std::string(tok.get_value().c_str()) ){
nodeMaps = true;
}
}else if( isSgVarRefExp(node) != NULL ){
SgVariableSymbol* varSymbol = isSgVarRefExp(node)->get_symbol();
SgInitializedName* initName = varSymbol->get_declaration();
if( initName->get_name().getString() == std::string(tok.get_value().c_str()) ){
nodeMaps = true;
std::cout << "Maps:" << initName->get_name().getString() << " " << std::string(tok.get_value().c_str())
<< std::endl;
}else
std::cout << "DONT Map:" << initName->get_name().getString() << " " << std::string(tok.get_value().c_str())
<< std::endl;
}else if( isSgFunctionRefExp(node) != NULL){
SgFunctionRefExp* funcRef = isSgFunctionRefExp(node);
SgFunctionSymbol* funcSymbol = funcRef->get_symbol_i();
if( funcSymbol->get_declaration()->get_name().getString() == std::string(tok.get_value().c_str()) )
nodeMaps = true;
}else if( isSgMemberFunctionRefExp(node) != NULL){
SgMemberFunctionRefExp* funcRef = isSgMemberFunctionRefExp(node);
SgMemberFunctionSymbol* funcSymbol = funcRef->get_symbol();
if( funcSymbol->get_declaration()->get_name().getString() == std::string(tok.get_value().c_str()) )
nodeMaps = true;
}
}
//Exceptions to the general rule
switch(token_id(tok)){
case T_CHARLIT:
{
switch(node->variantT())
{
case V_SgCharVal:
case V_SgComplexVal:
case V_SgDoubleVal:
case V_SgEnumVal:
case V_SgFloatVal:
case V_SgIntVal:
case V_SgLongDoubleVal:
case V_SgLongIntVal:
case V_SgLongLongIntVal:
case V_SgShortVal:
case V_SgStringVal:
case V_SgUnsignedCharVal:
case V_SgUnsignedIntVal:
case V_SgUnsignedLongLongIntVal:
case V_SgUnsignedLongVal:
case V_SgUnsignedShortVal:
case V_SgWcharVal:
{
nodeMaps=true;
break;
}
default:
break;
};
break;
};
}
switch(boost::wave::token_id(tok)){
case boost::wave::T_CHAR:
{
if(isSgTypeChar(node) != NULL)
nodeMaps=true;
break;
}
case boost::wave::T_CONST:
break;
case boost::wave::T_DOUBLE:
if(isSgTypeDouble(node) != NULL)
nodeMaps=true;
break;
case boost::wave::T_INT:
if(isSgTypeInt(node) != NULL)
nodeMaps=true;
break;
case boost::wave::T_LONG:
if(isSgTypeLong(node) != NULL)
nodeMaps=true;
break;
case boost::wave::T_SHORT:
if(isSgTypeShort(node) != NULL)
nodeMaps=true;
break;
case boost::wave::T_SIGNED:
case boost::wave::T_UNSIGNED:
case boost::wave::T_VOID:
if(isSgTypeVoid(node) != NULL)
nodeMaps=true;
break;
default:
break;
};
return nodeMaps;
}
int
main( int argc, char * argv[] )
{
// Initialize and check compatibility. See rose::initialize
ROSE_INITIALIZE;
// Build the AST used by ROSE
SgProject* project = frontend(argc,argv);
// Build a list of functions within the AST
Rose_STL_Container<SgNode*> memberFunctionDeclarationList = NodeQuery::querySubTree (project,V_SgMemberFunctionDeclaration);
int counter = 0;
for (Rose_STL_Container<SgNode*>::iterator i = memberFunctionDeclarationList.begin(); i != memberFunctionDeclarationList.end(); i++)
{
// Build a pointer to the current type so that we can call the get_name() member function.
SgMemberFunctionDeclaration* memberFunctionDeclaration = isSgMemberFunctionDeclaration(*i);
ROSE_ASSERT(memberFunctionDeclaration != NULL);
if (memberFunctionDeclaration->get_functionModifier().isVirtual() == true)
{
printf ("Virtual Member Function #%2d name is %s at line %d \n",
counter++,memberFunctionDeclaration->get_name().str(),
memberFunctionDeclaration->get_file_info()->get_line());
}
else
{
printf ("Non-virtual Member Function #%2d name is %s at line %d \n",
counter++,memberFunctionDeclaration->get_name().str(),
memberFunctionDeclaration->get_file_info()->get_line());
}
}
Rose_STL_Container<SgNode*> memberFunctionRefExpList = NodeQuery::querySubTree (project,V_SgMemberFunctionRefExp);
counter = 0;
for (Rose_STL_Container<SgNode*>::iterator i = memberFunctionRefExpList.begin(); i != memberFunctionRefExpList.end(); i++)
{
// Build a pointer to the current type so that we can call the get_name() member function.
SgMemberFunctionRefExp* memberFunctionRefExp = isSgMemberFunctionRefExp(*i);
ROSE_ASSERT(memberFunctionRefExp != NULL);
SgFunctionSymbol* functionSymbol = memberFunctionRefExp->get_symbol();
ROSE_ASSERT(functionSymbol != NULL);
SgDeclarationStatement* declaration = functionSymbol->get_declaration();
ROSE_ASSERT(declaration != NULL);
SgMemberFunctionDeclaration* memberFunctionDeclaration = isSgMemberFunctionDeclaration(declaration);
ROSE_ASSERT(memberFunctionDeclaration != NULL);
SgMemberFunctionDeclaration* nondefiningMemberFunctionDeclaration = isSgMemberFunctionDeclaration(memberFunctionDeclaration->get_firstNondefiningDeclaration());
if (nondefiningMemberFunctionDeclaration->get_functionModifier().isVirtual() == true)
{
printf ("Virtual function call #%2d name is %s at line %d MemberDeclaration at line = %d \n",
counter++,nondefiningMemberFunctionDeclaration->get_name().str(),
memberFunctionRefExp->get_file_info()->get_line(),
nondefiningMemberFunctionDeclaration->get_file_info()->get_line());
}
else
{
printf ("Non-virtual function call #%2d name is %s at line %d MemberDeclaration at line = %d \n",
counter++,nondefiningMemberFunctionDeclaration->get_name().str(),
memberFunctionRefExp->get_file_info()->get_line(),
nondefiningMemberFunctionDeclaration->get_file_info()->get_line());
}
}
return 0;
}
POETCode* POETAstInterface::Ast2POET(const Ast& n)
{
static SgTemplateInstantiationFunctionDecl* tmp=0;
SgNode* input = (SgNode*) n;
if (input == 0) return EMPTY;
POETCode* res = POETAstInterface::find_Ast2POET(input);
if (res != 0) return res;
{
SgProject* sageProject=isSgProject(input);
if (sageProject != 0) {
int filenum = sageProject->numberOfFiles();
for (int i = 0; i < filenum; ++i) {
SgSourceFile* sageFile = isSgSourceFile(sageProject->get_fileList()[i]);
SgGlobal *root = sageFile->get_globalScope();
SgDeclarationStatementPtrList declList = root->get_declarations ();
POETCode* curfile = ROSE_2_POET_list(declList, 0, tmp);
curfile = new POETCode_ext(sageFile, curfile);
POETAstInterface::set_Ast2POET(sageFile, curfile);
res=LIST(curfile, res);
}
POETAstInterface::set_Ast2POET(sageProject,res);
return res;
} }
{
SgBasicBlock* block = isSgBasicBlock(input);
if (block != 0) {
res=ROSE_2_POET_list(block->get_statements(), res, tmp);
POETAstInterface::set_Ast2POET(block, res);
return res;
} }
{
SgExprListExp* block = isSgExprListExp(input);
if (block != 0) {
res=ROSE_2_POET_list(block->get_expressions(), 0, tmp);
POETAstInterface::set_Ast2POET(block, res);
return res;
} }
{
SgForStatement *f = isSgForStatement(input);
if (f != 0) {
POETCode* init = ROSE_2_POET_list(f->get_for_init_stmt()->get_init_stmt(),0, tmp);
POETCode* ctrl = new POETCode_ext(f, TUPLE3(init,Ast2POET(f->get_test_expr()), Ast2POET(f->get_increment())));
res = CODE_ACC("Nest", PAIR(ctrl,Ast2POET(f->get_loop_body())));
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgVarRefExp * v = isSgVarRefExp(input);
if (v != 0) {
res = STRING(v->get_symbol()->get_name().str());
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgMemberFunctionRefExp * v = isSgMemberFunctionRefExp(input);
if (v != 0) {
res = STRING(v->get_symbol()->get_name().str());
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgIntVal * v = isSgIntVal(input);
if (v != 0) {
res = ICONST(v->get_value());
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgInitializedName* var = isSgInitializedName(input);
if (var != 0) {
POETCode* name = STRING(var->get_name().str());
POETCode* init = Ast2POET(var->get_initializer());
res = new POETCode_ext(var, PAIR(name,init));
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
/*
{
std::string fname;
AstInterface::AstList params;
AstNodeType returnType;
AstNodePtr body;
if (AstInterface :: IsFunctionDefinition( input, &fname, ¶ms, (AstInterface::AstList*)0, &body, (AstInterface::AstTypeList*)0, &returnType)) {
if (body != AST_NULL)
std::cerr << "body not empty:" << fname << "\n";
POETCode* c = TUPLE4(STRING(fname), ROSE_2_POET_list(0,params,0),
STRING(AstInterface::GetTypeName(returnType)),
Ast2POET(body.get_ptr()));
res = new POETCode_ext(input, c);
POETAstInterface::set_Ast2POET(input,res);
return res;
} }
*/
AstInterface::AstList c = AstInterface::GetChildrenList(input);
switch (input->variantT()) {
case V_SgCastExp:
case V_SgAssignInitializer:
res = Ast2POET(c[0]);
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgDotExp:
{
POETCode* v1 = Ast2POET(c[1]);
if (dynamic_cast<POETString*>(v1)->get_content() == "operator()")
return Ast2POET(c[0]);
res = CODE_ACC("Bop",TUPLE3(STRING("."), Ast2POET(c[0]), v1)); return res;
}
case V_SgLessThanOp:
res = CODE_ACC("Bop",TUPLE3(STRING("<"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgSubtractOp:
res = CODE_ACC("Bop",TUPLE3(STRING("-"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgAddOp:
res = CODE_ACC("Bop",TUPLE3(STRING("+"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgMultiplyOp:
res = CODE_ACC("Bop",TUPLE3(STRING("*"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgDivideOp:
res = CODE_ACC("Bop",TUPLE3(STRING("/"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgAssignOp:
res = CODE_ACC("Assign",PAIR(Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgFunctionCallExp:
res = CODE_ACC("FunctionCall",PAIR(Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
}
POETCode * c2 = 0;
if (tmp == 0) tmp=isSgTemplateInstantiationFunctionDecl(input);
switch (c.size()) {
case 0: break;
case 1: c2 = Ast2POET(c[0]); break;
case 2: c2 = PAIR(Ast2POET(c[0]),Ast2POET(c[1])); break;
case 3: c2 = TUPLE3(Ast2POET(c[0]),Ast2POET(c[1]),Ast2POET(c[2])); break;
case 4: c2 = TUPLE4(Ast2POET(c[0]),Ast2POET(c[1]),Ast2POET(c[2]),Ast2POET(c[3])); break;
default:
//std::cerr << "too many children: " << c.size() << ":" << input->unparseToString() << "\n";
c2 = EMPTY;
}
if (tmp == input) tmp = 0;
res = new POETCode_ext(input, c2);
POETAstInterface::set_Ast2POET(input,res);
return res;
}
SgFunctionDeclaration *
getFunctionDeclaration(SgFunctionCallExp *functionCall)
{
SgFunctionDeclaration *funcDec = NULL;
SgExpression *expression = functionCall->get_function();
ROSE_ASSERT(expression != NULL);
switch(expression->variantT()) {
case V_SgMemberFunctionRefExp:
{
SgMemberFunctionRefExp *memberFunctionRefExp =
isSgMemberFunctionRefExp(expression);
ROSE_ASSERT(memberFunctionRefExp != NULL);
funcDec = memberFunctionRefExp->get_symbol_i()->get_declaration();
ROSE_ASSERT(funcDec != NULL);
break;
}
case V_SgDotExp:
{
SgDotExp *dotExp = isSgDotExp(expression);
ROSE_ASSERT(dotExp != NULL);
if(dotExp->get_traversalSuccessorContainer().size()>=2) {
SgMemberFunctionRefExp *memberFunctionRefExp =
isSgMemberFunctionRefExp(dotExp->get_traversalSuccessorContainer()[1]);
funcDec = memberFunctionRefExp->get_symbol_i()->get_declaration();
}
ROSE_ASSERT(funcDec != NULL);
break;
}
case V_SgArrowExp:
{
SgArrowExp *arrowExp = isSgArrowExp(expression);
ROSE_ASSERT(arrowExp != NULL);
if(arrowExp->get_traversalSuccessorContainer().size()>=2) {
SgMemberFunctionRefExp *memberFunctionRefExp =
isSgMemberFunctionRefExp(arrowExp->get_traversalSuccessorContainer()[1]);
funcDec = memberFunctionRefExp->get_symbol_i()->get_declaration();
}
ROSE_ASSERT(funcDec != NULL);
break;
}
case V_SgFunctionRefExp:
{
SgFunctionRefExp *functionRefExp =
isSgFunctionRefExp(expression);
ROSE_ASSERT(functionRefExp != NULL);
// found a standard function reference
funcDec = functionRefExp->get_symbol_i()->get_declaration();
ROSE_ASSERT(funcDec != NULL);
break;
}
case V_SgPointerDerefExp:
{
ROSE_ABORT();
break;
}
default:
{
ROSE_ABORT();
}
}
return funcDec;
}