ROSE  0.11.109.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 
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.
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.
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 
139  {
140  e_sourcePositionError,
147  };
148 
151 
154 
156 ROSE_DLL_API std::string display(SourcePositionClassification & scp);
157 
160 
162 ROSE_DLL_API SgName appendTemplateArgumentsToName( const SgName & name, const SgTemplateArgumentPtrList & templateArgumentsList);
163 
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();
218 
219 #if 1
222 #endif
223 
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 
317 // PP (07/14/2016):
331 ROSE_DLL_API
333 buildClassTemplateType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
334 
336 ROSE_DLL_API
338 buildTemplateClassType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
339 
341 
347 ROSE_DLL_API SgType* buildOpaqueType(std::string const type_name, SgScopeStatement * scope);
348 
349 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
351 ROSE_DLL_API SgModifierType* buildUpcStrictType(SgType *base_type = NULL);
352 
354 ROSE_DLL_API SgModifierType* buildUpcRelaxedType(SgType *base_type = NULL);
355 
357 ROSE_DLL_API SgModifierType* buildUpcSharedType(SgType *base_type = NULL, long layout = -1);
358 // SgModifierType* buildUpcSharedType(SgType *base_type = NULL);
359 
361 ROSE_DLL_API SgModifierType* buildUpcBlockIndefiniteType(SgType *base_type = NULL);
362 
364 ROSE_DLL_API SgModifierType* buildUpcBlockStarType(SgType *base_type = NULL);
365 
367 ROSE_DLL_API SgModifierType* buildUpcBlockNumberType(SgType *base_type, long block_factor);
368 
370 ROSE_DLL_API SgTypeComplex* buildComplexType(SgType *base_type = NULL);
371 
373 ROSE_DLL_API SgTypeImaginary* buildImaginaryType(SgType *base_type = NULL);
374 
377 
379 ROSE_DLL_API SgTypeMatrix* buildMatrixType();
380 
382 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);
383 
385 ROSE_DLL_API SgNonrealType* buildNonrealType(const SgName & name, SgDeclarationScope* scope);
386 
388 
389 //--------------------------------------------------------------
391 
403 // JJW (11/19/2008): _nfi versions of functions set file info objects to NULL (used in frontend)
404 
406 
408 ROSE_DLL_API SgNullExpression* buildNullExpression();
411 
413 ROSE_DLL_API SgBoolValExp* buildBoolValExp(int value = 0);
414 ROSE_DLL_API SgBoolValExp* buildBoolValExp(bool value = 0);
415 ROSE_DLL_API SgBoolValExp* buildBoolValExp_nfi(int value);
416 
417 ROSE_DLL_API SgCharVal* buildCharVal(char value = 0);
418 ROSE_DLL_API SgCharVal* buildCharVal_nfi(char value, const std::string& str);
419 
421 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp();
423 
425 ROSE_DLL_API SgVoidVal* buildVoidVal();
426 ROSE_DLL_API SgVoidVal* buildVoidVal_nfi();
427 
428 ROSE_DLL_API SgWcharVal* buildWcharVal(wchar_t value = 0);
429 ROSE_DLL_API SgWcharVal* buildWcharVal_nfi(wchar_t value, const std::string& str);
430 
431 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
432 ROSE_DLL_API SgChar16Val* buildChar16Val(unsigned short value = 0);
433 ROSE_DLL_API SgChar16Val* buildChar16Val_nfi(unsigned short value, const std::string& str);
434 ROSE_DLL_API SgChar32Val* buildChar32Val(unsigned int value = 0);
435 ROSE_DLL_API SgChar32Val* buildChar32Val_nfi(unsigned int value, const std::string& str);
436 
437 // DQ (3/20/2017): This function has never existed (inputs must be SgValueExp pointers).
438 // ROSE_DLL_API SgComplexVal* buildComplexVal(long double real_value = 0.0, long double imaginary_value = 0.0 );
439 ROSE_DLL_API SgComplexVal* buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value);
440 ROSE_DLL_API SgComplexVal* buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, const std::string& str);
441 ROSE_DLL_API SgComplexVal* buildImaginaryVal(long double imaginary_value);
442 ROSE_DLL_API SgComplexVal* buildImaginaryVal(SgValueExp* imaginary_value);
443 ROSE_DLL_API SgComplexVal* buildImaginaryVal_nfi(SgValueExp* imaginary_value, const std::string& str);
444 
446 ROSE_DLL_API SgDoubleVal* buildDoubleVal(double value = 0.0);
447 ROSE_DLL_API SgDoubleVal* buildDoubleVal_nfi(double value, const std::string& str);
448 
449 ROSE_DLL_API SgFloatVal* buildFloatVal(float value = 0.0);
450 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value = 0.0);
451 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value, const std::string& str);
453 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(const std::string& str);
454 
456 ROSE_DLL_API SgIntVal* buildIntVal(int value = 0);
457 ROSE_DLL_API SgIntVal* buildIntValHex(int value = 0);
458 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value = 0);
459 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value, const std::string& str);
461 ROSE_DLL_API SgIntVal* buildIntVal_nfi(const std::string& str);
462 
464 ROSE_DLL_API SgLongIntVal* buildLongIntVal(long value = 0);
465 ROSE_DLL_API SgLongIntVal* buildLongIntValHex(long value = 0);
466 ROSE_DLL_API SgLongIntVal* buildLongIntVal_nfi(long value, const std::string& str);
467 
469 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal(long long value = 0);
470 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
471 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal_nfi(long long value, const std::string& str);
472 // !Build enum val without file info: nfi
473 ROSE_DLL_API SgEnumVal* buildEnumVal_nfi(long long int value, SgEnumDeclaration* decl, SgName name);
474 // !Build enum val with transformation file info
475 ROSE_DLL_API SgEnumVal* buildEnumVal(long long int value, SgEnumDeclaration* decl, SgName name);
476 ROSE_DLL_API SgEnumVal* buildEnumVal(SgEnumFieldSymbol * sym);
477 
478 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal(long double value = 0.0);
479 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal_nfi(long double value, const std::string& str);
480 
481 ROSE_DLL_API SgFloat80Val* buildFloat80Val(long double value = 0.0);
482 ROSE_DLL_API SgFloat80Val* buildFloat80Val_nfi(long double value, const std::string& str);
483 
484 ROSE_DLL_API SgFloat128Val* buildFloat128Val(long double value = 0.0);
485 ROSE_DLL_API SgFloat128Val* buildFloat128Val_nfi(long double value, const std::string& str);
486 
487 ROSE_DLL_API SgShortVal* buildShortVal(short value = 0);
488 ROSE_DLL_API SgShortVal* buildShortValHex(short value = 0);
489 ROSE_DLL_API SgShortVal* buildShortVal_nfi(short value, const std::string& str);
490 
491 ROSE_DLL_API SgStringVal* buildStringVal(std::string value="");
492 ROSE_DLL_API SgStringVal* buildStringVal_nfi(std::string value);
493 
495 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);
496 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
497 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal_nfi(unsigned char v, const std::string& str);
498 
500 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);
501 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
502 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal_nfi(unsigned short v, const std::string& str);
503 
505 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);
506 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
507 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal_nfi(unsigned int v, const std::string& str);
508 
510 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);
511 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
512 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal_nfi(unsigned long v, const std::string& str);
513 
515 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);
516 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
517 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string& str);
518 
520 ROSE_DLL_API SgJovialBitVal* buildJovialBitVal_nfi(const std::string& str);
521 
523 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal(int template_parameter_position = -1);
524 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal_nfi(int template_parameter_position, const std::string& str);
525 
527 ROSE_DLL_API SgTemplateType* buildTemplateType(SgName name="");
528 
532 
534 ROSE_DLL_API SgNonrealDecl * buildNonrealDecl(const SgName & name, SgDeclarationScope * scope, SgDeclarationScope * child_scope = NULL);
535 
538 
540 ROSE_DLL_API SgUpcThreads* buildUpcThreads();
541 ROSE_DLL_API SgUpcThreads* buildUpcThreads_nfi();
542 
544 ROSE_DLL_API SgUpcMythread* buildUpcMythread();
545 ROSE_DLL_API SgUpcMythread* buildUpcMythread_nfi();
546 
548 ROSE_DLL_API SgThisExp* buildThisExp(SgSymbol* sym);
549 ROSE_DLL_API SgThisExp* buildThisExp_nfi(SgSymbol* sym);
550 
552 ROSE_DLL_API SgSuperExp* buildSuperExp(SgClassSymbol* sym);
553 ROSE_DLL_API SgSuperExp* buildSuperExp_nfi(SgClassSymbol* sym);
554 
556 ROSE_DLL_API SgClassExp* buildClassExp(SgClassSymbol* sym);
557 ROSE_DLL_API SgClassExp* buildClassExp_nfi(SgClassSymbol* sym);
558 
560 ROSE_DLL_API SgLambdaRefExp* buildLambdaRefExp(SgType* return_type, SgFunctionParameterList* params, SgScopeStatement* scope);
561 
562 #define BUILD_UNARY_PROTO(suffix) \
563 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* op =NULL); \
564 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* op);
565 
566 BUILD_UNARY_PROTO(AddressOfOp)
567 BUILD_UNARY_PROTO(BitComplementOp)
568 BUILD_UNARY_PROTO(MinusOp)
569 BUILD_UNARY_PROTO(NotOp)
570 BUILD_UNARY_PROTO(PointerDerefExp)
571 BUILD_UNARY_PROTO(UnaryAddOp)
572 BUILD_UNARY_PROTO(MinusMinusOp)
573 BUILD_UNARY_PROTO(PlusPlusOp)
574 BUILD_UNARY_PROTO(RealPartOp)
575 BUILD_UNARY_PROTO(ImagPartOp)
576 BUILD_UNARY_PROTO(ConjugateOp)
577 BUILD_UNARY_PROTO(VarArgStartOneOperandOp)
578 BUILD_UNARY_PROTO(VarArgEndOp)
579 BUILD_UNARY_PROTO(AbsOp)
580 
581 //Matlab transpose op
582 BUILD_UNARY_PROTO(MatrixTransposeOp)
583 
585 ROSE_DLL_API SgCastExp * buildCastExp(SgExpression * operand_i = NULL,
586  SgType * expression_type = NULL,
587  SgCastExp::cast_type_enum cast_type = SgCastExp::e_C_style_cast);
588 ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression * operand_i,
589  SgType * expression_type,
590  SgCastExp::cast_type_enum cast_type);
591 
593 ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression * operand_i, SgType * expression_type);
594 
596 ROSE_DLL_API SgMinusOp *buildMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
597 ROSE_DLL_API SgMinusOp *buildMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
598 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
599 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
600 
602 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
603 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
604 
606 ROSE_DLL_API SgThrowOp* buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind);
607 
608 ROSE_DLL_API SgNewExp * buildNewExp(SgType* type,
609  SgExprListExp* exprListExp,
610  SgConstructorInitializer* constInit,
611  SgExpression* expr,
612  short int val,
613  SgFunctionDeclaration* funcDecl);
614 
615 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression* variable,
616  short is_array,
617  short need_global_specifier,
618  SgFunctionDeclaration* deleteOperatorDeclaration);
619 
621 ROSE_DLL_API SgTypeIdOp* buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type);
622 
623 
624 #undef BUILD_UNARY_PROTO
625 
630 #define BUILD_BINARY_PROTO(suffix) \
631 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* lhs =NULL, SgExpression* rhs =NULL); \
632 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* lhs, SgExpression* rhs);
633 
634 BUILD_BINARY_PROTO(AddOp)
635 BUILD_BINARY_PROTO(AndAssignOp)
636 BUILD_BINARY_PROTO(AndOp)
637 BUILD_BINARY_PROTO(ArrowExp)
638 BUILD_BINARY_PROTO(ArrowStarOp)
639 BUILD_BINARY_PROTO(AssignOp)
640 BUILD_BINARY_PROTO(AtOp)
641 BUILD_BINARY_PROTO(BitAndOp)
642 BUILD_BINARY_PROTO(BitOrOp)
643 BUILD_BINARY_PROTO(BitXorOp)
644 
645 BUILD_BINARY_PROTO(CommaOpExp)
646 BUILD_BINARY_PROTO(ConcatenationOp)
647 BUILD_BINARY_PROTO(DivAssignOp)
648 BUILD_BINARY_PROTO(DivideOp)
649 BUILD_BINARY_PROTO(DotExp)
650 BUILD_BINARY_PROTO(DotStarOp)
651 BUILD_BINARY_PROTO(EqualityOp)
652 
653 BUILD_BINARY_PROTO(ExponentiationOp)
654 BUILD_BINARY_PROTO(ExponentiationAssignOp)
655 BUILD_BINARY_PROTO(GreaterOrEqualOp)
656 BUILD_BINARY_PROTO(GreaterThanOp)
657 BUILD_BINARY_PROTO(IntegerDivideOp)
658 BUILD_BINARY_PROTO(IntegerDivideAssignOp)
659 BUILD_BINARY_PROTO(IorAssignOp)
660 BUILD_BINARY_PROTO(IsOp)
661 BUILD_BINARY_PROTO(IsNotOp)
662 
663 BUILD_BINARY_PROTO(LessOrEqualOp)
664 BUILD_BINARY_PROTO(LessThanOp)
665 BUILD_BINARY_PROTO(LshiftAssignOp)
666 BUILD_BINARY_PROTO(LshiftOp)
667 
668 BUILD_BINARY_PROTO(MembershipOp)
669 BUILD_BINARY_PROTO(MinusAssignOp)
670 BUILD_BINARY_PROTO(ModAssignOp)
671 BUILD_BINARY_PROTO(ModOp)
672 BUILD_BINARY_PROTO(MultAssignOp)
673 BUILD_BINARY_PROTO(MultiplyOp)
674 
675 BUILD_BINARY_PROTO(NonMembershipOp)
676 BUILD_BINARY_PROTO(NotEqualOp)
677 BUILD_BINARY_PROTO(OrOp)
678 BUILD_BINARY_PROTO(PlusAssignOp)
679 BUILD_BINARY_PROTO(PntrArrRefExp)
680 BUILD_BINARY_PROTO(RemOp)
681 BUILD_BINARY_PROTO(RshiftAssignOp)
682 BUILD_BINARY_PROTO(JavaUnsignedRshiftAssignOp)
683 
684 BUILD_BINARY_PROTO(ReplicationOp)
685 BUILD_BINARY_PROTO(RshiftOp)
686 BUILD_BINARY_PROTO(JavaUnsignedRshiftOp)
687 BUILD_BINARY_PROTO(ScopeOp)
688 BUILD_BINARY_PROTO(SubtractOp)
689 BUILD_BINARY_PROTO(XorAssignOp)
690 
691 BUILD_BINARY_PROTO(VarArgCopyOp)
692 BUILD_BINARY_PROTO(VarArgStartOp)
693 
694 BUILD_BINARY_PROTO(PowerOp);
695 BUILD_BINARY_PROTO(ElementwisePowerOp);
696 BUILD_BINARY_PROTO(ElementwiseMultiplyOp);
697 BUILD_BINARY_PROTO(ElementwiseDivideOp);
698 BUILD_BINARY_PROTO(LeftDivideOp);
699 BUILD_BINARY_PROTO(ElementwiseLeftDivideOp);
700 BUILD_BINARY_PROTO(ElementwiseAddOp);
701 BUILD_BINARY_PROTO(ElementwiseSubtractOp);
702 
703 // DQ (7/25/2020): Adding C++20 support
704 BUILD_BINARY_PROTO(SpaceshipOp)
705 
706 #undef BUILD_BINARY_PROTO
707 
709 ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression* test =NULL, SgExpression* a =NULL, SgExpression* b =NULL);
710 SgConditionalExp * buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
711 
713 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);
714 ROSE_DLL_API SgExprListExp * buildExprListExp(const std::vector<SgExpression*>& exprs);
716 SgExprListExp * buildExprListExp_nfi(const std::vector<SgExpression*>& exprs);
717 
719 SgSubscriptExpression * buildSubscriptExpression_nfi(SgExpression* lower_bound, SgExpression* upper_bound, SgExpression* stride);
720 
722 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);
723 ROSE_DLL_API SgTupleExp * buildTupleExp(const std::vector<SgExpression*>& exprs);
725 SgTupleExp * buildTupleExp_nfi(const std::vector<SgExpression*>& exprs);
726 
728 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);
729 ROSE_DLL_API SgListExp * buildListExp(const std::vector<SgExpression*>& exprs);
731 SgListExp * buildListExp_nfi(const std::vector<SgExpression*>& exprs);
732 
733 ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
734 SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
735 
736 ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators);
737 SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
738 
739 ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators);
740 SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
741 
744 
746 
750 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName& name, SgScopeStatement* scope=NULL);
751 
753 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const std::string& varName, SgScopeStatement* scope=NULL);
754 
756 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const char* varName, SgScopeStatement* scope=NULL);
757 
759 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableSymbol* varSymbol);
760 ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
761 
763 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableDeclaration* vardecl);
764 
767 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgInitializedName* initname, SgScopeStatement* scope=NULL);
768 
770 
772 ROSE_DLL_API SgVarRefExp* buildOpaqueVarRefExp(const std::string& varName,SgScopeStatement* scope=NULL);
773 
774 // DQ (9/4/2013): Added support for building compound literals (similar to a SgVarRefExp).
778 
780 ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol * s);
781 
783 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name, const SgType* func_type, SgScopeStatement* scope=NULL);
784 
785 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name, const SgType* func_type, SgScopeStatement* scope=NULL);
786 
788 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name,SgScopeStatement* scope=NULL);
789 
790 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name,SgScopeStatement* scope=NULL);
791 
793 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgFunctionDeclaration* func_decl);
794 
797 
799 
802 
805 
806 SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
807 ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
810 
812 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgFunctionSymbol* sym, SgExprListExp* parameters=NULL);
813 SgFunctionCallExp* buildFunctionCallExp_nfi(SgExpression* f, SgExprListExp* parameters=NULL);
814 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgExpression* f, SgExprListExp* parameters=NULL);
815 
817 ROSE_DLL_API SgFunctionCallExp*
818 buildFunctionCallExp(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
819 
820 
822 
837 ROSE_DLL_API SgFunctionCallExp*
838 buildMemberFunctionCall (std::string className, SgExpression *objectExpression, std::string functionName, SgExprListExp *params, SgScopeStatement *scope);
839 
841 ROSE_DLL_API SgFunctionCallExp* buildMemberFunctionCall (SgExpression* objectExpression, SgMemberFunctionSymbol* functionSymbol,
842  SgExprListExp* params);
843 
845 buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters);
846 
849  SgExpression * kernel,
850  SgExprListExp* parameters = NULL,
851  SgCudaKernelExecConfig * config = NULL
852 );
853 
856  SgExpression *grid = NULL,
857  SgExpression *blocks = NULL,
858  SgExpression *shared = NULL,
859  SgExpression *stream = NULL
860 );
861 
863 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
864 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
865 
867 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
868 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
869 
871 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
872 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
873 
874 // DQ (!/4/2009): Added support for building SgConstructorInitializer
875 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);
876 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);
877 
879 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
880 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
881 
883 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgExpression* exp = NULL);
884 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgExpression* exp);
885 
887 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgType* type = NULL);
888 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgType* type);
889 
891 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgExpression* exp = NULL);
892 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgExpression* exp);
893 
895 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgType* type = NULL);
896 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgType* type);
897 
899 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp(SgExpression* exp = NULL);
900 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
901 
902 // DQ (7/18/2011): Added support for SgJavaInstanceOfOp
904 ROSE_DLL_API SgJavaInstanceOfOp* buildJavaInstanceOfOp(SgExpression* exp = NULL, SgType* type = NULL);
905 
907 ROSE_DLL_API SgTypeExpression *buildTypeExpression(SgType* type);
908 
909 // DQ (8/11/2014): Added support for C++11 decltype used in new function return syntax.
910 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp(int parameter_number, int parameter_level );
911 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level );
912 
913 
915 ROSE_DLL_API SgLambdaExp* buildLambdaExp (SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
916 ROSE_DLL_API SgLambdaExp* buildLambdaExp_nfi(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
917 
918 #if 0
919 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
920 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
921 #else
922 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
923 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
924 #endif
925 
928 
929 // DQ (7/25/2020): Adding C++17 support
930  ROSE_DLL_API SgFoldExpression * buildFoldExpression(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
931 ROSE_DLL_API SgFoldExpression * buildFoldExpression_nfi(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
932 
933 // DQ (7/25/2020): Adding C++20 support
934 ROSE_DLL_API SgAwaitExpression * buildAwaitExpression();
936 
937 // DQ (7/25/2020): Adding C++20 support
940 
941 
943 
945 
947  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start);
949 
950 
952  ROSE_DLL_API SgMatrixExp* buildMatrixExp(SgExprListExp *firstRow);
953 
955  ROSE_DLL_API SgMagicColonExp* buildMagicColonExp();
956 
958  ROSE_DLL_API SgMatlabForStatement* buildMatlabForStatement(SgExpression* loop_index, SgExpression* loop_range, SgBasicBlock* loop_body);
960 
962 
965 // ! Build a range expression using start:end:stride for Ada
966  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start, SgExpression *end, SgExpression *stride);
967 
969 //
970 //--------------------------------------------------------------
972 
976 
980 ROSE_DLL_API SgInitializedName* buildInitializedName(const SgName & name, SgType* type, SgInitializer* init = NULL);
981 ROSE_DLL_API SgInitializedName* buildInitializedName(const std::string &name, SgType* type);
982 ROSE_DLL_API SgInitializedName* buildInitializedName(const char* name, SgType* type);
983 ROSE_DLL_API SgInitializedName* buildInitializedName_nfi(const SgName & name, SgType* type, SgInitializer* init);
984 
986 ROSE_DLL_API SgFunctionParameterTypeList *
988 
990 ROSE_DLL_API SgFunctionParameterTypeList *
992 
994 ROSE_DLL_API SgFunctionParameterTypeList *
995 buildFunctionParameterTypeList(SgType* type0 = NULL, SgType* type1 = NULL,
996  SgType* type2 = NULL, SgType* type3 = NULL,
997  SgType* type4 = NULL, SgType* type5 = NULL,
998  SgType* type6 = NULL, SgType* type7 = NULL);
999 
1000 
1001 //--------------------------------------------------------------
1003 
1009 ROSE_DLL_API SgVariableDeclaration*
1011 buildVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
1012 
1013 ROSE_DLL_API SgVariableDeclaration*
1014 buildVariableDeclaration(const std::string & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
1015 
1016 ROSE_DLL_API SgVariableDeclaration*
1017 buildVariableDeclaration(const char* name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
1018 
1019 // DQ (6/25/2019): Added support to force building the varialbe declaration from the variable use (e.g. within a class)
1020 // instead of from a declaration. Variable declaration built from a use are reused when the declaration is seen (later
1021 // in processing of the class members).
1022 // ROSE_DLL_API SgVariableDeclaration*
1023 // buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1024 ROSE_DLL_API SgVariableDeclaration*
1026 
1028 ROSE_DLL_API SgVariableDefinition*
1030 
1031 
1032 // DQ (8/31/2012): Note that this macro can't be used in header files since it can only be set
1033 // after sage3.h has been read. The reason is that this is a portability problem when "rose_config.h"
1034 // appears in header files of applications using ROSE's header files.
1035 // DQ (12/6/2011): Adding support for template declarations into the AST.
1036 // SgTemplateDeclaration*
1038 
1041 
1043 ROSE_DLL_API SgTypedefDeclaration*
1044 buildTypedefDeclaration(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1045 
1046 ROSE_DLL_API SgTypedefDeclaration*
1047 buildTypedefDeclaration_nfi(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1048 
1049 ROSE_DLL_API SgTemplateTypedefDeclaration*
1050 buildTemplateTypedefDeclaration_nfi(const SgName & name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1051 
1052 
1054  SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base,
1055  SgTemplateTypedefDeclaration * templateTypedefDeclaration,
1056  SgTemplateArgumentPtrList & templateArgumentsList
1057 );
1058 
1060 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);
1062 
1064 ROSE_DLL_API SgFunctionParameterList*
1066 
1067 ROSE_DLL_API SgFunctionParameterList*
1069 
1072 ROSE_DLL_API void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, const SgName & name );
1073 
1074 // 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.
1075 ROSE_DLL_API void setTemplateArgumentParents( SgDeclarationStatement* decl );
1076 ROSE_DLL_API void testTemplateArgumentParents( SgDeclarationStatement* decl );
1077 ROSE_DLL_API SgTemplateArgumentPtrList* getTemplateArgumentList( SgDeclarationStatement* decl );
1078 
1080 ROSE_DLL_API void testTemplateParameterParents( SgDeclarationStatement* decl );
1081 ROSE_DLL_API void setTemplateParameterParents( SgDeclarationStatement* decl );
1082 ROSE_DLL_API SgTemplateParameterPtrList* getTemplateParameterList( SgDeclarationStatement* decl );
1083 
1085 ROSE_DLL_API void setTemplateArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input );
1086 ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input );
1087 ROSE_DLL_API void setTemplateParametersInDeclaration ( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input );
1088 
1089 
1091 // 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).
1093  const SgName & name,
1094  SgType * return_type,
1095  SgFunctionParameterList *parlist,
1096  SgScopeStatement* scope = NULL,
1097  SgExprListExp* decoratorList = NULL,
1098  bool buildTemplateInstantiation = false,
1099  SgTemplateArgumentPtrList * templateArgumentsList = NULL,
1101 );
1102 
1105  const SgFunctionDeclaration * funcdecl,
1106  SgScopeStatement * scope = NULL,
1107  SgExprListExp * decoratorList = NULL
1108 );
1109 
1110 // DQ (8/11/2013): Even though template functions can't use partial specialization, they can be specialized,
1111 // however the specialization does not define a template and instead defines a template instantiation, so we
1112 // don't need the SgTemplateArgumentPtrList in this function.
1113 // SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1114 ROSE_DLL_API SgTemplateFunctionDeclaration*
1115 buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
1116 
1117 // DQ (8/11/2013): Note that access to the SgTemplateParameterPtrList should be handled through the first_nondefining_declaration (which is a required parameter).
1118 // DQ (12/1/2011): Adding support for template declarations into the AST.
1119 ROSE_DLL_API SgTemplateFunctionDeclaration*
1120 buildDefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateFunctionDeclaration* first_nondefining_declaration);
1121 
1122 // DQ (11/8/2020): Define a function to build a default constructor for a class.
1123 // ROSE_DLL_API SgMemberFunctionDeclaration* buildConstructor ( const SgName & typeName, SgClassType* initializedName_classType, SgClassDefinition* classDefinition);
1125 
1127 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1128 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1129 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0, bool buildTemplateInstantiation = false);
1130 ROSE_DLL_API SgMemberFunctionDeclaration*
1131 buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1132 
1133 // DQ (8/12/2013): This function needs to supporte SgTemplateParameterPtrList and SgTemplateArgumentPtrList parameters.
1134 // SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1136 buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList );
1137 
1138 // DQ (12/1/2011): Adding support for template declarations in the AST.
1140 buildDefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration );
1141 
1143 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgFunctionParameterList* paralist, SgScopeStatement* scope=NULL);
1144 
1145 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1147 // SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration);
1148 ROSE_DLL_API SgMemberFunctionDeclaration*
1149 buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration, SgTemplateArgumentPtrList* templateArgumentsList);
1150 
1151 #if 0
1152 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1153 // 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).
1154 // 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).
1156 ROSE_DLL_API SgMemberFunctionDeclaration*
1157 buildDefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgScopeStatement* scope, SgExprListExp* decoratorList = NULL /* , unsigned int functionConstVolatileFlags = 0 */, SgMemberFunctionDeclaration* first_nondefinng_declaration = NULL);
1158 #endif
1159 
1160 #if 0
1161 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1163 // SgMemberFunctionDeclaration*
1164 ROSE_DLL_API SgMemberFunctionDeclaration*
1165 buildNondefiningMemberFunctionDeclaration (const SgMemberFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1166 #endif
1167 
1168 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1169 // We need to decide if the SageBuilder API should include these sorts of functions.
1170 ROSE_DLL_API SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1171 
1172 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1173 // We need to decide if the SageBuilder API should include these sorts of functions.
1174 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1175 
1176 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1178 // SgFunctionDeclaration* buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgFunctionDeclaration* first_nondefinng_declaration);
1179 ROSE_DLL_API SgFunctionDeclaration*
1180 buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation = false, SgFunctionDeclaration* first_nondefinng_declaration = NULL, SgTemplateArgumentPtrList* templateArgumentsList = NULL);
1181 
1182 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1183 // We need to decide if the SageBuilder API should include these sorts of functions.
1184 ROSE_DLL_API SgFunctionDeclaration* buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1185 
1186 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1187 // We need to decide if the SageBuilder API should include these sorts of functions.
1189 
1191 ROSE_DLL_API SgProcedureHeaderStatement*
1193 
1194 // CR (9/24/2020)
1196 ROSE_DLL_API SgProcedureHeaderStatement*
1197 buildNondefiningProcedureHeaderStatement(const SgName & name, SgType* return_type, SgFunctionParameterList* param_list,
1199 
1201 ROSE_DLL_API SgExprStatement*
1202 buildFunctionCallStmt(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
1203 
1205 ROSE_DLL_API SgExprStatement*
1206 buildFunctionCallStmt(SgExpression* function, SgExprListExp* parameters=NULL);
1207 
1208 
1210 
1213 ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName& name, SgStatement * stmt = NULL, SgScopeStatement* scope=NULL);
1215 
1217 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement * label=NULL);
1219 
1221 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelSymbol* symbol);
1222 
1223 // DQ (11/22/2017): Added support for computed code goto as defined by GNU C/C++ extension.
1225 SgGotoStatement * buildGotoStatement_nfi(SgExpression* expr);
1226 
1228 ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt( SgExpression * key = NULL,SgStatement *body = NULL);
1229 SgCaseOptionStmt * buildCaseOptionStmt_nfi( SgExpression * key,SgStatement *body);
1230 
1232 ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt( SgStatement *body = NULL);
1234 
1236 ROSE_DLL_API SgExprStatement* buildExprStatement(SgExpression* exp = NULL);
1237 SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
1238 
1239 // DQ (3/27/2015): Added support for SgStatementExpression.
1243 
1245 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement(SgStatement *item_selector = NULL,SgStatement *body = NULL);
1246 inline SgSwitchStatement* buildSwitchStatement(SgExpression *item_selector, SgStatement *body = NULL) {
1247  return buildSwitchStatement(buildExprStatement(item_selector), body);
1248 }
1249 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement_nfi(SgStatement *item_selector,SgStatement *body);
1250 
1252 ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1253 inline SgIfStmt * buildIfStmt(SgExpression* conditional, SgStatement * true_body, SgStatement * false_body) {
1254  return buildIfStmt(buildExprStatement(conditional), true_body, false_body);
1255 }
1256 
1257 ROSE_DLL_API SgIfStmt* buildIfStmt_nfi(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1258 
1259 // CR (9/3/2018)
1261 ROSE_DLL_API SgFortranDo * buildFortranDo(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);
1262 
1265 ROSE_DLL_API SgForInitStatement* buildForInitStatement(const SgStatementPtrList & statements);
1266 ROSE_DLL_API SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList & statements);
1267 
1268 // DQ (10/12/2012): Added new function for a single statement.
1269 ROSE_DLL_API SgForInitStatement* buildForInitStatement( SgStatement* statement );
1270 
1272 ROSE_DLL_API SgForStatement * buildForStatement(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1273 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1274 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1275 ROSE_DLL_API void buildForStatement_nfi(SgForStatement* result, SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1276 
1277 // DQ (3/26/2018): Adding support for range based for statement.
1278 // ROSE_DLL_API SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(SgVariableDeclaration* initializer, SgExpression* range, SgStatement* body);
1280  SgVariableDeclaration* initializer, SgVariableDeclaration* range,
1281  SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration,
1282  SgExpression* not_equal_expression, SgExpression* increment_expression,
1283  SgStatement* body);
1284 
1285 // 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).
1286 // So we need an builder function that can use the existing SgDoWhileStatement scope already on the stack.
1287 ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt* result, SgStatement * body, SgStatement * condition);
1288 
1290 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1291 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1292 
1293 // DQ (3/3/2013): Added UPC specific build functions.
1295 ROSE_DLL_API SgUpcNotifyStatement* buildUpcNotifyStatement_nfi(SgExpression* exp);
1296 
1298 ROSE_DLL_API SgUpcWaitStatement* buildUpcWaitStatement_nfi(SgExpression* exp);
1299 
1301 ROSE_DLL_API SgUpcBarrierStatement* buildUpcBarrierStatement_nfi(SgExpression* exp);
1302 
1305 
1306 
1308 ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1309 inline SgWhileStmt * buildWhileStmt(SgExpression * condition, SgStatement *body, SgStatement* else_body = NULL) {
1310  return buildWhileStmt(buildExprStatement(condition), body, else_body);
1311 }
1312 SgWhileStmt * buildWhileStmt_nfi(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1313 
1315 ROSE_DLL_API SgWithStatement* buildWithStatement(SgExpression* expr, SgStatement* body);
1316 SgWithStatement* buildWithStatement_nfi(SgExpression* expr, SgStatement* body);
1317 
1319 ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement * body, SgStatement *condition);
1320 inline SgDoWhileStmt * buildDoWhileStmt(SgStatement* body, SgExpression * condition) {
1321  return buildDoWhileStmt(body, buildExprStatement(condition));
1322 }
1324 
1326 ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string & name, SgScopeStatement* scope=NULL);
1327 SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string & name, SgScopeStatement* scope);
1328 
1330 ROSE_DLL_API SgPragma* buildPragma(const std::string & name);
1331 
1334 
1336 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);
1337 ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi();
1338 SgBasicBlock * buildBasicBlock_nfi(const std::vector<SgStatement*>&);
1339 
1340 // CR (7/24/2020): Added additional functionality
1343 
1345 ROSE_DLL_API SgExprStatement*
1346 buildAssignStatement(SgExpression* lhs,SgExpression* rhs);
1347 
1348 // DQ (8/16/2011): Generated a new version of this function to define consistant semantics.
1350 ROSE_DLL_API SgExprStatement* buildAssignStatement_ast_translate(SgExpression* lhs,SgExpression* rhs);
1351 
1353 ROSE_DLL_API SgBreakStmt* buildBreakStmt();
1355 
1357 ROSE_DLL_API SgContinueStmt* buildContinueStmt();
1359 
1361 ROSE_DLL_API SgPassStatement* buildPassStatement();
1363 
1365 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression* test);
1366 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression *test, SgExpression *exceptionArgument);
1367 SgAssertStmt* buildAssertStmt_nfi(SgExpression* test);
1368 
1370 ROSE_DLL_API SgYieldExpression* buildYieldExpression(SgExpression* value);
1371 SgYieldExpression* buildYieldExpression_nfi(SgExpression* value);
1372 
1374 ROSE_DLL_API SgKeyDatumPair* buildKeyDatumPair (SgExpression* key, SgExpression* datum);
1375 SgKeyDatumPair* buildKeyDatumPair_nfi(SgExpression* key, SgExpression* datum);
1376 
1378 ROSE_DLL_API SgDictionaryExp* buildDictionaryExp (std::vector<SgKeyDatumPair*> pairs);
1379 SgDictionaryExp* buildDictionaryExp_nfi(std::vector<SgKeyDatumPair*> pairs);
1380 
1382 ROSE_DLL_API SgActualArgumentExpression* buildActualArgumentExpression(SgName arg_name, SgExpression* arg);
1384 
1386 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1387 SgDeleteExp* buildDeleteExp_nfi(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1388 
1390 ROSE_DLL_API SgDeclarationScope * buildDeclarationScope();
1391 
1393 // SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL);
1394 ROSE_DLL_API SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1395 
1397 // SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL);
1398 SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1399 
1400 // DQ (11/19/2011): Added more template declaration support.
1403 
1405 // DQ (6/6/2012): Added support to get the template arguments into place before computing the type.
1406 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1407 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation = false);
1408 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1409 
1410 // DQ (8/11/2013): We need to hand in both the SgTemplateParameterPtrList and the SgTemplateArgumentPtrList because class templates can be partially specialized.
1412 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1413 
1415 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1416 
1420 
1422 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration ( SgName name, SgScopeStatement* scope );
1423 
1426 
1428 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1429 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const std::string& name, SgScopeStatement* scope=NULL);
1430 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const char* name, SgScopeStatement* scope=NULL);
1431 
1435 
1437 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1438 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName& name, bool unnamednamespace, SgScopeStatement* scope );
1440 
1442 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp(SgExpression* lhs);
1443 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp_nfi(SgExpression* lhs);
1444 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp(SgExpression* lhs);
1445 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp_nfi(SgExpression* lhs);
1446 
1447 ROSE_DLL_API SgStringConversion* buildStringConversion(SgExpression* exp);
1448 ROSE_DLL_API SgStringConversion* buildStringConversion_nfi(SgExpression* exp);
1449 
1450 // DQ (6/6/2012): Addeding support to include template arguments in the generated type (template argument must be provided as early as possible).
1451 // DQ (1/24/2009): Added this "_nfi" function but refactored buildStructDeclaration to also use it (this needs to be done uniformally).
1452 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation = false);
1453 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation);
1454 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1455 
1456 // DQ (8/11/2013): I think that the specification of both SgTemplateParameterPtrList and SgTemplateArgumentPtrList is redundant with the nonDefiningDecl (which is a required parameter).
1457 // DQ (11/19/2011): Added to support template class declaration using EDG 4.x support (to support the template declarations directly in the AST).
1459  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1462  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1463 
1465 ROSE_DLL_API SgJovialDefineDeclaration * buildJovialDefineDeclaration_nfi (const SgName& name, const std::string& params,
1466  const std::string& def_string, SgScopeStatement* scope=NULL);
1467 
1469 ROSE_DLL_API SgJovialForThenStatement* buildJovialForThenStatement_nfi(SgExpression* init_expr, SgExpression* incr_expr,
1470  SgExpression* test_expr);
1471 
1474 ROSE_DLL_API SgDerivedTypeStatement * buildDerivedTypeStatement (const SgName& name, SgScopeStatement* scope=NULL);
1475 
1477 ROSE_DLL_API SgModuleStatement * buildModuleStatement(const SgName& name, SgScopeStatement* scope /*=NULL*/);
1478 
1480 ROSE_DLL_API SgJovialTableStatement * buildJovialTableStatement (const SgName& name,
1482 
1484  ROSE_DLL_API SgJovialTableType * buildJovialTableType (const SgName& name, SgType* base_type, SgExprListExp* dim_info, SgScopeStatement* scope=NULL);
1485 
1488 template <class DeclClass> ROSE_DLL_API
1490  SgScopeStatement* scope=NULL, SgClassDeclaration* nonDefiningDecl=NULL);
1491 
1493 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1494 
1496 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope=NULL);
1497 
1499 ROSE_DLL_API SgReturnStmt* buildReturnStmt(SgExpression* expression = NULL);
1500 ROSE_DLL_API SgReturnStmt* buildReturnStmt_nfi(SgExpression* expression);
1501 
1503 ROSE_DLL_API SgNullStatement* buildNullStatement();
1505 
1508 
1510 ROSE_DLL_API SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);
1511 
1513 ROSE_DLL_API SgCommonBlockObject* buildCommonBlockObject(std::string name="", SgExprListExp* exp_list=NULL);
1514 
1516 ROSE_DLL_API SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block=NULL);
1517 
1518 // driscoll6 (6/9/2011): Adding support for try stmts.
1520 ROSE_DLL_API SgCatchOptionStmt* buildCatchOptionStmt(SgVariableDeclaration* condition=NULL, SgStatement* body=NULL);
1521 
1523 ROSE_DLL_API SgAsyncStmt* buildAsyncStmt(SgBasicBlock *body);
1524 
1526 ROSE_DLL_API SgFinishStmt* buildFinishStmt(SgBasicBlock *body);
1527 
1529 ROSE_DLL_API SgAtStmt* buildAtStmt(SgExpression *expression, SgBasicBlock *body);
1530 
1531 // MH (11/12/2014): Added atomic support
1532 ROSE_DLL_API SgAtomicStmt* buildAtomicStmt(SgBasicBlock *body);
1533 
1534 ROSE_DLL_API SgWhenStmt* buildWhenStmt(SgExpression *expression, SgBasicBlock *body);
1535 
1536 // MH (9/16/2014): Added at support
1537 ROSE_DLL_API SgAtExp* buildAtExp(SgExpression *expression, SgBasicBlock *body);
1538 
1539 // MH (11/7/2014): Added finish expression support
1540 ROSE_DLL_API SgFinishExp* buildFinishExp(SgExpression *expression, SgBasicBlock *body);
1541 
1542 ROSE_DLL_API SgHereExp* buildHereExpression();
1543 
1544 ROSE_DLL_API SgDotDotExp* buildDotDotExp();
1545 
1546 
1547 // driscoll6 (6/9/2011): Adding support for try stmts.
1549 ROSE_DLL_API SgTryStmt* buildTryStmt(SgStatement* body,
1550  SgCatchOptionStmt* catch0=NULL,
1551  SgCatchOptionStmt* catch1=NULL,
1552  SgCatchOptionStmt* catch2=NULL,
1553  SgCatchOptionStmt* catch3=NULL,
1554  SgCatchOptionStmt* catch4=NULL);
1555 
1556 // charles4 (9/16/2011): Adding support for try stmts.
1558 //SgTryStmt* buildTryStmt(SgStatement *try_body, SgCatchStatementSeq *catches, SgStatement *finally_body = NULL);
1559 
1560 // charles4 (9/16/2011): Adding support for try stmts.
1562 ROSE_DLL_API SgTryStmt* buildTryStmt(SgBasicBlock *try_body, SgBasicBlock *finally_body = NULL);
1563 
1564 // charles4 (9/16/2011): Adding support for Catch Blocks.
1567 
1568 // charles4 (8/25/2011): Adding support for Java Synchronized stmts.
1571 
1572 // charles4 (8/25/2011): Adding support for Java Throw stmts.
1575 
1576 // charles4 (8/25/2011): Adding support for Java Foreach stmts.
1578 // SgJavaForEachStatement *buildJavaForEachStatement(SgInitializedName * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1579 ROSE_DLL_API SgJavaForEachStatement *buildJavaForEachStatement(SgVariableDeclaration * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1580 
1581 // charles4 (8/25/2011): Adding support for Java Label stmts.
1583 ROSE_DLL_API SgJavaLabelStatement *buildJavaLabelStatement(const SgName &, SgStatement * = NULL);
1584 
1586 ROSE_DLL_API SgExecStatement* buildExecStatement(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1587 SgExecStatement* buildExecStatement_nfi(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1588 
1590 ROSE_DLL_API SgPythonPrintStmt* buildPythonPrintStmt(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1591 SgPythonPrintStmt* buildPythonPrintStmt_nfi(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1592 
1594 ROSE_DLL_API SgPythonGlobalStmt* buildPythonGlobalStmt(SgInitializedNamePtrList& names);
1595 SgPythonGlobalStmt* buildPythonGlobalStmt_nfi(SgInitializedNamePtrList& names);
1596 
1597 // DQ (4/30/2010): Added support for building asm statements.
1599 ROSE_DLL_API SgAsmStmt* buildAsmStatement(std::string s);
1600 SgAsmStmt* buildAsmStatement_nfi(std::string s);
1601 
1604 ROSE_DLL_API SgAsmStmt* buildMultibyteNopStatement( int n );
1605 
1607 ROSE_DLL_API SgBaseClass* buildBaseClass ( SgClassDeclaration* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1608 
1609 ROSE_DLL_API SgNonrealBaseClass* buildNonrealBaseClass ( SgNonrealDecl* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1610 
1611 // SgAccessModifier buildAccessModifier ( unsigned int access );
1612 
1614 ROSE_DLL_API SgStaticAssertionDeclaration* buildStaticAssertionDeclaration(SgExpression* condition, const SgName & string_literal);
1615 
1618 
1620 ROSE_DLL_API SgStatement* buildStatementFromString(const std::string & stmt_str, SgScopeStatement* scope);
1621 
1625 
1626 //--------------------------------------------------------------
1628 
1632 
1635 ROSE_DLL_API SgFile* buildFile(const std::string& inputFileName,const std::string& outputFileName, SgProject* project = NULL, bool clear_globalScopeAcrossFiles = false);
1636 
1638 
1640 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& outputFileName, SgProject* project=NULL, bool clear_globalScopeAcrossFiles = false);
1641 
1643 
1645 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& inputFileName, const std::string& outputFileName, SgProject* project, bool clear_globalScopeAcrossFiles = false);
1646 
1647 // 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.
1649 // ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, const std::string& newFileName);
1650 ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, const std::string& newFileName);
1651 
1652 // DQ (11/10/2019): Support for sharing IR nodes when buildFile() is applied to an existing file.
1654 ROSE_DLL_API void fixupSharingSourcePosition(SgNode* subtreeRoot, int new_file_id);
1655 
1657 ROSE_DLL_API PreprocessingInfo* buildComment(SgLocatedNode* target, const std::string & content,
1658  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1659  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
1660 
1663  const std::string & content,
1664  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
1665 
1667 ROSE_DLL_API PreprocessingInfo* buildHeader(const std::string& header_filename,
1668  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1669  bool isSystemHeader =false);
1670 
1671 
1672 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
1675 #endif
1676 
1677 // 03/17/2014 PHL
1678 // //! Build an equivalence statement from two expression operands
1679 ROSE_DLL_API SgEquivalenceStatement*
1680 buildEquivalenceStatement(SgExpression* lhs,SgExpression* rhs);
1681 
1682 
1684 ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope,
1685  SgStatement *toInsert, SgStatement* original_before_copy);
1686 ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement* insertionPoint, bool insertionPointIsScope,
1687  SgNode* node_copy, SgNode* node_original);
1688 ROSE_DLL_API SgType* getTargetFileTypeSupport(SgType* snippet_type, SgScopeStatement* targetScope);
1689 ROSE_DLL_API SgType* getTargetFileType(SgType* snippet_type, SgScopeStatement* targetScope);
1690 
1691 // DQ (12/6/2020): This is the original function (modified slightly, but mostly I have defined a new function that
1692 // will not effect the AST snippet support that is used by this function.
1693 ROSE_DLL_API SgSymbol* findAssociatedSymbolInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1694 
1695 // DQ (12/6/2020): This is the new function (modified in API and made suitable for the codeSegregation support).
1697 
1699 ROSE_DLL_API void errorCheckingTargetAST (SgNode* node_copy, SgNode* node_original, SgFile* targetFile, bool failOnWarning);
1700 
1701 //-----------------------------------------------------------------------------
1702 //#ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1703 //-----------------------------------------------------------------------------
1708 ROSE_DLL_API SgJavaMemberValuePair *buildJavaMemberValuePair(const SgName &, SgExpression *);
1711 ROSE_DLL_API SgJavaNormalAnnotation *buildJavaNormalAnnotation(SgType *, std::list<SgJavaMemberValuePair *>&);
1712 ROSE_DLL_API SgInitializedName *buildJavaFormalParameter(SgType *, const SgName &, bool is_var_args = false, bool is_final = false);
1713 
1714 ROSE_DLL_API SgJavaPackageStatement *buildJavaPackageStatement(std::string);
1715 ROSE_DLL_API SgJavaImportStatement *buildJavaImportStatement(std::string, bool);
1717 ROSE_DLL_API SgSourceFile *buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string);
1718 ROSE_DLL_API SgArrayType *getUniqueJavaArrayType(SgType *, int);
1719 ROSE_DLL_API SgJavaParameterizedType *getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *);
1724 
1726 
1727 
1728 //----------------------------------------------------------
1730 
1744 
1745 
1746 
1747  //----------------------build unary expressions----------------------
1749 
1753 template <class T>
1754  T* buildUnaryExpression(SgExpression* operand) {
1755  SgExpression* myoperand=operand;
1756  T* result = new T(myoperand, NULL);
1757  ROSE_ASSERT(result);
1758  if (myoperand!=NULL) {
1759  myoperand->set_parent(result);
1760  // set lvalue, it asserts operand!=NULL
1761  markLhsValues(result);
1762  }
1764  return result;
1765  }
1766 
1768 
1771 template <class T>
1772 T* buildUnaryExpression_nfi(SgExpression* operand) {
1773  SgExpression* myoperand = operand;
1774  T* result = new T(myoperand, NULL);
1775  ROSE_ASSERT(result);
1776 
1777  if (myoperand != NULL) {
1778  myoperand->set_parent(result);
1779  // set lvalue, it asserts operand!=NULL
1780  markLhsValues(result);
1781  }
1783 
1784  result->set_need_paren(false);
1785  return result;
1786  }
1787 
1788 //---------------------binary expressions-----------------------
1789 
1791 
1794  template <class T>
1795  T* buildBinaryExpression(SgExpression* lhs, SgExpression* rhs) {
1796  SgExpression* mylhs, *myrhs;
1797  mylhs = lhs;
1798  myrhs = rhs;
1799  T* result = new T(mylhs,myrhs, NULL);
1800  ROSE_ASSERT(result);
1801  if (mylhs!=NULL) {
1802  mylhs->set_parent(result);
1803  // set lvalue
1804  markLhsValues(result);
1805  }
1806  if (myrhs!=NULL) myrhs->set_parent(result);
1808  return result;
1809  }
1810 
1812 
1815  template <class T>
1816  T* buildBinaryExpression_nfi(SgExpression* lhs, SgExpression* rhs) {
1817  SgExpression* mylhs, *myrhs;
1818  mylhs = lhs;
1819  myrhs = rhs;
1820  T* result = new T(mylhs,myrhs, NULL);
1821  ROSE_ASSERT(result);
1822  if (mylhs!=NULL) {
1823  mylhs->set_parent(result);
1824  // set lvalue
1825  markLhsValues(result);
1826  }
1827  if (myrhs!=NULL) myrhs->set_parent(result);
1829  result->set_need_paren(false);
1830 
1831  return result;
1832  }
1833 
1834 } // end of namespace
1835 
1836 namespace Rose {
1837  namespace Frontend {
1838  namespace Java {
1839 
1840  extern ROSE_DLL_API SgClassDefinition *javaLangPackageDefinition;
1841  extern ROSE_DLL_API SgClassType *ObjectClassType;
1842  extern ROSE_DLL_API SgClassType *StringClassType;
1843  extern ROSE_DLL_API SgClassType *ClassClassType;
1844  extern ROSE_DLL_API SgVariableSymbol *lengthSymbol;
1845 
1846  }// ::Rose::frontend::java
1847  }// ::Rose::frontend
1848 }// ::Rose
1849 
1850 namespace Rose {
1851  namespace Builder {
1852  namespace Templates {
1853 
1854  SgTemplateArgument * buildTemplateArgument(SgType * t);
1855  SgTemplateArgument * buildTemplateArgument(SgExpression * e);
1856  SgTemplateArgument * buildTemplateArgument(int v);
1857  SgTemplateArgument * buildTemplateArgument(bool v);
1858 
1859  std::string strTemplateArgument(int v);
1860  std::string strTemplateArgument(bool v);
1861  std::string strTemplateArgument(SgType * t);
1862  std::string strTemplateArgument(SgNamedType * nt);
1863  std::string strTemplateArgument(SgExpression * e);
1864 
1865  template <typename... Args>
1867  static std::string str() { return ""; }
1868  static void fill(std::vector<SgTemplateArgument *> & tpl_args) {}
1869  };
1870 
1871  template <typename T>
1873  static std::string str(T v) {
1874  return strTemplateArgument(v);
1875  }
1876  static void fill(std::vector<SgTemplateArgument *> & tpl_args, T v) {
1877  tpl_args.push_back(buildTemplateArgument(v));
1878  }
1879  };
1880 
1881  template <typename T, typename... Args>
1882  struct TemplateArgumentList<T, Args...> {
1883  static std::string str(T v, Args... args) {
1884  return strTemplateArgument(v) + ", " + TemplateArgumentList<Args...>::str(args...);
1885  }
1886  static void fill(std::vector<SgTemplateArgument *> & tpl_args, T v, Args... args) {
1887  tpl_args.push_back(buildTemplateArgument(v));
1888  TemplateArgumentList<Args...>::fill(tpl_args, args...);
1889  }
1890  };
1891 
1892  template <typename... Args>
1893  std::string strTemplateArgumentList(Args... args) {
1894  return TemplateArgumentList<Args...>::str(args...);
1895  }
1896 
1897  template <typename... Args>
1898  void fillTemplateArgumentList(std::vector<SgTemplateArgument *> & tpl_args, Args... args) {
1899  TemplateArgumentList<Args...>::fill(tpl_args, args...);
1900  }
1901 
1902  template <typename... Args>
1903  std::vector<SgTemplateArgument *> buildTemplateArgumentList(Args... args) {
1904  std::vector<SgTemplateArgument *> tpl_args;
1905  TemplateArgumentList<Args...>::fill(tpl_args, args...);
1906  return tpl_args;
1907  }
1908 
1909  SgExpression * instantiateNonrealRefExps(SgExpression * expr, std::vector<SgTemplateParameter *> & tpl_params, std::vector<SgTemplateArgument *> & tpl_args);
1910  SgType * instantiateNonrealTypes(SgType * type, std::vector<SgTemplateParameter *> & tpl_params, std::vector<SgTemplateArgument *> & tpl_args);
1911 
1912 } } }
1913 
1914 namespace SageBuilder {
1915  using namespace Rose::Builder::Templates;
1916 }
1917 
1918 //-----------------------------------------------------------------------------
1919 //#endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1920 //-----------------------------------------------------------------------------
1921 
1922 #endif //ROSE_SAGE_BUILDER_INTERFACE
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...
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 ...
SgPythonGlobalStmt * buildPythonGlobalStmt_nfi(SgInitializedNamePtrList &names)
Build a variable declaration, handle symbol table transparently.
This class represents the notion of an initializer for a variable declaration or expression in a func...
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal_nfi(long long value, const std::string &str)
ROSE_DLL_API SgHereExp * buildHereExpression()
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
This class represents the concept of an instantiation of member function template or a member functio...
ROSE_DLL_API SgJavaMarkerAnnotation * buildJavaMarkerAnnotation(SgType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgClassNameRefExp * buildClassNameRefExp(SgClassSymbol *sym)
This class represents the concept of a class declaration statement. It includes the concept of an ins...
ROSE_DLL_API void clearScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgWcharVal * buildWcharVal(wchar_t value=0)
ROSE_DLL_API SgAsmStmt * buildAsmStatement(std::string s)
Build a NULL statement.
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.
This class represents the concept of a declaration list.
ROSE_DLL_API SgTypeIdOp * buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type)
DQ (1/25/2013): Added support for typeId operators.
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)
This class represents a boolean value (expression value).
ROSE_DLL_API SgSuperExp * buildSuperExp_nfi(SgClassSymbol *sym)
SgCudaKernelExecConfig * buildCudaKernelExecConfig_nfi(SgExpression *grid=NULL, SgExpression *blocks=NULL, SgExpression *shared=NULL, SgExpression *stream=NULL)
Build a CUDA kernel execution configuration (<<>>)
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.
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
Build the rhs of a variable declaration which includes an assignment.
ROSE_DLL_API SgArrayType * buildArrayType(SgType *base_type=NULL, SgExpression *index=NULL)
Build ArrayType.
ROSE_DLL_API SgFoldExpression * buildFoldExpression(SgExpression *operands, std::string operator_token_string, bool is_left_associative)
This class represents the notion of an value (expression value).
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;.
ROSE_DLL_API SgForInitStatement * buildForInitStatement()
Build a for init statement.
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement(SgStatement *item_selector=NULL, SgStatement *body=NULL)
Build a switch statement.
ROSE_DLL_API SgTemplateParameterPtrList * getTemplateParameterList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a C or C++ goto statement.
ROSE_DLL_API SgExecStatement * buildExecStatement(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build an exec statement.
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.
ROSE_DLL_API SgModifierType * buildModifierType(SgType *base_type=NULL)
Build a modifier type.
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp_nfi(SgExpression *exp)
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.
ROSE_DLL_API SgReturnStmt * buildReturnStmt(SgExpression *expression=NULL)
Build a return statement.
ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol *s)
Build a Fortran numeric label ref exp.
SgActualArgumentExpression * buildActualArgumentExpression_nfi(SgName arg_name, SgExpression *arg)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API void pushScopeStack(SgScopeStatement *stmt)
Public interfaces of the scope stack, should be stable.
This class represents the concept of the dynamic execution of a string, file, or code object...
ROSE_DLL_API SgTypeUnsignedShort * buildUnsignedShortType()
Built in simple types.
ROSE_DLL_API SgDeclarationStatement * findAssociatedDeclarationInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgAtExp * buildAtExp(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardExtends(SgType *)
Build a SgFile node and attach it to SgProject.
SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
This class represents the concept of a C or C++ statement which contains a expression.
ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
ROSE_DLL_API SgUpcThreads * buildUpcThreads_nfi()
ROSE_DLL_API SgFloat128Val * buildFloat128Val(long double value=0.0)
ROSE_DLL_API SgLongIntVal * buildLongIntVal_nfi(long value, const std::string &str)
ROSE_DLL_API SgTypeChar32 * buildChar32Type()
Built in simple types.
ROSE_DLL_API SgTypeMatrix * buildMatrixType()
Build a Matlab Matrix Type.
This class represents a source file for a project (which may contian many source files and or directo...
ROSE_DLL_API SgEnumVal * buildEnumVal(long long int value, SgEnumDeclaration *decl, SgName name)
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.
ROSE_DLL_API SgEnumVal * buildEnumVal_nfi(long long int value, SgEnumDeclaration *decl, SgName name)
SgDefaultOptionStmt * buildDefaultOptionStmt_nfi(SgStatement *body)
Build a variable declaration, handle symbol table transparently.
This class represents the variable declaration or variable initialization withn a for loop...
ROSE_DLL_API SgModifierType * buildFortranKindType(SgType *base_type, SgExpression *kindExpression)
Build a type based on the Fortran kind mechanism.
ROSE_DLL_API SgAttributeSpecificationStatement * buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind)
Build Fortran attribute specification statement.
ROSE_DLL_API SgMagicColonExp * buildMagicColonExp()
Build a Matlab colon expression :
ROSE_DLL_API SgSuperExp * buildSuperExp(SgClassSymbol *sym)
Build super pointer.
ROSE_DLL_API SgFloat80Val * buildFloat80Val_nfi(long double value, const std::string &str)
This class represents the concept of a C++ sequence of catch statements.
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.
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
ROSE_DLL_API SgActualArgumentExpression * buildActualArgumentExpression(SgName arg_name, SgExpression *arg)
Build an Actual Argument Expression.
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp(SgExpression *exp=NULL)
Build alignof() expression with an expression parameter.
ROSE_DLL_API SgThisExp * buildThisExp_nfi(SgSymbol *sym)
ROSE_DLL_API SgClassType * buildClassTemplateType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Some support for building class template instantiation declarations.
bool inSwitchScope()
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgType * buildFortranImplicitType(SgName name)
Build a type based on Fortran's implicit typing rules.
This class represents the GNU extension "statement expression" (thus is non-standard C and C++)...
This class represents the C++ throw expression (handled as a unary operator).
This class represents the rhs of a variable declaration which includes an optional assignment (e...
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal(long double value=0.0)
ROSE_DLL_API SgTypeLongDouble * buildLongDoubleType()
Built in simple types.
ROSE_DLL_API SgTypeComplex * buildComplexType(SgType *base_type=NULL)
Build a complex type.
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal_nfi(unsigned long v, const std::string &str)
ROSE_DLL_API SgFoldExpression * buildFoldExpression_nfi(SgExpression *operands, std::string operator_token_string, bool is_left_associative)
ROSE_DLL_API SgLambdaExp * buildLambdaExp_nfi(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
This class represents the concept of a C++ using directive.
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 ...
ROSE_DLL_API void popScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
This class represents the base class for all types.
ROSE_DLL_API SgStringVal * buildStringVal(std::string value="")
SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
T * buildUnaryExpression(SgExpression *operand)
Template function to build a unary expression of type T. Instantiated functions include:buildAddressO...
Definition: sageBuilder.h:1754
ROSE_DLL_API SgJavaTypeExpression * buildJavaTypeExpression(SgType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgFortranDo * buildFortranDo(SgExpression *initialization, SgExpression *bound, SgExpression *increment, SgBasicBlock *loop_body)
Build a Fortran do construct.
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...
ROSE_DLL_API SgDotDotExp * buildDotDotExp()
Build a variable declaration, handle symbol table transparently.
SgCaseOptionStmt * buildCaseOptionStmt_nfi(SgExpression *key, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeChar16 * buildChar16Type()
Built in simple types.
Collection of streams.
Definition: Message.h:1606
This class represents the concept of a do-while statement.
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...
ROSE_DLL_API SgTemplateType * buildTemplateType(SgName name="")
Build a template type, used for template parameter and later argument.
ROSE_DLL_API SgFunctionType * buildFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList=NULL)
Build function type from return type and parameter type list.
ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators)
ROSE_DLL_API SgJovialForThenStatement * buildJovialForThenStatement_nfi(SgExpression *init_expr, SgExpression *incr_expr, SgExpression *test_expr)
Build a Jovial loop statement. Two variants are FOR and WHILE.
ROSE_DLL_API SgForInitStatement * buildForInitStatement_nfi(SgStatementPtrList &statements)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode *n)
Build an abstract handle from a SgNode.
This class represents the concept of a class name within the compiler.
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal(unsigned int v=0)
Build an unsigned integer.
ROSE_DLL_API SgAutoType * buildAutoType()
Built in simple types.
SourcePositionClassification SourcePositionClassificationMode
C++ SageBuilder namespace specific state for storage of the source code position state (used to contr...
Classify as compiler generated code (e.g. template instantiation).
Definition: sageBuilder.h:144
ROSE_DLL_API SgTypeExpression * buildTypeExpression(SgType *type)
DQ (7/24/2014): Adding support for c11 generic operands.
SgListExp * buildListExp_nfi()
ROSE_DLL_API SgExprStatement * buildFunctionCallStmt(const SgName &name, SgType *return_type, SgExprListExp *parameters=NULL, SgScopeStatement *scope=NULL)
Build a regular function call statement.
ROSE_DLL_API SgModifierType * buildRestrictType(SgType *base_type)
Build a restrict type.
ROSE_DLL_API SgThisExp * buildThisExp(SgSymbol *sym)
Build this pointer.
This class represents the concept of an enum declaration.
ROSE_DLL_API SgStatementExpression * buildStatementExpression_nfi(SgStatement *exp)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API void testTemplateParameterParents(SgDeclarationStatement *decl)
DQ (9/16/2012): Added function to support setting the template parameters and setting their parents (...
ROSE_DLL_API SgUpcMythread * buildUpcMythread_nfi()
ROSE_DLL_API SgKeyDatumPair * buildKeyDatumPair(SgExpression *key, SgExpression *datum)
Build a key-datum pair.
SgCompoundLiteralExp * buildCompoundLiteralExp_nfi(SgVariableSymbol *varSymbol)
Build function for compound literals (uses a SgVariableSymbol and is similar to buildVarRefExp_nfi())...
SgDictionaryComprehension * buildDictionaryComprehension_nfi(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
ROSE_DLL_API SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
buildNondefiningTemplateClassDeclaration()
ROSE_DLL_API SgEquivalenceStatement * buildEquivalenceStatement(SgExpression *lhs, SgExpression *rhs)
Build a SgFile node and attach it to SgProject.
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.
This class represents the "this" operator (can be applied to any member data).
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.
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
This class represents a string type used for SgStringVal IR node.
SgClassNameRefExp * buildClassNameRefExp_nfi(SgClassSymbol *sym)
ROSE_DLL_API SgModifierType * buildUpcStrictType(SgType *base_type=NULL)
Build a UPC strict type.
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.
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
attribute_spec_enum
Fortran specific classification of attribute statements (each corresponds to a declaration attribute)...
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
This class represents the notion of a declared variable.
ROSE_DLL_API SgModifierType * buildUpcBlockNumberType(SgType *base_type, long block_factor)
Build a UPC shared[n] type.
ROSE_DLL_API SgThrowOp * buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind)
Build a ThrowOp expression.
ROSE_DLL_API SgAwaitExpression * buildAwaitExpression_nfi()
SgNullStatement * buildNullStatement_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgModuleStatement * buildModuleStatement(const SgName &name, SgScopeStatement *scope)
Build a Fortran module declaration.
ROSE_DLL_API SgFunctionCallExp * buildFunctionCallExp(SgFunctionSymbol *sym, SgExprListExp *parameters=NULL)
Build a function call expression.
ROSE_DLL_API SgJavaParameterizedType * getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *)
Build a SgFile node and attach it to SgProject.
SgAssertStmt * buildAssertStmt_nfi(SgExpression *test)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a member function declaration statement.
This class represents the concept of a C and C++ case option (used within a switch statement)...
ROSE_DLL_API SgTemplateArgumentPtrList * getTemplateArgumentList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgStaticAssertionDeclaration * buildStaticAssertionDeclaration(SgExpression *condition, const SgName &string_literal)
DQ (7/25/2014): Adding support for C11 static assertions.
ROSE_DLL_API SgJavaSingleMemberAnnotation * buildJavaSingleMemberAnnotation(SgType *, SgExpression *)
Build a SgFile node and attach it to SgProject.
This class represents the concept of a function declaration statement.
SgAsmStmt * buildAsmStatement_nfi(std::string s)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeFloat128 * buildFloat128Type()
Built in simple types.
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.
ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build if statement.
ROSE_DLL_API SgEnumDeclaration * buildNondefiningEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope)
Build an enum first nondefining declaration, without file info.
This class represents the concept of a C Assembler statement (untested).
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
ROSE_DLL_API SgChar16Val * buildChar16Val_nfi(unsigned short value, const std::string &str)
ROSE_DLL_API SgBaseClass * buildBaseClass(SgClassDeclaration *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
DQ (5/6/2013): Added build functions to support SgBaseClass construction.
ROSE_DLL_API SgReferenceType * buildReferenceType(SgType *base_type=NULL)
Build a reference type.
ROSE_DLL_API SgClassType * buildTemplateClassType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Same as buildClassTemplateType(), just better name.
ROSE_DLL_API SgFloat128Val * buildFloat128Val_nfi(long double value, const std::string &str)
ROSE_DLL_API SgTypeSignedLongLong * buildSignedLongLongType()
Built in simple types.
This class represents the concept of a C and C++ expression list.
ROSE_DLL_API SgIntVal * buildIntValHex(int value=0)
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp_nfi(SgExpression *op)
ROSE_DLL_API SgTypeUnsignedInt * buildUnsignedIntType()
Built in simple types.
ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgNode *node_copy, SgNode *node_original)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgNewExp * buildNewExp(SgType *type, SgExprListExp *exprListExp, SgConstructorInitializer *constInit, SgExpression *expr, short int val, SgFunctionDeclaration *funcDecl)
SgFunctionParameterList * buildFunctionParameterList_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeOfType * buildTypeOfType(SgExpression *base_expression, SgType *base_type)
Build a GNU typeof operator.
This class represents the "sizeof()" operator (applied to any type).
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardUnbound()
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgArrayType * getUniqueJavaArrayType(SgType *, int)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgBoolValExp * buildBoolValExp(int value=0)
Build a bool value expression, the name convention of SgBoolValExp is little different from others fo...
ROSE_DLL_API SgType * getTargetFileType(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
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.
ROSE_DLL_API SgDeclarationScope * buildDeclarationScope()
Build a scope statement. Used to build SgNonrealDecl and SgNonrealType.
ROSE_DLL_API SgUpcBarrierStatement * buildUpcBarrierStatement_nfi(SgExpression *exp)
Build a UPC barrier statement.
ROSE_DLL_API SgIntVal * buildIntVal(int value=0)
Build an integer value expression.
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp(int parameter_number, int parameter_level)
ROSE_DLL_API SgTemplateClassDeclaration * buildTemplateClassDeclaration(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateClassDeclaration *nonDefiningDecl, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build tempplate class declaration.
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.
ROSE_DLL_API SgPragma * buildPragma(const std::string &name)
Build SgPragma.
Main namespace for the ROSE library.
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp(SgExpression *op=NULL)
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...
ROSE_DLL_API SgJavaMemberValuePair * buildJavaMemberValuePair(const SgName &, SgExpression *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgCommonBlock * buildCommonBlock(SgCommonBlockObject *first_block=NULL)
Build a Fortran Common statement.
ROSE_DLL_API SgReturnStmt * buildReturnStmt_nfi(SgExpression *expression)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgShortVal * buildShortValHex(short value=0)
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntValHex(unsigned long long v=0)
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement(SgStatement *stmt)
Build a StmtDeclarationStmt.
This class represents the notion of an value (expression value).
ROSE_DLL_API SgFortranIncludeLine * buildFortranIncludeLine(std::string filename)
Build Fortran include line.
ROSE_DLL_API SgDerivedTypeStatement * buildDerivedTypeStatement(const SgName &name, SgScopeStatement *scope=NULL)
Build an SgDerivedTypeStatement Fortran derived type declaration with a class declaration and definit...
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)
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration(SgName name, SgScopeStatement *scope)
DQ (11/7/2009): Added functions to build C++ class.
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgVarRefExp * buildJavaArrayLengthVarRefExp()
Build a SgFile node and attach it to SgProject.
RelativePositionType
MK: Enum type to store if the directive goes before or after the corresponding line of source code...
ROSE_DLL_API SgCatchOptionStmt * buildCatchOptionStmt(SgVariableDeclaration *condition=NULL, SgStatement *body=NULL)
Build a catch statement.
This class represents the concept of a C trinary conditional expression (e.g. "test ...
ROSE_DLL_API SgTypeFloat80 * buildFloat80Type()
Built in simple types.
ROSE_DLL_API SgJovialTableStatement * buildJovialTableStatement(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope=NULL)
Build a Jovial table declaration statement.
ROSE_DLL_API SgDoubleVal * buildDoubleVal_nfi(double value, const std::string &str)
ROSE_DLL_API SgRangeExp * buildRangeExp(SgExpression *start)
Build a Matlab range expression like start:end or start:stride:end.
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.
ROSE_DLL_API SgStringConversion * buildStringConversion(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgFunctionCallExp * buildFunctionCallExp_nfi(SgExpression *f, SgExprListExp *parameters=NULL)
ROSE_DLL_API SgTypeVoid * buildVoidType()
Built in simple types.
ROSE_DLL_API SgShortVal * buildShortVal_nfi(short value, const std::string &str)
ROSE_DLL_API SgClassDeclaration * buildClassDeclaration(SgName name, SgScopeStatement *scope)
DQ (11/7/2009): Added function to build C++ class (builds both the non-defining and defining declarat...
ROSE_DLL_API SgTypeInt * buildIntType()
Built in simple types.
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build a compound initializer, for vector type initialization.
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build template variable declarations.
SgKeyDatumPair * buildKeyDatumPair_nfi(SgExpression *key, SgExpression *datum)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp(SgExpression *op=NULL)
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.
SgTypeTraitBuiltinOperator * buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters)
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...
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp(SgExpression *exp=NULL)
Build sizeof() expression with an expression parameter.
SgName unparseTemplateArgumentToString(SgTemplateArgument *templateArgument)
DQ (3/9/2018): Added to support debugging.
ROSE_DLL_API SgTypeUnsignedChar * buildUnsignedCharType()
Built in simple types.
ROSE_DLL_API SgModifierType * buildConstType(SgType *base_type=NULL)
Build a const type.
ROSE_DLL_API SgMinusOp * buildMinusOp_nfi(SgExpression *op)
ROSE_DLL_API SgChooseExpression * buildChooseExpression()
ROSE_DLL_API SgAsyncStmt * buildAsyncStmt(SgBasicBlock *body)
MH (6/10/2014): Added async support.
ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement *body, SgStatement *condition)
Build do-while statement.
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.
ROSE_DLL_API SgTypeFixed * buildFixedType(SgExpression *fraction, SgExpression *scale)
Build a Jovial fixed type with a fraction specifier and a scale specifier.
This class represents the notion of a break statement (typically used in a switch statment)...
ROSE_DLL_API SgMatrixExp * buildMatrixExp(SgExprListExp *firstRow)
Build a Matlab Matrix.
ROSE_DLL_API SgClassDeclaration * buildJavaDefiningClassDeclaration(SgScopeStatement *, std::string, SgClassDeclaration::class_types kind=SgClassDeclaration::e_class)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntValHex(unsigned int v=0)
This class represents the concept of a name within the compiler.
ROSE_DLL_API SgNullExpression * buildNullExpression_nfi()
No file info version of buildNullExpression(). File info is to be set later on.
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:1772
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNamespaceDefinitionStatement * buildNamespaceDefinition(SgNamespaceDeclarationStatement *d=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeLong * buildLongType()
Built in simple types.
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build an aggregate initializer.
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp_nfi(SgExpression *exp)
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.
ROSE_DLL_API void setSourcePosition(SgNode *node)
Set the source code positon for the current (input) node.
ROSE_DLL_API SgIntVal * buildIntVal_nfi(int value=0)
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp(SgExpression *exp=NULL)
Build noexcept operator expression with an expression parameter.
ROSE_DLL_API SgModifierType * buildUpcBlockIndefiniteType(SgType *base_type=NULL)
Build a UPC shared[] type.
ROSE_DLL_API SgConstVolatileModifier * buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype=SgConstVolatileModifier::e_unknown)
Build a const/volatile type qualifier.
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal(unsigned long v=0)
Build a unsigned long integer.
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
storage_modifier_enum
Storage Modifiers (only one value can be specified)
ROSE_DLL_API SgStringConversion * buildStringConversion_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgPythonPrintStmt * buildPythonPrintStmt_nfi(SgExpression *dest=NULL, SgExprListExp *values=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgJavaLabelStatement * buildJavaLabelStatement(const SgName &, SgStatement *=NULL)
Build a Java Label statement.
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement_nfi(SgStatement *stmt)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTemplateParameter * buildTemplateParameter(SgTemplateParameter::template_parameter_enum parameterType, SgType *)
Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum { parameter_...
This class represents the concept of a class definition in C++.
SgTemplateFunctionRefExp * buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol *sym)
DQ (12/15/2011): Adding template declaration support to the AST.
ROSE_DLL_API SgJavaForEachStatement * buildJavaForEachStatement(SgVariableDeclaration *=NULL, SgExpression *=NULL, SgStatement *=NULL)
Build a Java Foreach statement.
This class represents strings within the IR nodes.
ROSE_DLL_API SgLongIntVal * buildLongIntVal(long value=0)
Build a long integer value expression.
ROSE_DLL_API bool emptyScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp_nfi(SgExpression *op)
SourcePositionClassification
Definition: sageBuilder.h:138
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 ...
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal(unsigned short v=0)
Build an unsigned short integer.
ROSE_DLL_API SgScopeStatement * topScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
SgWhileStmt * buildWhileStmt_nfi(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNullStatement * buildNullStatement()
Build a NULL statement.
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...
ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build a structure, It is also a declaration statement in SAGE III.
Functions that build an AST.
Definition: sageBuilder.h:31
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
ROSE_DLL_API SgComplexVal * buildImaginaryVal_nfi(SgValueExp *imaginary_value, const std::string &str)
SgContinueStmt * buildContinueStmt_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal_nfi(unsigned char v, const std::string &str)
This class represents the concept of a contructor initializer list (used in constructor (member funct...
ROSE_DLL_API SgAssertStmt * buildAssertStmt(SgExpression *test)
Build a Assert statement.
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.
Functions that are useful when operating on the AST.
Definition: sageBuilder.h:25
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)
ROSE_DLL_API SgJavaQualifiedType * getUniqueJavaQualifiedType(SgClassDeclaration *, SgNamedType *, SgNamedType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
ROSE_DLL_API SgClassDefinition * buildClassDefinition(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression *operand_i, SgType *expression_type, SgCastExp::cast_type_enum cast_type)
ROSE_DLL_API SgTypeUnsignedLong * buildUnsignedLongType()
Built in simple types.
subprogram_kind_enum
Classification for different types of Fortran subprograms.
ROSE_DLL_API SgSymbol * findAssociatedSymbolInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string &str)
SgTemplateMemberFunctionRefExp * buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
DQ (12/29/2011): Adding template declaration support to the AST.
ROSE_DLL_API SgBoolValExp * buildBoolValExp_nfi(int value)
ROSE_DLL_API SgAtomicStmt * buildAtomicStmt(SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
SgClassDefinition * buildClassDefinition_nfi(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgExpression *affinity, SgStatement *loop_body)
Build a UPC forall statement.
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture_nfi(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
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...
ROSE_DLL_API SgStatementExpression * buildStatementExpression(SgStatement *exp)
Build a GNU statement expression.
ROSE_DLL_API SgStringVal * buildStringVal_nfi(std::string value)
ROSE_DLL_API SgFinishStmt * buildFinishStmt(SgBasicBlock *body)
MH (6/11/2014): Added finish support.
ROSE_DLL_API SgChar32Val * buildChar32Val(unsigned int value=0)
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardSuper(SgType *)
Build a SgFile node and attach it to SgProject.
This class represents the notion of a typedef declaration.
ROSE_DLL_API SgChar16Val * buildChar16Val(unsigned short value=0)
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...
ROSE_DLL_API SgWcharVal * buildWcharVal_nfi(wchar_t value, const std::string &str)
ROSE_DLL_API SgVariableDefinition * buildVariableDefinition_nfi(SgVariableDeclaration *decl, SgInitializedName *init_name, SgInitializer *init)
Build variable definition.
ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression *test=NULL, SgExpression *a=NULL, SgExpression *b=NULL)
Build a conditional expression ?:
SgFunctionRefExp * buildFunctionRefExp_nfi(SgFunctionSymbol *sym)
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal(unsigned long long v=0)
Build an unsigned long long integer.
This class represents the notion of an value (expression value).
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:9737
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.
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortValHex(unsigned short v=0)
ROSE_DLL_API SgFunctionParameterTypeList * buildFunctionParameterTypeList(SgFunctionParameterList *paralist)
Build SgFunctionParameterTypeList from SgFunctionParameterList.
ROSE_DLL_API std::string display(SourcePositionClassification &scp)
display function for debugging
ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators)
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents a lambda expression.
ROSE_DLL_API SgFinishExp * buildFinishExp(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeSignedChar * buildSignedCharType()
Built in simple types.
ROSE_DLL_API SgFloatVal * buildFloatVal(float value=0.0)
ROSE_DLL_API SgShortVal * buildShortVal(short value=0)
SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string &name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SgScopeStatement * getGlobalScopeFromScopeStack()
Support to retrive the SgGlobal from the internal scope stack (error if not present in a non-empty li...
ROSE_DLL_API SgDictionaryExp * buildDictionaryExp(std::vector< SgKeyDatumPair * > pairs)
Build a list of key-datum pairs.
ROSE_DLL_API void setSourcePositionClassificationMode(SourcePositionClassification X)
Set the current source position classification (defines how IR nodes built by the SageBuilder interfa...
ROSE_DLL_API SgClassExp * buildClassExp(SgClassSymbol *sym)
Build class pointer.
ROSE_DLL_API SgContinueStmt * buildContinueStmt()
Build a continue statement.
ROSE_DLL_API SgSourceFile * buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp_nfi()
ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression *operand_i, SgType *expression_type)
Build vararg op expression.
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...
ROSE_DLL_API void setTemplateParametersInDeclaration(SgDeclarationStatement *decl, SgTemplateParameterPtrList *templateParametersList_input)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp(SgExpression *lhs)
driscoll6 (7/20/11) : Support n-ary operators for python
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
ROSE_DLL_API SgVariantExpression * buildVariantExpression()
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.
ROSE_DLL_API SgUpcWaitStatement * buildUpcWaitStatement_nfi(SgExpression *exp)
Build a UPC wait statement.
ROSE_DLL_API SgJovialBitType * buildJovialBitType(SgExpression *size)
Build a Jovial bit type of a given size.
ROSE_DLL_API SgJavaImportStatement * buildJavaImportStatement(std::string, bool)
Build a SgFile node and attach it to SgProject.
This class represents the concept of a block (not a basic block from control flow analysis)...
This class represents the concept of a C++ namespace declaration.
ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement *label=NULL)
Build a goto statement.
ROSE_DLL_API SgTypeSignedLong * buildSignedLongType()
Built in simple types.
This class represents a list display.
This class represents the notion of a statement.
ROSE_DLL_API SgCatchStatementSeq * buildCatchStatementSeq(SgCatchOptionStmt *=NULL)
Build an initial sequence of Catch blocks containing 0 or 1 element.
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList()
For preprocessing information including source comments, #include , #if, #define, etc...
ROSE_DLL_API SgDictionaryComprehension * buildDictionaryComprehension(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
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.
ROSE_DLL_API SgChar32Val * buildChar32Val_nfi(unsigned int value, const std::string &str)
This class represents the concept of a for loop.
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName &name, bool unnamednamespace, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateSpecializationArgumentsList_input)
Build a variable declaration, handle symbol table transparently.
SgBreakStmt * buildBreakStmt_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgRvalueReferenceType * buildRvalueReferenceType(SgType *base_type)
Build a rvalue reference type.
ROSE_DLL_API SgAtStmt * buildAtStmt(SgExpression *expression, SgBasicBlock *body)
MH (6/11/2014): Added at support.
SgTupleExp * buildTupleExp_nfi()
ROSE_DLL_API SgTypeSignedShort * buildSignedShortType()
Built in simple types.
SgGotoStatement * buildGotoStatement_nfi(SgLabelStatement *label)
Build a variable declaration, handle symbol table transparently.
SgCompoundLiteralExp * buildCompoundLiteralExp(SgVariableSymbol *varSymbol)
ROSE_DLL_API SgChooseExpression * buildChooseExpression_nfi()
ROSE_DLL_API SgIfStmt * buildIfStmt_nfi(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build a variable declaration, handle symbol table transparently.
Classify as a transformation.
Definition: sageBuilder.h:143
ROSE_DLL_API SgMemberFunctionDeclaration * buildDefaultConstructor(SgClassType *classType)
Build a variable declaration, handle symbol table transparently.
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.
ROSE_DLL_API SgLambdaRefExp * buildLambdaRefExp(SgType *return_type, SgFunctionParameterList *params, SgScopeStatement *scope)
Build lambda expression.
ROSE_DLL_API SgModifierType * buildUpcSharedType(SgType *base_type=NULL, long layout=-1)
Build a UPC shared type.
ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build while statement.
This class represents a C99 complex type.
This class represents a tuple display.
This class represents a type for all functions.
ROSE_DLL_API SgPointerType * buildPointerType(SgType *base_type=NULL)
Build a pointer type.
ROSE_DLL_API SgComplexVal * buildImaginaryVal(long double imaginary_value)
This class represents the concept of a namespace definition.
ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt *result, SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class represents the concept of a C Assembler statement (untested).
ROSE_DLL_API SgExprStatement * buildAssignStatement_ast_translate(SgExpression *lhs, SgExpression *rhs)
This version does not recursively reset the file info as a transformation.
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:1795
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp()
DQ (7/31/2014): Adding support for C++11 nullptr const value expressions.
This class represents the concept of a C or C++ default case within a switch statement.
ROSE_DLL_API SgComplexVal * buildComplexVal_nfi(SgValueExp *real_value, SgValueExp *imaginary_value, const std::string &str)
ROSE_DLL_API SgNonrealBaseClass * buildNonrealBaseClass(SgNonrealDecl *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgBreakStmt * buildBreakStmt()
Build a break statement.
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.
This class represents the concept of an "if" construct.
ROSE_DLL_API SgEmptyDeclaration * buildEmptyDeclaration()
Build an empty declaration (useful for adding precission to comments and CPP handling under token-bas...
SgCtorInitializerList * buildCtorInitializerList_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeDouble * buildDoubleType()
Built in simple types.
to specify a construct using a specifier Can be used alone or with parent handles when relative speci...
ROSE_DLL_API SgJavaNormalAnnotation * buildJavaNormalAnnotation(SgType *)
Build a SgFile node and attach it to SgProject.
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.
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...
ROSE_DLL_API SgWithStatement * buildWithStatement(SgExpression *expr, SgStatement *body)
Build a with statement.
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...
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntValHex(long long value=0)
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.
SgTemplateClassDefinition * buildTemplateClassDefinition(SgTemplateClassDeclaration *d=NULL)
Build a template class definition statement.
SgExprListExp * buildExprListExp_nfi()
ROSE_DLL_API SgTypeBool * buildBoolType()
Built in simple types.
This class represents the notion of an expression or statement which has a position within the source...
This class represents template argument within the use of a template to build an instantiation.
Set pointers to Sg_File_Info objects to NULL.
Definition: sageBuilder.h:145
This class represents the variable refernece in expressions.
This class represents the concept of a do-while statement.
ROSE_DLL_API SgAwaitExpression * buildAwaitExpression()
ROSE_DLL_API void errorCheckingTargetAST(SgNode *node_copy, SgNode *node_original, SgFile *targetFile, bool failOnWarning)
Error checking the inserted snippet AST.
ROSE_DLL_API SgTypeUnsignedLongLong * buildUnsignedLongLongType()
Built in simple types.
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement_nfi(SgStatement *item_selector, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgModifierType * buildConstVolatileType(SgType *base_type=NULL)
Build a const volatile type.
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.
This class represents the definition (initialization) of a variable.
ROSE_DLL_API SgNullExpression * buildNullExpression()
Build a null expression, set file info as the default one.
SgPassStatement * buildPassStatement_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList_nfi()
This class represents the concept of a C++ call to the delete operator.
This class represents the concept of a C++ call to the new operator.
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level)
ROSE_DLL_API void setTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a C or C++ continue statement.
ROSE_DLL_API void setTemplateParameterParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgMinusOp * buildMinusOp(SgExpression *op=NULL)
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
tps (09/02/2009) : Added support for building namespaces
ROSE_DLL_API SgUpcNotifyStatement * buildUpcNotifyStatement_nfi(SgExpression *exp)
Build a UPC notify statement.
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
ROSE_DLL_API SgTypeWchar * buildWcharType()
Built in simple types.
ROSE_DLL_API SgJovialBitVal * buildJovialBitVal_nfi(const std::string &str)
Build a Jovial bit value expression.
ROSE_DLL_API SgFloat80Val * buildFloat80Val(long double value=0.0)
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.
std::list< SgScopeStatement * > ScopeStack
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgType * getTargetFileTypeSupport(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt(SgExpression *key=NULL, SgStatement *body=NULL)
Build a case option statement.
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.
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...
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 ...
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.
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.
ROSE_DLL_API SgDeclType * buildDeclType(SgExpression *base_expression, SgType *base_type)
Build a decltype reference type.
ROSE_DLL_API SgFunctionCallExp * buildMemberFunctionCall(std::string className, SgExpression *objectExpression, std::string functionName, SgExprListExp *params, SgScopeStatement *scope)
Build member function calls.
ROSE_DLL_API SgJavaPackageStatement * buildJavaPackageStatement(std::string)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgMatlabForStatement * buildMatlabForStatement(SgExpression *loop_index, SgExpression *loop_range, SgBasicBlock *loop_body)
Build a For-loop statement for matlab.
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.
ROSE_DLL_API SgTypeUnknown * buildUnknownType()
Built in simple types.
ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *root)
Set current node's source position as transformation generated.
ROSE_DLL_API SgExprStatement * buildExprStatement(SgExpression *exp=NULL)
Build a SgExprStatement, set File_Info automatically.
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal_nfi(unsigned int v, const std::string &str)
SgExprStatement * buildExprStatement_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal(int template_parameter_position=-1)
Build an template parameter value expression.
ROSE_DLL_API SgCommonBlockObject * buildCommonBlockObject(std::string name="", SgExprListExp *exp_list=NULL)
Build a Fortran common block, possibly with a name.
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.
ROSE_DLL_API SgTypeLongLong * buildLongLongType()
Built in simple types.
ROSE_DLL_API SgWhenStmt * buildWhenStmt(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeShort * buildShortType()
Built in simple types.
ROSE_DLL_API SgTypeSignedInt * buildSignedIntType()
Built in simple types.
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.).
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt(SgStatement *body=NULL)
Build a default option statement.
ROSE_DLL_API SgJavaThrowStatement * buildJavaThrowStatement(SgThrowOp *)
Build a Java Throw statement.
ROSE_DLL_API SgExprStatement * buildAssignStatement(SgExpression *lhs, SgExpression *rhs)
Build an assignment statement from lefthand operand and right hand operand.
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...
ROSE_DLL_API SgComplexVal * buildComplexVal(SgValueExp *real_value, SgValueExp *imaginary_value)
This class represents the concept of try statement within the try-catch support for exception handlin...
SgWithStatement * buildWithStatement_nfi(SgExpression *expr, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
Build an braced initializer.
This class represents the concept of a C Assembler statement.
SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string &name, SgScopeStatement *scope=NULL)
Build pragma declaration, handle SgPragma and defining/nondefining pointers internally.
ROSE_DLL_API SgCharVal * buildCharVal_nfi(char value, const std::string &str)
ROSE_DLL_API SgClassExp * buildClassExp_nfi(SgClassSymbol *sym)
SgCudaKernelCallExp * buildCudaKernelCallExp_nfi(SgExpression *kernel, SgExprListExp *parameters=NULL, SgCudaKernelExecConfig *config=NULL)
Build a CUDA kernel call expression (kernel<<>>(parameters))
ROSE_DLL_API SgJavaSynchronizedStatement * buildJavaSynchronizedStatement(SgExpression *, SgBasicBlock *)
Build a Java Synchronized statement.
ROSE_DLL_API SgTypeNullptr * buildNullptrType()
Built in simple types.
Specify as source position to be filled in as part of AST construction in the front-end.
Definition: sageBuilder.h:146
This class represents a source project, with a list of SgFile objects and global information about th...
SgDoWhileStmt * buildDoWhileStmt_nfi(SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeUnsigned128bitInteger * buildUnsigned128bitIntegerType()
Built in simple types.
ROSE_DLL_API SgUpcThreads * buildUpcThreads()
Build UPC THREADS (integer expression)
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.
This class represents the concept of a 'global' stmt in Python.
ROSE_DLL_API SgModifierType * buildUpcBlockStarType(SgType *base_type=NULL)
Build a UPC shared[*] type.
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.
ROSE_DLL_API SgJavaInstanceOfOp * buildJavaInstanceOfOp(SgExpression *exp=NULL, SgType *type=NULL)
This is part of Java specific operator support.
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
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...
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...
ROSE_DLL_API SgScopeStatement * buildScopeStatement(SgClassDefinition *=NULL)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol *varSymbol)
ROSE_DLL_API SgModifierType * buildUpcRelaxedType(SgType *base_type=NULL)
Build a UPC relaxed type.
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal_nfi(long double value, const std::string &str)
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
ROSE_DLL_API void testTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgDeleteExp * buildDeleteExp(SgExpression *variable, short is_array, short need_global_specifier, SgFunctionDeclaration *deleteOperatorDeclaration)
ROSE_DLL_API SgClassDeclaration * buildDefiningClassDeclaration(SgName name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUpcFenceStatement * buildUpcFenceStatement_nfi()
Build a UPC fence statement.
This class represents a C99 complex type.
SgDictionaryExp * buildDictionaryExp_nfi(std::vector< SgKeyDatumPair * > pairs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgMicrosoftAttributeDeclaration * buildMicrosoftAttributeDeclaration(const SgName &name)
DQ (8/17/2014): Adding support for Microsoft MSVC specific attributes.
ROSE_DLL_API SgTypeFloat * buildFloatType()
Built in simple types.
ROSE_DLL_API SourcePositionClassification getSourcePositionClassificationMode()
Get the current source position classification (defines how IR nodes built by the SageBuilder interfa...
This class represents the concept of a C or C++ variable declaration.
cv_modifier_enum
Const Volatile Modifier.
ROSE_DLL_API SgVoidVal * buildVoidVal()
DQ (2/14/2019): Adding support for C++14 void value expressions.
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...
This class represents the notion of an initializer for a variable declaration or expression in a func...
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.
SgConditionalExp * buildConditionalExp_nfi(SgExpression *test, SgExpression *a, SgExpression *b, SgType *t)
SgExecStatement * buildExecStatement_nfi(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build a variable declaration, handle symbol table transparently.
bool symbol_table_case_insensitive_semantics
Support for construction of case sensitive/insensitive symbol table handling in scopes.
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongValHex(unsigned long v=0)
SgLabelStatement * buildLabelStatement_nfi(const SgName &name, SgStatement *stmt, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNonrealRefExp * buildNonrealRefExp_nfi(SgNonrealSymbol *sym)
Build a reference to the non-real declaration of a member of a non-real class.
ROSE_DLL_API SgTypeSigned128bitInteger * buildSigned128bitIntegerType()
Built in simple types.
This class represents the concept of a C or C++ label statement.
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal_nfi(unsigned short v, const std::string &str)
ROSE_DLL_API SgModifierType * buildAliasedType(SgType *base_type=NULL)
Build an aliased type for Ada.
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUpcMythread * buildUpcMythread()
Build UPC MYTHREAD (integer expression)
ROSE_DLL_API SgCharVal * buildCharVal(char value=0)
ROSE_DLL_API SgUsingDirectiveStatement * buildUsingDirectiveStatement(SgNamespaceDeclarationStatement *ns_decl)
Build a using directive statement.
ROSE_DLL_API SgDoubleVal * buildDoubleVal(double value=0.0)
Build a double value expression.
ROSE_DLL_API SgTypeString * buildStringType()
DQ (8/21/2010): We want to move to the new buildStringType( SgExpression*,size_t) function over the o...
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp_nfi(SgExpression *exp)
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. ...
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharValHex(unsigned char v=0)
ROSE_DLL_API SgTypeImaginary * buildImaginaryType(SgType *base_type=NULL)
Build an imaginary type.
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal(unsigned char v=0)
Build an unsigned char.
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal_nfi(int template_parameter_position, const std::string &str)
ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode *subtreeRoot, const std::string &newFileName)
Change the source file associated with the source position information in the AST.
ROSE_DLL_API SgModifierType * buildVolatileType(SgType *base_type=NULL)
Build a volatile type.
This class represents the concept of a C++ function call (which is an expression).
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal(long long value=0)
Build a long long integer value expression.
ROSE_DLL_API SgPassStatement * buildPassStatement()
Build a pass statement.
ROSE_DLL_API SgPythonGlobalStmt * buildPythonGlobalStmt(SgInitializedNamePtrList &names)
Build a python global statement.
ROSE_DLL_API SgVoidVal * buildVoidVal_nfi()
ROSE_DLL_API SgYieldExpression * buildYieldExpression(SgExpression *value)
Build a yield statement.
ROSE_DLL_API SgLongIntVal * buildLongIntValHex(long value=0)
SgYieldExpression * buildYieldExpression_nfi(SgExpression *value)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a declaration statement.
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:1816
This class represents the concept of a switch.
ROSE_DLL_API SgTypeChar * buildCharType()
Built in simple types.
This class represents the concept of a C++ expression built from a class name.
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.
SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
ROSE_DLL_API SgAsmStmt * buildMultibyteNopStatement(int n)
DQ (4/30/2010): Added support for building nop statement using asm statement Building nop statement u...
ROSE_DLL_API SgPythonPrintStmt * buildPythonPrintStmt(SgExpression *dest=NULL, SgExprListExp *values=NULL)
Build a python print statement.
ROSE_DLL_API SgFloatVal * buildFloatVal_nfi(float value=0.0)