void examineInitializedName(SgInitializedName *name, ostream &out) { SgSymbol* symbol = name->get_symbol_from_symbol_table(); if (NULL == symbol) return; SgType *type = symbol->get_type(); int nr_stars = 0; stringstream ss1; while (isSgArrayType(type) || isSgPointerType(type)) { if (isSgArrayType(type)) { SgArrayType *atype = isSgArrayType(type); SgExpression *expr = atype->get_index(); type = atype->get_base_type(); ss1 << "["; if (expr) examineExpr(expr, ss1); ss1 << "]"; } else { SgPointerType *ttype = isSgPointerType(type); type = ttype->get_base_type(); nr_stars++; } } examinePrimTypeName(type, out); out << " "; for (int i = 0; i < nr_stars; ++i) out << "*"; out << symbol->get_name().getString(); out << ss1.str(); SgInitializer *initer = name->get_initializer(); if (initer) { switch (initer->variantT()) { case V_SgAssignInitializer: SgAssignInitializer *ai = isSgAssignInitializer(initer); SgExpression *expr = ai->get_operand(); if (expr) { out << "="; examineExpr(expr, out); } break; default: break; } } }
string nodeColor( SgExpression* expression ) { /* color: colorCode:red:on color: colorCode:orange:on color: colorCode:yellow:on color: colorCode:blue:on color: colorCode:green:on color: colorCode:violet:on color: colorCode:brown:on color: colorCode:purple:on color: colorCode:lightblue:on color: colorCode:lightgreen:on color: colorCode:lightred:on color: colorCode:black:on color: colorCode:darkblue:on color: colorCode:grey:on color: colorCode:darkgrey:on color: colorCode:olivegreen:on color: colorCode:darkgreen:on */ string returnString; SgBinaryOp* binaryOperator = isSgBinaryOp(expression); if (binaryOperator != NULL) { switch (binaryOperator->variantT()) { case V_SgAddOp: case V_SgAndAssignOp: case V_SgAndOp: case V_SgArrowExp: case V_SgArrowStarOp: case V_SgAssignOp: case V_SgBitAndOp: case V_SgBitOrOp: case V_SgBitXorOp: case V_SgCommaOpExp: case V_SgDivAssignOp: case V_SgDivideOp: case V_SgDotExp: case V_SgDotStarOp: case V_SgMinusAssignOp: case V_SgModAssignOp: case V_SgModOp: case V_SgMultAssignOp: case V_SgMultiplyOp: case V_SgNotEqualOp: case V_SgOrOp: case V_SgPlusAssignOp: case V_SgPntrArrRefExp: case V_SgScopeOp: case V_SgSubtractOp: case V_SgXorAssignOp: returnString = "orange"; break; case V_SgEqualityOp: case V_SgGreaterOrEqualOp: case V_SgGreaterThanOp: case V_SgIntegerDivideOp: case V_SgIorAssignOp: case V_SgLessOrEqualOp: case V_SgLessThanOp: returnString = "yellow"; break; case V_SgLshiftAssignOp: case V_SgLshiftOp: case V_SgRshiftAssignOp: case V_SgRshiftOp: returnString = "lightred"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",binaryOperator->class_name().c_str()); ROSE_ASSERT(false); break; } } SgUnaryOp* unaryOperator = isSgUnaryOp(expression); if (unaryOperator != NULL) { switch (unaryOperator->variantT()) { case V_SgAddressOfOp: case V_SgBitComplementOp: case V_SgPointerDerefExp: case V_SgThrowOp: case V_SgUnaryAddOp: returnString = "lightblue"; break; case V_SgMinusMinusOp: case V_SgMinusOp: case V_SgNotOp: case V_SgPlusPlusOp: returnString = "darkblue"; break; case V_SgCastExp: case V_SgExpressionRoot: returnString = "black"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",unaryOperator->class_name().c_str()); ROSE_ASSERT(false); break; } } SgInitializer* initializer = isSgInitializer(expression); if (initializer != NULL) { switch (initializer->variantT()) { case V_SgAggregateInitializer: case V_SgAssignInitializer: case V_SgConstructorInitializer: returnString = "lightblue"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",initializer->class_name().c_str()); ROSE_ASSERT(false); break; } } SgValueExp* valueExpression = isSgValueExp(expression); if (valueExpression != NULL) { switch (valueExpression->variantT()) { case V_SgComplexVal: case V_SgIntVal: case V_SgLongIntVal: case V_SgLongLongIntVal: case V_SgShortVal: case V_SgUnsignedCharVal: case V_SgUnsignedIntVal: case V_SgUnsignedLongLongIntVal: case V_SgUnsignedLongVal: case V_SgUnsignedShortVal: returnString = "lightblue"; break; case V_SgFloatVal: case V_SgDoubleVal: case V_SgLongDoubleVal: returnString = "darkblue"; break; case V_SgEnumVal: case V_SgBoolValExp: case V_SgCharVal: case V_SgWcharVal: case V_SgStringVal: returnString = "black"; break; // DQ (11/11/2012): Added support for newer IR nodes in edg4x work. case V_SgTemplateParameterVal: returnString = "red"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",valueExpression->class_name().c_str()); ROSE_ASSERT(false); break; } } if (binaryOperator == NULL && unaryOperator == NULL && initializer == NULL && valueExpression == NULL) { switch (expression->variantT()) { case V_SgFunctionCallExp: case V_SgFunctionRefExp: case V_SgMemberFunctionRefExp: case V_SgPseudoDestructorRefExp: returnString = "violet"; break; case V_SgAsmOp: case V_SgClassNameRefExp: case V_SgConditionalExp: case V_SgDeleteExp: case V_SgExprListExp: case V_SgNewExp: case V_SgNullExpression: case V_SgRefExp: case V_SgSizeOfOp: case V_SgStatementExpression: case V_SgThisExp: case V_SgTypeIdOp: case V_SgVarArgCopyOp: case V_SgVarArgEndOp: case V_SgVarArgOp: case V_SgVarArgStartOneOperandOp: case V_SgVarArgStartOp: case V_SgVariantExpression: case V_SgVarRefExp: returnString = "brown"; break; // DQ (1/23/2013): Added support for newer IR nodes in edg4x work. case V_SgTemplateMemberFunctionRefExp: case V_SgTemplateFunctionRefExp: returnString = "brown"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",expression->class_name().c_str()); ROSE_ASSERT(false); break; } } return returnString; }
ExprSynAttr *examineVariableDeclaration(SgVariableDeclaration* decl, ostream &out) { SgInitializedNamePtrList& name_list = decl->get_variables(); SgInitializedNamePtrList::const_iterator name_iter; ExprSynAttr *ret = NULL; ExprSynAttr *gc = NULL; ret = new ExprSynAttr(); for (name_iter = name_list.begin(); name_iter != name_list.end(); name_iter++) { SgInitializedName* name = *name_iter; SgSymbol* symbol = name->get_symbol_from_symbol_table(); SgType *type = symbol->get_type(); int nr_stars = 0; stringstream ss1; while (isSgArrayType(type) || isSgPointerType(type)) { if (isSgArrayType(type)) { SgArrayType *atype = isSgArrayType(type); SgExpression *expr = atype->get_index(); type = atype->get_base_type(); ss1 << "["; if (expr) examineExpr(expr, ss1); ss1 << "]"; } else { SgPointerType *ttype = isSgPointerType(type); type = ttype->get_base_type(); nr_stars++; } } examinePrimTypeName(type, ret->code); ret->code << " "; for (int i = 0; i < nr_stars; ++i) ret->code << "*"; ret->code << symbol->get_name().getString(); ret->code << ss1.str(); ss1.str(""); SgInitializer *initer = name->get_initializer(); if (initer) { switch (initer->variantT()) { case V_SgAssignInitializer: SgAssignInitializer *ai = isSgAssignInitializer(initer); SgExpression *expr = ai->get_operand(); if (expr) { ret->code << "="; gc = examineExpr(expr, ret->code); if (gc != NULL) delete gc; } break; default: break; } } /* end of this decl */ ret->code << ";"; out << ret->code.str(); return ret; /* cout << "[Decl] Variable (name:"<<symbol->get_name().getString(); cout << ",type:"<<symbol->get_type()->class_name(); cout << ",init:"; SgInitializer* init_expr = name->get_initializer(); if (init_expr) cout << init_expr->class_name(); else cout << "none"; cout << ")" << endl; */ } }
std::string getSgInitializedName(SgInitializedName* initName) { std::string exprStr; SgSymbol* initNameSym = initName->search_for_symbol_from_symbol_table(); std::string varInit = initializeVariable(initName); std::string retString; if (initName->get_initptr() != NULL) { SgInitializer* nameInitializer = initName->get_initializer(); VariantT var = nameInitializer->variantT(); switch (var) { case V_SgAggregateInitializer: { SgAggregateInitializer* aggInit = isSgAggregateInitializer(nameInitializer); if (!isSgArrayType(aggInit->get_type())) { std::cout << "currently only arrays use aggregate initializers, you are using " << aggInit->class_name() << std::endl; ROSE_ASSERT(false); } SgExprListExp* members = aggInit->get_initializers(); SgExpressionPtrList member_expressions = members->get_expressions(); std::string symName = SymbolToZ3[initNameSym]; ROSE_ASSERT(SymbolToInstances[initNameSym] == 0); int arrmem = 0; std::stringstream exprStream; for (SgExpressionPtrList::iterator i = member_expressions.begin(); i != member_expressions.end(); i++) { exprStream << "\n(assert (= (select " << symName << "_0 " << arrmem << ") " << getSgExpressionString((isSgAssignInitializer((*i))->get_operand())) << ")"; arrmem = arrmem+1; } retString = varInit + "\n" + exprStream.str(); #ifdef ARRAY_TEST std::cout << "retString: " << retString << std::endl; #endif break; } case V_SgCompoundInitializer: { std::cout << "SgCompoundInitializer not yet supported" << std::endl; ROSE_ASSERT(false); break; } case V_SgConstructorInitializer: { std::cout << "SgConstructorInitializer is not yet supported" << std::endl; ROSE_ASSERT(false); break; } case V_SgDesignatedInitializer: { std::cout << "SgDesignatedInitializer is not yet supported" << std::endl; ROSE_ASSERT(false); break; } case V_SgAssignInitializer: { SgAssignInitializer* assignInit = isSgAssignInitializer(nameInitializer); std::string symName = SymbolToZ3[initNameSym]; ROSE_ASSERT(SymbolToInstances[initNameSym] == 0); exprStr = "(assert (= " + symName + "_0 " + getSgExpressionString(assignInit->get_operand()) + "))"; retString = varInit + "\n" + exprStr; break; } default: { std::cout << "unknown initializer of type: " << nameInitializer->class_name() << std::endl; ROSE_ASSERT(false); break; } } } else { retString = varInit; } return retString; }