ROSE  0.9.9.168
sageBuilder.h
1 #ifndef ROSE_SAGE_BUILDER_INTERFACE
2 #define ROSE_SAGE_BUILDER_INTERFACE
3 
4 #include <string>
5 
20 #include "sageInterface.h"
21 
22 #include "Diagnostics.h"
23 
24 // forward declarations required for templated functions using those functions
25 namespace SageInterface {
26  ROSE_DLL_API void setOneSourcePositionForTransformation (SgNode * root);
27  ROSE_DLL_API void setSourcePosition(SgNode* node);
28 }
29 
31 namespace SageBuilder
32 {
33 
34 // DQ (3/24/2016): Adding Robb's meageage mechanism (data member and function).
35  extern Sawyer::Message::Facility mlog;
36  void initDiagnostics();
37 
38 
39 #if 0
40 //---------------------AST creation/building/construction-----------------
41  SgExpression* buildConst(SgType* t, const string & val);
42  SgExpression* buildConstInt(int val);
43 
44  // build sth in languages, but not in SAGE AST
45  // how to specify position info? then
46 
48  // or
49  SgClassDeclaration* buildStruct(...);
50  SgClassDeclaration* buildClass(...);
51  SgClassDeclaration* buildUnion(...);
52 
53  // build B from dependent A
54  SgTemplateInstantiationMemberFunctionDecl* buildForwardFunctionDeclaration
55  (SgTemplateInstantiationMemberFunctionDecl * memberFunctionInstantiation);
56 
57  //previous attempt: src/midend/astUtil/astInterface
58  // AstNodePtr AstInterface::CreateConst( const string& val, const string& valtype) const
59  // AstNodePtr AstInterfaceBase::CreateConstInt( int val)
60 #endif
61 
62 //----------------------------------------------------------
64 
79 extern std::list<SgScopeStatement*> ScopeStack;
80 
81 // DQ (11/30/2010): Added support for building Fortran case insensitive symbol table handling.
84 
86 ROSE_DLL_API void pushScopeStack (SgScopeStatement* stmt);
87 
88 // DQ (3/20/2017): This function is not called (the function above is the more useful one that is used).
89 // ROSE_DLL_API void pushScopeStack (SgNode* node);
90 
91 ROSE_DLL_API void popScopeStack();
92 ROSE_DLL_API SgScopeStatement* topScopeStack();
93 ROSE_DLL_API bool emptyScopeStack();
94 ROSE_DLL_API void clearScopeStack();
95 
96 // DQ (3/11/2012): Added new function to the API for the internal scope stack.
99 
100 // DQ (3/20/2017): This function is not used.
101 // bool isInScopeStack(SgScopeStatement * scope);
102 
103 bool inSwitchScope();
104 
105 // DQ (3/20/2017): This function is not used.
106 // TV: for debug purpose
107 // std::string stringFromScopeStack();
108 
109 
111 
112 #if 0
113 // DQ (3/20/2017): These functions are not used (suggest using the API in the symbol table initialization).
114 //----------------------------------------------------------
116 
122 ROSE_DLL_API void setCaseInsensitive();
125 ROSE_DLL_API void setCaseSensitive();
127 ROSE_DLL_API void setCaseFromScope(SgScopeStatement* scope);
128 
130 #endif
131 
132 
133 // *************************************************************************************************************
134 // DQ (5/1/2012): This is another possible interface: supporting how we set the source code position and mark is
135 // as either a transformation or as actual code to be assigned a source position as part of the AST construction.
136 // *************************************************************************************************************
137 
139  {
140  e_sourcePositionError,
147  };
148 
151 
154 
156 ROSE_DLL_API std::string display(SourcePositionClassification & scp);
157 
160 
162 ROSE_DLL_API SgName appendTemplateArgumentsToName( const SgName & name, const SgTemplateArgumentPtrList & templateArgumentsList);
163 
164 // *************************************************************************************************************
165 
166 
167 
168 //--------------------------------------------------------------
170 
176 ROSE_DLL_API SgTypeBool * buildBoolType();
178 ROSE_DLL_API SgTypeNullptr* buildNullptrType();
179 ROSE_DLL_API SgTypeChar * buildCharType();
180 ROSE_DLL_API SgTypeDouble* buildDoubleType();
181 ROSE_DLL_API SgTypeFloat* buildFloatType();
182 ROSE_DLL_API SgTypeInt * buildIntType();
183 ROSE_DLL_API SgTypeLong* buildLongType();
184 ROSE_DLL_API SgTypeLongDouble* buildLongDoubleType();
185 ROSE_DLL_API SgTypeLongLong * buildLongLongType();
186 ROSE_DLL_API SgTypeShort* buildShortType();
187 
189 ROSE_DLL_API SgTypeString* buildStringType();
190 // SgTypeString* buildStringType( SgExpression* stringLengthExpression, size_t stringLengthLiteral );
191 ROSE_DLL_API SgTypeString* buildStringType( SgExpression* stringLengthExpression );
192 
193 ROSE_DLL_API SgTypeVoid * buildVoidType();
194 ROSE_DLL_API SgTypeWchar* buildWcharType();
195 
196 ROSE_DLL_API SgTypeSignedChar* buildSignedCharType();
197 ROSE_DLL_API SgTypeSignedInt* buildSignedIntType();
198 ROSE_DLL_API SgTypeSignedLong* buildSignedLongType();
201 
202 #if 1
205 #endif
206 
212 ROSE_DLL_API SgTypeUnknown * buildUnknownType();
213 
215 ROSE_DLL_API SgPointerType* buildPointerType(SgType *base_type = NULL);
216 
218 ROSE_DLL_API SgReferenceType* buildReferenceType(SgType *base_type = NULL);
219 
221 ROSE_DLL_API SgRvalueReferenceType* buildRvalueReferenceType(SgType *base_type);
222 
224 ROSE_DLL_API SgDeclType* buildDeclType(SgExpression *base_expression, SgType* base_type);
225 
227 ROSE_DLL_API SgTypeOfType* buildTypeOfType(SgExpression *base_expression, SgType* base_type);
228 
229 // Liao, entirely phase out this function ! Build a modifier type with no modifiers set
230 //SgModifierType* buildModifierType(SgType *base_type = NULL);
231 
232 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
234 ROSE_DLL_API SgModifierType* buildModifierType(SgType* base_type = NULL);
235 
237 ROSE_DLL_API SgModifierType* buildConstType(SgType* base_type = NULL);
238 
240 ROSE_DLL_API SgModifierType* buildVolatileType(SgType* base_type = NULL);
241 
243 ROSE_DLL_API SgModifierType* buildRestrictType(SgType* base_type);
244 
246 ROSE_DLL_API SgArrayType* buildArrayType(SgType* base_type=NULL, SgExpression* index=NULL);
247 
248 // DQ (8/27/2010): Added Fortran specific support for types based on kind expressions.
250 ROSE_DLL_API SgModifierType* buildFortranKindType(SgType* base_type, SgExpression* kindExpression );
251 
253 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList=NULL);
254 
256 ROSE_DLL_API SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterList * argList=NULL);
257 
259 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList * typeList, SgClassDefinition *struct_name, unsigned int mfunc_specifier);
260 
261 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
263 // ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterList* argList = NULL, SgClassDefinition *struct_name = NULL, unsigned int mfunc_specifier = 0);
264 
266 ROSE_DLL_API SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgClassType *classType, unsigned int mfunc_specifier);
267 
268 // PP (07/14/2016):
282 ROSE_DLL_API
284 buildClassTemplateType(SgTemplateClassDeclaration* template_decl, Rose_STL_Container<SgNode *>& template_args);
285 
286 
287 
289 
295 ROSE_DLL_API SgType* buildOpaqueType(std::string const type_name, SgScopeStatement * scope);
296 
297 // DQ (7/29/2010): Changed return type from SgType to SgModifierType for a number of the functions below.
299 ROSE_DLL_API SgModifierType* buildUpcStrictType(SgType *base_type = NULL);
300 
302 ROSE_DLL_API SgModifierType* buildUpcRelaxedType(SgType *base_type = NULL);
303 
305 ROSE_DLL_API SgModifierType* buildUpcSharedType(SgType *base_type = NULL, long layout = -1);
306 // SgModifierType* buildUpcSharedType(SgType *base_type = NULL);
307 
309 ROSE_DLL_API SgModifierType* buildUpcBlockIndefiniteType(SgType *base_type = NULL);
310 
312 ROSE_DLL_API SgModifierType* buildUpcBlockStarType(SgType *base_type = NULL);
313 
315 ROSE_DLL_API SgModifierType* buildUpcBlockNumberType(SgType *base_type, long block_factor);
316 
318 ROSE_DLL_API SgTypeComplex* buildComplexType(SgType *base_type = NULL);
319 
321 ROSE_DLL_API SgTypeImaginary* buildImaginaryType(SgType *base_type = NULL);
322 
325 
327 ROSE_DLL_API SgTypeMatrix* buildMatrixType();
328 
330 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);
331 
333 
334 //--------------------------------------------------------------
336 
348 // JJW (11/19/2008): _nfi versions of functions set file info objects to NULL (used in frontend)
349 
351 
353 ROSE_DLL_API SgNullExpression* buildNullExpression();
356 
358 ROSE_DLL_API SgBoolValExp* buildBoolValExp(int value = 0);
359 ROSE_DLL_API SgBoolValExp* buildBoolValExp(bool value = 0);
360 ROSE_DLL_API SgBoolValExp* buildBoolValExp_nfi(int value);
361 
362 ROSE_DLL_API SgCharVal* buildCharVal(char value = 0);
363 ROSE_DLL_API SgCharVal* buildCharVal_nfi(char value, const std::string& str);
364 
366 ROSE_DLL_API SgNullptrValExp* buildNullptrValExp();
368 
369 ROSE_DLL_API SgWcharVal* buildWcharVal(wchar_t value = 0);
370 ROSE_DLL_API SgWcharVal* buildWcharVal_nfi(wchar_t value, const std::string& str);
371 
372 // DQ (3/20/2017): This function has never existed (inputs must be SgValueExp pointers).
373 // ROSE_DLL_API SgComplexVal* buildComplexVal(long double real_value = 0.0, long double imaginary_value = 0.0 );
374 ROSE_DLL_API SgComplexVal* buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value);
375 ROSE_DLL_API SgComplexVal* buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, const std::string& str);
376 ROSE_DLL_API SgComplexVal* buildImaginaryVal(long double imaginary_value);
377 ROSE_DLL_API SgComplexVal* buildImaginaryVal(SgValueExp* imaginary_value);
378 ROSE_DLL_API SgComplexVal* buildImaginaryVal_nfi(SgValueExp* imaginary_value, const std::string& str);
379 
381 ROSE_DLL_API SgDoubleVal* buildDoubleVal(double value = 0.0);
382 ROSE_DLL_API SgDoubleVal* buildDoubleVal_nfi(double value, const std::string& str);
383 
384 ROSE_DLL_API SgFloatVal* buildFloatVal(float value = 0.0);
385 ROSE_DLL_API SgFloatVal* buildFloatVal_nfi(float value, const std::string& str);
386 
388 ROSE_DLL_API SgIntVal* buildIntVal(int value = 0);
389 ROSE_DLL_API SgIntVal* buildIntValHex(int value = 0);
390 ROSE_DLL_API SgIntVal* buildIntVal_nfi(int value, const std::string& str);
391 
393 ROSE_DLL_API SgLongIntVal* buildLongIntVal(long value = 0);
394 ROSE_DLL_API SgLongIntVal* buildLongIntValHex(long value = 0);
395 ROSE_DLL_API SgLongIntVal* buildLongIntVal_nfi(long value, const std::string& str);
396 
398 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal(long long value = 0);
399 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
400 ROSE_DLL_API SgLongLongIntVal* buildLongLongIntVal_nfi(long long value, const std::string& str);
401 // !Build enum val without file info: nfi
402 ROSE_DLL_API SgEnumVal* buildEnumVal_nfi(int value, SgEnumDeclaration* decl, SgName name);
403 // !Build enum val with transformation file info
404 ROSE_DLL_API SgEnumVal* buildEnumVal(int value, SgEnumDeclaration* decl, SgName name);
405 ROSE_DLL_API SgEnumVal* buildEnumVal(SgEnumFieldSymbol * sym);
406 
407 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal(long double value = 0.0);
408 ROSE_DLL_API SgLongDoubleVal* buildLongDoubleVal_nfi(long double value, const std::string& str);
409 
410 ROSE_DLL_API SgShortVal* buildShortVal(short value = 0);
411 ROSE_DLL_API SgShortVal* buildShortValHex(short value = 0);
412 ROSE_DLL_API SgShortVal* buildShortVal_nfi(short value, const std::string& str);
413 
414 ROSE_DLL_API SgStringVal* buildStringVal(std::string value="");
415 ROSE_DLL_API SgStringVal* buildStringVal_nfi(std::string value);
416 
418 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);
419 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
420 ROSE_DLL_API SgUnsignedCharVal* buildUnsignedCharVal_nfi(unsigned char v, const std::string& str);
421 
423 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);
424 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
425 ROSE_DLL_API SgUnsignedShortVal* buildUnsignedShortVal_nfi(unsigned short v, const std::string& str);
426 
428 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);
429 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
430 ROSE_DLL_API SgUnsignedIntVal* buildUnsignedIntVal_nfi(unsigned int v, const std::string& str);
431 
433 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);
434 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
435 ROSE_DLL_API SgUnsignedLongVal* buildUnsignedLongVal_nfi(unsigned long v, const std::string& str);
436 
438 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);
439 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
440 ROSE_DLL_API SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string& str);
441 
443 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal(int template_parameter_position = -1);
444 ROSE_DLL_API SgTemplateParameterVal* buildTemplateParameterVal_nfi(int template_parameter_position, const std::string& str);
445 
447 ROSE_DLL_API SgTemplateType* buildTemplateType(SgName name="", int template_parameter_position = -1);
448 
452 
454 ROSE_DLL_API SgUpcThreads* buildUpcThreads();
455 ROSE_DLL_API SgUpcThreads* buildUpcThreads_nfi();
456 
458 ROSE_DLL_API SgUpcMythread* buildUpcMythread();
459 ROSE_DLL_API SgUpcMythread* buildUpcMythread_nfi();
460 
462 ROSE_DLL_API SgThisExp* buildThisExp(SgClassSymbol* sym);
463 ROSE_DLL_API SgThisExp* buildThisExp_nfi(SgClassSymbol* sym);
464 
466 ROSE_DLL_API SgSuperExp* buildSuperExp(SgClassSymbol* sym);
467 ROSE_DLL_API SgSuperExp* buildSuperExp_nfi(SgClassSymbol* sym);
468 
470 ROSE_DLL_API SgClassExp* buildClassExp(SgClassSymbol* sym);
471 ROSE_DLL_API SgClassExp* buildClassExp_nfi(SgClassSymbol* sym);
472 
474 ROSE_DLL_API SgLambdaRefExp* buildLambdaRefExp(SgType* return_type, SgFunctionParameterList* params, SgScopeStatement* scope);
475 
476 #define BUILD_UNARY_PROTO(suffix) \
477 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* op =NULL); \
478 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* op);
479 
480 BUILD_UNARY_PROTO(AddressOfOp)
481 BUILD_UNARY_PROTO(BitComplementOp)
482 BUILD_UNARY_PROTO(MinusOp)
483 BUILD_UNARY_PROTO(NotOp)
484 BUILD_UNARY_PROTO(PointerDerefExp)
485 BUILD_UNARY_PROTO(UnaryAddOp)
486 BUILD_UNARY_PROTO(MinusMinusOp)
487 BUILD_UNARY_PROTO(PlusPlusOp)
488 BUILD_UNARY_PROTO(RealPartOp)
489 BUILD_UNARY_PROTO(ImagPartOp)
490 BUILD_UNARY_PROTO(ConjugateOp)
491 BUILD_UNARY_PROTO(VarArgStartOneOperandOp)
492 BUILD_UNARY_PROTO(VarArgEndOp)
493 
494 //Matlab transpose op
495 BUILD_UNARY_PROTO(MatrixTransposeOp)
496 
498 ROSE_DLL_API SgCastExp * buildCastExp(SgExpression * operand_i = NULL,
499  SgType * expression_type = NULL,
500  SgCastExp::cast_type_enum cast_type = SgCastExp::e_C_style_cast);
501 ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression * operand_i,
502  SgType * expression_type,
503  SgCastExp::cast_type_enum cast_type);
504 
506 ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression * operand_i, SgType * expression_type);
507 
509 ROSE_DLL_API SgMinusOp *buildMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
510 ROSE_DLL_API SgMinusOp *buildMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
511 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
512 ROSE_DLL_API SgMinusMinusOp *buildMinusMinusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
513 
515 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
516 ROSE_DLL_API SgPlusPlusOp* buildPlusPlusOp_nfi(SgExpression* operand_i, SgUnaryOp::Sgop_mode a_mode);
517 
519 ROSE_DLL_API SgThrowOp* buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind);
520 
521 ROSE_DLL_API SgNewExp * buildNewExp(SgType* type,
522  SgExprListExp* exprListExp,
523  SgConstructorInitializer* constInit,
524  SgExpression* expr,
525  short int val,
526  SgFunctionDeclaration* funcDecl);
527 
528 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression* variable,
529  short is_array,
530  short need_global_specifier,
531  SgFunctionDeclaration* deleteOperatorDeclaration);
532 
534 ROSE_DLL_API SgTypeIdOp* buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type);
535 
536 
537 #undef BUILD_UNARY_PROTO
538 
543 #define BUILD_BINARY_PROTO(suffix) \
544 ROSE_DLL_API Sg##suffix * build##suffix(SgExpression* lhs =NULL, SgExpression* rhs =NULL); \
545 ROSE_DLL_API Sg##suffix * build##suffix##_nfi(SgExpression* lhs, SgExpression* rhs);
546 
547 BUILD_BINARY_PROTO(AddOp)
548 BUILD_BINARY_PROTO(AndAssignOp)
549 BUILD_BINARY_PROTO(AndOp)
550 BUILD_BINARY_PROTO(ArrowExp)
551 BUILD_BINARY_PROTO(ArrowStarOp)
552 BUILD_BINARY_PROTO(AssignOp)
553 BUILD_BINARY_PROTO(BitAndOp)
554 BUILD_BINARY_PROTO(BitOrOp)
555 BUILD_BINARY_PROTO(BitXorOp)
556 
557 BUILD_BINARY_PROTO(CommaOpExp)
558 BUILD_BINARY_PROTO(ConcatenationOp)
559 BUILD_BINARY_PROTO(DivAssignOp)
560 BUILD_BINARY_PROTO(DivideOp)
561 BUILD_BINARY_PROTO(DotExp)
562 BUILD_BINARY_PROTO(DotStarOp)
563 BUILD_BINARY_PROTO(EqualityOp)
564 
565 BUILD_BINARY_PROTO(ExponentiationOp)
566 BUILD_BINARY_PROTO(ExponentiationAssignOp)
567 BUILD_BINARY_PROTO(GreaterOrEqualOp)
568 BUILD_BINARY_PROTO(GreaterThanOp)
569 BUILD_BINARY_PROTO(IntegerDivideOp)
570 BUILD_BINARY_PROTO(IntegerDivideAssignOp)
571 BUILD_BINARY_PROTO(IorAssignOp)
572 BUILD_BINARY_PROTO(IsOp)
573 BUILD_BINARY_PROTO(IsNotOp)
574 
575 BUILD_BINARY_PROTO(LessOrEqualOp)
576 BUILD_BINARY_PROTO(LessThanOp)
577 BUILD_BINARY_PROTO(LshiftAssignOp)
578 BUILD_BINARY_PROTO(LshiftOp)
579 
580 BUILD_BINARY_PROTO(MembershipOp)
581 BUILD_BINARY_PROTO(MinusAssignOp)
582 BUILD_BINARY_PROTO(ModAssignOp)
583 BUILD_BINARY_PROTO(ModOp)
584 BUILD_BINARY_PROTO(MultAssignOp)
585 BUILD_BINARY_PROTO(MultiplyOp)
586 
587 BUILD_BINARY_PROTO(NonMembershipOp)
588 BUILD_BINARY_PROTO(NotEqualOp)
589 BUILD_BINARY_PROTO(OrOp)
590 BUILD_BINARY_PROTO(PlusAssignOp)
591 BUILD_BINARY_PROTO(PntrArrRefExp)
592 BUILD_BINARY_PROTO(RshiftAssignOp)
593 BUILD_BINARY_PROTO(JavaUnsignedRshiftAssignOp)
594 
595 BUILD_BINARY_PROTO(RshiftOp)
596 BUILD_BINARY_PROTO(JavaUnsignedRshiftOp)
597 BUILD_BINARY_PROTO(ScopeOp)
598 BUILD_BINARY_PROTO(SubtractOp)
599 BUILD_BINARY_PROTO(XorAssignOp)
600 
601 BUILD_BINARY_PROTO(VarArgCopyOp)
602 BUILD_BINARY_PROTO(VarArgStartOp)
603 
604 BUILD_BINARY_PROTO(PowerOp);
605 BUILD_BINARY_PROTO(ElementwisePowerOp);
606 BUILD_BINARY_PROTO(ElementwiseMultiplyOp);
607 BUILD_BINARY_PROTO(ElementwiseDivideOp);
608 BUILD_BINARY_PROTO(LeftDivideOp);
609 BUILD_BINARY_PROTO(ElementwiseLeftDivideOp);
610 BUILD_BINARY_PROTO(ElementwiseAddOp);
611 BUILD_BINARY_PROTO(ElementwiseSubtractOp);
612 
613 #undef BUILD_BINARY_PROTO
614 
616 ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression* test =NULL, SgExpression* a =NULL, SgExpression* b =NULL);
617 SgConditionalExp * buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
618 
620 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);
621 ROSE_DLL_API SgExprListExp * buildExprListExp(const std::vector<SgExpression*>& exprs);
623 SgExprListExp * buildExprListExp_nfi(const std::vector<SgExpression*>& exprs);
624 
626 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);
627 ROSE_DLL_API SgTupleExp * buildTupleExp(const std::vector<SgExpression*>& exprs);
629 SgTupleExp * buildTupleExp_nfi(const std::vector<SgExpression*>& exprs);
630 
632 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);
633 ROSE_DLL_API SgListExp * buildListExp(const std::vector<SgExpression*>& exprs);
635 SgListExp * buildListExp_nfi(const std::vector<SgExpression*>& exprs);
636 
637 ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
638 SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs);
639 
640 ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators);
641 SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
642 
643 ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators);
644 SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators);
645 
648 
650 
654 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName& name, SgScopeStatement* scope=NULL);
655 
657 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const std::string& varName, SgScopeStatement* scope=NULL);
658 
660 ROSE_DLL_API SgVarRefExp * buildVarRefExp(const char* varName, SgScopeStatement* scope=NULL);
661 
663 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableSymbol* varSymbol);
664 ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
665 
667 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgVariableDeclaration* vardecl);
668 
671 ROSE_DLL_API SgVarRefExp * buildVarRefExp(SgInitializedName* initname, SgScopeStatement* scope=NULL);
672 
674 
676 ROSE_DLL_API SgVarRefExp* buildOpaqueVarRefExp(const std::string& varName,SgScopeStatement* scope=NULL);
677 
678 // DQ (9/4/2013): Added support for building compound literals (similar to a SgVarRefExp).
682 
684 ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol * s);
685 
687 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name, const SgType* func_type, SgScopeStatement* scope=NULL);
688 
689 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name, const SgType* func_type, SgScopeStatement* scope=NULL);
690 
692 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName& name,SgScopeStatement* scope=NULL);
693 
694 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const char* name,SgScopeStatement* scope=NULL);
695 
697 ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgFunctionDeclaration* func_decl);
698 
701 
703 
704 // #ifdef ROSE_USE_NEW_EDG_INTERFACE
707 // #endif
708 
709 // #ifdef ROSE_USE_NEW_EDG_INTERFACE
712 // #endif
713 
714 SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
715 ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
718 
720 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgFunctionSymbol* sym, SgExprListExp* parameters=NULL);
721 SgFunctionCallExp* buildFunctionCallExp_nfi(SgExpression* f, SgExprListExp* parameters=NULL);
722 ROSE_DLL_API SgFunctionCallExp* buildFunctionCallExp(SgExpression* f, SgExprListExp* parameters=NULL);
723 
725 ROSE_DLL_API SgFunctionCallExp*
726 buildFunctionCallExp(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
727 
729 buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters);
730 
733  SgExpression * kernel,
734  SgExprListExp* parameters = NULL,
735  SgCudaKernelExecConfig * config = NULL
736 );
737 
740  SgExpression *grid = NULL,
741  SgExpression *blocks = NULL,
742  SgExpression *shared = NULL,
743  SgExpression *stream = NULL
744 );
745 
747 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
748 ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression * operand_i = NULL, SgType * expression_type = NULL);
749 
751 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
752 ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
753 
755 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp * initializers = NULL, SgType * type = NULL);
756 ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp * initializers, SgType * type = NULL);
757 
758 // DQ (!/4/2009): Added support for building SgConstructorInitializer
759 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);
760 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);
761 
763 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
764 ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp * initializers = NULL, SgType * expression_type = NULL);
765 
767 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgExpression* exp = NULL);
768 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgExpression* exp);
769 
771 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp(SgType* type = NULL);
772 ROSE_DLL_API SgSizeOfOp* buildSizeOfOp_nfi(SgType* type);
773 
775 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgExpression* exp = NULL);
776 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgExpression* exp);
777 
779 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp(SgType* type = NULL);
780 ROSE_DLL_API SgAlignOfOp* buildAlignOfOp_nfi(SgType* type);
781 
783 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp(SgExpression* exp = NULL);
784 ROSE_DLL_API SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
785 
786 // DQ (7/18/2011): Added support for SgJavaInstanceOfOp
788 ROSE_DLL_API SgJavaInstanceOfOp* buildJavaInstanceOfOp(SgExpression* exp = NULL, SgType* type = NULL);
789 
791 ROSE_DLL_API SgTypeExpression *buildTypeExpression(SgType* type);
792 
793 // DQ (8/11/2014): Added support for C++11 decltype used in new function return syntax.
794 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp(int parameter_number, int parameter_level );
795 ROSE_DLL_API SgFunctionParameterRefExp *buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level );
796 
797 
799 ROSE_DLL_API SgLambdaExp* buildLambdaExp (SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
800 ROSE_DLL_API SgLambdaExp* buildLambdaExp_nfi(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
801 
802 #if 0
803 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
804 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgInitializedName* capture_variable, SgInitializedName* source_closure_variable, SgInitializedName* closure_variable);
805 #else
806 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture (SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
807 ROSE_DLL_API SgLambdaCapture* buildLambdaCapture_nfi(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
808 #endif
809 
812 
814 
816 
818  ROSE_DLL_API SgRangeExp* buildRangeExp(SgExpression *start);
820 
822  ROSE_DLL_API SgMatrixExp* buildMatrixExp(SgExprListExp *firstRow);
823 
825  ROSE_DLL_API SgMagicColonExp* buildMagicColonExp();
826 
828  ROSE_DLL_API SgMatlabForStatement* buildMatlabForStatement(SgExpression* loop_index, SgExpression* loop_range, SgBasicBlock* loop_body);
830 
831 
832 //--------------------------------------------------------------
834 
838 
842 ROSE_DLL_API SgInitializedName* buildInitializedName(const SgName & name, SgType* type, SgInitializer* init = NULL);
843 ROSE_DLL_API SgInitializedName* buildInitializedName(const std::string &name, SgType* type);
844 ROSE_DLL_API SgInitializedName* buildInitializedName(const char* name, SgType* type);
845 ROSE_DLL_API SgInitializedName* buildInitializedName_nfi(const SgName & name, SgType* type, SgInitializer* init);
846 
848 ROSE_DLL_API SgFunctionParameterTypeList *
850 
852 ROSE_DLL_API SgFunctionParameterTypeList *
854 
856 ROSE_DLL_API SgFunctionParameterTypeList *
857 buildFunctionParameterTypeList(SgType* type0 = NULL, SgType* type1 = NULL,
858  SgType* type2 = NULL, SgType* type3 = NULL,
859  SgType* type4 = NULL, SgType* type5 = NULL,
860  SgType* type6 = NULL, SgType* type7 = NULL);
861 
862 
863 //--------------------------------------------------------------
865 
871 ROSE_DLL_API SgVariableDeclaration*
873 buildVariableDeclaration(const SgName & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
874 
875 ROSE_DLL_API SgVariableDeclaration*
876 buildVariableDeclaration(const std::string & name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
877 
878 ROSE_DLL_API SgVariableDeclaration*
879 buildVariableDeclaration(const char* name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement* scope=NULL);
880 
881 ROSE_DLL_API SgVariableDeclaration*
882 buildVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
883 
885 ROSE_DLL_API SgVariableDefinition*
887 
888 
889 // DQ (8/31/2012): Note that this macro can't be used in header files since it can only be set
890 // after sage3.h has been read. The reason is that this is a portability problem when "rose_config.h"
891 // appears in header files of applications using ROSE's header files.
892 // #ifdef ROSE_USE_NEW_EDG_INTERFACE
893 // DQ (12/6/2011): Adding support for template declarations into the AST.
894 // SgTemplateDeclaration*
895 // SgVariableDeclaration* buildTemplateVariableDeclaration_nfi(const SgName & name, SgType *type, SgInitializer *varInit, SgScopeStatement* scope);
897 // #endif
898 
900 ROSE_DLL_API SgTypedefDeclaration*
901 buildTypedefDeclaration(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
902 
903 ROSE_DLL_API SgTypedefDeclaration*
904 buildTypedefDeclaration_nfi(const std::string& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
905 
906 ROSE_DLL_API SgTemplateTypedefDeclaration*
907 buildTemplateTypedefDeclaration_nfi(const SgName & name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base=false);
908 
909 #if 1
910 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
911 // buildTemplateInstantiationTypedefDeclaration_nfi(SgName name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList templateArgumentList);
912 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
913 // buildTemplateInstantiationTypedefDeclaration_nfi(SgName name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration);
914 // ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration*
915 // buildTemplateInstantiationTypedefDeclaration_nfi();
917 buildTemplateInstantiationTypedefDeclaration_nfi(SgName & name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList & templateArgumentList);
918 #endif
919 
921 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);
923 
925 ROSE_DLL_API SgFunctionParameterList*
927 
928 ROSE_DLL_API SgFunctionParameterList*
930 
932 ROSE_DLL_API void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, const SgName & name );
933 
934 // 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.
935 ROSE_DLL_API void setTemplateArgumentParents( SgDeclarationStatement* decl );
936 ROSE_DLL_API void testTemplateArgumentParents( SgDeclarationStatement* decl );
937 ROSE_DLL_API SgTemplateArgumentPtrList* getTemplateArgumentList( SgDeclarationStatement* decl );
938 
940 ROSE_DLL_API void testTemplateParameterParents( SgDeclarationStatement* decl );
941 ROSE_DLL_API void setTemplateParameterParents( SgDeclarationStatement* decl );
942 ROSE_DLL_API SgTemplateParameterPtrList* getTemplateParameterList( SgDeclarationStatement* decl );
943 
945 ROSE_DLL_API void setTemplateArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input );
946 ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration ( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input );
947 ROSE_DLL_API void setTemplateParametersInDeclaration ( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input );
948 
950 // 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).
951 ROSE_DLL_API SgFunctionDeclaration*
952 buildNondefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
953 
954 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
955 // We need to decide if the SageBuilder API should include these sorts of functions.
956 ROSE_DLL_API SgFunctionDeclaration* buildNondefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL);
957 
958 // DQ (8/11/2013): Even though template functions can't use partial specialization, they can be specialized,
959 // however the specialization does not define a template and instead defines a template instantiation, so we
960 // don't need the SgTemplateArgumentPtrList in this function.
961 // SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
962 ROSE_DLL_API SgTemplateFunctionDeclaration*
963 buildNondefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
964 
965 // DQ (8/11/2013): Note that access to the SgTemplateParameterPtrList should be handled through the first_nondefining_declaration (which is a required parameter).
966 // DQ (12/1/2011): Adding support for template declarations into the AST.
967 ROSE_DLL_API SgTemplateFunctionDeclaration*
968 buildDefiningTemplateFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, SgTemplateFunctionDeclaration* first_nondefining_declaration);
969 
971 ROSE_DLL_API SgFunctionDeclaration *
972 buildNondefiningFunctionDeclaration (const SgFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
973 
975 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL);
976 // SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
977 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0, bool buildTemplateInstantiation = false);
978 ROSE_DLL_API SgMemberFunctionDeclaration*
979 buildNondefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
980 
981 // DQ (8/12/2013): This function needs to supporte SgTemplateParameterPtrList and SgTemplateArgumentPtrList parameters.
982 // SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope = NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
984 buildNondefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList );
985 
986 // DQ (12/1/2011): Adding support for template declarations in the AST.
988 buildDefiningTemplateMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration );
989 
991 // SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgFunctionParameterList* paralist, SgScopeStatement* scope=NULL);
992 
993 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
995 // SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration);
996 ROSE_DLL_API SgMemberFunctionDeclaration*
997 buildDefiningMemberFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList *parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration* first_nondefinng_declaration, SgTemplateArgumentPtrList* templateArgumentsList);
998 
999 #if 0
1000 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1001 // 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).
1002 // 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).
1004 ROSE_DLL_API SgMemberFunctionDeclaration*
1005 buildDefiningMemberFunctionDeclaration (const SgName & name, SgMemberFunctionType* func_type, SgScopeStatement* scope, SgExprListExp* decoratorList = NULL /* , unsigned int functionConstVolatileFlags = 0 */, SgMemberFunctionDeclaration* first_nondefinng_declaration = NULL);
1006 #endif
1007 
1008 #if 0
1009 // DQ (3/20/2017): This function is not used (so let's see if we can remove it).
1011 // SgMemberFunctionDeclaration*
1012 ROSE_DLL_API SgMemberFunctionDeclaration*
1013 buildNondefiningMemberFunctionDeclaration (const SgMemberFunctionDeclaration* funcdecl, SgScopeStatement* scope=NULL, SgExprListExp* decoratorList = NULL, unsigned int functionConstVolatileFlags = 0);
1014 #endif
1015 
1016 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1017 // We need to decide if the SageBuilder API should include these sorts of functions.
1018 ROSE_DLL_API SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1019 
1020 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficent).
1021 // We need to decide if the SageBuilder API should include these sorts of functions.
1022 ROSE_DLL_API SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1023 
1024 // DQ (8/11/2013): Note that the specification of the SgTemplateArgumentPtrList is somewhat redundant with the required parameter first_nondefinng_declaration (I think).
1026 // SgFunctionDeclaration* buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation, SgFunctionDeclaration* first_nondefinng_declaration);
1027 ROSE_DLL_API SgFunctionDeclaration*
1028 buildDefiningFunctionDeclaration (const SgName & name, SgType* return_type, SgFunctionParameterList * parlist, SgScopeStatement* scope, SgExprListExp* decoratorList, bool buildTemplateInstantiation = false, SgFunctionDeclaration* first_nondefinng_declaration = NULL, SgTemplateArgumentPtrList* templateArgumentsList = NULL);
1029 
1030 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1031 // We need to decide if the SageBuilder API should include these sorts of functions.
1032 ROSE_DLL_API SgFunctionDeclaration* buildDefiningFunctionDeclaration(const SgName& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);
1033 
1034 // DQ (8/28/2012): This preserves the original API with a simpler function (however for C++ at least, it is frequently not sufficient).
1035 // We need to decide if the SageBuilder API should include these sorts of functions.
1037 
1039 ROSE_DLL_API SgProcedureHeaderStatement*
1041 
1043 ROSE_DLL_API SgExprStatement*
1044 buildFunctionCallStmt(const SgName& name, SgType* return_type, SgExprListExp* parameters=NULL, SgScopeStatement* scope=NULL);
1045 
1047 ROSE_DLL_API SgExprStatement*
1048 buildFunctionCallStmt(SgExpression* function, SgExprListExp* parameters=NULL);
1049 
1050 
1052 
1055 ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName& name, SgStatement * stmt = NULL, SgScopeStatement* scope=NULL);
1057 
1059 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement * label=NULL);
1061 
1063 ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelSymbol* symbol);
1064 
1065 // DQ (11/22/2017): Added support for computed code goto as defined by GNU C/C++ extension.
1067 SgGotoStatement * buildGotoStatement_nfi(SgExpression* expr);
1068 
1070 ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt( SgExpression * key = NULL,SgStatement *body = NULL);
1071 SgCaseOptionStmt * buildCaseOptionStmt_nfi( SgExpression * key,SgStatement *body);
1072 
1074 ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt( SgStatement *body = NULL);
1076 
1078 ROSE_DLL_API SgExprStatement* buildExprStatement(SgExpression* exp = NULL);
1079 SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
1080 
1081 // DQ (3/27/2015): Added support for SgStatementExpression.
1085 
1087 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement(SgStatement *item_selector = NULL,SgStatement *body = NULL);
1088 inline SgSwitchStatement* buildSwitchStatement(SgExpression *item_selector, SgStatement *body = NULL) {
1089  return buildSwitchStatement(buildExprStatement(item_selector), body);
1090 }
1091 ROSE_DLL_API SgSwitchStatement* buildSwitchStatement_nfi(SgStatement *item_selector,SgStatement *body);
1092 
1094 ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1095 inline SgIfStmt * buildIfStmt(SgExpression* conditional, SgStatement * true_body, SgStatement * false_body) {
1096  return buildIfStmt(buildExprStatement(conditional), true_body, false_body);
1097 }
1098 
1099 ROSE_DLL_API SgIfStmt* buildIfStmt_nfi(SgStatement* conditional, SgStatement * true_body, SgStatement * false_body);
1100 
1103 ROSE_DLL_API SgForInitStatement* buildForInitStatement(const SgStatementPtrList & statements);
1104 ROSE_DLL_API SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList & statements);
1105 
1106 // DQ (10/12/2012): Added new function for a single statement.
1107 ROSE_DLL_API SgForInitStatement* buildForInitStatement( SgStatement* statement );
1108 
1110 ROSE_DLL_API SgForStatement * buildForStatement(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1111 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1112 ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1113 ROSE_DLL_API void buildForStatement_nfi(SgForStatement* result, SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body, SgStatement * else_body = NULL);
1114 
1115 // 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).
1116 // So we need an builder function that can use the existing SgDoWhileStatement scope already on the stack.
1117 ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt* result, SgStatement * body, SgStatement * condition);
1118 
1120 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement* initialize_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1121 ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgExpression* affinity, SgStatement * loop_body);
1122 
1123 // DQ (3/3/2013): Added UPC specific build functions.
1125 ROSE_DLL_API SgUpcNotifyStatement* buildUpcNotifyStatement_nfi(SgExpression* exp);
1126 
1128 ROSE_DLL_API SgUpcWaitStatement* buildUpcWaitStatement_nfi(SgExpression* exp);
1129 
1131 ROSE_DLL_API SgUpcBarrierStatement* buildUpcBarrierStatement_nfi(SgExpression* exp);
1132 
1135 
1136 
1138 ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1139 inline SgWhileStmt * buildWhileStmt(SgExpression * condition, SgStatement *body, SgStatement* else_body = NULL) {
1140  return buildWhileStmt(buildExprStatement(condition), body, else_body);
1141 }
1142 SgWhileStmt * buildWhileStmt_nfi(SgStatement * condition, SgStatement *body, SgStatement *else_body = NULL);
1143 
1145 ROSE_DLL_API SgWithStatement* buildWithStatement(SgExpression* expr, SgStatement* body);
1146 SgWithStatement* buildWithStatement_nfi(SgExpression* expr, SgStatement* body);
1147 
1149 ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement * body, SgStatement *condition);
1150 inline SgDoWhileStmt * buildDoWhileStmt(SgStatement* body, SgExpression * condition) {
1151  return buildDoWhileStmt(body, buildExprStatement(condition));
1152 }
1154 
1156 ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string & name, SgScopeStatement* scope=NULL);
1157 SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string & name, SgScopeStatement* scope);
1158 
1160 ROSE_DLL_API SgPragma* buildPragma(const std::string & name);
1161 
1163 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);
1164 ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi();
1165 SgBasicBlock * buildBasicBlock_nfi(const std::vector<SgStatement*>&);
1166 
1168 ROSE_DLL_API SgExprStatement*
1169 buildAssignStatement(SgExpression* lhs,SgExpression* rhs);
1170 
1171 // DQ (8/16/2011): Generated a new version of this function to define consistant semantics.
1173 ROSE_DLL_API SgExprStatement* buildAssignStatement_ast_translate(SgExpression* lhs,SgExpression* rhs);
1174 
1176 ROSE_DLL_API SgBreakStmt* buildBreakStmt();
1178 
1180 ROSE_DLL_API SgContinueStmt* buildContinueStmt();
1182 
1184 ROSE_DLL_API SgPassStatement* buildPassStatement();
1186 
1188 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression* test);
1189 ROSE_DLL_API SgAssertStmt* buildAssertStmt(SgExpression *test, SgExpression *exceptionArgument);
1190 SgAssertStmt* buildAssertStmt_nfi(SgExpression* test);
1191 
1193 ROSE_DLL_API SgYieldExpression* buildYieldExpression(SgExpression* value);
1194 SgYieldExpression* buildYieldExpression_nfi(SgExpression* value);
1195 
1197 ROSE_DLL_API SgKeyDatumPair* buildKeyDatumPair (SgExpression* key, SgExpression* datum);
1198 SgKeyDatumPair* buildKeyDatumPair_nfi(SgExpression* key, SgExpression* datum);
1199 
1201 ROSE_DLL_API SgDictionaryExp* buildDictionaryExp (std::vector<SgKeyDatumPair*> pairs);
1202 SgDictionaryExp* buildDictionaryExp_nfi(std::vector<SgKeyDatumPair*> pairs);
1203 
1205 ROSE_DLL_API SgActualArgumentExpression* buildActualArgumentExpression(SgName arg_name, SgExpression* arg);
1207 
1209 ROSE_DLL_API SgDeleteExp* buildDeleteExp(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1210 SgDeleteExp* buildDeleteExp_nfi(SgExpression *target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration *deleteOperatorDeclaration = NULL);
1211 
1213 // SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL);
1214 ROSE_DLL_API SgClassDefinition* buildClassDefinition(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1215 
1217 // SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL);
1218 SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration *d = NULL, bool buildTemplateInstantiation = false);
1219 
1220 // DQ (11/19/2011): Added more template declaration support.
1223 
1225 // DQ (6/6/2012): Added support to get the template arguments into place before computing the type.
1226 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1227 // SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation = false);
1228 ROSE_DLL_API SgClassDeclaration* buildNondefiningClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1229 
1230 // DQ (8/11/2013): We need to hand in both the SgTemplateParameterPtrList and the SgTemplateArgumentPtrList because class templates can be partially specialized.
1231 // DQ (11/29/2011): Adding template declaration support to the AST.
1232 // SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope);
1233 ROSE_DLL_API SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
1234 
1238 
1240 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration ( SgName name, SgScopeStatement* scope );
1241 
1244 
1246 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1247 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const std::string& name, SgScopeStatement* scope=NULL);
1248 ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const char* name, SgScopeStatement* scope=NULL);
1249 
1253 
1255 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1256 ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName& name, bool unnamednamespace, SgScopeStatement* scope );
1258 
1260 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp(SgExpression* lhs);
1261 ROSE_DLL_API SgNaryComparisonOp* buildNaryComparisonOp_nfi(SgExpression* lhs);
1262 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp(SgExpression* lhs);
1263 ROSE_DLL_API SgNaryBooleanOp* buildNaryBooleanOp_nfi(SgExpression* lhs);
1264 
1265 ROSE_DLL_API SgStringConversion* buildStringConversion(SgExpression* exp);
1266 ROSE_DLL_API SgStringConversion* buildStringConversion_nfi(SgExpression* exp);
1267 
1268 // DQ (6/6/2012): Addeding support to include template arguments in the generated type (template argument must be provided as early as possible).
1269 // DQ (1/24/2009): Added this "_nfi" function but refactored buildStructDeclaration to also use it (this needs to be done uniformally).
1270 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation = false);
1271 // SgClassDeclaration * buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation);
1272 ROSE_DLL_API SgClassDeclaration* buildClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
1273 
1274 // DQ (8/11/2013): I think that the specification of both SgTemplateParameterPtrList and SgTemplateArgumentPtrList is redundant with the nonDefiningDecl (which is a required parameter).
1275 // DQ (11/19/2011): Added to support template class declaration using EDG 4.x support (to support the template declarations directly in the AST).
1276 // SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi(const SgName& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl );
1278  SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList );
1279 
1281 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName& name, SgScopeStatement* scope=NULL);
1282 
1284 ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName& name, SgScopeStatement* scope=NULL);
1285 
1287 ROSE_DLL_API SgReturnStmt* buildReturnStmt(SgExpression* expression = NULL);
1288 ROSE_DLL_API SgReturnStmt* buildReturnStmt_nfi(SgExpression* expression);
1289 
1291 ROSE_DLL_API SgNullStatement* buildNullStatement();
1293 
1296 
1298 ROSE_DLL_API SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);
1299 
1301 ROSE_DLL_API SgCommonBlockObject* buildCommonBlockObject(std::string name="", SgExprListExp* exp_list=NULL);
1302 
1304 ROSE_DLL_API SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block=NULL);
1305 
1306 // driscoll6 (6/9/2011): Adding support for try stmts.
1308 ROSE_DLL_API SgCatchOptionStmt* buildCatchOptionStmt(SgVariableDeclaration* condition=NULL, SgStatement* body=NULL);
1309 
1311 ROSE_DLL_API SgAsyncStmt* buildAsyncStmt(SgBasicBlock *body);
1312 
1314 ROSE_DLL_API SgFinishStmt* buildFinishStmt(SgBasicBlock *body);
1315 
1317 ROSE_DLL_API SgAtStmt* buildAtStmt(SgExpression *expression, SgBasicBlock *body);
1318 
1319 // MH (11/12/2014): Added atomic support
1320 ROSE_DLL_API SgAtomicStmt* buildAtomicStmt(SgBasicBlock *body);
1321 
1322 ROSE_DLL_API SgWhenStmt* buildWhenStmt(SgExpression *expression, SgBasicBlock *body);
1323 
1324 // MH (9/16/2014): Added at support
1325 ROSE_DLL_API SgAtExp* buildAtExp(SgExpression *expression, SgBasicBlock *body);
1326 
1327 // MH (11/7/2014): Added finish expression support
1328 ROSE_DLL_API SgFinishExp* buildFinishExp(SgExpression *expression, SgBasicBlock *body);
1329 
1330 ROSE_DLL_API SgHereExp* buildHereExpression();
1331 
1332 ROSE_DLL_API SgDotDotExp* buildDotDotExp();
1333 
1334 
1335 // driscoll6 (6/9/2011): Adding support for try stmts.
1337 ROSE_DLL_API SgTryStmt* buildTryStmt(SgStatement* body,
1338  SgCatchOptionStmt* catch0=NULL,
1339  SgCatchOptionStmt* catch1=NULL,
1340  SgCatchOptionStmt* catch2=NULL,
1341  SgCatchOptionStmt* catch3=NULL,
1342  SgCatchOptionStmt* catch4=NULL);
1343 
1344 // charles4 (9/16/2011): Adding support for try stmts.
1346 //SgTryStmt* buildTryStmt(SgStatement *try_body, SgCatchStatementSeq *catches, SgStatement *finally_body = NULL);
1347 
1348 // charles4 (9/16/2011): Adding support for try stmts.
1350 ROSE_DLL_API SgTryStmt* buildTryStmt(SgBasicBlock *try_body, SgBasicBlock *finally_body = NULL);
1351 
1352 // charles4 (9/16/2011): Adding support for Catch Blocks.
1355 
1356 // charles4 (8/25/2011): Adding support for Java Synchronized stmts.
1359 
1360 // charles4 (8/25/2011): Adding support for Java Throw stmts.
1363 
1364 // charles4 (8/25/2011): Adding support for Java Foreach stmts.
1366 // SgJavaForEachStatement *buildJavaForEachStatement(SgInitializedName * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1367 ROSE_DLL_API SgJavaForEachStatement *buildJavaForEachStatement(SgVariableDeclaration * = NULL, SgExpression * = NULL, SgStatement * = NULL);
1368 
1369 // charles4 (8/25/2011): Adding support for Java Label stmts.
1371 ROSE_DLL_API SgJavaLabelStatement *buildJavaLabelStatement(const SgName &, SgStatement * = NULL);
1372 
1374 ROSE_DLL_API SgExecStatement* buildExecStatement(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1375 SgExecStatement* buildExecStatement_nfi(SgExpression* executable, SgExpression* globals = NULL, SgExpression* locals = NULL);
1376 
1378 ROSE_DLL_API SgPythonPrintStmt* buildPythonPrintStmt(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1379 SgPythonPrintStmt* buildPythonPrintStmt_nfi(SgExpression* dest = NULL, SgExprListExp* values = NULL);
1380 
1382 ROSE_DLL_API SgPythonGlobalStmt* buildPythonGlobalStmt(SgInitializedNamePtrList& names);
1383 SgPythonGlobalStmt* buildPythonGlobalStmt_nfi(SgInitializedNamePtrList& names);
1384 
1385 // DQ (4/30/2010): Added support for building asm statements.
1387 ROSE_DLL_API SgAsmStmt* buildAsmStatement(std::string s);
1388 SgAsmStmt* buildAsmStatement_nfi(std::string s);
1389 
1392 ROSE_DLL_API SgAsmStmt* buildMultibyteNopStatement( int n );
1393 
1395 SgBaseClass* buildBaseClass ( SgClassDeclaration* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect );
1396 // SgAccessModifier buildAccessModifier ( unsigned int access );
1397 
1399 ROSE_DLL_API SgStaticAssertionDeclaration* buildStaticAssertionDeclaration(SgExpression* condition, const SgName & string_literal);
1400 
1403 
1405 ROSE_DLL_API SgStatement* buildStatementFromString(const std::string & stmt_str, SgScopeStatement* scope);
1406 
1408 
1409 //--------------------------------------------------------------
1411 
1415 
1418 ROSE_DLL_API SgFile* buildFile(const std::string& inputFileName,const std::string& outputFileName, SgProject* project=NULL);
1419 
1421 
1423 SgSourceFile* buildSourceFile(const std::string& outputFileName, SgProject* project=NULL);
1424 
1426 ROSE_DLL_API PreprocessingInfo* buildComment(SgLocatedNode* target, const std::string & content,
1427  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before,
1428  PreprocessingInfo::DirectiveType dtype= PreprocessingInfo::CpreprocessorUnknownDeclaration);
1429 
1432  const std::string & content,
1433  PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before);
1434 
1435 #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
1438 #endif
1439 
1440 // 03/17/2014 PHL
1441 // //! Build an equivalence statement from two expression operands
1442 ROSE_DLL_API SgEquivalenceStatement*
1443 buildEquivalenceStatement(SgExpression* lhs,SgExpression* rhs);
1444 
1445 
1447 ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope,
1448  SgStatement *toInsert, SgStatement* original_before_copy);
1449 ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement* insertionPoint, bool insertionPointIsScope,
1450  SgNode* node_copy, SgNode* node_original);
1451 ROSE_DLL_API SgType* getTargetFileTypeSupport(SgType* snippet_type, SgScopeStatement* targetScope);
1452 ROSE_DLL_API SgType* getTargetFileType(SgType* snippet_type, SgScopeStatement* targetScope);
1453 ROSE_DLL_API SgSymbol* findAssociatedSymbolInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
1454 
1456 ROSE_DLL_API void errorCheckingTargetAST (SgNode* node_copy, SgNode* node_original, SgFile* targetFile, bool failOnWarning);
1457 
1458 //-----------------------------------------------------------------------------
1459 //#ifdef ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1460 //-----------------------------------------------------------------------------
1465 ROSE_DLL_API SgJavaMemberValuePair *buildJavaMemberValuePair(const SgName &, SgExpression *);
1468 ROSE_DLL_API SgJavaNormalAnnotation *buildJavaNormalAnnotation(SgType *, std::list<SgJavaMemberValuePair *>&);
1469 ROSE_DLL_API SgInitializedName *buildJavaFormalParameter(SgType *, const SgName &, bool is_var_args = false, bool is_final = false);
1470 
1471 ROSE_DLL_API SgJavaPackageStatement *buildJavaPackageStatement(std::string);
1472 ROSE_DLL_API SgJavaImportStatement *buildJavaImportStatement(std::string, bool);
1474 ROSE_DLL_API SgSourceFile *buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string);
1475 ROSE_DLL_API SgArrayType *getUniqueJavaArrayType(SgType *, int);
1476 ROSE_DLL_API SgJavaParameterizedType *getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *);
1481 
1483 
1484 
1485 //----------------------------------------------------------
1487 
1501 
1505 
1509 
1511 
1513 
1514 
1515 
1516  //----------------------build unary expressions----------------------
1518 
1522 template <class T>
1523  T* buildUnaryExpression(SgExpression* operand) {
1524  SgExpression* myoperand=operand;
1525  T* result = new T(myoperand, NULL);
1526  ROSE_ASSERT(result);
1527  if (myoperand!=NULL) {
1528  myoperand->set_parent(result);
1529  // set lvalue, it asserts operand!=NULL
1530  markLhsValues(result);
1531  }
1533  return result;
1534  }
1535 
1537 
1540 template <class T>
1541 T* buildUnaryExpression_nfi(SgExpression* operand) {
1542  SgExpression* myoperand = operand;
1543  T* result = new T(myoperand, NULL);
1544  ROSE_ASSERT(result);
1545 
1546  if (myoperand != NULL) {
1547  myoperand->set_parent(result);
1548  // set lvalue, it asserts operand!=NULL
1549  markLhsValues(result);
1550  }
1552 
1553  result->set_need_paren(false);
1554  return result;
1555  }
1556 
1557 //---------------------binary expressions-----------------------
1558 
1560 
1563  template <class T>
1564  T* buildBinaryExpression(SgExpression* lhs, SgExpression* rhs) {
1565  SgExpression* mylhs, *myrhs;
1566  mylhs = lhs;
1567  myrhs = rhs;
1568  T* result = new T(mylhs,myrhs, NULL);
1569  ROSE_ASSERT(result);
1570  if (mylhs!=NULL) {
1571  mylhs->set_parent(result);
1572  // set lvalue
1573  markLhsValues(result);
1574  }
1575  if (myrhs!=NULL) myrhs->set_parent(result);
1577  return result;
1578  }
1579 
1581 
1584  template <class T>
1585  T* buildBinaryExpression_nfi(SgExpression* lhs, SgExpression* rhs) {
1586  SgExpression* mylhs, *myrhs;
1587  mylhs = lhs;
1588  myrhs = rhs;
1589  T* result = new T(mylhs,myrhs, NULL);
1590  ROSE_ASSERT(result);
1591  if (mylhs!=NULL) {
1592  mylhs->set_parent(result);
1593  // set lvalue
1594  markLhsValues(result);
1595  }
1596  if (myrhs!=NULL) myrhs->set_parent(result);
1598  result->set_need_paren(false);
1599 
1600  return result;
1601  }
1602 
1603 } // end of namespace
1604 
1605 namespace Rose {
1606  namespace Frontend {
1607  namespace Java {
1608 
1609  extern ROSE_DLL_API SgClassDefinition *javaLangPackageDefinition;
1610  extern ROSE_DLL_API SgClassType *ObjectClassType;
1611  extern ROSE_DLL_API SgClassType *StringClassType;
1612  extern ROSE_DLL_API SgClassType *ClassClassType;
1613  extern ROSE_DLL_API SgVariableSymbol *lengthSymbol;
1614 
1615  }// ::Rose::frontend::java
1616  }// ::Rose::frontend
1617 }// ::Rose
1618 //-----------------------------------------------------------------------------
1619 //#endif // ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
1620 //-----------------------------------------------------------------------------
1621 
1622 #endif //ROSE_SAGE_BUILDER_INTERFACE
ROSE_DLL_API SgInitializedName * buildInitializedName_nfi(const SgName &name, SgType *type, SgInitializer *init)
Initialized names are tricky, their scope vary depending on context, so scope and symbol information ...
ROSE_DLL_API SgUntypedModuleScope * buildUntypedModuleScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
SgPythonGlobalStmt * buildPythonGlobalStmt_nfi(SgInitializedNamePtrList &names)
Build a variable declaration, handle symbol table transparently.
This class represents the notion of an initializer for a variable declaration or expression in a func...
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal_nfi(long long value, const std::string &str)
ROSE_DLL_API SgHereExp * buildHereExpression()
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a scope in C++ (e.g. global scope, fuction scope, etc.).
This class represents the concept of an instantiation of member function template or a member functio...
ROSE_DLL_API SgJavaMarkerAnnotation * buildJavaMarkerAnnotation(SgType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgClassNameRefExp * buildClassNameRefExp(SgClassSymbol *sym)
This class represents the concept of a class declaration statement. It includes the concept of an ins...
ROSE_DLL_API void clearScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgWcharVal * buildWcharVal(wchar_t value=0)
ROSE_DLL_API SgAsmStmt * buildAsmStatement(std::string s)
Build a NULL statement.
ROSE_DLL_API SgLambdaExp * buildLambdaExp(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
DQ (9/3/2014): Adding support for C++11 Lambda expressions.
This class represents the concept of a declaration list.
ROSE_DLL_API SgTypeIdOp * buildTypeIdOp(SgExpression *operand_expr, SgType *operand_type)
DQ (1/25/2013): Added support for typeId operators.
ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer(SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown)
This class represents a boolean value (expression value).
ROSE_DLL_API SgSuperExp * buildSuperExp_nfi(SgClassSymbol *sym)
SgCudaKernelExecConfig * buildCudaKernelExecConfig_nfi(SgExpression *grid=NULL, SgExpression *blocks=NULL, SgExpression *shared=NULL, SgExpression *stream=NULL)
Build a CUDA kernel execution configuration (<<>>)
ROSE_DLL_API SgInitializedName * buildJavaFormalParameter(SgType *, const SgName &, bool is_var_args=false, bool is_final=false)
Build a SgFile node and attach it to SgProject.
This class represents the notion of an n-ary comparison operation. This node is intended for use with...
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
Build the rhs of a variable declaration which includes an assignment.
ROSE_DLL_API SgArrayType * buildArrayType(SgType *base_type=NULL, SgExpression *index=NULL)
Build ArrayType.
This class represents the notion of an value (expression value).
ROSE_DLL_API SgTypedefDeclaration * buildTypedefDeclaration(const std::string &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a typedef declaration, such as: typedef int myint; typedef struct A {..} s_A;.
ROSE_DLL_API SgForInitStatement * buildForInitStatement()
Build a for init statement.
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement(SgStatement *item_selector=NULL, SgStatement *body=NULL)
Build a switch statement.
ROSE_DLL_API SgTemplateParameterPtrList * getTemplateParameterList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a C or C++ goto statement.
ROSE_DLL_API SgExecStatement * buildExecStatement(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build an exec statement.
ROSE_DLL_API SgClassDeclaration * buildClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgClassDeclaration *nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgModifierType * buildModifierType(SgType *base_type=NULL)
Build a modifier type.
SgBaseClass * buildBaseClass(SgClassDeclaration *classDeclaration, SgClassDefinition *classDefinition, bool isVirtual, bool isDirect)
DQ (5/6/2013): Added build functions to support SgBaseClass construction.
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp_nfi(SgExpression *exp)
ROSE_DLL_API SgReturnStmt * buildReturnStmt(SgExpression *expression=NULL)
Build a return statement.
ROSE_DLL_API SgMemberFunctionType * buildMemberFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList, SgClassDefinition *struct_name, unsigned int mfunc_specifier)
DQ (1/16/2009): Added to support member function in C++ (for new interface)
ROSE_DLL_API SgLabelRefExp * buildLabelRefExp(SgLabelSymbol *s)
Build a Fortran numeric label ref exp.
SgActualArgumentExpression * buildActualArgumentExpression_nfi(SgName arg_name, SgExpression *arg)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API void pushScopeStack(SgScopeStatement *stmt)
Public interfaces of the scope stack, should be stable.
This class represents the concept of the dynamic execution of a string, file, or code object...
ROSE_DLL_API SgTypeUnsignedShort * buildUnsignedShortType()
Built in simple types.
ROSE_DLL_API SgAtExp * buildAtExp(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardExtends(SgType *)
Build a SgFile node and attach it to SgProject.
SgMemberFunctionRefExp * buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
ROSE_DLL_API SgUntypedProgramHeaderDeclaration * buildUntypedProgramHeaderDeclaration(std::string name, SgUntypedInitializedNameList *parameters, SgUntypedType *type, SgUntypedFunctionScope *scope, SgUntypedNamedStatement *end_statement)
build a concept of scope in the untyped AST.
This class represents the concept of a C or C++ statement which contains a expression.
ROSE_DLL_API SgMemberFunctionRefExp * buildMemberFunctionRefExp(SgMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
ROSE_DLL_API SgUpcThreads * buildUpcThreads_nfi()
ROSE_DLL_API SgLongIntVal * buildLongIntVal_nfi(long value, const std::string &str)
ROSE_DLL_API SgTypeMatrix * buildMatrixType()
Build a Matlab Matrix Type.
This class represents a source file for a project (which may contian many source files and or directo...
ROSE_DLL_API SgTemplateFunctionDeclaration * buildDefiningTemplateFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, SgTemplateFunctionDeclaration *first_nondefining_declaration)
Build a variable declaration, handle symbol table transparently.
SgDefaultOptionStmt * buildDefaultOptionStmt_nfi(SgStatement *body)
Build a variable declaration, handle symbol table transparently.
This class represents the variable declaration or variable initialization withn a for loop...
ROSE_DLL_API SgModifierType * buildFortranKindType(SgType *base_type, SgExpression *kindExpression)
Build a type based on the Fortran kind mechanism.
ROSE_DLL_API SgAttributeSpecificationStatement * buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind)
Build Fortran attribute specification statement.
ROSE_DLL_API SgMagicColonExp * buildMagicColonExp()
Build a Matlab colon expression :
ROSE_DLL_API SgSuperExp * buildSuperExp(SgClassSymbol *sym)
Build super pointer.
This class represents the concept of a C++ sequence of catch statements.
ROSE_DLL_API SgBasicBlock * buildBasicBlock(SgStatement *stmt1=NULL, SgStatement *stmt2=NULL, SgStatement *stmt3=NULL, SgStatement *stmt4=NULL, SgStatement *stmt5=NULL, SgStatement *stmt6=NULL, SgStatement *stmt7=NULL, SgStatement *stmt8=NULL, SgStatement *stmt9=NULL, SgStatement *stmt10=NULL)
Build a SgBasicBlock, setting file info internally.
This class represents the notion of a unary operator. It is derived from a SgExpression because opera...
ROSE_DLL_API SgThisExp * buildThisExp_nfi(SgClassSymbol *sym)
ROSE_DLL_API SgActualArgumentExpression * buildActualArgumentExpression(SgName arg_name, SgExpression *arg)
Build an Actual Argument Expression.
ROSE_DLL_API SgAlignOfOp * buildAlignOfOp(SgExpression *exp=NULL)
Build alignof() expression with an expression parameter.
ROSE_DLL_API SgClassType * buildClassTemplateType(SgTemplateClassDeclaration *template_decl, Rose_STL_Container< SgNode * > &template_args)
Some support for building class template instantiation declarations.
bool inSwitchScope()
intended to be a private member, don't access it directly. could be changed any time ...
This class represents the GNU extension "statement expression" (thus is non-standard C and C++)...
This class represents the C++ throw expression (handled as a unary operator).
This class represents the rhs of a variable declaration which includes an optional assignment (e...
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal(long double value=0.0)
ROSE_DLL_API SgTypeLongDouble * buildLongDoubleType()
Built in simple types.
ROSE_DLL_API SgTypeComplex * buildComplexType(SgType *base_type=NULL)
Build a complex type.
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal_nfi(unsigned long v, const std::string &str)
ROSE_DLL_API SgLambdaExp * buildLambdaExp_nfi(SgLambdaCaptureList *lambda_capture_list, SgClassDeclaration *lambda_closure_class, SgFunctionDeclaration *lambda_function)
ROSE_DLL_API SgInitializedName * buildInitializedName(const SgName &name, SgType *type, SgInitializer *init=NULL)
Initialized names are tricky, their scope vary depending on context, so scope and symbol information ...
ROSE_DLL_API void popScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
This class represents the base class for all types.
ROSE_DLL_API SgStringVal * buildStringVal(std::string value="")
SgSetComprehension * buildSetComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
T * buildUnaryExpression(SgExpression *operand)
Template function to build a unary expression of type T. Instantiated functions include:buildAddressO...
Definition: sageBuilder.h:1523
ROSE_DLL_API SgJavaTypeExpression * buildJavaTypeExpression(SgType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgVarRefExp * buildVarRefExp(const SgName &name, SgScopeStatement *scope=NULL)
Build SgVarRefExp based on a variable's Sage name. It will lookup symbol table internally starting fr...
ROSE_DLL_API SgDotDotExp * buildDotDotExp()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUntypedFunctionDeclaration * buildUntypedFunctionDeclaration(std::string name, SgUntypedInitializedNameList *parameters, SgUntypedType *type, SgUntypedFunctionScope *scope, SgUntypedNamedStatement *end_statement)
build a concept of scope in the untyped AST.
SgCaseOptionStmt * buildCaseOptionStmt_nfi(SgExpression *key, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
Collection of streams.
Definition: Message.h:1579
This class represents the concept of a do-while statement.
ROSE_DLL_API SgFunctionType * buildFunctionType(SgType *return_type, SgFunctionParameterTypeList *typeList=NULL)
Build function type from return type and parameter type list.
ROSE_DLL_API SgSetComprehension * buildSetComprehension(SgExpression *elt, SgExprListExp *generators)
ROSE_DLL_API SgForInitStatement * buildForInitStatement_nfi(SgStatementPtrList &statements)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API AbstractHandle::abstract_handle * buildAbstractHandle(SgNode *n)
Build an abstract handle from a SgNode.
This class represents the concept of a class name within the compiler.
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal(unsigned int v=0)
Build an unsigned integer.
SourcePositionClassification SourcePositionClassificationMode
C++ SageBuilder namespace specific state for storage of the source code position state (used to contr...
Classify as compiler generated code (e.g. template instantiation).
Definition: sageBuilder.h:144
ROSE_DLL_API SgTypeExpression * buildTypeExpression(SgType *type)
DQ (7/24/2014): Adding support for c11 generic operands.
SgListExp * buildListExp_nfi()
ROSE_DLL_API SgExprStatement * buildFunctionCallStmt(const SgName &name, SgType *return_type, SgExprListExp *parameters=NULL, SgScopeStatement *scope=NULL)
Build a regular function call statement.
ROSE_DLL_API SgModifierType * buildRestrictType(SgType *base_type)
Build a restrict type.
This class represents the concept of an enum declaration.
ROSE_DLL_API SgStatementExpression * buildStatementExpression_nfi(SgStatement *exp)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API void testTemplateParameterParents(SgDeclarationStatement *decl)
DQ (9/16/2012): Added function to support setting the template parameters and setting their parents (...
ROSE_DLL_API SgUpcMythread * buildUpcMythread_nfi()
ROSE_DLL_API SgKeyDatumPair * buildKeyDatumPair(SgExpression *key, SgExpression *datum)
Build a key-datum pair.
SgCompoundLiteralExp * buildCompoundLiteralExp_nfi(SgVariableSymbol *varSymbol)
Build function for compound literals (uses a SgVariableSymbol and is similar to buildVarRefExp_nfi())...
SgDictionaryComprehension * buildDictionaryComprehension_nfi(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
ROSE_DLL_API SgEquivalenceStatement * buildEquivalenceStatement(SgExpression *lhs, SgExpression *rhs)
Build a SgFile node and attach it to SgProject.
This class represents the "this" operator (can be applied to any member data).
ROSE_DLL_API SgExprListExp * buildExprListExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgExprListExp, used for function call parameter list etc.
void set_parent(SgNode *parent)
All nodes in the AST contain a reference to a parent node.
This class represents a string type used for SgStringVal IR node.
SgClassNameRefExp * buildClassNameRefExp_nfi(SgClassSymbol *sym)
ROSE_DLL_API SgModifierType * buildUpcStrictType(SgType *base_type=NULL)
Build a UPC strict type.
ROSE_DLL_API SgTemplateFunctionDeclaration * buildNondefiningTemplateFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope=NULL, SgExprListExp *decoratorList=NULL, SgTemplateParameterPtrList *templateParameterList=NULL)
Build a variable declaration, handle symbol table transparently.
This class represents the notion of an n-ary boolean operation. This node is intended for use with Py...
ROSE_DLL_API SgComprehension * buildComprehension(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
attribute_spec_enum
Fortran specific classification of attribute statements (each corresponds to a declaration attribute)...
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
This class represents the notion of a declared variable.
ROSE_DLL_API SgModifierType * buildUpcBlockNumberType(SgType *base_type, long block_factor)
Build a UPC shared[n] type.
ROSE_DLL_API SgThrowOp * buildThrowOp(SgExpression *, SgThrowOp::e_throw_kind)
Build a ThrowOp expression.
SgNullStatement * buildNullStatement_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgFunctionCallExp * buildFunctionCallExp(SgFunctionSymbol *sym, SgExprListExp *parameters=NULL)
Build a function call expression.
ROSE_DLL_API SgJavaParameterizedType * getUniqueJavaParameterizedType(SgNamedType *, SgTemplateParameterPtrList *)
Build a SgFile node and attach it to SgProject.
SgAssertStmt * buildAssertStmt_nfi(SgExpression *test)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a member function declaration statement.
This class represents the concept of a C and C++ case option (used within a switch statement)...
ROSE_DLL_API SgTemplateArgumentPtrList * getTemplateArgumentList(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgStaticAssertionDeclaration * buildStaticAssertionDeclaration(SgExpression *condition, const SgName &string_literal)
DQ (7/25/2014): Adding support for C11 static assertions.
ROSE_DLL_API SgJavaSingleMemberAnnotation * buildJavaSingleMemberAnnotation(SgType *, SgExpression *)
Build a SgFile node and attach it to SgProject.
This class represents the concept of a function declaration statement.
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SgAsmStmt * buildAsmStatement_nfi(std::string s)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgIfStmt * buildIfStmt(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build if statement.
ROSE_DLL_API SgEnumDeclaration * buildNondefiningEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope)
Build an enum first nondefining declaration, without file info.
This class represents the concept of a C Assembler statement (untested).
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
ROSE_DLL_API SgReferenceType * buildReferenceType(SgType *base_type=NULL)
Build a reference type.
ROSE_DLL_API SgTypeSignedLongLong * buildSignedLongLongType()
Built in simple types.
This class represents the concept of a C and C++ expression list.
ROSE_DLL_API SgIntVal * buildIntValHex(int value=0)
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp_nfi(SgExpression *op)
ROSE_DLL_API SgTypeUnsignedInt * buildUnsignedIntType()
Built in simple types.
ROSE_DLL_API void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgNode *node_copy, SgNode *node_original)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgNewExp * buildNewExp(SgType *type, SgExprListExp *exprListExp, SgConstructorInitializer *constInit, SgExpression *expr, short int val, SgFunctionDeclaration *funcDecl)
SgFunctionParameterList * buildFunctionParameterList_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeOfType * buildTypeOfType(SgExpression *base_expression, SgType *base_type)
Build a GNU typeof operator.
This class represents the "sizeof()" operator (applied to any type).
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardUnbound()
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgArrayType * getUniqueJavaArrayType(SgType *, int)
Build a SgFile node and attach it to SgProject.
SgSourceFile * buildSourceFile(const std::string &outputFileName, SgProject *project=NULL)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgBoolValExp * buildBoolValExp(int value=0)
Build a bool value expression, the name convention of SgBoolValExp is little different from others fo...
ROSE_DLL_API SgType * getTargetFileType(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgProcedureHeaderStatement * buildProcedureHeaderStatement(const SgName &name, SgType *return_type, SgFunctionParameterList *parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUpcBarrierStatement * buildUpcBarrierStatement_nfi(SgExpression *exp)
Build a UPC barrier statement.
ROSE_DLL_API SgIntVal * buildIntVal(int value=0)
Build an integer value expression.
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp(int parameter_number, int parameter_level)
ROSE_DLL_API SgPragma * buildPragma(const std::string &name)
Build SgPragma.
Main namespace for the ROSE library.
ROSE_DLL_API SgPlusPlusOp * buildPlusPlusOp(SgExpression *op=NULL)
ROSE_DLL_API SgVarRefExp * buildOpaqueVarRefExp(const std::string &varName, SgScopeStatement *scope=NULL)
Build a variable reference expression at scope to an opaque variable which has unknown information ex...
ROSE_DLL_API SgJavaMemberValuePair * buildJavaMemberValuePair(const SgName &, SgExpression *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUntypedGlobalScope * buildUntypedGlobalScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
ROSE_DLL_API SgCommonBlock * buildCommonBlock(SgCommonBlockObject *first_block=NULL)
Build a Fortran Common statement.
ROSE_DLL_API SgReturnStmt * buildReturnStmt_nfi(SgExpression *expression)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgShortVal * buildShortValHex(short value=0)
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntValHex(unsigned long long v=0)
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement(SgStatement *stmt)
Build a StmtDeclarationStmt.
This class represents the notion of an value (expression value).
ROSE_DLL_API SgFortranIncludeLine * buildFortranIncludeLine(std::string filename)
Build Fortran include line.
ROSE_DLL_API SgConstructorInitializer * buildConstructorInitializer_nfi(SgMemberFunctionDeclaration *declaration, SgExprListExp *args, SgType *expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown)
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration(SgName name, SgScopeStatement *scope)
DQ (11/7/2009): Added functions to build C++ class.
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp_nfi(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgVarRefExp * buildJavaArrayLengthVarRefExp()
Build a SgFile node and attach it to SgProject.
RelativePositionType
MK: Enum type to store if the directive goes before or after the corresponding line of source code...
ROSE_DLL_API SgCatchOptionStmt * buildCatchOptionStmt(SgVariableDeclaration *condition=NULL, SgStatement *body=NULL)
Build a catch statement.
This class represents the concept of a C trinary conditional expression (e.g. "test ...
ROSE_DLL_API SgDoubleVal * buildDoubleVal_nfi(double value, const std::string &str)
ROSE_DLL_API SgRangeExp * buildRangeExp(SgExpression *start)
Build a Matlab range expression like start:end or start:stride:end.
This class represents the notion of an expression. Expressions are derived from SgLocatedNodes, since similar to statement, expressions have a concrete location within the user's source code.
ROSE_DLL_API SgStringConversion * buildStringConversion(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgFunctionCallExp * buildFunctionCallExp_nfi(SgExpression *f, SgExprListExp *parameters=NULL)
ROSE_DLL_API SgTypeVoid * buildVoidType()
Built in simple types.
ROSE_DLL_API SgShortVal * buildShortVal_nfi(short value, const std::string &str)
ROSE_DLL_API SgClassDeclaration * buildClassDeclaration(SgName name, SgScopeStatement *scope)
DQ (11/7/2009): Added function to build C++ class (builds both the non-defining and defining declarat...
ROSE_DLL_API SgTypeInt * buildIntType()
Built in simple types.
ROSE_DLL_API SgCompoundInitializer * buildCompoundInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build a compound initializer, for vector type initialization.
SgKeyDatumPair * buildKeyDatumPair_nfi(SgExpression *key, SgExpression *datum)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp(SgExpression *op=NULL)
ROSE_DLL_API SgTemplateMemberFunctionDeclaration * buildNondefiningTemplateMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList *templateParameterList)
Build a variable declaration, handle symbol table transparently.
SgTypeTraitBuiltinOperator * buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters)
ROSE_DLL_API SgFunctionParameterList * buildFunctionParameterList(SgInitializedName *in1=NULL, SgInitializedName *in2=NULL, SgInitializedName *in3=NULL, SgInitializedName *in4=NULL, SgInitializedName *in5=NULL, SgInitializedName *in6=NULL, SgInitializedName *in7=NULL, SgInitializedName *in8=NULL, SgInitializedName *in9=NULL, SgInitializedName *in10=NULL)
Build an empty SgFunctionParameterList, possibly with some initialized names filled in...
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp(SgExpression *exp=NULL)
Build sizeof() expression with an expression parameter.
ROSE_DLL_API SgUntypedScope * buildUntypedScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
ROSE_DLL_API SgTypeUnsignedChar * buildUnsignedCharType()
Built in simple types.
ROSE_DLL_API SgModifierType * buildConstType(SgType *base_type=NULL)
Build a const type.
ROSE_DLL_API SgMinusOp * buildMinusOp_nfi(SgExpression *op)
ROSE_DLL_API SgAsyncStmt * buildAsyncStmt(SgBasicBlock *body)
MH (6/10/2014): Added async support.
ROSE_DLL_API SgDoWhileStmt * buildDoWhileStmt(SgStatement *body, SgStatement *condition)
Build do-while statement.
ROSE_DLL_API SgTupleExp * buildTupleExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgTupleExp.
This class represents the notion of a break statement (typically used in a switch statment)...
ROSE_DLL_API SgMatrixExp * buildMatrixExp(SgExprListExp *firstRow)
Build a Matlab Matrix.
ROSE_DLL_API SgUntypedFunctionScope * buildUntypedFunctionScope(SgUntypedDeclarationStatementList *declaration_list, SgUntypedStatementList *statement_list, SgUntypedFunctionDeclarationList *function_list)
build a concept of scope in the untyped AST.
ROSE_DLL_API SgClassDeclaration * buildJavaDefiningClassDeclaration(SgScopeStatement *, std::string, SgClassDeclaration::class_types kind=SgClassDeclaration::e_class)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntValHex(unsigned int v=0)
This class represents the concept of a name within the compiler.
ROSE_DLL_API SgNullExpression * buildNullExpression_nfi()
No file info version of buildNullExpression(). File info is to be set later on.
T * buildUnaryExpression_nfi(SgExpression *operand)
Template function to build a unary expression of type T with no file info. Instantiated functions inc...
Definition: sageBuilder.h:1541
ROSE_DLL_API SgTemplateVariableDeclaration * buildTemplateVariableDeclaration_nfi(const SgName &name, SgType *type, SgInitializer *varInit, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNamespaceDefinitionStatement * buildNamespaceDefinition(SgNamespaceDeclarationStatement *d=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeLong * buildLongType()
Built in simple types.
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer(SgExprListExp *initializers=NULL, SgType *type=NULL)
Build an aggregate initializer.
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp_nfi(SgExpression *exp)
ROSE_DLL_API SgMemberFunctionDeclaration * buildDefiningMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation, unsigned int functionConstVolatileFlags, SgMemberFunctionDeclaration *first_nondefinng_declaration, SgTemplateArgumentPtrList *templateArgumentsList)
Build a defining ( non-prototype) member function declaration.
ROSE_DLL_API void setSourcePosition(SgNode *node)
Set the source code positon for the current (input) node.
ROSE_DLL_API SgNoexceptOp * buildNoexceptOp(SgExpression *exp=NULL)
Build noecept operator expression with an expression parameter.
ROSE_DLL_API SgModifierType * buildUpcBlockIndefiniteType(SgType *base_type=NULL)
Build a UPC shared[] type.
ROSE_DLL_API SgConstVolatileModifier * buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype=SgConstVolatileModifier::e_unknown)
Build a const/volatile type qualifier.
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongVal(unsigned long v=0)
Build a unsigned long integer.
ROSE_DLL_API SgVariableDeclaration * buildVariableDeclaration(const SgName &name, SgType *type, SgInitializer *varInit=NULL, SgScopeStatement *scope=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgStringConversion * buildStringConversion_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
SgPythonPrintStmt * buildPythonPrintStmt_nfi(SgExpression *dest=NULL, SgExprListExp *values=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgJavaLabelStatement * buildJavaLabelStatement(const SgName &, SgStatement *=NULL)
Build a Java Label statement.
ROSE_DLL_API SgStmtDeclarationStatement * buildStmtDeclarationStatement_nfi(SgStatement *stmt)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTemplateParameter * buildTemplateParameter(SgTemplateParameter::template_parameter_enum parameterType, SgType *)
Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum { parameter_...
This class represents the concept of a class definition in C++.
SgTemplateFunctionRefExp * buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol *sym)
DQ (12/15/2011): Adding template declaration support to the AST.
ROSE_DLL_API SgJavaForEachStatement * buildJavaForEachStatement(SgVariableDeclaration *=NULL, SgExpression *=NULL, SgStatement *=NULL)
Build a Java Foreach statement.
This class represents strings within the IR nodes.
ROSE_DLL_API SgLongIntVal * buildLongIntVal(long value=0)
Build a long integer value expression.
ROSE_DLL_API bool emptyScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgMinusMinusOp * buildMinusMinusOp_nfi(SgExpression *op)
SourcePositionClassification
Definition: sageBuilder.h:138
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal(unsigned short v=0)
Build an unsigned short integer.
ROSE_DLL_API SgScopeStatement * topScopeStack()
intended to be a private member, don't access it directly. could be changed any time ...
SgWhileStmt * buildWhileStmt_nfi(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNullStatement * buildNullStatement()
Build a NULL statement.
ROSE_DLL_API SgClassDeclaration * buildStructDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
Build a structure, It is also a declaration statement in SAGE III.
Functions that build an AST.
Definition: sageBuilder.h:31
This class is intended to be a wrapper around SgStatements, allowing them to exist in scopes that onl...
ROSE_DLL_API SgComplexVal * buildImaginaryVal_nfi(SgValueExp *imaginary_value, const std::string &str)
SgContinueStmt * buildContinueStmt_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgEnumVal * buildEnumVal_nfi(int value, SgEnumDeclaration *decl, SgName name)
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal_nfi(unsigned char v, const std::string &str)
ROSE_DLL_API SgAssertStmt * buildAssertStmt(SgExpression *test)
Build a Assert statement.
ROSE_DLL_API SgTemplateClassDeclaration * buildTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateClassDeclaration *nonDefiningDecl, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build a variable declaration, handle symbol table transparently.
Functions that are useful when operating on the AST.
Definition: sageBuilder.h:25
ROSE_DLL_API SgJavaQualifiedType * getUniqueJavaQualifiedType(SgClassDeclaration *, SgNamedType *, SgNamedType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgAggregateInitializer * buildAggregateInitializer_nfi(SgExprListExp *initializers, SgType *type=NULL)
ROSE_DLL_API SgClassDefinition * buildClassDefinition(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
ROSE_DLL_API SgCastExp * buildCastExp_nfi(SgExpression *operand_i, SgType *expression_type, SgCastExp::cast_type_enum cast_type)
ROSE_DLL_API SgTypeUnsignedLong * buildUnsignedLongType()
Built in simple types.
subprogram_kind_enum
Classification for different types of Fortran subprograms.
ROSE_DLL_API SgSymbol * findAssociatedSymbolInTargetAST(SgDeclarationStatement *snippet_declaration, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal_nfi(unsigned long long v, const std::string &str)
SgTemplateMemberFunctionRefExp * buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol *sym, bool virtual_call, bool need_qualifier)
DQ (12/29/2011): Adding template declaration support to the AST.
ROSE_DLL_API SgBoolValExp * buildBoolValExp_nfi(int value)
ROSE_DLL_API SgAtomicStmt * buildAtomicStmt(SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
SgClassDefinition * buildClassDefinition_nfi(SgClassDeclaration *d=NULL, bool buildTemplateInstantiation=false)
Build a class definition scope statement.
ROSE_DLL_API SgUpcForAllStatement * buildUpcForAllStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgExpression *affinity, SgStatement *loop_body)
Build a UPC forall statement.
ROSE_DLL_API SgLambdaCapture * buildLambdaCapture_nfi(SgExpression *capture_variable, SgExpression *source_closure_variable, SgExpression *closure_variable)
ROSE_DLL_API SgStatementExpression * buildStatementExpression(SgStatement *exp)
Build a GNU statement expression.
ROSE_DLL_API SgStringVal * buildStringVal_nfi(std::string value)
ROSE_DLL_API SgFinishStmt * buildFinishStmt(SgBasicBlock *body)
MH (6/11/2014): Added finish support.
ROSE_DLL_API SgThisExp * buildThisExp(SgClassSymbol *sym)
Build this pointer.
ROSE_DLL_API SgJavaWildcardType * getUniqueJavaWildcardSuper(SgType *)
Build a SgFile node and attach it to SgProject.
This class represents the notion of a typedef declaration.
ROSE_DLL_API SgLabelStatement * buildLabelStatement(const SgName &name, SgStatement *stmt=NULL, SgScopeStatement *scope=NULL)
Build a label statement, name is the label's name. Handling label symbol and scope internally...
ROSE_DLL_API SgFile * buildFile(const std::string &inputFileName, const std::string &outputFileName, SgProject *project=NULL)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgWcharVal * buildWcharVal_nfi(wchar_t value, const std::string &str)
ROSE_DLL_API SgVariableDefinition * buildVariableDefinition_nfi(SgVariableDeclaration *decl, SgInitializedName *init_name, SgInitializer *init)
Build variable definition.
ROSE_DLL_API SgConditionalExp * buildConditionalExp(SgExpression *test=NULL, SgExpression *a=NULL, SgExpression *b=NULL)
Build a conditional expression ?:
SgFunctionRefExp * buildFunctionRefExp_nfi(SgFunctionSymbol *sym)
ROSE_DLL_API SgUnsignedLongLongIntVal * buildUnsignedLongLongIntVal(unsigned long long v=0)
Build an unsigned long long integer.
This class represents the notion of an value (expression value).
This class represents the base class for all IR nodes within Sage III.
Definition: Cxx_Grammar.h:8578
ROSE_DLL_API SgTypedefDeclaration * buildTypedefDeclaration_nfi(const std::string &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a catch within a try-catch construct used in C++ exception handl...
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortValHex(unsigned short v=0)
ROSE_DLL_API SgFunctionParameterTypeList * buildFunctionParameterTypeList(SgFunctionParameterList *paralist)
Build SgFunctionParameterTypeList from SgFunctionParameterList.
ROSE_DLL_API std::string display(SourcePositionClassification &scp)
display function for debugging
ROSE_DLL_API SgListComprehension * buildListComprehension(SgExpression *elt, SgExprListExp *generators)
This class represents the notion of an value (expression value).
This class represents the concept of a variable name within the compiler (a shared container for the ...
This class represents a lambda expression.
ROSE_DLL_API SgFinishExp * buildFinishExp(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeSignedChar * buildSignedCharType()
Built in simple types.
ROSE_DLL_API SgFloatVal * buildFloatVal(float value=0.0)
ROSE_DLL_API SgShortVal * buildShortVal(short value=0)
SgPragmaDeclaration * buildPragmaDeclaration_nfi(const std::string &name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
SgScopeStatement * getGlobalScopeFromScopeStack()
Support to retrive the SgGlobal from the internal scope stack (error if not present in a non-empty li...
ROSE_DLL_API SgFloatVal * buildFloatVal_nfi(float value, const std::string &str)
ROSE_DLL_API SgDictionaryExp * buildDictionaryExp(std::vector< SgKeyDatumPair * > pairs)
Build a list of key-datum pairs.
ROSE_DLL_API void setSourcePositionClassificationMode(SourcePositionClassification X)
Set the current source position classification (defines how IR nodes built by the SageBuilder interfa...
ROSE_DLL_API SgClassExp * buildClassExp(SgClassSymbol *sym)
Build class pointer.
ROSE_DLL_API SgContinueStmt * buildContinueStmt()
Build a continue statement.
ROSE_DLL_API SgSourceFile * buildJavaSourceFile(SgProject *, std::string, SgClassDefinition *, std::string)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp_nfi()
ROSE_DLL_API SgVarArgOp * buildVarArgOp_nfi(SgExpression *operand_i, SgType *expression_type)
Build vararg op expression.
ROSE_DLL_API void setTemplateArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateArgumentsList_input)
DQ (9/16/2012): Added function to support setting the template arguments and setting their parents (a...
ROSE_DLL_API void setTemplateParametersInDeclaration(SgDeclarationStatement *decl, SgTemplateParameterPtrList *templateParametersList_input)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgNaryComparisonOp * buildNaryComparisonOp(SgExpression *lhs)
driscoll6 (7/20/11) : Support n-ary operators for python
This class represents the conversion of an arbitrary expression to a string. This node is intended fo...
ROSE_DLL_API SgVariantExpression * buildVariantExpression()
ROSE_DLL_API SgClassDeclaration * buildNondefiningClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a structure first nondefining declaration, without file info.
ROSE_DLL_API SgUpcWaitStatement * buildUpcWaitStatement_nfi(SgExpression *exp)
Build a UPC wait statement.
ROSE_DLL_API SgJavaImportStatement * buildJavaImportStatement(std::string, bool)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgUntypedFile * buildUntypedFile(SgUntypedGlobalScope *scope)
build a concept of scope in the untyped AST.
This class represents the concept of a block (not a basic block from control flow analysis)...
This class represents the concept of a C++ namespace declaration.
ROSE_DLL_API SgGotoStatement * buildGotoStatement(SgLabelStatement *label=NULL)
Build a goto statement.
ROSE_DLL_API SgTypeSignedLong * buildSignedLongType()
Built in simple types.
This class represents a list display.
This class represents the notion of a statement.
ROSE_DLL_API SgCatchStatementSeq * buildCatchStatementSeq(SgCatchOptionStmt *=NULL)
Build an initial sequence of Catch blocks containing 0 or 1 element.
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList()
For preprocessing information including source comments, #include , #if, #define, etc...
ROSE_DLL_API SgDictionaryComprehension * buildDictionaryComprehension(SgKeyDatumPair *kd_pair, SgExprListExp *generators)
ROSE_DLL_API SgStatement * buildStatementFromString(const std::string &stmt_str, SgScopeStatement *scope)
Liao (9/18/2015): experimental support of building a statement from a string.
This class represents the concept of a for loop.
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration_nfi(const SgName &name, bool unnamednamespace, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API void setTemplateSpecializationArgumentsInDeclaration(SgDeclarationStatement *decl, SgTemplateArgumentPtrList *templateSpecializationArgumentsList_input)
Build a variable declaration, handle symbol table transparently.
SgBreakStmt * buildBreakStmt_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTemplateType * buildTemplateType(SgName name="", int template_parameter_position=-1)
Build a template type, used for template parameter and later argument.
ROSE_DLL_API SgRvalueReferenceType * buildRvalueReferenceType(SgType *base_type)
Build a rvalue reference type.
ROSE_DLL_API SgAtStmt * buildAtStmt(SgExpression *expression, SgBasicBlock *body)
MH (6/11/2014): Added at support.
SgTupleExp * buildTupleExp_nfi()
ROSE_DLL_API SgTypeSignedShort * buildSignedShortType()
Built in simple types.
SgGotoStatement * buildGotoStatement_nfi(SgLabelStatement *label)
Build a variable declaration, handle symbol table transparently.
SgCompoundLiteralExp * buildCompoundLiteralExp(SgVariableSymbol *varSymbol)
ROSE_DLL_API SgIfStmt * buildIfStmt_nfi(SgStatement *conditional, SgStatement *true_body, SgStatement *false_body)
Build a variable declaration, handle symbol table transparently.
Classify as a transformation.
Definition: sageBuilder.h:143
ROSE_DLL_API SgTemplateMemberFunctionDeclaration * buildDefiningTemplateMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration *first_nondefing_declaration)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgLambdaRefExp * buildLambdaRefExp(SgType *return_type, SgFunctionParameterList *params, SgScopeStatement *scope)
Build lambda expression.
ROSE_DLL_API SgModifierType * buildUpcSharedType(SgType *base_type=NULL, long layout=-1)
Build a UPC shared type.
ROSE_DLL_API SgWhileStmt * buildWhileStmt(SgStatement *condition, SgStatement *body, SgStatement *else_body=NULL)
Build while statement.
This class represents a C99 complex type.
This class represents a tuple display.
This class represents a type for all functions.
ROSE_DLL_API SgPointerType * buildPointerType(SgType *base_type=NULL)
Build a pointer type.
ROSE_DLL_API SgComplexVal * buildImaginaryVal(long double imaginary_value)
This class represents the concept of a namespace definition.
ROSE_DLL_API void buildDoWhileStatement_nfi(SgDoWhileStmt *result, SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
This class represents the numeric negation of a value. Not to be confused with SgSubtractOp.
This class represents the concept of a C Assembler statement (untested).
ROSE_DLL_API SgExprStatement * buildAssignStatement_ast_translate(SgExpression *lhs, SgExpression *rhs)
This version does not recursively reset the file info as a transformation.
T * buildBinaryExpression(SgExpression *lhs, SgExpression *rhs)
Template function to build a binary expression of type T, taking care of parent pointers, file info, lvalue, etc. Available instances include: buildAddOp(), buildAndAssignOp(), buildAndOp(), buildArrowExp(),buildArrowStarOp(), buildAssignOp(),buildBitAndOp(),buildBitOrOp(),buildBitXorOp(),buildCommaOpExp(), buildConcatenationOp(),buildDivAssignOp(),buildDivideOp(),buildDotExp(),buildEqualityOp(),buildExponentiationOp(),buildGreaterOrEqualOp(),buildGreaterThanOp(),buildIntegerDivideOp(),buildIorAssignOp(),buildLessOrEqualOp(),buildLessThanOp(),buildLshiftAssignOp(),buildLshiftOp(),buildMinusAssignOp(),buildModAssignOp(),buildModOp(),buildMultAssignOp(),buildMultiplyOp(),buildNotEqualOp(),buildOrOp(),buildPlusAssignOp(),buildPntrArrRefExp(),buildRshiftAssignOp(),buildRshiftOp(),buildScopeOp(),buildSubtractOp()buildXorAssignOp()
Definition: sageBuilder.h:1564
ROSE_DLL_API SgNullptrValExp * buildNullptrValExp()
DQ (7/31/2014): Adding support for C++11 nullptr const value expressions.
This class represents the concept of a C or C++ default case within a switch statement.
ROSE_DLL_API SgComplexVal * buildComplexVal_nfi(SgValueExp *real_value, SgValueExp *imaginary_value, const std::string &str)
ROSE_DLL_API SgBreakStmt * buildBreakStmt()
Build a break statement.
This class represents the concept of an "if" construct.
ROSE_DLL_API SgTypeDouble * buildDoubleType()
Built in simple types.
to specify a construct using a specifier Can be used alone or with parent handles when relative speci...
ROSE_DLL_API SgJavaNormalAnnotation * buildJavaNormalAnnotation(SgType *)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgWithStatement * buildWithStatement(SgExpression *expr, SgStatement *body)
Build a with statement.
ROSE_DLL_API PreprocessingInfo * buildComment(SgLocatedNode *target, const std::string &content, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before, PreprocessingInfo::DirectiveType dtype=PreprocessingInfo::CpreprocessorUnknownDeclaration)
Build and attach a comment, comment style is inferred from the language type of the target node if no...
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntValHex(long long value=0)
ROSE_DLL_API SgTemplateTypedefDeclaration * buildTemplateTypedefDeclaration_nfi(const SgName &name, SgType *base_type, SgScopeStatement *scope=NULL, bool has_defining_base=false)
Build a variable declaration, handle symbol table transparently.
SgTemplateClassDefinition * buildTemplateClassDefinition(SgTemplateClassDeclaration *d=NULL)
Build a template class definition statement.
SgExprListExp * buildExprListExp_nfi()
ROSE_DLL_API SgTypeBool * buildBoolType()
Built in simple types.
This class represents the notion of an expression or statement which has a position within the source...
Set pointers to Sg_File_Info objects to NULL.
Definition: sageBuilder.h:145
This class represents the variable refernece in expressions.
This class represents the concept of a do-while statement.
ROSE_DLL_API void errorCheckingTargetAST(SgNode *node_copy, SgNode *node_original, SgFile *targetFile, bool failOnWarning)
Error checking the inserted snippet AST.
ROSE_DLL_API SgTypeUnsignedLongLong * buildUnsignedLongLongType()
Built in simple types.
ROSE_DLL_API SgSwitchStatement * buildSwitchStatement_nfi(SgStatement *item_selector, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUntypedSubroutineDeclaration * buildUntypedSubroutineDeclaration(std::string name, SgUntypedInitializedNameList *parameters, SgUntypedType *type, SgUntypedFunctionScope *scope, SgUntypedNamedStatement *end_statement)
build a concept of scope in the untyped AST.
ROSE_DLL_API SgMemberFunctionDeclaration * buildNondefiningMemberFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, unsigned int functionConstVolatileFlags, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a prototype member function declaration.
This class represents the definition (initialization) of a variable.
ROSE_DLL_API SgNullExpression * buildNullExpression()
Build a null expression, set file info as the default one.
SgPassStatement * buildPassStatement_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgLambdaCaptureList * buildLambdaCaptureList_nfi()
This class represents the concept of a C++ call to the delete operator.
This class represents the concept of a C++ call to the new operator.
ROSE_DLL_API SgFunctionParameterRefExp * buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level)
ROSE_DLL_API void setTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a C or C++ continue statement.
ROSE_DLL_API SgEnumVal * buildEnumVal(int value, SgEnumDeclaration *decl, SgName name)
ROSE_DLL_API void setTemplateParameterParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgMinusOp * buildMinusOp(SgExpression *op=NULL)
ROSE_DLL_API SgNamespaceDeclarationStatement * buildNamespaceDeclaration(const SgName &name, SgScopeStatement *scope=NULL)
tps (09/02/2009) : Added support for building namespaces
ROSE_DLL_API SgUpcNotifyStatement * buildUpcNotifyStatement_nfi(SgExpression *exp)
Build a UPC notify statement.
ROSE_DLL_API SgTemplateInstantiationTypedefDeclaration * buildTemplateInstantiationTypedefDeclaration_nfi(SgName &name, SgType *base_type, SgScopeStatement *scope, bool has_defining_base, SgTemplateTypedefDeclaration *templateTypedefDeclaration, SgTemplateArgumentPtrList &templateArgumentList)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer_nfi(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
ROSE_DLL_API SgTypeWchar * buildWcharType()
Built in simple types.
ROSE_DLL_API SgIntVal * buildIntVal_nfi(int value, const std::string &str)
SgDeleteExp * buildDeleteExp_nfi(SgExpression *target, bool is_array=false, bool need_global_specifier=false, SgFunctionDeclaration *deleteOperatorDeclaration=NULL)
Build a variable declaration, handle symbol table transparently.
std::list< SgScopeStatement * > ScopeStack
intended to be a private member, don't access it directly. could be changed any time ...
ROSE_DLL_API SgType * getTargetFileTypeSupport(SgType *snippet_type, SgScopeStatement *targetScope)
Build a SgFile node and attach it to SgProject.
This class represents the member function being called and must be assembled in the SgFunctionCall wi...
ROSE_DLL_API SgCaseOptionStmt * buildCaseOptionStmt(SgExpression *key=NULL, SgStatement *body=NULL)
Build a case option statement.
ROSE_DLL_API SgCastExp * buildCastExp(SgExpression *operand_i=NULL, SgType *expression_type=NULL, SgCastExp::cast_type_enum cast_type=SgCastExp::e_C_style_cast)
Build a type casting expression.
ROSE_DLL_API void setTemplateNameInTemplateInstantiations(SgFunctionDeclaration *func, const SgName &name)
DQ (2/11/2012): Added support to set the template name in function template instantiations (member an...
ROSE_DLL_API SgFunctionRefExp * buildFunctionRefExp(const SgName &name, const SgType *func_type, SgScopeStatement *scope=NULL)
Build SgFunctionRefExp based on a C++ function's name and function type. It will lookup symbol table ...
ROSE_DLL_API SgTemplateClassDeclaration * buildNondefiningTemplateClassDeclaration_nfi(const SgName &name, SgClassDeclaration::class_types kind, SgScopeStatement *scope, SgTemplateParameterPtrList *templateParameterList, SgTemplateArgumentPtrList *templateSpecializationArgumentList)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgDeclType * buildDeclType(SgExpression *base_expression, SgType *base_type)
Build a decltype reference type.
ROSE_DLL_API SgJavaPackageStatement * buildJavaPackageStatement(std::string)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgMatlabForStatement * buildMatlabForStatement(SgExpression *loop_index, SgExpression *loop_range, SgBasicBlock *loop_body)
Build a For-loop statement for matlab.
ROSE_DLL_API SgForStatement * buildForStatement_nfi(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgStatement *loop_body, SgStatement *else_body=NULL)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeUnknown * buildUnknownType()
Built in simple types.
ROSE_DLL_API void setOneSourcePositionForTransformation(SgNode *root)
Set current node's source position as transformation generated.
ROSE_DLL_API SgExprStatement * buildExprStatement(SgExpression *exp=NULL)
Build a SgExprStatement, set File_Info automatically.
ROSE_DLL_API SgUnsignedIntVal * buildUnsignedIntVal_nfi(unsigned int v, const std::string &str)
SgExprStatement * buildExprStatement_nfi(SgExpression *exp)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal(int template_parameter_position=-1)
Build an template parameter value expression.
ROSE_DLL_API SgCommonBlockObject * buildCommonBlockObject(std::string name="", SgExprListExp *exp_list=NULL)
Build a Fortran common block, possibly with a name.
ROSE_DLL_API SgForStatement * buildForStatement(SgStatement *initialize_stmt, SgStatement *test, SgExpression *increment, SgStatement *loop_body, SgStatement *else_body=NULL)
Build a for statement, assume none of the arguments is NULL.
ROSE_DLL_API SgTypeLongLong * buildLongLongType()
Built in simple types.
ROSE_DLL_API SgWhenStmt * buildWhenStmt(SgExpression *expression, SgBasicBlock *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeShort * buildShortType()
Built in simple types.
ROSE_DLL_API SgTypeSignedInt * buildSignedIntType()
Built in simple types.
ROSE_DLL_API void fixupCopyOfAstFromSeparateFileInNewTargetAst(SgStatement *insertionPoint, bool insertionPointIsScope, SgStatement *toInsert, SgStatement *original_before_copy)
Fixup any AST moved from one file two another (references to symbols, types, etc.).
This class represents the function being called and must be assembled in the SgFunctionCall with the ...
ROSE_DLL_API SgDefaultOptionStmt * buildDefaultOptionStmt(SgStatement *body=NULL)
Build a default option statement.
ROSE_DLL_API SgJavaThrowStatement * buildJavaThrowStatement(SgThrowOp *)
Build a Java Throw statement.
ROSE_DLL_API SgExprStatement * buildAssignStatement(SgExpression *lhs, SgExpression *rhs)
Build an assignment statement from lefthand operand and right hand operand.
ROSE_DLL_API SgType * buildOpaqueType(std::string const type_name, SgScopeStatement *scope)
Build an opaque type with a name, useful when a type's details are unknown during transformation...
ROSE_DLL_API SgComplexVal * buildComplexVal(SgValueExp *real_value, SgValueExp *imaginary_value)
This class represents the concept of try statement within the try-catch support for exception handlin...
SgWithStatement * buildWithStatement_nfi(SgExpression *expr, SgStatement *body)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgBasicBlock * buildBasicBlock_nfi()
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgBracedInitializer * buildBracedInitializer(SgExprListExp *initializers=NULL, SgType *expression_type=NULL)
Build an braced initializer.
This class represents the concept of a C Assembler statement.
SgComprehension * buildComprehension_nfi(SgExpression *target, SgExpression *iter, SgExprListExp *ifs)
ROSE_DLL_API SgPragmaDeclaration * buildPragmaDeclaration(const std::string &name, SgScopeStatement *scope=NULL)
Build pragma declaration, handle SgPragma and defining/nondefining pointers internally.
ROSE_DLL_API SgCharVal * buildCharVal_nfi(char value, const std::string &str)
ROSE_DLL_API SgClassExp * buildClassExp_nfi(SgClassSymbol *sym)
SgCudaKernelCallExp * buildCudaKernelCallExp_nfi(SgExpression *kernel, SgExprListExp *parameters=NULL, SgCudaKernelExecConfig *config=NULL)
Build a CUDA kernel call expression (kernel<<>>(parameters))
ROSE_DLL_API SgJavaSynchronizedStatement * buildJavaSynchronizedStatement(SgExpression *, SgBasicBlock *)
Build a Java Synchronized statement.
ROSE_DLL_API SgTypeNullptr * buildNullptrType()
Built in simple types.
Specify as source position to be filled in as part of AST construction in the front-end.
Definition: sageBuilder.h:146
This class represents a source project, with a list of SgFile objects and global information about th...
SgDoWhileStmt * buildDoWhileStmt_nfi(SgStatement *body, SgStatement *condition)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeUnsigned128bitInteger * buildUnsigned128bitIntegerType()
Built in simple types.
ROSE_DLL_API SgUpcThreads * buildUpcThreads()
Build UPC THREADS (integer expression)
ROSE_DLL_API SgListExp * buildListExp(SgExpression *expr1=NULL, SgExpression *expr2=NULL, SgExpression *expr3=NULL, SgExpression *expr4=NULL, SgExpression *expr5=NULL, SgExpression *expr6=NULL, SgExpression *expr7=NULL, SgExpression *expr8=NULL, SgExpression *expr9=NULL, SgExpression *expr10=NULL)
Build a SgListExp.
This class represents the concept of a 'global' stmt in Python.
ROSE_DLL_API SgModifierType * buildUpcBlockStarType(SgType *base_type=NULL)
Build a UPC shared[*] type.
ROSE_DLL_API PreprocessingInfo * buildCpreprocessorDefineDeclaration(SgLocatedNode *target, const std::string &content, PreprocessingInfo::RelativePositionType position=PreprocessingInfo::before)
Build and attach #define XX directives, pass "#define xxx xxx" as content.
ROSE_DLL_API SgJavaInstanceOfOp * buildJavaInstanceOfOp(SgExpression *exp=NULL, SgType *type=NULL)
This is part of Java specific operator support.
ROSE_DLL_API SgAssignInitializer * buildAssignInitializer_nfi(SgExpression *operand_i=NULL, SgType *expression_type=NULL)
ROSE_DLL_API SgName appendTemplateArgumentsToName(const SgName &name, const SgTemplateArgumentPtrList &templateArgumentsList)
DQ (7/27/2012): changed semantics from removing the template arguments in names to adding the templat...
ROSE_DLL_API SgScopeStatement * buildScopeStatement(SgClassDefinition *=NULL)
Build a SgFile node and attach it to SgProject.
ROSE_DLL_API SgVarRefExp * buildVarRefExp_nfi(SgVariableSymbol *varSymbol)
ROSE_DLL_API SgModifierType * buildUpcRelaxedType(SgType *base_type=NULL)
Build a UPC relaxed type.
ROSE_DLL_API SgLongDoubleVal * buildLongDoubleVal_nfi(long double value, const std::string &str)
ROSE_DLL_API SgEnumDeclaration * buildEnumDeclaration_nfi(const SgName &name, SgScopeStatement *scope=NULL)
Build an enum, It is also a declaration statement in SAGE III.
ROSE_DLL_API void testTemplateArgumentParents(SgDeclarationStatement *decl)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgDeleteExp * buildDeleteExp(SgExpression *variable, short is_array, short need_global_specifier, SgFunctionDeclaration *deleteOperatorDeclaration)
ROSE_DLL_API SgClassDeclaration * buildDefiningClassDeclaration(SgName name, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUpcFenceStatement * buildUpcFenceStatement_nfi()
Build a UPC fence statement.
This class represents a C99 complex type.
SgDictionaryExp * buildDictionaryExp_nfi(std::vector< SgKeyDatumPair * > pairs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgMicrosoftAttributeDeclaration * buildMicrosoftAttributeDeclaration(const SgName &name)
DQ (8/17/2014): Adding support for Microsoft MSVC specific attributes.
ROSE_DLL_API SgTypeFloat * buildFloatType()
Built in simple types.
ROSE_DLL_API SourcePositionClassification getSourcePositionClassificationMode()
Get the current source position classification (defines how IR nodes built by the SageBuilder interfa...
This class represents the concept of a C or C++ variable declaration.
cv_modifier_enum
Const Volatile Modifier.
ROSE_DLL_API SgTypeTuple * buildTupleType(SgType *t1=NULL, SgType *t2=NULL, SgType *t3=NULL, SgType *t4=NULL, SgType *t5=NULL, SgType *t6=NULL, SgType *t7=NULL, SgType *t8=NULL, SgType *t9=NULL, SgType *t10=NULL)
Build a tuple of types. Useful for a function returning multiple variables of different types...
This class represents the notion of an initializer for a variable declaration or expression in a func...
ROSE_DLL_API SgFunctionDeclaration * buildDefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation=false, SgFunctionDeclaration *first_nondefinng_declaration=NULL, SgTemplateArgumentPtrList *templateArgumentsList=NULL)
Build a function declaration with a function body.
SgConditionalExp * buildConditionalExp_nfi(SgExpression *test, SgExpression *a, SgExpression *b, SgType *t)
SgExecStatement * buildExecStatement_nfi(SgExpression *executable, SgExpression *globals=NULL, SgExpression *locals=NULL)
Build a variable declaration, handle symbol table transparently.
bool symbol_table_case_insensitive_semantics
Support for construction of case sensitive/insensitive symbol table handling in scopes.
ROSE_DLL_API SgUnsignedLongVal * buildUnsignedLongValHex(unsigned long v=0)
SgLabelStatement * buildLabelStatement_nfi(const SgName &name, SgStatement *stmt, SgScopeStatement *scope)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgTypeSigned128bitInteger * buildSigned128bitIntegerType()
Built in simple types.
This class represents the concept of a C or C++ label statement.
ROSE_DLL_API SgUnsignedShortVal * buildUnsignedShortVal_nfi(unsigned short v, const std::string &str)
ROSE_DLL_API SgNaryBooleanOp * buildNaryBooleanOp(SgExpression *lhs)
Build a variable declaration, handle symbol table transparently.
ROSE_DLL_API SgUpcMythread * buildUpcMythread()
Build UPC MYTHREAD (integer expression)
ROSE_DLL_API SgCharVal * buildCharVal(char value=0)
ROSE_DLL_API SgDoubleVal * buildDoubleVal(double value=0.0)
Build a double value expression.
ROSE_DLL_API SgTypeString * buildStringType()
DQ (8/21/2010): We want to move to the new buildStringType( SgExpression*,size_t) function over the o...
ROSE_DLL_API SgSizeOfOp * buildSizeOfOp_nfi(SgExpression *exp)
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharValHex(unsigned char v=0)
ROSE_DLL_API SgTypeImaginary * buildImaginaryType(SgType *base_type=NULL)
Build an imaginary type.
ROSE_DLL_API SgUnsignedCharVal * buildUnsignedCharVal(unsigned char v=0)
Build an unsigned char.
ROSE_DLL_API SgTemplateParameterVal * buildTemplateParameterVal_nfi(int template_parameter_position, const std::string &str)
ROSE_DLL_API SgModifierType * buildVolatileType(SgType *base_type=NULL)
Build a volatile type.
This class represents the concept of a C++ function call (which is an expression).
ROSE_DLL_API SgLongLongIntVal * buildLongLongIntVal(long long value=0)
Build a long long integer value expression.
ROSE_DLL_API SgPassStatement * buildPassStatement()
Build a pass statement.
ROSE_DLL_API SgPythonGlobalStmt * buildPythonGlobalStmt(SgInitializedNamePtrList &names)
Build a python global statement.
ROSE_DLL_API SgYieldExpression * buildYieldExpression(SgExpression *value)
Build a yield statement.
ROSE_DLL_API SgLongIntVal * buildLongIntValHex(long value=0)
SgYieldExpression * buildYieldExpression_nfi(SgExpression *value)
Build a variable declaration, handle symbol table transparently.
This class represents the concept of a declaration statement.
T * buildBinaryExpression_nfi(SgExpression *lhs, SgExpression *rhs)
Template function to build a binary expression of type T, taking care of parent pointers, but without file-info. Available instances include: buildAddOp(), buildAndAssignOp(), buildAndOp(), buildArrowExp(),buildArrowStarOp(), buildAssignOp(),buildBitAndOp(),buildBitOrOp(),buildBitXorOp(),buildCommaOpExp(), buildConcatenationOp(),buildDivAssignOp(),buildDivideOp(),buildDotExp(),buildEqualityOp(),buildExponentiationOp(),buildGreaterOrEqualOp(),buildGreaterThanOp(),buildIntegerDivideOp(),buildIorAssignOp(),buildLessOrEqualOp(),buildLessThanOp(),buildLshiftAssignOp(),buildLshiftOp(),buildMinusAssignOp(),buildModAssignOp(),buildModOp(),buildMultAssignOp(),buildMultiplyOp(),buildNotEqualOp(),buildOrOp(),buildPlusAssignOp(),buildPntrArrRefExp(),buildRshiftAssignOp(),buildRshiftOp(),buildScopeOp(),buildSubtractOp()buildXorAssignOp()
Definition: sageBuilder.h:1585
This class represents the concept of a switch.
ROSE_DLL_API SgTypeChar * buildCharType()
Built in simple types.
This class represents the concept of a C++ expression built from a class name.
ROSE_DLL_API SgTryStmt * buildTryStmt(SgStatement *body, SgCatchOptionStmt *catch0=NULL, SgCatchOptionStmt *catch1=NULL, SgCatchOptionStmt *catch2=NULL, SgCatchOptionStmt *catch3=NULL, SgCatchOptionStmt *catch4=NULL)
Build a try statement.
ROSE_DLL_API SgFunctionDeclaration * buildNondefiningFunctionDeclaration(const SgName &name, SgType *return_type, SgFunctionParameterList *parlist, SgScopeStatement *scope, SgExprListExp *decoratorList, bool buildTemplateInstantiation, SgTemplateArgumentPtrList *templateArgumentsList)
Build a prototype for a function, handle function type, symbol etc transparently. ...
SgListComprehension * buildListComprehension_nfi(SgExpression *elt, SgExprListExp *generators)
ROSE_DLL_API SgAsmStmt * buildMultibyteNopStatement(int n)
DQ (4/30/2010): Added support for building nop statement using asm statement Building nop statement u...
ROSE_DLL_API SgPythonPrintStmt * buildPythonPrintStmt(SgExpression *dest=NULL, SgExprListExp *values=NULL)
Build a python print statement.