void
SourceLocationInheritedAttribute::
refineClassification ( SgNode* astNode )
{
ROSE_ASSERT (astNode != NULL);
// printf ("Inside of SourceLocationInheritedAttribute::refineClassification() astNode->sage_class_name() = %s \n",astNode->sage_class_name());
// Always update this variable
currentNode = astNode;
// Only update the currentStatement if the current node is a SgStatement node
if (isSgStatement(astNode) != NULL)
{
currentStatement = isSgStatement(astNode);
// With this stack we never have to pop anything off the stack
statementList.push_back(currentStatement);
// IDEA: Store the current statement with the scope as we push the scope onto the stack
// Then we can more accurately associate the statement with a given scope.
// if (isSgScopeStatement(astNode) != NULL)
// if ( (isSgScopeStatement(astNode) != NULL) && (astNode->get_traversalSuccessorNamesContainer().size() > 0) )
// Only save the scoep if it is a global scope or basic block
if ( (isSgGlobal(astNode) != NULL) ||
(isSgBasicBlock(astNode) != NULL) )
{
SgScopeStatement* scope = isSgScopeStatement(astNode);
scopeList.push_back(scope);
}
// printf ("Need to store the current statement with the scope (or something like that) \n");
}
#if ROSE_INTERNAL_DEBUG
// error checking
unsigned int i;
for (i = 0; i < scopeList.size(); i++)
{
ROSE_ASSERT (scopeList[i] != NULL);
}
for (i = 0; i < statementList.size(); i++)
{
ROSE_ASSERT (statementList[i] != NULL);
}
#endif
// Only update the currentExpression if the current node is a SgExpression node
if (isSgExpression(astNode) != NULL)
currentExpression = isSgExpression(astNode);
// currentFunctionBasicBlockScope = NULL;
// Refine the information with a classification of the current node
ROSE_ASSERT (astNode != NULL);
switch (astNode->variantT())
{
case V_SgProject:
project = isSgProject(astNode);
break;
// case V_SgFile:
case V_SgSourceFile:
case V_SgBinaryComposite:
file = isSgFile(astNode);
break;
case V_SgGlobal:
globalScope = isSgGlobal(astNode);
// This will be reset when we hit a SgBasicBlock (but should be set here
// so that the local scope can be refered to even in the global scope).
localScope = globalScope;
// With this stack we never have to pop anything off the stack
// scopeList.push_back(globalScope);
break;
case V_SgFunctionDeclaration:
#if 0
currentFunctionDeclaration = isSgFunctionDeclaration(astNode);
#endif
break;
case V_SgFunctionDefinition:
{
currentFunctionDefinitionScope = isSgFunctionDefinition(astNode);
// With this stack we heve have to pop anything off the stack (don't add function definition to scope list)
// scopeList.push_back(currentFunctionDefinitionScope);
#if 0
// Maybe the function scope should be set when we process the basic block?
SgFunctionDefenition functionDefinition = isSgFunctionDefinition(astNode);
if (functionDefinition != NULL)
currentFunctionScope = functionDefinition->get_block();
#endif
break;
}
case V_SgBasicBlock:
{
// printf ("Case V_SgBasicBlock \n");
localScope = isSgBasicBlock(astNode);
if ( isSgFunctionDefinition(localScope->get_parent()) != NULL )
{
currentFunctionBasicBlockScope = isSgBasicBlock(astNode);
ROSE_ASSERT ( currentFunctionBasicBlockScope == currentFunctionDefinitionScope->get_body() );
}
// loop back through the loop nest to recover the parent scope of the loop nest
SgForStatement* forStatement = isSgForStatement(localScope->get_parent());
while ( forStatement != NULL )
{
SgStatement* parentStatement = isSgStatement(forStatement->get_parent());
loopNestParentScope = isSgBasicBlock(parentStatement);
ROSE_ASSERT (loopNestParentScope != NULL);
forStatement = isSgForStatement(loopNestParentScope->get_parent());
}
// don't worry about nested conditionals (not yet at least)
SgIfStmt* ifStatement = isSgIfStmt(localScope->get_parent());
if ( ifStatement != NULL )
{
SgStatement* parentStatement = isSgStatement(ifStatement->get_parent());
conditionalParentScope = isSgBasicBlock(parentStatement);
ROSE_ASSERT (conditionalParentScope != NULL);
}
// With this stack we never have to pop anything off the stack
// scopeList.push_back(localScope);
break;
}
// For now all these cases are the same
case V_SgCatchOptionStmt:
case V_SgClassDefinition:
case V_SgDoWhileStmt:
case V_SgForStatement:
case V_SgIfStmt:
case V_SgSwitchStatement:
case V_SgWhileStmt:
{
SgScopeStatement* scope = isSgScopeStatement(astNode);
ROSE_ASSERT (scope != NULL);
// With this stack we never have to pop anything off the stack
// scopeList.push_back(scope);
break;
}
default:
// astNode is some other type of AST node which we don't keep track of in this inherited
// attribute.
#if 0
printf ("Default case inside of SourceLocationInheritedAttribute::refineClassification(astNode = %p) \n",astNode);
ROSE_ABORT();
#endif
break;
}
// assertValidPointers();
#if 0
printf ("Inside of SourceLocationInheritedAttribute::refineClassification(astNode = %p) \n",astNode);
display("Inside of SourceLocationInheritedAttribute::refineClassification()");
#endif
#if 0
printf ("Inside of SourceLocationInheritedAttribute::refineClassification(astNode = %p) \n",astNode);
ROSE_ABORT();
#endif
}
// Move variables declared in a for statement to just outside that statement.
void moveForDeclaredVariables(SgNode* root)
{
vector<SgForStatement*> for_statements;
FindForStatementsVisitor(for_statements).traverse(root, preorder);
for (unsigned int i = 0; i < for_statements.size(); ++i)
{
SgForStatement* stmt = for_statements[i];
#ifdef FD_DEBUG
cout << "moveForDeclaredVariables: " << stmt->unparseToString() << endl;
#endif
SgForInitStatement* init = stmt->get_for_init_stmt();
if (!init) continue;
SgStatementPtrList& inits = init->get_init_stmt();
vector<SgVariableDeclaration*> decls;
for (SgStatementPtrList::iterator j = inits.begin(); j != inits.end(); ++j) {
SgStatement* one_init = *j;
if (isSgVariableDeclaration(one_init))
{
decls.push_back(isSgVariableDeclaration(one_init));
}
}
if (decls.empty()) continue;
SgStatement* parent = isSgStatement(stmt->get_parent());
assert (parent);
SgBasicBlock* bb = new SgBasicBlock(SgNULL_FILE);
stmt->set_parent(bb);
bb->set_parent(parent);
SgStatementPtrList ls;
for (unsigned int j = 0; j < decls.size(); ++j)
{
for (SgInitializedNamePtrList::iterator k = decls[j]->get_variables().begin(); k != decls[j]->get_variables().end(); ++k)
{
#ifdef FD_DEBUG
cout << "Working on variable " << (*k)->get_name().getString() << endl;
#endif
SgVariableSymbol* sym = new SgVariableSymbol(*k);
bb->insert_symbol((*k)->get_name(), sym);
(*k)->set_scope(bb);
SgAssignInitializer* kinit = 0;
if (isSgAssignInitializer((*k)->get_initializer()))
{
kinit = isSgAssignInitializer((*k)->get_initializer());
(*k)->set_initializer(0);
}
if (kinit)
{
SgVarRefExp* vr = new SgVarRefExp(SgNULL_FILE, sym);
vr->set_endOfConstruct(SgNULL_FILE);
vr->set_lvalue(true);
SgAssignOp* assignment = new SgAssignOp(SgNULL_FILE,vr,kinit->get_operand());
vr->set_parent(assignment);
kinit->get_operand()->set_parent(assignment);
SgExprStatement* expr = new SgExprStatement(SgNULL_FILE, assignment);
assignment->set_parent(expr);
ls.push_back(expr);
expr->set_parent(init);
}
}
#if 0
SgStatementPtrList::iterator fiiter = std::find(inits.begin(), inits.end(), decls[j]);
assert (fiiter != inits.end());
size_t idx = fiiter - inits.begin();
inits.erase(inits.begin() + idx);
inits.insert(inits.begin() + idx, ls.begin(), ls.end());
#endif
bb->get_statements().push_back(decls[j]);
decls[j]->set_parent(bb);
}
inits = ls;
bb->get_statements().push_back(stmt);
// printf ("In moveForDeclaredVariables(): parent = %p = %s bb = %p stmt = %p = %s \n",parent,parent->class_name().c_str(),bb,stmt,stmt->class_name().c_str());
ROSE_ASSERT(stmt->get_parent() == bb);
parent->replace_statement(stmt, bb);
}
}
