int main(int argc, char** argv) {
SgProject* proj = frontend(argc,argv);
SgFunctionDeclaration* mainDecl = SageInterface::findMain(proj);
SgFunctionDefinition* mainDef = mainDecl->get_definition();
std::vector<SgNode*> ifExps;
ifExps = NodeQuery::querySubTree(mainDef, V_SgIfStmt);
for (int i = 0; i < ifExps.size(); i++) {
getIfConds(isSgIfStmt(ifExps[i]), isSgScopeStatement(mainDef));
}
std::vector<SgNode*> assignNodes = NodeQuery::querySubTree(mainDef, V_SgVariableDeclaration);
std::cout << assignNodes.size() << " nodes found" << std::endl;
std::vector<SgBinaryOp*> bin_ops;
std::vector<SgUnaryOp*> un_ops;
std::vector<SgNode*> other;
std::vector<SgExpression*> results;
for (std::vector<SgNode*>::iterator i = assignNodes.begin(); i != assignNodes.end(); i++) {
SgVariableDeclaration* vdecl = isSgVariableDeclaration(*i);
SgInitializedNamePtrList vlst = vdecl->get_variables();
SgInitializedName* initName = isSgInitializedName((*(vlst.begin())));
SgExpression* exp = isSgAssignInitializer(initName->get_initializer())->get_operand();
std::cout << exp->class_name() << std::endl;
if (!isSgFunctionCallExp(exp)) {
getExps(exp, isSgInitializedName(*i), results, 0);
std::cout << "prefixes" << std::endl;
for (int j = 0; j < prefixes.size(); j++) {
SgExprStatement* expSt = SageBuilder::buildExprStatement_nfi(prefixes[j]);
SageInterface::insertStatement(isSgVariableDeclaration(*i),expSt,true);
std::cout << prefixes[j]->class_name() << std::endl;
}
std::cout << "results" << std::endl;
for (int j = 0; j < results.size(); j++) {
std::cout << results[j]->class_name() << std::endl;
}
std::cout << "postfixes" << std::endl;
for (int j = 0; j < postfixes.size(); j++) {
SgExprStatement* expSt = SageBuilder::buildExprStatement_nfi(postfixes[j]);
SageInterface::insertStatement(isSgVariableDeclaration(*i),expSt,false);
std::cout << postfixes[j]->class_name() << std::endl;
}
replaceExps(exp,vdecl);
simplifyExps(exp);
}
}
backend(proj);
return 0;
}
bool compare_types(SgInitializedName* f_name, SgInitializedName* c_name)
{
SgType* c_type = c_name->get_type();
SgType* f_type = f_name->get_type();
SgExpression* f_kind_type = f_type->get_type_kind();
bool hasValue = false;
SgVariableDeclaration* var_dec = isSgVariableDeclaration(f_name->get_declaration());
if (var_dec!= NULL) {
SgTypeModifier type_mod = var_dec->get_declarationModifier().get_typeModifier();
hasValue = type_mod.isValue();
}
SgType* f_to_c_type = fortran_to_c_type(f_type, f_kind_type, hasValue);
if (f_to_c_type != NULL) {
std::cout << "f_to_c_type is " << f_to_c_type->class_name() << ": " << f_to_c_type << std::endl;
if (f_to_c_type == c_type) {
std::cout << "f_to_c_type is equal to c_type, returning true" << std::endl;
return true;
}
}
else {
std::cout << "f_to_c_type is NULL, returning false" << std::endl;
return false;
}
std::cout << "\t compare_types(): Types don't match, returning false" << std::endl;
return false;
}
/*QY: This is used to support traversal of AST by the POET interpreter*/
bool POETAstInterface::MatchAstTypeName(const Ast& n, const std::string& tname)
{
if (tname == "EXP") {
return AstInterface::IsExpression((SgNode*)n) != AST_NULL;
}
else if (tname == "ExpStmt") {
SgExprStatement* s = isSgExprStatement((SgNode*)n);
return (s != 0);
}
else if (tname == "FunctionDecl") {
return AstInterface :: IsFunctionDefinition((SgNode*)n);
}
else if (tname == "For") {
return isSgForStatement((SgNode*)n) != 0;
}
else if (tname == "Assign") {
return AstInterface::IsAssignment((SgNode*)n);
}
else if (tname == "Pragma") {
return isSgPragmaDeclaration((SgNode*)n) != 0;
}
else if (tname == "VarDecl") {
return isSgVariableDeclaration((SgNode*)n) != 0;
}
else if (tname == "Variable") {
return isSgInitializedName((SgNode*)n);
}
else if (tname == "Loop") {}
else std::cerr << "does not recognize type name:" << tname << "\n";
return false;
}
bool
TaintAnalysis::magic_tainted(SgNode *node, FiniteVarsExprsProductLattice *prodLat) {
if (isSgInitializedName(node)) {
SgInitializedName *iname = isSgInitializedName(node);
std::string vname = iname->get_name().getString();
TaintLattice *tlat = dynamic_cast<TaintLattice*>(prodLat->getVarLattice(varID(iname)));
if (tlat && 0==vname.compare(0, 7, "TAINTED")) {
bool modified = tlat->set_vertex(TaintLattice::VERTEX_TAINTED);
if (debug) {
*debug <<"TaintAnalysis::magic_tainted: lattice is magically " <<tlat->to_string()
<<(modified?" (modified)":" (not modified)") <<"\n";
}
return modified;
}
} else if (isSgVarRefExp(node)) {
SgVarRefExp *vref = isSgVarRefExp(node);
std::string vname = vref->get_symbol()->get_name().getString();
TaintLattice *tlat = dynamic_cast<TaintLattice*>(prodLat->getVarLattice(varID(vref)));
if (tlat && 0==vname.compare(0, 7, "TAINTED")) {
bool modified = tlat->set_vertex(TaintLattice::VERTEX_TAINTED);
if (debug) {
*debug <<"TaintAnalysis::magic_tainted: lattice is magically " <<tlat->to_string()
<<(modified?" (modified)":" (not modified)") <<"\n";
}
return modified;
}
} else if (isSgVariableDeclaration(node)) {
SgVariableDeclaration *vdecl = isSgVariableDeclaration(node);
const SgInitializedNamePtrList &inames = vdecl->get_variables();
for (size_t i=0; i<inames.size(); ++i) {
std::string vname = inames[i]->get_name().getString();
TaintLattice *tlat = dynamic_cast<TaintLattice*>(prodLat->getVarLattice(varID(inames[i])));
if (tlat && 0==vname.compare(0, 7, "TAINTED")) {
bool modified = tlat->set_vertex(TaintLattice::VERTEX_TAINTED);
if (debug) {
*debug <<"TaintAnalysis::magic_tainted: lattice is magically " <<tlat->to_string()
<<(modified?" (modified)":" (not modified)") <<"\n";
}
return modified;
}
}
}
return false;
}
void
CompassAnalyses::StaticConstructorInitialization::Traversal::
visit(SgNode* node)
{
// Test for static initialization of variables of type class, such initializations where they are
// static or appear in global scope can be called in an order dependent upon the compiler and this
// can lead to subtle bugs in large scale applications.
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
if (variableDeclaration != NULL)
{
SgInitializedNamePtrList::iterator i = variableDeclaration->get_variables().begin();
while (i != variableDeclaration->get_variables().end())
{
SgInitializedName* initializedName = *i;
// Check the type and see if it is a class (check for typedefs too)
SgType* variableType = initializedName->get_type();
SgClassType *classType = isSgClassType(variableType);
if (classType != NULL)
{
// Now check if this is a global or namespace variable or an static class member
// This might also have to be a test for other scopes as well.
SgScopeStatement* scope = variableDeclaration->get_scope();
if (isSgGlobal(scope) != NULL || isSgNamespaceDefinitionStatement(scope) != NULL)
{
// printf ("Found a global variable defining a class = %p \n",initializedName);
// variableDeclaration->get_file_info()->display("global variable defining a class");
output->addOutput(new CheckerOutput(initializedName));
}
if (isSgClassDefinition(scope) != NULL)
{
// Now check if it is a static data member
if (variableDeclaration->get_declarationModifier().get_storageModifier().isStatic() == true)
{
// printf ("Found a static data member defining a class = %p \n",initializedName);
// variableDeclaration->get_file_info()->display("static data member defining a class");
output->addOutput(new CheckerOutput(initializedName));
}
}
}
// increment though the variables in the declaration (typically just one)
i++;
}
}
} //End of the visit function.
void
SgVariableDeclaration::fixupCopy_symbols(SgNode* copy, SgCopyHelp & help) const
{
#if DEBUG_FIXUP_COPY
printf ("Inside of SgVariableDeclaration::fixupCopy_symbols() for %p = %s copy = %p \n",this,this->class_name().c_str(),copy);
#endif
// Also call the base class version of the fixupCopycopy() member function
SgDeclarationStatement::fixupCopy_symbols(copy,help);
SgVariableDeclaration* variableDeclaration_copy = isSgVariableDeclaration(copy);
ROSE_ASSERT(variableDeclaration_copy != NULL);
// DQ (10/14/2007): Handle the case of a type defined in the base type of the typedef (similar problem for SgVariableDeclaration).
// printf ("this = %p this->get_variableDeclarationContainsBaseTypeDefiningDeclaration() = %s \n",this,this->get_variableDeclarationContainsBaseTypeDefiningDeclaration() ? "true" : "false");
if (this->get_variableDeclarationContainsBaseTypeDefiningDeclaration() == true)
{
ROSE_ASSERT(variableDeclaration_copy->get_variableDeclarationContainsBaseTypeDefiningDeclaration() == true);
SgDeclarationStatement* baseTypeDeclaration_original = this->get_baseTypeDefiningDeclaration();
SgDeclarationStatement* baseTypeDeclaration_copy = variableDeclaration_copy->get_baseTypeDefiningDeclaration();
ROSE_ASSERT(baseTypeDeclaration_original != NULL);
ROSE_ASSERT(baseTypeDeclaration_copy != NULL);
// printf ("In SgVariableDeclaration::fixupCopy_symbols(): Calling fixupCopy on %p = %s \n",baseTypeDeclaration_original,baseTypeDeclaration_original->class_name().c_str());
baseTypeDeclaration_original->fixupCopy_symbols(baseTypeDeclaration_copy,help);
}
const SgInitializedNamePtrList & variableList_original = this->get_variables();
SgInitializedNamePtrList & variableList_copy = variableDeclaration_copy->get_variables();
// printf ("Inside of SgVariableDeclaration::fixupCopy_symbols(): variableList_original.size() = %ld \n",(long)variableList_original.size());
ROSE_ASSERT(variableList_original.size() == variableList_copy.size());
SgInitializedNamePtrList::const_iterator i_original = variableList_original.begin();
SgInitializedNamePtrList::iterator i_copy = variableList_copy.begin();
// Iterate over both lists to match up the correct pairs of SgInitializedName objects
while ( (i_original != variableList_original.end()) && (i_copy != variableList_copy.end()) )
{
// printf ("Looping over the initialized names in the variable declaration variable = %p = %s \n",(*i_copy),(*i_copy)->get_name().str());
(*i_original)->fixupCopy_symbols(*i_copy,help);
i_original++;
i_copy++;
}
}
TEST(SageInterfaceTypeEquivalence, ConstVarIntLiteralArrayIsEqual){
::SgGlobal *global = new SgGlobal();
// build assign-initializer, build variable declaration, build varrefexp
::SgBasicBlock* bb = SageBuilder::buildBasicBlock();
bb->set_parent(global);
::SgAssignInitializer* init = SageBuilder::buildAssignInitializer(SageBuilder::buildIntVal(42), SageBuilder::buildIntType());
::SgVariableDeclaration* vDecl = isSgVariableDeclaration(SageBuilder::buildVariableDeclaration(SgName("refVar"), SageBuilder::buildConstType(SageBuilder::buildIntType()), init, bb));
// vDecl->get_declarationModifier().get_typeModifier().get_constVolatileModifier().setConst();
::SgVarRefExp* vRef = SageBuilder::buildVarRefExp(vDecl);
::SgArrayType* a_7 = SageBuilder::buildArrayType(SageBuilder::buildIntType(), vRef);
::SgArrayType* a_8 = SageBuilder::buildArrayType(SageBuilder::buildIntType(), vRef);
bool tcRef = SageInterface::checkTypesAreEqual(a_7, a_8);
EXPECT_EQ(tcRef, true);
delete global;
}
void UnparseHeadersTransformVisitor::visit(SgNode* node) {
//Use a pointer to a constant SgVariableDeclaration to be able to call the constant getter variableDeclaration -> get_variables(),
//which does not mark the node as modified.
const SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
if (variableDeclaration != NULL) {
const SgInitializedNamePtrList& nameList = variableDeclaration -> get_variables();
for (SgInitializedNamePtrList::const_iterator nameListIterator = nameList.begin(); nameListIterator != nameList.end(); nameListIterator++) {
string originalName = ((*nameListIterator) -> get_name()).getString();
//Rename any variable, whose name ends with matchEnding.
if (originalName.size() >= matchEndingSize && originalName.compare(originalName.size() - matchEndingSize, matchEndingSize, matchEnding) == 0) {
SageInterface::set_name(*nameListIterator, originalName + renameEnding);
}
}
}
}
void
Traversal::visit(SgNode* node)
{
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
// Look for variable declarations appearing in global scope!
// if (variableDeclaration != NULL && isSgGlobal(variableDeclaration->get_parent()) != NULL)
if (variableDeclaration != NULL)
{
SgInitializedNamePtrList::iterator i = variableDeclaration->get_variables().begin();
while (i != variableDeclaration->get_variables().end())
{
SgInitializedName* initializedName = *i;
// Check the type and see if it is a class (check for typedefs too)
SgType* variableType = initializedName->get_type();
SgClassType *classType = isSgClassType(variableType);
if (classType != NULL)
{
// Now check if this is a global variable or an static class member
SgScopeStatement* scope = variableDeclaration->get_scope();
if (isSgGlobal(scope) != NULL)
{
printf ("Found a global variable defining a class \n");
// variableDeclaration->get_file_info()->display("global variable defining a class");
outputPositionInformation(variableDeclaration);
}
if (isSgClassDefinition(scope) != NULL)
{
// Now check if it is a static data member
if (variableDeclaration->get_declarationModifier().get_storageModifier().isStatic() == true)
{
printf ("Found a static data member defining a class \n");
// variableDeclaration->get_file_info()->display("static data member defining a class");
outputPositionInformation(variableDeclaration);
}
}
}
// increment though the variables in the declaration (typically just one)
i++;
}
}
}
VariableIdSet AnalysisAbstractionLayer::astSubTreeVariables(SgNode* node, VariableIdMapping& vidm) {
VariableIdSet vset;
RoseAst ast(node);
for(RoseAst::iterator i=ast.begin();i!=ast.end();++i) {
VariableId vid; // default creates intentionally an invalid id.
if(SgVariableDeclaration* varDecl=isSgVariableDeclaration(*i)) {
vid=vidm.variableId(varDecl);
} else if(SgVarRefExp* varRefExp=isSgVarRefExp(*i)) {
vid=vidm.variableId(varRefExp);
} else if(SgInitializedName* initName=isSgInitializedName(*i)) {
vid=vidm.variableId(initName);
}
if(vid.isValid())
vset.insert(vid);
}
return vset;
}
void
FindVariableDeclarations::visit ( SgNode* astNode )
{
SgBasicBlock* block = isSgBasicBlock(astNode);
if (block != NULL)
{
SgStatementPtrList & listOfStatements = block->get_statements();
for (size_t i = 0; i < listOfStatements.size(); i++)
{
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(listOfStatements[i]);
if (variableDeclaration != NULL)
{
printf ("Found a variable decaration in a SgBasicBlock at: \n");
variableDeclaration->get_file_info()->display("Found a variable decaration in a SgBasicBlock");
}
}
}
}
bool findPublicVarMembers (SgNode *node, string &str) {
SgVariableDeclaration *decl;
if (decl = isSgVariableDeclaration(node)) {
SgDeclarationModifier &dfm = decl->get_declarationModifier();
if (dfm.get_accessModifier().isPublic()) {
// check if it belongs to a class
SgStatement *block = ((SgVariableDeclaration *) node)->get_scope();
SgClassDefinition *classDef;
if (classDef = isSgClassDefinition(block)) {
if (classDef->get_declaration()->get_class_type() == SgClassDeclaration::e_class) {
str = classDef->get_qualified_name().getString();
return true;
}
}
}
}
return false;
}
int main(int argc, char* argv[]) {
SgProject* proj = frontend(argc,argv);
SgFunctionDeclaration* mainDecl = SageInterface::findMain(proj);
SgFunctionDefinition* mainDef = mainDecl->get_definition();
// std::vector<SgNode*> dotExps = NodeQuery::querySubTree(mainDef, V_SgDotExp);
std::vector<SgNode*> varRefs = NodeQuery::querySubTree(mainDef,V_SgVarRefExp);
int classExps = 0;
for (unsigned int i = 0; i < varRefs.size(); i++) {
if (isSgClassType(isSgVarRefExp(varRefs[i])->get_type())) {
SgClassType* ct = isSgClassType(isSgVarRefExp(varRefs[i])->get_type());
std::cout << "name of ref: " << isSgVarRefExp(varRefs[i])->get_symbol()->get_name().getString() << std::endl;
if (SageInterface::isStructType(ct)) {
SgDeclarationStatement* decl = isSgType(ct)->getAssociatedDeclaration();
SgDeclarationStatement* defining_decl = decl->get_definingDeclaration();
if (!(defining_decl->isNameOnly())) {
if (isSgClassDeclaration(defining_decl)) {
if (isSgClassDeclaration(defining_decl)->get_definition()) {
SgDeclarationStatementPtrList member_stats = isSgClassDeclaration(defining_decl)->get_definition()->get_members();
SgDeclarationStatementPtrList::iterator j = member_stats.begin();
for (; j != member_stats.end(); j++) {
SgDeclarationStatement* d = isSgDeclarationStatement(*j);
std::cout << "decl stat name: " << d->class_name() << std::endl;
SgInitializedNamePtrList init_lst = isSgVariableDeclaration(d)->get_variables();
SgInitializedNamePtrList::iterator k = init_lst.begin();
std::cout << "variables in initialized name ptr list..." << std::endl;
for (; k != init_lst.end(); k++) {
std::cout << isSgInitializedName(*k)->get_name().getString() << std::endl;
std::cout << isSgInitializedName(*k)->get_type()->class_name() << std::endl;
}
}
classExps+=1;
}
}
}
}
}
}
std::cout << "num class_exp: " << classExps << std::endl;
return 0;
}
void fixupEdgBugDuplicateVariablesInAST()
{
// DQ (3/11/2006): Introduce tracking of performance of ROSE.
TimingPerformance timer1 ("Fixup known EDG bug where some variable declarations are dropped from the source sequence lists:");
std::set<SgVariableDeclaration*> declarations_to_remove;
// Loop over all variables added using the convert_field_use() function.
std::set<SgVariableDeclaration*>::iterator i = nodesAddedWithinFieldUseSet.begin();
while (i != nodesAddedWithinFieldUseSet.end())
{
SgVariableDeclaration* var_decl = *i;
SgName name = var_decl->get_variables()[0]->get_name();
SgClassDefinition* classDefinition = isSgClassDefinition(var_decl->get_parent());
ROSE_ASSERT(classDefinition != NULL);
std::vector<SgDeclarationStatement*> & members = classDefinition->get_members();
// Loop over all data members in the class.
std::vector<SgDeclarationStatement*>::iterator j = members.begin();
while (j != members.end())
{
SgVariableDeclaration* possible_matching_variable_declaration = isSgVariableDeclaration(*j);
if (possible_matching_variable_declaration != NULL && possible_matching_variable_declaration != var_decl)
{
if (possible_matching_variable_declaration->get_variables()[0]->get_name() == name)
{
#if 0
printf ("matching variable declaration found for name = %s \n",name.str());
#endif
declarations_to_remove.insert(var_decl);
}
}
j++;
}
i++;
}
// Now remove all of the variable declarations that we detected to be duplicates.
std::set<SgVariableDeclaration*>::iterator k = declarations_to_remove.begin();
while (k != declarations_to_remove.end())
{
SgDeclarationStatement* var_decl = *k;
SgClassDefinition* classDefinition = isSgClassDefinition(var_decl->get_parent());
ROSE_ASSERT(classDefinition != NULL);
std::vector<SgDeclarationStatement*> myvector;
myvector.push_back(*k);
std::vector<SgDeclarationStatement*> & members = classDefinition->get_members();
// members.erase(*k);
// members.erase(myvector.begin(),myvector.end());
// This is the remove/erase idiom.
members.erase(remove(members.begin(), members.end(), *k), members.end());
k++;
}
}
void DataFlow<Annotation, Language, Runtime>::createContextFromLoopTree(
const LoopTrees<Annotation> & loop_trees,
context_t & context
) const {
assert(context.datas.empty());
assert(context.datas_in.empty());
assert(context.datas_out.empty());
assert(context.accesses_map.empty());
typename std::set<Data<Annotation> *>::iterator it_data;
const std::vector<Data<Annotation> *> & data_vect = loop_trees.getDatas();
context.datas.insert(data_vect.begin(), data_vect.end());
for (it_data = context.datas.begin(); it_data != context.datas.end(); it_data++) {
assert(*it_data != NULL);
if ((*it_data)->isFlowIn())
context.datas_in.insert(*it_data);
if ((*it_data)->isFlowOut())
context.datas_out.insert(*it_data);
}
const std::vector<typename LoopTrees<Annotation>::node_t *> & nodes = loop_trees.getNodes();
typename std::vector<typename LoopTrees<Annotation>::node_t *>::const_iterator it_node;
for (it_node = nodes.begin(); it_node != nodes.end(); it_node++) {
typename LoopTrees<Annotation>::cond_t * cond = dynamic_cast<typename LoopTrees<Annotation>::cond_t *>(*it_node);
typename LoopTrees<Annotation>::stmt_t * stmt = dynamic_cast<typename LoopTrees<Annotation>::stmt_t *>(*it_node);
if (cond == NULL && stmt == NULL) continue;
typename std::map<typename LoopTrees<Annotation>::node_t *, accesses_list_t>::iterator it_access =
context.accesses_map.insert(std::pair<typename LoopTrees<Annotation>::node_t *, accesses_list_t>(*it_node, accesses_list_t())).first;
std::vector<data_access_t> & read = it_access->second.reads;
std::vector<data_access_t> & write = it_access->second.writes;
if (cond != NULL) {
assert(false); /// \todo
}
else if (stmt != NULL) {
SgExprStatement * expr_stmt = isSgExprStatement(stmt->statement);
SgVariableDeclaration * var_decl = isSgVariableDeclaration(stmt->statement);
if (expr_stmt != NULL) {
SgExpression * exp = expr_stmt->get_expression();
assert(exp != NULL);
SgBinaryOp * bin_op = isSgBinaryOp(exp);
if (bin_op != NULL) {
SgExpression * lhs_exp = bin_op->get_lhs_operand_i();
SgExpression * rhs_exp = bin_op->get_rhs_operand_i();
assert(lhs_exp != NULL && rhs_exp != NULL);
SgAssignOp * assign_op = isSgAssignOp(exp);
SgCompoundAssignOp * compound_assign_op = isSgCompoundAssignOp(exp);
assert((assign_op != NULL) xor (compound_assign_op != NULL)); // FIXME expression statement are not always made of assignement
if (assign_op != NULL || compound_assign_op != NULL) {
append_access(lhs_exp, write, context); // add access in lhs to write set
append_access(rhs_exp, read, context); // add access in rhs to read set
}
if (compound_assign_op != NULL) {
append_access(lhs_exp, read, context); // add access in lhs to read set
}
}
else assert(false); // FIXME expression statement are not always made of binary op
}
else if (var_decl != NULL) {
assert(var_decl->get_variables().size() == 1);
SgInitializedName * init_name = isSgInitializedName(var_decl->get_variables()[0]);
assert(init_name != NULL);
SgInitializer * init = isSgInitializer(init_name->get_initptr());
if (init != NULL) {
SgAssignInitializer * assign_init = isSgAssignInitializer(init);
if (assign_init != NULL) {
SgExpression * exp = assign_init->get_operand_i();
assert(exp != NULL);
append_access(exp, read, context);
}
else assert(false);
}
}
else assert(false);
}
}
}
int main(int argc, char **argv)
{
SgProject *project = frontend(argc, argv);
// Instantiate a class hierarchy wrapper.
ClassHierarchyWrapper classHierarchy( project );
std::list<SgNode *> nodes2 = NodeQuery::querySubTree(project,
V_SgVariableDefinition);
for (std::list<SgNode *>::iterator it = nodes2.begin();
it != nodes2.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgVariableDefinition *varDefn =
isSgVariableDefinition(n);
ROSE_ASSERT(varDefn != NULL);
std::cout << "Var defn: " << varDefn->unparseToCompleteString() << std::endl;
}
std::list<SgNode *> nodes1 = NodeQuery::querySubTree(project,
V_SgVariableDeclaration);
for (std::list<SgNode *>::iterator it = nodes1.begin();
it != nodes1.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgVariableDeclaration *varDecl =
isSgVariableDeclaration(n);
ROSE_ASSERT(varDecl != NULL);
SgInitializedNamePtrList &variables =
varDecl->get_variables();
SgInitializedNamePtrList::iterator varIter;
for (varIter = variables.begin();
varIter != variables.end(); ++varIter) {
SgNode *var = *varIter;
ROSE_ASSERT(var != NULL);
SgInitializedName *initName =
isSgInitializedName(var);
ROSE_ASSERT(initName != NULL);
if ( isSgClassType(initName->get_type()) ) {
SgClassType *classType = isSgClassType(initName->get_type());
ROSE_ASSERT(classType != NULL);
SgDeclarationStatement *declStmt = classType->get_declaration();
ROSE_ASSERT(declStmt != NULL);
SgClassDeclaration *classDeclaration = isSgClassDeclaration(declStmt);
ROSE_ASSERT(classDeclaration != NULL);
// std::cout << "From var decl got: " << classDeclaration->unparseToCompleteString() << std::endl;
SgClassDefinition *classDefinition =
classDeclaration->get_definition();
if ( classDefinition != NULL ) {
std::cout << "From var decl got: " << classDefinition->unparseToCompleteString() << std::endl;
}
}
}
}
std::list<SgNode *> nodes = NodeQuery::querySubTree(project,
V_SgClassDeclaration);
for (std::list<SgNode *>::iterator it = nodes.begin();
it != nodes.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgClassDeclaration *classDeclaration1 =
isSgClassDeclaration(n);
ROSE_ASSERT(classDeclaration1 != NULL);
SgDeclarationStatement *definingDecl =
classDeclaration1->get_definingDeclaration();
if ( definingDecl == NULL )
continue;
SgClassDeclaration *classDeclaration =
isSgClassDeclaration(definingDecl);
ROSE_ASSERT(classDeclaration != NULL);
SgClassDefinition *classDefinition =
classDeclaration->get_definition();
ROSE_ASSERT(classDefinition != NULL);
std::cout << "Calling getSubclasses on " << classDefinition->unparseToCompleteString() << std::endl;
SgClassDefinitionPtrList subclasses =
classHierarchy.getSubclasses(classDefinition);
// Iterate over all subclasses.
for (SgClassDefinitionPtrList::iterator subclassIt = subclasses.begin();
subclassIt != subclasses.end(); ++subclassIt) {
SgClassDefinition *subclass = *subclassIt;
ROSE_ASSERT(subclass != NULL);
std::cout << "subclass" << std::endl;
}
}
#if 0
#if 0
std::list<SgNode *> nodes = NodeQuery::querySubTree(project,
V_SgClassDefinition);
for (std::list<SgNode *>::iterator it = nodes.begin();
it != nodes.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgClassDefinition *classDefinition =
isSgClassDefinition(n);
ROSE_ASSERT(classDefinition != NULL);
std::cout << "Calling getSubclasses on " << classDefinition->unparseToCompleteString() << std::endl;
SgClassDefinitionPtrList subclasses =
classHierarchy.getSubclasses(classDefinition);
// Iterate over all subclasses.
for (SgClassDefinitionPtrList::iterator subclassIt = subclasses.begin();
subclassIt != subclasses.end(); ++subclassIt) {
SgClassDefinition *subclass = *subclassIt;
ROSE_ASSERT(subclass != NULL);
std::cout << "subclass" << std::endl;
}
}
#else
// Collect all function/method invocations.
std::list<SgNode *> nodes = NodeQuery::querySubTree(project,
V_SgFunctionCallExp);
unsigned int numCallSites = 0;
unsigned int numMonomorphicCallSites = 0;
unsigned int numPossibleResolutions = 0;
// Visit each call site.
for (std::list<SgNode *>::iterator it = nodes.begin();
it != nodes.end(); ++it ) {
SgNode *n = *it;
ROSE_ASSERT(n != NULL);
SgFunctionCallExp *functionCallExp =
isSgFunctionCallExp(n);
ROSE_ASSERT(functionCallExp != NULL);
// We are only interested in examining method invocations.
bool isDotExp = false;
if ( !isMethodCall(functionCallExp, isDotExp) )
continue;
numCallSites++;
// Certainly can be resolved to the static method.
numPossibleResolutions++;
if ( isDotExp ) {
// If this is a dot expression (i.e., a.foo()), we can
// statically determine its type.
numMonomorphicCallSites++;
continue;
}
// Retrieve the static function declaration.
SgFunctionDeclaration *functionDeclaration =
getFunctionDeclaration(functionCallExp);
// Ensure it is actually a method declaration.
SgMemberFunctionDeclaration *memberFunctionDeclaration =
isSgMemberFunctionDeclaration(functionDeclaration);
ROSE_ASSERT(memberFunctionDeclaration != NULL);
unsigned int numOverridesForMethod = 0;
if ( ( isVirtual(functionDeclaration) ) ||
( isDeclaredVirtualWithinAncestor(functionDeclaration) ) ) {
SgClassDefinition *classDefinition =
isSgClassDefinition(memberFunctionDeclaration->get_scope());
ROSE_ASSERT(classDefinition != NULL);
SgClassDefinitionPtrList subclasses =
classHierarchy.getSubclasses(classDefinition);
// Iterate over all subclasses.
for (SgClassDefinitionPtrList::iterator subclassIt = subclasses.begin();
subclassIt != subclasses.end(); ++subclassIt) {
SgClassDefinition *subclass = *subclassIt;
ROSE_ASSERT(subclass != NULL);
std::cout << "subclass" << std::endl;
// Iterate over all of the methods defined in this subclass.
SgDeclarationStatementPtrList &decls =
subclass->get_members();
for (SgDeclarationStatementPtrList::iterator declIter = decls.begin();
declIter != decls.end(); ++declIter) {
SgDeclarationStatement *declStmt = *declIter;
ROSE_ASSERT(declStmt != NULL);
SgMemberFunctionDeclaration *method =
isSgMemberFunctionDeclaration(declStmt);
if ( method == NULL ) {
continue;
}
// Determine whether subclass of the class defining this
// method overrides the method.
if ( methodOverridesVirtualMethod(method,
memberFunctionDeclaration) ) {
numOverridesForMethod++;
}
}
}
if ( numOverridesForMethod == 0 )
numMonomorphicCallSites++;
numPossibleResolutions += numOverridesForMethod;
std::cout << "Method invocation has " << numOverridesForMethod + 1 << " possible resolutions " << std::endl;
std::cout << functionCallExp->unparseToCompleteString() << std::endl;
}
}
#endif
#endif
return 0;
}
MySynthesizedAttribute
MyTraversal::evaluateRewriteSynthesizedAttribute (
SgNode* astNode,
MyInheritedAttribute inheritedAttribute,
SubTreeSynthesizedAttributes synthesizedAttributeList )
{
MySynthesizedAttribute returnAttribute;
switch(astNode->variantT())
{
case V_SgVarRefExp: {
cout << " found V_SgVarRefExp " << astNode->unparseToString() << endl;
if(mReplaceVariable) {
if( ( strcmp( astNode->unparseToString().c_str(), VARIABLE_NAME )==0 ) &&
( isSgTypeInt(isSgVarRefExp(astNode)->get_type()) )
) {
returnAttribute.setVarRefFound( true );
AstRestructure::unparserReplace( isSgVarRefExp(astNode), "newInt" );
cout << " replacing with 'newInt' " << endl;
}
}
} break;
case V_SgVariableDeclaration: {
SgVariableDeclaration *varDecl = isSgVariableDeclaration(astNode);
cout << " found V_SgVariableDeclaration " << astNode->unparseToString() << endl;
// replace only integer variables called "i"
if( (varDecl->get_traversalSuccessorContainer().size() > 0) &&
isSgInitializedName( varDecl->get_traversalSuccessorContainer()[0]) &&
( strcmp(isSgInitializedName(varDecl->get_traversalSuccessorContainer()[0])->get_name().str(), VARIABLE_NAME )==0 ) &&
( isSgTypeInt(isSgInitializedName(varDecl->get_traversalSuccessorContainer()[0])->get_type()) )
) {
// found declaration of "int i"
string newDeclaration("int newInt = i + 100;");
returnAttribute.insert( varDecl, newDeclaration, HighLevelCollectionTypedefs::LocalScope, HighLevelCollectionTypedefs::AfterCurrentPosition );
assert( mReplaceVariable==0 ); // if it's true, there is another "int i", and this transformation wont work...
mReplaceVariable = 1;
cout << " inserted: '" << newDeclaration <<"' , starting variable replacement " << endl;
}
} break;
default:
break;
} // node type
bool synth = false;
for( SubTreeSynthesizedAttributes::iterator i=synthesizedAttributeList.begin();
i!= synthesizedAttributeList.end(); i++ ) {
if( (*i).getVarRefFound() ) synth = true;
}
if( synth ) {
returnAttribute.setVarRefFound( true );
if(isSgStatement( astNode )) {
cout << " new statement " << " : '" << astNode->unparseToString() << "' " << endl;
returnAttribute.setVarRefFound( false );
//if(!isSgReturnStmt( astNode )) { // DEBUG, this should work!??!?
returnAttribute.replace( astNode, astNode->unparseToString(), HighLevelCollectionTypedefs::LocalScope );
//}
}
}
if(isSgScopeStatement(astNode)) {
// dont replace variable in higher scopes...
if(mReplaceVariable > 0) {
mReplaceVariable--;
cerr << "end of scope " << mReplaceVariable << endl;
}
}
return returnAttribute;
}
void
TypeTransformation::visit ( SgNode* astNode )
{
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(astNode);
if (variableDeclaration != NULL)
{
#if 0
// One way to know where you are when your doing a transformation (debugging).
printf ("Found a variable decaration: \n");
variableDeclaration->get_file_info()->display("Found a variable decaration");
#endif
SgInitializedNamePtrList & varList = variableDeclaration->get_variables();
SgInitializedNamePtrList::iterator i = varList.begin();
bool transformed = false;
// Iterate over the SgInitializedName objects.
while (i != varList.end())
{
SgPointerType* pointerType = isSgPointerType((*i)->get_type());
if (pointerType != NULL)
{
// Types are shared, so don't modify the types directly, but point to a new type.
(*i)->set_type(SageBuilder::buildRestrictType((*i)->get_type()));
#if 1
printf ("In TypeTransformation::visit(): Calling setTransformation on SgInitializedName: i = %p = %s \n",*i,(*i)->get_name().str());
#endif
// DQ (4/14/2015): Explicitly set this as containing a transformation (we might want
// to alternatively fixup the token-based unparsing frontier tests to triggered based
// on the setting of the isModified flag in each IR node.
// (*i)->set_containsTransformation(true);
// (*i)->setTransformation();
transformed = true;
}
i++;
}
if (transformed == true)
{
#if 0
// DQ (4/16/2015): That this can be commented out means that we have general support in place to
// interpret transformations from status of the isModified flags that are set by all of the
// set_* access functions. This interpretation of the isModified flag status to explicitly
// mark transformations is handled in the function:
// SimpleFrontierDetectionForTokenStreamMapping::evaluateInheritedAttribute()
// in file: simpleFrontierDetection.C
// DQ (4/14/2015): Mark the SgVariableDeclaration as being a transformation.
variableDeclaration->setTransformation();
// Also set to be output in the generated code.
variableDeclaration->setOutputInCodeGeneration();
// By definition: for this to be a transformation it cannot also contain a transforamtion.
ROSE_ASSERT(variableDeclaration->get_containsTransformation() == false);
ROSE_ASSERT(variableDeclaration->isTransformation() == true);
#endif
}
}
}
//! Translate generated Pragma Attributes one by one
void translatePragmas (std::vector <MPI_PragmaAttribute*>& Attribute_List)
{
std::vector<MPI_PragmaAttribute*>::iterator iter;
for (iter = Attribute_List.begin(); iter!=Attribute_List.end(); iter ++)
{
MPI_PragmaAttribute* cur_attr = *iter;
cout<<"Translating ..." << cur_attr->toString() <<endl;
SgScopeStatement* scope = cur_attr->pragma_node ->get_scope();
ROSE_ASSERT (scope != NULL);
// simply obtain the default value and remove the pragma
if (cur_attr-> pragma_type == pragma_mpi_device_default)
{
mpi_device_default_choice = cur_attr->default_semantics;
// no automatic handling of attached preprocessed info. for now
removeStatement(cur_attr->pragma_node, false);
}
// find omp target device(mpi:all) begin
else if (cur_attr-> pragma_type == pragma_mpi_device_all_begin)
{
iter ++; // additional increment once
MPI_PragmaAttribute* end_attribute = *iter;
ROSE_ASSERT (end_attribute->pragma_type = pragma_mpi_device_all_end);
removeStatement(cur_attr->pragma_node, false);
removeStatement(end_attribute ->pragma_node, false);
}
else if (cur_attr-> pragma_type == pragma_mpi_device_master_begin)
{ // TODO refactor into a function
iter ++; // additional increment once
MPI_PragmaAttribute* end_attribute = *iter;
ROSE_ASSERT (end_attribute->pragma_type = pragma_mpi_device_master_end);
//insert a if (rank) .. after the end pragma
SgIfStmt * ifstmt = buildIfStmt (buildEqualityOp(buildVarRefExp("_xomp_rank", scope), buildIntVal(0)), buildBasicBlock(), NULL);
insertStatementAfter (end_attribute->pragma_node, ifstmt);
SgBasicBlock * bb = isSgBasicBlock(ifstmt->get_true_body());
SgStatement* next_stmt = getNextStatement(cur_attr->pragma_node); // the next stmt is BB, skip it by starting the search from it
ROSE_ASSERT (next_stmt != NULL);
// normalize all declarations
while ( next_stmt != end_attribute ->pragma_node)
{
// save current stmt before getting next one
SgStatement* cur_stmt = next_stmt;
next_stmt = getNextStatement (next_stmt);
ROSE_ASSERT (next_stmt != NULL);
if (SgVariableDeclaration* decl = isSgVariableDeclaration (cur_stmt))
splitVariableDeclaration (decl);
}
// move all non-declaration statements in between into the block
next_stmt = getNextStatement(cur_attr->pragma_node); //reset from the beginning
while ( next_stmt != end_attribute ->pragma_node)
{
// save current stmt before getting next one
SgStatement* cur_stmt = next_stmt;
next_stmt = getNextStatement (next_stmt);
ROSE_ASSERT (next_stmt != NULL);
if (!isSgVariableDeclaration(cur_stmt))
{
// now remove the current stmt
removeStatement (cur_stmt, false);
appendStatement(cur_stmt, bb);
}
}
// remove pragmas
removeStatement(cur_attr->pragma_node, false);
removeStatement(end_attribute ->pragma_node, false);
}
} // end for
} // end translatePragmas ()
//return name for various named constructs
string roseNode::getName() const
{
string result;
ROSE_ASSERT(mNode!=NULL);
// only declarations with symbols in ROSE have user-level names
// need to double check this
if (isSgFile(mNode))
{
return isSgFile(mNode)->get_file_info()->get_filenameString ();
}
else if (isSgProject(mNode))
{ // No name field for rose projects
return "";
}
else if (isSgFunctionDefinition(mNode))
{
SgFunctionDefinition* def = isSgFunctionDefinition(mNode);
return (def->get_declaration()->search_for_symbol_from_symbol_table()->get_name()).getString();
}
SgDeclarationStatement* decl = isSgDeclarationStatement(mNode);
if (decl)
{
switch (decl->variantT())
{
case V_SgVariableDeclaration:
{
SgVariableSymbol * symbol=SageInterface::getFirstVarSym(isSgVariableDeclaration(decl));
result = symbol->get_name();
break;
}
case V_SgClassDeclaration:
case V_SgTypedefDeclaration:
case V_SgNamespaceDeclarationStatement:
case V_SgFunctionDeclaration:
case V_SgTemplateDeclaration:
case V_SgMemberFunctionDeclaration:
{
result = (decl->search_for_symbol_from_symbol_table()->get_name()).getString();
ROSE_ASSERT(result.length()!=0);
break;
}
// No explicit name available
case V_SgCtorInitializerList:
case V_SgPragmaDeclaration:
case V_SgFunctionParameterList:
case V_SgUsingDirectiveStatement:
case V_SgStmtDeclarationStatement:
{
break;
}
default:
{
cerr<<"error, unhandled declaration type in roseNode::getName(): "<<mNode->class_name()<<endl;
ROSE_ASSERT(false);
break;
}
}// end switch
}
return result ;
}
void flattenScopes(SgFunctionDefinition * fDef)
{
// * 3.3: find all variables in the function,give them a unique name and move them to the bgeinning of the function, this is allowed because this is for C only!!!. This would not work for classes which must be constructed
// rename variables
list<SgNode*> varDeclList=NodeQuery::querySubTree(fDef,V_SgInitializedName);
for (list<SgNode*>::iterator varDecl=varDeclList.begin();varDecl!=varDeclList.end();varDecl++)
{
tring varName=isSgInitializedName(*varDecl)->get_name().getString();
char numberCString[255];
sprintf(numberCString,"%i",idNr);
string newVarName=string("PML")+string(numberCString)+string("_")+varName;
idNr++;
isSgInitializedName(*varDecl)->set_name(SgName(newVarName.c_str()));
}
list<SgNode*> newDeclList;
varDeclList.clear();
varDeclList=NodeQuery::querySubTree(procFuncVec[procNr],V_SgVariableDeclaration);
// the move the variable declaration to the function begin and replace the old declaration site with a definition
for (list<SgNode*>::iterator varDecl=varDeclList.begin();varDecl!=varDeclList.end();varDecl++)
{
SgVariableDeclaration * varDeclStmt=isSgVariableDeclaration(*varDecl);
SgVariableDefinition * varDef=varDeclStmt->get_definition();
SgInitializedName *iniName=isSgInitializedName(varDef->get_vardefn());
if (iniName->get_initializer () !=NULL)
{
// cout <<"VarDecl >"<<iniName->get_name().getString()<<"< has initilizer >"<<iniName->get_initializer ()->unparseToString()<<"<"<<endl;
// determine if it is safe to separate initializer from decl
// for now true
if (1)
{
Sg_File_Info * fi=Sg_File_Info::generateDefaultFileInfoForTransformationNode();
SgVarRefExp * varRef=new SgVarRefExp (Sg_File_Info::generateDefaultFileInfoForTransformationNode(),new SgVariableSymbol(iniName));
SgType * type=isSgAssignInitializer(iniName->get_initializer())->get_type ();
SgAssignInitializer * sai=isSgAssignInitializer(iniName->get_initializer());
if (sai==NULL)
{
cerr<<"isSgAssignInitializer(iniName->get_initializer())=NULL"<<endl;
exit(-1);
}
SgExpression *lhs,*rhs;
lhs=varRef;
rhs=sai->get_operand ();
if (lhs==NULL)
{
cerr<<"lhs=NULL"<<endl;
exit(-1);
}
if (rhs==NULL)
{
cerr<<"rhs=NULL"<<endl;
exit(-1);
}
SgAssignOp * assignment=new SgAssignOp(Sg_File_Info::generateDefaultFileInfoForTransformationNode(),lhs,rhs);
SgExprStatement * expr=new SgExprStatement(fi,assignment);
if (expr==NULL)
{
cerr<<"construction of expr failed"<<endl;
}
isSgAssignInitializer(iniName->get_initializer ())->set_operand(NULL);
free(iniName->get_initializer ());
iniName->set_initializer (NULL);
// put the iniName in the list
newDeclList.push_back(varDeclStmt);
if (isSgStatement(varDeclStmt)==NULL)
{
cerr<<"isSgStatement(varDeclStmt)==NULL"<<endl;
}
LowLevelRewrite::replace(isSgStatement(varDeclStmt),isSgStatement(expr));
}
}
else
{
cout <<"VarDecl >"<<iniName->get_name().getString()<<"> is uninitialized"<<endl;
newDeclList.push_back(varDeclStmt);
LowLevelRewrite::remove(isSgStatement(varDeclStmt));
}
}
for (list<SgNode*>::iterator varDecl=newDeclList.begin();varDecl!=newDeclList.end();varDecl++)
{
fDef->prepend_statement(isSgStatement(*varDecl));
}
return ;
}
void getSgDeclarationStatement(SgDeclarationStatement* declStat) {
VariantT var = declStat->variantT();
std::string declStatStr = "";
switch (var) {
case V_SgEnumDeclaration:
{
SgEnumDeclaration* enum_decl = isSgEnumDeclaration(declStat);
std::string enum_str_name = enum_decl->get_name().getString();
std::cout << ";enum_str_name = " << enum_str_name << std::endl;
if (enums_defined.find(enum_str_name) == enums_defined.end()) {
std::cout << ";enum not yet defined" << std::endl;
std::string enum_name = enum_decl->get_name().getString();
std::stringstream enum_z3;
enum_z3 << "(declare-datatypes () ((" << enum_name;
SgInitializedNamePtrList enumerated_values = enum_decl->get_enumerators();
for (SgInitializedNamePtrList::iterator j = enumerated_values.begin(); j != enumerated_values.end(); j++) {
SgName enum_value_name = (*j)->get_name();
enum_z3 << " " << enum_value_name.getString();
}
enum_z3 << ")))";
std::cout << enum_z3.str() << std::endl;
enums_defined[enum_str_name] = enum_z3.str();
}
break;
}
case V_SgFunctionParameterList:
{
std::cout << "SgFunctionParameterList is not yet implemented" << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgTypedefDeclaration:
{
std::cout << "SgTypedefDeclaration is not yet implemented" << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgVariableDeclaration:
{
SgVariableDeclaration* varDecl = isSgVariableDeclaration(declStat);
SgInitializedName* nam = SageInterface::getFirstInitializedName(varDecl);
/* SgInitializedNamePtrList list = varDecl->get_variables();
std::stringstream declStatStrStream;
int checkOne = 0;
for (SgInitializedNamePtrList::iterator i = list.begin(); i != list.end(); i++) {
if (checkOne == 1) {
std::cout << "InitializedNamePtrList should have only one InitializedName" << std::endl;
ROSE_ASSERT(false);
}
SgInitializedName* ithName = isSgInitializedName(*i);
declStatStrStream << getSgInitializedName(*i) << "\n";
checkOne++;
}
*/
declStatStr = getSgInitializedName(nam) + "\n";
break;
}
case V_SgVariableDefinition:
{
std::cout << "SgVariableDefinition is not yet implemented" << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgAttributeSpecificationStatement:
{
std::cout << "SgAttributeSpecificationStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgCommonBlock:
{
std::cout << "SgCommonBlock is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgEquivalenceStatement:
{
std::cout << "SgEquivalenceStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgImplicitStatement:
{
std::cout << "SgImplicitStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgNamelistStatement:
{
std::cout << "SgNamelistStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgNamespaceDeclarationStatement:
{
std::cout << "SgNamespaceDeclarationStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgTemplateInstantiationDirectiveStatement:
{
std::cout << "SgTemplateInstantiationDirectiveStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgUsingDeclarationStatement:
{
std::cout << "SgUsingDeclarationStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgUsingDirectiveStatement:
{
std::cout << "SgUsingDirectiveStatement is not yet implemented" << std::endl; ;
ROSE_ASSERT(false);
break;
}
case V_SgClassDeclaration:
{
std::cout << "SgClassDeclaration should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgContainsStatement:
{
std::cout << "SgContainsStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgFunctionDeclaration:
{
std::cout << "SgFunctionDeclaration should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgTemplateDeclaration:
{
std::cout << "SgTemplateDeclaration should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgAsmStmt:
{
std::cout << "SgAsmStmt should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgC_PreprocessorDirectiveStatement:
{
std::cout << "SgC_PreprocessorDirectiveStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgClinkageDeclarationStatement:
{
std::cout << "SgClinkageDeclarationStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgCtorInitializerList:
{
std::cout << "SgCtorInitializerList should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgFormatStatement:
{
std::cout << "SgFormatStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgFortranIncludeLine:
{
std::cout << "SgFortranIncludeLine should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgImportStatement:
{
std::cout << "SgImportStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgInterfaceStatement:
{
std::cout << "SgInterfaceStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgJavaImportStatement:
{
std::cout << "SgJavaImportStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgNamespaceAliasDeclarationStatement:
{
std::cout << "SgNamespaceAliasDeclarationStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgStmtDeclarationStatement:
{
std::cout << "SgStmtDeclarationStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgUseStatement:
{
std::cout << "SgUseStatement should not be found here! " << std::endl;
ROSE_ASSERT(false);
break;
}
case V_SgPragmaDeclaration:
{
//std::cout << "pragmas skipped" << std::endl;
// declStatStr=";;pragma\n";
break;
}
default:
{
std::cout << " Unknown node type!: " << declStat->class_name() << std::endl;
ROSE_ASSERT(false);
}
}
declarations.push_back(declStatStr);
return;
}
