void
FixupTypesTraversal::visit ( SgNode* node)
{
ROSE_ASSERT(node != NULL);
// printf ("FixupTypesTraversal::visit: node = %p = %s \n",node,node->class_name().c_str());
SgDeclarationStatement* declaration = isSgDeclarationStatement(node);
if (declaration != NULL)
{
#if 0
printf ("FixupTypesTraversal::visit: declaration = %p = %s \n",declaration,declaration->class_name().c_str());
#endif
NormalizeTypesTraversal::DeclarationTypeMultiMapType::iterator lowerBound = declarationTypeMultiMap.lower_bound(declaration);
NormalizeTypesTraversal::DeclarationTypeMultiMapType::iterator upperBound = declarationTypeMultiMap.upper_bound(declaration);
// Increment the upperBound just past the end
// if (upperBound != declarationTypeMultiMap.end())
// upperBound++;
// if ( lowerBound != declarationTypeMultiMap.end() )
#if 0
if ( upperBound != declarationTypeMultiMap.end() && (lowerBound != upperBound) )
{
while (lowerBound != upperBound)
{
printf ("loop: lowerBound = %p = %s \n",lowerBound->second,lowerBound->second->class_name().c_str());
lowerBound++;
}
if (upperBound != declarationTypeMultiMap.end())
printf ("end: upperBound = %p = %s \n",upperBound->second,upperBound->second->class_name().c_str());
}
#endif
// if ( upperBound != declarationTypeMultiMap.end() && (lowerBound != upperBound) )
// if ( upperBound != declarationTypeMultiMap.end() )
NormalizeTypesTraversal::DeclarationTypeMultiMapType::iterator i = lowerBound;
if ( i != declarationTypeMultiMap.end() )
{
// There must be at least two reference to what we want to be a shared type
// printf ("end: upperBound = %p = %s \n",upperBound->second,upperBound->second->class_name().c_str());
// printf ("loop: lowerBound = %p = %s \n",lowerBound->second,lowerBound->second->class_name().c_str());
while (i != upperBound)
{
#if 0
printf ("loop: i = %p = %s \n",i->second,i->second->class_name().c_str());
#endif
i++;
}
}
}
}
int main(int argc, char* argv[]) {
SgProject* proj = frontend(argc,argv);
SgFunctionDeclaration* mainDecl = SageInterface::findMain(proj);
SgFunctionDefinition* mainDef = mainDecl->get_definition();
// std::vector<SgNode*> dotExps = NodeQuery::querySubTree(mainDef, V_SgDotExp);
std::vector<SgNode*> varRefs = NodeQuery::querySubTree(mainDef,V_SgVarRefExp);
int classExps = 0;
for (unsigned int i = 0; i < varRefs.size(); i++) {
if (isSgClassType(isSgVarRefExp(varRefs[i])->get_type())) {
SgClassType* ct = isSgClassType(isSgVarRefExp(varRefs[i])->get_type());
std::cout << "name of ref: " << isSgVarRefExp(varRefs[i])->get_symbol()->get_name().getString() << std::endl;
if (SageInterface::isStructType(ct)) {
SgDeclarationStatement* decl = isSgType(ct)->getAssociatedDeclaration();
SgDeclarationStatement* defining_decl = decl->get_definingDeclaration();
if (!(defining_decl->isNameOnly())) {
if (isSgClassDeclaration(defining_decl)) {
if (isSgClassDeclaration(defining_decl)->get_definition()) {
SgDeclarationStatementPtrList member_stats = isSgClassDeclaration(defining_decl)->get_definition()->get_members();
SgDeclarationStatementPtrList::iterator j = member_stats.begin();
for (; j != member_stats.end(); j++) {
SgDeclarationStatement* d = isSgDeclarationStatement(*j);
std::cout << "decl stat name: " << d->class_name() << std::endl;
SgInitializedNamePtrList init_lst = isSgVariableDeclaration(d)->get_variables();
SgInitializedNamePtrList::iterator k = init_lst.begin();
std::cout << "variables in initialized name ptr list..." << std::endl;
for (; k != init_lst.end(); k++) {
std::cout << isSgInitializedName(*k)->get_name().getString() << std::endl;
std::cout << isSgInitializedName(*k)->get_type()->class_name() << std::endl;
}
}
classExps+=1;
}
}
}
}
}
}
std::cout << "num class_exp: " << classExps << std::endl;
return 0;
}
void
FixupAstSymbolTables::visit ( SgNode* node )
{
// DQ (6/27/2005): Output the local symbol table from each scope.
// printf ("node = %s \n",node->sage_class_name());
SgScopeStatement* scope = isSgScopeStatement(node);
if (scope != NULL)
{
#if 0
printf ("AST Fixup: Fixup Symbol Table for %p = %s at: \n",scope,scope->class_name().c_str());
#endif
SgSymbolTable* symbolTable = scope->get_symbol_table();
if (symbolTable == NULL)
{
#if 0
printf ("AST Fixup: Fixup Symbol Table for %p = %s at: \n",scope,scope->class_name().c_str());
scope->get_file_info()->display("Symbol Table Location");
#endif
SgSymbolTable* tempSymbolTable = new SgSymbolTable();
ROSE_ASSERT(tempSymbolTable != NULL);
// name this table as compiler generated! The name is a static member used to store
// state for the next_symbol() functions. It is meaningless to set these.
// tempSymbolTable->set_name("compiler-generated symbol table");
scope->set_symbol_table(tempSymbolTable);
// reset the symbolTable using the get_symbol_table() member function
symbolTable = scope->get_symbol_table();
ROSE_ASSERT(symbolTable != NULL);
// DQ (2/16/2006): Set this parent directly (now tested)
symbolTable->set_parent(scope);
ROSE_ASSERT(symbolTable->get_parent() != NULL);
}
ROSE_ASSERT(symbolTable != NULL);
if (symbolTable->get_parent() == NULL)
{
printf ("Warning: Fixing up symbolTable, calling symbolTable->set_parent() (parent not previously set) \n");
symbolTable->set_parent(scope);
}
ROSE_ASSERT(symbolTable->get_parent() != NULL);
// Make sure that the internal hash table used in the symbol table is also present!
if (symbolTable->get_table() == NULL)
{
// DQ (6/27/2005): There are a lot of these built, perhaps more than we really need!
#if 0
printf ("AST Fixup: Building internal Symbol Table hash table (rose_hash_multimap) for %p = %s at: \n",
scope,scope->sage_class_name());
scope->get_file_info()->display("Symbol Table Location");
#endif
rose_hash_multimap* internalHashTable = new rose_hash_multimap();
ROSE_ASSERT(internalHashTable != NULL);
symbolTable->set_table(internalHashTable);
}
ROSE_ASSERT(symbolTable->get_table() != NULL);
SgSymbolTable::BaseHashType* internalTable = symbolTable->get_table();
ROSE_ASSERT(internalTable != NULL);
// DQ (6/23/2011): Note: Declarations that reference types that have not been seen yet may be placed into the
// wronge scope, then later when we see the correct scope we have a symbol in two or more symbol tables. The
// code below detects and fixes this problem.
// DQ (6/16/2011): List of symbols we need to remove from symbol tables where they are multibily represented.
std::vector<SgSymbol*> listOfSymbolsToRemove;
// DQ (6/12/2011): Fixup symbol table by removing symbols that are not associated with a declaration in the current scope.
int idx = 0;
SgSymbolTable::hash_iterator i = internalTable->begin();
while (i != internalTable->end())
{
// DQ: removed SgName casting operator to char*
// cout << "[" << idx << "] " << (*i).first.str();
ROSE_ASSERT ( (*i).first.str() != NULL );
ROSE_ASSERT ( isSgSymbol( (*i).second ) != NULL );
// printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) sage_class_name() = %s \n",
// idx,(*i).first.str(),(*i).second->sage_class_name());
SgSymbol* symbol = isSgSymbol((*i).second);
ROSE_ASSERT ( symbol != NULL );
// We have to look at each type of symbol separately! This is because there is no virtual function,
// the reason for this is that each get_declaration() function returns a different type!
// ROSE_ASSERT ( symbol->get_declaration() != NULL );
switch(symbol->variantT())
{
case V_SgClassSymbol:
{
SgClassSymbol* classSymbol = isSgClassSymbol(symbol);
ROSE_ASSERT(classSymbol != NULL);
ROSE_ASSERT(classSymbol->get_declaration() != NULL);
SgDeclarationStatement* declarationToFindInScope = NULL;
// Search for the declaration in the associated scope.
declarationToFindInScope = classSymbol->get_declaration();
ROSE_ASSERT(declarationToFindInScope != NULL);
SgClassDeclaration* classDeclaration = isSgClassDeclaration(declarationToFindInScope);
ROSE_ASSERT(classDeclaration != NULL);
SgName name = classDeclaration->get_name();
// SgType* declarationType = declarationToFindInScope->get_type();
SgType* declarationType = classDeclaration->get_type();
ROSE_ASSERT(declarationType != NULL);
if (declarationToFindInScope->get_definingDeclaration() != NULL)
{
declarationToFindInScope = declarationToFindInScope->get_definingDeclaration();
SgClassDeclaration* definingClassDeclaration = isSgClassDeclaration(declarationToFindInScope);
ROSE_ASSERT(definingClassDeclaration != NULL);
// SgType* definingDeclarationType = declarationToFindInScope->get_type();
SgType* definingDeclarationType = definingClassDeclaration->get_type();
ROSE_ASSERT(definingDeclarationType != NULL);
// DQ (6/22/2011): This assertion fails for CompileTests/copyAST_tests/copytest2007_24.C
// A simple rule that all declarations should follow (now that we have proper global type tables).
// ROSE_ASSERT(definingDeclarationType == declarationType);
if (definingDeclarationType != declarationType)
{
printf ("In fixupSymbolTables.C: Note that definingDeclarationType != declarationType \n");
}
}
SgNamedType* namedType = isSgNamedType(declarationType);
ROSE_ASSERT(namedType != NULL);
SgDeclarationStatement* declarationAssociatedToType = namedType->get_declaration();
ROSE_ASSERT(declarationAssociatedToType != NULL);
#if 0
printf ("Found a symbol without a matching declaration in the current scope (declList): declarationToFindInScope = %p = %s \n",declarationToFindInScope,declarationToFindInScope->class_name().c_str());
printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) class_name() = %s \n",idx,(*i).first.str(),(*i).second->class_name().c_str());
#endif
SgScopeStatement* scopeOfDeclarationToFindInScope = declarationToFindInScope->get_scope();
SgScopeStatement* scopeOfDeclarationAssociatedWithType = declarationAssociatedToType->get_scope();
#if 0
printf ("declarationToFindInScope = %p declarationToFindInScope->get_scope() = %p = %s \n",declarationToFindInScope,declarationToFindInScope->get_scope(),declarationToFindInScope->get_scope()->class_name().c_str());
printf ("declarationAssociatedToType = %p declarationAssociatedToType->get_scope() = %p = %s \n",declarationAssociatedToType,declarationAssociatedToType->get_scope(),declarationAssociatedToType->get_scope()->class_name().c_str());
#endif
if (scopeOfDeclarationToFindInScope != scopeOfDeclarationAssociatedWithType)
{
// DQ (6/12/2011): Houston, we have a problem! The trick is to fix it...
// A symbol has been placed into a scope when we could not be certain which scope it should be placed.
// We have a default of placing such symbols into the global scope, but it might be better to just have
// a special scope where such symbols could be placed so that we could have them separate from the global
// scope and then fix them up more clearly.
// Note that test2011_80.C still fails but the AST is at least correct (I think).
SgGlobal* scopeOfDeclarationToFindInScope_GlobalScope = isSgGlobal(scopeOfDeclarationToFindInScope);
// SgGlobal* scopeOfDeclarationAssociatedWithType_GlobalScope = isSgGlobal(scopeOfDeclarationAssociatedWithType);
if (scopeOfDeclarationToFindInScope_GlobalScope != NULL)
{
// In general which ever scope is the global scope is where the error is...???
// This is because when we don't know where to put a symbol (e.g. from a declaration of a pointer) we put it into global scope.
// There is even an agrument that this is correct as a default for C/C++, but only if it must exist (see test2011_80.C).
// Remove the symbol from the symbol table of the global scope.
printf ("Remove the associated symbol in the current symbol table \n");
// DQ (6/22/2011): This assertion fails for CompileTests/copyAST_tests/copytest2007_24.C
// ROSE_ASSERT (declarationToFindInScope->get_scope() == declarationAssociatedToType->get_scope());
if (declarationToFindInScope->get_scope() != declarationAssociatedToType->get_scope())
printf ("In fixupSymbolTables.C: Note that declarationToFindInScope->get_scope() != declarationAssociatedToType->get_scope() \n");
}
else
{
listOfSymbolsToRemove.push_back(classSymbol);
}
}
// ROSE_ASSERT (declarationToFindInScope->get_scope() == declarationAssociatedToType->get_scope());
break;
}
default:
{
// It night be there are are no other types of symbols to consider...
// printf ("Ignoring non SgClassSymbols (fixupSymbolTables.C) symbol = %s \n",symbol->class_name().c_str());
// ROSE_ASSERT(false);
}
}
// Increment iterator!
i++;
// Increment counter!
idx++;
}
// DQ (6/18/2011): Now that we are through with the symbol table we can support removal of any
// identified problematic symbol without worrying about STL iterator invalidation.
for (size_t j = 0; j < listOfSymbolsToRemove.size(); j++)
{
// Remove these symbols.
SgSymbol* removeSymbol = listOfSymbolsToRemove[j];
ROSE_ASSERT(removeSymbol != NULL);
SgSymbolTable* associatedSymbolTable = isSgSymbolTable(removeSymbol->get_parent());
ROSE_ASSERT(associatedSymbolTable != NULL);
ROSE_ASSERT(associatedSymbolTable == symbolTable);
associatedSymbolTable->remove(removeSymbol);
printf ("Redundant symbol removed...from symbol table \n");
// ROSE_ASSERT(false);
}
#if 0
// debugging
symbolTable->print("In FixupAstSymbolTables::visit(): printing out the symbol tables");
#endif
}
}
void
MangledNameMapTraversal::visit ( SgNode* node)
{
ROSE_ASSERT(node != NULL);
#if 0
printf ("MangledNameMapTraversal::visit: node = %s \n",node->class_name().c_str());
#endif
// Keep track of the number of IR nodes visited
numberOfNodes++;
// DQ (7/4/2010): Optimizations:
// 1) Only process each IR node once
// 2) Only process declarations that we want to share (can we be selective?).
// DQ (7/4/2010): To optimize performance, build a set of previously visited IR nodes
// so that we only test IR nodes once to add them into the mangled name map. This
// should be especially important where the AST is sharing nodes since shared nodes
// are visited multiple times (as if they were not shared).
// We need to tet if this actually optimizes the performance.
if (setOfNodesPreviouslyVisited.find(node) == setOfNodesPreviouslyVisited.end())
{
setOfNodesPreviouslyVisited.insert(node);
}
else
{
return;
}
bool sharable = shareableIRnode(node);
#if 0
printf ("MangledNameMapTraversal::visit: node = %p = %s sharable = %s \n",node,node->class_name().c_str(),sharable ? "true" : "false");
#endif
// DQ (7/10/2010): This is a test of the AST merge to investigate robustness.
#if 1
if (sharable == true)
{
// Initially we will only merge things in global scope! Then
// we will operate on namespaces! Then I think we are done!
// Basically we can simplify the problem by skipping merging of things in
// function definitions since if the function definitions are the same they
// will be merged directly.
// Keep track of the number of IR nodes that were considered sharable
numberOfNodesSharable++;
// Here is where we get much more specific about what is sharable!
switch (node->variantT())
{
// Since we abstract out the generation of the key we can simplify this code!
#if 1
// DQ (7/11/2010): This fails for tests/nonsmoke/functional/CompileTests/mergeAST_tests/mergeTest_06.C, I don't know why!
case V_SgFunctionDeclaration:
#endif
#if 1
// DQ (7/20/2010): Testing this case...
case V_SgVariableDeclaration:
case V_SgClassDeclaration:
// DQ (2/10/2007): These need to be shared (but I still see "xxxxx____Lnnnn" based names)
case V_SgTemplateInstantiationDecl:
// DQ (2/10/2007): These should be shared
case V_SgPragmaDeclaration:
case V_SgTemplateInstantiationDirectiveStatement:
case V_SgTypedefDeclaration:
case V_SgEnumDeclaration:
case V_SgTemplateDeclaration:
case V_SgUsingDeclarationStatement:
case V_SgUsingDirectiveStatement:
// DQ (2/3/2007): Added additional declarations that we should share
case V_SgMemberFunctionDeclaration:
case V_SgTemplateInstantiationFunctionDecl:
case V_SgTemplateInstantiationMemberFunctionDecl:
#endif
#if 1
// DQ (2/3/2007): Added support for symbols
case V_SgClassSymbol:
case V_SgEnumFieldSymbol:
case V_SgEnumSymbol:
case V_SgFunctionSymbol:
case V_SgMemberFunctionSymbol:
case V_SgLabelSymbol:
case V_SgNamespaceSymbol:
// DQ (2/10/2007): This case has been a problem previously
case V_SgTemplateSymbol:
case V_SgTypedefSymbol:
case V_SgVariableSymbol:
#endif
#if 0
// DQ (7/20/2010): These nodes are a problem to merge, but also not important to merge
// since they are contained within associated declarations.
// DQ (2/20/2007): Added to list so that it could be process to build the delete list
// statement fo the SgBasicBlock have to be considerd for the delete list. However,
// it is still not meaningful since we don't generate a unique name for the SgBasicBlock
// so it will never be shared.
// case V_SgBasicBlock:
case V_SgClassDefinition:
case V_SgTemplateInstantiationDefn:
case V_SgFunctionDefinition:
case V_SgVariableDefinition:
#endif
#if 1
// DQ (5/29/2006): Added support for types
case V_SgFunctionType:
case V_SgMemberFunctionType:
case V_SgModifierType:
case V_SgPointerType:
// DQ (5/29/2006): Added support for types
case V_SgClassType:
case V_SgEnumType:
case V_SgTypedefType:
// DQ (2/10/2007): Add this case
case V_SgTemplateArgument:
// DQ (3/17/2007): These should be shared, I think!
case V_SgPragma:
// DQ (5/20/2006): Initialized names are held in SgVariableDeclaration IR
// nodes or other sharable structures so we don't have to share these.
// But we have to permit them all to be shared because all pointers to
// them need to be reset they all need to be reset.
case V_SgInitializedName:
#endif
#if 1
{
// DQ (7/4/2010): To improve the performance avoid regenerating the unique name for the same IR nodes when it is revisited!
// Make the use of false in generateUniqueName() more clear. We need to
// distinguish between defining and non-defining declarations in the generation
// of unique names for the AST merge.
// string key = generateUniqueName(node,false);
bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations = false;
string key = SageInterface::generateUniqueName(node,ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);
ROSE_ASSERT(key.empty() == false);
#if 1
SgDeclarationStatement* declaration = isSgDeclarationStatement(node);
if (declaration != NULL)
{
// ROSE_ASSERT(declaration->get_symbol_from_symbol_table() != NULL);
// DQ (7/4/2007): Some SgDeclarationStatement IR nodes don't have a representation
// in the symbol table (the list of SgInitializedName object have them instead).
if (isSgVariableDeclaration(declaration) == NULL &&
isSgVariableDefinition(declaration) == NULL &&
isSgUsingDeclarationStatement(declaration) == NULL &&
isSgUsingDirectiveStatement(declaration) == NULL &&
isSgTemplateInstantiationDirectiveStatement(declaration) == NULL &&
isSgPragmaDeclaration(declaration) == NULL)
{
// DQ (6/8/2010): Only do this test for non compiler generated variable...(e.g. __default_member_function_pointer_name
// is compiler generated to handle function pointers where no member function id specified).
if (declaration->get_startOfConstruct()->isCompilerGenerated() == false)
{
SgSymbol* symbol = declaration->search_for_symbol_from_symbol_table();
if (symbol == NULL)
{
// Output more information to support debugging!
printf ("declaration = %p = %s = %s \n",declaration,declaration->class_name().c_str(),SageInterface::get_name(declaration).c_str());
SgScopeStatement* scope = declaration->get_scope();
ROSE_ASSERT(scope != NULL);
printf (" scope = %p = %s = %s \n",scope,scope->class_name().c_str(),SageInterface::get_name(scope).c_str());
declaration->get_startOfConstruct()->display("declaration->search_for_symbol_from_symbol_table() == NULL");
}
ROSE_ASSERT(symbol != NULL);
}
}
#if 0
// DQ (6/23/2010): Added the base type of the typedef
SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(declaration);
if (typedefDeclaration != NULL)
{
}
#endif
}
#endif
addToMap(key,node);
// Keep track of the number of IR nodes that were evaluated for mangled name matching
numberOfNodesEvaluated++;
break;
}
#endif
default:
{
// Nothing to do here
}
}
}
#endif
}
void fixupAstDeclarationScope( SgNode* node )
{
// This function was designed to fixup what I thought were inconsistancies in how the
// defining and some non-defining declarations associated with friend declarations had
// their scope set. I now know this this was not a problem, but it is helpful to enforce the
// consistancy. It might also be useful to process declarations with scopes set to
// namespace definitions, so that the namespace definition can be normalized to be
// consistant across all of the different re-entrant namespace definitions. This is
// possible within the new namespace support in ROSE.
TimingPerformance timer ("Fixup declaration scopes:");
// This simplifies how the traversal is called!
FixupAstDeclarationScope astFixupTraversal;
// DQ (1/29/2007): This traversal now uses the memory pool (so that we will visit declaration hidden in types (e.g. SgClassType)
// SgClassType::traverseMemoryPoolNodes(v);
astFixupTraversal.traverseMemoryPool();
// Now process the map of sets of declarations.
std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* > & mapOfSets = astFixupTraversal.mapOfSets;
#if 0
printf ("In fixupAstDeclarationScope(): mapOfSets.size() = %" PRIuPTR " \n",mapOfSets.size());
#endif
std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* >::iterator i = mapOfSets.begin();
while (i != mapOfSets.end())
{
SgDeclarationStatement* firstNondefiningDeclaration = i->first;
// DQ (3/2/2015): Added assertion.
ROSE_ASSERT(firstNondefiningDeclaration != NULL);
// DQ (3/2/2015): Added assertion.
ROSE_ASSERT(firstNondefiningDeclaration->get_firstNondefiningDeclaration() != NULL);
// DQ (3/2/2015): Make this assertion a warning: fails in outlining example seq7a_test2006_78.C.
// ROSE_ASSERT(firstNondefiningDeclaration == firstNondefiningDeclaration->get_firstNondefiningDeclaration());
if (firstNondefiningDeclaration != firstNondefiningDeclaration->get_firstNondefiningDeclaration())
{
printf ("WARNING: In fixupAstDeclarationScope(): firstNondefiningDeclaration != firstNondefiningDeclaration->get_firstNondefiningDeclaration() \n");
printf (" --- firstNondefiningDeclaration = %p = %s \n",
firstNondefiningDeclaration,firstNondefiningDeclaration->class_name().c_str());
printf (" --- firstNondefiningDeclaration->get_firstNondefiningDeclaration() = %p = %s \n",
firstNondefiningDeclaration->get_firstNondefiningDeclaration(),firstNondefiningDeclaration->get_firstNondefiningDeclaration()->class_name().c_str());
}
SgScopeStatement* correctScope = firstNondefiningDeclaration->get_scope();
ROSE_ASSERT(correctScope != NULL);
#if 0
printf ("In FixupAstDeclarationScope::visit(): node = %p = %s firstNondefiningDeclaration = %p correctScope = %p = %s \n",node,node->class_name().c_str(),firstNondefiningDeclaration,correctScope,correctScope->class_name().c_str());
#endif
std::set<SgDeclarationStatement*>* declarationSet = i->second;
ROSE_ASSERT(declarationSet != NULL);
#if 0
printf ("In fixupAstDeclarationScope(): mapOfSets[%p]->size() = %" PRIuPTR " \n",firstNondefiningDeclaration,mapOfSets[firstNondefiningDeclaration]->size());
#endif
std::set<SgDeclarationStatement*>::iterator j = declarationSet->begin();
while (j != declarationSet->end())
{
SgScopeStatement* associatedScope = (*j)->get_scope();
ROSE_ASSERT(associatedScope != NULL);
// DQ (6/11/2013): This is triggered by namespace definition scopes that are different
// due to re-entrant namespace declarations. We should maybe fix this.
// TV (7/22/13): This is also triggered when for global scope accross files.
if (associatedScope != correctScope)
{
// DQ (1/30/2014): Cleaning up some output spew.
if (SgProject::get_verbose() > 0)
{
mprintf ("WARNING: This is the wrong scope (declaration = %p = %s): associatedScope = %p = %s correctScope = %p = %s \n",
*j,(*j)->class_name().c_str(),associatedScope,associatedScope->class_name().c_str(),correctScope,correctScope->class_name().c_str());
}
#if 0
printf ("Make this an error for now! \n");
ROSE_ASSERT(false);
#endif
}
j++;
}
i++;
}
#if 0
printf ("Leaving fixupAstDeclarationScope() node = %p = %s \n",node,node->class_name().c_str());
#endif
}
void
FixupAstDeclarationScope::visit ( SgNode* node )
{
// DQ (6/11/2013): This corrects where EDG can set the scope of a friend declaration to be different from the defining declaration.
// We need it to be a rule in ROSE that the scope of the declarations are consistant between defining and all non-defining declaration).
#if 0
printf ("In FixupAstDeclarationScope::visit(node = %p = %s) \n",node,node->class_name().c_str());
#endif
SgDeclarationStatement* declaration = isSgDeclarationStatement(node);
if (declaration != NULL)
{
// SgDeclarationStatement* definingDeclaration = declaration->get_definingDeclaration();
SgDeclarationStatement* firstNondefiningDeclaration = declaration->get_firstNondefiningDeclaration();
// Note that these declarations don't follow the same rules (namely the get_firstNondefiningDeclaration() can be NULL).
if ( isSgFunctionParameterList(node) != NULL || isSgVariableDefinition(node) != NULL)
{
#if 0
printf ("In FixupAstDeclarationScope::visit(): node = %p = %s firstNondefiningDeclaration = %p (skipping this processing) \n",node,node->class_name().c_str(),firstNondefiningDeclaration);
#endif
}
else
{
// DQ (6/15/2013): The older tutorial examples demonstrate addition of new functions using older rules that allows
// there to not be a non-defining declaration. We need to remove these tutrial example in favor of the AST builder
// API to build functions that will follow the newer AST constistancy rules. Until we do this work in the tutorial
// we can't inforce this below else the older tutorial examples (e.g. addFunctionDeclaration.C) will fail. So I will
// allow this for now and output a warning when (firstNondefiningDeclaration == NULL).
// ROSE_ASSERT(firstNondefiningDeclaration != NULL);
if (firstNondefiningDeclaration == NULL)
{
printf ("WARNING: In FixupAstDeclarationScope::visit(): firstNondefiningDeclaration == NULL for case of node = %p = %s (allowed for tutorial example transformations only) \n",node,node->class_name().c_str());
}
else
{
if (mapOfSets.find(firstNondefiningDeclaration) == mapOfSets.end())
{
std::set<SgDeclarationStatement*>* new_empty_set = new std::set<SgDeclarationStatement*>();
ROSE_ASSERT(new_empty_set != NULL);
#if 0
printf ("In FixupAstDeclarationScope::visit(): Adding a set of declarations to the mapOfSets: new_empty_set = %p \n",new_empty_set);
#endif
// DQ (3/2/2015): Added assertion.
ROSE_ASSERT(firstNondefiningDeclaration != NULL);
mapOfSets.insert(std::pair<SgDeclarationStatement*,std::set<SgDeclarationStatement*>*>(firstNondefiningDeclaration,new_empty_set));
}
ROSE_ASSERT(mapOfSets.find(firstNondefiningDeclaration) != mapOfSets.end());
// DQ (3/2/2015): Added assertion.
ROSE_ASSERT(declaration != NULL);
#if 0
printf ("In FixupAstDeclarationScope::visit(): Adding a declaration = %p = %s to a specific set in the mapOfSets: mapOfSets[firstNondefiningDeclaration=%p] = %p \n",
declaration,declaration->class_name().c_str(),firstNondefiningDeclaration,mapOfSets[firstNondefiningDeclaration]);
printf (" --- declaration->get_firstNondefiningDeclaration() = %p \n",declaration->get_firstNondefiningDeclaration());
#endif
// DQ (3/2/2015): Added assertion.
// ROSE_ASSERT(declaration == declaration->get_firstNondefiningDeclaration());
// mapOfSets[firstNondefiningDeclaration]->insert(firstNondefiningDeclaration);
mapOfSets[firstNondefiningDeclaration]->insert(declaration);
}
}
}
}
string
nodeColor( SgStatement* statement )
{
/* color: colorCode:red:on
color: colorCode:orange:on
color: colorCode:yellow:on
color: colorCode:blue:on
color: colorCode:green:on
color: colorCode:violet:on
color: colorCode:brown:on
color: colorCode:purple:on
color: colorCode:lightblue:on
color: colorCode:lightgreen:on
color: colorCode:lightred:on
color: colorCode:black:on
color: colorCode:darkblue:on
color: colorCode:grey:on
color: colorCode:darkgrey:on
color: colorCode:olivegreen:on
color: colorCode:darkgreen:on
*/
string returnString;
SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(statement);
if (declarationStatement != NULL)
{
switch (declarationStatement->variantT())
{
case V_SgFunctionDeclaration:
case V_SgMemberFunctionDeclaration:
case V_SgTemplateInstantiationFunctionDecl:
case V_SgTemplateInstantiationMemberFunctionDecl:
returnString = "orange";
break;
case V_SgClassDeclaration:
case V_SgTemplateInstantiationDecl:
returnString = "yellow";
break;
case V_SgAsmStmt:
case V_SgCtorInitializerList:
case V_SgEnumDeclaration:
case V_SgFunctionParameterList:
case V_SgNamespaceAliasDeclarationStatement:
case V_SgNamespaceDeclarationStatement:
case V_SgPragmaDeclaration:
case V_SgTemplateDeclaration:
case V_SgTemplateInstantiationDirectiveStatement:
case V_SgTypedefDeclaration:
case V_SgUsingDeclarationStatement:
case V_SgUsingDirectiveStatement:
case V_SgVariableDeclaration:
case V_SgVariableDefinition:
returnString = "lightred";
break;
// DQ (11/11/2012): Added support for newer IR nodes in edg4x work.
case V_SgTemplateMemberFunctionDeclaration:
case V_SgTemplateClassDeclaration:
case V_SgTemplateFunctionDeclaration:
case V_SgTemplateVariableDeclaration:
returnString = "red";
break;
default:
returnString = "ERROR DEFAULT REACHED";
printf ("Default reached in nodeColor() exiting ... (%s) \n",declarationStatement->class_name().c_str());
ROSE_ASSERT(false);
break;
}
}
SgScopeStatement* scopeStatement = isSgScopeStatement(statement);
if (scopeStatement != NULL)
{
switch (scopeStatement->variantT())
{
case V_SgBasicBlock:
returnString = "lightblue";
break;
case V_SgClassDefinition:
returnString = "lightblue";
break;
case V_SgTemplateInstantiationDefn:
case V_SgFunctionDefinition:
returnString = "lightblue";
break;
case V_SgWhileStmt:
case V_SgDoWhileStmt:
case V_SgForStatement:
returnString = "darkblue";
break;
case V_SgGlobal:
case V_SgIfStmt:
case V_SgNamespaceDefinitionStatement:
case V_SgSwitchStatement:
case V_SgCatchOptionStmt:
returnString = "black";
break;
// DQ (11/11/2012): Added support for newer IR nodes in edg4x work.
case V_SgTemplateClassDefinition:
case V_SgTemplateFunctionDefinition:
returnString = "red";
break;
default:
returnString = "ERROR DEFAULT REACHED";
printf ("Default reached in nodeColor() exiting ... (%s) \n",scopeStatement->class_name().c_str());
ROSE_ASSERT(false);
break;
}
}
if (scopeStatement == NULL && declarationStatement == NULL)
{
switch (statement->variantT())
{
case V_SgExprStatement:
returnString = "violet";
break;
case V_SgBreakStmt:
case V_SgCaseOptionStmt:
case V_SgCatchStatementSeq:
case V_SgContinueStmt:
case V_SgDefaultOptionStmt:
case V_SgClinkageStartStatement:
case V_SgForInitStatement:
case V_SgFunctionTypeTable:
case V_SgGotoStatement:
case V_SgLabelStatement:
case V_SgNullStatement:
case V_SgReturnStmt:
case V_SgSpawnStmt:
case V_SgTryStmt:
case V_SgVariantStatement:
returnString = "brown";
break;
default:
returnString = "ERROR DEFAULT REACHED";
printf ("Default reached in nodeColor() exiting ... (%s) \n",statement->class_name().c_str());
ROSE_ASSERT(false);
break;
}
}
return returnString;
}
void
ReportUnsharedDeclarationsTraversal::visit ( SgNode* node)
{
ROSE_ASSERT(node != NULL);
#if 0
printf ("ReportUnsharedDeclarationsTraversal::visit: node = %p = %s \n",node,node->class_name().c_str());
#endif
SgDeclarationStatement* declaration = isSgDeclarationStatement(node);
if (declaration != NULL)
{
bool skipTest = isSgFunctionParameterList(declaration) || isSgNamespaceDeclarationStatement(declaration) || isSgCtorInitializerList(declaration);
if (skipTest == false && declaration->get_startOfConstruct()->isShared() == false)
{
printf ("Found a declaration which is not shared declaration = %p = %s = %s \n",declaration,declaration->class_name().c_str(),SageInterface::get_name(declaration).c_str());
}
}
#if 0
SgSupport* support = isSgSupport(node);
if (support != NULL)
{
bool skipTest = !(isSgTemplateArgument(support));
if (skipTest == false && support->get_file_info()->isShared() == false)
{
printf ("Found a support IR node which is not shared = %p = %s = %s \n",support,support->class_name().c_str(),SageInterface::get_name(support).c_str());
}
}
#endif
#if 0
printf ("ReportUnsharedDeclarationsTraversal::visit(): node = %p = %s \n",node,node->class_name().c_str());
#endif
}
void
FixupAstSymbolTablesToSupportAliasedSymbols::visit ( SgNode* node )
{
// DQ (11/24/2007): Output the current IR node for debugging the traversal of the Fortran AST.
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols::visit() (preorder AST traversal) node = %p = %s \n",node,node->class_name().c_str());
#endif
#if 0
// DQ (7/23/2011): New support for linking namespaces sharing the same name (mangled name).
// std::map<SgName,std::vector<SgNamespaceDefinition*> > namespaceMap;
SgNamespaceDefinitionStatement* namespaceDefinition = isSgNamespaceDefinitionStatement(node);
if (namespaceDefinition != NULL)
{
// DQ (7/23/2011): Assemble namespaces with the same name into vectors defined in the map
// accessed using the name of the namespace as a key.
#error "DEAD CODE"
SgName name = namespaceDefinition->get_namespaceDeclaration()->get_name();
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: namespace definition found for name = %s #symbols = %d \n",name.str(),namespaceDefinition->get_symbol_table()->size());
#endif
// It is important to use mangled names to define unique names when namespaces are nested.
SgName mangledNamespaceName = namespaceDefinition->get_namespaceDeclaration()->get_mangled_name();
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: namespace definition associated mangled name = %s \n",mangledNamespaceName.str());
#endif
// DQ (7/23/2011): Fixup the name we use as a key in the map to relect that some namespaces don't have a name.
if (name == "")
{
// Modify the mangled name to reflect the unnamed namespace...
#if ALIAS_SYMBOL_DEBUGGING
printf ("Warning in FixupAstSymbolTablesToSupportAliasedSymbols::visit(): Unnamed namespaces shuld be mangled to reflect the lack of a name \n");
#endif
mangledNamespaceName += "_unnamed_namespace";
}
#if ALIAS_SYMBOL_DEBUGGING
printf ("namespace definition associated mangled name = %s \n",mangledNamespaceName.str());
#endif
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: associated mangled name = %s namespaceMap size = %" PRIuPTR " \n",mangledNamespaceName.str(),namespaceMap.size());
#endif
std::map<SgName,std::vector<SgNamespaceDefinitionStatement*> >::iterator i = namespaceMap.find(mangledNamespaceName);
if (i != namespaceMap.end())
{
std::vector<SgNamespaceDefinitionStatement*> & namespaceVector = i->second;
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: (found an entry): Namespace vector size = %" PRIuPTR " \n",namespaceVector.size());
#endif
// Testing each entry...
for (size_t j = 0; j < namespaceVector.size(); j++)
{
ROSE_ASSERT(namespaceVector[j] != NULL);
SgName existingNamespaceName = namespaceVector[j]->get_namespaceDeclaration()->get_name();
#if ALIAS_SYMBOL_DEBUGGING
printf ("Existing namespace (SgNamespaceDefinitionStatement) %p = %s \n",namespaceVector[j],existingNamespaceName.str());
#endif
if (j > 0)
{
ROSE_ASSERT(namespaceVector[j]->get_previousNamespaceDefinition() != NULL);
}
if (namespaceVector.size() > 1 && j < namespaceVector.size() - 2)
{
ROSE_ASSERT(namespaceVector[j]->get_nextNamespaceDefinition() != NULL);
}
}
#error "DEAD CODE"
size_t namespaceListSize = namespaceVector.size();
if (namespaceListSize > 0)
{
size_t lastNamespaceIndex = namespaceListSize - 1;
// DQ (5/9/2013): Before setting these, I think they should be unset (to NULL values).
// ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL);
// ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == NULL);
// ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() != NULL);
// namespaceVector[lastNamespaceIndex]->set_nextNamespaceDefinition(namespaceDefinition);
#if 1
printf ("namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() = %p \n",namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition());
#endif
if (namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL)
{
namespaceVector[lastNamespaceIndex]->set_nextNamespaceDefinition(namespaceDefinition);
}
else
{
// DQ (5/9/2013): If this is already set then make sure it was set to the correct value.
ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == namespaceDefinition);
}
#error "DEAD CODE"
// DQ (5/9/2013): If this is already set then make sure it was set to the correct value.
// namespaceDefinition->set_previousNamespaceDefinition(namespaceVector[lastNamespaceIndex]);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() != NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == namespaceVector[lastNamespaceIndex]);
// DQ (5/9/2013): I think I can assert this.
ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_namespaceDeclaration()->get_name() == namespaceDefinition->get_namespaceDeclaration()->get_name());
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() != NULL);
#if 1
printf ("namespaceDefinition = %p namespaceDefinition->get_nextNamespaceDefinition() = %p \n",namespaceDefinition,namespaceDefinition->get_nextNamespaceDefinition());
#endif
// ROSE_ASSERT(namespaceDefinition->get_nextNamespaceDefinition() == NULL);
// ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL);
}
// Add the namespace matching a previous name to the list.
namespaceVector.push_back(namespaceDefinition);
#error "DEAD CODE"
// Setup scopes as sources and distinations of alias symbols.
SgNamespaceDefinitionStatement* referencedScope = namespaceDefinition->get_previousNamespaceDefinition();
ROSE_ASSERT(referencedScope != NULL);
SgNamespaceDefinitionStatement* currentScope = namespaceDefinition;
ROSE_ASSERT(currentScope != NULL);
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: Suppress injection of symbols from one namespace to the other for each reintrant namespace \n");
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: referencedScope #symbols = %d currentScope #symbols = %d \n",referencedScope->get_symbol_table()->size(),currentScope->get_symbol_table()->size());
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: referencedScope = %p currentScope = %p \n",referencedScope,currentScope);
#endif
#if 1
// Generate the alias symbols from the referencedScope and inject into the currentScope.
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,currentScope,SgAccessModifier::e_default);
#endif
}
else
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: (entry NOT found): Insert namespace %p for name = %s into the namespaceMap \n",namespaceDefinition,mangledNamespaceName.str());
#endif
std::vector<SgNamespaceDefinitionStatement*> list(1);
ROSE_ASSERT(list.size() == 1);
#error "DEAD CODE"
list[0] = namespaceDefinition;
#if 0
// DQ (3/11/2012): New code, but maybe we should instead put the implicit "std" namespace into the global scope more directly.
if (mangledNamespaceName == "std" && false)
{
// This case has to be handled special since the implicit "std" namespace primary declaration was
// constructed but not added to the global scope. But maybe it should be.
}
else
{
// DQ (7/24/2011): get_nextNamespaceDefinition() == NULL is false in the case of the AST copy tests
// (see tests/nonsmoke/functional/CompileTests/copyAST_tests/copytest2007_30.C). Only get_nextNamespaceDefinition()
// appears to sometimes be non-null, so we reset them both to NULL just to make sure.
namespaceDefinition->set_nextNamespaceDefinition(NULL);
namespaceDefinition->set_previousNamespaceDefinition(NULL);
ROSE_ASSERT(namespaceDefinition->get_nextNamespaceDefinition() == NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == NULL);
}
#else
// DQ (7/24/2011): get_nextNamespaceDefinition() == NULL is false in the case of the AST copy tests
// (see tests/nonsmoke/functional/CompileTests/copyAST_tests/copytest2007_30.C). Only get_nextNamespaceDefinition()
// appears to sometimes be non-null, so we reset them both to NULL just to make sure.
namespaceDefinition->set_nextNamespaceDefinition(NULL);
namespaceDefinition->set_previousNamespaceDefinition(NULL);
ROSE_ASSERT(namespaceDefinition->get_nextNamespaceDefinition() == NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == NULL);
#endif
namespaceMap.insert(std::pair<SgName,std::vector<SgNamespaceDefinitionStatement*> >(mangledNamespaceName,list));
#error "DEAD CODE"
#if ALIAS_SYMBOL_DEBUGGING
printf ("namespaceMap.size() = %" PRIuPTR " \n",namespaceMap.size());
#endif
}
}
#error "DEAD CODE"
#else
// DQ (5/23/2013): Commented out since we now have a newer and better namespace support for symbol handling.
// printf ("NOTE:: COMMENTED OUT old support for namespace declarations in FixupAstSymbolTablesToSupportAliasedSymbols traversal \n");
#endif
SgUseStatement* useDeclaration = isSgUseStatement(node);
if (useDeclaration != NULL)
{
// This must be done in the Fortran AST construction since aliased symbols must be inserted
// before they are looked up as part of name resolution of variable, functions, and types.
// For C++ we can be more flexible and support the construction of symbol aliases within
// post-processing.
}
// DQ (4/14/2010): Added this C++ specific support.
// In the future we may want to support the injection of alias symbols for C++ "using" directives and "using" declarations.
SgUsingDeclarationStatement* usingDeclarationStatement = isSgUsingDeclarationStatement(node);
if (usingDeclarationStatement != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("Found the SgUsingDeclarationStatement \n");
#endif
SgScopeStatement* currentScope = usingDeclarationStatement->get_scope();
ROSE_ASSERT(currentScope != NULL);
SgDeclarationStatement* declaration = usingDeclarationStatement->get_declaration();
SgInitializedName* initializedName = usingDeclarationStatement->get_initializedName();
// Only one of these can be non-null.
ROSE_ASSERT(initializedName != NULL || declaration != NULL);
ROSE_ASSERT( (initializedName != NULL && declaration != NULL) == false);
if (declaration != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols::visit(): declaration = %p = %s \n",declaration,declaration->class_name().c_str());
#endif
}
else
{
if (initializedName != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols::visit(): initializedName = %s \n",initializedName->get_name().str());
#endif
}
else
{
printf ("Error: both declaration and initializedName in SgUsingDeclarationStatement are NULL \n");
ROSE_ASSERT(false);
}
}
#if 0
printf ("Exiting at the base of FixupAstSymbolTablesToSupportAliasedSymbols::visit() \n");
ROSE_ASSERT(false);
#endif
}
SgUsingDirectiveStatement* usingDirectiveStatement = isSgUsingDirectiveStatement(node);
if (usingDirectiveStatement != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("Found the SgUsingDirectiveStatement \n");
#endif
SgNamespaceDeclarationStatement* namespaceDeclaration = usingDirectiveStatement->get_namespaceDeclaration();
ROSE_ASSERT(namespaceDeclaration != NULL);
SgScopeStatement* currentScope = usingDirectiveStatement->get_scope();
// To be more specific this is really a SgNamespaceDefinitionStatement
SgScopeStatement* referencedScope = namespaceDeclaration->get_definition();
if (referencedScope == NULL)
{
// DQ (5/21/2010): Handle case of using "std" (predefined namespace in C++), but it not having been explicitly defined (see test2005_57.C).
if (namespaceDeclaration->get_name() != "std")
{
printf ("ERROR: namespaceDeclaration has no valid definition \n");
namespaceDeclaration->get_startOfConstruct()->display("ERROR: namespaceDeclaration has no valid definition");
// DQ (5/20/2010): Added assertion to trap this case.
printf ("Exiting because referencedScope could not be identified.\n");
ROSE_ASSERT(false);
}
}
// Note that "std", as a predefined namespace, can have a null definition, so we can't
// insist that we inject all symbols in namespaces that we can't see explicitly.
if (referencedScope != NULL)
{
ROSE_ASSERT(referencedScope != NULL);
ROSE_ASSERT(currentScope != NULL);
#if 0
printf ("Calling injectSymbolsFromReferencedScopeIntoCurrentScope() for usingDirectiveStatement = %p = %s \n",node,node->class_name().c_str());
#endif
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,currentScope,usingDirectiveStatement,SgAccessModifier::e_default);
}
#if 0
printf ("Exiting at the base of FixupAstSymbolTablesToSupportAliasedSymbols::visit() \n");
ROSE_ASSERT(false);
#endif
}
// DQ (5/6/2011): Added support to build SgAliasSymbols in derived class scopes that reference the symbols of the base classes associated with protected and public declarations.
SgClassDefinition* classDefinition = isSgClassDefinition(node);
if (classDefinition != NULL)
{
// Handle any derived classes.
SgBaseClassPtrList & baseClassList = classDefinition->get_inheritances();
SgBaseClassPtrList::iterator i = baseClassList.begin();
for ( ; i != baseClassList.end(); ++i)
{
// Check each base class.
SgBaseClass* baseClass = *i;
ROSE_ASSERT(baseClass != NULL);
/* skip processing for SgExpBaseClasses (which don't have to define p_base_class) */
if (baseClass->variantT() == V_SgExpBaseClass) {
continue;
}
// printf ("baseClass->get_baseClassModifier().displayString() = %s \n",baseClass->get_baseClassModifier().displayString().c_str());
// printf ("baseClass->get_baseClassModifier().get_accessModifier().displayString() = %s \n",baseClass->get_baseClassModifier().get_accessModifier().displayString().c_str());
// if (baseClass->get_modifier() == SgBaseClass::e_virtual)
if (baseClass->get_baseClassModifier().get_modifier() == SgBaseClassModifier::e_virtual)
{
// Not clear if virtual as a modifier effects the handling of alias symbols.
// printf ("Not clear if virtual as a modifier effects the handling of alias symbols. \n");
}
// DQ (6/22/2011): Define the access level for alias symbol's declarations to be included.
SgAccessModifier::access_modifier_enum accessLevel = baseClass->get_baseClassModifier().get_accessModifier().get_modifier();
SgClassDeclaration* tmpClassDeclaration = baseClass->get_base_class();
ROSE_ASSERT(tmpClassDeclaration != NULL);
#if 0
// ROSE_ASSERT(tmpClassDeclaration->get_definingDeclaration() != NULL);
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(tmpClassDeclaration->get_definingDeclaration());
ROSE_ASSERT(targetClassDeclaration != NULL);
SgScopeStatement* referencedScope = targetClassDeclaration->get_definition();
// We need this function to restrict it's injection of symbol to just those that are associated with public and protected declarations.
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,classDefinition,accessLevel);
#else
// DQ (2/25/2012) We only want to inject the symbol where we have identified the defining scope.
if (tmpClassDeclaration->get_definingDeclaration() != NULL)
{
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(tmpClassDeclaration->get_definingDeclaration());
ROSE_ASSERT(targetClassDeclaration != NULL);
SgScopeStatement* referencedScope = targetClassDeclaration->get_definition();
#if 0
printf ("Calling injectSymbolsFromReferencedScopeIntoCurrentScope() for classDefinition = %p = %s baseClass = %p accessLevel = %d \n",
node,node->class_name().c_str(),baseClass,accessLevel);
#endif
// DQ (7/12/2014): Use the SgBaseClass as the causal node that has triggered the insertion of the SgAliasSymbols.
// We need this function to restrict it's injection of symbol to just those that are associated with public and protected declarations.
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,classDefinition,baseClass,accessLevel);
}
else
{
// DQ (2/25/2012): Print a warning message when this happens (so far only test2012_08.C).
if (SgProject::get_verbose() > 0)
{
mprintf ("WARNING: In FixupAstSymbolTablesToSupportAliasedSymbols::visit(): Not really clear how to handle this case where tmpClassDeclaration->get_definingDeclaration() == NULL! \n");
}
}
#endif
}
}
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(node);
if (functionDeclaration != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("Found a the SgFunctionDeclaration \n");
#endif
// SgScopeStatement* functionScope = functionDeclaration->get_scope();
SgScopeStatement* currentScope = isSgScopeStatement(functionDeclaration->get_parent());
SgClassDefinition* classDefinition = isSgClassDefinition(currentScope);
if (classDefinition != NULL)
{
// This is a function declared in a class definition, test of friend (forget why it is important to test for isOperator().
if (functionDeclaration->get_declarationModifier().isFriend() == true || functionDeclaration->get_specialFunctionModifier().isOperator() == true)
{
// printf ("Process all friend function with a SgAliasSymbol to where they are declared in another scope (usually global scope) \n");
#if 0
SgName name = functionDeclaration->get_name();
SgSymbol* symbol = functionDeclaration->search_for_symbol_from_symbol_table();
ROSE_ASSERT ( symbol != NULL );
SgAliasSymbol* aliasSymbol = new SgAliasSymbol (symbol);
// Use the current name and the alias to the symbol
currentScope->insert_symbol(name,aliasSymbol);
#endif
#if 0
printf ("Error: friend functions not processed yet! \n");
ROSE_ASSERT(false);
#endif
}
}
}
#if ALIAS_SYMBOL_DEBUGGING
printf ("Leaving FixupAstSymbolTablesToSupportAliasedSymbols::visit() (preorder AST traversal) node = %p = %s \n",node,node->class_name().c_str());
#endif
}
IntermediateRepresentationNodeGraph::IntermediateRepresentationNodeGraph(ofstream & inputFile, SgProject* project, const std::vector<VariantT> & inputNodeKindList)
: file(inputFile),
nodeKindList(inputNodeKindList)
{
for (size_t i = 0; i < nodeKindList.size(); i++)
{
printf ("Adding nodeKindList[%" PRIuPTR "] = %d = %s to nodeKindSet \n",i,Cxx_GrammarTerminalNames[nodeKindList[i]].variant,Cxx_GrammarTerminalNames[nodeKindList[i]].name.c_str());
include_nodeKindSet.insert(nodeKindList[i]);
}
// Build a list of functions within the AST
// Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree (project,V_SgFunctionDeclaration);
// Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree (project,V_SgDeclarationStatement);
Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree (project,V_SgStatement);
// include_nodeSet.insert(functionDeclarationList.begin(),functionDeclarationList.end());
int maxNumberOfNodes = 5000;
int numberOfNodes = (int)functionDeclarationList.size();
printf ("Number of IR nodes in IntermediateRepresentationNodeGraph = %d \n",numberOfNodes);
#if 1
int counter = 0;
for (Rose_STL_Container<SgNode*>::iterator i = functionDeclarationList.begin(); i != functionDeclarationList.end(); i++)
{
SgStatement* statement = isSgStatement(*i);
SgDeclarationStatement* declaration = isSgDeclarationStatement(*i);
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(*i);
SgTemplateInstantiationFunctionDecl* templateInstantiationFunctionDeclaration = isSgTemplateInstantiationFunctionDecl(*i);
// if (declaration != NULL && declaration->get_file_info()->isCompilerGenerated() == false)
if (statement != NULL && statement->get_file_info()->isCompilerGenerated() == false)
{
include_nodeSet.insert(statement);
}
if (templateInstantiationFunctionDeclaration != NULL)
{
include_nodeSet.insert(statement);
}
#if 0
// Build a pointer to the current type so that we can call the get_name() member function.
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(*i);
if (functionDeclaration != NULL)
{
// DQ (3/5/2006): Only output the non-compiler generated IR nodes
if ( (*i)->get_file_info()->isCompilerGenerated() == false)
{
// output the function number and the name of the function
printf ("Function #%2d name is %s at line %d \n",counter++,functionDeclaration->get_name().str(),functionDeclaration->get_file_info()->get_line());
}
else
{
// Output something about the compiler-generated builtin functions
printf ("Compiler-generated (builtin) function #%2d name is %s \n",counter++,functionDeclaration->get_name().str());
}
}
else
{
SgDeclarationStatement* declaration = isSgDeclarationStatement(*i);
ROSE_ASSERT(declaration != NULL);
printf ("--- declaration #%2d is: %p = %s \n",counter++,declaration,declaration->class_name().c_str());
}
#endif
}
#endif
if (numberOfNodes <= maxNumberOfNodes)
{
// Ouput nodes.
for (std::set<SgNode*>::iterator i = include_nodeSet.begin(); i != include_nodeSet.end(); i++)
{
SgNode* node = *i;
file << "\"" << StringUtility::numberToString(node) << "\"[" << "label=\"" << node->class_name() << "\\n" << StringUtility::numberToString(node) << "\"];" << endl;
}
// Output edges
for (std::set<SgNode*>::iterator i = include_nodeSet.begin(); i != include_nodeSet.end(); i++)
{
SgNode* node = *i;
std::vector<std::pair<SgNode*,std::string> > listOfIRnodes = node->returnDataMemberPointers();
std::vector<std::pair<SgNode*,std::string> >::iterator j = listOfIRnodes.begin();
while (j != listOfIRnodes.end())
{
if (include_nodeSet.find(j->first) != include_nodeSet.end())
{
file << "\"" << StringUtility::numberToString(node) << "\" -> \"" << StringUtility::numberToString(j->first) << "\"[label=\"" << j->second << "\"];" << endl;
}
j++;
}
}
}
else
{
printf ("WARNING: IntermediateRepresentationNodeGraph is too large to generate: numberOfNodes = %d (max size = %d) \n",numberOfNodes,maxNumberOfNodes);
}
}