adoptFunctionDeclaratorScope
[[visibility("default")]] void adoptFunctionDeclaratorScope( SgFunctionDeclaration* owner, SgDeclarationScope* scope); | Transfer one detached signature scope to its exact function owner. |
adoptSourceDeclaratorScope
[[visibility("default")]] void adoptSourceDeclaratorScope( SgDeclarationStatement* owner, SgDeclarationScope* scope); | Transfer a detached declarator-local source scope to its exact non-function declaration owner. The scope's declarations keep their independent semantic symbol scopes; only structural source ownership changes. |
attachAuxiliaryDeclaration
[[visibility("default")]] void attachAuxiliaryDeclaration( SgScopeStatement* owner, SgDeclarationStatement* declaration); | Own a semantic-only declaration without adding it to source emission. |
attachSemanticDeclarationScope
[[visibility("default")]] void attachSemanticDeclarationScope( SgScopeStatement* owner, SgDeclarationScope* scope); | Attach semantic-only declaration-scope infrastructure to its exact structural owner. Both the container and scope must already carry exact semantic provenance; this operation never publishes a physical output owner or reclassifies their subtree. |
attachSourceDeclaratorTag
[[visibility("default")]] void attachSourceDeclaratorTag( SgDeclarationScope* owner, SgDeclarationStatement* declaration); | Attach a fresh source-written class/enum declaration to its exact function declarator scope without changing its semantic symbol scope. This is the construction-time structural transaction used by Clang TypeLoc producers; it does not synthesize source provenance or transfer an existing owner. |
beginSourceDeclaratorScopeConstruction
[[visibility("default")]] void beginSourceDeclaratorScopeConstruction( SgDeclarationStatement* owner, SgDeclarationScope* scope); | Begin construction of a non-function declaration whose TypeLoc owns nested source-written tags. Both nodes must be fresh and the scope must be empty; finishSourceDeclaratorScopeConstruction() hard-validates the populated source children before the declaration can be published. |
buildActualArgumentExpression_nfi
SgActualArgumentExpression* buildActualArgumentExpression_nfi( SgName arg_name, SgExpression* arg); | Build an Actual Argument Expression |
buildAddOp
[[visibility("default")]] SgAddOp* buildAddOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAddOp_nfi
[[visibility("default")]] SgAddOp* buildAddOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAddressOfOp
[[visibility("default")]] SgAddressOfOp* buildAddressOfOp( SgExpression* operand, SgType* type, SgAddressOfOp::address_operand_form_enum form); | |
buildAddressOfOp_nfi
[[visibility("default")]] SgAddressOfOp* buildAddressOfOp_nfi( SgExpression* operand, SgType* type, SgAddressOfOp::address_operand_form_enum form); | |
buildAddressOfResultType
[[visibility("default")]] SgPointerType* buildAddressOfResultType(SgType* operand_type); | Build the exact semantic result type of applying unary '&' to an expression of operand_type. C++ reference declarations denote their referred-to object in an expression, so this never constructs the illegal pointer-to-reference type. |
buildAggregateInitializer
[[visibility("default")]] SgAggregateInitializer* buildAggregateInitializer( SgExprListExp* initializers, SgType* type, SgAggregateInitializer::aggregate_initializer_source_form_enum source_form); | Build an aggregate initializer |
buildAggregateInitializer_nfi
[[visibility("default")]] SgAggregateInitializer* buildAggregateInitializer_nfi( SgExprListExp* initializers, SgType* type, SgAggregateInitializer::aggregate_initializer_source_form_enum source_form); | |
buildAlignOfOp
[[visibility("default")]] SgAlignOfOp* buildAlignOfOp( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_preferred_alignof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt); | buildAlignOfOp overloads |
buildAlignOfOp_nfi
[[visibility("default")]] SgAlignOfOp* buildAlignOfOp_nfi( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_preferred_alignof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt); | |
buildAndAssignOp
[[visibility("default")]] SgAndAssignOp* buildAndAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAndAssignOp_nfi
[[visibility("default")]] SgAndAssignOp* buildAndAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAndOp
[[visibility("default")]] SgAndOp* buildAndOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAndOp_nfi
[[visibility("default")]] SgAndOp* buildAndOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAnonymousStructDeclaration
[[visibility("default")]] SgClassDeclaration* buildAnonymousStructDeclaration( declaration_ownership const& ownership, SgName const& internalName, SgScopeStatement* scope); | Build a source-anonymous structure with an explicit, non-empty semantic identity. The internal name is never emitted as source. |
buildArrayType
[[visibility("default")]] SgArrayType* buildArrayType( SgType* base_type, SgExprListExp* dim_info); | buildArrayType overloads |
buildArrowExp
[[visibility("default")]] SgArrowExp* buildArrowExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildArrowExp_nfi
[[visibility("default")]] SgArrowExp* buildArrowExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildArrowStarOp
[[visibility("default")]] SgArrowStarOp* buildArrowStarOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildArrowStarOp_nfi
[[visibility("default")]] SgArrowStarOp* buildArrowStarOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAsmStatement
[[visibility("default")]] SgAsmStmt* buildAsmStatement(std::string s); | Build an asm statement |
buildAssignInitializer
[[visibility("default")]] SgAssignInitializer* buildAssignInitializer( SgExpression* operand_i, SgType* expression_type); | Build the rhs of a variable declaration which includes an assignment |
buildAssignInitializer_nfi
[[visibility("default")]] SgAssignInitializer* buildAssignInitializer_nfi( SgExpression* operand_i, SgType* expression_type); | |
buildAssignOp
[[visibility("default")]] SgAssignOp* buildAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAssignOp_nfi
[[visibility("default")]] SgAssignOp* buildAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildAssignStatement
[[visibility("default")]] SgExprStatement* buildAssignStatement( SgExpression* lhs, SgExpression* rhs); | Build an assignment statement from lefthand operand and right hand operand |
buildAttributeSpecificationStatement
[[visibility("default")]] SgAttributeSpecificationStatement* buildAttributeSpecificationStatement( SgAttributeSpecificationStatement::attribute_spec_enum kind, SgDataStatementGroupPtrList const& groups = {}); | Build Fortran attribute specification statement |
buildAttributeSpecificationStatement_nfi
[[visibility("default")]] SgAttributeSpecificationStatement* buildAttributeSpecificationStatement_nfi( SgAttributeSpecificationStatement::attribute_spec_enum kind, SgDataStatementGroupPtrList const& groups = {}); | Build a source-backed Fortran attribute specification statement whose exact file information will be published by the frontend. |
buildAutoType
[[visibility("default")]] SgAutoType* buildAutoType(); | |
buildAwaitExpression_nfi
[[visibility("default")]] SgAwaitExpression* buildAwaitExpression_nfi( SgExpression* value, SgType* result_type, SgAwaitExpression::coroutine_keyword_kind_enum keyword); | |
buildBFloat16Type
[[visibility("default")]] SgTypeBFloat16* buildBFloat16Type(); | |
buildBFloat16Val
[[visibility("default")]] SgBFloat16Val* buildBFloat16Val(float v = 0); | Build a bfloat16 |
buildBFloat16Val_nfi
[[visibility("default")]] SgBFloat16Val* buildBFloat16Val_nfi( float v, std::string const& str); | |
buildBaseClass
[[visibility("default")]] SgBaseClass* buildBaseClass( SgClassDeclaration* classDeclaration, SgType* sourceType, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect, SgSymbol* fortranSourceSymbol = nullptr); | |
buildBasicBlock
[[visibility("default")]] 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
[[visibility("default")]] SgBasicBlock* buildBasicBlock_nfi(); | Build a SgBasicBlock and set its parent. This function does NOT link the parent scope to the block. |
buildBinaryConditionalExp
[[visibility("default")]] SgConditionalExp* buildBinaryConditionalExp( SgExpression* common, SgExpression* false_expression, SgType* result_type); | Build the GNU omitted-middle conditional common ?: false_expression. The common operand is represented once and therefore evaluated once. |
buildBinaryConditionalExp_nfi
SgConditionalExp* buildBinaryConditionalExp_nfi( SgExpression* common, SgExpression* false_expression, SgType* result_type); | |
buildBinaryExpression
template<class T> T* buildBinaryExpression( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBinaryExpression_nfi
template< class T, class... Args> T* buildBinaryExpression_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type, Args&&... args); | |
buildBitAndOp
[[visibility("default")]] SgBitAndOp* buildBitAndOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBitAndOp_nfi
[[visibility("default")]] SgBitAndOp* buildBitAndOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBitComplementOp
[[visibility("default")]] SgBitComplementOp* buildBitComplementOp( SgExpression* op, SgType* result_type); | |
buildBitComplementOp_nfi
[[visibility("default")]] SgBitComplementOp* buildBitComplementOp_nfi( SgExpression* op, SgType* result_type); | |
buildBitOrOp
[[visibility("default")]] SgBitOrOp* buildBitOrOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBitOrOp_nfi
[[visibility("default")]] SgBitOrOp* buildBitOrOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBitXorOp
[[visibility("default")]] SgBitXorOp* buildBitXorOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBitXorOp_nfi
[[visibility("default")]] SgBitXorOp* buildBitXorOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildBoolType
[[visibility("default")]] SgTypeBool* buildBoolType(); | buildBoolType overloads |
buildBoolValExp
[[visibility("default")]] SgBoolValExp* buildBoolValExp(bool value = 0); | Build a bool value expression. |
buildBoolValExp_nfi
[[visibility("default")]] SgBoolValExp* buildBoolValExp_nfi(int value); | |
buildBracedInitializer
[[visibility("default")]] SgBracedInitializer* buildBracedInitializer( SgExprListExp* initializers, SgType* expression_type); | Build an braced initializer |
buildBracedInitializer_nfi
[[visibility("default")]] SgBracedInitializer* buildBracedInitializer_nfi( SgExprListExp* initializers, SgType* expression_type); | |
buildBreakStmt
[[visibility("default")]] SgBreakStmt* buildBreakStmt(); | Build a break statement |
buildBreakStmt_nfi
SgBreakStmt* buildBreakStmt_nfi(); | |
buildCaseOptionStmt
[[visibility("default")]] SgCaseOptionStmt* buildCaseOptionStmt( SgExpression* key = NULL, SgStatement* body = NULL); | Build a case option statement |
buildCaseOptionStmt_nfi
SgCaseOptionStmt* buildCaseOptionStmt_nfi( SgExpression* key, SgStatement* body); | |
buildCastExp
[[visibility("default")]] SgCastExp* buildCastExp( SgExpression* operand_i, SgType* expression_type); | buildCastExp overloads |
buildCastExp_nfi
[[visibility("default")]] SgCastExp* buildCastExp_nfi( SgExpression* operand_i, SgType* expression_type); | |
buildCatchOptionStmt
[[visibility("default")]] SgCatchOptionStmt* buildCatchOptionStmt( SgVariableDeclaration* condition = NULL, SgStatement* body = NULL); | Build a catch statement. |
buildCatchOptionStmt_nfi
[[visibility("default")]] SgCatchOptionStmt* buildCatchOptionStmt_nfi( SgVariableDeclaration* condition = NULL, SgStatement* body = NULL); | |
buildChar16Type
[[visibility("default")]] SgTypeChar16* buildChar16Type(); | |
buildChar16Val
[[visibility("default")]] SgChar16Val* buildChar16Val(unsigned short value = 0); | |
buildChar16Val_nfi
[[visibility("default")]] SgChar16Val* buildChar16Val_nfi( unsigned short value, std::string const& str); | |
buildChar32Type
[[visibility("default")]] SgTypeChar32* buildChar32Type(); | |
buildChar32Val
[[visibility("default")]] SgChar32Val* buildChar32Val(unsigned int value = 0); | |
buildChar32Val_nfi
[[visibility("default")]] SgChar32Val* buildChar32Val_nfi( unsigned int value, std::string const& str); | |
buildChar8Type
[[visibility("default")]] SgTypeChar8* buildChar8Type(); | |
buildCharType
[[visibility("default")]] SgTypeChar* buildCharType(); | |
buildCharVal
[[visibility("default")]] SgCharVal* buildCharVal(int64_t value = 0); | |
buildCharVal_nfi
[[visibility("default")]] SgCharVal* buildCharVal_nfi( int64_t value, std::string const& str); | |
buildChooseExpression_nfi
[[visibility("default")]] SgChooseExpression* buildChooseExpression_nfi( SgExpression* condition, SgExpression* true_expression, SgExpression* false_expression, SgType* result_type, SgChooseExpression::selection_kind_enum selection); | |
buildClassDeclaration
[[visibility("default")]] SgClassDeclaration* buildClassDeclaration( declaration_ownership const& ownership, SgName name, SgScopeStatement* scope); | Build both nondefining and defining class declarations, in that order. |
buildClassDeclarationStatement_nfi
template<class DeclClass> [[visibility("default")]] DeclClass* buildClassDeclarationStatement_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl); | 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
[[visibility("default")]] SgClassDeclaration* buildClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDecl, bool buildTemplateInstantiation, SgTemplateArgumentPtrList* templateArgumentsList, SgName const* templateInstantiationName); | |
buildClassDefinition
[[visibility("default")]] SgClassDefinition* buildClassDefinition( SgClassDeclaration* d, bool buildTemplateInstantiation = false); | Build a class definition scope statement |
buildClassDefinition_nfi
SgClassDefinition* buildClassDefinition_nfi( SgClassDeclaration* d, bool buildTemplateInstantiation = false); | Build a class definition scope statement |
buildClassNameRefExp
[[visibility("default")]] SgClassNameRefExp* buildClassNameRefExp(SgClassSymbol* sym); | |
buildClassNameRefExp_nfi
SgClassNameRefExp* buildClassNameRefExp_nfi(SgClassSymbol* sym); | |
buildColonShapeExp
[[visibility("default")]] SgColonShapeExp* buildColonShapeExp(); | Build a Fortran colon-shape expression, set file info as the default one. |
buildColonShapeExp_nfi
[[visibility("default")]] SgColonShapeExp* buildColonShapeExp_nfi(); | No file info version of buildColonShapeExp(). File info is to be set later on. |
buildCommaOpExp
[[visibility("default")]] SgCommaOpExp* buildCommaOpExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildCommaOpExp_nfi
[[visibility("default")]] SgCommaOpExp* buildCommaOpExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildComment
[[visibility("default")]] PreprocessingInfo* buildComment( SgLocatedNode* target, std::string const& content, PreprocessingInfo::DirectiveType commentStyle, PreprocessingInfo::RelativePositionType position = PreprocessingInfo::before); | Build and attach a comment with an explicit lexical comment style. It is a wrapper of SageInterface::attachComment(). |
buildCommonBlock
[[visibility("default")]] SgCommonBlock* buildCommonBlock(SgCommonBlockObject* first_block = NULL); | Build a Fortran Common statement |
buildCommonBlockObject
[[visibility("default")]] SgCommonBlockObject* buildCommonBlockObject( std::string name = "", SgExprListExp* exp_list = NULL); | Build a Fortran common block, possibly with a name |
buildComplexType
[[visibility("default")]] SgTypeComplex* buildComplexType(SgType* base_type = nullptr); | Build a complex type |
buildComplexVal
[[visibility("default")]] SgComplexVal* buildComplexVal( SgExpression* real_value, SgExpression* imaginary_value, SgType* precision_type); | |
buildComplexVal_nfi
[[visibility("default")]] SgComplexVal* buildComplexVal_nfi( SgExpression* real_value, SgExpression* imaginary_value, SgType* precision_type); | |
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()). |
buildCompoundRequirement_nfi
[[visibility("default")]] SgCompoundRequirement* buildCompoundRequirement_nfi( SgExpression* expression, bool noexcept_required, SgExpression* type_constraint); | |
buildConcatenationOp
[[visibility("default")]] SgConcatenationOp* buildConcatenationOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildConcatenationOp_nfi
[[visibility("default")]] SgConcatenationOp* buildConcatenationOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildConditionalExp
[[visibility("default")]] SgConditionalExp* buildConditionalExp( SgExpression* test, SgExpression* a, SgExpression* b, SgType* result_type); | Build a conditional expression ?: |
buildConditionalExp_nfi
SgConditionalExp* buildConditionalExp_nfi( SgExpression* test, SgExpression* a, SgExpression* b, SgType* t); | |
buildConjugateOp
[[visibility("default")]] SgConjugateOp* buildConjugateOp( SgExpression* op, SgType* result_type); | |
buildConjugateOp_nfi
[[visibility("default")]] SgConjugateOp* buildConjugateOp_nfi( SgExpression* op, SgType* result_type); | |
buildConstType
[[visibility("default")]] SgModifierType* buildConstType(SgType* base_type = nullptr); | Build a const type. |
buildConstVolatileModifier
[[visibility("default")]] SgConstVolatileModifier* buildConstVolatileModifier(SgConstVolatileModifier::cv_modifier_enum mtype = SgConstVolatileModifier::e_unknown); | Build a const/volatile type qualifier |
buildConstVolatileType
[[visibility("default")]] SgModifierType* buildConstVolatileType(SgType* base_type = nullptr); | Build a const volatile type. |
buildConstructorInitializer
[[visibility("default")]] 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
[[visibility("default")]] 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, SgConstructorInitializer::argument_source_enum argument_source = SgConstructorInitializer::e_constructor_argument_expressions); | |
buildContinueStmt_nfi
SgContinueStmt* buildContinueStmt_nfi(); | Build a continue statement |
buildCpreprocessorDefineDeclaration
[[visibility("default")]] 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 (<<<grid, blocks, shared, stream>>>) |
buildDeclType
[[visibility("default")]] SgDeclType* buildDeclType( SgExpression* base_expression, SgType* base_type, bool is_gnu_decltype = false); | Build a decltype reference type |
buildDeclarationScope
[[visibility("default")]] SgDeclarationScope* buildDeclarationScope(SgScopeStatement* semantic_outer_scope = nullptr); | Build a scope statement. Used to build SgNonrealDecl and SgNonrealType |
buildDefaultOptionStmt
[[visibility("default")]] SgDefaultOptionStmt* buildDefaultOptionStmt(SgStatement* body = NULL); | Build a default option statement |
buildDefaultOptionStmt_nfi
SgDefaultOptionStmt* buildDefaultOptionStmt_nfi(SgStatement* body); | |
buildDefiningClassDeclaration
[[visibility("default")]] SgClassDeclaration* buildDefiningClassDeclaration( declaration_ownership const& ownership, SgName name, SgScopeStatement* scope, SgClassDeclaration* nonDefiningDeclaration); | |
buildDefiningFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* buildDefiningFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope, bool forceFreeFunctionScope = false); | Build a function declaration with a function body |
buildDefiningMemberFunctionDeclaration
[[visibility("default")]] SgMemberFunctionDeclaration* buildDefiningMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope); | Build a defining ( non-prototype) member function declaration |
buildDefiningTemplateFunctionDeclaration
[[visibility("default")]] SgTemplateFunctionDeclaration* buildDefiningTemplateFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, SgTemplateFunctionDeclaration* first_nondefining_declaration, SgTemplateParameterPtrList* definingTemplateParameterList); | |
buildDefiningTemplateMemberFunctionDeclaration
[[visibility("default")]] SgTemplateMemberFunctionDeclaration* buildDefiningTemplateMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, unsigned int functionConstVolatileFlags, SgTemplateMemberFunctionDeclaration* first_nondefing_declaration, SgTemplateParameterPtrList* definingTemplateParameterList); | |
buildDeleteExp
[[visibility("default")]] 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
[[visibility("default")]] SgDerivedTypeStatement* buildDerivedTypeStatement( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope); | Build an SgDerivedTypeStatement Fortran derived type declaration with a class declaration and definition (creating both the defining and nondefining declarations as required). |
buildDivAssignOp
[[visibility("default")]] SgDivAssignOp* buildDivAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDivAssignOp_nfi
[[visibility("default")]] SgDivAssignOp* buildDivAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDivideOp
[[visibility("default")]] SgDivideOp* buildDivideOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDivideOp_nfi
[[visibility("default")]] SgDivideOp* buildDivideOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDoWhileStmt
SgDoWhileStmt* buildDoWhileStmt( SgStatement* body, SgExpression* condition); | Build do-while statement |
buildDoWhileStmt_nfi
SgDoWhileStmt* buildDoWhileStmt_nfi( SgStatement* body, SgStatement* condition); | |
buildDotExp
[[visibility("default")]] SgDotExp* buildDotExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDotExp_nfi
[[visibility("default")]] SgDotExp* buildDotExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDotStarOp
[[visibility("default")]] SgDotStarOp* buildDotStarOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDotStarOp_nfi
[[visibility("default")]] SgDotStarOp* buildDotStarOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildDoubleType
[[visibility("default")]] SgTypeDouble* buildDoubleType(); | |
buildDoubleVal
[[visibility("default")]] SgDoubleVal* buildDoubleVal(double value = 0.0); | Build a double value expression |
buildDoubleVal_nfi
[[visibility("default")]] SgDoubleVal* buildDoubleVal_nfi( double value, std::string const& str); | |
buildEmptyDeclaration
[[visibility("default")]] SgEmptyDeclaration* buildEmptyDeclaration(SgEmptyDeclaration::empty_declaration_role_enum lexicalRole); | Build a detached empty declaration with one explicit lexical role. This builder never consults the ambient scope stack; callers must publish the result through one explicit structural ownership transaction and must distinguish a real ; from a zero-spelling preprocessing/source anchor. |
buildEnumDeclaration
[[visibility("default")]] SgEnumDeclaration* buildEnumDeclaration( declaration_ownership const& ownership, SgName const& name, bool isUnNamed, SgScopeStatement* scope); | Build an enum, It is also a declaration statement in SAGE III |
buildEnumDeclaration_nfi
[[visibility("default")]] SgEnumDeclaration* buildEnumDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, bool isUnNamed, SgScopeStatement* scope, SgEnumDeclaration* canonicalDeclaration); | Build one enum definition over an explicit canonical type identity. |
buildEnumVal
[[visibility("default")]] SgEnumVal* buildEnumVal(SgEnumFieldSymbol* sym); | |
buildEnumVal_nfi
[[visibility("default")]] SgEnumVal* buildEnumVal_nfi( long long value, SgEnumDeclaration* decl, SgName name); | |
buildEqualityOp
[[visibility("default")]] SgEqualityOp* buildEqualityOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildEqualityOp_nfi
[[visibility("default")]] SgEqualityOp* buildEqualityOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildEquivalenceStatement
[[visibility("default")]] SgEquivalenceStatement* buildEquivalenceStatement( SgExpression* lhs, SgExpression* rhs); | |
buildExponentiationAssignOp
[[visibility("default")]] SgExponentiationAssignOp* buildExponentiationAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildExponentiationAssignOp_nfi
[[visibility("default")]] SgExponentiationAssignOp* buildExponentiationAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildExponentiationOp
[[visibility("default")]] SgExponentiationOp* buildExponentiationOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildExponentiationOp_nfi
[[visibility("default")]] SgExponentiationOp* buildExponentiationOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildExprListExp
[[visibility("default")]] SgExprListExp* buildExprListExp(std::vector<SgExpression*> const& exprs); | Build a SgExprListExp, used for function call parameter list etc. |
buildExprListExp_nfi
SgExprListExp* buildExprListExp_nfi(); | |
buildExprStatement
[[visibility("default")]] SgExprStatement* buildExprStatement(SgExpression* exp = NULL); | Build a SgExprStatement, set File_Info automatically |
buildExprStatement_nfi
SgExprStatement* buildExprStatement_nfi(SgExpression* exp); | |
buildFile
[[visibility("default")]] SgFile* buildFile( std::string const& inputFileName, std::string const& outputFileName, SgProject* project = NULL); | AST high level builders for others |
buildFloat128Type
[[visibility("default")]] SgTypeFloat128* buildFloat128Type(); | |
buildFloat128Val
[[visibility("default")]] SgFloat128Val* buildFloat128Val(Rose::FloatingValue value = 0.0); | |
buildFloat128Val_nfi
[[visibility("default")]] SgFloat128Val* buildFloat128Val_nfi( Rose::FloatingValue value, std::string const& str); | |
buildFloat16Type
[[visibility("default")]] SgTypeFloat16* buildFloat16Type(); | |
buildFloat16Val
[[visibility("default")]] SgFloat16Val* buildFloat16Val(float v = 0); | Build a float16 |
buildFloat16Val_nfi
[[visibility("default")]] SgFloat16Val* buildFloat16Val_nfi( float v, std::string const& str); | |
buildFloat32Type
[[visibility("default")]] SgTypeFloat32* buildFloat32Type(); | |
buildFloat32Val
[[visibility("default")]] SgFloat32Val* buildFloat32Val(float v = 0); | Build a float32 |
buildFloat32Val_nfi
[[visibility("default")]] SgFloat32Val* buildFloat32Val_nfi( float v, std::string const& str); | |
buildFloat32xType
[[visibility("default")]] SgTypeFloat32x* buildFloat32xType(); | |
buildFloat64Type
[[visibility("default")]] SgTypeFloat64* buildFloat64Type(); | |
buildFloat64Val
[[visibility("default")]] SgFloat64Val* buildFloat64Val(double v = 0); | Build a float64 |
buildFloat64Val_nfi
[[visibility("default")]] SgFloat64Val* buildFloat64Val_nfi( double v, std::string const& str); | |
buildFloat64xType
[[visibility("default")]] SgTypeFloat64x* buildFloat64xType(); | |
buildFloat80Type
[[visibility("default")]] SgTypeFloat80* buildFloat80Type(); | |
buildFloat80Val
[[visibility("default")]] SgFloat80Val* buildFloat80Val(Rose::FloatingValue value = 0.0); | |
buildFloat80Val_nfi
[[visibility("default")]] SgFloat80Val* buildFloat80Val_nfi( Rose::FloatingValue value, std::string const& str); | |
buildFloatType
[[visibility("default")]] SgTypeFloat* buildFloatType(); | |
buildFloatVal
[[visibility("default")]] SgFloatVal* buildFloatVal(float value = 0.0); | |
buildFloatVal_nfi
[[visibility("default")]] SgFloatVal* buildFloatVal_nfi(float value = 0.0); | |
buildFoldExpression_nfi
[[visibility("default")]] SgFoldExpression* buildFoldExpression_nfi( SgExpression* operands, SgFoldExpression::operator_kind_enum operator_kind, bool is_left_associative, SgType* result_type); | |
buildForInitStatement
[[visibility("default")]] SgForInitStatement* buildForInitStatement(); | Build a for init statement |
buildForInitStatement_nfi
[[visibility("default")]] SgForInitStatement* buildForInitStatement_nfi(SgStatementPtrList& statements); | |
buildForStatement
[[visibility("default")]] 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
[[visibility("default")]] SgForStatement* buildForStatement_nfi( SgForInitStatement* init_stmt, SgStatement* test, SgExpression* increment, SgStatement* loop_body); | |
buildFortranContinueStmt
[[visibility("default")]] SgFortranContinueStmt* buildFortranContinueStmt(); | Build a Fortran continue statement |
buildFortranContinueStmt_nfi
SgFortranContinueStmt* buildFortranContinueStmt_nfi(); | |
buildFortranDo
[[visibility("default")]] SgFortranDo* buildFortranDo( SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body); | Build a Fortran do construct |
buildFortranDo_nfi
[[visibility("default")]] SgFortranDo* buildFortranDo_nfi( SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* loop_body); | |
buildFortranFunctionRefExp
[[visibility("default")]] SgFunctionRefExp* buildFortranFunctionRefExp( SgFunctionSymbol* semantic_symbol, SgFunctionSymbol* source_visible_symbol, SgFunctionRefExp::fortran_source_visible_binding_kind_enum kind); | Build a Fortran function reference with separate resolved-procedure and source-visible binding identities. |
buildFortranFunctionRefExp_nfi
[[visibility("default")]] SgFunctionRefExp* buildFortranFunctionRefExp_nfi( SgFunctionSymbol* semantic_symbol, SgFunctionSymbol* source_visible_symbol, SgFunctionRefExp::fortran_source_visible_binding_kind_enum kind); | |
buildFortranIncludeLine
[[visibility("default")]] SgFortranIncludeLine* buildFortranIncludeLine(std::string filename); | Build Fortran include line |
buildFortranIncludeLine_nfi
[[visibility("default")]] SgFortranIncludeLine* buildFortranIncludeLine_nfi(std::string filename); | |
buildFortranKindType
[[visibility("default")]] SgModifierType* buildFortranKindType( SgType* base_type, SgExpression* kindExpression); | Build a type based on the Fortran kind mechanism |
buildFp16Type
[[visibility("default")]] SgTypeFp16* buildFp16Type(); | |
buildFriendTypeDeclaration
[[visibility("default")]] SgFriendTypeDeclaration* buildFriendTypeDeclaration(SgType* friend_type); | Build a C++11 type-only friend declaration, such as friend T;. |
buildFunctionCallExp
[[visibility("default")]] SgFunctionCallExp* buildFunctionCallExp( SgFunctionSymbol* sym, SgExprListExp* parameters = NULL); | buildFunctionCallExp overloads |
buildFunctionCallExp_nfi
SgFunctionCallExp* buildFunctionCallExp_nfi( SgExpression* f, SgType* result_type, SgExprListExp* parameters = NULL); | |
buildFunctionCallStmt
[[visibility("default")]] SgExprStatement* buildFunctionCallStmt( SgExpression* function, SgType* result_type, SgExprListExp* parameters = NULL); | buildFunctionCallStmt overloads |
buildFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* buildFunctionParameterList(SgFunctionParameterTypeList* paraTypeList); | buildFunctionParameterList overloads |
buildFunctionParameterList_nfi
SgFunctionParameterList* buildFunctionParameterList_nfi(); | |
buildFunctionParameterRefExp
[[visibility("default")]] SgFunctionParameterRefExp* buildFunctionParameterRefExp( int parameter_number, int parameter_level, SgType* parameter_type); | |
buildFunctionParameterRefExp_nfi
[[visibility("default")]] SgFunctionParameterRefExp* buildFunctionParameterRefExp_nfi( int parameter_number, int parameter_level, SgType* parameter_type); | |
buildFunctionParameterTypeList
[[visibility("default")]] SgFunctionParameterTypeList* buildFunctionParameterTypeList(SgExprListExp* expList); | buildFunctionParameterTypeList overloads |
buildFunctionParameterTypeList_nfi
SgFunctionParameterTypeList* buildFunctionParameterTypeList_nfi(SgExprListExp* expList); | |
buildFunctionRefExp
[[visibility("default")]] SgFunctionRefExp* buildFunctionRefExp(SgFunctionSymbol* sym); | buildFunctionRefExp overloads |
buildFunctionRefExp_nfi
SgFunctionRefExp* buildFunctionRefExp_nfi(SgFunctionSymbol* sym); | |
buildFunctionType
[[visibility("default")]] SgFunctionType* buildFunctionType( SgType* return_type, SgFunctionParameterList* argList); | buildFunctionType overloads |
buildGeneratedFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* buildGeneratedFunctionParameterList(SgFunctionParameterList const* sourceParameters); | Build an independent generated prototype signature from an existing parameter list. Default arguments remain owned by the source declaration; the result contains fresh transformation identities with the same names, types, pack roles, and qualification metadata. This is the generated-source counterpart to buildSemanticFunctionParameterList(). |
buildGeneratedSourceFile
[[visibility("default")]] SgSourceFile* buildGeneratedSourceFile( std::string const& outputFileName, SgProject* project = NULL); | Build an output-only SgSourceFile node and attach it to SgProject The file is constructed with an empty global scope without creating an input file or invoking a frontend. The output filename is canonicalized to one absolute translation-unit identity before construction and determines the source language. The same identity owns the file command line, source positions, and unparse output. If project is null, a new SgProject is created and can be retrieved with SgFile::get_project(). |
buildGotoStatement
[[visibility("default")]] 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
[[visibility("default")]] SgGreaterOrEqualOp* buildGreaterOrEqualOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildGreaterOrEqualOp_nfi
[[visibility("default")]] SgGreaterOrEqualOp* buildGreaterOrEqualOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildGreaterThanOp
[[visibility("default")]] SgGreaterThanOp* buildGreaterThanOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildGreaterThanOp_nfi
[[visibility("default")]] SgGreaterThanOp* buildGreaterThanOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildIfStmt
SgIfStmt* buildIfStmt( SgExpression* conditional, SgStatement* true_body, SgStatement* false_body); | Build if statement |
buildIfStmt_nfi
[[visibility("default")]] SgIfStmt* buildIfStmt_nfi( SgStatement* conditional, SgStatement* true_body, SgStatement* false_body); | |
buildImagPartOp
[[visibility("default")]] SgImagPartOp* buildImagPartOp( SgExpression* op, SgType* result_type); | |
buildImagPartOp_nfi
[[visibility("default")]] SgImagPartOp* buildImagPartOp_nfi( SgExpression* op, SgType* result_type); | |
buildImaginaryType
[[visibility("default")]] SgTypeImaginary* buildImaginaryType(SgType* base_type = nullptr); | Build an imaginary type |
buildImaginaryVal
[[visibility("default")]] SgComplexVal* buildImaginaryVal(Rose::FloatingValue imaginary_value); | |
buildImaginaryVal_nfi
[[visibility("default")]] SgComplexVal* buildImaginaryVal_nfi( SgExpression* imaginary_value, SgType* precision_type); | |
buildInitializedName
[[visibility("default")]] 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
[[visibility("default")]] SgInitializedName* buildInitializedName_nfi( SgName const& name, SgType* type, SgInitializer* init, SgVariableDeclaration* declptr = NULL); | |
buildIntType
[[visibility("default")]] SgTypeInt* buildIntType(); | |
buildIntVal
[[visibility("default")]] SgIntVal* buildIntVal(int value = 0); | Build an integer value expression |
buildIntValHex
[[visibility("default")]] SgIntVal* buildIntValHex(int value = 0); | |
buildIntVal_nfi
[[visibility("default")]] SgIntVal* buildIntVal_nfi(int value = 0); | Build an integer value expression by converting the string |
buildIntegerDivideAssignOp
[[visibility("default")]] SgIntegerDivideAssignOp* buildIntegerDivideAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildIntegerDivideAssignOp_nfi
[[visibility("default")]] SgIntegerDivideAssignOp* buildIntegerDivideAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildIntegerDivideOp
[[visibility("default")]] SgIntegerDivideOp* buildIntegerDivideOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildIntegerDivideOp_nfi
[[visibility("default")]] SgIntegerDivideOp* buildIntegerDivideOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildIorAssignOp
[[visibility("default")]] SgIorAssignOp* buildIorAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildIorAssignOp_nfi
[[visibility("default")]] SgIorAssignOp* buildIorAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLabelRefExp
[[visibility("default")]] SgLabelRefExp* buildLabelRefExp(SgLabelSymbol* s); | Build a Fortran numeric label ref exp |
buildLabelStatement
[[visibility("default")]] SgLabelStatement* buildLabelStatement( SgName const& name, SgStatement* stmt, 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); | |
buildLambdaCaptureList_nfi
[[visibility("default")]] SgLambdaCaptureList* buildLambdaCaptureList_nfi(); | |
buildLambdaCapture_nfi
[[visibility("default")]] SgLambdaCapture* buildLambdaCapture_nfi( SgExpression* capture_variable, SgExpression* capture_initializer, SgExpression* closure_variable, bool capture_by_reference, bool implicit, bool pack_expansion, bool is_init_capture); | |
buildLambdaExp_nfi
[[visibility("default")]] SgLambdaExp* buildLambdaExp_nfi( SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function); | |
buildLessOrEqualOp
[[visibility("default")]] SgLessOrEqualOp* buildLessOrEqualOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLessOrEqualOp_nfi
[[visibility("default")]] SgLessOrEqualOp* buildLessOrEqualOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLessThanOp
[[visibility("default")]] SgLessThanOp* buildLessThanOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLessThanOp_nfi
[[visibility("default")]] SgLessThanOp* buildLessThanOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLongDoubleType
[[visibility("default")]] SgTypeLongDouble* buildLongDoubleType(); | |
buildLongDoubleVal
[[visibility("default")]] SgLongDoubleVal* buildLongDoubleVal(Rose::FloatingValue value = 0.0); | |
buildLongDoubleVal_nfi
[[visibility("default")]] SgLongDoubleVal* buildLongDoubleVal_nfi( Rose::FloatingValue value, std::string const& str); | |
buildLongIntVal
[[visibility("default")]] SgLongIntVal* buildLongIntVal(long value = 0); | Build a long integer value expression |
buildLongIntVal_nfi
[[visibility("default")]] SgLongIntVal* buildLongIntVal_nfi( long value, std::string const& str); | |
buildLongLongIntVal
[[visibility("default")]] SgLongLongIntVal* buildLongLongIntVal(long long value = 0); | Build a long long integer value expression |
buildLongLongIntValHex
[[visibility("default")]] SgLongLongIntVal* buildLongLongIntValHex(long long value = 0); | |
buildLongLongIntVal_nfi
[[visibility("default")]] SgLongLongIntVal* buildLongLongIntVal_nfi( long long value, std::string const& str); | |
buildLongLongType
[[visibility("default")]] SgTypeLongLong* buildLongLongType(); | |
buildLongType
[[visibility("default")]] SgTypeLong* buildLongType(); | |
buildLshiftAssignOp
[[visibility("default")]] SgLshiftAssignOp* buildLshiftAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLshiftAssignOp_nfi
[[visibility("default")]] SgLshiftAssignOp* buildLshiftAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLshiftOp
[[visibility("default")]] SgLshiftOp* buildLshiftOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildLshiftOp_nfi
[[visibility("default")]] SgLshiftOp* buildLshiftOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildMemberFunctionCall
[[visibility("default")]] SgFunctionCallExp* buildMemberFunctionCall( SgExpression* objectExpression, SgMemberFunctionSymbol* functionSymbol, SgExprListExp* params); | buildMemberFunctionCall overloads |
buildMemberFunctionRefExp
[[visibility("default")]] SgMemberFunctionRefExp* buildMemberFunctionRefExp( SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier); | |
buildMemberFunctionRefExp_nfi
SgMemberFunctionRefExp* buildMemberFunctionRefExp_nfi( SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier); | |
buildMemberFunctionType
[[visibility("default")]] SgMemberFunctionType* buildMemberFunctionType( SgFunctionType const* type, SgScopeStatement* scope, unsigned int mfunc_specifier); | Bind a complete semantic function signature to its member class. |
buildMinusAssignOp
[[visibility("default")]] SgMinusAssignOp* buildMinusAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildMinusAssignOp_nfi
[[visibility("default")]] SgMinusAssignOp* buildMinusAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildMinusMinusOp
[[visibility("default")]] SgMinusMinusOp* buildMinusMinusOp( SgExpression* op, SgType* result_type); | |
buildMinusMinusOp_nfi
[[visibility("default")]] SgMinusMinusOp* buildMinusMinusOp_nfi( SgExpression* op, SgType* result_type); | |
buildMinusOp
[[visibility("default")]] SgMinusOp* buildMinusOp( SgExpression* op, SgType* result_type); | Build -- expression, Sgop_mode is a value of either SgUnaryOp::prefix or SgUnaryOp::postfix |
buildMinusOp_nfi
[[visibility("default")]] SgMinusOp* buildMinusOp_nfi( SgExpression* op, SgType* result_type); | |
buildModAssignOp
[[visibility("default")]] SgModAssignOp* buildModAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildModAssignOp_nfi
[[visibility("default")]] SgModAssignOp* buildModAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildModOp
[[visibility("default")]] SgModOp* buildModOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildModOp_nfi
[[visibility("default")]] SgModOp* buildModOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildModifierType
[[visibility("default")]] SgModifierType* buildModifierType( SgType* base_type, SgTypeModifier const& modifier); | Build a modifier type. |
buildModuleStatement
[[visibility("default")]] SgModuleStatement* buildModuleStatement( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope); | Build a Fortran module declaration. |
buildMultAssignOp
[[visibility("default")]] SgMultAssignOp* buildMultAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildMultAssignOp_nfi
[[visibility("default")]] SgMultAssignOp* buildMultAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildMultiplyOp
[[visibility("default")]] SgMultiplyOp* buildMultiplyOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildMultiplyOp_nfi
[[visibility("default")]] SgMultiplyOp* buildMultiplyOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildNamespaceAliasDeclarationStatement
[[visibility("default")]] SgNamespaceAliasDeclarationStatement* buildNamespaceAliasDeclarationStatement( declaration_ownership const& ownership, SgName const& name, SgNamespaceDeclarationStatement* namespaceDeclaration, SgScopeStatement* scope); | |
buildNamespaceDeclaration
[[visibility("default")]] SgNamespaceDeclarationStatement* buildNamespaceDeclaration( SgName const& name, SgScopeStatement* scope); | tps (09/02/2009) : Added support for building namespaces |
buildNamespaceDeclaration_nfi
[[visibility("default")]] SgNamespaceDeclarationStatement* buildNamespaceDeclaration_nfi( SgName const& name, bool unnamednamespace, SgScopeStatement* scope, namespace_declaration_ownership_enum ownership, SgNamespaceSourceFragment* openingIntroducerFragment, SgNamespaceSourceFragment* openingFragment, SgNamespaceSourceFragment* closingFragment, std::optional<unsigned int> sourceOrder); | Build one namespace declaration with explicit semantic and lexical ownership. Source-lexical declarations require source-spelled fragments and a positive producer-wide namespace order in the final expanded token stream; generated and semantic-only declarations require no order. |
buildNamespaceDefinition
[[visibility("default")]] SgNamespaceDefinitionStatement* buildNamespaceDefinition(SgNamespaceDeclarationStatement* d = NULL); | |
buildNamespaceDefinition_nfi
[[visibility("default")]] SgNamespaceDefinitionStatement* buildNamespaceDefinition_nfi(SgNamespaceDeclarationStatement* d = NULL); | |
buildNestedRequirement_nfi
[[visibility("default")]] SgNestedRequirement* buildNestedRequirement_nfi(SgExpression* constraint); | |
buildNewExp
[[visibility("default")]] SgNewExp* buildNewExp( SgType* type, SgPointerType* result_type, SgExpression* array_bound, SgNewExp::array_bound_source_form_enum source_form, SgExprListExp* exprListExp, SgConstructorInitializer* constInit, SgExpression* expr, short val, SgFunctionDeclaration* funcDecl, unsigned int allocation_implicit_argument_count); | |
buildNewExp_nfi
[[visibility("default")]] SgNewExp* buildNewExp_nfi( SgType* type, SgPointerType* result_type, SgExpression* array_bound, SgNewExp::array_bound_source_form_enum source_form, SgExprListExp* exprListExp, SgConstructorInitializer* constInit, SgExpression* expr, short val, SgFunctionDeclaration* funcDecl, unsigned int allocation_implicit_argument_count); | |
buildNoexceptOp
[[visibility("default")]] SgNoexceptOp* buildNoexceptOp(SgExpression* exp); | Build noexcept operator expression with an expression parameter |
buildNoexceptOp_nfi
[[visibility("default")]] SgNoexceptOp* buildNoexceptOp_nfi(SgExpression* exp); | |
buildNondefiningClassDeclaration
[[visibility("default")]] SgClassDeclaration* buildNondefiningClassDeclaration( declaration_ownership const& ownership, SgName name, SgScopeStatement* scope); | |
buildNondefiningClassDeclaration_nfi
[[visibility("default")]] SgClassDeclaration* buildNondefiningClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, SgScopeStatement* scope, SgTemplateClassDeclaration* templateDeclaration, SgTemplateClassDeclaration* specializedTemplateDeclaration, SgTemplateArgumentPtrList* templateArgumentsList, SgName const* templateInstantiationNameOverride, bool anonymousInternalIdentity = false, SgTemplateArgumentPtrList const* semanticTemplateArgumentsList = nullptr, bool sourceSpellsInjectedClassName = false, SgTemplateArgumentPtrList* deducedTemplateArgumentsList = nullptr); | Build a class first nondefining declaration, without file info. |
buildNondefiningDerivedTypeStatement
[[visibility("default")]] SgDerivedTypeStatement* buildNondefiningDerivedTypeStatement( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope); | Build the canonical semantic forward declaration for a Fortran derived type. A derived-type forward has no source surface or definition and must be completed later by exactly one buildDerivedTypeStatement() call. |
buildNondefiningEnumDeclaration_nfi
[[visibility("default")]] SgEnumDeclaration* buildNondefiningEnumDeclaration_nfi( SgName const& name, bool isUnNamed, SgScopeStatement* scope, declaration_ownership const& ownership, SgEnumDeclaration* canonicalDeclaration); | Build an enum nondefining declaration, without file info |
buildNondefiningFunctionDeclaration
[[visibility("default")]] SgFunctionDeclaration* buildNondefiningFunctionDeclaration( function_declaration_ownership const& ownership, SgFunctionDeclaration const* funcdecl, SgScopeStatement* scope); | buildNondefiningFunctionDeclaration overloads |
buildNondefiningMemberFunctionDeclaration
[[visibility("default")]] SgMemberFunctionDeclaration* buildNondefiningMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgScopeStatement* scope); | Build a prototype member function declaration |
buildNondefiningProcedureHeaderStatement
[[visibility("default")]] SgProcedureHeaderStatement* buildNondefiningProcedureHeaderStatement( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* param_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgProcedureHeaderStatement::fortran_procedure_source_form_enum source_form, SgScopeStatement* scope, FortranBlockDataBuilderIdentity const* block_data_identity = nullptr); | Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently |
buildNondefiningTemplateClassDeclaration
[[visibility("default")]] SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride); | buildNondefiningTemplateClassDeclaration() |
buildNondefiningTemplateClassDeclaration_nfi
[[visibility("default")]] SgTemplateClassDeclaration* buildNondefiningTemplateClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride); | |
buildNondefiningTemplateClassRedeclaration_nfi
[[visibility("default")]] SgTemplateClassDeclaration* buildNondefiningTemplateClassRedeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateClassDeclaration* canonicalDeclaration, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride); | Build one nondefining redeclaration of an existing template class. The canonical declaration is required explicitly; the redeclaration reuses its exact type and symbol and never publishes another symbol. |
buildNondefiningTemplateFunctionDeclaration
[[visibility("default")]] SgTemplateFunctionDeclaration* buildNondefiningTemplateFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, SgTemplateParameterPtrList* templateParameterList = NULL); | |
buildNondefiningTemplateMemberFunctionDeclaration
[[visibility("default")]] SgTemplateMemberFunctionDeclaration* buildNondefiningTemplateMemberFunctionDeclaration( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parlist, SgScopeStatement* scope, unsigned int functionConstVolatileFlags, SgTemplateParameterPtrList* templateParameterList, SgTemplateParameterPtrList* symbolIdentityTemplateParameterList); | |
buildNonrealBaseClass
[[visibility("default")]] SgNonrealBaseClass* buildNonrealBaseClass( SgNonrealDecl* classDeclaration, SgType* sourceType, SgClassDefinition* classDefinition, bool isVirtual, bool isDirect); | |
buildNonrealDecl
[[visibility("default")]] SgNonrealDecl* buildNonrealDecl( SgName const& name, SgDeclarationScope* scope, SgDeclarationScope* child_scope = NULL); | Build a declaration of a non-real class or class-member in an explicit, non-null lexical declaration scope. A null child scope requests creation of a new owned child declaration scope. |
buildNonrealRefExp_nfi
[[visibility("default")]] SgNonrealRefExp* buildNonrealRefExp_nfi(SgNonrealSymbol* sym); | Build a reference to the non-real declaration of a member of a non-real class |
buildNotEqualOp
[[visibility("default")]] SgNotEqualOp* buildNotEqualOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildNotEqualOp_nfi
[[visibility("default")]] SgNotEqualOp* buildNotEqualOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildNotOp
[[visibility("default")]] SgNotOp* buildNotOp( SgExpression* op, SgType* result_type); | |
buildNotOp_nfi
[[visibility("default")]] SgNotOp* buildNotOp_nfi( SgExpression* op, SgType* result_type); | |
buildNullExpression
[[visibility("default")]] SgNullExpression* buildNullExpression(SgNullExpression::null_expression_role_enum role); | Build a typed null-expression placeholder, set file info as the default one. |
buildNullExpression_nfi
[[visibility("default")]] SgNullExpression* buildNullExpression_nfi(SgNullExpression::null_expression_role_enum role); | No file info version of buildNullExpression(). File info is to be set later on. |
buildNullStatement
[[visibility("default")]] SgNullStatement* buildNullStatement(); | Build a NULL statement |
buildNullStatement_nfi
SgNullStatement* buildNullStatement_nfi(); | |
buildNullptrType
[[visibility("default")]] SgTypeNullptr* buildNullptrType(); | |
buildNullptrValExp
[[visibility("default")]] SgNullptrValExp* buildNullptrValExp(); | |
buildNullptrValExp_nfi
[[visibility("default")]] SgNullptrValExp* buildNullptrValExp_nfi(); | |
buildOrOp
[[visibility("default")]] SgOrOp* buildOrOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildOrOp_nfi
[[visibility("default")]] SgOrOp* buildOrOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildPackExpansionExpr_nfi
[[visibility("default")]] SgPackExpansionExpr* buildPackExpansionExpr_nfi( SgExpression* pattern, SgType* result_type); | |
buildPlusAssignOp
[[visibility("default")]] SgPlusAssignOp* buildPlusAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildPlusAssignOp_nfi
[[visibility("default")]] SgPlusAssignOp* buildPlusAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildPlusPlusOp
[[visibility("default")]] SgPlusPlusOp* buildPlusPlusOp( SgExpression* op, SgType* result_type); | Build ++x or x++ , specify prefix or postfix using either SgUnaryOp::prefix or SgUnaryOp::postfix |
buildPlusPlusOp_nfi
[[visibility("default")]] SgPlusPlusOp* buildPlusPlusOp_nfi( SgExpression* op, SgType* result_type); | |
buildPntrArrRefExp
[[visibility("default")]] SgPntrArrRefExp* buildPntrArrRefExp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildPntrArrRefExp_nfi
[[visibility("default")]] SgPntrArrRefExp* buildPntrArrRefExp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildPointerDerefExp
[[visibility("default")]] SgPointerDerefExp* buildPointerDerefExp( SgExpression* op, SgType* result_type); | |
buildPointerDerefExp_nfi
[[visibility("default")]] SgPointerDerefExp* buildPointerDerefExp_nfi( SgExpression* op, SgType* result_type); | |
buildPointerMemberType
[[visibility("default")]] SgPointerMemberType* buildPointerMemberType( SgType* base_type, SgType* classType); | |
buildPointerType
[[visibility("default")]] SgPointerType* buildPointerType(SgType* base_type = nullptr); | Build a pointer type |
buildPragma
[[visibility("default")]] SgPragma* buildPragma(std::string const& name); | Build SgPragma |
buildPragmaDeclaration
[[visibility("default")]] 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
[[visibility("default")]] SgProcedureHeaderStatement* buildProcedureHeaderStatement( function_declaration_ownership const& ownership, SgName const& name, SgType* return_type, SgFunctionParameterList* parameter_list, SgFunctionParameterList* canonical_parameter_list, SgProcedureHeaderStatement::subprogram_kind_enum, SgProcedureHeaderStatement::fortran_procedure_source_form_enum source_form, SgScopeStatement* scope); | Build a defining Fortran procedure with an explicit lexical source form. |
buildProcedureHeaderStatementFromExactDefinition
[[visibility("default")]] SgProcedureHeaderStatement* buildProcedureHeaderStatementFromExactDefinition( function_declaration_ownership const& ownership, SgFunctionDefinition* exact_definition, char const* name, SgType* return_type, SgFunctionParameterList* parlist, SgProcedureHeaderStatement::subprogram_kind_enum, SgProcedureHeaderStatement::fortran_procedure_source_form_enum source_form, SgScopeStatement* scope, SgProcedureHeaderStatement* first_nondefining_declaration, FortranBlockDataBuilderIdentity const* block_data_identity = nullptr); | Complete a bottom-up Fortran procedure construction around its exact preconstructed definition and body. The definition is consumed exactly once and must already carry final source classification and scope identity. |
buildRangeBasedForStatement_nfi
[[visibility("default")]] SgRangeBasedForStatement* buildRangeBasedForStatement_nfi( SgVariableDeclaration* initializer, SgVariableDeclaration* range, SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration, SgExpression* not_equal_expression, SgExpression* increment_expression, SgStatement* body); | |
buildRangeExp
[[visibility("default")]] SgRangeExp* buildRangeExp( SgExpression* start, SgExpression* end, SgExpression* stride); | |
buildRangeExp_nfi
SgRangeExp* buildRangeExp_nfi( SgExpression* start, SgExpression* end, SgExpression* stride); | |
buildRealPartOp
[[visibility("default")]] SgRealPartOp* buildRealPartOp( SgExpression* op, SgType* result_type); | |
buildRealPartOp_nfi
[[visibility("default")]] SgRealPartOp* buildRealPartOp_nfi( SgExpression* op, SgType* result_type); | |
buildReferenceType
[[visibility("default")]] SgReferenceType* buildReferenceType(SgType* base_type = nullptr); | Build a reference type |
buildRequirementSubstitutionFailure_nfi
[[visibility("default")]] SgRequirementSubstitutionFailure* buildRequirementSubstitutionFailure_nfi( SgRequirementSubstitutionFailure::failure_kind_enum failure_kind, std::string const& substituted_entity, std::string const& diagnostic_message); | |
buildRequiresExpr
[[visibility("default")]] SgRequiresExpr* buildRequiresExpr( SgFunctionParameterList* local_parameter_list, SgExprListExp* requirements, SgFunctionParameterScope* local_parameter_scope = nullptr, SgFunctionParameterList* local_parameter_list_syntax = nullptr); | |
buildRequiresExpr_nfi
[[visibility("default")]] SgRequiresExpr* buildRequiresExpr_nfi( SgFunctionParameterList* local_parameter_list, SgExprListExp* requirements, SgFunctionParameterScope* local_parameter_scope = nullptr, SgFunctionParameterList* local_parameter_list_syntax = nullptr); | |
buildRestrictType
[[visibility("default")]] SgModifierType* buildRestrictType(SgType* base_type); | Build a restrict type. |
buildReturnStmt
[[visibility("default")]] SgReturnStmt* buildReturnStmt( SgExpression* expression = nullptr, SgInitializedName* nrvo_candidate = nullptr); | Build a return statement |
buildReturnStmt_nfi
[[visibility("default")]] SgReturnStmt* buildReturnStmt_nfi( SgExpression* expression, SgInitializedName* nrvo_candidate = nullptr); | |
buildRshiftAssignOp
[[visibility("default")]] SgRshiftAssignOp* buildRshiftAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildRshiftAssignOp_nfi
[[visibility("default")]] SgRshiftAssignOp* buildRshiftAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildRshiftOp
[[visibility("default")]] SgRshiftOp* buildRshiftOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildRshiftOp_nfi
[[visibility("default")]] SgRshiftOp* buildRshiftOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildRvalueReferenceType
[[visibility("default")]] SgRvalueReferenceType* buildRvalueReferenceType(SgType* base_type); | Build a rvalue reference type |
buildScopeOp
[[visibility("default")]] SgScopeOp* buildScopeOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildScopeOp_nfi
[[visibility("default")]] SgScopeOp* buildScopeOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildSemanticAuxiliaryVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* buildSemanticAuxiliaryVariableDeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope); | Build and publish one named semantic-only variable declaration under the scope's exact auxiliary owner. Structural ownership is established before the variable symbol is inserted, so copied scope symbol tables can map the symbol only to an attached declaration basis. |
buildSemanticFunctionParameterList
[[visibility("default")]] SgFunctionParameterList* buildSemanticFunctionParameterList(SgFunctionParameterList const* sourceParameters); | Build an independent semantic-only signature from an existing parameter list. Default arguments remain owned by the source declaration; the result contains fresh parameter identities with the same names, types, pack roles, and qualification metadata. |
buildSemanticInitializedName
[[visibility("default")]] SgInitializedName* buildSemanticInitializedName( SgName const& name, SgType* type, SgInitializer* init = NULL, SgVariableDeclaration* declptr = NULL); | Build an initialized name that has no independently written source surface. The result is classified and validated as exact frontend semantic output at this producer; callers must not repair its provenance after attachment. |
buildSemanticMemberFunctionRefExp
[[visibility("default")]] SgMemberFunctionRefExp* buildSemanticMemberFunctionRefExp( SgMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier); | |
buildSemanticNonrealType
[[visibility("default")]] SgNonrealType* buildSemanticNonrealType( SgNonrealDecl const* source, SgTemplateArgumentPtrList const& arguments, SgType* aliasedType); | Build a semantic non-real dependent type (optionally with template arguments). Every structurally owned located template-argument node must be unclassified or already have exact compiler-generated semantic provenance. The optional template declaration is linked before the internal SgNonrealDecl is published. |
buildShortType
[[visibility("default")]] SgTypeShort* buildShortType(); | |
buildShortVal
[[visibility("default")]] SgShortVal* buildShortVal(short value = 0); | |
buildShortValHex
[[visibility("default")]] SgShortVal* buildShortValHex(short value = 0); | |
buildShortVal_nfi
[[visibility("default")]] SgShortVal* buildShortVal_nfi( short value, std::string const& str); | |
buildSigned128bitIntegerType
[[visibility("default")]] SgTypeSigned128bitInteger* buildSigned128bitIntegerType(); | |
buildSignedCharType
[[visibility("default")]] SgTypeSignedChar* buildSignedCharType(); | |
buildSignedCharVal
[[visibility("default")]] SgSignedCharVal* buildSignedCharVal(signed char v = 0); | Build a signed char |
buildSignedCharValHex
[[visibility("default")]] SgSignedCharVal* buildSignedCharValHex(signed char v = 0); | |
buildSignedCharVal_nfi
[[visibility("default")]] SgSignedCharVal* buildSignedCharVal_nfi( signed char v, std::string const& str); | |
buildSignedIntType
[[visibility("default")]] SgTypeSignedInt* buildSignedIntType(); | |
buildSignedLongLongType
[[visibility("default")]] SgTypeSignedLongLong* buildSignedLongLongType(); | |
buildSignedLongType
[[visibility("default")]] SgTypeSignedLong* buildSignedLongType(); | |
buildSignedShortType
[[visibility("default")]] SgTypeSignedShort* buildSignedShortType(); | |
buildSimpleRequirement_nfi
[[visibility("default")]] SgSimpleRequirement* buildSimpleRequirement_nfi(SgExpression* expression); | |
buildSizeOfOp
[[visibility("default")]] SgSizeOfOp* buildSizeOfOp( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_sizeof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt); | buildSizeOfOp overloads |
buildSizeOfOp_nfi
[[visibility("default")]] SgSizeOfOp* buildSizeOfOp_nfi( SgExpression* exp, SgType* expression_type, SgExpression::unary_type_trait_kind_enum operator_kind = SgExpression::e_sizeof, std::optional<Rose::Integer128Value> evaluated_value = std::nullopt); | |
buildSourceFile
[[visibility("default")]] SgSourceFile* buildSourceFile( std::string const& inputFileName, std::string const& outputFileName, SgProject* project); | Build a SgSourceFile node and attach it to SgProject Parse an existing readable input file. An unreadable input or frontend failure is a hard error. Use buildGeneratedSourceFile for output-only AST construction. outputFileName selects the unparse destination. The file is registered in project; buildFile creates a project when none is supplied. Retrieve its owner with SgFile::get_project(). |
buildSpaceshipOp
[[visibility("default")]] SgSpaceshipOp* buildSpaceshipOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildSpaceshipOp_nfi
[[visibility("default")]] SgSpaceshipOp* buildSpaceshipOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildStatementExpression
[[visibility("default")]] SgStatementExpression* buildStatementExpression( SgStatement* exp, SgType* result_type, SgScopeStatement* semantic_scope); | Build a GNU statement expression |
buildStatementExpression_nfi
[[visibility("default")]] SgStatementExpression* buildStatementExpression_nfi( SgStatement* exp, SgType* result_type, SgScopeStatement* semantic_scope); | |
buildStaticAssertionDeclaration_nfi
[[visibility("default")]] SgStaticAssertionDeclaration* buildStaticAssertionDeclaration_nfi( SgExpression* condition, SgExpression* message = nullptr); | |
buildStringType
[[visibility("default")]] SgTypeString* buildStringType(SgExpression* stringLengthExpression); | Build a Fortran CHARACTER type from its typed length expression. |
buildStringVal
[[visibility("default")]] SgStringVal* buildStringVal(std::string value = ""); | |
buildStringVal_nfi
[[visibility("default")]] SgStringVal* buildStringVal_nfi(std::string value); | |
buildStructDeclaration
[[visibility("default")]] SgClassDeclaration* buildStructDeclaration( declaration_ownership const& ownership, SgName const& name, SgScopeStatement* scope); | 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
[[visibility("default")]] SgSubtractOp* buildSubtractOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildSubtractOp_nfi
[[visibility("default")]] SgSubtractOp* buildSubtractOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildSwitchStatement
SgSwitchStatement* buildSwitchStatement( SgExpression* item_selector, SgStatement* body = NULL); | Build a switch statement |
buildSwitchStatement_nfi
[[visibility("default")]] SgSwitchStatement* buildSwitchStatement_nfi( SgStatement* item_selector, SgStatement* body); | |
buildTargetBuiltinType
[[visibility("default")]] SgTypeTargetBuiltin* buildTargetBuiltinType( SgName const& spelling, SgTypeTargetBuiltin::target_family_enum target_family); | |
buildTemplateClassDeclaration
[[visibility("default")]] SgTemplateClassDeclaration* buildTemplateClassDeclaration( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateClassDeclaration* nonDefiningDecl, SgTemplateParameterPtrList* nondefiningTemplateParameterList, SgTemplateParameterPtrList* definingTemplateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride); | Build tempplate class declaration |
buildTemplateClassDeclaration_nfi
[[visibility("default")]] SgTemplateClassDeclaration* buildTemplateClassDeclaration_nfi( declaration_ownership const& ownership, SgName const& name, SgClassDeclaration::class_types kind, template_class_declaration_scopes const& scopes, SgTemplateClassDeclaration* nonDefiningDecl, SgTemplateParameterPtrList* nondefiningTemplateParameterList, SgTemplateParameterPtrList* definingTemplateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList, SgName const* templateSpecializationNameOverride); | |
buildTemplateClassDefinition
SgTemplateClassDefinition* buildTemplateClassDefinition(SgTemplateClassDeclaration* d); | Build a template class definition statement |
buildTemplateFunctionRefExp_nfi
SgTemplateFunctionRefExp* buildTemplateFunctionRefExp_nfi(SgTemplateFunctionSymbol* sym); | |
buildTemplateInstantiationTypedefDeclaration_nfi
[[visibility("default")]] SgTemplateInstantiationTypedefDeclaration* buildTemplateInstantiationTypedefDeclaration_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, SgName& name, SgType* base_type, SgScopeStatement* scope, SgTemplateTypedefDeclaration* templateTypedefDeclaration, SgTemplateArgumentPtrList& templateArgumentsList, SgName const& semanticInstantiationName); | |
buildTemplateMemberFunctionRefExp_nfi
SgTemplateMemberFunctionRefExp* buildTemplateMemberFunctionRefExp_nfi( SgTemplateMemberFunctionSymbol* sym, bool virtual_call, bool need_qualifier); | |
buildTemplateParameter
[[visibility("default")]] SgTemplateParameter* buildTemplateParameter( SgTemplateParameter::template_parameter_enum parameterType, SgType*, SgTemplateParameter::template_parameter_keyword_enum keyword, SgInitializedName* initializedName = nullptr, SgTemplateParameter* canonicalNonTypeParameter = nullptr, SgTemplateDeclaration* templateDeclaration = nullptr); | Build a template parameter, passing enum kind and SgTemplateType template_parameter_enum |
buildTemplateParameterVal
[[visibility("default")]] SgTemplateParameterVal* buildTemplateParameterVal( int template_parameter_position, SgTemplateParameter* parameter); | Build an template parameter value expression |
buildTemplateParameterVal_nfi
[[visibility("default")]] SgTemplateParameterVal* buildTemplateParameterVal_nfi( int template_parameter_position, SgTemplateParameter* parameter); | |
buildTemplateType
[[visibility("default")]] SgTemplateType* buildTemplateType(SgName name = ""); | Build a template type, used for template parameter and later argument |
buildTemplateTypedefDeclaration_nfi
[[visibility("default")]] SgTemplateTypedefDeclaration* buildTemplateTypedefDeclaration_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, SgName const& name, SgType* base_type, SgScopeStatement* scope); | |
buildTemplateVariableDeclaration
[[visibility("default")]] SgTemplateVariableDeclaration* buildTemplateVariableDeclaration( declaration_ownership const& ownership, SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgTemplateVariableDeclaration* specializedTemplateDeclaration, SgTemplateArgumentPtrList const& semanticArguments, SgInitializedName* priorDeclaration = nullptr); | Build and atomically publish a template variable declaration with explicit structural ownership. The semantic scope is supplied separately; sourceLexicalIn() represents an out-of-class definition without changing the variable entity's semantic class scope. |
buildTemplateVariableDeclaration_nfi
[[visibility("default")]] SgTemplateVariableDeclaration* buildTemplateVariableDeclaration_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgTemplateVariableDeclaration* specializedTemplateDeclaration, SgTemplateArgumentPtrList const& semanticArguments, SgInitializedName* priorDeclaration = nullptr); | |
buildThisExp
[[visibility("default")]] SgThisExp* buildThisExp( SgSymbol* sym, SgType* expression_type); | Build this pointer |
buildThisExp_nfi
[[visibility("default")]] SgThisExp* buildThisExp_nfi( SgSymbol* sym, SgType* expression_type); | |
buildThrowOp
[[visibility("default")]] SgThrowOp* buildThrowOp( SgExpression*, SgType* result_type, SgThrowOp::e_throw_kind); | Build a ThrowOp expression |
buildThrowOp_nfi
[[visibility("default")]] SgThrowOp* buildThrowOp_nfi( SgExpression*, SgType* result_type, SgThrowOp::e_throw_kind); | |
buildTransformationCastExp
[[visibility("default")]] SgCastExp* buildTransformationCastExp( SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type); | Build a source-emitting transformation cast whose semantics are completely determined by its exact operand and result types. Ambiguous conversions are rejected instead of being assigned a guessed conversion kind. |
buildTransformationCastExp_nfi
[[visibility("default")]] SgCastExp* buildTransformationCastExp_nfi( SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type); | |
buildTryStmt
[[visibility("default")]] SgTryStmt* buildTryStmt( SgStatement* body, SgCatchOptionStmt* catch0 = NULL, SgCatchOptionStmt* catch1 = NULL, SgCatchOptionStmt* catch2 = NULL, SgCatchOptionStmt* catch3 = NULL, SgCatchOptionStmt* catch4 = NULL); | Build a try statement. |
buildTypeExpression
[[visibility("default")]] SgTypeExpression* buildTypeExpression(SgType* type); | |
buildTypeExpression_nfi
[[visibility("default")]] SgTypeExpression* buildTypeExpression_nfi(SgType* type); | |
buildTypeIdOp
[[visibility("default")]] SgTypeIdOp* buildTypeIdOp( SgExpression* operand_expr, SgType* operand_type, SgType* expression_type, bool operand_is_evaluated); | |
buildTypeIdOp_nfi
[[visibility("default")]] SgTypeIdOp* buildTypeIdOp_nfi( SgExpression* operand_expr, SgType* operand_type, SgType* expression_type, bool operand_is_evaluated); | |
buildTypeOfType
[[visibility("default")]] SgTypeOfType* buildTypeOfType( SgExpression* base_expression, SgType* base_type); | Build a GNU typeof operator |
buildTypeRequirement_nfi
[[visibility("default")]] SgTypeRequirement* buildTypeRequirement_nfi(SgType* required_type); | |
buildTypeTraitBuiltinOperator
SgTypeTraitBuiltinOperator* buildTypeTraitBuiltinOperator( SgName functionName, SgTypeTraitBuiltinOperator::builtin_operator_kind_enum builtinKind, SgType* result_type, SgExpressionPtrList parameters); | |
buildTypeTraitBuiltinOperator_nfi
[[visibility("default")]] SgTypeTraitBuiltinOperator* buildTypeTraitBuiltinOperator_nfi( SgName functionName, SgTypeTraitBuiltinOperator::builtin_operator_kind_enum builtinKind, SgType* result_type, SgExpressionPtrList parameters); | |
buildTypedefDeclaration
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclaration( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope); | |
buildTypedefDeclarationWithEmbeddedTag
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclarationWithEmbeddedTag( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope, SgDeclarationStatement* embeddedDefinition); | |
buildTypedefDeclarationWithEmbeddedTag_nfi
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclarationWithEmbeddedTag_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope, SgDeclarationStatement* embeddedDefinition); | |
buildTypedefDeclaration_nfi
[[visibility("default")]] SgTypedefDeclaration* buildTypedefDeclaration_nfi( typedef_declaration_ownership const& ownership, SgTypedefDeclaration::typedef_type_enum declarationForm, std::string const& name, SgType* base_type, SgScopeStatement* scope); | |
buildUnaryAddOp
[[visibility("default")]] SgUnaryAddOp* buildUnaryAddOp( SgExpression* op, SgType* result_type); | |
buildUnaryAddOp_nfi
[[visibility("default")]] SgUnaryAddOp* buildUnaryAddOp_nfi( SgExpression* op, SgType* result_type); | |
buildUnaryExpression
template< class T, class... ConstructorArgs> T* buildUnaryExpression( SgExpression* operand, SgType* result_type, ConstructorArgs&&... constructor_args); | 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, class... ConstructorArgs> T* buildUnaryExpression_nfi( SgExpression* operand, SgType* result_type, ConstructorArgs&&... constructor_args); | 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
[[visibility("default")]] SgTypeUnknown* buildUnknownType(); | |
buildUnpublishedVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* buildUnpublishedVariableDeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope); | Build one source-positioned variable declaration without publishing a symbol. This is an internal transaction primitive: the caller must establish exact lexical ownership and publish the symbol before returning the declaration to application code. |
buildUnpublishedVariableDeclarationWithEmbeddedTag_nfi
[[visibility("default")]] SgVariableDeclaration* buildUnpublishedVariableDeclarationWithEmbeddedTag_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgDeclarationStatement* embeddedDefinition, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default); | Build an embedded-tag variable subtree without publishing its symbol. The frontend must attach exact redeclaration identity and publish the symbol in the same construction transaction. |
buildUnsigned128bitIntegerType
[[visibility("default")]] SgTypeUnsigned128bitInteger* buildUnsigned128bitIntegerType(); | |
buildUnsignedCharType
[[visibility("default")]] SgTypeUnsignedChar* buildUnsignedCharType(); | |
buildUnsignedCharVal
[[visibility("default")]] SgUnsignedCharVal* buildUnsignedCharVal(unsigned char v = 0); | Build an unsigned char |
buildUnsignedCharValHex
[[visibility("default")]] SgUnsignedCharVal* buildUnsignedCharValHex(unsigned char v = 0); | |
buildUnsignedCharVal_nfi
[[visibility("default")]] SgUnsignedCharVal* buildUnsignedCharVal_nfi( unsigned char v, std::string const& str); | |
buildUnsignedIntType
[[visibility("default")]] SgTypeUnsignedInt* buildUnsignedIntType(); | |
buildUnsignedIntVal
[[visibility("default")]] SgUnsignedIntVal* buildUnsignedIntVal(unsigned int v = 0); | Build an unsigned integer |
buildUnsignedIntValHex
[[visibility("default")]] SgUnsignedIntVal* buildUnsignedIntValHex(unsigned int v = 0); | |
buildUnsignedIntVal_nfi
[[visibility("default")]] SgUnsignedIntVal* buildUnsignedIntVal_nfi( unsigned int v, std::string const& str); | |
buildUnsignedLongLongIntVal
[[visibility("default")]] SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal(unsigned long long v = 0); | Build an unsigned long long integer |
buildUnsignedLongLongIntValHex
[[visibility("default")]] SgUnsignedLongLongIntVal* buildUnsignedLongLongIntValHex(unsigned long long v = 0); | |
buildUnsignedLongLongIntVal_nfi
[[visibility("default")]] SgUnsignedLongLongIntVal* buildUnsignedLongLongIntVal_nfi( unsigned long long v, std::string const& str); | |
buildUnsignedLongLongType
[[visibility("default")]] SgTypeUnsignedLongLong* buildUnsignedLongLongType(); | |
buildUnsignedLongType
[[visibility("default")]] SgTypeUnsignedLong* buildUnsignedLongType(); | |
buildUnsignedLongVal
[[visibility("default")]] SgUnsignedLongVal* buildUnsignedLongVal(unsigned long v = 0); | Build a unsigned long integer |
buildUnsignedLongValHex
[[visibility("default")]] SgUnsignedLongVal* buildUnsignedLongValHex(unsigned long v = 0); | |
buildUnsignedLongVal_nfi
[[visibility("default")]] SgUnsignedLongVal* buildUnsignedLongVal_nfi( unsigned long v, std::string const& str); | |
buildUnsignedShortType
[[visibility("default")]] SgTypeUnsignedShort* buildUnsignedShortType(); | |
buildUnsignedShortVal
[[visibility("default")]] SgUnsignedShortVal* buildUnsignedShortVal(unsigned short v = 0); | Build an unsigned short integer |
buildUnsignedShortValHex
[[visibility("default")]] SgUnsignedShortVal* buildUnsignedShortValHex(unsigned short v = 0); | |
buildUnsignedShortVal_nfi
[[visibility("default")]] SgUnsignedShortVal* buildUnsignedShortVal_nfi( unsigned short v, std::string const& str); | |
buildUsingDirectiveStatement
[[visibility("default")]] SgUsingDirectiveStatement* buildUsingDirectiveStatement(SgNamespaceDeclarationStatement* ns_decl); | Build a using directive statement |
buildUsingDirectiveStatement_nfi
[[visibility("default")]] SgUsingDirectiveStatement* buildUsingDirectiveStatement_nfi(SgNamespaceDeclarationStatement* ns_decl); | |
buildVarArgCopyOp
[[visibility("default")]] SgVarArgCopyOp* buildVarArgCopyOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildVarArgCopyOp_nfi
[[visibility("default")]] SgVarArgCopyOp* buildVarArgCopyOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildVarArgEndOp
[[visibility("default")]] SgVarArgEndOp* buildVarArgEndOp( SgExpression* op, SgType* result_type); | |
buildVarArgEndOp_nfi
[[visibility("default")]] SgVarArgEndOp* buildVarArgEndOp_nfi( SgExpression* op, SgType* result_type); | |
buildVarArgOp_nfi
[[visibility("default")]] SgVarArgOp* buildVarArgOp_nfi( SgExpression* operand_i, SgType* expression_type); | Build vararg op expression |
buildVarArgStartOneOperandOp
[[visibility("default")]] SgVarArgStartOneOperandOp* buildVarArgStartOneOperandOp( SgExpression* op, SgType* result_type); | |
buildVarArgStartOneOperandOp_nfi
[[visibility("default")]] SgVarArgStartOneOperandOp* buildVarArgStartOneOperandOp_nfi( SgExpression* op, SgType* result_type); | |
buildVarArgStartOp
[[visibility("default")]] SgVarArgStartOp* buildVarArgStartOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildVarArgStartOp_nfi
[[visibility("default")]] SgVarArgStartOp* buildVarArgStartOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildVarRefExp
[[visibility("default")]] SgVarRefExp* buildVarRefExp(SgVariableDeclaration* vardecl); | buildVarRefExp overloads |
buildVarRefExp_nfi
[[visibility("default")]] SgVarRefExp* buildVarRefExp_nfi(SgVariableSymbol* varSymbol); | |
buildVariableDeclaration
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgType* cxxSourceType = nullptr); | Build a fresh, structurally detached variable declaration in an exact semantic scope. A same-scope declaration with the same name is a hard error; use buildVariableRedeclaration() when the prior declaration is known. An explicit C/C++ written type must be distinct and semantically equivalent; it is attached before the declaration's variable symbol is published. |
buildVariableDeclarationWithEmbeddedTag
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclarationWithEmbeddedTag( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration, SgDeclarationStatement* embeddedDefinition); | Build a fresh variable declaration which is the exact physical owner of a source-spelled class/enum definition embedded in its declarator. |
buildVariableDeclarationWithEmbeddedTag_nfi
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclarationWithEmbeddedTag_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration, SgDeclarationStatement* embeddedDefinition, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default); | Build an embedded-tag variable declaration with null frontend positions. |
buildVariableDeclaration_nfi
[[visibility("default")]] SgVariableDeclaration* buildVariableDeclaration_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default); | Build a fresh variable declaration with null frontend source positions. |
buildVariableDefinition_nfi
[[visibility("default")]] SgVariableDefinition* buildVariableDefinition_nfi( SgVariableDeclaration* decl, SgInitializedName* init_name, SgInitializer* init); | Build variable definition |
buildVariableRedeclaration
[[visibility("default")]] SgVariableDeclaration* buildVariableRedeclaration( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration); | Build a fresh, detached redeclaration with an explicit prior identity. |
buildVariableRedeclaration_nfi
[[visibility("default")]] SgVariableDeclaration* buildVariableRedeclaration_nfi( SgName const& name, SgType* type, SgInitializer* varInit, SgScopeStatement* scope, SgInitializedName* priorDeclaration, SgStorageModifier::storage_modifier_enum sm = SgStorageModifier::e_default); | Build a fresh, detached redeclaration with null frontend source positions. |
buildVariantExpression
[[visibility("default")]] SgVariantExpression* buildVariantExpression(SgType* anchor_type); | |
buildVoidType
[[visibility("default")]] SgTypeVoid* buildVoidType(); | |
buildVoidVal
[[visibility("default")]] SgVoidVal* buildVoidVal(); | |
buildVoidVal_nfi
[[visibility("default")]] SgVoidVal* buildVoidVal_nfi(); | |
buildVolatileType
[[visibility("default")]] SgModifierType* buildVolatileType(SgType* base_type = nullptr); | Build a volatile type. |
buildWcharType
[[visibility("default")]] SgTypeWchar* buildWcharType(); | |
buildWcharVal
[[visibility("default")]] SgWcharVal* buildWcharVal(int64_t value = 0); | |
buildWcharVal_nfi
[[visibility("default")]] SgWcharVal* buildWcharVal_nfi( int64_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
[[visibility("default")]] SgXorAssignOp* buildXorAssignOp( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
buildXorAssignOp_nfi
[[visibility("default")]] SgXorAssignOp* buildXorAssignOp_nfi( SgExpression* lhs, SgExpression* rhs, SgType* result_type); | |
clearScopeStack
[[visibility("default")]] void clearScopeStack(); | |
completeSemanticFunctionDeclarationAsDefinition
[[visibility("default")]] SgFunctionDeclaration* completeSemanticFunctionDeclarationAsDefinition(SgFunctionDeclaration* declaration); | Complete one source-less semantic function declaration as its own definition when no distinct declaration precedes it. |
copyFunctionSignature
[[visibility("default")]] std::unique_ptr<SgFunctionType> copyFunctionSignature( SgFunctionType const* specification, SgType* returnType, std::unique_ptr<SgFunctionParameterTypeList> arguments, SgType* classType, unsigned int memberFlags, SgCopyHelp& bindings, SgFunctionType* semanticSignature); | |
detachAuxiliaryDeclaration
[[visibility("default")]] bool detachAuxiliaryDeclaration( SgScopeStatement* owner, SgDeclarationStatement* declaration); | Remove a semantic-only declaration ownership edge. |
detachDeclarationScope
[[visibility("default")]] void detachDeclarationScope( SgScopeStatement* owner, SgDeclarationScope* scope); | |
display
[[visibility("default")]] std::string display(SourcePositionClassification& scp); | display function for debugging |
emptyScopeStack
[[visibility("default")]] bool emptyScopeStack(); | |
errorCheckingTargetAST
[[visibility("default")]] void errorCheckingTargetAST( SgNode* node_copy, SgNode* node_original, SgFile* targetFile); | Error checking the inserted snippet AST. |
findAssociatedSymbolInTargetAST
[[visibility("default")]] SgSymbol* findAssociatedSymbolInTargetAST( SgDeclarationStatement* snippet_declaration, SgScopeStatement* targetScope); | |
finishSourceDeclaratorScopeConstruction
[[visibility("default")]] void finishSourceDeclaratorScopeConstruction( SgDeclarationStatement* owner, SgDeclarationScope* scope); | Complete a source-declarator scope begun by beginSourceDeclaratorScopeConstruction(). Every child must have one exact nonautonomous structural role and already-published physical provenance. |
fixupCopyOfNodeFromSeparateFileInNewTargetAst
[[visibility("default")]] void fixupCopyOfNodeFromSeparateFileInNewTargetAst( SgStatement* insertionPoint, bool insertionPointIsScope, SgNode* node_copy, SgNode* node_original); | |
functionParameterTypeFromDeclaredType
[[visibility("default")]] SgType* functionParameterTypeFromDeclaredType(SgType* type); | Derive a callable parameter type from a validated declared type without mutating the declaration's type. |
getDeclarationScopeOwner
[[visibility("default")]] SgNode* getDeclarationScopeOwner(SgDeclarationScope const* scope); | |
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). |
getNonrealDeclarationScope
[[visibility("default")]] SgDeclarationScope* getNonrealDeclarationScope(SgDeclarationStatement* owner); | Get the nonreal declaration scope associated with a declaration (if any). |
getOrCreateNonrealDeclarationScope
[[visibility("default")]] SgDeclarationScope* getOrCreateNonrealDeclarationScope(SgDeclarationStatement* owner); | Get or create the nonreal declaration scope associated with a declaration. |
getSourcePositionClassificationMode
[[visibility("default")]] SourcePositionClassification getSourcePositionClassificationMode(); | Get the current source position classification (defines how IR nodes built by the SageBuilder interface will be classified). |
getTargetFileType
[[visibility("default")]] SgType* getTargetFileType( SgType* snippet_type, SgScopeStatement* targetScope); | |
getTemplateArgumentList
[[visibility("default")]] SgTemplateArgumentPtrList* getTemplateArgumentList(SgDeclarationStatement* decl); | |
getTemplateParameterList
[[visibility("default")]] SgTemplateParameterPtrList* getTemplateParameterList(SgDeclarationStatement* decl); | |
inSwitchScope
bool inSwitchScope(); | |
initializePendingSourceVariableDeclarationProvenance
[[visibility("default")]] void initializePendingSourceVariableDeclarationProvenance(SgVariableDeclaration* declaration); | Complete the provenance of a detached frontend source declaration before its exact declaration range is known. Fresh structural wrappers receive semantic generated provenance while already source-positioned expression operands retain their exact immutable provenance. |
initializeSemanticExpressionSourceProvenance
[[visibility("default")]] void initializeSemanticExpressionSourceProvenance(SgExpression* expression); | Classify one fresh semantic-only expression with complete compiler-generated provenance. Source-positioned or partially positioned input is malformed. |
initializeSemanticVariableDeclarationSourceProvenance
[[visibility("default")]] void initializeSemanticVariableDeclarationSourceProvenance(SgVariableDeclaration* declaration); | Classify a freshly built semantic-only variable declaration and every structurally owned located child with exact compiler-generated provenance. Source-positioned or partially positioned input is malformed and aborts. |
internFunctionType
[[visibility("default")]] SgFunctionType* internFunctionType(std::unique_ptr<SgFunctionType> candidate); | Intern a complete semantic signature, consuming its owned children even when an identical canonical type already exists. |
popScopeStack
[[visibility("default")]] void popScopeStack(); | |
publishExactSourceLexicalDeclaration
[[visibility("default")]] void publishExactSourceLexicalDeclaration( SgDeclarationStatement* declaration, SgScopeStatement* scope); | Complete one source-lexical declaration transaction whose builder used sourceLexicalPendingExactSource(). The declaration must still be detached and must already own exact physical source provenance. This operation publishes the lexical owner exactly once and never synthesizes or repairs source information. |
pushScopeStack
[[visibility("default")]] void pushScopeStack(SgScopeStatement* stmt); | Public interfaces of the scope stack, should be stable |
rebindCopiedSourceFilePhysicalIdentity
[[visibility("default")]] void rebindCopiedSourceFilePhysicalIdentity( SgSourceFile* sourceFile, std::string const& newFileName); | Commit the physical identity of a parsed source-file copy. The source file must still identify the primary file it was parsed from. Positions owned by that primary file are rebound to newFileName. Positions originating in included files retain their exact physical provenance. Incomplete or shared source ranges are hard producer errors. Rooted Fortran transfers only the primary occurrence, preserving included occurrences even when they refer to the same physical file. Composite Fortran endpoints keep their independent occurrence identities and canonical lexical order. Mixed physical ranges outside that validated Fortran contract still fail. The requested spelling remains the logical identity; its absolute resolved destination is the physical identity recorded by the Fortran context. |
requireFreshNfiExpressionSourceState
[[visibility("default")]] void requireFreshNfiExpressionSourceState( SgExpression* expression, char const* producer); | |
requireFreshNfiLocatedNodeSourceState
[[visibility("default")]] void requireFreshNfiLocatedNodeSourceState( SgLocatedNode* node, char const* producer); | Enforce the construction-time contract shared by all expression builders whose names end in _nfi: the newly allocated root must not already own any source-position object. This validator never clears or repairs provenance. |
setNonrealDeclarationScope
[[visibility("default")]] void setNonrealDeclarationScope( SgDeclarationStatement* owner, SgDeclarationScope* scope); | Attach a nonreal declaration scope to a declaration. |
setSourcePositionClassificationMode
[[visibility("default")]] void setSourcePositionClassificationMode(SourcePositionClassification X); | Set the current source position classification (defines how IR nodes built by the SageBuilder interface will be classified). |
setTemplateArgumentParents
[[visibility("default")]] void setTemplateArgumentParents(SgDeclarationStatement* decl); | |
setTemplateArgumentsInDeclaration
[[visibility("default")]] void setTemplateArgumentsInDeclaration( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateArgumentsList_input); | |
setTemplateNameInTemplateInstantiations
[[visibility("default")]] void setTemplateNameInTemplateInstantiations( SgFunctionDeclaration* func, SgName const& name); | |
setTemplateParameterParents
[[visibility("default")]] void setTemplateParameterParents(SgDeclarationStatement* decl); | |
setTemplateParametersInDeclaration
[[visibility("default")]] void setTemplateParametersInDeclaration( SgDeclarationStatement* decl, SgTemplateParameterPtrList* templateParametersList_input); | |
setTemplateSpecializationArgumentsInDeclaration
[[visibility("default")]] void setTemplateSpecializationArgumentsInDeclaration( SgDeclarationStatement* decl, SgTemplateArgumentPtrList* templateSpecializationArgumentsList_input); | |
testTemplateArgumentParents
[[visibility("default")]] void testTemplateArgumentParents(SgDeclarationStatement* decl); | |
testTemplateParameterParents
[[visibility("default")]] void testTemplateParameterParents(SgDeclarationStatement* decl); | |
topScopeStack
[[visibility("default")]] SgScopeStatement* topScopeStack(); | |