sageInterface.h

Go to the documentation of this file.

#ifndef ROSE_SAGE_INTERFACE
#define ROSE_SAGE_INTERFACE

#include "sage3basic.hhh"
#include <stdint.h>
#include <utility>

#if 0   // FMZ(07/07/2010): the argument "nextErrorCode" should be call-by-reference
SgFile* determineFileType ( std::vector<std::string> argv, int nextErrorCode, SgProject* project );
#else
SgFile* determineFileType ( std::vector<std::string> argv, int& nextErrorCode, SgProject* project );
#endif

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
#include "rewrite.h"
#endif

// DQ (7/20/2008): Added support for unparsing abitrary strings in the unparser.
#include "astUnparseAttribute.h"
#include <set>

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
#include "LivenessAnalysis.h"
#include "abstract_handle.h"
#include "ClassHierarchyGraph.h"
#endif

// DQ (8/19/2004): Moved from ROSE/src/midend/astRewriteMechanism/rewrite.h
ROSE_DLL_API std::string getVariantName (VariantT v);

// DQ (12/9/2004): Qing, Rich and Dan have decided to start this namespace within ROSE
// This namespace is specific to interface functions that operate on the Sage III AST.
// The name was chosen so as not to conflict with other classes within ROSE.
// This will become the future home of many interface functions which operate on
// the AST and which are generally useful to users.  As a namespace multiple files can be used
// to represent the compete interface and different developers may contribute interface
// functions easily.

// Constructor handling: (We have sageBuilder.h now for this purpose, Liao 2/1/2008)
//     We could add simpler layers of support for construction of IR nodes by
// hiding many details in "makeSg***()" functions. Such functions would
// return pointers to the associated Sg*** objects and would be able to hide
// many IR specific details, including:
//      memory handling
//      optional parameter settings not often required
//      use of Sg_File_Info objects (and setting them as transformations)
//
// namespace AST_Interface  (this name is taken already by some of Qing's work :-)

#define TRANS_FILE Sg_File_Info::generateDefaultFileInfoForTransformationNode()

//------------------------------------------------------------------------
namespace SageInterface
   {
  // DQ (4/3/2014): Added general AST support seperate from the AST.

  // Container and API for analysis information that is outside of the AST and as a result
  // prevents frequent modification of the IR.
     class DeclarationSets
        {
       // DQ (4/3/2014): This stores all associated declarations as a map of sets.
       // the key to the map is the first nondefining declaration and the elements of the set are
       // all of the associated declarations (including the defining declaration).

          private:
               std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* > declarationMap;

          public:
               void addDeclaration(SgDeclarationStatement* decl);
               const std::set<SgDeclarationStatement*>* getDeclarations(SgDeclarationStatement* decl);

               std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* > & getDeclarationMap();

               bool isLocatedInDefiningScope(SgDeclarationStatement* decl);

        };

  // DQ (4/3/2014): This constucts a data structure that holds analysis information about
  // the AST that is seperate from the AST.  This is intended to be a general mechanism 
  // to support analysis information without constantly modifing the IR.
     DeclarationSets* buildDeclarationSets(SgNode*);



ROSE_DLL_API extern int gensym_counter;

// tps : 28 Oct 2008 - support for finding the main interpretation
 SgAsmInterpretation* getMainInterpretation(SgAsmGenericFile* file);

uint64_t getAsmConstant(SgAsmValueExpression* e);

int64_t getAsmSignedConstant(SgAsmValueExpression *e);

 void addMessageStatement( SgStatement* stmt, std::string message );

  class UniqueNameAttribute : public AstAttribute
  {
    private:
     std::string name;
    public:
     UniqueNameAttribute(std::string n="") {name =n; };
     void set_name (std::string n) {name = n;};
     std::string get_name () {return name;};
  };

// DQ (3/2/2009): Added support for collectiong an merging the referenced symbols in the outlined
// function into the list used to edit the outlined code subtree to fixup references (from symbols
// in the original file to the symbols in the newer separate file).
// typedef rose_hash::unordered_map<SgNode*, SgNode*, hash_nodeptr> ReplacementMapType;
// void supplementReplacementSymbolMap ( const ReplacementMapTraversal::ReplacementMapType & inputReplacementMap );

// CH (4/9/2010): Use boost::hash instead
//#ifdef _MSC_VER
#if 0
inline size_t hash_value(SgNode* t) {return (size_t)t;}
#endif

struct hash_nodeptr
   {
// CH (4/9/2010): Use boost::hash instead
//#ifndef _MSC_VER
#if 0
           //rose_hash::hash<char*> hasher;
#endif
     public:
          size_t operator()(SgNode* node) const
             {
// CH (4/9/2010): Use boost::hash instead
//#ifdef _MSC_VER
 #if 0
                                  return (size_t) hash_value(node);
 #else
                                  return (size_t) node;
 #endif
                   }
    };

#ifndef SWIG
// DQ (3/10/2013): This appears to be a problem for the SWIG interface (undefined reference at link-time).
  void supplementReplacementSymbolMap ( rose_hash::unordered_map<SgNode*, SgNode*, hash_nodeptr> & inputReplacementMap );
#endif

 //------------------------------------------------------------------------

   // Liao 1/22/2008, used for get symbols for generating variable reference nodes
   // ! Find a variable symbol in current and ancestor scopes for a given name
   ROSE_DLL_API SgVariableSymbol *lookupVariableSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);

// DQ (8/21/2013): Modified to make newest function parameters be default arguments.
// DQ (8/16/2013): For now we want to remove the use of default parameters and add the support for template parameters and template arguments.
// SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope=NULL);
// SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList);
   ROSE_DLL_API SgSymbol *lookupSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);

   // DQ (11/24/2007): Functions moved from the Fortran support so that they could be called from within astPostProcessing.
   ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName & functionName, SgScopeStatement *currentScope=NULL);

   // Liao, 1/24/2008, find exact match for a function
   ROSE_DLL_API SgFunctionSymbol *lookupFunctionSymbolInParentScopes (const SgName &  functionName,
                                                         const SgType* t,
                                                         SgScopeStatement *currentScope=NULL);

// DQ (8/21/2013): Modified to make newest function parameters be default arguments.
// DQ (8/16/2013): For now we want to remove the use of default parameters and add the support for template parameters and template arguments.
// DQ (5/7/2011): Added support for SgClassSymbol (used in name qualification support).
// SgClassSymbol*     lookupClassSymbolInParentScopes    (const SgName & name, SgScopeStatement *currentScope = NULL);
   ROSE_DLL_API SgClassSymbol*     lookupClassSymbolInParentScopes    (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
   ROSE_DLL_API SgTypedefSymbol*   lookupTypedefSymbolInParentScopes  (const SgName & name, SgScopeStatement *currentScope = NULL);

#if 0
 // DQ (8/13/2013): This function does not make since any more, now that we have make the symbol
 // table handling more precise and we have to provide template parameters for any template lookup.
 // We also have to know if we want to lookup template classes, template functions, or template 
 // member functions (since each have specific requirements).
   SgTemplateSymbol*  lookupTemplateSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL);
#endif
#if 0
// DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
// Where these are called we might not know enough information about the template parameters or function 
// types, for example.
   SgTemplateClassSymbol*           lookupTemplateClassSymbolInParentScopes          (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL, SgTemplateArgumentPtrList* templateArgumentList = NULL);
   SgTemplateFunctionSymbol*        lookupTemplateFunctionSymbolInParentScopes       (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
   SgTemplateMemberFunctionSymbol*  lookupTemplateMemberFunctionSymbolInParentScopes (const SgName & name, SgScopeStatement *currentScope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
#endif

// DQ (8/21/2013): Modified to make some of the newest function parameters be default arguments.
// DQ (8/13/2013): I am not sure if we want this functions in place of lookupTemplateSymbolInParentScopes.
   ROSE_DLL_API SgTemplateClassSymbol* lookupTemplateClassSymbolInParentScopes (const SgName &  name, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, SgScopeStatement *cscope = NULL);

   ROSE_DLL_API SgEnumSymbol*      lookupEnumSymbolInParentScopes     (const SgName & name, SgScopeStatement *currentScope = NULL);
   ROSE_DLL_API SgNamespaceSymbol* lookupNamespaceSymbolInParentScopes(const SgName & name, SgScopeStatement *currentScope = NULL);

// DQ (7/17/2011): Added function from cxx branch that I need here for the Java support.
// SgClassSymbol* lookupClassSymbolInParentScopes (const SgName &  name, SgScopeStatement *cscope);

   // DQ (12/9/2004): Moved this function (by Alin Jula) from being a member of SgInitializedName
   // to this location where it can be a part of the interface for the Sage III AST.
   ROSE_DLL_API int set_name (SgInitializedName * initializedNameNode, SgName new_name);

   void outputGlobalFunctionTypeSymbolTable ();

   // DQ (6/27/2005):
   ROSE_DLL_API void outputLocalSymbolTables (SgNode * node);

   class OutputLocalSymbolTables:public AstSimpleProcessing
         {
           public:
     void visit (SgNode * node);
         };
   // DQ (9/28/2005):
   void rebuildSymbolTable (SgScopeStatement * scope);

   void clearUnusedVariableSymbols (SgNode* root = NULL);

   // DQ (3/1/2009):
   void fixupReferencesToSymbols( const SgScopeStatement* this_scope,  SgScopeStatement* copy_scope, SgCopyHelp & help );


 //------------------------------------------------------------------------

   // DQ (9/21/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgNode * node);

   // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgStatement * stmt);

     std::string get_name (const SgExpression * expr);

   // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgDeclarationStatement * declaration);

   // DQ (6/13/2005): General function for extracting the name of declarations (when they have names)
     std::string get_name (const SgScopeStatement * scope);

   // DQ (2/11/2007): Added this function to make debugging support more complete (useful for symbol table debugging support).
     std::string get_name (const SgSymbol * symbol);

     std::string get_name (const SgType * type);


     std::string get_name (const SgSupport * node);


     std::string get_name (const SgLocatedNodeSupport * node);

     std::string get_name ( const SgC_PreprocessorDirectiveStatement* directive );

     std::string get_name ( const SgToken* token );


 //------------------------------------------------------------------------

   // DQ (6/21/2005): Get the default destructor from the class declaration
   SgMemberFunctionDeclaration *getDefaultDestructor (SgClassDeclaration *
                                                      classDeclaration);

   // DQ (6/22/2005): Get the default constructor from the class declaration
   ROSE_DLL_API SgMemberFunctionDeclaration *getDefaultConstructor (SgClassDeclaration *
                                                       classDeclaration);
   // DQ (8/27/2005):
   bool templateDefinitionIsInClass (SgTemplateInstantiationMemberFunctionDecl
                                     * memberFunctionDeclaration);

   // DQ (9/17/2005):
      SgTemplateInstantiationMemberFunctionDecl*
      buildForwardFunctionDeclaration
         (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);

   bool isStructDeclaration(SgNode * node);
   bool isUnionDeclaration(SgNode * node);
 #if 0
 // DQ (8/28/2005): This is already a member function of the SgFunctionDeclaration
 // (so that it can handle template functions and member functions)

    // DQ (8/27/2005):
   bool isTemplateMemberFunction (SgTemplateInstantiationMemberFunctionDecl *
                                  memberFunctionDeclaration);
 #endif


 //------------------------------------------------------------------------

 // DQ (2/12/2012): Added some diagnostic support.
   void whereAmI(SgNode* node);

   std::string extractPragmaKeyword(const SgPragmaDeclaration *);

   ROSE_DLL_API bool isOmpStatement(SgNode* );
   // DQ (8/27/2005):
   bool isOverloaded (SgFunctionDeclaration * functionDeclaration);

// DQ (2/14/2012): Added support function used for variable declarations in conditionals.
   void initializeIfStmt(SgIfStmt *ifstmt, SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);

   void initializeSwitchStatement(SgSwitchStatement* switchStatement,SgStatement *item_selector,SgStatement *body);

   void initializeWhileStatement(SgWhileStmt* whileStatement, SgStatement *  condition, SgStatement *body, SgStatement *else_body);

   void annotateExpressionsWithUniqueNames (SgProject* project);

   ROSE_DLL_API bool isMain (const SgNode* node);
   // DQ (6/22/2005):
    std::string generateUniqueName ( const SgNode * node, bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);

    std::string generateUniqueVariableName(SgScopeStatement* scope, std::string baseName = "temp");

  // DQ (8/10/2010): Added const to first parameter.
  // DQ (3/10/2007):
    std::string declarationPositionString (const SgDeclarationStatement * declaration);

  // DQ (1/20/2007):
    ROSE_DLL_API std::string generateProjectName (const SgProject * project, bool supressSuffix = false );

  SgFunctionDeclaration* getDeclarationOfNamedFunction(SgExpression* func);

  SgExpression* forallMaskExpression(SgForAllStatement* stmt);

  void addVarRefExpFromArrayDimInfo(SgNode * astNode, Rose_STL_Container<SgNode *>& NodeList_t);

  // DQ (10/6/2006): Added support for faster mangled name generation (caching avoids recomputation).
#ifndef SWIG
// DQ (3/10/2013): This appears to be a problem for the SWIG interface (undefined reference at link-time).
  void clearMangledNameCache (SgGlobal * globalScope);
  void resetMangledNameCache (SgGlobal * globalScope);
#endif

  std::string getMangledNameFromCache (SgNode * astNode);
  std::string addMangledNameToCache (SgNode * astNode, const std::string & mangledName);

  SgDeclarationStatement * getNonInstantiatonDeclarationForClass (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);

  void setBaseTypeDefiningDeclaration(SgVariableDeclaration* var_decl, SgDeclarationStatement *base_decl);

  // DQ (10/14/2006): This function tests the AST to see if for a non-defining declaration, the
  // bool declarationPreceedsDefinition ( SgClassDeclaration* classNonDefiningDeclaration, SgClassDeclaration* classDefiningDeclaration );
  bool declarationPreceedsDefinition (SgDeclarationStatement *nonDefiningDeclaration, SgDeclarationStatement *definingDeclaration);

  // DQ (10/19/2006): Function calls have interesting context dependent rules to determine if
  // they are output with a global qualifier or not.  Were this is true we have to avoid global
  // qualifiers, since the function's scope has not been defined.  This is an example of where
  // qualification of function names in function calls are context dependent; an interesting
  // example of where the C++ language is not friendly to source-to-source processing :-).
  bool functionCallExpressionPreceedsDeclarationWhichAssociatesScope (SgFunctionCallExp * functionCall);

    ROSE_DLL_API std::vector < SgNode * >astIntersection (SgNode * original, SgNode * copy, SgCopyHelp * help = NULL);

   ROSE_DLL_API SgNode* deepCopyNode (const SgNode* subtree);

   template <typename NodeType>
   NodeType* deepCopy (const NodeType* subtree) {
     return dynamic_cast<NodeType*>(deepCopyNode(subtree));
   }

   ROSE_DLL_API SgExpression* copyExpression(SgExpression* e);

   ROSE_DLL_API SgStatement* copyStatement(SgStatement* s);

// from VarSym.cc in src/midend/astOutlining/src/ASTtools
  ROSE_DLL_API SgVariableSymbol* getFirstVarSym (SgVariableDeclaration* decl);

  ROSE_DLL_API SgInitializedName* getFirstInitializedName (SgVariableDeclaration* decl);

ROSE_DLL_API void myRemoveStatement(SgStatement* stmt);

ROSE_DLL_API bool isConstantTrue(SgExpression* e);
ROSE_DLL_API bool isConstantFalse(SgExpression* e);

ROSE_DLL_API bool isCallToParticularFunction(SgFunctionDeclaration* decl, SgExpression* e);
ROSE_DLL_API bool isCallToParticularFunction(const std::string& qualifiedName, size_t arity, SgExpression* e);

bool ROSE_DLL_API isStatic(SgDeclarationStatement* stmt);

ROSE_DLL_API void setStatic(SgDeclarationStatement* stmt);

ROSE_DLL_API bool isExtern(SgDeclarationStatement* stmt);

ROSE_DLL_API void setExtern(SgDeclarationStatement* stmt);

class StatementGenerator {
  public:
  virtual ~StatementGenerator() {};
  virtual SgStatement* generate(SgExpression* where_to_write_answer) = 0;
};

  bool isAssignmentStatement(SgNode* _s, SgExpression** lhs=NULL, SgExpression** rhs=NULL, bool* readlhs=NULL);

ROSE_DLL_API SgInitializedName* convertRefToInitializedName(SgNode* current);

ROSE_DLL_API AbstractHandle::abstract_handle* buildAbstractHandle(SgNode*);

ROSE_DLL_API SgNode* getSgNodeFromAbstractHandleString(const std::string& input_string);

ROSE_DLL_API void dumpInfo(SgNode* node, std::string desc="");

ROSE_DLL_API std::vector<SgDeclarationStatement*>
sortSgNodeListBasedOnAppearanceOrderInSource(const std::vector<SgDeclarationStatement*>& nodevec);

// DQ (4/13/2013): We need these to support the unparing of operators defined by operator syntax or member function names.
// bool isPrefixOperator( const SgMemberFunctionRefExp* memberFunctionRefExp );
bool isPrefixOperator( SgExpression* exp );

bool isPrefixOperatorName( const SgName & functionName );

bool isPostfixOperator( SgExpression* exp );

bool isIndexOperator( SgExpression* exp );


//------------------------------------------------------------------------

//  std::string version();  // utility_functions.h, version number
  ROSE_DLL_API bool is_C_language ();
  ROSE_DLL_API bool is_OpenMP_language ();
  ROSE_DLL_API bool is_UPC_language ();
  ROSE_DLL_API bool is_UPC_dynamic_threads();
  ROSE_DLL_API bool is_C99_language ();
  ROSE_DLL_API bool is_Cxx_language ();
  ROSE_DLL_API bool is_Java_language ();
  ROSE_DLL_API bool is_Fortran_language ();
  ROSE_DLL_API bool is_CAF_language ();
  ROSE_DLL_API bool is_PHP_language();
  ROSE_DLL_API bool is_Python_language();
  ROSE_DLL_API bool is_Cuda_language();
  ROSE_DLL_API bool is_X10_language();
  ROSE_DLL_API bool is_binary_executable();
  ROSE_DLL_API bool is_mixed_C_and_Cxx_language ();
  ROSE_DLL_API bool is_mixed_Fortran_and_C_language ();
  ROSE_DLL_API bool is_mixed_Fortran_and_Cxx_language ();
  ROSE_DLL_API bool is_mixed_Fortran_and_C_and_Cxx_language ();

//------------------------------------------------------------------------

  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
  // labels for scopes in a function (as required for name mangling).
  void resetScopeNumbers (SgFunctionDefinition * functionDeclaration);

  // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
  // labels for scopes in a function (as required for name mangling).
  void clearScopeNumbers (SgFunctionDefinition * functionDefinition);


  SgNamespaceDefinitionStatement * enclosingNamespaceScope (SgDeclarationStatement * declaration);
//  SgNamespaceDefinitionStatement * getEnclosingNamespaceScope (SgNode * node);

  bool isPrototypeInScope (SgScopeStatement * scope,
                           SgFunctionDeclaration * functionDeclaration,
                           SgDeclarationStatement * startingAtDeclaration);

  bool ROSE_DLL_API isAncestor(SgNode* node1, SgNode* node2);
//------------------------------------------------------------------------

  void dumpPreprocInfo (SgLocatedNode* locatedNode);

ROSE_DLL_API PreprocessingInfo* insertHeader(const std::string& filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::after, bool isSystemHeader=false, SgScopeStatement* scope=NULL);

ROSE_DLL_API void moveUpPreprocessingInfo (SgStatement* stmt_dst, SgStatement* stmt_src, PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,  PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);

ROSE_DLL_API void movePreprocessingInfo (SgStatement* stmt_src, SgStatement* stmt_dst,  PreprocessingInfo::RelativePositionType src_position=PreprocessingInfo::undef,
                             PreprocessingInfo::RelativePositionType dst_position=PreprocessingInfo::undef, bool usePrepend= false);


ROSE_DLL_API void cutPreprocessingInfo (SgLocatedNode* src_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& save_buf);

ROSE_DLL_API void pastePreprocessingInfo (SgLocatedNode* dst_node, PreprocessingInfo::RelativePositionType pos, AttachedPreprocessingInfoType& saved_buf);

ROSE_DLL_API PreprocessingInfo* attachArbitraryText(SgLocatedNode* target,
                const std::string & text,
               PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);

ROSE_DLL_API void replaceMacroCallsWithExpandedStrings(SgPragmaDeclaration* target);


//------------------------------------------------------------------------

   ROSE_DLL_API PreprocessingInfo* attachComment(SgLocatedNode* target, const std::string & content,
               PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
               PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);

// DQ (11/25/2009): Added matching support for adding comments to SgAsm nodes.
// Build and attach comment
// void attachComment(SgAsmStatement* target, const std::string & content );

// DQ (7/20/2008): I am not clear were I should put this function, candidates include: SgLocatedNode or SgInterface
  ROSE_DLL_API void addTextForUnparser ( SgNode* astNode, std::string s, AstUnparseAttribute::RelativePositionType inputlocation );



// ************************************************************************
//              Newer versions of now depricated functions
// ************************************************************************

// DQ (5/1/2012): This function queries the SageBuilder::SourcePositionClassification mode (stored in the SageBuilder 
// interface) and used the specified mode to initialize the source position data (Sg_File_Info objects).  This 
// function is the only function that should be called directly (though in a namespace we can't define permissions).
  void setSourcePosition(SgNode* node);

// A better name might be "setSourcePositionForSubTree"
  void setSourcePositionAtRootAndAllChildren(SgNode *root);

// DQ (5/1/2012): New function with improved name (still preserving the previous interface).
// This function is not required once the new mechanism defining a source position mode is complete (shortly).
// void setSourcePositionAtRootAndAllChildrenAsTransformation(SgNode *root);
// void setSourcePositionAtRootAndAllChildrenAsDefault(SgNode *root);

// Removed to force use of the API and permit flexability in the lower level implementation.
// void setSourcePositionToDefault( SgLocatedNode* locatedNode );
  template<class T> void setSourcePositionToDefault( T* node );

void setSourcePositionAsTransformation(SgNode *node);

// DQ (5/1/2012): Newly renamed function (previous name preserved for backward compatability).
void setSourcePositionPointersToNull(SgNode *node);

// ************************************************************************



// ************************************************************************
//                  Older deprecated functions
// ************************************************************************
  // Liao, 1/8/2007, set file info. for a whole subtree as transformation generated
  ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *node);

  ROSE_DLL_API void setOneSourcePositionNull(SgNode *node);

  ROSE_DLL_API void setSourcePositionForTransformation (SgNode * root);

  ROSE_DLL_API void setSourcePositionForTransformation_memoryPool();

// ROSE_DLL_API void setSourcePosition (SgLocatedNode * locatedNode);
// ************************************************************************



//------------------------------------------------------------------------

// from src/midend/astInlining/typeTraits.h
// src/midend/astUtil/astInterface/AstInterface.h

SgType* getBoolType(SgNode* n);


ROSE_DLL_API bool isStrictIntegerType(SgType* t);
ROSE_DLL_API SgType* getFirstVarType(SgVariableDeclaration* decl);

ROSE_DLL_API bool isDefaultConstructible(SgType* type);

ROSE_DLL_API bool isCopyConstructible(SgType* type);

ROSE_DLL_API bool isAssignable(SgType* type);

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
ROSE_DLL_API bool isPureVirtualClass(SgType* type, const ClassHierarchyWrapper& classHierarchy);
#endif

ROSE_DLL_API bool hasTrivialDestructor(SgType* t);

ROSE_DLL_API bool isNonconstReference(SgType* t);

ROSE_DLL_API bool isReferenceType(SgType* t);

ROSE_DLL_API bool isPointerType(SgType* t);

ROSE_DLL_API bool isPointerToNonConstType(SgType* type);

/* const char* p = "aa"; is not treated as having a const type. It is a pointer to const char.
 * Similarly, neither for const int b[10]; or const int & c =10;
 * The standard says, "A compound type is not cv-qualified by the cv-qualifiers (if any) of
the types from which it is compounded. Any cv-qualifiers applied to an array type affect the array element type, not the array type".
 */
ROSE_DLL_API bool isConstType(SgType* t);

SgType* removeConst(SgType* t);

ROSE_DLL_API bool isVolatileType(SgType* t);

ROSE_DLL_API bool isRestrictType(SgType* t);


ROSE_DLL_API bool isScalarType(SgType* t);

ROSE_DLL_API bool isStrictIntegerType(SgType* t);

ROSE_DLL_API bool isStructType(SgType* t);

ROSE_DLL_API std::string mangleType(SgType* type);

ROSE_DLL_API std::string mangleScalarType(SgType* type);

ROSE_DLL_API std::string mangleModifierType(SgModifierType* type);

ROSE_DLL_API size_t getArrayElementCount(SgArrayType* t);

ROSE_DLL_API int getDimensionCount(SgType* t);

ROSE_DLL_API SgType* getArrayElementType(SgType* t);

ROSE_DLL_API SgType* getElementType(SgType* t);


std::vector<SgExpression*>
get_C_array_dimensions(const SgArrayType& arrtype);

std::vector<SgExpression*>
get_C_array_dimensions(const SgArrayType& arrtype, const SgVarRefExp& varref);

std::vector<SgExpression*>
get_C_array_dimensions(const SgArrayType& arrtype, SgInitializedName& initname);


ROSE_DLL_API bool isArrayReference(SgExpression* ref, SgExpression** arrayNameExp=NULL, std::vector<SgExpression*>** subscripts=NULL);



ROSE_DLL_API bool hasUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL  );


ROSE_DLL_API bool isUpcSharedType(SgType* t, SgModifierType ** mod_type_out = NULL);

ROSE_DLL_API bool isUpcSharedModifierType (SgModifierType* mod_type);

ROSE_DLL_API bool isUpcSharedArrayType (SgArrayType* array_type);

ROSE_DLL_API bool isUpcStrictSharedModifierType(SgModifierType* mode_type);

ROSE_DLL_API size_t getUpcSharedBlockSize(SgModifierType* mod_type);

ROSE_DLL_API size_t getUpcSharedBlockSize(SgType* t);

ROSE_DLL_API bool isUpcPhaseLessSharedType (SgType* t);

ROSE_DLL_API bool isUpcPrivateToSharedType(SgType* t);

ROSE_DLL_API bool isUpcArrayWithThreads(SgArrayType* t);

ROSE_DLL_API SgType* lookupNamedTypeInParentScopes(const std::string& type_name, SgScopeStatement* scope=NULL);


//------------------------------------------------------------------------

// by Jeremiah
ROSE_DLL_API void addStepToLoopBody(SgScopeStatement* loopStmt, SgStatement* step);

ROSE_DLL_API void moveForStatementIncrementIntoBody(SgForStatement* f);
ROSE_DLL_API void convertForToWhile(SgForStatement* f);
ROSE_DLL_API void convertAllForsToWhiles(SgNode* top);
ROSE_DLL_API void changeContinuesToGotos(SgStatement* stmt, SgLabelStatement* label);

ROSE_DLL_API SgInitializedName* getLoopIndexVariable(SgNode* loop);

ROSE_DLL_API bool isLoopIndexVariable(SgInitializedName* ivar, SgNode* subtree_root);

ROSE_DLL_API SgStatement* getLoopBody(SgScopeStatement* loop);

ROSE_DLL_API void setLoopBody(SgScopeStatement* loop, SgStatement* body);

ROSE_DLL_API SgStatement* getLoopCondition(SgScopeStatement* loop);

ROSE_DLL_API void setLoopCondition(SgScopeStatement* loop, SgStatement* cond);

ROSE_DLL_API bool isCanonicalForLoop(SgNode* loop, SgInitializedName** ivar=NULL, SgExpression** lb=NULL, SgExpression** ub=NULL, SgExpression** step=NULL, SgStatement** body=NULL, bool *hasIncrementalIterationSpace = NULL, bool* isInclusiveUpperBound = NULL);

ROSE_DLL_API bool isCanonicalDoLoop(SgFortranDo* loop,SgInitializedName** ivar/*=NULL*/, SgExpression** lb/*=NULL*/, SgExpression** ub/*=NULL*/, SgExpression** step/*=NULL*/, SgStatement** body/*=NULL*/, bool *hasIncrementalIterationSpace/*= NULL*/, bool* isInclusiveUpperBound/*=NULL*/);

ROSE_DLL_API void setLoopLowerBound(SgNode* loop, SgExpression* lb);

ROSE_DLL_API void setLoopUpperBound(SgNode* loop, SgExpression* ub);

ROSE_DLL_API void setLoopStride(SgNode* loop, SgExpression* stride);


ROSE_DLL_API bool normalizeForLoopInitDeclaration(SgForStatement* loop);

ROSE_DLL_API bool forLoopNormalization(SgForStatement* loop);

ROSE_DLL_API bool doLoopNormalization(SgFortranDo* loop);

ROSE_DLL_API bool loopUnrolling(SgForStatement* loop, size_t unrolling_factor);

ROSE_DLL_API bool loopInterchange(SgForStatement* loop, size_t depth, size_t lexicoOrder);

ROSE_DLL_API bool loopTiling(SgForStatement* loopNest, size_t targetLevel, size_t tileSize);

//Winnie Loop Collapsing
SgExprListExp * loopCollapsing(SgForStatement* target_loop, size_t collapsing_factor);


//------------------------------------------------------------------------

template <typename NodeType>
std::vector<NodeType*> querySubTree(SgNode* top, VariantT variant = (VariantT)NodeType::static_variant)
{
  Rose_STL_Container<SgNode*> nodes = NodeQuery::querySubTree(top,variant);
  std::vector<NodeType*> result(nodes.size(), NULL);
  int count = 0;
  for (Rose_STL_Container<SgNode*>::const_iterator i = nodes.begin();
       i != nodes.end(); ++i, ++count) {
    NodeType* node = dynamic_cast<NodeType*>(*i);
    ROSE_ASSERT (node);
    result[count] = node;
  }
  return result;
}
    std::vector < SgFile * >generateFileList ();

  ROSE_DLL_API SgProject * getProject();

template <typename NodeType>
static std::vector<NodeType*> getSgNodeListFromMemoryPool()
{
  // This function uses a memory pool traversal specific to the SgFile IR nodes
  class MyTraversal : public ROSE_VisitTraversal
  {
    public:
      std::vector<NodeType*> resultlist;
      void visit ( SgNode* node)
      {
        NodeType* result = dynamic_cast<NodeType* > (node);
        ROSE_ASSERT(result!= NULL);
        if (result!= NULL)
        {
          resultlist.push_back(result);
        }
      };
      virtual ~MyTraversal() {}
  };

  MyTraversal my_traversal;
  NodeType::visitRepresentativeNode(my_traversal);
  return my_traversal.resultlist;
}


ROSE_DLL_API SgFunctionDeclaration* findMain(SgNode* currentNode);

SgStatement* findLastDeclarationStatement(SgScopeStatement * scope);

          //midend/programTransformation/partialRedundancyElimination/pre.h
std::vector<SgVariableSymbol*> getSymbolsUsedInExpression(SgExpression* expr);


std::vector<SgBreakStmt*> findBreakStmts(SgStatement* code, const std::string& fortranLabel = "");


  std::vector<SgContinueStmt*> findContinueStmts(SgStatement* code, const std::string& fortranLabel = "");
  std::vector<SgGotoStatement*> findGotoStmts(SgStatement* scope, SgLabelStatement* l);
  std::vector<SgStatement*> getSwitchCases(SgSwitchStatement* sw);

  template <typename T>
  T* findDeclarationStatement(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining)
  {
    bool found = false;
    if (!root) return 0;
    T* decl = dynamic_cast<T*>(root);
    if (decl!=NULL)
    {
      if (scope)
      {
        if ((decl->get_scope() == scope)&&
            (decl->search_for_symbol_from_symbol_table()->get_name()==name))
        { 
          found = true;
        }
      }
      else // Liao 2/9/2010. We should allow NULL scope
      {
        if(decl->search_for_symbol_from_symbol_table()->get_name()==name)
        {
          found = true;
       }
      }
    }

   if (found)
   {
     if (isDefining)
     {
       ROSE_ASSERT (decl->get_definingDeclaration() != NULL);
       return dynamic_cast<T*> (decl->get_definingDeclaration()); 
     }
     else 
       return decl;
   }

    std::vector<SgNode*> children = root->get_traversalSuccessorContainer();
    for (std::vector<SgNode*>::const_iterator i = children.begin();
            i != children.end(); ++i)
    {
     T* target= findDeclarationStatement<T> (*i,name, scope, isDefining);
     if (target)
       return target;
    }
    return 0;
  }
  SgFunctionDeclaration* findFunctionDeclaration(SgNode* root, std::string name, SgScopeStatement* scope, bool isDefining);

#if 0 //TODO
  // 1. preorder traversal from current SgNode till find next SgNode of type V_SgXXX
  //    until reach the end node
  SgNode* getNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);

  // 2. return all nodes of type VariantT following the source node
  std::vector<SgNode*> getAllNextSgNode( const SgNode* astSourceNode, VariantT=V_SgNode, SgNode* astEndNode=NULL);
#endif


//------------------------------------------------------------------------

// remember to put const to all arguments.


template <typename NodeType>
NodeType* getEnclosingNode(const SgNode* astNode, const bool includingSelf = false)
   {
#if 1
  // DQ (10/20/2012): This is the older version of this implementation.  Until I am sure that
  // the newer version (below) is what we want to use I will resolve this conflict by keeping
  // the previousl version in place.

     if (NULL == astNode)
        {
          return NULL;
        }

     if ( (includingSelf ) && (dynamic_cast<const NodeType*>(astNode)) )
        {
          return const_cast<NodeType*>(dynamic_cast<const NodeType*> (astNode));
        }

  // DQ (3/5/2012): Check for reference to self...
     ROSE_ASSERT(astNode->get_parent() != astNode);

     SgNode* parent = astNode->get_parent();

  // DQ (3/5/2012): Check for loops that will cause infinite loops.
     SgNode* previouslySeenParent = parent;
     bool foundCycle = false;
     while ( (foundCycle == false) && (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
        {
          ROSE_ASSERT(parent->get_parent() != parent);
#if 0
          printf ("In getEnclosingNode(): parent = %p = %s \n",parent,parent->class_name().c_str());
#endif
          parent = parent->get_parent();

       // DQ (3/5/2012): Check for loops that will cause infinite loops.
       // ROSE_ASSERT(parent != previouslySeenParent);
          if (parent == previouslySeenParent)
             {
               foundCycle = true;
             }
        }

#if 0
     printf ("previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
#endif

     parent = previouslySeenParent;

     SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
     if (declarationStatement != NULL)
        {
#if 0
          printf ("Found a SgDeclarationStatement \n");
#endif
          SgDeclarationStatement* definingDeclaration         = declarationStatement->get_definingDeclaration();
          SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();

#if 0
          printf (" --- declarationStatement         = %p \n",declarationStatement);
          printf (" --- definingDeclaration          = %p \n",definingDeclaration);
          if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
               printf (" --- definingDeclaration ->get_parent()         = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());
          printf (" --- firstNondefiningDeclaration  = %p \n",firstNondefiningDeclaration);
          if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
               printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
#endif
          if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
             {
#if 0
               printf ("Found a nondefining declaration so use the non-defining declaration instead \n");
#endif
            // DQ (10/19/2012): Use the defining declaration instead.
            // parent = firstNondefiningDeclaration;
               parent = definingDeclaration;
             }
        }

#if 0
     printf ("reset: previouslySeenParent = %p = %s \n",previouslySeenParent,previouslySeenParent->class_name().c_str());
#endif

  // DQ (10/19/2012): This branch is just to document the cycle that was previously detected, it is for 
  // debugging only. Thus it ony make sense for it to be executed when "(foundCycle == true)".  However, 
  // this will have to be revisited later since it appears clear that it is a problem for the binary analysis 
  // work when it is visited for this case.  Since the cycle is detected, but there is no assertion on the
  // cycle, we don't exit when a cycle is identified (which is the point of the code below). 
  // Note also that I have fixed the code (above and below) to only chase pointers through defining 
  // declarations (where they exist), this is important since non-defining declarations can be almost
  // anywhere (and thus chasing them can make it appear that there are cycles where there are none 
  // (I think); test2012_234.C demonstrates an example of this.
  // DQ (10/9/2012): Robb has suggested this change to fix the binary analysis work.
  // if (foundCycle == true)
     if (foundCycle == false)
        {


          while ( (parent != NULL) && (!dynamic_cast<const NodeType*>(parent)) )
             {
               ROSE_ASSERT(parent->get_parent() != parent);
#if 0
               printf ("In getEnclosingNode() (2nd try): parent = %p = %s \n",parent,parent->class_name().c_str());
               if (parent->get_file_info() != NULL)
                    parent->get_file_info()->display("In getEnclosingNode() (2nd try): debug");
#endif
               SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(parent);
               if (declarationStatement != NULL)
                  {
#if 0
                    printf ("Found a SgDeclarationStatement \n");
#endif
                    SgDeclarationStatement* definingDeclaration         = declarationStatement->get_definingDeclaration();
                    SgDeclarationStatement* firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
#if 0
                    printf (" --- declarationStatement                       = %p = %s \n",declarationStatement,(declarationStatement != NULL) ? declarationStatement->class_name().c_str() : "null");

                    printf (" --- definingDeclaration                        = %p \n",definingDeclaration);
                    if (definingDeclaration != NULL && definingDeclaration->get_parent() != NULL)
                         printf (" --- definingDeclaration ->get_parent()         = %p = %s \n",definingDeclaration->get_parent(),definingDeclaration->get_parent()->class_name().c_str());

                    printf (" --- firstNondefiningDeclaration                = %p \n",firstNondefiningDeclaration);
                    if (firstNondefiningDeclaration != NULL && firstNondefiningDeclaration->get_parent() != NULL)
                         printf (" --- firstNondefiningDeclaration ->get_parent() = %p = %s \n",firstNondefiningDeclaration->get_parent(),firstNondefiningDeclaration->get_parent()->class_name().c_str());
#endif
                    if (definingDeclaration != NULL && declarationStatement != firstNondefiningDeclaration)
                       {
#if 0
                         printf ("Found a nondefining declaration so use the firstNondefining declaration instead \n");
#endif
                      // DQ (10/19/2012): Use the defining declaration instead.
                      // parent = firstNondefiningDeclaration;
                         parent = definingDeclaration;
                       }
                  }

               parent = parent->get_parent();

#if 1
            // DQ (3/5/2012): Check for loops that will cause infinite loops.
               ROSE_ASSERT(parent != previouslySeenParent);
#else
               printf ("WARNING::WARNING::WARNING commented out assertion for parent != previouslySeenParent \n");
               if (parent == previouslySeenParent)
                    break;
#endif
             }
        }

     return const_cast<NodeType*>(dynamic_cast<const NodeType*> (parent));
#else
  // DQ (10/20/2012): Using Robb's newer version with my modification to use the definingDeclaration rather than firstNondefiningDeclaration (below).

       // Find the parent of specified type, but watch out for cycles in the ancestry (which would cause an infinite loop).
       // Cast away const because isSg* functions aren't defined for const node pointers; and our return is not const.
       SgNode *node = const_cast<SgNode*>(!astNode || includingSelf ? astNode : astNode->get_parent());
       std::set<const SgNode*> seen; // nodes we've seen, in order to detect cycles
       while (node) {
           if (NodeType *found = dynamic_cast<NodeType*>(node))
               return found;

           // FIXME: Cycle detection could be moved elsewhere so we don't need to do it on every call. [RPM 2012-10-09]
           ROSE_ASSERT(seen.insert(node).second);

           // Traverse to parent (declaration statements are a special case)
           if (SgDeclarationStatement *declarationStatement = isSgDeclarationStatement(node)) {
               SgDeclarationStatement *definingDeclaration = declarationStatement->get_definingDeclaration();
               SgDeclarationStatement *firstNondefiningDeclaration = declarationStatement->get_firstNondefiningDeclaration();
               if (definingDeclaration && firstNondefiningDeclaration && declarationStatement != firstNondefiningDeclaration) {
                // DQ (10/19/2012): Use the defining declaration instead.
                // node = firstNondefiningDeclaration;
                   node = definingDeclaration;
               }
           } else {
               node = node->get_parent();
           }
       }
       return NULL;
#endif
   }

  ROSE_DLL_API SgSourceFile* getEnclosingSourceFile(SgNode* n, const bool includingSelf=false);

  ROSE_DLL_API SgScopeStatement* getScope(const SgNode* astNode);

  ROSE_DLL_API SgScopeStatement* getEnclosingScope(SgNode* n, const bool includingSelf=false);

  ROSE_DLL_API SgGlobal* getGlobalScope( const SgNode* astNode);


  ROSE_DLL_API SgFunctionDefinition* getEnclosingProcedure(SgNode* n, const bool includingSelf=false);

  ROSE_DLL_API SgFunctionDefinition* getEnclosingFunctionDefinition(SgNode* astNode, const bool includingSelf=false);

  ROSE_DLL_API SgStatement* getEnclosingStatement(SgNode* n);

  ROSE_DLL_API SgSwitchStatement* findEnclosingSwitch(SgStatement* s);

  ROSE_DLL_API SgScopeStatement* findEnclosingLoop(SgStatement* s, const std::string& fortranLabel = "", bool stopOnSwitches = false);

  ROSE_DLL_API SgFunctionDeclaration * getEnclosingFunctionDeclaration (SgNode * astNode, const bool includingSelf=false);
   //roseSupport/utility_functions.h
  ROSE_DLL_API SgFile* getEnclosingFileNode (SgNode* astNode );

  ROSE_DLL_API SgInitializer* getInitializerOfExpression(SgExpression* n);

  ROSE_DLL_API SgClassDefinition* getEnclosingClassDefinition(SgNode* astnode, const bool includingSelf=false);

// TODO
#if 0
   SgNode * getEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
   std::vector<SgNode *>  getAllEnclosingSgNode(SgNode* source,VariantT, SgNode* endNode=NULL);
   SgVariableDeclaration* findVariableDeclaratin( const string& varname)

   SgClassDeclaration* getEnclosingClassDeclaration( const SgNode* astNode);

   // e.g. for some expression, find its parent statement
   SgStatement* getEnclosingStatement(const SgNode* astNode);

   SgSwitchStatement* getEnclosingSwitch(SgStatement* s);
   SgModuleStatement* getEnclosingModuleStatement( const SgNode* astNode);

  // used to build a variable reference for compiler generated code in current scope
   SgSymbol * findReachingDefinition (SgScopeStatement* startScope, SgName &name);
#endif


//------------------------------------------------------------------------

  // Liao, 1/9/2008
  ROSE_DLL_API SgGlobal * getFirstGlobalScope(SgProject *project);

  ROSE_DLL_API SgStatement* getLastStatement(SgScopeStatement *scope);

  ROSE_DLL_API SgStatement* getFirstStatement(SgScopeStatement *scope,bool includingCompilerGenerated=false);
  ROSE_DLL_API SgFunctionDeclaration* findFirstDefiningFunctionDecl(SgScopeStatement* scope);

  ROSE_DLL_API SgStatement* getNextStatement(SgStatement * currentStmt);

  ROSE_DLL_API SgStatement* getPreviousStatement(SgStatement * currentStmt);
#if 0 //TODO
  // preorder traversal from current SgNode till find next SgNode of type V_SgXXX
  SgNode* getNextSgNode( const SgNode* currentNode, VariantT=V_SgNode);
#endif


//------------------------------------------------------------------------

 ROSE_DLL_API bool isEqualToIntConst(SgExpression* e, int value);


 ROSE_DLL_API bool isSameFunction(SgFunctionDeclaration* func1, SgFunctionDeclaration* func2);

 ROSE_DLL_API bool isLastStatement(SgStatement* stmt);


//------------------------------------------------------------------------

// DQ (2/24/2009): Simple function to delete an AST subtree (used in outlining).
ROSE_DLL_API void deleteAST(SgNode* node);

ROSE_DLL_API void deleteExpressionTreeWithOriginalExpressionSubtrees(SgNode* root);

// DQ (2/25/2009): Added new function to support outliner.
ROSE_DLL_API void moveStatementsBetweenBlocks ( SgBasicBlock* sourceBlock, SgBasicBlock* targetBlock );


ROSE_DLL_API void appendStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);

ROSE_DLL_API void appendStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);

// DQ (2/6/2009): Added function to support outlining into separate file.
ROSE_DLL_API void appendStatementWithDependentDeclaration( SgDeclarationStatement* decl, SgGlobal* scope, SgStatement* original_statement, bool excludeHeaderFiles );

ROSE_DLL_API void prependStatement(SgStatement *stmt, SgScopeStatement* scope=NULL);

ROSE_DLL_API void prependStatementList(const std::vector<SgStatement*>& stmt, SgScopeStatement* scope=NULL);

ROSE_DLL_API bool  hasSimpleChildrenList (SgScopeStatement* scope);

ROSE_DLL_API void insertStatement(SgStatement *targetStmt, SgStatement* newStmt, bool insertBefore= true, bool autoMovePreprocessingInfo = true);

//target's scope
ROSE_DLL_API void insertStatementList(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts, bool insertBefore= true);

ROSE_DLL_API void insertStatementBefore(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);

ROSE_DLL_API void insertStatementListBefore(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmts);

ROSE_DLL_API void insertStatementAfter(SgStatement *targetStmt, SgStatement* newStmt, bool autoMovePreprocessingInfo = true);

ROSE_DLL_API void insertStatementListAfter(SgStatement *targetStmt, const std::vector<SgStatement*>& newStmt);

ROSE_DLL_API void insertStatementAfterLastDeclaration(SgStatement* stmt, SgScopeStatement* scope);

ROSE_DLL_API void insertStatementAfterLastDeclaration(std::vector<SgStatement*> stmt_list, SgScopeStatement* scope);

//  then the statement is inserted at the end of the scope.
ROSE_DLL_API void insertStatementBeforeFirstNonDeclaration(SgStatement *newStmt, SgScopeStatement *scope,
                                                           bool movePreprocessingInfo=true);

//then the new statements are inserted at the end of the scope.
ROSE_DLL_API void insertStatementListBeforeFirstNonDeclaration(const std::vector<SgStatement*> &newStmts,
                                                               SgScopeStatement *scope);

ROSE_DLL_API void removeStatement(SgStatement* stmt, bool autoRelocatePreprocessingInfo = true);

ROSE_DLL_API void deepDelete(SgNode* root);

ROSE_DLL_API void replaceStatement(SgStatement* oldStmt, SgStatement* newStmt, bool movePreprocessinInfo = false);

ROSE_DLL_API SgNode* replaceWithPattern (SgNode * anchor, SgNode* new_pattern);

std::pair<SgVariableDeclaration*, SgExpression* > createTempVariableForExpression(SgExpression* expression,
        SgScopeStatement* scope, bool initializeInDeclaration, SgAssignOp** reEvaluate = NULL);

/*  This function creates a temporary variable for a given expression in the given scope
   This is different from SageInterface::createTempVariableForExpression in that it does not
   try to be smart to create pointers to reference types and so on. The tempt is initialized to expression.
   The caller is responsible for setting the parent of SgVariableDeclaration since buildVariableDeclaration
   may not set_parent() when the scope stack is empty. See programTransformation/extractFunctionArgumentsNormalization/ExtractFunctionArguments.C for sample usage.
   @param expression Expression which will be replaced by a variable
   @param scope scope in which the temporary variable will be generated
*/
    
std::pair<SgVariableDeclaration*, SgExpression*> createTempVariableAndReferenceForExpression
    (SgExpression* expression, SgScopeStatement* scope);
    

ROSE_DLL_API SgVariableSymbol* appendArg(SgFunctionParameterList *, SgInitializedName*);
ROSE_DLL_API SgVariableSymbol* prependArg(SgFunctionParameterList *, SgInitializedName*);

ROSE_DLL_API void appendExpression(SgExprListExp *, SgExpression*);

ROSE_DLL_API void appendExpressionList(SgExprListExp *, const std::vector<SgExpression*>&);

// void setParameterList(SgFunctionDeclaration *func,SgFunctionParameterList *paralist);
template <class actualFunction> 
ROSE_DLL_API void setParameterList(actualFunction *func,SgFunctionParameterList *paralist);

# if 1
  // DQ (11/25/2011): Moved to the header file so that it could be seen as a template function.

  // TODO consider the difference between C++ and Fortran
  // fixup the scope of arguments,no symbols for nondefining function declaration's arguments
template <class actualFunction>
void
// SageInterface::setParameterList(SgFunctionDeclaration * func,SgFunctionParameterList * paralist)
setParameterList(actualFunction* func, SgFunctionParameterList* paralist)
   {
  // DQ (11/25/2011): Modified this to be a templated function so that we can handle both 
  // SgFunctionDeclaration and SgTemplateFunctionDeclaration (and their associated member 
  // function derived classes).

     ROSE_ASSERT(func != NULL);
     ROSE_ASSERT(paralist != NULL);

#if 0
  // At this point we don't have cerr and endl defined, so comment this code out.
  // Warn to users if a paralist is being shared
     if (paralist->get_parent() !=NULL)
        {
          cerr << "Waring! Setting a used SgFunctionParameterList to function: "
               << (func->get_name()).getString()<<endl
               << " Sharing parameter lists can corrupt symbol tables!"<<endl
               << " Please use deepCopy() to get an exclusive parameter list for each function declaration!"<<endl;
       // ROSE_ASSERT(false);
        }
#endif

  // Liao,2/5/2008  constructor of SgFunctionDeclaration will automatically generate SgFunctionParameterList, so be cautious when set new paralist!!
     if (func->get_parameterList() != NULL)
        {
          if (func->get_parameterList() != paralist)
             {
               delete func->get_parameterList();
             }
        }

     func->set_parameterList(paralist);
     paralist->set_parent(func);

  // DQ (5/15/2012): Need to set the declptr in each SgInitializedName IR node.
  // This is needed to support the AST Copy mechanism (at least). The files: test2005_150.C, 
  // test2012_81.C and testcode2012_82.C demonstrate this problem.
     SgInitializedNamePtrList & args = paralist->get_args();
     for (SgInitializedNamePtrList::iterator i = args.begin(); i != args.end(); i++)
        {
          (*i)->set_declptr(func);
        }
   }
#endif

ROSE_DLL_API void setPragma(SgPragmaDeclaration* decl, SgPragma *pragma);

ROSE_DLL_API void replaceExpression(SgExpression* oldExp, SgExpression* newExp, bool keepOldExp=false);

ROSE_DLL_API void replaceExpressionWithStatement(SgExpression* from,
                                    SageInterface::StatementGenerator* to);
ROSE_DLL_API void replaceSubexpressionWithStatement(SgExpression* from,
                                      SageInterface::StatementGenerator* to);

ROSE_DLL_API void setOperand(SgExpression* target, SgExpression* operand);

ROSE_DLL_API void setLhsOperand(SgExpression* target, SgExpression* lhs);

ROSE_DLL_API void setRhsOperand(SgExpression* target, SgExpression* rhs);

ROSE_DLL_API void removeAllOriginalExpressionTrees(SgNode* top);

// DQ (1/25/2010): Added support for directories
ROSE_DLL_API void moveToSubdirectory ( std::string directoryName, SgFile* file );

ROSE_DLL_API SgStatement* findSurroundingStatementFromSameFile(SgStatement* targetStmt, bool & surroundingStatementPreceedsTargetStatement);

ROSE_DLL_API void moveCommentsToNewStatement(SgStatement* sourceStatement, const std::vector<int> & indexList, SgStatement* targetStatement, bool surroundingStatementPreceedsTargetStatement);

//------------------------------------------------------------------------


ROSE_DLL_API int fixVariableReferences(SgNode* root);


void fixVariableDeclaration(SgVariableDeclaration* varDecl, SgScopeStatement* scope);

void fixStructDeclaration(SgClassDeclaration* structDecl, SgScopeStatement* scope);
void fixClassDeclaration(SgClassDeclaration* classDecl, SgScopeStatement* scope);

void fixNamespaceDeclaration(SgNamespaceDeclarationStatement* structDecl, SgScopeStatement* scope);


void fixLabelStatement(SgLabelStatement* label_stmt, SgScopeStatement* scope);

void setFortranNumericLabel(SgStatement* stmt, int label_value);

int  suggestNextNumericLabel(SgFunctionDefinition* func_def);

void fixFunctionDeclaration(SgFunctionDeclaration* stmt, SgScopeStatement* scope);

void fixTemplateDeclaration(SgTemplateDeclaration* stmt, SgScopeStatement* scope);

void fixStatement(SgStatement* stmt, SgScopeStatement* scope);


void updateDefiningNondefiningLinks(SgFunctionDeclaration* func, SgScopeStatement* scope);

//------------------------------------------------------------------------

ROSE_DLL_API bool
collectReadWriteRefs(SgStatement* stmt, std::vector<SgNode*>& readRefs, std::vector<SgNode*>& writeRefs, bool useCachedDefUse=false);

ROSE_DLL_API bool collectReadWriteVariables(SgStatement* stmt, std::set<SgInitializedName*>& readVars, std::set<SgInitializedName*>& writeVars);

ROSE_DLL_API void collectReadOnlyVariables(SgStatement* stmt, std::set<SgInitializedName*>& readOnlyVars);

ROSE_DLL_API void collectReadOnlySymbols(SgStatement* stmt, std::set<SgVariableSymbol*>& readOnlySymbols);

ROSE_DLL_API bool isUseByAddressVariableRef(SgVarRefExp* ref);

ROSE_DLL_API void collectUseByAddressVariableRefs (const SgStatement* s, std::set<SgVarRefExp* >& varSetB);

#ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
ROSE_DLL_API LivenessAnalysis * call_liveness_analysis(SgProject* project, bool debug=false);

ROSE_DLL_API void getLiveVariables(LivenessAnalysis * liv, SgForStatement* loop, std::set<SgInitializedName*>& liveIns, std::set<SgInitializedName*> & liveOuts);
#endif

ROSE_DLL_API void ReductionRecognition(SgForStatement* loop, std::set< std::pair <SgInitializedName*, VariantT> > & results);


ROSE_DLL_API void constantFolding(SgNode* r);


ROSE_DLL_API int instrumentEndOfFunction(SgFunctionDeclaration * func, SgStatement* s);

ROSE_DLL_API void removeJumpsToNextStatement(SgNode*);

ROSE_DLL_API void removeUnusedLabels(SgNode* top);

ROSE_DLL_API void removeConsecutiveLabels(SgNode* top);


 ROSE_DLL_API SgAssignInitializer* splitExpression(SgExpression* from, std::string newName = "");

ROSE_DLL_API void splitExpressionIntoBasicBlock(SgExpression* expr);

ROSE_DLL_API void removeLabeledGotos(SgNode* top);

ROSE_DLL_API void changeBreakStatementsToGotos(SgStatement* loopOrSwitch);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfFor(SgForStatement* fs);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfUpcForAll(SgUpcForAllStatement* fs);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfWhile(SgWhileStmt* ws);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfDoWhile(SgDoWhileStmt* ws);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfSwitch(SgSwitchStatement* ws);

SgBasicBlock* ensureBasicBlockAsBodyOfCaseOption(SgCaseOptionStmt* cs);

SgBasicBlock* ensureBasicBlockAsBodyOfDefaultOption(SgDefaultOptionStmt * cs);
    
ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsTrueBodyOfIf(SgIfStmt* ifs);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsFalseBodyOfIf(SgIfStmt* ifs);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfCatch(SgCatchOptionStmt* cos);

ROSE_DLL_API SgBasicBlock* ensureBasicBlockAsBodyOfOmpBodyStmt(SgOmpBodyStatement* ompbodyStmt);


bool isBodyStatement (SgStatement* s);

void changeAllBodiesToBlocks(SgNode* top);

void changeAllLoopBodiesToBlocks(SgNode* top);

SgBasicBlock * makeSingleStatementBodyToBlock(SgStatement* singleStmt);

#if 0

SgLocatedNode* ensureBasicBlockAsParent(SgStatement* s);
#endif

unsigned long long getIntegerConstantValue(SgValueExp* expr);

std::vector<SgDeclarationStatement*> getDependentDeclarations (SgStatement* stmt );


SgCommaOpExp *insertBeforeUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp);

SgCommaOpExp *insertAfterUsingCommaOp (SgExpression* new_exp, SgExpression* anchor_exp, SgStatement** temp_decl = NULL, SgVarRefExp** temp_ref = NULL);


std::pair<SgStatement*, SgInitializedName*>
wrapFunction(SgFunctionDeclaration& definingDeclaration, SgName newName);

template <class NameGen>
std::pair<SgStatement*, SgInitializedName*>
wrapFunction(SgFunctionDeclaration& definingDeclaration, NameGen nameGen)
{
  return wrapFunction(definingDeclaration, nameGen(definingDeclaration.get_name()));
}

SgInitializedName& getFirstVariable(SgVariableDeclaration& vardecl);



// DQ (6/7/2012): Unclear where this function should go...
  bool hasTemplateSyntax( const SgName & name );


#if 0

//------------------------AST dump, stringify-----------------------------
//------------------------------------------------------------------------
  std::string buildOperatorString ( SgNode* astNode ); //transformationSupport.h

  // do we need these?
  std::string dump_node(const SgNode* astNode);
  std::string dump_tree(const SgNode* astNode);

  // or a friendly version of  unparseToString(), as a memeber function
  std::string SgNode::toString(bool asSubTree=true); // dump node or subtree

//----------------------------AST comparison------------------------------
//------------------------------------------------------------------------
// How to get generic functions for comparison?
  bool isNodeEqual(SgNode* node1, SgNode* node2); //?
  bool isTreeEqual(SgNode* tree1, SgNode* tree2);

  bool expressionTreeEqual(SgExpression*, SgExpression*);
  bool expressionTreeEqualStar(const SgExpressionPtrList&,
                             const SgExpressionPtrList&);

//----------------------AST verfication/repair----------------------------
//------------------------------------------------------------------------
// sanity check of AST subtree, any suggestions?
//  TODO
    verifySgNode(SgNode* node, bool subTree=true);
  //src/midend/astDiagnostics/AstConsistencyTests.h
  // AstTests::runAllTests(SgProject * )

  //src/midend/astUtil/astInterface/AstInterface.h.C
  //FixSgProject(SgProject &project)
  //FixSgTree(SgNode* r)

  //src/frontend/SageIII/astPostProcessing
  //AstPostProcessing(SgNode * node)

//--------------------------AST modification------------------------------
//------------------------------------------------------------------------
// any operations changing AST tree, including
// insert, copy, delete(remove), replace

  // insert before or after some point, argument list is consistent with LowLevelRewrite
  void insertAst(SgNode* targetPosition, SgNode* newNode, bool insertBefore=true);

  // previous examples
  //void myStatementInsert(SgStatement* target,...)
  // void AstInterfaceBase::InsertStmt(AstNodePtr const & orig, AstNodePtr const &n, bool insertbefore, bool extractfromBasicBlock)

  // copy
  // copy children of one basic block to another basic block
  //void appendStatementCopy (const SgBasicBlock* a, SgBasicBlock* b);
  void copyStatements (const SgBasicBlock* src, SgBasicBlock* dst);

  // delete (remove) a node or a whole subtree
  void removeSgNode(SgNode* targetNode); // need this?
  void removeSgNodeTree(SgNode* subtree); // need this?

  void removeStatement( SgStatement* targetStmt);

  //Move = delete + insert
  void moveAst (SgNode* src, SgNode* target); // need this?
      // similar to
  void moveStatements (SgBasicBlock* src, SgBasicBlock* target);

  // replace= delete old + insert new (via building or copying)

// DQ (1/25/2010): This does not appear to exist as a definition anywhere in ROSE.
// void replaceAst(SgNode* oldNode, SgNode* newNode);

   //void replaceChild(SgNode* parent, SgNode* from, SgNode* to);
   //bool AstInterface::ReplaceAst( const AstNodePtr& orig, const AstNodePtr& n)

//--------------------------AST transformations---------------------------
//------------------------------------------------------------------------
// Advanced AST modifications through basic AST modifications
// Might not be included in AST utitlity list, but listed here for the record.

  // extract statements/content from a scope
  void flattenBlocks(SgNode* n);

  //src/midend/astInlining/inlinerSupport.h
  void renameVariables(SgNode* n);
  void renameLabels(SgNode* n, SgFunctionDefinition* enclosingFunctionDefinition);

  void simpleCopyAndConstantPropagation(SgNode* top);
  void changeAllMembersToPublic(SgNode* n);

  void removeVariableDeclaration(SgInitializedName* initname);

  SgAssignOp* convertInitializerIntoAssignment(SgAssignInitializer* init);

  void pushTestIntoBody(LoopStatement* loopStmt);

  //programTransformation/finiteDifferencing/finiteDifferencing.h
  void moveForDeclaredVariables(SgNode* root);

//------------------------ Is/Has functions ------------------------------
//------------------------------------------------------------------------
// misc. boolean functions
// some of them could moved to SgXXX class as a member function

  bool isOverloaded (SgFunctionDeclaration * functionDeclaration);

  bool isSwitchCond (const SgStatement* s);
  bool isIfCond (const SgStatement* s);
  bool isWhileCond (const SgStatement* s);
  bool isStdNamespace (const SgScopeStatement* scope);
  bool isTemplateInst (const SgDeclarationStatement* decl);


  bool isCtor (const SgFunctionDeclaration* func);
  bool isDtor (const SgFunctionDeclaration* func);

   // src/midend/astInlining/typeTraits.h
  bool hasTrivialDestructor(SgType* t);
  ROSE_DLL_API bool isNonconstReference(SgType* t);
  ROSE_DLL_API bool isReferenceType(SgType* t);

  //  generic ones, or move to the SgXXX class as a member function

  bool isConst(SgNode* node); // const type, variable, function, etc.
  // .... and more

  bool isConstType (const SgType* type);
  bool isConstFunction (const SgFunctionDeclaration* decl);


  bool isMemberVariable(const SgInitializedName & var);
  //bool isMemberVariable(const SgNode& in);

  bool isPrototypeInScope (SgScopeStatement * scope,
                           SgFunctionDeclaration * functionDeclaration,
                           SgDeclarationStatement * startingAtDeclaration);

  bool MayRedefined(SgExpression* expr, SgNode* root);
  // bool isPotentiallyModified(SgExpression* expr, SgNode* root); // inlinderSupport.h
  bool hasAddressTaken(SgExpression* expr, SgNode* root);

  //src/midend/astInlining/inlinerSupport.C
     // can also classified as topdown search
  bool containsVariableReference(SgNode* root, SgInitializedName* var);

  bool isDeclarationOf(SgVariableDeclaration* decl, SgInitializedName* var);
  bool isPotentiallyModifiedDuringLifeOf(SgBasicBlock* sc,
                                       SgInitializedName* toCheck,
                                       SgInitializedName* lifetime)
  //src/midend/programTransformation/partialRedundancyElimination/pre.h
  bool anyOfListPotentiallyModifiedIn(const std::vector<SgVariableSymbol*>& syms, SgNode* n);

//------------------------ loop handling ---------------------------------
//------------------------------------------------------------------------
  //get and set loop control expressions
  // 0: init expr, 1: condition expr, 2: stride expr

  SgExpression* getForLoopTripleValues(int valuetype,SgForStatement* forstmt );
  int setForLoopTripleValues(int valuetype,SgForStatement* forstmt, SgExpression* exp);

  bool isLoopIndexVarRef(SgForStatement* forstmt, SgVarRefExp *varref);
  SgInitializedName * getLoopIndexVar(SgForStatement* forstmt);

//------------------------expressions-------------------------------------
//------------------------------------------------------------------------
  //src/midend/programTransformation/partialRedundancyElimination/pre.h
  int countComputationsOfExpressionIn(SgExpression* expr, SgNode* root);

        //src/midend/astInlining/replaceExpressionWithStatement.h
  void replaceAssignmentStmtWithStatement(SgExprStatement* from, StatementGenerator* to);

  void replaceSubexpressionWithStatement(SgExpression* from,
                                       StatementGenerator* to);
  SgExpression* getRootOfExpression(SgExpression* n);

//--------------------------preprocessing info. -------------------------
//------------------------------------------------------------------------
  void cutPreprocInfo (SgBasicBlock* b,
                       PreprocessingInfo::RelativePositionType pos,
                       AttachedPreprocessingInfoType& save_buf);
  void pastePreprocInfoFront (AttachedPreprocessingInfoType& save_buf,
                              SgStatement* s);
  void pastePreprocInfoBack (AttachedPreprocessingInfoType& save_buf,
                             SgStatement* s);

  // a generic one for all
  void moveBeforePreprocInfo (SgStatement* src, SgStatement* dest);
  void moveInsidePreprocInfo (SgBasicBlock* src, SgBasicBlock* dest);
  void moveAfterPreprocInfo (SgStatement* src, SgStatement* dest);

//--------------------------------operator--------------------------------
//------------------------------------------------------------------------
  from transformationSupport.h, not sure if they should be included here
  /* return enum code for SAGE operators */
  operatorCodeType classifyOverloadedOperator(); // transformationSupport.h

  std::string stringifyOperator (std::string name);

//--------------------------------macro ----------------------------------
//------------------------------------------------------------------------
  std::string buildMacro ( std::string s ); //transformationSupport.h

//--------------------------------access functions---------------------------
//----------------------------------get/set sth.-----------------------------
// several categories:
* get/set a direct child/grandchild node or fields
* get/set a property flag value
* get a descendent child node using preorder searching
* get an ancestor node using bottomup/reverse searching

        // SgName or string?
  std::string getFunctionName (SgFunctionCallExp* functionCallExp);
  std::string getFunctionTypeName ( SgFunctionCallExp* functionCallExpression );

    // do we need them anymore? or existing member functions are enought?
    // a generic one:
   std::string get_name (const SgNode* node);
   std::string get_name (const SgDeclarationStatement * declaration);

  // get/set some property: should moved to SgXXX as an inherent memeber function?
  // access modifier
  void  setExtern (SgFunctionDeclartion*)
  void  clearExtern()

   // similarly for other declarations and other properties
  void setExtern (SgVariableDeclaration*)
  void setPublic()
  void setPrivate()

#endif

// DQ (1/23/2013): Added support for generated a set of source sequence entries.
   std::set<unsigned int> collectSourceSequenceNumbers( SgNode* astNode );
      
//--------------------------------Type Traits (C++)---------------------------
      bool HasNoThrowAssign(const SgType * const inputType);
      bool HasNoThrowCopy(const SgType * const inputType);
      bool HasNoThrowConstructor(const SgType * const inputType);
      bool HasTrivialAssign(const SgType * const inputType);
      bool HasTrivialCopy(const SgType * const inputType);
      bool HasTrivialConstructor(const SgType * const inputType);
      bool HasTrivialDestructor(const SgType * const inputType);
      bool HasVirtualDestructor(const SgType * const inputType);
      bool IsBaseOf(const SgType * const inputBaseType, const SgType * const inputDerivedType);
      bool IsAbstract(const SgType * const inputType);
      bool IsClass(const SgType * const inputType);
      bool IsEmpty(const SgType * const inputType);
      bool IsEnum(const SgType * const inputType);
      bool IsPod(const SgType * const inputType);
      bool IsPolymorphic(const SgType * const inputType);
      bool IsStandardLayout(const SgType * const inputType);
      bool IsLiteralType(const SgType * const inputType);
      bool IsTrivial(const SgType * const inputType);
      bool IsUnion(const SgType * const inputType);
      SgType *  UnderlyingType(SgType *type);

// DQ (3/2/2014): Added a new interface function (used in the snippet insertion support).
   void supportForInitializedNameLists ( SgScopeStatement* scope, SgInitializedNamePtrList & variableList );

// DQ (3/4/2014): Added support for testing two trees for equivalents using the AST iterators.
   bool isStructurallyEquivalentAST( SgNode* tree1, SgNode* tree2 );

//--------------------------------Java interface functions ---------------------
//#ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
      std::string getTempDirectory(SgProject *project);
      void destroyTempDirectory(std::string);
      SgFile *processFile(SgProject *, std::string, bool unparse = false);
      std::string preprocessPackage(SgProject *, std::string);
      std::string preprocessImport(SgProject *, std::string);
      SgFile* preprocessCompilationUnit(SgProject *, std::string, std::string, bool unparse = true);
      SgClassDefinition *findJavaPackage(SgScopeStatement *, std::string);
      SgClassDefinition *findOrInsertJavaPackage(SgProject *, std::string, bool create_directory = false);
      SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassDefinition *package_definition, std::string);
      SgClassDeclaration *findOrImportJavaClass(SgProject *, std::string, std::string);
      SgClassDeclaration *findOrImportJavaClass(SgProject *, SgClassType *);
      SgMemberFunctionDeclaration *findJavaMain(SgClassDefinition *);
      SgMemberFunctionDeclaration *findJavaMain(SgClassType *);
//#endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT

}// end of namespace

#endif