sageBuilder.C

// tps (01/14/2010) : Switching from rose.h to sage3
// test cases are put into tests/nonsmoke/functional/roseTests/astInterfaceTests
// Last modified, by Liao, Jan 10, 2008
 
// includes "sageBuilder.h"
#include "sage3basic.h"
 
#include <rose_config.h>
 
#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
   #include "roseAdapter.h"
   #include "markLhsValues.h"
   #include <fstream>
   #include "Outliner.hh"
#else
   #include <fstream>
   #include "transformationSupport.h"
#endif
 
#include <boost/algorithm/string/trim.hpp>
 
// DQ (4/3/2012): Added so that I can enforce some rules as the AST is constructed.
#include "AstConsistencyTests.h"
 
// DQ (2/27/2014): We need this feature to support the function: fixupCopyOfAstFromSeparateFileInNewTargetAst()
#include "RoseAst.h"
 
// DQ (2/17/2013): This is a operation on the global AST that we don't need to do too often
// depending on the grainularity sought for the debugging information.  It is done on the
// whole AST once after construction (in edgRose.C), but is not needed more than that
// since it is a performance issue.
#define BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS 0
#define BUILDER_MAKE_REDUNDANT_CALLS_TO_SYMBOL_TABLE_LOOKUP 0
 
using namespace std;
using namespace Rose;
using namespace SageInterface;
using namespace Rose::Diagnostics;
 
namespace EDG_ROSE_Translation
   {
  // DQ (6/3/2019): The case of outlining to a seperate file will have transformations
  // that this checking will fail on because it is for the typical case of checking the
  // AST for transformations after construction of the AST from an typical input file.
#if defined(ROSE_BUILD_CXX_LANGUAGE_SUPPORT) && !defined(ROSE_USE_CLANG_FRONTEND)
  // DQ (6/3/2019): Use the definition in the EDG edgRose.C file if C/C++ support IS defined.
     extern bool suppress_detection_of_transformations;
#else
  // DQ (6/3/2019): Allow this to be the definition if C/C++ support is NOT defined.
     bool suppress_detection_of_transformations;
#endif
   }
 
// MS 2015: utility functions used in the implementation of SageBuilder functions, but are not exposed in the SageBuilder-Interface.
namespace SageBuilder {
 
// DQ (3/24/2016): Adding Robb's message mechanism (data member and function).
Sawyer::Message::Facility mlog;
void
initDiagnostics()
   {
     static bool initialized = false;
     if (!initialized)
        {
          initialized = true;
          Rose::Diagnostics::initAndRegister(&mlog, "Rose::SageBuilder");
          mlog.comment("building abstract syntax trees");
        }
   }
 
 
template <class actualFunction>
actualFunction*
buildNondefiningFunctionDeclaration_T (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, bool isMemberFunction, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateArgumentPtrList* templateArgumentsList, SgTemplateParameterPtrList* templateParameterList, SgStorageModifier::storage_modifier_enum sm);
 
// DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
template <class actualFunction>
actualFunction*
buildDefiningFunctionDeclaration_T (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, bool isMemberFunction, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, actualFunction* first_nondefinng_declaration, SgTemplateArgumentPtrList* templateArgumentsList);
 
template <class T> ROSE_DLL_API void resetDeclaration(T* classDeclaration_copy, T* classDeclaration_original, SgScopeStatement* targetScope);
 
}; // SageBuilder namespace
 
//---------------------------------------------
// scope stack interfaces
//   hide actual implementation of the stack
//---------------------------------------------
 
// DQ (1/18/2008): Added declaration in source file with Liao.
// std::list<SgScopeStatement*> SageBuilder::ScopeStack;
std::list<SgScopeStatement*> SageBuilder::ScopeStack(0);
 
 
// DQ (11/30/2010): Added support for building Fortran case insensitive symbol table handling.
// Support for construction of case sensitive/insensitive symbol table handling in scopes.
// Rasmussen (3/22/2020): Setting this variable to properly reflect language properties
// was removed in 2017. I would like to remove it from SageBuilder.
bool SageBuilder::symbol_table_case_insensitive_semantics = false;
 
 
// (used to control how the source code positon is defined for IR nodes built within the SageBuilder interface).
// Set the default to be to mark everything as a transformation.
SageBuilder::SourcePositionClassification SageBuilder::SourcePositionClassificationMode = SageBuilder::e_sourcePositionTransformation;
 
 
SgMemberFunctionDeclaration*
SageBuilder::buildDefaultConstructor (SgClassType* classType)
   {
     ASSERT_not_null(classType);
 
     SgClassDeclaration* classDeclaration = isSgClassDeclaration(classType->get_declaration());
     ASSERT_not_null(classDeclaration);
 
     SgName className = classDeclaration->get_name();
 
#if 0
     printf ("In SageBuilder::buildDefaultConstructor(): building default constructor for class = %s \n",className.str());
#endif
 
     SgClassDeclaration* definingClassDeclaration = isSgClassDeclaration(classDeclaration->get_definingDeclaration());
     ASSERT_not_null(definingClassDeclaration);
     SgClassDefinition* classDefinition = definingClassDeclaration->get_definition();
     ASSERT_not_null(classDefinition);
 
     SgFunctionParameterList*     functionParameterList     = SageBuilder::buildFunctionParameterList();
     ASSERT_not_null(functionParameterList);
 
  // Constructors are specified with type void internally, though the type name is not output.
     SgType* return_type = SageBuilder::buildVoidType();
     ASSERT_not_null(return_type);
 
     SgExprListExp* decoratorList            = nullptr;
     bool buildTemplateInstantiation         = false;
 
  // These are zero for a constructor.
     unsigned int functionConstVolatileFlags = 0;
 
     SgTemplateArgumentPtrList templateArgumentsList;
 
     SgMemberFunctionDeclaration* first_nondefining_declaration = buildNondefiningMemberFunctionDeclaration (className, return_type, functionParameterList,
          classDefinition, decoratorList, functionConstVolatileFlags, buildTemplateInstantiation, &templateArgumentsList);
     ASSERT_not_null(first_nondefining_declaration);
 
     first_nondefining_declaration->get_specialFunctionModifier().setConstructor();
     ROSE_ASSERT(first_nondefining_declaration->get_specialFunctionModifier().isConstructor() == true);
 
  // DQ (11/10/2020): Need to make sure that the firstNondefiningDeclaration is being used (reset is needed).
     if (first_nondefining_declaration->get_firstNondefiningDeclaration() != first_nondefining_declaration)
        {
          first_nondefining_declaration = isSgMemberFunctionDeclaration(first_nondefining_declaration->get_firstNondefiningDeclaration());
        }
     ROSE_ASSERT(first_nondefining_declaration->get_firstNondefiningDeclaration() == first_nondefining_declaration);
 
     SgMemberFunctionDeclaration* memberFunctionDeclaration = SageBuilder::buildDefiningMemberFunctionDeclaration (className, return_type, functionParameterList,
          classDefinition, decoratorList, buildTemplateInstantiation, functionConstVolatileFlags, first_nondefining_declaration, &templateArgumentsList);
     ASSERT_not_null(memberFunctionDeclaration);
 
     memberFunctionDeclaration->get_specialFunctionModifier().setConstructor();
     ROSE_ASSERT(memberFunctionDeclaration->get_specialFunctionModifier().isConstructor() == true);
 
  // We return the default constructor and the use should insert it, I think.
  // classDefinition->prepend_statement(memberFunctionDeclaration);
 
  // Mark the constructor as public.
     memberFunctionDeclaration->get_declarationModifier().get_accessModifier().setPublic();
 
     ROSE_ASSERT (memberFunctionDeclaration->get_declarationModifier().get_accessModifier().isPublic() == true);
 
#if 0
  // DQ (6/27/2021): Added debugging information.  It appears that when we build the prototype for a default
  // constructor we also build the defining declaration, which might not always exist in the original source
  // file.  So this seems like a potential subtle error.
     printf ("In SageBuilder::buildDefaultConstructor(): building default constructor for class = %s \n",className.str());
     printf (" --- memberFunctionDeclaration                                    = %p \n",memberFunctionDeclaration);
     printf (" --- first_nondefining_declaration                                = %p \n",first_nondefining_declaration);
     printf (" --- memberFunctionDeclaration->get_firstNondefiningDeclaration() = %p \n",memberFunctionDeclaration->get_firstNondefiningDeclaration());
     printf (" --- memberFunctionDeclaration->get_definingDeclaration()         = %p \n",memberFunctionDeclaration->get_definingDeclaration());
#endif
 
     return memberFunctionDeclaration;
   }
 
 
SageBuilder::SourcePositionClassification
SageBuilder::getSourcePositionClassificationMode()
   {
     return SourcePositionClassificationMode;
   }
 
void
SageBuilder::setSourcePositionClassificationMode(SageBuilder::SourcePositionClassification X)
   {
     SourcePositionClassificationMode = X;
   }
 
string
SageBuilder::display(SourcePositionClassification & scp)
   {
  // DQ (11/19/2012): This function is build to support debugging the value of the statically defined mode.
 
     string s;
     switch(scp)
        {
          case e_sourcePositionError:                s = "e_sourcePositionError";                break;
          case e_sourcePositionDefault:              s = "e_sourcePositionDefault";              break;
          case e_sourcePositionTransformation:       s = "e_sourcePositionTransformation";       break;
          case e_sourcePositionCompilerGenerated:    s = "e_sourcePositionCompilerGenerated";    break;
          case e_sourcePositionNullPointers:         s = "e_sourcePositionNullPointers";         break;
          case e_sourcePositionFrontendConstruction: s = "e_sourcePositionFrontendConstruction"; break;
          case e_sourcePosition_last:                s = "e_sourcePosition_last";                break;
 
          default:
             {
               printf ("Error: default reached in SageBuilder::display(SourcePositionClassification & scp): scp = %d \n",scp);
               ROSE_ABORT();
             }
 
        }
 
     return s;
   }
 
 
// DQ (5/21/2013): Added function to support hidding the implementation in the SgScopeStatement API.
// template <class T> SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function (const SgName & name, const SgType* func_type)
template <class T>
SgFunctionSymbol*
SgScopeStatement::find_symbol_by_type_of_function (const SgName & name, const SgType* func_type, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentsList)
   {
  // DQ (3/13/2012): This is to address the fact that there are 6 different types of functions in ROSE:
  //    1) SgFunctionDeclaration
  //    2) SgMemberFunctionDeclaration
  //    3) SgTemplateFunctionDeclaration
  //    4) SgTemplateMemberFunctionDeclaration
  //    5) SgTemplateFunctionInstntiationDeclaration
  //    6) SgTemplateMemberFunctionInstntiationDeclaration
  // And 4 different types of function symbols:
  //    1) SgFunctionSymbol
  //    2) SgMemberFunctionSymbol
  //    3) SgTemplateFunctionSymbol
  //    4) SgTemplateMemberFunctionSymbol
  // Note that both:
  //    SgTemplateFunctionInstntiationDeclaration
  //    SgTemplateMemberFunctionInstntiationDeclaration
  // map to
  //    SgFunctionSymbol
  //    SgMemberFunctionSymbol
  // respectively.
 
  // Check if there is a function symbol of any kind, then narrow the selection.
     SgFunctionSymbol* func_symbol = nullptr;
 
        {
       // Use the static variant as a selector.
          switch((VariantT)T::static_variant)
             {
               case V_SgFunctionDeclaration:
               case V_SgProcedureHeaderStatement:
               case V_SgTemplateInstantiationFunctionDecl:
                  {
                 // DQ (8/11/2013): Verify that the template arguments are provided for the correct cases and not for the incorrect cases.
                    if ((VariantT)T::static_variant == V_SgTemplateInstantiationFunctionDecl)
                       {
                         ROSE_ASSERT(templateArgumentsList != NULL);
                       }
                      else
                       {
                         ROSE_ASSERT(templateArgumentsList == NULL);
                       }
 
                 // DQ (5/21/2013): Calling the SgScopeStatement API.
                    func_symbol = lookup_nontemplate_function_symbol(name,func_type,templateArgumentsList);
                 // DQ (5/22/2013): This function symbol should not be a SgTemplateFunctionSymbol (associated with a template function.  It should be an instantiated template.
                    ROSE_ASSERT(isSgTemplateFunctionSymbol(func_symbol) == NULL);
                    break;
                  }
 
               case V_SgMemberFunctionDeclaration:
               case V_SgTemplateInstantiationMemberFunctionDecl:
                  {
                 // DQ (5/21/2013): there is no SgScopeStatement API that calls this function.
                 // DQ (8/11/2013): Verify that the template arguments are provided for the correct cases and not for the incorrect cases.
                    if ((VariantT)T::static_variant == V_SgTemplateInstantiationMemberFunctionDecl)
                       {
                         ROSE_ASSERT(templateArgumentsList != NULL);
                       }
                      else
                       {
                         ROSE_ASSERT(templateArgumentsList == NULL);
                       }
                    func_symbol = lookup_nontemplate_member_function_symbol(name,func_type,templateArgumentsList);
                    break;
                  }
 
               case V_SgTemplateFunctionDeclaration:
                  {
                 // DQ (8/11/2013): I think this should fail in cases were we should be handing the templateArgumentsList
                 // to the lookup_template_function_symbol() function.
                    ROSE_ASSERT(templateArgumentsList == NULL);
 
                 // DQ (8/11/2013): I think this should always be non-null.
                    ROSE_ASSERT(templateParameterList != NULL);
 
                 // DQ (8/7/2013): Adding support to permit template function overloading on template parameters.
                 // Note that the template arguments are being handed in as templateSpecializationArgumentList since this is the matching list.
                 // However, we might expect template parameter.
 
                 // DQ (8/7/2013): Adding support for template function overloading using template parameters (info passed as template arguments for specialization).
                 // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
                 // In this case these are unavailable from this point.
                 // DQ (5/21/2013): Calling the SgScopeStatement API.
                    func_symbol = lookup_template_function_symbol(name,func_type,templateParameterList);
 
                    break;
                  }
 
               case V_SgTemplateMemberFunctionDeclaration:
                  {
                 // DQ (8/11/2013): I think this should fail in cases were we should be handing the templateArgumentsList
                 // to the lookup_template_member_function_symbol() function.
                    ROSE_ASSERT(templateArgumentsList == NULL);
 
                 // DQ (8/11/2013): I think this sould always be non-null.
                    ROSE_ASSERT(templateParameterList != NULL);
 
                 // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
                 // In this case these are unavailable from this point.
                 // DQ (5/21/2013): Calling the SgScopeStatement API.
                    func_symbol = lookup_template_member_function_symbol(name,func_type,templateParameterList);
                    break;
                  }
 
               default:
                  {
                    printf ("In SgScopeStatement::find_symbol_by_type_of_function(): default reached --- variantT(T::static_variant) = %d \n",T::static_variant);
                    ROSE_ABORT();
                  }
             }
        }
     return func_symbol;
   }
 
 
// explicit instantiation of find_symbol_by_type_of_function
template SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function<SgTemplateFunctionDeclaration>(SgName const&, SgType const*, SgTemplateParameterPtrList*, SgTemplateArgumentPtrList*);
template SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function<SgTemplateInstantiationMemberFunctionDecl>(SgName const&, SgType const*, SgTemplateParameterPtrList*, SgTemplateArgumentPtrList*);
template SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function<SgTemplateInstantiationFunctionDecl>(SgName const&, SgType const*, SgTemplateParameterPtrList*, SgTemplateArgumentPtrList*);
template SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function<SgMemberFunctionDeclaration>(SgName const&, SgType const*, SgTemplateParameterPtrList*, SgTemplateArgumentPtrList*);
template SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function<SgTemplateMemberFunctionDeclaration>(SgName const&, SgType const*, SgTemplateParameterPtrList*, SgTemplateArgumentPtrList*);
template SgFunctionSymbol* SgScopeStatement::find_symbol_by_type_of_function<SgFunctionDeclaration>(SgName const&, SgType const*, SgTemplateParameterPtrList*, SgTemplateArgumentPtrList*);
 
void
SageBuilder::pushScopeStack (SgScopeStatement* stmt)
   {
     ASSERT_not_null(stmt);
     ScopeStack.push_back(stmt);
   }
 
void SageBuilder::popScopeStack()
   {
     ASSERT_require(ScopeStack.empty() == false);
     ScopeStack.pop_back();
   }
 
SgScopeStatement* SageBuilder::topScopeStack()
   {
  // If this is an empty stack, return nullptr (ScopeStack.back() should be undefined for this case).
     if (ScopeStack.empty()) {
         return nullptr;
     }
 
  // DQ (9/28/2009): This is part of testing for GNU 4.0.x (other versions of g++ work fine).
     SgScopeStatement* tempScope = ScopeStack.back();
     if (tempScope) {
         tempScope->class_name();
     }
 
     return tempScope;
   }
 
 
SgScopeStatement*
SageBuilder::getGlobalScopeFromScopeStack()
   {
  // This function adds new support within the internal scope stack mechanism.
 
  // DQ (3/20/2017): This branch is never taken and can be reported as an error (this improves code coverage).
  // DQ (3/11/2012): Test if this is an empty stack, and if so return NULL (ScopeStack.back() should be undefined for this case).
     ROSE_ASSERT(ScopeStack.empty() == false);
 
  // The SgGlobal scope should be the first (front) element in the list (the current scope at the end (back) of the list).
     SgScopeStatement* tempScope = ScopeStack.front();
     ASSERT_not_null(isSgGlobal(tempScope));
 
     return tempScope;
   }
 
bool SageBuilder::emptyScopeStack()
   {
     return ScopeStack.empty();
   }
 
void SageBuilder::clearScopeStack()
   {
     ScopeStack.clear();
   }
 
bool SageBuilder::inSwitchScope()
   {
  // DQ (11/26/2012): This is used to turn off some pragma processing which is a problem in switch statements.
     bool returnVar = false;
     std::list<SgScopeStatement*>::iterator i;
     for (i = ScopeStack.begin(); i != ScopeStack.end(); i++)
        {
          if (isSgSwitchStatement(*i) != nullptr)
               returnVar = true;
        }
 
     return returnVar;
   }
 
// *******************************************************************************
// *******************************  Build Functions  *****************************
// *******************************************************************************
SgName
SageBuilder::appendTemplateArgumentsToName( const SgName & name, const SgTemplateArgumentPtrList & templateArgumentsList)
   {
  // DQ (7/23/2012): This function is somewhat redundant with the SgDeclarationStatement::resetTemplateNameSupport() in that
  // they both have to generate identical names.  this was a problem and thus this code is seneitive to " ," instead of ","
  // below.
 
  // DQ (7/23/2012): This is one of three locations where the template arguments are assembled and where
  // the name generated identically (in each case) is critical.  Not clear how to best refactor this code.
  // The other two are:
  //      Unparse_ExprStmt::unparseTemplateArgumentList()
  // and in:
  //      void SgDeclarationStatement::resetTemplateNameSupport ( bool & nameResetFromMangledForm, SgName & name )
  // It is less clear how to refactor this code.
 
#define DEBUG_APPEND_TEMPLATE_ARGUMENT_LIST 0
 
#if DEBUG_APPEND_TEMPLATE_ARGUMENT_LIST
     printf ("In SageBuilder::appendTemplateArgumentsToName(): CRITICAL FUNCTION TO BE REFACTORED (name = %s) \n",name.str());
#endif
 
  // DQ (3/10/2018): This is now partially redundant with SgTemplateArgumentList::unparseToStringSupport().
     SgUnparse_Info *info = new SgUnparse_Info();
     ASSERT_not_null(info);
 
     info->set_language(SgFile::e_Cxx_language);
     info->set_requiresGlobalNameQualification();
 
  // DQ (4/28/2017): For template arguments we never want to output the definitions of classes, and enums.
     info->set_SkipClassDefinition();
     info->set_SkipEnumDefinition();
     info->set_use_generated_name_for_template_arguments(true);
 
     bool emptyArgumentList = templateArgumentsList.empty();
 
  // DQ (9/24/2012): Don't add "< >" if there are no template arguments (see test2012_221.C).
  // SgName returnName = name + " < ";
     SgName returnName = name;
     if (emptyArgumentList == false)
          returnName += " < ";
 
     SgTemplateArgumentPtrList::const_iterator i = templateArgumentsList.begin();
     bool need_separator = false;
 
     bool exit_after_name_is_generated = false;
 
     while (i != templateArgumentsList.end())
        {
          if ((*i)->get_argumentType() == SgTemplateArgument::start_of_pack_expansion_argument)
             {
               i++;
               continue;
             }
 
          if (need_separator)
             {
               returnName += " , ";
             }
 
#if DEBUG_APPEND_TEMPLATE_ARGUMENT_LIST
          printf ("In SageBuilder::appendTemplateArgumentsToName(): (top of loop) templateArgumentsList element *i = %p = %s returnName = %s \n",*i,(*i)->class_name().c_str(),returnName.str());
#endif
 
       // DQ (2/5/2022): We need to use a fully qualified name as demonstrated by test2022_05.C.
       // Where there are two different template arguments with the same name (e.g. in different
       // namespaces) the generated names will be the same and the symbols will collide in the
       // symbol table for the scope where they are both constructed.
       // So a fix is to add the fully qualified name of the scope of the expression used as a template argument.
 
       // DQ (2/6/2022): Newer version of code (still refactoring this section).
          bool used_fully_qualified_name = false;
 
#define DEBUG_TEMPLATE_ARGUMENT_NAMES 0
 
       // DQ (2/6/2022): This is the newly refactored implementation to add name qualification to
       // the template arguments in the used in symbol tables key for template instantiations.
          SgTemplateArgument* templateArgument = *i;
          ASSERT_not_null(templateArgument);
 
          switch (templateArgument->get_argumentType())
             {
               case SgTemplateArgument::type_argument:
                  {
                    SgType* type = templateArgument->get_type();
                    ASSERT_not_null(type);
 
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                    printf ("In SageBuilder::appendTemplateArgumentsToName(): case SgTemplateArgument::type_argument: BEFORE stripType: type = %p = %s \n",type,type->class_name().c_str());
#endif
                 // I think that we need to strip off any pointer or reference modifier types.
                 // unsigned char bit_array == (SgType::STRIP_MODIFIER_TYPE | SgType::STRIP_REFERENCE_TYPE | SgType::STRIP_RVALUE_REFERENCE_TYPE | SgType::STRIP_POINTER_TYPE | SgType::STRIP_ARRAY_TYPE | SgType::STRIP_TYPEDEF_TYPE | SgType::STRIP_POINTER_MEMBER_TYPE);
                    unsigned char bit_array = (SgType::STRIP_MODIFIER_TYPE | SgType::STRIP_REFERENCE_TYPE | SgType::STRIP_RVALUE_REFERENCE_TYPE | SgType::STRIP_POINTER_TYPE | SgType::STRIP_ARRAY_TYPE | SgType::STRIP_POINTER_MEMBER_TYPE);
                    type = type->stripType(bit_array);
 
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                    printf ("In SageBuilder::appendTemplateArgumentsToName(): case SgTemplateArgument::type_argument: AFTER stripType: type = %p = %s \n",type,type->class_name().c_str());
#endif
                 // DQ (2/6/2022): We need to find an example of the case where the template argument is a pointer type.
                    if (isSgPointerType(templateArgument->get_type()) != nullptr)
                       {
 
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                         printf ("Found a templateArgument->get_type() that is SgPointerType: name = %s \n",name.str());
#endif
                       }
 
                    SgNamedType* namedType = isSgNamedType(type);
                    if (namedType != nullptr)
                       {
                      // DQ (2/5/2022): Since SgNonrealType is a SgNamedType, is this sufficiant to handle those cases?
                         SgDeclarationStatement* declaration = namedType->get_declaration();
                         ASSERT_not_null(declaration);
 
                         switch (declaration->variantT())
                            {
                              case V_SgTemplateInstantiationDecl:
                              case V_SgTemplateClassDeclaration:
                              case V_SgClassDeclaration:
                                 {
                                   SgClassDeclaration* classDeclaration = isSgClassDeclaration(declaration);
                                   string fully_qualified_name = classDeclaration->get_qualified_name();
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                                   printf ("fully_qualified_name = %s \n",fully_qualified_name.c_str());
#endif
                                   returnName += fully_qualified_name;
                                   used_fully_qualified_name = true;
                                   break;
                                 }
 
                              case V_SgTemplateInstantiationTypedefDeclaration:
                              case V_SgTemplateTypedefDeclaration:
                              case V_SgTypedefDeclaration:
                                 {
                                   SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(declaration);
                                   string fully_qualified_name = typedefDeclaration->get_qualified_name();
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                                   printf ("fully_qualified_name = %s \n",fully_qualified_name.c_str());
#endif
                                   returnName += fully_qualified_name;
                                   used_fully_qualified_name = true;
                                   break;
                                 }
 
                              case V_SgEnumDeclaration:
                                 {
                                   SgEnumDeclaration* enumDeclaration = isSgEnumDeclaration(declaration);
                                   string fully_qualified_name = enumDeclaration->get_qualified_name();
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                                   printf ("fully_qualified_name = %s \n",fully_qualified_name.c_str());
#endif
                                   returnName += fully_qualified_name;
                                   used_fully_qualified_name = true;
                                   break;
                                 }
 
                           // DQ (2/5/2022): Is this implementation correct for SgNonrealDecl?
                              case V_SgNonrealDecl:
                                 {
                                   SgNonrealDecl* nonrealDeclaration = isSgNonrealDecl(declaration);
                                   string fully_qualified_name = nonrealDeclaration->get_qualified_name();
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                                   printf ("fully_qualified_name = %s \n",fully_qualified_name.c_str());
#endif
                                   returnName += fully_qualified_name;
                                   used_fully_qualified_name = true;
                                   break;
                                 }
 
                              default:
                                 {
                                // I'm not clear if we need to support any other cases, so this default case is an error.
                                   printf ("In SageBuilder::appendTemplateArgumentsToName(): default reached: get_type() != NULL: declaration = %s \n",declaration->class_name().c_str());
                                   ROSE_ASSERT(false);
                                 }
                            }
                       }
                      else
                       {
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                         printf ("In SageBuilder::appendTemplateArgumentsToName(): not a SgNamedType: get_type() != NULL: type = %s \n",type->class_name().c_str());
#endif
                       }
 
                    break;
                  }
 
               case SgTemplateArgument::nontype_argument:
                  {
                 // DQ (8/12/2013): This can be either an SgExpression or SgInitializedName.
                    ROSE_ASSERT (templateArgument->get_expression() != NULL || templateArgument->get_initializedName() != NULL);
                    ROSE_ASSERT (templateArgument->get_expression() == NULL || templateArgument->get_initializedName() == NULL);
                    if (templateArgument->get_expression() != NULL)
                       {
                         SgExpression* expression = templateArgument->get_expression();
                         ASSERT_not_null(expression);
 
                      // Now we care about types of expression that could require name qualification.
                      // Is there anything more than SgVarRefExp that we need to worry about?
                         SgVarRefExp* varRefExp = isSgVarRefExp(expression);
                         if (varRefExp != NULL)
                            {
                           // SgVariableSymbol* variableSymbol = isSgVariableSymbol(varRefExp->get_symbol());
                              SgVariableSymbol* variableSymbol = varRefExp->get_symbol();
                              ROSE_ASSERT(variableSymbol != NULL);
                              SgInitializedName* initializedName = variableSymbol->get_declaration();
                              ROSE_ASSERT(initializedName != NULL);
                              string fully_qualified_name = initializedName->get_qualified_name();
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                              printf ("fully_qualified_name = %s \n",fully_qualified_name.c_str());
#endif
                              returnName += fully_qualified_name;
                              used_fully_qualified_name = true;
                            }
                           else
                            {
                           // Unclear if we have cases here to support (need more examples of different types of template arguments in use).
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                              printf ("In SageBuilder::appendTemplateArgumentsToName(): Case of template argument varRefExp == NULL: expression = %p = %s \n",
                                   expression,expression->class_name().c_str());
#endif
#if 0
                              printf ("In SageBuilder::appendTemplateArgumentsToName(): Case of template argument varRefExp == NULL is not yet supported! \n");
                              ROSE_ASSERT(false);
#endif
                            }
                       }
                      else
                       {
                      // SgType* type = templateArgument->get_initializedName()->get_type();
                      // ROSE_ASSERT(type != NULL);
 
                         SgInitializedName* initializedName = templateArgument->get_initializedName();
                         ROSE_ASSERT(initializedName != NULL);
                         printf ("initializedName = %p = %s \n",initializedName,initializedName->get_name().str());
 
                         printf ("In SageBuilder::appendTemplateArgumentsToName(): Case of template argument initializedName != NULL: Unclear what do do in this case \n");
                         ROSE_ASSERT(false);
                       }
 
                    break;
                  }
 
               case SgTemplateArgument::template_template_argument:
                  {
                    SgDeclarationStatement* decl = templateArgument->get_templateDeclaration();
                    ASSERT_not_null(decl);
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                    printf ("In SageBuilder::appendTemplateArgumentsToName(): case SgTemplateArgument::template_template_argument: decl = %p = %s \n",decl,decl->class_name().c_str());
#endif
                    exit_after_name_is_generated = true;
#if 0
                    printf ("Exiting as a test! \n");
                    ROSE_ASSERT(false);
#endif
                    SgTemplateDeclaration* tpl_decl = isSgTemplateDeclaration(decl);
                    ROSE_ASSERT(tpl_decl == NULL);
 
                    break;
                  }
 
                case SgTemplateArgument::start_of_pack_expansion_argument:
                  {
#if DEBUG_TEMPLATE_ARGUMENT_NAMES
                    printf("WARNING: start_of_pack_expansion_argument in evaluateNameQualificationForTemplateArgumentList (can happen from some debug output)\n");
#endif
                    break;
                  }
 
               case SgTemplateArgument::argument_undefined:
                  {
                 // mfprintf(mlog [ WARN ] ) ("Error argument_undefined in evaluateNameQualificationForTemplateArgumentList \n");
                    printf("Error argument_undefined in evaluateNameQualificationForTemplateArgumentList \n");
                    ROSE_ABORT();
                    break;
                  }
 
               default:
                  {
                 // mfprintf(mlog [ WARN ] ) ("Error default reached in evaluateNameQualificationForTemplateArgumentList \n");
                    printf("Error default reached in evaluateNameQualificationForTemplateArgumentList \n");
                    ROSE_ABORT();
                  }
             }
 
       // DQ (2/5/2022): if it is not set above then use the old way without name qualification (debugging test2022_05.C).
       // DQ (9/15/2012): We need to communicate that the language so that SgBoolVal will not be unparsed to "1" instead of "true" (see test2012_215.C).
       // Calling the unparseToString (SgUnparse_Info *info) function instead of the version not taking an argument.
       // returnName += (*i)->unparseToString(info);
          if (used_fully_qualified_name == false)
             {
               returnName += (*i)->unparseToString(info);
             }
 
#if DEBUG_APPEND_TEMPLATE_ARGUMENT_LIST
          printf ("In SageBuilder::appendTemplateArgumentsToName(): (after appending template name) *i = %p returnName = %s \n",*i,returnName.str());
#endif
          need_separator = true;
          i++;
 
#if DEBUG_APPEND_TEMPLATE_ARGUMENT_LIST
          printf ("In SageBuilder::appendTemplateArgumentsToName(): (bottom of loop) returnName = %s \n",returnName.str());
#endif
        }
 
     if (emptyArgumentList == false)
          returnName += " > ";
 
#if DEBUG_APPEND_TEMPLATE_ARGUMENT_LIST || DEBUG_TEMPLATE_ARGUMENT_NAMES
     printf ("Leaving SageBuilder::appendTemplateArgumentsToName(): returnName = %s \n",returnName.str());
#endif
 
     if (false) // was: #if 0
         {
            // This allows me to test a large number of input codes and identify ones that are using specific features (e.g. template template parameters).
             if (exit_after_name_is_generated == true)
                {
                  printf ("Exiting as a test! \n");
                  ROSE_ASSERT(false);
                }
         } // #endif
 
     delete info;
     info = NULL;
 
     return returnName;
   }
 
 
SgName
SageBuilder::unparseTemplateArgumentToString (SgTemplateArgument* templateArgument)
   {
  // DQ (3/10/2018): This is now redundant with SgTemplateArgument::unparseToStringSupport().
  // DQ (3/9/2018): Added function to support debugging.
 
     ROSE_ASSERT(templateArgument != NULL);
 
     SgUnparse_Info *info = new SgUnparse_Info();
     ROSE_ASSERT(info != NULL);
 
     info->set_language(SgFile::e_Cxx_language);
 
  // DQ (4/28/2017): For template arguments we never want to output the definitions of classes, and enums.
     info->set_SkipClassDefinition();
     info->set_SkipEnumDefinition();
     info->set_use_generated_name_for_template_arguments(true);
 
     SgName returnName = templateArgument->unparseToString(info);
 
     delete info;
     info = NULL;
 
     return returnName;
   }
 
 
SgTemplateArgumentPtrList*
SageBuilder::getTemplateArgumentList( SgDeclarationStatement* decl )
   {
  // DQ (9/13/2012): This function returns the SgTemplateArgumentPtrList. Both template declarations and template instanatiations have them.
  // In a template instantiation it is the templateArguments field and from template declarations it is the templateSpecializationArguments field.
 
     ROSE_ASSERT(decl != NULL);
 
     SgTemplateArgumentPtrList* templateArgumentsList = NULL;
 
     switch(decl->variantT())
        {
       // DQ (4/9/2018): Added support for namespace alias.
          case V_SgNamespaceAliasDeclarationStatement:
       // DQ (8/17/2013): These cases do not use templates.
       // This function has to handle these cases because it is called in a general context
       // on many types of declarations as part of the name qualification support.
          case V_SgNamespaceDeclarationStatement:
          case V_SgEnumDeclaration:
          case V_SgVariableDeclaration:
          case V_SgTypedefDeclaration:
             {
               templateArgumentsList = NULL;
               break;
             }
 
       // PC (10/11/13):  Added case of SgJavaPackageDeclaration
       // DQ (8/11/2013): Added cases for SgFunctionDeclaration and SgMemberFunctionDeclaration
       // I forget why we needed this case...
          case V_SgProcedureHeaderStatement:
          case V_SgJovialTableStatement:
          case V_SgJavaPackageDeclaration:
          case V_SgFunctionDeclaration:
          case V_SgMemberFunctionDeclaration:
          case V_SgClassDeclaration:
             {
               templateArgumentsList = NULL;
               break;
             }
 
          case V_SgTemplateInstantiationDecl:
             {
               templateArgumentsList = &(isSgTemplateInstantiationDecl(decl)->get_templateArguments());
               break;
             }
 
          case V_SgTemplateClassDeclaration:
             {
               templateArgumentsList = &(isSgTemplateClassDeclaration(decl)->get_templateSpecializationArguments());
               break;
             }
 
          case V_SgTemplateInstantiationFunctionDecl:
             {
               templateArgumentsList = &(isSgTemplateInstantiationFunctionDecl(decl)->get_templateArguments());
               break;
             }
 
          case V_SgTemplateFunctionDeclaration:
             {
               templateArgumentsList = &(isSgTemplateFunctionDeclaration(decl)->get_templateSpecializationArguments());
               break;
             }
 
          case V_SgTemplateInstantiationMemberFunctionDecl:
             {
               templateArgumentsList = &(isSgTemplateInstantiationMemberFunctionDecl(decl)->get_templateArguments());
               break;
             }
 
          case V_SgTemplateMemberFunctionDeclaration:
             {
               templateArgumentsList = &(isSgTemplateMemberFunctionDeclaration(decl)->get_templateSpecializationArguments());
               break;
             }
 
          case V_SgTemplateVariableDeclaration:
             {
               templateArgumentsList = &(isSgTemplateVariableDeclaration(decl)->get_templateSpecializationArguments());
               break;
             }
 
       // DQ (11/10/2014): Added support for template typedef declarations.
          case V_SgTemplateTypedefDeclaration:
             {
               templateArgumentsList = &(isSgTemplateTypedefDeclaration(decl)->get_templateSpecializationArguments());
               break;
             }
 
       // DQ (11/10/2014): Added support for template typedef declarations.
          case V_SgTemplateInstantiationTypedefDeclaration:
             {
               templateArgumentsList = &(isSgTemplateInstantiationTypedefDeclaration(decl)->get_templateArguments());
               break;
             }
 
          case V_SgTemplateDeclaration:
             {
               templateArgumentsList = NULL;
               break;
             }
 
          case V_SgNonrealDecl:
             {
               templateArgumentsList = &(isSgNonrealDecl(decl)->get_tpl_args());
               break;
             }
 
          default:
             {
               printf ("getTemplateArgumentList(): Default reached in switch: decl = %p = %s \n",decl,decl->class_name().c_str());
               ROSE_ABORT();
             }
        }
 
     return templateArgumentsList;
   }
 
 
 
SgTemplateParameterPtrList*
SageBuilder::getTemplateParameterList( SgDeclarationStatement* decl )
   {
  // DQ (9/16/2012): This function returns the SgTemplateParameterPtrList that is associated with template declarations.
  // For all other cases it returns NULL (or is an error).
 
     ROSE_ASSERT(decl != NULL);
 
     SgTemplateParameterPtrList* templateParameterList = NULL;
 
     switch(decl->variantT())
        {
       // DQ (4/9/2018): Added support for namespace alias.
          case V_SgNamespaceAliasDeclarationStatement:
       // DQ (8/17/2013): These cases do not use templates.
       // This function has to handle these cases because it is called in a general context
       // on many types of declarations as part of the name qualification support.
          case V_SgNamespaceDeclarationStatement:
          case V_SgEnumDeclaration:
          case V_SgVariableDeclaration:
          case V_SgTypedefDeclaration:
             {
               templateParameterList = NULL;
               break;
             }
 
       // PC (10/11/13):  Added case of SgJavaPackageDeclaration
       // DQ (8/12/2013): This function has to be supported when called using any kind of declaration (at least SgFunctionDeclaration and SgClassDeclaration).
       // DQ (9/16/2012): I think it should be an error to call this function for a SgClassDeclaration.
          case V_SgProcedureHeaderStatement:
          case V_SgJovialTableStatement:
          case V_SgJavaPackageDeclaration:
          case V_SgFunctionDeclaration:
          case V_SgMemberFunctionDeclaration:
          case V_SgClassDeclaration:
             {
               templateParameterList = NULL;
               break;
             }
 
       // DQ (11/10/2014): Added support for template typedef declarations.
          case V_SgTemplateInstantiationTypedefDeclaration:
 
       // DQ (8/12/2013): This function has to be supported when called using any kind of declaration (at least SgFunctionDeclaration and SgClassDeclaration).
       // DQ (9/16/2012): I think it should be an error to call this function for these types of declarations.
          case V_SgTemplateInstantiationDecl:
          case V_SgTemplateInstantiationFunctionDecl:
          case V_SgTemplateInstantiationMemberFunctionDecl:
             {
               templateParameterList = NULL;
               break;
             }
 
          case V_SgTemplateClassDeclaration:
             {
               templateParameterList = &(isSgTemplateClassDeclaration(decl)->get_templateParameters());
               break;
             }
 
          case V_SgTemplateFunctionDeclaration:
             {
               templateParameterList = &(isSgTemplateFunctionDeclaration(decl)->get_templateParameters());
               break;
             }
 
          case V_SgTemplateMemberFunctionDeclaration:
             {
               templateParameterList = &(isSgTemplateMemberFunctionDeclaration(decl)->get_templateParameters());
               break;
             }
 
          case V_SgTemplateVariableDeclaration:
             {
               templateParameterList = &(isSgTemplateVariableDeclaration(decl)->get_templateParameters());
               break;
             }
 
       // DQ (11/10/2014): Added support for template typedef declarations.
          case V_SgTemplateTypedefDeclaration:
             {
               templateParameterList = &(isSgTemplateTypedefDeclaration(decl)->get_templateParameters());
               break;
             }
 
          case V_SgNonrealDecl:
             {
               templateParameterList = &(isSgNonrealDecl(decl)->get_tpl_params());
               break;
             }
 
          case V_SgTemplateDeclaration:
             {
               templateParameterList = &(isSgTemplateDeclaration(decl)->get_templateParameters());
               break;
             }
 
          default:
             {
               printf ("getTemplateParameterList(): Default reached in switch: decl = %p = %s \n",decl,decl->class_name().c_str());
               ROSE_ABORT();
             }
        }
 
     return templateParameterList;
   }
 
 
 
void
SageBuilder::setTemplateArgumentParents( SgDeclarationStatement* decl )
   {
  // DQ (9/13/2012): Set the parents of the template arguments (if not already set, to the first non-defining declaration).
 
     ROSE_ASSERT(decl != NULL);
 
     SgTemplateArgumentPtrList* templateArgumentsList = getTemplateArgumentList(decl);
 
     if (templateArgumentsList != NULL)
        {
          SgDeclarationStatement* first_decl = decl->get_firstNondefiningDeclaration();
          ROSE_ASSERT(first_decl != NULL);
 
          SgTemplateArgumentPtrList::iterator i = templateArgumentsList->begin();
          while (i != templateArgumentsList->end())
             {
               SgNode* parent = (*i)->get_parent();
               if (parent== NULL)
                  {
                 // (*i)->set_parent(decl);
                    (*i)->set_parent(first_decl);
                  }
                 else
                  {
                    SgScopeStatement* scope = isSgScopeStatement(parent);
                    if (scope != NULL)
                       {
                      // Template Arguments should have had there parents set to a scope when they were build, we want
                      // to refine that now that the declaration which we want them to be specified in has been build.
                         (*i)->set_parent(first_decl);
                       }
                      else
                       {
                         SgDeclarationStatement* declaration = isSgDeclarationStatement(parent);
                         if (declaration != NULL)
                            {
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
                              printf ("In setTemplateArgumentParents(): Template argument already set to declaration = %p = %s \n",declaration,declaration->class_name().c_str());
#endif
                            }
                           else
                            {
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
                              printf ("Error: In setTemplateArgumentParents(): I think it is an error for the template argument parent to be set to %p = %s \n",parent,parent->class_name().c_str());
#endif
                            }
                       }
                  }
 
               i++;
             }
        }
 
     testTemplateArgumentParents(decl);
   }
 
 
void
SageBuilder::setTemplateParameterParents( SgDeclarationStatement* decl )
   {
  // DQ (9/13/2012): Set the parents of the template arguments (if not already set, to the first non-defining declaration).
     ROSE_ASSERT(decl != NULL);
 
     SgTemplateParameterPtrList* templateParameterList = getTemplateParameterList(decl);
 
     if (templateParameterList != NULL)
        {
          SgDeclarationStatement* first_decl = decl->get_firstNondefiningDeclaration();
          ROSE_ASSERT(first_decl != NULL);
 
          SgTemplateParameterPtrList::iterator i = templateParameterList->begin();
          while (i != templateParameterList->end())
             {
               SgNode* parent = (*i)->get_parent();
               if (parent == NULL)
                  {
                    (*i)->set_parent(first_decl);
                  }
                 else
                  {
                    SgScopeStatement* scope = isSgScopeStatement(parent);
                    if (scope != NULL)
                       {
                      // Template Arguments should have had their parents set to a scope when they were build, we want
                      // to refine that now that the declaration which we want them to be specified in has been build.
                         (*i)->set_parent(first_decl);
                       }
                  }
 
               i++;
             }
        }
 
     testTemplateParameterParents(decl);
   }
 
 
void
SageBuilder::testTemplateArgumentParents( SgDeclarationStatement* decl )
   {
  // DQ (9/13/2012): Set the parents of the template arguments (if not already set, to the first non-defining declaration).
 
     ROSE_ASSERT(decl != NULL);
 
     SgTemplateArgumentPtrList* templateArgumentsList = getTemplateArgumentList(decl);
 
     if (templateArgumentsList != NULL)
        {
          SgTemplateArgumentPtrList::iterator i = templateArgumentsList->begin();
          while (i != templateArgumentsList->end())
             {
               SgNode* parent = (*i)->get_parent();
               if (parent == NULL)
                  {
                    printf ("Error: In testTemplateArgumentParents(): decl = %p = %s has template argument = %p with null parent \n",decl,decl->class_name().c_str(),*i);
                  }
               ROSE_ASSERT(parent != NULL);
 
            // DQ (9/16/2012): Adding new test.
               ROSE_ASSERT(decl->get_firstNondefiningDeclaration() != NULL);
            // DQ (1/30/2013): Commented this test out so that we could reuse SgTemplateArguments and
            // assure that the mapping from EDG a_template_arg_ptr's to SgTemplateArgument's was 1-to-1.
            // It is not clear if we can relax this constraint in the future.
 
               i++;
             }
        }
   }
 
 
void
SageBuilder::testTemplateParameterParents( SgDeclarationStatement* decl )
   {
  // DQ (9/13/2012): Set the parents of the template arguments (if not already set, to the first non-defining declaration).
 
     ROSE_ASSERT(decl != NULL);
 
     SgTemplateParameterPtrList* templateParameterList = getTemplateParameterList(decl);
 
     if (templateParameterList != NULL)
        {
          SgTemplateParameterPtrList::iterator i = templateParameterList->begin();
          while (i != templateParameterList->end())
             {
               SgNode* parent = (*i)->get_parent();
               if (parent == NULL)
                  {
                    printf ("Error: In testTemplateParameterParents(): decl = %p = %s has template argument = %p with null parent \n",decl,decl->class_name().c_str(),*i);
                  }
               ROSE_ASSERT(parent != NULL);
 
            // DQ (9/16/2012): Adding new test.
               ROSE_ASSERT(decl->get_firstNondefiningDeclaration() != NULL);
               if (parent != decl->get_firstNondefiningDeclaration())
                  {
#if 0
                 // DQ (2/7/2015): This message is output a lot for C++11 test projects/ShiftCalculus/simpleCNS.cpp (also test2014_83.C and test2014_84.C).
                    printf ("Error: In testTemplateParameterParents(): decl = %p = %s has template argument = %p with parent = %p = %s \n",decl,decl->class_name().c_str(),*i,parent,parent->class_name().c_str());
#endif
                  }
 
            // DQ (8/22/2013): Since these are now shared, it makes less sense to expect these to have such simple parent relationships.
            // This commit of work on ROSE added caching to template parameters so that we could support pointer equality for tests
            // of template parameter equality in the symbol table handling (this was a technique previously used for template arguments).
            // This test fails in the mergeTest_04.C test , but only on the GNU 4.4.x compiler (passes on the GNU 4.2.4 compiler).
 
               i++;
             }
        }
   }
 
 
void
SageBuilder::setTemplateArgumentsInDeclaration( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input )
   {
  // DQ (9/16/2012): Setup the template arguments for any type of template instantiation.
 
     ROSE_ASSERT(templateArgumentsList_input != NULL);
 
     ROSE_ASSERT(decl->variantT() == V_SgTemplateInstantiationDecl ||
                 decl->variantT() == V_SgTemplateInstantiationFunctionDecl ||
                 decl->variantT() == V_SgTemplateInstantiationMemberFunctionDecl ||
                 decl->variantT() == V_SgTemplateInstantiationTypedefDeclaration);
 
     SgTemplateArgumentPtrList* templateArgumentsList_from_declaration = getTemplateArgumentList(decl);
 
     if (templateArgumentsList_from_declaration != NULL)
        {
          *templateArgumentsList_from_declaration = *templateArgumentsList_input;
 
       // Set the parents.
          setTemplateArgumentParents(decl);
        }
 
     testTemplateArgumentParents(decl);
   }
 
 
void
SageBuilder::setTemplateSpecializationArgumentsInDeclaration( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input )
   {
  // DQ (9/16/2012): Setup the template arguments for any type of template declaration
 
     ROSE_ASSERT(templateSpecializationArgumentsList_input != NULL);
 
     ROSE_ASSERT(decl->variantT() == V_SgTemplateClassDeclaration          || decl->variantT() == V_SgTemplateFunctionDeclaration ||
                 decl->variantT() == V_SgTemplateMemberFunctionDeclaration || decl->variantT() == V_SgTemplateVariableDeclaration );
 
     SgTemplateArgumentPtrList* templateSpecializationArgumentsList_from_declaration = getTemplateArgumentList(decl);
 
     if (templateSpecializationArgumentsList_from_declaration != NULL)
        {
          *templateSpecializationArgumentsList_from_declaration = *templateSpecializationArgumentsList_input;
 
       // Set the parents.
          setTemplateArgumentParents(decl);
        }
 
     testTemplateArgumentParents(decl);
   }
 
void
SageBuilder::setTemplateParametersInDeclaration( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParameterList_input )
   {
  // DQ (9/16/2012): Setup the template parameters for any type of template declaration.
 
     ROSE_ASSERT(templateParameterList_input != NULL);
 
     ROSE_ASSERT(decl->variantT() == V_SgTemplateClassDeclaration          || decl->variantT() == V_SgTemplateFunctionDeclaration ||
                 decl->variantT() == V_SgTemplateMemberFunctionDeclaration || decl->variantT() == V_SgTemplateVariableDeclaration );
 
     SgTemplateParameterPtrList* templateParameterList_from_declaration = getTemplateParameterList(decl);
 
     if (templateParameterList_from_declaration != NULL)
        {
          *templateParameterList_from_declaration = *templateParameterList_input;
 
       // Set the parents.
          setTemplateParameterParents(decl);
        }
 
     testTemplateParameterParents(decl);
   }
 
// Only used to build parameter arguments for function ??
// should be transparently generated for most variable declaration builder
// deferred symbol insertion, scope setting , etc
// do them when it is actually used with the  parameterList!!
SgInitializedName *
SageBuilder::buildInitializedName (const SgName & name, SgType* type, SgInitializer* init /*= NULL*/)
{
     ASSERT_not_null(type);
 
     SgInitializedName* initializedName = new SgInitializedName(name,type,init);
     ASSERT_not_null(initializedName);
 
    setSourcePositionAtRootAndAllChildren(initializedName);
    return initializedName;
}
 
SgInitializedName *
SageBuilder::buildInitializedName ( const std::string & name, SgType* type)
   {
     SgName var_name(name);
     return buildInitializedName(var_name,type);
   }
 
SgInitializedName *
SageBuilder::buildInitializedName ( const char* name, SgType* type)
   {
  // DQ (3/20/2017): Call the version of the function that takes a string as part of migration away from this function that takes a const char*.
  // This also provides a test of the string based version of this function (for code coverage).
     string var_name(name);
     return buildInitializedName(var_name,type);
   }
 
SgInitializedName *
SageBuilder::buildInitializedName_nfi ( const SgName & name, SgType* type, SgInitializer* init)
   {
     ASSERT_not_null(type);
 
     SgInitializedName* initializedName = new SgInitializedName(name,type,init);
     ASSERT_not_null(initializedName);
     ASSERT_require(init == nullptr || init->get_parent() == initializedName);
 
     setOneSourcePositionNull(initializedName);
 
     return initializedName;
   }
 
//-----------------------------------------------
// could have two declarations for a same variable
// extern int i;
//  int i;
SgVariableDeclaration*
SageBuilder::buildVariableDeclaration (const SgName & name, SgType* type, SgInitializer * varInit, SgScopeStatement* scope)
 //(const SgName & name, SgType* type, SgInitializer * varInit= NULL, SgScopeStatement* scope = NULL)
{
  if (scope == NULL)
    scope = SageBuilder::topScopeStack();
   ROSE_ASSERT(name.is_null() == false);
   ROSE_ASSERT(type != NULL);
 
  SgVariableDeclaration * varDecl = new SgVariableDeclaration(name, type, varInit);
  ROSE_ASSERT(varDecl);
 
// DQ (8/21/2011): Note that the default is to set the declaration modifier's access modifier to be
// default (which is the same as public).  So the effect it to set it to be public.  This is ignored
// by the unparser for most languguages in ROSE.
  varDecl->set_firstNondefiningDeclaration(varDecl);
 
  if (scope!=NULL)
  {
    // Liao 12/13/2010
    // Fortran subroutine/function parameters have corresponding variable declarations in the body
    // For this declaration, it should use the initialized names of the parameters instead of creating new ones
    // The symbol of the init name should be under SgFunctionDefinition, instead of the function body block
    bool isFortranParameter = false;
    if (SageInterface::is_Fortran_language())
    {
      SgFunctionDefinition * f_def = getEnclosingProcedure (scope);
      if (f_def != NULL)
      {
     // DQ (5/21/2013): Removed direct reference to symbol table (namespace handling is only supported at the SgScopeStatement level).
        SgVariableSymbol * v_symbol = f_def->lookup_variable_symbol(name);
        if (v_symbol != NULL) // find a function parameter with the same name
        {
          // replace the default one with the one from parameter
          SgInitializedName *default_initName = varDecl->get_decl_item (name);
          ROSE_ASSERT (default_initName != NULL);
          SgInitializedName * new_initName = v_symbol->get_declaration();
          ROSE_ASSERT (new_initName != NULL);
          ROSE_ASSERT (default_initName != new_initName);
 
          SgInitializedNamePtrList&  n_list= varDecl->get_variables();
          std::replace (n_list.begin(), n_list.end(),default_initName, new_initName );
          ROSE_ASSERT (varDecl->get_decl_item (name)==new_initName); //ensure the new one can be found
 
          // change the function argument's old parent to the variable declaration
          SgNode * old_parent = new_initName->get_parent();
          ROSE_ASSERT  (old_parent != NULL);
          ROSE_ASSERT  (isSgFunctionParameterList(old_parent) != NULL);
          new_initName->set_parent(varDecl); // adjust parent from SgFunctionParameterList to SgVariableDeclaration
 
       // DQ (1/25/2011): Deleting these causes problems if I use this function in the Fortran support...
       // delete (default_initName->get_declptr()); // delete the var definition
       // delete (default_initName->get_declptr()); // relink the var definition
 
          SgVariableDefinition * var_def = isSgVariableDefinition(default_initName->get_declptr()) ;
          ROSE_ASSERT (var_def != NULL);
          var_def->set_parent(new_initName);
          var_def->set_vardefn(new_initName);
          new_initName->set_declptr(var_def); // it was set to SgProcedureHeaderStatement as a function argument
 
          delete (default_initName); // must delete the old one to pass AST consistency test
 
       // DQ (12/13/2011): Is this executed...
          //printf ("Is this executed \n");
          //ROSE_ASSERT(false);
 
          isFortranParameter = true;
        }
      }
    }
    if (! isFortranParameter) // No need to add symbol to the function body if it is a Fortran parameter
                              // The symbol should already exist under function definition for the parameter
      fixVariableDeclaration(varDecl,scope);
  }
 
  SgInitializedName *initName = varDecl->get_decl_item (name);
  ROSE_ASSERT(initName != NULL);
  ROSE_ASSERT((initName->get_declptr())!=NULL);
 
  //bug 119, SgVariableDefintion's File_info is needed for deep copy to work
  // AstQuery based setSourcePositionForTransformation() cannot access all child nodes
  // have to set SgVariableDefintion explicitly
  SgDeclarationStatement* variableDefinition_original = initName->get_declptr();
  setOneSourcePositionForTransformation(variableDefinition_original);
  ROSE_ASSERT((variableDefinition_original->get_startOfConstruct()) !=NULL);
  ROSE_ASSERT((variableDefinition_original->get_endOfConstruct())!=NULL);
 
  setSourcePositionAtRootAndAllChildren(varDecl);
  //ROSE_ASSERT (isSgVariableDefinition(initName->get_declptr())->get_startOfConstruct()!=NULL);
 
 
  // DQ (4/16/2015): This is replaced with a better implementation.
  // DQ (4/15/2015): We should reset the isModified flags as part of the transforamtion
  // because we have added statements explicitly marked as transformations.
  // checkIsModifiedFlag(varDecl);
     unsetNodesMarkedAsModified(varDecl);
 
// ROSE_ASSERT(findFirstSgCastExpMarkedAsTransformation(varDecl,"testing buildVariableDeclaration(): 9") == false);
// ROSE_ASSERT(findFirstSgCastExpMarkedAsTransformation(scope,"testing buildVariableDeclaration(): 9-scope") == false);
 
  return varDecl;
}
 
//-----------------------------------------------
// could have two declarations for a same variable
// extern int i;
//  int i;
SgVariableDeclaration*
SageBuilder::buildVariableDeclaration_nfi (const SgName & name, SgType* type, SgInitializer * varInit, SgScopeStatement* scope, bool builtFromUseOnly, SgStorageModifier::storage_modifier_enum sm)
   {
 
#define DEBUG_BUILD_VARIABLE_DECLARATION 0
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
     printf ("In SageBuilder::buildVariableDeclaration_nfi(): name = %s scope = %p varInit = %p \n",name.str(),scope,varInit);
     if (scope != NULL)
        {
          printf (" --- scope = %p = %s \n",scope,scope->class_name().c_str());
        }
#endif
 
     if (scope == NULL)
        {
#if DEBUG_BUILD_VARIABLE_DECLARATION
          printf ("Scope determined from the SageBuilder::topScopeStack() \n");
#endif
          scope = SageBuilder::topScopeStack();
        }
 
     ROSE_ASSERT (scope != NULL);
     ROSE_ASSERT(type != NULL);
 
  // DQ (7/18/2012): Added debugging code (should fail for test2011_75.C).
     SgVariableSymbol* variableSymbol = scope->lookup_variable_symbol(name);
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
     printf ("In SageBuilder::buildVariableDeclaration_nfi(): variableSymbol = %p \n",variableSymbol);
#endif
 
  // If there was a previous use of the variable, then there will be an existing symbol with it's declaration pointing to the SgInitializedName object.
     SgVariableDeclaration * varDecl = NULL;
     if (variableSymbol == NULL)
        {
          varDecl = new SgVariableDeclaration(name, type, varInit);
#if DEBUG_BUILD_VARIABLE_DECLARATION
          SgInitializedName* tmp_initializedName = getFirstInitializedName(varDecl);
          ROSE_ASSERT(tmp_initializedName != NULL);
          printf ("In SageBuilder::buildVariableDeclaration_nfi(): variableSymbol == NULL: varDecl = %p: initializedName = %p = %s \n",varDecl,tmp_initializedName,tmp_initializedName->get_name().str());
          printf (" --- tmp_initializedName->get_initptr() = %p \n",tmp_initializedName->get_initptr());
#endif
       // DQ (6/25/2019): This is a new feature to input the builtFromUseOnly function optional parameter.
          if (builtFromUseOnly == true)
             {
#if DEBUG_BUILD_VARIABLE_DECLARATION
               printf ("In buildVariableDeclaration_nfi(): this is the first reference to this variable: building a new SgVariableDeclaration: varDecl = %p name = %s \n",varDecl,name.str());
#endif
               varDecl->set_builtFromUseOnly(true);
             }
        }
       else
        {
          SgInitializedName* initializedName = variableSymbol->get_declaration();
          ROSE_ASSERT(initializedName != NULL);
 
          SgVariableDeclaration* associatedVariableDeclaration = isSgVariableDeclaration(initializedName->get_parent());
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
          printf ("In SageBuilder::buildVariableDeclaration_nfi(): initializedName->get_parent() = %p \n",initializedName->get_parent());
          if (initializedName->get_parent() != NULL)
             {
               printf ("In SageBuilder::buildVariableDeclaration_nfi(): initializedName->get_parent() = %p = %s \n",initializedName->get_parent(),initializedName->get_parent()->class_name().c_str());
             }
          printf ("In SageBuilder::buildVariableDeclaration_nfi(): associatedVariableDeclaration = %p \n",associatedVariableDeclaration);
#endif
#if DEBUG_BUILD_VARIABLE_DECLARATION
       // DQ (6/24/2019): If this has been previously built as part of a variable use (in a class declaration),
       // then it should not be attached to the class definition as a variable declaration yet, and we should reuse it.
          if (associatedVariableDeclaration != NULL && associatedVariableDeclaration->get_parent() != NULL)
             {
               printf ("In SageBuilder::buildVariableDeclaration_nfi(): associatedVariableDeclaration->get_parent() = %p = %s \n",
                    associatedVariableDeclaration->get_parent(),associatedVariableDeclaration->get_parent()->class_name().c_str());
             }
#endif
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
          printf ("associatedVariableDeclaration = %p \n",associatedVariableDeclaration);
          if (associatedVariableDeclaration != NULL)
             {
               printf ("associatedVariableDeclaration->get_builtFromUseOnly() = %s \n",associatedVariableDeclaration->get_builtFromUseOnly() ? "true" : "false");
             }
#endif
 
       // DQ (6/25/2019): Trigger the reuse of the available variable declaration.
          bool reuseTheAssociatedVariableDeclaration = ((associatedVariableDeclaration != NULL) && (associatedVariableDeclaration->get_builtFromUseOnly() == true));
          if (reuseTheAssociatedVariableDeclaration == true)
             {
            // Build a seperate SgVariableDeclaration so that we can avoid sharing the SgInitializedName
            // (and it's possible initializer which would be an error for the secondary declaration
            // (the declaration in the class for the case of a static declaration))
 
               ROSE_ASSERT(associatedVariableDeclaration != NULL);
 
            // DQ (6/24/2019): Fix this to use the associatedVariableDeclaration.
               varDecl = associatedVariableDeclaration;
 
            // DQ (6/25/2019): Mark this variable declaration so that it will not be reused again.
               varDecl->set_builtFromUseOnly(false);
 
            // DQ (6/24/2019): Set the parent to NULL, since we are reusing this variable declaration and it would not have been set correctly before.
               varDecl->set_parent(NULL);
 
            // DQ (6/24/2019): this veriable declaration that is being reused, should not have had an initializer (check this).
               SgInitializedName* variable = getFirstInitializedName(varDecl);
               ROSE_ASSERT(variable != NULL);
 
            // DQ (6/25/2019): See Cxx11_tests/test2019_121.C and Cxx11_tests/test2019_482.C.
            // ROSE_ASSERT(variable->get_initptr() == NULL);
#if DEBUG_BUILD_VARIABLE_DECLARATION
               if (variable->get_initptr() != NULL)
                  {
                    printf ("Found initializer associated with variable declaration being reused: variable = %p name = %s \n",variable,variable->get_name().str());
                  }
#endif
            // DQ (7/3/2019): Reuse in a conditional will have a valid initializer.
             }
            else
             {
            // DQ (6/25/2019): We can't reuse the existing SgInitializedName, because it could have been initialized in the other SgVariableDeclaration.
            // DQ (6/26/2019): Added assertion.
               ROSE_ASSERT(reuseTheAssociatedVariableDeclaration == false);
 
            // DQ (6/27/2019): If the SgInitializedName was generated from the convert_variable_use() function in the
            // EDG/ROSE translation, then where was not associated SgVariableDeclaration built (an inconsistancy).
            // So we want to check for the parent being a scope statement (e.g. SgIfStmt or other statement that can
            // accept a conditional expression where in C++ it can alternatively declare a variable.
               if (associatedVariableDeclaration == NULL)
                  {
                    ROSE_ASSERT(initializedName->get_parent() != NULL);
                    SgScopeStatement* scopeStatement = isSgScopeStatement(initializedName->get_parent());
                    if (scopeStatement != NULL)
                       {
#if DEBUG_BUILD_VARIABLE_DECLARATION
                         printf ("scopeStatement = %p = %s \n",scopeStatement,scopeStatement->class_name().c_str());
#endif
                       }
                      else
                       {
#if DEBUG_BUILD_VARIABLE_DECLARATION
                         printf ("initializedName->get_parent() = %p = %s \n",initializedName->get_parent(),initializedName->get_parent()->class_name().c_str());
#endif
                       }
                  }
 
            // DQ (6/27/2019): In some case we want to reuse the associated SgInitializedName node.
            // For example: variable declarations in conditionals (e.g. SgIfStmt, and other scope statements).
            // DQ (6/26/2019): Build an additional variable to support another reference to the original variable.
            // Note: we need another one because either one can have an initializer that cannot be shared in the AST.
               SgInitializedName* additional_variable = NULL;
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
               printf ("In SageBuilder::buildVariableDeclaration_nfi(): initializedName->get_scope()     = %p = %s \n",initializedName->get_scope(),initializedName->get_scope()->class_name().c_str());
#endif
               SgScopeStatement* scopeStatement = isSgScopeStatement(initializedName->get_parent());
               if (scopeStatement != NULL)
                  {
                    additional_variable = initializedName;
 
                 // DQ (6/28/2019): Support case when the borrowed SgInitializedName has a valid initializer.
                 // DQ (6/26/2019): Adding the initializer.
                    if (additional_variable->get_initptr() != NULL)
                       {
#if DEBUG_BUILD_VARIABLE_DECLARATION
                         printf ("In SageBuilder::buildVariableDeclaration_nfi(): borrowed SgInitializedName is alread initialized \n");
                         printf (" --- additional_variable->get_initptr() = %p \n",additional_variable->get_initptr());
                         printf (" --- varInit = %p \n",varInit);
#endif
                      // DQ (6/28/2019): when this is assertion is false, we have constructed a redundant initializer (debugging this).
                         // PP (7/22/2019) faults in CUDA code
                       }
                      else
                       {
                         additional_variable->set_initptr(varInit);
                       }
 
#if DEBUG_BUILD_VARIABLE_DECLARATION || 0
                    printf (" --- additional_variable->get_scope() = %p = %s \n",additional_variable->get_scope(),additional_variable->get_scope()->class_name().c_str());
                    printf (" --- Reusing the SgInitializedName (not associated with a previous SgVariableDeclaration where the parent is a SgScopeStatement) \n");
#endif
                  }
                 else
                  {
#if DEBUG_BUILD_VARIABLE_DECLARATION
                    printf (" --- Building a new SgInitializedName \n");
#endif
                    additional_variable = buildInitializedName_nfi(name,type,varInit);
                  }
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
               ROSE_ASSERT(initializedName->get_scope() != NULL);
#endif
            // DQ (6/26/2019): Set the scopes to be the same (a symbol already exists at this point).
            // DQ (6/26/2019): Set the pointer to the original version of this variable (unless we reused the SgInitializedName above).
               if (additional_variable != initializedName)
                  {
                    additional_variable->set_prev_decl_item(initializedName);
                  }
 
            // If there is not an associated SgVariableDeclaration then reuse the existing SgInitializedName.
               varDecl = new SgVariableDeclaration(additional_variable);
#if DEBUG_BUILD_VARIABLE_DECLARATION
               ROSE_ASSERT(initializedName->get_parent() != NULL);
               printf ("initializedName->get_parent()     = %p = %s \n",initializedName->get_parent(),initializedName->get_parent()->class_name().c_str());
               ROSE_ASSERT(additional_variable->get_parent() != NULL);
               printf ("additional_variable->get_parent() = %p = %s \n",additional_variable->get_parent(),additional_variable->get_parent()->class_name().c_str());
#endif
            // DQ (6/26/2019): Set the parent of the first SgInitializedName to that of the second SgInitializedName.
            // This is an issue for the range for initialization: see test2019_483.C.
 
               ASSERT_not_null(initializedName->get_scope());
 
            // DQ (6/26/2019): Set the pointer to the original version of this variable (unless we reused the SgInitializedName above).
               if (additional_variable != initializedName)
                  {
                    additional_variable->set_scope(initializedName->get_scope());
                  }
            // DQ (7/14/2014): Set the variable initialized (see test2014_107.C, also required for boost for_each support)).
            // initializedName->set_initptr(varInit);
#if DEBUG_BUILD_VARIABLE_DECLARATION
               printf ("In SageBuilder::buildVariableDeclaration_nfi(): After sharing the exisitng SgInitializedName: initializedName = %p = %s \n",initializedName,initializedName->get_name().str());
               printf (" --- initializedName->get_initptr()     = %p \n",initializedName->get_initptr());
               printf (" --- additional_variable->get_initptr() = %p \n",additional_variable->get_initptr());
#endif
             }
        }
 
  // DQ (11/3/2012): The SgInitializedName inside the SgVariableDeclaration must have valid source position object (even if default initialized).
     SgInitializedName* variable = getFirstInitializedName(varDecl);
     ASSERT_not_null(variable);
     setSourcePosition(variable);
 
     ASSERT_not_null(varDecl);
     varDecl->set_firstNondefiningDeclaration(varDecl);
     varDecl->get_declarationModifier().get_storageModifier().set_modifier(sm);
 
  // DQ (7/9/2012): Added test (parent should not be set yet; set in parse_statement).
     ROSE_ASSERT(varDecl->get_parent() == NULL);
 
     if (name != "")
        {
       // Anonymous bit fields should not have symbols
          fixVariableDeclaration(varDecl,scope);
 
       // DQ (7/9/2012): Added test (parent should not be set yet; set in parse_statement).
        }
       else
        {
       // DQ (7/12/2012): This is not correct for C++ (to use the input scope), so don't set it here (unless we use the current scope instead of scope).
       // Yes, let's set it to the current top of the scope stack.  This might be a problem if the scope stack is not being used...
          varDecl->set_parent(topScopeStack());
          ASSERT_not_null(varDecl->get_parent());
        }
 
     SgInitializedName *initName = varDecl->get_decl_item (name);
     ASSERT_not_null(initName);
     ASSERT_not_null(initName->get_declptr());
 
     if (initName->get_scope())
        {
       // Make this a warning for the few places where this fails.
#if DEBUG_BUILD_VARIABLE_DECLARATION
          printf ("WARNING: Note in buildVariableDeclaration_nfi(): initName->get_scope() == NULL \n");
#endif
        }
 
  // DQ (7/9/2012): Added test (parent should not be set yet; set in parse_statement).
  // bug 119, SgVariableDefintion's File_info is needed for deep copy to work
  // AstQuery based setSourcePositionForTransformation() cannot access all child nodes
  // have to set SgVariableDefintion explicitly
     SgVariableDefinition* variableDefinition_original = isSgVariableDefinition(initName->get_declptr());
     ASSERT_not_null(variableDefinition_original);
     setOneSourcePositionNull(variableDefinition_original);
     setOneSourcePositionNull(varDecl);
 
  // DQ (7/12/2012): The parent should be set to the current scope (not the same as that specified
  // in the scope (since that applies to the variable (SgInitializedName) not the SgVariableDeclaration).
  // Liao, 1/23/2013, quick fix for now, this condition is a mirror to the code setting parent in SageInterface::fixVariableDeclaration()
     if (topScopeStack())
        {
          ASSERT_not_null(varDecl->get_parent());
        }
 
  // DQ (4/16/2015): This is replaced with a better implementation.
  // DQ (4/15/2015): We should reset the isModified flags as part of the transforamtion
  // because we have added statements explicitly marked as transformations.
     unsetNodesMarkedAsModified(varDecl);
 
     ASSERT_not_null(varDecl);
 
#if DEBUG_BUILD_VARIABLE_DECLARATION
     printf ("Leaving buildVariableDeclaration_nfi(): varDecl = %p varDecl->get_parent() = %p \n",varDecl,varDecl->get_parent());
#endif
 
     return varDecl;
   }
 
 
SgVariableDefinition*
SageBuilder::buildVariableDefinition_nfi (SgVariableDeclaration* decl, SgInitializedName* init_name,  SgInitializer *init)
{
// refactored from ROSETTA/Grammar/Statement.code SgVariableDeclaration::append_variable ()
 
  ROSE_ASSERT (decl!=NULL);
  ROSE_ASSERT (init_name !=NULL);
  // init can be NULL
 
  SgVariableDefinition *defn_stmt = NULL;
  if (!isSgFunctionType(init_name->get_type()))
  {
    Sg_File_Info* copyOfFileInfo = NULL;
    if (decl->get_file_info() != NULL)
    {
      copyOfFileInfo = new Sg_File_Info(*(decl->get_file_info()));
      ROSE_ASSERT (copyOfFileInfo != NULL);
 
      // Note that the SgVariableDefinition will connect the new IR node into the AST.
      defn_stmt = new SgVariableDefinition(copyOfFileInfo, init_name, init);
      ROSE_ASSERT (defn_stmt != NULL);
 
      copyOfFileInfo->set_parent(defn_stmt);
 
      // DQ (3/13/2007): We can't enforce that the endOfConstruct is set (if the interface using the startOfConstruct is used.
      // DQ (2/3/2007): Need to build the endOfConstruct position as well.
      if (decl->get_endOfConstruct() != NULL)
      {
        Sg_File_Info* copyOfEndOfConstruct = new Sg_File_Info(*(decl->get_endOfConstruct()));
        defn_stmt->set_endOfConstruct(copyOfEndOfConstruct);
        copyOfEndOfConstruct->set_parent(defn_stmt);
      }
    }
    else
    {
      // Note that the SgVariableDefinition will connect the new IR node into the AST.
      defn_stmt = new SgVariableDefinition(init_name, init);
    }
    ROSE_ASSERT(defn_stmt != NULL);
  }
  else
    defn_stmt = NULL;
  return defn_stmt ;
}
 
 
SgTemplateVariableDeclaration*
SageBuilder::buildTemplateVariableDeclaration (const SgName & name, SgType* type, SgInitializer * varInit, SgScopeStatement* scope)
{
  SgTemplateVariableDeclaration* res = buildTemplateVariableDeclaration_nfi(name, type, varInit, scope);
  setOneSourcePositionForTransformation(res);
  return res;
}
 
// DQ (12/6/2011): Adding support for template declarations into the AST.
// SgTemplateDeclaration*
// SgVariableDeclaration*
// SgTemplateVariableDeclaration* buildTemplateVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
SgTemplateVariableDeclaration*
SageBuilder::buildTemplateVariableDeclaration_nfi (const SgName & name, SgType* type, SgInitializer * varInit, SgScopeStatement* scope)
   {
     ROSE_ASSERT (scope != NULL);
     ROSE_ASSERT(type != NULL);
 
     SgTemplateVariableDeclaration * varDecl = new SgTemplateVariableDeclaration(name, type, varInit);
     ROSE_ASSERT(varDecl);
 
     varDecl->set_firstNondefiningDeclaration(varDecl);
 
  // DQ (11/3/2012): The SgInitializedName inside the SgVariableDeclaration must have valid source position object (even if default initialized).
     SgInitializedName* variable = getFirstInitializedName(varDecl);
     ROSE_ASSERT(variable != NULL);
     setSourcePosition(variable);
 
     if (name != "")
        {
       // Anonymous bit fields should not have symbols
          fixVariableDeclaration(varDecl,scope);
        }
 
     SgInitializedName *initName = varDecl->get_decl_item (name);
     ROSE_ASSERT(initName);
     ROSE_ASSERT((initName->get_declptr())!=NULL);
 
  // bug 119, SgVariableDefintion's File_info is needed for deep copy to work
  // AstQuery based setSourcePositionForTransformation() cannot access all child nodes
  // have to set SgVariableDefintion explicitly
     SgVariableDefinition* variableDefinition_original = isSgVariableDefinition(initName->get_declptr());
     ROSE_ASSERT(variableDefinition_original != NULL);
     setOneSourcePositionNull(variableDefinition_original);
 
     setOneSourcePositionNull(varDecl);
 
     return varDecl;
   }
 
SgVariableDeclaration*
SageBuilder::buildVariableDeclaration(const std::string & name, SgType* type, SgInitializer * varInit, SgScopeStatement* scope)
{
  SgName name2(name);
  return buildVariableDeclaration(name2,type, varInit,scope);
}
 
SgVariableDeclaration*
SageBuilder::buildVariableDeclaration(const char* name, SgType* type, SgInitializer * varInit, SgScopeStatement* scope)
{
  SgName name2(name);
  return buildVariableDeclaration(name2,type, varInit,scope);
}
 
SgTypedefDeclaration*
SageBuilder::buildTypedefDeclaration(const std::string& name, SgType* base_type, SgScopeStatement* scope /*= NULL*/, bool has_defining_base/*= false*/)
{
  SgTypedefDeclaration* type_decl = buildTypedefDeclaration_nfi(name, base_type, scope, has_defining_base);
  setOneSourcePositionForTransformation(type_decl);
 
  return type_decl;
}
 
// The side effects include: creating SgTypedefType, SgTypedefSymbol, and add SgTypedefType to the base type
SgTypedefDeclaration*
SageBuilder::buildTypedefDeclaration_nfi(const std::string& name, SgType* base_type,  SgScopeStatement* scope /*= NULL*/, bool has_defining_base/*=false*/)
   {
     ROSE_ASSERT (base_type != NULL);
 
     if (scope == NULL )
        {
          scope = SageBuilder::topScopeStack();
        }
 
  // We don't yet support bottom up construction for this node yet
     ASSERT_not_null(scope);
 
     SgDeclarationStatement* base_decl = nullptr;
 
  // Handle the case where this is a pointer, reference, or typedef to another type.
     SgType* stripedBaseType = base_type->stripType();
     ASSERT_not_null(stripedBaseType);
 
     SgNamedType* namedType = isSgNamedType(stripedBaseType);
     if (namedType)
        {
       // DQ (12/28/2019): the problem with getting the base declaration from the type is that it forces sharing
       // of the base declaration when the typedef has a defining declaration for a base type in multiple files.
 
       // DQ (3/20/2012): Use this to set the value of base_decl (which was previously unset).
       // isSgNamedType(base_type)->get_declaration();
       // base_decl = isSgNamedType(base_type)->get_declaration();
          base_decl = namedType->get_declaration();
 
       // DQ (3/20/2012): All named types should have a valid declaration!
          ROSE_ASSERT(base_decl != NULL);
        }
 
  // DQ (3/20/2012): I don't remember why we need to provide the symbol for the scope of the
  // parent rather then the scope. But as I recall there was a special corner of C++ that
  // required this sort of support.
     SgSymbol* parent_scope = NULL;
#ifndef ROSE_USE_CLANG_FRONTEND
     if (scope != NULL)
        {
          ROSE_ASSERT(scope->get_parent() != NULL);
          SgDeclarationStatement* declaration = isSgDeclarationStatement(scope->get_parent());
 
          // PP (3/9/22)
          // In Ada, discriminated type may not have been fully built yet.
          //   this is because a the discriminated type obtains the name of the underlying
          //   declaration.
          // PP (5/9/22)
          // Unsure if declaration link should be set at all for Ada.
          //    The AstConsistencyTest flags typedefdecls with declaration link set...
          if (declaration && !isSgAdaDiscriminatedTypeDecl(declaration))
             {
               mprintf ("Found a valid declaration = %p = %s \n",declaration,declaration->class_name().c_str());
 
               ROSE_ASSERT(SageInterface::is_Ada_language() || declaration->get_firstNondefiningDeclaration() != NULL);
 
               parent_scope = declaration->search_for_symbol_from_symbol_table();
 
               ROSE_ASSERT(parent_scope != NULL);
             }
        }
#endif
 
  // Create the first nondefining declaration (note that the typedef type is always a NULL input value).
     SgTypedefDeclaration* type_decl = new SgTypedefDeclaration(SgName(name), base_type, NULL, base_decl, parent_scope);
     ROSE_ASSERT(type_decl != NULL);
 
  // TV (08/17/2018): moved it before building type as SgTypedefType::createType uses SgTemplateTypedefDeclaration::get_mangled_name which requires the scope to be set (else name of the associated type might not be unique)
     type_decl->set_scope(scope);
     type_decl->set_parent(scope);
 
  // DQ (2/27/2018): Add this call here to reflect change to the constructor semantics.
     type_decl->set_type(SgTypedefType::createType(type_decl));
 
  // DQ (3/20/2012): Comment ouly, these are always set this way. first defining is a self reference, and defining is always NULL (required for AST consistancy)).
     type_decl->set_firstNondefiningDeclaration (type_decl);
     type_decl->set_definingDeclaration(NULL);
 
  // Set the source code position information.
     setOneSourcePositionNull(type_decl);
 
  // Liao 11/29/2012, for typedef struct Frame {int x;} st_frame; We have to set parent for the struct.
  // AstPostProcessing() has resetParentPointers(). But it is kind of too late.
     if (SgClassDeclaration* base_class = isSgClassDeclaration(base_decl))
        {
          SgClassDeclaration* def_class = isSgClassDeclaration(base_class->get_definingDeclaration());
          SgClassDeclaration* nondef_class = isSgClassDeclaration(base_class->get_firstNondefiningDeclaration());
       // Dan and Liao, 12/3/2012, handle test2003_08.C nested typedef
          if (has_defining_base)
             {
               if (def_class != NULL)
                    if (def_class->get_parent() == NULL)
                         def_class->set_parent(type_decl);
             }
            else
             {
               if (nondef_class != NULL)
                    if (nondef_class->get_parent() == NULL)
                       {
                         nondef_class->set_parent(type_decl);
                       }
             }
        }
 
     SgTypedefSymbol* typedef_symbol = new SgTypedefSymbol(type_decl);
     ROSE_ASSERT(typedef_symbol);
 
     scope->insert_symbol(SgName(name),typedef_symbol);
 
     return type_decl;
   }
 
 
SgTemplateTypedefDeclaration*
SageBuilder::buildTemplateTypedefDeclaration_nfi(const SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base )
   {
  // DQ (11/2/2014): Adding support for templated typedef.
 
     ROSE_ASSERT (base_type != NULL);
 
     if (scope == NULL )
        {
          scope = SageBuilder::topScopeStack();
        }
 
  // We don't yet support bottom up construction for this node yet
     ROSE_ASSERT(scope != NULL);
 
     SgDeclarationStatement* base_decl = NULL;
 
  // DQ (3/20/2012): I don't remember why we need to provide the symbol for the scope of the
  // parent rather then the scope. But as I recall there was a special corner of C++ that
  // required this sort of support.
     SgSymbol* parent_scope = NULL;
     if (scope != NULL)
        {
          ROSE_ASSERT(scope->get_parent() != NULL);
          SgDeclarationStatement* declaration = isSgDeclarationStatement(scope->get_parent());
 
          if (declaration != NULL)
             {
               ROSE_ASSERT(declaration->get_firstNondefiningDeclaration() != NULL);
               parent_scope = declaration->search_for_symbol_from_symbol_table();
 
               ROSE_ASSERT(parent_scope != NULL);
             }
       // DQ (2/28/2018): check out if the symbol associated with the declaration used for the base type used in this typedef has a symbol.
          SgNamedType* namedType = isSgNamedType(base_type);
 
       // DQ (3/4/2018): This might not always be true (sure enough it fails for Cxx11_tests/test2014_58.C).
 
          if (namedType != NULL)
             {
               SgDeclarationStatement* declarationStatement = namedType->get_declaration();
 
            // This might not always be true.
               ROSE_ASSERT(declarationStatement != NULL);
               if (declarationStatement != NULL)
                  {
                    SgTemplateInstantiationDecl* templateInstantiationDecl = isSgTemplateInstantiationDecl(declarationStatement);
                    if (templateInstantiationDecl != NULL)
                       {
                         SgName name = templateInstantiationDecl->get_name();
                      // DQ (2/28/2018): Added debugging to track down redundnat symbol.
                         if (scope->lookup_template_typedef_symbol(name) != NULL)
                            {
                              printf ("Error: it appears that there is already a symbol in scope = %p = %s for name = %s \n",scope,scope->class_name().c_str(),name.str());
                            }
                         ROSE_ASSERT(scope->lookup_template_typedef_symbol(name) == NULL);
                       }
                  }
             }
        }
 
  // We need to add the template parameter and partial specialization support to the SgTemplateTypedefDeclaration IR node.
     SgTemplateTypedefDeclaration* type_decl = new SgTemplateTypedefDeclaration(name, base_type, NULL, base_decl, parent_scope);
     ROSE_ASSERT(type_decl != NULL);
 
  // TV (08/17/2018): moved it before building type as SgTypedefType::createType uses SgTemplateTypedefDeclaration::get_mangled_name which requires the scope to be set (else name of the associated type might not be unique)
     type_decl->set_scope(scope);
     type_decl->set_parent(scope);
 
  // DQ (2/27/2018): We now have to set the type explicitly.
     ROSE_ASSERT(type_decl->get_type() == NULL);
 
     SgTypedefType* typedefType = SgTypedefType::createType(type_decl);
     ROSE_ASSERT(typedefType != NULL);
 
  // DQ (2/27/2018): It is an inconsistancy for the type to be set here.
     type_decl->set_type(typedefType);
 
  // DQ (2/27/2018): This should be non-null, since we just built the new type.
     ROSE_ASSERT(type_decl->get_type() != NULL);
 
  // DQ (3/20/2012): Comment ouly, these are always set this way. first defining is a self reference, and defining is always NULL (required for AST consistancy)).
     type_decl->set_firstNondefiningDeclaration (type_decl);
     type_decl->set_definingDeclaration(NULL);
 
  // Set the source code position information.
     setOneSourcePositionNull(type_decl);
 
       // DQ (2/28/2018): check out if the symbol associated with the declaration used for the base type used in this typedef has a symbol.
          SgNamedType* namedType = isSgNamedType(base_type);
 
       // DQ (3/4/2018): This might not always be true (sure enough it fails for Cxx11_tests/test2014_58.C).
 
          if (namedType != NULL)
             {
               SgDeclarationStatement* declarationStatement = namedType->get_declaration();
 
            // This might not always be true.
               ROSE_ASSERT(declarationStatement != NULL);
               if (declarationStatement != NULL)
                  {
                    SgTemplateInstantiationDecl* templateInstantiationDecl = isSgTemplateInstantiationDecl(declarationStatement);
                    if (templateInstantiationDecl != NULL)
                       {
                         SgName name = templateInstantiationDecl->get_name();
                      // DQ (2/28/2018): Added debugging to track down redundnat symbol.
                         if (scope->lookup_template_typedef_symbol(name) != NULL)
                            {
                              printf ("Error: it appears that there is already a symbol in scope = %p = %s for name = %s \n",scope,scope->class_name().c_str(),name.str());
                            }
                         ROSE_ASSERT(scope->lookup_template_typedef_symbol(name) == NULL);
                       }
                  }
             }
 
          SgTemplateTypedefSymbol* typedef_symbol = new SgTemplateTypedefSymbol(type_decl);
          ROSE_ASSERT(typedef_symbol);
 
       // DQ (5/16/2013): This is the code we want now that we have implemented the namespace support behind the scope symbol bable interface.
          scope->insert_symbol(name, typedef_symbol);
 
          ROSE_ASSERT(scope->lookup_template_typedef_symbol(name) != NULL);
 
     return type_decl;
   }
 
#define DEBUG__SageBuilder__buildTemplateInstantiationTypedefDeclaration_nfi 0
 
ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
SageBuilder::buildTemplateInstantiationTypedefDeclaration_nfi(
  SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base,
  SgTemplateTypedefDeclaration* templateTypedefDeclaration,
  SgTemplateArgumentPtrList & templateArgumentsList
) {
#if DEBUG__SageBuilder__buildTemplateInstantiationTypedefDeclaration_nfi
     std::cout << "SageBuilder::buildTemplateInstantiationTypedefDeclaration_nfi" << std::endl;
     std::cout << "  name = " << name.getString() << std::endl;
     std::cout << "  base_type = " << std::hex << base_type << " : " << ( base_type ? base_type->class_name() : "" ) << std::endl;
#endif
     ROSE_ASSERT (base_type != NULL);
 
     SgName nameWithoutTemplateArguments = name;
     SgName nameWithTemplateArguments    = appendTemplateArgumentsToName(nameWithoutTemplateArguments,templateArgumentsList);
#if DEBUG__SageBuilder__buildTemplateInstantiationTypedefDeclaration_nfi
     std::cout << "  nameWithoutTemplateArguments = " << nameWithoutTemplateArguments.getString() << std::endl;
     std::cout << "  nameWithTemplateArguments    = " << nameWithTemplateArguments.getString() << std::endl;
#endif
 
  // We don't yet support bottom up construction for this node yet
     ROSE_ASSERT(scope != NULL);
 
     SgDeclarationStatement* base_decl = NULL;
 
  // DQ (3/20/2012): I don't remember why we need to provide the symbol for the scope of the
  // parent rather then the scope. But as I recall there was a special corner of C++ that
  // required this sort of support.
     SgSymbol* parent_scope = NULL;
     if (scope != NULL)
        {
          ROSE_ASSERT(scope->get_parent() != NULL);
          SgDeclarationStatement* declaration = isSgDeclarationStatement(scope->get_parent());
          if (declaration != NULL)
             {
               ROSE_ASSERT(declaration->get_firstNondefiningDeclaration() != NULL);
               parent_scope = declaration->search_for_symbol_from_symbol_table();
 
               ROSE_ASSERT(parent_scope != NULL);
             }
        }
 
  // DQ (11/5/2014): I think this might be set afterward.
     ROSE_ASSERT(templateTypedefDeclaration != NULL);
 
     SgTemplateTypedefSymbol* prexisting_template_typedef_symbol = scope->lookup_template_typedef_symbol(nameWithTemplateArguments);
     if (prexisting_template_typedef_symbol != NULL)
        {
          SgDeclarationStatement* declarationStatement = prexisting_template_typedef_symbol->get_declaration();
          ROSE_ASSERT(declarationStatement != NULL);
          SgTemplateInstantiationTypedefDeclaration* return_declaration = isSgTemplateInstantiationTypedefDeclaration(declarationStatement);
          ROSE_ASSERT(return_declaration != NULL);
          return return_declaration;
        }
     ROSE_ASSERT(scope->lookup_template_typedef_symbol(nameWithTemplateArguments) == NULL);
 
  // DQ (2/25/2018): Not clear if we want to use the template name with arguments.
  // Calling: SgTemplateInstantiationTypedefDeclaration(SgName, SgType*, SgTypedefType*, SgDeclarationStatement*, SgSymbol*, SgTemplateTypedefDeclaration*, SgTemplateArgumentPtrList)
     SgTypedefType* typedefType = NULL;
     SgTemplateInstantiationTypedefDeclaration* type_decl =
          new SgTemplateInstantiationTypedefDeclaration(nameWithTemplateArguments, base_type, typedefType, base_decl, parent_scope, templateTypedefDeclaration, templateArgumentsList);
     ROSE_ASSERT(type_decl != NULL);
     ROSE_ASSERT(type_decl->get_base_type() == base_type);
 
#if DEBUG__SageBuilder__buildTemplateInstantiationTypedefDeclaration_nfi
     std::cout << "  type_decl = " << std::hex << type_decl << " : " << ( type_decl ? type_decl->class_name() : "" ) << std::endl;
     std::cout << "    ->get_base_type() = " << std::hex << type_decl->get_base_type() << " : " << ( type_decl->get_base_type() ? type_decl->get_base_type()->class_name() : "" ) << std::endl;
#endif
 
  // DQ (2/27/2018): This is a change in the constructor semantics, we now have to build the type explicitly.
  // printf ("We now have to build the type explicitly \n");
     ROSE_ASSERT(type_decl->get_type() == NULL);
 
 
  // DQ (2/27/2018): Set the template name that this instantiation is using.
     type_decl->set_templateName(nameWithoutTemplateArguments);
 
     ROSE_ASSERT(scope != NULL);
     type_decl->set_scope(scope);
 
  // DQ (3/1/2018): A bug in the name of the template with arguments has been detected (extra spaces in
  // the name generated by type_decl->resetTemplateName()), make sure that we have a consistant naming.
     ROSE_ASSERT(type_decl->get_name() == nameWithTemplateArguments);
 
  // DQ (2/28/2018): Added debugging to track down redundnat symbol.
     if (scope->lookup_template_typedef_symbol(nameWithTemplateArguments) != NULL)
        {
          printf ("Error: it appears that there is already a symbol in scope = %p = %s for name = %s \n",scope,scope->class_name().c_str(),name.str());
        }
     ROSE_ASSERT(scope->lookup_template_typedef_symbol(nameWithTemplateArguments) == NULL);
 
 
  // DQ (2/26/2018): Can we assert this?
     ROSE_ASSERT(type_decl->get_type() == NULL);
 
     SgTypedefType* new_typedefType = SgTypedefType::createType(type_decl);
     ROSE_ASSERT(new_typedefType != NULL);
 
     type_decl->set_type(new_typedefType);
     ROSE_ASSERT(type_decl->get_type() != NULL);
     ROSE_ASSERT(type_decl->get_scope() != NULL);
 
     type_decl->set_firstNondefiningDeclaration (type_decl);
     type_decl->set_definingDeclaration(NULL);
 
     setOneSourcePositionNull(type_decl);
 
     SgName mangled_name = type_decl->get_mangled_name();
     setTemplateArgumentsInDeclaration(type_decl,&templateArgumentsList);
 
     ROSE_ASSERT(type_decl->get_firstNondefiningDeclaration() != NULL);
     ROSE_ASSERT(type_decl->get_definingDeclaration() == NULL);
     ROSE_ASSERT(type_decl->get_firstNondefiningDeclaration() == type_decl);
 
     ROSE_ASSERT(type_decl->get_type() != NULL);
     ROSE_ASSERT(scope != NULL);
 
#if DEBUG__SageBuilder__buildTemplateInstantiationTypedefDeclaration_nfi
     std::cout << "  type_decl = " << std::hex << type_decl << " : " << ( type_decl ? type_decl->class_name() : "" ) << std::endl;
     std::cout << "    ->get_base_type() = " << std::hex << type_decl->get_base_type() << " : " << ( type_decl->get_base_type() ? type_decl->get_base_type()->class_name() : "" ) << std::endl;
#endif
 
     if (scope != NULL)
        {
          if (scope->lookup_template_typedef_symbol(nameWithTemplateArguments) != NULL)
             {
               printf ("Error: it appears that there is already a symbol in scope = %p = %s for nameWithTemplateArguments = %s \n",scope,scope->class_name().c_str(),nameWithTemplateArguments.str());
             }
          ROSE_ASSERT(scope->lookup_template_typedef_symbol(nameWithTemplateArguments) == NULL);
 
          SgTemplateTypedefSymbol* typedef_symbol = new SgTemplateTypedefSymbol(type_decl);
          ROSE_ASSERT(typedef_symbol);
 
          scope->insert_symbol(nameWithTemplateArguments,typedef_symbol);
          type_decl->set_scope(scope);
          type_decl->set_parent(scope);
          ROSE_ASSERT(scope->lookup_template_typedef_symbol(nameWithTemplateArguments) != NULL);
        }
 
#if DEBUG__SageBuilder__buildTemplateInstantiationTypedefDeclaration_nfi
     std::cout << "  type_decl = " << std::hex << type_decl << " : " << ( type_decl ? type_decl->class_name() : "" ) << std::endl;
     std::cout << "    ->get_base_type() = " << std::hex << type_decl->get_base_type() << " : " << ( type_decl->get_base_type() ? type_decl->get_base_type()->class_name() : "" ) << std::endl;
#endif
 
     return type_decl;
   }
 
 
 
 
 
//-----------------------------------------------
// Assertion `definingDeclaration != NULL || firstNondefiningDeclaration != NULL'
SgFunctionParameterList *
SageBuilder::buildFunctionParameterList(SgInitializedName* in1, SgInitializedName* in2, SgInitializedName* in3, SgInitializedName* in4, SgInitializedName* in5, SgInitializedName* in6, SgInitializedName* in7, SgInitializedName* in8, SgInitializedName* in9, SgInitializedName* in10)
{
  SgFunctionParameterList *parameterList = new SgFunctionParameterList();
  ROSE_ASSERT (parameterList);
 
  parameterList->set_definingDeclaration (NULL);
  parameterList->set_firstNondefiningDeclaration (parameterList);
 
  setOneSourcePositionForTransformation(parameterList);
 
  if (in1) appendArg(parameterList, in1);
  if (in2) appendArg(parameterList, in2);
  if (in3) appendArg(parameterList, in3);
  if (in4) appendArg(parameterList, in4);
  if (in5) appendArg(parameterList, in5);
  if (in6) appendArg(parameterList, in6);
  if (in7) appendArg(parameterList, in7);
  if (in8) appendArg(parameterList, in8);
  if (in9) appendArg(parameterList, in9);
  if (in10) appendArg(parameterList, in10);
 
  return parameterList;
}
 
SgFunctionParameterList *
SageBuilder::buildFunctionParameterList_nfi() {
  SgFunctionParameterList *parameterList = new SgFunctionParameterList();
  ROSE_ASSERT (parameterList);
  parameterList->set_definingDeclaration (NULL);
  parameterList->set_firstNondefiningDeclaration (parameterList);
 
  setOneSourcePositionNull(parameterList);
 
  return parameterList;
}
 
//-----------------------------------------------
SgCtorInitializerList *
SageBuilder::buildCtorInitializerList_nfi() {
  SgCtorInitializerList *ctorInitList = new SgCtorInitializerList();
  ROSE_ASSERT (ctorInitList);
  ctorInitList->set_definingDeclaration (NULL);
  ctorInitList->set_firstNondefiningDeclaration (ctorInitList);
 
  setOneSourcePositionNull(ctorInitList);
 
  return ctorInitList;
}
 
//-----------------------------------------------
// no type vs. void type ?
SgFunctionParameterTypeList *
SageBuilder::buildFunctionParameterTypeList(SgFunctionParameterList* paralist)
   {
  // DQ (8/19/2012): I am not a fan of this sort of codeing style either (NULL pointers as inputs should be an error).
     if (paralist == NULL)
        {
          printf ("WARNING: In buildFunctionParameterTypeList(): Accepting NULL input and returning NULL pointer. \n");
 
          return NULL;
        }
 
  // DQ (8/18/2012): This is a problem, any valid list (even zero length) should result in a valid return list of types (even zero length).
  // if (paralist->get_args().size()==0)
  //      return NULL;
 
     SgFunctionParameterTypeList* typePtrList = new SgFunctionParameterTypeList;
     ROSE_ASSERT(typePtrList != NULL);
 
     SgInitializedNamePtrList args = paralist->get_args();
     SgInitializedNamePtrList::const_iterator i;
     for(i = args.begin(); i != args.end(); i++)
          (typePtrList->get_arguments()).push_back( (*i)->get_type() );
 
     setSourcePositionAtRootAndAllChildren(typePtrList);
 
     return typePtrList;
   }
 
 
SgFunctionParameterTypeList *
SageBuilder::buildFunctionParameterTypeList (SgExprListExp * expList)
   {
     if (expList ==NULL) return NULL;
     SgExpressionPtrList expPtrList = expList->get_expressions();
 
     SgFunctionParameterTypeList* typePtrList = new SgFunctionParameterTypeList;
     ROSE_ASSERT(typePtrList);
 
     SgExpressionPtrList::const_iterator i;
     for (i=expPtrList.begin();i!=expPtrList.end();i++)
        {
          typePtrList->get_arguments().push_back( (*i)->get_type() );
        }
 
     setSourcePositionAtRootAndAllChildren(typePtrList);
 
     return typePtrList;
   }
 
SgFunctionParameterTypeList *
SageBuilder::buildFunctionParameterTypeList(SgType* type0, SgType* type1, SgType* type2, SgType* type3,
                                            SgType* type4, SgType* type5, SgType* type6, SgType* type7)
   {
     SgFunctionParameterTypeList* typePtrList = new SgFunctionParameterTypeList;
     ROSE_ASSERT(typePtrList);
 
     SgTypePtrList & types = typePtrList->get_arguments();
 
     if (type0 != NULL) types.push_back(type0);
     if (type1 != NULL) types.push_back(type1);
     if (type2 != NULL) types.push_back(type2);
     if (type3 != NULL) types.push_back(type3);
     if (type4 != NULL) types.push_back(type4);
     if (type5 != NULL) types.push_back(type5);
     if (type6 != NULL) types.push_back(type6);
     if (type7 != NULL) types.push_back(type7);
 
     return typePtrList;
   }
 
//-----------------------------------------------
// build function type,
//
// insert into symbol table when not duplicated
SgFunctionType *
SageBuilder::buildFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList)
   {
     ROSE_ASSERT(return_type != NULL);
 
  // DQ (8/19/2012): Can we enforce this?
     ROSE_ASSERT(typeList != NULL);
 
     SgFunctionTypeTable * fTable = SgNode::get_globalFunctionTypeTable();
     ROSE_ASSERT(fTable);
 
  // This function make clever use of a static member function which can't be built
  // for the case of a SgMemberFunctionType (or at least not without more work).
     SgName typeName = SgFunctionType::get_mangled(return_type, typeList);
 
     SgFunctionType* funcType = isSgFunctionType(fTable->lookup_function_type(typeName));
 
     if (funcType == NULL)
        {
       // Only build the new type if it can't be found in the global type table.
          funcType = new SgFunctionType(return_type, false);
          ROSE_ASSERT(funcType);
 
          if (typeList != NULL)
             {
            // DQ (12/5/2012): We want to avoid overwriting an existing SgFunctionParameterTypeList. Could be related to failing tests for AST File I/O.
               if (funcType->get_argument_list() != NULL)
                  {
                    delete funcType->get_argument_list();
                    funcType->set_argument_list(NULL);
                  }
               ROSE_ASSERT(funcType->get_argument_list() == NULL);
 
               funcType->set_argument_list(typeList);
               typeList->set_parent(funcType);
             }
 
          fTable->insert_function_type(typeName,funcType);
        }
       else
        {
       // DQ (12/6/2012): Tracking down orphaned SgFunctionParameterTypeList objects.
        }
 
     return funcType;
   }
 
 
 
SgMemberFunctionType*
SageBuilder::buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgType *classType, unsigned int mfunc_specifier)
   {
  // DQ (8/19/2012): This is a refactored version of the buildMemberFunctionType() below so that we can
  // isolate out the part that uses a SgClassType from the version that uses the SgClassDefinition.
 
  // Maintain the global type table
     SgFunctionTypeTable* fTable = SgNode::get_globalFunctionTypeTable();
     ROSE_ASSERT(fTable != NULL);
 
  // DQ (12/6/2012): Added assertion.
  // ROSE_ASSERT(classType != NULL);
 
  // DQ (12/13/2012): Added assertion.
     ROSE_ASSERT(typeList != NULL);
 
  // DQ (12/6/2012): Newer simpler code (using static function SgMemberFunctionType::get_mangled()).
     SgName                typeName    = SgMemberFunctionType::get_mangled(return_type,typeList,classType,mfunc_specifier);
     SgType*               typeInTable = fTable->lookup_function_type(typeName);
 
#if 0
     printf ("In buildMemberFunctionType(SgType*,SgFunctionParameterTypeList*,SgType*,int,int): fTable->lookup_function_type(typeName = %s) = %p \n",typeName.str(),typeInTable);
     printf (" --- mfunc_specifier = %d ref_qualifiers = %d \n",mfunc_specifier,ref_qualifiers);
#endif
 
#if 0
  // DQ (1/10/2020): I think that these qualifiers are contained in the mfunc_specifier.
     if (ref_qualifiers > 0)
        {
          printf ("Exiting as a test! \n");
          ROSE_ABORT();
        }
#endif
 
     SgMemberFunctionType* funcType = NULL;
     if (typeInTable == NULL)
        {
          bool has_ellipses = false;
          //~ SgPartialFunctionType* partialFunctionType = new SgPartialFunctionType(return_type, has_ellipses, classType, mfunc_specifier, ref_qualifiers);
          // PP (10/4/22): removing ref_qualifiers
          SgPartialFunctionType* partialFunctionType = new SgPartialFunctionType(return_type, has_ellipses, classType, mfunc_specifier);
          ROSE_ASSERT(partialFunctionType != NULL);
#if 0
          printf ("Building a SgPartialFunctionType: partialFunctionType = %p \n",partialFunctionType);
          printf (" --- partialFunctionType->isLvalueReferenceFunc() = %s \n",partialFunctionType->isLvalueReferenceFunc() ? "true" : "false");
          printf (" --- partialFunctionType->isRvalueReferenceFunc() = %s \n",partialFunctionType->isRvalueReferenceFunc() ? "true" : "false");
#endif
       // DQ (12/5/2012): We want to avoid overwriting an existing SgFunctionParameterTypeList. Could be related to failing tests for AST File I/O.
          if (partialFunctionType->get_argument_list() != NULL)
             {
               delete partialFunctionType->get_argument_list();
               partialFunctionType->set_argument_list(NULL);
             }
          ROSE_ASSERT(partialFunctionType->get_argument_list() == NULL);
 
          typeList->set_parent(partialFunctionType);
 
       // DQ (12/6/2012): Set the SgFunctionParameterTypeList in the SgPartialFunctionType before trying
       // to build a SgMemberFunctionType (not critical that it be set before, but might be in the future,
       // but it is important that it be set).
          partialFunctionType->set_argument_list(typeList);
 
          ROSE_ASSERT(partialFunctionType->get_argument_list() != NULL);
 
       // The optional_fortran_type_kind is only required for Fortran support.
          SgExpression* optional_fortran_type_kind = NULL;
          funcType = SgMemberFunctionType::createType(partialFunctionType, optional_fortran_type_kind);
 
       // DQ (12/13/2012): Remove the SgPartialFunctionType after it has been used to build the SgMemberFunctionType.
       // I would rather modify the SgMemberFunctionType::createType() API so that we didn't use the SgPartialFunctionType IR nodes.
       // First we have to reset the pointer to the type argument list to NULL since it is shared with the SgMemberFunctionType.
          partialFunctionType->set_argument_list(NULL);
 
       // Then we can delete the SgPartialFunctionType.
          delete partialFunctionType;
          partialFunctionType = NULL;
 
       // This is perhaps redundant since it was set to a derived class (but might be an important distiction).
          typeList->set_parent(funcType);
 
          ROSE_ASSERT(funcType->get_argument_list() != NULL);
        }
 
     if (typeInTable == nullptr)
        {
          ASSERT_not_null(funcType);
          fTable->insert_function_type(typeName,funcType);
        }
       else
        {
       // DQ (12/3/2011): Added this case to support reuse of function types (not handled by the createType functions).
       // Delete the one generated so that we could form the mangled name.
          ASSERT_require(typeInTable != funcType);
          delete funcType;
 
       // Return the one from the global type table.
          funcType = isSgMemberFunctionType(typeInTable);
          ASSERT_not_null(funcType);
        }
 
     return funcType;
   }
 
 
// DQ (1/4/2009): Need to finish this!!!
//-----------------------------------------------
// build member function type,
//
// insert into symbol table when not duplicated
SgMemberFunctionType*
SageBuilder::buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgScopeStatement * struct_name, unsigned int mfunc_specifier)
   {
  // This function has to first build a version of the SgMemberFunctionType so that it can generate a mangled name.
  // If the mangled name can be use to lookup a SgMemberFunctionType then the "just built" SgMemberFunctionType
  // is deleted and the one from the global function type table is returned.  This fixes a lot of subtle C++
  // specific issues with the build interface and it's use with the newer EDG 4.3 connection to ROSE.
 
     ROSE_ASSERT(return_type != NULL);
 
  // SgMemberFunctionType (SgType *return_type=NULL, bool has_ellipses=true, SgClassDefinition *struct_name=NULL, unsigned int mfunc_specifier=0)
  // SgMemberFunctionType * funcType = new SgMemberFunctionType(return_type, false);
 
     ROSE_ASSERT(struct_name != NULL);
 
#if 0
     printf("In buildMemberFunctionType():\n");
     printf("  - struct_name = %p (%s)\n", struct_name, struct_name->class_name().c_str());
#endif
 
#if 0
  // DQ (1/9/2020): Unclear why this function is not using the ref_qualifiers.
     printf ("SageBuilder::buildMemberFunctionType(SgType*,SgFunctionParameterTypeList*,SgScopeStatement*,int,int): This function does not use the input ref_qualifiers = %x \n",ref_qualifiers);
     printf (" --- mfunc_specifier = %d ref_qualifiers = %d \n",mfunc_specifier,ref_qualifiers);
#endif
 
#if 0
     printf ("Exiting as a test! \n");
     ROSE_ABORT();
#endif
 
     ROSE_ASSERT(struct_name->get_parent() != NULL);
  // ROSE_ASSERT(struct_name->get_declaration() != NULL);
 
#if 0
     printf("struct_name = %p ( %s )\n", struct_name, struct_name->class_name().c_str());
#endif
 
  // SgDeclarationStatement* declaration = struct_name->get_declaration();
     SgClassDefinition*  classDefinition = isSgClassDefinition(struct_name);
     SgDeclarationScope* decl_scope      = isSgDeclarationScope(struct_name);
 
     if (classDefinition == NULL && decl_scope == NULL)
        {
          printf ("Error: (classDefinition == NULL && decl_scope == NULL): struct_name = %p = %s name = %s \n",
                  struct_name,struct_name->class_name().c_str(),SageInterface::get_name(struct_name).c_str());
        }
     ROSE_ASSERT(classDefinition != NULL || decl_scope != NULL);
 
     SgDeclarationStatement* declaration = NULL;
     if (classDefinition != NULL)
        {
          declaration = classDefinition->get_declaration();
        }
       else if (decl_scope != NULL)
        {
          declaration = isSgDeclarationStatement(decl_scope->get_parent());
        }
       else
        {
          ROSE_ABORT();
        }
 
     ROSE_ASSERT(declaration != NULL);
 
     if (typeList != NULL)
        {
#if 0
          SgTypePtrList & typeListArgs = typeList->get_arguments();
          for (SgTypePtrList::iterator i = typeListArgs.begin(); i != typeListArgs.end(); i++)
             {
               printf ("   --- type argument = %p = %s \n",*i,(*i)->class_name().c_str());
             }
#endif
        }
       else
        {
          printf ("WARNING: typeList == NULL \n");
        }
 
     SgClassDeclaration*         classDeclaration         = isSgClassDeclaration(declaration);
  // SgTemplateClassDeclaration* templateClassDeclaration = isSgTemplateClassDeclaration(declaration);
     SgNonrealDecl *             nrdecl                   = isSgNonrealDecl(declaration);
 
     ROSE_ASSERT(classDeclaration != NULL || nrdecl != NULL);
 
     SgMemberFunctionType* funcType = NULL;
 
  // DQ (12/4/2011): Modified SgClassType to support template declarations (SgTemplateClassDeclaration now contains a type set to SgClassType.
  // The SgClassType has been modified (browdened) to support a SgDeclarationStatement instead of a SgClassDeclaration.
  // SgClassType* classType = classDeclaration->get_type();
     SgType* classType = NULL;
     if (classDeclaration != NULL)
        {
          classType = classDeclaration->get_type();
        }
       else if (decl_scope != NULL)
        {
          classType = nrdecl->get_type();
        }
       else
        {
          ROSE_ABORT();
        }
 
     ROSE_ASSERT(classType != NULL);
 
#if 0
     printf ("In buildMemberFunctionType(): Calling refactored function: buildMemberFunctionType(...,classType = %p,...) \n",classType);
#endif
 
  // DQ (8/19/2012): This code has been refactored.
     funcType = buildMemberFunctionType(return_type,typeList,classType,mfunc_specifier);
 
#if 0
     printf ("In buildMemberFunctionType(): DONE: Calling refactored function: buildMemberFunctionType(...,classType = %p,...) \n",classType);
#endif
 
     return funcType;
   }
 
 
SgPointerMemberType*
SageBuilder::buildPointerMemberType(SgType* base_type, SgType* classType)
   {
     ROSE_ASSERT(base_type != NULL);
 
     ROSE_ASSERT(classType != NULL);
     SgPointerMemberType* pointerToMemberType = new SgPointerMemberType(base_type,classType);
     return pointerToMemberType;
 
   }
 
//----------------------------------------------------
SgType * SageBuilder::buildOpaqueType(std::string const name, SgScopeStatement * scope)
{
  // we require users to specify a target scope
  ROSE_ASSERT(scope);
  SgTypedefDeclaration* type_decl = NULL;
  SgTypedefType* result = NULL;
 
  // Liao and Greg Bronevetsky , 8/27/2009
  // patch up the symbol
  // and avoid duplicated creation
  // TODO  a function like fixTypeDeclaration() (similar to SageInterface::fixVariableDeclaration()) for this
  SgTypedefSymbol* type_symbol = scope->lookup_typedef_symbol(name);
  if (type_symbol == NULL)
  {
    type_decl =  new SgTypedefDeclaration(name,buildIntType(),NULL, NULL, NULL);
    ROSE_ASSERT(type_decl);
 
  // DQ (2/27/2018): Add this call here to reflect change to the constructor semantics.
     type_decl->set_type(SgTypedefType::createType(type_decl));
 
    type_symbol = new SgTypedefSymbol(type_decl);
    ROSE_ASSERT(type_symbol);
    SgName n = name;
 
 // DQ (5/21/2013): The symbol table should only be accessed through the SgScopeStatement interface.
    scope->insert_symbol(n,type_symbol);
 
    type_decl->set_firstNondefiningDeclaration (type_decl);
    setOneSourcePositionForTransformation(type_decl);
    prependStatement(type_decl,scope);
    // Hide it from unparser
    Sg_File_Info* file_info = type_decl->get_file_info();
    file_info->unsetOutputInCodeGeneration ();
    result = new SgTypedefType(type_decl);
  }
  else
  {
    type_decl = type_symbol->get_declaration();
    result = type_decl->get_type();
  }
  ROSE_ASSERT(result);
  return result;
}
 
 
//----------------- function type------------
// same function declarations (defining or nondefining) should share the same function type!
SgFunctionType*
SageBuilder::buildFunctionType(SgType* return_type, SgFunctionParameterList * argList)
   {
     ASSERT_not_null(argList);
 
     SgFunctionParameterTypeList* typeList  = buildFunctionParameterTypeList(argList);
     SgFunctionType* func_type = buildFunctionType(return_type, typeList);
 
     if (func_type->get_argument_list() != typeList)
        {
          delete typeList;
          typeList = NULL;
        }
 
     return func_type;
   }
 
void
checkThatNoTemplateInstantiationIsDeclaredInTemplateDefinitionScope ( SgDeclarationStatement* func, SgScopeStatement* scope )
   {
  // DQ (12/14/2011): We need the parent to be set so that we can call some of the test functions
  // (e.g assert that get_class_scope() for member functions).  So we set the parent to the scope
  // by default and see if this will work, else we could disable to assertion that the parent is
  // non-null in the get_class_scope() member function.
 
     if (isSgMemberFunctionDeclaration(func) != NULL)
        {
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
          printf ("WARNING: setting parent of function to match scope by default \n");
#endif
          func->set_parent(scope);
 
          ROSE_ASSERT(scope != NULL);
 
          if (isSgTemplateInstantiationMemberFunctionDecl(func) != NULL)
             {
            // DQ (12/14/2011): We should not have a member function template instantiation in a template class definition.
 
            // DQ (8/25/2014): Un-Commented out to revert to previous working state.
            // DQ (8/25/2014): Commented out to test new logic at base of isTemplateDeclaration(a_routine_ptr).
            // DQ (8/25/2014): Un-Commented out to revert to previous working state.
            // DQ (8/25/2014): Allow non-template functions in a template class declaration (see test2014_161.C).
#if !ENFORCE_NO_FUNCTION_TEMPLATE_DECLARATIONS_IN_TEMPLATE_CLASS_INSTANTIATIONS
            // printf ("In checkThatNoTemplateInstantiationIsDeclaredInTemplateDefinitionScope(): This is the wrong scope that is associated with this function (because EDG uses a single pointeer for a scope that maps to two different scopes in ROSE (and the scope_cache is not reset) \n");
#endif
             }
        }
       else
        {
          if (isSgTemplateFunctionDeclaration(func) != NULL)
             {
               if (isSgTemplateInstantiationMemberFunctionDecl(func) != NULL)
                  {
                    ROSE_ASSERT(isSgTemplateClassDefinition(scope) != NULL);
                  }
             }
        }
   }
 
//----------------- function declaration------------
// considering
// 1. fresh building
// 2. secondary building after another nondefining functiondeclaration
// 3. secondary building after another defining function declaration
// 4. fortran ?
template <class actualFunction>
actualFunction*
SageBuilder::buildNondefiningFunctionDeclaration_T (
   const SgName & XXX_name, SgType* return_type, SgFunctionParameterList * paralist, bool isMemberFunction,
   SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags,
   SgTemplateArgumentPtrList* templateArgumentsList, SgTemplateParameterPtrList* templateParameterList,
   SgStorageModifier::storage_modifier_enum sm
) {
  // DQ (11/25/2011): This function has been modified to work when used with a SgTemplateFunctionDeclaration as a template argument.
  // It was originally designed to work with only SgFunctionDeclaration and SgMemberFunctionDeclaration, it now works with these
  // plus SgTemplateFunctionDeclaration and SgTemplateMemberonDeclaration IR nodes. This is part of providing new support for template
  // declarations in the AST and a general update of this function to support this expanded use.
 
  // DQ (11/27/2011) Note: it is not clear if we need the newly added input paramter: buildTemplateInstantiation; since this is represented in the template parameter.
 
  // argument verification
     if (scope == nullptr)
        {
          scope = SageBuilder::topScopeStack();
        }
     ASSERT_not_null(scope);
 
     if (XXX_name.is_null() == true)
        {
       // DQ (4/2/2013): This case is generated for test2013_86.C.
          mprintf ("NOTE: In buildNondefiningFunctionDeclaration_T(): XXX_name.is_null() == true: This is a function with an empty name (allowed as compiler generated initializing constructors to un-named classes, structs, and unions in C++ \n");
        }
 
     SgName nameWithoutTemplateArguments = XXX_name;
     SgName nameWithTemplateArguments    = nameWithoutTemplateArguments;
 
     bool buildTemplateInstantiation = ((VariantT)actualFunction::static_variant == V_SgTemplateInstantiationFunctionDecl || (VariantT)actualFunction::static_variant == V_SgTemplateInstantiationMemberFunctionDecl);
 
  // DQ (8/7/2013): Added support for template declarations.
     bool buildTemplateDeclaration   = ((VariantT)actualFunction::static_variant == V_SgTemplateFunctionDeclaration || (VariantT)actualFunction::static_variant == V_SgTemplateMemberFunctionDeclaration);
 
  // DQ (8/7/2013): Added support for template declarations (need to handle template names overloaded on template parameters).
  // We want to use the template arguments in the symbol table lookup, but not in the name generation.
     if (buildTemplateInstantiation == true)
        {
          ASSERT_not_null(templateArgumentsList);
          nameWithTemplateArguments = appendTemplateArgumentsToName(nameWithoutTemplateArguments,*templateArgumentsList);
        }
 
  // this function is also called when building a function reference before the function declaration exists.  So, skip the check
     if (nameWithTemplateArguments.is_null() == true)
        {
       // DQ (3/25/2017): Modified to use message logging.
       // DQ (4/2/2013): This case is generated for test2013_86.C.
          mprintf ("NOTE: In buildNondefiningFunctionDeclaration_T(): nameWithTemplateArguments.is_null() == true: This is a function with an empty name (allowed as compiler generated initializing constructors to un-named classes, structs, and unions in C++ \n");
        }
 
     if (nameWithoutTemplateArguments.is_null() == true)
        {
       // DQ (3/25/2017): Modified to use message logging.
       // DQ (4/2/2013): This case is generated for test2013_86.C.
          mprintf ("NOTE: In buildNondefiningFunctionDeclaration_T(): nameWithoutTemplateArguments.is_null() == true: This is a function with an empty name (allowed as compiler generated initializing constructors to un-named classes, structs, and unions in C++ \n");
        }
 
     ASSERT_not_null(return_type);
     ASSERT_not_null(paralist);
 
  // DQ (7/27/2012): Note that the input name should not have template argument syntax.
  // I think this could still fail for a function with a name such as "X<Y>"  strange converstion operators.
     if (SageInterface::hasTemplateSyntax(nameWithoutTemplateArguments) == true)
        {
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
          printf ("Warning: In buildNondefiningFunctionDeclaration_T(): nameWithoutTemplateArguments = %s nameWithTemplateArguments = %s \n",nameWithoutTemplateArguments.str(),nameWithTemplateArguments.str());
#endif
        }
  // DQ (7/27/2012): There are reasons why this can fail: e.g. for functions with names such as:
  // "operator std::auto_ptr_ref<_Tp1>" which is a user defined conversion operator to one class from another.
 
  // tentatively build a function type, since it is shared
  // by all prototypes and defining declarations of a same function!
 
     SgFunctionType* func_type = nullptr;
     if (isMemberFunction == true)
        {
          SgFunctionParameterTypeList * typeList = buildFunctionParameterTypeList(paralist);
          func_type = buildMemberFunctionType(return_type,typeList,scope, functionConstVolatileFlags);
        }
       else
        {
          func_type = buildFunctionType(return_type,paralist);
        }
 
     ASSERT_not_null(func_type);
 
  // function declaration
     actualFunction* func = nullptr;
 
  // search before using the function type to create the function declaration
  // TODO only search current scope or all ancestor scope?? (DQ: Only current scope!)
  // We don't have lookup_member_function_symbol  yet
 
  // DQ (12/27/2011): Under the new design we can make the symbol type SgFunctionSymbol instead of the less specific SgSymbol.
  // DQ (11/25/2011): We want to add the support for template function declarations,
  // so this should be a SgSymbol so that we can have it be either a SgFunctionSymbol
  // or a SgTemplateSymbol.
     SgFunctionSymbol* func_symbol = NULL;
 
     if (scope != NULL)
        {
       // DQ (3/13/2012): Experiment with new function to support only associating the right type of symbol with the
       // function being built.  I don't think I like the design of this interface, but we might change that later.
 
       // DQ (8/7/2013): We need to use the template arguments in the symbol table lookup for template functions to permit template function overloading on template perameters.
          func_symbol = scope->find_symbol_by_type_of_function<actualFunction>(nameWithTemplateArguments,func_type,templateParameterList,templateArgumentsList);
 
#if 0 // DBG1
          printf ("In buildNondefiningFunctionDeclaration_T(): func_symbol from scope->find_symbol_by_type_of_function<actualFunction>(name = %s) = %p \n",nameWithTemplateArguments.str(),func_symbol);
          if (func_symbol != NULL) {
            printf ("In buildNondefiningFunctionDeclaration_T(): func_symbol->get_declaration() = %p \n", func_symbol->get_declaration());
          }
#endif /* DBG1 */
 
       // If not a proper function (or instantiated template function), then check for a template function declaration.
          if (func_symbol == NULL)
             {
            // Note that a template function does not have a function type (just a name).
               ROSE_ASSERT(func_type != NULL);
             }
        }
 
  // DQ (3/13/2012): I want to introduce error checking on the symbol matching the template parameter.
     if (func_symbol != NULL)
        {
          switch((VariantT)actualFunction::static_variant)
             {
               case V_SgFunctionDeclaration:
               case V_SgProcedureHeaderStatement:
               case V_SgTemplateInstantiationFunctionDecl:
                  {
                    ROSE_ASSERT(isSgFunctionSymbol(func_symbol) != NULL);
                    break;
                  }
               case V_SgMemberFunctionDeclaration:
               case V_SgTemplateInstantiationMemberFunctionDecl:
                  {
                    ROSE_ASSERT(isSgMemberFunctionSymbol(func_symbol) != NULL);
                    break;
                  }
               case V_SgTemplateFunctionDeclaration:
                  {
                    ROSE_ASSERT(isSgTemplateFunctionSymbol(func_symbol) != NULL);
                    break;
                  }
               case V_SgTemplateMemberFunctionDeclaration:
                  {
                    ROSE_ASSERT(isSgTemplateMemberFunctionSymbol(func_symbol) != NULL);
                    break;
                  }
 
               default:
                  {
                    printf ("default reach in buildNondefiningFunctionDeclaration_T(): variantT(actualFunction::static_variant) = %d \n",actualFunction::static_variant);
                    ROSE_ABORT();
                  }
             }
 
          // TV (2/5/14): Found symbol might come from another file, in this case we need to insert it in the current scope.
          //              Can only happen when scope is a global scope
             ROSE_ASSERT(scope != NULL);
             if (  isSgGlobal(scope) != NULL
                && scope != func_symbol->get_scope()
                && !SageInterface::isAncestor(scope, func_symbol->get_scope())
             && !scope->symbol_exists(nameWithTemplateArguments, func_symbol) )
             {
               scope->insert_symbol(nameWithTemplateArguments, func_symbol);
             }
        }
 
     if (func_symbol == NULL)
        {
          func = new actualFunction (nameWithTemplateArguments,func_type,NULL);
          ROSE_ASSERT(func != NULL);
 
          // Storage modifier (esp. static) must be set before inserting symbol
          func->get_declarationModifier().get_storageModifier().set_modifier(sm);
 
       // DQ (5/1/2012): This should always be true.
          ROSE_ASSERT(func->get_file_info() == NULL);
 
       // DQ (12/14/2011): Moved this from lower in this function.
          func->set_scope(scope);
 
       // DQ (12/15/2011): Added test.
          checkThatNoTemplateInstantiationIsDeclaredInTemplateDefinitionScope(func,scope);
 
       // This fails below for a SgTemplateFunctionDeclaration, so test it here.
          ROSE_ASSERT(func->get_parameterList() != NULL);
 
       // NOTE: we want to allow the input scope to be NULL (and even the SageBuilder::topScopeStack() == NULL)
       // so that function can be built bottom up style.  However this means that the symbol tables in the
       // scope of the returned function declaration will have to be setup separately.
          if (scope != NULL)
             {
            // function symbol table
               if (isSgMemberFunctionDeclaration(func))
                  {
                 // DQ (11/23/2011): This change allows this to compile for where SgTemplateFunctionDeclarations are used. I have
                 // not decided if template declarations should cause symbols to be generated for functions and member functions.
                 // func_symbol = new SgMemberFunctionSymbol(func);
                    if (isSgTemplateMemberFunctionDeclaration(func) != NULL)
                       func_symbol = new SgTemplateMemberFunctionSymbol(isSgTemplateMemberFunctionDeclaration(func));
                    else
                     {
                       SgMemberFunctionDeclaration* memberFunctionDeclaration = isSgMemberFunctionDeclaration(func);
                       ROSE_ASSERT(memberFunctionDeclaration != NULL);
                       func_symbol = new SgMemberFunctionSymbol(memberFunctionDeclaration);
                     }
 
                    ROSE_ASSERT(func_symbol != NULL);
                    ROSE_ASSERT(func_symbol->get_symbol_basis() != NULL);
                  }
                 else
                  {
                 // if (isSgFunctionDeclaration(func))
                    if (isSgTemplateFunctionDeclaration(func))
                       {
                      // How should we handled template functions in the symbol table???
                      // DQ (11/24/2011): After some thought, I think that template declarations for function are more template declarations
                      // than functions.  So all template function declarations will be handled as SgTemplateSymbols and not SgFunctionSymbols.mplate function declarations.
                         SgTemplateFunctionDeclaration* templatedeclaration = isSgTemplateFunctionDeclaration(func);
                         ROSE_ASSERT(templatedeclaration != NULL);
                         SgTemplateFunctionSymbol* template_symbol = new SgTemplateFunctionSymbol(templatedeclaration);
                         ROSE_ASSERT(template_symbol != NULL);
                         ROSE_ASSERT(template_symbol->get_symbol_basis() != NULL);
                         func_symbol = template_symbol;
                       }
                      else
                       {
                         func_symbol = new SgFunctionSymbol(isSgFunctionDeclaration(func));
                         ROSE_ASSERT(func_symbol->get_symbol_basis() != NULL);
                       }
                  }
 
               ROSE_ASSERT(func_symbol != NULL);
               ROSE_ASSERT(func_symbol->get_symbol_basis() != NULL);
               scope->insert_symbol(nameWithTemplateArguments, func_symbol);
 
            // DQ (3/8/2012): Added assertion.
               ROSE_ASSERT(func->get_symbol_from_symbol_table() != NULL);
 
               if (isSgFunctionDeclaration(func) == NULL)
                  {
                 // DQ (12/18/2011): If this is a SgTemplateDeclaration, then we shuld be able to find the name in the associated scope.
                 // DQ (8/12/2013): Added template parameter list.
                 // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
                 // In this case these are unavailable from this point.
                    ROSE_ASSERT(scope->lookup_template_function_symbol(nameWithTemplateArguments,func_type,templateParameterList) != NULL);
                  }
 
            // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
            // In this case these are unavailable from this point.
            // DQ (11/25/2011): Added support for template functions.
            // DQ (2/26/2009): uncommented assertion.
            // Did not pass for member function? Should we have used the mangled name?
               ROSE_ASSERT(buildTemplateDeclaration == false || templateParameterList != NULL);
 
            // DQ (8/13/2013): We need to test for function symbols (which will include member function symbols),
            // template functions and template member functions. Each must be tested for seperately because template
            // functions and template member functions are not connected to derivation which non-template functions
            // and non-template member functions are connected through derivation.
               ROSE_ASSERT(scope->lookup_function_symbol(nameWithTemplateArguments) != NULL ||
                           scope->lookup_template_function_symbol(nameWithTemplateArguments,func_type,templateParameterList) != NULL ||
                           scope->lookup_template_member_function_symbol(nameWithTemplateArguments,func_type,templateParameterList) != NULL);
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_SYMBOL_TABLE_LOOKUP
            // if (scope->lookup_function_symbol(name) == NULL || scope->lookup_template_symbol(name) != NULL)
            // if (scope->lookup_function_symbol(nameWithTemplateArguments) == NULL || scope->lookup_template_symbol(nameWithTemplateArguments) != NULL)
            // if (scope->lookup_function_symbol(nameWithTemplateArguments) == NULL || scope->lookup_template_symbol(nameWithTemplateArguments,NULL,NULL) != NULL)
               if (scope->lookup_function_symbol(nameWithTemplateArguments,templateArgumentList) == NULL || scope->lookup_template_symbol(nameWithTemplateArguments,templateParameterList,NULL) != NULL)
                  {
                 // Make sure this is a template function declaration...
                    printf ("Need to make sure this is a template function declaration... \n");
                  }
#endif
             }
 
       // DQ (12/14/2011): Added test.
          ROSE_ASSERT(func->get_scope() != NULL);
 
          if (isSgFunctionDeclaration(func) == NULL)
             {
            // If this is a SgTemplateDeclaration, then we shuld be able to find the name in the associated scope.
 
            // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
            // In this case these are unavailable from this point.
               ROSE_ASSERT(scope->lookup_template_function_symbol(nameWithTemplateArguments,func_type,templateParameterList) != NULL);
             }
          func->set_firstNondefiningDeclaration(func);
          func->set_definingDeclaration(NULL);
 
       // DQ (5/8/2016): We need to test the first defining declaration that we used.
          ROSE_ASSERT(func->get_firstNondefiningDeclaration() == func);
 
          ROSE_ASSERT(func->get_definingDeclaration() == NULL);
 
       // DQ (12/14/2011): Error checking
          SgTemplateInstantiationMemberFunctionDecl* testMemberDecl = isSgTemplateInstantiationMemberFunctionDecl(func);
          if (testMemberDecl != NULL)
             {
               ROSE_ASSERT(testMemberDecl->get_scope() != NULL);
               ROSE_ASSERT(testMemberDecl->get_class_scope() != NULL);
               ROSE_ASSERT(testMemberDecl->get_associatedClassDeclaration() != NULL);
             }
        }
       else
        {
          ROSE_ASSERT(func_symbol != NULL);
 
          ROSE_ASSERT(scope != NULL);
 
       // 2nd, or 3rd... prototype declaration
       // reuse function type, function symbol of previous declaration
 
       // std::cout<<"debug:SageBuilder.C: 267: "<<"found func_symbol!"<<std::endl;
       // delete (func_type-> get_argument_list ());
       // delete func_type; // bug 189
          SgNode* associatedSymbolBasis = func_symbol->get_symbol_basis();
          ROSE_ASSERT(associatedSymbolBasis != NULL);
 
          SgDeclarationStatement* associatedDeclaration = isSgDeclarationStatement(associatedSymbolBasis);
          ROSE_ASSERT(associatedDeclaration != NULL);
          SgFunctionDeclaration*         functionDeclaration         = isSgFunctionDeclaration(associatedDeclaration);
          SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(associatedDeclaration);
 
          if (functionDeclaration != NULL)
             {
               func_type = functionDeclaration->get_type();
             }
            else
             {
               if (templateFunctionDeclaration != NULL)
                  {
                 // DQ (5/8/2016): I think this code is never executed (because a templateFunctionDeclaration
                 // is derived from a SgFunctionDeclaration, in the newer design (a few years ago)).
 
                    printf ("This code should not be reachable! \n");
                    ROSE_ABORT();
 
                    func_type = templateFunctionDeclaration->get_type();
                  }
                 else
                  {
                    printf ("Error: associatedDeclaration = %p = %s \n",associatedDeclaration,associatedDeclaration->class_name().c_str());
                    ROSE_ABORT();
                  }
             }
          ROSE_ASSERT(func_type != NULL);
 
          func = new actualFunction(nameWithTemplateArguments,func_type,NULL);
          ROSE_ASSERT(func != NULL);
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS
       // DQ (5/1/2012): Make sure that we don't have IR nodes marked as translformations.
       // This is too early a point to test since the source position has not been set for func yet.
       // detectTransformations_local(func);
#endif
 
       // DQ (12/14/2011): Moved this up from below.
          func->set_scope(scope);
 
       // DQ (3/8/2012): Added assertion.
          ROSE_ASSERT(func->get_symbol_from_symbol_table() == NULL);
 
       // DQ (12/15/2011): Added test.
          checkThatNoTemplateInstantiationIsDeclaredInTemplateDefinitionScope(func,scope);
 
       // we don't care if it is member function or function here for a pointer
          SgDeclarationStatement* prevDecl = NULL;
 
       // This does not handle the case of a template function declaration.
          if (functionDeclaration != NULL)
             {
               prevDecl = functionDeclaration;
             }
            else
             {
               ROSE_ASSERT(templateFunctionDeclaration != NULL);
               prevDecl = templateFunctionDeclaration;
             }
 
          ROSE_ASSERT(prevDecl != NULL);
 
          SgFunctionSymbol *function_symbol = isSgFunctionSymbol(func_symbol);
          if (prevDecl == prevDecl->get_definingDeclaration())
             {
            // The symbol points to a defining declaration and now that we have added a non-defining
            // declaration we should have the symbol point to the new non-defining declaration.
               printf ("WARNING: Switching declaration in functionSymbol to point to the non-defining declaration \n");
               function_symbol->set_declaration(isSgFunctionDeclaration(func));
               ROSE_ASSERT(function_symbol->get_declaration() != NULL);
             }
 
       // If this is the first non-defining declaration then set the associated data member.
          SgDeclarationStatement* nondefiningDeclaration = prevDecl->get_firstNondefiningDeclaration();
          if (nondefiningDeclaration == NULL)
             {
               nondefiningDeclaration = func;
             }
 
          ROSE_ASSERT(nondefiningDeclaration != NULL);
          ROSE_ASSERT(func != NULL);
          ROSE_ASSERT(prevDecl != NULL);
 
          func->set_firstNondefiningDeclaration(nondefiningDeclaration);
          func->set_definingDeclaration(prevDecl->get_definingDeclaration());
 
          ROSE_ASSERT(nondefiningDeclaration->get_symbol_from_symbol_table() != NULL);
          ROSE_ASSERT(func->get_firstNondefiningDeclaration()->get_symbol_from_symbol_table() != NULL);
 
       // DQ (3/8/2012): If this is the redundant function prototype then we have to look
       // at the first defining declaration since only it will have an associated symbol.
          if (func->get_symbol_from_symbol_table() == NULL)
             {
               ROSE_ASSERT(nondefiningDeclaration != NULL);
               ROSE_ASSERT(func->get_firstNondefiningDeclaration() == nondefiningDeclaration);
             }
 
       // DQ (12/14/2011): Added test.
          ROSE_ASSERT(scope != NULL);
          ROSE_ASSERT(func->get_scope() != NULL);
          ROSE_ASSERT(func->get_scope() == scope);
 
       // DQ (12/14/2011): Error checking
          SgTemplateInstantiationMemberFunctionDecl* testMemberDecl = isSgTemplateInstantiationMemberFunctionDecl(func);
          if (testMemberDecl != NULL)
             {
               ROSE_ASSERT(testMemberDecl->get_scope() != NULL);
               ROSE_ASSERT(testMemberDecl->get_associatedClassDeclaration() != NULL);
             }
 
       // DQ (12/18/2011): Testing to debug generation of wrong kind of declaration (symbol not found in correct scope or ...).
          if (isSgFunctionDeclaration(func) == NULL)
             {
            // If this is a SgTemplateDeclaration, then we shuld be able to find the name in the associated scope.
            // DQ (8/12/2013): Added template parameter list.
            // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
            // In this case these are unavailable from this point.
            // DQ (12/18/2011): This fails because the first use of the function causes a non-defining function declaration
            // to be built and it is built as a template instantiation instead of a template declaration.  So the symbol for
            // the non-defining declaration is put into the correct scope, but as a SgMemberFunctionSymbol instead of as a
            // SgTemplateSymbol (if it were built as a SgTemplateMemberFunctionDeclaration).  So of course we can't find it
            // using lookup_template_symbol().
               ROSE_ASSERT(scope->lookup_template_function_symbol(nameWithTemplateArguments,func_type,templateParameterList) != NULL);
             }
        }
 
     ROSE_ASSERT(func != NULL);
 
     ROSE_ASSERT(func->get_file_info() == NULL);
 
  // DQ (3/8/2012): Added assertion.
     ROSE_ASSERT(func->get_firstNondefiningDeclaration() != NULL);
     ROSE_ASSERT(func_symbol != NULL);
     ROSE_ASSERT(func_symbol->get_symbol_basis() == func->get_firstNondefiningDeclaration());
     ROSE_ASSERT(func->get_symbol_from_symbol_table() != NULL || func->get_firstNondefiningDeclaration()->get_symbol_from_symbol_table() != NULL);
 
  // DQ (2/24/2009): Delete the old parameter list build by the actualFunction (template argument) constructor.
     ROSE_ASSERT(func->get_parameterList() != NULL);
     delete func->get_parameterList();
     func->set_parameterList(NULL);
 
  // DQ (9/16/2012): Setup up the template arguments and the parents of the template arguments.
     if (buildTemplateInstantiation == true)
        {
          setTemplateArgumentsInDeclaration(func,templateArgumentsList);
        }
 
  // DQ (8/10/2013): Setup the template parameters if this is a template declaration.
     if (buildTemplateDeclaration == true)
        {
          setTemplateParametersInDeclaration(func,templateParameterList);
 
       // DQ (8/13/2013): Adding test of template parameter lists.
          SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(func);
          ROSE_ASSERT(templateFunctionDeclaration == NULL || (templateParameterList != NULL && templateParameterList->size() == templateFunctionDeclaration->get_templateParameters().size()));
 
          SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = isSgTemplateMemberFunctionDeclaration(func);
          ROSE_ASSERT(templateMemberFunctionDeclaration == NULL || (templateParameterList != NULL && templateParameterList->size() == templateMemberFunctionDeclaration->get_templateParameters().size()));
        }
 
  // parameter list
  // DQ (11/23/2011): This change allows this to compile for where SgTemplateFunctionDeclarations are used.
     setParameterList(func, paralist);
 
     for (SgInitializedName* i_name : paralist->get_args())
        {
          i_name->set_scope(scope);
        }
 
#if 0
  // DQ (7/12/2021): Debugging where nodes in the outliner are being marked as transformations (SgCastExpressions should not be marked as transformations).
     printf ("In buildNondefiningFunctionDeclaration_T(): setting the source position information (calling setTransformation()) \n");
#endif
 
  // DQ (5/2/2012): Test this to make sure we have SgInitializedNames set properly.
     SageInterface::setSourcePosition(paralist);
 
#if 0
  // DQ (7/12/2021): Debugging where nodes in the outliner are being marked as transformations (SgCastExpressions should not be marked as transformations).
     printf ("In buildNondefiningFunctionDeclaration_T(): DONE: setting the source position information (calling setTransformation()) \n");
#endif
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS
  // Liao 11/21/2012: we should assert no transformation only when the current model is NOT transformation
     if (SourcePositionClassificationMode != e_sourcePositionTransformation)
        {
          detectTransformations_local(paralist);
        }
#endif
 
     ASSERT_not_null(scope);
     ASSERT_not_null(func->get_scope());
     ASSERT_require(func->get_scope() == scope);
 
  // DQ (1/5/2009): This is not always true (should likely use SageBuilder::topScopeStack() instead)
     if (SageBuilder::topScopeStack() != nullptr) // This comparison only makes sense when topScopeStack() returns non-NULL value
        {
       // since  stack scope is totally optional in SageBuilder.
          if (scope != SageBuilder::topScopeStack())
             {
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
               printf ("Warning: SageBuilder::buildNondefiningFunctionDeclaration_T(): scope parameter may not be the same as the topScopeStack() (e.g. for member functions) \n");
#endif
             }
        }
 
     func->set_parent(scope);
     ASSERT_not_null(func->get_firstNondefiningDeclaration());
 
  // mark as a forward declartion
     func->setForward();
 
     ROSE_ASSERT(func->get_file_info() == NULL);
 
  // set File_Info as transformation generated or front end generated
     setSourcePositionAtRootAndAllChildren(func);
 
     ROSE_ASSERT(func->get_file_info() != NULL);
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS
  // DQ (5/1/2012): Make sure that we don't have IR nodes marked as transformations.
     if (SourcePositionClassificationMode != e_sourcePositionTransformation)
        {
          detectTransformations_local(func);
        }
#endif
 
  // printf ("In SageBuilder::buildNondefiningFunctionDeclaration_T(): generated function func = %p \n",func);
 
  // Liao 12/2/2010, special handling for Fortran functions and subroutines
     if ((SageInterface::is_Fortran_language() == true) && (getEnclosingFileNode(scope)->get_outputLanguage() == SgFile::e_Fortran_language))
        {
          SgProcedureHeaderStatement * f_func = isSgProcedureHeaderStatement(func);
          ROSE_ASSERT (f_func != NULL);
          if (return_type == buildVoidType())
               f_func->set_subprogram_kind(SgProcedureHeaderStatement::e_subroutine_subprogram_kind);
            else
               f_func->set_subprogram_kind(SgProcedureHeaderStatement::e_function_subprogram_kind);
 
       // hide it from the unparser since fortran prototype func declaration is internally used by ROSE AST
          f_func->get_startOfConstruct()->unsetOutputInCodeGeneration();
          f_func->get_endOfConstruct()->unsetOutputInCodeGeneration();
          ROSE_ASSERT(f_func->get_startOfConstruct()->isOutputInCodeGeneration() == false);
          ROSE_ASSERT(f_func->get_endOfConstruct()->isOutputInCodeGeneration() == false);
        }
 
  // DQ (12/11/2011): Added new test.
     ROSE_ASSERT(func->get_firstNondefiningDeclaration() != NULL);
     SgSymbol* symbol_from_first_nondefining_function = func->get_firstNondefiningDeclaration()->get_symbol_from_symbol_table();
     ROSE_ASSERT(symbol_from_first_nondefining_function != NULL);
 
  // DQ (12/11/2011): Note that this may be false when func is not the first nondefining declaration.
     if (func != func->get_firstNondefiningDeclaration())
        {
          SgSymbol* symbol_from_nondefining_function = func->get_symbol_from_symbol_table();
          ROSE_ASSERT(symbol_from_nondefining_function == NULL);
        }
 
  // DQ (12/18/2011): Testing to debug generation of wrong kind of declaration (symbol not found in correct scope or ...).
     if (isSgFunctionDeclaration(func) == NULL)
        {
       // If this is a SgTemplateDeclaration, then we shuld be able to find the name in the associated scope.
       // DQ (8/12/2013): Make sure we use the template parameters and the template arguments that are available.
       // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
       // In this case these are unavailable from this point.
          ROSE_ASSERT(scope->lookup_template_function_symbol(nameWithTemplateArguments,func_type,templateParameterList) != NULL);
        }
 
  // DQ (2/11/2012): If this is a template instantiation then we have to set the template name (seperate from the name of the function which can include template parameters)).
     setTemplateNameInTemplateInstantiations(func,nameWithoutTemplateArguments);
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS
  // DQ (5/1/2012): Make sure that we don't have IR nodes marked as transformations.
     if (SourcePositionClassificationMode !=e_sourcePositionTransformation)
        {
          detectTransformations_local(func);
        }
#endif
 
  // DQ (12/11/2012): Force the two different ways that this can be set to match (we want consistancy).
     if (functionConstVolatileFlags & SgMemberFunctionType::e_restrict)
        {
          func->get_declarationModifier().get_typeModifier().setRestrict();
        }
 
  // DQ (8/19/2013): Added assertion that is tested and which fails for test_3 of the RoseExample_tests directory (in edgRose.C).
  // This fails for everything.... not sure why...
 
  // DQ (4/16/2015): This is replaced with a better implementation.
  // Make sure the isModified boolean is clear for all newly-parsed nodes.
     unsetNodesMarkedAsModified(func);
 
     ROSE_ASSERT(paralist->get_parent() != NULL);
     return func;
   }
 
 
SgFunctionDeclaration *
SageBuilder::buildNondefiningFunctionDeclaration (const SgFunctionDeclaration* funcdecl, SgScopeStatement* scope/*=NULL*/, SgExprListExp* decoratorList)
{
  ROSE_ASSERT(funcdecl!=NULL);
  SgName name=funcdecl->get_name();
  SgFunctionType * funcType = funcdecl->get_type();
  SgType* return_type = funcType->get_return_type();
  SgFunctionParameterList* paralist = deepCopy<SgFunctionParameterList>(funcdecl->get_parameterList());
 
 // make sure the function has consistent function type based on its return type and parameter list
 SgFunctionType * ref_funcType= findFunctionType (return_type, funcType->get_argument_list());
  ROSE_ASSERT(funcType== ref_funcType);
 
  // buildNondefiningFunctionDeclaration() will check if a same function is created before by looking up function symbols.
  SgFunctionDeclaration* returnFunction  = buildNondefiningFunctionDeclaration (name, return_type, paralist, scope, decoratorList, false, NULL);
 
  returnFunction->set_linkage(funcdecl->get_linkage());
  if (funcdecl->get_declarationModifier().get_storageModifier().isExtern() == true)
  {
    returnFunction->get_declarationModifier().get_storageModifier().setExtern();
  }
 
  ROSE_ASSERT (returnFunction->get_linkage() == funcdecl->get_linkage());
  ROSE_ASSERT (returnFunction->get_declarationModifier().get_storageModifier().isExtern() ==
               funcdecl->get_declarationModifier().get_storageModifier().isExtern());
 
  ROSE_ASSERT(returnFunction->get_firstNondefiningDeclaration() != NULL);
  // Make sure that internal references are to the same file (else the symbol table information will not be consistent).
  if (scope != NULL)
  {
    ROSE_ASSERT(returnFunction->get_firstNondefiningDeclaration() != NULL);
  }
 
  return returnFunction;
}
 
SgFunctionDeclaration*
SageBuilder::buildNondefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList, SgStorageModifier::storage_modifier_enum sm)
   {
     SgFunctionDeclaration * result = NULL;
     if ((SageInterface::is_Fortran_language() == true) && (getEnclosingFileNode(scope)->get_outputLanguage() == SgFile::e_Fortran_language))
        {
          result = buildNondefiningFunctionDeclaration_T <SgProcedureHeaderStatement> (name,return_type,paralist, /* isMemberFunction = */ false, scope, decoratorList, false, NULL, NULL, sm);
        }
       else
        {
       // DQ (11/27/2011): Added support to generate template declarations in the AST (this is part of a common API to make the build functions support more uniform).
          if (buildTemplateInstantiation == true)
             {
               result = buildNondefiningFunctionDeclaration_T <SgTemplateInstantiationFunctionDecl> (name,return_type,paralist, /* isMemberFunction = */ false, scope, decoratorList, false, templateArgumentsList, NULL, sm);
             }
            else
             {
               result = buildNondefiningFunctionDeclaration_T <SgFunctionDeclaration> (name,return_type,paralist, /* isMemberFunction = */ false, scope, decoratorList, false, NULL, NULL, sm);
             }
        }
 
     return result;
   }
 
 
// DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
// We need to decide if the SageBuilder API should include these sorts of functions.
SgMemberFunctionDeclaration*
SageBuilder::buildNondefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* paralist, SgScopeStatement* scope)
   {
     unsigned int memberFunctionModifiers = 0;
     return buildNondefiningMemberFunctionDeclaration (name,return_type,paralist,scope,NULL,memberFunctionModifiers,false,NULL);
   }
 
// DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
// We need to decide if the SageBuilder API should include these sorts of functions.
SgMemberFunctionDeclaration*
SageBuilder::buildDefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* paralist, SgScopeStatement* scope)
   {
     if (scope == NULL)
        {
          scope = SageBuilder::topScopeStack();
        }
 
     unsigned int memberFunctionModifiers = 0;
     SgFunctionParameterTypeList* param_type_list = buildFunctionParameterTypeList(paralist);
     SgMemberFunctionDeclaration* nondefining_decl = NULL;
     SgMemberFunctionType* member_func_type = buildMemberFunctionType(return_type,param_type_list, scope, memberFunctionModifiers);
     SgFunctionSymbol* func_symbol = scope->find_symbol_by_type_of_function<SgMemberFunctionDeclaration>(name,member_func_type,NULL,NULL);
     SgMemberFunctionSymbol* member_func_symbol = isSgMemberFunctionSymbol(func_symbol);
 
     if (member_func_symbol != NULL)
        {
          nondefining_decl = member_func_symbol->get_declaration();
        }
       else
        {
  // each defining member function decl must have a non-defining counter part now. 11/27/2012, Liao
          nondefining_decl = buildNondefiningMemberFunctionDeclaration (name, return_type, paralist, scope,NULL, memberFunctionModifiers, false, NULL);
        }
     return buildDefiningMemberFunctionDeclaration (name,return_type,paralist,scope,NULL,false,memberFunctionModifiers,nondefining_decl,NULL);
   }
 
 
// SgTemplateFunctionDeclaration* SageBuilder::buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList)
// SgTemplateFunctionDeclaration* SageBuilder::buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateArgumentPtrList* templateArgumentsList)
SgTemplateFunctionDeclaration*
SageBuilder::buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateParameterPtrList* templateParameterList)
   {
  // DQ (8/15/2013): Note that we don't need template arguments because teplate functions can't support partial specialization.
 
  // DQ (11/25/2011): Adding support for template declarations in the AST.
 
  // DQ (8/7/2013): Added support for template function overloading using template parameters.
     SgTemplateFunctionDeclaration* result = buildNondefiningFunctionDeclaration_T <SgTemplateFunctionDeclaration> (name,return_type,paralist, /* isMemberFunction = */ false, scope, decoratorList, false, NULL, templateParameterList, SgStorageModifier::e_default);
 
  // DQ (12/12/2011): Added test.
     ROSE_ASSERT(result != NULL);
     if (result->get_symbol_from_symbol_table() == NULL)
        {
          ROSE_ASSERT(result->get_firstNondefiningDeclaration() != NULL);
          ROSE_ASSERT(result != result->get_firstNondefiningDeclaration());
          ROSE_ASSERT(result->get_firstNondefiningDeclaration()->get_symbol_from_symbol_table() != NULL);
        }
 
  // DQ (2/12/2015): Added assertions earlier before calling buildDefiningFunctionDeclaration_T<>().
     ROSE_ASSERT(result->get_firstNondefiningDeclaration() != NULL);
 
     return result;
   }
 
SgTemplateFunctionDeclaration*
SageBuilder::buildDefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateFunctionDeclaration* first_nondefining_declaration)
   {
  // DQ (12/1/2011): Adding support for template declarations in the AST.
 
  // DQ (7/31/2013): Added assertions earlier before calling buildDefiningFunctionDeclaration_T<>().
     ROSE_ASSERT(first_nondefining_declaration != NULL);
     ROSE_ASSERT(first_nondefining_declaration->get_firstNondefiningDeclaration() != NULL);
     ROSE_ASSERT(first_nondefining_declaration->get_firstNondefiningDeclaration() == first_nondefining_declaration);
 
  // template <class actualFunction> actualFunction * buildDefiningFunctionDeclaration_T (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
  // SgTemplateFunctionDeclaration* result = buildDefiningFunctionDeclaration_T <SgTemplateFunctionDeclaration> (name,return_type,paralist,/* isMemberFunction = */ false, scope, decoratorList,functionConstVolatileFlags);
  // SgTemplateFunctionDeclaration* result = buildDefiningFunctionDeclaration_T <SgTemplateFunctionDeclaration> (name,return_type,paralist,/* isMemberFunction = */ false, scope, decoratorList, 0, first_nondefining_declaration);
     SgTemplateFunctionDeclaration* result = buildDefiningFunctionDeclaration_T <SgTemplateFunctionDeclaration> (name,return_type,paralist,/* isMemberFunction = */ false, scope, decoratorList, 0, first_nondefining_declaration, NULL);
 
     return result;
   }
 
SgTemplateMemberFunctionDeclaration*
SageBuilder::buildDefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefining_declaration)
   {
  // DQ (12/1/2011): Adding support for template declarations in the AST.
 
     ROSE_ASSERT(first_nondefining_declaration->get_firstNondefiningDeclaration() == first_nondefining_declaration);
 
     SgTemplateMemberFunctionDeclaration* result = buildDefiningFunctionDeclaration_T <SgTemplateMemberFunctionDeclaration> (name,return_type,paralist, /* isMemberFunction = */ true, scope, decoratorList, functionConstVolatileFlags, first_nondefining_declaration, NULL);
     ROSE_ASSERT(result != NULL);
 
     ROSE_ASSERT(result->get_definition() != NULL);
 
     return result;
   }
 
SgMemberFunctionDeclaration*
SageBuilder::buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope,
   SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList)
   {
  // This function builds either a SgMemberFunctionDeclaration (non-template; normal member function) or a SgTemplateInstantiationMemberFunctionDecl (template instantiation).
 
  // DQ (11/27/2011): Added support for instations of template member functions.
     SgMemberFunctionDeclaration * result = NULL;
 
     if (buildTemplateInstantiation == true)
        {
       // This is how we build an instantiation of a template (SgTemplateInstantiationMemberFunctionDecl).
          result = buildNondefiningFunctionDeclaration_T <SgTemplateInstantiationMemberFunctionDecl> (name,return_type,paralist, /* isMemberFunction = */ true,scope,decoratorList,functionConstVolatileFlags,templateArgumentsList,NULL, SgStorageModifier::e_default);
        }
       else
        {
       // This is a non-template instatiation (normal member function).
          result = buildNondefiningFunctionDeclaration_T <SgMemberFunctionDeclaration> (name,return_type,paralist, /* isMemberFunction = */ true,scope,decoratorList,functionConstVolatileFlags,NULL,NULL, SgStorageModifier::e_default);
        }
     ROSE_ASSERT(result != NULL);
 
  // set definingdecl for SgCtorInitializerList
     SgCtorInitializerList* ctor = result->get_CtorInitializerList();
     ROSE_ASSERT(ctor != NULL);
 
  // required in AstConsistencyTests.C:TestAstForProperlySetDefiningAndNondefiningDeclarations()
     ctor->set_definingDeclaration(ctor);
     ctor->set_firstNondefiningDeclaration(ctor);
 
  // DQ (1/4/2009): Error checking
     ROSE_ASSERT(result->get_associatedClassDeclaration() != NULL);
 
     if (result->get_associatedClassDeclaration() == NULL)
        {
          printf ("Warning, must set the SgMemberFunctionDeclaration::associatedClassDeclaration \n");
 
          ROSE_ASSERT(scope != NULL);
          SgClassDefinition* classDefinition = isSgClassDefinition(scope);
          ROSE_ASSERT(classDefinition != NULL);
          SgDeclarationStatement* associatedDeclaration = classDefinition->get_declaration();
          ROSE_ASSERT(associatedDeclaration != NULL);
          SgClassDeclaration* associatedClassDeclaration = isSgClassDeclaration(associatedDeclaration);
 
       // DQ (1/4/2009): This needs to be set, checked in AstConsistencyTests.C!
          result->set_associatedClassDeclaration(associatedClassDeclaration);
        }
 
     return result;
   }
 
 
// DQ (8/12/2013): This function needs to handle the SgTemplateParameterPtrList (since it is generating a template).
// It need not take a SgTemplateArgumentPtrList because template functions (including template member functions) can not support partial specialization.
// SgTemplateMemberFunctionDeclaration* SageBuilder::buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags)
SgTemplateMemberFunctionDeclaration*
SageBuilder::buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList)
   {
  // This function only builds template member function declarations.
 
     SgTemplateMemberFunctionDeclaration * result = buildNondefiningFunctionDeclaration_T <SgTemplateMemberFunctionDeclaration> (name,return_type,paralist, /* isMemberFunction = */ true,scope,decoratorList,functionConstVolatileFlags,NULL,templateParameterList, SgStorageModifier::e_default);
 
  // set definingdecl for SgCtorInitializerList
     ROSE_ASSERT(result != NULL);
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS
  // DQ (5/1/2012): Make sure that we don't have IR nodes marked as translformations.
     if (SourcePositionClassificationMode != e_sourcePositionTransformation)
        {
          detectTransformations_local(result);
        }
#endif
 
  // DQ (8/12/2013): Added template paremter list to call to get the function template symbol.
  // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
  // In this case these are unavailable from this point.
     SgSymbol* associatedSymbol = scope->lookup_template_member_function_symbol(name,result->get_type(),templateParameterList);
     if (associatedSymbol == NULL)
        {
          printf ("ERROR: associatedSymbol == NULL \n");
          printf ("   --- result = %p = %s \n",result,result->class_name().c_str());
          printf ("   --- scope = %p = %s \n",scope,scope->class_name().c_str());
          printf ("   --- name = %s \n",name.str());
          printf ("   --- result->get_type() = %p = %s \n",result->get_type(),result->get_type()->class_name().c_str());
          printf ("   --- result->get_type()->get_mangled() = %s \n",result->get_type()->get_mangled().str());
       }
     ROSE_ASSERT(associatedSymbol != NULL);
 
     SgCtorInitializerList * ctor = result->get_CtorInitializerList();
     ROSE_ASSERT(ctor != NULL);
  // required ty AstConsistencyTests.C:TestAstForProperlySetDefiningAndNondefiningDeclarations()
     ctor->set_definingDeclaration(ctor);
     ctor->set_firstNondefiningDeclaration(ctor);
 
  // DQ (12/11/2011): Added new test (also at the base of buildNondefiningFunctionDeclaration_T<>() function).
     ROSE_ASSERT(result->get_firstNondefiningDeclaration() != NULL);
     SgSymbol* symbol_from_first_nondefining_function = result->get_firstNondefiningDeclaration()->get_symbol_from_symbol_table();
     ROSE_ASSERT(symbol_from_first_nondefining_function != NULL);
 
  // DQ (12/11/2011): Note that this may be false when func is not the first nondefining declaration.
     if (result != result->get_firstNondefiningDeclaration())
        {
          SgSymbol* symbol_from_nondefining_function = result->get_symbol_from_symbol_table();
          ROSE_ASSERT(symbol_from_nondefining_function == NULL);
        }
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_SYMBOL_TABLE_LOOKUP
  // DQ (7/31/2013): Fixing API to use functions that now require template parameters and template specialization arguments.
  // In this case these are unavailable from this point.
     if (scope->lookup_template_member_function_symbol(name,result->get_type(),templateParameterList) == NULL)
        {
          printf ("Error: scope->lookup_template_member_function_symbol(name,result->get_type()) == NULL (investigate this) \n");
          printf ("--- function name = %s in scope = %p = %s result->get_type() = %p = %s \n",name.str(),scope,scope->class_name().c_str(),result->get_type(),result->get_type()->class_name().c_str());
          scope->get_symbol_table()->print("Error: scope->lookup_template_member_function_symbol(name,result->get_type()) == NULL (investigate this)");
        }
#endif
     ROSE_ASSERT(scope->lookup_template_member_function_symbol(name,result->get_type(),templateParameterList) != NULL);
 
#if BUILDER_MAKE_REDUNDANT_CALLS_TO_DETECT_TRANSFORAMTIONS
  // DQ (5/1/2012): Make sure that we don't have IR nodes marked as transformations.
     if (SourcePositionClassificationMode != e_sourcePositionTransformation)
        {
          detectTransformations_local(result);
        }
#endif
 
     return result;
   }
 
SgMemberFunctionDeclaration*
SageBuilder::buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefining_declaration, SgTemplateArgumentPtrList* templateArgumentsList)
   {
  // DQ (12/18/2011): Need to build a SgTemplateInstantiationMemberFunctionDecl when buildTemplateInstantiation == true
     SgMemberFunctionDeclaration * result = NULL;
     if (buildTemplateInstantiation == true)
        {
          SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunctionDecl = isSgTemplateInstantiationMemberFunctionDecl(first_nondefining_declaration);
          ROSE_ASSERT(templateInstantiationMemberFunctionDecl != NULL);
 
       // DQ (1/26/2013): Added test failing in buildDefiningFunctionDeclaration_T().
             {
               ROSE_ASSERT(templateArgumentsList != NULL);
               string nameWithoutTemplateArguments = name;
               string nameWithTemplateArguments = appendTemplateArgumentsToName(nameWithoutTemplateArguments,*templateArgumentsList);
               SgMemberFunctionType* func_type = isSgMemberFunctionType(first_nondefining_declaration->get_type());
               ROSE_ASSERT(func_type != NULL);
 
            // DQ (8/7/2013): API change due to added support for template function overloading using template parameters.
               SgSymbol* func_symbol = scope->find_symbol_by_type_of_function<SgTemplateInstantiationMemberFunctionDecl>(nameWithTemplateArguments,func_type,NULL,templateArgumentsList);
               if (func_symbol == NULL)
                  {
                    printf ("ERROR caught in SageBuilder::buildDefiningMemberFunctionDeclaration(): nameWithTemplateArguments = %s buildTemplateInstantiation = %s \n",nameWithTemplateArguments.c_str(),buildTemplateInstantiation ? "true:" : "false");
                    printf ("ERROR caught in SageBuilder::buildDefiningMemberFunctionDeclaration(): func_symbol == NULL for first_nondefining_declaration = %p = %s and func_type = %p = %s \n",
                         templateInstantiationMemberFunctionDecl,templateInstantiationMemberFunctionDecl->class_name().c_str(),func_type,func_type->class_name().c_str());
                  }
             }
 
          result = buildDefiningFunctionDeclaration_T <SgTemplateInstantiationMemberFunctionDecl> (name, return_type, paralist, /* isMemberFunction = */ true, scope, decoratorList, functionConstVolatileFlags, templateInstantiationMemberFunctionDecl, templateArgumentsList);
          ROSE_ASSERT(isSgTemplateInstantiationMemberFunctionDecl(result) != NULL);
          ROSE_ASSERT(isSgTemplateInstantiationMemberFunctionDecl(result)->get_templateName().is_null() == false);
        }
       else
        {
          ROSE_ASSERT(first_nondefining_declaration != NULL);
 
       // DQ (12/27/20134): Added these to permit testing earlier than in the buildDefiningFunctionDeclaration_T() function.
          ROSE_ASSERT(first_nondefining_declaration->get_firstNondefiningDeclaration() != NULL);
          ROSE_ASSERT(first_nondefining_declaration->get_firstNondefiningDeclaration() == first_nondefining_declaration);
 
          result = buildDefiningFunctionDeclaration_T <SgMemberFunctionDeclaration> (name,return_type,paralist,/* isMemberFunction = */ true,scope,decoratorList,functionConstVolatileFlags,first_nondefining_declaration, NULL);
        }
 
     ROSE_ASSERT(result != NULL);
 
  // set definingdecl for SgCtorInitializerList
     SgCtorInitializerList* ctor = result->get_CtorInitializerList();
     ROSE_ASSERT(ctor != NULL);
 
  // required ty AstConsistencyTests.C:TestAstForProperlySetDefiningAndNondefiningDeclarations()
     ctor->set_definingDeclaration(ctor);
     ctor->set_firstNondefiningDeclaration(ctor);
 
  // DQ (1/4/2009): Error checking
     ROSE_ASSERT(result->get_associatedClassDeclaration() != NULL);
 
     return result;
   }
 
 
//----------------- defining function declaration------------
// a template builder for all kinds of defining SgFunctionDeclaration
// handle common chores for function type, symbol, paramter etc.
 
template <class actualFunction>
actualFunction*
SageBuilder::buildDefiningFunctionDeclaration_T(const SgName & XXX_name, SgType* return_type, SgFunctionParameterList* paralist, bool isMemberFunction, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, actualFunction* first_nondefining_declaration, SgTemplateArgumentPtrList* templateArgumentsList)
   {
  // Note that the semantics of this function now differs from that of the buildDefiningClassDeclaration().
  // We want to have the non-defining declaration already exist before calling this function.
  // We could still build a higher level function that built both together.  Or we could provide two versions
  // named differently (from this one) and depricate this function...which I like much better.
 
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
     printf ("WARNING: This function for building defining function declarations has different semantics from that of the function to build defining class declarations. \n");
#endif
 
     ASSERT_not_null(first_nondefining_declaration);
     ASSERT_require(first_nondefining_declaration->get_firstNondefiningDeclaration() == first_nondefining_declaration);
 
     if (scope == nullptr)
        {
          scope = SageBuilder::topScopeStack();
        }
 
     ASSERT_require(XXX_name.is_null() == false);
     ASSERT_not_null(scope);
     ASSERT_not_null(return_type);
 
     SgName nameWithoutTemplateArguments = XXX_name;
     SgName nameWithTemplateArguments    = nameWithoutTemplateArguments;
 
     bool buildTemplateInstantiation = ((VariantT)actualFunction::static_variant == V_SgTemplateInstantiationFunctionDecl || (VariantT)actualFunction::static_variant == V_SgTemplateInstantiationMemberFunctionDecl);
 
  // DQ (8/7/2013): Added support for template declarations.
     bool buildTemplateDeclaration   = ((VariantT)actualFunction::static_variant == V_SgTemplateFunctionDeclaration || (VariantT)actualFunction::static_variant == V_SgTemplateMemberFunctionDeclaration);
 
  // DQ (8/11/2013): Check that the template argument lists are consistant.  The templateArgumentsList can then be considered redundant if this works.
     if (buildTemplateInstantiation == true)
        {
          ASSERT_not_null(templateArgumentsList);
 
          SgTemplateArgumentPtrList & templateArgumentsList_from_first_nondefining_declaration = (isMemberFunction == false) ?
               isSgTemplateInstantiationFunctionDecl(first_nondefining_declaration)->get_templateArguments() :
               isSgTemplateInstantiationMemberFunctionDecl(first_nondefining_declaration)->get_templateArguments();
 
          ASSERT_not_null(templateArgumentsList);
          bool templateArgumentListsAreEquivalent = SageInterface::templateArgumentListEquivalence(*templateArgumentsList, templateArgumentsList_from_first_nondefining_declaration);
          ASSERT_require(templateArgumentListsAreEquivalent == true);
        }
 
     SgTemplateParameterPtrList* templateParameterList = nullptr;
     if (buildTemplateDeclaration == true)
        {
       // DQ (8/11/2013): Since this is not passed in so we can access it but not assert its equivalence with a redundant input parameter.
          templateParameterList = (isMemberFunction == false) ?
               &(isSgTemplateFunctionDeclaration(first_nondefining_declaration)->get_templateParameters()) :
               &(isSgTemplateMemberFunctionDeclaration(first_nondefining_declaration)->get_templateParameters());
 
          ASSERT_require(templateArgumentsList == nullptr);
          ASSERT_not_null(templateParameterList);
        }
 
     if (buildTemplateInstantiation == true)
        {
          ASSERT_not_null(templateArgumentsList);
          nameWithTemplateArguments = appendTemplateArgumentsToName(nameWithoutTemplateArguments,*templateArgumentsList);
 
          if (nameWithTemplateArguments == "insert < __normal_iterator< SgInitializedName ** , __type  >  > ")
             {
               printf ("In buildDefiningFunctionDeclaration_T(): Found function nameWithTemplateArguments = %s \n",nameWithTemplateArguments.str());
             }
        }
 
     ASSERT_require(nameWithoutTemplateArguments.is_null() == false);
     ASSERT_require(nameWithTemplateArguments.is_null() == false);
     ASSERT_not_null(paralist);
 
     if (SageInterface::language_may_contain_nondeclarations_in_scope() == false)
        {
           ASSERT_require(scope->containsOnlyDeclarations());
        }
 
  // build function type, manage function type symbol internally
     actualFunction* defining_func = nullptr;
     SgFunctionType* func_type = nullptr;
 
  // DQ (5/11/2012): Enforce this so that we can avoid building the function type (be reusing the function type of the first non-defining declaration).
  // This is a special problem for templates because the function parameters will evaluate different for different builds of the same template.
  // This is a problem for test2012_74.C (and a dozen other test codes that make use of STL).
     ASSERT_not_null(first_nondefining_declaration);
 
  // DQ (7/27/2012): Note that the input name should not have template argument syntax.
  // I think this could still fail for a function with a name such as "X<Y>"  strange converstion operators.
  // DQ (7/27/2012): There are reasons why this can fail: e.g. for functions with names such as:
  // "operator std::auto_ptr_ref<_Tp1>" which is a user defined conversion operator to one class from another.
 
  // DQ (5/12/2012): Use the newly added parameter to get the exact SgFunctionType used to build the symbol.
  // This should make the template handling more robust since we were sometimes using types that had different
  // levels of template instantiation between the non-definng and defining function declarations and this
  // caused symbols build to support the non-defining declaration to not be found when we searched for them
  // using the function type built for the defining declaration.  We want the function types for all defining
  // and non-defining declarations to be identical.  This define also means that we don't have to build a
  // SgFunctionType just to look up a symbol in the symbol table (which was always silly).  However, only
  // the defining function declaration can use the existing function type because it is required that a
  // non-defining declaration exist prior to the construction of the defining declaration (built by this
  // function).
     func_type = first_nondefining_declaration->get_type();
     ASSERT_not_null(func_type);
 
  // Make sure these are the same (this will fail until we generate the func_type directly from first_nondefining_declaration).
     ASSERT_require(func_type == first_nondefining_declaration->get_type());
 
     SgDeclarationStatement* firstNondefiningFunctionDeclaration = nullptr;
 
  // symbol table and non-defining
     SgSymbol* func_symbol = scope->find_symbol_by_type_of_function<actualFunction>(nameWithTemplateArguments,func_type,templateParameterList,templateArgumentsList);
 
  // DQ (1/26/2013): This fails for ROSE compiling ROSE.
     ASSERT_not_null(func_symbol);
 
     if (func_symbol == nullptr)
        {
       // DQ (12/2/2011): After discussion with Liao, we think this should be an error.
       // The defining declaration requires that the associated non-defining declaration should already exist.
       // If required, a higher level build function could build both of these and connect them as required.
          printf ("Error: building a defining declaration requires that the associated non-defining declaration already exists and it's symbol found the the same scope's symbol table! \n");
          ROSE_ABORT();
        }
       else
        {
       // We will now build a reference to the non-defining declaration found in the symbol.
 
       // defining declaration after nondefining declaration
       // reuse function type, function symbol
 
       // Cong (10/25/2010): Make sure in this situation there is no defining declaration for this symbol.
 
          SgFunctionSymbol* temp_function_sym = isSgFunctionSymbol(func_symbol);
          SgTemplateSymbol* temp_template_sym = isSgTemplateSymbol(func_symbol);
          if (temp_function_sym != nullptr)
             {
               func_type = temp_function_sym->get_declaration()->get_type();
               firstNondefiningFunctionDeclaration = temp_function_sym->get_declaration()->get_firstNondefiningDeclaration();
             }
            else
             {
            // There is no type for a template function declaration.
               ASSERT_not_null(temp_template_sym);
               firstNondefiningFunctionDeclaration = temp_template_sym->get_declaration()->get_firstNondefiningDeclaration();
             }
          ASSERT_not_null(firstNondefiningFunctionDeclaration);
        }
 
     defining_func = new actualFunction(nameWithTemplateArguments,func_type,nullptr);
     ASSERT_not_null(defining_func);
 
     ASSERT_not_null(firstNondefiningFunctionDeclaration);
     defining_func->set_firstNondefiningDeclaration(firstNondefiningFunctionDeclaration);
 
  // fix up defining declarations before current statement
     firstNondefiningFunctionDeclaration->set_definingDeclaration(defining_func);
 
  // Handle decorators (Python specific)
     if (decoratorList != nullptr)
        {
          defining_func->set_decoratorList(decoratorList);
          decoratorList->set_parent(defining_func);
        }
 
  // definingDeclaration
     defining_func->set_definingDeclaration(defining_func);
 
  // function body and definition are created before setting argument list
     SgBasicBlock * func_body = new SgBasicBlock();
     ASSERT_not_null(func_body);
 
     SgFunctionDefinition* func_def = nullptr;
     SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(defining_func);
 
  // Build either a definition for a template or non-template function definition.
     if (templateFunctionDeclaration == nullptr)
        {
          SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(defining_func);
          ASSERT_not_null(functionDeclaration);
          func_def = new SgFunctionDefinition(functionDeclaration,func_body);
        }
       else
        {
          ASSERT_not_null(templateFunctionDeclaration);
          func_def = new SgTemplateFunctionDefinition(templateFunctionDeclaration,func_body);
        }
     ASSERT_not_null(func_def);
 
   if (SageInterface::is_language_case_insensitive())
        {
          func_def->setCaseInsensitive(true);
          func_body->setCaseInsensitive(true);
        }
 
     func_def->set_parent(defining_func);
     func_def->set_body(func_body);
     func_body->set_parent(func_def);
 
  // parameter list,
  // TODO consider the difference between C++ and Fortran
     setParameterList(defining_func,paralist);
  // fixup the scope and symbol of arguments,
     for (SgInitializedName* i_name : paralist->get_args())
        {
          i_name->set_scope(func_def);
 
          SgVariableSymbol* variableSymbol = new SgVariableSymbol(i_name);
          ASSERT_not_null(variableSymbol);
          func_def->insert_symbol(i_name->get_name(), variableSymbol);
 
       // For variable length array types in the function parameter list
          SgArrayType* arrayType = isSgArrayType(i_name->get_type());
          if (arrayType != nullptr)
             {
            // Check if this is a VLA array type, if so look for the index expressions and check
            // if we need to add asociated symbols to the current function definition scope.
               SgExpression* indexExpression = arrayType->get_index();
 
               if (indexExpression != nullptr)
                  {
                 // DQ (2/14/2016): Handle the case of an expression tree with any number of variable references.
                 // Get the list of SgVarRef IR nodes and process each one as above.
                    vector<SgVarRefExp* > varRefList;
                    collectVarRefs(indexExpression,varRefList);
 
                    for (size_t i = 0; i < varRefList.size(); i++)
                       {
                      // Process each index subtree's SgVarRefExp.
                         SgVariableSymbol* dimension_variableSymbol = varRefList[i]->get_symbol();
                         ASSERT_not_null(dimension_variableSymbol);
                         ASSERT_require(dimension_variableSymbol != variableSymbol);
 
                      // The symbol from the referenced variable for the array dimension expression shuld already by in the function definition's symbol table.
                         SgSymbol* symbolFromLookup = func_def->lookup_symbol(dimension_variableSymbol->get_name());
                         if (symbolFromLookup != nullptr)
                            {
                              SgVariableSymbol* variableSymbolFromLookup = isSgVariableSymbol(symbolFromLookup);
                              ASSERT_not_null(variableSymbolFromLookup);
 
                              varRefList[i]->set_symbol(variableSymbolFromLookup);
                              ASSERT_require(dimension_variableSymbol != variableSymbol);
                            }
                           else
                            {
                           // This is not a reference to a variable from the current function's paramter lists, so we can ignore processing it within the VLA handling.
                            }
                       }
                  }
             }
        }
 
     defining_func->set_parent(scope);
     defining_func->set_scope(scope);
 
     ASSERT_not_null(defining_func->get_scope());
 
     checkThatNoTemplateInstantiationIsDeclaredInTemplateDefinitionScope(defining_func,scope);
 
  // set File_Info as transformation generated
     setSourcePositionAtRootAndAllChildren(defining_func);
 
  // Enforce that the return type matches the specification to build a member function.
     if (isMemberFunction == true)
        {
          ASSERT_not_null(isSgMemberFunctionDeclaration(defining_func));
        }
 
  // DQ (2/11/2012): If this is a template instantiation then we have to set the template name (seperate from the name of the function which can include template parameters)).
     setTemplateNameInTemplateInstantiations(defining_func,nameWithoutTemplateArguments);
 
  // DQ (9/16/2012): Setup up the template arguments and the parents of the template arguments.
     if (buildTemplateInstantiation == true)
        {
          setTemplateArgumentsInDeclaration(defining_func,templateArgumentsList);
        }
 
  // DQ (8/13/2013): Added code to set the template parameters in the defining declaration (if it is a template declaration).
     if (buildTemplateDeclaration == true)
        {
          setTemplateParametersInDeclaration(defining_func,templateParameterList);
 
       // DQ (8/13/2013): Adding test of template parameter lists.
          SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(defining_func);
          ROSE_ASSERT(templateFunctionDeclaration == nullptr || (templateParameterList != nullptr && templateParameterList->size() == templateFunctionDeclaration->get_templateParameters().size()));
          SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = isSgTemplateMemberFunctionDeclaration(defining_func);
          ROSE_ASSERT(templateMemberFunctionDeclaration == nullptr || (templateParameterList != nullptr && templateParameterList->size() == templateMemberFunctionDeclaration->get_templateParameters().size()));
        }
 
  // DQ (12/12/2012): Force the two different ways that this can be set to match (we want consistancy).
     if (functionConstVolatileFlags & SgMemberFunctionType::e_restrict)
        {
          defining_func->get_declarationModifier().get_typeModifier().setRestrict();
        }
 
  // DQ (4/16/2015): This is replaced with a better implementation.
  // DQ (4/15/2015): We should reset the isModified flags as part of the transforamtion
  // because we have added statements explicitly marked as transformations.
  // checkIsModifiedFlag(defining_func);
     unsetNodesMarkedAsModified(defining_func);
 
     return defining_func;
   }
 
void
SageBuilder::setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, const SgName & name )
   {
  // DQ (2/11/2012): If this is a template instantiation then we have to set the template name (seperate from the name of the function which can include template parameters)).
 
     SgTemplateInstantiationFunctionDecl*       templateInstantiationFunctionDecl       = isSgTemplateInstantiationFunctionDecl(func);
     SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunctionDecl = isSgTemplateInstantiationMemberFunctionDecl(func);
     bool isTemplateInstantition = (templateInstantiationFunctionDecl != NULL) || (templateInstantiationMemberFunctionDecl != NULL);
     if (isTemplateInstantition == true)
        {
       // If this is a template instantiation then we need to take care of a few more issues.
 
          SgName templateNameWithoutArguments = name;
 
       // DQ (7/27/2012): New semantics is that we want to have the input name be without template arguments and
       // we will add the template arguments instead of trying to remove then (which was problematic for examples
       // such as "X<Y<Z>> operator X&()" and "X<Y<Z>> operator>()".
 
          bool isMemberFunction = (templateInstantiationMemberFunctionDecl != NULL);
          if (isMemberFunction == true)
             {
               ROSE_ASSERT(templateInstantiationMemberFunctionDecl != NULL);
               ROSE_ASSERT(templateInstantiationFunctionDecl == NULL);
 
               if (templateInstantiationMemberFunctionDecl->get_templateName().is_null() == true)
                  {
                 // Set the template name for the member function template instantiation.
                 // templateInstantiationMemberFunctionDecl->set_templateName(name);
                    templateInstantiationMemberFunctionDecl->set_templateName(templateNameWithoutArguments);
 
                 // DQ (5/31/2012): Find locations where this is set and include template syntax.
                  }
               ROSE_ASSERT(templateInstantiationMemberFunctionDecl->get_templateName().is_null() == false);
             }
            else
             {
               ROSE_ASSERT(templateInstantiationFunctionDecl != NULL);
               ROSE_ASSERT(templateInstantiationMemberFunctionDecl == NULL);
 
               if (templateInstantiationFunctionDecl->get_templateName().is_null() == true)
                  {
                 // Set the template name for the function template instantiation.
                 // templateInstantiationFunctionDecl->set_templateName(name);
                    templateInstantiationFunctionDecl->set_templateName(templateNameWithoutArguments);
 
                 // DQ (5/31/2012): Find locations where this is set and include template syntax.
                    ROSE_ASSERT(hasTemplateSyntax(templateNameWithoutArguments) == false);
                  }
               ROSE_ASSERT(templateInstantiationFunctionDecl->get_templateName().is_null() == false);
             }
        }
   }
 
SgFunctionDeclaration*
SageBuilder::buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* paralist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgFunctionDeclaration* first_nondefining_declaration, SgTemplateArgumentPtrList* templateArgumentsList)
   {
  // DQ (2/10/2012): Fixed to build either SgTemplateInstantiationFunctionDecl or SgFunctionDeclaration.
     SgFunctionDeclaration* func = NULL;
     if (buildTemplateInstantiation == true)
        {
          SgTemplateInstantiationFunctionDecl* templateInstantiationFunctionDecl = isSgTemplateInstantiationFunctionDecl(first_nondefining_declaration);
 
          ROSE_ASSERT(first_nondefining_declaration != NULL);
 
          func = buildDefiningFunctionDeclaration_T<SgTemplateInstantiationFunctionDecl>(name,return_type,paralist,/* isMemberFunction = */ false,scope,decoratorList,0,templateInstantiationFunctionDecl, templateArgumentsList);
 
          ROSE_ASSERT(isSgTemplateInstantiationFunctionDecl(func) != NULL);
          ROSE_ASSERT(isSgTemplateInstantiationFunctionDecl(func)->get_templateName().is_null() == false);
        }
       else
        {
          ROSE_ASSERT(first_nondefining_declaration != NULL);
 
          func = buildDefiningFunctionDeclaration_T<SgFunctionDeclaration>(name,return_type,paralist,/* isMemberFunction = */ false,scope,decoratorList,0,first_nondefining_declaration, NULL);
 
          ROSE_ASSERT(isSgFunctionDeclaration(func) != NULL);
        }
 
     return func;
   }
 
 
// DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
// We need to decide if the SageBuilder API should include these sorts of functions.
SgFunctionDeclaration*
SageBuilder::buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope)
   {
  // DQ (11/12/2012): Note that this function is not used in the AST construction in the EDG/ROSE interface.
 
  // DQ (8/23/2013): Added assertions.
     ROSE_ASSERT(return_type != NULL);
     ROSE_ASSERT(parameter_list != NULL);
 
  // DQ (8/23/2013): We need to provide the buildDefiningFunctionDeclaration() function with a pointer to the first non-defining declaration.
  // So we need to find it, and if it does not exist we need to build one so that we have a simple API for building defining declarations.
  // DQ (11/12/2012): Building a defining declaration from scratch now requires a non-defining declaration to exist.
  // SgFunctionDeclaration* nondefininfDeclaration = buildNondefiningFunctionDeclaration(name,return_type,parameter_list,scope,NULL);
 
     if (scope == NULL)
        {
          scope = SageBuilder::topScopeStack();
        }
 
     SgFunctionDeclaration* nondefiningDeclaration = NULL;
 
     SgFunctionType* func_type = buildFunctionType(return_type,parameter_list);
     SgFunctionSymbol* func_symbol = scope->find_symbol_by_type_of_function<SgFunctionDeclaration>(name,func_type,NULL,NULL);
     if (func_symbol != NULL)
        {
          nondefiningDeclaration = func_symbol->get_declaration();
        }
       else
        {
          nondefiningDeclaration = buildNondefiningFunctionDeclaration(name,return_type,parameter_list,scope,NULL);
        }
 
     ROSE_ASSERT(nondefiningDeclaration != NULL);
     ROSE_ASSERT(nondefiningDeclaration->get_firstNondefiningDeclaration() != NULL);
     ROSE_ASSERT(nondefiningDeclaration->get_firstNondefiningDeclaration() == nondefiningDeclaration);
 
     return buildDefiningFunctionDeclaration (name,return_type,parameter_list,scope,NULL,false,nondefiningDeclaration,NULL);
   }
 
// Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently [Rasmussen 9/24/2020]
SgProcedureHeaderStatement* SageBuilder::
buildNondefiningProcedureHeaderStatement(const SgName & name, SgType* return_type, SgFunctionParameterList* param_list,
                                         SgProcedureHeaderStatement::subprogram_kind_enum kind, SgScopeStatement* scope)
  {
    ASSERT_not_null(return_type);
    ASSERT_not_null(param_list);
 
    SgProcedureHeaderStatement* nondef_decl = nullptr;
 
    if (scope == nullptr) {
        scope = SageBuilder::topScopeStack();
    }
 
  // A new nondefing declaration is needed even if the function symbol already exists. The function symbol
  // should always contain the _first_ nondefining declaration (even though this may not be the first one).
    nondef_decl = buildNondefiningFunctionDeclaration_T <SgProcedureHeaderStatement>
                       ( name, return_type, param_list, /*isMemberFunction*/false, scope, /*decoratorList*/nullptr,
                        /*functionConstVolatileFlags*/0, nullptr, nullptr, SgStorageModifier::e_default );
 
    ASSERT_not_null(isSgProcedureHeaderStatement(nondef_decl));
    ASSERT_not_null(nondef_decl->get_firstNondefiningDeclaration());
 
    nondef_decl->set_subprogram_kind(kind);
 
    return nondef_decl;
  }
 
SgProcedureHeaderStatement* SageBuilder::
buildProcedureHeaderStatement(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list,
                              SgProcedureHeaderStatement::subprogram_kind_enum kind, SgScopeStatement* scope)
   {
     ASSERT_not_null(return_type);
     ASSERT_not_null(parameter_list);
 
     SgFunctionDeclaration* nondef_decl = nullptr;
 
     if (scope == nullptr) {
         scope = SageBuilder::topScopeStack();
     }
 
     SgFunctionType* func_type = buildFunctionType(return_type,parameter_list);
     SgFunctionSymbol* func_symbol = scope->find_symbol_by_type_of_function<SgProcedureHeaderStatement>(name,func_type,nullptr,nullptr);
     if (func_symbol == nullptr)
        {
          nondef_decl = buildNondefiningFunctionDeclaration_T <SgProcedureHeaderStatement>
                           ( name, return_type, parameter_list, /*isMemberFunction*/false, scope,
                            /*decoratorList*/nullptr, /*functionConstVolatileFlags*/0, nullptr, nullptr, SgStorageModifier::e_default);
        }
       else
        {
          nondef_decl = func_symbol->get_declaration();
        }
 
     SgProcedureHeaderStatement* proc_header_stmt = isSgProcedureHeaderStatement(nondef_decl);
     ASSERT_not_null(proc_header_stmt);
     ASSERT_require(nondef_decl->get_firstNondefiningDeclaration() == nondef_decl);
 
     return buildProcedureHeaderStatement(name.str(), return_type, parameter_list, kind, scope, proc_header_stmt);
   }
 
 
SgProcedureHeaderStatement*
SageBuilder::buildProcedureHeaderStatement(const char* name, SgType* returnType, SgFunctionParameterList* params,
                                           SgProcedureHeaderStatement::subprogram_kind_enum kind, SgScopeStatement* scope/*=nullptr*/,
                                           SgProcedureHeaderStatement* firstNondefDecl)
{
  ASSERT_not_null(firstNondefDecl);
  SgProcedureHeaderStatement* func{nullptr};
 
  if (kind == SgProcedureHeaderStatement::e_subroutine_subprogram_kind ||
      kind == SgProcedureHeaderStatement::e_block_data_subprogram_kind) {
    ASSERT_require(returnType == buildVoidType());
  }
  else if (kind != SgProcedureHeaderStatement::e_function_subprogram_kind) {
    mlog[ERROR] << "unhandled subprogram kind for Fortran (or Jovial) function declaration:"
                << kind << endl;
    ROSE_ABORT();
  }
 
  func = buildDefiningFunctionDeclaration_T<SgProcedureHeaderStatement>(SgName(name), returnType, params, /*isMemberFunction =*/false,
                                                                        scope, nullptr, 0U, firstNondefDecl, nullptr);
  ASSERT_not_null(func);
  func->set_subprogram_kind(kind);
 
  return func;
}
 
//------------------build value expressions -------------------
//-------------------------------------------------------------
SgBoolValExp* SageBuilder::buildBoolValExp(int value /*=0*/)
{
  //TODO does valueString matter here?
  SgBoolValExp* boolValue= new SgBoolValExp(value);
  ROSE_ASSERT(boolValue);
  setOneSourcePositionForTransformation(boolValue);
  return boolValue;
}
SgBoolValExp* SageBuilder::buildBoolValExp(bool value /*=0*/)
{
  return buildBoolValExp(int(value));
}
SgBoolValExp* SageBuilder::buildBoolValExp_nfi(int value)
{
  SgBoolValExp* boolValue= new SgBoolValExp(value);
  ROSE_ASSERT(boolValue);
  setOneSourcePositionNull(boolValue);
  return boolValue;
}
 
SgNullptrValExp* SageBuilder::buildNullptrValExp()
   {
     SgNullptrValExp* nullptrValue = new SgNullptrValExp();
     ROSE_ASSERT(nullptrValue);
     setOneSourcePositionForTransformation(nullptrValue);
     return nullptrValue;
   }
 
SgNullptrValExp* SageBuilder::buildNullptrValExp_nfi()
   {
     SgNullptrValExp* nullptrValue = new SgNullptrValExp();
     ROSE_ASSERT(nullptrValue);
     setOneSourcePositionNull(nullptrValue);
     return nullptrValue;
   }
 
SgVoidVal* SageBuilder::buildVoidVal()
   {
     SgVoidVal* voidValue = new SgVoidVal();
     ROSE_ASSERT(voidValue);
     setOneSourcePositionForTransformation(voidValue);
     return voidValue;
   }
 
SgVoidVal* SageBuilder::buildVoidVal_nfi()
   {
     SgVoidVal* voidValue = new SgVoidVal();
     ROSE_ASSERT(voidValue);
     setOneSourcePositionNull(voidValue);
     return voidValue;
   }
 
SgCharVal* SageBuilder::buildCharVal(char value /*= 0*/)
{
  SgCharVal* result = new SgCharVal(value, "");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgCharVal* SageBuilder::buildCharVal_nfi(char value, const string& str)
{
  SgCharVal* result = new SgCharVal(value, str);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgWcharVal* SageBuilder::buildWcharVal(wchar_t value /*= 0*/)
{
  SgWcharVal* result = new SgWcharVal(value, "");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgWcharVal* SageBuilder::buildWcharVal_nfi(wchar_t value, const string& str)
{
  SgWcharVal* result = new SgWcharVal(value, str);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
// DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
SgChar16Val* SageBuilder::buildChar16Val(unsigned short value /*= 0*/)
{
  SgChar16Val* result = new SgChar16Val(value, "");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgChar16Val* SageBuilder::buildChar16Val_nfi(unsigned short value, const string& str)
{
  SgChar16Val* result = new SgChar16Val(value, str);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
// DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
SgChar32Val* SageBuilder::buildChar32Val(unsigned int value /*= 0*/)
{
  SgChar32Val* result = new SgChar32Val(value, "");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgChar32Val* SageBuilder::buildChar32Val_nfi(unsigned int value, const string& str)
{
  SgChar32Val* result = new SgChar32Val(value, str);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
 
SgComplexVal* SageBuilder::buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value)
{
  SgComplexVal* result = new SgComplexVal(real_value,imaginary_value,imaginary_value->get_type(),"");
  ROSE_ASSERT(result);
 
// DQ (12/31/2008): set and test the parents
  if (real_value != NULL)
       real_value->set_parent(result);
 
  if (imaginary_value != NULL)
       imaginary_value->set_parent(result);
 
  ROSE_ASSERT(real_value == NULL || real_value->get_parent() != NULL);
  ROSE_ASSERT(imaginary_value == NULL || imaginary_value->get_parent() != NULL);
 
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgComplexVal* SageBuilder::buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, const std::string& str)
{
  ROSE_ASSERT(imaginary_value != NULL);
  SgComplexVal* result = new SgComplexVal(real_value,imaginary_value,imaginary_value->get_type(),str);
  ROSE_ASSERT(result != NULL);
 
// DQ (12/31/2008): set and test the parents
  if (real_value != NULL)
       real_value->set_parent(result);
 
  if (imaginary_value != NULL)
       imaginary_value->set_parent(result);
 
  ROSE_ASSERT(real_value == NULL || real_value->get_parent() != NULL);
  ROSE_ASSERT(imaginary_value == NULL || imaginary_value->get_parent() != NULL);
 
  setOneSourcePositionNull(result);
  return result;
}
 
SgComplexVal* SageBuilder::buildImaginaryVal(long double imaginary_value /*= 0.0*/ )
{
  SgComplexVal* result = new SgComplexVal(NULL,buildLongDoubleVal(imaginary_value),SgTypeLongDouble::createType(),"");
  ROSE_ASSERT(result);
 
// DQ (12/31/2008): set and test the parents
  result->get_imaginary_value()->set_parent(result);
  ROSE_ASSERT(result->get_imaginary_value()->get_parent() != NULL);
 
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgComplexVal* SageBuilder::buildImaginaryVal(SgValueExp* imaginary_value)
{
  ROSE_ASSERT(imaginary_value != NULL);
 
  SgComplexVal* result = new SgComplexVal(NULL,imaginary_value,imaginary_value->get_type(),"");
  ROSE_ASSERT(result);
 
// DQ (12/31/2008): set and test the parents
  imaginary_value->set_parent(result);
  ROSE_ASSERT(imaginary_value->get_parent() != NULL);
 
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgComplexVal* SageBuilder::buildImaginaryVal_nfi(SgValueExp* imaginary_value, const std::string& str)
{
  ROSE_ASSERT(imaginary_value != NULL);
 
  SgComplexVal* result = new SgComplexVal(NULL,imaginary_value,imaginary_value->get_type(),str);
  imaginary_value->set_parent(result);
  ROSE_ASSERT(result);
 
// DQ (12/31/2008): set and test the parents
  ROSE_ASSERT(imaginary_value->get_parent() != NULL);
 
  setOneSourcePositionNull(result);
  return result;
}
 
SgDoubleVal* SageBuilder::buildDoubleVal(double t)
{
  SgDoubleVal* value = new SgDoubleVal(t,"");
  ROSE_ASSERT(value);
  setOneSourcePositionForTransformation(value);
  return value;
}
 
SgDoubleVal* SageBuilder::buildDoubleVal_nfi(double t, const string& str)
{
  SgDoubleVal* value = new SgDoubleVal(t,str);
  ROSE_ASSERT(value);
  setOneSourcePositionNull(value);
  return value;
}
 
SgFloatVal* SageBuilder::buildFloatVal(float value /*= 0.0*/)
{
  SgFloatVal* result = new SgFloatVal(value,"");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgFloatVal* SageBuilder::buildFloatVal_nfi(float value)
{
  SgFloatVal* result = new SgFloatVal(value,"");
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgFloatVal* SageBuilder::buildFloatVal_nfi(float value, const string& str)
{
  SgFloatVal* result = new SgFloatVal(value,str);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgFloatVal* SageBuilder::buildFloatVal_nfi(const string& str)
{
  // C++11 please [CR 2020.02.25]
  // return buildFloatVal_nfi(std::stof(str), str);
     return buildFloatVal_nfi(atof(str.c_str()), str);
}
 
SgIntVal* SageBuilder::buildIntVal(int value)
   {
     SgIntVal* intValue= new SgIntVal(value,"");
     ASSERT_not_null(intValue);
     setOneSourcePositionForTransformation(intValue);
     return intValue;
   }
 
SgIntVal* SageBuilder::buildIntValHex(int value)
   {
     SgIntVal* intValue= new SgIntVal(value, (value >= 0 ? StringUtility::intToHex((unsigned int)value) : "-" + StringUtility::intToHex((unsigned int)(-value))));
     ASSERT_not_null(intValue);
     setOneSourcePositionForTransformation(intValue);
     return intValue;
   }
 
SgIntVal* SageBuilder::buildIntVal_nfi(int value)
   {
     SgIntVal* intValue = new SgIntVal(value,"");
     ASSERT_not_null(intValue);
     setOneSourcePositionNull(intValue);
     return intValue;
   }
 
SgIntVal* SageBuilder::buildIntVal_nfi(int value, const string& str)
   {
     SgIntVal* intValue = new SgIntVal(value,str);
     ASSERT_not_null(intValue);
     setOneSourcePositionNull(intValue);
     return intValue;
   }
 
SgIntVal* SageBuilder::buildIntVal_nfi(const string& str)
   {
     return buildIntVal_nfi(std::stoi(str), str);
   }
 
SgLongIntVal* SageBuilder::buildLongIntVal(long value)
{
  SgLongIntVal* intValue= new SgLongIntVal(value,"");
  ASSERT_not_null(intValue);
  setOneSourcePositionForTransformation(intValue);
  return intValue;
}
 
SgLongIntVal* SageBuilder::buildLongIntVal_nfi(long value, const string& str)
{
  SgLongIntVal* intValue= new SgLongIntVal(value,str);
  ASSERT_not_null(intValue);
  setOneSourcePositionNull(intValue);
  return intValue;
}
 
SgLongLongIntVal* SageBuilder::buildLongLongIntVal(long long value)
{
  SgLongLongIntVal* intValue= new SgLongLongIntVal(value,"");
  ASSERT_not_null(intValue);
  setOneSourcePositionForTransformation(intValue);
  return intValue;
}
 
SgLongLongIntVal* SageBuilder::buildLongLongIntVal_nfi(long long value, const string& str)
{
  SgLongLongIntVal* intValue= new SgLongLongIntVal(value,str);
  ASSERT_not_null(intValue);
  setOneSourcePositionNull(intValue);
  return intValue;
}
 
SgEnumVal* SageBuilder::buildEnumVal(long long int value, SgEnumDeclaration* decl, SgName name)
   {
     SgEnumVal* enumVal= new SgEnumVal(value,decl,name);
     ASSERT_not_null(enumVal);
     setOneSourcePositionForTransformation(enumVal);
     return enumVal;
   }
 
 
SgEnumVal* SageBuilder::buildEnumVal_nfi(long long int value, SgEnumDeclaration* decl, SgName name)
   {
     SgEnumVal* enumVal= new SgEnumVal(value,decl,name);
     ASSERT_not_null(enumVal);
     setOneSourcePositionNull(enumVal);
     return enumVal;
   }
 
SgEnumVal* SageBuilder::buildEnumVal(SgEnumFieldSymbol * sym) {
  SgInitializedName * init_name = sym->get_declaration();
  ROSE_ASSERT(init_name != NULL);
  SgAssignInitializer * assign_init = isSgAssignInitializer(init_name->get_initptr());
  ROSE_ASSERT(assign_init != NULL);
  SgEnumVal * enum_val = isSgEnumVal(assign_init->get_operand_i());
  ROSE_ASSERT(enum_val != NULL);
  enum_val = isSgEnumVal(SageInterface::copyExpression(enum_val));
  return enum_val;
}
 
SgLongDoubleVal* SageBuilder::buildLongDoubleVal(long double value /*= 0.0*/)
{
  SgLongDoubleVal* result = new SgLongDoubleVal(value,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgLongDoubleVal* SageBuilder::buildLongDoubleVal_nfi(long double value, const string& str)
{
  SgLongDoubleVal* result = new SgLongDoubleVal(value,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgFloat80Val* SageBuilder::buildFloat80Val(long double value /*= 0.0*/)
{
  SgFloat80Val* result = new SgFloat80Val(value,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgFloat80Val* SageBuilder::buildFloat80Val_nfi(long double value, const string& str)
{
  SgFloat80Val* result = new SgFloat80Val(value,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgFloat128Val* SageBuilder::buildFloat128Val(long double value /*= 0.0*/)
{
  SgFloat128Val* result = new SgFloat128Val(value,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgFloat128Val* SageBuilder::buildFloat128Val_nfi(long double value, const string& str)
{
  SgFloat128Val* result = new SgFloat128Val(value,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgStringVal* SageBuilder::buildStringVal(std::string value /*=""*/)
{
  SgStringVal* result = new SgStringVal(value);
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgStringVal* SageBuilder::buildStringVal_nfi(std::string value)
{
  SgStringVal* result = new SgStringVal(value);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgUnsignedCharVal* SageBuilder::buildUnsignedCharVal(unsigned char v)
{
  SgUnsignedCharVal* result = new SgUnsignedCharVal(v,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedCharVal* SageBuilder::buildUnsignedCharValHex(unsigned char v)
{
  SgUnsignedCharVal* result = new SgUnsignedCharVal(v,StringUtility::intToHex(v));
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedCharVal* SageBuilder::buildUnsignedCharVal_nfi(unsigned char v, const string& str)
{
  SgUnsignedCharVal* result = new SgUnsignedCharVal(v,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgShortVal* SageBuilder::buildShortVal(short v)
{
  SgShortVal* result = new SgShortVal(v,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgShortVal* SageBuilder::buildShortValHex(short v)
{
  SgShortVal* result = new SgShortVal(v, (v >= 0 ? StringUtility::intToHex((unsigned int)v) : "-" + StringUtility::intToHex((unsigned int)(-v))));
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgShortVal* SageBuilder::buildShortVal_nfi(short v, const string& str)
{
  SgShortVal* result = new SgShortVal(v,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgUnsignedShortVal* SageBuilder::buildUnsignedShortVal(unsigned short v)
{
  SgUnsignedShortVal* result = new SgUnsignedShortVal(v,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedShortVal* SageBuilder::buildUnsignedShortValHex(unsigned short v)
{
  SgUnsignedShortVal* result = new SgUnsignedShortVal(v,StringUtility::intToHex(v));
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedShortVal* SageBuilder::buildUnsignedShortVal_nfi(unsigned short v, const string& str)
{
  SgUnsignedShortVal* result = new SgUnsignedShortVal(v,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgUnsignedIntVal* SageBuilder::buildUnsignedIntVal(unsigned int v)
{
  SgUnsignedIntVal* result = new SgUnsignedIntVal(v,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedIntVal* SageBuilder::buildUnsignedIntValHex(unsigned int v)
{
  SgUnsignedIntVal* result = new SgUnsignedIntVal(v,StringUtility::intToHex(v) + "U");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedIntVal* SageBuilder::buildUnsignedIntVal_nfi(unsigned int v, const string& str)
{
  SgUnsignedIntVal* result = new SgUnsignedIntVal(v,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgUnsignedLongVal* SageBuilder::buildUnsignedLongVal(unsigned long v)
{
  SgUnsignedLongVal* result = new SgUnsignedLongVal(v,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedLongVal* SageBuilder::buildUnsignedLongValHex(unsigned long v)
{
  SgUnsignedLongVal* result = new SgUnsignedLongVal(v,StringUtility::intToHex(v) + "UL");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedLongVal* SageBuilder::buildUnsignedLongVal_nfi(unsigned long v, const string& str)
{
  SgUnsignedLongVal* result = new SgUnsignedLongVal(v,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgUnsignedLongLongIntVal* SageBuilder::buildUnsignedLongLongIntVal(unsigned long long v)
{
  SgUnsignedLongLongIntVal* result = new SgUnsignedLongLongIntVal(v,"");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedLongLongIntVal* SageBuilder::buildUnsignedLongLongIntValHex(unsigned long long v)
{
  SgUnsignedLongLongIntVal* result = new SgUnsignedLongLongIntVal(v,StringUtility::intToHex(v) + "ULL");
  ASSERT_not_null(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUnsignedLongLongIntVal* SageBuilder::buildUnsignedLongLongIntVal_nfi(unsigned long long v, const string& str)
{
  SgUnsignedLongLongIntVal* result = new SgUnsignedLongLongIntVal(v,str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgJovialBitVal* SageBuilder::buildJovialBitVal_nfi(const string& str)
{
  SgJovialBitVal* result = new SgJovialBitVal(str);
  ASSERT_not_null(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgTemplateType* SageBuilder::buildTemplateType(SgName name/* ="" */)
{
  SgTemplateType* result = new SgTemplateType (name);
  ASSERT_not_null (result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgTemplateParameter * SageBuilder::buildTemplateParameter (SgTemplateParameter::template_parameter_enum parameterType, SgType* t)
{
  ROSE_ASSERT (t);
  SgTemplateParameter* result = new SgTemplateParameter(parameterType, t);
  ROSE_ASSERT (result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgTemplateParameterVal* SageBuilder::buildTemplateParameterVal(int template_parameter_position)
{
  SgTemplateParameterVal* templateParameterValue = new SgTemplateParameterVal(template_parameter_position,"");
  ROSE_ASSERT(templateParameterValue);
  setOneSourcePositionForTransformation(templateParameterValue);
 
// DQ (7/25/2012): Assert this (it will be set later).
  ROSE_ASSERT(templateParameterValue->get_parent() == NULL);
 
  return templateParameterValue;
}
 
SgTemplateParameterVal* SageBuilder::buildTemplateParameterVal_nfi(int template_parameter_position, const string& str)
{
  SgTemplateParameterVal* templateParameterValue= new SgTemplateParameterVal(template_parameter_position,str);
  ROSE_ASSERT(templateParameterValue);
  setOneSourcePositionNull(templateParameterValue);
 
// DQ (7/25/2012): Assert this (it will be set later).
  ROSE_ASSERT(templateParameterValue->get_parent() == NULL);
 
  return templateParameterValue;
}
 
#define DEBUG_BUILD_NONREAL_DECL 0
 
SgNonrealDecl * SageBuilder::buildNonrealDecl(const SgName & name, SgDeclarationScope * scope, SgDeclarationScope * child_scope) {
  ROSE_ASSERT(scope != NULL);
#if DEBUG_BUILD_NONREAL_DECL
  printf("ENTER SageBuilder::buildNonrealDecl\n");
  printf("  --- name = %s\n", name.str());
  printf("  --- scope = %p (%s)\n", scope, scope->class_name().c_str());
#endif
 
  SgNonrealDecl * nrdecl = NULL;
 
  nrdecl = new SgNonrealDecl(name);
  SageInterface::setSourcePosition(nrdecl);
  nrdecl->set_firstNondefiningDeclaration(nrdecl);
#if DEBUG_BUILD_NONREAL_DECL
  printf("  --- nrdecl = %p (%s)\n", nrdecl, nrdecl->class_name().c_str());
#endif
 
  SgNonrealSymbol * symbol = new SgNonrealSymbol(nrdecl);
  scope->insert_symbol(name, symbol);
#if DEBUG_BUILD_NONREAL_DECL
  printf("  --- symbol = %p (%s)\n", symbol, symbol->class_name().c_str());
#endif
 
  SgNonrealType * type = new SgNonrealType();
  type->set_declaration(nrdecl);
  type->set_parent(scope);
  nrdecl->set_type(type);
  // FIXME (???) insert `type` in `scope`
#if DEBUG_BUILD_NONREAL_DECL
  printf("  --- type = %p (%s)\n", type, type->class_name().c_str());
#endif
 
  if (child_scope == NULL) {
    child_scope = new SgDeclarationScope();
#if DEBUG_BUILD_NONREAL_DECL
  printf("  --- child_scope = %p (new)\n", name.str(), child_scope);
#endif
    SageInterface::setSourcePosition(child_scope);
    child_scope->get_startOfConstruct()->setCompilerGenerated();
    child_scope->get_endOfConstruct()->setCompilerGenerated();
  } else {
#if DEBUG_BUILD_NONREAL_DECL
  printf("  --- child_scope = %p (provided)\n", name.str(), child_scope);
#endif
 
  }
  child_scope->set_parent(nrdecl);
  nrdecl->set_nonreal_decl_scope(child_scope);
 
#if DEBUG_BUILD_NONREAL_DECL
  printf("LEAVE SageBuilder::buildNonrealDecl\n");
#endif
 
  return nrdecl;
}
 
SgUpcThreads* SageBuilder::buildUpcThreads()
{
  SgUpcThreads* result = new SgUpcThreads(0,"");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUpcThreads* SageBuilder::buildUpcThreads_nfi()
{
  SgUpcThreads* result = new SgUpcThreads(0,"");
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgUpcMythread* SageBuilder::buildUpcMythread()
{
  SgUpcMythread* result = new SgUpcMythread(0,"");
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgUpcMythread* SageBuilder::buildUpcMythread_nfi()
{
  SgUpcMythread* result = new SgUpcMythread(0,"");
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgThisExp* SageBuilder::buildThisExp(SgSymbol* sym)
{
  SgThisExp* result = new SgThisExp(isSgClassSymbol(sym), isSgNonrealSymbol(sym), 0);
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgThisExp* SageBuilder::buildThisExp_nfi(SgSymbol* sym)
{
  SgThisExp* result = new SgThisExp(isSgClassSymbol(sym), isSgNonrealSymbol(sym), 0);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgSuperExp* SageBuilder::buildSuperExp(SgClassSymbol* sym)
{
  SgSuperExp* result = new SgSuperExp(sym, 0);
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgSuperExp* SageBuilder::buildSuperExp_nfi(SgClassSymbol* sym)
{
  SgSuperExp* result = new SgSuperExp(sym, 0);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgClassExp* SageBuilder::buildClassExp(SgClassSymbol* sym)
{
  SgClassExp* result = new SgClassExp(sym, 0);
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgClassExp* SageBuilder::buildClassExp_nfi(SgClassSymbol* sym)
{
  SgClassExp* result = new SgClassExp(sym, 0);
  ROSE_ASSERT(result);
  setOneSourcePositionNull(result);
  return result;
}
 
SgTupleExp*
SageBuilder::buildTupleExp(SgExpression * elt1, SgExpression* elt2, SgExpression* elt3, SgExpression* elt4, SgExpression* elt5, SgExpression* elt6, SgExpression* elt7, SgExpression* elt8, SgExpression* elt9, SgExpression* elt10)
{
  SgTupleExp* tuple = new SgTupleExp();
  ROSE_ASSERT(tuple);
  if (elt1) appendExpression(tuple, elt1);
  if (elt2) appendExpression(tuple, elt2);
  if (elt3) appendExpression(tuple, elt3);
  if (elt4) appendExpression(tuple, elt4);
  if (elt5) appendExpression(tuple, elt5);
  if (elt6) appendExpression(tuple, elt6);
  if (elt7) appendExpression(tuple, elt7);
  if (elt8) appendExpression(tuple, elt8);
  if (elt9) appendExpression(tuple, elt9);
  if (elt10) appendExpression(tuple, elt10);
 
  setOneSourcePositionForTransformation(tuple);
  return tuple;
}
 
SgTupleExp*
SageBuilder::buildTupleExp(const std::vector<SgExpression*>& elts)
{
  SgTupleExp* expList = SageBuilder::buildTupleExp();
  appendExpressionList(expList, elts);
  return expList;
}
 
SgTupleExp*
SageBuilder::buildTupleExp_nfi()
{
  SgTupleExp* tuple = new SgTupleExp();
  ROSE_ASSERT(tuple);
  setOneSourcePositionNull(tuple);
  return tuple;
}
 
SgTupleExp*
SageBuilder::buildTupleExp_nfi(const std::vector<SgExpression*>& elts)
{
  SgTupleExp* tuple = SageBuilder::buildTupleExp_nfi();
  appendExpressionList(tuple, elts);
  return tuple;
}
 
SgListExp*
SageBuilder::buildListExp(SgExpression * elt1, SgExpression* elt2, SgExpression* elt3, SgExpression* elt4, SgExpression* elt5, SgExpression* elt6, SgExpression* elt7, SgExpression* elt8, SgExpression* elt9, SgExpression* elt10)
{
  SgListExp* tuple = new SgListExp();
  ROSE_ASSERT(tuple);
  if (elt1) appendExpression(tuple, elt1);
  if (elt2) appendExpression(tuple, elt2);
  if (elt3) appendExpression(tuple, elt3);
  if (elt4) appendExpression(tuple, elt4);
  if (elt5) appendExpression(tuple, elt5);
  if (elt6) appendExpression(tuple, elt6);
  if (elt7) appendExpression(tuple, elt7);
  if (elt8) appendExpression(tuple, elt8);
  if (elt9) appendExpression(tuple, elt9);
  if (elt10) appendExpression(tuple, elt10);
 
  setOneSourcePositionForTransformation(tuple);
  return tuple;
}
 
SgListExp*
SageBuilder::buildListExp(const std::vector<SgExpression*>& elts)
{
  SgListExp* expList = SageBuilder::buildListExp();
  appendExpressionList(expList, elts);
  return expList;
}
 
SgListExp*
SageBuilder::buildListExp_nfi()
{
  SgListExp* tuple = new SgListExp();
  ROSE_ASSERT(tuple);
  setOneSourcePositionNull(tuple);
  return tuple;
}
 
SgListExp*
SageBuilder::buildListExp_nfi(const std::vector<SgExpression*>& elts)
{
  SgListExp* tuple = SageBuilder::buildListExp_nfi();
  appendExpressionList(tuple, elts);
  return tuple;
}
 
 
#define BUILD_UNARY_DEF(suffix) \
  ROSE_DLL_API Sg##suffix* SageBuilder::build##suffix##_nfi(SgExpression* op) \
  { \
     return SageBuilder::buildUnaryExpression_nfi<Sg##suffix>(op); \
  } \
  ROSE_DLL_API Sg##suffix* SageBuilder::build##suffix(SgExpression* op) \
  { \
     return SageBuilder::buildUnaryExpression<Sg##suffix>(op); \
  }
 
BUILD_UNARY_DEF(AddressOfOp)
BUILD_UNARY_DEF(BitComplementOp)
BUILD_UNARY_DEF(MinusOp)
BUILD_UNARY_DEF(NotOp)
BUILD_UNARY_DEF(PointerDerefExp)
BUILD_UNARY_DEF(UnaryAddOp)
BUILD_UNARY_DEF(AbsOp)
BUILD_UNARY_DEF(MinusMinusOp)
BUILD_UNARY_DEF(PlusPlusOp)
BUILD_UNARY_DEF(RealPartOp)
BUILD_UNARY_DEF(ImagPartOp)
BUILD_UNARY_DEF(ConjugateOp)
BUILD_UNARY_DEF(VarArgStartOneOperandOp)
BUILD_UNARY_DEF(VarArgEndOp)
 
BUILD_UNARY_DEF(MatrixTransposeOp) //SK(08/20/2015): Matlab matrix transpose operators
 
#undef BUILD_UNARY_DEF
 
SgCastExp * SageBuilder::buildCastExp(SgExpression *  operand_i,
                SgType * expression_type,
                SgCastExp::cast_type_enum cast_type)
{
  SgCastExp* result = new SgCastExp(operand_i, expression_type, cast_type);
  ROSE_ASSERT(result);
  if (operand_i) {operand_i->set_parent(result); markLhsValues(result);}
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgNewExp*
SageBuilder::buildNewExp ( SgType* specified_type,
                           SgExprListExp* placement_args,
                           SgConstructorInitializer* constructor_args,
                           SgExpression* builtin_args,
                        // FIXME: Change this from "short int" to "bool".
                           short int need_global_specifier,
                           SgFunctionDeclaration* newOperatorDeclaration)
   {
  // DQ (11/18/2012): Modified parameter names to make this function more clear.
     SgNewExp* result = new SgNewExp(specified_type, placement_args, constructor_args, builtin_args, need_global_specifier, newOperatorDeclaration);
     ROSE_ASSERT(result);
 
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgDeleteExp* SageBuilder::buildDeleteExp(SgExpression* variable,
                                         short is_array,
                                         short need_global_specifier,
                                         SgFunctionDeclaration* deleteOperatorDeclaration)
{
  SgDeleteExp* result = new SgDeleteExp(variable, is_array,
          need_global_specifier, deleteOperatorDeclaration);
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgTypeIdOp*
SageBuilder::buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type)
   {
  // DQ (1/25/2013): Added support for typeId operators.
     SgTypeIdOp* result = new SgTypeIdOp(operand_expr,operand_type);
     ROSE_ASSERT(result != NULL);
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgCastExp * SageBuilder::buildCastExp_nfi(SgExpression *  operand_i, SgType * expression_type, SgCastExp::cast_type_enum cast_type)
{
  SgCastExp* result = new SgCastExp(operand_i, expression_type, cast_type);
  ROSE_ASSERT(result);
  if (operand_i) {operand_i->set_parent(result); markLhsValues(result);}
  setOneSourcePositionNull(result);
  return result;
}
 
SgVarArgOp * SageBuilder::buildVarArgOp_nfi(SgExpression *  operand_i, SgType * expression_type) {
  SgVarArgOp* result = new SgVarArgOp(operand_i, expression_type);
  ROSE_ASSERT(result);
  if (operand_i) {operand_i->set_parent(result); markLhsValues(result);}
  setOneSourcePositionNull(result);
  return result;
}
 
SgMinusMinusOp *SageBuilder::buildMinusMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode  a_mode)
{
  SgMinusMinusOp* result = buildUnaryExpression<SgMinusMinusOp>(operand_i);
  ROSE_ASSERT(result);
  result->set_mode(a_mode);
  return result;
}
 
SgMinusMinusOp *SageBuilder::buildMinusMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode  a_mode)
{
  SgMinusMinusOp* result = buildUnaryExpression_nfi<SgMinusMinusOp>(operand_i);
  ROSE_ASSERT(result);
  result->set_mode(a_mode);
  return result;
}
 
SgMinusOp *SageBuilder::buildMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode  a_mode)
{
  SgMinusOp* result = buildUnaryExpression<SgMinusOp>(operand_i);
  ROSE_ASSERT(result);
  result->set_mode(a_mode);
  return result;
}
 
SgMinusOp *SageBuilder::buildMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode  a_mode)
{
  SgMinusOp* result = buildUnaryExpression_nfi<SgMinusOp>(operand_i);
  ROSE_ASSERT(result);
  result->set_mode(a_mode);
  return result;
}
 
SgPlusPlusOp *SageBuilder::buildPlusPlusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode  a_mode)
{
  SgPlusPlusOp* result = buildUnaryExpression<SgPlusPlusOp>(operand_i);
  ROSE_ASSERT(result);
  result->set_mode(a_mode);
  return result;
}
 
 
SgPlusPlusOp *SageBuilder::buildPlusPlusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode  a_mode)
{
  SgPlusPlusOp* result = buildUnaryExpression_nfi<SgPlusPlusOp>(operand_i);
  ROSE_ASSERT(result);
  result->set_mode(a_mode);
  return result;
}
 
SgThrowOp *SageBuilder::buildThrowOp(SgExpression *operand_i, SgThrowOp::e_throw_kind throwKind)
   {
  // DQ (11/8/2011): operand_i is allowed to be NULL.
 
  // SgThrowOp* result = new SgThrowOp(operand_i, operand_i -> get_type(), throwKind);
     SgThrowOp* result = new SgThrowOp(operand_i, (operand_i != NULL) ? operand_i->get_type() : NULL, throwKind);
 
     if (operand_i)
        {
          markLhsValues(result);
        }
 
     setOneSourcePositionForTransformation(result);
 
     if (operand_i)
          operand_i -> set_parent(result);
 
     ROSE_ASSERT(result);
 
     return result;
   }
 
 
 
#define BUILD_BINARY_DEF(suffix) \
  ROSE_DLL_API Sg##suffix* SageBuilder::build##suffix##_nfi(SgExpression* lhs, SgExpression* rhs) \
  { \
     return buildBinaryExpression_nfi<Sg##suffix>(lhs, rhs); \
  } \
  ROSE_DLL_API Sg##suffix* SageBuilder::build##suffix(SgExpression* lhs, SgExpression* rhs) \
  { \
     return buildBinaryExpression<Sg##suffix>(lhs, rhs); \
  }
 
BUILD_BINARY_DEF(AddOp)
BUILD_BINARY_DEF(AndAssignOp)
BUILD_BINARY_DEF(AndOp)
BUILD_BINARY_DEF(ArrowExp)
BUILD_BINARY_DEF(ArrowStarOp)
BUILD_BINARY_DEF(AssignOp)
BUILD_BINARY_DEF(AtOp)
BUILD_BINARY_DEF(BitAndOp)
BUILD_BINARY_DEF(BitOrOp)
BUILD_BINARY_DEF(BitXorOp)
 
BUILD_BINARY_DEF(CommaOpExp)
BUILD_BINARY_DEF(ConcatenationOp)
BUILD_BINARY_DEF(DivAssignOp)
BUILD_BINARY_DEF(DivideOp)
BUILD_BINARY_DEF(DotExp)
BUILD_BINARY_DEF(DotStarOp)
BUILD_BINARY_DEF(EqualityOp)
 
BUILD_BINARY_DEF(ExponentiationOp)
BUILD_BINARY_DEF(ExponentiationAssignOp)
BUILD_BINARY_DEF(GreaterOrEqualOp)
BUILD_BINARY_DEF(GreaterThanOp)
BUILD_BINARY_DEF(IntegerDivideOp)
BUILD_BINARY_DEF(IntegerDivideAssignOp)
BUILD_BINARY_DEF(IorAssignOp)
BUILD_BINARY_DEF(IsOp)
BUILD_BINARY_DEF(IsNotOp)
 
BUILD_BINARY_DEF(LessOrEqualOp)
BUILD_BINARY_DEF(LessThanOp)
BUILD_BINARY_DEF(LshiftAssignOp)
BUILD_BINARY_DEF(LshiftOp)
 
BUILD_BINARY_DEF(MembershipOp)
BUILD_BINARY_DEF(MinusAssignOp)
BUILD_BINARY_DEF(ModAssignOp)
BUILD_BINARY_DEF(ModOp)
BUILD_BINARY_DEF(MultAssignOp)
BUILD_BINARY_DEF(MultiplyOp)
 
BUILD_BINARY_DEF(NotEqualOp)
BUILD_BINARY_DEF(NonMembershipOp)
BUILD_BINARY_DEF(OrOp)
BUILD_BINARY_DEF(PlusAssignOp)
BUILD_BINARY_DEF(PntrArrRefExp)
BUILD_BINARY_DEF(RemOp)
BUILD_BINARY_DEF(RshiftAssignOp)
BUILD_BINARY_DEF(JavaUnsignedRshiftAssignOp)
 
BUILD_BINARY_DEF(RshiftOp)
BUILD_BINARY_DEF(JavaUnsignedRshiftOp)
BUILD_BINARY_DEF(ScopeOp)
BUILD_BINARY_DEF(SubtractOp)
BUILD_BINARY_DEF(XorAssignOp)
 
BUILD_BINARY_DEF(VarArgCopyOp)
BUILD_BINARY_DEF(VarArgStartOp)
 
// CR(07/26/2018): Jovial operators
BUILD_BINARY_DEF(ReplicationOp);
 
//SK(08/20/2015): Matlab operators
BUILD_BINARY_DEF(PowerOp);
BUILD_BINARY_DEF(ElementwisePowerOp);
BUILD_BINARY_DEF(ElementwiseMultiplyOp);
BUILD_BINARY_DEF(ElementwiseDivideOp);
BUILD_BINARY_DEF(LeftDivideOp);
BUILD_BINARY_DEF(ElementwiseLeftDivideOp);
BUILD_BINARY_DEF(ElementwiseAddOp);
BUILD_BINARY_DEF(ElementwiseSubtractOp);
 
// DQ (7/25/2020): Adding C++20 support
BUILD_BINARY_DEF(SpaceshipOp)
 
#undef BUILD_BINARY_DEF
 
 
 
// CR ( 1/25/2018):
//    (10/30/2018): Fixed case when this function is called with NULL dim_info object.
SgArrayType* SageBuilder::buildArrayType(SgType* base_type, SgExprListExp* dim_info)
   {
     ROSE_ASSERT(base_type != NULL);
 
  // There must always be a dim_info object for this function.  If not, the
  // overloaded function must be used to handle it.
     if (dim_info == NULL)
        {
           SgExpression* index = NULL;
           return buildArrayType(base_type, index);
        }
 
     SgExpression* index = new SgNullExpression();
     ROSE_ASSERT(index);
     setSourcePosition(index);
 
     SgArrayType* array_type = new SgArrayType(base_type, index);
     ROSE_ASSERT(array_type);
     ROSE_ASSERT(array_type->get_dim_info() == NULL);
 
     index   ->set_parent(array_type);
     dim_info->set_parent(array_type);
 
     array_type->set_dim_info(dim_info);
     array_type->set_rank(dim_info->get_expressions().size());
 
     return array_type;
   }
 
SgArrayType* SageBuilder::buildArrayType(SgType* base_type/*=NULL*/, SgExpression* index/*=NULL*/)
{
  SgArrayType* result = new SgArrayType(base_type,index);
  ASSERT_not_null(result);
 
  if (index != nullptr) {
    index->set_parent(result); // important!
  }
 
  return result;
}
 
SgConditionalExp* SageBuilder::buildConditionalExp(SgExpression* test, SgExpression* a, SgExpression* b)
{
  SgConditionalExp* result = new SgConditionalExp(test, a, b, NULL);
  if (test) test->set_parent(result);
  if (a) a->set_parent(result);
  if (b) b->set_parent(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgConditionalExp* SageBuilder::buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t)
{
  SgConditionalExp* result = new SgConditionalExp(test, a, b, t);
  if (test) test->set_parent(result);
  if (a) {a->set_parent(result); markLhsValues(a);}
  if (b) {b->set_parent(result); markLhsValues(b);}
  setOneSourcePositionNull(result);
  return result;
}
 
SgVariantExpression * SageBuilder::buildVariantExpression()
{
  SgVariantExpression * result =  new SgVariantExpression();
  ROSE_ASSERT(result);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgNullExpression* SageBuilder::buildNullExpression_nfi() {
  SgNullExpression* ne = new SgNullExpression();
  ROSE_ASSERT(ne);
  setOneSourcePositionNull(ne);
  return ne;
}
 
SgNullExpression* SageBuilder::buildNullExpression() {
  SgNullExpression* e = buildNullExpression_nfi();
  setOneSourcePositionForTransformation(e);
  return e;
}
 
SgColonShapeExp* SageBuilder::buildColonShapeExp_nfi() {
  SgColonShapeExp* expr = new SgColonShapeExp();
  ASSERT_not_null(expr);
  setOneSourcePositionNull(expr);
  return expr;
}
 
SgColonShapeExp* SageBuilder::buildColonShapeExp() {
  SgColonShapeExp* expr = buildColonShapeExp_nfi();
  setOneSourcePositionForTransformation(expr);
  return expr;
}
 
SgAssignInitializer * SageBuilder::buildAssignInitializer(SgExpression * operand_i /*= NULL*/, SgType * expression_type /* = NULL */)
   {
     SgAssignInitializer* result = new SgAssignInitializer(operand_i, expression_type);
     ROSE_ASSERT(result);
     if (operand_i!=NULL)
        {
          operand_i->set_parent(result);
       // set lvalue, it asserts operand!=NULL
          markLhsValues(result);
        }
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgAssignInitializer * SageBuilder::buildAssignInitializer_nfi(SgExpression * operand_i /*= nullptr*/, SgType * expression_type /*=nullptr*/)
   {
     SgAssignInitializer* result = new SgAssignInitializer(operand_i, expression_type);
     ASSERT_not_null(result);
     if (operand_i)
        {
          operand_i->set_parent(result);
       // set lvalue, it asserts operand!=NULL
          markLhsValues(result);
        }
 
     setSourcePosition(result);
     result->set_need_paren(false);
 
     return result;
   }
 
SgAggregateInitializer * SageBuilder::buildAggregateInitializer(SgExprListExp * initializers/* = NULL*/, SgType *type/* = NULL */)
{
  SgAggregateInitializer* result = new SgAggregateInitializer(initializers, type);
  ROSE_ASSERT(result);
  if (initializers!=NULL)
  {
    initializers->set_parent(result);
  }
  result->set_need_explicit_braces(true);
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgAggregateInitializer * SageBuilder::buildAggregateInitializer_nfi(SgExprListExp * initializers/* = NULL*/, SgType *type/* = NULL */)
{
  SgAggregateInitializer* result = new SgAggregateInitializer(initializers, type);
  ROSE_ASSERT(result);
  if (initializers!=NULL)
  {
    initializers->set_parent(result);
  }
  result->set_need_explicit_braces(true);
  setOneSourcePositionNull(result);
  return result;
}
 
SgCompoundInitializer * SageBuilder::buildCompoundInitializer(SgExprListExp * initializers/* = NULL*/, SgType *type/* = NULL */)
{
  SgCompoundInitializer* result = new SgCompoundInitializer(initializers, type);
  ROSE_ASSERT(result);
  if (initializers!=NULL)
  {
    initializers->set_parent(result);
  }
  setOneSourcePositionForTransformation(result);
  return result;
}
 
SgCompoundInitializer * SageBuilder::buildCompoundInitializer_nfi(SgExprListExp * initializers/* = NULL*/, SgType *type/* = NULL */)
{
  SgCompoundInitializer* result = new SgCompoundInitializer(initializers, type);
  ROSE_ASSERT(result);
  if (initializers!=NULL)
  {
    initializers->set_parent(result);
  }
  setOneSourcePositionNull(result);
  return result;
}
 
// DQ (1/4/2009): Added support for SgConstructorInitializer
SgConstructorInitializer *
SageBuilder::buildConstructorInitializer(
   SgMemberFunctionDeclaration *declaration/* = NULL*/,
   SgExprListExp *args/* = NULL*/,
   SgType *expression_type/* = NULL*/,
   bool need_name /*= false*/,
   bool need_qualifier /*= false*/,
   bool need_parenthesis_after_name /*= false*/,
   bool associated_class_unknown /*= false*/)
   {
  // Prototype:
  // SgConstructorInitializer (SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type,
  //    bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown);
 
     //George Vulov (05/24/2011) Modified this assertion to allow for a NULL declaration (in case of implicit constructors)
     ROSE_ASSERT(declaration == NULL || declaration->get_associatedClassDeclaration() != NULL);
 
     SgConstructorInitializer* result = new SgConstructorInitializer( declaration, args, expression_type, need_name,
                                        need_qualifier, need_parenthesis_after_name, associated_class_unknown );
     ROSE_ASSERT(result != NULL);
     if (args != NULL)
        {
          args->set_parent(result);
          setOneSourcePositionForTransformation(args);
        }
 
     setOneSourcePositionForTransformation(result);
 
     return result;
   }
 
// DQ (1/4/2009): Added support for SgConstructorInitializer
SgConstructorInitializer *
SageBuilder::buildConstructorInitializer_nfi(
   SgMemberFunctionDeclaration *declaration/* = NULL*/,
   SgExprListExp *args/* = NULL*/,
   SgType *expression_type/* = NULL*/,
   bool need_name /*= false*/,
   bool need_qualifier /*= false*/,
   bool need_parenthesis_after_name /*= false*/,
   bool associated_class_unknown /*= false*/)
   {
  // Prototype:
  // SgConstructorInitializer (SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown);
 
  // DQ (11/7/2011): Fix symetric to the way George did it above.
     ROSE_ASSERT(declaration == NULL || declaration->get_associatedClassDeclaration() != NULL);
 
     SgConstructorInitializer* result = new SgConstructorInitializer( declaration, args, expression_type, need_name, need_qualifier, need_parenthesis_after_name, associated_class_unknown );
     ROSE_ASSERT(result != NULL);
 
     setOneSourcePositionNull(result);
 
     if (args != NULL)
        {
          args->set_parent(result);
        }
 
  // DQ (11/4/2012): This is required and appears to work fine now.
  // DQ (11/23/2011): Fixup the expression list (but this does not appear to work...)
     if (result->get_args()->get_startOfConstruct() == NULL)
       {
         setOneSourcePositionNull(result->get_args());
       }
 
     return result;
   }
 
// DQ (11/15/2016):Adding support for braced initializer (required for template support).
SgBracedInitializer*
SageBuilder::buildBracedInitializer(SgExprListExp * initializers, SgType * expression_type )
   {
     SgBracedInitializer* result = new SgBracedInitializer(initializers, expression_type);
     ROSE_ASSERT(result);
     if (initializers!=NULL)
        {
          initializers->set_parent(result);
        }
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgBracedInitializer* SageBuilder::buildBracedInitializer_nfi(SgExprListExp * initializers, SgType * expression_type )
   {
     SgBracedInitializer* result = new SgBracedInitializer(initializers, expression_type);
     ROSE_ASSERT(result);
     if (initializers!=NULL)
        {
          initializers->set_parent(result);
        }
     setOneSourcePositionNull(result);
     return result;
   }
 
 
SgSizeOfOp* SageBuilder::buildSizeOfOp(SgExpression* exp/*= NULL*/)
   {
  // SgType* exp_type = NULL;
  // if (exp) exp_type = exp->get_type();
 
     SgSizeOfOp* result = new SgSizeOfOp(exp,NULL, NULL);
  // SgSizeOfOp* result = new SgSizeOfOp(exp,NULL, exp_type);
     ROSE_ASSERT(result);
     if (exp)
        {
          exp->set_parent(result);
          markLhsValues(result);
        }
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgSizeOfOp* SageBuilder::buildSizeOfOp_nfi(SgExpression* exp/*= NULL*/)
   {
  // SgType* exp_type =NULL;
  // if (exp) exp_type = exp->get_type();
 
     SgSizeOfOp* result = new SgSizeOfOp(exp,NULL, NULL);
  // SgSizeOfOp* result = new SgSizeOfOp(exp,NULL, exp_type);
     ROSE_ASSERT(result);
     if (exp)
        {
          exp->set_parent(result);
          markLhsValues(result);
        }
     setOneSourcePositionNull(result);
     return result;
   }
 
SgSizeOfOp* SageBuilder::buildSizeOfOp(SgType* type /* = NULL*/)
   {
     SgSizeOfOp* result = new SgSizeOfOp((SgExpression*)NULL,type,NULL);
  // SgSizeOfOp* result = new SgSizeOfOp((SgExpression*)NULL,type,type);
     ROSE_ASSERT(result);
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgSizeOfOp* SageBuilder::buildSizeOfOp_nfi(SgType* type /* = NULL*/)
   {
     SgSizeOfOp* result = new SgSizeOfOp((SgExpression*)NULL,type,NULL);
  // SgSizeOfOp* result = new SgSizeOfOp((SgExpression*)NULL,type,type);
     ROSE_ASSERT(result);
     setOneSourcePositionNull(result);
     return result;
   }
 
SgAlignOfOp* SageBuilder::buildAlignOfOp(SgExpression* exp/*= NULL*/)
   {
  // SgType* exp_type =NULL;
  // if (exp) exp_type = exp->get_type();
 
     SgAlignOfOp* result = new SgAlignOfOp(exp,NULL, NULL);
     ROSE_ASSERT(result);
     if (exp)
        {
          exp->set_parent(result);
          markLhsValues(result);
        }
     setOneSourcePositionForTransformation(result);
     return result;
   }
 
SgAlignOfOp* SageBuilder::buildAlignOfOp_nfi(SgExpression* exp/*= NULL*/)
   {
  // SgType* exp_type =NULL;
  // if (exp) exp_type = exp->get_type();
 
     SgAlignOfOp* result = new SgAlignOfOp(exp,NULL, NULL);
     ROSE_ASSERT(result);
     if (exp)
        {
          exp->set_parent(result);
          markLhsValues(result);
        }
     setOneSourcePositionNull(result);
     return result;
   }
 
SgNoexceptOp* SageBuilder::buildNoexceptOp(