Skip to content

ClangToSageTranslator

Translator from Clang AST to SAGE III (ROSE Compiler AST)

Synopsis

Declared in <Clang/clang-frontend-private.hpp>

class ClangToSageTranslator
    : public clang::ASTConsumer

Base Classes

Name Description
clang::ASTConsumer

Types

Name
OpenMPCVariantScope

Enums

Name Description
ExpandedTokenBoundary
Language the 5 C-family languages supported by Clang

Member Functions

Name Description
ClangToSageTranslator
ClangToSageTranslator( clang::CompilerInstance* compiler_instance, Language language_, SgSourceFile* sage_source_file, SagePreprocessorRecord* preprocessor_recorder); [constructor]
~ClangToSageTranslator
virtual ~ClangToSageTranslator(); [destructor] [virtual]
Destructor
HandleTranslationUnit
virtual void HandleTranslationUnit(clang::ASTContext& ast_context); [virtual]
Traverse
virtual SgNode* Traverse(clang::Decl* decl);
TraverseForDeclContext
virtual bool TraverseForDeclContext(clang::DeclContext* decl_context); [virtual]
TraverseMemberIdentityOwner
SgNode* TraverseMemberIdentityOwner(clang::RecordDecl* owner);
TraverseOnDemand
virtual SgNode* TraverseOnDemand(clang::Decl* decl); [virtual]
VisitAbstractConditionalOperator
virtual bool VisitAbstractConditionalOperator( clang::AbstractConditionalOperator* abstract_conditional_operator, SgNode** node); [virtual]
VisitAccessSpecDecl
virtual bool VisitAccessSpecDecl( clang::AccessSpecDecl* access_spec_decl, SgNode** node); [virtual]
VisitAddrLabelExpr
virtual bool VisitAddrLabelExpr( clang::AddrLabelExpr* addr_label_expr, SgNode** node); [virtual]
VisitAdjustedType
virtual bool VisitAdjustedType( clang::AdjustedType* adjusted_type, SgNode** node); [virtual]
VisitArrayInitIndexExpr
virtual bool VisitArrayInitIndexExpr( clang::ArrayInitIndexExpr* expression, SgNode** node); [virtual]
VisitArrayInitLoopExpr
virtual bool VisitArrayInitLoopExpr( clang::ArrayInitLoopExpr* array_init_loop_expr, SgNode** node); [virtual]
VisitArraySubscriptExpr
virtual bool VisitArraySubscriptExpr( clang::ArraySubscriptExpr* array_subscript_expr, SgNode** node); [virtual]
VisitArrayType
virtual bool VisitArrayType( clang::ArrayType* array_type, SgNode** node); [virtual]
VisitArrayTypeTraitExpr
virtual bool VisitArrayTypeTraitExpr( clang::ArrayTypeTraitExpr* array_type_trait_expr, SgNode** node); [virtual]
VisitAtomicExpr
virtual bool VisitAtomicExpr( clang::AtomicExpr* atomic_expr, SgNode** node); [virtual]
VisitAtomicType
virtual bool VisitAtomicType( clang::AtomicType* atomic_type, SgNode** node); [virtual]
VisitAttributedStmt
virtual bool VisitAttributedStmt( clang::AttributedStmt* attributed_stmt, SgNode** node); [virtual]
VisitAttributedType
virtual bool VisitAttributedType( clang::AttributedType* attributed_type, SgNode** node); [virtual]
VisitAutoType
virtual bool VisitAutoType( clang::AutoType* auto_type, SgNode** node); [virtual]
VisitBinaryConditionalOperator
virtual bool VisitBinaryConditionalOperator( clang::BinaryConditionalOperator* binary_conditional_operator, SgNode** node); [virtual]
VisitBinaryOperator
virtual bool VisitBinaryOperator( clang::BinaryOperator* binary_operator, SgNode** node); [virtual]
VisitBindingDecl
virtual bool VisitBindingDecl( clang::BindingDecl* binding_decl, SgNode** node); [virtual]
VisitBlockDecl
virtual bool VisitBlockDecl( clang::BlockDecl* block_decl, SgNode** node); [virtual]
VisitBlockExpr
virtual bool VisitBlockExpr( clang::BlockExpr* block_expr, SgNode** node); [virtual]
VisitBlockPointerType
virtual bool VisitBlockPointerType( clang::BlockPointerType* block_pointer_type, SgNode** node); [virtual]
VisitBreakStmt
virtual bool VisitBreakStmt( clang::BreakStmt* break_stmt, SgNode** node); [virtual]
VisitBuiltinBitCastExpr
virtual bool VisitBuiltinBitCastExpr( clang::BuiltinBitCastExpr* builtin_bit_cast_expr, SgNode** node); [virtual]
VisitBuiltinTemplateDecl
virtual bool VisitBuiltinTemplateDecl( clang::BuiltinTemplateDecl* builtin_template_decl, SgNode** node); [virtual]
VisitBuiltinType
virtual bool VisitBuiltinType( clang::BuiltinType* builtin_type, SgNode** node); [virtual]
VisitCStyleCastExpr
virtual bool VisitCStyleCastExpr( clang::CStyleCastExpr* c_style_cast, SgNode** node); [virtual]
VisitCUDAKernelCallExpr
virtual bool VisitCUDAKernelCallExpr( clang::CUDAKernelCallExpr* cuda_kernel_call_expr, SgNode** node); [virtual]
VisitCXXAddrspaceCastExpr
virtual bool VisitCXXAddrspaceCastExpr( clang::CXXAddrspaceCastExpr* cxx_addrspace_cast_expr, SgNode** node); [virtual]
VisitCXXBindTemporaryExpr
virtual bool VisitCXXBindTemporaryExpr( clang::CXXBindTemporaryExpr* cxx_bind_temporary_expr, SgNode** node); [virtual]
VisitCXXBoolLiteralExpr
virtual bool VisitCXXBoolLiteralExpr( clang::CXXBoolLiteralExpr* cxx_bool_literal_expr, SgNode** node); [virtual]
VisitCXXCatchStmt
virtual bool VisitCXXCatchStmt( clang::CXXCatchStmt* cxx_catch_stmt, SgNode** node); [virtual]
VisitCXXConstructExpr
virtual bool VisitCXXConstructExpr( clang::CXXConstructExpr* cxx_construct_expr, SgNode** node); [virtual]
VisitCXXConstructorDecl
virtual bool VisitCXXConstructorDecl( clang::CXXConstructorDecl* cxx_constructor_decl, SgNode** node); [virtual]
VisitCXXConversionDecl
virtual bool VisitCXXConversionDecl( clang::CXXConversionDecl* cxx_conversion_decl, SgNode** node); [virtual]
VisitCXXDeductionGuideDecl
virtual bool VisitCXXDeductionGuideDecl( clang::CXXDeductionGuideDecl* cxx_deduction_guide_guide, SgNode** node); [virtual]
VisitCXXDefaultArgExpr
virtual bool VisitCXXDefaultArgExpr( clang::CXXDefaultArgExpr* cxx_default_arg_expr, SgNode** node); [virtual]
VisitCXXDefaultInitExpr
virtual bool VisitCXXDefaultInitExpr( clang::CXXDefaultInitExpr* cxx_default_init_expr, SgNode** node); [virtual]
VisitCXXDeleteExpr
virtual bool VisitCXXDeleteExpr( clang::CXXDeleteExpr* cxx_delete_expr, SgNode** node); [virtual]
VisitCXXDependentScopeMemberExpr
virtual bool VisitCXXDependentScopeMemberExpr( clang::CXXDependentScopeMemberExpr* cxx_dependent_scope_member_expr, SgNode** node); [virtual]
VisitCXXDestructorDecl
virtual bool VisitCXXDestructorDecl( clang::CXXDestructorDecl* cxx_destructor_decl, SgNode** node); [virtual]
VisitCXXFoldExpr
virtual bool VisitCXXFoldExpr( clang::CXXFoldExpr* cxx_fold_expr, SgNode** node); [virtual]
VisitCXXForRangeStmt
virtual bool VisitCXXForRangeStmt( clang::CXXForRangeStmt* cxx_for_range_stmt, SgNode** node); [virtual]
VisitCXXFunctionalCastExpr
virtual bool VisitCXXFunctionalCastExpr( clang::CXXFunctionalCastExpr* cxx_functional_cast_expr, SgNode** node); [virtual]
VisitCXXMemberCallExpr
virtual bool VisitCXXMemberCallExpr( clang::CXXMemberCallExpr* cxx_member_call_expr, SgNode** node); [virtual]
VisitCXXNewExpr
virtual bool VisitCXXNewExpr( clang::CXXNewExpr* cxx_new_expr, SgNode** node); [virtual]
VisitCXXNoexceptExpr
virtual bool VisitCXXNoexceptExpr( clang::CXXNoexceptExpr* cxx_noexcept_expr, SgNode** node); [virtual]
VisitCXXNullPtrLiteralExpr
virtual bool VisitCXXNullPtrLiteralExpr( clang::CXXNullPtrLiteralExpr* cxx_null_ptr_literal_expr, SgNode** node); [virtual]
VisitCXXOperatorCallExpr
virtual bool VisitCXXOperatorCallExpr( clang::CXXOperatorCallExpr* cxx_operator_call_expr, SgNode** node); [virtual]
VisitCXXParenListInitExpr
virtual bool VisitCXXParenListInitExpr( clang::CXXParenListInitExpr* cxx_paren_list_init_expr, SgNode** node); [virtual]
VisitCXXPseudoDestructorExpr
virtual bool VisitCXXPseudoDestructorExpr( clang::CXXPseudoDestructorExpr* cxx_pseudo_destructor_expr, SgNode** node); [virtual]
VisitCXXRecordDecl
virtual bool VisitCXXRecordDecl( clang::CXXRecordDecl* cxx_record_decl, SgNode** node); [virtual]
VisitCXXRewrittenBinaryOperator
virtual bool VisitCXXRewrittenBinaryOperator( clang::CXXRewrittenBinaryOperator* cxx_rewrite_binary_operator, SgNode** node); [virtual]
VisitCXXScalarValueInitExpr
virtual bool VisitCXXScalarValueInitExpr( clang::CXXScalarValueInitExpr* cxx_scalar_value_init_expr, SgNode** node); [virtual]
VisitCXXStdInitializerListExpr
virtual bool VisitCXXStdInitializerListExpr( clang::CXXStdInitializerListExpr* cxx_std_initializer_list_expr, SgNode** node); [virtual]
VisitCXXTemporaryObjectExpr
virtual bool VisitCXXTemporaryObjectExpr( clang::CXXTemporaryObjectExpr* cxx_temporary_object_expr, SgNode** node); [virtual]
VisitCXXThisExpr
virtual bool VisitCXXThisExpr( clang::CXXThisExpr* cxx_this_expr, SgNode** node); [virtual]
VisitCXXThrowExpr
virtual bool VisitCXXThrowExpr( clang::CXXThrowExpr* cxx_throw_expr, SgNode** node); [virtual]
VisitCXXTryStmt
virtual bool VisitCXXTryStmt( clang::CXXTryStmt* cxx_try_stmt, SgNode** node); [virtual]
VisitCXXTypeidExpr
virtual bool VisitCXXTypeidExpr( clang::CXXTypeidExpr* cxx_typeid_expr, SgNode** node); [virtual]
VisitCXXUnresolvedConstructExpr
virtual bool VisitCXXUnresolvedConstructExpr( clang::CXXUnresolvedConstructExpr* cxx_unresolved_construct_expr, SgNode** node); [virtual]
VisitCallExpr
virtual bool VisitCallExpr( clang::CallExpr* call_expr, SgNode** node); [virtual]
VisitCapturedDecl
virtual bool VisitCapturedDecl( clang::CapturedDecl* capture_decl, SgNode** node); [virtual]
VisitCapturedStmt
virtual bool VisitCapturedStmt( clang::CapturedStmt* captured_stmt, SgNode** node); [virtual]
VisitCaseStmt
virtual bool VisitCaseStmt( clang::CaseStmt* case_stmt, SgNode** node); [virtual]
VisitCharacterLiteral
virtual bool VisitCharacterLiteral( clang::CharacterLiteral* character_literal, SgNode** node); [virtual]
VisitChooseExpr
virtual bool VisitChooseExpr( clang::ChooseExpr* choose_expr, SgNode** node); [virtual]
VisitClassTemplateDecl
virtual bool VisitClassTemplateDecl( clang::ClassTemplateDecl* class_template_decl, SgNode** node); [virtual]
VisitClassTemplatePartialSpecializationDecl
virtual bool VisitClassTemplatePartialSpecializationDecl( clang::ClassTemplatePartialSpecializationDecl* class_tpl_part_spec_decl, SgNode** node); [virtual]
VisitClassTemplateSpecializationDecl
virtual bool VisitClassTemplateSpecializationDecl( clang::ClassTemplateSpecializationDecl* class_tpl_spec_decl, SgNode** node); [virtual]
VisitCoawaitExpr
virtual bool VisitCoawaitExpr( clang::CoawaitExpr* coawait_expr, SgNode** node); [virtual]
VisitComplexType
virtual bool VisitComplexType( clang::ComplexType* complex_type, SgNode** node); [virtual]
VisitCompoundAssignOperator
virtual bool VisitCompoundAssignOperator( clang::CompoundAssignOperator* compound_assign_operator, SgNode** node); [virtual]
VisitCompoundLiteralExpr
virtual bool VisitCompoundLiteralExpr( clang::CompoundLiteralExpr* compound_literal, SgNode** node); [virtual]
VisitCompoundStmt
virtual bool VisitCompoundStmt( clang::CompoundStmt* compound_stmt, SgNode** node); [virtual]
VisitConceptDecl
virtual bool VisitConceptDecl( clang::ConceptDecl* concept_decl, SgNode** node); [virtual]
VisitConceptSpecializationExpr
virtual bool VisitConceptSpecializationExpr( clang::ConceptSpecializationExpr* concept_specialization_expr, SgNode** node); [virtual]
VisitConditionalOperator
virtual bool VisitConditionalOperator( clang::ConditionalOperator* conditional_operator, SgNode** node); [virtual]
VisitConstantArrayType
virtual bool VisitConstantArrayType( clang::ConstantArrayType* constant_array_type, SgNode** node); [virtual]
VisitConstantExpr
virtual bool VisitConstantExpr( clang::ConstantExpr* constant_expr, SgNode** node); [virtual]
VisitConstructorUsingShadowDecl
virtual bool VisitConstructorUsingShadowDecl( clang::ConstructorUsingShadowDecl* constructor_using_shadow_decl, SgNode** node); [virtual]
VisitContinueStmt
virtual bool VisitContinueStmt( clang::ContinueStmt* continue_stmt, SgNode** node); [virtual]
VisitConvertVectorExpr
virtual bool VisitConvertVectorExpr( clang::ConvertVectorExpr* convert_vector_expr, SgNode** node); [virtual]
VisitCoreturnStmt
virtual bool VisitCoreturnStmt( clang::CoreturnStmt* coreturn_stmt, SgNode** node); [virtual]
VisitCoroutineBodyStmt
virtual bool VisitCoroutineBodyStmt( clang::CoroutineBodyStmt* coroutine_body_stmt, SgNode** node); [virtual]
VisitCoyieldExpr
virtual bool VisitCoyieldExpr( clang::CoyieldExpr* coyield_expr, SgNode** node); [virtual]
VisitDecayedType
virtual bool VisitDecayedType( clang::DecayedType* decayed_type, SgNode** node); [virtual]
VisitDecl
virtual bool VisitDecl( clang::Decl* decl, SgNode** node); [virtual]
VisitDeclRefExpr
virtual bool VisitDeclRefExpr( clang::DeclRefExpr* decl_ref_expr, SgNode** node); [virtual]
VisitDeclStmt
virtual bool VisitDeclStmt( clang::DeclStmt* decl_stmt, SgNode** node); [virtual]
VisitDeclaratorDecl
virtual bool VisitDeclaratorDecl( clang::DeclaratorDecl* declarator_decl, SgNode** node); [virtual]
VisitDecltypeType
virtual bool VisitDecltypeType( clang::DecltypeType* decltype_type, SgNode** node); [virtual]
VisitDecompositionDecl
virtual bool VisitDecompositionDecl( clang::DecompositionDecl* decomposition_decl, SgNode** node); [virtual]
VisitDeducedTemplateSpecializationType
virtual bool VisitDeducedTemplateSpecializationType( clang::DeducedTemplateSpecializationType* deduced_template_specialization_type, SgNode** node); [virtual]
VisitDeducedType
virtual bool VisitDeducedType( clang::DeducedType* deduced_type, SgNode** node); [virtual]
VisitDefaultStmt
virtual bool VisitDefaultStmt( clang::DefaultStmt* default_stmt, SgNode** node); [virtual]
VisitDependentCoawaitExpr
virtual bool VisitDependentCoawaitExpr( clang::DependentCoawaitExpr* dependent_coawait_expr, SgNode** node); [virtual]
VisitDependentNameType
virtual bool VisitDependentNameType( clang::DependentNameType* dependent_name_type, SgNode** node); [virtual]
VisitDependentScopeDeclRefExpr
virtual bool VisitDependentScopeDeclRefExpr( clang::DependentScopeDeclRefExpr* dependent_scope_decl_ref_expr, SgNode** node); [virtual]
VisitDependentSizedArrayType
virtual bool VisitDependentSizedArrayType( clang::DependentSizedArrayType* dependent_sized_array_type, SgNode** node); [virtual]
VisitDependentSizedExtVectorType
virtual bool VisitDependentSizedExtVectorType( clang::DependentSizedExtVectorType* dependent_sized_ext_vector_type, SgNode** node); [virtual]
VisitDependentVectorType
virtual bool VisitDependentVectorType( clang::DependentVectorType* dependent_vector_type, SgNode** node); [virtual]
VisitDesignatedInitExpr
virtual bool VisitDesignatedInitExpr( clang::DesignatedInitExpr* designated_init_expr, SgNode** node); [virtual]
VisitDesignatedInitUpdateExpr
virtual bool VisitDesignatedInitUpdateExpr( clang::DesignatedInitUpdateExpr* designated_init_update_expr, SgNode** node); [virtual]
VisitDoStmt
virtual bool VisitDoStmt( clang::DoStmt* do_stmt, SgNode** node); [virtual]
VisitEmptyDecl
virtual bool VisitEmptyDecl( clang::EmptyDecl* empty_decl, SgNode** node); [virtual]
VisitEnumConstantDecl
virtual bool VisitEnumConstantDecl( clang::EnumConstantDecl* enum_constant_decl, SgNode** node); [virtual]
VisitEnumDecl
virtual bool VisitEnumDecl( clang::EnumDecl* enum_decl, SgNode** node); [virtual]
VisitEnumType
virtual bool VisitEnumType( clang::EnumType* enum_type, SgNode** node); [virtual]
VisitExplicitCastExpr
virtual bool VisitExplicitCastExpr( clang::ExplicitCastExpr* explicit_cast_expr, SgNode** node); [virtual]
VisitExportDecl
virtual bool VisitExportDecl( clang::ExportDecl* export_decl, SgNode** node); [virtual]
VisitExpr
virtual bool VisitExpr( clang::Expr* expr, SgNode** node); [virtual]
VisitExprWithCleanups
virtual bool VisitExprWithCleanups( clang::ExprWithCleanups* expr_with_cleanups, SgNode** node); [virtual]
VisitExpressionTraitExpr
virtual bool VisitExpressionTraitExpr( clang::ExpressionTraitExpr* expression_trait_expr, SgNode** node); [virtual]
VisitExtVectorElementExpr
virtual bool VisitExtVectorElementExpr( clang::ExtVectorElementExpr* ext_vector_element_expr, SgNode** node); [virtual]
VisitExtVectorType
virtual bool VisitExtVectorType( clang::ExtVectorType* ext_vector_type, SgNode** node); [virtual]
VisitExternCContextDecl
virtual bool VisitExternCContextDecl( clang::ExternCContextDecl* ccontext_decl, SgNode** node); [virtual]
VisitFieldDecl
virtual bool VisitFieldDecl( clang::FieldDecl* field_decl, SgNode** node); [virtual]
VisitFileScopeAsmDecl
virtual bool VisitFileScopeAsmDecl( clang::FileScopeAsmDecl* file_scope_asm_decl, SgNode** node); [virtual]
VisitFloatingLiteral
virtual bool VisitFloatingLiteral( clang::FloatingLiteral* floating_literal, SgNode** node); [virtual]
VisitForStmt
virtual bool VisitForStmt( clang::ForStmt* for_stmt, SgNode** node); [virtual]
VisitFriendDecl
virtual bool VisitFriendDecl( clang::FriendDecl* friend_decl, SgNode** node); [virtual]
VisitFullExpr
virtual bool VisitFullExpr( clang::FullExpr* full_expr, SgNode** node); [virtual]
VisitFunctionDecl
virtual bool VisitFunctionDecl( clang::FunctionDecl* function_decl, SgNode** node); [virtual]
VisitFunctionNoProtoType
virtual bool VisitFunctionNoProtoType( clang::FunctionNoProtoType* function_no_proto_type, SgNode** node); [virtual]
VisitFunctionProtoType
virtual bool VisitFunctionProtoType( clang::FunctionProtoType* function_proass_symo_type, SgNode** node); [virtual]
VisitFunctionTemplateDecl
virtual bool VisitFunctionTemplateDecl( clang::FunctionTemplateDecl* function_template_decl, SgNode** node); [virtual]
VisitGCCAsmStmt
virtual bool VisitGCCAsmStmt( clang::GCCAsmStmt* gcc_asm_stmt, SgNode** node); [virtual]
VisitGNUNullExpr
virtual bool VisitGNUNullExpr( clang::GNUNullExpr* gnu_null_expr, SgNode** node); [virtual]
VisitGenericSelectionExpr
virtual bool VisitGenericSelectionExpr( clang::GenericSelectionExpr* generic_selection_expr, SgNode** node); [virtual]
VisitGotoStmt
virtual bool VisitGotoStmt( clang::GotoStmt* goto_stmt, SgNode** node); [virtual]
VisitIfStmt
virtual bool VisitIfStmt( clang::IfStmt* if_stmt, SgNode** node); [virtual]
VisitImaginaryLiteral
virtual bool VisitImaginaryLiteral( clang::ImaginaryLiteral* imaginary_literal, SgNode** node); [virtual]
VisitImplicitCastExpr
virtual bool VisitImplicitCastExpr( clang::ImplicitCastExpr* implicit_cast_expr, SgNode** node); [virtual]
VisitImplicitParamDecl
virtual bool VisitImplicitParamDecl( clang::ImplicitParamDecl* implicit_param_decl, SgNode** node); [virtual]
VisitImplicitValueInitExpr
virtual bool VisitImplicitValueInitExpr( clang::ImplicitValueInitExpr* implicit_value_init_expr, SgNode** node); [virtual]
VisitImportDecl
virtual bool VisitImportDecl( clang::ImportDecl* import_decl, SgNode** node); [virtual]
VisitIncompleteArrayType
virtual bool VisitIncompleteArrayType( clang::IncompleteArrayType* incomplete_array_type, SgNode** node); [virtual]
VisitIndirectFieldDecl
virtual bool VisitIndirectFieldDecl( clang::IndirectFieldDecl* indirect_field_decl, SgNode** node); [virtual]
VisitIndirectGotoStmt
virtual bool VisitIndirectGotoStmt( clang::IndirectGotoStmt* indirect_goto_stmt, SgNode** node); [virtual]
VisitInitListExpr
virtual bool VisitInitListExpr( clang::InitListExpr* init_list_expr, SgNode** node); [virtual]
VisitInjectedClassNameType
virtual bool VisitInjectedClassNameType( clang::InjectedClassNameType* injected_class_name_type, SgNode** node); [virtual]
VisitIntegerLiteral
virtual bool VisitIntegerLiteral( clang::IntegerLiteral* integer_literal, SgNode** node); [virtual]
VisitLValueReferenceType
virtual bool VisitLValueReferenceType( clang::LValueReferenceType* lvalue_reference_type, SgNode** node); [virtual]
VisitLabelDecl
virtual bool VisitLabelDecl( clang::LabelDecl* label_decl, SgNode** node); [virtual]
VisitLabelStmt
virtual bool VisitLabelStmt( clang::LabelStmt* label_stmt, SgNode** node); [virtual]
VisitLambdaExpr
virtual bool VisitLambdaExpr( clang::LambdaExpr* lambda_expr, SgNode** node); [virtual]
VisitLinkageSpecDecl
virtual bool VisitLinkageSpecDecl( clang::LinkageSpecDecl* linkage_spec_decl, SgNode** node); [virtual]
VisitMSAsmStmt
virtual bool VisitMSAsmStmt( clang::MSAsmStmt* ms_asm_stmt, SgNode** node); [virtual]
VisitMSDependentExistsStmt
virtual bool VisitMSDependentExistsStmt( clang::MSDependentExistsStmt* ms_dependent_exists_stmt, SgNode** node); [virtual]
VisitMSPropertyDecl
virtual bool VisitMSPropertyDecl( clang::MSPropertyDecl* ms_property_decl, SgNode** node); [virtual]
VisitMSPropertyRefExpr
virtual bool VisitMSPropertyRefExpr( clang::MSPropertyRefExpr* ms_property_expr, SgNode** node); [virtual]
VisitMSPropertySubscriptExpr
virtual bool VisitMSPropertySubscriptExpr( clang::MSPropertySubscriptExpr* ms_property_subscript_expr, SgNode** node); [virtual]
VisitMacroQualifiedType
virtual bool VisitMacroQualifiedType( clang::MacroQualifiedType* macro_qualified_type, SgNode** node); [virtual]
VisitMaterializeTemporaryExpr
virtual bool VisitMaterializeTemporaryExpr( clang::MaterializeTemporaryExpr* materialize_temporary_expr, SgNode** node); [virtual]
VisitMemberExpr
virtual bool VisitMemberExpr( clang::MemberExpr* member_expr, SgNode** node); [virtual]
VisitMemberPointerType
virtual bool VisitMemberPointerType( clang::MemberPointerType* member_pointer_type, SgNode** node); [virtual]
VisitNamedDecl
virtual bool VisitNamedDecl( clang::NamedDecl* named_decl, SgNode** node); [virtual]
VisitNamespaceAliasDecl
virtual bool VisitNamespaceAliasDecl( clang::NamespaceAliasDecl* namespace_alias_decl, SgNode** node); [virtual]
VisitNamespaceDecl
virtual bool VisitNamespaceDecl( clang::NamespaceDecl* namespace_decl, SgNode** node); [virtual]
VisitNoInitExpr
virtual bool VisitNoInitExpr( clang::NoInitExpr* no_init_expr, SgNode** node); [virtual]
VisitNonTypeTemplateParmDecl
virtual bool VisitNonTypeTemplateParmDecl( clang::NonTypeTemplateParmDecl* non_type_template_param_decl, SgNode** node); [virtual]
VisitNullStmt
virtual bool VisitNullStmt( clang::NullStmt* null_stmt, SgNode** node); [virtual]
VisitOffsetOfExpr
virtual bool VisitOffsetOfExpr( clang::OffsetOfExpr* offset_of_expr, SgNode** node); [virtual]
VisitOpaqueValueExpr
virtual bool VisitOpaqueValueExpr( clang::OpaqueValueExpr* opaque_value_expr, SgNode** node); [virtual]
VisitPackExpansionExpr
virtual bool VisitPackExpansionExpr( clang::PackExpansionExpr* pack_expansion_expr, SgNode** node); [virtual]
VisitPackExpansionType
virtual bool VisitPackExpansionType( clang::PackExpansionType* pack_expansion_type, SgNode** node); [virtual]
VisitParenExpr
virtual bool VisitParenExpr( clang::ParenExpr* paren_expr, SgNode** node); [virtual]
VisitParenListExpr
virtual bool VisitParenListExpr( clang::ParenListExpr* paran_list_expr, SgNode** node); [virtual]
VisitParenType
virtual bool VisitParenType( clang::ParenType* paren_type, SgNode** node); [virtual]
VisitParmVarDecl
virtual bool VisitParmVarDecl( clang::ParmVarDecl* param_var_decl, SgNode** node); [virtual]
VisitPipeType
virtual bool VisitPipeType( clang::PipeType* pipe_type, SgNode** node); [virtual]
VisitPointerType
virtual bool VisitPointerType( clang::PointerType* pointer_type, SgNode** node); [virtual]
VisitPragmaCommentDecl
virtual bool VisitPragmaCommentDecl( clang::PragmaCommentDecl* pragma_comment_decl, SgNode** node); [virtual]
VisitPragmaDetectMismatchDecl
virtual bool VisitPragmaDetectMismatchDecl( clang::PragmaDetectMismatchDecl* pragma_detect_mismatch, SgNode** node); [virtual]
VisitPredefinedExpr
virtual bool VisitPredefinedExpr( clang::PredefinedExpr* predefined_expr, SgNode** node); [virtual]
VisitPseudoObjectExpr
virtual bool VisitPseudoObjectExpr( clang::PseudoObjectExpr* pseudo_object_expr, SgNode** node); [virtual]
VisitRValueReferenceType
virtual bool VisitRValueReferenceType( clang::RValueReferenceType* rvalue_reference_type, SgNode** node); [virtual]
VisitRecordDecl
virtual bool VisitRecordDecl( clang::RecordDecl* record_decl, SgNode** node); [virtual]
VisitRecordType
virtual bool VisitRecordType( clang::RecordType* record_type, SgNode** node); [virtual]
VisitReferenceType
virtual bool VisitReferenceType( clang::ReferenceType* reference_type, SgNode** node); [virtual]
VisitRequiresExpr
virtual bool VisitRequiresExpr( clang::RequiresExpr* requires_expr, SgNode** node); [virtual]
VisitReturnStmt
virtual bool VisitReturnStmt( clang::ReturnStmt* return_stmt, SgNode** node); [virtual]
VisitSEHExceptStmt
virtual bool VisitSEHExceptStmt( clang::SEHExceptStmt* seh_except_stmt, SgNode** node); [virtual]
VisitSEHFinallyStmt
virtual bool VisitSEHFinallyStmt( clang::SEHFinallyStmt* seh_finally_stmt, SgNode** node); [virtual]
VisitSEHLeaveStmt
virtual bool VisitSEHLeaveStmt( clang::SEHLeaveStmt* seh_leave_stmt, SgNode** node); [virtual]
VisitSEHTryStmt
virtual bool VisitSEHTryStmt( clang::SEHTryStmt* seh_try_stmt, SgNode** node); [virtual]
VisitShuffleVectorExpr
virtual bool VisitShuffleVectorExpr( clang::ShuffleVectorExpr* shuffle_vector_expr, SgNode** node); [virtual]
VisitSizeOfPackExpr
virtual bool VisitSizeOfPackExpr( clang::SizeOfPackExpr* size_of_pack_expr, SgNode** node); [virtual]
VisitSourceLocExpr
virtual bool VisitSourceLocExpr( clang::SourceLocExpr* source_loc_expr, SgNode** node); [virtual]
VisitStaticAssertDecl
virtual bool VisitStaticAssertDecl( clang::StaticAssertDecl* static_assert_decl, SgNode** node); [virtual]
VisitStmt
virtual bool VisitStmt( clang::Stmt* stmt, SgNode** node); [virtual]
VisitStmtExpr
virtual bool VisitStmtExpr( clang::StmtExpr* stmt_expr, SgNode** node); [virtual]
VisitStringLiteral
virtual bool VisitStringLiteral( clang::StringLiteral* string_literal, SgNode** node); [virtual]
VisitSubstNonTypeTemplateParmExpr
virtual bool VisitSubstNonTypeTemplateParmExpr( clang::SubstNonTypeTemplateParmExpr* subst_non_type_template_parm_expr, SgNode** node); [virtual]
VisitSubstNonTypeTemplateParmPackExpr
virtual bool VisitSubstNonTypeTemplateParmPackExpr( clang::SubstNonTypeTemplateParmPackExpr* subst_non_type_template_parm_pack_expr, SgNode** node); [virtual]
VisitSubstTemplateTypeParmPackType
virtual bool VisitSubstTemplateTypeParmPackType( clang::SubstTemplateTypeParmPackType* subst_template_type_parm_pack_type, SgNode** node); [virtual]
VisitSubstTemplateTypeParmType
virtual bool VisitSubstTemplateTypeParmType( clang::SubstTemplateTypeParmType* subst_template_type_parm_type, SgNode** node); [virtual]
VisitSwitchCase
virtual bool VisitSwitchCase( clang::SwitchCase* switch_case, SgNode** node); [virtual]
VisitSwitchStmt
virtual bool VisitSwitchStmt( clang::SwitchStmt* switch_stmt, SgNode** node); [virtual]
VisitTagDecl
virtual bool VisitTagDecl( clang::TagDecl* tag_decl, SgNode** node); [virtual]
VisitTemplateSpecializationType
virtual bool VisitTemplateSpecializationType( clang::TemplateSpecializationType* template_specialization_type, SgNode** node); [virtual]
VisitTemplateTemplateParmDecl
virtual bool VisitTemplateTemplateParmDecl( clang::TemplateTemplateParmDecl* template_template_parm_decl, SgNode** node); [virtual]
VisitTemplateTypeParmDecl
virtual bool VisitTemplateTypeParmDecl( clang::TemplateTypeParmDecl* template_type_parm_decl, SgNode** node); [virtual]
VisitTemplateTypeParmType
virtual bool VisitTemplateTypeParmType( clang::TemplateTypeParmType* template_type_parm_type, SgNode** node); [virtual]
VisitTranslationUnitDecl
virtual bool VisitTranslationUnitDecl( clang::TranslationUnitDecl* translation_unit_decl, SgNode** node); [virtual]
VisitType
virtual bool VisitType( clang::Type* type, SgNode** node); [virtual]
VisitTypeAliasDecl
virtual bool VisitTypeAliasDecl( clang::TypeAliasDecl* type_alias_decl, SgNode** node); [virtual]
VisitTypeAliasTemplateDecl
virtual bool VisitTypeAliasTemplateDecl( clang::TypeAliasTemplateDecl* type_alias_template_decl, SgNode** node); [virtual]
VisitTypeDecl
virtual bool VisitTypeDecl( clang::TypeDecl* type_decl, SgNode** node); [virtual]
VisitTypeOfExprType
virtual bool VisitTypeOfExprType( clang::TypeOfExprType* type_of_expr_type, SgNode** node); [virtual]
VisitTypeOfType
virtual bool VisitTypeOfType( clang::TypeOfType* type_of_type, SgNode** node); [virtual]
VisitTypeTraitExpr
virtual bool VisitTypeTraitExpr( clang::TypeTraitExpr* type_trait, SgNode** node); [virtual]
VisitTypedefDecl
virtual bool VisitTypedefDecl( clang::TypedefDecl* typedef_decl, SgNode** node); [virtual]
VisitTypedefNameDecl
virtual bool VisitTypedefNameDecl( clang::TypedefNameDecl* typedef_name_decl, SgNode** node); [virtual]
VisitTypedefType
virtual bool VisitTypedefType( clang::TypedefType* typedef_type, SgNode** node); [virtual]
VisitUnaryExprOrTypeTraitExpr
virtual bool VisitUnaryExprOrTypeTraitExpr( clang::UnaryExprOrTypeTraitExpr* unary_expr_or_type_trait_expr, SgNode** node); [virtual]
VisitUnaryOperator
virtual bool VisitUnaryOperator( clang::UnaryOperator* unary_operator, SgNode** node); [virtual]
VisitUnaryTransformType
virtual bool VisitUnaryTransformType( clang::UnaryTransformType* unary_transform_type, SgNode** node); [virtual]
VisitUnresolvedLookupExpr
virtual bool VisitUnresolvedLookupExpr( clang::UnresolvedLookupExpr* unresolved_lookup_expr, SgNode** node); [virtual]
VisitUnresolvedMemberExpr
virtual bool VisitUnresolvedMemberExpr( clang::UnresolvedMemberExpr* unresolved_member_expr, SgNode** node); [virtual]
VisitUnresolvedUsingType
virtual bool VisitUnresolvedUsingType( clang::UnresolvedUsingType* unresolved_using_type, SgNode** node); [virtual]
VisitUnresolvedUsingTypenameDecl
virtual bool VisitUnresolvedUsingTypenameDecl( clang::UnresolvedUsingTypenameDecl* unresolved_using_type_name_decl, SgNode** node); [virtual]
VisitUnresolvedUsingValueDecl
virtual bool VisitUnresolvedUsingValueDecl( clang::UnresolvedUsingValueDecl* unresolved_using_value_decl, SgNode** node); [virtual]
VisitUserDefinedLiteral
virtual bool VisitUserDefinedLiteral( clang::UserDefinedLiteral* user_defined_literal, SgNode** node); [virtual]
VisitUsingDecl
virtual bool VisitUsingDecl( clang::UsingDecl* using_decl, SgNode** node); [virtual]
VisitUsingDirectiveDecl
virtual bool VisitUsingDirectiveDecl( clang::UsingDirectiveDecl* using_directive_decl, SgNode** node); [virtual]
VisitUsingPackDecl
virtual bool VisitUsingPackDecl( clang::UsingPackDecl* using_pack_decl, SgNode** node); [virtual]
VisitUsingShadowDecl
virtual bool VisitUsingShadowDecl( clang::UsingShadowDecl* using_shadow_decl, SgNode** node); [virtual]
VisitUsingType
virtual bool VisitUsingType( clang::UsingType* using_type, SgNode** node); [virtual]
VisitVAArgExpr
virtual bool VisitVAArgExpr( clang::VAArgExpr* va_arg_expr, SgNode** node); [virtual]
VisitValueDecl
virtual bool VisitValueDecl( clang::ValueDecl* value_decl, SgNode** node); [virtual]
VisitValueStmt
virtual bool VisitValueStmt( clang::ValueStmt* value_stmt, SgNode** node); [virtual]
VisitVarDecl
virtual bool VisitVarDecl( clang::VarDecl* var_decl, SgNode** node); [virtual]
VisitVarTemplateDecl
virtual bool VisitVarTemplateDecl( clang::VarTemplateDecl* var_template_decl, SgNode** node); [virtual]
VisitVarTemplatePartialSpecializationDecl
virtual bool VisitVarTemplatePartialSpecializationDecl( clang::VarTemplatePartialSpecializationDecl* var_template_partial_specialization, SgNode** node); [virtual]
VisitVarTemplateSpecializationDecl
virtual bool VisitVarTemplateSpecializationDecl( clang::VarTemplateSpecializationDecl* var_template_specialization_decl, SgNode** node); [virtual]
VisitVariableArrayType
virtual bool VisitVariableArrayType( clang::VariableArrayType* variable_array_type, SgNode** node); [virtual]
VisitVectorType
virtual bool VisitVectorType( clang::VectorType* vector_type, SgNode** node); [virtual]
VisitWhileStmt
virtual bool VisitWhileStmt( clang::WhileStmt* while_stmt, SgNode** node); [virtual]
anonymousDeclarationId
std::string anonymousDeclarationId(clang::NamedDecl const* declaration);
applySemanticAuxiliarySourceRange
void applySemanticAuxiliarySourceRange( SgNode* node, clang::SourceRange source_range);
Publish a physical Clang range as provenance for a declaration that is already owned by a typed semantic auxiliary container. This records no lexical source-owner edge and retains the physical coordinates only as frontend semantic identity.
applySourceRange
void applySourceRange( SgNode* node, clang::SourceRange source_range);
Update a Sage node source position using Clang information
applySourceRangeWithTrailingSemicolon
void applySourceRangeWithTrailingSemicolon( SgNode* rose_node, clang::Stmt const* clang_stmt);
Apply a source range to a ROSE node, extending the range to include a trailing semicolon when present. This is used when Clang provides an expression in statement position and ROSE must build a wrapper SgExprStatement.
buildConceptReference
SgNonrealRefExp* buildConceptReference( clang::ConceptReference const& reference, clang::ConceptSpecializationExpr const* specialization = nullptr);
buildDeclarationConditionValue
SgExpression* buildDeclarationConditionValue( clang::Expr* condition, SgScopeStatement* owner);
constructDestructorEpilogue
void constructDestructorEpilogue( clang::CXXDestructorDecl* declaration, SgFunctionDefinition* definition);
constructStructuredBindingPattern
void constructStructuredBindingPattern( clang::DecompositionDecl*, SgVariableDeclaration*);
getGlobalScope
SgGlobal* getGlobalScope() const;
getSourceText
std::string getSourceText(clang::SourceRange range) const;
get_sgAsmOperandModifier
SgAsmOp::asm_operand_modifier_enum get_sgAsmOperandModifier(std::string modifier);
hasExactSemanticExpressionConstructionEvidence
bool hasExactSemanticExpressionConstructionEvidence(clang::SourceRange construction_evidence) const;
An exact semantic expression is evidenced either by a physical Clang range or by the active Clang expression traversal itself. The latter is required for implicit semantic expressions whose Clang SourceRange is intentionally invalid.
hasExactSemanticExpressionConstructionRole
bool hasExactSemanticExpressionConstructionRole(char const* context) const;
Test whether the current producer owns a semantic expression.
lookupTranslatedFunctionDecl
SgFunctionDeclaration* lookupTranslatedFunctionDecl( clang::FunctionDecl* decl, bool allow_on_demand = true);
materializeCapturedOpenMPReferencedEnumConstants
void materializeCapturedOpenMPReferencedEnumConstants(clang::TranslationUnitDecl* translation_unit);
openMPVariantBase
clang::FunctionDecl* openMPVariantBase(clang::FunctionDecl* function) const;
openMPVariantOrdinal
std::optional<unsigned int> openMPVariantOrdinal(clang::FunctionDecl const* function) const;
preprocessor_list_size
size_t preprocessor_list_size();
preprocessor_mark_attached
void preprocessor_mark_attached(PreprocessingInfo* preprocessing_info);
preprocessor_pop
bool preprocessor_pop();
preprocessor_remaining_records
std::vector<std::pair<Sg_File_Info*, PreprocessingInfo*>> preprocessor_remaining_records();
preprocessor_top
std::pair<Sg_File_Info*, PreprocessingInfo*> preprocessor_top();
publishCanonicalSemanticExpressionSourceProvenance
void publishCanonicalSemanticExpressionSourceProvenance( SgExpression* expression, char const* context);
Publish one canonical semantic expression at its typed producer.
publishCanonicalSemanticImplicitConversionProvenance
void publishCanonicalSemanticImplicitConversionProvenance( SgCastExp* conversion, char const* context);
Publish a canonical semantic expression whose typed role is an implicit conversion, including the matching provenance role on every position.
publishCanonicalTemplateParameterSourceIdentity
void publishCanonicalTemplateParameterSourceIdentity( SgTemplateType* type, clang::NamedDecl* parameter, char const* context) const;
publishSemanticExpressionSourceProvenance
void publishSemanticExpressionSourceProvenance( SgExpression* expression, clang::SourceRange construction_evidence, char const* context);
Publish one exact semantic expression from Clang evidence.
recordExpandedToken
void recordExpandedToken(clang::Token const& token);
requireCanonicalTemplateParameterSourceIdentity
SgTemplateType::canonical_source_identity requireCanonicalTemplateParameterSourceIdentity( clang::NamedDecl* parameter, char const* context) const;
Resolve a Clang template parameter to the macro-aware canonical physical source token used by every Sage coordinate type for that parameter.
requireExpandedTokenSourceOrder
unsigned int requireExpandedTokenSourceOrder( clang::SourceLocation location, char const* context, ExpandedTokenBoundary boundary = ExpandedTokenBoundary::unique) const;
requireParsedDeclarationSemicolon
clang::SourceRange requireParsedDeclarationSemicolon( clang::SourceRange range, char const* context) const;
requireVariableTemplatePredecessor
SgInitializedName* requireVariableTemplatePredecessor( clang::Decl* previous, SgScopeStatement* scope, SgName const& name);
setActiveParser
void setActiveParser(clang::Parser* parser);
setOpenMPPragmaCallback
void setOpenMPPragmaCallback(RoseOpenMPPragmaCallback* callback);
setSynthesizedFileInfo
void setSynthesizedFileInfo(SgNode* node);
Publish exact synthesized provenance for a Sage node.
sortPreprocessorList
void sortPreprocessorList();
sourceSpellsTopLevelConstQualifier
bool sourceSpellsTopLevelConstQualifier( clang::VarDecl const* decl, clang::TypeLoc const& type_loc) const;
synchronizeOpenMPCVariantScope
void synchronizeOpenMPCVariantScope( clang::Parser& parser, clang::DeclGroupRef previous_declarations);
translateCastBasePath
SgTypePtrList translateCastBasePath(clang::CastExpr const& cast);
translateClangCastKind
SgCastExp::semantic_conversion_kind_enum translateClangCastKind(clang::CastKind kind) const;
Preserve LLVM's exact implicit/explicit conversion classification on every typed Sage cast producer.
translateClangValueCategory
SgCastExp::value_category_enum translateClangValueCategory(clang::ExprValueKind kind) const;
Preserve the value category selected by Clang for a typed conversion.
validateDeclarationAttachmentSession
void validateDeclarationAttachmentSession();
wrapMacroExpansionExpression
SgExpression* wrapMacroExpansionExpression( clang::Expr* clang_expression, SgExpression* expanded_expression);

Static Member Functions

Name
exactInitializedNameFromTranslatedVariableNode
static SgInitializedName* exactInitializedNameFromTranslatedVariableNode(SgNode* translated);

Data Members

Name
p_openmp_c_variant_scopes
p_openmp_variant_bases
p_openmp_variant_boundary_cursor
p_openmp_variant_ordinals
p_openmp_variant_region_count

Protected Types

Name
BindingStorageConstruction
CapturedPragma
ClassDefinitionPopulationFrame
DeclStatementConstruction
DeclaratorOwnedTagIntroductionConstructionFrame
ExactLiteralOperandSpelling
ExpandedTokenRecord
FieldInitializerConstruction
FunctionBodyTranslationOwner
FunctionBodyTranslationOwnerScope
FunctionExceptionConstructionFrame
FunctionExceptionSpecification
FunctionParameterConstructionFrame
FunctionTypeParameterConstructionFrame
LambdaInitCaptureOwnerFrame
NamespaceSourceRanges
PendingConstructorPostTranslation
PendingWrittenTypedefValidation
PostTranslationTemplateParameterSurface
PseudoObjectConstructionFrame
ReceiverMemberResolutionCacheEntry
RecordMemberAccessIndex
RequiresParameterConstructionFrame
SemanticExpressionConstruction
SourceDeclarationGroupConstruction
SourceDeclaratorTagConstructionFrame
StatementExpressionBodyConstruction
TemplateParameterSurfaceFrame
TypedOwnerTagConstruction
TypedStatementChildConstruction

Protected Type Aliases

Name
ConstructorPostTranslationKey
ContextualLocalTypeDeclarationKey
ContextualTypeTranslationKey
DefinitionFreeSemanticFunctionCompletionKey
ExactTemplateTypeArgumentLocMap
ExpressionPragmaOwner
LexicalPragmaOwner
PhysicalPragmaKey

Protected Enums

Name
DeclarationGroupRole
DeclarationLookupPurpose
OnDemandSourcePublicationState
ParameterCloneRole
TemplateParameterOwnership

Protected Member Functions

Name
GetSymbolFromSymbolTable
SgSymbol* GetSymbolFromSymbolTable(clang::NamedDecl* decl);
activeClassDefinitionOwnerForDeclaration
SgClassDefinition* activeClassDefinitionOwnerForDeclaration( clang::Decl* decl, char const* context) const;
activeClassDefinitionOwnerForRecord
SgClassDefinition* activeClassDefinitionOwnerForRecord( clang::RecordDecl* record, char const* context) const;
activeDeclStatementConstructionFor
DeclStatementConstruction const* activeDeclStatementConstructionFor(clang::Decl const* declaration) const;
activeDeclaratorOwnedTagIntroductionScope
SgScopeStatement* activeDeclaratorOwnedTagIntroductionScope(clang::TagDecl const* tag_decl) const;
activeExactDeclarationGroupIsSemantic
bool activeExactDeclarationGroupIsSemantic(clang::Decl* member) const;
activeExactSourceDeclarationGroupOwner
SgDeclarationGroupStatement* activeExactSourceDeclarationGroupOwner(clang::Decl* member) const;
activeExactSourceDeclarationGroupOwnsPublishedMember
bool activeExactSourceDeclarationGroupOwnsPublishedMember( clang::Decl* clang_member, SgDeclarationStatement* sage_member) const;
activeFunctionBodyOwnerForDeclaration
SgScopeStatement* activeFunctionBodyOwnerForDeclaration(clang::Decl* decl) const;
activePendingConditionDeclarationScopeFor
SgScopeStatement* activePendingConditionDeclarationScopeFor(clang::VarDecl const* declaration) const;
activeSourceDeclaratorTagScope
SgDeclarationScope* activeSourceDeclaratorTagScope(clang::TagDecl const* tag_decl) const;
activeSourceFunctionBodyDeclStmtOwnsDeclaration
bool activeSourceFunctionBodyDeclStmtOwnsDeclaration( clang::Decl* decl, SgScopeStatement* structural_scope) const;
activeTypedOwnerTagConstructionScope
SgScopeStatement* activeTypedOwnerTagConstructionScope(clang::TagDecl const* tag_decl) const;
activeTypedOwnerTagDefinition
SgDeclarationStatement* activeTypedOwnerTagDefinition(clang::TagDecl const* tag_decl) const;
activeTypedStatementChildConstructionFor
TypedStatementChildConstruction const* activeTypedStatementChildConstructionFor(clang::Stmt const* statement) const;
appendPragmasBefore
void appendPragmasBefore( clang::Stmt* stmt, SgScopeStatement* scope);
appendTemplateArguments
void appendTemplateArguments( SgTemplateArgumentPtrList& arg_list, clang::TemplateArgument const& arg, bool explicitlySpecified = false);
applyNamespaceSourceFragments
void applyNamespaceSourceFragments( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
attachCapturedPragmas
void attachCapturedPragmas( SgLocatedNode* owner, std::vector<CapturedPragma> const& pragmas, PreprocessingInfo::RelativePositionType position, char const* context);
attachConstraintSatisfaction
void attachConstraintSatisfaction( SgNode* node, ConstraintSatisfactionResult const& result);
attachSFINAEFailure
void attachSFINAEFailure( SgNode* node, SFINAEFailureResult const& result);
attachSymbolToExactScope
void attachSymbolToExactScope( SgSymbol* symbol, SgScopeStatement* scope);
beginTypedOwnerTagConstruction
void beginTypedOwnerTagConstruction( clang::TagDecl* tag_decl, SgScopeStatement* semantic_scope, char const* context);
bindClassRedeclarationSurface
void bindClassRedeclarationSurface( SgClassDeclaration* surface, SgClassDeclaration* canonical);
buildCapturedPragmaDeclaration
SgPragmaDeclaration* buildCapturedPragmaDeclaration( std::string const& directive, std::string const& source_directive, clang::FileID physical_file_id, unsigned int physical_line, std::string const& filename, unsigned int pragma_line, unsigned int pragma_column, unsigned int pragma_end_line, unsigned int pragma_end_column, SgScopeStatement* scope, bool has_top_level_macro_expansion, bool source_file_only_owner = false, std::optional<clang::SourceRange> attribute_range = std::nullopt);
buildConversionFunctionId
void buildConversionFunctionId( SgExpression* reference, clang::DeclarationNameInfo const& name, bool source_written = true);
buildCoroutineAwaitExpression
void buildCoroutineAwaitExpression( clang::Expr* operand, clang::QualType result_type, clang::SourceRange source_range, SgAwaitExpression::coroutine_keyword_kind_enum keyword, char const* operand_description, SgNode** node);
buildDeclaredFunctionExceptionSignature
SgFunctionType* buildDeclaredFunctionExceptionSignature( SgFunctionType* canonical_type, clang::FunctionProtoType const* type, clang::FunctionDecl const* owner, bool is_written, bool semantic);
buildDependentAliasUnderlyingType
SgType* buildDependentAliasUnderlyingType(clang::TemplateSpecializationType const* type);
buildExplicitTemplateIdTypeUseFromQualifiedType
SgType* buildExplicitTemplateIdTypeUseFromQualifiedType( clang::QualType const& qual_type, char const* context);
buildExplicitTemplateIdTypeUseFromTypeLoc
SgType* buildExplicitTemplateIdTypeUseFromTypeLoc( clang::TypeLoc const& type_loc, char const* context);
buildFunctionReference
SgFunctionRefExp* buildFunctionReference( SgFunctionSymbol* symbol, clang::QualType type, bool semantic);
buildFunctionTypeForClangProto
SgFunctionType* buildFunctionTypeForClangProto( SgType* return_type, std::unique_ptr<SgFunctionParameterTypeList> parameters, clang::FunctionProtoType const* type, SgType* class_type = nullptr, clang::FunctionProtoTypeLoc const* source = nullptr);
buildNonrealRefExpFromNestedNameSpecifier
SgNonrealRefExp* buildNonrealRefExpFromNestedNameSpecifier( clang::NestedNameSpecifier qualifier, SgScopeStatement* scope, SgName const& terminalName, bool terminalHasTemplateKeyword, SgTemplateArgumentPtrList const* terminalSemanticTemplateArgs, SgTemplateArgumentPtrList const* terminalReferenceTemplateArgs, SgDeclarationStatement* terminalDeclaration = nullptr);
buildNonrealScopeFromNestedNameSpecifier
SgScopeStatement* buildNonrealScopeFromNestedNameSpecifier( clang::NestedNameSpecifier qualifier, SgScopeStatement* scope);
buildNonrealTypeForNestedNameSpecifierType
SgNonrealType* buildNonrealTypeForNestedNameSpecifierType( clang::Type const* clang_type, SgScopeStatement* scope, bool prefer_current_scope = false, SgScopeStatement* template_use_scope = nullptr);
buildRecordTypePlaceholderDecl
SgClassDeclaration* buildRecordTypePlaceholderDecl(clang::RecordDecl* record_decl);
buildSemanticNonrealTypeFromNestedNameSpecifier
SgNonrealType* buildSemanticNonrealTypeFromNestedNameSpecifier( clang::NestedNameSpecifier qualifier, SgScopeStatement* scope, SgName const& terminalName, SgTemplateArgumentPtrList const* terminalTemplateArgs, SgDeclarationStatement* terminalDeclaration = nullptr, SgType* aliasedType = nullptr);
buildSemanticTemplateArguments
SgTemplateArgumentPtrList buildSemanticTemplateArguments( clang::TemplateArgumentListInfo const& arg_info, bool explicitlySpecified, char const* context);
buildSemanticTypeFromQualifiedType
SgType* buildSemanticTypeFromQualifiedType( clang::QualType const& qual_type, char const* context);
buildSymbolForDeclaration
SgSymbol* buildSymbolForDeclaration(SgDeclarationStatement* decl);
buildTemplateArguments
SgTemplateArgumentPtrList buildTemplateArguments( clang::TemplateArgumentListInfo const& arg_info, bool explicitlySpecified = false);
buildTemplateDeclarationValue
SgExpression* buildTemplateDeclarationValue( SgExpression* expression, SgType* parameter_type);
buildTemplateInstantiationCacheKey
ClangTemplateInstantiationCacheKey buildTemplateInstantiationCacheKey( clang::ClassTemplateDecl const* primary_template, clang::TemplateArgumentList const& args, clang::DeclContext const* semantic_owner);
buildTypeFromQualifiedType
SgType* buildTypeFromQualifiedType( clang::QualType const& qual_type, SgType* unqualified_type = nullptr);
buildTypeFromTypeLoc
SgType* buildTypeFromTypeLoc( clang::TypeLoc const& type_loc, SgType* member_function_class = nullptr);
buildTypeFromTypeLocImpl
SgType* buildTypeFromTypeLocImpl( clang::TypeLoc const& type_loc, SgType* member_function_class);
buildTypeFromTypeLocWithSemanticOwner
SgType* buildTypeFromTypeLocWithSemanticOwner( clang::TypeLoc const& type_loc, SgScopeStatement* semantic_owner_scope, char const* context);
buildUnqualifiedWrittenRecordMemberType
SgType* buildUnqualifiedWrittenRecordMemberType( clang::Type const* written_type, SgScopeStatement* scope);
cacheRecordTypePlaceholderDecl
void cacheRecordTypePlaceholderDecl( clang::RecordDecl* record_decl, SgClassDeclaration* decl);
cloneParameter
SgInitializedName* cloneParameter( SgInitializedName* source, clang::ParmVarDecl const* parameter, SgType* type, ParameterCloneRole role);
cloneTemplateArgumentSurfacePreservingIdentity
SgTemplateArgumentPtrList cloneTemplateArgumentSurfacePreservingIdentity(SgTemplateArgumentPtrList const& source) const;
collectOpenMPAttributePragmas
void collectOpenMPAttributePragmas( clang::Stmt* stmt, std::vector<CapturedPragma>& pragmas);
collectPragmas
bool collectPragmas( clang::Stmt* stmt, std::vector<CapturedPragma>& pragmas);
completeClassRedeclarationFamily
void completeClassRedeclarationFamily( SgClassDeclaration* canonical, SgClassDeclaration* defining);
completeExactSourceDeclarationGroupMember
SgDeclarationGroupStatement* completeExactSourceDeclarationGroupMember( clang::Decl* clang_member, SgDeclarationStatement* sage_member);
constructExpressionPragmas
void constructExpressionPragmas( clang::Expr const* source, SgExpression* expression);
constructFunctionParameterType
SgType* constructFunctionParameterType(FunctionParameterConstructionFrame& frame);
constructLexicalPragmas
void constructLexicalPragmas( LexicalPragmaOwner owner, SgScopeStatement* scope);
copyExpressionForFrontendReuse
SgExpression* copyExpressionForFrontendReuse(SgExpression* expr);
countExpandedTemplateArguments
size_t countExpandedTemplateArguments(clang::TemplateArgumentList const& args);
currentExactTemplateParameters
ClangTemplateParameterMap const* currentExactTemplateParameters() const;
currentMemberCallSpecializationContext
clang::ClassTemplateSpecializationDecl const* currentMemberCallSpecializationContext() const;
currentTemplateParameterConstructionScope
SgDeclarationScope* currentTemplateParameterConstructionScope() const;
currentTemplateParameterDeclContext
clang::DeclContext const* currentTemplateParameterDeclContext() const;
declaration_has_exact_auxiliary_ownership
bool declaration_has_exact_auxiliary_ownership(SgDeclarationStatement* declaration) const;
declaration_has_exact_lexical_source_ownership
bool declaration_has_exact_lexical_source_ownership(SgDeclarationStatement* declaration) const;
declaration_has_exact_source_surface_ownership
bool declaration_has_exact_source_surface_ownership(SgDeclarationStatement* declaration) const;
declarationsShareSourceDeclaration
bool declarationsShareSourceDeclaration( clang::Decl* previous, clang::Decl* current) const;
deleteTransientAST
void deleteTransientAST(std::unordered_set<SgNode*> const& roots);
ensureDeclInScopeChildList
void ensureDeclInScopeChildList( SgDeclarationStatement* decl, SgScopeStatement* scope, char const* context = "ClangToSageTranslator");
ensureNamespaceDeclaration
SgNamespaceDeclarationStatement* ensureNamespaceDeclaration(clang::NamespaceDecl* ns_decl);
evaluateConstraintSatisfaction
ConstraintSatisfactionResult evaluateConstraintSatisfaction( clang::NamedDecl const* constraint_owner, llvm::ArrayRef<clang::AssociatedConstraint> constraints, clang::NamedDecl const* instantiation, clang::SourceRange template_id_range);
evaluateSFINAEFailure
SFINAEFailureResult evaluateSFINAEFailure(clang::FunctionDecl const* function_decl);
exactClassDefinitionOwnerForFieldTranslation
SgClassDefinition* exactClassDefinitionOwnerForFieldTranslation( clang::ValueDecl* field, SgNode* translation, char const* context) const;
exactClassDefinitionOwnerForFunctionTranslation
SgClassDefinition* exactClassDefinitionOwnerForFunctionTranslation( clang::Decl* function, SgNode* translation, char const* context);
exactExpandedDeclaratorQualifier
SourceQualification exactExpandedDeclaratorQualifier( std::size_t declaration_begin_index, std::size_t name_index, char const* entity_kind, std::string const& entity_name, std::size_t* qualification_begin_index = nullptr);
exactTypeLocSourceElaborationKind
SgNonrealDecl::source_elaboration_kind_enum exactTypeLocSourceElaborationKind(clang::TypeLoc const& type_loc) const;
exactTypeLocSourceQualification
bool exactTypeLocSourceQualification( clang::TypeLoc const& type_loc, SgStringList& tokens, bool& global_qualification);
exact_direct_structural_successor_count
size_t exact_direct_structural_successor_count( SgNode* owner, SgNode* child) const;
extractUsingTargetFromNode
bool extractUsingTargetFromNode( SgNode* target_node, SgDeclarationStatement*& target_decl, SgInitializedName*& target_init);
extractUsingTargetFromSymbol
bool extractUsingTargetFromSymbol( SgSymbol* symbol, SgDeclarationStatement*& target_decl, SgInitializedName*& target_init);
finishTypedOwnerTagConstruction
SgDeclarationStatement* finishTypedOwnerTagConstruction( clang::TagDecl* tag_decl, char const* context);
getOrCreateTemplateInstantiation
SgTemplateInstantiationDecl* getOrCreateTemplateInstantiation( SgTemplateClassDeclaration* template_decl, clang::TemplateSpecializationType const* clang_type);
getTypeFromTranslatedRecordDecl
SgType* getTypeFromTranslatedRecordDecl(clang::RecordDecl* record_decl);
isHiddenSystemOrBuiltinDecl
bool isHiddenSystemOrBuiltinDecl(clang::Decl const* decl) const;
isTagEmbeddedInField
bool isTagEmbeddedInField( clang::TagDecl* tag_decl, clang::RecordDecl* parent_decl);
localDeclarationMatchesCurrentConstruction
bool localDeclarationMatchesCurrentConstruction( clang::Decl* decl, SgDeclarationStatement* declaration, SgScopeStatement* active_function, SgNode* construction_locus, char const* context) const;
lookupActiveFunctionBodyParameter
SgInitializedName* lookupActiveFunctionBodyParameter(clang::ParmVarDecl const* parameter);
lookupActiveRequiresExpressionParameter
SgInitializedName* lookupActiveRequiresExpressionParameter(clang::ParmVarDecl const* parameter);
lookupActiveSemanticTemplateParameterSurface
SgTemplateParameter* lookupActiveSemanticTemplateParameterSurface( clang::NamedDecl const* param_decl, char const* consumer);
lookupActiveTemplateParameterConstructionScope
SgDeclarationScope* lookupActiveTemplateParameterConstructionScope( clang::NamedDecl const* param_decl, char const* consumer);
lookupActiveTemplateParameterSurface
SgTemplateParameter* lookupActiveTemplateParameterSurface( clang::NamedDecl const* param_decl, char const* consumer, TemplateParameterSurfaceFrame const** matched_frame = nullptr);
lookupActiveTemplateParameterSurfaceOwner
SgDeclarationStatement* lookupActiveTemplateParameterSurfaceOwner( clang::NamedDecl const* param_decl, char const* consumer);
lookupCachedTranslationForTraverse
SgNode* lookupCachedTranslationForTraverse( clang::Decl* decl, bool* needs_translation);
lookupContextualLocalTypeDeclaration
SgDeclarationStatement* lookupContextualLocalTypeDeclaration( clang::NamedDecl* decl, SgScopeStatement* active_function, SgNode* construction_locus, char const* context) const;
lookupExactSgDeclarationForClangDecl
SgDeclarationStatement* lookupExactSgDeclarationForClangDecl( clang::Decl* key, bool allow_on_demand, DeclarationLookupPurpose purpose = DeclarationLookupPurpose::Ordinary);
lookupFunctionParameterFromOwner
SgInitializedName* lookupFunctionParameterFromOwner(clang::ParmVarDecl const* parameter);
lookupParameterFromExactOwner
SgInitializedName* lookupParameterFromExactOwner(clang::ParmVarDecl const* parameter);
lookupPublishedTemplateTypeParameterFamily
SgTemplateParameter* lookupPublishedTemplateTypeParameterFamily( clang::TemplateTypeParmDecl const* param_decl, char const* consumer, bool require_exact_owner);
lookupRecordTypePlaceholderDecl
SgClassDeclaration* lookupRecordTypePlaceholderDecl(clang::RecordDecl* record_decl) const;
lookupSgDeclarationForClangDecl
SgDeclarationStatement* lookupSgDeclarationForClangDecl( clang::Decl* key, bool allow_on_demand);
lookupUsingDeclTargetNode
SgNode* lookupUsingDeclTargetNode(clang::Decl* decl);
namespaceSourceRanges
NamespaceSourceRanges namespaceSourceRanges(clang::NamespaceDecl const* namespace_decl) const;
planLexicalPragmas
void planLexicalPragmas(clang::TranslationUnitDecl* translation_unit);
populateClassDefinition
void populateClassDefinition( clang::RecordDecl* record_decl, SgClassDefinition* class_def);
pragmaFileHasLexicalOwner
bool pragmaFileHasLexicalOwner(clang::FileID file_id) const;
prepareExactSourceDeclarationGroup
SgDeclarationGroupStatement* prepareExactSourceDeclarationGroup( clang::Decl* first_member, SgScopeStatement* lexical_scope);
prepareExpressionForAttachment
SgExpression* prepareExpressionForAttachment(SgExpression* expr);
prepareFunctionDeclarationExceptionOwnership
SageBuilder::function_declaration_ownership prepareFunctionDeclarationExceptionOwnership( SageBuilder::function_declaration_ownership ownership, clang::FunctionDecl const* declaration, SgFunctionType* canonical_type, bool is_written, bool semantic = false);
prepareFunctionExceptionSpecification
FunctionExceptionSpecification prepareFunctionExceptionSpecification( clang::FunctionProtoType const* type, clang::FunctionDecl const* owner, bool is_written, bool semantic);
prepareOpenMPAttributePragmas
void prepareOpenMPAttributePragmas();
preserveExplicitFunctionReturnTypeQualifier
void preserveExplicitFunctionReturnTypeQualifier( SgFunctionDeclaration* function, clang::TypeLoc return_type_loc);
pruneSymbolsForConstraints
void pruneSymbolsForConstraints(SgDeclarationStatement* decl);
publishClangSynthesizedNamespaceProvenance
void publishClangSynthesizedNamespaceProvenance( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
publishContextualLocalTypeDeclaration
void publishContextualLocalTypeDeclaration( clang::NamedDecl* decl, SgScopeStatement* active_function, SgDeclarationStatement* declaration, SgNode* construction_locus, char const* context);
publishExactEffectiveDeclarationAccess
void publishExactEffectiveDeclarationAccess( clang::Decl* clang_decl, SgDeclarationStatement* sage_decl, char const* producer);
publishFrontendSupportNamespaceProvenance
void publishFrontendSupportNamespaceProvenance( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
publishHiddenFriendCallable
SgFunctionDeclaration* publishHiddenFriendCallable( clang::FunctionDecl* clang_decl, SgFunctionDeclaration* surface_decl);
publishImportedNamespaceProvenance
void publishImportedNamespaceProvenance( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
publishSourceSpelledOuterClassTemplateHeaders
void publishSourceSpelledOuterClassTemplateHeaders( clang::CXXRecordDecl* record_decl, SgClassDeclaration* source_declaration, unsigned int outer_header_count, char const* consumer);
publishTemplateParameterList
void publishTemplateParameterList( clang::TemplateParameterList* param_list, SgTemplateParameterPtrList& parameters, SgDeclarationStatement* owning_template);
publishTypedOwnerTagDefinition
void publishTypedOwnerTagDefinition( clang::TagDecl* tag_decl, SgDeclarationStatement* defining_declaration);
queuePendingImplicitClassTemplateSpecialization
void queuePendingImplicitClassTemplateSpecialization( clang::ClassTemplateSpecializationDecl* spec, bool allow_hidden_system = false);
queueWrittenTypedefDependenciesForOutputSurface
void queueWrittenTypedefDependenciesForOutputSurface( clang::TypeLoc written_type_loc, SgType* sage_type, SgNode* output_surface_anchor, std::string const& surface_kind, std::string const& surface_name);
registerDeclarationSymbol
void registerDeclarationSymbol(SgDeclarationStatement* decl);
requireDetachedSourceExpressionProvenance
void requireDetachedSourceExpressionProvenance( SgExpression* expression, char const* context) const;
requireExactTemplateDeclaration
SgTemplateClassDeclaration* requireExactTemplateDeclaration(clang::TemplateSpecializationType const* clang_type);
requireExactVariableDeclaratorSurface
SgVariableDeclaration* requireExactVariableDeclaratorSurface( clang::Decl* clang_decl, SgNode* sage_node, char const* context) const;
requireMemberFunctionScope
void requireMemberFunctionScope( SgFunctionDeclaration* decl, SgClassDefinition* parent_def);
requirePublishedTemplateParameter
SgTemplateParameter* requirePublishedTemplateParameter( clang::NamedDecl* param_decl, SgDeclarationStatement* owning_template, char const* consumer);
requireSelectedFunctionDeclaration
SgFunctionDeclaration* requireSelectedFunctionDeclaration(clang::FunctionDecl* selected);
requireSymbolInExactScope
void requireSymbolInExactScope( SgSymbol* symbol, SgScopeStatement* scope, char const* context);
resolveActiveTemplateTypeParameterSourceCounterpart
clang::TemplateTypeParmDecl* resolveActiveTemplateTypeParameterSourceCounterpart( clang::TemplateTypeParmDecl const* semantic_parameter, char const* consumer);
resolveActiveTemplateTypeParameterSurface
clang::TemplateTypeParmDecl* resolveActiveTemplateTypeParameterSurface( unsigned int depth, unsigned int index, char const* consumer);
resolveCanonicalNonTypeTemplateParameterUse
clang::NonTypeTemplateParmDecl* resolveCanonicalNonTypeTemplateParameterUse(clang::NonTypeTemplateParmDecl* parameter);
resolveExactTemplateTypeParameterDeclaration
clang::TemplateTypeParmDecl const* resolveExactTemplateTypeParameterDeclaration( unsigned int depth, unsigned int index) const;
resolveExplicitInstantiationSourceScope
SgScopeStatement* resolveExplicitInstantiationSourceScope( clang::SourceLocation point_of_instantiation, char const* entity_kind, std::string const& entity_name);
resolveNonrealTemplateDeclarationTarget
SgDeclarationStatement* resolveNonrealTemplateDeclarationTarget( clang::Decl* template_decl, char const* context);
resolvePublishedTemplateParameterList
SgTemplateParameterPtrList const* resolvePublishedTemplateParameterList( clang::TemplateParameterList* source_parameters, char const* consumer);
resolveScopeFromDeclContext
SgScopeStatement* resolveScopeFromDeclContext(clang::DeclContext* context);
resolveTemplateParameterOwner
SgDeclarationStatement* resolveTemplateParameterOwner( clang::NamedDecl* param_decl, bool allow_on_demand);
resolveUsingDeclTargetNode
SgNode* resolveUsingDeclTargetNode(clang::Decl* decl);
retireUnusedFunctionParameterList
void retireUnusedFunctionParameterList( SgFunctionDeclaration* declaration, SgFunctionParameterList* candidate);
scopeIsWithinNamespaceChain
bool scopeIsWithinNamespaceChain( SgScopeStatement* scope, clang::DeclContext* context) const;
scopeReachableFromCurrentFile
bool scopeReachableFromCurrentFile(SgScopeStatement* scope);
shouldQueueImplicitClassTemplateSpecialization
bool shouldQueueImplicitClassTemplateSpecialization( clang::ClassTemplateSpecializationDecl* spec, bool allow_hidden_system) const;
shouldSkipSymbolForConstraints
bool shouldSkipSymbolForConstraints(SgDeclarationStatement const* decl) const;
statementConstructionOwner
SgNode* statementConstructionOwner( clang::Stmt const* statement, char const* context) const;
tagDefinitionWrittenInTypedDeclContextOwner
bool tagDefinitionWrittenInTypedDeclContextOwner(clang::TagDecl* tag_decl);
tagIsSemanticTemplateInstantiation
bool tagIsSemanticTemplateInstantiation(clang::TagDecl const* tag_decl) const;
translateClassTemplateDecl
SgTemplateClassDeclaration* translateClassTemplateDecl( clang::ClassTemplateDecl* class_template_decl, SgScopeStatement* override_semantic_scope, SgScopeStatement* override_lexical_parent, clang::Decl const* source_decl_for_matching = nullptr, SgTemplateClassDeclaration* canonical_friend_owner = nullptr);
translateConstraintExpression
SgExpression* translateConstraintExpression(clang::Expr const* expr);
translateControlledSubstatement
SgStatement* translateControlledSubstatement( clang::Stmt* stmt, SgScopeStatement* typed_owner, char const* context);
translateDetachedTemplateParameterList
std::unique_ptr<SgTemplateParameterPtrList> translateDetachedTemplateParameterList( clang::TemplateParameterList* param_list, SgScopeStatement* semantic_scope, SgTemplateParameterPtrList const* semantic_parameters = nullptr, char const* source_consumer = nullptr, SgDeclarationScope* construction_scope = nullptr, TemplateParameterOwnership construction_ownership = TemplateParameterOwnership::detached, bool include_defaults = true);
translateFunctionDeclCommon
bool translateFunctionDeclCommon( clang::FunctionDecl* function_decl, clang::FunctionTemplateDecl* template_decl, SgNode** node);
translateSemanticExpressionSubtree
SgExpression* translateSemanticExpressionSubtree( clang::Expr const* expr, char const* context);
translateStatement
SgStatement* translateStatement( clang::Stmt* stmt, char const* context, bool expression_owns_terminator = true);
translateTemplateArgument
SgTemplateArgument* translateTemplateArgument( clang::TemplateArgumentLoc const& arg_loc, bool explicitlySpecified = false);
translateTemplateParameterImpl
SgTemplateParameter* translateTemplateParameterImpl( clang::NamedDecl* param_decl, SgDeclarationStatement* owning_template, unsigned int position, TemplateParameterOwnership ownership, SgScopeStatement* detached_semantic_scope, SgTemplateParameter* semantic_parameter, SgTemplateParameterPtrList* construction_parameters, bool include_defaults = true);
translateTemplateParameterList
std::unique_ptr<SgTemplateParameterPtrList> translateTemplateParameterList( clang::TemplateParameterList* param_list, SgDeclarationStatement* owning_template, TemplateParameterOwnership ownership = TemplateParameterOwnership::attached);
translateTypeTemplateArgument
SgType* translateTypeTemplateArgument( clang::TemplateArgumentLoc const& arg, SgScopeStatement* semantic_owner_scope);
translateTypedStatementChild
SgStatement* translateTypedStatementChild( clang::Stmt* stmt, SgStatement* typed_owner, char const* context);
validateClangSynthesizedNamespaceProvenance
void validateClangSynthesizedNamespaceProvenance( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
validateFrontendSupportNamespaceProvenance
void validateFrontendSupportNamespaceProvenance( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
validateImportedNamespaceProvenance
void validateImportedNamespaceProvenance( clang::NamespaceDecl const* clang_declaration, SgNamespaceDeclarationStatement* sage_declaration);
validateQueuedWrittenTypedefDependenciesForOutputSurfaces
void validateQueuedWrittenTypedefDependenciesForOutputSurfaces();
validateWrittenTypedefDependenciesForOutputSurface
void validateWrittenTypedefDependenciesForOutputSurface( clang::TypeLoc written_type_loc, SgType* sage_type, SgNode* output_surface_anchor, std::string const& surface_kind, std::string const& surface_name);
validate_exact_auxiliary_owner
SgScopeStatement* validate_exact_auxiliary_owner( SgDeclarationStatement* declaration, char const* operation) const;
wrapStatementWithPragmas
SgStatement* wrapStatementWithPragmas( clang::Stmt* stmt, SgStatement* statement);

Protected Data Members

Name
language
p_active_function_body_completions
p_active_parser
p_anonymous_declaration_ids
p_array_init_binding_stack
p_binding_storage_constructions
p_canonical_generated_literal_depth
p_canonical_template_argument_context
p_clang_statement_traversal_stack
p_class_definition_population_stack
p_class_redeclaration_surfaces
p_compiler_instance
p_completed_constructor_post_translations
p_completed_definition_free_semantic_functions
p_consumed_pragma_lines
p_contextual_local_type_declaration_map
p_contextual_type_translation_map
p_decl_attachment_session
p_decl_context_map
p_decl_context_tag_owners
p_decl_statement_constructions
p_decl_translation_in_progress
p_decl_translation_map
p_decl_translation_on_demand
p_declarations_with_finalized_provenance
p_declarator_owned_tag_introduction_construction_stack
p_defer_on_demand_cxx_record_population_depth
p_defer_parameter_default_argument_depth
p_deferred_explicit_class_instantiation_publications
p_exact_literal_operand_spellings
p_exact_qualified_namespace_source_declarations
p_exact_template_parameter_stack
p_exact_template_type_argument_loc_stack
p_expanded_token_order_by_equivalent_location
p_expanded_token_order_by_raw_location
p_expanded_tokens
p_explicit_global_friend_decls
p_explicit_template_id_type_loc_use_depth
p_explicit_template_id_type_use_depth
p_field_initializer_constructions
p_force_written_named_type_qualification_depth
p_force_written_template_specialization_depth
p_function_body_map
p_function_body_translation_owner_stack
p_function_exception_construction
p_function_parameter_construction_stack
p_function_type_parameter_construction_stack
p_global_scope
p_hidden_friend_callable_decl_map
p_hidden_friend_function_decl_map
p_imported_external_semantic_traversal_stack
p_in_for_init_translation
p_inline_tag_decls
p_lambda_call_operator_definition_transactions
p_lambda_capture_declaration_map
p_lambda_closure_construction_output_owners
p_lambda_init_capture_owner_stack
p_lexical_pragmas
p_lexical_source_nodes
p_member_call_specialization_context_stack
p_namespace_canonical_decl_map
p_namespace_decl_contexts_traversed
p_on_demand_declaration_from_semantic_function_body_traversal_depth
p_on_demand_source_publication_state
p_openmp_attribute_pragmas
p_openmp_pragma_callback
p_pending_condition_declaration_scope_stack
p_pending_function_body_completions
p_pending_function_body_completions_set
p_pending_function_body_scopes
p_pending_implicit_class_template_specializations
p_pending_implicit_class_template_specializations_set
p_pending_written_typedef_validations
p_post_translation_template_parameter_surfaces
p_preserve_current_class_qualifier_depth
p_pseudo_object_construction_frames
p_qualified_type_translation_map
p_rebuild_translation_cache_depth
p_receiver_member_resolution_cache
p_reconstructed_template_argument_surface_depth
p_record_decl_type_map
p_record_definitions_populated
p_record_field_tag_owners
p_record_member_access_indices
p_record_type_placeholder_decl_map
p_requires_parameter_construction_stack
p_resolved_reference_current_semantic_argument_kind
p_resolved_reference_semantic_argument_cursor
p_resolved_reference_semantic_argument_kinds
p_resolved_reference_written_argument_owner
p_sage_preprocessor_recorder
p_sage_source_file
p_semantic_auxiliary_physical_source_range_nodes
p_semantic_auxiliary_source_nodes
p_semantic_container_child_stack
p_semantic_expression_subtree_depth
p_semantic_function_body_traversal_depth
p_semantic_range_declaration_shell_nodes
p_semantic_range_for_declaration_shell_stack
p_semantic_template_argument_expression_depth
p_source_declaration_group_constructions
p_source_declarator_tag_construction_stack
p_statement_expression_body_construction_stack
p_stmt_translation_map
p_synthesized_callee_expressions
p_synthesized_source_nodes
p_template_inst_cache
p_template_parameter_decl_context_stack
p_template_parameter_owner_index
p_template_parameter_owner_index_built
p_template_parameter_surface_stack
p_type_loc_semantic_owner_scope_stack
p_type_translation_map
p_typed_owner_tag_construction_stack
p_typed_statement_child_constructions
p_user_defined_literal_semantic_call_depth
p_user_defined_literal_semantic_expression_depth

Created with MrDocs