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;
}
