SageBuilder

High level SAGE III AST node and subtree builders.

Enums

Name

SourcePositionClassification

Functions

Name	Description
appendTemplateArgumentsToName SgName appendTemplateArgumentsToName(SgName const& name, SgTemplateArgumentPtrList const& templateArgumentsList);	DQ (7/27/2012): changed semantics from removing the template arguments in names to adding the template arguments to names.
buildActualArgumentExpression SgActualArgumentExpression* buildActualArgumentExpression(SgName arg_name, SgExpression* arg);	Build an Actual Argument Expression
buildActualArgumentExpression_nfi SgActualArgumentExpression* buildActualArgumentExpression_nfi(SgName arg_name, SgExpression* arg);
buildAddOp SgAddOp* buildAddOp(SgExpression* lhs, SgExpression* rhs);
buildAddOp_nfi SgAddOp* buildAddOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildAddressOfOp SgAddressOfOp* buildAddressOfOp(SgExpression* op);
buildAddressOfOp_nfi SgAddressOfOp* buildAddressOfOp_nfi(SgExpression* op);
buildAggregateInitializer SgAggregateInitializer* buildAggregateInitializer(SgExprListExp* initializers = NULL, SgType* type = NULL);	Build an aggregate initializer
buildAggregateInitializer_nfi SgAggregateInitializer* buildAggregateInitializer_nfi(SgExprListExp* initializers, SgType* type = NULL);
buildAlignOfOp SgAlignOfOp* buildAlignOfOp(SgExpression* exp = NULL);	buildAlignOfOp overloads
buildAlignOfOp_nfi SgAlignOfOp* buildAlignOfOp_nfi(SgExpression* exp);
buildAndAssignOp SgAndAssignOp* buildAndAssignOp(SgExpression* lhs, SgExpression* rhs);
buildAndAssignOp_nfi SgAndAssignOp* buildAndAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildAndOp SgAndOp* buildAndOp(SgExpression* lhs, SgExpression* rhs);
buildAndOp_nfi SgAndOp* buildAndOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildArrayType SgArrayType* buildArrayType(SgType* base_type, SgExprListExp* dim_info);	buildArrayType overloads
buildArrowExp SgArrowExp* buildArrowExp(SgExpression* lhs, SgExpression* rhs);
buildArrowExp_nfi SgArrowExp* buildArrowExp_nfi(SgExpression* lhs, SgExpression* rhs);
buildArrowStarOp SgArrowStarOp* buildArrowStarOp(SgExpression* lhs, SgExpression* rhs);
buildArrowStarOp_nfi SgArrowStarOp* buildArrowStarOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildAsmStatement SgAsmStmt* buildAsmStatement(std::string s);	Build a NULL statement
buildAsmStatement_nfi SgAsmStmt* buildAsmStatement_nfi(std::string s);
buildAssignInitializer SgAssignInitializer* buildAssignInitializer(SgExpression* operand_i = NULL, SgType* expression_type = NULL);	Build the rhs of a variable declaration which includes an assignment
buildAssignInitializer_nfi SgAssignInitializer* buildAssignInitializer_nfi(SgExpression* operand_i = NULL, SgType* expression_type = NULL);
buildAssignOp SgAssignOp* buildAssignOp(SgExpression* lhs, SgExpression* rhs);
buildAssignOp_nfi SgAssignOp* buildAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildAssignStatement SgExprStatement* buildAssignStatement(SgExpression* lhs, SgExpression* rhs);	Build an assignment statement from lefthand operand and right hand operand
buildAssignStatement_ast_translate SgExprStatement* buildAssignStatement_ast_translate(SgExpression* lhs, SgExpression* rhs);	This version does not recursively reset the file info as a transformation.
buildAttributeSpecificationStatement SgAttributeSpecificationStatement* buildAttributeSpecificationStatement(SgAttributeSpecificationStatement::attribute_spec_enum kind);	Build Fortran attribute specification statement
buildAutoType SgAutoType* buildAutoType();
buildAwaitExpression SgAwaitExpression* buildAwaitExpression();
buildAwaitExpression_nfi SgAwaitExpression* buildAwaitExpression_nfi();
buildBFloat16Type SgTypeBFloat16* buildBFloat16Type();
buildBFloat16Val SgBFloat16Val* buildBFloat16Val(float v = 0);	Build a bfloat16
buildBFloat16Val_nfi SgBFloat16Val* buildBFloat16Val_nfi(float v, std::string const& str);
buildBaseClass SgBaseClass* buildBaseClass(SgClassDeclaration* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect);	DQ (5/6/2013): Added build functions to support SgBaseClass construction.
buildBasicBlock 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
buildBasicBlock_nfi SgBasicBlock* buildBasicBlock_nfi();	Build a SgBasicBlock and set its parent. This function does NOT link the parent scope to the block.
buildBinaryExpression template<class T> T* buildBinaryExpression(SgExpression* lhs, SgExpression* rhs);	Template function to build a binary expression of type T, taking care of parent pointers, file info, lvalue, etc. Available instances include: buildAddOp(), buildAndAssignOp(), buildAndOp(), buildArrowExp(),buildArrowStarOp(),buildAtOp, buildAssignOp(),buildBitAndOp(),buildBitOrOp(),buildBitXorOp(),buildCommaOpExp(), buildConcatenationOp(),buildDivAssignOp(),buildDivideOp(),buildDotExp(),buildEqualityOp(),buildExponentiationOp(),buildGreaterOrEqualOp(),buildGreaterThanOp(),buildIntegerDivideOp(),buildIorAssignOp(),buildLessOrEqualOp(),buildLessThanOp(),buildLshiftAssignOp(),buildLshiftOp(),buildMinusAssignOp(),buildModAssignOp(),buildModOp(),buildMultAssignOp(),buildMultiplyOp(),buildNotEqualOp(),buildOrOp(),buildPlusAssignOp(),buildPntrArrRefExp(),buildRshiftAssignOp(),buildRshiftOp(),buildReplicationOp,buildScopeOp(),buildSubtractOp()buildXorAssignOp() The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros.
buildBinaryExpression_nfi template<class T> T* buildBinaryExpression_nfi(SgExpression* lhs, SgExpression* rhs);	Template function to build a binary expression of type T, taking care of parent pointers, but without file‐info. Available instances include: buildAddOp(), buildAndAssignOp(), buildAndOp(), buildArrowExp(),buildArrowStarOp(),buildAtOp, buildAssignOp(),buildBitAndOp(),buildBitOrOp(),buildBitXorOp(),buildCommaOpExp(), buildConcatenationOp(),buildDivAssignOp(),buildDivideOp(),buildDotExp(),buildEqualityOp(),buildExponentiationOp(),buildGreaterOrEqualOp(),buildGreaterThanOp(),buildIntegerDivideOp(),buildIorAssignOp(),buildLessOrEqualOp(),buildLessThanOp(),buildLshiftAssignOp(),buildLshiftOp(),buildMinusAssignOp(),buildModAssignOp(),buildModOp(),buildMultAssignOp(),buildMultiplyOp(),buildNotEqualOp(),buildOrOp(),buildPlusAssignOp(),buildPntrArrRefExp(),buildRshiftAssignOp(),buildRshiftOp(),buildReplicationOp(),buildScopeOp(),buildSubtractOp()buildXorAssignOp() The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros.
buildBitAndOp SgBitAndOp* buildBitAndOp(SgExpression* lhs, SgExpression* rhs);
buildBitAndOp_nfi SgBitAndOp* buildBitAndOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildBitComplementOp SgBitComplementOp* buildBitComplementOp(SgExpression* op);
buildBitComplementOp_nfi SgBitComplementOp* buildBitComplementOp_nfi(SgExpression* op);
buildBitOrOp SgBitOrOp* buildBitOrOp(SgExpression* lhs, SgExpression* rhs);
buildBitOrOp_nfi SgBitOrOp* buildBitOrOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildBitXorOp SgBitXorOp* buildBitXorOp(SgExpression* lhs, SgExpression* rhs);
buildBitXorOp_nfi SgBitXorOp* buildBitXorOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildBoolType SgTypeBool* buildBoolType();	buildBoolType overloads
buildBoolValExp SgBoolValExp* buildBoolValExp(bool value = 0);	Build a bool value expression, the name convention of SgBoolValExp is little different from others for some unknown reason
buildBoolValExp_nfi SgBoolValExp* buildBoolValExp_nfi(int value);
buildBracedInitializer SgBracedInitializer* buildBracedInitializer(SgExprListExp* initializers = NULL, SgType* expression_type = NULL);	Build an braced initializer
buildBracedInitializer_nfi SgBracedInitializer* buildBracedInitializer_nfi(SgExprListExp* initializers = NULL, SgType* expression_type = NULL);
buildBreakStmt SgBreakStmt* buildBreakStmt();	Build a break statement
buildBreakStmt_nfi SgBreakStmt* buildBreakStmt_nfi();
buildCaseOptionStmt SgCaseOptionStmt* buildCaseOptionStmt(SgExpression* key = NULL, SgStatement* body = NULL);	Build a case option statement
buildCaseOptionStmt_nfi SgCaseOptionStmt* buildCaseOptionStmt_nfi(SgExpression* key, SgStatement* body);
buildCastExp 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
buildCastExp_nfi SgCastExp* buildCastExp_nfi(SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type);
buildCatchOptionStmt SgCatchOptionStmt* buildCatchOptionStmt(SgVariableDeclaration* condition = NULL, SgStatement* body = NULL);	Build a catch statement.
buildCatchStatementSeq SgCatchStatementSeq* buildCatchStatementSeq(SgCatchOptionStmt* = NULL);	Build an initial sequence of Catch blocks containing 0 or 1 element.
buildChar16Type SgTypeChar16* buildChar16Type();
buildChar16Val SgChar16Val* buildChar16Val(unsigned short value = 0);
buildChar16Val_nfi SgChar16Val* buildChar16Val_nfi(unsigned short value, std::string const& str);
buildChar32Type SgTypeChar32* buildChar32Type();
buildChar32Val SgChar32Val* buildChar32Val(unsigned int value = 0);
buildChar32Val_nfi SgChar32Val* buildChar32Val_nfi(unsigned int value, std::string const& str);
buildCharType SgTypeChar* buildCharType();
buildCharVal SgCharVal* buildCharVal(char value = 0);
buildCharVal_nfi SgCharVal* buildCharVal_nfi(char value, std::string const& str);
buildChooseExpression SgChooseExpression* buildChooseExpression();
buildChooseExpression_nfi SgChooseExpression* buildChooseExpression_nfi();
buildClassDeclaration SgClassDeclaration* buildClassDeclaration(SgName name, SgScopeStatement* scope);	DQ (11/7/2009): Added function to build C++ class (builds both the non‐defining and defining declarations; in that order).
buildClassDeclarationStatement_nfi template<class DeclClass> DeclClass* buildClassDeclarationStatement_nfi(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope = NULL, SgClassDeclaration* nonDefiningDecl = NULL);	Build a generic class declaration statement (SgClassDeclaration or subclass) with a class declaration and definition (creating both the defining and nondefining declarations as required.
buildClassDeclaration_nfi SgClassDeclaration* buildClassDeclaration_nfi(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
buildClassDefinition SgClassDefinition* buildClassDefinition(SgClassDeclaration* d = NULL, bool buildTemplateInstantiation = false);
buildClassDefinition_nfi SgClassDefinition* buildClassDefinition_nfi(SgClassDeclaration* d = NULL, bool buildTemplateInstantiation = false);
buildClassExp SgClassExp* buildClassExp(SgClassSymbol* sym);	Build class pointer
buildClassExp_nfi SgClassExp* buildClassExp_nfi(SgClassSymbol* sym);
buildClassNameRefExp SgClassNameRefExp* buildClassNameRefExp(SgClassSymbol* sym);
buildClassNameRefExp_nfi SgClassNameRefExp* buildClassNameRefExp_nfi(SgClassSymbol* sym);
buildClassTemplateType SgClassType* buildClassTemplateType(SgTemplateClassDeclaration* template_decl, std::vector<SgNode*>& template_args);	Some support for building class template instantiation declarations. Note, the template is not actually instantiated, but a `forward declaration' node is created.
buildColonShapeExp SgColonShapeExp* buildColonShapeExp();	Build a Fortran colon‐shape expression, set file info as the default one.
buildColonShapeExp_nfi SgColonShapeExp* buildColonShapeExp_nfi();	No file info version of buildColonShapeExp(). File info is to be set later on.
buildCommaOpExp SgCommaOpExp* buildCommaOpExp(SgExpression* lhs, SgExpression* rhs);
buildCommaOpExp_nfi SgCommaOpExp* buildCommaOpExp_nfi(SgExpression* lhs, SgExpression* rhs);
buildComment PreprocessingInfo* buildComment(SgLocatedNode* target, std::string const& 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 not provided. It is indeed a wrapper of SageInterface::attachComment().
buildCommonBlock SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block = NULL);	Build a Fortran Common statement
buildCommonBlockObject SgCommonBlockObject* buildCommonBlockObject(std::string name = "", SgExprListExp* exp_list = NULL);	Build a Fortran common block, possibly with a name
buildComplexType SgTypeComplex* buildComplexType(SgType* base_type = nullptr);	Build a complex type
buildComplexVal SgComplexVal* buildComplexVal(SgValueExp* real_value, SgValueExp* imaginary_value);
buildComplexVal_nfi SgComplexVal* buildComplexVal_nfi(SgValueExp* real_value, SgValueExp* imaginary_value, std::string const& str);
buildCompoundInitializer SgCompoundInitializer* buildCompoundInitializer(SgExprListExp* initializers = NULL, SgType* type = NULL);	Build a compound initializer, for vector type initialization
buildCompoundInitializer_nfi SgCompoundInitializer* buildCompoundInitializer_nfi(SgExprListExp* initializers, SgType* type = NULL);
buildCompoundLiteralExp SgCompoundLiteralExp* buildCompoundLiteralExp(SgVariableSymbol* varSymbol);
buildCompoundLiteralExp_nfi SgCompoundLiteralExp* buildCompoundLiteralExp_nfi(SgVariableSymbol* varSymbol);	Build function for compound literals (uses a SgVariableSymbol and is similar to buildVarRefExp_nfi()).
buildConcatenationOp SgConcatenationOp* buildConcatenationOp(SgExpression* lhs, SgExpression* rhs);
buildConcatenationOp_nfi SgConcatenationOp* buildConcatenationOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildConditionalExp SgConditionalExp* buildConditionalExp(SgExpression* test = NULL, SgExpression* a = NULL, SgExpression* b = NULL);	Build a conditional expression ?:
buildConditionalExp_nfi SgConditionalExp* buildConditionalExp_nfi(SgExpression* test, SgExpression* a, SgExpression* b, SgType* t);
buildConjugateOp SgConjugateOp* buildConjugateOp(SgExpression* op);
buildConjugateOp_nfi SgConjugateOp* buildConjugateOp_nfi(SgExpression* op);
buildConstType SgModifierType* buildConstType(SgType* base_type = nullptr);	Build a const type.
buildConstVolatileModifier SgConstVolatileModifier* buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype = SgConstVolatileModifier::e_unknown);	Build a const/volatile type qualifier
buildConstVolatileType SgModifierType* buildConstVolatileType(SgType* base_type = nullptr);	Build a const volatile type.
buildConstructorInitializer SgConstructorInitializer* buildConstructorInitializer(SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgType* expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown);
buildConstructorInitializer_nfi 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);
buildContinueStmt SgContinueStmt* buildContinueStmt();	Build a continue statement
buildContinueStmt_nfi SgContinueStmt* buildContinueStmt_nfi();
buildCpreprocessorDefineDeclaration PreprocessingInfo* buildCpreprocessorDefineDeclaration(SgLocatedNode* target, std::string const& content, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before);	Build and attach #define XX directives, pass "#define xxx xxx" as content.
buildCtorInitializerList_nfi SgCtorInitializerList* buildCtorInitializerList_nfi();
buildCudaKernelCallExp_nfi SgCudaKernelCallExp* buildCudaKernelCallExp_nfi(SgExpression* kernel, SgExprListExp* parameters = NULL, SgCudaKernelExecConfig* config = NULL);	Build a CUDA kernel call expression (kernel<[config]>(parameters))
buildCudaKernelExecConfig_nfi SgCudaKernelExecConfig* buildCudaKernelExecConfig_nfi(SgExpression* grid = NULL, SgExpression* blocks = NULL, SgExpression* shared = NULL, SgExpression* stream = NULL);	Build a CUDA kernel execution configuration (<blocks, shared, stream>)
buildDanglingVarRefExp SgVarRefExp* buildDanglingVarRefExp(SgName const& name, SgScopeStatement* scope = NULL);	Build a variable reference expression without symbol‐table lookup.
buildDeclType SgDeclType* buildDeclType(SgExpression* base_expression, SgType* base_type);	Build a decltype reference type
buildDeclarationScope SgDeclarationScope* buildDeclarationScope();	Build a scope statement. Used to build SgNonrealDecl and SgNonrealType
buildDefaultConstructor SgMemberFunctionDeclaration* buildDefaultConstructor(SgClassType* classType);
buildDefaultOptionStmt SgDefaultOptionStmt* buildDefaultOptionStmt(SgStatement* body = NULL);	Build a default option statement
buildDefaultOptionStmt_nfi SgDefaultOptionStmt* buildDefaultOptionStmt_nfi(SgStatement* body);
buildDefiningClassDeclaration SgClassDeclaration* buildDefiningClassDeclaration(SgName name, SgScopeStatement* scope);
buildDefiningFunctionDeclaration SgFunctionDeclaration* buildDefiningFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL, bool forceFreeFunctionScope = false);	Build a function declaration with a function body
buildDefiningMemberFunctionDeclaration SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);	Build a defining ( non‐prototype) member function declaration
buildDefiningTemplateFunctionDeclaration SgTemplateFunctionDeclaration* buildDefiningTemplateFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, SgTemplateFunctionDeclaration* first_nondefining_declaration);
buildDefiningTemplateMemberFunctionDeclaration SgTemplateMemberFunctionDeclaration* buildDefiningTemplateMemberFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration);
buildDeleteExp SgDeleteExp* buildDeleteExp(SgExpression* target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration* deleteOperatorDeclaration = NULL);	Build a delete statement
buildDeleteExp_nfi SgDeleteExp* buildDeleteExp_nfi(SgExpression* target, bool is_array = false, bool need_global_specifier = false, SgFunctionDeclaration* deleteOperatorDeclaration = NULL);
buildDerivedTypeStatement SgDerivedTypeStatement* buildDerivedTypeStatement(SgName const& name, SgScopeStatement* scope = NULL);	Build an SgDerivedTypeStatement Fortran derived type declaration with a class declaration and definition (creating both the defining and nondefining declarations as required).
buildDivAssignOp SgDivAssignOp* buildDivAssignOp(SgExpression* lhs, SgExpression* rhs);
buildDivAssignOp_nfi SgDivAssignOp* buildDivAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildDivideOp SgDivideOp* buildDivideOp(SgExpression* lhs, SgExpression* rhs);
buildDivideOp_nfi SgDivideOp* buildDivideOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildDoWhileStatement_nfi void buildDoWhileStatement_nfi(SgDoWhileStmt* result, SgStatement* body, SgStatement* condition);
buildDoWhileStmt SgDoWhileStmt* buildDoWhileStmt(SgStatement* body, SgExpression* condition);	Build do‐while statement
buildDoWhileStmt_nfi SgDoWhileStmt* buildDoWhileStmt_nfi(SgStatement* body, SgStatement* condition);
buildDotExp SgDotExp* buildDotExp(SgExpression* lhs, SgExpression* rhs);
buildDotExp_nfi SgDotExp* buildDotExp_nfi(SgExpression* lhs, SgExpression* rhs);
buildDotStarOp SgDotStarOp* buildDotStarOp(SgExpression* lhs, SgExpression* rhs);
buildDotStarOp_nfi SgDotStarOp* buildDotStarOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildDoubleType SgTypeDouble* buildDoubleType();
buildDoubleVal SgDoubleVal* buildDoubleVal(double value = 0.0);	Build a double value expression
buildDoubleVal_nfi SgDoubleVal* buildDoubleVal_nfi(double value, std::string const& str);
buildEmptyDeclaration SgEmptyDeclaration* buildEmptyDeclaration();	Build an empty declaration (useful for adding precission to comments and CPP handling under token‐based unparsing).
buildEnumDeclaration SgEnumDeclaration* buildEnumDeclaration(SgName const& name, SgScopeStatement* scope = NULL);	Build an enum, It is also a declaration statement in SAGE III
buildEnumDeclaration_nfi SgEnumDeclaration* buildEnumDeclaration_nfi(SgName const& name, SgScopeStatement* scope = NULL);	Build an enum, It is also a declaration statement in SAGE III
buildEnumVal SgEnumVal* buildEnumVal(SgEnumFieldSymbol* sym);
buildEnumVal_nfi SgEnumVal* buildEnumVal_nfi(long long value, SgEnumDeclaration* decl, SgName name);
buildEqualityOp SgEqualityOp* buildEqualityOp(SgExpression* lhs, SgExpression* rhs);
buildEqualityOp_nfi SgEqualityOp* buildEqualityOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildEquivalenceStatement SgEquivalenceStatement* buildEquivalenceStatement(SgExpression* lhs, SgExpression* rhs);
buildExponentiationAssignOp SgExponentiationAssignOp* buildExponentiationAssignOp(SgExpression* lhs, SgExpression* rhs);
buildExponentiationAssignOp_nfi SgExponentiationAssignOp* buildExponentiationAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildExponentiationOp SgExponentiationOp* buildExponentiationOp(SgExpression* lhs, SgExpression* rhs);
buildExponentiationOp_nfi SgExponentiationOp* buildExponentiationOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildExprListExp SgExprListExp* buildExprListExp(std::vector<SgExpression*> const& exprs);	Build a SgExprListExp, used for function call parameter list etc.
buildExprListExp_nfi SgExprListExp* buildExprListExp_nfi();
buildExprStatement SgExprStatement* buildExprStatement(SgExpression* exp = NULL);	Build a SgExprStatement, set File_Info automatically
buildExprStatement_nfi SgExprStatement* buildExprStatement_nfi(SgExpression* exp);
buildFile SgFile* buildFile(std::string const& inputFileName, std::string const& outputFileName, SgProject* project = NULL, bool clear_globalScopeAcrossFiles = false);	AST high level builders for others
buildFloat128Type SgTypeFloat128* buildFloat128Type();
buildFloat128Val SgFloat128Val* buildFloat128Val(long double value = 0.0);
buildFloat128Val_nfi SgFloat128Val* buildFloat128Val_nfi(long double value, std::string const& str);
buildFloat16Type SgTypeFloat16* buildFloat16Type();
buildFloat16Val SgFloat16Val* buildFloat16Val(float v = 0);	Build a float16
buildFloat16Val_nfi SgFloat16Val* buildFloat16Val_nfi(float v, std::string const& str);
buildFloat32Type SgTypeFloat32* buildFloat32Type();
buildFloat32Val SgFloat32Val* buildFloat32Val(float v = 0);	Build a float32
buildFloat32Val_nfi SgFloat32Val* buildFloat32Val_nfi(float v, std::string const& str);
buildFloat32xType SgTypeFloat32x* buildFloat32xType();
buildFloat64Type SgTypeFloat64* buildFloat64Type();
buildFloat64Val SgFloat64Val* buildFloat64Val(double v = 0);	Build a float64
buildFloat64Val_nfi SgFloat64Val* buildFloat64Val_nfi(double v, std::string const& str);
buildFloat64xType SgTypeFloat64x* buildFloat64xType();
buildFloat80Type SgTypeFloat80* buildFloat80Type();
buildFloat80Val SgFloat80Val* buildFloat80Val(long double value = 0.0);
buildFloat80Val_nfi SgFloat80Val* buildFloat80Val_nfi(long double value, std::string const& str);
buildFloatType SgTypeFloat* buildFloatType();
buildFloatVal SgFloatVal* buildFloatVal(float value = 0.0);
buildFloatVal_nfi SgFloatVal* buildFloatVal_nfi(float value = 0.0);	Build a float value expression by converting the string
buildFoldExpression SgFoldExpression* buildFoldExpression(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
buildFoldExpression_nfi SgFoldExpression* buildFoldExpression_nfi(SgExpression* operands, std::string operator_token_string, bool is_left_associative);
buildForInitStatement SgForInitStatement* buildForInitStatement();	Build a for init statement
buildForInitStatement_nfi SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList& statements);
buildForStatement SgForStatement* buildForStatement(SgStatement* initialize_stmt, SgStatement* test, SgExpression* increment, SgStatement* loop_body);	Build a for statement, assume none of the arguments is NULL
buildForStatement_nfi SgForStatement* buildForStatement_nfi(SgForInitStatement* init_stmt, SgStatement* test, SgExpression* increment, SgStatement* loop_body);
buildFortranContinueStmt SgFortranContinueStmt* buildFortranContinueStmt();	Build a Fortran continue statement
buildFortranContinueStmt_nfi SgFortranContinueStmt* buildFortranContinueStmt_nfi();
buildFortranDo SgFortranDo* buildFortranDo(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);	Build a Fortran do construct
buildFortranDo_nfi SgFortranDo* buildFortranDo_nfi(SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body);
buildFortranImplicitType SgType* buildFortranImplicitType(SgName name);	Build a type based on Fortran's implicit typing rules. Currently this interface does not take into account possible implicit statements that change the rules.
buildFortranIncludeLine SgFortranIncludeLine* buildFortranIncludeLine(std::string filename);	Build Fortran include line
buildFortranKindType SgModifierType* buildFortranKindType(SgType* base_type, SgExpression* kindExpression);	Build a type based on the Fortran kind mechanism
buildFp16Type SgTypeFp16* buildFp16Type();
buildFunctionCallExp SgFunctionCallExp* buildFunctionCallExp(SgExpression* f, SgExprListExp* parameters = NULL);	buildFunctionCallExp overloads
buildFunctionCallExp_nfi SgFunctionCallExp* buildFunctionCallExp_nfi(SgExpression* f, SgExprListExp* parameters = NULL);
buildFunctionCallStmt SgExprStatement* buildFunctionCallStmt(SgExpression* function, SgExprListExp* parameters = NULL);	buildFunctionCallStmt overloads
buildFunctionParameterList SgFunctionParameterList* buildFunctionParameterList(SgFunctionParameterTypeList* paraTypeList);	buildFunctionParameterList overloads
buildFunctionParameterList_nfi SgFunctionParameterList* buildFunctionParameterList_nfi();
buildFunctionParameterRefExp SgFunctionParameterRefExp* buildFunctionParameterRefExp(int parameter_number, int parameter_level);
buildFunctionParameterRefExp_nfi SgFunctionParameterRefExp* buildFunctionParameterRefExp_nfi(int parameter_number, int parameter_level);
buildFunctionParameterTypeList SgFunctionParameterTypeList* buildFunctionParameterTypeList(SgExprListExp* expList);	buildFunctionParameterTypeList overloads
buildFunctionRefExp SgFunctionRefExp* buildFunctionRefExp(SgFunctionSymbol* sym);	buildFunctionRefExp overloads
buildFunctionRefExp_nfi SgFunctionRefExp* buildFunctionRefExp_nfi(SgFunctionSymbol* sym);
buildFunctionType SgFunctionType* buildFunctionType(SgType* return_type, SgFunctionParameterList* argList = nullptr);	buildFunctionType overloads
buildGotoStatement SgGotoStatement* buildGotoStatement(SgLabelStatement* label = NULL);	buildGotoStatement overloads
buildGotoStatement_nfi SgGotoStatement* buildGotoStatement_nfi(SgExpression* expr);	Build a goto statement from a label expression, supporting only C/C++ and not Fortran cases
buildGreaterOrEqualOp SgGreaterOrEqualOp* buildGreaterOrEqualOp(SgExpression* lhs, SgExpression* rhs);
buildGreaterOrEqualOp_nfi SgGreaterOrEqualOp* buildGreaterOrEqualOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildGreaterThanOp SgGreaterThanOp* buildGreaterThanOp(SgExpression* lhs, SgExpression* rhs);
buildGreaterThanOp_nfi SgGreaterThanOp* buildGreaterThanOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildHeader PreprocessingInfo* buildHeader(std::string const& header_filename, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before, bool isSystemHeader = false);	Build a dangling #include "x.h" header, insertHeader() is needed to actually insert it
buildIfStmt SgIfStmt* buildIfStmt(SgExpression* conditional, SgStatement* true_body, SgStatement* false_body);	Build if statement
buildIfStmt_nfi SgIfStmt* buildIfStmt_nfi(SgStatement* conditional, SgStatement* true_body, SgStatement* false_body);
buildImagPartOp SgImagPartOp* buildImagPartOp(SgExpression* op);
buildImagPartOp_nfi SgImagPartOp* buildImagPartOp_nfi(SgExpression* op);
buildImaginaryType SgTypeImaginary* buildImaginaryType(SgType* base_type = nullptr);	Build an imaginary type
buildImaginaryVal SgComplexVal* buildImaginaryVal(long double imaginary_value);
buildImaginaryVal_nfi SgComplexVal* buildImaginaryVal_nfi(SgValueExp* imaginary_value, std::string const& str);
buildInitializedName SgInitializedName* buildInitializedName(std::string const& name, SgType* type);	e.g the scope of arguments of functions are different for defining and nondefining functions.
buildInitializedName_nfi SgInitializedName* buildInitializedName_nfi(SgName const& name, SgType* type, SgInitializer* init, SgVariableDeclaration* declptr = NULL);
buildIntType SgTypeInt* buildIntType();
buildIntVal SgIntVal* buildIntVal(int value = 0);	Build an integer value expression
buildIntValHex SgIntVal* buildIntValHex(int value = 0);
buildIntVal_nfi SgIntVal* buildIntVal_nfi(int value = 0);	Build an integer value expression by converting the string
buildIntegerDivideAssignOp SgIntegerDivideAssignOp* buildIntegerDivideAssignOp(SgExpression* lhs, SgExpression* rhs);
buildIntegerDivideAssignOp_nfi SgIntegerDivideAssignOp* buildIntegerDivideAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildIntegerDivideOp SgIntegerDivideOp* buildIntegerDivideOp(SgExpression* lhs, SgExpression* rhs);
buildIntegerDivideOp_nfi SgIntegerDivideOp* buildIntegerDivideOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildIorAssignOp SgIorAssignOp* buildIorAssignOp(SgExpression* lhs, SgExpression* rhs);
buildIorAssignOp_nfi SgIorAssignOp* buildIorAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildLabelRefExp SgLabelRefExp* buildLabelRefExp(SgLabelSymbol* s);	Build a Fortran numeric label ref exp
buildLabelStatement SgLabelStatement* buildLabelStatement(SgName const& name, SgStatement* stmt = NULL, SgScopeStatement* scope = NULL);	Note that the scope of a label statement is special. It is SgFunctionDefinition, not the closest scope statement such as SgBasicBlock.
buildLabelStatement_nfi SgLabelStatement* buildLabelStatement_nfi(SgName const& name, SgStatement* stmt, SgScopeStatement* scope);
buildLambdaCapture SgLambdaCapture* buildLambdaCapture(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
buildLambdaCaptureList SgLambdaCaptureList* buildLambdaCaptureList();
buildLambdaCaptureList_nfi SgLambdaCaptureList* buildLambdaCaptureList_nfi();
buildLambdaCapture_nfi SgLambdaCapture* buildLambdaCapture_nfi(SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable);
buildLambdaExp SgLambdaExp* buildLambdaExp(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);	DQ (9/3/2014): Adding support for C++11 Lambda expressions
buildLambdaExp_nfi SgLambdaExp* buildLambdaExp_nfi(SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function);
buildLessOrEqualOp SgLessOrEqualOp* buildLessOrEqualOp(SgExpression* lhs, SgExpression* rhs);
buildLessOrEqualOp_nfi SgLessOrEqualOp* buildLessOrEqualOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildLessThanOp SgLessThanOp* buildLessThanOp(SgExpression* lhs, SgExpression* rhs);
buildLessThanOp_nfi SgLessThanOp* buildLessThanOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildLongDoubleType SgTypeLongDouble* buildLongDoubleType();
buildLongDoubleVal SgLongDoubleVal* buildLongDoubleVal(long double value = 0.0);
buildLongDoubleVal_nfi SgLongDoubleVal* buildLongDoubleVal_nfi(long double value, std::string const& str);
buildLongIntVal SgLongIntVal* buildLongIntVal(long value = 0);	Build a long integer value expression
buildLongIntValHex SgLongIntVal* buildLongIntValHex(long value = 0);
buildLongIntVal_nfi SgLongIntVal* buildLongIntVal_nfi(long value, std::string const& str);
buildLongLongIntVal SgLongLongIntVal* buildLongLongIntVal(long long value = 0);	Build a long long integer value expression
buildLongLongIntValHex SgLongLongIntVal* buildLongLongIntValHex(long long value = 0);
buildLongLongIntVal_nfi SgLongLongIntVal* buildLongLongIntVal_nfi(long long value, std::string const& str);
buildLongLongType SgTypeLongLong* buildLongLongType();
buildLongType SgTypeLong* buildLongType();
buildLshiftAssignOp SgLshiftAssignOp* buildLshiftAssignOp(SgExpression* lhs, SgExpression* rhs);
buildLshiftAssignOp_nfi SgLshiftAssignOp* buildLshiftAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildLshiftOp SgLshiftOp* buildLshiftOp(SgExpression* lhs, SgExpression* rhs);
buildLshiftOp_nfi SgLshiftOp* buildLshiftOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildMemberFunctionCall SgFunctionCallExp* buildMemberFunctionCall(SgExpression* objectExpression, SgMemberFunctionSymbol* functionSymbol, SgExprListExp* params);	buildMemberFunctionCall overloads
buildMemberFunctionRefExp SgMemberFunctionRefExp* buildMemberFunctionRefExp(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
buildMemberFunctionRefExp_nfi SgMemberFunctionRefExp* buildMemberFunctionRefExp_nfi(SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);
buildMemberFunctionType SgMemberFunctionType* buildMemberFunctionType(SgType* return_type, SgFunctionParameterTypeList* typeList, SgScopeStatement* struct_name, unsigned int mfunc_specifier);	DQ (8/19/2012): Refactored some of the code supporting construction of the SgMemberFunctionType.
buildMicrosoftAttributeDeclaration SgMicrosoftAttributeDeclaration* buildMicrosoftAttributeDeclaration(SgName const& name);	DQ (8/17/2014): Adding support for MS‐style attribute declarations.
buildMinusAssignOp SgMinusAssignOp* buildMinusAssignOp(SgExpression* lhs, SgExpression* rhs);
buildMinusAssignOp_nfi SgMinusAssignOp* buildMinusAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildMinusMinusOp SgMinusMinusOp* buildMinusMinusOp(SgExpression* op);
buildMinusMinusOp_nfi SgMinusMinusOp* buildMinusMinusOp_nfi(SgExpression* op);
buildMinusOp SgMinusOp* buildMinusOp(SgExpression* op);	Build ‐‐ expression, Sgop_mode is a value of either SgUnaryOp::prefix or SgUnaryOp::postfix
buildMinusOp_nfi SgMinusOp* buildMinusOp_nfi(SgExpression* op);
buildModAssignOp SgModAssignOp* buildModAssignOp(SgExpression* lhs, SgExpression* rhs);
buildModAssignOp_nfi SgModAssignOp* buildModAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildModOp SgModOp* buildModOp(SgExpression* lhs, SgExpression* rhs);
buildModOp_nfi SgModOp* buildModOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildModifierType SgModifierType* buildModifierType(SgType* base_type = nullptr);	Build a modifier type.
buildModuleStatement SgModuleStatement* buildModuleStatement(SgName const& name, SgScopeStatement* scope);	Build a Fortran module declaration.
buildMultAssignOp SgMultAssignOp* buildMultAssignOp(SgExpression* lhs, SgExpression* rhs);
buildMultAssignOp_nfi SgMultAssignOp* buildMultAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildMultibyteNopStatement SgAsmStmt* buildMultibyteNopStatement(int n);	DQ (4/30/2010): Added support for building nop statement using asm statement Building nop statement using asm statement
buildMultiplyOp SgMultiplyOp* buildMultiplyOp(SgExpression* lhs, SgExpression* rhs);
buildMultiplyOp_nfi SgMultiplyOp* buildMultiplyOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildNamespaceAliasDeclarationStatement SgNamespaceAliasDeclarationStatement* buildNamespaceAliasDeclarationStatement(SgName const& name, SgNamespaceDeclarationStatement* namespaceDeclaration);
buildNamespaceDeclaration SgNamespaceDeclarationStatement* buildNamespaceDeclaration(SgName const& name, SgScopeStatement* scope = NULL);	tps (09/02/2009) : Added support for building namespaces
buildNamespaceDeclaration_nfi SgNamespaceDeclarationStatement* buildNamespaceDeclaration_nfi(SgName const& name, bool unnamednamespace, SgScopeStatement* scope);
buildNamespaceDefinition SgNamespaceDefinitionStatement* buildNamespaceDefinition(SgNamespaceDeclarationStatement* d = NULL);
buildNewExp SgNewExp* buildNewExp(SgType* type, SgExprListExp* exprListExp, SgConstructorInitializer* constInit, SgExpression* expr, short val, SgFunctionDeclaration* funcDecl);
buildNoexceptOp SgNoexceptOp* buildNoexceptOp(SgExpression* exp = NULL);	Build noexcept operator expression with an expression parameter
buildNoexceptOp_nfi SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp);
buildNondefiningClassDeclaration SgClassDeclaration* buildNondefiningClassDeclaration(SgName name, SgScopeStatement* scope);	DQ (11/7/2009): Added functions to build C++ class.
buildNondefiningClassDeclaration_nfi SgClassDeclaration* buildNondefiningClassDeclaration_nfi(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList);
buildNondefiningEnumDeclaration_nfi SgEnumDeclaration* buildNondefiningEnumDeclaration_nfi(SgName const& name, SgScopeStatement* scope);	Build an enum first nondefining declaration, without file info
buildNondefiningFunctionDeclaration SgFunctionDeclaration* buildNondefiningFunctionDeclaration(SgFunctionDeclaration const* funcdecl, SgScopeStatement* scope = NULL);	buildNondefiningFunctionDeclaration overloads
buildNondefiningMemberFunctionDeclaration SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope = NULL);	Build a prototype member function declaration
buildNondefiningProcedureHeaderStatement SgProcedureHeaderStatement* buildNondefiningProcedureHeaderStatement(SgName const& name, SgType* return_type, SgFunctionParameterList* param_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope = NULL);	Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently
buildNondefiningTemplateClassDeclaration SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);	buildNondefiningTemplateClassDeclaration()
buildNondefiningTemplateClassDeclaration_nfi SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);	DQ (11/29/2011): Adding template declaration support to the AST.
buildNondefiningTemplateFunctionDeclaration SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope = NULL, SgTemplateParameterPtrList* templateParameterList = NULL);
buildNondefiningTemplateMemberFunctionDeclaration SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration(SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList);
buildNonrealBaseClass SgNonrealBaseClass* buildNonrealBaseClass(SgNonrealDecl* classDeclaration, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect);
buildNonrealDecl SgNonrealDecl* buildNonrealDecl(SgName const& name, SgDeclarationScope* scope, SgDeclarationScope* child_scope = NULL);	Build a declaration of a non‐real class or class‐member representing template parameters and their members
buildNonrealRefExp_nfi SgNonrealRefExp* buildNonrealRefExp_nfi(SgNonrealSymbol* sym);	Build a reference to the non‐real declaration of a member of a non‐real class
buildNonrealType SgNonrealType* buildNonrealType(SgName const& name, SgDeclarationScope* scope);	buildNonrealType overloads
buildNotEqualOp SgNotEqualOp* buildNotEqualOp(SgExpression* lhs, SgExpression* rhs);
buildNotEqualOp_nfi SgNotEqualOp* buildNotEqualOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildNotOp SgNotOp* buildNotOp(SgExpression* op);
buildNotOp_nfi SgNotOp* buildNotOp_nfi(SgExpression* op);
buildNullExpression SgNullExpression* buildNullExpression();	Build a null expression, set file info as the default one.
buildNullExpression_nfi SgNullExpression* buildNullExpression_nfi();	No file info version of buildNullExpression(). File info is to be set later on.
buildNullStatement SgNullStatement* buildNullStatement();	Build a NULL statement
buildNullStatement_nfi SgNullStatement* buildNullStatement_nfi();
buildNullptrType SgTypeNullptr* buildNullptrType();
buildNullptrValExp SgNullptrValExp* buildNullptrValExp();	DQ (7/31/2014): Adding support for C++11 nullptr const value expressions.
buildNullptrValExp_nfi SgNullptrValExp* buildNullptrValExp_nfi();
buildOpaqueType 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, especially for a runtime library's internal type. Must provide scope here. Some types are not known during translation but nevertheless are needed. For example, some internal types from a runtime library. To work around this problem: this function prepends a hidden typedef declaration into scope 'typedef int OpaqueTypeName;' The translation‐generated code is expected to include the runtime library's headers to have the real type declarations.
buildOpaqueVarRefExp SgVarRefExp* buildOpaqueVarRefExp(std::string const& varName, SgScopeStatement* scope = NULL);	Build a variable reference expression at scope to an opaque variable which has unknown information except for its name. Used when referring to an internal variable defined in some headers of runtime libraries.(The headers are not yet inserted into the file during translation). Similar to buildOpaqueType(); It will declare a hidden int varName at the specified scope to cheat the AST consistence tests.
buildOrOp SgOrOp* buildOrOp(SgExpression* lhs, SgExpression* rhs);
buildOrOp_nfi SgOrOp* buildOrOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildPlusAssignOp SgPlusAssignOp* buildPlusAssignOp(SgExpression* lhs, SgExpression* rhs);
buildPlusAssignOp_nfi SgPlusAssignOp* buildPlusAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildPlusPlusOp SgPlusPlusOp* buildPlusPlusOp(SgExpression* op);	Build ++x or x++ , specify prefix or postfix using either SgUnaryOp::prefix or SgUnaryOp::postfix
buildPlusPlusOp_nfi SgPlusPlusOp* buildPlusPlusOp_nfi(SgExpression* op);
buildPntrArrRefExp SgPntrArrRefExp* buildPntrArrRefExp(SgExpression* lhs, SgExpression* rhs);
buildPntrArrRefExp_nfi SgPntrArrRefExp* buildPntrArrRefExp_nfi(SgExpression* lhs, SgExpression* rhs);
buildPointerDerefExp SgPointerDerefExp* buildPointerDerefExp(SgExpression* op);
buildPointerDerefExp_nfi SgPointerDerefExp* buildPointerDerefExp_nfi(SgExpression* op);
buildPointerMemberType SgPointerMemberType* buildPointerMemberType(SgType* base_type, SgType* classType);	Pei‐Hung (06/30/2023): support for SgPointerMemberType
buildPointerType SgPointerType* buildPointerType(SgType* base_type = nullptr);	Build a pointer type
buildPragma SgPragma* buildPragma(std::string const& name);	Build SgPragma
buildPragmaDeclaration SgPragmaDeclaration* buildPragmaDeclaration(std::string const& name, SgScopeStatement* scope = NULL);	Build pragma declaration, handle SgPragma and defining/nondefining pointers internally
buildPragmaDeclaration_nfi SgPragmaDeclaration* buildPragmaDeclaration_nfi(std::string const& name, SgScopeStatement* scope);
buildProcedureHeaderStatement SgProcedureHeaderStatement* buildProcedureHeaderStatement(SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgScopeStatement* scope = NULL);	Build a Fortran subroutine or procedure
buildRangeBasedForStatement_nfi SgRangeBasedForStatement* buildRangeBasedForStatement_nfi(SgVariableDeclaration* initializer, SgVariableDeclaration* range, SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration, SgExpression* not_equal_expression, SgExpression* increment_expression, SgStatement* body);
buildRangeExp SgRangeExp* buildRangeExp(SgExpression* start);
buildRealPartOp SgRealPartOp* buildRealPartOp(SgExpression* op);
buildRealPartOp_nfi SgRealPartOp* buildRealPartOp_nfi(SgExpression* op);
buildReferenceType SgReferenceType* buildReferenceType(SgType* base_type = nullptr);	Build a reference type
buildRestrictType SgModifierType* buildRestrictType(SgType* base_type);	Build a restrict type.
buildReturnStmt SgReturnStmt* buildReturnStmt(SgExpression* expression = NULL);	Build a return statement
buildReturnStmt_nfi SgReturnStmt* buildReturnStmt_nfi(SgExpression* expression);
buildRshiftAssignOp SgRshiftAssignOp* buildRshiftAssignOp(SgExpression* lhs, SgExpression* rhs);
buildRshiftAssignOp_nfi SgRshiftAssignOp* buildRshiftAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildRshiftOp SgRshiftOp* buildRshiftOp(SgExpression* lhs, SgExpression* rhs);
buildRshiftOp_nfi SgRshiftOp* buildRshiftOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildRvalueReferenceType SgRvalueReferenceType* buildRvalueReferenceType(SgType* base_type);	Build a rvalue reference type
buildScopeOp SgScopeOp* buildScopeOp(SgExpression* lhs, SgExpression* rhs);
buildScopeOp_nfi SgScopeOp* buildScopeOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildShortType SgTypeShort* buildShortType();
buildShortVal SgShortVal* buildShortVal(short value = 0);
buildShortValHex SgShortVal* buildShortValHex(short value = 0);
buildShortVal_nfi SgShortVal* buildShortVal_nfi(short value, std::string const& str);
buildSigned128bitIntegerType SgTypeSigned128bitInteger* buildSigned128bitIntegerType();
buildSignedCharType SgTypeSignedChar* buildSignedCharType();
buildSignedCharVal SgSignedCharVal* buildSignedCharVal(signed char v = 0);	Build a signed char
buildSignedCharValHex SgSignedCharVal* buildSignedCharValHex(signed char v = 0);
buildSignedCharVal_nfi SgSignedCharVal* buildSignedCharVal_nfi(signed char v, std::string const& str);
buildSignedIntType SgTypeSignedInt* buildSignedIntType();
buildSignedLongLongType SgTypeSignedLongLong* buildSignedLongLongType();
buildSignedLongType SgTypeSignedLong* buildSignedLongType();
buildSignedShortType SgTypeSignedShort* buildSignedShortType();
buildSizeOfOp SgSizeOfOp* buildSizeOfOp(SgExpression* exp = NULL);	buildSizeOfOp overloads
buildSizeOfOp_nfi SgSizeOfOp* buildSizeOfOp_nfi(SgExpression* exp);
buildSourceFile SgSourceFile* buildSourceFile(std::string const& outputFileName, SgProject* project = NULL, bool clear_globalScopeAcrossFiles = false);	buildSourceFile overloads
buildSpaceshipOp SgSpaceshipOp* buildSpaceshipOp(SgExpression* lhs, SgExpression* rhs);
buildSpaceshipOp_nfi SgSpaceshipOp* buildSpaceshipOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildStatementExpression SgStatementExpression* buildStatementExpression(SgStatement* exp);	Build a GNU statement expression
buildStatementExpression_nfi SgStatementExpression* buildStatementExpression_nfi(SgStatement* exp);
buildStaticAssertionDeclaration SgStaticAssertionDeclaration* buildStaticAssertionDeclaration(SgExpression* condition, SgName const& string_literal);	DQ (7/25/2014): Adding support for C11 static assertions.
buildStmtDeclarationStatement SgStmtDeclarationStatement* buildStmtDeclarationStatement(SgStatement* stmt);	Build a StmtDeclarationStmt
buildStmtDeclarationStatement_nfi SgStmtDeclarationStatement* buildStmtDeclarationStatement_nfi(SgStatement* stmt);
buildStringType SgTypeString* buildStringType();	DQ (8/21/2010): We want to move to the new buildStringType( SgExpression*,size_t) function over the older buildStringType() function.
buildStringVal SgStringVal* buildStringVal(std::string value = "");
buildStringVal_nfi SgStringVal* buildStringVal_nfi(std::string value);
buildStructDeclaration SgClassDeclaration* buildStructDeclaration(SgName const& name, SgScopeStatement* scope = NULL);	Build a structure, It is also a declaration statement in SAGE III
buildSubscriptExpression_nfi SgSubscriptExpression* buildSubscriptExpression_nfi(SgExpression* lower_bound, SgExpression* upper_bound, SgExpression* stride);	Build a SgSubscriptExpression, used for array shape expressions. The lower bound and stride may be nullptrs
buildSubtractOp SgSubtractOp* buildSubtractOp(SgExpression* lhs, SgExpression* rhs);
buildSubtractOp_nfi SgSubtractOp* buildSubtractOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildSuperExp SgSuperExp* buildSuperExp(SgClassSymbol* sym);	Build super pointer
buildSuperExp_nfi SgSuperExp* buildSuperExp_nfi(SgClassSymbol* sym);
buildSwitchStatement SgSwitchStatement* buildSwitchStatement(SgExpression* item_selector, SgStatement* body = NULL);	Build a switch statement
buildSwitchStatement_nfi SgSwitchStatement* buildSwitchStatement_nfi(SgStatement* item_selector, SgStatement* body);
buildTemplateClassDeclaration SgTemplateClassDeclaration* buildTemplateClassDeclaration(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);	Build tempplate class declaration
buildTemplateClassDeclaration_nfi SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi(SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* nonDefiningDecl, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList);
buildTemplateClassDefinition SgTemplateClassDefinition* buildTemplateClassDefinition(SgTemplateClassDeclaration* d = NULL);	Build a template class definition statement
buildTemplateClassType SgClassType* buildTemplateClassType(SgTemplateClassDeclaration* template_decl, std::vector<SgNode*>& template_args);	Same as buildClassTemplateType(), just better name
buildTemplateFunctionRefExp_nfi SgTemplateFunctionRefExp* buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol* sym);	DQ (12/15/2011): Adding template declaration support to the AST.
buildTemplateInstantiationTypedefDeclaration_nfi SgTemplateInstantiationTypedefDeclaration* buildTemplateInstantiationTypedefDeclaration_nfi(SgName& name, SgType* base_type, SgScopeStatement* scope, bool has_defining_base, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList& templateArgumentsList);
buildTemplateMemberFunctionRefExp_nfi SgTemplateMemberFunctionRefExp* buildTemplateMemberFunctionRefExp_nfi(SgTemplateMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier);	DQ (12/29/2011): Adding template declaration support to the AST.
buildTemplateParameter SgTemplateParameter* buildTemplateParameter(SgTemplateParameter::template_parameter_enum parameterType, SgType*);	Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum { parameter_undefined = 0, type_parameter = 1, nontype_parameter = 2, template_parameter = 3}
buildTemplateParameterVal SgTemplateParameterVal* buildTemplateParameterVal(int template_parameter_position = ‐1);	Build an template parameter value expression
buildTemplateParameterVal_nfi SgTemplateParameterVal* buildTemplateParameterVal_nfi(int template_parameter_position, std::string const& str);
buildTemplateType SgTemplateType* buildTemplateType(SgName name = "");	Build a template type, used for template parameter and later argument
buildTemplateTypedefDeclaration_nfi SgTemplateTypedefDeclaration* buildTemplateTypedefDeclaration_nfi(SgName const& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base = false);
buildTemplateVariableDeclaration SgTemplateVariableDeclaration* buildTemplateVariableDeclaration(SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope);	Build template variable declarations
buildTemplateVariableDeclaration_nfi SgTemplateVariableDeclaration* buildTemplateVariableDeclaration_nfi(SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope);
buildThisExp SgThisExp* buildThisExp(SgSymbol* sym);	Build this pointer
buildThisExp_nfi SgThisExp* buildThisExp_nfi(SgSymbol* sym);
buildThrowOp SgThrowOp* buildThrowOp(SgExpression*, SgThrowOp::e_throw_kind);	Build a ThrowOp expression
buildTryStmt SgTryStmt* buildTryStmt(SgStatement* body, SgCatchOptionStmt* catch0 = NULL, SgCatchOptionStmt* catch1 = NULL, SgCatchOptionStmt* catch2 = NULL, SgCatchOptionStmt* catch3 = NULL, SgCatchOptionStmt* catch4 = NULL);	Build a try statement.
buildTypeExpression SgTypeExpression* buildTypeExpression(SgType* type);	DQ (7/24/2014): Adding support for c11 generic operands.
buildTypeIdOp SgTypeIdOp* buildTypeIdOp(SgExpression* operand_expr, SgType* operand_type, SgType* expression_type = NULL);	DQ (1/25/2013): Added support for typeId operators.
buildTypeOfType SgTypeOfType* buildTypeOfType(SgExpression* base_expression, SgType* base_type);	Build a GNU typeof operator
buildTypeTraitBuiltinOperator SgTypeTraitBuiltinOperator* buildTypeTraitBuiltinOperator(SgName functionName, SgNodePtrList parameters);
buildTypedefDeclaration SgTypedefDeclaration* buildTypedefDeclaration(std::string const& 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;
buildTypedefDeclaration_nfi SgTypedefDeclaration* buildTypedefDeclaration_nfi(std::string const& name, SgType* base_type, SgScopeStatement* scope = NULL, bool has_defining_base = false);
buildUnaryAddOp SgUnaryAddOp* buildUnaryAddOp(SgExpression* op);
buildUnaryAddOp_nfi SgUnaryAddOp* buildUnaryAddOp_nfi(SgExpression* op);
buildUnaryExpression template<class T> T* buildUnaryExpression(SgExpression* operand);	Template function to build a unary expression of type T. Instantiated functions include:buildAddressOfOp(),buildBitComplementOp(),buildBitComplementOp(),buildMinusOp(),buildNotOp(),buildPointerDerefExp(),buildUnaryAddOp(),buildMinusMinusOp(),buildPlusPlusOp(). They are also used for the unary vararg operators (which are not technically unary operators). The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros.
buildUnaryExpression_nfi template<class T> T* buildUnaryExpression_nfi(SgExpression* operand);	Template function to build a unary expression of type T with no file info. Instantiated functions include:buildAddressOfOp(),buildBitComplementOp(),buildBitComplementOp(),buildMinusOp(),buildNotOp(),buildPointerDerefExp(),buildUnaryAddOp(),buildMinusMinusOp(),buildPlusPlusOp(). They are also used for the unary vararg operators (which are not technically unary operators). The instantiated functions' prototypes are not shown since they are expanded using macros. Documentation tools do not expand these macros.
buildUnknownType SgTypeUnknown* buildUnknownType();
buildUnsigned128bitIntegerType SgTypeUnsigned128bitInteger* buildUnsigned128bitIntegerType();
buildUnsignedCharType SgTypeUnsignedChar* buildUnsignedCharType();
buildUnsignedCharVal SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0);	Build an unsigned char
buildUnsignedCharValHex SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0);
buildUnsignedCharVal_nfi SgUnsignedCharVal* buildUnsignedCharVal_nfi(unsigned char v, std::string const& str);
buildUnsignedIntType SgTypeUnsignedInt* buildUnsignedIntType();
buildUnsignedIntVal SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0);	Build an unsigned integer
buildUnsignedIntValHex SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0);
buildUnsignedIntVal_nfi SgUnsignedIntVal* buildUnsignedIntVal_nfi(unsigned int v, std::string const& str);
buildUnsignedLongLongIntVal SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0);	Build an unsigned long long integer
buildUnsignedLongLongIntValHex SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0);
buildUnsignedLongLongIntVal_nfi SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi(unsigned long long v, std::string const& str);
buildUnsignedLongLongType SgTypeUnsignedLongLong* buildUnsignedLongLongType();
buildUnsignedLongType SgTypeUnsignedLong* buildUnsignedLongType();
buildUnsignedLongVal SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0);	Build a unsigned long integer
buildUnsignedLongValHex SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0);
buildUnsignedLongVal_nfi SgUnsignedLongVal* buildUnsignedLongVal_nfi(unsigned long v, std::string const& str);
buildUnsignedShortType SgTypeUnsignedShort* buildUnsignedShortType();
buildUnsignedShortVal SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0);	Build an unsigned short integer
buildUnsignedShortValHex SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0);
buildUnsignedShortVal_nfi SgUnsignedShortVal* buildUnsignedShortVal_nfi(unsigned short v, std::string const& str);
buildUsingDirectiveStatement SgUsingDirectiveStatement* buildUsingDirectiveStatement(SgNamespaceDeclarationStatement* ns_decl);	Build a using directive statement
buildVarArgCopyOp SgVarArgCopyOp* buildVarArgCopyOp(SgExpression* lhs, SgExpression* rhs);
buildVarArgCopyOp_nfi SgVarArgCopyOp* buildVarArgCopyOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildVarArgEndOp SgVarArgEndOp* buildVarArgEndOp(SgExpression* op);
buildVarArgEndOp_nfi SgVarArgEndOp* buildVarArgEndOp_nfi(SgExpression* op);
buildVarArgOp_nfi SgVarArgOp* buildVarArgOp_nfi(SgExpression* operand_i, SgType* expression_type);	Build vararg op expression
buildVarArgStartOneOperandOp SgVarArgStartOneOperandOp* buildVarArgStartOneOperandOp(SgExpression* op);
buildVarArgStartOneOperandOp_nfi SgVarArgStartOneOperandOp* buildVarArgStartOneOperandOp_nfi(SgExpression* op);
buildVarArgStartOp SgVarArgStartOp* buildVarArgStartOp(SgExpression* lhs, SgExpression* rhs);
buildVarArgStartOp_nfi SgVarArgStartOp* buildVarArgStartOp_nfi(SgExpression* lhs, SgExpression* rhs);
buildVarRefExp SgVarRefExp* buildVarRefExp(SgVariableDeclaration* vardecl);	buildVarRefExp overloads
buildVarRefExp_nfi SgVarRefExp* buildVarRefExp_nfi(SgVariableSymbol* varSymbol);
buildVariableDeclaration SgVariableDeclaration* buildVariableDeclaration(SgName const& name, SgType* type, SgInitializer* varInit = NULL, SgScopeStatement* scope = NULL);	Build a variable declaration, handle symbol table transparently
buildVariableDeclaration_nfi SgVariableDeclaration* buildVariableDeclaration_nfi(SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, bool builtFromUseOnly = false, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default);
buildVariableDefinition_nfi SgVariableDefinition* buildVariableDefinition_nfi(SgVariableDeclaration* decl, SgInitializedName* init_name, SgInitializer* init);	Build variable definition
buildVariantExpression SgVariantExpression* buildVariantExpression();	handle side effects of parent pointers, Sg_File_Info, lvalue etc.
buildVoidType SgTypeVoid* buildVoidType();
buildVoidVal SgVoidVal* buildVoidVal();	DQ (2/14/2019): Adding support for C++14 void value expressions.
buildVoidVal_nfi SgVoidVal* buildVoidVal_nfi();
buildVolatileType SgModifierType* buildVolatileType(SgType* base_type = nullptr);	Build a volatile type.
buildWcharType SgTypeWchar* buildWcharType();
buildWcharVal SgWcharVal* buildWcharVal(wchar_t value = 0);
buildWcharVal_nfi SgWcharVal* buildWcharVal_nfi(wchar_t value, std::string const& str);
buildWhileStmt SgWhileStmt* buildWhileStmt(SgExpression* condition, SgStatement* body);	Build while statement
buildWhileStmt_nfi SgWhileStmt* buildWhileStmt_nfi(SgStatement* condition, SgStatement* body);
buildXorAssignOp SgXorAssignOp* buildXorAssignOp(SgExpression* lhs, SgExpression* rhs);
buildXorAssignOp_nfi SgXorAssignOp* buildXorAssignOp_nfi(SgExpression* lhs, SgExpression* rhs);
clearScopeStack void clearScopeStack();
display std::string display(SourcePositionClassification& scp);	display function for debugging
emptyScopeStack bool emptyScopeStack();
errorCheckingTargetAST void errorCheckingTargetAST(SgNode* node_copy, SgNode* node_original, SgFile* targetFile, bool failOnWarning);	Error checking the inserted snippet AST.
findAssociatedDeclarationInTargetAST SgDeclarationStatement* findAssociatedDeclarationInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
findAssociatedSymbolInTargetAST SgSymbol* findAssociatedSymbolInTargetAST(SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope);
fixupCopyOfAstFromSeparateFileInNewTargetAst 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.).
fixupCopyOfNodeFromSeparateFileInNewTargetAst void fixupCopyOfNodeFromSeparateFileInNewTargetAst(SgStatement* insertionPoint, bool insertionPointIsScope, SgNode* node_copy, SgNode* node_original);
fixupSharingSourcePosition void fixupSharingSourcePosition(SgNode* subtreeRoot, int new_file_id);	Sharing IR nodes requires that the file id be added to the fileIDsToUnparse held in the Sg_File_Info object.
fixupSourcePositionFileSpecification void fixupSourcePositionFileSpecification(SgNode* subtreeRoot, std::string const& newFileName);
getGlobalScopeFromScopeStack SgScopeStatement* getGlobalScopeFromScopeStack();	Support to retrive the SgGlobal from the internal scope stack (error if not present in a non‐empty list, return null for empty list).
getSourcePositionClassificationMode SourcePositionClassification getSourcePositionClassificationMode();	Get the current source position classification (defines how IR nodes built by the SageBuilder interface will be classified).
getTargetFileType SgType* getTargetFileType(SgType* snippet_type, SgScopeStatement* targetScope);
getTargetFileTypeSupport SgType* getTargetFileTypeSupport(SgType* snippet_type, SgScopeStatement* targetScope);
getTemplateArgumentList SgTemplateArgumentPtrList* getTemplateArgumentList(SgDeclarationStatement* decl);
getTemplateParameterList SgTemplateParameterPtrList* getTemplateParameterList(SgDeclarationStatement* decl);
inSwitchScope bool inSwitchScope();
popScopeStack void popScopeStack();
pushScopeStack void pushScopeStack(SgScopeStatement* stmt);	Public interfaces of the scope stack, should be stable
setSourcePositionClassificationMode void setSourcePositionClassificationMode(SourcePositionClassification X);	Set the current source position classification (defines how IR nodes built by the SageBuilder interface will be classified).
setTemplateArgumentParents void setTemplateArgumentParents(SgDeclarationStatement* decl);
setTemplateArgumentsInDeclaration void setTemplateArgumentsInDeclaration(SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input);	DQ (9/16/2012): Added function to support setting the template arguments and setting their parents (and for any relevant declaration).
setTemplateNameInTemplateInstantiations void setTemplateNameInTemplateInstantiations(SgFunctionDeclaration* func, SgName const& name);	DQ (2/11/2012): Added support to set the template name in function template instantiations (member and non‐member).
setTemplateParameterParents void setTemplateParameterParents(SgDeclarationStatement* decl);
setTemplateParametersInDeclaration void setTemplateParametersInDeclaration(SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input);
setTemplateSpecializationArgumentsInDeclaration void setTemplateSpecializationArgumentsInDeclaration(SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input);
testTemplateArgumentParents void testTemplateArgumentParents(SgDeclarationStatement* decl);
testTemplateParameterParents void testTemplateParameterParents(SgDeclarationStatement* decl);	DQ (9/16/2012): Added function to support setting the template parameters and setting their parents (and for any relevant declaration).
topScopeStack SgScopeStatement* topScopeStack();
unparseTemplateArgumentToString SgName unparseTemplateArgumentToString(SgTemplateArgument* templateArgument);	DQ (3/9/2018): Added to support debugging.

Variables

Name	Description
ScopeStack	intended to be a private member, don't access it directly. could be changed any time
SourcePositionClassificationMode	C++ SageBuilder namespace specific state for storage of the source code position state (used to control how the source code positon is defined for IR nodes built within the SageBuilder interface).
symbol_table_case_insensitive_semantics	Support for construction of case sensitive/insensitive symbol table handling in scopes.

Using Namespace Directives

Name

Templates

Description

Building AST trees using raw SgNode constructors is tedious and error‐prone. It becomes even more difficult with the presence of symbol tables. This namespace contains major AST node builders on top of the constructors to take care of symbol tables, various edges to scope, parent relationships, and so on.

See frontendSageHighLevelInterface.

Created with MrDocs