void RtedTransformation::insertNamespaceIntoSourceFile(SgSourceFile* sf) {
cerr << "Building Namespace RTED" << endl;
// build new namespace
// the first namespace is used for all forward declarations
SgNamespaceDeclarationStatement* rosenamesp = buildNamespaceDeclaration(
"RTED", sf->get_globalScope());
if (RTEDDEBUG) cerr << " *** Prepending namespace to sf->globalScope() : " << sf->get_globalScope() << endl;
SageInterface::prependStatement(rosenamesp, sf->get_globalScope());
ROSE_ASSERT(rosenamesp->get_definition()->get_parent());
sourceFileRoseNamespaceMap[sf] = rosenamesp; //make_pair(rosenamesp, rosenamesp2);
}
void
Traversal::processNode(SgNode* n, SynthesizedAttribute& synthesizedAttribute )
{
// Look for names of functions
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(n);
if (functionDeclaration != NULL)
{
string name = functionDeclaration->get_name().str();
#if DEBUG > 3
SgFunctionDefinition* functionDefinition =
functionDeclaration->get_definition();
if (functionDefinition != NULL)
printf ("SgFunctionDefinition: %s \n",name.c_str());
else
printf ("SgFunctionDeclaration: %s \n",name.c_str());
#endif
synthesizedAttribute.nameList.push_back(
NameStructureType(name,n));
// nameSet.insert(name);
}
SgInitializedName* initializedName = isSgInitializedName(n);
if (initializedName != NULL)
{
string name = initializedName->get_name().str();
#if DEBUG > 3
printf ("SgInitializedName: %s \n",name.c_str());
#endif
synthesizedAttribute.nameList.push_back(
NameStructureType(name,n));
// nameSet.insert(name);
}
SgNamespaceDeclarationStatement* namespaceDeclaration = isSgNamespaceDeclarationStatement(n);
if (namespaceDeclaration != NULL)
{
string name = namespaceDeclaration->get_name().str();
#if DEBUG > 3
printf ("SgNamespaceDeclaration: %s \n",name.c_str());
#endif
synthesizedAttribute.nameList.push_back(
NameStructureType(name,n));
// nameSet.insert(name);
}
}
PrologCompTerm*
RoseToTerm::getNamespaceScopeName(SgNamespaceDefinitionStatement* def) {
ROSE_ASSERT(def != NULL);
/* get declaration*/
SgNamespaceDeclarationStatement* decl = def->get_namespaceDeclaration();
ROSE_ASSERT(decl != NULL);
/* create annotation term*/
return new PrologCompTerm
("namespace_scope", //3,
/* add qualified name*/
new PrologAtom(decl->get_qualified_name().getString()),
/* add unnamed */
new PrologInt((int)decl->get_isUnnamedNamespace()),
PPI(def));
}
SgClassDeclaration* RtedTransformation::instrumentClassDeclarationIntoTopOfAllSourceFiles(
SgProject* project, SgClassDeclaration* classDecl) {
// **********************
if (RTEDDEBUG) cerr <<"@@@ instrumenting into top "<< endl;
// deep copy the classdecl and make it unparseable
SgClassDeclaration* cd_copy = SageInterface::deepCopy(classDecl);
// cout << ">>>>>> Original ClassType :::: " << classDecl->get_type() << endl;
// cout << ">>>>>> Copied ClassType :::: " << cd_copy->get_type() << endl;
// SgClassType* type_copy = new SgClassType(cd_copy);
//cd_copy->set_type(type_copy);
ROSE_ASSERT(cd_copy);
const SgNodePtrList& nodes2 = NodeQuery::querySubTree(cd_copy, V_SgLocatedNode);
SgNodePtrList::const_iterator nodesIT2 = nodes2.begin();
for (; nodesIT2 != nodes2.end(); ++nodesIT2) {
SgLocatedNode* node = isSgLocatedNode(*nodesIT2);
ROSE_ASSERT(node);
Sg_File_Info* file_info = node->get_file_info();
file_info->setOutputInCodeGeneration();
//cerr << "copying node : " << node->class_name() << endl;
}
if (RTEDDEBUG) cerr << "deep copy of firstnondefining" << endl;
SgClassDeclaration* nondefDecl = isSgClassDeclaration(classDecl->get_firstNondefiningDeclaration());
SgClassDeclaration* cdn_copy = SageInterface::deepCopy(nondefDecl);
ROSE_ASSERT(cdn_copy);
const SgNodePtrList& nodes = NodeQuery::querySubTree(cdn_copy, V_SgLocatedNode);
SgNodePtrList::const_iterator nodesIT = nodes.begin();
for (; nodesIT != nodes.end(); ++nodesIT) {
SgLocatedNode* node = isSgLocatedNode(*nodesIT);
ROSE_ASSERT(node);
Sg_File_Info* file_info = node->get_file_info();
file_info->setOutputInCodeGeneration();
}
cd_copy->set_firstNondefiningDeclaration(cdn_copy);
SgClassType* cls_type = SgClassType::createType(cdn_copy);
cls_type->set_declaration(cdn_copy);
ROSE_ASSERT(cls_type != NULL);
ROSE_ASSERT (cls_type->get_declaration() == cdn_copy);
cdn_copy->set_type(cls_type);
cdn_copy->set_definingDeclaration(cd_copy);
cd_copy->set_type(cdn_copy->get_type());
if (RTEDDEBUG) {
cerr << "@@@@@@@@@@@@@@ Original Class classDecl : " << classDecl << " :: " << cd_copy << endl;
cerr << "@@@@@@@@@@@@@@ Original Class nondefining : " << classDecl->get_firstNondefiningDeclaration()<< " :: " << cdn_copy << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->get_type() : " << cd_copy->get_type() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cdn_copy->get_type() : " << cdn_copy->get_type() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->get_type()->declaration : " <<cd_copy->get_type()->get_declaration() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->definingDeclaration : " << cd_copy->get_definingDeclaration() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->set_firstNondefiningDeclaration : " << cd_copy->get_firstNondefiningDeclaration() << endl;
}
// **********************
// add to top of each source file
// insert at top of all source files in reverse order
// only if the class has private members and if it is declared in a header file
std::vector<SgSourceFile*>::const_iterator aa = srcfiles.begin();
std::vector<SgSourceFile*>::const_iterator zz = srcfiles.end();
for (; aa != zz; ++aa)
{
SgSourceFile* sf = *aa;
assert( isInInstrumentedFile(sf) );
if (RTEDDEBUG) cerr << "Looking through sourcefile: " << sf -> get_file_info() -> get_filename() << endl;
// once we have the new class_decl inserted, we remove all functions and the constructor and destructor
const SgNodePtrList& remNodes = NodeQuery::querySubTree(cd_copy, V_SgFunctionDeclaration);
SgNodePtrList::const_iterator remNodesIt = remNodes.begin();
for (; remNodesIt != remNodes.end(); ++remNodesIt) {
SgFunctionDeclaration* node = isSgFunctionDeclaration(*remNodesIt);
ROSE_ASSERT(node);
SageInterface::removeStatement(node);
}
if (RTEDDEBUG) cerr << " changing privates to public" << endl;
// change each private: to public:
SgClassDefinition* cd_def = cd_copy->get_definition();
ROSE_ASSERT(cd_def);
SgDeclarationStatementPtrList decls = cd_def->get_members();
SgDeclarationStatementPtrList::const_iterator itDecls = decls.begin();
for (;itDecls!=decls.end();++itDecls) {
SgVariableDeclaration* node = isSgVariableDeclaration(*itDecls);
if (node) {
SgDeclarationModifier& mod = node->get_declarationModifier();
SgAccessModifier& am = mod.get_accessModifier();
if (am.isPrivate() || am.isProtected())
am.setPublic();
}
}
// get the namespace RTED to put new class into
if (RTEDDEBUG) cerr << "Finding Namespace RTED " << endl;
SourceFileRoseNMType::const_iterator pit = sourceFileRoseNamespaceMap.find(sf);
ROSE_ASSERT(pit!=sourceFileRoseNamespaceMap.end());
SgNamespaceDeclarationStatement* firstNamespace = pit->second;
// insert at top of file - after includes
if (RTEDDEBUG)
{
cerr << " Prepending to source file: " << sf -> get_file_info() -> get_filename()
<< " class : " << cd_copy->get_name().str()
<< endl;
}
// we prepend it to the top of the file and later move the include back up
SageInterface::prependStatement(cdn_copy,firstNamespace->get_definition());
SageInterface::appendStatement(cd_copy, firstNamespace->get_definition() );
ROSE_ASSERT(cdn_copy->get_symbol_from_symbol_table() != NULL);
classesInRTEDNamespace[classDecl->get_definition()] = cd_def;
}
return cd_copy;
}
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
}
