static SgType *GetTypedef(SgGlobal *globalScope, const char *name,
SgType *surrogateType)
{
SgTypedefDeclaration *typeDecl ;
SgType *type ;
if (!globalScope->symbol_exists(SgName(name)))
{
SgTypedefSymbol* typedefSymbol ;
/* Note that typeDecl is not added to AST */
typeDecl =
buildTypedefDeclaration(name, surrogateType, globalScope) ;
ROSE_ASSERT(typeDecl) ;
typeDecl->get_file_info()->unsetOutputInCodeGeneration() ;
}
else
{
SgTypedefSymbol *ts = globalScope->lookup_typedef_symbol(SgName(name)) ;
ROSE_ASSERT(ts) ;
typeDecl = ts->get_declaration() ;
ROSE_ASSERT(typeDecl) ;
}
type = isSgType(typeDecl->get_type()) ;
ROSE_ASSERT(type) ;
return type ;
}
/*
* The function
* queryNodeAnonymousTypedef()
* is a NodeQuery which finds all Anonymous Typedefs is the scope.
*/
NodeQuerySynthesizedAttributeType NodeQuery::queryNodeAnonymousTypedef(SgNode* node)
{
NodeQuerySynthesizedAttributeType returnList;
ROSE_ASSERT( node != NULL );
SgTypedefDeclaration* sageTypedefDeclaration = isSgTypedefDeclaration(node);
if (sageTypedefDeclaration != NULL)
if(isSgClassType(sageTypedefDeclaration->get_base_type()))
returnList.push_back(node);
return returnList;
} /* End function:queryNodeCLassDeclarationFromName() */
NameQuerySynthesizedAttributeType
NameQuery::queryNameTypedefDeclarationNames (SgNode * astNode)
{
ROSE_ASSERT (astNode != 0);
NameQuerySynthesizedAttributeType returnNodeList;
SgTypedefDeclaration *sageTypedefDeclaration =
isSgTypedefDeclaration (astNode);
if (sageTypedefDeclaration != NULL)
returnNodeList.push_back (sageTypedefDeclaration->get_name ().str ());
return returnNodeList;
} /* End function queryNameTypedefDeclarationNames */
/**
* class: SgEnumType
* term: enum_type(declaration)
* arg declaration: the term representation of the declaration
*/
PrologCompTerm*
RoseToTerm::getEnumTypeSpecific(SgType* mtype) {
/*make sure we are actually dealing with a class type*/
SgEnumType* ctype = isSgEnumType(mtype);
ROSE_ASSERT(ctype != NULL);
/*add base type*/
string id = ctype->get_name().str();
if (id == "") {
/* nameless enum declarations can occur in typedefs */
SgTypedefDeclaration *td;
if (td = isSgTypedefDeclaration(ctype->get_declaration()->get_parent())) {
id = td->get_mangled_name().str();
}
}
ROSE_ASSERT(id != "" && id != "''");
/*nested type -> nested term*/
return new PrologCompTerm("enum_type", /*1,*/ new PrologAtom(id));
}
/*
* The function
* findTypedefFromTypeName()
* takes as a first parameter a vector<SgNode*> where SgNode*
* is SgScopeStatement*, and as a second parameter it akes
* a typename. It returns a unique instance of a typedef
* corresponding to the typename in the scope. If it has
* not found a corresponding typename it returns 0
*
*
*/
SgTypedefDeclaration *
findTypedefFromTypeName (SgNodePtrVector nodeVector, const string sageName)
{
typedef SgNodePtrVector::iterator nodeIterator;
Rose_STL_Container< SgNode * >tempNodeList, typedefDeclarationList,
foundClassDeclarations;
ROSE_ASSERT (sageName.length () > 0);
for (nodeIterator i = nodeVector.begin (); i != nodeVector.end (); ++i)
{
ROSE_ASSERT (isSgScopeStatement (*i) != NULL);
typedefDeclarationList =
NodeQuery::querySubTree (*i,
NodeQuery::TypedefDeclarations,
NodeQuery::ChildrenOnly);
Rose_STL_Container< SgNode * >::iterator j;
for (j = typedefDeclarationList.begin ();
j != typedefDeclarationList.end (); ++j)
{
// Take an action on each typedef declarations: generate a list of variable declarations
ROSE_ASSERT ((*j) != NULL);
// list<SgNode*> variableDeclarationList = NodeQuery::getTypeDefDeclarations(astNode,NodeQuery::ChildrenOnly);
SgTypedefDeclaration *typedefDeclaration =
isSgTypedefDeclaration (*j);
ROSE_ASSERT (typedefDeclaration != NULL);
string typeName = typedefDeclaration->get_name ().str ();
if (typeName == sageName)
return typedefDeclaration;
}
}
return NULL;
}
/**
* class SgEnumDeclaration
* term: enum_declaration_annotation(name,decl_att)
* arg name: name of the enum
* arg decl_att: declaration attributes (see SgDeclarationStatement
*/
PrologCompTerm*
RoseToTerm::getEnumDeclarationSpecific(SgEnumDeclaration* d) {
ROSE_ASSERT(d != NULL);
//get Enum name
string ename = d->get_name().getString();
if (ename == "") {
/* nameless enum declarations can occur in typedefs */
SgTypedefDeclaration *td;
if (td = isSgTypedefDeclaration(d->get_parent())) {
ename = td->get_mangled_name().str();
}
}
ROSE_ASSERT(ename != "");
PrologTerm *typet = getTypeSpecific(d->get_type());
typeWasDeclaredBefore(typet->getRepresentation());
//create term
return new PrologCompTerm
("enum_declaration_annotation", //4,
new PrologAtom(ename),
getDeclarationAttributes(d),
new PrologInt(d->get_embedded()),
PPI(d));
}
/*
* The function:
* buildTypedefTranslationTable()
* takes as a parameter a SgProject*. It will return a map<SgTypedefDeclaration*, SgType*>
* where the idea is that all SgTypedefDeclaration* are unique, and therefore it is
* possible to create a map with it's corresponding type for easy access.
*/
map< SgTypedefDeclaration*, SgType*>
typeInterpreter::buildTypedefTranslationTable(SgProject* project){
ROSE_ASSERT (project != NULL);
const SgFilePtrList& sageFilePtrList = project->get_fileList ();
//Iterate over all global scopes in the all the files the project spans.
for (unsigned int i = 0; i < sageFilePtrList.size (); i += 1)
{
const SgSourceFile *sageFile = isSgSourceFile (sageFilePtrList[i]);
ROSE_ASSERT (sageFile != NULL);
SgGlobal *sageGlobal = sageFile->get_globalScope();
ROSE_ASSERT (sageGlobal != NULL);
SgTypedefDeclaration* typedefDeclaration;
//Find all TypedefdefDeclarations in current global scope.
Rose_STL_Container< SgNode * > typedefDeclarationList =
NodeQuery::querySubTree (sageGlobal,
NodeQuery::TypedefDeclarations);
// DQ (9/26/2007): Moved from std::list to std::vector uniformly within ROSE.
printf ("Commented out unique() member function since it is not in std::vector class \n");
// typedefDeclarationList.unique();
//Iterate over all SgTypedefDeclarations in current global scope,
//and find corresponding SgType*.
for (Rose_STL_Container< SgNode * >::iterator typedefDeclarationElm =
typedefDeclarationList.begin ();
typedefDeclarationElm != typedefDeclarationList.end ();
++typedefDeclarationElm)
{
typedefDeclaration =
isSgTypedefDeclaration (*typedefDeclarationElm);
ROSE_ASSERT (typedefDeclaration != NULL);
//We only register a typedef once
ROSE_ASSERT (typedefTranslationTable.find (typedefDeclaration) == typedefTranslationTable.end ());
SgType* typedefBaseType = typedefDeclaration->get_base_type();
ROSE_ASSERT(typedefBaseType != NULL );
SgType* baseType = typedefBaseType->findBaseType();
//If the SgTypedefDeclarations has a base type which is of SgTypedefType, find a
//SgType* which is not of type SgTypedefType. That is the corresponging SgType*.
while(isSgTypedefType(baseType) != NULL)
baseType = isSgTypedefType(baseType)->get_base_type();
/* cout << "The name of the typedef is:" << typedefDeclaration->get_name().str() ;
string baseName = TransformationSupport::getTypeName(baseType);
cout << " The correpsonding basetype is:" << baseName << endl;
if(isSgClassType(baseType) == NULL)
cout << "It is NOT a CLASS TYPE." << endl;
*/
ROSE_ASSERT( baseType != NULL );
typedefTranslationTable[typedefDeclaration] = baseType;
}
}
return typedefTranslationTable;
} /* End method: buildTypedefTranslationTable */
DOTSynthesizedAttribute
AstDOTGeneration::evaluateSynthesizedAttribute(SgNode* node, DOTInheritedAttribute ia, SubTreeSynthesizedAttributes l)
{
SubTreeSynthesizedAttributes::iterator iter;
ROSE_ASSERT(node);
// printf ("AstDOTGeneration::evaluateSynthesizedAttribute(): node = %s \n",node->class_name().c_str());
// DQ (5/3/2006): Skip this IR node if it is specified as such in the inherited attribute
if (ia.skipSubTree == true)
{
// I am unclear if I should return NULL or node as a parameter to DOTSynthesizedAttribute
// Figured this out: if we return a valid pointer then we get a node in the DOT graph
// (with just the pointer value as a label), where as if we return a DOTSynthesizedAttribute
// with a NUL pointer then the node will NOT appear in the DOT graph.
// return DOTSynthesizedAttribute(node);
return DOTSynthesizedAttribute(NULL);
}
string nodeoption;
if(AstTests::isProblematic(node))
{
// cout << "problematic node found." << endl;
nodeoption="color=\"orange\" ";
}
string nodelabel=string("\\n")+node->class_name();
// DQ (1/24/2009): Added support for output of isForward flag in the dot graph.
SgDeclarationStatement* genericDeclaration = isSgDeclarationStatement(node);
if (genericDeclaration != NULL)
{
// At the moment the mnemonic name is stored, but it could be computed in the
// future from the kind and the tostring() function.
string name = (genericDeclaration->isForward() == true) ? "isForward" : "!isForward";
ROSE_ASSERT(name.empty() == false);
// DQ (3/20/2011): Added class names to the generated dot file graphs of the AST.
SgClassDeclaration* classDeclaration = isSgClassDeclaration(genericDeclaration);
if (classDeclaration != NULL)
{
nodelabel += string("\\n") + classDeclaration->get_name();
}
// DQ (3/20/2011): Added function names to the generated dot file graphs of the AST.
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(genericDeclaration);
if (functionDeclaration != NULL)
{
nodelabel += string("\\n") + functionDeclaration->get_name();
}
// DQ (2/29/2012): Added typedef names to the generated dot file graphs of the AST.
SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(genericDeclaration);
if (typedefDeclaration != NULL)
{
nodelabel += string("\\n") + typedefDeclaration->get_name();
}
nodelabel += string("\\n") + name;
}
// DQ (4/6/2011): Added support for output of the name for SgInitializedName IR nodes.
SgInitializedName* initializedName = isSgInitializedName(node);
if (initializedName != NULL)
{
nodelabel += string("\\n") + initializedName->get_name();
}
// DQ (4/6/2011): Added support for output of the name for SgInitializedName IR nodes.
SgIntVal* intValue = isSgIntVal(node);
if (intValue != NULL)
{
nodelabel += string("\\n value = ") + StringUtility::numberToString(intValue->get_value());
}
// DQ (4/6/2011): Added support for output of the name for SgInitializedName IR nodes.
SgVarRefExp* varRefExp = isSgVarRefExp(node);
if (varRefExp != NULL)
{
SgVariableSymbol* variableSymbol = varRefExp->get_symbol();
ROSE_ASSERT(variableSymbol != NULL);
string name = variableSymbol->get_name();
nodelabel += string("\\n name = ") + name;
}
// DQ (1/19/2009): Added support for output of what specific instrcution this is in the dot graph.
SgAsmInstruction* genericInstruction = isSgAsmInstruction(node);
if (genericInstruction != NULL)
{
#ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT
// At the moment the mnemonic name is stored, but it could be computed in the
// future from the kind and the tostring() function.
#if 1
string unparsedInstruction = unparseInstruction(genericInstruction);
string addressString = StringUtility::numberToString( (void*) genericInstruction->get_address() );
// string name = genericInstruction->get_mnemonic();
string name = unparsedInstruction + "\\n address: " + addressString;
#else
string name = unparsedInstruction + "\\n" + addressString;
#endif
ROSE_ASSERT(name.empty() == false);
nodelabel += string("\\n") + name;
#else
printf ("Warning: In AstDOTGeneration.C ROSE_BUILD_BINARY_ANALYSIS_SUPPORT is not defined \n");
#endif
}
SgAsmExpression* genericExpression = isSgAsmExpression(node);
if (genericExpression != NULL)
{
#ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT
string name = unparseExpression(genericExpression, NULL, NULL);
ROSE_ASSERT(name.empty() == false);
nodelabel += string("\\n") + name;
#else
printf ("Warning: In AstDOTGeneration.C ROSE_BUILD_BINARY_ANALYSIS_SUPPORT is not defined \n");
#endif
}
// DQ (10/29/2008): Added some support for additional output of internal names for specific IR nodes.
// In generall there are long list of these IR nodes in the binary and this helps make some sense of
// the lists (sections, symbols, etc.).
SgAsmExecutableFileFormat* binaryFileFormatNode = isSgAsmExecutableFileFormat(node);
if (binaryFileFormatNode != NULL)
{
#ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT
// The case of binary file format IR nodes can be especially confusing so we want the
// default to output some more specific information for some IR nodes (e.g. sections).
string name;
SgAsmGenericSection* genericSection = isSgAsmGenericSection(node);
if (genericSection != NULL)
{
SgAsmGenericString* genericString = genericSection->get_name();
ROSE_ASSERT(genericString != NULL);
name = genericString->get_string();
}
SgAsmGenericSymbol* genericSymbol = isSgAsmGenericSymbol(node);
if (genericSymbol != NULL)
{
SgAsmGenericString* genericString = genericSymbol->get_name();
ROSE_ASSERT(genericString != NULL);
name = genericString->get_string();
if (name.empty() == true)
name = "no_name_for_symbol";
}
SgAsmGenericDLL* genericDLL = isSgAsmGenericDLL(node);
if (genericDLL != NULL)
{
SgAsmGenericString* genericString = genericDLL->get_name();
ROSE_ASSERT(genericString != NULL);
name = genericString->get_string();
}
SgAsmPEImportItem* peImportItem = isSgAsmPEImportItem(node);
if (peImportItem != NULL)
{
SgAsmGenericString* genericString = peImportItem->get_name();
ROSE_ASSERT(genericString != NULL);
name = genericString->get_string();
}
SgAsmDwarfLine* asmDwarfLine = isSgAsmDwarfLine(node);
if (asmDwarfLine != NULL)
{
char buffer[100];
// It does not work to embed the "\n" into the single sprintf parameter.
// sprintf(buffer," Addr: 0x%08"PRIx64" \n line: %d col: %d ",asmDwarfLine->get_address(),asmDwarfLine->get_line(),asmDwarfLine->get_column());
sprintf(buffer,"Addr: 0x%08"PRIx64,asmDwarfLine->get_address());
name = buffer;
sprintf(buffer,"line: %d col: %d",asmDwarfLine->get_line(),asmDwarfLine->get_column());
name += string("\\n") + buffer;
}
SgAsmDwarfConstruct* asmDwarfConstruct = isSgAsmDwarfConstruct(node);
if (asmDwarfConstruct != NULL)
{
name = asmDwarfConstruct->get_name();
}
#if 0
// This might not be the best way to implement this, since we want to detect common base classes of IR nodes.
switch (node->variantT())
{
case V_SgAsmElfSection:
{
SgAsmElfSection* n = isSgAsmElfSection(node);
name = n->get_name();
break;
}
default:
{
// No additional information is suggested for the default case!
}
}
#endif
if (name.empty() == false)
nodelabel += string("\\n") + name;
#else
printf ("Warning: In AstDOTGeneration.C ROSE_BUILD_BINARY_ANALYSIS_SUPPORT is not defined \n");
#endif
}
// DQ (11/29/2008): Output the directives in the label of the IR node.
SgC_PreprocessorDirectiveStatement* preprocessorDirective = isSgC_PreprocessorDirectiveStatement(node);
if (preprocessorDirective != NULL)
{
string s = preprocessorDirective->get_directiveString();
// Change any double quotes to single quotes so that DOT will not misunderstand the generated lables.
while (s.find("\"") != string::npos)
{
s.replace(s.find("\""),1,"\'");
}
if (s.empty() == false)
nodelabel += string("\\n") + s;
}
nodelabel += additionalNodeInfo(node);
// DQ (11/1/2003) added mechanism to add additional options (to add color, etc.)
// nodeoption += additionalNodeOptions(node);
string additionalOptions = additionalNodeOptions(node);
// printf ("nodeoption = %s size() = %ld \n",nodeoption.c_str(),nodeoption.size());
// printf ("additionalOptions = %s size() = %ld \n",additionalOptions.c_str(),additionalOptions.size());
string x;
string y;
x += additionalOptions;
nodeoption += additionalOptions;
DOTSynthesizedAttribute d(0);
// DQ (7/27/2008): Added mechanism to support pruning of AST
bool commentoutNode = commentOutNodeInGraph(node);
if (commentoutNode == true)
{
// DQ (11/10/2008): Fixed to only output message when (verbose_level > 0); command-line option.
// DQ (7/27/2008): For now just return to test this mechanism, then we want to add comment "//" propoerly to generated DOT file.
if (SgProject::get_verbose() > 0)
{
printf ("Skipping the use of this IR node in the DOT Graph \n");
}
}
else
{
// **************************
switch(traversal)
{
case TOPDOWNBOTTOMUP:
dotrep.addNode(node,dotrep.traceFormat(ia.tdbuTracePos,tdbuTrace)+nodelabel,nodeoption);
break;
case PREORDER:
case TOPDOWN:
dotrep.addNode(node,dotrep.traceFormat(ia.tdTracePos)+nodelabel,nodeoption);
break;
case POSTORDER:
case BOTTOMUP:
dotrep.addNode(node,dotrep.traceFormat(buTrace)+nodelabel,nodeoption);
break;
default:
assert(false);
}
++tdbuTrace;
++buTrace;
// add edges or null values
int testnum=0;
for (iter = l.begin(); iter != l.end(); iter++)
{
string edgelabel = string(node->get_traversalSuccessorNamesContainer()[testnum]);
string toErasePrefix = "p_";
if (AstTests::isPrefix(toErasePrefix,edgelabel))
{
edgelabel.erase(0, toErasePrefix.size());
}
if ( iter->node == NULL)
{
// SgNode* snode=node->get_traversalSuccessorContainer()[testnum];
AstSuccessorsSelectors::SuccessorsContainer c;
AstSuccessorsSelectors::selectDefaultSuccessors(node,c);
SgNode* snode=c[testnum];
// isDefault shows that the default constructor for synth attribute was used
if (l[testnum].isDefault() && snode && (visitedNodes.find(snode) != visitedNodes.end()) )
{
// handle bugs in SAGE
dotrep.addEdge(node,edgelabel,snode,"dir=forward arrowhead=\"odot\" color=red ");
}
else
{
if (snode == NULL)
{
dotrep.addNullValue(node,"",edgelabel,"");
}
}
}
else
{
// DQ (3/5/2007) added mechanism to add additional options (to add color, etc.)
string edgeoption = additionalEdgeOptions(node,iter->node,edgelabel);
switch(traversal)
{
case TOPDOWNBOTTOMUP:
dotrep.addEdge(node,edgelabel,(*iter).node,edgeoption + "dir=both");
break;
case PREORDER:
case TOPDOWN:
dotrep.addEdge(node,edgelabel,(*iter).node,edgeoption + "dir=forward");
break;
case POSTORDER:
case BOTTOMUP:
dotrep.addEdge(node,edgelabel,(*iter).node,edgeoption + "dir=back");
break;
default:
assert(false);
}
}
testnum++;
}
// **************************
}
// DQ (7/4/2008): Support for edges specified in AST attributes
AstAttributeMechanism* astAttributeContainer = node->get_attributeMechanism();
if (astAttributeContainer != NULL)
{
// Loop over all the attributes at this IR node
for (AstAttributeMechanism::iterator i = astAttributeContainer->begin(); i != astAttributeContainer->end(); i++)
{
// std::string name = i->first;
AstAttribute* attribute = i->second;
ROSE_ASSERT(attribute != NULL);
// This can return a non-empty list in user-defined attributes (derived from AstAttribute).
// printf ("Calling attribute->additionalNodeInfo() \n");
std::vector<AstAttribute::AttributeNodeInfo> nodeList = attribute->additionalNodeInfo();
// printf ("nodeList.size() = %lu \n",nodeList.size());
for (std::vector<AstAttribute::AttributeNodeInfo>::iterator i_node = nodeList.begin(); i_node != nodeList.end(); i_node++)
{
SgNode* nodePtr = i_node->nodePtr;
string nodelabel = i_node->label;
string nodeoption = i_node->options;
// printf ("In AstDOTGeneration::evaluateSynthesizedAttribute(): Adding a node nodelabel = %s nodeoption = %s \n",nodelabel.c_str(),nodeoption.c_str());
// dotrep.addNode(NULL,dotrep.traceFormat(ia.tdTracePos)+nodelabel,nodeoption);
dotrep.addNode( nodePtr, dotrep.traceFormat(ia.tdTracePos) + nodelabel, nodeoption );
}
// printf ("Calling attribute->additionalEdgeInfo() \n");
std::vector<AstAttribute::AttributeEdgeInfo> edgeList = attribute->additionalEdgeInfo();
// printf ("edgeList.size() = %lu \n",edgeList.size());
for (std::vector<AstAttribute::AttributeEdgeInfo>::iterator i_edge = edgeList.begin(); i_edge != edgeList.end(); i_edge++)
{
string edgelabel = i_edge->label;
string edgeoption = i_edge->options;
// printf ("In AstDOTGeneration::evaluateSynthesizedAttribute(): Adding an edge from i_edge->fromNode = %p to i_edge->toNode = %p edgelabel = %s edgeoption = %s \n",i_edge->fromNode,i_edge->toNode,edgelabel.c_str(),edgeoption.c_str());
dotrep.addEdge(i_edge->fromNode,edgelabel,i_edge->toNode,edgeoption + "dir=forward");
}
}
}
switch(node->variantT())
{
// DQ (9/1/2008): Added case for output of SgProject rooted DOT file.
// This allows source code and binary files to be combined into the same DOT file.
case V_SgProject:
{
SgProject* project = dynamic_cast<SgProject*>(node);
ROSE_ASSERT(project != NULL);
string generatedProjectName = SageInterface::generateProjectName( project );
// printf ("generatedProjectName (from SgProject) = %s \n",generatedProjectName.c_str());
if (generatedProjectName.length() > 40)
{
// printf ("Warning: generatedProjectName (from SgProject) = %s \n",generatedProjectName.c_str());
generatedProjectName = "aggregatedFileNameTooLong";
printf ("Proposed (generated) filename is too long, shortened to: %s \n",generatedProjectName.c_str());
}
string filename = string("./") + generatedProjectName + ".dot";
// printf ("generated filename for dot file (from SgProject) = %s \n",filename.c_str());
if ( SgProject::get_verbose() >= 1 )
printf ("Output the DOT graph from the SgProject IR node (filename = %s) \n",filename.c_str());
dotrep.writeToFileAsGraph(filename);
break;
}
// case V_SgFile:
case V_SgSourceFile:
case V_SgBinaryComposite:
{
SgFile* file = dynamic_cast<SgFile*>(node);
ROSE_ASSERT(file != NULL);
string original_filename = file->getFileName();
// DQ (7/4/2008): Fix filenamePostfix to go before the "."
// string filename = string("./") + ROSE::stripPathFromFileName(original_filename) + "."+filenamePostfix+"dot";
string filename = string("./") + ROSE::stripPathFromFileName(original_filename) + filenamePostfix + ".dot";
// printf ("generated filename for dot file (from SgSourceFile or SgBinaryComposite) = %s file->get_parent() = %p \n",filename.c_str(),file->get_parent());
// printf ("file->get_parent() = %p \n",file->get_parent());
// cout << "generating DOT file (from SgSourceFile or SgBinaryComposite): " << filename2 << " ... ";
// DQ (9/1/2008): this effects the output of DOT files when multiple files are specified
// on the command line. A SgProject is still built even when a single file is specificed
// on the command line, however there are cases where a SgFile can be built without a
// SgProject and this case allows those SgFile rooted subtrees to be output as DOT files.
// If there is a SgProject then output the dot file from there, else output as a SgFile.
if (file->get_parent() == NULL)
{
// If there is no SgProject then output the file now!
if ( SgProject::get_verbose() >= 1 )
printf ("Output the DOT graph from the SgFile IR node (no SgProject available) \n");
dotrep.writeToFileAsGraph(filename);
}
else
{
// There is a SgProject IR node, but if we will be traversing it we want to output the
// graph then (so that the graph will include the SgProject IR nodes and connect multiple
// files (SgSourceFile or SgBinaryComposite IR nodes).
if ( visitedNodes.find(file->get_parent()) == visitedNodes.end() )
{
// This SgProject node was not input as part of the traversal,
// so we will not be traversing the SgProject IR nodes and we
// have to output the graph now!
if ( SgProject::get_verbose() >= 1 )
printf ("Output the DOT graph from the SgFile IR node (SgProject was not traversed) \n");
dotrep.writeToFileAsGraph(filename);
}
else
{
if ( SgProject::get_verbose() >= 1 )
printf ("Skip the output of the DOT graph from the SgFile IR node (SgProject will be traversed) \n");
}
}
// cout << "done." << endl;
break;
}
// DQ (7/23/2005): Implemented default case to avoid g++ warnings
// about enum values not handled by this switch
default:
{
// nothing to do here
break;
}
}
d.node = node;
return d;
}
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;
}
SgName
Unparser_Nameq::lookup_generated_qualified_name ( SgNode* referencedNode )
{
// These are all of the types of IR nodes that can reference anything that is qualified.
// It is a longer list than I expected (or designed for initially), but still not unreasonable.
SgName nameQualifier;
if (referencedNode == NULL)
{
// DQ (6/25/2011): This is the case of the using the unparseToString() function. Our more sophisticated name
// qualification support is not possible to support in this case (because we don;'t have the scope from which
// to compute the qualified name) and so a fully qualified name is generated by default.
// printf ("Note that info.set_reference_node_for_qualification(SgNode*) should have been called before calling this function. \n");
// DQ (6/23/2011): This test fails this assertion: tests/roseTests/programAnalysisTests/testCallGraphAnalysis/test3.C
// but allow it to pass as a test.
// printf ("WARNING: referencedNode in Unparser_Nameq::lookup_generated_qualified_name() should be a valid pointer! \n");
#if 0
// DQ (3/5/2012): Uncommenting this for debugging.
printf ("WARNING: referencedNode in Unparser_Nameq::lookup_generated_qualified_name() should be a valid pointer! \n");
#endif
return nameQualifier;
}
ROSE_ASSERT(referencedNode != NULL);
#if 0
printf ("In Unparser_Nameq::lookup_generated_qualified_name(): referencedNode = %p = %s \n",referencedNode,referencedNode->class_name().c_str());
#endif
switch (referencedNode->variantT())
{
case V_SgInitializedName:
{
SgInitializedName* initializedName = isSgInitializedName(referencedNode);
nameQualifier = initializedName->get_qualified_name_prefix_for_type();
break;
}
// DQ (12/29/2011): Added cases for new template IR nodes.
case V_SgTemplateFunctionDeclaration:
case V_SgTemplateMemberFunctionDeclaration:
case V_SgFunctionDeclaration:
case V_SgMemberFunctionDeclaration:
case V_SgTemplateInstantiationFunctionDecl:
case V_SgTemplateInstantiationMemberFunctionDecl:
{
SgFunctionDeclaration* node = isSgFunctionDeclaration(referencedNode);
nameQualifier = node->get_qualified_name_prefix_for_return_type();
break;
}
case V_SgTypedefDeclaration:
{
SgTypedefDeclaration* node = isSgTypedefDeclaration(referencedNode);
nameQualifier = node->get_qualified_name_prefix_for_base_type();
break;
}
case V_SgTemplateArgument:
{
#if 0
// DQ (5/4/2013): This was previously disabled, maybe because the SgTemplateArgument is shared between too many declarations (in different scopes).
printf ("WARNING: lookup of qualifier prefix from SgTemplateArgument was previously disabled \n");
#endif
SgTemplateArgument* node = isSgTemplateArgument(referencedNode);
nameQualifier = node->get_qualified_name_prefix_for_type();
break;
}
// DQ (7/13/2013): I think we need this here, but wait until we generate the error to drive it to be introduced.
// Also this does not permit handling of multiple types requiring different name qualification (same as for throw support).
// DQ (7/12/2013): Added support to type trait builtin functions
case V_SgTypeTraitBuiltinOperator:
// DQ (8/19/2013): Added support for constructor initializers that might have an associated
// qualified name string associated with the templated class or instantiated template class.
case V_SgConstructorInitializer:
case V_SgTypeIdOp:
case V_SgSizeOfOp:
case V_SgNewExp:
case V_SgCastExp:
{
// SgCastExp* node = isSgCastExp(referencedNode);
SgExpression* node = isSgExpression(referencedNode);
nameQualifier = node->get_qualified_name_prefix_for_referenced_type();
break;
}
case V_SgClassType:
{
// These can appear in throw expression lists...ignore for now...
// SgType* node = isSgType(referencedNode);
// nameQualifier = node->get_qualified_name_prefix_for_type();
// printf ("WARNING: Note that qualified types in throw expression lists are not yet supported... \n");
break;
}
case V_SgFunctionType:
{
// These can appear in typedefs of function pointers...ignore for now...
// SgType* node = isSgType(referencedNode);
// nameQualifier = node->get_qualified_name_prefix_for_type();
// printf ("WARNING: Note that qualified types in function pointer typedefs are not yet supported... \n");
break;
}
case V_SgTypedefType:
{
// These can appear in typedef types...ignore for now...
// SgType* node = isSgType(referencedNode);
// nameQualifier = node->get_qualified_name_prefix_for_type();
// printf ("WARNING: Note that qualified types in typedef types are not yet supported... \n");
break;
}
#if 0
case V_:
{
* node = is (referencedNode);
nameQualifier = node->get_qualified_name_prefix_for_type();
break;
}
#endif
default:
{
printf ("In Unparser_Nameq::lookup_generated_qualified_name(): Sorry not implemented case of name qualification for info.get_reference_node_for_qualification() = %s \n",referencedNode->class_name().c_str());
ROSE_ASSERT(false);
}
}
return nameQualifier;
}