std::string CompassAnalyses::AllowedFunctions::Traversal:: typeVariantT( SgType *type, int vT ) { switch( vT ) { case V_SgArrayType: { SgType *baseType = isSgArrayType(type)->get_base_type(); ROSE_ASSERT(baseType != NULL); return this->typeVariantT( baseType, baseType->variantT() ) + "[]"; } break; case V_SgMemberFunctionType: //fall case V_SgPartialFunctionType: //fall case V_SgPartialFunctionModifierType: //fall thru case V_SgFunctionType: { SgFunctionType *fType = isSgFunctionType(type); ROSE_ASSERT(fType != NULL); return fType->get_mangled_type().getString(); } break; case V_SgModifierType: { SgType *baseType = isSgModifierType(type)->get_base_type(); ROSE_ASSERT(baseType != NULL); return this->typeVariantT(baseType,baseType->variantT()); } break; case V_SgClassType: //fall case V_SgEnumType: //fall case V_SgTypedefType: //fall thru case V_SgNamedType: { SgNamedType *nType = isSgNamedType(type); ROSE_ASSERT(nType != NULL); return nType->get_name().getString(); } break; case V_SgPointerMemberType: //fall thru case V_SgPointerType: { SgType *baseType = isSgPointerType(type)->get_base_type(); ROSE_ASSERT(baseType != NULL); return "*" + this->typeVariantT(baseType,baseType->variantT()); } break; case V_SgQualifiedNameType: { SgType *baseType = isSgQualifiedNameType(type)->get_base_type(); ROSE_ASSERT(baseType != NULL); return this->typeVariantT(baseType,baseType->variantT()); } break; case V_SgReferenceType: { SgType *baseType = isSgReferenceType(type)->get_base_type(); ROSE_ASSERT(baseType != NULL); return "&" + this->typeVariantT(baseType,baseType->variantT()); } break; case V_SgTemplateType: { return "template<T>"; // return isSgTemplateType(type)->get_mangled().getString(); } break; case V_SgTypeBool: return "bool"; case V_SgTypeChar: return "char"; case V_SgTypeComplex: return "complex"; case V_SgTypeDefault: return "default"; case V_SgTypeDouble: return "double"; case V_SgTypeEllipse: return "..."; case V_SgTypeFloat: return "float"; case V_SgTypeGlobalVoid: return "global void"; case V_SgTypeImaginary: return "imaginary"; case V_SgTypeInt: return "int"; case V_SgTypeLong: return "long"; case V_SgTypeLongDouble: return "long double"; case V_SgTypeLongLong: return "long long"; case V_SgTypeShort: return "short"; case V_SgTypeSignedChar: return "signed char"; case V_SgTypeSignedInt: return "signed int"; case V_SgTypeSignedLong: return "signed long"; case V_SgTypeSignedShort: return "signed short"; case V_SgTypeString: return "string"; case V_SgTypeUnknown: return isSgTypeUnknown(type)->get_mangled().getString(); case V_SgTypeUnsignedChar: return "unsigned char"; case V_SgTypeUnsignedInt: return "unsigned int"; case V_SgTypeUnsignedLong: return "unsigned long"; case V_SgTypeUnsignedLongLong: return "unsigned long long"; case V_SgTypeUnsignedShort: return "unsigned short"; case V_SgTypeVoid: return "void"; case V_SgTypeWchar: return "wchar"; default: break; } //switch( vT ) std::cerr << "Got Unknown Variant: " << vT << std::endl; return "unknown"; }
// DQ (8/27/2006): This functionality already exists elsewhere // It is a shame that it is recreated here as well !!! NameQuerySynthesizedAttributeType NameQuery::queryNameTypeName (SgNode * astNode) { ROSE_ASSERT (astNode != NULL); string typeName = ""; Rose_STL_Container< string > returnList; SgType *type = isSgType (astNode); // printf ("In TransformationSupport::getTypeName(): type->sage_class_name() = %s \n",type->sage_class_name()); if (type != NULL) switch (type->variantT ()) { case V_SgTypeComplex: typeName = "complex"; break; case V_SgTypeImaginary: typeName = "imaginary"; break; case V_SgTypeBool: typeName = "bool"; break; case V_SgEnumType: typeName = "enum"; break; case V_SgTypeChar: typeName = "char"; break; case V_SgTypeVoid: typeName = "void"; break; case V_SgTypeInt: typeName = "int"; break; case V_SgTypeDouble: typeName = "double"; break; case V_SgTypeFloat: typeName = "float"; break; case V_SgTypeLong: typeName = "long"; break; case V_SgTypeLongDouble: typeName = "long double"; break; case V_SgTypeEllipse: typeName = "ellipse"; break; case V_SgTypeGlobalVoid: typeName = "void"; break; case V_SgTypeLongLong: typeName = "long long"; break; case V_SgTypeShort: typeName = "short"; break; case V_SgTypeSignedChar: typeName = "signed char"; break; case V_SgTypeSignedInt: typeName = "signed int"; break; case V_SgTypeSignedLong: typeName = "signed long"; break; case V_SgTypeSignedShort: typeName = "signed short"; break; case V_SgTypeString: typeName = "string"; break; case V_SgTypeUnknown: typeName = "unknown"; break; case V_SgTypeUnsignedChar: typeName = "unsigned char"; break; case V_SgTypeUnsignedInt: typeName = "unsigned int"; break; case V_SgTypeUnsignedLong: typeName = "unsigned long"; break; case V_SgTypeUnsignedShort: typeName = "unsigned short"; break; case V_SgTypeUnsignedLongLong: typeName = "unsigned long long"; break; case V_SgReferenceType: { ROSE_ASSERT (isSgReferenceType (type)->get_base_type () != NULL); Rose_STL_Container< string > subTypeNames = queryNameTypeName (isSgReferenceType (type)->get_base_type ()); typedef Rose_STL_Container< string >::iterator typeIterator; //This iterator will only contain one name for (typeIterator i = subTypeNames.begin (); i != subTypeNames.end (); ++i) { string e = *i; typeName = e; break; } break; } case V_SgPointerType: { ROSE_ASSERT (isSgPointerType (type)->get_base_type () != NULL); Rose_STL_Container< string > subTypeNames = queryNameTypeName (isSgPointerType (type)->get_base_type ()); typedef Rose_STL_Container< string >::iterator typeIterator; //This iterator will only contain one name for (typeIterator i = subTypeNames.begin (); i != subTypeNames.end (); ++i) { string e = *i; typeName = e; break; } break; } case V_SgModifierType: { ROSE_ASSERT (isSgModifierType (type)->get_base_type () != NULL); Rose_STL_Container< string > subTypeNames = queryNameTypeName (isSgModifierType (type)->get_base_type ()); typedef Rose_STL_Container< string >::iterator typeIterator; //This iterator will only contain one name for (typeIterator i = subTypeNames.begin (); i != subTypeNames.end (); ++i) { string e = *i; typeName = e; break; } break; } case V_SgNamedType: { SgNamedType *sageNamedType = isSgNamedType (type); ROSE_ASSERT (sageNamedType != NULL); typeName = sageNamedType->get_name ().str (); break; } case V_SgClassType: { SgClassType *sageClassType = isSgClassType (type); ROSE_ASSERT (sageClassType != NULL); typeName = sageClassType->get_name ().str (); break; } case V_SgTypedefType: { SgTypedefType *sageTypedefType = isSgTypedefType (type); ROSE_ASSERT (sageTypedefType != NULL); typeName = sageTypedefType->get_name ().str (); break; } case V_SgPointerMemberType: { SgPointerMemberType *pointerMemberType = isSgPointerMemberType (type); ROSE_ASSERT (pointerMemberType != NULL); SgClassType *classType = isSgClassType(pointerMemberType->get_class_type()->stripTypedefsAndModifiers()); ROSE_ASSERT (classType != NULL); SgClassDeclaration *classDeclaration = isSgClassDeclaration(classType->get_declaration()); ROSE_ASSERT (classDeclaration != NULL); typeName = classDeclaration->get_name ().str (); break; } case V_SgArrayType: { ROSE_ASSERT (isSgArrayType (type)->get_base_type () != NULL); Rose_STL_Container< string > subTypeNames = queryNameTypeName (isSgArrayType (type)->get_base_type ()); typedef Rose_STL_Container< string >::iterator typeIterator; //This iterator will only contain one name for (typeIterator i = subTypeNames.begin (); i != subTypeNames.end (); ++i) { string e = *i; typeName = e; break; } break; } case V_SgFunctionType: { SgFunctionType *functionType = isSgFunctionType (type); ROSE_ASSERT (functionType != NULL); typeName = functionType->get_mangled_type ().str (); break; } case V_SgMemberFunctionType: { SgMemberFunctionType *memberFunctionType = isSgMemberFunctionType (type); ROSE_ASSERT (memberFunctionType != NULL); SgClassType *classType = isSgClassType(memberFunctionType->get_class_type()->stripTypedefsAndModifiers()); ROSE_ASSERT (classType != NULL); SgClassDeclaration *classDeclaration = isSgClassDeclaration(classType->get_declaration()); ROSE_ASSERT (classDeclaration != NULL); typeName = classDeclaration->get_name ().str (); break; } case V_SgTypeWchar: typeName = "wchar"; break; case V_SgTypeDefault: typeName = "default"; break; default: printf ("default reached in switch within TransformationSupport::getTypeName type->sage_class_name() = %s variant = %d \n", type->sage_class_name (), type->variant ()); ROSE_ABORT (); break; } // Fix for purify problem report // typeName = ROSE::stringDuplicate(typeName); if (typeName.size () > 0) returnList.push_back (typeName); //ROSE_ASSERT(typeName.c_str() != NULL); // return typeName; return returnList; //return ROSE::stringDuplicate(typeName.c_str()); }