manglingSupport.h

#ifndef mangling_support_INCLUDED
#define mangling_support_INCLUDED
 
// DQ (10/31/2015): Adding new namespace to organize mangled name handling.
namespace MangledNameSupport
   {
  // Although the purpose of this namespace is to eventually have most or all of 
  // the mangled name support function below (not in this namespace) be put into
  // this namespace, at present it is used to organize data structures required 
  // to support handling of recursive template instantiations that are recognized 
  // as a problem for some rare case of C++ template support (test2015_105.C
  // is so far the smallest example of this issue).  There are many examples
  // of recursive templates, but all except for test2015_105.C appear to terminate
  // nicely and are not a problem for the mangled name support.
 
 
  // We need to keep a set of visit template declarations so that in the processing 
  // of mangled names for each template instnatiation we can detect the use recursion 
  // that would represent a cycle in the type system represented by the instantiated 
  // template.
     typedef std::set<SgClassDefinition*> setType;
 
     extern setType visitedTemplateDefinitions;
 
     void outputVisitedTemplateDefinitions();
   }
 
std::string replaceNonAlphaNum (const std::string& s);
 
std::string trimSpaces (const std::string& s);
 
#if 0
bool isValidMangledName (std::string name);
#endif
 
std::string joinMangledQualifiersToString (const std::string& base, const std::string& name);
 
SgName joinMangledQualifiers (const SgName& base, const SgName& name);
 
const SgFunctionDefinition* findRootFunc (const SgScopeStatement* scope);
 
// *****************************************************************
//         New code added to support better name mangling
// *****************************************************************
 
size_t getLocalScopeNum (const SgFunctionDefinition* func_def, const SgScopeStatement* target);
// size_t getLocalScopeNum ( SgFunctionDefinition* func_def, const SgScopeStatement* target);
 
std::string mangleLocalScopeToString (const SgScopeStatement* scope);
 
std::string mangleQualifiersToString (const SgScopeStatement* scope);
 
SgName mangleQualifiers (const SgScopeStatement* scope);
 
std::string mangleTypesToString (const SgTypePtrList::const_iterator b, const SgTypePtrList::const_iterator e);
 
SgName mangleTypes (const SgTypePtrList::const_iterator b, const SgTypePtrList::const_iterator e);
 
std::string mangleFunctionNameToString (const std::string& s, const std::string& ret_type_name = std::string (""));
 
SgName mangleFunctionName (const SgName& n, const SgName& ret_type_name = SgName (""));
 
std::string mangleTemplateArgsToString (const SgTemplateArgumentPtrList::const_iterator b, const SgTemplateArgumentPtrList::const_iterator e);
 
#if 0
// DQ (2/7/2006): This function is not used or required.
SgName mangleTemplateArgs (const SgTemplateArgumentPtrList::const_iterator b, const SgTemplateArgumentPtrList::const_iterator e);
#endif
 
std::string mangleTemplateToString (const std::string& templ_name,
                               const SgTemplateArgumentPtrList& templ_args,
                               const SgScopeStatement* scope);
 
SgName mangleTemplate (const SgName& templ_name,
                       const SgTemplateArgumentPtrList& templ_args,
                       const SgScopeStatement* scope);
 
std::string
mangleTemplateFunctionToString (const std::string& templ_name,
                                const SgTemplateArgumentPtrList& templ_args,
                                const SgFunctionType* func_type,
                                const SgScopeStatement* scope);
 
SgName
mangleTemplateFunction (const std::string& templ_name,
                        const SgTemplateArgumentPtrList& templ_args,
                        const SgFunctionType* func_type,
                        const SgScopeStatement* scope);
 
std::string mangleTemplateArgsToString (const SgTemplateParameterPtrList::const_iterator b, const SgTemplateParameterPtrList::const_iterator e);
 
std::string mangleTemplateToString (const std::string& templ_name,
                               const SgTemplateParameterPtrList& templ_params,
                               const SgScopeStatement* scope);
 
SgName mangleTemplate (const SgName& templ_name,
                       const SgTemplateParameterPtrList& templ_params,
                       const SgScopeStatement* scope);
 
std::string mangleSgValueExp (const SgBoolValExp* expr);
 
std::string mangleValueExp (const SgValueExp* expr);
 
std::string mangleExpression (const SgExpression* expr);
 
std::string mangleTranslationUnitQualifiers (const SgDeclarationStatement* decl);
 
// DQ (10/29/2017): Added support for testing for a specific cycle in the type system for template arguments.
// It is not clear how readily this cycle detection can be easily generalized, so this is a test for a specific cycle at present.
void testForCycleInTemplateArgumentsOfTemplateDeclaration ( const SgTemplateInstantiationDefn* templateInstantiationDefinition );
 
 
#if 0
// DQ (3/29/2006): I think this is only required interanlly in the mangledSupport.C file (where it is defined)
 
template <class SgValueExpType_>
std::string
mangleSgValueExp (const SgValueExpType_* expr)
  {
    // Verify that SgValueExpType_ descends from SgValueExp.
    ROSE_ASSERT (isSgValueExp (expr) || !expr);
 
    ostringstream mangled_name;
    if (expr)
      mangled_name << expr->get_value ();
    return mangled_name.str ();
  }
#endif
 
#endif // mangling_support_INCLUDED