ROSE  0.11.28.0
utility_functions.h
1 // utility_functions.h -- header file for the ROSE Optimizing Preprocessor
2 
3 #ifndef UTILITY_FUNCTIONS_H
4 #define UTILITY_FUNCTIONS_H
5 
6 #include "Cxx_Grammar.h"
7 class UnparseDelegate;
8 
9 #define BACKEND_VERBOSE_LEVEL 2
10 
11 // DQ (11/1/2009): replaced "version()" with separate "version_number()" and "version_message()" functions.
12 // returns a string containing the current version message (includes the version number).
13 std::string version_message();
14 
15 // DQ (11/1/2009): replaced "version()" with separate "version_number()" and "version_message()" functions.
16 // returns a string containing the current version number
17 std::string version_number();
18 
20 unsigned int rose_boost_version_id();
21 
23 std::string rose_boost_version_path();
24 
25 // DQ (7/3/2013): Added support to output pre-defined macro settings.
27 void outputPredefinedMacros();
28 
29 
30 // Simple interface for ROSE (error codes are in SgProject.frontendErrorCode(), backendErrorCode() )
31 // tps : Need to make this function (DLL) public
32 ROSE_DLL_API SgProject* frontend ( int argc, char** argv, bool frontendConstantFolding = false );
33 ROSE_DLL_API SgProject* frontend ( const std::vector<std::string>& argv, bool frontendConstantFolding = false );
34 
35 // DQ (4/17/2015): After discussion with Liao, Markus, and Pei-Hung, we have agreed that
36 // we want to support multiple SgProject IR nodes. So in addition to the SgProject* frontend()
37 // function we will in the future support:
38 // 1) A SgProject member function "frontend()" that can be used to generate a new SgFile in
39 // an existing SgProject.
40 // 2) A SgBuilder function for building an empty SgProject (without files).
41 // 3) We will remove the use of the SageInterface::getProject() (which asserts that there
42 // is only one SgProject).
43 
44 // This builds a shell of a frontend SgProject with associated SgFile objects (but with empty
45 // SgGlobal objects) supporting only commandline processing and requiring the frontend to be
46 // called explicitly for each SgFile object. See tutorial/selectedFileTranslation.C for example.
47 SgProject* frontendShell ( int argc, char** argv);
48 ROSE_DLL_API SgProject* frontendShell ( const std::vector<std::string>& argv);
49 
50 // DQ (3/18/2006): Modified backend function interface to permit handling of user specified
51 // objects to control the formatting of code generation and the use of alternative code generation
52 // techniques (e.g. copy-based code generation).
53 // int backend ( SgProject* project );
54 //
55 // WARNING: If a non-null unparseFormatHelp is specified then backend will unconditionally delete it. Therefore, the caller
56 // must have allocated it on the heap or else strange errors will result.
57 ROSE_DLL_API int backend ( SgProject* project, UnparseFormatHelp *unparseFormatHelp = NULL, UnparseDelegate* unparseDelegate = NULL );
58 
59 // DQ (8/24/2009): This backend calls the backend compiler using the original input source file list.
60 // This is useful as a test code for testing ROSE for use on projects that target Compass or any
61 // other analysis only tool using ROSE. Called in tests/nonsmoke/functional/testAnalysis.C for example.
62 ROSE_DLL_API int backendCompilesUsingOriginalInputFile ( SgProject* project, bool compile_with_USE_ROSE_macro = false );
63 
64 // DQ (2/6/2010): This backend forces all code to be generated but still uses the backend vendor
65 // compiler to compile the original code. This is a step between backendUsingOriginalInputFile(),
66 // which does not generate code; and backend() which generated code and compiles it. The use of
67 // this backend permits an intermediate test of robustness where the code that we generate might
68 // be generated incorrectly (usually with missing name qualification as required for a specific
69 // backend (vendor) compiler).
70 ROSE_DLL_API int backendGeneratesSourceCodeButCompilesUsingOriginalInputFile ( SgProject* project );
71 
72 //QY: new back end that performs only source-to-source translations
73 // of the original file. Furthermore, statements are copied from
74 // the original file if they are not changed
75 ROSE_DLL_API int copy_backend( SgProject* project, UnparseFormatHelp *unparseFormatHelp = NULL );
76 
77 // int globalBackendErrorCode = 0;
78 // int backend ( const SgProject & project, int & errorCode = globalBackendErrorCode);
79 // SgProject & frontend ( int argc, char * argv[] );
80 
81 ROSE_DLL_API void generatePDF ( const SgProject & project );
82 
83 // DQ (12/20/2018): Added option to exclude template instantiations which make the graphs smaller and tractable t manage for larger C++ applications.
84 ROSE_DLL_API void generateDOT ( const SgProject & project, std::string filenamePostfix = "", bool excludeTemplateInstantiations = false );
85 
86 // DQ (9/22/2017): Adding support that is can work with any IR node, so that we can generated DOT files on untyped ASTs.
87 // I prefer the API that takes a SgNode pointer.
88 // ROSE_DLL_API void generateDOT ( SgNode* node, std::string baseFilename, std::string filenamePostfix = "" );
89 ROSE_DLL_API void generateDOT ( SgNode* node, std::string filename );
90 
91 // DQ (9/1/2008): Added function to generate the compete AST when specificed with multiple files
92 // on the command line. This is the older default behavior of generateDOT (from last year, or so).
93 ROSE_DLL_API void generateDOT_withIncludes ( const SgProject & project, std::string filenamePostfix = "" );
94 ROSE_DLL_API void generateDOTforMultipleFile ( const SgProject & project, std::string filenamePostfix = "" );
95 
96 // DQ (6/14/2007): Support for whole AST graphs output with attributes (types, symbols, all edges, etc.)
97 // We define a default value for the maximum graph size (number of nodes).
98 ROSE_DLL_API void generateAstGraph ( const SgProject* project, int maxSize = 2000, std::string filenameSuffix = "" );
99 // void generateAstGraph ( const SgProject* project, int maxSize, std::string filenameSuffix = "", CustomMemoryPoolDOTGeneration::s_Filter_Flags* filter_flags = NULL)
100 
101 // output of EDG AST (useful for debugging connection to SAGE)
102 //void pdfPrintAbstractSyntaxTreeEDG ( SgFile *file );
103 // void generatePDFofEDG ( const SgProject & project );
104 
105 #ifndef SWIG
106 
107 //#include "rose.h"
108 //#include "../midend/astProcessing/DOTGeneration.h"
109 //#include "roseInternal.h"
110 //#include "../midend/astProcessing/AstDotGeneration.h"
111 //using namespace AstDOTGenerationExtended_Defaults;
112 //#include "../midend/astProcessing/AstDOTGeneration.h"
113 #include "AstDOTGeneration.h"
114 
115 template <typename ExtraNodeInfo_t = AstDOTGenerationExtended_Defaults::DefaultExtraNodeInfo, typename ExtraNodeOptions_t = AstDOTGenerationExtended_Defaults::DefaultExtraNodeOptions, typename ExtraEdgeInfo_t = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeInfo, typename ExtraEdgeOptions_t = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeOptions>
117 //void
118 //generateDOTExtended ( const SgProject & project, std::string filenamePostfix = "", ExtraNodeInfo_t eni = AstDOTGenerationExtended_Defaults::DefaultExtraNodeInfo(), ExtraNodeOptions_t eno = AstDOTGenerationExtended_Defaults::DefaultExtraNodeOptions(), ExtraEdgeInfo_t eei = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeInfo(), ExtraEdgeOptions_t eeo = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeOptions() );
119 
120 template <typename ExtraNodeInfo_t = AstDOTGenerationExtended_Defaults::DefaultExtraNodeInfo, typename ExtraNodeOptions_t = AstDOTGenerationExtended_Defaults::DefaultExtraNodeOptions, typename ExtraEdgeInfo_t = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeInfo, typename ExtraEdgeOptions_t = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeOptions>
122 
123 template <typename ExtraNodeInfo_t = AstDOTGenerationExtended_Defaults::DefaultExtraNodeInfo, typename ExtraNodeOptions_t = AstDOTGenerationExtended_Defaults::DefaultExtraNodeOptions, typename ExtraEdgeInfo_t = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeInfo, typename ExtraEdgeOptions_t = AstDOTGenerationExtended_Defaults::DefaultExtraEdgeOptions>
125 
126 // endif for ifndef SWIG
127 #endif
128 
129 #ifndef SWIG
130 // DQ (3/10/2013): Swig has a problem with:
131 // src/roseSupport/utility_functions.h:138: Error: 'stripPathFromFileName' is multiply defined in the generated target language module in scope 'roseJNI'.
132 // src/util/stringSupport/string_functions.h:221: Error: Previous declaration of 'stripPathFromFileName'
133 // src/util/stringSupport/string_functions.h:223: Error: Previous declaration of 'getPathFromFileName'
134 // So exclude this code below.
135 
136 namespace Rose
137  {
138  // This class serves as a catch all location for functions of general use within ROSE
139  // we have added variables that are set using command line parameters to avoid the use of
140  // global variables.
141 
142  // DQ (3/6/2017): Adding ROSE options data structure to support frontend and backend options such as:
143  // 1) output of warnings from the EDG (or other) frontend.
144  // 2) output of notes from the EDG (or other) frontend.
145  // 3) output of warnings from the backend compiler.
146  // The reason for this options clas is to support tools that would want to suppress warnings from ROSE,
147  // and still also permit compilers that would be implemented using ROSE to have the full range of output
148  // from EDG (or other frontends) to control notes and warnings.
149  class Options
150  {
151  private:
152  bool frontend_notes;
153  bool frontend_warnings;
154  bool backend_notes;
155  bool backend_warnings;
156 
157  public:
158  ROSE_DLL_API Options();
159  ROSE_DLL_API Options(const Options & X);
160  ROSE_DLL_API Options & operator= (const Options & X);
161 
162  // Access functions for options API.
163  ROSE_DLL_API bool get_frontend_notes();
164  ROSE_DLL_API void set_frontend_notes(bool flag);
165  ROSE_DLL_API bool get_frontend_warnings();
166  ROSE_DLL_API void set_frontend_warnings(bool flag);
167  ROSE_DLL_API bool get_backend_notes();
168  ROSE_DLL_API void set_backend_notes(bool flag);
169  ROSE_DLL_API bool get_backend_warnings();
170  ROSE_DLL_API void set_backend_warnings(bool flag);
171  };
172 
173  // Global variable (in this rose namespace) to permit multiple parts of ROSE to access consistant information on options.
174  ROSE_DLL_API extern Options global_options;
175 
176  // DQ (8/10/2004): This was moved to the SgFile a long time ago and should not be used any more)
177  // DQ (8/11/2004): Need to put this back so that there is a global concept of verbosity for all of ROSE.
178  // static int roseVerboseLevel;
179 
180  // These functions trim the header files from the unparsed output.
181  // static int isCutStart ( SgStatement *st );
182  // static int isCutEnd ( SgStatement *st );
183  // void ROSE_Unparse ( SgFile *f , std::ostream *of );
184 
185  // This function helps isolate the details of the UNIX strcmp function
186  // static int isSameName ( const std::string& s1, const std::string& s2 );
187  int containsString ( const std::string& masterString, const std::string& targetString );
188 
189  // DQ (9/5/2008): Try to remove these functions...
190  std::string getFileNameByTraversalBackToFileNode ( const SgNode* astNode );
191  // std::string getFileName ( const SgFile* file );
192 
193  // DQ (5/25/2005): Removed from ROSE class (since they are redundant with other uses)
194  std::string getFileName ( SgLocatedNode* locatedNodePointer ) ROSE_DEPRECATED_FUNCTION;
195  int getLineNumber ( SgLocatedNode* locatedNodePointer ) ROSE_DEPRECATED_FUNCTION;
196  int getColumnNumber ( SgLocatedNode* locatedNodePointer ) ROSE_DEPRECATED_FUNCTION;
197  bool isPartOfTransformation( SgLocatedNode* locatedNodePointer ) ROSE_DEPRECATED_FUNCTION;
198 
199  ROSE_DLL_API std::string getWorkingDirectory ();
200  ROSE_DLL_API std::string getSourceDirectory ( std::string fileNameWithPath );
201 
202  std::string getFileNameWithoutPath ( SgStatement* statementPointer );
203  ROSE_DLL_API std::string utility_stripPathFromFileName ( const std::string& fileNameWithPath );
204 
205  ROSE_DLL_API std::string getPathFromFileName ( std::string fileNameWithPath );
206 
207  // DQ (9/8/2008): This is removed since it is redundant with the version in StringUtility.
208  // std::string stripFileSuffixFromFileName ( const std::string& fileNameWithSuffix ); //! get the name without the ".C"
209 
210  // std::string getPragmaString ( SgStatement *stmt );
211  // std::string getPragmaString ( SgExpression *expr );
212 
213  // SgPragma* getPragma ( SgExpression *expr );
214  // SgPragma* getPragma ( SgStatement *stmt );
215  // SgPragma* getPragma ( SgBinaryOp *binaryOperator );
216 
217  // std::string identifyVariant ( int Code );
218 
219  SgName concatenate ( const SgName & X, const SgName & Y );
220 
221  ROSE_DLL_API void usage (int status);
222 
223  void filterInputFile ( const std::string inputFileName, const std::string outputFileName );
224 
226  SgStatement* getPreviousStatement ( SgStatement *targetStatement , bool climbOutScope = true);
227  SgStatement* getNextStatement ( SgStatement *targetStatement );
228 
229  // DQ (9/27/2018): We need to build multiple maps, one for each file (to support token based unparsing for multiple files,
230  // such as what is required when using the unparsing header files feature).
231  // DQ (10/28/2013): Put the token sequence map here, it is set and accessed via member functions on the SgSourceFile IR node.
232  // extern std::map<SgNode*,TokenStreamSequenceToNodeMapping*> tokenSubsequenceMap;
233  extern std::map<int,std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* > tokenSubsequenceMapOfMaps;
234 
235  // DQ (1/19/2021): This is part of moving to a new map that uses the SgSourceFile pointer instead of the fild_id.
236  extern std::map<SgSourceFile*,std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* > tokenSubsequenceMapOfMapsBySourceFile;
237 
238  // DQ (11/27/2013): Adding vector of nodes in the AST that defines the token unparsing AST frontier.
239  // extern std::vector<FrontierNode*> frontierNodes;
240  // extern std::map<SgStatement*,FrontierNode*> frontierNodes;
241  extern std::map<int,std::map<SgStatement*,FrontierNode*>*> frontierNodesMapOfMaps;
242 
243  // DQ (11/27/2013): Adding adjacency information for the nodes in the token unparsing AST frontier.
244  // extern std::map<SgNode*,PreviousAndNextNodeData*> previousAndNextNodeMap;
245  extern std::map<int,std::map<SgNode*,PreviousAndNextNodeData*>*> previousAndNextNodeMapOfMaps;
246 
247  // DQ (11/29/2013): Added to support access to multi-map of redundant mapping of frontier IR nodes to token subsequences.
248  // extern std::multimap<int,SgStatement*> redundantlyMappedTokensToStatementMultimap;
249  // extern std::set<int> redundantTokenEndingsSet;
250  extern std::map<int,std::multimap<int,SgStatement*>*> redundantlyMappedTokensToStatementMapOfMultimaps;
251  extern std::map<int,std::set<int>*> redundantTokenEndingsMapOfSets;
252 
253  // DQ (11/20/2015): Provide a statement to use as a key in the token sequence map to get representative whitespace.
254  // extern std::map<SgScopeStatement*,SgStatement*> representativeWhitespaceStatementMap;
255  extern std::map<int,std::map<SgScopeStatement*,SgStatement*>*> representativeWhitespaceStatementMapOfMaps;
256 
257  // DQ (11/30/2015): Provide a statement to use as a key in the macro expansion map to get info about macro expansions.
258  // extern std::map<SgStatement*,MacroExpansion*> macroExpansionMap;
259  extern std::map<int,std::map<SgStatement*,MacroExpansion*>*> macroExpansionMapOfMaps;
260 
261  // DQ (10/29/2018): Build a map for the unparser to use to locate SgIncludeFile IR nodes.
262  extern std::map<std::string, SgIncludeFile*> includeFileMapForUnparsing;
263 
264  // DQ (3/5/2017): Added general IR node specific message stream to support debugging message from the ROSE IR nodes.
265  extern Sawyer::Message::Facility ir_node_mlog;
266 
267  void initDiagnostics();
268 
269  // DQ (11/25/2020): These are the boolean variables that are computed in the function compute_language_kind()
270  // and inlined via the SageInterface::is_<language kind>_language() functions. This fixes a significant
271  // performacne bug that was identified by Matt Sottile. First indications of this problem were from HPCToolKit,
272  // when it reported that there were large ammounts of time spent in the memory pool traversals, but the results
273  // were not clear since we could not trace that to the SageInterface::is_<language kind>_language() functions
274  // directly. Matt was able to identify the root cause of the problem. It turns out the that the
275  // SageInterface::is_<language kind>_language() functions are implemented using a memory pool traversal of the
276  // SgSourceFile (and SgBinaryFile, when binary analysis is enabled at configure time). The new implementation
277  // supports these boolean values to be inlined via the SageInterface::is_<language kind>_language() functions.
278  // And the compute_language_kind() function is called from the:
279  // SgFile* determineFileType ( vector<string> argv, int & nextErrorCode, SgProject* project );
280  // contained in the sage_support.cpp file. This function is the single point at whcuh all of the SgFile IR nodes
281  // (including SgSourceFile, and SgBinaryFile) are generated.
282 
283  // Note: the semantics is that there is at least one of the language kind files processed by ROSE, across all
284  // SgFile objects across all SgProject objects.
285  extern bool is_Ada_language;
286  extern bool is_C_language;
287  extern bool is_Cobol_language;
288  extern bool is_OpenMP_language;
289  extern bool is_UPC_language;
290  extern bool is_UPC_dynamic_threads;
291  extern bool is_C99_language;
292  extern bool is_Cxx_language;
293  extern bool is_Java_language;
294  extern bool is_Jovial_language;
295  extern bool is_Fortran_language;
296  extern bool is_CAF_language;
297  extern bool is_PHP_language;
298  extern bool is_Python_language;
299  extern bool is_Cuda_language;
300  extern bool is_OpenCL_language;
301  extern bool is_X10_language;
302  extern bool is_binary_executable;
303  };
304 
305 
306 // endif for ifndef SWIG
307 #endif
308 
309 #endif // ifndef UTILITY_FUNCTIONS_H
310 
311 
312 
313 
314 
315 
316 
Collection of streams.
Definition: Message.h:1599
Main namespace for the ROSE library.
SgName concatenate(const SgName &X, const SgName &Y)
get the path from the full filename
SgStatement * getPreviousStatement(SgStatement *targetStatement, bool climbOutScope=true)
Functions to move to SgStatement object in SAGE III later.
This class represents strings within the IR nodes.
ROSE_DLL_API std::string getPathFromFileName(std::string fileNameWithPath)
get the filename from the full filename
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:9435
ROSE_DLL_API std::string getSourceDirectory(std::string fileNameWithPath)
get the current directory
This class represents the notion of a statement.
This class represents the notion of an expression or statement which has a position within the source...
This class represents a source project, with a list of SgFile objects and global information about th...
std::string getFileNameWithoutPath(SgStatement *statementPointer)
get the sourceDirectory directory