ROSE  0.11.96.11
sageBuilder.h
1 #ifndef ROSE_SAGE_BUILDER_INTERFACE
2 #define ROSE_SAGE_BUILDER_INTERFACE
3 
4 #include <string>
5 
20 #include "sageInterface.h"
21 
22 #include <Rose/Diagnostics.h>
23 
24 // forward declarations required for templated functions using those functions
25 namespace SageInterface {
26  ROSE_DLL_API void setOneSourcePositionForTransformation (SgNode * root);
27  ROSE_DLL_API void setSourcePosition(SgNode* node);
28 }
29 
31 namespace SageBuilder
32 {
33 
34 // DQ (3/24/2016): Adding Robb's meageage mechanism (data member and function).
35  extern Sawyer::Message::Facility mlog;
36  void initDiagnostics();
37 
38 
39 #if 0
40 //---------------------AST creation/building/construction-----------------
41  SgExpression* buildConst(SgType* t, const string & val);
42  SgExpression* buildConstInt(int val);
43 
44  // build sth in languages, but not in SAGE AST
45  // how to specify position info? then
46 
47  SgClassDeclaration* buildClassDeclaration(...,class_type);
48  // or
49  SgClassDeclaration* buildStruct(...);
50  SgClassDeclaration* buildClass(...);
51  SgClassDeclaration* buildUnion(...);
52 
53  // build B from dependent A
54  SgTemplateInstantiationMemberFunctionDecl* buildForwardFunctionDeclaration
55  (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);
56 
57  //previous attempt: src/midend/astUtil/astInterface
58  // AstNodePtr AstInterface::CreateConst( const string& val, const string& valtype) const
59  // AstNodePtr AstInterfaceBase::CreateConstInt( int val)
60 #endif
61 
62 //----------------------------------------------------------
64 
79 extern std::list<SgScopeStatement*> ScopeStack;
80 
81 // DQ (11/30/2010): Added support for building Fortran case insensitive symbol table handling.
83 extern bool symbol_table_case_insensitive_semantics;
84 
86 ROSE_DLL_API void pushScopeStack (SgScopeStatement* stmt);
87 
88 // DQ (3/20/2017): This function is not called (the function above is the more useful one that is used).
89 // ROSE_DLL_API void pushScopeStack (SgNode* node);
90 
91 ROSE_DLL_API void popScopeStack();
92 ROSE_DLL_API SgScopeStatement* topScopeStack();
93 ROSE_DLL_API bool emptyScopeStack();
94 ROSE_DLL_API void clearScopeStack();
95 
96 // DQ (3/11/2012): Added new function to the API for the internal scope stack.
98 SgScopeStatement* getGlobalScopeFromScopeStack();
99 
100 // DQ (3/20/2017): This function is not used.
101 // bool isInScopeStack(SgScopeStatement * scope);
102 
103 bool inSwitchScope();
104 
105 // DQ (3/20/2017): This function is not used.
106 // TV: for debug purpose
107 // std::string stringFromScopeStack();
108 
109 
111 
112 #if 0
113 // DQ (3/20/2017): These functions are not used (suggest using the API in the symbol table initialization).
114 //----------------------------------------------------------
116 
122 ROSE_DLL_API void setCaseInsensitive();
125 ROSE_DLL_API void setCaseSensitive();
127 ROSE_DLL_API void setCaseFromScope(SgScopeStatement* scope);
128 
130 #endif
131 
132 
133 // *************************************************************************************************************
134 // DQ (5/1/2012): This is another possible interface: supporting how we set the source code position and mark is
135 // as either a transformation or as actual code to be assigned a source position as part of the AST construction.
136 // *************************************************************************************************************
137 
138 enum SourcePositionClassification
139  {
140  e_sourcePositionError,
141  e_sourcePositionDefault,
142  e_sourcePositionTransformation,
143  e_sourcePositionCompilerGenerated,
144  e_sourcePositionNullPointers,
145  e_sourcePositionFrontendConstruction,
146  e_sourcePosition_last
147  };
148 
150 extern SourcePositionClassification SourcePositionClassificationMode;
151 
153 ROSE_DLL_API SourcePositionClassification getSourcePositionClassificationMode();
154 
156 ROSE_DLL_API std::string display(SourcePositionClassification & scp);
157 
159 ROSE_DLL_API void setSourcePositionClassificationMode(SourcePositionClassification X);
160 
162 ROSE_DLL_API SgName appendTemplateArgumentsToName( const SgName & name, const SgTemplateArgumentPtrList & templateArgumentsList);
163 
165 SgName unparseTemplateArgumentToString (SgTemplateArgument* templateArgument);
166 
167 // *************************************************************************************************************
168 
169 
170 
171 //--------------------------------------------------------------
173 
179 ROSE_DLL_API SgTypeBool * buildBoolType();
181 ROSE_DLL_API SgTypeNullptr* buildNullptrType();
182 ROSE_DLL_API SgTypeChar * buildCharType();
183 ROSE_DLL_API SgTypeDouble* buildDoubleType();
184 ROSE_DLL_API SgTypeFloat* buildFloatType();
185 ROSE_DLL_API SgTypeInt * buildIntType();
186 ROSE_DLL_API SgTypeLong* buildLongType();
187 ROSE_DLL_API SgTypeLongDouble* buildLongDoubleType();
188 ROSE_DLL_API SgTypeLongLong * buildLongLongType();
189 ROSE_DLL_API SgTypeShort* buildShortType();
190 ROSE_DLL_API SgTypeFloat80* buildFloat80Type();
191 ROSE_DLL_API SgTypeFloat128* buildFloat128Type();
192 
193 // CR (2/20/2020): Added builder for Jovial fixed type
195 ROSE_DLL_API SgTypeFixed* buildFixedType(SgExpression* fraction, SgExpression* scale);
196 
198 ROSE_DLL_API SgTypeString* buildStringType();
199 // SgTypeString* buildStringType( SgExpression* stringLengthExpression, size_t stringLengthLiteral );
200 ROSE_DLL_API SgTypeString* buildStringType( SgExpression* stringLengthExpression );
201 
202 ROSE_DLL_API SgTypeVoid * buildVoidType();
203 ROSE_DLL_API SgTypeWchar* buildWcharType();
204 
205 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
206 ROSE_DLL_API SgTypeChar16* buildChar16Type();
207 ROSE_DLL_API SgTypeChar32* buildChar32Type();
208 
209 ROSE_DLL_API SgTypeSignedChar* buildSignedCharType();
210 ROSE_DLL_API SgTypeSignedInt* buildSignedIntType();
211 ROSE_DLL_API SgTypeSignedLong* buildSignedLongType();
212 ROSE_DLL_API SgTypeSignedLongLong* buildSignedLongLongType();
213 ROSE_DLL_API SgTypeSignedShort* buildSignedShortType();
214 
215 #if 1
216 ROSE_DLL_API SgTypeSigned128bitInteger* buildSigned128bitIntegerType();
217 ROSE_DLL_API SgTypeUnsigned128bitInteger* buildUnsigned128bitIntegerType();
218 #endif
219 
220 ROSE_DLL_API SgTypeUnsignedChar* buildUnsignedCharType();
221 ROSE_DLL_API SgTypeUnsignedInt* buildUnsignedIntType();
222 ROSE_DLL_API SgTypeUnsignedLong* buildUnsignedLongType();
223 ROSE_DLL_API SgTypeUnsignedLongLong* buildUnsignedLongLongType();
224 ROSE_DLL_API SgTypeUnsignedShort* buildUnsignedShortType();
225 ROSE_DLL_API SgTypeUnknown * buildUnknownType();
226 
227 ROSE_DLL_API SgAutoType * buildAutoType();
228 
229 // CR (2/20/2020): Added builder functions for type size (kind) expressions for Fortran and Jovial
231 ROSE_DLL_API SgTypeBool * buildBoolType(SgExpression* kind_expr);
232 ROSE_DLL_API SgTypeInt * buildIntType(SgExpression* kind_expr);
233 ROSE_DLL_API SgTypeFloat * buildFloatType(SgExpression* kind_expr);
234 ROSE_DLL_API SgTypeUnsignedInt* buildUnsignedIntType(SgExpression* kind_expr);
235 
239 ROSE_DLL_API SgType* buildFortranImplicitType(SgName name);
240 
242 ROSE_DLL_API SgPointerType* buildPointerType(SgType *base_type = NULL);
243 
245 ROSE_DLL_API SgReferenceType* buildReferenceType(SgType *base_type = NULL);
246 
248 ROSE_DLL_API SgRvalueReferenceType* buildRvalueReferenceType(SgType *base_type);
249 
251 ROSE_DLL_API SgDeclType* buildDeclType(SgExpression *base_expression, SgType* base_type);
252 
254 ROSE_DLL_API SgTypeOfType* buildTypeOfType(SgExpression *base_expression, SgType* base_type);
255 
256 // Liao, entirely phase out this function ! Build a modifier type with no modifiers set
257 //SgModifierType* buildModifierType(SgType *base_type = NULL);
258 
259 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
261 ROSE_DLL_API SgModifierType* buildModifierType(SgType* base_type = NULL);
262 
264 ROSE_DLL_API SgModifierType* buildConstType(SgType* base_type = NULL);
265 
267 ROSE_DLL_API SgModifierType* buildAliasedType(SgType* base_type = NULL);
268 
270 ROSE_DLL_API SgModifierType* buildVolatileType(SgType* base_type = NULL);
271 
273 ROSE_DLL_API SgModifierType* buildConstVolatileType(SgType* base_type = NULL);
274 
276 ROSE_DLL_API SgModifierType* buildRestrictType(SgType* base_type);
277 
279 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type=NULL, SgExpression* index=NULL);
280 
281 // RASMUSSEN (1/25/2018)
289 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type, SgExprListExp* dim_info);
290 
291 // DQ (8/27/2010): Added Fortran specific support for types based on kind expressions.
293 ROSE_DLL_API SgModifierType* buildFortranKindType(SgType* base_type, SgExpression* kindExpression );
294 
296 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList=NULL);
297 
299 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterList * argList=NULL);
300 
301 // DQ (1/10/2020): removed the default argument since we need to make sure it is used.
303 // ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier, unsigned int ref_qualifiers = 0);
304 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList, SgScopeStatement *struct_name, unsigned int mfunc_specifier, unsigned int ref_qualifiers = 0);
305 
306 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
308 // ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterList* argList = NULL, SgClassDefinition *struct_name = NULL, unsigned int mfunc_specifier = 0);
309 
311 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgType *classType, unsigned int mfunc_specifier, unsigned int ref_qualifiers = 0);
312 
313 // PP (07/14/2016):
327 ROSE_DLL_API
328 SgClassType*
329 buildClassTemplateType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
330 
332 ROSE_DLL_API
333 SgClassType*
334 buildTemplateClassType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
335 
337 
343 ROSE_DLL_API SgType* buildOpaqueType(std::string const type_name, SgScopeStatement * scope);
344 
345 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
347 ROSE_DLL_API SgModifierType* buildUpcStrictType(SgType *base_type = NULL);
348 
350 ROSE_DLL_API SgModifierType* buildUpcRelaxedType(SgType *base_type = NULL);
351 
353 ROSE_DLL_API SgModifierType* buildUpcSharedType(SgType *base_type = NULL, long layout = -1);
354 // SgModifierType* buildUpcSharedType(SgType *base_type = NULL);
355 
357 ROSE_DLL_API SgModifierType* buildUpcBlockIndefiniteType(SgType *base_type = NULL);
358 
360 ROSE_DLL_API SgModifierType* buildUpcBlockStarType(SgType *base_type = NULL);
361 
363 ROSE_DLL_API SgModifierType* buildUpcBlockNumberType(SgType *base_type, long block_factor);
364 
366 ROSE_DLL_API SgTypeComplex* buildComplexType(SgType *base_type = NULL);
367 
369 ROSE_DLL_API SgTypeImaginary* buildImaginaryType(SgType *base_type = NULL);
370 
372 ROSE_DLL_API SgConstVolatileModifier * buildConstVolatileModifier (SgConstVolatileModifier::cv_modifier_enum mtype=SgConstVolatileModifier::e_unknown);
373 
375 ROSE_DLL_API SgTypeMatrix* buildMatrixType();
376 
378 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);
379 
381 ROSE_DLL_API SgNonrealType* buildNonrealType(const SgName & name, SgDeclarationScope* scope);
382 
384 
385 //--------------------------------------------------------------
387 
399 // JJW (11/19/2008): _nfi versions of functions set file info objects to NULL (used in frontend)
400 
401 ROSE_DLL_API SgVariantExpression * buildVariantExpression();
402 
404 ROSE_DLL_API SgNullExpression* buildNullExpression();
406 ROSE_DLL_API SgNullExpression* buildNullExpression_nfi();
407 
409 ROSE_DLL_API SgBoolValExp* buildBoolValExp(int value = 0);
410 ROSE_DLL_API SgBoolValExp* buildBoolValExp(bool value = 0);
411 ROSE_DLL_API SgBoolValExp* buildBoolValExp_nfi(int value);
412 
413 ROSE_DLL_API SgCharVal* buildCharVal(char value = 0);
414 ROSE_DLL_API SgCharVal* buildCharVal_nfi(char value, const std::string& str);
415 
417 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp();
418 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp_nfi();
419 
421 ROSE_DLL_API SgVoidVal* buildVoidVal();
422 ROSE_DLL_API SgVoidVal* buildVoidVal_nfi();
423 
424 ROSE_DLL_API SgWcharVal* buildWcharVal(wchar_t value = 0);
425 ROSE_DLL_API SgWcharVal* buildWcharVal_nfi(wchar_t value, const std::string& str);
426 
427 // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
428 ROSE_DLL_API SgChar16Val* buildChar16Val(unsigned short value = 0);
429 ROSE_DLL_API SgChar16Val* buildChar16Val_nfi(unsigned short value, const std::string& str);
430 ROSE_DLL_API SgChar32Val* buildChar32Val(unsigned int value = 0);
431 ROSE_DLL_API SgChar32Val* buildChar32Val_nfi(unsigned int value, const std::string& str);
432 
433 // DQ (3/20/2017): This function has never existed (inputs must be SgValueExp pointers).
434 // ROSE_DLL_API SgComplexVal* buildComplexVal(long double real_value = 0.0, long double imaginary_value = 0.0 );
435 ROSE_DLL_API SgComplexVal* buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value);
436 ROSE_DLL_API SgComplexVal* buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, const std::string& str);
437 ROSE_DLL_API SgComplexVal* buildImaginaryVal(long double imaginary_value);
438 ROSE_DLL_API SgComplexVal* buildImaginaryVal(SgValueExp* imaginary_value);
439 ROSE_DLL_API SgComplexVal* buildImaginaryVal_nfi(SgValueExp* imaginary_value, const std::string& str);
440 
442 ROSE_DLL_API SgDoubleVal* buildDoubleVal(double value = 0.0);
443 ROSE_DLL_API SgDoubleVal* buildDoubleVal_nfi(double value, const std::string& str);
444 
445 ROSE_DLL_API SgFloatVal* buildFloatVal(float value = 0.0);
446 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value = 0.0);
447 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value, const std::string& str);
449 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(const std::string& str);
450 
452 ROSE_DLL_API SgIntVal* buildIntVal(int value = 0);
453 ROSE_DLL_API SgIntVal* buildIntValHex(int value = 0);
454 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value = 0);
455 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value, const std::string& str);
457 ROSE_DLL_API SgIntVal* buildIntVal_nfi(const std::string& str);
458 
460 ROSE_DLL_API SgLongIntVal* buildLongIntVal(long value = 0);
461 ROSE_DLL_API SgLongIntVal* buildLongIntValHex(long value = 0);
462 ROSE_DLL_API SgLongIntVal* buildLongIntVal_nfi(long value, const std::string& str);
463 
465 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal(long long value = 0);
466 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
467 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal_nfi(long long value, const std::string& str);
468 // !Build enum val without file info: nfi
469 ROSE_DLL_API SgEnumVal* buildEnumVal_nfi(long long int value, SgEnumDeclaration* decl, SgName name);
470 // !Build enum val with transformation file info
471 ROSE_DLL_API SgEnumVal* buildEnumVal(long long int value, SgEnumDeclaration* decl, SgName name);
472 ROSE_DLL_API SgEnumVal* buildEnumVal(SgEnumFieldSymbol * sym);
473 
474 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal(long double value = 0.0);
475 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal_nfi(long double value, const std::string& str);
476 
477 ROSE_DLL_API SgFloat80Val* buildFloat80Val(long double value = 0.0);
478 ROSE_DLL_API SgFloat80Val* buildFloat80Val_nfi(long double value, const std::string& str);
479 
480 ROSE_DLL_API SgFloat128Val* buildFloat128Val(long double value = 0.0);
481 ROSE_DLL_API SgFloat128Val* buildFloat128Val_nfi(long double value, const std::string& str);
482 
483 ROSE_DLL_API SgShortVal* buildShortVal(short value = 0);
484 ROSE_DLL_API SgShortVal* buildShortValHex(short value = 0);
485 ROSE_DLL_API SgShortVal* buildShortVal_nfi(short value, const std::string& str);
486 
487 ROSE_DLL_API SgStringVal* buildStringVal(std::string value="");
488 ROSE_DLL_API SgStringVal* buildStringVal_nfi(std::string value);
489 
491 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);
492 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
493 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal_nfi(unsigned char v, const std::string& str);
494 
496 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);
497 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
498 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal_nfi(unsigned short v, const std::string& str);
499 
501 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);
502 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
503 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal_nfi(unsigned int v, const std::string& str);
504 
506 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);
507 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
508 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal_nfi(unsigned long v, const std::string& str);
509 
511 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);
512 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
513 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string& str);
514 
516 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal(int template_parameter_position = -1);
517 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal_nfi(int template_parameter_position, const std::string& str);
518 
520 ROSE_DLL_API SgTemplateType* buildTemplateType(SgName name="");
521 
524 ROSE_DLL_API SgTemplateParameter * buildTemplateParameter (SgTemplateParameter::template_parameter_enum parameterType, SgType*);
525 
527 ROSE_DLL_API SgNonrealDecl * buildNonrealDecl(const SgName & name, SgDeclarationScope * scope, SgDeclarationScope * child_scope = NULL);
528 
530 ROSE_DLL_API SgNonrealRefExp * buildNonrealRefExp_nfi(SgNonrealSymbol * sym);
531 
533 ROSE_DLL_API SgUpcThreads* buildUpcThreads();
534 ROSE_DLL_API SgUpcThreads* buildUpcThreads_nfi();
535 
537 ROSE_DLL_API SgUpcMythread* buildUpcMythread();
538 ROSE_DLL_API SgUpcMythread* buildUpcMythread_nfi();
539 
541 ROSE_DLL_API SgThisExp* buildThisExp(SgSymbol* sym);
542 ROSE_DLL_API SgThisExp* buildThisExp_nfi(SgSymbol* sym);
543 
545 ROSE_DLL_API SgSuperExp* buildSuperExp(SgClassSymbol* sym);
546 ROSE_DLL_API SgSuperExp* buildSuperExp_nfi(SgClassSymbol* sym);
547 
549 ROSE_DLL_API SgClassExp* buildClassExp(SgClassSymbol* sym);
550 ROSE_DLL_API SgClassExp* buildClassExp_nfi(SgClassSymbol* sym);
551 
553 ROSE_DLL_API SgLambdaRefExp* buildLambdaRefExp(SgType* return_type, SgFunctionParameterList* params, SgScopeStatement* scope);
554 
555 #define BUILD_UNARY_PROTO(suffix) \
556 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* op =NULL); \
557 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* op);
558 
559 BUILD_UNARY_PROTO(AddressOfOp)
560 BUILD_UNARY_PROTO(BitComplementOp)
561 BUILD_UNARY_PROTO(MinusOp)
562 BUILD_UNARY_PROTO(NotOp)
563 BUILD_UNARY_PROTO(PointerDerefExp)
564 BUILD_UNARY_PROTO(UnaryAddOp)
565 BUILD_UNARY_PROTO(MinusMinusOp)
566 BUILD_UNARY_PROTO(PlusPlusOp)
567 BUILD_UNARY_PROTO(RealPartOp)
568 BUILD_UNARY_PROTO(ImagPartOp)
569 BUILD_UNARY_PROTO(ConjugateOp)
570 BUILD_UNARY_PROTO(VarArgStartOneOperandOp)
571 BUILD_UNARY_PROTO(VarArgEndOp)
572 
573 //Matlab transpose op
574 BUILD_UNARY_PROTO(MatrixTransposeOp)
575 
576 ROSE_DLL_API SgCastExp * buildCastExp(SgExpression * operand_i = NULL,
578  SgType * expression_type = NULL,
579  SgCastExp::cast_type_enum cast_type = SgCastExp::e_C_style_cast);
580 ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression * operand_i,
581  SgType * expression_type,
582  SgCastExp::cast_type_enum cast_type);
583 
585 ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression * operand_i, SgType * expression_type);
586 
588 ROSE_DLL_API SgMinusOp *buildMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
589 ROSE_DLL_API SgMinusOp *buildMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
590 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
591 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
592 
594 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
595 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
596 
598 ROSE_DLL_API SgThrowOp* buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind);
599 
600 ROSE_DLL_API SgNewExp * buildNewExp(SgType* type,
601  SgExprListExp* exprListExp,
602  SgConstructorInitializer* constInit,
603  SgExpression* expr,
604  short int val,
605  SgFunctionDeclaration* funcDecl);
606 
607 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression* variable,
608  short is_array,
609  short need_global_specifier,
610  SgFunctionDeclaration* deleteOperatorDeclaration);
611 
613 ROSE_DLL_API SgTypeIdOp* buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type);
614 
615 
616 #undef BUILD_UNARY_PROTO
617 
622 #define BUILD_BINARY_PROTO(suffix) \
623 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* lhs =NULL, SgExpression* rhs =NULL); \
624 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* lhs, SgExpression* rhs);
625 
626 BUILD_BINARY_PROTO(AddOp)
627 BUILD_BINARY_PROTO(AndAssignOp)
628 BUILD_BINARY_PROTO(AndOp)
629 BUILD_BINARY_PROTO(ArrowExp)
630 BUILD_BINARY_PROTO(ArrowStarOp)
631 BUILD_BINARY_PROTO(AssignOp)
632 BUILD_BINARY_PROTO(BitAndOp)
633 BUILD_BINARY_PROTO(BitOrOp)
634 BUILD_BINARY_PROTO(BitXorOp)
635 
636 BUILD_BINARY_PROTO(CommaOpExp)
637 BUILD_BINARY_PROTO(ConcatenationOp)
638 BUILD_BINARY_PROTO(DivAssignOp)
639 BUILD_BINARY_PROTO(DivideOp)
640 BUILD_BINARY_PROTO(DotExp)
641 BUILD_BINARY_PROTO(DotStarOp)
642 BUILD_BINARY_PROTO(EqualityOp)
643 
644 BUILD_BINARY_PROTO(ExponentiationOp)
645 BUILD_BINARY_PROTO(ExponentiationAssignOp)
646 BUILD_BINARY_PROTO(GreaterOrEqualOp)
647 BUILD_BINARY_PROTO(GreaterThanOp)
648 BUILD_BINARY_PROTO(IntegerDivideOp)
649 BUILD_BINARY_PROTO(IntegerDivideAssignOp)
650 BUILD_BINARY_PROTO(IorAssignOp)
651 BUILD_BINARY_PROTO(IsOp)
652 BUILD_BINARY_PROTO(IsNotOp)
653 
654 BUILD_BINARY_PROTO(LessOrEqualOp)
655 BUILD_BINARY_PROTO(LessThanOp)
656 BUILD_BINARY_PROTO(LshiftAssignOp)
657 BUILD_BINARY_PROTO(LshiftOp)
658 
659 BUILD_BINARY_PROTO(MembershipOp)
660 BUILD_BINARY_PROTO(MinusAssignOp)
661 BUILD_BINARY_PROTO(ModAssignOp)
662 BUILD_BINARY_PROTO(ModOp)
663 BUILD_BINARY_PROTO(MultAssignOp)
664 BUILD_BINARY_PROTO(MultiplyOp)
665 
666 BUILD_BINARY_PROTO(NonMembershipOp)
667 BUILD_BINARY_PROTO(NotEqualOp)
668 BUILD_BINARY_PROTO(OrOp)
669 BUILD_BINARY_PROTO(PlusAssignOp)
670 BUILD_BINARY_PROTO(PntrArrRefExp)
671 BUILD_BINARY_PROTO(RshiftAssignOp)
672 
673 BUILD_BINARY_PROTO(RshiftOp)
674 BUILD_BINARY_PROTO(ScopeOp)
675 BUILD_BINARY_PROTO(SubtractOp)
676 BUILD_BINARY_PROTO(XorAssignOp)
677 
678 BUILD_BINARY_PROTO(VarArgCopyOp)
679 BUILD_BINARY_PROTO(VarArgStartOp)
680 
681 BUILD_BINARY_PROTO(PowerOp);
682 BUILD_BINARY_PROTO(ElementwisePowerOp);
683 BUILD_BINARY_PROTO(ElementwiseMultiplyOp);
684 BUILD_BINARY_PROTO(ElementwiseDivideOp);
685 BUILD_BINARY_PROTO(LeftDivideOp);
686 BUILD_BINARY_PROTO(ElementwiseLeftDivideOp);
687 BUILD_BINARY_PROTO(ElementwiseAddOp);
688 BUILD_BINARY_PROTO(ElementwiseSubtractOp);
689 
690 // DQ (7/25/2020): Adding C++20 support
691 BUILD_BINARY_PROTO(SpaceshipOp)
692 
693 #undef BUILD_BINARY_PROTO
694 
696 ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression* test =NULL, SgExpression* a =NULL, SgExpression* b =NULL);
697 SgConditionalExp * buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
698 
700 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);
701 ROSE_DLL_API SgExprListExp * buildExprListExp(const std::vector<SgExpression*>& exprs);
702 SgExprListExp * buildExprListExp_nfi();
703 SgExprListExp * buildExprListExp_nfi(const std::vector<SgExpression*>& exprs);
704 
706 SgSubscriptExpression * buildSubscriptExpression_nfi(SgExpression* lower_bound, SgExpression* upper_bound, SgExpression* stride);
707 
709 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);
710 ROSE_DLL_API SgTupleExp * buildTupleExp(const std::vector<SgExpression*>& exprs);
711 SgTupleExp * buildTupleExp_nfi();
712 SgTupleExp * buildTupleExp_nfi(const std::vector<SgExpression*>& exprs);
713 
715 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);
716 ROSE_DLL_API SgListExp * buildListExp(const std::vector<SgExpression*>& exprs);
717 SgListExp * buildListExp_nfi();
718 SgListExp * buildListExp_nfi(const std::vector<SgExpression*>& exprs);
719 
720 ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
721 SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
722 
723 ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators);
724 SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
725 
726 ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators);
727 SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
728 
729 ROSE_DLL_API SgDictionaryComprehension * buildDictionaryComprehension(SgKeyDatumPair *kd_pair, SgExprListExp *generators);
730 SgDictionaryComprehension * buildDictionaryComprehension_nfi(SgKeyDatumPair *kd_pair, SgExprListExp *generators);
731 
733 
737 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName& name, SgScopeStatement* scope=NULL);
738 
740 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const std::string& varName, SgScopeStatement* scope=NULL);
741 
743 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const char* varName, SgScopeStatement* scope=NULL);
744 
746 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableSymbol* varSymbol);
747 ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
748 
750 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableDeclaration* vardecl);
751 
754 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgInitializedName* initname, SgScopeStatement* scope=NULL);
755 
757 
759 ROSE_DLL_API SgVarRefExp* buildOpaqueVarRefExp(const std::string& varName,SgScopeStatement* scope=NULL);
760 
761 // DQ (9/4/2013): Added support for building compound literals (similar to a SgVarRefExp).
763 SgCompoundLiteralExp* buildCompoundLiteralExp_nfi(SgVariableSymbol* varSymbol);
764 SgCompoundLiteralExp* buildCompoundLiteralExp(SgVariableSymbol* varSymbol);
765 
767 ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol * s);
768 
770 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name, const SgType* func_type, SgScopeStatement* scope=NULL);
771 
772 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name, const SgType* func_type, SgScopeStatement* scope=NULL);
773 
775 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name,SgScopeStatement* scope=NULL);
776 
777 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name,SgScopeStatement* scope=NULL);
778 
780 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgFunctionDeclaration* func_decl);
781 
783 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(SgFunctionSymbol* sym);
784 
785 SgFunctionRefExp * buildFunctionRefExp_nfi(SgFunctionSymbol* sym);
786 
788 SgTemplateFunctionRefExp* buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol* sym);
789 
791 SgTemplateMemberFunctionRefExp* buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
792 
793 SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
794 ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
795 SgClassNameRefExp * buildClassNameRefExp_nfi(SgClassSymbol* sym);
796 ROSE_DLL_API SgClassNameRefExp * buildClassNameRefExp(SgClassSymbol* sym);
797 
799 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgFunctionSymbol* sym, SgExprListExp* parameters=NULL);
800 SgFunctionCallExp* buildFunctionCallExp_nfi(SgExpression* f, SgExprListExp* parameters=NULL);
801 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgExpression* f, SgExprListExp* parameters=NULL);
802 
804 ROSE_DLL_API SgFunctionCallExp*
805 buildFunctionCallExp(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
806 
807 
809 
824 ROSE_DLL_API SgFunctionCallExp*
825 buildMemberFunctionCall (std::string className, SgExpression *objectExpression, std::string functionName, SgExprListExp *params, SgScopeStatement *scope);
826 
828 ROSE_DLL_API SgFunctionCallExp* buildMemberFunctionCall (SgExpression* objectExpression, SgMemberFunctionSymbol* functionSymbol,
829  SgExprListExp* params);
830 
831 SgTypeTraitBuiltinOperator*
832 buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters);
833 
835 SgCudaKernelCallExp * buildCudaKernelCallExp_nfi(
836  SgExpression * kernel,
837  SgExprListExp* parameters = NULL,
838  SgCudaKernelExecConfig * config = NULL
839 );
840 
842 SgCudaKernelExecConfig * buildCudaKernelExecConfig_nfi(
843  SgExpression *grid = NULL,
844  SgExpression *blocks = NULL,
845  SgExpression *shared = NULL,
846  SgExpression *stream = NULL
847 );
848 
850 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
851 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
852 
854 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
855 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
856 
858 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
859 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
860 
861 // DQ (!/4/2009): Added support for building SgConstructorInitializer
862 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);
863 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);
864 
866 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
867 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
868 
870 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgExpression* exp = NULL);
871 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgExpression* exp);
872 
874 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgType* type = NULL);
875 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgType* type);
876 
878 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgExpression* exp = NULL);
879 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgExpression* exp);
880 
882 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgType* type = NULL);
883 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgType* type);
884 
886 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp(SgExpression* exp = NULL);
887 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
888 
890 ROSE_DLL_API SgTypeExpression *buildTypeExpression(SgType* type);
891 
892 // DQ (8/11/2014): Added support for C++11 decltype used in new function return syntax.
893 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp(int parameter_number, int parameter_level );
894 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level );
895 
896 
898 ROSE_DLL_API SgLambdaExp* buildLambdaExp (SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
899 ROSE_DLL_API SgLambdaExp* buildLambdaExp_nfi(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
900 
901 #if 0
902 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
903 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
904 #else
905 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
906 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
907 #endif
908 
909 ROSE_DLL_API SgLambdaCaptureList* buildLambdaCaptureList ();
910 ROSE_DLL_API SgLambdaCaptureList* buildLambdaCaptureList_nfi();
911 
912 // DQ (7/25/2020): Adding C++17 support
913  ROSE_DLL_API SgFoldExpression * buildFoldExpression(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
914 ROSE_DLL_API SgFoldExpression * buildFoldExpression_nfi(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
915 
916 // DQ (7/25/2020): Adding C++20 support
917 ROSE_DLL_API SgAwaitExpression * buildAwaitExpression();
918 ROSE_DLL_API SgAwaitExpression * buildAwaitExpression_nfi();
919 
920 // DQ (7/25/2020): Adding C++20 support
921 ROSE_DLL_API SgChooseExpression * buildChooseExpression();
922 ROSE_DLL_API SgChooseExpression * buildChooseExpression_nfi();
923 
924 
926 
928 
930  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start);
932 
933 
935  ROSE_DLL_API SgMatrixExp* buildMatrixExp(SgExprListExp *firstRow);
936 
938  ROSE_DLL_API SgMagicColonExp* buildMagicColonExp();
939 
941 
943 
946 // ! Build a range expression using start:end:stride for Ada
947  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start, SgExpression *end, SgExpression *stride);
948 
950 //
951 //--------------------------------------------------------------
953 
957 
961 ROSE_DLL_API SgInitializedName* buildInitializedName(const SgName & name, SgType* type, SgInitializer* init = NULL);
962 ROSE_DLL_API SgInitializedName* buildInitializedName(const std::string &name, SgType* type);
963 ROSE_DLL_API SgInitializedName* buildInitializedName(const char* name, SgType* type);
964 ROSE_DLL_API SgInitializedName* buildInitializedName_nfi(const SgName & name, SgType* type, SgInitializer* init);
965 
967 ROSE_DLL_API SgFunctionParameterTypeList *
968 buildFunctionParameterTypeList(SgFunctionParameterList * paralist);
969 
971 ROSE_DLL_API SgFunctionParameterTypeList *
972 buildFunctionParameterTypeList(SgExprListExp * expList);
973 
975 ROSE_DLL_API SgFunctionParameterTypeList *
976 buildFunctionParameterTypeList(SgType* type0 = NULL, SgType* type1 = NULL,
977  SgType* type2 = NULL, SgType* type3 = NULL,
978  SgType* type4 = NULL, SgType* type5 = NULL,
979  SgType* type6 = NULL, SgType* type7 = NULL);
980 
981 
982 //--------------------------------------------------------------
984 
990 ROSE_DLL_API SgVariableDeclaration*
992 buildVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
993 
994 ROSE_DLL_API SgVariableDeclaration*
995 buildVariableDeclaration(const std::string & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
996 
997 ROSE_DLL_API SgVariableDeclaration*
998 buildVariableDeclaration(const char* name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
999 
1000 // DQ (6/25/2019): Added support to force building the varialbe declaration from the variable use (e.g. within a class)
1001 // instead of from a declaration. Variable declaration built from a use are reused when the declaration is seen (later
1002 // in processing of the class members).
1003 // ROSE_DLL_API SgVariableDeclaration*
1004 // buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1005 ROSE_DLL_API SgVariableDeclaration*
1006 buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope, bool builtFromUseOnly = false, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
1007 
1009 ROSE_DLL_API SgVariableDefinition*
1010 buildVariableDefinition_nfi (SgVariableDeclaration* decl, SgInitializedName* init_name, SgInitializer *init);
1011 
1012 
1013 // DQ (8/31/2012): Note that this macro can't be used in header files since it can only be set
1014 // after sage3.h has been read. The reason is that this is a portability problem when "rose_config.h"
1015 // appears in header files of applications using ROSE's header files.
1016 // DQ (12/6/2011): Adding support for template declarations into the AST.
1017 // SgTemplateDeclaration*
1018 ROSE_DLL_API SgTemplateVariableDeclaration* buildTemplateVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1019 
1021 ROSE_DLL_API SgTemplateVariableDeclaration* buildTemplateVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
1022 
1024 ROSE_DLL_API SgTypedefDeclaration*
1025 buildTypedefDeclaration(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1026 
1027 ROSE_DLL_API SgTypedefDeclaration*
1028 buildTypedefDeclaration_nfi(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1029 
1030 ROSE_DLL_API SgTemplateTypedefDeclaration*
1031 buildTemplateTypedefDeclaration_nfi(const SgName & name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
1032 
1033 #if 1
1034 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
1035 // buildTemplateInstantiationTypedefDeclaration_nfi(SgName name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList templateArgumentList);
1036 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
1037 // buildTemplateInstantiationTypedefDeclaration_nfi(SgName name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration);
1038 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
1039 // buildTemplateInstantiationTypedefDeclaration_nfi();
1040 ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
1041 buildTemplateInstantiationTypedefDeclaration_nfi(SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList & templateArgumentsList);
1042 #endif
1043 
1045 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);
1046 SgFunctionParameterList * buildFunctionParameterList_nfi();
1047 
1049 ROSE_DLL_API SgFunctionParameterList*
1050 buildFunctionParameterList(SgFunctionParameterTypeList * paraTypeList);
1051 
1052 ROSE_DLL_API SgFunctionParameterList*
1053 buildFunctionParameterList_nfi(SgFunctionParameterTypeList * paraTypeList);
1054 
1055 SgCtorInitializerList * buildCtorInitializerList_nfi();
1057 ROSE_DLL_API void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, const SgName & name );
1058 
1059 // 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.
1060 ROSE_DLL_API void setTemplateArgumentParents( SgDeclarationStatement* decl );
1061 ROSE_DLL_API void testTemplateArgumentParents( SgDeclarationStatement* decl );
1062 ROSE_DLL_API SgTemplateArgumentPtrList* getTemplateArgumentList( SgDeclarationStatement* decl );
1063 
1065 ROSE_DLL_API void testTemplateParameterParents( SgDeclarationStatement* decl );
1066 ROSE_DLL_API void setTemplateParameterParents( SgDeclarationStatement* decl );
1067 ROSE_DLL_API SgTemplateParameterPtrList* getTemplateParameterList( SgDeclarationStatement* decl );
1068 
1070 ROSE_DLL_API void setTemplateArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input );
1071 ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input );
1072 ROSE_DLL_API void setTemplateParametersInDeclaration ( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input );
1073 
1075 // 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).
1076 ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(
1077  const SgName & name,
1078  SgType * return_type,
1079  SgFunctionParameterList *parlist,
1080  SgScopeStatement* scope = NULL,
1081  SgExprListExp* decoratorList = NULL,
1082  bool buildTemplateInstantiation = false,
1083  SgTemplateArgumentPtrList * templateArgumentsList = NULL,
1084  SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default
1085 );
1086 
1088 ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(
1089  const SgFunctionDeclaration * funcdecl,
1090  SgScopeStatement * scope = NULL,
1091  SgExprListExp * decoratorList = NULL
1092 );
1093 
1094 // DQ (8/11/2013): Even though template functions can't use partial specialization, they can be specialized,
1095 // however the specialization does not define a template and instead defines a template instantiation, so we
1096 // don't need the SgTemplateArgumentPtrList in this function.
1097 // SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1098 ROSE_DLL_API SgTemplateFunctionDeclaration*
1099 buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
1100 
1101 // DQ (8/11/2013): Note that access to the SgTemplateParameterPtrList should be handled through the first_nondefining_declaration (which is a required parameter).
1102 // DQ (12/1/2011): Adding support for template declarations into the AST.
1103 ROSE_DLL_API SgTemplateFunctionDeclaration*
1104 buildDefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateFunctionDeclaration* first_nondefining_declaration);
1105 
1106 // DQ (11/8/2020): Define a function to build a default constructor for a class.
1107 // ROSE_DLL_API SgMemberFunctionDeclaration* buildConstructor ( const SgName & typeName, SgClassType* initializedName_classType, SgClassDefinition* classDefinition);
1108 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefaultConstructor ( SgClassType* classType );
1109 
1111 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
1112 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1113 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0, bool buildTemplateInstantiation = false);
1114 ROSE_DLL_API SgMemberFunctionDeclaration*
1115 buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1116 
1117 // DQ (8/12/2013): This function needs to supporte SgTemplateParameterPtrList and SgTemplateArgumentPtrList parameters.
1118 // SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1119 ROSE_DLL_API SgTemplateMemberFunctionDeclaration*
1120 buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList );
1121 
1122 // DQ (12/1/2011): Adding support for template declarations in the AST.
1123 ROSE_DLL_API SgTemplateMemberFunctionDeclaration*
1124 buildDefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration );
1125 
1127 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgFunctionParameterList* paralist, SgScopeStatement* scope=NULL);
1128 
1129 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1131 // SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration);
1132 ROSE_DLL_API SgMemberFunctionDeclaration*
1133 buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration, SgTemplateArgumentPtrList* templateArgumentsList);
1134 
1135 #if 0
1136 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1137 // 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).
1138 // 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).
1140 ROSE_DLL_API SgMemberFunctionDeclaration*
1141 buildDefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgScopeStatement* scope, SgExprListExp* decoratorList = NULL /* , unsigned int functionConstVolatileFlags = 0 */, SgMemberFunctionDeclaration* first_nondefinng_declaration = NULL);
1142 #endif
1143 
1144 #if 0
1145 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1147 // SgMemberFunctionDeclaration*
1148 ROSE_DLL_API SgMemberFunctionDeclaration*
1149 buildNondefiningMemberFunctionDeclaration (const SgMemberFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1150 #endif
1151 
1152 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1153 // We need to decide if the SageBuilder API should include these sorts of functions.
1154 ROSE_DLL_API SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1155 
1156 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1157 // We need to decide if the SageBuilder API should include these sorts of functions.
1158 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1159 
1160 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1162 // SgFunctionDeclaration* buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgFunctionDeclaration* first_nondefinng_declaration);
1163 ROSE_DLL_API SgFunctionDeclaration*
1164 buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation = false, SgFunctionDeclaration* first_nondefinng_declaration = NULL, SgTemplateArgumentPtrList* templateArgumentsList = NULL);
1165 
1166 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1167 // We need to decide if the SageBuilder API should include these sorts of functions.
1168 ROSE_DLL_API SgFunctionDeclaration* buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1169 
1170 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1171 // We need to decide if the SageBuilder API should include these sorts of functions.
1172 ROSE_DLL_API SgProcedureHeaderStatement* buildProcedureHeaderStatement(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope = NULL);
1173 
1175 ROSE_DLL_API SgProcedureHeaderStatement*
1176 buildProcedureHeaderStatement(const char* name, SgType* return_type, SgFunctionParameterList * parlist, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope, SgProcedureHeaderStatement* first_nondefining_declaration );
1177 
1178 // CR (9/24/2020)
1180 ROSE_DLL_API SgProcedureHeaderStatement*
1181 buildNondefiningProcedureHeaderStatement(const SgName & name, SgType* return_type, SgFunctionParameterList* param_list,
1182  SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope=NULL);
1183 
1185 ROSE_DLL_API SgExprStatement*
1186 buildFunctionCallStmt(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
1187 
1189 ROSE_DLL_API SgExprStatement*
1190 buildFunctionCallStmt(SgExpression* function, SgExprListExp* parameters=NULL);
1191 
1192 
1194 
1197 ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName& name, SgStatement * stmt = NULL, SgScopeStatement* scope=NULL);
1198 SgLabelStatement * buildLabelStatement_nfi(const SgName& name, SgStatement * stmt, SgScopeStatement* scope);
1199 
1201 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement * label=NULL);
1202 SgGotoStatement * buildGotoStatement_nfi(SgLabelStatement * label);
1203 
1205 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelSymbol* symbol);
1206 
1207 // DQ (11/22/2017): Added support for computed code goto as defined by GNU C/C++ extension.
1209 SgGotoStatement * buildGotoStatement_nfi(SgExpression* expr);
1210 
1212 ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt( SgExpression * key = NULL,SgStatement *body = NULL);
1213 SgCaseOptionStmt * buildCaseOptionStmt_nfi( SgExpression * key,SgStatement *body);
1214 
1216 ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt( SgStatement *body = NULL);
1217 SgDefaultOptionStmt * buildDefaultOptionStmt_nfi( SgStatement *body);
1218 
1220 ROSE_DLL_API SgExprStatement* buildExprStatement(SgExpression* exp = NULL);
1221 SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
1222 
1223 // DQ (3/27/2015): Added support for SgStatementExpression.
1225 ROSE_DLL_API SgStatementExpression* buildStatementExpression(SgStatement* exp);
1226 ROSE_DLL_API SgStatementExpression* buildStatementExpression_nfi(SgStatement* exp);
1227 
1229 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement(SgStatement *item_selector = NULL,SgStatement *body = NULL);
1230 inline SgSwitchStatement* buildSwitchStatement(SgExpression *item_selector, SgStatement *body = NULL) {
1231  return buildSwitchStatement(buildExprStatement(item_selector), body);
1232 }
1233 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement_nfi(SgStatement *item_selector,SgStatement *body);
1234 
1236 ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1237 inline SgIfStmt * buildIfStmt(SgExpression* conditional, SgStatement * true_body, SgStatement * false_body) {
1238  return buildIfStmt(buildExprStatement(conditional), true_body, false_body);
1239 }
1240 
1241 ROSE_DLL_API SgIfStmt* buildIfStmt_nfi(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1242 
1243 // CR (9/3/2018)
1245 ROSE_DLL_API SgFortranDo * buildFortranDo(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);
1246 
1248 ROSE_DLL_API SgForInitStatement* buildForInitStatement();
1249 ROSE_DLL_API SgForInitStatement* buildForInitStatement(const SgStatementPtrList & statements);
1250 ROSE_DLL_API SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList & statements);
1251 
1252 // DQ (10/12/2012): Added new function for a single statement.
1253 ROSE_DLL_API SgForInitStatement* buildForInitStatement( SgStatement* statement );
1254 
1256 ROSE_DLL_API SgForStatement * buildForStatement(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1257 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1258 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1259 ROSE_DLL_API void buildForStatement_nfi(SgForStatement* result, SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1260 
1261 // DQ (3/26/2018): Adding support for range based for statement.
1262 // ROSE_DLL_API SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(SgVariableDeclaration* initializer, SgExpression* range, SgStatement* body);
1263 ROSE_DLL_API SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(
1264  SgVariableDeclaration* initializer, SgVariableDeclaration* range,
1265  SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration,
1266  SgExpression* not_equal_expression, SgExpression* increment_expression,
1267  SgStatement* body);
1268 
1269 // 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).
1270 // So we need an builder function that can use the existing SgDoWhileStatement scope already on the stack.
1271 ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt* result, SgStatement * body, SgStatement * condition);
1272 
1274 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1275 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1276 
1277 // DQ (3/3/2013): Added UPC specific build functions.
1279 ROSE_DLL_API SgUpcNotifyStatement* buildUpcNotifyStatement_nfi(SgExpression* exp);
1280 
1282 ROSE_DLL_API SgUpcWaitStatement* buildUpcWaitStatement_nfi(SgExpression* exp);
1283 
1285 ROSE_DLL_API SgUpcBarrierStatement* buildUpcBarrierStatement_nfi(SgExpression* exp);
1286 
1288 ROSE_DLL_API SgUpcFenceStatement* buildUpcFenceStatement_nfi();
1289 
1290 
1292 ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1293 inline SgWhileStmt * buildWhileStmt(SgExpression * condition, SgStatement *body, SgStatement* else_body = NULL) {
1294  return buildWhileStmt(buildExprStatement(condition), body, else_body);
1295 }
1296 SgWhileStmt * buildWhileStmt_nfi(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1297 
1299 ROSE_DLL_API SgWithStatement* buildWithStatement(SgExpression* expr, SgStatement* body);
1300 SgWithStatement* buildWithStatement_nfi(SgExpression* expr, SgStatement* body);
1301 
1303 ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement * body, SgStatement *condition);
1304 inline SgDoWhileStmt * buildDoWhileStmt(SgStatement* body, SgExpression * condition) {
1305  return buildDoWhileStmt(body, buildExprStatement(condition));
1306 }
1307 SgDoWhileStmt * buildDoWhileStmt_nfi(SgStatement * body, SgStatement *condition);
1308 
1310 ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string & name, SgScopeStatement* scope=NULL);
1311 SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string & name, SgScopeStatement* scope);
1312 
1314 ROSE_DLL_API SgPragma* buildPragma(const std::string & name);
1315 
1317 ROSE_DLL_API SgEmptyDeclaration* buildEmptyDeclaration();
1318 
1320 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);
1321 ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi();
1322 SgBasicBlock * buildBasicBlock_nfi(const std::vector<SgStatement*>&);
1323 
1324 // CR (7/24/2020): Added additional functionality
1326 SgBasicBlock * buildBasicBlock_nfi(SgScopeStatement* parent);
1327 
1329 ROSE_DLL_API SgExprStatement*
1330 buildAssignStatement(SgExpression* lhs,SgExpression* rhs);
1331 
1332 // DQ (8/16/2011): Generated a new version of this function to define consistant semantics.
1334 ROSE_DLL_API SgExprStatement* buildAssignStatement_ast_translate(SgExpression* lhs,SgExpression* rhs);
1335 
1337 ROSE_DLL_API SgBreakStmt* buildBreakStmt();
1338 SgBreakStmt* buildBreakStmt_nfi();
1339 
1341 ROSE_DLL_API SgContinueStmt* buildContinueStmt();
1342 SgContinueStmt* buildContinueStmt_nfi();
1343 
1345 ROSE_DLL_API SgPassStatement* buildPassStatement();
1346 SgPassStatement* buildPassStatement_nfi();
1347 
1349 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression* test);
1350 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression *test, SgExpression *exceptionArgument);
1351 SgAssertStmt* buildAssertStmt_nfi(SgExpression* test);
1352 
1354 ROSE_DLL_API SgYieldExpression* buildYieldExpression(SgExpression* value);
1355 SgYieldExpression* buildYieldExpression_nfi(SgExpression* value);
1356 
1358 ROSE_DLL_API SgKeyDatumPair* buildKeyDatumPair (SgExpression* key, SgExpression* datum);
1359 SgKeyDatumPair* buildKeyDatumPair_nfi(SgExpression* key, SgExpression* datum);
1360 
1362 ROSE_DLL_API SgDictionaryExp* buildDictionaryExp (std::vector<SgKeyDatumPair*> pairs);
1363 SgDictionaryExp* buildDictionaryExp_nfi(std::vector<SgKeyDatumPair*> pairs);
1364 
1366 ROSE_DLL_API SgActualArgumentExpression* buildActualArgumentExpression(SgName arg_name, SgExpression* arg);
1367 SgActualArgumentExpression* buildActualArgumentExpression_nfi(SgName arg_name, SgExpression* arg);
1368 
1370 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1371 SgDeleteExp* buildDeleteExp_nfi(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1372 
1374 ROSE_DLL_API SgDeclarationScope * buildDeclarationScope();
1375 
1377 // SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL);
1378 ROSE_DLL_API SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1379 
1381 // SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL);
1382 SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1383 
1384 // DQ (11/19/2011): Added more template declaration support.
1386 SgTemplateClassDefinition* buildTemplateClassDefinition(SgTemplateClassDeclaration *d = NULL );
1387 
1389 // DQ (6/6/2012): Added support to get the template arguments into place before computing the type.
1390 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1391 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation = false);
1392 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1393 
1394 // DQ (8/11/2013): We need to hand in both the SgTemplateParameterPtrList and the SgTemplateArgumentPtrList because class templates can be partially specialized.
1396 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1397 
1399 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1400 
1402 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration ( SgName name, SgScopeStatement* scope );
1403 ROSE_DLL_API SgClassDeclaration* buildDefiningClassDeclaration ( SgName name, SgScopeStatement* scope );
1404 
1406 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration ( SgName name, SgScopeStatement* scope );
1407 
1409 ROSE_DLL_API SgEnumDeclaration* buildNondefiningEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope);
1410 
1412 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1413 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const std::string& name, SgScopeStatement* scope=NULL);
1414 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const char* name, SgScopeStatement* scope=NULL);
1415 
1417 ROSE_DLL_API SgStmtDeclarationStatement* buildStmtDeclarationStatement(SgStatement* stmt);
1418 ROSE_DLL_API SgStmtDeclarationStatement* buildStmtDeclarationStatement_nfi(SgStatement* stmt);
1419 
1421 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1422 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName& name, bool unnamednamespace, SgScopeStatement* scope );
1423 ROSE_DLL_API SgNamespaceDefinitionStatement * buildNamespaceDefinition(SgNamespaceDeclarationStatement* d=NULL);
1424 
1426 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp(SgExpression* lhs);
1427 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp_nfi(SgExpression* lhs);
1428 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp(SgExpression* lhs);
1429 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp_nfi(SgExpression* lhs);
1430 
1431 ROSE_DLL_API SgStringConversion* buildStringConversion(SgExpression* exp);
1432 ROSE_DLL_API SgStringConversion* buildStringConversion_nfi(SgExpression* exp);
1433 
1434 // DQ (6/6/2012): Addeding support to include template arguments in the generated type (template argument must be provided as early as possible).
1435 // DQ (1/24/2009): Added this "_nfi" function but refactored buildStructDeclaration to also use it (this needs to be done uniformally).
1436 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation = false);
1437 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation);
1438 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1439 
1440 // DQ (8/11/2013): I think that the specification of both SgTemplateParameterPtrList and SgTemplateArgumentPtrList is redundant with the nonDefiningDecl (which is a required parameter).
1441 // DQ (11/19/2011): Added to support template class declaration using EDG 4.x support (to support the template declarations directly in the AST).
1442 ROSE_DLL_API SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl,
1443  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1445 ROSE_DLL_API SgTemplateClassDeclaration* buildTemplateClassDeclaration(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl,
1446  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1447 
1450 ROSE_DLL_API SgDerivedTypeStatement * buildDerivedTypeStatement (const SgName& name, SgScopeStatement* scope=NULL);
1451 
1453 ROSE_DLL_API SgModuleStatement * buildModuleStatement(const SgName& name, SgScopeStatement* scope /*=NULL*/);
1454 
1457 template <class DeclClass> ROSE_DLL_API
1458 DeclClass * buildClassDeclarationStatement_nfi(const SgName& name, SgClassDeclaration::class_types kind,
1459  SgScopeStatement* scope=NULL, SgClassDeclaration* nonDefiningDecl=NULL);
1460 
1462 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1463 
1465 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope=NULL);
1466 
1468 ROSE_DLL_API SgReturnStmt* buildReturnStmt(SgExpression* expression = NULL);
1469 ROSE_DLL_API SgReturnStmt* buildReturnStmt_nfi(SgExpression* expression);
1470 
1472 ROSE_DLL_API SgNullStatement* buildNullStatement();
1473 SgNullStatement* buildNullStatement_nfi();
1474 
1476 ROSE_DLL_API SgAttributeSpecificationStatement * buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind);
1477 
1479 ROSE_DLL_API SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);
1480 
1482 ROSE_DLL_API SgCommonBlockObject* buildCommonBlockObject(std::string name="", SgExprListExp* exp_list=NULL);
1483 
1485 ROSE_DLL_API SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block=NULL);
1486 
1487 // driscoll6 (6/9/2011): Adding support for try stmts.
1489 ROSE_DLL_API SgCatchOptionStmt* buildCatchOptionStmt(SgVariableDeclaration* condition=NULL, SgStatement* body=NULL);
1490 
1491 // driscoll6 (6/9/2011): Adding support for try stmts.
1493 ROSE_DLL_API SgTryStmt* buildTryStmt(SgStatement* body,
1494  SgCatchOptionStmt* catch0=NULL,
1495  SgCatchOptionStmt* catch1=NULL,
1496  SgCatchOptionStmt* catch2=NULL,
1497  SgCatchOptionStmt* catch3=NULL,
1498  SgCatchOptionStmt* catch4=NULL);
1499 
1500 // charles4 (9/16/2011): Adding support for try stmts.
1502 //SgTryStmt* buildTryStmt(SgStatement *try_body, SgCatchStatementSeq *catches, SgStatement *finally_body = NULL);
1503 
1504 // charles4 (9/16/2011): Adding support for try stmts.
1506 ROSE_DLL_API SgTryStmt* buildTryStmt(SgBasicBlock *try_body, SgBasicBlock *finally_body = NULL);
1507 
1508 // charles4 (9/16/2011): Adding support for Catch Blocks.
1510 ROSE_DLL_API SgCatchStatementSeq *buildCatchStatementSeq(SgCatchOptionStmt * = NULL);
1511 
1513 ROSE_DLL_API SgExecStatement* buildExecStatement(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1514 SgExecStatement* buildExecStatement_nfi(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1515 
1516 // DQ (4/30/2010): Added support for building asm statements.
1518 ROSE_DLL_API SgAsmStmt* buildAsmStatement(std::string s);
1519 SgAsmStmt* buildAsmStatement_nfi(std::string s);
1520 
1523 ROSE_DLL_API SgAsmStmt* buildMultibyteNopStatement( int n );
1524 
1526 ROSE_DLL_API SgBaseClass* buildBaseClass ( SgClassDeclaration* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1527 
1528 ROSE_DLL_API SgNonrealBaseClass* buildNonrealBaseClass ( SgNonrealDecl* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1529 
1530 // SgAccessModifier buildAccessModifier ( unsigned int access );
1531 
1533 ROSE_DLL_API SgStaticAssertionDeclaration* buildStaticAssertionDeclaration(SgExpression* condition, const SgName & string_literal);
1534 
1536 ROSE_DLL_API SgMicrosoftAttributeDeclaration* buildMicrosoftAttributeDeclaration (const SgName & name);
1537 
1539 ROSE_DLL_API SgStatement* buildStatementFromString(const std::string & stmt_str, SgScopeStatement* scope);
1540 
1542 ROSE_DLL_API SgUsingDirectiveStatement* buildUsingDirectiveStatement(SgNamespaceDeclarationStatement * ns_decl);
1544 
1545 //--------------------------------------------------------------
1547 
1551 
1554 ROSE_DLL_API SgFile* buildFile(const std::string& inputFileName,const std::string& outputFileName, SgProject* project = NULL, bool clear_globalScopeAcrossFiles = false);
1555 
1557 
1559 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& outputFileName, SgProject* project=NULL, bool clear_globalScopeAcrossFiles = false);
1560 
1562 
1564 ROSE_DLL_API SgSourceFile* buildSourceFile(const std::string& inputFileName, const std::string& outputFileName, SgProject* project, bool clear_globalScopeAcrossFiles = false);
1565 
1566 // DQ (11/8/2019): Support function for the new file (to support changing the file names in the source position info objects of each AST subtree node.
1568 // ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, const std::string& newFileName);
1569 ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, const std::string& newFileName);
1570 
1571 // DQ (11/10/2019): Support for sharing IR nodes when buildFile() is applied to an existing file.
1573 ROSE_DLL_API void fixupSharingSourcePosition(SgNode* subtreeRoot, int new_file_id);
1574 
1576 ROSE_DLL_API PreprocessingInfo* buildComment(SgLocatedNode* target, const std::string & content,
1577  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1578  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
1579 
1581 ROSE_DLL_API PreprocessingInfo* buildCpreprocessorDefineDeclaration(SgLocatedNode* target,
1582  const std::string & content,
1583  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
1584 
1586 ROSE_DLL_API PreprocessingInfo* buildHeader(const std::string& header_filename,
1587  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1588  bool isSystemHeader =false);
1589 
1590 
1591 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
1592 ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode* n);
1594 #endif
1595 
1596 // 03/17/2014 PHL
1597 // //! Build an equivalence statement from two expression operands
1598 ROSE_DLL_API SgEquivalenceStatement*
1599 buildEquivalenceStatement(SgExpression* lhs,SgExpression* rhs);
1600 
1601 
1603 ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope,
1604  SgStatement *toInsert, SgStatement* original_before_copy);
1605 ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement* insertionPoint, bool insertionPointIsScope,
1606  SgNode* node_copy, SgNode* node_original);
1607 ROSE_DLL_API SgType* getTargetFileTypeSupport(SgType* snippet_type, SgScopeStatement* targetScope);
1608 ROSE_DLL_API SgType* getTargetFileType(SgType* snippet_type, SgScopeStatement* targetScope);
1609 
1610 // DQ (12/6/2020): This is the original function (modified slightly, but mostly I have defined a new function that
1611 // will not effect the AST snippet support that is used by this function.
1612 ROSE_DLL_API SgSymbol* findAssociatedSymbolInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1613 
1614 // DQ (12/6/2020): This is the new function (modified in API and made suitable for the codeSegregation support).
1615 ROSE_DLL_API SgDeclarationStatement* findAssociatedDeclarationInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1616 
1618 ROSE_DLL_API void errorCheckingTargetAST (SgNode* node_copy, SgNode* node_original, SgFile* targetFile, bool failOnWarning);
1619 
1621 
1622 
1623 //----------------------------------------------------------
1625 
1639 
1640 
1641 
1642  //----------------------build unary expressions----------------------
1644 
1648 template <class T>
1649  T* buildUnaryExpression(SgExpression* operand) {
1650  SgExpression* myoperand=operand;
1651  T* result = new T(myoperand, NULL);
1652  ROSE_ASSERT(result);
1653  if (myoperand!=NULL) {
1654  myoperand->set_parent(result);
1655  // set lvalue, it asserts operand!=NULL
1656  markLhsValues(result);
1657  }
1658  SageInterface::setOneSourcePositionForTransformation(result);
1659  return result;
1660  }
1661 
1663 
1666 template <class T>
1667 T* buildUnaryExpression_nfi(SgExpression* operand) {
1668  SgExpression* myoperand = operand;
1669  T* result = new T(myoperand, NULL);
1670  ROSE_ASSERT(result);
1671 
1672  if (myoperand != NULL) {
1673  myoperand->set_parent(result);
1674  // set lvalue, it asserts operand!=NULL
1675  markLhsValues(result);
1676  }
1677  SageInterface::setSourcePosition(result);
1678 
1679  result->set_need_paren(false);
1680  return result;
1681  }
1682 
1683 //---------------------binary expressions-----------------------
1684 
1686 
1689  template <class T>
1690  T* buildBinaryExpression(SgExpression* lhs, SgExpression* rhs) {
1691  SgExpression* mylhs, *myrhs;
1692  mylhs = lhs;
1693  myrhs = rhs;
1694  T* result = new T(mylhs,myrhs, NULL);
1695  ROSE_ASSERT(result);
1696  if (mylhs!=NULL) {
1697  mylhs->set_parent(result);
1698  // set lvalue
1699  markLhsValues(result);
1700  }
1701  if (myrhs!=NULL) myrhs->set_parent(result);
1702  SageInterface::setOneSourcePositionForTransformation(result);
1703  return result;
1704  }
1705 
1707 
1710  template <class T>
1711  T* buildBinaryExpression_nfi(SgExpression* lhs, SgExpression* rhs) {
1712  SgExpression* mylhs, *myrhs;
1713  mylhs = lhs;
1714  myrhs = rhs;
1715  T* result = new T(mylhs,myrhs, NULL);
1716  ROSE_ASSERT(result);
1717  if (mylhs!=NULL) {
1718  mylhs->set_parent(result);
1719  // set lvalue
1720  markLhsValues(result);
1721  }
1722  if (myrhs!=NULL) myrhs->set_parent(result);
1723  SageInterface::setSourcePosition(result);
1724  result->set_need_paren(false);
1725 
1726  return result;
1727  }
1728 
1729 } // end of namespace
1730 
1731 #endif //ROSE_SAGE_BUILDER_INTERFACE
SgTemplateFunctionDeclaration
Definition: Cxx_Grammar.h:156666
SageBuilder::buildStringConversion_nfi
ROSE_DLL_API SgStringConversion * buildStringConversion_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgTemplateType
Definition: Cxx_Grammar.h:65255
SageBuilder::buildAsmStatement
ROSE_DLL_API SgAsmStmt * buildAsmStatement(std::string s)
Build a NULL statement.
SageBuilder::buildEnumVal
ROSE_DLL_API SgEnumVal * buildEnumVal(long long int value, SgEnumDeclaration *decl, SgName name)
SgCudaKernelExecConfig
Definition: Cxx_Grammar.h:307314
SageBuilder::buildPragmaDeclaration_nfi
SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string &name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SgTypeVoid
Definition: Cxx_Grammar.h:50944
SageBuilder::buildTemplateParameter
ROSE_DLL_API SgTemplateParameter * buildTemplateParameter(SgTemplateParameter::template_parameter_enum parameterType, SgType *)
Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum { parameter_...
SgLocatedNode
This class represents the notion of an expression or statement which has a position within the source...
Definition: Cxx_Grammar.h:74391
SageBuilder::buildUnsignedLongValHex
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongValHex(unsigned long v=0)
SageBuilder::buildIntVal
ROSE_DLL_API SgIntVal * buildIntVal(int value=0)
Build an integer value expression.
SageBuilder::errorCheckingTargetAST
ROSE_DLL_API void errorCheckingTargetAST(SgNode *node_copy, SgNode *node_original, SgFile *targetFile, bool failOnWarning)
Error checking the inserted snippet AST.
SgTemplateTypedefDeclaration
Definition: Cxx_Grammar.h:148453
SgAttributeSpecificationStatement::attribute_spec_enum
attribute_spec_enum
Fortran specific classification of attribute statements (each corresponds to a declaration attribute)...
Definition: Cxx_Grammar.h:142484
SageBuilder::buildSwitchStatement_nfi
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement_nfi(SgStatement *item_selector, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SgBoolValExp
This class represents a boolean value (expression value).
Definition: Cxx_Grammar.h:275163
SgCastExp::e_C_style_cast
@ e_C_style_cast
Definition: Cxx_Grammar.h:234267
SageBuilder::buildKeyDatumPair
ROSE_DLL_API SgKeyDatumPair * buildKeyDatumPair(SgExpression *key, SgExpression *datum)
Build a key-datum pair.
SgClassDeclaration::class_types
class_types
Definition: Cxx_Grammar.h:151332
SageBuilder::buildStructDeclaration
ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build a structure, It is also a declaration statement in SAGE III.
SgTypeFloat128
Definition: Cxx_Grammar.h:72966
SageBuilder::buildForInitStatement
ROSE_DLL_API SgForInitStatement * buildForInitStatement()
Build a for init statement.
SageBuilder::buildCastExp
ROSE_DLL_API SgCastExp * buildCastExp(SgExpression *operand_i=NULL, SgType *expression_type=NULL, SgCastExp::cast_type_enum cast_type=SgCastExp::e_C_style_cast)
Build a type casting expression.
SgTypeWchar
Definition: Cxx_Grammar.h:51886
SageBuilder::buildNondefiningClassDeclaration_nfi
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a structure first nondefining declaration, without file info.
SageBuilder::findAssociatedSymbolInTargetAST
ROSE_DLL_API SgSymbol * findAssociatedSymbolInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildForStatement_nfi
ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgStatement *loop_body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildComprehension
ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
SgCatchStatementSeq
This class represents the concept of a C++ sequence of catch statements.
Definition: Cxx_Grammar.h:179846
SgMemberFunctionType
Definition: Cxx_Grammar.h:62756
SgUpcWaitStatement
Definition: Cxx_Grammar.h:191515
SgStmtDeclarationStatement
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
Definition: Cxx_Grammar.h:170824
SageBuilder::buildModuleStatement
ROSE_DLL_API SgModuleStatement * buildModuleStatement(const SgName &name, SgScopeStatement *scope)
Build a Fortran module declaration.
SageBuilder::fixupCopyOfAstFromSeparateFileInNewTargetAst
ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgStatement *toInsert, SgStatement *original_before_copy)
Fixup any AST moved from one file two another (references to symbols, types, etc.).
SgTypeString
This class represents a string type used for SgStringVal IR node.
Definition: Cxx_Grammar.h:56596
SageBuilder::buildCastExp_nfi
ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression *operand_i, SgType *expression_type, SgCastExp::cast_type_enum cast_type)
SgWcharVal
Definition: Cxx_Grammar.h:277535
SageBuilder::buildUnsignedIntVal_nfi
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal_nfi(unsigned int v, const std::string &str)
SageBuilder::buildTemplateParameterVal
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal(int template_parameter_position=-1)
Build an template parameter value expression.
SgVarArgOp
Definition: Cxx_Grammar.h:298722
SgTemplateParameter::template_parameter_enum
template_parameter_enum
Definition: Cxx_Grammar.h:28970
SageBuilder::setTemplateNameInTemplateInstantiations
ROSE_DLL_API void setTemplateNameInTemplateInstantiations(SgFunctionDeclaration *func, const SgName &name)
DQ (2/11/2012): Added support to set the template name in function template instantiations (member an...
SageBuilder::buildOpaqueType
ROSE_DLL_API SgType * buildOpaqueType(std::string const type_name, SgScopeStatement *scope)
Build an opaque type with a name, useful when a type's details are unknown during transformation,...
SgMinusMinusOp
Definition: Cxx_Grammar.h:232882
SageBuilder::buildComplexVal
ROSE_DLL_API SgComplexVal * buildComplexVal(SgValueExp *real_value, SgValueExp *imaginary_value)
SgTypedefDeclaration
This class represents the notion of a typedef declaration.
Definition: Cxx_Grammar.h:147816
SgStatementExpression
This class represents the GNU extension "statement expression" (thus is non-standard C and C++).
Definition: Cxx_Grammar.h:303843
SgVariableSymbol
This class represents the concept of a variable name within the compiler (a shared container for the ...
Definition: Cxx_Grammar.h:321540
SageBuilder::buildNondefiningTemplateClassDeclaration_nfi
ROSE_DLL_API SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
DQ (11/29/2011): Adding template declaration support to the AST.
SageBuilder::buildModifierType
ROSE_DLL_API SgModifierType * buildModifierType(SgType *base_type=NULL)
Build a modifier type.
SageBuilder::buildDeclType
ROSE_DLL_API SgDeclType * buildDeclType(SgExpression *base_expression, SgType *base_type)
Build a decltype reference type.
SgThrowOp
This class represents the C++ throw expression (handled as a unary operator).
Definition: Cxx_Grammar.h:234820
SageBuilder::buildWithStatement_nfi
SgWithStatement * buildWithStatement_nfi(SgExpression *expr, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildShortType
ROSE_DLL_API SgTypeShort * buildShortType()
Built in simple types.
SageBuilder::buildChar32Val
ROSE_DLL_API SgChar32Val * buildChar32Val(unsigned int value=0)
SgFortranDo
Definition: Cxx_Grammar.h:132466
SageBuilder::SourcePositionClassificationMode
SourcePositionClassification SourcePositionClassificationMode
C++ SageBuilder namespace specific state for storage of the source code position state (used to contr...
SgTemplateFunctionRefExp
Definition: Cxx_Grammar.h:313338
SageBuilder::buildLabelRefExp
ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol *s)
Build a Fortran numeric label ref exp.
SageBuilder::buildLongLongType
ROSE_DLL_API SgTypeLongLong * buildLongLongType()
Built in simple types.
SageBuilder::pushScopeStack
ROSE_DLL_API void pushScopeStack(SgScopeStatement *stmt)
Public interfaces of the scope stack, should be stable.
SgLambdaRefExp
This class represents a lambda expression.
Definition: Cxx_Grammar.h:307795
SgClassNameRefExp
This class represents the concept of a C++ expression built from a class name.
Definition: Cxx_Grammar.h:273213
SageBuilder::buildPlusPlusOp_nfi
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp_nfi(SgExpression *op)
SgTypeIdOp
Definition: Cxx_Grammar.h:291680
SgLongDoubleVal
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:282701
SageBuilder::buildActualArgumentExpression
ROSE_DLL_API SgActualArgumentExpression * buildActualArgumentExpression(SgName arg_name, SgExpression *arg)
Build an Actual Argument Expression.
SgTypeDouble
Definition: Cxx_Grammar.h:52828
SageBuilder::buildFunctionParameterTypeList
ROSE_DLL_API SgFunctionParameterTypeList * buildFunctionParameterTypeList(SgFunctionParameterList *paralist)
Build SgFunctionParameterTypeList from SgFunctionParameterList.
SgNamespaceDeclarationStatement
This class represents the concept of a C++ namespace declaration.
Definition: Cxx_Grammar.h:145393
SageBuilder::buildDefiningTemplateMemberFunctionDeclaration
ROSE_DLL_API SgTemplateMemberFunctionDeclaration * buildDefiningTemplateMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration *first_nondefing_declaration)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildMinusOp_nfi
ROSE_DLL_API SgMinusOp * buildMinusOp_nfi(SgExpression *op)
SgFunctionType
This class represents a type for all functions.
Definition: Cxx_Grammar.h:62210
SageBuilder::buildUpcThreads
ROSE_DLL_API SgUpcThreads * buildUpcThreads()
Build UPC THREADS (integer expression)
SgBaseClass
Definition: Cxx_Grammar.h:27083
SgFloatVal
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:281771
SageBuilder::setSourcePositionClassificationMode
ROSE_DLL_API void setSourcePositionClassificationMode(SourcePositionClassification X)
Set the current source position classification (defines how IR nodes built by the SageBuilder interfa...
SageBuilder::buildChooseExpression
ROSE_DLL_API SgChooseExpression * buildChooseExpression()
SgCaseOptionStmt
This class represents the concept of a C and C++ case option (used within a switch statement).
Definition: Cxx_Grammar.h:174649
SageBuilder::buildMatrixType
ROSE_DLL_API SgTypeMatrix * buildMatrixType()
Build a Matlab Matrix Type.
SageBuilder::buildAssignInitializer_nfi
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
SageBuilder::buildCharVal_nfi
ROSE_DLL_API SgCharVal * buildCharVal_nfi(char value, const std::string &str)
SgChar32Val
Definition: Cxx_Grammar.h:285969
SageBuilder::buildUpcBarrierStatement_nfi
ROSE_DLL_API SgUpcBarrierStatement * buildUpcBarrierStatement_nfi(SgExpression *exp)
Build a UPC barrier statement.
SageBuilder::buildDoWhileStmt_nfi
SgDoWhileStmt * buildDoWhileStmt_nfi(SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsigned128bitIntegerType
ROSE_DLL_API SgTypeUnsigned128bitInteger * buildUnsigned128bitIntegerType()
Built in simple types.
SageBuilder::buildNondefiningTemplateMemberFunctionDeclaration
ROSE_DLL_API SgTemplateMemberFunctionDeclaration * buildNondefiningTemplateMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList *templateParameterList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildSignedLongType
ROSE_DLL_API SgTypeSignedLong * buildSignedLongType()
Built in simple types.
SgIfStmt
This class represents the concept of an "if" construct.
Definition: Cxx_Grammar.h:125431
SgAlignOfOp
Definition: Cxx_Grammar.h:314364
SageBuilder::unparseTemplateArgumentToString
SgName unparseTemplateArgumentToString(SgTemplateArgument *templateArgument)
DQ (3/9/2018): Added to support debugging.
SageBuilder::buildCatchStatementSeq
ROSE_DLL_API SgCatchStatementSeq * buildCatchStatementSeq(SgCatchOptionStmt *=NULL)
Build an initial sequence of Catch blocks containing 0 or 1 element.
SgExecStatement
This class represents the concept of the dynamic execution of a string, file, or code object....
Definition: Cxx_Grammar.h:225373
SgMemberFunctionSymbol
Definition: Cxx_Grammar.h:323344
SageBuilder::buildDictionaryComprehension
ROSE_DLL_API SgDictionaryComprehension * buildDictionaryComprehension(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
SageBuilder::buildChar32Val_nfi
ROSE_DLL_API SgChar32Val * buildChar32Val_nfi(unsigned int value, const std::string &str)
SgEnumVal
Definition: Cxx_Grammar.h:278933
SageBuilder::buildBoolType
ROSE_DLL_API SgTypeBool * buildBoolType()
Built in simple types.
SageBuilder::e_sourcePositionCompilerGenerated
@ e_sourcePositionCompilerGenerated
Classify as a transformation.
Definition: sageBuilder.h:143
SgTypeFloat
Definition: Cxx_Grammar.h:52357
SgTypeUnsignedInt
Definition: Cxx_Grammar.h:49060
SgThrowOp::e_throw_kind
e_throw_kind
Throw IR node can be used in three different ways.
Definition: Cxx_Grammar.h:234833
SageBuilder::buildOpaqueVarRefExp
ROSE_DLL_API SgVarRefExp * buildOpaqueVarRefExp(const std::string &varName, SgScopeStatement *scope=NULL)
Build a variable reference expression at scope to an opaque variable which has unknown information ex...
SgClassDefinition
This class represents the concept of a class definition in C++.
Definition: Cxx_Grammar.h:127505
SgComprehension
Definition: Cxx_Grammar.h:309178
SageBuilder::buildIfStmt
ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build if statement.
SageBuilder::buildNonrealType
ROSE_DLL_API SgNonrealType * buildNonrealType(const SgName &name, SgDeclarationScope *scope)
Build a non real type used for template parameter. Internally a SgNorealDecl is also built.
SgConditionalExp
This class represents the concept of a C trinary conditional expression (e.g. "test ?...
Definition: Cxx_Grammar.h:292209
SageBuilder::buildComment
ROSE_DLL_API PreprocessingInfo * buildComment(SgLocatedNode *target, const std::string &content, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before, PreprocessingInfo::DirectiveType dtype=PreprocessingInfo::CpreprocessorUnknownDeclaration)
Build and attach a comment, comment style is inferred from the language type of the target node if no...
SgDefaultOptionStmt
This class represents the concept of a C or C++ default case within a switch statement.
Definition: Cxx_Grammar.h:175666
SageBuilder::buildMemberFunctionType
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)
SgUpcThreads
Definition: Cxx_Grammar.h:283647
SgProcedureHeaderStatement::subprogram_kind_enum
subprogram_kind_enum
Classification for different types of Fortran subprograms.
Definition: Cxx_Grammar.h:159702
SageBuilder::buildForInitStatement_nfi
ROSE_DLL_API SgForInitStatement * buildForInitStatement_nfi(SgStatementPtrList &statements)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNamespaceDefinition
ROSE_DLL_API SgNamespaceDefinitionStatement * buildNamespaceDefinition(SgNamespaceDeclarationStatement *d=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTemplateClassDefinition
SgTemplateClassDefinition * buildTemplateClassDefinition(SgTemplateClassDeclaration *d=NULL)
Build a template class definition statement.
SgThisExp
This class represents the "this" operator (can be applied to any member data).
Definition: Cxx_Grammar.h:293772
SgDoWhileStmt
This class represents the concept of a do-while statement.
Definition: Cxx_Grammar.h:129505
SageBuilder::buildNamespaceDeclaration_nfi
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName &name, bool unnamednamespace, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildWhileStmt
ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build while statement.
SageBuilder::buildReturnStmt
ROSE_DLL_API SgReturnStmt * buildReturnStmt(SgExpression *expression=NULL)
Build a return statement.
SgCompoundLiteralExp
Definition: Cxx_Grammar.h:316274
SageBuilder::buildIntValHex
ROSE_DLL_API SgIntVal * buildIntValHex(int value=0)
SgTypeUnsignedShort
Definition: Cxx_Grammar.h:47616
SgClassDeclaration
This class represents the concept of a class declaration statement. It includes the concept of an ins...
Definition: Cxx_Grammar.h:151319
SgForStatement
This class represents the concept of a for loop.
Definition: Cxx_Grammar.h:125996
SageBuilder::buildUpcFenceStatement_nfi
ROSE_DLL_API SgUpcFenceStatement * buildUpcFenceStatement_nfi()
Build a UPC fence statement.
SgNonrealSymbol
Definition: Cxx_Grammar.h:322438
SageBuilder::buildFunctionParameterList_nfi
SgFunctionParameterList * buildFunctionParameterList_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNullStatement
ROSE_DLL_API SgNullStatement * buildNullStatement()
Build a NULL statement.
SageBuilder::buildImaginaryVal
ROSE_DLL_API SgComplexVal * buildImaginaryVal(long double imaginary_value)
SageBuilder::buildIntVal_nfi
ROSE_DLL_API SgIntVal * buildIntVal_nfi(int value=0)
SageBuilder::buildExecStatement_nfi
SgExecStatement * buildExecStatement_nfi(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildFunctionType
ROSE_DLL_API SgFunctionType * buildFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList=NULL)
Build function type from return type and parameter type list.
SageBuilder::buildCatchOptionStmt
ROSE_DLL_API SgCatchOptionStmt * buildCatchOptionStmt(SgVariableDeclaration *condition=NULL, SgStatement *body=NULL)
Build a catch statement.
SgVariableDefinition
This class represents the definition (initialization) of a variable.
Definition: Cxx_Grammar.h:139585
SageBuilder::buildUpcSharedType
ROSE_DLL_API SgModifierType * buildUpcSharedType(SgType *base_type=NULL, long layout=-1)
Build a UPC shared type.
SgTemplateMemberFunctionRefExp
Definition: Cxx_Grammar.h:313843
SgCommonBlock
Definition: Cxx_Grammar.h:147363
SageBuilder::setTemplateArgumentParents
ROSE_DLL_API void setTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsignedIntVal
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal(unsigned int v=0)
Build an unsigned integer.
SgVarRefExp
This class represents the variable refernece in expressions.
Definition: Cxx_Grammar.h:272706
SageBuilder::buildImaginaryType
ROSE_DLL_API SgTypeImaginary * buildImaginaryType(SgType *base_type=NULL)
Build an imaginary type.
SageBuilder::buildSigned128bitIntegerType
ROSE_DLL_API SgTypeSigned128bitInteger * buildSigned128bitIntegerType()
Built in simple types.
SgAssignInitializer
This class represents the rhs of a variable declaration which includes an optional assignment (e....
Definition: Cxx_Grammar.h:296780
SgExprListExp
This class represents the concept of a C and C++ expression list.
Definition: Cxx_Grammar.h:270871
SgShortVal
Definition: Cxx_Grammar.h:276140
SgTypeShort
Definition: Cxx_Grammar.h:46674
SageBuilder::buildVoidType
ROSE_DLL_API SgTypeVoid * buildVoidType()
Built in simple types.
SgUnaryOp::Sgop_mode
Sgop_mode
Enum value defines operators as prefix or postfix, as appropriate, e.g. operator++().
Definition: Cxx_Grammar.h:229698
SageBuilder::buildTemplateParameterVal_nfi
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal_nfi(int template_parameter_position, const std::string &str)
SgUnsignedCharVal
Definition: Cxx_Grammar.h:277070
SgFoldExpression
Definition: Cxx_Grammar.h:319631
SageBuilder::buildAttributeSpecificationStatement
ROSE_DLL_API SgAttributeSpecificationStatement * buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind)
Build Fortran attribute specification statement.
SageBuilder::buildMinusMinusOp
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp(SgExpression *op=NULL)
SageBuilder::buildTypeTraitBuiltinOperator
SgTypeTraitBuiltinOperator * buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters)
SgFile
This class represents a source file for a project (which may contian many source files and or directo...
Definition: Cxx_Grammar.h:21163
SgRangeExp
Definition: Cxx_Grammar.h:314877
SageBuilder::buildTypedefDeclaration
ROSE_DLL_API SgTypedefDeclaration * buildTypedefDeclaration(const std::string &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a typedef declaration, such as: typedef int myint; typedef struct A {..} s_A;.
SageBuilder::buildFortranImplicitType
ROSE_DLL_API SgType * buildFortranImplicitType(SgName name)
Build a type based on Fortran's implicit typing rules.
SageBuilder::buildDoubleType
ROSE_DLL_API SgTypeDouble * buildDoubleType()
Built in simple types.
SageBuilder::buildAggregateInitializer_nfi
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
SageBuilder::buildImaginaryVal_nfi
ROSE_DLL_API SgComplexVal * buildImaginaryVal_nfi(SgValueExp *imaginary_value, const std::string &str)
SgUpcNotifyStatement
Definition: Cxx_Grammar.h:191065
SgNonrealType
Definition: Cxx_Grammar.h:60929
SageBuilder::buildUnsignedLongVal_nfi
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal_nfi(unsigned long v, const std::string &str)
SageBuilder::buildUpcStrictType
ROSE_DLL_API SgModifierType * buildUpcStrictType(SgType *base_type=NULL)
Build a UPC strict type.
SageBuilder::e_sourcePositionNullPointers
@ e_sourcePositionNullPointers
Classify as compiler generated code (e.g. template instantiation).
Definition: sageBuilder.h:144
SageBuilder::buildDeleteExp_nfi
SgDeleteExp * buildDeleteExp_nfi(SgExpression *target, bool is_array=false, bool need_global_specifier=false, SgFunctionDeclaration *deleteOperatorDeclaration=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::ScopeStack
std::list< SgScopeStatement * > ScopeStack
intended to be a private member, don't access it directly. could be changed any time
SgTypeChar
Definition: Cxx_Grammar.h:45261
SageBuilder::buildTemplateClassDeclaration_nfi
ROSE_DLL_API SgTemplateClassDeclaration * buildTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateClassDeclaration *nonDefiningDecl, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildLongLongIntValHex
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntValHex(long long value=0)
SageBuilder::buildLambdaExp_nfi
ROSE_DLL_API SgLambdaExp * buildLambdaExp_nfi(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
SgNonrealDecl
Definition: Cxx_Grammar.h:172654
SgRvalueReferenceType
Definition: Cxx_Grammar.h:69133
SgBracedInitializer
Definition: Cxx_Grammar.h:297741
SageBuilder::buildTemplateVariableDeclaration_nfi
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildDerivedTypeStatement
ROSE_DLL_API SgDerivedTypeStatement * buildDerivedTypeStatement(const SgName &name, SgScopeStatement *scope=NULL)
Build an SgDerivedTypeStatement Fortran derived type declaration with a class declaration and definit...
SageBuilder::buildAwaitExpression
ROSE_DLL_API SgAwaitExpression * buildAwaitExpression()
SageBuilder::buildListComprehension_nfi
SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
SageBuilder::buildUnsignedLongType
ROSE_DLL_API SgTypeUnsignedLong * buildUnsignedLongType()
Built in simple types.
SgTemplateClassDeclaration
Definition: Cxx_Grammar.h:151985
SageBuilder::buildFloat128Type
ROSE_DLL_API SgTypeFloat128 * buildFloat128Type()
Built in simple types.
SageBuilder::buildListComprehension
ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators)
SgType
This class represents the base class for all types.
Definition: Cxx_Grammar.h:43961
SgPragma
Definition: Cxx_Grammar.h:18449
SageBuilder::buildLambdaCapture_nfi
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture_nfi(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
SageBuilder::buildPassStatement_nfi
SgPassStatement * buildPassStatement_nfi()
Build a variable declaration, handle symbol table transparently.
SgUnsignedShortVal
Definition: Cxx_Grammar.h:278003
SgFunctionCallExp
This class represents the concept of a C++ function call (which is an expression).
Definition: Cxx_Grammar.h:288304
SageBuilder::buildSetComprehension
ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators)
SageBuilder::clearScopeStack
ROSE_DLL_API void clearScopeStack()
intended to be a private member, don't access it directly. could be changed any time
SageBuilder::buildCharType
ROSE_DLL_API SgTypeChar * buildCharType()
Built in simple types.
SgWhileStmt
This class represents the concept of a do-while statement.
Definition: Cxx_Grammar.h:128984
SageBuilder::buildStringConversion
ROSE_DLL_API SgStringConversion * buildStringConversion(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgNewExp
This class represents the concept of a C++ call to the new operator.
Definition: Cxx_Grammar.h:292707
SgTypeLongDouble
Definition: Cxx_Grammar.h:56125
SageBuilder::buildTypeExpression
ROSE_DLL_API SgTypeExpression * buildTypeExpression(SgType *type)
DQ (7/24/2014): Adding support for c11 generic operands.
SgEnumFieldSymbol
Definition: Cxx_Grammar.h:327411
SageBuilder::buildTemplateVariableDeclaration
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build template variable declarations.
SgMemberFunctionRefExp
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
Definition: Cxx_Grammar.h:274179
SageBuilder::buildKeyDatumPair_nfi
SgKeyDatumPair * buildKeyDatumPair_nfi(SgExpression *key, SgExpression *datum)
Build a variable declaration, handle symbol table transparently.
SgLambdaCaptureList
Definition: Cxx_Grammar.h:122303
SageBuilder::buildBasicBlock
ROSE_DLL_API SgBasicBlock * buildBasicBlock(SgStatement *stmt1=NULL, SgStatement *stmt2=NULL, SgStatement *stmt3=NULL, SgStatement *stmt4=NULL, SgStatement *stmt5=NULL, SgStatement *stmt6=NULL, SgStatement *stmt7=NULL, SgStatement *stmt8=NULL, SgStatement *stmt9=NULL, SgStatement *stmt10=NULL)
Build a SgBasicBlock, setting file info internally.
SageBuilder::buildFunctionParameterList
ROSE_DLL_API SgFunctionParameterList * buildFunctionParameterList(SgInitializedName *in1=NULL, SgInitializedName *in2=NULL, SgInitializedName *in3=NULL, SgInitializedName *in4=NULL, SgInitializedName *in5=NULL, SgInitializedName *in6=NULL, SgInitializedName *in7=NULL, SgInitializedName *in8=NULL, SgInitializedName *in9=NULL, SgInitializedName *in10=NULL)
Build an empty SgFunctionParameterList, possibly with some initialized names filled in.
SgSwitchStatement
This class represents the concept of a switch.
Definition: Cxx_Grammar.h:129987
SageBuilder::buildCudaKernelExecConfig_nfi
SgCudaKernelExecConfig * buildCudaKernelExecConfig_nfi(SgExpression *grid=NULL, SgExpression *blocks=NULL, SgExpression *shared=NULL, SgExpression *stream=NULL)
Build a CUDA kernel execution configuration (<<<grid, blocks, shared, stream>>>)
SageBuilder::buildFloat80Val
ROSE_DLL_API SgFloat80Val * buildFloat80Val(long double value=0.0)
SageBuilder::buildComprehension_nfi
SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
SageBuilder::buildVariantExpression
ROSE_DLL_API SgVariantExpression * buildVariantExpression()
SgContinueStmt
This class represents the concept of a C or C++ continue statement.
Definition: Cxx_Grammar.h:176607
SageBuilder::buildPlusPlusOp
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp(SgExpression *op=NULL)
SageBuilder::buildCaseOptionStmt
ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt(SgExpression *key=NULL, SgStatement *body=NULL)
Build a case option statement.
SageBuilder::buildClassDeclaration_nfi
ROSE_DLL_API SgClassDeclaration * buildClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgClassDeclaration *nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildVarArgOp_nfi
ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression *operand_i, SgType *expression_type)
Build vararg op expression.
SgFunctionRefExp
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
Definition: Cxx_Grammar.h:273663
SageBuilder::setTemplateArgumentsInDeclaration
ROSE_DLL_API void setTemplateArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateArgumentsList_input)
DQ (9/16/2012): Added function to support setting the template arguments and setting their parents (a...
SageBuilder::buildStmtDeclarationStatement
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement(SgStatement *stmt)
Build a StmtDeclarationStmt.
SageBuilder::buildNoexceptOp_nfi
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp_nfi(SgExpression *exp)
SageBuilder::buildExecStatement
ROSE_DLL_API SgExecStatement * buildExecStatement(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build an exec statement.
SageBuilder::buildRvalueReferenceType
ROSE_DLL_API SgRvalueReferenceType * buildRvalueReferenceType(SgType *base_type)
Build a rvalue reference type.
SageBuilder::findAssociatedDeclarationInTargetAST
ROSE_DLL_API SgDeclarationStatement * findAssociatedDeclarationInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildDefiningClassDeclaration
ROSE_DLL_API SgClassDeclaration * buildDefiningClassDeclaration(SgName name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SgCudaKernelCallExp
Definition: Cxx_Grammar.h:288784
SgTypeUnsignedLong
Definition: Cxx_Grammar.h:50473
SageBuilder::buildMemberFunctionCall
ROSE_DLL_API SgFunctionCallExp * buildMemberFunctionCall(std::string className, SgExpression *objectExpression, std::string functionName, SgExprListExp *params, SgScopeStatement *scope)
Build member function calls.
SageBuilder::buildUpcWaitStatement_nfi
ROSE_DLL_API SgUpcWaitStatement * buildUpcWaitStatement_nfi(SgExpression *exp)
Build a UPC wait statement.
SgWithStatement
Definition: Cxx_Grammar.h:224008
SageBuilder::buildTemplateType
ROSE_DLL_API SgTemplateType * buildTemplateType(SgName name="")
Build a template type, used for template parameter and later argument.
SageBuilder::buildTemplateMemberFunctionRefExp_nfi
SgTemplateMemberFunctionRefExp * buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
DQ (12/29/2011): Adding template declaration support to the AST.
SgLambdaCapture
Definition: Cxx_Grammar.h:121819
SgBasicBlock
This class represents the concept of a block (not a basic block from control flow analysis).
Definition: Cxx_Grammar.h:124904
SgNullptrValExp
Definition: Cxx_Grammar.h:285049
SageBuilder::buildTupleExp_nfi
SgTupleExp * buildTupleExp_nfi()
SageBuilder::buildDefiningFunctionDeclaration
ROSE_DLL_API SgFunctionDeclaration * buildDefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation=false, SgFunctionDeclaration *first_nondefinng_declaration=NULL, SgTemplateArgumentPtrList *templateArgumentsList=NULL)
Build a function declaration with a function body.
SageBuilder::buildChooseExpression_nfi
ROSE_DLL_API SgChooseExpression * buildChooseExpression_nfi()
SageBuilder::buildAutoType
ROSE_DLL_API SgAutoType * buildAutoType()
Built in simple types.
SageBuilder::symbol_table_case_insensitive_semantics
bool symbol_table_case_insensitive_semantics
Support for construction of case sensitive/insensitive symbol table handling in scopes.
SageBuilder::buildStmtDeclarationStatement_nfi
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement_nfi(SgStatement *stmt)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildFile
ROSE_DLL_API SgFile * buildFile(const std::string &inputFileName, const std::string &outputFileName, SgProject *project=NULL, bool clear_globalScopeAcrossFiles=false)
Build a SgFile node and attach it to SgProject.
SgTemplateFunctionSymbol
Definition: Cxx_Grammar.h:324246
SageBuilder::buildTemplateFunctionRefExp_nfi
SgTemplateFunctionRefExp * buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol *sym)
DQ (12/15/2011): Adding template declaration support to the AST.
SgNonrealBaseClass
Definition: Cxx_Grammar.h:28055
SgTypeFloat80
Definition: Cxx_Grammar.h:55654
SageBuilder::buildLongIntVal
ROSE_DLL_API SgLongIntVal * buildLongIntVal(long value=0)
Build a long integer value expression.
SageBuilder::buildMinusMinusOp_nfi
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp_nfi(SgExpression *op)
SageBuilder::SourcePositionClassification
SourcePositionClassification
intended to be a private member, don't access it directly. could be changed any time
Definition: sageBuilder.h:138
SageBuilder::buildSignedLongLongType
ROSE_DLL_API SgTypeSignedLongLong * buildSignedLongLongType()
Built in simple types.
SageBuilder::buildUnsignedShortVal
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal(unsigned short v=0)
Build an unsigned short integer.
SgNaryBooleanOp
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
Definition: Cxx_Grammar.h:311524
SageBuilder::buildSignedShortType
ROSE_DLL_API SgTypeSignedShort * buildSignedShortType()
Built in simple types.
SageBuilder::buildGotoStatement_nfi
SgGotoStatement * buildGotoStatement_nfi(SgLabelStatement *label)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildSizeOfOp
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp(SgExpression *exp=NULL)
Build sizeof() expression with an expression parameter.
SgCommonBlockObject
Definition: Cxx_Grammar.h:76400
SgIntVal
Definition: Cxx_Grammar.h:278468
SgYieldExpression
Definition: Cxx_Grammar.h:312881
SageBuilder::buildNullptrValExp
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp()
DQ (7/31/2014): Adding support for C++11 nullptr const value expressions.
SageBuilder::buildUsingDirectiveStatement
ROSE_DLL_API SgUsingDirectiveStatement * buildUsingDirectiveStatement(SgNamespaceDeclarationStatement *ns_decl)
Build a using directive statement.
SageBuilder::buildContinueStmt_nfi
SgContinueStmt * buildContinueStmt_nfi()
Build a variable declaration, handle symbol table transparently.
SgFunctionParameterTypeList
Definition: Cxx_Grammar.h:31632
SgMemberFunctionDeclaration
This class represents the concept of a member function declaration statement.
Definition: Cxx_Grammar.h:157151
SgNullExpression
Definition: Cxx_Grammar.h:300596
SgDictionaryExp
Definition: Cxx_Grammar.h:308256
SgTypeMatrix
Definition: Cxx_Grammar.h:71057
SgFunctionDeclaration
This class represents the concept of a function declaration statement.
Definition: Cxx_Grammar.h:155826
SageBuilder::buildEmptyDeclaration
ROSE_DLL_API SgEmptyDeclaration * buildEmptyDeclaration()
Build an empty declaration (useful for adding precission to comments and CPP handling under token-bas...
SageBuilder::buildAlignOfOp
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp(SgExpression *exp=NULL)
Build alignof() expression with an expression parameter.
SgTypeNullptr
Definition: Cxx_Grammar.h:69602
SgDeclType
Definition: Cxx_Grammar.h:70073
SageBuilder::buildThrowOp
ROSE_DLL_API SgThrowOp * buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind)
Build a ThrowOp expression.
SageBuilder::buildFortranKindType
ROSE_DLL_API SgModifierType * buildFortranKindType(SgType *base_type, SgExpression *kindExpression)
Build a type based on the Fortran kind mechanism.
SageBuilder::buildAliasedType
ROSE_DLL_API SgModifierType * buildAliasedType(SgType *base_type=NULL)
Build an aliased type for Ada.
SgTypeSignedShort
Definition: Cxx_Grammar.h:47145
SageBuilder::buildMagicColonExp
ROSE_DLL_API SgMagicColonExp * buildMagicColonExp()
Build a Matlab colon expression :
SageBuilder::buildLongDoubleVal_nfi
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal_nfi(long double value, const std::string &str)
SageBuilder::buildSetComprehension_nfi
SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
SageBuilder::buildLongDoubleType
ROSE_DLL_API SgTypeLongDouble * buildLongDoubleType()
Built in simple types.
SageBuilder::buildSizeOfOp_nfi
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp_nfi(SgExpression *exp)
SageBuilder::buildComplexType
ROSE_DLL_API SgTypeComplex * buildComplexType(SgType *base_type=NULL)
Build a complex type.
SageBuilder::buildTemplateTypedefDeclaration_nfi
ROSE_DLL_API SgTemplateTypedefDeclaration * buildTemplateTypedefDeclaration_nfi(const SgName &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildClassTemplateType
ROSE_DLL_API SgClassType * buildClassTemplateType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Some support for building class template instantiation declarations.
SgNonrealRefExp
Definition: Cxx_Grammar.h:319145
SageBuilder::buildHeader
ROSE_DLL_API PreprocessingInfo * buildHeader(const std::string &header_filename, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before, bool isSystemHeader=false)
Build a dangling #include "x.h" header, insertHeader() is needed to actually insert it.
SgFunctionParameterRefExp
Definition: Cxx_Grammar.h:317668
SgTypeSigned128bitInteger
Definition: Cxx_Grammar.h:54712
SageBuilder::buildLongDoubleVal
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal(long double value=0.0)
SageBuilder::popScopeStack
ROSE_DLL_API void popScopeStack()
intended to be a private member, don't access it directly. could be changed any time
SgTypeBool
Definition: Cxx_Grammar.h:57057
SageBuilder::buildStringVal_nfi
ROSE_DLL_API SgStringVal * buildStringVal_nfi(std::string value)
SageBuilder::buildConstVolatileModifier
ROSE_DLL_API SgConstVolatileModifier * buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype=SgConstVolatileModifier::e_unknown)
Build a const/volatile type qualifier.
SageBuilder::buildLambdaCaptureList
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList()
SageBuilder::buildCaseOptionStmt_nfi
SgCaseOptionStmt * buildCaseOptionStmt_nfi(SgExpression *key, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder
Functions that build an AST.
Definition: sageBuilder.h:31
SgPassStatement
Definition: Cxx_Grammar.h:224466
SageBuilder::buildLongIntValHex
ROSE_DLL_API SgLongIntVal * buildLongIntValHex(long value=0)
SgEquivalenceStatement
Definition: Cxx_Grammar.h:145904
SgDeleteExp
This class represents the concept of a C++ call to the delete operator.
Definition: Cxx_Grammar.h:293277
SageBuilder::buildChar16Type
ROSE_DLL_API SgTypeChar16 * buildChar16Type()
Built in simple types.
SgDeclarationScope
Definition: Cxx_Grammar.h:135417
SgStaticAssertionDeclaration
Definition: Cxx_Grammar.h:171275
SgEmptyDeclaration
Definition: Cxx_Grammar.h:173206
SageBuilder::buildConditionalExp_nfi
SgConditionalExp * buildConditionalExp_nfi(SgExpression *test, SgExpression *a, SgExpression *b, SgType *t)
SgTemplateParameter
Definition: Cxx_Grammar.h:28952
SageBuilder::buildDoubleVal
ROSE_DLL_API SgDoubleVal * buildDoubleVal(double value=0.0)
Build a double value expression.
SageBuilder::buildStringType
ROSE_DLL_API SgTypeString * buildStringType()
DQ (8/21/2010): We want to move to the new buildStringType( SgExpression*,size_t) function over the o...
SageBuilder::buildUnsignedCharVal_nfi
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal_nfi(unsigned char v, const std::string &str)
SageBuilder::buildListExp_nfi
SgListExp * buildListExp_nfi()
SageBuilder::buildCompoundLiteralExp_nfi
SgCompoundLiteralExp * buildCompoundLiteralExp_nfi(SgVariableSymbol *varSymbol)
Build function for compound literals (uses a SgVariableSymbol and is similar to buildVarRefExp_nfi())...
SgTypeTraitBuiltinOperator
Definition: Cxx_Grammar.h:315795
SageBuilder::buildUnsignedCharVal
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal(unsigned char v=0)
Build an unsigned char.
SageInterface::setSourcePosition
ROSE_DLL_API void setSourcePosition(SgNode *node)
Set the source code positon for the current (input) node.
SageBuilder::buildLambdaCapture
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
SgTypeChar32
Definition: Cxx_Grammar.h:72495
SageBuilder::buildTypeIdOp
ROSE_DLL_API SgTypeIdOp * buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type)
DQ (1/25/2013): Added support for typeId operators.
SageBuilder::fixupSharingSourcePosition
ROSE_DLL_API void fixupSharingSourcePosition(SgNode *subtreeRoot, int new_file_id)
Sharing IR nodes requires that the file id be added to the fileIDsToUnparse held in the Sg_File_Info ...
SageBuilder::buildStatementExpression_nfi
ROSE_DLL_API SgStatementExpression * buildStatementExpression_nfi(SgStatement *exp)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildBinaryExpression
T * buildBinaryExpression(SgExpression *lhs, SgExpression *rhs)
Template function to build a binary expression of type T, taking care of parent pointers,...
Definition: sageBuilder.h:1690
SgTypeImaginary
This class represents a C99 complex type.
Definition: Cxx_Grammar.h:66746
SageBuilder::buildWcharVal
ROSE_DLL_API SgWcharVal * buildWcharVal(wchar_t value=0)
SageBuilder::setTemplateParameterParents
ROSE_DLL_API void setTemplateParameterParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SgExpression
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes,...
Definition: Cxx_Grammar.h:229045
SageBuilder::buildClassNameRefExp_nfi
SgClassNameRefExp * buildClassNameRefExp_nfi(SgClassSymbol *sym)
SageBuilder::buildDictionaryComprehension_nfi
SgDictionaryComprehension * buildDictionaryComprehension_nfi(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
SgMinusOp
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
Definition: Cxx_Grammar.h:230611
SageBuilder::buildDoWhileStmt
ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement *body, SgStatement *condition)
Build do-while statement.
SageBuilder::buildTupleExp
ROSE_DLL_API SgTupleExp * buildTupleExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgTupleExp.
SageBuilder::buildExprStatement
ROSE_DLL_API SgExprStatement * buildExprStatement(SgExpression *exp=NULL)
Build a SgExprStatement, set File_Info automatically.
SgStorageModifier::storage_modifier_enum
storage_modifier_enum
Storage Modifiers (only one value can be specified)
Definition: Cxx_Grammar.h:9564
SgEnumDeclaration
This class represents the concept of an enum declaration.
Definition: Cxx_Grammar.h:141371
SgNoexceptOp
Definition: Cxx_Grammar.h:318679
SgTypeInt
Definition: Cxx_Grammar.h:48087
SageBuilder::buildWithStatement
ROSE_DLL_API SgWithStatement * buildWithStatement(SgExpression *expr, SgStatement *body)
Build a with statement.
SgAssertStmt
Definition: Cxx_Grammar.h:224908
PreprocessingInfo::RelativePositionType
RelativePositionType
MK: Enum type to store if the directive goes before or after the corresponding line of source code.
Definition: rose_attributes_list.h:133
SgNaryComparisonOp
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
Definition: Cxx_Grammar.h:311974
SageBuilder::buildUnsignedLongLongIntValHex
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntValHex(unsigned long long v=0)
SageBuilder::buildFoldExpression
ROSE_DLL_API SgFoldExpression * buildFoldExpression(SgExpression *operands, std::string operator_token_string, bool is_left_associative)
SageBuilder::buildFortranIncludeLine
ROSE_DLL_API SgFortranIncludeLine * buildFortranIncludeLine(std::string filename)
Build Fortran include line.
SageBuilder::buildDefaultOptionStmt
ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt(SgStatement *body=NULL)
Build a default option statement.
AbstractHandle::abstract_handle
to specify a construct using a specifier Can be used alone or with parent handles when relative speci...
Definition: abstract_handle.h:182
SgTemplateInstantiationMemberFunctionDecl
This class represents the concept of an instantiation of member function template or a member functio...
Definition: Cxx_Grammar.h:158167
SageBuilder::buildForStatement
ROSE_DLL_API SgForStatement * buildForStatement(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgStatement *loop_body, SgStatement *else_body=NULL)
Build a for statement, assume none of the arguments is NULL.
SageBuilder::buildNondefiningClassDeclaration
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration(SgName name, SgScopeStatement *scope)
DQ (11/7/2009): Added functions to build C++ class.
SgUnsignedLongVal
Definition: Cxx_Grammar.h:281306
SageBuilder::buildFloatVal_nfi
ROSE_DLL_API SgFloatVal * buildFloatVal_nfi(float value=0.0)
SageInterface
Functions that are useful when operating on the AST.
Definition: sageBuilder.h:25
SgFloat128Val
Definition: Cxx_Grammar.h:286905
SageBuilder::buildBaseClass
ROSE_DLL_API SgBaseClass * buildBaseClass(SgClassDeclaration *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
DQ (5/6/2013): Added build functions to support SgBaseClass construction.
SgCharVal
Definition: Cxx_Grammar.h:276605
SgFunctionParameterList
This class represents the concept of a declaration list.
Definition: Cxx_Grammar.h:137786
SgMicrosoftAttributeDeclaration
Definition: Cxx_Grammar.h:172198
SageBuilder::buildUpcBlockIndefiniteType
ROSE_DLL_API SgModifierType * buildUpcBlockIndefiniteType(SgType *base_type=NULL)
Build a UPC shared[] type.
SageBuilder::buildClassExp_nfi
ROSE_DLL_API SgClassExp * buildClassExp_nfi(SgClassSymbol *sym)
SgTemplateArgument
This class represents template argument within the use of a template to build an instantiation.
Definition: Cxx_Grammar.h:29484
SageBuilder::buildEnumDeclaration
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
SageBuilder::buildBracedInitializer
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
Build an braced initializer.
SageBuilder::buildNullptrType
ROSE_DLL_API SgTypeNullptr * buildNullptrType()
Built in simple types.
SageBuilder::buildClassNameRefExp
ROSE_DLL_API SgClassNameRefExp * buildClassNameRefExp(SgClassSymbol *sym)
SageBuilder::buildFunctionCallExp_nfi
SgFunctionCallExp * buildFunctionCallExp_nfi(SgExpression *f, SgExprListExp *parameters=NULL)
SageBuilder::e_sourcePositionTransformation
@ e_sourcePositionTransformation
Default source position.
Definition: sageBuilder.h:142
SageBuilder::buildLambdaExp
ROSE_DLL_API SgLambdaExp * buildLambdaExp(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
DQ (9/3/2014): Adding support for C++11 Lambda expressions.
SageBuilder::buildEnumVal_nfi
ROSE_DLL_API SgEnumVal * buildEnumVal_nfi(long long int value, SgEnumDeclaration *decl, SgName name)
SgTypeSignedInt
Definition: Cxx_Grammar.h:48589
SageBuilder::buildTypeOfType
ROSE_DLL_API SgTypeOfType * buildTypeOfType(SgExpression *base_expression, SgType *base_type)
Build a GNU typeof operator.
SgAwaitExpression
Definition: Cxx_Grammar.h:320104
SageBuilder::buildMemberFunctionRefExp
ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
SageBuilder::buildBoolValExp
ROSE_DLL_API SgBoolValExp * buildBoolValExp(int value=0)
Build a bool value expression, the name convention of SgBoolValExp is little different from others fo...
SageBuilder::setTemplateParametersInDeclaration
ROSE_DLL_API void setTemplateParametersInDeclaration(SgDeclarationStatement *decl, SgTemplateParameterPtrList *templateParametersList_input)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildSuperExp_nfi
ROSE_DLL_API SgSuperExp * buildSuperExp_nfi(SgClassSymbol *sym)
SageBuilder::fixupCopyOfNodeFromSeparateFileInNewTargetAst
ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgNode *node_copy, SgNode *node_original)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildNaryComparisonOp
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp(SgExpression *lhs)
driscoll6 (7/20/11) : Support n-ary operators for python
SageBuilder::display
ROSE_DLL_API std::string display(SourcePositionClassification &scp)
display function for debugging
SageBuilder::buildFunctionParameterRefExp_nfi
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level)
SageBuilder::buildWhileStmt_nfi
SgWhileStmt * buildWhileStmt_nfi(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildDefiningTemplateFunctionDeclaration
ROSE_DLL_API SgTemplateFunctionDeclaration * buildDefiningTemplateFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, SgTemplateFunctionDeclaration *first_nondefining_declaration)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildTemplateInstantiationTypedefDeclaration_nfi
ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration * buildTemplateInstantiationTypedefDeclaration_nfi(SgName &name, SgType *base_type, SgScopeStatement *scope, bool has_defining_base, SgTemplateTypedefDeclaration *templateTypedefDeclaration, SgTemplateArgumentPtrList &templateArgumentsList)
Build a variable declaration, handle symbol table transparently.
SageBuilder::appendTemplateArgumentsToName
ROSE_DLL_API SgName appendTemplateArgumentsToName(const SgName &name, const SgTemplateArgumentPtrList &templateArgumentsList)
DQ (7/27/2012): changed semantics from removing the template arguments in names to adding the templat...
SgName
This class represents strings within the IR nodes.
Definition: Cxx_Grammar.h:16476
SgUpcForAllStatement
Definition: Cxx_Grammar.h:133943
SageBuilder::buildUpcRelaxedType
ROSE_DLL_API SgModifierType * buildUpcRelaxedType(SgType *base_type=NULL)
Build a UPC relaxed type.
SageBuilder::buildSuperExp
ROSE_DLL_API SgSuperExp * buildSuperExp(SgClassSymbol *sym)
Build super pointer.
SageBuilder::e_sourcePosition_last
@ e_sourcePosition_last
Specify as source position to be filled in as part of AST construction in the front-end.
Definition: sageBuilder.h:146
SageBuilder::testTemplateArgumentParents
ROSE_DLL_API void testTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SgTypeOfType
Definition: Cxx_Grammar.h:70564
SageBuilder::buildDeclarationScope
ROSE_DLL_API SgDeclarationScope * buildDeclarationScope()
Build a scope statement. Used to build SgNonrealDecl and SgNonrealType.
SageBuilder::buildThisExp_nfi
ROSE_DLL_API SgThisExp * buildThisExp_nfi(SgSymbol *sym)
SageBuilder::getTargetFileTypeSupport
ROSE_DLL_API SgType * getTargetFileTypeSupport(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::setTemplateSpecializationArgumentsInDeclaration
ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateSpecializationArgumentsList_input)
Build a variable declaration, handle symbol table transparently.
SgDeclarationStatement
This class represents the concept of a declaration statement.
Definition: Cxx_Grammar.h:136861
SageBuilder::buildAlignOfOp_nfi
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp_nfi(SgExpression *exp)
SgLongIntVal
Definition: Cxx_Grammar.h:279911
SgTypeUnsignedLongLong
Definition: Cxx_Grammar.h:54241
SageBuilder::buildUnaryExpression
T * buildUnaryExpression(SgExpression *operand)
Template function to build a unary expression of type T. Instantiated functions include:buildAddressO...
Definition: sageBuilder.h:1649
SageBuilder::buildConstructorInitializer_nfi
ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer_nfi(SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown)
SageBuilder::buildVarRefExp
ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName &name, SgScopeStatement *scope=NULL)
Build SgVarRefExp based on a variable's Sage name. It will lookup the name in the symbol table intern...
SageBuilder::buildPragma
ROSE_DLL_API SgPragma * buildPragma(const std::string &name)
Build SgPragma.
SageBuilder::getSourcePositionClassificationMode
ROSE_DLL_API SourcePositionClassification getSourcePositionClassificationMode()
Get the current source position classification (defines how IR nodes built by the SageBuilder interfa...
SageBuilder::buildActualArgumentExpression_nfi
SgActualArgumentExpression * buildActualArgumentExpression_nfi(SgName arg_name, SgExpression *arg)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsignedShortType
ROSE_DLL_API SgTypeUnsignedShort * buildUnsignedShortType()
Built in simple types.
SgComplexVal
Definition: Cxx_Grammar.h:283166
SageBuilder::buildDictionaryExp_nfi
SgDictionaryExp * buildDictionaryExp_nfi(std::vector< SgKeyDatumPair * > pairs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNaryBooleanOp_nfi
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildCompoundLiteralExp
SgCompoundLiteralExp * buildCompoundLiteralExp(SgVariableSymbol *varSymbol)
SageBuilder::buildBoolValExp_nfi
ROSE_DLL_API SgBoolValExp * buildBoolValExp_nfi(int value)
SgTypeLong
Definition: Cxx_Grammar.h:49531
SageBuilder::buildEnumDeclaration_nfi
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
SageBuilder::buildFloat80Type
ROSE_DLL_API SgTypeFloat80 * buildFloat80Type()
Built in simple types.
SageBuilder::buildVariableDeclaration
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
SgTemplateInstantiationTypedefDeclaration
Definition: Cxx_Grammar.h:148943
SageBuilder::buildShortValHex
ROSE_DLL_API SgShortVal * buildShortValHex(short value=0)
SageBuilder::buildFloat128Val
ROSE_DLL_API SgFloat128Val * buildFloat128Val(long double value=0.0)
SgNamespaceDefinitionStatement
This class represents the concept of a namespace definition.
Definition: Cxx_Grammar.h:130989
SageBuilder::buildPointerType
ROSE_DLL_API SgPointerType * buildPointerType(SgType *base_type=NULL)
Build a pointer type.
SgRangeBasedForStatement
Definition: Cxx_Grammar.h:135866
SageBuilder::buildClassDeclarationStatement_nfi
ROSE_DLL_API DeclClass * buildClassDeclarationStatement_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope=NULL, SgClassDeclaration *nonDefiningDecl=NULL)
Build a generic class declaration statement (SgClassDeclaration or subclass) with a class declaration...
SageBuilder::buildNonrealRefExp_nfi
ROSE_DLL_API SgNonrealRefExp * buildNonrealRefExp_nfi(SgNonrealSymbol *sym)
Build a reference to the non-real declaration of a member of a non-real class.
SageBuilder::buildChar16Val
ROSE_DLL_API SgChar16Val * buildChar16Val(unsigned short value=0)
SgTypeSignedLong
Definition: Cxx_Grammar.h:50002
SageBuilder::buildChar32Type
ROSE_DLL_API SgTypeChar32 * buildChar32Type()
Built in simple types.
SageBuilder::buildThisExp
ROSE_DLL_API SgThisExp * buildThisExp(SgSymbol *sym)
Build this pointer.
SageBuilder::buildCompoundInitializer_nfi
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
SageBuilder::buildVoidVal
ROSE_DLL_API SgVoidVal * buildVoidVal()
DQ (2/14/2019): Adding support for C++14 void value expressions.
SageBuilder::buildNaryBooleanOp
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
SgKeyDatumPair
Definition: Cxx_Grammar.h:308713
SgReturnStmt
This class represents the concept of a C Assembler statement (untested).
Definition: Cxx_Grammar.h:177063
SgMagicColonExp
Definition: Cxx_Grammar.h:315352
SageBuilder::buildUpcThreads_nfi
ROSE_DLL_API SgUpcThreads * buildUpcThreads_nfi()
SageBuilder::buildDefaultConstructor
ROSE_DLL_API SgMemberFunctionDeclaration * buildDefaultConstructor(SgClassType *classType)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsignedCharValHex
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharValHex(unsigned char v=0)
SageBuilder::buildLambdaRefExp
ROSE_DLL_API SgLambdaRefExp * buildLambdaRefExp(SgType *return_type, SgFunctionParameterList *params, SgScopeStatement *scope)
Build lambda expression.
SgDoubleVal
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:282236
SageBuilder::buildPragmaDeclaration
ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string &name, SgScopeStatement *scope=NULL)
Build pragma declaration, handle SgPragma and defining/nondefining pointers internally.
SageBuilder::e_sourcePositionFrontendConstruction
@ e_sourcePositionFrontendConstruction
Set pointers to Sg_File_Info objects to NULL.
Definition: sageBuilder.h:145
SgCompoundInitializer
Definition: Cxx_Grammar.h:295730
SageBuilder::buildFunctionCallStmt
ROSE_DLL_API SgExprStatement * buildFunctionCallStmt(const SgName &name, SgType *return_type, SgExprListExp *parameters=NULL, SgScopeStatement *scope=NULL)
Build a regular function call statement.
SgCastExp
Definition: Cxx_Grammar.h:234243
SageBuilder::buildNamespaceDeclaration
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
tps (09/02/2009) : Added support for building namespaces
SageBuilder::buildCtorInitializerList_nfi
SgCtorInitializerList * buildCtorInitializerList_nfi()
Build a variable declaration, handle symbol table transparently.
SgListExp
This class represents a list display.
Definition: Cxx_Grammar.h:271359
SageBuilder::buildCharVal
ROSE_DLL_API SgCharVal * buildCharVal(char value=0)
SageBuilder::buildLabelStatement_nfi
SgLabelStatement * buildLabelStatement_nfi(const SgName &name, SgStatement *stmt, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SageBuilder::getGlobalScopeFromScopeStack
SgScopeStatement * getGlobalScopeFromScopeStack()
Support to retrive the SgGlobal from the internal scope stack (error if not present in a non-empty li...
SgTypeTuple
Definition: Cxx_Grammar.h:71536
SgSetComprehension
Definition: Cxx_Grammar.h:310116
SgNode
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:6739
SgClassExp
Definition: Cxx_Grammar.h:317197
SageBuilder::buildDoubleVal_nfi
ROSE_DLL_API SgDoubleVal * buildDoubleVal_nfi(double value, const std::string &str)
SgTemplateMemberFunctionSymbol
Definition: Cxx_Grammar.h:323801
SageBuilder::testTemplateParameterParents
ROSE_DLL_API void testTemplateParameterParents(SgDeclarationStatement *decl)
DQ (9/16/2012): Added function to support setting the template parameters and setting their parents (...
SageBuilder::buildUpcMythread_nfi
ROSE_DLL_API SgUpcMythread * buildUpcMythread_nfi()
SageBuilder::buildLongLongIntVal
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal(long long value=0)
Build a long long integer value expression.
SageBuilder::buildFloat80Val_nfi
ROSE_DLL_API SgFloat80Val * buildFloat80Val_nfi(long double value, const std::string &str)
SgTemplateVariableDeclaration
Definition: Cxx_Grammar.h:139097
SageBuilder::buildAssignStatement_ast_translate
ROSE_DLL_API SgExprStatement * buildAssignStatement_ast_translate(SgExpression *lhs, SgExpression *rhs)
This version does not recursively reset the file info as a transformation.
SageBuilder::inSwitchScope
bool inSwitchScope()
intended to be a private member, don't access it directly. could be changed any time
SgClassSymbol
This class represents the concept of a class name within the compiler.
Definition: Cxx_Grammar.h:325607
SageBuilder::buildInitializedName
ROSE_DLL_API SgInitializedName * buildInitializedName(const SgName &name, SgType *type, SgInitializer *init=NULL)
Initialized names are tricky, their scope vary depending on context, so scope and symbol information ...
SageBuilder::buildNullStatement_nfi
SgNullStatement * buildNullStatement_nfi()
Build a variable declaration, handle symbol table transparently.
SgListComprehension
Definition: Cxx_Grammar.h:309651
SageBuilder::buildFixedType
ROSE_DLL_API SgTypeFixed * buildFixedType(SgExpression *fraction, SgExpression *scale)
Build a Jovial fixed type with a fraction specifier and a scale specifier.
SageBuilder::buildRangeBasedForStatement_nfi
ROSE_DLL_API SgRangeBasedForStatement * buildRangeBasedForStatement_nfi(SgVariableDeclaration *initializer, SgVariableDeclaration *range, SgVariableDeclaration *begin_declaration, SgVariableDeclaration *end_declaration, SgExpression *not_equal_expression, SgExpression *increment_expression, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildStringVal
ROSE_DLL_API SgStringVal * buildStringVal(std::string value="")
SageBuilder::buildDefiningMemberFunctionDeclaration
ROSE_DLL_API SgMemberFunctionDeclaration * buildDefiningMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration *first_nondefinng_declaration, SgTemplateArgumentPtrList *templateArgumentsList)
Build a defining ( non-prototype) member function declaration.
SgCastExp::cast_type_enum
cast_type_enum
Classification of Casts.
Definition: Cxx_Grammar.h:234263
SgConstructorInitializer
This class represents the notion of an initializer for a variable declaration or expression in a func...
Definition: Cxx_Grammar.h:296215
SageBuilder::buildUpcBlockStarType
ROSE_DLL_API SgModifierType * buildUpcBlockStarType(SgType *base_type=NULL)
Build a UPC shared[*] type.
SageBuilder::buildNondefiningTemplateFunctionDeclaration
ROSE_DLL_API SgTemplateFunctionDeclaration * buildNondefiningTemplateFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope=NULL, SgExprListExp *decoratorList=NULL, SgTemplateParameterPtrList *templateParameterList=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildSourceFile
ROSE_DLL_API SgSourceFile * buildSourceFile(const std::string &outputFileName, SgProject *project=NULL, bool clear_globalScopeAcrossFiles=false)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildFoldExpression_nfi
ROSE_DLL_API SgFoldExpression * buildFoldExpression_nfi(SgExpression *operands, std::string operator_token_string, bool is_left_associative)
SageBuilder::buildBinaryExpression_nfi
T * buildBinaryExpression_nfi(SgExpression *lhs, SgExpression *rhs)
Template function to build a binary expression of type T, taking care of parent pointers,...
Definition: sageBuilder.h:1711
SgUsingDirectiveStatement
This class represents the concept of a C++ using directive.
Definition: Cxx_Grammar.h:150832
SageBuilder::buildYieldExpression
ROSE_DLL_API SgYieldExpression * buildYieldExpression(SgExpression *value)
Build a yield statement.
SageBuilder::buildAsmStatement_nfi
SgAsmStmt * buildAsmStatement_nfi(std::string s)
Build a variable declaration, handle symbol table transparently.
SgTypeExpression
Definition: Cxx_Grammar.h:316741
SageBuilder::buildVariableDeclaration_nfi
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope, bool builtFromUseOnly=false, SgStorageModifier::storage_modifier_enum sm=SgStorageModifier::e_default)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildLongType
ROSE_DLL_API SgTypeLong * buildLongType()
Built in simple types.
SageBuilder::buildVarRefExp_nfi
ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol *varSymbol)
SageBuilder::buildSubscriptExpression_nfi
SgSubscriptExpression * buildSubscriptExpression_nfi(SgExpression *lower_bound, SgExpression *upper_bound, SgExpression *stride)
Build a SgSubscriptExpression, used for array shape expressions. The lower bound and stride may be nu...
SgAttributeSpecificationStatement
Definition: Cxx_Grammar.h:142464
SgTypeFixed
Definition: Cxx_Grammar.h:73437
SgVoidVal
Definition: Cxx_Grammar.h:287370
SageBuilder::buildUnsignedLongLongType
ROSE_DLL_API SgTypeUnsignedLongLong * buildUnsignedLongLongType()
Built in simple types.
SgTypeLongLong
Definition: Cxx_Grammar.h:53299
SgCatchOptionStmt
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
Definition: Cxx_Grammar.h:130494
SageBuilder::buildLabelStatement
ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName &name, SgStatement *stmt=NULL, SgScopeStatement *scope=NULL)
Build a label statement, name is the label's name. Handling label symbol and scope internally.
SgTemplateClassDefinition
Definition: Cxx_Grammar.h:128530
SageBuilder::buildTryStmt
ROSE_DLL_API SgTryStmt * buildTryStmt(SgStatement *body, SgCatchOptionStmt *catch0=NULL, SgCatchOptionStmt *catch1=NULL, SgCatchOptionStmt *catch2=NULL, SgCatchOptionStmt *catch3=NULL, SgCatchOptionStmt *catch4=NULL)
Build a try statement.
SageBuilder::buildBreakStmt_nfi
SgBreakStmt * buildBreakStmt_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildAssignStatement
ROSE_DLL_API SgExprStatement * buildAssignStatement(SgExpression *lhs, SgExpression *rhs)
Build an assignment statement from lefthand operand and right hand operand.
SageBuilder::buildAggregateInitializer
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build an aggregate initializer.
SgInitializedName
This class represents the notion of a declared variable.
Definition: Cxx_Grammar.h:76851
variable
Definition: variables.h:40
SgLongLongIntVal
Definition: Cxx_Grammar.h:280376
SageBuilder::buildNoexceptOp
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp(SgExpression *exp=NULL)
Build noexcept operator expression with an expression parameter.
SageInterface::setOneSourcePositionForTransformation
ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *root)
Set current node's source position as transformation generated.
SgLabelStatement
This class represents the concept of a C or C++ label statement.
Definition: Cxx_Grammar.h:174131
SageBuilder::buildTypedefDeclaration_nfi
ROSE_DLL_API SgTypedefDeclaration * buildTypedefDeclaration_nfi(const std::string &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a variable declaration, handle symbol table transparently.
SgAggregateInitializer
Definition: Cxx_Grammar.h:295163
SageBuilder::buildNewExp
ROSE_DLL_API SgNewExp * buildNewExp(SgType *type, SgExprListExp *exprListExp, SgConstructorInitializer *constInit, SgExpression *expr, short int val, SgFunctionDeclaration *funcDecl)
SageBuilder::buildAbstractHandle
ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode *n)
Build an abstract handle from a SgNode.
SageBuilder::buildLongLongIntVal_nfi
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal_nfi(long long value, const std::string &str)
SageBuilder::buildFloatVal
ROSE_DLL_API SgFloatVal * buildFloatVal(float value=0.0)
SgModifierType
Definition: Cxx_Grammar.h:61411
SgUpcFenceStatement
Definition: Cxx_Grammar.h:192415
SageBuilder::buildRestrictType
ROSE_DLL_API SgModifierType * buildRestrictType(SgType *base_type)
Build a restrict type.
SageBuilder::buildDictionaryExp
ROSE_DLL_API SgDictionaryExp * buildDictionaryExp(std::vector< SgKeyDatumPair * > pairs)
Build a list of key-datum pairs.
SageBuilder::buildProcedureHeaderStatement
ROSE_DLL_API SgProcedureHeaderStatement * buildProcedureHeaderStatement(const SgName &name, SgType *return_type, SgFunctionParameterList *parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildConstVolatileType
ROSE_DLL_API SgModifierType * buildConstVolatileType(SgType *base_type=NULL)
Build a const volatile type.
SageBuilder::buildConstructorInitializer
ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer(SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown)
SgArrayType
Definition: Cxx_Grammar.h:64255
SgModuleStatement
Definition: Cxx_Grammar.h:153453
SageBuilder::buildFunctionParameterRefExp
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp(int parameter_number, int parameter_level)
SageBuilder::buildAwaitExpression_nfi
ROSE_DLL_API SgAwaitExpression * buildAwaitExpression_nfi()
SageBuilder::buildSwitchStatement
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement(SgStatement *item_selector=NULL, SgStatement *body=NULL)
Build a switch statement.
SgSuperExp
Definition: Cxx_Grammar.h:291209
SgValueExp
This class represents the notion of an value (expression value).
Definition: Cxx_Grammar.h:274702
SageBuilder::buildExprListExp
ROSE_DLL_API SgExprListExp * buildExprListExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgExprListExp, used for function call parameter list etc.
SageBuilder::buildNondefiningProcedureHeaderStatement
ROSE_DLL_API SgProcedureHeaderStatement * buildNondefiningProcedureHeaderStatement(const SgName &name, SgType *return_type, SgFunctionParameterList *param_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement *scope=NULL)
Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently.
SageBuilder::buildAssertStmt_nfi
SgAssertStmt * buildAssertStmt_nfi(SgExpression *test)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildArrayType
ROSE_DLL_API SgArrayType * buildArrayType(SgType *base_type=NULL, SgExpression *index=NULL)
Build ArrayType.
SageBuilder::buildAssertStmt
ROSE_DLL_API SgAssertStmt * buildAssertStmt(SgExpression *test)
Build a Assert statement.
SgSourceFile
Definition: Cxx_Grammar.h:22972
SageBuilder::buildUpcNotifyStatement_nfi
ROSE_DLL_API SgUpcNotifyStatement * buildUpcNotifyStatement_nfi(SgExpression *exp)
Build a UPC notify statement.
SageBuilder::buildExprStatement_nfi
SgExprStatement * buildExprStatement_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgFortranIncludeLine
Definition: Cxx_Grammar.h:169916
SgNullStatement
Definition: Cxx_Grammar.h:178464
SageBuilder::buildGotoStatement
ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement *label=NULL)
Build a goto statement.
SageBuilder::buildDeleteExp
ROSE_DLL_API SgDeleteExp * buildDeleteExp(SgExpression *variable, short is_array, short need_global_specifier, SgFunctionDeclaration *deleteOperatorDeclaration)
SageBuilder::buildCommonBlock
ROSE_DLL_API SgCommonBlock * buildCommonBlock(SgCommonBlockObject *first_block=NULL)
Build a Fortran Common statement.
SageBuilder::buildFunctionCallExp
ROSE_DLL_API SgFunctionCallExp * buildFunctionCallExp(SgFunctionSymbol *sym, SgExprListExp *parameters=NULL)
Build a function call expression.
SgTypeUnsigned128bitInteger
Definition: Cxx_Grammar.h:55183
SageBuilder::buildSignedIntType
ROSE_DLL_API SgTypeSignedInt * buildSignedIntType()
Built in simple types.
SgNode::set_parent
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
SgDictionaryComprehension
Definition: Cxx_Grammar.h:310581
SageBuilder::buildNaryComparisonOp_nfi
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildMemberFunctionRefExp_nfi
SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
SageBuilder::getTemplateParameterList
ROSE_DLL_API SgTemplateParameterPtrList * getTemplateParameterList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SgProcedureHeaderStatement
Definition: Cxx_Grammar.h:159680
SageBuilder::buildYieldExpression_nfi
SgYieldExpression * buildYieldExpression_nfi(SgExpression *value)
Build a variable declaration, handle symbol table transparently.
SgTypeChar16
Definition: Cxx_Grammar.h:72024
SageBuilder::buildClassDefinition
ROSE_DLL_API SgClassDefinition * buildClassDefinition(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
SgMatrixExp
Definition: Cxx_Grammar.h:272257
SageBuilder::buildUnsignedLongLongIntVal
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal(unsigned long long v=0)
Build an unsigned long long integer.
SgReferenceType
Definition: Cxx_Grammar.h:58487
SageBuilder::buildReturnStmt_nfi
ROSE_DLL_API SgReturnStmt * buildReturnStmt_nfi(SgExpression *expression)
Build a variable declaration, handle symbol table transparently.
SgStringVal
Definition: Cxx_Grammar.h:275620
SgConstVolatileModifier
Definition: Cxx_Grammar.h:9040
SgPointerType
Definition: Cxx_Grammar.h:57528
SageBuilder::buildReferenceType
ROSE_DLL_API SgReferenceType * buildReferenceType(SgType *base_type=NULL)
Build a reference type.
SageBuilder::buildWcharVal_nfi
ROSE_DLL_API SgWcharVal * buildWcharVal_nfi(wchar_t value, const std::string &str)
SageBuilder::buildMultibyteNopStatement
ROSE_DLL_API SgAsmStmt * buildMultibyteNopStatement(int n)
DQ (4/30/2010): Added support for building nop statement using asm statement Building nop statement u...
SgTypeSignedLongLong
Definition: Cxx_Grammar.h:53770
SageBuilder::buildClassExp
ROSE_DLL_API SgClassExp * buildClassExp(SgClassSymbol *sym)
Build class pointer.
SgTypeUnsignedChar
Definition: Cxx_Grammar.h:46203
SageBuilder::buildUnsignedIntType
ROSE_DLL_API SgTypeUnsignedInt * buildUnsignedIntType()
Built in simple types.
SgUnsignedLongLongIntVal
Definition: Cxx_Grammar.h:280841
SageBuilder::buildNullptrValExp_nfi
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp_nfi()
SageBuilder::buildDefaultOptionStmt_nfi
SgDefaultOptionStmt * buildDefaultOptionStmt_nfi(SgStatement *body)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnsignedShortVal_nfi
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal_nfi(unsigned short v, const std::string &str)
SgActualArgumentExpression
Definition: Cxx_Grammar.h:305397
SageBuilder::buildIntType
ROSE_DLL_API SgTypeInt * buildIntType()
Built in simple types.
SageBuilder::buildConditionalExp
ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression *test=NULL, SgExpression *a=NULL, SgExpression *b=NULL)
Build a conditional expression ?:
SageBuilder::buildTemplateClassDeclaration
ROSE_DLL_API SgTemplateClassDeclaration * buildTemplateClassDeclaration(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateClassDeclaration *nonDefiningDecl, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build tempplate class declaration.
SageBuilder::buildFunctionRefExp_nfi
SgFunctionRefExp * buildFunctionRefExp_nfi(SgFunctionSymbol *sym)
SgStorageModifier::e_default
@ e_default
Definition: Cxx_Grammar.h:9567
SageBuilder::buildUpcMythread
ROSE_DLL_API SgUpcMythread * buildUpcMythread()
Build UPC MYTHREAD (integer expression)
SageBuilder::buildSignedCharType
ROSE_DLL_API SgTypeSignedChar * buildSignedCharType()
Built in simple types.
SageBuilder::buildBasicBlock_nfi
ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi()
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildComplexVal_nfi
ROSE_DLL_API SgComplexVal * buildComplexVal_nfi(SgValueExp *real_value, SgValueExp *imaginary_value, const std::string &str)
SgConstVolatileModifier::cv_modifier_enum
cv_modifier_enum
Const Volatile Modifier.
Definition: Cxx_Grammar.h:9060
SageBuilder::buildUnsignedShortValHex
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortValHex(unsigned short v=0)
SgStringConversion
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
Definition: Cxx_Grammar.h:312424
SageBuilder::buildRangeExp
ROSE_DLL_API SgRangeExp * buildRangeExp(SgExpression *start)
Build a Matlab range expression like start:end or start:stride:end.
SageBuilder::buildConstType
ROSE_DLL_API SgModifierType * buildConstType(SgType *base_type=NULL)
Build a const type.
SgVariableDeclaration
This class represents the concept of a C or C++ variable declaration.
Definition: Cxx_Grammar.h:138274
SageBuilder::buildLongIntVal_nfi
ROSE_DLL_API SgLongIntVal * buildLongIntVal_nfi(long value, const std::string &str)
SgUpcBarrierStatement
Definition: Cxx_Grammar.h:191965
Sawyer::Message::Facility
Collection of streams.
Definition: Message.h:1606
SgTupleExp
Definition: Cxx_Grammar.h:271808
SgSizeOfOp
This class represents the "sizeof()" operator (applied to any type).
Definition: Cxx_Grammar.h:289241
SageBuilder::buildShortVal_nfi
ROSE_DLL_API SgShortVal * buildShortVal_nfi(short value, const std::string &str)
SageBuilder::buildShortVal
ROSE_DLL_API SgShortVal * buildShortVal(short value=0)
SageBuilder::fixupSourcePositionFileSpecification
ROSE_DLL_API void fixupSourcePositionFileSpecification(SgNode *subtreeRoot, const std::string &newFileName)
Change the source file associated with the source position information in the AST.
SageBuilder::buildCudaKernelCallExp_nfi
SgCudaKernelCallExp * buildCudaKernelCallExp_nfi(SgExpression *kernel, SgExprListExp *parameters=NULL, SgCudaKernelExecConfig *config=NULL)
Build a CUDA kernel call expression (kernel<<<config>>>(parameters))
SageBuilder::buildCompoundInitializer
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build a compound initializer, for vector type initialization.
SgScopeStatement
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope,...
Definition: Cxx_Grammar.h:123553
SageBuilder::buildBracedInitializer_nfi
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
SageBuilder::buildWcharType
ROSE_DLL_API SgTypeWchar * buildWcharType()
Built in simple types.
SgDerivedTypeStatement
Definition: Cxx_Grammar.h:153002
SageBuilder::buildContinueStmt
ROSE_DLL_API SgContinueStmt * buildContinueStmt()
Build a continue statement.
SgLabelRefExp
Definition: Cxx_Grammar.h:304918
SgFunctionSymbol
Definition: Cxx_Grammar.h:322891
SgCtorInitializerList
This class represents the concept of a contructor initializer list (used in constructor (member funct...
Definition: Cxx_Grammar.h:149893
SgUpcMythread
Definition: Cxx_Grammar.h:284112
SgConstVolatileModifier::e_unknown
@ e_unknown
Definition: Cxx_Grammar.h:9062
SgTypeComplex
This class represents a C99 complex type.
Definition: Cxx_Grammar.h:66285
SageBuilder::buildAssignInitializer
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
Build the rhs of a variable declaration which includes an assignment.
SageBuilder::buildMicrosoftAttributeDeclaration
ROSE_DLL_API SgMicrosoftAttributeDeclaration * buildMicrosoftAttributeDeclaration(const SgName &name)
DQ (8/17/2014): Adding support for Microsoft MSVC specific attributes.
SgTypeSignedChar
Definition: Cxx_Grammar.h:45732
SgFloat80Val
Definition: Cxx_Grammar.h:286440
SageBuilder::buildListExp
ROSE_DLL_API SgListExp * buildListExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgListExp.
SgLabelSymbol
Definition: Cxx_Grammar.h:328762
SgUnsignedIntVal
Definition: Cxx_Grammar.h:279446
SageBuilder::buildCpreprocessorDefineDeclaration
ROSE_DLL_API PreprocessingInfo * buildCpreprocessorDefineDeclaration(SgLocatedNode *target, const std::string &content, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before)
Build and attach #define XX directives, pass "#define xxx xxx" as content.
SageBuilder::buildUnaryExpression_nfi
T * buildUnaryExpression_nfi(SgExpression *operand)
Template function to build a unary expression of type T with no file info. Instantiated functions inc...
Definition: sageBuilder.h:1667
SageBuilder::e_sourcePositionDefault
@ e_sourcePositionDefault
Error value for enum.
Definition: sageBuilder.h:141
SgVariantExpression
Definition: Cxx_Grammar.h:301051
SgProject
This class represents a source project, with a list of SgFile objects and global information about th...
Definition: Cxx_Grammar.h:24060
SageBuilder::buildCommonBlockObject
ROSE_DLL_API SgCommonBlockObject * buildCommonBlockObject(std::string name="", SgExprListExp *exp_list=NULL)
Build a Fortran common block, possibly with a name.
SgTemplateParameterVal
Definition: Cxx_Grammar.h:284577
SageBuilder::buildStatementFromString
ROSE_DLL_API SgStatement * buildStatementFromString(const std::string &stmt_str, SgScopeStatement *scope)
Liao (9/18/2015): experimental support of building a statement from a string.
SgStatement
This class represents the notion of a statement.
Definition: Cxx_Grammar.h:122747
SageBuilder::buildInitializedName_nfi
ROSE_DLL_API SgInitializedName * buildInitializedName_nfi(const SgName &name, SgType *type, SgInitializer *init)
Initialized names are tricky, their scope vary depending on context, so scope and symbol information ...
SageBuilder::buildIfStmt_nfi
ROSE_DLL_API SgIfStmt * buildIfStmt_nfi(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build a variable declaration, handle symbol table transparently.
SgGotoStatement
This class represents the concept of a C or C++ goto statement.
Definition: Cxx_Grammar.h:177523
SageBuilder::buildFloatType
ROSE_DLL_API SgTypeFloat * buildFloatType()
Built in simple types.
SageBuilder::buildLambdaCaptureList_nfi
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList_nfi()
SageBuilder::topScopeStack
ROSE_DLL_API SgScopeStatement * topScopeStack()
intended to be a private member, don't access it directly. could be changed any time
SageBuilder::buildNondefiningTemplateClassDeclaration
ROSE_DLL_API SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
buildNondefiningTemplateClassDeclaration()
SgSubscriptExpression
Definition: Cxx_Grammar.h:301500
PreprocessingInfo
For preprocessing information including source comments, #include , #if, #define, etc.
Definition: rose_attributes_list.h:127
SageBuilder::buildEquivalenceStatement
ROSE_DLL_API SgEquivalenceStatement * buildEquivalenceStatement(SgExpression *lhs, SgExpression *rhs)
Build a SgFile node and attach it to SgProject.
SgAutoType
Definition: Cxx_Grammar.h:73921
SageBuilder::buildNondefiningFunctionDeclaration
ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope=NULL, SgExprListExp *decoratorList=NULL, bool buildTemplateInstantiation=false, SgTemplateArgumentPtrList *templateArgumentsList=NULL, SgStorageModifier::storage_modifier_enum sm=SgStorageModifier::e_default)
Build a prototype for a function, handle function type, symbol etc transparently.
SageBuilder::buildMinusOp
ROSE_DLL_API SgMinusOp * buildMinusOp(SgExpression *op=NULL)
SgTypeUnknown
Definition: Cxx_Grammar.h:44774
SgChooseExpression
Definition: Cxx_Grammar.h:320561
SgInitializer
This class represents the notion of an initializer for a variable declaration or expression in a func...
Definition: Cxx_Grammar.h:294701
SageBuilder::buildClassDeclaration
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...
SgTemplateMemberFunctionDeclaration
Definition: Cxx_Grammar.h:157682
SageBuilder::buildMatrixExp
ROSE_DLL_API SgMatrixExp * buildMatrixExp(SgExprListExp *firstRow)
Build a Matlab Matrix.
SageBuilder::buildVolatileType
ROSE_DLL_API SgModifierType * buildVolatileType(SgType *base_type=NULL)
Build a volatile type.
SageBuilder::buildUnsignedIntValHex
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntValHex(unsigned int v=0)
SageBuilder::buildPassStatement
ROSE_DLL_API SgPassStatement * buildPassStatement()
Build a pass statement.
SageBuilder::buildDoWhileStatement_nfi
ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt *result, SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNonrealBaseClass
ROSE_DLL_API SgNonrealBaseClass * buildNonrealBaseClass(SgNonrealDecl *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildNullExpression_nfi
ROSE_DLL_API SgNullExpression * buildNullExpression_nfi()
No file info version of buildNullExpression(). File info is to be set later on.
SgClassType
Definition: Cxx_Grammar.h:59461
SgExprStatement
This class represents the concept of a C or C++ statement which contains a expression.
Definition: Cxx_Grammar.h:173661
SageBuilder::buildNonrealDecl
ROSE_DLL_API SgNonrealDecl * buildNonrealDecl(const SgName &name, SgDeclarationScope *scope, SgDeclarationScope *child_scope=NULL)
Build a declaration of a non-real class or class-member representing template parameters and their me...
SgPlusPlusOp
Definition: Cxx_Grammar.h:233338
SageBuilder::buildUnsignedCharType
ROSE_DLL_API SgTypeUnsignedChar * buildUnsignedCharType()
Built in simple types.
SgLambdaExp
Definition: Cxx_Grammar.h:318158
SageBuilder::buildStaticAssertionDeclaration
ROSE_DLL_API SgStaticAssertionDeclaration * buildStaticAssertionDeclaration(SgExpression *condition, const SgName &string_literal)
DQ (7/25/2014): Adding support for C11 static assertions.
SgBreakStmt
This class represents the notion of a break statement (typically used in a switch statment).
Definition: Cxx_Grammar.h:176151
SageBuilder::buildExprListExp_nfi
SgExprListExp * buildExprListExp_nfi()
SageBuilder::buildVoidVal_nfi
ROSE_DLL_API SgVoidVal * buildVoidVal_nfi()
SgForInitStatement
This class represents the variable declaration or variable initialization withn a for loop.
Definition: Cxx_Grammar.h:179356
SageBuilder::buildFunctionRefExp
ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName &name, const SgType *func_type, SgScopeStatement *scope=NULL)
Build SgFunctionRefExp based on a C++ function's name and function type. It will lookup symbol table ...
SageBuilder::buildBreakStmt
ROSE_DLL_API SgBreakStmt * buildBreakStmt()
Build a break statement.
SageBuilder::getTemplateArgumentList
ROSE_DLL_API SgTemplateArgumentPtrList * getTemplateArgumentList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
SageBuilder::buildUnknownType
ROSE_DLL_API SgTypeUnknown * buildUnknownType()
Built in simple types.
SgSymbol
This class represents the concept of a name within the compiler.
Definition: Cxx_Grammar.h:321018
SageBuilder::buildUnsignedLongLongIntVal_nfi
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string &str)
SgPragmaDeclaration
This class represents the concept of a C Assembler statement (untested).
Definition: Cxx_Grammar.h:150372
SageBuilder::buildUpcBlockNumberType
ROSE_DLL_API SgModifierType * buildUpcBlockNumberType(SgType *base_type, long block_factor)
Build a UPC shared[n] type.
SageBuilder::buildNondefiningEnumDeclaration_nfi
ROSE_DLL_API SgEnumDeclaration * buildNondefiningEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope)
Build an enum first nondefining declaration, without file info.
SgTryStmt
This class represents the concept of try statement within the try-catch support for exception handlin...
Definition: Cxx_Grammar.h:175144
SageBuilder::buildTemplateClassType
ROSE_DLL_API SgClassType * buildTemplateClassType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Same as buildClassTemplateType(), just better name.
SageBuilder::buildFloat128Val_nfi
ROSE_DLL_API SgFloat128Val * buildFloat128Val_nfi(long double value, const std::string &str)
SageBuilder::buildChar16Val_nfi
ROSE_DLL_API SgChar16Val * buildChar16Val_nfi(unsigned short value, const std::string &str)
SageBuilder::buildUnsignedLongVal
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal(unsigned long v=0)
Build a unsigned long integer.
SageBuilder::buildFortranDo
ROSE_DLL_API SgFortranDo * buildFortranDo(SgExpression *initialization, SgExpression *bound, SgExpression *increment, SgBasicBlock *loop_body)
Build a Fortran do construct.
SgAsmStmt
This class represents the concept of a C Assembler statement.
Definition: Cxx_Grammar.h:141968
SageBuilder::buildClassDefinition_nfi
SgClassDefinition * buildClassDefinition_nfi(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
SageBuilder::buildUpcForAllStatement_nfi
ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgExpression *affinity, SgStatement *loop_body)
Build a UPC forall statement.
SageBuilder::buildVariableDefinition_nfi
ROSE_DLL_API SgVariableDefinition * buildVariableDefinition_nfi(SgVariableDeclaration *decl, SgInitializedName *init_name, SgInitializer *init)
Build variable definition.
SageBuilder::buildNondefiningMemberFunctionDeclaration
ROSE_DLL_API SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a prototype member function declaration.
SageBuilder::emptyScopeStack
ROSE_DLL_API bool emptyScopeStack()
intended to be a private member, don't access it directly. could be changed any time
SageBuilder::buildNullExpression
ROSE_DLL_API SgNullExpression * buildNullExpression()
Build a null expression, set file info as the default one.
SageBuilder::buildStatementExpression
ROSE_DLL_API SgStatementExpression * buildStatementExpression(SgStatement *exp)
Build a GNU statement expression.
SageBuilder::getTargetFileType
ROSE_DLL_API SgType * getTargetFileType(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
SageBuilder::buildTupleType
ROSE_DLL_API SgTypeTuple * buildTupleType(SgType *t1=NULL, SgType *t2=NULL, SgType *t3=NULL, SgType *t4=NULL, SgType *t5=NULL, SgType *t6=NULL, SgType *t7=NULL, SgType *t8=NULL, SgType *t9=NULL, SgType *t10=NULL)
Build a tuple of types. Useful for a function returning multiple variables of different types.
SgChar16Val
Definition: Cxx_Grammar.h:285498
Generated on Mon Dec 19 2022 23:39:54 for ROSE by   doxygen 1.8.17