ROSE  0.11.145.0
sageBuilder.h
1 #ifndef ROSE_SAGE_BUILDER_INTERFACE
2 #define ROSE_SAGE_BUILDER_INTERFACE
3 
4 #include <string>
5 
20 #include "sageInterface.h"
21 
22 #include <Rose/Diagnostics.h>
23 
24 // forward declarations required for templated functions using those functions
25 namespace SageInterface {
26  ROSE_DLL_API void setOneSourcePositionForTransformation (SgNode * root);
27  ROSE_DLL_API void setSourcePosition(SgNode* node);
28 }
29 
31 namespace SageBuilder
32 {
33 
34 // DQ (3/24/2016): Adding Robb's meageage mechanism (data member and function).
35  extern Sawyer::Message::Facility mlog;
36  void initDiagnostics();
37 
38 
39 #if 0
40 //---------------------AST creation/building/construction-----------------
41  SgExpression* buildConst(SgType* t, const string & val);
42  SgExpression* buildConstInt(int val);
43 
44  // build sth in languages, but not in SAGE AST
45  // how to specify position info? then
46 
47  SgClassDeclaration* buildClassDeclaration(...,class_type);
48  // or
49  SgClassDeclaration* buildStruct(...);
50  SgClassDeclaration* buildClass(...);
51  SgClassDeclaration* buildUnion(...);
52 
53  // build B from dependent A
54  SgTemplateInstantiationMemberFunctionDecl* buildForwardFunctionDeclaration
55  (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);
56 
57  //previous attempt: src/midend/astUtil/astInterface
58  // AstNodePtr AstInterface::CreateConst( const string& val, const string& valtype) const
59  // AstNodePtr AstInterfaceBase::CreateConstInt( int val)
60 #endif
61 
62 //----------------------------------------------------------
64 
79 extern std::list<SgScopeStatement*> ScopeStack;
80 
81 // DQ (11/30/2010): Added support for building Fortran case insensitive symbol table handling.
83 extern bool symbol_table_case_insensitive_semantics;
84 
86 ROSE_DLL_API void pushScopeStack (SgScopeStatement* stmt);
87 
88 // DQ (3/20/2017): This function is not called (the function above is the more useful one that is used).
89 // ROSE_DLL_API void pushScopeStack (SgNode* node);
90 
91 ROSE_DLL_API void popScopeStack();
92 ROSE_DLL_API SgScopeStatement* topScopeStack();
93 ROSE_DLL_API bool emptyScopeStack();
94 ROSE_DLL_API void clearScopeStack();
95 
96 // DQ (3/11/2012): Added new function to the API for the internal scope stack.
98 SgScopeStatement* getGlobalScopeFromScopeStack();
99 
100 // DQ (3/20/2017): This function is not used.
101 // bool isInScopeStack(SgScopeStatement * scope);
102 
103 bool inSwitchScope();
104 
105 // DQ (3/20/2017): This function is not used.
106 // TV: for debug purpose
107 // std::string stringFromScopeStack();
108 
109 
111 
112 #if 0
113 // DQ (3/20/2017): These functions are not used (suggest using the API in the symbol table initialization).
114 //----------------------------------------------------------
116 
122 ROSE_DLL_API void setCaseInsensitive();
125 ROSE_DLL_API void setCaseSensitive();
127 ROSE_DLL_API void setCaseFromScope(SgScopeStatement* scope);
128 
130 #endif
131 
132 
133 // *************************************************************************************************************
134 // DQ (5/1/2012): This is another possible interface: supporting how we set the source code position and mark is
135 // as either a transformation or as actual code to be assigned a source position as part of the AST construction.
136 // *************************************************************************************************************
137 
138 enum SourcePositionClassification
139  {
140  e_sourcePositionError,
141  e_sourcePositionDefault,
142  e_sourcePositionTransformation,
143  e_sourcePositionCompilerGenerated,
144  e_sourcePositionNullPointers,
145  e_sourcePositionFrontendConstruction,
146  e_sourcePosition_last
147  };
148 
150 extern SourcePositionClassification SourcePositionClassificationMode;
151 
153 ROSE_DLL_API SourcePositionClassification getSourcePositionClassificationMode();
154 
156 ROSE_DLL_API std::string display(SourcePositionClassification & scp);
157 
159 ROSE_DLL_API void setSourcePositionClassificationMode(SourcePositionClassification X);
160 
162 ROSE_DLL_API SgName appendTemplateArgumentsToName( const SgName & name, const SgTemplateArgumentPtrList & templateArgumentsList);
163 
165 SgName unparseTemplateArgumentToString (SgTemplateArgument* templateArgument);
166 
167 // *************************************************************************************************************
168 
169 
170 
171 //--------------------------------------------------------------
173 
179 ROSE_DLL_API SgTypeBool * buildBoolType();
181 ROSE_DLL_API SgTypeNullptr* buildNullptrType();
182 ROSE_DLL_API SgTypeChar * buildCharType();
183 ROSE_DLL_API SgTypeDouble* buildDoubleType();
184 ROSE_DLL_API SgTypeFloat* buildFloatType();
185 ROSE_DLL_API SgTypeInt * buildIntType();
186 ROSE_DLL_API SgTypeLong* buildLongType();
187 ROSE_DLL_API SgTypeLongDouble* buildLongDoubleType();
188 ROSE_DLL_API SgTypeLongLong * buildLongLongType();
189 ROSE_DLL_API SgTypeShort* buildShortType();
190 ROSE_DLL_API SgTypeFloat80* buildFloat80Type();
191 ROSE_DLL_API SgTypeFloat128* buildFloat128Type();
192 
193 // CR (2/20/2020): Added builder for Jovial fixed type
195 ROSE_DLL_API SgTypeFixed* buildFixedType(SgExpression* fraction, SgExpression* scale);
196 
197 // CR (5/5/2020): Added builder for Jovial bit type
199 ROSE_DLL_API SgJovialBitType* buildJovialBitType(SgExpression* size);
200 
202 ROSE_DLL_API SgTypeString* buildStringType();
203 // SgTypeString* buildStringType( SgExpression* stringLengthExpression, size_t stringLengthLiteral );
204 ROSE_DLL_API SgTypeString* buildStringType( SgExpression* stringLengthExpression );
205 
206 ROSE_DLL_API SgTypeVoid * buildVoidType();
207 ROSE_DLL_API SgTypeWchar* buildWcharType();
208 
209 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
210 ROSE_DLL_API SgTypeChar16* buildChar16Type();
211 ROSE_DLL_API SgTypeChar32* buildChar32Type();
212 
213 ROSE_DLL_API SgTypeSignedChar* buildSignedCharType();
214 ROSE_DLL_API SgTypeSignedInt* buildSignedIntType();
215 ROSE_DLL_API SgTypeSignedLong* buildSignedLongType();
216 ROSE_DLL_API SgTypeSignedLongLong* buildSignedLongLongType();
217 ROSE_DLL_API SgTypeSignedShort* buildSignedShortType();
218 
219 #if 1
220 ROSE_DLL_API SgTypeSigned128bitInteger* buildSigned128bitIntegerType();
221 ROSE_DLL_API SgTypeUnsigned128bitInteger* buildUnsigned128bitIntegerType();
222 #endif
223 
224 ROSE_DLL_API SgTypeUnsignedChar* buildUnsignedCharType();
225 ROSE_DLL_API SgTypeUnsignedInt* buildUnsignedIntType();
226 ROSE_DLL_API SgTypeUnsignedLong* buildUnsignedLongType();
227 ROSE_DLL_API SgTypeUnsignedLongLong* buildUnsignedLongLongType();
228 ROSE_DLL_API SgTypeUnsignedShort* buildUnsignedShortType();
229 ROSE_DLL_API SgTypeUnknown * buildUnknownType();
230 
231 ROSE_DLL_API SgAutoType * buildAutoType();
232 
233 // CR (2/20/2020): Added builder functions for type size (kind) expressions for Fortran and Jovial
235 ROSE_DLL_API SgTypeBool * buildBoolType(SgExpression* kind_expr);
236 ROSE_DLL_API SgTypeInt * buildIntType(SgExpression* kind_expr);
237 ROSE_DLL_API SgTypeFloat * buildFloatType(SgExpression* kind_expr);
238 ROSE_DLL_API SgTypeUnsignedInt* buildUnsignedIntType(SgExpression* kind_expr);
239 
243 ROSE_DLL_API SgType* buildFortranImplicitType(SgName name);
244 
246 ROSE_DLL_API SgPointerType* buildPointerType(SgType *base_type = NULL);
247 
249 ROSE_DLL_API SgReferenceType* buildReferenceType(SgType *base_type = NULL);
250 
252 ROSE_DLL_API SgRvalueReferenceType* buildRvalueReferenceType(SgType *base_type);
253 
255 ROSE_DLL_API SgDeclType* buildDeclType(SgExpression *base_expression, SgType* base_type);
256 
258 ROSE_DLL_API SgTypeOfType* buildTypeOfType(SgExpression *base_expression, SgType* base_type);
259 
260 // Liao, entirely phase out this function ! Build a modifier type with no modifiers set
261 //SgModifierType* buildModifierType(SgType *base_type = NULL);
262 
263 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
265 ROSE_DLL_API SgModifierType* buildModifierType(SgType* base_type = NULL);
266 
268 ROSE_DLL_API SgModifierType* buildConstType(SgType* base_type = NULL);
269 
271 ROSE_DLL_API SgModifierType* buildAliasedType(SgType* base_type = NULL);
272 
274 ROSE_DLL_API SgModifierType* buildVolatileType(SgType* base_type = NULL);
275 
277 ROSE_DLL_API SgModifierType* buildConstVolatileType(SgType* base_type = NULL);
278 
280 ROSE_DLL_API SgModifierType* buildRestrictType(SgType* base_type);
281 
283 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type=NULL, SgExpression* index=NULL);
284 
285 // RASMUSSEN (1/25/2018)
293 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type, SgExprListExp* dim_info);
294 
295 // DQ (8/27/2010): Added Fortran specific support for types based on kind expressions.
297 ROSE_DLL_API SgModifierType* buildFortranKindType(SgType* base_type, SgExpression* kindExpression );
298 
300 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList=NULL);
301 
303 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterList * argList=NULL);
304 
305 // DQ (1/10/2020): removed the default argument since we need to make sure it is used.
307 // ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier, unsigned int ref_qualifiers = 0);
308 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier);
309 
310 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
312 // ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterList* argList = NULL, SgClassDefinition *struct_name = NULL, unsigned int mfunc_specifier = 0);
313 
315 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgType *classType, unsigned int mfunc_specifier);
316 
318 ROSE_DLL_API SgPointerMemberType* buildPointerMemberType(SgType* base_type, SgType* classType);
319 
320 // PP (07/14/2016):
334 ROSE_DLL_API
335 SgClassType*
336 buildClassTemplateType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
337 
339 ROSE_DLL_API
340 SgClassType*
341 buildTemplateClassType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
342 
344 
350 ROSE_DLL_API SgType* buildOpaqueType(std::string const type_name, SgScopeStatement * scope);
351 
352 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
354 ROSE_DLL_API SgModifierType* buildUpcStrictType(SgType *base_type = NULL);
355 
357 ROSE_DLL_API SgModifierType* buildUpcRelaxedType(SgType *base_type = NULL);
358 
360 ROSE_DLL_API SgModifierType* buildUpcSharedType(SgType *base_type = NULL, long layout = -1);
361 // SgModifierType* buildUpcSharedType(SgType *base_type = NULL);
362 
364 ROSE_DLL_API SgModifierType* buildUpcBlockIndefiniteType(SgType *base_type = NULL);
365 
367 ROSE_DLL_API SgModifierType* buildUpcBlockStarType(SgType *base_type = NULL);
368 
370 ROSE_DLL_API SgModifierType* buildUpcBlockNumberType(SgType *base_type, long block_factor);
371 
373 ROSE_DLL_API SgTypeComplex* buildComplexType(SgType *base_type = NULL);
374 
376 ROSE_DLL_API SgTypeImaginary* buildImaginaryType(SgType *base_type = NULL);
377 
379 ROSE_DLL_API SgConstVolatileModifier * buildConstVolatileModifier (SgConstVolatileModifier::cv_modifier_enum mtype=SgConstVolatileModifier::e_unknown);
380 
382 ROSE_DLL_API SgTypeMatrix* buildMatrixType();
383 
385 ROSE_DLL_API SgTypeTuple* buildTupleType(SgType *t1 = NULL, SgType *t2 = NULL, SgType *t3 = NULL, SgType *t4 = NULL, SgType *t5 = NULL, SgType *t6 = NULL, SgType *t7 = NULL, SgType *t8 = NULL, SgType *t9 = NULL, SgType *t10 = NULL);
386 
388 ROSE_DLL_API SgNonrealType* buildNonrealType(const SgName & name, SgDeclarationScope* scope);
389 
391 
392 //--------------------------------------------------------------
394 
406 // JJW (11/19/2008): _nfi versions of functions set file info objects to NULL (used in frontend)
407 
408 ROSE_DLL_API SgVariantExpression * buildVariantExpression();
409 
411 ROSE_DLL_API SgNullExpression* buildNullExpression();
413 ROSE_DLL_API SgNullExpression* buildNullExpression_nfi();
414 
416 ROSE_DLL_API SgBoolValExp* buildBoolValExp(int value = 0);
417 ROSE_DLL_API SgBoolValExp* buildBoolValExp(bool value = 0);
418 ROSE_DLL_API SgBoolValExp* buildBoolValExp_nfi(int value);
419 
420 ROSE_DLL_API SgCharVal* buildCharVal(char value = 0);
421 ROSE_DLL_API SgCharVal* buildCharVal_nfi(char value, const std::string& str);
422 
424 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp();
425 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp_nfi();
426 
428 ROSE_DLL_API SgVoidVal* buildVoidVal();
429 ROSE_DLL_API SgVoidVal* buildVoidVal_nfi();
430 
431 ROSE_DLL_API SgWcharVal* buildWcharVal(wchar_t value = 0);
432 ROSE_DLL_API SgWcharVal* buildWcharVal_nfi(wchar_t value, const std::string& str);
433 
434 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
435 ROSE_DLL_API SgChar16Val* buildChar16Val(unsigned short value = 0);
436 ROSE_DLL_API SgChar16Val* buildChar16Val_nfi(unsigned short value, const std::string& str);
437 ROSE_DLL_API SgChar32Val* buildChar32Val(unsigned int value = 0);
438 ROSE_DLL_API SgChar32Val* buildChar32Val_nfi(unsigned int value, const std::string& str);
439 
440 // DQ (3/20/2017): This function has never existed (inputs must be SgValueExp pointers).
441 // ROSE_DLL_API SgComplexVal* buildComplexVal(long double real_value = 0.0, long double imaginary_value = 0.0 );
442 ROSE_DLL_API SgComplexVal* buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value);
443 ROSE_DLL_API SgComplexVal* buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, const std::string& str);
444 ROSE_DLL_API SgComplexVal* buildImaginaryVal(long double imaginary_value);
445 ROSE_DLL_API SgComplexVal* buildImaginaryVal(SgValueExp* imaginary_value);
446 ROSE_DLL_API SgComplexVal* buildImaginaryVal_nfi(SgValueExp* imaginary_value, const std::string& str);
447 
449 ROSE_DLL_API SgDoubleVal* buildDoubleVal(double value = 0.0);
450 ROSE_DLL_API SgDoubleVal* buildDoubleVal_nfi(double value, const std::string& str);
451 
452 ROSE_DLL_API SgFloatVal* buildFloatVal(float value = 0.0);
453 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value = 0.0);
454 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value, const std::string& str);
456 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(const std::string& str);
457 
459 ROSE_DLL_API SgIntVal* buildIntVal(int value = 0);
460 ROSE_DLL_API SgIntVal* buildIntValHex(int value = 0);
461 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value = 0);
462 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value, const std::string& str);
464 ROSE_DLL_API SgIntVal* buildIntVal_nfi(const std::string& str);
465 
467 ROSE_DLL_API SgLongIntVal* buildLongIntVal(long value = 0);
468 ROSE_DLL_API SgLongIntVal* buildLongIntValHex(long value = 0);
469 ROSE_DLL_API SgLongIntVal* buildLongIntVal_nfi(long value, const std::string& str);
470 
472 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal(long long value = 0);
473 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
474 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal_nfi(long long value, const std::string& str);
475 // !Build enum val without file info: nfi
476 ROSE_DLL_API SgEnumVal* buildEnumVal_nfi(long long int value, SgEnumDeclaration* decl, SgName name);
477 // !Build enum val with transformation file info
478 ROSE_DLL_API SgEnumVal* buildEnumVal(long long int value, SgEnumDeclaration* decl, SgName name);
479 ROSE_DLL_API SgEnumVal* buildEnumVal(SgEnumFieldSymbol * sym);
480 
481 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal(long double value = 0.0);
482 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal_nfi(long double value, const std::string& str);
483 
484 ROSE_DLL_API SgFloat80Val* buildFloat80Val(long double value = 0.0);
485 ROSE_DLL_API SgFloat80Val* buildFloat80Val_nfi(long double value, const std::string& str);
486 
487 ROSE_DLL_API SgFloat128Val* buildFloat128Val(long double value = 0.0);
488 ROSE_DLL_API SgFloat128Val* buildFloat128Val_nfi(long double value, const std::string& str);
489 
490 ROSE_DLL_API SgShortVal* buildShortVal(short value = 0);
491 ROSE_DLL_API SgShortVal* buildShortValHex(short value = 0);
492 ROSE_DLL_API SgShortVal* buildShortVal_nfi(short value, const std::string& str);
493 
494 ROSE_DLL_API SgStringVal* buildStringVal(std::string value="");
495 ROSE_DLL_API SgStringVal* buildStringVal_nfi(std::string value);
496 
498 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);
499 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
500 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal_nfi(unsigned char v, const std::string& str);
501 
503 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);
504 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
505 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal_nfi(unsigned short v, const std::string& str);
506 
508 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);
509 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
510 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal_nfi(unsigned int v, const std::string& str);
511 
513 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);
514 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
515 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal_nfi(unsigned long v, const std::string& str);
516 
518 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);
519 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
520 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string& str);
521 
523 ROSE_DLL_API SgJovialBitVal* buildJovialBitVal_nfi(const std::string& str);
524 
526 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal(int template_parameter_position = -1);
527 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal_nfi(int template_parameter_position, const std::string& str);
528 
530 ROSE_DLL_API SgTemplateType* buildTemplateType(SgName name="");
531 
534 ROSE_DLL_API SgTemplateParameter * buildTemplateParameter (SgTemplateParameter::template_parameter_enum parameterType, SgType*);
535 
537 ROSE_DLL_API SgNonrealDecl * buildNonrealDecl(const SgName & name, SgDeclarationScope * scope, SgDeclarationScope * child_scope = NULL);
538 
540 ROSE_DLL_API SgNonrealRefExp * buildNonrealRefExp_nfi(SgNonrealSymbol * sym);
541 
543 ROSE_DLL_API SgUpcThreads* buildUpcThreads();
544 ROSE_DLL_API SgUpcThreads* buildUpcThreads_nfi();
545 
547 ROSE_DLL_API SgUpcMythread* buildUpcMythread();
548 ROSE_DLL_API SgUpcMythread* buildUpcMythread_nfi();
549 
551 ROSE_DLL_API SgThisExp* buildThisExp(SgSymbol* sym);
552 ROSE_DLL_API SgThisExp* buildThisExp_nfi(SgSymbol* sym);
553 
555 ROSE_DLL_API SgSuperExp* buildSuperExp(SgClassSymbol* sym);
556 ROSE_DLL_API SgSuperExp* buildSuperExp_nfi(SgClassSymbol* sym);
557 
559 ROSE_DLL_API SgClassExp* buildClassExp(SgClassSymbol* sym);
560 ROSE_DLL_API SgClassExp* buildClassExp_nfi(SgClassSymbol* sym);
561 
563 ROSE_DLL_API SgLambdaRefExp* buildLambdaRefExp(SgType* return_type, SgFunctionParameterList* params, SgScopeStatement* scope);
564 
565 #define BUILD_UNARY_PROTO(suffix) \
566 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* op =NULL); \
567 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* op);
568 
569 BUILD_UNARY_PROTO(AddressOfOp)
570 BUILD_UNARY_PROTO(BitComplementOp)
571 BUILD_UNARY_PROTO(MinusOp)
572 BUILD_UNARY_PROTO(NotOp)
573 BUILD_UNARY_PROTO(PointerDerefExp)
574 BUILD_UNARY_PROTO(UnaryAddOp)
575 BUILD_UNARY_PROTO(MinusMinusOp)
576 BUILD_UNARY_PROTO(PlusPlusOp)
577 BUILD_UNARY_PROTO(RealPartOp)
578 BUILD_UNARY_PROTO(ImagPartOp)
579 BUILD_UNARY_PROTO(ConjugateOp)
580 BUILD_UNARY_PROTO(VarArgStartOneOperandOp)
581 BUILD_UNARY_PROTO(VarArgEndOp)
582 BUILD_UNARY_PROTO(AbsOp)
583 
584 //Matlab transpose op
585 BUILD_UNARY_PROTO(MatrixTransposeOp)
586 
588 ROSE_DLL_API SgCastExp * buildCastExp(SgExpression * operand_i = NULL,
589  SgType * expression_type = NULL,
590  SgCastExp::cast_type_enum cast_type = SgCastExp::e_C_style_cast);
591 ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression * operand_i,
592  SgType * expression_type,
593  SgCastExp::cast_type_enum cast_type);
594 
596 ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression * operand_i, SgType * expression_type);
597 
599 ROSE_DLL_API SgMinusOp *buildMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
600 ROSE_DLL_API SgMinusOp *buildMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
601 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
602 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
603 
605 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
606 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
607 
609 ROSE_DLL_API SgThrowOp* buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind);
610 
611 ROSE_DLL_API SgNewExp * buildNewExp(SgType* type,
612  SgExprListExp* exprListExp,
613  SgConstructorInitializer* constInit,
614  SgExpression* expr,
615  short int val,
616  SgFunctionDeclaration* funcDecl);
617 
618 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression* variable,
619  short is_array,
620  short need_global_specifier,
621  SgFunctionDeclaration* deleteOperatorDeclaration);
622 
624 ROSE_DLL_API SgTypeIdOp* buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type);
625 
626 
627 #undef BUILD_UNARY_PROTO
628 
633 #define BUILD_BINARY_PROTO(suffix) \
634 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* lhs =NULL, SgExpression* rhs =NULL); \
635 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* lhs, SgExpression* rhs);
636 
637 BUILD_BINARY_PROTO(AddOp)
638 BUILD_BINARY_PROTO(AndAssignOp)
639 BUILD_BINARY_PROTO(AndOp)
640 BUILD_BINARY_PROTO(ArrowExp)
641 BUILD_BINARY_PROTO(ArrowStarOp)
642 BUILD_BINARY_PROTO(AssignOp)
643 BUILD_BINARY_PROTO(AtOp)
644 BUILD_BINARY_PROTO(BitAndOp)
645 BUILD_BINARY_PROTO(BitOrOp)
646 BUILD_BINARY_PROTO(BitXorOp)
647 
648 BUILD_BINARY_PROTO(CommaOpExp)
649 BUILD_BINARY_PROTO(ConcatenationOp)
650 BUILD_BINARY_PROTO(DivAssignOp)
651 BUILD_BINARY_PROTO(DivideOp)
652 BUILD_BINARY_PROTO(DotExp)
653 BUILD_BINARY_PROTO(DotStarOp)
654 BUILD_BINARY_PROTO(EqualityOp)
655 
656 BUILD_BINARY_PROTO(ExponentiationOp)
657 BUILD_BINARY_PROTO(ExponentiationAssignOp)
658 BUILD_BINARY_PROTO(GreaterOrEqualOp)
659 BUILD_BINARY_PROTO(GreaterThanOp)
660 BUILD_BINARY_PROTO(IntegerDivideOp)
661 BUILD_BINARY_PROTO(IntegerDivideAssignOp)
662 BUILD_BINARY_PROTO(IorAssignOp)
663 BUILD_BINARY_PROTO(IsOp)
664 BUILD_BINARY_PROTO(IsNotOp)
665 
666 BUILD_BINARY_PROTO(LessOrEqualOp)
667 BUILD_BINARY_PROTO(LessThanOp)
668 BUILD_BINARY_PROTO(LshiftAssignOp)
669 BUILD_BINARY_PROTO(LshiftOp)
670 
671 BUILD_BINARY_PROTO(MembershipOp)
672 BUILD_BINARY_PROTO(MinusAssignOp)
673 BUILD_BINARY_PROTO(ModAssignOp)
674 BUILD_BINARY_PROTO(ModOp)
675 BUILD_BINARY_PROTO(MultAssignOp)
676 BUILD_BINARY_PROTO(MultiplyOp)
677 
678 BUILD_BINARY_PROTO(NonMembershipOp)
679 BUILD_BINARY_PROTO(NotEqualOp)
680 BUILD_BINARY_PROTO(OrOp)
681 BUILD_BINARY_PROTO(PlusAssignOp)
682 BUILD_BINARY_PROTO(PntrArrRefExp)
683 BUILD_BINARY_PROTO(RemOp)
684 BUILD_BINARY_PROTO(RshiftAssignOp)
685 BUILD_BINARY_PROTO(JavaUnsignedRshiftAssignOp)
686 
687 BUILD_BINARY_PROTO(ReplicationOp)
688 BUILD_BINARY_PROTO(RshiftOp)
689 BUILD_BINARY_PROTO(JavaUnsignedRshiftOp)
690 BUILD_BINARY_PROTO(ScopeOp)
691 BUILD_BINARY_PROTO(SubtractOp)
692 BUILD_BINARY_PROTO(XorAssignOp)
693 
694 BUILD_BINARY_PROTO(VarArgCopyOp)
695 BUILD_BINARY_PROTO(VarArgStartOp)
696 
697 BUILD_BINARY_PROTO(PowerOp);
698 BUILD_BINARY_PROTO(ElementwisePowerOp);
699 BUILD_BINARY_PROTO(ElementwiseMultiplyOp);
700 BUILD_BINARY_PROTO(ElementwiseDivideOp);
701 BUILD_BINARY_PROTO(LeftDivideOp);
702 BUILD_BINARY_PROTO(ElementwiseLeftDivideOp);
703 BUILD_BINARY_PROTO(ElementwiseAddOp);
704 BUILD_BINARY_PROTO(ElementwiseSubtractOp);
705 
706 // DQ (7/25/2020): Adding C++20 support
707 BUILD_BINARY_PROTO(SpaceshipOp)
708 
709 #undef BUILD_BINARY_PROTO
710 
712 ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression* test =NULL, SgExpression* a =NULL, SgExpression* b =NULL);
713 SgConditionalExp * buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
714 
716 ROSE_DLL_API SgExprListExp * buildExprListExp(SgExpression * expr1 = NULL, SgExpression* expr2 = NULL, SgExpression* expr3 = NULL, SgExpression* expr4 = NULL, SgExpression* expr5 = NULL, SgExpression* expr6 = NULL, SgExpression* expr7 = NULL, SgExpression* expr8 = NULL, SgExpression* expr9 = NULL, SgExpression* expr10 = NULL);
717 ROSE_DLL_API SgExprListExp * buildExprListExp(const std::vector<SgExpression*>& exprs);
718 SgExprListExp * buildExprListExp_nfi();
719 SgExprListExp * buildExprListExp_nfi(const std::vector<SgExpression*>& exprs);
720 
722 SgSubscriptExpression * buildSubscriptExpression_nfi(SgExpression* lower_bound, SgExpression* upper_bound, SgExpression* stride);
723 
725 ROSE_DLL_API SgTupleExp * buildTupleExp(SgExpression * expr1 = NULL, SgExpression* expr2 = NULL, SgExpression* expr3 = NULL, SgExpression* expr4 = NULL, SgExpression* expr5 = NULL, SgExpression* expr6 = NULL, SgExpression* expr7 = NULL, SgExpression* expr8 = NULL, SgExpression* expr9 = NULL, SgExpression* expr10 = NULL);
726 ROSE_DLL_API SgTupleExp * buildTupleExp(const std::vector<SgExpression*>& exprs);
727 SgTupleExp * buildTupleExp_nfi();
728 SgTupleExp * buildTupleExp_nfi(const std::vector<SgExpression*>& exprs);
729 
731 ROSE_DLL_API SgListExp * buildListExp(SgExpression * expr1 = NULL, SgExpression* expr2 = NULL, SgExpression* expr3 = NULL, SgExpression* expr4 = NULL, SgExpression* expr5 = NULL, SgExpression* expr6 = NULL, SgExpression* expr7 = NULL, SgExpression* expr8 = NULL, SgExpression* expr9 = NULL, SgExpression* expr10 = NULL);
732 ROSE_DLL_API SgListExp * buildListExp(const std::vector<SgExpression*>& exprs);
733 SgListExp * buildListExp_nfi();
734 SgListExp * buildListExp_nfi(const std::vector<SgExpression*>& exprs);
735 
736 ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
737 SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
738 
739 ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators);
740 SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
741 
742 ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators);
743 SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
744 
745 ROSE_DLL_API SgDictionaryComprehension * buildDictionaryComprehension(SgKeyDatumPair *kd_pair, SgExprListExp *generators);
746 SgDictionaryComprehension * buildDictionaryComprehension_nfi(SgKeyDatumPair *kd_pair, SgExprListExp *generators);
747 
749 
753 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName& name, SgScopeStatement* scope=NULL);
754 
756 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const std::string& varName, SgScopeStatement* scope=NULL);
757 
759 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const char* varName, SgScopeStatement* scope=NULL);
760 
762 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableSymbol* varSymbol);
763 ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
764 
766 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableDeclaration* vardecl);
767 
770 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgInitializedName* initname, SgScopeStatement* scope=NULL);
771 
773 
775 ROSE_DLL_API SgVarRefExp* buildOpaqueVarRefExp(const std::string& varName,SgScopeStatement* scope=NULL);
776 
777 // DQ (9/4/2013): Added support for building compound literals (similar to a SgVarRefExp).
779 SgCompoundLiteralExp* buildCompoundLiteralExp_nfi(SgVariableSymbol* varSymbol);
780 SgCompoundLiteralExp* buildCompoundLiteralExp(SgVariableSymbol* varSymbol);
781 
783 ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol * s);
784 
786 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name, const SgType* func_type, SgScopeStatement* scope=NULL);
787 
788 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name, const SgType* func_type, SgScopeStatement* scope=NULL);
789 
791 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name,SgScopeStatement* scope=NULL);
792 
793 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name,SgScopeStatement* scope=NULL);
794 
796 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgFunctionDeclaration* func_decl);
797 
799 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(SgFunctionSymbol* sym);
800 
801 SgFunctionRefExp * buildFunctionRefExp_nfi(SgFunctionSymbol* sym);
802 
804 SgTemplateFunctionRefExp* buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol* sym);
805 
807 SgTemplateMemberFunctionRefExp* buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
808 
809 SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
810 ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
811 SgClassNameRefExp * buildClassNameRefExp_nfi(SgClassSymbol* sym);
812 ROSE_DLL_API SgClassNameRefExp * buildClassNameRefExp(SgClassSymbol* sym);
813 
815 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgFunctionSymbol* sym, SgExprListExp* parameters=NULL);
816 SgFunctionCallExp* buildFunctionCallExp_nfi(SgExpression* f, SgExprListExp* parameters=NULL);
817 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgExpression* f, SgExprListExp* parameters=NULL);
818 
820 ROSE_DLL_API SgFunctionCallExp*
821 buildFunctionCallExp(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
822 
823 
825 
840 ROSE_DLL_API SgFunctionCallExp*
841 buildMemberFunctionCall (std::string className, SgExpression *objectExpression, std::string functionName, SgExprListExp *params, SgScopeStatement *scope);
842 
844 ROSE_DLL_API SgFunctionCallExp* buildMemberFunctionCall (SgExpression* objectExpression, SgMemberFunctionSymbol* functionSymbol,
845  SgExprListExp* params);
846 
847 SgTypeTraitBuiltinOperator*
848 buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters);
849 
851 SgCudaKernelCallExp * buildCudaKernelCallExp_nfi(
852  SgExpression * kernel,
853  SgExprListExp* parameters = NULL,
854  SgCudaKernelExecConfig * config = NULL
855 );
856 
858 SgCudaKernelExecConfig * buildCudaKernelExecConfig_nfi(
859  SgExpression *grid = NULL,
860  SgExpression *blocks = NULL,
861  SgExpression *shared = NULL,
862  SgExpression *stream = NULL
863 );
864 
866 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
867 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
868 
870 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
871 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
872 
874 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
875 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
876 
877 // DQ (!/4/2009): Added support for building SgConstructorInitializer
878 ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer( SgMemberFunctionDeclaration *declaration,SgExprListExp *args,SgType *expression_type,bool need_name,bool need_qualifier,bool need_parenthesis_after_name,bool associated_class_unknown);
879 ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer_nfi( SgMemberFunctionDeclaration *declaration,SgExprListExp *args,SgType *expression_type,bool need_name,bool need_qualifier,bool need_parenthesis_after_name,bool associated_class_unknown);
880 
882 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
883 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
884 
886 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgExpression* exp = NULL);
887 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgExpression* exp);
888 
890 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgType* type = NULL);
891 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgType* type);
892 
894 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgExpression* exp = NULL);
895 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgExpression* exp);
896 
898 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgType* type = NULL);
899 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgType* type);
900 
902 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp(SgExpression* exp = NULL);
903 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
904 
905 // DQ (7/18/2011): Added support for SgJavaInstanceOfOp
907 ROSE_DLL_API SgJavaInstanceOfOp* buildJavaInstanceOfOp(SgExpression* exp = NULL, SgType* type = NULL);
908 
910 ROSE_DLL_API SgTypeExpression *buildTypeExpression(SgType* type);
911 
912 // DQ (8/11/2014): Added support for C++11 decltype used in new function return syntax.
913 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp(int parameter_number, int parameter_level );
914 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level );
915 
916 
918 ROSE_DLL_API SgLambdaExp* buildLambdaExp (SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
919 ROSE_DLL_API SgLambdaExp* buildLambdaExp_nfi(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
920 
921 #if 0
922 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
923 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
924 #else
925 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
926 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
927 #endif
928 
929 ROSE_DLL_API SgLambdaCaptureList* buildLambdaCaptureList ();
930 ROSE_DLL_API SgLambdaCaptureList* buildLambdaCaptureList_nfi();
931 
932 // DQ (7/25/2020): Adding C++17 support
933  ROSE_DLL_API SgFoldExpression * buildFoldExpression(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
934 ROSE_DLL_API SgFoldExpression * buildFoldExpression_nfi(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
935 
936 // DQ (7/25/2020): Adding C++20 support
937 ROSE_DLL_API SgAwaitExpression * buildAwaitExpression();
938 ROSE_DLL_API SgAwaitExpression * buildAwaitExpression_nfi();
939 
940 // DQ (7/25/2020): Adding C++20 support
941 ROSE_DLL_API SgChooseExpression * buildChooseExpression();
942 ROSE_DLL_API SgChooseExpression * buildChooseExpression_nfi();
943 
944 
946 
948 
950  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start);
952 
953 
955  ROSE_DLL_API SgMatrixExp* buildMatrixExp(SgExprListExp *firstRow);
956 
958  ROSE_DLL_API SgMagicColonExp* buildMagicColonExp();
959 
961  ROSE_DLL_API SgMatlabForStatement* buildMatlabForStatement(SgExpression* loop_index, SgExpression* loop_range, SgBasicBlock* loop_body);
963 
965 
968 // ! Build a range expression using start:end:stride for Ada
969  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start, SgExpression *end, SgExpression *stride);
970 
972 //
973 //--------------------------------------------------------------
975 
979 
983 ROSE_DLL_API SgInitializedName* buildInitializedName(const SgName & name, SgType* type, SgInitializer* init = NULL);
984 ROSE_DLL_API SgInitializedName* buildInitializedName(const std::string &name, SgType* type);
985 ROSE_DLL_API SgInitializedName* buildInitializedName(const char* name, SgType* type);
986 ROSE_DLL_API SgInitializedName* buildInitializedName_nfi(const SgName & name, SgType* type, SgInitializer* init);
987 
989 ROSE_DLL_API SgFunctionParameterTypeList *
990 buildFunctionParameterTypeList(SgFunctionParameterList * paralist);
991 
993 ROSE_DLL_API SgFunctionParameterTypeList *
994 buildFunctionParameterTypeList(SgExprListExp * expList);
995 
997 ROSE_DLL_API SgFunctionParameterTypeList *
998 buildFunctionParameterTypeList(SgType* type0 = NULL, SgType* type1 = NULL,
999  SgType* type2 = NULL, SgType* type3 = NULL,
1000  SgType* type4 = NULL, SgType* type5 = NULL,
1001  SgType* type6 = NULL, SgType* type7 = NULL);
1002 
1003 
1004 //--------------------------------------------------------------
1006 
1012 ROSE_DLL_API SgVariableDeclaration*
1014 buildVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
1015 
1016 ROSE_DLL_API SgVariableDeclaration*
1017 buildVariableDeclaration(const std::string & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
1018 
1019 ROSE_DLL_API SgVariableDeclaration*
1020 buildVariableDeclaration(const char* name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
1021 
1022 // DQ (6/25/2019): Added support to force building the varialbe declaration from the variable use (e.g. within a class)
1023 // instead of from a declaration. Variable declaration built from a use are reused when the declaration is seen (later
1024 // in processing of the class members).
1025 // ROSE_DLL_API SgVariableDeclaration*
1026 // buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1027 ROSE_DLL_API SgVariableDeclaration*
1028 buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope, bool builtFromUseOnly = false, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
1029 
1031 ROSE_DLL_API SgVariableDefinition*
1032 buildVariableDefinition_nfi (SgVariableDeclaration* decl, SgInitializedName* init_name, SgInitializer *init);
1033 
1034 
1035 // DQ (8/31/2012): Note that this macro can't be used in header files since it can only be set
1036 // after sage3.h has been read. The reason is that this is a portability problem when "rose_config.h"
1037 // appears in header files of applications using ROSE's header files.
1038 // DQ (12/6/2011): Adding support for template declarations into the AST.
1039 // SgTemplateDeclaration*
1040 ROSE_DLL_API SgTemplateVariableDeclaration* buildTemplateVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1041 
1043 ROSE_DLL_API SgTemplateVariableDeclaration* buildTemplateVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1044 
1046 ROSE_DLL_API SgTypedefDeclaration*
1047 buildTypedefDeclaration(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1048 
1049 ROSE_DLL_API SgTypedefDeclaration*
1050 buildTypedefDeclaration_nfi(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1051 
1052 ROSE_DLL_API SgTemplateTypedefDeclaration*
1053 buildTemplateTypedefDeclaration_nfi(const SgName & name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1054 
1055 
1056 ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration * buildTemplateInstantiationTypedefDeclaration_nfi(
1057  SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base,
1058  SgTemplateTypedefDeclaration * templateTypedefDeclaration,
1059  SgTemplateArgumentPtrList & templateArgumentsList
1060 );
1061 
1063 ROSE_DLL_API SgFunctionParameterList * buildFunctionParameterList(SgInitializedName* in1 = NULL, SgInitializedName* in2 = NULL, SgInitializedName* in3 = NULL, SgInitializedName* in4 = NULL, SgInitializedName* in5 = NULL, SgInitializedName* in6 = NULL, SgInitializedName* in7 = NULL, SgInitializedName* in8 = NULL, SgInitializedName* in9 = NULL, SgInitializedName* in10 = NULL);
1064 SgFunctionParameterList * buildFunctionParameterList_nfi();
1065 
1067 ROSE_DLL_API SgFunctionParameterList*
1068 buildFunctionParameterList(SgFunctionParameterTypeList * paraTypeList);
1069 
1070 ROSE_DLL_API SgFunctionParameterList*
1071 buildFunctionParameterList_nfi(SgFunctionParameterTypeList * paraTypeList);
1072 
1073 SgCtorInitializerList * buildCtorInitializerList_nfi();
1075 ROSE_DLL_API void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, const SgName & name );
1076 
1077 // DQ (9/13/2012): Need to set the parents of SgTemplateArgument IR nodes now that they are passed in as part of the SageBuilder API.
1078 ROSE_DLL_API void setTemplateArgumentParents( SgDeclarationStatement* decl );
1079 ROSE_DLL_API void testTemplateArgumentParents( SgDeclarationStatement* decl );
1080 ROSE_DLL_API SgTemplateArgumentPtrList* getTemplateArgumentList( SgDeclarationStatement* decl );
1081 
1083 ROSE_DLL_API void testTemplateParameterParents( SgDeclarationStatement* decl );
1084 ROSE_DLL_API void setTemplateParameterParents( SgDeclarationStatement* decl );
1085 ROSE_DLL_API SgTemplateParameterPtrList* getTemplateParameterList( SgDeclarationStatement* decl );
1086 
1088 ROSE_DLL_API void setTemplateArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input );
1089 ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input );
1090 ROSE_DLL_API void setTemplateParametersInDeclaration ( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input );
1091 
1092 
1094 // DQ (7/26/2012): Changing the API to include template arguments so that we can generate names with and without template arguments (to support name mangiling).
1095 ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(
1096  const SgName & name,
1097  SgType * return_type,
1098  SgFunctionParameterList *parlist,
1099  SgScopeStatement* scope = NULL,
1100  SgExprListExp* decoratorList = NULL,
1101  bool buildTemplateInstantiation = false,
1102  SgTemplateArgumentPtrList * templateArgumentsList = NULL,
1103  SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default
1104 );
1105 
1107 ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(
1108  const SgFunctionDeclaration * funcdecl,
1109  SgScopeStatement * scope = NULL,
1110  SgExprListExp * decoratorList = NULL
1111 );
1112 
1113 // DQ (8/11/2013): Even though template functions can't use partial specialization, they can be specialized,
1114 // however the specialization does not define a template and instead defines a template instantiation, so we
1115 // don't need the SgTemplateArgumentPtrList in this function.
1116 // SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1117 ROSE_DLL_API SgTemplateFunctionDeclaration*
1118 buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
1119 
1120 // DQ (8/11/2013): Note that access to the SgTemplateParameterPtrList should be handled through the first_nondefining_declaration (which is a required parameter).
1121 // DQ (12/1/2011): Adding support for template declarations into the AST.
1122 ROSE_DLL_API SgTemplateFunctionDeclaration*
1123 buildDefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateFunctionDeclaration* first_nondefining_declaration);
1124 
1125 // DQ (11/8/2020): Define a function to build a default constructor for a class.
1126 // ROSE_DLL_API SgMemberFunctionDeclaration* buildConstructor ( const SgName & typeName, SgClassType* initializedName_classType, SgClassDefinition* classDefinition);
1127 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefaultConstructor ( SgClassType* classType );
1128 
1130 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1131 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1132 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0, bool buildTemplateInstantiation = false);
1133 ROSE_DLL_API SgMemberFunctionDeclaration*
1134 buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1135 
1136 // DQ (8/12/2013): This function needs to supporte SgTemplateParameterPtrList and SgTemplateArgumentPtrList parameters.
1137 // SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1138 ROSE_DLL_API SgTemplateMemberFunctionDeclaration*
1139 buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList );
1140 
1141 // DQ (12/1/2011): Adding support for template declarations in the AST.
1142 ROSE_DLL_API SgTemplateMemberFunctionDeclaration*
1143 buildDefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration );
1144 
1146 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgFunctionParameterList* paralist, SgScopeStatement* scope=NULL);
1147 
1148 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1150 // SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration);
1151 ROSE_DLL_API SgMemberFunctionDeclaration*
1152 buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration, SgTemplateArgumentPtrList* templateArgumentsList);
1153 
1154 #if 0
1155 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1156 // DQ (8/29/2012): This is re-enabled because the backstroke project is using it (also added back the default parameters; which I don't think I like in the API).
1157 // DQ (7/26/2012): I would like to remove this from the API (at least for now while debugging the newer API required for template argument handling).
1159 ROSE_DLL_API SgMemberFunctionDeclaration*
1160 buildDefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgScopeStatement* scope, SgExprListExp* decoratorList = NULL /* , unsigned int functionConstVolatileFlags = 0 */, SgMemberFunctionDeclaration* first_nondefinng_declaration = NULL);
1161 #endif
1162 
1163 #if 0
1164 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1166 // SgMemberFunctionDeclaration*
1167 ROSE_DLL_API SgMemberFunctionDeclaration*
1168 buildNondefiningMemberFunctionDeclaration (const SgMemberFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1169 #endif
1170 
1171 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1172 // We need to decide if the SageBuilder API should include these sorts of functions.
1173 ROSE_DLL_API SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1174 
1175 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1176 // We need to decide if the SageBuilder API should include these sorts of functions.
1177 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1178 
1179 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1181 // SgFunctionDeclaration* buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgFunctionDeclaration* first_nondefinng_declaration);
1182 ROSE_DLL_API SgFunctionDeclaration*
1183 buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation = false, SgFunctionDeclaration* first_nondefinng_declaration = NULL, SgTemplateArgumentPtrList* templateArgumentsList = NULL);
1184 
1185 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1186 // We need to decide if the SageBuilder API should include these sorts of functions.
1187 ROSE_DLL_API SgFunctionDeclaration* buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1188 
1189 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1190 // We need to decide if the SageBuilder API should include these sorts of functions.
1191 ROSE_DLL_API SgProcedureHeaderStatement* buildProcedureHeaderStatement(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope = NULL);
1192 
1194 ROSE_DLL_API SgProcedureHeaderStatement*
1195 buildProcedureHeaderStatement(const char* name, SgType* return_type, SgFunctionParameterList * parlist, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope, SgProcedureHeaderStatement* first_nondefining_declaration );
1196 
1197 // CR (9/24/2020)
1199 ROSE_DLL_API SgProcedureHeaderStatement*
1200 buildNondefiningProcedureHeaderStatement(const SgName & name, SgType* return_type, SgFunctionParameterList* param_list,
1201  SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope=NULL);
1202 
1204 ROSE_DLL_API SgExprStatement*
1205 buildFunctionCallStmt(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
1206 
1208 ROSE_DLL_API SgExprStatement*
1209 buildFunctionCallStmt(SgExpression* function, SgExprListExp* parameters=NULL);
1210 
1211 
1213 
1216 ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName& name, SgStatement * stmt = NULL, SgScopeStatement* scope=NULL);
1217 SgLabelStatement * buildLabelStatement_nfi(const SgName& name, SgStatement * stmt, SgScopeStatement* scope);
1218 
1220 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement * label=NULL);
1221 SgGotoStatement * buildGotoStatement_nfi(SgLabelStatement * label);
1222 
1224 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelSymbol* symbol);
1225 
1226 // DQ (11/22/2017): Added support for computed code goto as defined by GNU C/C++ extension.
1228 SgGotoStatement * buildGotoStatement_nfi(SgExpression* expr);
1229 
1231 ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt( SgExpression * key = NULL,SgStatement *body = NULL);
1232 SgCaseOptionStmt * buildCaseOptionStmt_nfi( SgExpression * key,SgStatement *body);
1233 
1235 ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt( SgStatement *body = NULL);
1236 SgDefaultOptionStmt * buildDefaultOptionStmt_nfi( SgStatement *body);
1237 
1239 ROSE_DLL_API SgExprStatement* buildExprStatement(SgExpression* exp = NULL);
1240 SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
1241 
1242 // DQ (3/27/2015): Added support for SgStatementExpression.
1244 ROSE_DLL_API SgStatementExpression* buildStatementExpression(SgStatement* exp);
1245 ROSE_DLL_API SgStatementExpression* buildStatementExpression_nfi(SgStatement* exp);
1246 
1248 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement(SgStatement *item_selector = NULL,SgStatement *body = NULL);
1249 inline SgSwitchStatement* buildSwitchStatement(SgExpression *item_selector, SgStatement *body = NULL) {
1250  return buildSwitchStatement(buildExprStatement(item_selector), body);
1251 }
1252 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement_nfi(SgStatement *item_selector,SgStatement *body);
1253 
1255 ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1256 inline SgIfStmt * buildIfStmt(SgExpression* conditional, SgStatement * true_body, SgStatement * false_body) {
1257  return buildIfStmt(buildExprStatement(conditional), true_body, false_body);
1258 }
1259 
1260 ROSE_DLL_API SgIfStmt* buildIfStmt_nfi(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1261 
1262 // Rasmussen (9/3/2018)
1264 ROSE_DLL_API SgFortranDo* buildFortranDo(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock*);
1265 ROSE_DLL_API SgFortranDo* buildFortranDo_nfi(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock*);
1266 
1268 ROSE_DLL_API SgForInitStatement* buildForInitStatement();
1269 ROSE_DLL_API SgForInitStatement* buildForInitStatement(const SgStatementPtrList & statements);
1270 ROSE_DLL_API SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList & statements);
1271 
1272 // DQ (10/12/2012): Added new function for a single statement.
1273 ROSE_DLL_API SgForInitStatement* buildForInitStatement( SgStatement* statement );
1274 
1276 ROSE_DLL_API SgForStatement * buildForStatement(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1277 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1278 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1279 ROSE_DLL_API void buildForStatement_nfi(SgForStatement* result, SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1280 
1281 // DQ (3/26/2018): Adding support for range based for statement.
1282 // ROSE_DLL_API SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(SgVariableDeclaration* initializer, SgExpression* range, SgStatement* body);
1283 ROSE_DLL_API SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(
1284  SgVariableDeclaration* initializer, SgVariableDeclaration* range,
1285  SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration,
1286  SgExpression* not_equal_expression, SgExpression* increment_expression,
1287  SgStatement* body);
1288 
1289 // EDG 4.8 handled the do-while statement differently (more similar to a block scope than before in EDG 4.7 (i.e. with an end-of-construct statement).
1290 // So we need an builder function that can use the existing SgDoWhileStatement scope already on the stack.
1291 ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt* result, SgStatement * body, SgStatement * condition);
1292 
1294 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1295 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1296 
1297 // DQ (3/3/2013): Added UPC specific build functions.
1299 ROSE_DLL_API SgUpcNotifyStatement* buildUpcNotifyStatement_nfi(SgExpression* exp);
1300 
1302 ROSE_DLL_API SgUpcWaitStatement* buildUpcWaitStatement_nfi(SgExpression* exp);
1303 
1305 ROSE_DLL_API SgUpcBarrierStatement* buildUpcBarrierStatement_nfi(SgExpression* exp);
1306 
1308 ROSE_DLL_API SgUpcFenceStatement* buildUpcFenceStatement_nfi();
1309 
1310 
1312 ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1313 inline SgWhileStmt * buildWhileStmt(SgExpression * condition, SgStatement *body, SgStatement* else_body = NULL) {
1314  return buildWhileStmt(buildExprStatement(condition), body, else_body);
1315 }
1316 SgWhileStmt * buildWhileStmt_nfi(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1317 
1319 ROSE_DLL_API SgWithStatement* buildWithStatement(SgExpression* expr, SgStatement* body);
1320 SgWithStatement* buildWithStatement_nfi(SgExpression* expr, SgStatement* body);
1321 
1323 ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement * body, SgStatement *condition);
1324 inline SgDoWhileStmt * buildDoWhileStmt(SgStatement* body, SgExpression * condition) {
1325  return buildDoWhileStmt(body, buildExprStatement(condition));
1326 }
1327 SgDoWhileStmt * buildDoWhileStmt_nfi(SgStatement * body, SgStatement *condition);
1328 
1330 ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string & name, SgScopeStatement* scope=NULL);
1331 SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string & name, SgScopeStatement* scope);
1332 
1334 ROSE_DLL_API SgPragma* buildPragma(const std::string & name);
1335 
1337 ROSE_DLL_API SgEmptyDeclaration* buildEmptyDeclaration();
1338 
1340 ROSE_DLL_API SgBasicBlock * buildBasicBlock(SgStatement * stmt1 = NULL, SgStatement* stmt2 = NULL, SgStatement* stmt3 = NULL, SgStatement* stmt4 = NULL, SgStatement* stmt5 = NULL, SgStatement* stmt6 = NULL, SgStatement* stmt7 = NULL, SgStatement* stmt8 = NULL, SgStatement* stmt9 = NULL, SgStatement* stmt10 = NULL);
1341 ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi();
1342 SgBasicBlock * buildBasicBlock_nfi(const std::vector<SgStatement*>&);
1343 
1344 // CR (7/24/2020): Added additional functionality
1346 SgBasicBlock * buildBasicBlock_nfi(SgScopeStatement* parent);
1347 
1349 ROSE_DLL_API SgExprStatement*
1350 buildAssignStatement(SgExpression* lhs,SgExpression* rhs);
1351 
1352 // DQ (8/16/2011): Generated a new version of this function to define consistant semantics.
1354 ROSE_DLL_API SgExprStatement* buildAssignStatement_ast_translate(SgExpression* lhs,SgExpression* rhs);
1355 
1357 ROSE_DLL_API SgBreakStmt* buildBreakStmt();
1358 SgBreakStmt* buildBreakStmt_nfi();
1359 
1361 ROSE_DLL_API SgContinueStmt* buildContinueStmt();
1362 SgContinueStmt* buildContinueStmt_nfi();
1363 
1365 ROSE_DLL_API SgFortranContinueStmt* buildFortranContinueStmt();
1366 SgFortranContinueStmt* buildFortranContinueStmt_nfi();
1367 
1369 ROSE_DLL_API SgPassStatement* buildPassStatement();
1370 SgPassStatement* buildPassStatement_nfi();
1371 
1373 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression* test);
1374 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression *test, SgExpression *exceptionArgument);
1375 SgAssertStmt* buildAssertStmt_nfi(SgExpression* test);
1376 
1378 ROSE_DLL_API SgYieldExpression* buildYieldExpression(SgExpression* value);
1379 SgYieldExpression* buildYieldExpression_nfi(SgExpression* value);
1380 
1382 ROSE_DLL_API SgKeyDatumPair* buildKeyDatumPair (SgExpression* key, SgExpression* datum);
1383 SgKeyDatumPair* buildKeyDatumPair_nfi(SgExpression* key, SgExpression* datum);
1384 
1386 ROSE_DLL_API SgDictionaryExp* buildDictionaryExp (std::vector<SgKeyDatumPair*> pairs);
1387 SgDictionaryExp* buildDictionaryExp_nfi(std::vector<SgKeyDatumPair*> pairs);
1388 
1390 ROSE_DLL_API SgActualArgumentExpression* buildActualArgumentExpression(SgName arg_name, SgExpression* arg);
1391 SgActualArgumentExpression* buildActualArgumentExpression_nfi(SgName arg_name, SgExpression* arg);
1392 
1394 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1395 SgDeleteExp* buildDeleteExp_nfi(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1396 
1398 ROSE_DLL_API SgDeclarationScope * buildDeclarationScope();
1399 
1401 // SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL);
1402 ROSE_DLL_API SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1403 
1405 // SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL);
1406 SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1407 
1408 // DQ (11/19/2011): Added more template declaration support.
1410 SgTemplateClassDefinition* buildTemplateClassDefinition(SgTemplateClassDeclaration *d = NULL );
1411 
1413 // DQ (6/6/2012): Added support to get the template arguments into place before computing the type.
1414 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1415 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation = false);
1416 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1417 
1418 // DQ (8/11/2013): We need to hand in both the SgTemplateParameterPtrList and the SgTemplateArgumentPtrList because class templates can be partially specialized.
1420 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1421 
1423 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1424 
1426 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration ( SgName name, SgScopeStatement* scope );
1427 ROSE_DLL_API SgClassDeclaration* buildDefiningClassDeclaration ( SgName name, SgScopeStatement* scope );
1428 
1430 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration(SgName name, SgScopeStatement* scope);
1431 
1433 ROSE_DLL_API SgEnumDeclaration* buildNondefiningEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope);
1434 
1436 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1437 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const std::string& name, SgScopeStatement* scope=NULL);
1438 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const char* name, SgScopeStatement* scope=NULL);
1439 
1441 ROSE_DLL_API SgStmtDeclarationStatement* buildStmtDeclarationStatement(SgStatement* stmt);
1442 ROSE_DLL_API SgStmtDeclarationStatement* buildStmtDeclarationStatement_nfi(SgStatement* stmt);
1443 
1445 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1446 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName& name, bool unnamednamespace, SgScopeStatement* scope );
1447 ROSE_DLL_API SgNamespaceDefinitionStatement * buildNamespaceDefinition(SgNamespaceDeclarationStatement* d=NULL);
1448 
1449 // Pei-Hung (09/14/2023) :added support for building namespace alias
1450 ROSE_DLL_API SgNamespaceAliasDeclarationStatement * buildNamespaceAliasDeclarationStatement(const SgName& name, SgNamespaceDeclarationStatement* namespaceDeclaration);
1451 
1453 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp(SgExpression* lhs);
1454 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp_nfi(SgExpression* lhs);
1455 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp(SgExpression* lhs);
1456 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp_nfi(SgExpression* lhs);
1457 
1458 ROSE_DLL_API SgStringConversion* buildStringConversion(SgExpression* exp);
1459 ROSE_DLL_API SgStringConversion* buildStringConversion_nfi(SgExpression* exp);
1460 
1461 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1462 
1463 // DQ (8/11/2013): I think that the specification of both SgTemplateParameterPtrList and SgTemplateArgumentPtrList is redundant with the nonDefiningDecl (which is a required parameter).
1464 // DQ (11/19/2011): Added to support template class declaration using EDG 4.x support (to support the template declarations directly in the AST).
1465 ROSE_DLL_API SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl,
1466  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1468 ROSE_DLL_API SgTemplateClassDeclaration* buildTemplateClassDeclaration(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl,
1469  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1470 
1472 ROSE_DLL_API SgJovialDefineDeclaration * buildJovialDefineDeclaration_nfi (const SgName& name, const std::string& params,
1473  const std::string& def_string, SgScopeStatement* scope=NULL);
1474 
1477 ROSE_DLL_API SgJovialForThenStatement* buildJovialForThenStatement_nfi();
1478 
1481 ROSE_DLL_API SgDerivedTypeStatement * buildDerivedTypeStatement (const SgName& name, SgScopeStatement* scope=NULL);
1482 
1484 ROSE_DLL_API SgModuleStatement * buildModuleStatement(const SgName& name, SgScopeStatement* scope /*=NULL*/);
1485 
1487 ROSE_DLL_API SgJovialTableStatement * buildJovialTableStatement (const SgName& name,
1488  SgClassDeclaration::class_types kind, SgScopeStatement* scope=NULL);
1489 
1491  ROSE_DLL_API SgJovialTableType * buildJovialTableType (const SgName& name, SgType* base_type, SgExprListExp* dim_info, SgScopeStatement* scope=NULL);
1492 
1495 template <class DeclClass> ROSE_DLL_API
1496 DeclClass * buildClassDeclarationStatement_nfi(const SgName& name, SgClassDeclaration::class_types kind,
1497  SgScopeStatement* scope=NULL, SgClassDeclaration* nonDefiningDecl=NULL);
1498 
1500 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1501 
1503 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope=NULL);
1504 
1506 ROSE_DLL_API SgReturnStmt* buildReturnStmt(SgExpression* expression = NULL);
1507 ROSE_DLL_API SgReturnStmt* buildReturnStmt_nfi(SgExpression* expression);
1508 
1510 ROSE_DLL_API SgNullStatement* buildNullStatement();
1511 SgNullStatement* buildNullStatement_nfi();
1512 
1514 ROSE_DLL_API SgAttributeSpecificationStatement * buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind);
1515 
1517 ROSE_DLL_API SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);
1518 
1520 ROSE_DLL_API SgCommonBlockObject* buildCommonBlockObject(std::string name="", SgExprListExp* exp_list=NULL);
1521 
1523 ROSE_DLL_API SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block=NULL);
1524 
1525 // driscoll6 (6/9/2011): Adding support for try stmts.
1527 ROSE_DLL_API SgCatchOptionStmt* buildCatchOptionStmt(SgVariableDeclaration* condition=NULL, SgStatement* body=NULL);
1528 
1530 ROSE_DLL_API SgAsyncStmt* buildAsyncStmt(SgBasicBlock *body);
1531 
1533 ROSE_DLL_API SgFinishStmt* buildFinishStmt(SgBasicBlock *body);
1534 
1536 ROSE_DLL_API SgAtStmt* buildAtStmt(SgExpression *expression, SgBasicBlock *body);
1537 
1538 // MH (11/12/2014): Added atomic support
1539 ROSE_DLL_API SgAtomicStmt* buildAtomicStmt(SgBasicBlock *body);
1540 
1541 ROSE_DLL_API SgWhenStmt* buildWhenStmt(SgExpression *expression, SgBasicBlock *body);
1542 
1543 // MH (9/16/2014): Added at support
1544 ROSE_DLL_API SgAtExp* buildAtExp(SgExpression *expression, SgBasicBlock *body);
1545 
1546 // MH (11/7/2014): Added finish expression support
1547 ROSE_DLL_API SgFinishExp* buildFinishExp(SgExpression *expression, SgBasicBlock *body);
1548 
1549 ROSE_DLL_API SgHereExp* buildHereExpression();
1550 
1551 ROSE_DLL_API SgDotDotExp* buildDotDotExp();
1552 
1553 
1554 // driscoll6 (6/9/2011): Adding support for try stmts.
1556 ROSE_DLL_API SgTryStmt* buildTryStmt(SgStatement* body,
1557  SgCatchOptionStmt* catch0=NULL,
1558  SgCatchOptionStmt* catch1=NULL,
1559  SgCatchOptionStmt* catch2=NULL,
1560  SgCatchOptionStmt* catch3=NULL,
1561  SgCatchOptionStmt* catch4=NULL);
1562 
1563 // charles4 (9/16/2011): Adding support for try stmts.
1565 //SgTryStmt* buildTryStmt(SgStatement *try_body, SgCatchStatementSeq *catches, SgStatement *finally_body = NULL);
1566 
1567 // charles4 (9/16/2011): Adding support for try stmts.
1569 ROSE_DLL_API SgTryStmt* buildTryStmt(SgBasicBlock *try_body, SgBasicBlock *finally_body = NULL);
1570 
1571 // charles4 (9/16/2011): Adding support for Catch Blocks.
1573 ROSE_DLL_API SgCatchStatementSeq *buildCatchStatementSeq(SgCatchOptionStmt * = NULL);
1574 
1575 // charles4 (8/25/2011): Adding support for Java Synchronized stmts.
1577 ROSE_DLL_API SgJavaSynchronizedStatement *buildJavaSynchronizedStatement(SgExpression *, SgBasicBlock *);
1578 
1579 // charles4 (8/25/2011): Adding support for Java Throw stmts.
1581 ROSE_DLL_API SgJavaThrowStatement *buildJavaThrowStatement(SgThrowOp *);
1582 
1583 // charles4 (8/25/2011): Adding support for Java Foreach stmts.
1585 // SgJavaForEachStatement *buildJavaForEachStatement(SgInitializedName * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1586 ROSE_DLL_API SgJavaForEachStatement *buildJavaForEachStatement(SgVariableDeclaration * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1587 
1588 // charles4 (8/25/2011): Adding support for Java Label stmts.
1590 ROSE_DLL_API SgJavaLabelStatement *buildJavaLabelStatement(const SgName &, SgStatement * = NULL);
1591 
1593 ROSE_DLL_API SgExecStatement* buildExecStatement(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1594 SgExecStatement* buildExecStatement_nfi(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1595 
1597 ROSE_DLL_API SgPythonPrintStmt* buildPythonPrintStmt(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1598 SgPythonPrintStmt* buildPythonPrintStmt_nfi(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1599 
1601 ROSE_DLL_API SgPythonGlobalStmt* buildPythonGlobalStmt(SgInitializedNamePtrList& names);
1602 SgPythonGlobalStmt* buildPythonGlobalStmt_nfi(SgInitializedNamePtrList& names);
1603 
1604 // DQ (4/30/2010): Added support for building asm statements.
1606 ROSE_DLL_API SgAsmStmt* buildAsmStatement(std::string s);
1607 SgAsmStmt* buildAsmStatement_nfi(std::string s);
1608 
1611 ROSE_DLL_API SgAsmStmt* buildMultibyteNopStatement( int n );
1612 
1614 ROSE_DLL_API SgBaseClass* buildBaseClass ( SgClassDeclaration* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1615 
1616 ROSE_DLL_API SgNonrealBaseClass* buildNonrealBaseClass ( SgNonrealDecl* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1617 
1618 // SgAccessModifier buildAccessModifier ( unsigned int access );
1619 
1621 ROSE_DLL_API SgStaticAssertionDeclaration* buildStaticAssertionDeclaration(SgExpression* condition, const SgName & string_literal);
1622 
1624 ROSE_DLL_API SgMicrosoftAttributeDeclaration* buildMicrosoftAttributeDeclaration (const SgName & name);
1625 
1627 ROSE_DLL_API SgStatement* buildStatementFromString(const std::string & stmt_str, SgScopeStatement* scope);
1628 
1630 ROSE_DLL_API SgUsingDirectiveStatement* buildUsingDirectiveStatement(SgNamespaceDeclarationStatement * ns_decl);
1632 
1633 //--------------------------------------------------------------
1635 
1639 
1642 ROSE_DLL_API SgFile* buildFile(const std::string& inputFileName,const std::string& outputFileName, SgProject* project = NULL, bool clear_globalScopeAcrossFiles = false);
1643 
1645 
1647 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& outputFileName, SgProject* project=NULL, bool clear_globalScopeAcrossFiles = false);
1648 
1650 
1652 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& inputFileName, const std::string& outputFileName, SgProject* project, bool clear_globalScopeAcrossFiles = false);
1653 
1654 // DQ (11/8/2019): Support function for the new file (to support changing the file names in the source position info objects of each AST subtree node.
1656 // ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, const std::string& newFileName);
1657 ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, const std::string& newFileName);
1658 
1659 // DQ (11/10/2019): Support for sharing IR nodes when buildFile() is applied to an existing file.
1661 ROSE_DLL_API void fixupSharingSourcePosition(SgNode* subtreeRoot, int new_file_id);
1662 
1664 ROSE_DLL_API PreprocessingInfo* buildComment(SgLocatedNode* target, const std::string & content,
1665  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1666  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
1667 
1669 ROSE_DLL_API PreprocessingInfo* buildCpreprocessorDefineDeclaration(SgLocatedNode* target,
1670  const std::string & content,
1671  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
1672 
1674 ROSE_DLL_API PreprocessingInfo* buildHeader(const std::string& header_filename,
1675  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1676  bool isSystemHeader =false);
1677 
1678 
1679 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
1680 ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode* n);
1682 #endif
1683 
1684 // 03/17/2014 PHL
1685 // //! Build an equivalence statement from two expression operands
1686 ROSE_DLL_API SgEquivalenceStatement*
1687 buildEquivalenceStatement(SgExpression* lhs,SgExpression* rhs);
1688 
1689 
1691 ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope,
1692  SgStatement *toInsert, SgStatement* original_before_copy);
1693 ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement* insertionPoint, bool insertionPointIsScope,
1694  SgNode* node_copy, SgNode* node_original);
1695 ROSE_DLL_API SgType* getTargetFileTypeSupport(SgType* snippet_type, SgScopeStatement* targetScope);
1696 ROSE_DLL_API SgType* getTargetFileType(SgType* snippet_type, SgScopeStatement* targetScope);
1697 
1698 // DQ (12/6/2020): This is the original function (modified slightly, but mostly I have defined a new function that
1699 // will not effect the AST snippet support that is used by this function.
1700 ROSE_DLL_API SgSymbol* findAssociatedSymbolInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1701 
1702 // DQ (12/6/2020): This is the new function (modified in API and made suitable for the codeSegregation support).
1703 ROSE_DLL_API SgDeclarationStatement* findAssociatedDeclarationInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1704 
1706 ROSE_DLL_API void errorCheckingTargetAST (SgNode* node_copy, SgNode* node_original, SgFile* targetFile, bool failOnWarning);
1707 
1708 //-----------------------------------------------------------------------------
1709 //#ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1710 //-----------------------------------------------------------------------------
1711 ROSE_DLL_API SgVarRefExp *buildJavaArrayLengthVarRefExp();
1712 ROSE_DLL_API SgScopeStatement *buildScopeStatement(SgClassDefinition * = NULL);
1713 ROSE_DLL_API SgJavaTypeExpression *buildJavaTypeExpression(SgType *);
1714 ROSE_DLL_API SgJavaMarkerAnnotation *buildJavaMarkerAnnotation(SgType *);
1715 ROSE_DLL_API SgJavaMemberValuePair *buildJavaMemberValuePair(const SgName &, SgExpression *);
1716 ROSE_DLL_API SgJavaSingleMemberAnnotation *buildJavaSingleMemberAnnotation(SgType *, SgExpression *);
1717 ROSE_DLL_API SgJavaNormalAnnotation *buildJavaNormalAnnotation(SgType *);
1718 ROSE_DLL_API SgJavaNormalAnnotation *buildJavaNormalAnnotation(SgType *, std::list<SgJavaMemberValuePair *>&);
1719 ROSE_DLL_API SgInitializedName *buildJavaFormalParameter(SgType *, const SgName &, bool is_var_args = false, bool is_final = false);
1720 
1721 ROSE_DLL_API SgJavaPackageStatement *buildJavaPackageStatement(std::string);
1722 ROSE_DLL_API SgJavaImportStatement *buildJavaImportStatement(std::string, bool);
1723 ROSE_DLL_API SgClassDeclaration *buildJavaDefiningClassDeclaration(SgScopeStatement *, std::string, SgClassDeclaration::class_types kind = SgClassDeclaration::e_class);
1724 ROSE_DLL_API SgSourceFile *buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string);
1725 ROSE_DLL_API SgArrayType *getUniqueJavaArrayType(SgType *, int);
1726 ROSE_DLL_API SgJavaParameterizedType *getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *);
1727 ROSE_DLL_API SgJavaQualifiedType *getUniqueJavaQualifiedType(SgClassDeclaration *, SgNamedType *, SgNamedType *);
1728 ROSE_DLL_API SgJavaWildcardType *getUniqueJavaWildcardUnbound();
1729 ROSE_DLL_API SgJavaWildcardType *getUniqueJavaWildcardExtends(SgType *);
1730 ROSE_DLL_API SgJavaWildcardType *getUniqueJavaWildcardSuper(SgType *);
1731 
1733 
1734 
1735 //----------------------------------------------------------
1737 
1751 
1752 
1753 
1754  //----------------------build unary expressions----------------------
1756 
1760 template <class T>
1761  T* buildUnaryExpression(SgExpression* operand) {
1762  SgExpression* myoperand=operand;
1763  T* result = new T(myoperand, NULL);
1764  ROSE_ASSERT(result);
1765  if (myoperand!=NULL) {
1766  myoperand->set_parent(result);
1767  // set lvalue, it asserts operand!=NULL
1768  markLhsValues(result);
1769  }
1770  SageInterface::setOneSourcePositionForTransformation(result);
1771  return result;
1772  }
1773 
1775 
1778 template <class T>
1779 T* buildUnaryExpression_nfi(SgExpression* operand) {
1780  SgExpression* myoperand = operand;
1781  T* result = new T(myoperand, NULL);
1782  ROSE_ASSERT(result);
1783 
1784  if (myoperand != NULL) {
1785  myoperand->set_parent(result);
1786  // set lvalue, it asserts operand!=NULL
1787  markLhsValues(result);
1788  }
1789  SageInterface::setSourcePosition(result);
1790 
1791  result->set_need_paren(false);
1792  return result;
1793  }
1794 
1795 //---------------------binary expressions-----------------------
1796 
1798 
1801  template <class T>
1802  T* buildBinaryExpression(SgExpression* lhs, SgExpression* rhs) {
1803  SgExpression* mylhs, *myrhs;
1804  mylhs = lhs;
1805  myrhs = rhs;
1806  T* result = new T(mylhs,myrhs, NULL);
1807  ROSE_ASSERT(result);
1808  if (mylhs!=NULL) {
1809  mylhs->set_parent(result);
1810  // set lvalue
1811  markLhsValues(result);
1812  }
1813  if (myrhs!=NULL) myrhs->set_parent(result);
1814  SageInterface::setOneSourcePositionForTransformation(result);
1815  return result;
1816  }
1817 
1819 
1822  template <class T>
1823  T* buildBinaryExpression_nfi(SgExpression* lhs, SgExpression* rhs) {
1824  SgExpression* mylhs, *myrhs;
1825  mylhs = lhs;
1826  myrhs = rhs;
1827  T* result = new T(mylhs,myrhs, NULL);
1828  ROSE_ASSERT(result);
1829  if (mylhs!=NULL) {
1830  mylhs->set_parent(result);
1831  // set lvalue
1832  markLhsValues(result);
1833  }
1834  if (myrhs!=NULL) myrhs->set_parent(result);
1835  SageInterface::setSourcePosition(result);
1836  result->set_need_paren(false);
1837 
1838  return result;
1839  }
1840 
1841 } // end of namespace
1842 
1843 namespace Rose {
1844  namespace Frontend {
1845  namespace Java {
1846 
1847  extern ROSE_DLL_API SgClassDefinition *javaLangPackageDefinition;
1848  extern ROSE_DLL_API SgClassType *ObjectClassType;
1849  extern ROSE_DLL_API SgClassType *StringClassType;
1850  extern ROSE_DLL_API SgClassType *ClassClassType;
1851  extern ROSE_DLL_API SgVariableSymbol *lengthSymbol;
1852 
1853  }// ::Rose::frontend::java
1854  }// ::Rose::frontend
1855 }// ::Rose
1856 
1857 namespace Rose {
1858  namespace Builder {
1859  namespace Templates {
1860 
1861  SgTemplateArgument * buildTemplateArgument(SgType * t);
1862  SgTemplateArgument * buildTemplateArgument(SgExpression * e);
1863  SgTemplateArgument * buildTemplateArgument(int v);
1864  SgTemplateArgument * buildTemplateArgument(bool v);
1865 
1866  std::string strTemplateArgument(int v);
1867  std::string strTemplateArgument(bool v);
1868  std::string strTemplateArgument(SgType * t);
1869  std::string strTemplateArgument(SgNamedType * nt);
1870  std::string strTemplateArgument(SgExpression * e);
1871 
1872  template <typename... Args>
1873  struct TemplateArgumentList {
1874  static std::string str() { return ""; }
1875  static void fill(std::vector<SgTemplateArgument *> & tpl_args) {}
1876  };
1877 
1878  template <typename T>
1879  struct TemplateArgumentList<T> {
1880  static std::string str(T v) {
1881  return strTemplateArgument(v);
1882  }
1883  static void fill(std::vector<SgTemplateArgument *> & tpl_args, T v) {
1884  tpl_args.push_back(buildTemplateArgument(v));
1885  }
1886  };
1887 
1888  template <typename T, typename... Args>
1889  struct TemplateArgumentList<T, Args...> {
1890  static std::string str(T v, Args... args) {
1891  return strTemplateArgument(v) + ", " + TemplateArgumentList<Args...>::str(args...);
1892  }
1893  static void fill(std::vector<SgTemplateArgument *> & tpl_args, T v, Args... args) {
1894  tpl_args.push_back(buildTemplateArgument(v));
1895  TemplateArgumentList<Args...>::fill(tpl_args, args...);
1896  }
1897  };
1898 
1899  template <typename... Args>
1900  std::string strTemplateArgumentList(Args... args) {
1901  return TemplateArgumentList<Args...>::str(args...);
1902  }
1903 
1904  template <typename... Args>
1905  void fillTemplateArgumentList(std::vector<SgTemplateArgument *> & tpl_args, Args... args) {
1906  TemplateArgumentList<Args...>::fill(tpl_args, args...);
1907  }
1908 
1909  template <typename... Args>
1910  std::vector<SgTemplateArgument *> buildTemplateArgumentList(Args... args) {
1911  std::vector<SgTemplateArgument *> tpl_args;
1912  TemplateArgumentList<Args...>::fill(tpl_args, args...);
1913  return tpl_args;
1914  }
1915 
1916  SgExpression * instantiateNonrealRefExps(SgExpression * expr, std::vector<SgTemplateParameter *> & tpl_params, std::vector<SgTemplateArgument *> & tpl_args);
1917  SgType * instantiateNonrealTypes(SgType * type, std::vector<SgTemplateParameter *> & tpl_params, std::vector<SgTemplateArgument *> & tpl_args);
1918 
1919 } } }
1920 
1921 namespace SageBuilder {
1922  using namespace Rose::Builder::Templates;
1923 }
1924 
1925 //-----------------------------------------------------------------------------
1926 //#endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1927 //-----------------------------------------------------------------------------
1928 
1929 #endif //ROSE_SAGE_BUILDER_INTERFACE
SageBuilder::buildJovialTableType
ROSE_DLL_API SgJovialTableType * buildJovialTableType(const SgName &name, SgType *base_type, SgExprListExp *dim_info, SgScopeStatement *scope=NULL)
Build a Jovial table type with required class definition and defining and nondefining declarations...
SageBuilder::buildInitializedName_nfi
ROSE_DLL_API SgInitializedName * buildInitializedName_nfi(const SgName &name, SgType *type, SgInitializer *init)
Initialized names are tricky, their scope vary depending on context, so scope and symbol information ...
SageBuilder::buildPythonGlobalStmt_nfi
SgPythonGlobalStmt * buildPythonGlobalStmt_nfi(SgInitializedNamePtrList &names)
Build a variable declaration, handle symbol table transparently.
SgInitializer
This class represents the notion of an initializer for a variable declaration or expression in a func...
Definition: Cxx_Grammar.h:313231
SageBuilder::buildLongLongIntVal_nfi
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal_nfi(long long value, const std::string &str)
SageBuilder::buildHereExpression
ROSE_DLL_API SgHereExp * buildHereExpression()
Build a variable declaration, handle symbol table transparently.
SgScopeStatement
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
Definition: Cxx_Grammar.h:122367
SgTemplateInstantiationMemberFunctionDecl
This class represents the concept of an instantiation of member function template or a member functio...
Definition: Cxx_Grammar.h:167223
SageBuilder::buildJavaMarkerAnnotation
ROSE_DLL_API SgJavaMarkerAnnotation * buildJavaMarkerAnnotation(SgType *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildClassNameRefExp
ROSE_DLL_API SgClassNameRefExp * buildClassNameRefExp(SgClassSymbol *sym)
SgClassDeclaration
This class represents the concept of a class declaration statement. It includes the concept of an ins...
Definition: Cxx_Grammar.h:158741
SageBuilder::clearScopeStack
ROSE_DLL_API void clearScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
SageBuilder::buildWcharVal
ROSE_DLL_API SgWcharVal * buildWcharVal(wchar_t value=0)
SageBuilder::buildAsmStatement
ROSE_DLL_API SgAsmStmt * buildAsmStatement(std::string s)
Build a NULL statement.
SageBuilder::buildLambdaExp
ROSE_DLL_API SgLambdaExp * buildLambdaExp(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
DQ (9/3/2014): Adding support for C++11 Lambda expressions.
SgFunctionParameterList
This class represents the concept of a declaration list.
Definition: Cxx_Grammar.h:144012
SageBuilder::buildTypeIdOp
ROSE_DLL_API SgTypeIdOp * buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type)
DQ (1/25/2013): Added support for typeId operators.
SageBuilder::buildConstructorInitializer
ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer(SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown)
SgBoolValExp
This class represents a boolean value (expression value).
Definition: Cxx_Grammar.h:290582
SageBuilder::buildSuperExp_nfi
ROSE_DLL_API SgSuperExp * buildSuperExp_nfi(SgClassSymbol *sym)
SageBuilder::buildCudaKernelExecConfig_nfi
SgCudaKernelExecConfig * buildCudaKernelExecConfig_nfi(SgExpression *grid=NULL, SgExpression *blocks=NULL, SgExpression *shared=NULL, SgExpression *stream=NULL)
Build a CUDA kernel execution configuration (<<>>)
SageBuilder::buildPointerMemberType
ROSE_DLL_API SgPointerMemberType * buildPointerMemberType(SgType *base_type, SgType *classType)
Pei-Hung (06/30/2023): support for SgPointerMemberType.
SageBuilder::buildJavaFormalParameter
ROSE_DLL_API SgInitializedName * buildJavaFormalParameter(SgType *, const SgName &, bool is_var_args=false, bool is_final=false)
Build a SgFile node and attach it to SgProject.
SgNaryComparisonOp
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
Definition: Cxx_Grammar.h:332416
SageBuilder::buildAssignInitializer
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
Build the rhs of a variable declaration which includes an assignment.
SageBuilder::buildArrayType
ROSE_DLL_API SgArrayType * buildArrayType(SgType *base_type=NULL, SgExpression *index=NULL)
Build ArrayType.
SageBuilder::buildFoldExpression
ROSE_DLL_API SgFoldExpression * buildFoldExpression(SgExpression *operands, std::string operator_token_string, bool is_left_associative)
SgLongDoubleVal
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:298720
SageBuilder::buildTypedefDeclaration
ROSE_DLL_API SgTypedefDeclaration * buildTypedefDeclaration(const std::string &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a typedef declaration, such as: typedef int myint; typedef struct A {..} s_A;.
SageBuilder::buildForInitStatement
ROSE_DLL_API SgForInitStatement * buildForInitStatement()
Build a for init statement.
SageBuilder::buildSwitchStatement
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement(SgStatement *item_selector=NULL, SgStatement *body=NULL)
Build a switch statement.
SageBuilder::getTemplateParameterList
ROSE_DLL_API SgTemplateParameterPtrList * getTemplateParameterList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SgGotoStatement
This class represents the concept of a C or C++ goto statement.
Definition: Cxx_Grammar.h:202222
SageBuilder::buildExecStatement
ROSE_DLL_API SgExecStatement * buildExecStatement(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build an exec statement.
SageBuilder::buildClassDeclaration_nfi
ROSE_DLL_API SgClassDeclaration * buildClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgClassDeclaration *nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildModifierType
ROSE_DLL_API SgModifierType * buildModifierType(SgType *base_type=NULL)
Build a modifier type.
SageBuilder::buildNaryComparisonOp_nfi
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildAlignOfOp_nfi
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp_nfi(SgExpression *exp)
SageBuilder::buildFile
ROSE_DLL_API SgFile * buildFile(const std::string &inputFileName, const std::string &outputFileName, SgProject *project=NULL, bool clear_globalScopeAcrossFiles=false)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildReturnStmt
ROSE_DLL_API SgReturnStmt * buildReturnStmt(SgExpression *expression=NULL)
Build a return statement.
SageBuilder::buildLabelRefExp
ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol *s)
Build a Fortran numeric label ref exp.
SageBuilder::buildActualArgumentExpression_nfi
SgActualArgumentExpression * buildActualArgumentExpression_nfi(SgName arg_name, SgExpression *arg)
Build a variable declaration, handle symbol table transparently.
SageBuilder::pushScopeStack
ROSE_DLL_API void pushScopeStack(SgScopeStatement *stmt)
Public interfaces of the scope stack, should be stable.
SgExecStatement
This class represents the concept of the dynamic execution of a string, file, or code object...
Definition: Cxx_Grammar.h:231971
SageBuilder::buildUnsignedShortType
ROSE_DLL_API SgTypeUnsignedShort * buildUnsignedShortType()
Built in simple types.
SageBuilder::findAssociatedDeclarationInTargetAST
ROSE_DLL_API SgDeclarationStatement * findAssociatedDeclarationInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildAtExp
ROSE_DLL_API SgAtExp * buildAtExp(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::getUniqueJavaWildcardExtends
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardExtends(SgType *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildMemberFunctionRefExp_nfi
SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
SgExprStatement
This class represents the concept of a C or C++ statement which contains a expression.
Definition: Cxx_Grammar.h:197985
SageBuilder::buildMemberFunctionRefExp
ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
SageBuilder::buildUpcThreads_nfi
ROSE_DLL_API SgUpcThreads * buildUpcThreads_nfi()
SageBuilder::buildFloat128Val
ROSE_DLL_API SgFloat128Val * buildFloat128Val(long double value=0.0)
SageBuilder::buildLongIntVal_nfi
ROSE_DLL_API SgLongIntVal * buildLongIntVal_nfi(long value, const std::string &str)
SageBuilder::buildChar32Type
ROSE_DLL_API SgTypeChar32 * buildChar32Type()
Built in simple types.
SageBuilder::buildMatrixType
ROSE_DLL_API SgTypeMatrix * buildMatrixType()
Build a Matlab Matrix Type.
SgFile
This class represents a source file for a project (which may contian many source files and or directo...
Definition: Cxx_Grammar.h:25448
SageBuilder::buildEnumVal
ROSE_DLL_API SgEnumVal * buildEnumVal(long long int value, SgEnumDeclaration *decl, SgName name)
SageBuilder::buildDefiningTemplateFunctionDeclaration
ROSE_DLL_API SgTemplateFunctionDeclaration * buildDefiningTemplateFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, SgTemplateFunctionDeclaration *first_nondefining_declaration)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildEnumVal_nfi
ROSE_DLL_API SgEnumVal * buildEnumVal_nfi(long long int value, SgEnumDeclaration *decl, SgName name)
SageBuilder::buildDefaultOptionStmt_nfi
SgDefaultOptionStmt * buildDefaultOptionStmt_nfi(SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SgForInitStatement
This class represents the variable declaration or variable initialization withn a for loop...
Definition: Cxx_Grammar.h:204219
SageBuilder::buildFortranKindType
ROSE_DLL_API SgModifierType * buildFortranKindType(SgType *base_type, SgExpression *kindExpression)
Build a type based on the Fortran kind mechanism.
SageBuilder::buildAttributeSpecificationStatement
ROSE_DLL_API SgAttributeSpecificationStatement * buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind)
Build Fortran attribute specification statement.
SageBuilder::buildMagicColonExp
ROSE_DLL_API SgMagicColonExp * buildMagicColonExp()
Build a Matlab colon expression :
SageBuilder::buildSuperExp
ROSE_DLL_API SgSuperExp * buildSuperExp(SgClassSymbol *sym)
Build super pointer.
SageBuilder::buildFloat80Val_nfi
ROSE_DLL_API SgFloat80Val * buildFloat80Val_nfi(long double value, const std::string &str)
SgCatchStatementSeq
This class represents the concept of a C++ sequence of catch statements.
Definition: Cxx_Grammar.h:204750
SageBuilder::buildBasicBlock
ROSE_DLL_API SgBasicBlock * buildBasicBlock(SgStatement *stmt1=NULL, SgStatement *stmt2=NULL, SgStatement *stmt3=NULL, SgStatement *stmt4=NULL, SgStatement *stmt5=NULL, SgStatement *stmt6=NULL, SgStatement *stmt7=NULL, SgStatement *stmt8=NULL, SgStatement *stmt9=NULL, SgStatement *stmt10=NULL)
Build a SgBasicBlock, setting file info internally.
SgUnaryOp
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
Definition: Cxx_Grammar.h:244701
SageBuilder::buildActualArgumentExpression
ROSE_DLL_API SgActualArgumentExpression * buildActualArgumentExpression(SgName arg_name, SgExpression *arg)
Build an Actual Argument Expression.
SageBuilder::buildAlignOfOp
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp(SgExpression *exp=NULL)
Build alignof() expression with an expression parameter.
SageBuilder::buildThisExp_nfi
ROSE_DLL_API SgThisExp * buildThisExp_nfi(SgSymbol *sym)
SageBuilder::buildClassTemplateType
ROSE_DLL_API SgClassType * buildClassTemplateType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Some support for building class template instantiation declarations.
SageBuilder::inSwitchScope
bool inSwitchScope()
intended to be a private member, don't access it directly. could be changed any time ...
SageBuilder::buildFortranImplicitType
ROSE_DLL_API SgType * buildFortranImplicitType(SgName name)
Build a type based on Fortran's implicit typing rules.
SgStatementExpression
This class represents the GNU extension "statement expression" (thus is non-standard C and C++)...
Definition: Cxx_Grammar.h:323626
SgThrowOp
This class represents the C++ throw expression (handled as a unary operator).
Definition: Cxx_Grammar.h:250281
SgAssignInitializer
This class represents the rhs of a variable declaration which includes an optional assignment (e...
Definition: Cxx_Grammar.h:315464
SageBuilder::buildLongDoubleVal
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal(long double value=0.0)
SageBuilder::buildLongDoubleType
ROSE_DLL_API SgTypeLongDouble * buildLongDoubleType()
Built in simple types.
SageBuilder::buildComplexType
ROSE_DLL_API SgTypeComplex * buildComplexType(SgType *base_type=NULL)
Build a complex type.
SageBuilder::buildUnsignedLongVal_nfi
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal_nfi(unsigned long v, const std::string &str)
SageBuilder::buildFoldExpression_nfi
ROSE_DLL_API SgFoldExpression * buildFoldExpression_nfi(SgExpression *operands, std::string operator_token_string, bool is_left_associative)
SageBuilder::buildLambdaExp_nfi
ROSE_DLL_API SgLambdaExp * buildLambdaExp_nfi(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
SgUsingDirectiveStatement
This class represents the concept of a C++ using directive.
Definition: Cxx_Grammar.h:158210
SageBuilder::buildInitializedName
ROSE_DLL_API SgInitializedName * buildInitializedName(const SgName &name, SgType *type, SgInitializer *init=NULL)
Initialized names are tricky, their scope vary depending on context, so scope and symbol information ...
SageBuilder::popScopeStack
ROSE_DLL_API void popScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
SgType
This class represents the base class for all types.
Definition: Cxx_Grammar.h:52473
SageBuilder::buildStringVal
ROSE_DLL_API SgStringVal * buildStringVal(std::string value="")
SageBuilder::buildSetComprehension_nfi
SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
SageBuilder::buildUnaryExpression
T * buildUnaryExpression(SgExpression *operand)
Template function to build a unary expression of type T. Instantiated functions include:buildAddressO...
Definition: sageBuilder.h:1761
SageBuilder::buildJavaTypeExpression
ROSE_DLL_API SgJavaTypeExpression * buildJavaTypeExpression(SgType *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildVarRefExp
ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName &name, SgScopeStatement *scope=NULL)
Build SgVarRefExp based on a variable's Sage name. It will lookup the name in the symbol table intern...
SageBuilder::buildDotDotExp
ROSE_DLL_API SgDotDotExp * buildDotDotExp()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildCaseOptionStmt_nfi
SgCaseOptionStmt * buildCaseOptionStmt_nfi(SgExpression *key, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildChar16Type
ROSE_DLL_API SgTypeChar16 * buildChar16Type()
Built in simple types.
Sawyer::Message::Facility
Collection of streams.
Definition: Message.h:1606
SgWhileStmt
This class represents the concept of a do-while statement.
Definition: Cxx_Grammar.h:128235
SageBuilder::buildClassDeclarationStatement_nfi
ROSE_DLL_API DeclClass * buildClassDeclarationStatement_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope=NULL, SgClassDeclaration *nonDefiningDecl=NULL)
Build a generic class declaration statement (SgClassDeclaration or subclass) with a class declaration...
SageBuilder::buildTemplateType
ROSE_DLL_API SgTemplateType * buildTemplateType(SgName name="")
Build a template type, used for template parameter and later argument.
SageBuilder::buildFunctionType
ROSE_DLL_API SgFunctionType * buildFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList=NULL)
Build function type from return type and parameter type list.
SageBuilder::buildSetComprehension
ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators)
SageBuilder::buildForInitStatement_nfi
ROSE_DLL_API SgForInitStatement * buildForInitStatement_nfi(SgStatementPtrList &statements)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildAbstractHandle
ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode *n)
Build an abstract handle from a SgNode.
SgClassSymbol
This class represents the concept of a class name within the compiler.
Definition: Cxx_Grammar.h:355647
SageBuilder::buildUnsignedIntVal
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal(unsigned int v=0)
Build an unsigned integer.
SageBuilder::buildAutoType
ROSE_DLL_API SgAutoType * buildAutoType()
Built in simple types.
SageBuilder::SourcePositionClassificationMode
SourcePositionClassification SourcePositionClassificationMode
C++ SageBuilder namespace specific state for storage of the source code position state (used to contr...
SageBuilder::e_sourcePositionNullPointers
Classify as compiler generated code (e.g. template instantiation).
Definition: sageBuilder.h:144
SageBuilder::buildTypeExpression
ROSE_DLL_API SgTypeExpression * buildTypeExpression(SgType *type)
DQ (7/24/2014): Adding support for c11 generic operands.
SageBuilder::buildListExp_nfi
SgListExp * buildListExp_nfi()
SageBuilder::buildFunctionCallStmt
ROSE_DLL_API SgExprStatement * buildFunctionCallStmt(const SgName &name, SgType *return_type, SgExprListExp *parameters=NULL, SgScopeStatement *scope=NULL)
Build a regular function call statement.
SageBuilder::buildRestrictType
ROSE_DLL_API SgModifierType * buildRestrictType(SgType *base_type)
Build a restrict type.
SageBuilder::buildThisExp
ROSE_DLL_API SgThisExp * buildThisExp(SgSymbol *sym)
Build this pointer.
SgEnumDeclaration
This class represents the concept of an enum declaration.
Definition: Cxx_Grammar.h:147903
SageBuilder::buildStatementExpression_nfi
ROSE_DLL_API SgStatementExpression * buildStatementExpression_nfi(SgStatement *exp)
Build a variable declaration, handle symbol table transparently.
SageBuilder::testTemplateParameterParents
ROSE_DLL_API void testTemplateParameterParents(SgDeclarationStatement *decl)
DQ (9/16/2012): Added function to support setting the template parameters and setting their parents (...
SageBuilder::buildUpcMythread_nfi
ROSE_DLL_API SgUpcMythread * buildUpcMythread_nfi()
SageBuilder::buildKeyDatumPair
ROSE_DLL_API SgKeyDatumPair * buildKeyDatumPair(SgExpression *key, SgExpression *datum)
Build a key-datum pair.
SageBuilder::buildCompoundLiteralExp_nfi
SgCompoundLiteralExp * buildCompoundLiteralExp_nfi(SgVariableSymbol *varSymbol)
Build function for compound literals (uses a SgVariableSymbol and is similar to buildVarRefExp_nfi())...
SageBuilder::buildDictionaryComprehension_nfi
SgDictionaryComprehension * buildDictionaryComprehension_nfi(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
SageBuilder::buildNondefiningTemplateClassDeclaration
ROSE_DLL_API SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
buildNondefiningTemplateClassDeclaration()
SageBuilder::buildEquivalenceStatement
ROSE_DLL_API SgEquivalenceStatement * buildEquivalenceStatement(SgExpression *lhs, SgExpression *rhs)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildRangeBasedForStatement_nfi
ROSE_DLL_API SgRangeBasedForStatement * buildRangeBasedForStatement_nfi(SgVariableDeclaration *initializer, SgVariableDeclaration *range, SgVariableDeclaration *begin_declaration, SgVariableDeclaration *end_declaration, SgExpression *not_equal_expression, SgExpression *increment_expression, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SgThisExp
This class represents the "this" operator (can be applied to any member data).
Definition: Cxx_Grammar.h:312225
SageBuilder::buildExprListExp
ROSE_DLL_API SgExprListExp * buildExprListExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgExprListExp, used for function call parameter list etc.
SgNode::set_parent
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
SgTypeString
This class represents a string type used for SgStringVal IR node.
Definition: Cxx_Grammar.h:66162
SageBuilder::buildClassNameRefExp_nfi
SgClassNameRefExp * buildClassNameRefExp_nfi(SgClassSymbol *sym)
SageBuilder::buildUpcStrictType
ROSE_DLL_API SgModifierType * buildUpcStrictType(SgType *base_type=NULL)
Build a UPC strict type.
SageBuilder::buildNondefiningTemplateFunctionDeclaration
ROSE_DLL_API SgTemplateFunctionDeclaration * buildNondefiningTemplateFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope=NULL, SgExprListExp *decoratorList=NULL, SgTemplateParameterPtrList *templateParameterList=NULL)
Build a variable declaration, handle symbol table transparently.
SgNaryBooleanOp
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
Definition: Cxx_Grammar.h:331926
SageBuilder::buildComprehension
ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
SgAttributeSpecificationStatement::attribute_spec_enum
attribute_spec_enum
Fortran specific classification of attribute statements (each corresponds to a declaration attribute)...
Definition: Cxx_Grammar.h:149114
SageBuilder::buildLambdaCapture
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
SgInitializedName
This class represents the notion of a declared variable.
Definition: Cxx_Grammar.h:97176
SageBuilder::buildUpcBlockNumberType
ROSE_DLL_API SgModifierType * buildUpcBlockNumberType(SgType *base_type, long block_factor)
Build a UPC shared[n] type.
SageBuilder::buildThrowOp
ROSE_DLL_API SgThrowOp * buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind)
Build a ThrowOp expression.
SageBuilder::buildAwaitExpression_nfi
ROSE_DLL_API SgAwaitExpression * buildAwaitExpression_nfi()
SageBuilder::buildNullStatement_nfi
SgNullStatement * buildNullStatement_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildModuleStatement
ROSE_DLL_API SgModuleStatement * buildModuleStatement(const SgName &name, SgScopeStatement *scope)
Build a Fortran module declaration.
SageBuilder::buildFunctionCallExp
ROSE_DLL_API SgFunctionCallExp * buildFunctionCallExp(SgFunctionSymbol *sym, SgExprListExp *parameters=NULL)
Build a function call expression.
SageBuilder::getUniqueJavaParameterizedType
ROSE_DLL_API SgJavaParameterizedType * getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildAssertStmt_nfi
SgAssertStmt * buildAssertStmt_nfi(SgExpression *test)
Build a variable declaration, handle symbol table transparently.
SgMemberFunctionDeclaration
This class represents the concept of a member function declaration statement.
Definition: Cxx_Grammar.h:166120
SgCaseOptionStmt
This class represents the concept of a C and C++ case option (used within a switch statement)...
Definition: Cxx_Grammar.h:199077
SageBuilder::getTemplateArgumentList
ROSE_DLL_API SgTemplateArgumentPtrList * getTemplateArgumentList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildStaticAssertionDeclaration
ROSE_DLL_API SgStaticAssertionDeclaration * buildStaticAssertionDeclaration(SgExpression *condition, const SgName &string_literal)
DQ (7/25/2014): Adding support for C11 static assertions.
SageBuilder::buildJavaSingleMemberAnnotation
ROSE_DLL_API SgJavaSingleMemberAnnotation * buildJavaSingleMemberAnnotation(SgType *, SgExpression *)
Build a SgFile node and attach it to SgProject.
SgFunctionDeclaration
This class represents the concept of a function declaration statement.
Definition: Cxx_Grammar.h:164666
SageBuilder::buildAsmStatement_nfi
SgAsmStmt * buildAsmStatement_nfi(std::string s)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildFloat128Type
ROSE_DLL_API SgTypeFloat128 * buildFloat128Type()
Built in simple types.
SageBuilder::buildVariableDeclaration_nfi
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope, bool builtFromUseOnly=false, SgStorageModifier::storage_modifier_enum sm=SgStorageModifier::e_default)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildIfStmt
ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build if statement.
SageBuilder::buildNondefiningEnumDeclaration_nfi
ROSE_DLL_API SgEnumDeclaration * buildNondefiningEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope)
Build an enum first nondefining declaration, without file info.
SgReturnStmt
This class represents the concept of a C Assembler statement (untested).
Definition: Cxx_Grammar.h:201721
SageBuilder::buildEnumDeclaration
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
SageBuilder::buildChar16Val_nfi
ROSE_DLL_API SgChar16Val * buildChar16Val_nfi(unsigned short value, const std::string &str)
SageBuilder::buildBaseClass
ROSE_DLL_API SgBaseClass * buildBaseClass(SgClassDeclaration *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
DQ (5/6/2013): Added build functions to support SgBaseClass construction.
SageBuilder::buildReferenceType
ROSE_DLL_API SgReferenceType * buildReferenceType(SgType *base_type=NULL)
Build a reference type.
SageBuilder::buildTemplateClassType
ROSE_DLL_API SgClassType * buildTemplateClassType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Same as buildClassTemplateType(), just better name.
SageBuilder::buildFloat128Val_nfi
ROSE_DLL_API SgFloat128Val * buildFloat128Val_nfi(long double value, const std::string &str)
SageBuilder::buildSignedLongLongType
ROSE_DLL_API SgTypeSignedLongLong * buildSignedLongLongType()
Built in simple types.
SgExprListExp
This class represents the concept of a C and C++ expression list.
Definition: Cxx_Grammar.h:285941
SageBuilder::buildIntValHex
ROSE_DLL_API SgIntVal * buildIntValHex(int value=0)
SageBuilder::buildPlusPlusOp_nfi
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp_nfi(SgExpression *op)
SageBuilder::buildUnsignedIntType
ROSE_DLL_API SgTypeUnsignedInt * buildUnsignedIntType()
Built in simple types.
SageBuilder::fixupCopyOfNodeFromSeparateFileInNewTargetAst
ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgNode *node_copy, SgNode *node_original)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildNewExp
ROSE_DLL_API SgNewExp * buildNewExp(SgType *type, SgExprListExp *exprListExp, SgConstructorInitializer *constInit, SgExpression *expr, short int val, SgFunctionDeclaration *funcDecl)
SageBuilder::buildFunctionParameterList_nfi
SgFunctionParameterList * buildFunctionParameterList_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTypeOfType
ROSE_DLL_API SgTypeOfType * buildTypeOfType(SgExpression *base_expression, SgType *base_type)
Build a GNU typeof operator.
SgSizeOfOp
This class represents the "sizeof()" operator (applied to any type).
Definition: Cxx_Grammar.h:306799
SageBuilder::getUniqueJavaWildcardUnbound
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardUnbound()
Build a SgFile node and attach it to SgProject.
SageBuilder::getUniqueJavaArrayType
ROSE_DLL_API SgArrayType * getUniqueJavaArrayType(SgType *, int)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildBoolValExp
ROSE_DLL_API SgBoolValExp * buildBoolValExp(int value=0)
Build a bool value expression, the name convention of SgBoolValExp is little different from others fo...
SageBuilder::getTargetFileType
ROSE_DLL_API SgType * getTargetFileType(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildJovialForThenStatement_nfi
ROSE_DLL_API SgJovialForThenStatement * buildJovialForThenStatement_nfi()
Build a Jovial loop statement.
SageBuilder::buildProcedureHeaderStatement
ROSE_DLL_API SgProcedureHeaderStatement * buildProcedureHeaderStatement(const SgName &name, SgType *return_type, SgFunctionParameterList *parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildDeclarationScope
ROSE_DLL_API SgDeclarationScope * buildDeclarationScope()
Build a scope statement. Used to build SgNonrealDecl and SgNonrealType.
SageBuilder::buildUpcBarrierStatement_nfi
ROSE_DLL_API SgUpcBarrierStatement * buildUpcBarrierStatement_nfi(SgExpression *exp)
Build a UPC barrier statement.
SageBuilder::buildIntVal
ROSE_DLL_API SgIntVal * buildIntVal(int value=0)
Build an integer value expression.
SageBuilder::buildFunctionParameterRefExp
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp(int parameter_number, int parameter_level)
SageBuilder::buildTemplateClassDeclaration
ROSE_DLL_API SgTemplateClassDeclaration * buildTemplateClassDeclaration(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateClassDeclaration *nonDefiningDecl, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build tempplate class declaration.
SgNamespaceAliasDeclarationStatement
This class represents the concept of a C++ namespace alias declaration statement. ...
Definition: Cxx_Grammar.h:153875
SageBuilder::buildNamespaceAliasDeclarationStatement
ROSE_DLL_API SgNamespaceAliasDeclarationStatement * buildNamespaceAliasDeclarationStatement(const SgName &name, SgNamespaceDeclarationStatement *namespaceDeclaration)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildJovialDefineDeclaration_nfi
ROSE_DLL_API SgJovialDefineDeclaration * buildJovialDefineDeclaration_nfi(const SgName &name, const std::string &params, const std::string &def_string, SgScopeStatement *scope=NULL)
Build a Jovial define directive declaration statement.
SageBuilder::buildPragma
ROSE_DLL_API SgPragma * buildPragma(const std::string &name)
Build SgPragma.
Rose
Main namespace for the ROSE library.
Definition: BinaryTutorial.dox:3
SageBuilder::buildPlusPlusOp
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp(SgExpression *op=NULL)
SageBuilder::buildOpaqueVarRefExp
ROSE_DLL_API SgVarRefExp * buildOpaqueVarRefExp(const std::string &varName, SgScopeStatement *scope=NULL)
Build a variable reference expression at scope to an opaque variable which has unknown information ex...
SageBuilder::buildJavaMemberValuePair
ROSE_DLL_API SgJavaMemberValuePair * buildJavaMemberValuePair(const SgName &, SgExpression *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildCommonBlock
ROSE_DLL_API SgCommonBlock * buildCommonBlock(SgCommonBlockObject *first_block=NULL)
Build a Fortran Common statement.
SageBuilder::buildReturnStmt_nfi
ROSE_DLL_API SgReturnStmt * buildReturnStmt_nfi(SgExpression *expression)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildShortValHex
ROSE_DLL_API SgShortVal * buildShortValHex(short value=0)
SageBuilder::buildUnsignedLongLongIntValHex
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntValHex(unsigned long long v=0)
SageBuilder::buildStmtDeclarationStatement
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement(SgStatement *stmt)
Build a StmtDeclarationStmt.
SgDoubleVal
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:298219
SageBuilder::buildFortranIncludeLine
ROSE_DLL_API SgFortranIncludeLine * buildFortranIncludeLine(std::string filename)
Build Fortran include line.
SageBuilder::buildDerivedTypeStatement
ROSE_DLL_API SgDerivedTypeStatement * buildDerivedTypeStatement(const SgName &name, SgScopeStatement *scope=NULL)
Build an SgDerivedTypeStatement Fortran derived type declaration with a class declaration and definit...
SageBuilder::buildConstructorInitializer_nfi
ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer_nfi(SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown)
SageBuilder::buildCompoundInitializer_nfi
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
SageBuilder::buildNondefiningClassDeclaration
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration(SgName name, SgScopeStatement *scope)
DQ (11/7/2009): Added functions to build C++ class.
SageBuilder::buildNaryBooleanOp_nfi
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildJavaArrayLengthVarRefExp
ROSE_DLL_API SgVarRefExp * buildJavaArrayLengthVarRefExp()
Build a SgFile node and attach it to SgProject.
PreprocessingInfo::RelativePositionType
RelativePositionType
MK: Enum type to store if the directive goes before or after the corresponding line of source code...
Definition: rose_attributes_list.h:133
SageBuilder::buildCatchOptionStmt
ROSE_DLL_API SgCatchOptionStmt * buildCatchOptionStmt(SgVariableDeclaration *condition=NULL, SgStatement *body=NULL)
Build a catch statement.
SgConditionalExp
This class represents the concept of a C trinary conditional expression (e.g. "test ...
Definition: Cxx_Grammar.h:310525
SageBuilder::buildFloat80Type
ROSE_DLL_API SgTypeFloat80 * buildFloat80Type()
Built in simple types.
SageBuilder::buildJovialTableStatement
ROSE_DLL_API SgJovialTableStatement * buildJovialTableStatement(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope=NULL)
Build a Jovial table declaration statement.
SageBuilder::buildDoubleVal_nfi
ROSE_DLL_API SgDoubleVal * buildDoubleVal_nfi(double value, const std::string &str)
SageBuilder::buildRangeExp
ROSE_DLL_API SgRangeExp * buildRangeExp(SgExpression *start)
Build a Matlab range expression like start:end or start:stride:end.
SgExpression
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes, since similar to statement, expressions have a concrete location within the user's source code.
Definition: Cxx_Grammar.h:244075
SageBuilder::buildStringConversion
ROSE_DLL_API SgStringConversion * buildStringConversion(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildFunctionCallExp_nfi
SgFunctionCallExp * buildFunctionCallExp_nfi(SgExpression *f, SgExprListExp *parameters=NULL)
SageBuilder::buildVoidType
ROSE_DLL_API SgTypeVoid * buildVoidType()
Built in simple types.
SageBuilder::buildShortVal_nfi
ROSE_DLL_API SgShortVal * buildShortVal_nfi(short value, const std::string &str)
SageBuilder::buildClassDeclaration
ROSE_DLL_API SgClassDeclaration * buildClassDeclaration(SgName name, SgScopeStatement *scope)
Build C++ class (builds both the non-defining and defining declarations; in that order).
SageBuilder::buildIntType
ROSE_DLL_API SgTypeInt * buildIntType()
Built in simple types.
SageBuilder::buildCompoundInitializer
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build a compound initializer, for vector type initialization.
SageBuilder::buildTemplateVariableDeclaration
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build template variable declarations.
SageBuilder::buildKeyDatumPair_nfi
SgKeyDatumPair * buildKeyDatumPair_nfi(SgExpression *key, SgExpression *datum)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildMinusMinusOp
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp(SgExpression *op=NULL)
SageBuilder::buildNondefiningTemplateMemberFunctionDeclaration
ROSE_DLL_API SgTemplateMemberFunctionDeclaration * buildNondefiningTemplateMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList *templateParameterList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTypeTraitBuiltinOperator
SgTypeTraitBuiltinOperator * buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters)
SageBuilder::buildFunctionParameterList
ROSE_DLL_API SgFunctionParameterList * buildFunctionParameterList(SgInitializedName *in1=NULL, SgInitializedName *in2=NULL, SgInitializedName *in3=NULL, SgInitializedName *in4=NULL, SgInitializedName *in5=NULL, SgInitializedName *in6=NULL, SgInitializedName *in7=NULL, SgInitializedName *in8=NULL, SgInitializedName *in9=NULL, SgInitializedName *in10=NULL)
Build an empty SgFunctionParameterList, possibly with some initialized names filled in...
SageBuilder::buildSizeOfOp
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp(SgExpression *exp=NULL)
Build sizeof() expression with an expression parameter.
SageBuilder::unparseTemplateArgumentToString
SgName unparseTemplateArgumentToString(SgTemplateArgument *templateArgument)
DQ (3/9/2018): Added to support debugging.
SageBuilder::buildUnsignedCharType
ROSE_DLL_API SgTypeUnsignedChar * buildUnsignedCharType()
Built in simple types.
SageBuilder::buildConstType
ROSE_DLL_API SgModifierType * buildConstType(SgType *base_type=NULL)
Build a const type.
SageBuilder::buildMinusOp_nfi
ROSE_DLL_API SgMinusOp * buildMinusOp_nfi(SgExpression *op)
SageBuilder::buildChooseExpression
ROSE_DLL_API SgChooseExpression * buildChooseExpression()
SageBuilder::buildAsyncStmt
ROSE_DLL_API SgAsyncStmt * buildAsyncStmt(SgBasicBlock *body)
MH (6/10/2014): Added async support.
SageBuilder::buildDoWhileStmt
ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement *body, SgStatement *condition)
Build do-while statement.
SageBuilder::buildTupleExp
ROSE_DLL_API SgTupleExp * buildTupleExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgTupleExp.
SageBuilder::buildFixedType
ROSE_DLL_API SgTypeFixed * buildFixedType(SgExpression *fraction, SgExpression *scale)
Build a Jovial fixed type with a fraction specifier and a scale specifier.
SgBreakStmt
This class represents the notion of a break statement (typically used in a switch statment)...
Definition: Cxx_Grammar.h:200727
SageBuilder::buildMatrixExp
ROSE_DLL_API SgMatrixExp * buildMatrixExp(SgExprListExp *firstRow)
Build a Matlab Matrix.
SageBuilder::buildJavaDefiningClassDeclaration
ROSE_DLL_API SgClassDeclaration * buildJavaDefiningClassDeclaration(SgScopeStatement *, std::string, SgClassDeclaration::class_types kind=SgClassDeclaration::e_class)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildUnsignedIntValHex
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntValHex(unsigned int v=0)
SgSymbol
This class represents the concept of a name within the compiler.
Definition: Cxx_Grammar.h:350139
SageBuilder::buildNullExpression_nfi
ROSE_DLL_API SgNullExpression * buildNullExpression_nfi()
No file info version of buildNullExpression(). File info is to be set later on.
SageBuilder::buildUnaryExpression_nfi
T * buildUnaryExpression_nfi(SgExpression *operand)
Template function to build a unary expression of type T with no file info. Instantiated functions inc...
Definition: sageBuilder.h:1779
SageBuilder::buildTemplateVariableDeclaration_nfi
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNamespaceDefinition
ROSE_DLL_API SgNamespaceDefinitionStatement * buildNamespaceDefinition(SgNamespaceDeclarationStatement *d=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildLongType
ROSE_DLL_API SgTypeLong * buildLongType()
Built in simple types.
SageBuilder::buildAggregateInitializer
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build an aggregate initializer.
SageBuilder::buildNoexceptOp_nfi
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp_nfi(SgExpression *exp)
SageBuilder::buildDefiningMemberFunctionDeclaration
ROSE_DLL_API SgMemberFunctionDeclaration * buildDefiningMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration *first_nondefinng_declaration, SgTemplateArgumentPtrList *templateArgumentsList)
Build a defining ( non-prototype) member function declaration.
SageBuilder::buildFortranContinueStmt
ROSE_DLL_API SgFortranContinueStmt * buildFortranContinueStmt()
Build a Fortran continue statement.
SageInterface::setSourcePosition
ROSE_DLL_API void setSourcePosition(SgNode *node)
Set the source code positon for the current (input) node.
SageBuilder::buildIntVal_nfi
ROSE_DLL_API SgIntVal * buildIntVal_nfi(int value=0)
SageBuilder::buildNoexceptOp
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp(SgExpression *exp=NULL)
Build noexcept operator expression with an expression parameter.
SageBuilder::buildUpcBlockIndefiniteType
ROSE_DLL_API SgModifierType * buildUpcBlockIndefiniteType(SgType *base_type=NULL)
Build a UPC shared[] type.
SageBuilder::buildConstVolatileModifier
ROSE_DLL_API SgConstVolatileModifier * buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype=SgConstVolatileModifier::e_unknown)
Build a const/volatile type qualifier.
SageBuilder::buildUnsignedLongVal
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal(unsigned long v=0)
Build a unsigned long integer.
SageBuilder::buildVariableDeclaration
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
SgStorageModifier::storage_modifier_enum
storage_modifier_enum
Storage Modifiers (only one value can be specified)
Definition: Cxx_Grammar.h:13064
SageBuilder::buildStringConversion_nfi
ROSE_DLL_API SgStringConversion * buildStringConversion_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildPythonPrintStmt_nfi
SgPythonPrintStmt * buildPythonPrintStmt_nfi(SgExpression *dest=NULL, SgExprListExp *values=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildJavaLabelStatement
ROSE_DLL_API SgJavaLabelStatement * buildJavaLabelStatement(const SgName &, SgStatement *=NULL)
Build a Java Label statement.
SageBuilder::buildStmtDeclarationStatement_nfi
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement_nfi(SgStatement *stmt)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTemplateParameter
ROSE_DLL_API SgTemplateParameter * buildTemplateParameter(SgTemplateParameter::template_parameter_enum parameterType, SgType *)
Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum { parameter_...
SgClassDefinition
This class represents the concept of a class definition in C++.
Definition: Cxx_Grammar.h:126630
SageBuilder::buildTemplateFunctionRefExp_nfi
SgTemplateFunctionRefExp * buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol *sym)
DQ (12/15/2011): Adding template declaration support to the AST.
SageBuilder::buildJavaForEachStatement
ROSE_DLL_API SgJavaForEachStatement * buildJavaForEachStatement(SgVariableDeclaration *=NULL, SgExpression *=NULL, SgStatement *=NULL)
Build a Java Foreach statement.
SgName
This class represents strings within the IR nodes.
Definition: Cxx_Grammar.h:20553
SageBuilder::buildLongIntVal
ROSE_DLL_API SgLongIntVal * buildLongIntVal(long value=0)
Build a long integer value expression.
SageBuilder::emptyScopeStack
ROSE_DLL_API bool emptyScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
SageBuilder::buildMinusMinusOp_nfi
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp_nfi(SgExpression *op)
SageBuilder::SourcePositionClassification
SourcePositionClassification
Definition: sageBuilder.h:138
SageBuilder::fixupSharingSourcePosition
ROSE_DLL_API void fixupSharingSourcePosition(SgNode *subtreeRoot, int new_file_id)
Sharing IR nodes requires that the file id be added to the fileIDsToUnparse held in the Sg_File_Info ...
SageBuilder::buildUnsignedShortVal
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal(unsigned short v=0)
Build an unsigned short integer.
SageBuilder::topScopeStack
ROSE_DLL_API SgScopeStatement * topScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
SageBuilder::buildWhileStmt_nfi
SgWhileStmt * buildWhileStmt_nfi(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNullStatement
ROSE_DLL_API SgNullStatement * buildNullStatement()
Build a NULL statement.
SageBuilder::buildNonrealDecl
ROSE_DLL_API SgNonrealDecl * buildNonrealDecl(const SgName &name, SgDeclarationScope *scope, SgDeclarationScope *child_scope=NULL)
Build a declaration of a non-real class or class-member representing template parameters and their me...
SageBuilder::buildStructDeclaration
ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build a structure, It is also a declaration statement in SAGE III.
SageBuilder
Functions that build an AST.
Definition: sageBuilder.h:31
SgStmtDeclarationStatement
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
Definition: Cxx_Grammar.h:182037
SageBuilder::buildImaginaryVal_nfi
ROSE_DLL_API SgComplexVal * buildImaginaryVal_nfi(SgValueExp *imaginary_value, const std::string &str)
SageBuilder::buildContinueStmt_nfi
SgContinueStmt * buildContinueStmt_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsignedCharVal_nfi
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal_nfi(unsigned char v, const std::string &str)
SgCtorInitializerList
This class represents the concept of a contructor initializer list (used in constructor (member funct...
Definition: Cxx_Grammar.h:157189
SageBuilder::buildAssertStmt
ROSE_DLL_API SgAssertStmt * buildAssertStmt(SgExpression *test)
Build a Assert statement.
SageBuilder::buildTemplateClassDeclaration_nfi
ROSE_DLL_API SgTemplateClassDeclaration * buildTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateClassDeclaration *nonDefiningDecl, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build a variable declaration, handle symbol table transparently.
SageInterface
Functions that are useful when operating on the AST.
Definition: sageBuilder.h:25
SageBuilder::buildMemberFunctionType
ROSE_DLL_API SgMemberFunctionType * buildMemberFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier)
DQ (1/16/2009): Added to support member function in C++ (for new interface)
SageBuilder::getUniqueJavaQualifiedType
ROSE_DLL_API SgJavaQualifiedType * getUniqueJavaQualifiedType(SgClassDeclaration *, SgNamedType *, SgNamedType *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildAggregateInitializer_nfi
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
SageBuilder::buildClassDefinition
ROSE_DLL_API SgClassDefinition * buildClassDefinition(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
SageBuilder::buildCastExp_nfi
ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression *operand_i, SgType *expression_type, SgCastExp::cast_type_enum cast_type)
SageBuilder::buildUnsignedLongType
ROSE_DLL_API SgTypeUnsignedLong * buildUnsignedLongType()
Built in simple types.
SgProcedureHeaderStatement::subprogram_kind_enum
subprogram_kind_enum
Classification for different types of Fortran subprograms.
Definition: Cxx_Grammar.h:168890
SageBuilder::findAssociatedSymbolInTargetAST
ROSE_DLL_API SgSymbol * findAssociatedSymbolInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildUnsignedLongLongIntVal_nfi
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string &str)
SageBuilder::buildTemplateMemberFunctionRefExp_nfi
SgTemplateMemberFunctionRefExp * buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
DQ (12/29/2011): Adding template declaration support to the AST.
SageBuilder::buildBoolValExp_nfi
ROSE_DLL_API SgBoolValExp * buildBoolValExp_nfi(int value)
SageBuilder::buildAtomicStmt
ROSE_DLL_API SgAtomicStmt * buildAtomicStmt(SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildClassDefinition_nfi
SgClassDefinition * buildClassDefinition_nfi(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
SageBuilder::buildUpcForAllStatement_nfi
ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgExpression *affinity, SgStatement *loop_body)
Build a UPC forall statement.
SageBuilder::buildLambdaCapture_nfi
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture_nfi(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
SageBuilder::buildSubscriptExpression_nfi
SgSubscriptExpression * buildSubscriptExpression_nfi(SgExpression *lower_bound, SgExpression *upper_bound, SgExpression *stride)
Build a SgSubscriptExpression, used for array shape expressions. The lower bound and stride may be nu...
SageBuilder::buildStatementExpression
ROSE_DLL_API SgStatementExpression * buildStatementExpression(SgStatement *exp)
Build a GNU statement expression.
SageBuilder::buildStringVal_nfi
ROSE_DLL_API SgStringVal * buildStringVal_nfi(std::string value)
SageBuilder::buildFinishStmt
ROSE_DLL_API SgFinishStmt * buildFinishStmt(SgBasicBlock *body)
MH (6/11/2014): Added finish support.
SageBuilder::buildChar32Val
ROSE_DLL_API SgChar32Val * buildChar32Val(unsigned int value=0)
SageBuilder::getUniqueJavaWildcardSuper
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardSuper(SgType *)
Build a SgFile node and attach it to SgProject.
SgTypedefDeclaration
This class represents the notion of a typedef declaration.
Definition: Cxx_Grammar.h:154924
SageBuilder::buildChar16Val
ROSE_DLL_API SgChar16Val * buildChar16Val(unsigned short value=0)
SageBuilder::buildLabelStatement
ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName &name, SgStatement *stmt=NULL, SgScopeStatement *scope=NULL)
Build a label statement, name is the label's name. Handling label symbol and scope internally...
SageBuilder::buildWcharVal_nfi
ROSE_DLL_API SgWcharVal * buildWcharVal_nfi(wchar_t value, const std::string &str)
SageBuilder::buildVariableDefinition_nfi
ROSE_DLL_API SgVariableDefinition * buildVariableDefinition_nfi(SgVariableDeclaration *decl, SgInitializedName *init_name, SgInitializer *init)
Build variable definition.
SageBuilder::buildConditionalExp
ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression *test=NULL, SgExpression *a=NULL, SgExpression *b=NULL)
Build a conditional expression ?:
SageBuilder::buildFunctionRefExp_nfi
SgFunctionRefExp * buildFunctionRefExp_nfi(SgFunctionSymbol *sym)
SageBuilder::buildUnsignedLongLongIntVal
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal(unsigned long long v=0)
Build an unsigned long long integer.
SgFloatVal
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:297718
SgNode
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:9846
SageBuilder::buildTypedefDeclaration_nfi
ROSE_DLL_API SgTypedefDeclaration * buildTypedefDeclaration_nfi(const std::string &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a variable declaration, handle symbol table transparently.
SgCatchOptionStmt
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
Definition: Cxx_Grammar.h:129877
SageBuilder::buildUnsignedShortValHex
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortValHex(unsigned short v=0)
SageBuilder::buildFunctionParameterTypeList
ROSE_DLL_API SgFunctionParameterTypeList * buildFunctionParameterTypeList(SgFunctionParameterList *paralist)
Build SgFunctionParameterTypeList from SgFunctionParameterList.
SageBuilder::display
ROSE_DLL_API std::string display(SourcePositionClassification &scp)
display function for debugging
SageBuilder::buildListComprehension
ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators)
SgValueExp
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:290081
SgVariableSymbol
This class represents the concept of a variable name within the compiler (a shared container for the ...
Definition: Cxx_Grammar.h:350702
SgLambdaRefExp
This class represents a lambda expression.
Definition: Cxx_Grammar.h:327897
SageBuilder::buildFinishExp
ROSE_DLL_API SgFinishExp * buildFinishExp(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildSignedCharType
ROSE_DLL_API SgTypeSignedChar * buildSignedCharType()
Built in simple types.
SageBuilder::buildFloatVal
ROSE_DLL_API SgFloatVal * buildFloatVal(float value=0.0)
SageBuilder::buildShortVal
ROSE_DLL_API SgShortVal * buildShortVal(short value=0)
SageBuilder::buildPragmaDeclaration_nfi
SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string &name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::getGlobalScopeFromScopeStack
SgScopeStatement * getGlobalScopeFromScopeStack()
Support to retrive the SgGlobal from the internal scope stack (error if not present in a non-empty li...
SageBuilder::buildDictionaryExp
ROSE_DLL_API SgDictionaryExp * buildDictionaryExp(std::vector< SgKeyDatumPair * > pairs)
Build a list of key-datum pairs.
SageBuilder::setSourcePositionClassificationMode
ROSE_DLL_API void setSourcePositionClassificationMode(SourcePositionClassification X)
Set the current source position classification (defines how IR nodes built by the SageBuilder interfa...
SageBuilder::buildClassExp
ROSE_DLL_API SgClassExp * buildClassExp(SgClassSymbol *sym)
Build class pointer.
SageBuilder::buildContinueStmt
ROSE_DLL_API SgContinueStmt * buildContinueStmt()
Build a continue statement.
SageBuilder::buildJavaSourceFile
ROSE_DLL_API SgSourceFile * buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildNullptrValExp_nfi
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp_nfi()
SageBuilder::buildVarArgOp_nfi
ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression *operand_i, SgType *expression_type)
Build vararg op expression.
SageBuilder::setTemplateArgumentsInDeclaration
ROSE_DLL_API void setTemplateArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateArgumentsList_input)
DQ (9/16/2012): Added function to support setting the template arguments and setting their parents (a...
SageBuilder::setTemplateParametersInDeclaration
ROSE_DLL_API void setTemplateParametersInDeclaration(SgDeclarationStatement *decl, SgTemplateParameterPtrList *templateParametersList_input)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNaryComparisonOp
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp(SgExpression *lhs)
driscoll6 (7/20/11) : Support n-ary operators for python
SgStringConversion
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
Definition: Cxx_Grammar.h:332906
SageBuilder::buildVariantExpression
ROSE_DLL_API SgVariantExpression * buildVariantExpression()
SageBuilder::buildNondefiningClassDeclaration_nfi
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a structure first nondefining declaration, without file info.
SageBuilder::buildUpcWaitStatement_nfi
ROSE_DLL_API SgUpcWaitStatement * buildUpcWaitStatement_nfi(SgExpression *exp)
Build a UPC wait statement.
SageBuilder::buildJovialBitType
ROSE_DLL_API SgJovialBitType * buildJovialBitType(SgExpression *size)
Build a Jovial bit type of a given size.
SageBuilder::buildJavaImportStatement
ROSE_DLL_API SgJavaImportStatement * buildJavaImportStatement(std::string, bool)
Build a SgFile node and attach it to SgProject.
SgBasicBlock
This class represents the concept of a block (not a basic block from control flow analysis)...
Definition: Cxx_Grammar.h:123806
SgNamespaceDeclarationStatement
This class represents the concept of a C++ namespace declaration.
Definition: Cxx_Grammar.h:152284
SageBuilder::buildGotoStatement
ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement *label=NULL)
Build a goto statement.
SgCastExp
This class represents a cast of one type to another.
Definition: Cxx_Grammar.h:249655
SageBuilder::buildSignedLongType
ROSE_DLL_API SgTypeSignedLong * buildSignedLongType()
Built in simple types.
SgListExp
This class represents a list display.
Definition: Cxx_Grammar.h:286466
SgStatement
This class represents the notion of a statement.
Definition: Cxx_Grammar.h:121519
SageBuilder::buildCatchStatementSeq
ROSE_DLL_API SgCatchStatementSeq * buildCatchStatementSeq(SgCatchOptionStmt *=NULL)
Build an initial sequence of Catch blocks containing 0 or 1 element.
SageBuilder::buildLambdaCaptureList
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList()
PreprocessingInfo
For preprocessing information including source comments, include , if, define, etc.
Definition: rose_attributes_list.h:127
SageBuilder::buildDictionaryComprehension
ROSE_DLL_API SgDictionaryComprehension * buildDictionaryComprehension(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
SageBuilder::buildStatementFromString
ROSE_DLL_API SgStatement * buildStatementFromString(const std::string &stmt_str, SgScopeStatement *scope)
Liao (9/18/2015): experimental support of building a statement from a string.
SageBuilder::buildChar32Val_nfi
ROSE_DLL_API SgChar32Val * buildChar32Val_nfi(unsigned int value, const std::string &str)
SgForStatement
This class represents the concept of a for loop.
Definition: Cxx_Grammar.h:124993
SageBuilder::buildNamespaceDeclaration_nfi
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName &name, bool unnamednamespace, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::setTemplateSpecializationArgumentsInDeclaration
ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateSpecializationArgumentsList_input)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildBreakStmt_nfi
SgBreakStmt * buildBreakStmt_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildRvalueReferenceType
ROSE_DLL_API SgRvalueReferenceType * buildRvalueReferenceType(SgType *base_type)
Build a rvalue reference type.
SageBuilder::buildAtStmt
ROSE_DLL_API SgAtStmt * buildAtStmt(SgExpression *expression, SgBasicBlock *body)
MH (6/11/2014): Added at support.
SageBuilder::buildTupleExp_nfi
SgTupleExp * buildTupleExp_nfi()
SageBuilder::buildSignedShortType
ROSE_DLL_API SgTypeSignedShort * buildSignedShortType()
Built in simple types.
SageBuilder::buildGotoStatement_nfi
SgGotoStatement * buildGotoStatement_nfi(SgLabelStatement *label)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildCompoundLiteralExp
SgCompoundLiteralExp * buildCompoundLiteralExp(SgVariableSymbol *varSymbol)
SageBuilder::buildChooseExpression_nfi
ROSE_DLL_API SgChooseExpression * buildChooseExpression_nfi()
SageBuilder::buildIfStmt_nfi
ROSE_DLL_API SgIfStmt * buildIfStmt_nfi(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::e_sourcePositionCompilerGenerated
Classify as a transformation.
Definition: sageBuilder.h:143
SageBuilder::buildDefaultConstructor
ROSE_DLL_API SgMemberFunctionDeclaration * buildDefaultConstructor(SgClassType *classType)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildDefiningTemplateMemberFunctionDeclaration
ROSE_DLL_API SgTemplateMemberFunctionDeclaration * buildDefiningTemplateMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration *first_nondefing_declaration)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildLambdaRefExp
ROSE_DLL_API SgLambdaRefExp * buildLambdaRefExp(SgType *return_type, SgFunctionParameterList *params, SgScopeStatement *scope)
Build lambda expression.
SageBuilder::buildUpcSharedType
ROSE_DLL_API SgModifierType * buildUpcSharedType(SgType *base_type=NULL, long layout=-1)
Build a UPC shared type.
SageBuilder::buildWhileStmt
ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build while statement.
SgTypeImaginary
This class represents a C99 complex type.
Definition: Cxx_Grammar.h:82038
SgTupleExp
This class represents a tuple display.
Definition: Cxx_Grammar.h:286949
SageBuilder::buildFortranDo
ROSE_DLL_API SgFortranDo * buildFortranDo(SgExpression *initialization, SgExpression *bound, SgExpression *increment, SgBasicBlock *)
Build a Fortran do construct.
SgFunctionType
This class represents a type for all functions.
Definition: Cxx_Grammar.h:77126
SageBuilder::buildPointerType
ROSE_DLL_API SgPointerType * buildPointerType(SgType *base_type=NULL)
Build a pointer type.
SageBuilder::buildImaginaryVal
ROSE_DLL_API SgComplexVal * buildImaginaryVal(long double imaginary_value)
SgNamespaceDefinitionStatement
This class represents the concept of a namespace definition.
Definition: Cxx_Grammar.h:130415
SageBuilder::buildDoWhileStatement_nfi
ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt *result, SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
SgMinusOp
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
Definition: Cxx_Grammar.h:245725
SgPragmaDeclaration
This class represents the concept of a C Assembler statement (untested).
Definition: Cxx_Grammar.h:157709
SageBuilder::buildAssignStatement_ast_translate
ROSE_DLL_API SgExprStatement * buildAssignStatement_ast_translate(SgExpression *lhs, SgExpression *rhs)
This version does not recursively reset the file info as a transformation.
SageBuilder::buildBinaryExpression
T * buildBinaryExpression(SgExpression *lhs, SgExpression *rhs)
Template function to build a binary expression of type T, taking care of parent pointers, file info, lvalue, etc. Available instances include: buildAddOp(), buildAndAssignOp(), buildAndOp(), buildArrowExp(),buildArrowStarOp(),buildAtOp, buildAssignOp(),buildBitAndOp(),buildBitOrOp(),buildBitXorOp(),buildCommaOpExp(), buildConcatenationOp(),buildDivAssignOp(),buildDivideOp(),buildDotExp(),buildEqualityOp(),buildExponentiationOp(),buildGreaterOrEqualOp(),buildGreaterThanOp(),buildIntegerDivideOp(),buildIorAssignOp(),buildLessOrEqualOp(),buildLessThanOp(),buildLshiftAssignOp(),buildLshiftOp(),buildMinusAssignOp(),buildModAssignOp(),buildModOp(),buildMultAssignOp(),buildMultiplyOp(),buildNotEqualOp(),buildOrOp(),buildPlusAssignOp(),buildPntrArrRefExp(),buildRshiftAssignOp(),buildRshiftOp(),buildReplicationOp,buildScopeOp(),buildSubtractOp()buildXorAssignOp()
Definition: sageBuilder.h:1802
SageBuilder::buildNullptrValExp
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp()
DQ (7/31/2014): Adding support for C++11 nullptr const value expressions.
SgDefaultOptionStmt
This class represents the concept of a C or C++ default case within a switch statement.
Definition: Cxx_Grammar.h:200191
SageBuilder::buildComplexVal_nfi
ROSE_DLL_API SgComplexVal * buildComplexVal_nfi(SgValueExp *real_value, SgValueExp *imaginary_value, const std::string &str)
SageBuilder::buildNonrealBaseClass
ROSE_DLL_API SgNonrealBaseClass * buildNonrealBaseClass(SgNonrealDecl *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildBreakStmt
ROSE_DLL_API SgBreakStmt * buildBreakStmt()
Build a break statement.
SageBuilder::buildSourceFile
ROSE_DLL_API SgSourceFile * buildSourceFile(const std::string &outputFileName, SgProject *project=NULL, bool clear_globalScopeAcrossFiles=false)
Build a SgFile node and attach it to SgProject.
SgIfStmt
This class represents the concept of an "if" construct.
Definition: Cxx_Grammar.h:124376
SageBuilder::buildEmptyDeclaration
ROSE_DLL_API SgEmptyDeclaration * buildEmptyDeclaration()
Build an empty declaration (useful for adding precission to comments and CPP handling under token-bas...
SageBuilder::buildCtorInitializerList_nfi
SgCtorInitializerList * buildCtorInitializerList_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildDoubleType
ROSE_DLL_API SgTypeDouble * buildDoubleType()
Built in simple types.
AbstractHandle::abstract_handle
to specify a construct using a specifier Can be used alone or with parent handles when relative speci...
Definition: abstract_handle.h:182
SageBuilder::buildJavaNormalAnnotation
ROSE_DLL_API SgJavaNormalAnnotation * buildJavaNormalAnnotation(SgType *)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildTemplateInstantiationTypedefDeclaration_nfi
ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration * buildTemplateInstantiationTypedefDeclaration_nfi(SgName &name, SgType *base_type, SgScopeStatement *scope, bool has_defining_base, SgTemplateTypedefDeclaration *templateTypedefDeclaration, SgTemplateArgumentPtrList &templateArgumentsList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNonrealType
ROSE_DLL_API SgNonrealType * buildNonrealType(const SgName &name, SgDeclarationScope *scope)
Build a non real type used for template parameter. Internally a SgNorealDecl is also built...
SageBuilder::buildWithStatement
ROSE_DLL_API SgWithStatement * buildWithStatement(SgExpression *expr, SgStatement *body)
Build a with statement.
SageBuilder::buildComment
ROSE_DLL_API PreprocessingInfo * buildComment(SgLocatedNode *target, const std::string &content, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before, PreprocessingInfo::DirectiveType dtype=PreprocessingInfo::CpreprocessorUnknownDeclaration)
Build and attach a comment, comment style is inferred from the language type of the target node if no...
SageBuilder::buildLongLongIntValHex
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntValHex(long long value=0)
SageBuilder::buildTemplateTypedefDeclaration_nfi
ROSE_DLL_API SgTemplateTypedefDeclaration * buildTemplateTypedefDeclaration_nfi(const SgName &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTemplateClassDefinition
SgTemplateClassDefinition * buildTemplateClassDefinition(SgTemplateClassDeclaration *d=NULL)
Build a template class definition statement.
SageBuilder::buildExprListExp_nfi
SgExprListExp * buildExprListExp_nfi()
SageBuilder::buildBoolType
ROSE_DLL_API SgTypeBool * buildBoolType()
Built in simple types.
SgLocatedNode
This class represents the notion of an expression or statement which has a position within the source...
Definition: Cxx_Grammar.h:94566
SgTemplateArgument
This class represents template argument within the use of a template to build an instantiation.
Definition: Cxx_Grammar.h:35771
SageBuilder::e_sourcePositionFrontendConstruction
Set pointers to Sg_File_Info objects to NULL.
Definition: sageBuilder.h:145
SgVarRefExp
This class represents the variable refernece in expressions.
Definition: Cxx_Grammar.h:287915
SgDoWhileStmt
This class represents the concept of a do-while statement.
Definition: Cxx_Grammar.h:128802
SageBuilder::buildAwaitExpression
ROSE_DLL_API SgAwaitExpression * buildAwaitExpression()
SageBuilder::errorCheckingTargetAST
ROSE_DLL_API void errorCheckingTargetAST(SgNode *node_copy, SgNode *node_original, SgFile *targetFile, bool failOnWarning)
Error checking the inserted snippet AST.
SageBuilder::buildUnsignedLongLongType
ROSE_DLL_API SgTypeUnsignedLongLong * buildUnsignedLongLongType()
Built in simple types.
SageBuilder::buildSwitchStatement_nfi
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement_nfi(SgStatement *item_selector, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildConstVolatileType
ROSE_DLL_API SgModifierType * buildConstVolatileType(SgType *base_type=NULL)
Build a const volatile type.
SageBuilder::buildNondefiningMemberFunctionDeclaration
ROSE_DLL_API SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a prototype member function declaration.
SgVariableDefinition
This class represents the definition (initialization) of a variable.
Definition: Cxx_Grammar.h:145954
SageBuilder::buildNullExpression
ROSE_DLL_API SgNullExpression * buildNullExpression()
Build a null expression, set file info as the default one.
SageBuilder::buildPassStatement_nfi
SgPassStatement * buildPassStatement_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildLambdaCaptureList_nfi
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList_nfi()
SgDeleteExp
This class represents the concept of a C++ call to the delete operator.
Definition: Cxx_Grammar.h:311687
SgNewExp
This class represents the concept of a C++ call to the new operator.
Definition: Cxx_Grammar.h:311066
SageBuilder::buildFunctionParameterRefExp_nfi
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level)
SageBuilder::setTemplateArgumentParents
ROSE_DLL_API void setTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SgContinueStmt
This class represents the concept of a C or C++ continue statement.
Definition: Cxx_Grammar.h:201224
SageBuilder::setTemplateParameterParents
ROSE_DLL_API void setTemplateParameterParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildMinusOp
ROSE_DLL_API SgMinusOp * buildMinusOp(SgExpression *op=NULL)
SageBuilder::buildNamespaceDeclaration
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
tps (09/02/2009) : Added support for building namespaces
SageBuilder::buildUpcNotifyStatement_nfi
ROSE_DLL_API SgUpcNotifyStatement * buildUpcNotifyStatement_nfi(SgExpression *exp)
Build a UPC notify statement.
SageBuilder::buildBracedInitializer_nfi
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
SageBuilder::buildWcharType
ROSE_DLL_API SgTypeWchar * buildWcharType()
Built in simple types.
SageBuilder::buildJovialBitVal_nfi
ROSE_DLL_API SgJovialBitVal * buildJovialBitVal_nfi(const std::string &str)
Build a Jovial bit value expression.
SageBuilder::buildFloat80Val
ROSE_DLL_API SgFloat80Val * buildFloat80Val(long double value=0.0)
SageBuilder::buildDeleteExp_nfi
SgDeleteExp * buildDeleteExp_nfi(SgExpression *target, bool is_array=false, bool need_global_specifier=false, SgFunctionDeclaration *deleteOperatorDeclaration=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::ScopeStack
std::list< SgScopeStatement * > ScopeStack
intended to be a private member, don't access it directly. could be changed any time ...
SageBuilder::getTargetFileTypeSupport
ROSE_DLL_API SgType * getTargetFileTypeSupport(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SgMemberFunctionRefExp
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
Definition: Cxx_Grammar.h:289512
SageBuilder::buildCaseOptionStmt
ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt(SgExpression *key=NULL, SgStatement *body=NULL)
Build a case option statement.
SageBuilder::buildCastExp
ROSE_DLL_API SgCastExp * buildCastExp(SgExpression *operand_i=NULL, SgType *expression_type=NULL, SgCastExp::cast_type_enum cast_type=SgCastExp::e_C_style_cast)
Build a type casting expression.
SageBuilder::setTemplateNameInTemplateInstantiations
ROSE_DLL_API void setTemplateNameInTemplateInstantiations(SgFunctionDeclaration *func, const SgName &name)
DQ (2/11/2012): Added support to set the template name in function template instantiations (member an...
SageBuilder::buildFunctionRefExp
ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName &name, const SgType *func_type, SgScopeStatement *scope=NULL)
Build SgFunctionRefExp based on a C++ function's name and function type. It will lookup symbol table ...
SageBuilder::buildNondefiningProcedureHeaderStatement
ROSE_DLL_API SgProcedureHeaderStatement * buildNondefiningProcedureHeaderStatement(const SgName &name, SgType *return_type, SgFunctionParameterList *param_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement *scope=NULL)
Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently.
SageBuilder::buildNondefiningTemplateClassDeclaration_nfi
ROSE_DLL_API SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
DQ (11/29/2011): Adding template declaration support to the AST.
SageBuilder::buildDeclType
ROSE_DLL_API SgDeclType * buildDeclType(SgExpression *base_expression, SgType *base_type)
Build a decltype reference type.
SageBuilder::buildMemberFunctionCall
ROSE_DLL_API SgFunctionCallExp * buildMemberFunctionCall(std::string className, SgExpression *objectExpression, std::string functionName, SgExprListExp *params, SgScopeStatement *scope)
Build member function calls.
SageBuilder::buildJavaPackageStatement
ROSE_DLL_API SgJavaPackageStatement * buildJavaPackageStatement(std::string)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildMatlabForStatement
ROSE_DLL_API SgMatlabForStatement * buildMatlabForStatement(SgExpression *loop_index, SgExpression *loop_range, SgBasicBlock *loop_body)
Build a For-loop statement for matlab.
SageBuilder::buildForStatement_nfi
ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgStatement *loop_body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnknownType
ROSE_DLL_API SgTypeUnknown * buildUnknownType()
Built in simple types.
SageInterface::setOneSourcePositionForTransformation
ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *root)
Set current node's source position as transformation generated.
SageBuilder::buildExprStatement
ROSE_DLL_API SgExprStatement * buildExprStatement(SgExpression *exp=NULL)
Build a SgExprStatement, set File_Info automatically.
SageBuilder::buildUnsignedIntVal_nfi
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal_nfi(unsigned int v, const std::string &str)
SageBuilder::buildExprStatement_nfi
SgExprStatement * buildExprStatement_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTemplateParameterVal
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal(int template_parameter_position=-1)
Build an template parameter value expression.
SageBuilder::buildCommonBlockObject
ROSE_DLL_API SgCommonBlockObject * buildCommonBlockObject(std::string name="", SgExprListExp *exp_list=NULL)
Build a Fortran common block, possibly with a name.
SageBuilder::buildForStatement
ROSE_DLL_API SgForStatement * buildForStatement(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgStatement *loop_body, SgStatement *else_body=NULL)
Build a for statement, assume none of the arguments is NULL.
SageBuilder::buildLongLongType
ROSE_DLL_API SgTypeLongLong * buildLongLongType()
Built in simple types.
SageBuilder::buildWhenStmt
ROSE_DLL_API SgWhenStmt * buildWhenStmt(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildShortType
ROSE_DLL_API SgTypeShort * buildShortType()
Built in simple types.
SageBuilder::buildSignedIntType
ROSE_DLL_API SgTypeSignedInt * buildSignedIntType()
Built in simple types.
SageBuilder::fixupCopyOfAstFromSeparateFileInNewTargetAst
ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgStatement *toInsert, SgStatement *original_before_copy)
Fixup any AST moved from one file two another (references to symbols, types, etc.).
SgFunctionRefExp
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
Definition: Cxx_Grammar.h:288951
SageBuilder::buildDefaultOptionStmt
ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt(SgStatement *body=NULL)
Build a default option statement.
SageBuilder::buildJavaThrowStatement
ROSE_DLL_API SgJavaThrowStatement * buildJavaThrowStatement(SgThrowOp *)
Build a Java Throw statement.
SageBuilder::buildAssignStatement
ROSE_DLL_API SgExprStatement * buildAssignStatement(SgExpression *lhs, SgExpression *rhs)
Build an assignment statement from lefthand operand and right hand operand.
SageBuilder::buildOpaqueType
ROSE_DLL_API SgType * buildOpaqueType(std::string const type_name, SgScopeStatement *scope)
Build an opaque type with a name, useful when a type's details are unknown during transformation...
SageBuilder::buildComplexVal
ROSE_DLL_API SgComplexVal * buildComplexVal(SgValueExp *real_value, SgValueExp *imaginary_value)
SgTryStmt
This class represents the concept of try statement within the try-catch support for exception handlin...
Definition: Cxx_Grammar.h:199625
SageBuilder::buildWithStatement_nfi
SgWithStatement * buildWithStatement_nfi(SgExpression *expr, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildBasicBlock_nfi
ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildBracedInitializer
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
Build an braced initializer.
SgAsmStmt
This class represents the concept of a C Assembler statement.
Definition: Cxx_Grammar.h:148553
SageBuilder::buildComprehension_nfi
SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
SageBuilder::buildPragmaDeclaration
ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string &name, SgScopeStatement *scope=NULL)
Build pragma declaration, handle SgPragma and defining/nondefining pointers internally.
SageBuilder::buildCharVal_nfi
ROSE_DLL_API SgCharVal * buildCharVal_nfi(char value, const std::string &str)
SageBuilder::buildClassExp_nfi
ROSE_DLL_API SgClassExp * buildClassExp_nfi(SgClassSymbol *sym)
SageBuilder::buildCudaKernelCallExp_nfi
SgCudaKernelCallExp * buildCudaKernelCallExp_nfi(SgExpression *kernel, SgExprListExp *parameters=NULL, SgCudaKernelExecConfig *config=NULL)
Build a CUDA kernel call expression (kernel<<>>(parameters))
SageBuilder::buildJavaSynchronizedStatement
ROSE_DLL_API SgJavaSynchronizedStatement * buildJavaSynchronizedStatement(SgExpression *, SgBasicBlock *)
Build a Java Synchronized statement.
SageBuilder::buildNullptrType
ROSE_DLL_API SgTypeNullptr * buildNullptrType()
Built in simple types.
SageBuilder::e_sourcePosition_last
Specify as source position to be filled in as part of AST construction in the front-end.
Definition: sageBuilder.h:146
SgProject
This class represents a source project, with a list of SgFile objects and global information about th...
Definition: Cxx_Grammar.h:29782
SageBuilder::buildDoWhileStmt_nfi
SgDoWhileStmt * buildDoWhileStmt_nfi(SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsigned128bitIntegerType
ROSE_DLL_API SgTypeUnsigned128bitInteger * buildUnsigned128bitIntegerType()
Built in simple types.
SageBuilder::buildUpcThreads
ROSE_DLL_API SgUpcThreads * buildUpcThreads()
Build UPC THREADS (integer expression)
SageBuilder::buildListExp
ROSE_DLL_API SgListExp * buildListExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgListExp.
SgPythonGlobalStmt
This class represents the concept of a 'global' stmt in Python.
Definition: Cxx_Grammar.h:232474
SageBuilder::buildUpcBlockStarType
ROSE_DLL_API SgModifierType * buildUpcBlockStarType(SgType *base_type=NULL)
Build a UPC shared[*] type.
SageBuilder::buildCpreprocessorDefineDeclaration
ROSE_DLL_API PreprocessingInfo * buildCpreprocessorDefineDeclaration(SgLocatedNode *target, const std::string &content, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before)
Build and attach #define XX directives, pass "#define xxx xxx" as content.
SageBuilder::buildJavaInstanceOfOp
ROSE_DLL_API SgJavaInstanceOfOp * buildJavaInstanceOfOp(SgExpression *exp=NULL, SgType *type=NULL)
This is part of Java specific operator support.
SageBuilder::buildAssignInitializer_nfi
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
SageBuilder::appendTemplateArgumentsToName
ROSE_DLL_API SgName appendTemplateArgumentsToName(const SgName &name, const SgTemplateArgumentPtrList &templateArgumentsList)
DQ (7/27/2012): changed semantics from removing the template arguments in names to adding the templat...
SageBuilder::buildHeader
ROSE_DLL_API PreprocessingInfo * buildHeader(const std::string &header_filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before, bool isSystemHeader=false)
Build a dangling #include "x.h" header, insertHeader() is needed to actually insert it...
SageBuilder::buildScopeStatement
ROSE_DLL_API SgScopeStatement * buildScopeStatement(SgClassDefinition *=NULL)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildVarRefExp_nfi
ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol *varSymbol)
SageBuilder::buildUpcRelaxedType
ROSE_DLL_API SgModifierType * buildUpcRelaxedType(SgType *base_type=NULL)
Build a UPC relaxed type.
SageBuilder::buildLongDoubleVal_nfi
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal_nfi(long double value, const std::string &str)
SageBuilder::buildEnumDeclaration_nfi
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
SageBuilder::testTemplateArgumentParents
ROSE_DLL_API void testTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildDeleteExp
ROSE_DLL_API SgDeleteExp * buildDeleteExp(SgExpression *variable, short is_array, short need_global_specifier, SgFunctionDeclaration *deleteOperatorDeclaration)
SageBuilder::buildDefiningClassDeclaration
ROSE_DLL_API SgClassDeclaration * buildDefiningClassDeclaration(SgName name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUpcFenceStatement_nfi
ROSE_DLL_API SgUpcFenceStatement * buildUpcFenceStatement_nfi()
Build a UPC fence statement.
SgTypeComplex
This class represents a C99 complex type.
Definition: Cxx_Grammar.h:81536
SageBuilder::buildDictionaryExp_nfi
SgDictionaryExp * buildDictionaryExp_nfi(std::vector< SgKeyDatumPair * > pairs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildMicrosoftAttributeDeclaration
ROSE_DLL_API SgMicrosoftAttributeDeclaration * buildMicrosoftAttributeDeclaration(const SgName &name)
DQ (8/17/2014): Adding support for Microsoft MSVC specific attributes.
SageBuilder::buildFortranContinueStmt_nfi
SgFortranContinueStmt * buildFortranContinueStmt_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildFloatType
ROSE_DLL_API SgTypeFloat * buildFloatType()
Built in simple types.
SageBuilder::getSourcePositionClassificationMode
ROSE_DLL_API SourcePositionClassification getSourcePositionClassificationMode()
Get the current source position classification (defines how IR nodes built by the SageBuilder interfa...
SgVariableDeclaration
This class represents the concept of a C or C++ variable declaration.
Definition: Cxx_Grammar.h:144541
SgConstVolatileModifier::cv_modifier_enum
cv_modifier_enum
Const Volatile Modifier.
Definition: Cxx_Grammar.h:12511
SageBuilder::buildFortranDo_nfi
ROSE_DLL_API SgFortranDo * buildFortranDo_nfi(SgExpression *initialization, SgExpression *bound, SgExpression *increment, SgBasicBlock *)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildVoidVal
ROSE_DLL_API SgVoidVal * buildVoidVal()
DQ (2/14/2019): Adding support for C++14 void value expressions.
SageBuilder::buildTupleType
ROSE_DLL_API SgTypeTuple * buildTupleType(SgType *t1=NULL, SgType *t2=NULL, SgType *t3=NULL, SgType *t4=NULL, SgType *t5=NULL, SgType *t6=NULL, SgType *t7=NULL, SgType *t8=NULL, SgType *t9=NULL, SgType *t10=NULL)
Build a tuple of types. Useful for a function returning multiple variables of different types...
SgConstructorInitializer
This class represents the call of a class constructor to initialize a variable. For example "Foo foo;...
Definition: Cxx_Grammar.h:314849
SageBuilder::buildDefiningFunctionDeclaration
ROSE_DLL_API SgFunctionDeclaration * buildDefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation=false, SgFunctionDeclaration *first_nondefinng_declaration=NULL, SgTemplateArgumentPtrList *templateArgumentsList=NULL)
Build a function declaration with a function body.
SageBuilder::buildConditionalExp_nfi
SgConditionalExp * buildConditionalExp_nfi(SgExpression *test, SgExpression *a, SgExpression *b, SgType *t)
SageBuilder::buildExecStatement_nfi
SgExecStatement * buildExecStatement_nfi(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::symbol_table_case_insensitive_semantics
bool symbol_table_case_insensitive_semantics
Support for construction of case sensitive/insensitive symbol table handling in scopes.
SageBuilder::buildUnsignedLongValHex
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongValHex(unsigned long v=0)
SageBuilder::buildLabelStatement_nfi
SgLabelStatement * buildLabelStatement_nfi(const SgName &name, SgStatement *stmt, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNonrealRefExp_nfi
ROSE_DLL_API SgNonrealRefExp * buildNonrealRefExp_nfi(SgNonrealSymbol *sym)
Build a reference to the non-real declaration of a member of a non-real class.
SageBuilder::buildSigned128bitIntegerType
ROSE_DLL_API SgTypeSigned128bitInteger * buildSigned128bitIntegerType()
Built in simple types.
SgLabelStatement
This class represents the concept of a C or C++ label statement.
Definition: Cxx_Grammar.h:198496
SageBuilder::buildUnsignedShortVal_nfi
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal_nfi(unsigned short v, const std::string &str)
SageBuilder::buildAliasedType
ROSE_DLL_API SgModifierType * buildAliasedType(SgType *base_type=NULL)
Build an aliased type for Ada.
SageBuilder::buildNaryBooleanOp
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUpcMythread
ROSE_DLL_API SgUpcMythread * buildUpcMythread()
Build UPC MYTHREAD (integer expression)
SageBuilder::buildCharVal
ROSE_DLL_API SgCharVal * buildCharVal(char value=0)
SageBuilder::buildUsingDirectiveStatement
ROSE_DLL_API SgUsingDirectiveStatement * buildUsingDirectiveStatement(SgNamespaceDeclarationStatement *ns_decl)
Build a using directive statement.
SageBuilder::buildDoubleVal
ROSE_DLL_API SgDoubleVal * buildDoubleVal(double value=0.0)
Build a double value expression.
SageBuilder::buildStringType
ROSE_DLL_API SgTypeString * buildStringType()
DQ (8/21/2010): We want to move to the new buildStringType( SgExpression*,size_t) function over the o...
SageBuilder::buildSizeOfOp_nfi
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp_nfi(SgExpression *exp)
SageBuilder::buildNondefiningFunctionDeclaration
ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope=NULL, SgExprListExp *decoratorList=NULL, bool buildTemplateInstantiation=false, SgTemplateArgumentPtrList *templateArgumentsList=NULL, SgStorageModifier::storage_modifier_enum sm=SgStorageModifier::e_default)
Build a prototype for a function, handle function type, symbol etc transparently. ...
SageBuilder::buildUnsignedCharValHex
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharValHex(unsigned char v=0)
SageBuilder::buildImaginaryType
ROSE_DLL_API SgTypeImaginary * buildImaginaryType(SgType *base_type=NULL)
Build an imaginary type.
SageBuilder::buildUnsignedCharVal
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal(unsigned char v=0)
Build an unsigned char.
SageBuilder::buildTemplateParameterVal_nfi
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal_nfi(int template_parameter_position, const std::string &str)
SageBuilder::fixupSourcePositionFileSpecification
ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode *subtreeRoot, const std::string &newFileName)
Change the source file associated with the source position information in the AST.
SageBuilder::buildVolatileType
ROSE_DLL_API SgModifierType * buildVolatileType(SgType *base_type=NULL)
Build a volatile type.
SgFunctionCallExp
This class represents the concept of a C++ function call (which is an expression).
Definition: Cxx_Grammar.h:305779
SageBuilder::buildLongLongIntVal
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal(long long value=0)
Build a long long integer value expression.
SageBuilder::buildPassStatement
ROSE_DLL_API SgPassStatement * buildPassStatement()
Build a pass statement.
SageBuilder::buildPythonGlobalStmt
ROSE_DLL_API SgPythonGlobalStmt * buildPythonGlobalStmt(SgInitializedNamePtrList &names)
Build a python global statement.
SageBuilder::buildVoidVal_nfi
ROSE_DLL_API SgVoidVal * buildVoidVal_nfi()
SageBuilder::buildYieldExpression
ROSE_DLL_API SgYieldExpression * buildYieldExpression(SgExpression *value)
Build a yield statement.
SageBuilder::buildLongIntValHex
ROSE_DLL_API SgLongIntVal * buildLongIntValHex(long value=0)
SageBuilder::buildYieldExpression_nfi
SgYieldExpression * buildYieldExpression_nfi(SgExpression *value)
Build a variable declaration, handle symbol table transparently.
SgDeclarationStatement
This class represents the concept of a declaration statement.
Definition: Cxx_Grammar.h:143025
SageBuilder::buildBinaryExpression_nfi
T * buildBinaryExpression_nfi(SgExpression *lhs, SgExpression *rhs)
Template function to build a binary expression of type T, taking care of parent pointers, but without file-info. Available instances include: buildAddOp(), buildAndAssignOp(), buildAndOp(), buildArrowExp(),buildArrowStarOp(),buildAtOp, buildAssignOp(),buildBitAndOp(),buildBitOrOp(),buildBitXorOp(),buildCommaOpExp(), buildConcatenationOp(),buildDivAssignOp(),buildDivideOp(),buildDotExp(),buildEqualityOp(),buildExponentiationOp(),buildGreaterOrEqualOp(),buildGreaterThanOp(),buildIntegerDivideOp(),buildIorAssignOp(),buildLessOrEqualOp(),buildLessThanOp(),buildLshiftAssignOp(),buildLshiftOp(),buildMinusAssignOp(),buildModAssignOp(),buildModOp(),buildMultAssignOp(),buildMultiplyOp(),buildNotEqualOp(),buildOrOp(),buildPlusAssignOp(),buildPntrArrRefExp(),buildRshiftAssignOp(),buildRshiftOp(),buildReplicationOp(),buildScopeOp(),buildSubtractOp()buildXorAssignOp()
Definition: sageBuilder.h:1823
SgSwitchStatement
This class represents the concept of a switch.
Definition: Cxx_Grammar.h:129326
SageBuilder::buildCharType
ROSE_DLL_API SgTypeChar * buildCharType()
Built in simple types.
SgClassNameRefExp
This class represents the concept of a C++ expression built from a class name.
Definition: Cxx_Grammar.h:288466
SageBuilder::buildTryStmt
ROSE_DLL_API SgTryStmt * buildTryStmt(SgStatement *body, SgCatchOptionStmt *catch0=NULL, SgCatchOptionStmt *catch1=NULL, SgCatchOptionStmt *catch2=NULL, SgCatchOptionStmt *catch3=NULL, SgCatchOptionStmt *catch4=NULL)
Build a try statement.
SageBuilder::buildListComprehension_nfi
SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
SageBuilder::buildMultibyteNopStatement
ROSE_DLL_API SgAsmStmt * buildMultibyteNopStatement(int n)
DQ (4/30/2010): Added support for building nop statement using asm statement Building nop statement u...
SageBuilder::buildPythonPrintStmt
ROSE_DLL_API SgPythonPrintStmt * buildPythonPrintStmt(SgExpression *dest=NULL, SgExprListExp *values=NULL)
Build a python print statement.
SageBuilder::buildFloatVal_nfi
ROSE_DLL_API SgFloatVal * buildFloatVal_nfi(float value=0.0)
Generated on Mon Oct 23 2023 02:34:38 for ROSE by   doxygen 1.8.10