ROSE  0.9.10.164
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 "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 
194 ROSE_DLL_API SgTypeString* buildStringType();
195 // SgTypeString* buildStringType( SgExpression* stringLengthExpression, size_t stringLengthLiteral );
196 ROSE_DLL_API SgTypeString* buildStringType( SgExpression* stringLengthExpression );
197 
198 ROSE_DLL_API SgTypeVoid * buildVoidType();
199 ROSE_DLL_API SgTypeWchar* buildWcharType();
200 
201 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
202 ROSE_DLL_API SgTypeChar16* buildChar16Type();
203 ROSE_DLL_API SgTypeChar32* buildChar32Type();
204 
205 ROSE_DLL_API SgTypeSignedChar* buildSignedCharType();
206 ROSE_DLL_API SgTypeSignedInt* buildSignedIntType();
207 ROSE_DLL_API SgTypeSignedLong* buildSignedLongType();
210 
211 #if 1
214 #endif
215 
221 ROSE_DLL_API SgTypeUnknown * buildUnknownType();
222 
226 ROSE_DLL_API SgType* buildFortranImplicitType(SgName name);
227 
229 ROSE_DLL_API SgPointerType* buildPointerType(SgType *base_type = NULL);
230 
232 ROSE_DLL_API SgReferenceType* buildReferenceType(SgType *base_type = NULL);
233 
235 ROSE_DLL_API SgRvalueReferenceType* buildRvalueReferenceType(SgType *base_type);
236 
238 ROSE_DLL_API SgDeclType* buildDeclType(SgExpression *base_expression, SgType* base_type);
239 
241 ROSE_DLL_API SgTypeOfType* buildTypeOfType(SgExpression *base_expression, SgType* base_type);
242 
243 // Liao, entirely phase out this function ! Build a modifier type with no modifiers set
244 //SgModifierType* buildModifierType(SgType *base_type = NULL);
245 
246 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
248 ROSE_DLL_API SgModifierType* buildModifierType(SgType* base_type = NULL);
249 
251 ROSE_DLL_API SgModifierType* buildConstType(SgType* base_type = NULL);
252 
254 ROSE_DLL_API SgModifierType* buildVolatileType(SgType* base_type = NULL);
255 
257 ROSE_DLL_API SgModifierType* buildConstVolatileType(SgType* base_type = NULL);
258 
260 ROSE_DLL_API SgModifierType* buildRestrictType(SgType* base_type);
261 
263 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type=NULL, SgExpression* index=NULL);
264 
265 // RASMUSSEN (1/25/2018)
273 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type, SgExprListExp* dim_info);
274 
275 // DQ (8/27/2010): Added Fortran specific support for types based on kind expressions.
277 ROSE_DLL_API SgModifierType* buildFortranKindType(SgType* base_type, SgExpression* kindExpression );
278 
280 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList=NULL);
281 
283 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterList * argList=NULL);
284 
286 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier, unsigned int ref_qualifiers = 0);
287 
288 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
290 // ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterList* argList = NULL, SgClassDefinition *struct_name = NULL, unsigned int mfunc_specifier = 0);
291 
293 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgType *classType, unsigned int mfunc_specifier, unsigned int ref_qualifiers = 0);
294 
295 // PP (07/14/2016):
309 ROSE_DLL_API
311 buildClassTemplateType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
312 
313 
314 
316 
322 ROSE_DLL_API SgType* buildOpaqueType(std::string const type_name, SgScopeStatement * scope);
323 
324 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
326 ROSE_DLL_API SgModifierType* buildUpcStrictType(SgType *base_type = NULL);
327 
329 ROSE_DLL_API SgModifierType* buildUpcRelaxedType(SgType *base_type = NULL);
330 
332 ROSE_DLL_API SgModifierType* buildUpcSharedType(SgType *base_type = NULL, long layout = -1);
333 // SgModifierType* buildUpcSharedType(SgType *base_type = NULL);
334 
336 ROSE_DLL_API SgModifierType* buildUpcBlockIndefiniteType(SgType *base_type = NULL);
337 
339 ROSE_DLL_API SgModifierType* buildUpcBlockStarType(SgType *base_type = NULL);
340 
342 ROSE_DLL_API SgModifierType* buildUpcBlockNumberType(SgType *base_type, long block_factor);
343 
345 ROSE_DLL_API SgTypeComplex* buildComplexType(SgType *base_type = NULL);
346 
348 ROSE_DLL_API SgTypeImaginary* buildImaginaryType(SgType *base_type = NULL);
349 
352 
354 ROSE_DLL_API SgTypeMatrix* buildMatrixType();
355 
357 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);
358 
360 
361 //--------------------------------------------------------------
363 
375 // JJW (11/19/2008): _nfi versions of functions set file info objects to NULL (used in frontend)
376 
378 
380 ROSE_DLL_API SgNullExpression* buildNullExpression();
383 
385 ROSE_DLL_API SgBoolValExp* buildBoolValExp(int value = 0);
386 ROSE_DLL_API SgBoolValExp* buildBoolValExp(bool value = 0);
387 ROSE_DLL_API SgBoolValExp* buildBoolValExp_nfi(int value);
388 
389 ROSE_DLL_API SgCharVal* buildCharVal(char value = 0);
390 ROSE_DLL_API SgCharVal* buildCharVal_nfi(char value, const std::string& str);
391 
393 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp();
395 
396 ROSE_DLL_API SgWcharVal* buildWcharVal(wchar_t value = 0);
397 ROSE_DLL_API SgWcharVal* buildWcharVal_nfi(wchar_t value, const std::string& str);
398 
399 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
400 ROSE_DLL_API SgChar16Val* buildChar16Val(unsigned short value = 0);
401 ROSE_DLL_API SgChar16Val* buildChar16Val_nfi(unsigned short value, const std::string& str);
402 ROSE_DLL_API SgChar32Val* buildChar32Val(unsigned int value = 0);
403 ROSE_DLL_API SgChar32Val* buildChar32Val_nfi(unsigned int value, const std::string& str);
404 
405 // DQ (3/20/2017): This function has never existed (inputs must be SgValueExp pointers).
406 // ROSE_DLL_API SgComplexVal* buildComplexVal(long double real_value = 0.0, long double imaginary_value = 0.0 );
407 ROSE_DLL_API SgComplexVal* buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value);
408 ROSE_DLL_API SgComplexVal* buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, const std::string& str);
409 ROSE_DLL_API SgComplexVal* buildImaginaryVal(long double imaginary_value);
410 ROSE_DLL_API SgComplexVal* buildImaginaryVal(SgValueExp* imaginary_value);
411 ROSE_DLL_API SgComplexVal* buildImaginaryVal_nfi(SgValueExp* imaginary_value, const std::string& str);
412 
414 ROSE_DLL_API SgDoubleVal* buildDoubleVal(double value = 0.0);
415 ROSE_DLL_API SgDoubleVal* buildDoubleVal_nfi(double value, const std::string& str);
416 
417 ROSE_DLL_API SgFloatVal* buildFloatVal(float value = 0.0);
418 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value, const std::string& str);
419 
421 ROSE_DLL_API SgIntVal* buildIntVal(int value = 0);
422 ROSE_DLL_API SgIntVal* buildIntValHex(int value = 0);
423 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value, const std::string& str);
424 
426 ROSE_DLL_API SgLongIntVal* buildLongIntVal(long value = 0);
427 ROSE_DLL_API SgLongIntVal* buildLongIntValHex(long value = 0);
428 ROSE_DLL_API SgLongIntVal* buildLongIntVal_nfi(long value, const std::string& str);
429 
431 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal(long long value = 0);
432 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
433 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal_nfi(long long value, const std::string& str);
434 // !Build enum val without file info: nfi
435 ROSE_DLL_API SgEnumVal* buildEnumVal_nfi(int value, SgEnumDeclaration* decl, SgName name);
436 // !Build enum val with transformation file info
437 ROSE_DLL_API SgEnumVal* buildEnumVal(int value, SgEnumDeclaration* decl, SgName name);
438 ROSE_DLL_API SgEnumVal* buildEnumVal(SgEnumFieldSymbol * sym);
439 
440 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal(long double value = 0.0);
441 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal_nfi(long double value, const std::string& str);
442 
443 ROSE_DLL_API SgFloat80Val* buildFloat80Val(long double value = 0.0);
444 ROSE_DLL_API SgFloat80Val* buildFloat80Val_nfi(long double value, const std::string& str);
445 
446 ROSE_DLL_API SgFloat128Val* buildFloat128Val(long double value = 0.0);
447 ROSE_DLL_API SgFloat128Val* buildFloat128Val_nfi(long double value, const std::string& str);
448 
449 ROSE_DLL_API SgShortVal* buildShortVal(short value = 0);
450 ROSE_DLL_API SgShortVal* buildShortValHex(short value = 0);
451 ROSE_DLL_API SgShortVal* buildShortVal_nfi(short value, const std::string& str);
452 
453 ROSE_DLL_API SgStringVal* buildStringVal(std::string value="");
454 ROSE_DLL_API SgStringVal* buildStringVal_nfi(std::string value);
455 
457 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);
458 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
459 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal_nfi(unsigned char v, const std::string& str);
460 
462 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);
463 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
464 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal_nfi(unsigned short v, const std::string& str);
465 
467 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);
468 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
469 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal_nfi(unsigned int v, const std::string& str);
470 
472 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);
473 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
474 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal_nfi(unsigned long v, const std::string& str);
475 
477 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);
478 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
479 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string& str);
480 
482 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal(int template_parameter_position = -1);
483 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal_nfi(int template_parameter_position, const std::string& str);
484 
486 ROSE_DLL_API SgTemplateType* buildTemplateType(SgName name="");
487 
491 
493 ROSE_DLL_API SgNonrealDecl * buildNonrealDecl(const SgName & name, SgDeclarationScope * scope, SgDeclarationScope * child_scope = NULL);
494 
497 
499 ROSE_DLL_API SgUpcThreads* buildUpcThreads();
500 ROSE_DLL_API SgUpcThreads* buildUpcThreads_nfi();
501 
503 ROSE_DLL_API SgUpcMythread* buildUpcMythread();
504 ROSE_DLL_API SgUpcMythread* buildUpcMythread_nfi();
505 
507 ROSE_DLL_API SgThisExp* buildThisExp(SgSymbol* sym);
508 ROSE_DLL_API SgThisExp* buildThisExp_nfi(SgSymbol* sym);
509 
511 ROSE_DLL_API SgSuperExp* buildSuperExp(SgClassSymbol* sym);
512 ROSE_DLL_API SgSuperExp* buildSuperExp_nfi(SgClassSymbol* sym);
513 
515 ROSE_DLL_API SgClassExp* buildClassExp(SgClassSymbol* sym);
516 ROSE_DLL_API SgClassExp* buildClassExp_nfi(SgClassSymbol* sym);
517 
519 ROSE_DLL_API SgLambdaRefExp* buildLambdaRefExp(SgType* return_type, SgFunctionParameterList* params, SgScopeStatement* scope);
520 
521 #define BUILD_UNARY_PROTO(suffix) \
522 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* op =NULL); \
523 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* op);
524 
525 BUILD_UNARY_PROTO(AddressOfOp)
526 BUILD_UNARY_PROTO(BitComplementOp)
527 BUILD_UNARY_PROTO(MinusOp)
528 BUILD_UNARY_PROTO(NotOp)
529 BUILD_UNARY_PROTO(PointerDerefExp)
530 BUILD_UNARY_PROTO(UnaryAddOp)
531 BUILD_UNARY_PROTO(MinusMinusOp)
532 BUILD_UNARY_PROTO(PlusPlusOp)
533 BUILD_UNARY_PROTO(RealPartOp)
534 BUILD_UNARY_PROTO(ImagPartOp)
535 BUILD_UNARY_PROTO(ConjugateOp)
536 BUILD_UNARY_PROTO(VarArgStartOneOperandOp)
537 BUILD_UNARY_PROTO(VarArgEndOp)
538 
539 //Matlab transpose op
540 BUILD_UNARY_PROTO(MatrixTransposeOp)
541 
543 ROSE_DLL_API SgCastExp * buildCastExp(SgExpression * operand_i = NULL,
544  SgType * expression_type = NULL,
545  SgCastExp::cast_type_enum cast_type = SgCastExp::e_C_style_cast);
546 ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression * operand_i,
547  SgType * expression_type,
548  SgCastExp::cast_type_enum cast_type);
549 
551 ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression * operand_i, SgType * expression_type);
552 
554 ROSE_DLL_API SgMinusOp *buildMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
555 ROSE_DLL_API SgMinusOp *buildMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
556 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
557 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
558 
560 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
561 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
562 
564 ROSE_DLL_API SgThrowOp* buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind);
565 
566 ROSE_DLL_API SgNewExp * buildNewExp(SgType* type,
567  SgExprListExp* exprListExp,
568  SgConstructorInitializer* constInit,
569  SgExpression* expr,
570  short int val,
571  SgFunctionDeclaration* funcDecl);
572 
573 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression* variable,
574  short is_array,
575  short need_global_specifier,
576  SgFunctionDeclaration* deleteOperatorDeclaration);
577 
579 ROSE_DLL_API SgTypeIdOp* buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type);
580 
581 
582 #undef BUILD_UNARY_PROTO
583 
588 #define BUILD_BINARY_PROTO(suffix) \
589 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* lhs =NULL, SgExpression* rhs =NULL); \
590 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* lhs, SgExpression* rhs);
591 
592 BUILD_BINARY_PROTO(AddOp)
593 BUILD_BINARY_PROTO(AndAssignOp)
594 BUILD_BINARY_PROTO(AndOp)
595 BUILD_BINARY_PROTO(ArrowExp)
596 BUILD_BINARY_PROTO(ArrowStarOp)
597 BUILD_BINARY_PROTO(AssignOp)
598 BUILD_BINARY_PROTO(BitAndOp)
599 BUILD_BINARY_PROTO(BitOrOp)
600 BUILD_BINARY_PROTO(BitXorOp)
601 
602 BUILD_BINARY_PROTO(CommaOpExp)
603 BUILD_BINARY_PROTO(ConcatenationOp)
604 BUILD_BINARY_PROTO(DivAssignOp)
605 BUILD_BINARY_PROTO(DivideOp)
606 BUILD_BINARY_PROTO(DotExp)
607 BUILD_BINARY_PROTO(DotStarOp)
608 BUILD_BINARY_PROTO(EqualityOp)
609 
610 BUILD_BINARY_PROTO(ExponentiationOp)
611 BUILD_BINARY_PROTO(ExponentiationAssignOp)
612 BUILD_BINARY_PROTO(GreaterOrEqualOp)
613 BUILD_BINARY_PROTO(GreaterThanOp)
614 BUILD_BINARY_PROTO(IntegerDivideOp)
615 BUILD_BINARY_PROTO(IntegerDivideAssignOp)
616 BUILD_BINARY_PROTO(IorAssignOp)
617 BUILD_BINARY_PROTO(IsOp)
618 BUILD_BINARY_PROTO(IsNotOp)
619 
620 BUILD_BINARY_PROTO(LessOrEqualOp)
621 BUILD_BINARY_PROTO(LessThanOp)
622 BUILD_BINARY_PROTO(LshiftAssignOp)
623 BUILD_BINARY_PROTO(LshiftOp)
624 
625 BUILD_BINARY_PROTO(MembershipOp)
626 BUILD_BINARY_PROTO(MinusAssignOp)
627 BUILD_BINARY_PROTO(ModAssignOp)
628 BUILD_BINARY_PROTO(ModOp)
629 BUILD_BINARY_PROTO(MultAssignOp)
630 BUILD_BINARY_PROTO(MultiplyOp)
631 
632 BUILD_BINARY_PROTO(NonMembershipOp)
633 BUILD_BINARY_PROTO(NotEqualOp)
634 BUILD_BINARY_PROTO(OrOp)
635 BUILD_BINARY_PROTO(PlusAssignOp)
636 BUILD_BINARY_PROTO(PntrArrRefExp)
637 BUILD_BINARY_PROTO(RshiftAssignOp)
638 BUILD_BINARY_PROTO(JavaUnsignedRshiftAssignOp)
639 
640 BUILD_BINARY_PROTO(RshiftOp)
641 BUILD_BINARY_PROTO(JavaUnsignedRshiftOp)
642 BUILD_BINARY_PROTO(ScopeOp)
643 BUILD_BINARY_PROTO(SubtractOp)
644 BUILD_BINARY_PROTO(XorAssignOp)
645 
646 BUILD_BINARY_PROTO(VarArgCopyOp)
647 BUILD_BINARY_PROTO(VarArgStartOp)
648 
649 BUILD_BINARY_PROTO(PowerOp);
650 BUILD_BINARY_PROTO(ElementwisePowerOp);
651 BUILD_BINARY_PROTO(ElementwiseMultiplyOp);
652 BUILD_BINARY_PROTO(ElementwiseDivideOp);
653 BUILD_BINARY_PROTO(LeftDivideOp);
654 BUILD_BINARY_PROTO(ElementwiseLeftDivideOp);
655 BUILD_BINARY_PROTO(ElementwiseAddOp);
656 BUILD_BINARY_PROTO(ElementwiseSubtractOp);
657 
658 #undef BUILD_BINARY_PROTO
659 
661 ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression* test =NULL, SgExpression* a =NULL, SgExpression* b =NULL);
662 SgConditionalExp * buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
663 
665 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);
666 ROSE_DLL_API SgExprListExp * buildExprListExp(const std::vector<SgExpression*>& exprs);
668 SgExprListExp * buildExprListExp_nfi(const std::vector<SgExpression*>& exprs);
669 
671 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);
672 ROSE_DLL_API SgTupleExp * buildTupleExp(const std::vector<SgExpression*>& exprs);
674 SgTupleExp * buildTupleExp_nfi(const std::vector<SgExpression*>& exprs);
675 
677 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);
678 ROSE_DLL_API SgListExp * buildListExp(const std::vector<SgExpression*>& exprs);
680 SgListExp * buildListExp_nfi(const std::vector<SgExpression*>& exprs);
681 
682 ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
683 SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
684 
685 ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators);
686 SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
687 
688 ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators);
689 SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
690 
693 
695 
699 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName& name, SgScopeStatement* scope=NULL);
700 
702 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const std::string& varName, SgScopeStatement* scope=NULL);
703 
705 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const char* varName, SgScopeStatement* scope=NULL);
706 
708 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableSymbol* varSymbol);
709 ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
710 
712 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableDeclaration* vardecl);
713 
716 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgInitializedName* initname, SgScopeStatement* scope=NULL);
717 
719 
721 ROSE_DLL_API SgVarRefExp* buildOpaqueVarRefExp(const std::string& varName,SgScopeStatement* scope=NULL);
722 
723 // DQ (9/4/2013): Added support for building compound literals (similar to a SgVarRefExp).
727 
729 ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol * s);
730 
732 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name, const SgType* func_type, SgScopeStatement* scope=NULL);
733 
734 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name, const SgType* func_type, SgScopeStatement* scope=NULL);
735 
737 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name,SgScopeStatement* scope=NULL);
738 
739 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name,SgScopeStatement* scope=NULL);
740 
742 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgFunctionDeclaration* func_decl);
743 
746 
748 
749 // #ifdef ROSE_USE_NEW_EDG_INTERFACE
752 // #endif
753 
754 // #ifdef ROSE_USE_NEW_EDG_INTERFACE
757 // #endif
758 
759 SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
760 ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
763 
765 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgFunctionSymbol* sym, SgExprListExp* parameters=NULL);
766 SgFunctionCallExp* buildFunctionCallExp_nfi(SgExpression* f, SgExprListExp* parameters=NULL);
767 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgExpression* f, SgExprListExp* parameters=NULL);
768 
770 ROSE_DLL_API SgFunctionCallExp*
771 buildFunctionCallExp(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
772 
774 buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters);
775 
778  SgExpression * kernel,
779  SgExprListExp* parameters = NULL,
780  SgCudaKernelExecConfig * config = NULL
781 );
782 
785  SgExpression *grid = NULL,
786  SgExpression *blocks = NULL,
787  SgExpression *shared = NULL,
788  SgExpression *stream = NULL
789 );
790 
792 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
793 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
794 
796 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
797 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
798 
800 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
801 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
802 
803 // DQ (!/4/2009): Added support for building SgConstructorInitializer
804 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);
805 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);
806 
808 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
809 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
810 
812 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgExpression* exp = NULL);
813 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgExpression* exp);
814 
816 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgType* type = NULL);
817 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgType* type);
818 
820 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgExpression* exp = NULL);
821 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgExpression* exp);
822 
824 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgType* type = NULL);
825 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgType* type);
826 
828 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp(SgExpression* exp = NULL);
829 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
830 
831 // DQ (7/18/2011): Added support for SgJavaInstanceOfOp
833 ROSE_DLL_API SgJavaInstanceOfOp* buildJavaInstanceOfOp(SgExpression* exp = NULL, SgType* type = NULL);
834 
836 ROSE_DLL_API SgTypeExpression *buildTypeExpression(SgType* type);
837 
838 // DQ (8/11/2014): Added support for C++11 decltype used in new function return syntax.
839 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp(int parameter_number, int parameter_level );
840 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level );
841 
842 
844 ROSE_DLL_API SgLambdaExp* buildLambdaExp (SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
845 ROSE_DLL_API SgLambdaExp* buildLambdaExp_nfi(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
846 
847 #if 0
848 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
849 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
850 #else
851 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
852 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
853 #endif
854 
857 
859 
861 
863  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start);
865 
867  ROSE_DLL_API SgMatrixExp* buildMatrixExp(SgExprListExp *firstRow);
868 
870  ROSE_DLL_API SgMagicColonExp* buildMagicColonExp();
871 
873  ROSE_DLL_API SgMatlabForStatement* buildMatlabForStatement(SgExpression* loop_index, SgExpression* loop_range, SgBasicBlock* loop_body);
875 
876 
877 //--------------------------------------------------------------
879 
883 
887 ROSE_DLL_API SgInitializedName* buildInitializedName(const SgName & name, SgType* type, SgInitializer* init = NULL);
888 ROSE_DLL_API SgInitializedName* buildInitializedName(const std::string &name, SgType* type);
889 ROSE_DLL_API SgInitializedName* buildInitializedName(const char* name, SgType* type);
890 ROSE_DLL_API SgInitializedName* buildInitializedName_nfi(const SgName & name, SgType* type, SgInitializer* init);
891 
893 ROSE_DLL_API SgFunctionParameterTypeList *
895 
897 ROSE_DLL_API SgFunctionParameterTypeList *
899 
901 ROSE_DLL_API SgFunctionParameterTypeList *
902 buildFunctionParameterTypeList(SgType* type0 = NULL, SgType* type1 = NULL,
903  SgType* type2 = NULL, SgType* type3 = NULL,
904  SgType* type4 = NULL, SgType* type5 = NULL,
905  SgType* type6 = NULL, SgType* type7 = NULL);
906 
907 
908 //--------------------------------------------------------------
910 
916 ROSE_DLL_API SgVariableDeclaration*
918 buildVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
919 
920 ROSE_DLL_API SgVariableDeclaration*
921 buildVariableDeclaration(const std::string & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
922 
923 ROSE_DLL_API SgVariableDeclaration*
924 buildVariableDeclaration(const char* name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
925 
926 ROSE_DLL_API SgVariableDeclaration*
927 buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
928 
930 ROSE_DLL_API SgVariableDefinition*
932 
933 
934 // DQ (8/31/2012): Note that this macro can't be used in header files since it can only be set
935 // after sage3.h has been read. The reason is that this is a portability problem when "rose_config.h"
936 // appears in header files of applications using ROSE's header files.
937 // #ifdef ROSE_USE_NEW_EDG_INTERFACE
938 // DQ (12/6/2011): Adding support for template declarations into the AST.
939 // SgTemplateDeclaration*
940 // SgVariableDeclaration* buildTemplateVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
942 // #endif
943 
945 ROSE_DLL_API SgTypedefDeclaration*
946 buildTypedefDeclaration(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
947 
948 ROSE_DLL_API SgTypedefDeclaration*
949 buildTypedefDeclaration_nfi(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
950 
951 ROSE_DLL_API SgTemplateTypedefDeclaration*
952 buildTemplateTypedefDeclaration_nfi(const SgName & name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
953 
954 #if 1
955 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
956 // buildTemplateInstantiationTypedefDeclaration_nfi(SgName name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList templateArgumentList);
957 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
958 // buildTemplateInstantiationTypedefDeclaration_nfi(SgName name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration);
959 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
960 // buildTemplateInstantiationTypedefDeclaration_nfi();
962 buildTemplateInstantiationTypedefDeclaration_nfi(SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList & templateArgumentsList);
963 #endif
964 
966 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);
968 
970 ROSE_DLL_API SgFunctionParameterList*
972 
973 ROSE_DLL_API SgFunctionParameterList*
975 
977 ROSE_DLL_API void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, const SgName & name );
978 
979 // 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.
980 ROSE_DLL_API void setTemplateArgumentParents( SgDeclarationStatement* decl );
981 ROSE_DLL_API void testTemplateArgumentParents( SgDeclarationStatement* decl );
982 ROSE_DLL_API SgTemplateArgumentPtrList* getTemplateArgumentList( SgDeclarationStatement* decl );
983 
985 ROSE_DLL_API void testTemplateParameterParents( SgDeclarationStatement* decl );
986 ROSE_DLL_API void setTemplateParameterParents( SgDeclarationStatement* decl );
987 ROSE_DLL_API SgTemplateParameterPtrList* getTemplateParameterList( SgDeclarationStatement* decl );
988 
990 ROSE_DLL_API void setTemplateArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input );
991 ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input );
992 ROSE_DLL_API void setTemplateParametersInDeclaration ( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input );
993 
995 // 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).
996 ROSE_DLL_API SgFunctionDeclaration*
997 buildNondefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
998 
999 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1000 // We need to decide if the SageBuilder API should include these sorts of functions.
1001 ROSE_DLL_API SgFunctionDeclaration* buildNondefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL);
1002 
1003 // DQ (8/11/2013): Even though template functions can't use partial specialization, they can be specialized,
1004 // however the specialization does not define a template and instead defines a template instantiation, so we
1005 // don't need the SgTemplateArgumentPtrList in this function.
1006 // SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1007 ROSE_DLL_API SgTemplateFunctionDeclaration*
1008 buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
1009 
1010 // DQ (8/11/2013): Note that access to the SgTemplateParameterPtrList should be handled through the first_nondefining_declaration (which is a required parameter).
1011 // DQ (12/1/2011): Adding support for template declarations into the AST.
1012 ROSE_DLL_API SgTemplateFunctionDeclaration*
1013 buildDefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateFunctionDeclaration* first_nondefining_declaration);
1014 
1016 ROSE_DLL_API SgFunctionDeclaration *
1017 buildNondefiningFunctionDeclaration (const SgFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1018 
1020 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1021 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1022 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0, bool buildTemplateInstantiation = false);
1023 ROSE_DLL_API SgMemberFunctionDeclaration*
1024 buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1025 
1026 // DQ (8/12/2013): This function needs to supporte SgTemplateParameterPtrList and SgTemplateArgumentPtrList parameters.
1027 // SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1029 buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList );
1030 
1031 // DQ (12/1/2011): Adding support for template declarations in the AST.
1033 buildDefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration );
1034 
1036 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgFunctionParameterList* paralist, SgScopeStatement* scope=NULL);
1037 
1038 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1040 // SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration);
1041 ROSE_DLL_API SgMemberFunctionDeclaration*
1042 buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration, SgTemplateArgumentPtrList* templateArgumentsList);
1043 
1044 #if 0
1045 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1046 // 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).
1047 // 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).
1049 ROSE_DLL_API SgMemberFunctionDeclaration*
1050 buildDefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgScopeStatement* scope, SgExprListExp* decoratorList = NULL /* , unsigned int functionConstVolatileFlags = 0 */, SgMemberFunctionDeclaration* first_nondefinng_declaration = NULL);
1051 #endif
1052 
1053 #if 0
1054 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1056 // SgMemberFunctionDeclaration*
1057 ROSE_DLL_API SgMemberFunctionDeclaration*
1058 buildNondefiningMemberFunctionDeclaration (const SgMemberFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1059 #endif
1060 
1061 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1062 // We need to decide if the SageBuilder API should include these sorts of functions.
1063 ROSE_DLL_API SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1064 
1065 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1066 // We need to decide if the SageBuilder API should include these sorts of functions.
1067 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1068 
1069 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1071 // SgFunctionDeclaration* buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgFunctionDeclaration* first_nondefinng_declaration);
1072 ROSE_DLL_API SgFunctionDeclaration*
1073 buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation = false, SgFunctionDeclaration* first_nondefinng_declaration = NULL, SgTemplateArgumentPtrList* templateArgumentsList = NULL);
1074 
1075 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1076 // We need to decide if the SageBuilder API should include these sorts of functions.
1077 ROSE_DLL_API SgFunctionDeclaration* buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1078 
1079 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1080 // We need to decide if the SageBuilder API should include these sorts of functions.
1082 
1084 ROSE_DLL_API SgProcedureHeaderStatement*
1086 
1088 ROSE_DLL_API SgExprStatement*
1089 buildFunctionCallStmt(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
1090 
1092 ROSE_DLL_API SgExprStatement*
1093 buildFunctionCallStmt(SgExpression* function, SgExprListExp* parameters=NULL);
1094 
1095 
1097 
1100 ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName& name, SgStatement * stmt = NULL, SgScopeStatement* scope=NULL);
1102 
1104 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement * label=NULL);
1106 
1108 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelSymbol* symbol);
1109 
1110 // DQ (11/22/2017): Added support for computed code goto as defined by GNU C/C++ extension.
1112 SgGotoStatement * buildGotoStatement_nfi(SgExpression* expr);
1113 
1115 ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt( SgExpression * key = NULL,SgStatement *body = NULL);
1116 SgCaseOptionStmt * buildCaseOptionStmt_nfi( SgExpression * key,SgStatement *body);
1117 
1119 ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt( SgStatement *body = NULL);
1121 
1123 ROSE_DLL_API SgExprStatement* buildExprStatement(SgExpression* exp = NULL);
1124 SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
1125 
1126 // DQ (3/27/2015): Added support for SgStatementExpression.
1130 
1132 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement(SgStatement *item_selector = NULL,SgStatement *body = NULL);
1133 inline SgSwitchStatement* buildSwitchStatement(SgExpression *item_selector, SgStatement *body = NULL) {
1134  return buildSwitchStatement(buildExprStatement(item_selector), body);
1135 }
1136 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement_nfi(SgStatement *item_selector,SgStatement *body);
1137 
1139 ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1140 inline SgIfStmt * buildIfStmt(SgExpression* conditional, SgStatement * true_body, SgStatement * false_body) {
1141  return buildIfStmt(buildExprStatement(conditional), true_body, false_body);
1142 }
1143 
1144 ROSE_DLL_API SgIfStmt* buildIfStmt_nfi(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1145 
1146 // Rasmussen (9/3/2018)
1148 ROSE_DLL_API SgFortranDo * buildFortranDo(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);
1149 
1152 ROSE_DLL_API SgForInitStatement* buildForInitStatement(const SgStatementPtrList & statements);
1153 ROSE_DLL_API SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList & statements);
1154 
1155 // DQ (10/12/2012): Added new function for a single statement.
1156 ROSE_DLL_API SgForInitStatement* buildForInitStatement( SgStatement* statement );
1157 
1159 ROSE_DLL_API SgForStatement * buildForStatement(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1160 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1161 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1162 ROSE_DLL_API void buildForStatement_nfi(SgForStatement* result, SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1163 
1164 // DQ (3/26/2018): Adding support for range based for statement.
1165 // ROSE_DLL_API SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(SgVariableDeclaration* initializer, SgExpression* range, SgStatement* body);
1167  SgVariableDeclaration* initializer, SgVariableDeclaration* range,
1168  SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration,
1169  SgExpression* not_equal_expression, SgExpression* increment_expression,
1170  SgStatement* body);
1171 
1172 // 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).
1173 // So we need an builder function that can use the existing SgDoWhileStatement scope already on the stack.
1174 ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt* result, SgStatement * body, SgStatement * condition);
1175 
1177 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1178 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1179 
1180 // DQ (3/3/2013): Added UPC specific build functions.
1182 ROSE_DLL_API SgUpcNotifyStatement* buildUpcNotifyStatement_nfi(SgExpression* exp);
1183 
1185 ROSE_DLL_API SgUpcWaitStatement* buildUpcWaitStatement_nfi(SgExpression* exp);
1186 
1188 ROSE_DLL_API SgUpcBarrierStatement* buildUpcBarrierStatement_nfi(SgExpression* exp);
1189 
1192 
1193 
1195 ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1196 inline SgWhileStmt * buildWhileStmt(SgExpression * condition, SgStatement *body, SgStatement* else_body = NULL) {
1197  return buildWhileStmt(buildExprStatement(condition), body, else_body);
1198 }
1199 SgWhileStmt * buildWhileStmt_nfi(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1200 
1202 ROSE_DLL_API SgWithStatement* buildWithStatement(SgExpression* expr, SgStatement* body);
1203 SgWithStatement* buildWithStatement_nfi(SgExpression* expr, SgStatement* body);
1204 
1206 ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement * body, SgStatement *condition);
1207 inline SgDoWhileStmt * buildDoWhileStmt(SgStatement* body, SgExpression * condition) {
1208  return buildDoWhileStmt(body, buildExprStatement(condition));
1209 }
1211 
1213 ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string & name, SgScopeStatement* scope=NULL);
1214 SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string & name, SgScopeStatement* scope);
1215 
1217 ROSE_DLL_API SgPragma* buildPragma(const std::string & name);
1218 
1220 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);
1221 ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi();
1222 SgBasicBlock * buildBasicBlock_nfi(const std::vector<SgStatement*>&);
1223 
1225 ROSE_DLL_API SgExprStatement*
1226 buildAssignStatement(SgExpression* lhs,SgExpression* rhs);
1227 
1228 // DQ (8/16/2011): Generated a new version of this function to define consistant semantics.
1230 ROSE_DLL_API SgExprStatement* buildAssignStatement_ast_translate(SgExpression* lhs,SgExpression* rhs);
1231 
1233 ROSE_DLL_API SgBreakStmt* buildBreakStmt();
1235 
1237 ROSE_DLL_API SgContinueStmt* buildContinueStmt();
1239 
1241 ROSE_DLL_API SgPassStatement* buildPassStatement();
1243 
1245 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression* test);
1246 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression *test, SgExpression *exceptionArgument);
1247 SgAssertStmt* buildAssertStmt_nfi(SgExpression* test);
1248 
1250 ROSE_DLL_API SgYieldExpression* buildYieldExpression(SgExpression* value);
1251 SgYieldExpression* buildYieldExpression_nfi(SgExpression* value);
1252 
1254 ROSE_DLL_API SgKeyDatumPair* buildKeyDatumPair (SgExpression* key, SgExpression* datum);
1255 SgKeyDatumPair* buildKeyDatumPair_nfi(SgExpression* key, SgExpression* datum);
1256 
1258 ROSE_DLL_API SgDictionaryExp* buildDictionaryExp (std::vector<SgKeyDatumPair*> pairs);
1259 SgDictionaryExp* buildDictionaryExp_nfi(std::vector<SgKeyDatumPair*> pairs);
1260 
1262 ROSE_DLL_API SgActualArgumentExpression* buildActualArgumentExpression(SgName arg_name, SgExpression* arg);
1264 
1266 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1267 SgDeleteExp* buildDeleteExp_nfi(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1268 
1270 // SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL);
1271 ROSE_DLL_API SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1272 
1274 // SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL);
1275 SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1276 
1277 // DQ (11/19/2011): Added more template declaration support.
1280 
1282 // DQ (6/6/2012): Added support to get the template arguments into place before computing the type.
1283 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1284 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation = false);
1285 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1286 
1287 // DQ (8/11/2013): We need to hand in both the SgTemplateParameterPtrList and the SgTemplateArgumentPtrList because class templates can be partially specialized.
1288 // DQ (11/29/2011): Adding template declaration support to the AST.
1289 // SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1290 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1291 
1295 
1297 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration ( SgName name, SgScopeStatement* scope );
1298 
1301 
1303 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1304 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const std::string& name, SgScopeStatement* scope=NULL);
1305 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const char* name, SgScopeStatement* scope=NULL);
1306 
1310 
1312 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1313 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName& name, bool unnamednamespace, SgScopeStatement* scope );
1315 
1317 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp(SgExpression* lhs);
1318 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp_nfi(SgExpression* lhs);
1319 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp(SgExpression* lhs);
1320 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp_nfi(SgExpression* lhs);
1321 
1322 ROSE_DLL_API SgStringConversion* buildStringConversion(SgExpression* exp);
1323 ROSE_DLL_API SgStringConversion* buildStringConversion_nfi(SgExpression* exp);
1324 
1325 // DQ (6/6/2012): Addeding support to include template arguments in the generated type (template argument must be provided as early as possible).
1326 // DQ (1/24/2009): Added this "_nfi" function but refactored buildStructDeclaration to also use it (this needs to be done uniformally).
1327 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation = false);
1328 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation);
1329 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1330 
1331 // DQ (8/11/2013): I think that the specification of both SgTemplateParameterPtrList and SgTemplateArgumentPtrList is redundant with the nonDefiningDecl (which is a required parameter).
1332 // DQ (11/19/2011): Added to support template class declaration using EDG 4.x support (to support the template declarations directly in the AST).
1333 // SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl );
1335  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1336 
1338 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1339 
1341 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope=NULL);
1342 
1344 ROSE_DLL_API SgReturnStmt* buildReturnStmt(SgExpression* expression = NULL);
1345 ROSE_DLL_API SgReturnStmt* buildReturnStmt_nfi(SgExpression* expression);
1346 
1348 ROSE_DLL_API SgNullStatement* buildNullStatement();
1350 
1353 
1355 ROSE_DLL_API SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);
1356 
1358 ROSE_DLL_API SgCommonBlockObject* buildCommonBlockObject(std::string name="", SgExprListExp* exp_list=NULL);
1359 
1361 ROSE_DLL_API SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block=NULL);
1362 
1363 // driscoll6 (6/9/2011): Adding support for try stmts.
1365 ROSE_DLL_API SgCatchOptionStmt* buildCatchOptionStmt(SgVariableDeclaration* condition=NULL, SgStatement* body=NULL);
1366 
1368 ROSE_DLL_API SgAsyncStmt* buildAsyncStmt(SgBasicBlock *body);
1369 
1371 ROSE_DLL_API SgFinishStmt* buildFinishStmt(SgBasicBlock *body);
1372 
1374 ROSE_DLL_API SgAtStmt* buildAtStmt(SgExpression *expression, SgBasicBlock *body);
1375 
1376 // MH (11/12/2014): Added atomic support
1377 ROSE_DLL_API SgAtomicStmt* buildAtomicStmt(SgBasicBlock *body);
1378 
1379 ROSE_DLL_API SgWhenStmt* buildWhenStmt(SgExpression *expression, SgBasicBlock *body);
1380 
1381 // MH (9/16/2014): Added at support
1382 ROSE_DLL_API SgAtExp* buildAtExp(SgExpression *expression, SgBasicBlock *body);
1383 
1384 // MH (11/7/2014): Added finish expression support
1385 ROSE_DLL_API SgFinishExp* buildFinishExp(SgExpression *expression, SgBasicBlock *body);
1386 
1387 ROSE_DLL_API SgHereExp* buildHereExpression();
1388 
1389 ROSE_DLL_API SgDotDotExp* buildDotDotExp();
1390 
1391 
1392 // driscoll6 (6/9/2011): Adding support for try stmts.
1394 ROSE_DLL_API SgTryStmt* buildTryStmt(SgStatement* body,
1395  SgCatchOptionStmt* catch0=NULL,
1396  SgCatchOptionStmt* catch1=NULL,
1397  SgCatchOptionStmt* catch2=NULL,
1398  SgCatchOptionStmt* catch3=NULL,
1399  SgCatchOptionStmt* catch4=NULL);
1400 
1401 // charles4 (9/16/2011): Adding support for try stmts.
1403 //SgTryStmt* buildTryStmt(SgStatement *try_body, SgCatchStatementSeq *catches, SgStatement *finally_body = NULL);
1404 
1405 // charles4 (9/16/2011): Adding support for try stmts.
1407 ROSE_DLL_API SgTryStmt* buildTryStmt(SgBasicBlock *try_body, SgBasicBlock *finally_body = NULL);
1408 
1409 // charles4 (9/16/2011): Adding support for Catch Blocks.
1412 
1413 // charles4 (8/25/2011): Adding support for Java Synchronized stmts.
1416 
1417 // charles4 (8/25/2011): Adding support for Java Throw stmts.
1420 
1421 // charles4 (8/25/2011): Adding support for Java Foreach stmts.
1423 // SgJavaForEachStatement *buildJavaForEachStatement(SgInitializedName * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1424 ROSE_DLL_API SgJavaForEachStatement *buildJavaForEachStatement(SgVariableDeclaration * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1425 
1426 // charles4 (8/25/2011): Adding support for Java Label stmts.
1428 ROSE_DLL_API SgJavaLabelStatement *buildJavaLabelStatement(const SgName &, SgStatement * = NULL);
1429 
1431 ROSE_DLL_API SgExecStatement* buildExecStatement(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1432 SgExecStatement* buildExecStatement_nfi(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1433 
1435 ROSE_DLL_API SgPythonPrintStmt* buildPythonPrintStmt(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1436 SgPythonPrintStmt* buildPythonPrintStmt_nfi(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1437 
1439 ROSE_DLL_API SgPythonGlobalStmt* buildPythonGlobalStmt(SgInitializedNamePtrList& names);
1440 SgPythonGlobalStmt* buildPythonGlobalStmt_nfi(SgInitializedNamePtrList& names);
1441 
1442 // DQ (4/30/2010): Added support for building asm statements.
1444 ROSE_DLL_API SgAsmStmt* buildAsmStatement(std::string s);
1445 SgAsmStmt* buildAsmStatement_nfi(std::string s);
1446 
1449 ROSE_DLL_API SgAsmStmt* buildMultibyteNopStatement( int n );
1450 
1452 ROSE_DLL_API SgBaseClass* buildBaseClass ( SgClassDeclaration* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1453 
1454 ROSE_DLL_API SgNonrealBaseClass* buildNonrealBaseClass ( SgNonrealDecl* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1455 
1456 // SgAccessModifier buildAccessModifier ( unsigned int access );
1457 
1459 ROSE_DLL_API SgStaticAssertionDeclaration* buildStaticAssertionDeclaration(SgExpression* condition, const SgName & string_literal);
1460 
1463 
1465 ROSE_DLL_API SgStatement* buildStatementFromString(const std::string & stmt_str, SgScopeStatement* scope);
1466 
1468 
1469 //--------------------------------------------------------------
1471 
1475 
1478 ROSE_DLL_API SgFile* buildFile(const std::string& inputFileName,const std::string& outputFileName, SgProject* project=NULL);
1479 
1481 
1483 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& outputFileName, SgProject* project=NULL);
1484 
1486 
1488 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& inputFileName, const std::string& outputFileName, SgProject* project);
1489 
1491 ROSE_DLL_API PreprocessingInfo* buildComment(SgLocatedNode* target, const std::string & content,
1492  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1493  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
1494 
1497  const std::string & content,
1498  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
1499 
1500 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
1503 #endif
1504 
1505 // 03/17/2014 PHL
1506 // //! Build an equivalence statement from two expression operands
1507 ROSE_DLL_API SgEquivalenceStatement*
1508 buildEquivalenceStatement(SgExpression* lhs,SgExpression* rhs);
1509 
1510 
1512 ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope,
1513  SgStatement *toInsert, SgStatement* original_before_copy);
1514 ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement* insertionPoint, bool insertionPointIsScope,
1515  SgNode* node_copy, SgNode* node_original);
1516 ROSE_DLL_API SgType* getTargetFileTypeSupport(SgType* snippet_type, SgScopeStatement* targetScope);
1517 ROSE_DLL_API SgType* getTargetFileType(SgType* snippet_type, SgScopeStatement* targetScope);
1518 ROSE_DLL_API SgSymbol* findAssociatedSymbolInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1519 
1521 ROSE_DLL_API void errorCheckingTargetAST (SgNode* node_copy, SgNode* node_original, SgFile* targetFile, bool failOnWarning);
1522 
1523 //-----------------------------------------------------------------------------
1524 //#ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1525 //-----------------------------------------------------------------------------
1530 ROSE_DLL_API SgJavaMemberValuePair *buildJavaMemberValuePair(const SgName &, SgExpression *);
1533 ROSE_DLL_API SgJavaNormalAnnotation *buildJavaNormalAnnotation(SgType *, std::list<SgJavaMemberValuePair *>&);
1534 ROSE_DLL_API SgInitializedName *buildJavaFormalParameter(SgType *, const SgName &, bool is_var_args = false, bool is_final = false);
1535 
1536 ROSE_DLL_API SgJavaPackageStatement *buildJavaPackageStatement(std::string);
1537 ROSE_DLL_API SgJavaImportStatement *buildJavaImportStatement(std::string, bool);
1539 ROSE_DLL_API SgSourceFile *buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string);
1540 ROSE_DLL_API SgArrayType *getUniqueJavaArrayType(SgType *, int);
1541 ROSE_DLL_API SgJavaParameterizedType *getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *);
1546 
1548 
1549 
1550 //----------------------------------------------------------
1552 
1565 ROSE_DLL_API SgUntypedScope* buildUntypedScope();
1567 
1571 
1572 ROSE_DLL_API SgUntypedBlockStatement* buildUntypedBlockStatement(std::string label_string, SgUntypedScope* scope=NULL);
1573 
1577 
1579 
1580 
1581 ROSE_DLL_API SgUntypedIfStatement* buildUntypedIfStatement(std::string label, SgUntypedExpression* conditional,
1582  SgUntypedStatement* true_body, SgUntypedStatement* false_body);
1583 
1584 
1586 
1587 
1588 
1589  //----------------------build unary expressions----------------------
1591 
1595 template <class T>
1596  T* buildUnaryExpression(SgExpression* operand) {
1597  SgExpression* myoperand=operand;
1598  T* result = new T(myoperand, NULL);
1599  ROSE_ASSERT(result);
1600  if (myoperand!=NULL) {
1601  myoperand->set_parent(result);
1602  // set lvalue, it asserts operand!=NULL
1603  markLhsValues(result);
1604  }
1606  return result;
1607  }
1608 
1610 
1613 template <class T>
1614 T* buildUnaryExpression_nfi(SgExpression* operand) {
1615  SgExpression* myoperand = operand;
1616  T* result = new T(myoperand, NULL);
1617  ROSE_ASSERT(result);
1618 
1619  if (myoperand != NULL) {
1620  myoperand->set_parent(result);
1621  // set lvalue, it asserts operand!=NULL
1622  markLhsValues(result);
1623  }
1625 
1626  result->set_need_paren(false);
1627  return result;
1628  }
1629 
1630 //---------------------binary expressions-----------------------
1631 
1633 
1636  template <class T>
1637  T* buildBinaryExpression(SgExpression* lhs, SgExpression* rhs) {
1638  SgExpression* mylhs, *myrhs;
1639  mylhs = lhs;
1640  myrhs = rhs;
1641  T* result = new T(mylhs,myrhs, NULL);
1642  ROSE_ASSERT(result);
1643  if (mylhs!=NULL) {
1644  mylhs->set_parent(result);
1645  // set lvalue
1646  markLhsValues(result);
1647  }
1648  if (myrhs!=NULL) myrhs->set_parent(result);
1650  return result;
1651  }
1652 
1654 
1657  template <class T>
1658  T* buildBinaryExpression_nfi(SgExpression* lhs, SgExpression* rhs) {
1659  SgExpression* mylhs, *myrhs;
1660  mylhs = lhs;
1661  myrhs = rhs;
1662  T* result = new T(mylhs,myrhs, NULL);
1663  ROSE_ASSERT(result);
1664  if (mylhs!=NULL) {
1665  mylhs->set_parent(result);
1666  // set lvalue
1667  markLhsValues(result);
1668  }
1669  if (myrhs!=NULL) myrhs->set_parent(result);
1671  result->set_need_paren(false);
1672 
1673  return result;
1674  }
1675 
1676 } // end of namespace
1677 
1678 namespace Rose {
1679  namespace Frontend {
1680  namespace Java {
1681 
1682  extern ROSE_DLL_API SgClassDefinition *javaLangPackageDefinition;
1683  extern ROSE_DLL_API SgClassType *ObjectClassType;
1684  extern ROSE_DLL_API SgClassType *StringClassType;
1685  extern ROSE_DLL_API SgClassType *ClassClassType;
1686  extern ROSE_DLL_API SgVariableSymbol *lengthSymbol;
1687 
1688  }// ::Rose::frontend::java
1689  }// ::Rose::frontend
1690 }// ::Rose
1691 //-----------------------------------------------------------------------------
1692 //#endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1693 //-----------------------------------------------------------------------------
1694 
1695 #endif //ROSE_SAGE_BUILDER_INTERFACE
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 ...
ROSE_DLL_API SgUntypedModuleScope * buildUntypedModuleScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
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.
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 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 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)
ROSE_DLL_API SgUntypedProgramHeaderDeclaration * buildUntypedProgramHeaderDeclaration(std::string name, SgUntypedInitializedNameList *parameters, SgUntypedType *type, SgUntypedFunctionScope *scope, SgUntypedNamedStatement *end_statement)
build a concept of scope in the untyped AST.
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 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.
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 SgLambdaExp * buildLambdaExp_nfi(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
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:1596
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 symbol table internally starting fr...
ROSE_DLL_API SgDotDotExp * buildDotDotExp()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUntypedFunctionDeclaration * buildUntypedFunctionDeclaration(std::string name, SgUntypedInitializedNameList *parameters, SgUntypedType *type, SgUntypedFunctionScope *scope, SgUntypedNamedStatement *end_statement)
build a concept of scope in the untyped AST.
ROSE_DLL_API SgSourceFile * buildSourceFile(const std::string &outputFileName, SgProject *project=NULL)
Build a SgFile node and attach it to SgProject.
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:1579
This class represents the concept of a do-while statement.
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 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.
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 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.
SgNullStatement * buildNullStatement_nfi()
Build a variable declaration, handle symbol table transparently.
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.
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
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 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 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 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 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 SgUntypedGlobalScope * buildUntypedGlobalScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
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 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 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.
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 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.
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 SgUntypedFunctionScope * buildUntypedFunctionScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
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:1614
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 SgNoexceptOp * buildNoexceptOp(SgExpression *exp=NULL)
Build noecept 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.
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 SgUntypedBlockStatement * buildUntypedBlockStatement(std::string label_string, SgUntypedScope *scope=NULL)
build a concept of scope in the untyped AST.
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 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 SgEnumVal * buildEnumVal_nfi(int value, SgEnumDeclaration *decl, SgName name)
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal_nfi(unsigned char v, const std::string &str)
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 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)
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 SgFile * buildFile(const std::string &inputFileName, const std::string &outputFileName, SgProject *project=NULL)
Build a SgFile node and attach it to SgProject.
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:8882
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 SgFloatVal * buildFloatVal_nfi(float value, const std::string &str)
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 SgJavaImportStatement * buildJavaImportStatement(std::string, bool)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUntypedFile * buildUntypedFile(SgUntypedGlobalScope *scope)
build a concept of scope in the untyped AST.
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 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 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.
ROSE_DLL_API SgUntypedIfStatement * buildUntypedIfStatement(std::string label, SgUntypedExpression *conditional, SgUntypedStatement *true_body, SgUntypedStatement *false_body)
build a concept of scope in the untyped AST.
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(), 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(),buildScopeOp(),buildSubtractOp()buildXorAssignOp()
Definition: sageBuilder.h:1637
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.
This class represents the concept of an "if" construct.
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 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 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 SgUntypedSubroutineDeclaration * buildUntypedSubroutineDeclaration(std::string name, SgUntypedInitializedNameList *parameters, SgUntypedType *type, SgUntypedFunctionScope *scope, SgUntypedNamedStatement *end_statement)
build a concept of scope in the untyped AST.
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 SgEnumVal * buildEnumVal(int value, SgEnumDeclaration *decl, SgName name)
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 SgIntVal * buildIntVal_nfi(int value, const std::string &str)
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 SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgDeclType * buildDeclType(SgExpression *base_expression, SgType *base_type)
Build a decltype reference type.
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 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 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.
ROSE_DLL_API SgMemberFunctionType * buildMemberFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier, unsigned int ref_qualifiers=0)
DQ (1/16/2009): Added to support member function in C++ (for new interface)
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 SgUntypedScope * buildUntypedScope()
build a concept of scope in the untyped AST.
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal_nfi(unsigned short v, const std::string &str)
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 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 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 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 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(), 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(),buildScopeOp(),buildSubtractOp()buildXorAssignOp()
Definition: sageBuilder.h:1658
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.
ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a prototype for a function, handle function type, symbol etc transparently. ...
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.