void visitorTraversal::visit(SgNode* n)
{
// There are three types ir IR nodes that can be queried for scope:
// - SgStatement, and
// - SgInitializedName
SgStatement* statement = isSgStatement(n);
if (statement != NULL)
{
SgScopeStatement* scope = statement->get_scope();
ROSE_ASSERT(scope != NULL);
printf ("SgStatement = %12p = %30s has scope = %12p = %s (total number = %d) \n",
statement,statement->class_name().c_str(),
scope,scope->class_name().c_str(),(int)scope->numberOfNodes());
}
SgInitializedName* initializedName = isSgInitializedName(n);
if (initializedName != NULL)
{
SgScopeStatement* scope = initializedName->get_scope();
ROSE_ASSERT(scope != NULL);
printf ("SgInitializedName = %12p = %30s has scope = %12p = %s (total number = %d)\n",
initializedName,initializedName->get_name().str(),
scope,scope->class_name().c_str(),(int)scope->numberOfNodes());
}
}
const SgFunctionDefinition*
findRootFunc (const SgScopeStatement* scope)
{
// DQ (12/13/2011): This function is being called recursively (infinite recursion) for test2011_187.C (added support for SgTemplateFunctionDefinition).
// printf ("Inside of findRootFunc(scope = %p) \n",scope);
if (scope != NULL)
{
if (scope->variantT () == V_SgFunctionDefinition)
{
return isSgFunctionDefinition (scope);
}
else
{
if (scope->variantT () == V_SgTemplateFunctionDefinition)
{
return isSgTemplateFunctionDefinition (scope);
}
else
{
// DQ (12/13/2011): Adding test for improperly set scope.
// printf ("In findRootFunc(): scope = %p = %s \n",scope,scope->class_name().c_str());
SgScopeStatement* nextOuterScope = scope->get_scope();
ROSE_ASSERT(nextOuterScope != NULL);
#if 0
printf ("nextOuterScope = %p = %s \n",nextOuterScope,nextOuterScope->class_name().c_str());
#endif
ROSE_ASSERT(nextOuterScope != scope);
return findRootFunc(scope->get_scope());
}
}
}
// Not found.
return NULL;
}
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
Traversal::processNames(SgNode* n, SynthesizedAttribute& synthesizedAttribute )
{
// Now process the list of names for matches
// Matching names (eventually we have to map this back to the AST)
vector< std::pair<NameStructureType,NameStructureType> > results;
SgScopeStatement* scopeStatement = isSgScopeStatement(n);
ROSE_ASSERT(scopeStatement != NULL);
int i_index = 0;
vector<NameStructureType>::iterator i;
for (i = synthesizedAttribute.nameList.begin();
i != synthesizedAttribute.nameList.end();
++i)
{
++i_index;
// size_t i_length = i->size();
int j_index = 0;
vector<NameStructureType>::iterator j;
for (j = synthesizedAttribute.nameList.begin();
j != synthesizedAttribute.nameList.end();
++j)
{
++j_index;
// We only want to visit the lower triangular part of the n^2
// matchings of names to each other. This reduces the number of
// comparisions required.
if (j_index <= i_index)
{
#if DEBUG > 1
printf ("Skipping case of "
"j_index = %d <= i_index = %d (%s,%s) \n",
j_index,
i_index,
i->c_str(),
j->c_str());
#endif
continue;
}
#if DEBUG > 2
printf ("Evaluating greatestPossibleSimilarity of "
"j_index = %d <= i_index = %d (%s,%s) \n",
j_index,
i_index,
i->c_str(),
j->c_str());
#endif
size_t i_length = i->size();
size_t j_length = j->size();
float greatestPossibleSimilarity =
((float)j_length) / ((float)i_length);
if (greatestPossibleSimilarity > 1.0)
{
greatestPossibleSimilarity =
1.0 / greatestPossibleSimilarity;
}
if (greatestPossibleSimilarity < similarity_threshold)
{
#if DEBUG > 1
printf ("Skipping case of "
"j_index = %d i_index = %d (%s,%s) "
"greatestPossibleSimilarity = %f \n",
j_index,
i_index,
i->c_str(),
j->c_str(),
greatestPossibleSimilarity);
#endif
continue;
}
#if DEBUG > 2
printf ("Evaluating similarityMetric of"
"j_index = %d <= i_index = %d (%s,%s) \n",
j_index,
i_index,
i->c_str(),
j->c_str());
#endif
float similarity =
similarityMetric(
i->c_str(),
j->c_str());
if (similarity > similarity_threshold)
{
string lcs = longestCommonSubstring(i->c_str(), j->c_str());
#if DEBUG > 1
printf("\n\"%s\" and \"%s\" are %3.0f%% similar.\n"
"One of the longest common sequences is \"%s\".\n\n",
i->c_str(),
j->c_str(),
similarity*100,
lcs.c_str());
#endif
results.push_back(
std::pair<NameStructureType, NameStructureType> (*i, *j));
}
}
}// for each synthesized attribute
// Output the resulting matches of any non-empty list of results
if (results.empty() == false)
{
if (SgProject::get_verbose() > 2)
{
printf ("Processing matches of name in "
"scope = %p = %s = %s \n",
scopeStatement,
scopeStatement->class_name().c_str(),
SageInterface::get_name(scopeStatement).c_str());
}
vector< std::pair<NameStructureType, NameStructureType> >::iterator i;
for (i = results.begin(); i != results.end(); ++i)
{
// Output the matching names
SgNode* firstNode = i->first.associatedNode;
ROSE_ASSERT(firstNode != NULL);
SgNode* secondNode = i->second.associatedNode;
ROSE_ASSERT(secondNode != NULL);
float similarity =
similarityMetric(i->first.c_str(), i->second.c_str());
int similarityPercentage = 100 * similarity;
SgLocatedNode* first_node =
isSgLocatedNode(i->first.associatedNode);
SgLocatedNode* second_node =
isSgLocatedNode(i->second.associatedNode);
if (first_node != NULL &&
second_node != NULL &&
first_node != second_node)
{
if (Compass::IsNodeInUserLocation(first_node, source_directory_) &&
Compass::IsNodeInUserLocation(second_node, source_directory_))
{
output_->addOutput(
CompassAnalyses::VariableNameSimilarity::
CreateCheckerOutput(
similarityPercentage,
first_node,
second_node));
}
}
}
}
}
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
}
SgScopeStatement*
AtermSupport::getAtermScopeNodeAttribute (ATerm term, const std::string & annotationName )
{
SgScopeStatement* returnNode = NULL;
ATerm idannot = ATgetAnnotation(term, ATmake(annotationName.c_str()));
if (idannot)
{
#if 1
printf ("In getAtermScopeNodeAttribute(): Found an annotation: annotationName = %s \n",annotationName.c_str());
#endif
char* id = NULL;
// Get the associated annotation string.
if (ATmatch(idannot, "<str>", &id))
{
#if 1
printf ("In getAtermScopeNodeAttribute(): Found an string in the annotation: annotationName = %s id = %s \n",annotationName.c_str(),id);
#endif
if (translationScopeMap.find(id) != translationScopeMap.end())
{
returnNode = translationScopeMap[id];
ROSE_ASSERT(returnNode != NULL);
#if 1
printf ("In getAtermScopeNodeAttribute translationScopeMap: id = %s returnNode = %p = %s \n",id,returnNode,returnNode->class_name().c_str());
#endif
}
else
{
#if 1
printf ("In getAtermScopeNodeAttribute(): Node not found in translationNodeMap: returing NULL pointer \n");
#endif
}
}
else
{
printf ("Error: The nested aterm associated with the annotation must be available on the aterm: annotationName = %s \n",annotationName.c_str());
ROSE_ASSERT(false);
}
}
else
{
printf ("Error: The annotation not found on the aterm: annotationName = %s \n",annotationName.c_str());
ROSE_ASSERT(false);
}
#if 0
printf ("In AtermSupport::getAtermScopeNodeAttribute(): not yet implemented \n");
ROSE_ASSERT(false);
#endif
return returnNode;
}
void
FixupTemplateArguments::visit ( SgNode* node )
{
ROSE_ASSERT(node != NULL);
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
if (variableDeclaration != NULL)
{
// Check the type of the variable declaration, and any template arguments if it is a template type with template arguments.
// SgType* type = variableDeclaration->get_type();
// ROSE_ASSERT(type != NULL);
SgInitializedName* initializedName = SageInterface::getFirstInitializedName(variableDeclaration);
ROSE_ASSERT(initializedName != NULL);
SgType* type = initializedName->get_type();
ROSE_ASSERT(type != NULL);
#if 0
printf ("\n**************************************************************************** \n");
printf ("FixupTemplateArguments::visit(): variableDeclaration = %p = %s initializedName = %s \n",variableDeclaration,variableDeclaration->class_name().c_str(),initializedName->get_name().str());
printf (" --- type = %p = %s \n",type,type->class_name().c_str());
string filename = initializedName->get_file_info()->get_filename();
int linenumber = initializedName->get_file_info()->get_line();
printf (" --- filename = %s line = %d \n",filename.c_str(),linenumber);
#endif
SgScopeStatement* targetScope = variableDeclaration->get_scope();
ROSE_ASSERT(targetScope != NULL);
#if 0
printf ("In FixupTemplateArguments::visit(): targetScope for variableDeclaration = %p = %s \n",targetScope,targetScope->class_name().c_str());
#endif
// DQ (2/16/2017): Don't process code in template instantiations.
SgTemplateInstantiationDefn* templateInstantiationDefn = isSgTemplateInstantiationDefn(targetScope);
SgFunctionDeclaration* functionDeclaration = TransformationSupport::getFunctionDeclaration(targetScope);
SgTemplateInstantiationFunctionDecl* templateInstantiationFunctionDec = isSgTemplateInstantiationFunctionDecl(functionDeclaration);
SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunctionDec = isSgTemplateInstantiationMemberFunctionDecl(functionDeclaration);
// if (templateInstantiationDefn == NULL)
if (templateInstantiationDefn == NULL && templateInstantiationFunctionDec == NULL && templateInstantiationMemberFunctionDec == NULL)
{
#if 1
// DQ (2/15/2017): When this is run, we cause transformations that cause ROSE to have an infinte loop.
// Since this is a second (redundant) invocaion, we likely should just not run this. But it is not
// clear if this truely fixes the problem that I am seeing.
bool result = contains_private_type(type,targetScope);
// DQ (3/25/2017): Added a trivial use to eliminate Clang warning about the return value not being used.
// But it might be that we should not run the function, however this is a complex subject from last month
// that I don't wish to revisit at the moment while being focused om eliminating warnings from Clang.
ROSE_ASSERT(result == true || result == false);
#endif
#if 0
if (result == true)
{
printf ("******** contains private type: variableDeclaration = %p = %s initializedName = %s \n",variableDeclaration,variableDeclaration->class_name().c_str(),initializedName->get_name().str());
}
#endif
}
#if 0
printf ("DONE: FixupTemplateArguments::visit(): variableDeclaration = %p = %s initializedName = %s \n",variableDeclaration,variableDeclaration->class_name().c_str(),initializedName->get_name().str());
#endif
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
}
bool
FixupTemplateArguments::contains_private_type (SgTemplateArgument* templateArgument, SgScopeStatement* targetScope)
{
// Note that within EDG and ROSE the template arguments may be shared so that we can support testing for equivalence.
// static std::list<SgTemplateArgument*> templateArgumentList;
// templateArgumentList.push_back(templateArgument);
static std::set<SgTemplateArgument*> templateArgumentSet;
if (templateArgumentSet.find(templateArgument) == templateArgumentSet.end())
{
templateArgumentSet.insert(templateArgument);
}
else
{
#if DEBUGGING_USING_RECURSIVE_DEPTH
printf ("@@@@@@@@@@@@@@@@@ Already been or being processed: templateArgument = %p = %s templateArgumentSet.size() = %zu \n",templateArgument,templateArgument->unparseToString().c_str(),templateArgumentSet.size());
#endif
#if 0
printf ("Leaving contains_private_type(SgTemplateArgument): templateArgument = %p returning FALSE \n",templateArgument);
#endif
// DQ (2/15/2017): Unclear if this is the correct return value, it might be that we want to record
// the associated value from the first time the argument list was processed and use that value.
// Then again, if the value had already been substituted into the template argument then no further
// processing is required.
return false;
}
#if DEBUGGING_USING_RECURSIVE_DEPTH
printf ("--- added templateArgument = %p templateArgumentSet.size() = %zu \n",templateArgument,templateArgumentSet.size());
#endif
#if DEBUGGING_USING_RECURSIVE_DEPTH
// For debugging, keep track of the recursive depth.
static size_t depth = 0;
printf ("In contains_private_type(SgTemplateArgument*): depth = %zu \n",depth);
ROSE_ASSERT(depth < 500);
printf ("In contains_private_type(SgTemplateArgument*): global_depth = %zu \n",global_depth);
if (global_depth >= 50)
{
// output the list of SgTemplateArgument in the list
printf ("Error: too many elements in list: recursuion too deep \n");
size_t counter = 0;
for (std::set<SgTemplateArgument*>::iterator i = templateArgumentSet.begin(); i != templateArgumentSet.end(); i++)
{
printf ("--- templateArgumentSet[counter] = %p = %s \n",*i,templateArgument->unparseToString().c_str());
counter++;
}
}
ROSE_ASSERT(global_depth < 50);
#endif
// Note this is the recursive function.
bool returnValue = false;
#if DEBUG_PRIVATE_TYPE
printf ("In contains_private_type(SgTemplateArgument*): templateArgument = %p = %s = %s \n",templateArgument,templateArgument->class_name().c_str(),templateArgument->unparseToString().c_str());
#endif
switch (templateArgument->get_argumentType())
{
case SgTemplateArgument::type_argument:
{
ROSE_ASSERT (templateArgument->get_type() != NULL);
SgType* templateArgumentType = templateArgument->get_type();
#if DEBUG_PRIVATE_TYPE
printf ("templateArgumentType = %p = %s \n",templateArgumentType,templateArgumentType->class_name().c_str());
if (isSgModifierType(templateArgumentType) != NULL)
{
SgModifierType* modifierType = isSgModifierType(templateArgumentType);
SgType* base_type = modifierType->get_base_type();
printf ("--- base_type = %p = %s \n",base_type,base_type->class_name().c_str());
SgNamedType* namedType = isSgNamedType(base_type);
if (namedType != NULL)
{
printf ("--- base_type: name = %s \n",namedType->get_name().str());
}
}
#endif
#if DEBUGGING_USING_RECURSIVE_DEPTH
depth++;
global_depth++;
#endif
#if 0
printf ("In contains_private_type(SgTemplateArgument*): case SgTemplateArgument::type_argument: Calling contains_private_type(templateArgumentType) \n");
#endif
// DQ (2/14/2017): We might want to generate a list of the private types used so
// that we can check them against the scope of the declaration where they occur.
// Note also that this does not address types that might appear in name qualification.
returnValue = contains_private_type(templateArgumentType,targetScope);
#if DEBUGGING_USING_RECURSIVE_DEPTH
depth--;
global_depth--;
#endif
#if 0
printf ("In contains_private_type(SgTemplateArgument*): case SgTemplateArgument::type_argument: DONE calling contains_private_type(templateArgumentType): returnValue = %s \n",returnValue ? "true" : "false");
#endif
if (returnValue == true)
{
// Find an alternative typedef to use instead.
// Note that this need not be a SgTypedefType (the lists are available in every SgType).
SgTypedefType* typedefType = isSgTypedefType(templateArgumentType);
if (typedefType == NULL && isSgModifierType(templateArgumentType) != NULL)
{
SgModifierType* modifierType = isSgModifierType(templateArgumentType);
SgType* base_type = modifierType->get_base_type();
#if 0
printf ("Found SgModifierType: --- base_type = %p = %s \n",base_type,base_type->class_name().c_str());
SgNamedType* namedType = isSgNamedType(base_type);
if (namedType != NULL)
{
printf ("--- base_type: name = %s \n",namedType->get_name().str());
}
#endif
#if 0
printf ("******* Reset the typedefType to what was found in the modifier type as a base type = %p = %s \n",base_type,base_type->class_name().c_str());
#endif
typedefType = isSgTypedefType(base_type);
}
if (typedefType != NULL)
{
// Check if this is a type from a typedef that is in the same scope as the target declaration (variable declaration).
SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(typedefType->get_declaration());
ROSE_ASSERT(typedefDeclaration != NULL);
// Test for the matching scope (an even better test would be to make sure that the targetScope is nested in the typedef scope).
SgScopeStatement* typedefDeclarationScope = typedefDeclaration->get_scope();
ROSE_ASSERT(targetScope != NULL);
ROSE_ASSERT(typedefDeclarationScope != NULL);
#if 0
printf ("targetScope = %p = %s \n",targetScope,targetScope->class_name().c_str());
printf ("typedefDeclarationScope = %p = %s \n",typedefDeclarationScope,typedefDeclarationScope->class_name().c_str());
if (typedefDeclarationScope == targetScope)
{
printf ("In contains_private_type(SgTemplateArgument*): This is a typedef type from the same scope as the target declaration \n");
ROSE_ASSERT(false);
}
#endif
// Consult the list of alreanative typedefs.
SgTypedefSeq* typedef_table = typedefType->get_typedefs();
ROSE_ASSERT(typedef_table != NULL);
#if DEBUG_PRIVATE_TYPE || 0
printf ("Looking at typedef typedefType = %p = %s = %s \n",typedefType,typedefType->class_name().c_str(),typedefType->unparseToString().c_str());
#endif
SgTypePtrList & typedefList = typedef_table->get_typedefs();
bool foundNonPrivateTypeAlias = false;
SgType* suitableTypeAlias = NULL;
int counter = 0;
SgTypePtrList::iterator i = typedefList.begin();
while (foundNonPrivateTypeAlias == false && i != typedefList.end())
{
ROSE_ASSERT(*i != NULL);
#if DEBUG_PRIVATE_TYPE || 0
printf ("Looking for suitable type alias (#%d): *i = %p = %s = %s \n",counter,*i,(*i)->class_name().c_str(),(*i)->unparseToString().c_str());
#endif
#if DEBUGGING_USING_RECURSIVE_DEPTH
global_depth++;
#endif
bool isPrivateType = contains_private_type(*i,targetScope);
#if DEBUGGING_USING_RECURSIVE_DEPTH
global_depth--;
#endif
if (isPrivateType == false)
{
suitableTypeAlias = *i;
foundNonPrivateTypeAlias = true;
}
// foundNonPrivateTypeAlias = !isPrivateType;
i++;
counter++;
}
#if 0
printf ("foundNonPrivateTypeAlias = %s \n",foundNonPrivateTypeAlias ? "true" : "false");
#endif
if (foundNonPrivateTypeAlias == true)
{
ROSE_ASSERT(suitableTypeAlias != NULL);
#if DEBUG_PRIVATE_TYPE_TRANSFORMATION || 0
printf ("targetScope = %p = %s \n",targetScope,targetScope->class_name().c_str());
printf ("typedefDeclarationScope = %p = %s \n",typedefDeclarationScope,typedefDeclarationScope->class_name().c_str());
targetScope->get_file_info()->display("targetScope: debug");
typedefDeclarationScope->get_file_info()->display("typedefDeclarationScope: debug");
printf ("Found private type to be replaced: typedefType = %p = %s = %s \n",typedefType,typedefType->class_name().c_str(),typedefType->unparseToString().c_str());
printf ("Found suitable type alias: suitableTypeAlias = %p = %s = %s \n",suitableTypeAlias,suitableTypeAlias->class_name().c_str(),suitableTypeAlias->unparseToString().c_str());
#endif
#if 0
printf ("SageInterface::whereAmI(targetScope): \n");
SageInterface::whereAmI(targetScope);
printf ("SageInterface::whereAmI(typedefDeclaration): \n");
SageInterface::whereAmI(typedefDeclaration);
#endif
#if 0
printf ("Selecting alternative type to use for unparsing: \n");
printf ("--- were going to use: %s \n",templateArgument->unparseToString().c_str());
printf ("--- selecing instead : %s \n",suitableTypeAlias->unparseToString().c_str());
#endif
// TV (10/05/2018): (ROSE-1431) Traverse the chain of all associated template arguments (coming from the same EDG template argument)
SgTemplateArgument * templateArgument_it = templateArgument;
while (templateArgument_it->get_previous_instance() != NULL) {
templateArgument_it = templateArgument_it->get_previous_instance();
}
ROSE_ASSERT(templateArgument_it != NULL && templateArgument_it->get_previous_instance() == NULL);
do {
#if 0
printf (" Update templateArgument = %p\n", templateArgument);
#endif
templateArgument_it->set_unparsable_type_alias(suitableTypeAlias);
// DQ (1/9/2017): Also set the return result from get_type() so that the name qualification will be handled correctly.
templateArgument_it->set_type(suitableTypeAlias);
templateArgument_it = templateArgument_it->get_next_instance();
}
while (templateArgument_it != NULL);
ROSE_ASSERT(templateArgument_it == NULL);
// #if DEBUG_PRIVATE_TYPE_TRANSFORMATION
#if 0
string typedefType_typeName = generate_string_name (typedefType,NULL);
printf ("typedefType_typeName size = %zu \n",typedefType_typeName.length());
printf ("typedefType_typeName = %s \n",typedefType_typeName.c_str());
string suitableTypeAlias_typeName = generate_string_name (suitableTypeAlias,NULL);
printf ("suitableTypeAlias_typeName size = %zu \n",suitableTypeAlias_typeName.length());
printf ("suitableTypeAlias_typeName size = %s \n",suitableTypeAlias_typeName.c_str());
ROSE_ASSERT(suitableTypeAlias_typeName.length() < typedefType_typeName.length() * 100);
ROSE_ASSERT(suitableTypeAlias_typeName.length() < 40000);
#endif
}
}
else
{
#if DEBUG_PRIVATE_TYPE
printf ("Alternative types not searched for in nontypedef types (not implemented) \n");
#endif
#if 0
printf ("####### Alternative types not searched: templateArgumentType = %p = %s \n",templateArgumentType,templateArgumentType->class_name().c_str());
if (isSgModifierType(templateArgumentType) != NULL)
{
SgModifierType* modifierType = isSgModifierType(templateArgumentType);
SgType* base_type = modifierType->get_base_type();
printf ("--- base_type = %p = %s \n",base_type,base_type->class_name().c_str());
SgNamedType* namedType = isSgNamedType(base_type);
if (namedType != NULL)
{
printf ("--- base_type: name = %s \n",namedType->get_name().str());
}
}
#endif
}
}
break;
}
default:
{
#if DEBUG_PRIVATE_TYPE
printf ("Ignoring non-type template arguments \n");
#endif
}
}
#if DEBUG_PRIVATE_TYPE
printf ("Leaving contains_private_type(SgTemplateArgument*): templateArgument = %p = %s = %s \n",templateArgument,templateArgument->class_name().c_str(),templateArgument->unparseToString().c_str());
#endif
// templateArgumentList.pop_back();
templateArgumentSet.erase(templateArgument);
#if DEBUGGING_USING_RECURSIVE_DEPTH
printf ("--- pop templateArgument = %p templateArgumentSet.size() = %zu \n",templateArgument,templateArgumentSet.size());
#endif
#if 0
printf ("Leaving contains_private_type(SgTemplateArgument): templateArgument = %p returnValue = %s \n",templateArgument,returnValue ? "true" : "false");
#endif
return returnValue;
}
bool FixupTemplateArguments::contains_private_type (SgType* type, SgScopeStatement* targetScope)
{
// DQ (4/2/2018): Note that this function now addresses requirements of supporting both private and protected types.
#if DEBUGGING_USING_RECURSIVE_DEPTH
// For debugging, keep track of the recursive depth.
static size_t depth = 0;
printf ("In contains_private_type(SgType*): depth = %zu \n",depth);
ROSE_ASSERT(depth < 500);
printf ("In contains_private_type(SgType*): global_depth = %zu \n",global_depth);
ROSE_ASSERT(global_depth < 55);
#endif
// Note this is the recursive function.
bool returnValue = false;
#if DEBUG_PRIVATE_TYPE || 0
// DQ (1/7/2016): It is a problem to do this for some files (failing about 35 files in Cxx_tests).
// The issues appears to be in the unparsing of the template arguments of the qualified names for the types.
// printf ("In contains_private_type(SgType*): type = %p = %s = %s \n",type,type->class_name().c_str(),type->unparseToString().c_str());
printf ("In contains_private_type(SgType*): type = %p = %s \n",type,type->class_name().c_str());
#endif
SgTypedefType* typedefType = isSgTypedefType(type);
if (typedefType != NULL)
{
// Get the associated declaration.
SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(typedefType->get_declaration());
ROSE_ASSERT(typedefDeclaration != NULL);
#if 0
bool isPrivate = typedefDeclaration->get_declarationModifier().get_accessModifier().isPrivate();
#else
// DQ (4/2/2018): Fix this to address requirements of both private and protected class members (see Cxx11_tests/test2018_71.C).
bool isPrivate = typedefDeclaration->get_declarationModifier().get_accessModifier().isPrivate() ||
typedefDeclaration->get_declarationModifier().get_accessModifier().isProtected();
#endif
#if DEBUG_PRIVATE_TYPE || 0
printf ("typedefDeclaration isPrivate = %s \n",isPrivate ? "true" : "false");
#endif
// First we need to know if this is a visable type.
bool isVisable = false;
#if 0
printf ("targetScope = %p = %s \n",targetScope,targetScope->class_name().c_str());
// printf ("typedefDeclaration = %p = %s \n",typedefDeclaration,typedefDeclaration->class_name().c_str());
printf ("typedefDeclaration->get_scope() = %p = %s \n",typedefDeclaration->get_scope(),typedefDeclaration->get_scope()->class_name().c_str());
#endif
#if 0
printf ("SageInterface::whereAmI(targetScope): \n");
SageInterface::whereAmI(targetScope);
printf ("SageInterface::whereAmI(typedefDeclaration): \n");
SageInterface::whereAmI(typedefDeclaration);
#endif
#if 0
printf ("\ntargetScope symbol table: \n");
targetScope->get_symbol_table()->print("targetScope");
printf ("end of symbol table \n");
printf ("\ntypedefDeclaration->get_scope() symbol table: \n");
typedefDeclaration->get_scope()->get_symbol_table()->print("typedefDeclaration->get_scope()");
printf ("end of symbol table \n\n");
#endif
// Test for the trivial case of matching scope (an even better test (below) is be to make sure that the targetScope is nested in the typedef scope).
if (typedefDeclaration->get_scope() == targetScope)
{
#if 0
printf ("In contains_private_type(SgType*): This is a typedef type from the same scope as the target declaration \n");
#endif
// ROSE_ASSERT(false);
// return false;
isVisable = true;
}
else
{
// SgTypedefSymbol* lookupTypedefSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
SgTypedefSymbol* typedefSymbol = SageInterface::lookupTypedefSymbolInParentScopes (typedefDeclaration->get_name(),targetScope);
if (typedefSymbol != NULL)
{
#if 0
printf ("In contains_private_type(SgType*): This is not in the current scope but can be reached from the current scope \n");
#endif
// ROSE_ASSERT(false);
// return false;
isVisable = true;
}
else
{
#if 0
printf ("Symbol for typedef name = %s not found in parent scopes \n",typedefDeclaration->get_name().str());
#endif
// ROSE_ASSERT(false);
}
}
#if 0
// Testing codes because it seems that "BitSet" shuld be visiable and so we need to debug this first.
if (typedefDeclaration->get_name() == "BitSet")
{
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
}
#endif
// If this is not private, then we are looking at what would be possbile template arguments used in a possible name qualification.
// if (isPrivate == false)
// if (isPrivate == false && isVisable == false)
if (isVisable == false)
{
if (isPrivate == true)
{
return true;
}
else
{
// Get the scope and see if it is a template instantiation.
SgScopeStatement* scope = typedefDeclaration->get_scope();
#if DEBUG_PRIVATE_TYPE || 0
printf ("++++++++++++++ Looking in parent scope for template arguments: scope = %p = %s \n",scope,scope->class_name().c_str());
#endif
// Get the associated declaration.
switch (scope->variantT())
{
case V_SgTemplateInstantiationDefn:
{
SgTemplateInstantiationDefn* templateInstantiationDefinition = isSgTemplateInstantiationDefn(scope);
ROSE_ASSERT(templateInstantiationDefinition != NULL);
SgTemplateInstantiationDecl* templateInstantiationDeclaration = isSgTemplateInstantiationDecl(templateInstantiationDefinition->get_declaration());
ROSE_ASSERT(templateInstantiationDeclaration != NULL);
SgTemplateArgumentPtrList & templateArgumentPtrList = templateInstantiationDeclaration->get_templateArguments();
for (SgTemplateArgumentPtrList::iterator i = templateArgumentPtrList.begin(); i != templateArgumentPtrList.end(); i++)
{
#if DEBUG_PRIVATE_TYPE
printf ("recursive call to contains_private_type(%p): name = %s = %s \n",*i,(*i)->class_name().c_str(),(*i)->unparseToString().c_str());
#endif
#if DEBUGGING_USING_RECURSIVE_DEPTH
global_depth++;
#endif
bool isPrivateType = contains_private_type(*i,targetScope);
#if DEBUGGING_USING_RECURSIVE_DEPTH
global_depth--;
#endif
returnValue |= isPrivateType;
}
break;
}
default:
{
#if DEBUG_PRIVATE_TYPE
printf ("Ignoring non-SgTemplateInstantiationDefn \n");
#endif
}
}
}
}
else
{
// If it is visible then it need not be qualified and we don't care about if it was private.
ROSE_ASSERT(isVisable == true);
// returnValue = true;
returnValue = false;
}
}
else
{
#if DEBUG_PRIVATE_TYPE || 0
printf ("could be a wrapped type: type = %p = %s (not a template class instantiaton) \n",type,type->class_name().c_str());
if (isSgModifierType(type) != NULL)
{
SgModifierType* modifierType = isSgModifierType(type);
SgType* base_type = modifierType->get_base_type();
printf ("--- base_type = %p = %s \n",base_type,base_type->class_name().c_str());
SgNamedType* namedType = isSgNamedType(base_type);
if (namedType != NULL)
{
printf ("--- base_type: name = %s \n",namedType->get_name().str());
}
}
#endif
// If this is a default SgModifierType then unwrap it.
#if 0
SgModifierType* modifierType = isSgModifierType(type);
if (modifierType != NULL)
{
#error "DEAD CODE!"
// What kind of modifier is this?
printf ("What kind of type modifier: %s \n",modifierType->get_typeModifier().displayString().c_str());
if (modifierType->get_typeModifier().isDefault() == true)
{
// This is a default mode modifier (acting as a wrapper type).
type = modifierType->get_base_type();
}
else
{
printf ("Not a default modifierType wrapper (need to handle this case) \n");
ROSE_ASSERT(false);
}
}
#else
// Strip past pointers and other wrapping modifiers (but not the typedef types, since the whole point is to detect private instatances).
type = type->stripType(SgType::STRIP_MODIFIER_TYPE|SgType::STRIP_REFERENCE_TYPE|SgType::STRIP_RVALUE_REFERENCE_TYPE|SgType::STRIP_POINTER_TYPE|SgType::STRIP_ARRAY_TYPE);
#endif
#if 0
printf ("After stripType(): type = %p = %s \n",type,type->class_name().c_str());
SgNamedType* namedType = isSgNamedType(type);
if (namedType != NULL)
{
printf ("--- stripType: name = %s \n",namedType->get_name().str());
}
#endif
ROSE_ASSERT(type != NULL);
// Make sure this is not a simple template type (else we will have infinite recursion).
// if (type != NULL && type->isIntegerType() == false && type->isFloatType() == false)
// if (type != NULL)
SgTemplateType* templateType = isSgTemplateType(type);
SgClassType* classType = isSgClassType(type);
SgTypeVoid* voidType = isSgTypeVoid(type);
SgRvalueReferenceType* rvalueReferenceType = isSgRvalueReferenceType(type);
SgFunctionType* functionType = isSgFunctionType(type);
SgDeclType* declType = isSgDeclType(type);
// DQ (12/7/2016): An enum type needs to be handled since the declaration might be private (but still debugging this for now).
SgEnumType* enumType = isSgEnumType(type);
// DQ (2/12/2017): Added specific type (causing infinite recursion for CompileTests/RoseExample_tests/testRoseHeaders_03.C.
SgTypeEllipse* typeEllipse = isSgTypeEllipse(type);
SgTypeUnknown* typeUnknown = isSgTypeUnknown(type);
SgTypeComplex* typeComplex = isSgTypeComplex(type);
// DQ (2/16/2017): This is a case causeing many C codes to fail.
SgTypeOfType* typeOfType = isSgTypeOfType(type);
if (type != NULL && templateType == NULL && classType == NULL && voidType == NULL && rvalueReferenceType == NULL &&
functionType == NULL && declType == NULL && enumType == NULL && typeEllipse == NULL &&
typeUnknown == NULL && typeComplex == NULL && typeOfType == NULL)
{
#if DEBUG_PRIVATE_TYPE || 0
printf ("found unwrapped type = %p = %s = %s (not a template class instantiaton) \n",type,type->class_name().c_str(),type->unparseToString().c_str());
#endif
// if (type->isIntegerType() == false && type->isFloatType() == false)
// if (type->isIntegerType() == false && type->isFloatType() == false)
if (type->isIntegerType() == false && type->isFloatType() == false)
{
#if DEBUG_PRIVATE_TYPE || 0
printf ("Making a recursive call to contains_private_type(type): not integer or float type: type = %p = %s \n",type,type->class_name().c_str());
#endif
#if DEBUGGING_USING_RECURSIVE_DEPTH
depth++;
global_depth++;
#endif
bool isPrivateType = contains_private_type(type,targetScope);
#if DEBUGGING_USING_RECURSIVE_DEPTH
depth--;
global_depth--;
#endif
returnValue = isPrivateType;
}
else
{
// This can't be a private type.
#if DEBUG_PRIVATE_TYPE
printf ("This is an integer or float type (of some sort): type = %p = %s = %s \n",type,type->class_name().c_str(),type->unparseToString().c_str());
#endif
returnValue = false;
}
}
else
{
// This is where we need to resolve is any types that are associated with declarations might be private (e.g. SgEnumType).
if (classType != NULL)
{
// Check if this is associated with a template class instantiation.
#if 0
SgClassDeclaration* classDeclaration = isSgClassDeclaration(classType->get_declaration());
ROSE_ASSERT(classDeclaration != NULL);
printf ("--------- classDeclaration = %p = %s = %s \n",classDeclaration,classDeclaration->class_name().c_str(),classDeclaration->get_name().str());
#endif
SgTemplateInstantiationDecl* templateInstantiationDeclaration = isSgTemplateInstantiationDecl(classType->get_declaration());
if (templateInstantiationDeclaration != NULL)
{
#if DEBUGGING_USING_RECURSIVE_DEPTH
global_depth++;
#endif
#if 0
printf ("Calling contains_private_type(SgTemplateArgumentPtrList): templateInstantiationDeclaration = %p = %s \n",
templateInstantiationDeclaration,templateInstantiationDeclaration->get_name().str());
#endif
returnValue = contains_private_type(templateInstantiationDeclaration->get_templateArguments(),targetScope);
#if DEBUGGING_USING_RECURSIVE_DEPTH
global_depth--;
#endif
#if 0
printf ("DONE: Calling contains_private_type(SgTemplateArgumentPtrList): templateInstantiationDeclaration = %p = %s \n",
templateInstantiationDeclaration,templateInstantiationDeclaration->get_name().str());
#endif
}
#if 0
printf ("DONE: --- classDeclaration = %p = %s = %s \n",classDeclaration,classDeclaration->class_name().c_str(),classDeclaration->get_name().str());
#endif
}
}
}
#if DEBUG_PRIVATE_TYPE || 0
printf ("Leaving contains_private_type(SgType*): type = %p = %s = %s returnValue = %s \n",type,type->class_name().c_str(),type->unparseToString().c_str(),returnValue ? "true" : "false");
#endif
return returnValue;
}
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
}
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;
}