From 06ddf85b4f0cc06dfb1fc03046239b23c6ba6d2c Mon Sep 17 00:00:00 2001 From: Joao Matos Date: Thu, 21 Feb 2019 23:03:15 +0000 Subject: [PATCH] Added managed AST conversion code for statements and expressions. --- src/AST/Function.cs | 1 + src/AST/SourceLocation.cs | 4 + src/Parser/ASTConverter.Expr.cs | 2925 +++++++++++++++++++++++++++++++ src/Parser/ASTConverter.Stmt.cs | 1098 ++++++++++++ src/Parser/ASTConverter.cs | 68 +- 5 files changed, 4094 insertions(+), 2 deletions(-) create mode 100644 src/Parser/ASTConverter.Expr.cs create mode 100644 src/Parser/ASTConverter.Stmt.cs diff --git a/src/AST/Function.cs b/src/AST/Function.cs index 66f97858..5ba7d562 100644 --- a/src/AST/Function.cs +++ b/src/AST/Function.cs @@ -250,6 +250,7 @@ namespace CppSharp.AST public string Mangled { get; set; } public string Signature { get; set; } public string Body { get; set; } + public Stmt BodyStmt { get; set; } public override T Visit(IDeclVisitor visitor) { diff --git a/src/AST/SourceLocation.cs b/src/AST/SourceLocation.cs index 7d663ff6..62673d62 100644 --- a/src/AST/SourceLocation.cs +++ b/src/AST/SourceLocation.cs @@ -87,4 +87,8 @@ return IsMacroID ? "Macro ID: " + ID : "File ID: " + Offset; } } + + public struct SourceRange + { + } } diff --git a/src/Parser/ASTConverter.Expr.cs b/src/Parser/ASTConverter.Expr.cs new file mode 100644 index 00000000..150a17c3 --- /dev/null +++ b/src/Parser/ASTConverter.Expr.cs @@ -0,0 +1,2925 @@ +// ---------------------------------------------------------------------------- +// +// This is autogenerated code by CppSharp. +// Do not edit this file or all your changes will be lost after re-generation. +// +// ---------------------------------------------------------------------------- + +using CppSharp.Parser.AST; +using static CppSharp.ConversionUtils; + +namespace CppSharp +{ + // + // Implements the visitor pattern for the generated expr bindings. + // + public abstract class ExprVisitor where TRet : class + { + public abstract TRet VisitConstantExpr(ConstantExpr expr); + public abstract TRet VisitOpaqueValueExpr(OpaqueValueExpr expr); + public abstract TRet VisitDeclRefExpr(DeclRefExpr expr); + public abstract TRet VisitIntegerLiteral(IntegerLiteral expr); + public abstract TRet VisitFixedPointLiteral(FixedPointLiteral expr); + public abstract TRet VisitCharacterLiteral(CharacterLiteral expr); + public abstract TRet VisitFloatingLiteral(FloatingLiteral expr); + public abstract TRet VisitImaginaryLiteral(ImaginaryLiteral expr); + public abstract TRet VisitStringLiteral(StringLiteral expr); + public abstract TRet VisitPredefinedExpr(PredefinedExpr expr); + public abstract TRet VisitParenExpr(ParenExpr expr); + public abstract TRet VisitUnaryOperator(UnaryOperator expr); + public abstract TRet VisitOffsetOfExpr(OffsetOfExpr expr); + public abstract TRet VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr expr); + public abstract TRet VisitArraySubscriptExpr(ArraySubscriptExpr expr); + public abstract TRet VisitCallExpr(CallExpr expr); + public abstract TRet VisitMemberExpr(MemberExpr expr); + public abstract TRet VisitCompoundLiteralExpr(CompoundLiteralExpr expr); + public abstract TRet VisitImplicitCastExpr(ImplicitCastExpr expr); + public abstract TRet VisitCStyleCastExpr(CStyleCastExpr expr); + public abstract TRet VisitBinaryOperator(BinaryOperator expr); + public abstract TRet VisitCompoundAssignOperator(CompoundAssignOperator expr); + public abstract TRet VisitConditionalOperator(ConditionalOperator expr); + public abstract TRet VisitBinaryConditionalOperator(BinaryConditionalOperator expr); + public abstract TRet VisitAddrLabelExpr(AddrLabelExpr expr); + public abstract TRet VisitStmtExpr(StmtExpr expr); + public abstract TRet VisitShuffleVectorExpr(ShuffleVectorExpr expr); + public abstract TRet VisitConvertVectorExpr(ConvertVectorExpr expr); + public abstract TRet VisitChooseExpr(ChooseExpr expr); + public abstract TRet VisitGNUNullExpr(GNUNullExpr expr); + public abstract TRet VisitVAArgExpr(VAArgExpr expr); + public abstract TRet VisitInitListExpr(InitListExpr expr); + public abstract TRet VisitDesignatedInitExpr(DesignatedInitExpr expr); + public abstract TRet VisitNoInitExpr(NoInitExpr expr); + public abstract TRet VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr expr); + public abstract TRet VisitArrayInitLoopExpr(ArrayInitLoopExpr expr); + public abstract TRet VisitArrayInitIndexExpr(ArrayInitIndexExpr expr); + public abstract TRet VisitImplicitValueInitExpr(ImplicitValueInitExpr expr); + public abstract TRet VisitParenListExpr(ParenListExpr expr); + public abstract TRet VisitGenericSelectionExpr(GenericSelectionExpr expr); + public abstract TRet VisitExtVectorElementExpr(ExtVectorElementExpr expr); + public abstract TRet VisitBlockExpr(BlockExpr expr); + public abstract TRet VisitAsTypeExpr(AsTypeExpr expr); + public abstract TRet VisitPseudoObjectExpr(PseudoObjectExpr expr); + public abstract TRet VisitAtomicExpr(AtomicExpr expr); + public abstract TRet VisitTypoExpr(TypoExpr expr); + public abstract TRet VisitCXXOperatorCallExpr(CXXOperatorCallExpr expr); + public abstract TRet VisitCXXMemberCallExpr(CXXMemberCallExpr expr); + public abstract TRet VisitCUDAKernelCallExpr(CUDAKernelCallExpr expr); + public abstract TRet VisitCXXStaticCastExpr(CXXStaticCastExpr expr); + public abstract TRet VisitCXXDynamicCastExpr(CXXDynamicCastExpr expr); + public abstract TRet VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr expr); + public abstract TRet VisitCXXConstCastExpr(CXXConstCastExpr expr); + public abstract TRet VisitUserDefinedLiteral(UserDefinedLiteral expr); + public abstract TRet VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr expr); + public abstract TRet VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr expr); + public abstract TRet VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr expr); + public abstract TRet VisitCXXTypeidExpr(CXXTypeidExpr expr); + public abstract TRet VisitMSPropertyRefExpr(MSPropertyRefExpr expr); + public abstract TRet VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr expr); + public abstract TRet VisitCXXUuidofExpr(CXXUuidofExpr expr); + public abstract TRet VisitCXXThisExpr(CXXThisExpr expr); + public abstract TRet VisitCXXThrowExpr(CXXThrowExpr expr); + public abstract TRet VisitCXXDefaultArgExpr(CXXDefaultArgExpr expr); + public abstract TRet VisitCXXDefaultInitExpr(CXXDefaultInitExpr expr); + public abstract TRet VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr expr); + public abstract TRet VisitCXXConstructExpr(CXXConstructExpr expr); + public abstract TRet VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr expr); + public abstract TRet VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr expr); + public abstract TRet VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr expr); + public abstract TRet VisitLambdaExpr(LambdaExpr expr); + public abstract TRet VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr expr); + public abstract TRet VisitCXXNewExpr(CXXNewExpr expr); + public abstract TRet VisitCXXDeleteExpr(CXXDeleteExpr expr); + public abstract TRet VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr expr); + public abstract TRet VisitTypeTraitExpr(TypeTraitExpr expr); + public abstract TRet VisitArrayTypeTraitExpr(ArrayTypeTraitExpr expr); + public abstract TRet VisitExpressionTraitExpr(ExpressionTraitExpr expr); + public abstract TRet VisitUnresolvedLookupExpr(UnresolvedLookupExpr expr); + public abstract TRet VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr expr); + public abstract TRet VisitExprWithCleanups(ExprWithCleanups expr); + public abstract TRet VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr expr); + public abstract TRet VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr expr); + public abstract TRet VisitUnresolvedMemberExpr(UnresolvedMemberExpr expr); + public abstract TRet VisitCXXNoexceptExpr(CXXNoexceptExpr expr); + public abstract TRet VisitPackExpansionExpr(PackExpansionExpr expr); + public abstract TRet VisitSizeOfPackExpr(SizeOfPackExpr expr); + public abstract TRet VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr expr); + public abstract TRet VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr expr); + public abstract TRet VisitFunctionParmPackExpr(FunctionParmPackExpr expr); + public abstract TRet VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr expr); + public abstract TRet VisitCXXFoldExpr(CXXFoldExpr expr); + public abstract TRet VisitCoawaitExpr(CoawaitExpr expr); + public abstract TRet VisitDependentCoawaitExpr(DependentCoawaitExpr expr); + public abstract TRet VisitCoyieldExpr(CoyieldExpr expr); + + public virtual TRet Visit(Parser.AST.Expr expr) + { + if (expr == null) + return default(TRet); + + switch(expr.StmtClass) + { + case StmtClass.ConstantExpr: + { + var _expr = ConstantExpr.__CreateInstance(expr.__Instance); + return VisitConstantExpr(_expr); + } + case StmtClass.OpaqueValueExpr: + { + var _expr = OpaqueValueExpr.__CreateInstance(expr.__Instance); + return VisitOpaqueValueExpr(_expr); + } + case StmtClass.DeclRefExpr: + { + var _expr = DeclRefExpr.__CreateInstance(expr.__Instance); + return VisitDeclRefExpr(_expr); + } + case StmtClass.IntegerLiteral: + { + var _expr = IntegerLiteral.__CreateInstance(expr.__Instance); + return VisitIntegerLiteral(_expr); + } + case StmtClass.FixedPointLiteral: + { + var _expr = FixedPointLiteral.__CreateInstance(expr.__Instance); + return VisitFixedPointLiteral(_expr); + } + case StmtClass.CharacterLiteral: + { + var _expr = CharacterLiteral.__CreateInstance(expr.__Instance); + return VisitCharacterLiteral(_expr); + } + case StmtClass.FloatingLiteral: + { + var _expr = FloatingLiteral.__CreateInstance(expr.__Instance); + return VisitFloatingLiteral(_expr); + } + case StmtClass.ImaginaryLiteral: + { + var _expr = ImaginaryLiteral.__CreateInstance(expr.__Instance); + return VisitImaginaryLiteral(_expr); + } + case StmtClass.StringLiteral: + { + var _expr = StringLiteral.__CreateInstance(expr.__Instance); + return VisitStringLiteral(_expr); + } + case StmtClass.PredefinedExpr: + { + var _expr = PredefinedExpr.__CreateInstance(expr.__Instance); + return VisitPredefinedExpr(_expr); + } + case StmtClass.ParenExpr: + { + var _expr = ParenExpr.__CreateInstance(expr.__Instance); + return VisitParenExpr(_expr); + } + case StmtClass.UnaryOperator: + { + var _expr = UnaryOperator.__CreateInstance(expr.__Instance); + return VisitUnaryOperator(_expr); + } + case StmtClass.OffsetOfExpr: + { + var _expr = OffsetOfExpr.__CreateInstance(expr.__Instance); + return VisitOffsetOfExpr(_expr); + } + case StmtClass.UnaryExprOrTypeTraitExpr: + { + var _expr = UnaryExprOrTypeTraitExpr.__CreateInstance(expr.__Instance); + return VisitUnaryExprOrTypeTraitExpr(_expr); + } + case StmtClass.ArraySubscriptExpr: + { + var _expr = ArraySubscriptExpr.__CreateInstance(expr.__Instance); + return VisitArraySubscriptExpr(_expr); + } + case StmtClass.CallExpr: + { + var _expr = CallExpr.__CreateInstance(expr.__Instance); + return VisitCallExpr(_expr); + } + case StmtClass.MemberExpr: + { + var _expr = MemberExpr.__CreateInstance(expr.__Instance); + return VisitMemberExpr(_expr); + } + case StmtClass.CompoundLiteralExpr: + { + var _expr = CompoundLiteralExpr.__CreateInstance(expr.__Instance); + return VisitCompoundLiteralExpr(_expr); + } + case StmtClass.ImplicitCastExpr: + { + var _expr = ImplicitCastExpr.__CreateInstance(expr.__Instance); + return VisitImplicitCastExpr(_expr); + } + case StmtClass.CStyleCastExpr: + { + var _expr = CStyleCastExpr.__CreateInstance(expr.__Instance); + return VisitCStyleCastExpr(_expr); + } + case StmtClass.BinaryOperator: + { + var _expr = BinaryOperator.__CreateInstance(expr.__Instance); + return VisitBinaryOperator(_expr); + } + case StmtClass.CompoundAssignOperator: + { + var _expr = CompoundAssignOperator.__CreateInstance(expr.__Instance); + return VisitCompoundAssignOperator(_expr); + } + case StmtClass.ConditionalOperator: + { + var _expr = ConditionalOperator.__CreateInstance(expr.__Instance); + return VisitConditionalOperator(_expr); + } + case StmtClass.BinaryConditionalOperator: + { + var _expr = BinaryConditionalOperator.__CreateInstance(expr.__Instance); + return VisitBinaryConditionalOperator(_expr); + } + case StmtClass.AddrLabelExpr: + { + var _expr = AddrLabelExpr.__CreateInstance(expr.__Instance); + return VisitAddrLabelExpr(_expr); + } + case StmtClass.StmtExpr: + { + var _expr = StmtExpr.__CreateInstance(expr.__Instance); + return VisitStmtExpr(_expr); + } + case StmtClass.ShuffleVectorExpr: + { + var _expr = ShuffleVectorExpr.__CreateInstance(expr.__Instance); + return VisitShuffleVectorExpr(_expr); + } + case StmtClass.ConvertVectorExpr: + { + var _expr = ConvertVectorExpr.__CreateInstance(expr.__Instance); + return VisitConvertVectorExpr(_expr); + } + case StmtClass.ChooseExpr: + { + var _expr = ChooseExpr.__CreateInstance(expr.__Instance); + return VisitChooseExpr(_expr); + } + case StmtClass.GNUNullExpr: + { + var _expr = GNUNullExpr.__CreateInstance(expr.__Instance); + return VisitGNUNullExpr(_expr); + } + case StmtClass.VAArgExpr: + { + var _expr = VAArgExpr.__CreateInstance(expr.__Instance); + return VisitVAArgExpr(_expr); + } + case StmtClass.InitListExpr: + { + var _expr = InitListExpr.__CreateInstance(expr.__Instance); + return VisitInitListExpr(_expr); + } + case StmtClass.DesignatedInitExpr: + { + var _expr = DesignatedInitExpr.__CreateInstance(expr.__Instance); + return VisitDesignatedInitExpr(_expr); + } + case StmtClass.NoInitExpr: + { + var _expr = NoInitExpr.__CreateInstance(expr.__Instance); + return VisitNoInitExpr(_expr); + } + case StmtClass.DesignatedInitUpdateExpr: + { + var _expr = DesignatedInitUpdateExpr.__CreateInstance(expr.__Instance); + return VisitDesignatedInitUpdateExpr(_expr); + } + case StmtClass.ArrayInitLoopExpr: + { + var _expr = ArrayInitLoopExpr.__CreateInstance(expr.__Instance); + return VisitArrayInitLoopExpr(_expr); + } + case StmtClass.ArrayInitIndexExpr: + { + var _expr = ArrayInitIndexExpr.__CreateInstance(expr.__Instance); + return VisitArrayInitIndexExpr(_expr); + } + case StmtClass.ImplicitValueInitExpr: + { + var _expr = ImplicitValueInitExpr.__CreateInstance(expr.__Instance); + return VisitImplicitValueInitExpr(_expr); + } + case StmtClass.ParenListExpr: + { + var _expr = ParenListExpr.__CreateInstance(expr.__Instance); + return VisitParenListExpr(_expr); + } + case StmtClass.GenericSelectionExpr: + { + var _expr = GenericSelectionExpr.__CreateInstance(expr.__Instance); + return VisitGenericSelectionExpr(_expr); + } + case StmtClass.ExtVectorElementExpr: + { + var _expr = ExtVectorElementExpr.__CreateInstance(expr.__Instance); + return VisitExtVectorElementExpr(_expr); + } + case StmtClass.BlockExpr: + { + var _expr = BlockExpr.__CreateInstance(expr.__Instance); + return VisitBlockExpr(_expr); + } + case StmtClass.AsTypeExpr: + { + var _expr = AsTypeExpr.__CreateInstance(expr.__Instance); + return VisitAsTypeExpr(_expr); + } + case StmtClass.PseudoObjectExpr: + { + var _expr = PseudoObjectExpr.__CreateInstance(expr.__Instance); + return VisitPseudoObjectExpr(_expr); + } + case StmtClass.AtomicExpr: + { + var _expr = AtomicExpr.__CreateInstance(expr.__Instance); + return VisitAtomicExpr(_expr); + } + case StmtClass.TypoExpr: + { + var _expr = TypoExpr.__CreateInstance(expr.__Instance); + return VisitTypoExpr(_expr); + } + case StmtClass.CXXOperatorCallExpr: + { + var _expr = CXXOperatorCallExpr.__CreateInstance(expr.__Instance); + return VisitCXXOperatorCallExpr(_expr); + } + case StmtClass.CXXMemberCallExpr: + { + var _expr = CXXMemberCallExpr.__CreateInstance(expr.__Instance); + return VisitCXXMemberCallExpr(_expr); + } + case StmtClass.CUDAKernelCallExpr: + { + var _expr = CUDAKernelCallExpr.__CreateInstance(expr.__Instance); + return VisitCUDAKernelCallExpr(_expr); + } + case StmtClass.CXXStaticCastExpr: + { + var _expr = CXXStaticCastExpr.__CreateInstance(expr.__Instance); + return VisitCXXStaticCastExpr(_expr); + } + case StmtClass.CXXDynamicCastExpr: + { + var _expr = CXXDynamicCastExpr.__CreateInstance(expr.__Instance); + return VisitCXXDynamicCastExpr(_expr); + } + case StmtClass.CXXReinterpretCastExpr: + { + var _expr = CXXReinterpretCastExpr.__CreateInstance(expr.__Instance); + return VisitCXXReinterpretCastExpr(_expr); + } + case StmtClass.CXXConstCastExpr: + { + var _expr = CXXConstCastExpr.__CreateInstance(expr.__Instance); + return VisitCXXConstCastExpr(_expr); + } + case StmtClass.UserDefinedLiteral: + { + var _expr = UserDefinedLiteral.__CreateInstance(expr.__Instance); + return VisitUserDefinedLiteral(_expr); + } + case StmtClass.CXXBoolLiteralExpr: + { + var _expr = CXXBoolLiteralExpr.__CreateInstance(expr.__Instance); + return VisitCXXBoolLiteralExpr(_expr); + } + case StmtClass.CXXNullPtrLiteralExpr: + { + var _expr = CXXNullPtrLiteralExpr.__CreateInstance(expr.__Instance); + return VisitCXXNullPtrLiteralExpr(_expr); + } + case StmtClass.CXXStdInitializerListExpr: + { + var _expr = CXXStdInitializerListExpr.__CreateInstance(expr.__Instance); + return VisitCXXStdInitializerListExpr(_expr); + } + case StmtClass.CXXTypeidExpr: + { + var _expr = CXXTypeidExpr.__CreateInstance(expr.__Instance); + return VisitCXXTypeidExpr(_expr); + } + case StmtClass.MSPropertyRefExpr: + { + var _expr = MSPropertyRefExpr.__CreateInstance(expr.__Instance); + return VisitMSPropertyRefExpr(_expr); + } + case StmtClass.MSPropertySubscriptExpr: + { + var _expr = MSPropertySubscriptExpr.__CreateInstance(expr.__Instance); + return VisitMSPropertySubscriptExpr(_expr); + } + case StmtClass.CXXUuidofExpr: + { + var _expr = CXXUuidofExpr.__CreateInstance(expr.__Instance); + return VisitCXXUuidofExpr(_expr); + } + case StmtClass.CXXThisExpr: + { + var _expr = CXXThisExpr.__CreateInstance(expr.__Instance); + return VisitCXXThisExpr(_expr); + } + case StmtClass.CXXThrowExpr: + { + var _expr = CXXThrowExpr.__CreateInstance(expr.__Instance); + return VisitCXXThrowExpr(_expr); + } + case StmtClass.CXXDefaultArgExpr: + { + var _expr = CXXDefaultArgExpr.__CreateInstance(expr.__Instance); + return VisitCXXDefaultArgExpr(_expr); + } + case StmtClass.CXXDefaultInitExpr: + { + var _expr = CXXDefaultInitExpr.__CreateInstance(expr.__Instance); + return VisitCXXDefaultInitExpr(_expr); + } + case StmtClass.CXXBindTemporaryExpr: + { + var _expr = CXXBindTemporaryExpr.__CreateInstance(expr.__Instance); + return VisitCXXBindTemporaryExpr(_expr); + } + case StmtClass.CXXConstructExpr: + { + var _expr = CXXConstructExpr.__CreateInstance(expr.__Instance); + return VisitCXXConstructExpr(_expr); + } + case StmtClass.CXXInheritedCtorInitExpr: + { + var _expr = CXXInheritedCtorInitExpr.__CreateInstance(expr.__Instance); + return VisitCXXInheritedCtorInitExpr(_expr); + } + case StmtClass.CXXFunctionalCastExpr: + { + var _expr = CXXFunctionalCastExpr.__CreateInstance(expr.__Instance); + return VisitCXXFunctionalCastExpr(_expr); + } + case StmtClass.CXXTemporaryObjectExpr: + { + var _expr = CXXTemporaryObjectExpr.__CreateInstance(expr.__Instance); + return VisitCXXTemporaryObjectExpr(_expr); + } + case StmtClass.LambdaExpr: + { + var _expr = LambdaExpr.__CreateInstance(expr.__Instance); + return VisitLambdaExpr(_expr); + } + case StmtClass.CXXScalarValueInitExpr: + { + var _expr = CXXScalarValueInitExpr.__CreateInstance(expr.__Instance); + return VisitCXXScalarValueInitExpr(_expr); + } + case StmtClass.CXXNewExpr: + { + var _expr = CXXNewExpr.__CreateInstance(expr.__Instance); + return VisitCXXNewExpr(_expr); + } + case StmtClass.CXXDeleteExpr: + { + var _expr = CXXDeleteExpr.__CreateInstance(expr.__Instance); + return VisitCXXDeleteExpr(_expr); + } + case StmtClass.CXXPseudoDestructorExpr: + { + var _expr = CXXPseudoDestructorExpr.__CreateInstance(expr.__Instance); + return VisitCXXPseudoDestructorExpr(_expr); + } + case StmtClass.TypeTraitExpr: + { + var _expr = TypeTraitExpr.__CreateInstance(expr.__Instance); + return VisitTypeTraitExpr(_expr); + } + case StmtClass.ArrayTypeTraitExpr: + { + var _expr = ArrayTypeTraitExpr.__CreateInstance(expr.__Instance); + return VisitArrayTypeTraitExpr(_expr); + } + case StmtClass.ExpressionTraitExpr: + { + var _expr = ExpressionTraitExpr.__CreateInstance(expr.__Instance); + return VisitExpressionTraitExpr(_expr); + } + case StmtClass.UnresolvedLookupExpr: + { + var _expr = UnresolvedLookupExpr.__CreateInstance(expr.__Instance); + return VisitUnresolvedLookupExpr(_expr); + } + case StmtClass.DependentScopeDeclRefExpr: + { + var _expr = DependentScopeDeclRefExpr.__CreateInstance(expr.__Instance); + return VisitDependentScopeDeclRefExpr(_expr); + } + case StmtClass.ExprWithCleanups: + { + var _expr = ExprWithCleanups.__CreateInstance(expr.__Instance); + return VisitExprWithCleanups(_expr); + } + case StmtClass.CXXUnresolvedConstructExpr: + { + var _expr = CXXUnresolvedConstructExpr.__CreateInstance(expr.__Instance); + return VisitCXXUnresolvedConstructExpr(_expr); + } + case StmtClass.CXXDependentScopeMemberExpr: + { + var _expr = CXXDependentScopeMemberExpr.__CreateInstance(expr.__Instance); + return VisitCXXDependentScopeMemberExpr(_expr); + } + case StmtClass.UnresolvedMemberExpr: + { + var _expr = UnresolvedMemberExpr.__CreateInstance(expr.__Instance); + return VisitUnresolvedMemberExpr(_expr); + } + case StmtClass.CXXNoexceptExpr: + { + var _expr = CXXNoexceptExpr.__CreateInstance(expr.__Instance); + return VisitCXXNoexceptExpr(_expr); + } + case StmtClass.PackExpansionExpr: + { + var _expr = PackExpansionExpr.__CreateInstance(expr.__Instance); + return VisitPackExpansionExpr(_expr); + } + case StmtClass.SizeOfPackExpr: + { + var _expr = SizeOfPackExpr.__CreateInstance(expr.__Instance); + return VisitSizeOfPackExpr(_expr); + } + case StmtClass.SubstNonTypeTemplateParmExpr: + { + var _expr = SubstNonTypeTemplateParmExpr.__CreateInstance(expr.__Instance); + return VisitSubstNonTypeTemplateParmExpr(_expr); + } + case StmtClass.SubstNonTypeTemplateParmPackExpr: + { + var _expr = SubstNonTypeTemplateParmPackExpr.__CreateInstance(expr.__Instance); + return VisitSubstNonTypeTemplateParmPackExpr(_expr); + } + case StmtClass.FunctionParmPackExpr: + { + var _expr = FunctionParmPackExpr.__CreateInstance(expr.__Instance); + return VisitFunctionParmPackExpr(_expr); + } + case StmtClass.MaterializeTemporaryExpr: + { + var _expr = MaterializeTemporaryExpr.__CreateInstance(expr.__Instance); + return VisitMaterializeTemporaryExpr(_expr); + } + case StmtClass.CXXFoldExpr: + { + var _expr = CXXFoldExpr.__CreateInstance(expr.__Instance); + return VisitCXXFoldExpr(_expr); + } + case StmtClass.CoawaitExpr: + { + var _expr = CoawaitExpr.__CreateInstance(expr.__Instance); + return VisitCoawaitExpr(_expr); + } + case StmtClass.DependentCoawaitExpr: + { + var _expr = DependentCoawaitExpr.__CreateInstance(expr.__Instance); + return VisitDependentCoawaitExpr(_expr); + } + case StmtClass.CoyieldExpr: + { + var _expr = CoyieldExpr.__CreateInstance(expr.__Instance); + return VisitCoyieldExpr(_expr); + } + default: + throw new System.NotImplementedException(expr.StmtClass.ToString()); + } + } + } + + public unsafe class ExprConverter : ExprVisitor + { + public override AST.Expr VisitConstantExpr(ConstantExpr expr) + { + var _expr = new AST.ConstantExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitOpaqueValueExpr(OpaqueValueExpr expr) + { + var _expr = new AST.OpaqueValueExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.IsUnique = expr.IsUnique; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.SourceExpr = VisitExpression(expr.SourceExpr) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitDeclRefExpr(DeclRefExpr expr) + { + var _expr = new AST.DeclRefExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.HadMultipleCandidates = expr.HadMultipleCandidates; + _expr.HasQualifier = expr.HasQualifier; + _expr.HasTemplateKWAndArgsInfo = expr.HasTemplateKWAndArgsInfo; + _expr.TemplateKeywordLoc = VisitSourceLocation(expr.TemplateKeywordLoc); + _expr.LAngleLoc = VisitSourceLocation(expr.LAngleLoc); + _expr.RAngleLoc = VisitSourceLocation(expr.RAngleLoc); + _expr.HasTemplateKeyword = expr.HasTemplateKeyword; + _expr.HasExplicitTemplateArgs = expr.HasExplicitTemplateArgs; + _expr.NumTemplateArgs = expr.NumTemplateArgs; + _expr.RefersToEnclosingVariableOrCapture = expr.RefersToEnclosingVariableOrCapture; + return _expr; + } + + public override AST.Expr VisitIntegerLiteral(IntegerLiteral expr) + { + var _expr = new AST.IntegerLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + return _expr; + } + + public override AST.Expr VisitFixedPointLiteral(FixedPointLiteral expr) + { + var _expr = new AST.FixedPointLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + return _expr; + } + + public override AST.Expr VisitCharacterLiteral(CharacterLiteral expr) + { + var _expr = new AST.CharacterLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.Kind = (AST.CharacterLiteral.CharacterKind) expr.Kind; + _expr.Value = expr.Value; + return _expr; + } + + public override AST.Expr VisitFloatingLiteral(FloatingLiteral expr) + { + var _expr = new AST.FloatingLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Exact = expr.Exact; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.ValueAsApproximateDouble = expr.ValueAsApproximateDouble; + return _expr; + } + + public override AST.Expr VisitImaginaryLiteral(ImaginaryLiteral expr) + { + var _expr = new AST.ImaginaryLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitStringLiteral(StringLiteral expr) + { + var _expr = new AST.StringLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.String = expr.String; + _expr.Bytes = expr.Bytes; + _expr.ByteLength = expr.ByteLength; + _expr.Length = expr.Length; + _expr.CharByteWidth = expr.CharByteWidth; + _expr.Kind = (AST.StringLiteral.StringKind) expr.Kind; + _expr.IsAscii = expr.IsAscii; + _expr.IsWide = expr.IsWide; + _expr.IsUTF8 = expr.IsUTF8; + _expr.IsUTF16 = expr.IsUTF16; + _expr.IsUTF32 = expr.IsUTF32; + _expr.IsPascal = expr.IsPascal; + _expr.ContainsNonAscii = expr.ContainsNonAscii; + _expr.ContainsNonAsciiOrNull = expr.ContainsNonAsciiOrNull; + _expr.NumConcatenated = expr.NumConcatenated; + return _expr; + } + + public override AST.Expr VisitPredefinedExpr(PredefinedExpr expr) + { + var _expr = new AST.PredefinedExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.identKind = (AST.PredefinedExpr.IdentKind) expr.identKind; + return _expr; + } + + public override AST.Expr VisitParenExpr(ParenExpr expr) + { + var _expr = new AST.ParenExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.LParen = VisitSourceLocation(expr.LParen); + _expr.RParen = VisitSourceLocation(expr.RParen); + return _expr; + } + + public override AST.Expr VisitUnaryOperator(UnaryOperator expr) + { + var _expr = new AST.UnaryOperator(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Opcode = (AST.UnaryOperatorKind) expr.Opcode; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.CanOverflow = expr.CanOverflow; + return _expr; + } + + public override AST.Expr VisitOffsetOfExpr(OffsetOfExpr expr) + { + var _expr = new AST.OffsetOfExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumComponents = expr.NumComponents; + _expr.NumExpressions = expr.NumExpressions; + return _expr; + } + + public override AST.Expr VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr expr) + { + var _expr = new AST.UnaryExprOrTypeTraitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Kind = (AST.UnaryExprOrTypeTrait) expr.Kind; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.IsArgumentType = expr.IsArgumentType; + _expr.ArgumentType = VisitQualifiedType(expr.ArgumentType); + _expr.TypeOfArgument = VisitQualifiedType(expr.TypeOfArgument); + return _expr; + } + + public override AST.Expr VisitArraySubscriptExpr(ArraySubscriptExpr expr) + { + var _expr = new AST.ArraySubscriptExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.LHS = VisitExpression(expr.LHS) as AST.Expr; + _expr.RHS = VisitExpression(expr.RHS) as AST.Expr; + _expr.RBracketLoc = VisitSourceLocation(expr.RBracketLoc); + return _expr; + } + + public override AST.Expr VisitCallExpr(CallExpr expr) + { + var _expr = new AST.CallExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Callee = VisitExpression(expr.Callee) as AST.Expr; + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumArgs = expr.NumArgs; + _expr.NumCommas = expr.NumCommas; + _expr.BuiltinCallee = expr.BuiltinCallee; + _expr.IsCallToStdMove = expr.IsCallToStdMove; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + return _expr; + } + + public override AST.Expr VisitMemberExpr(MemberExpr expr) + { + var _expr = new AST.MemberExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Base = VisitExpression(expr.Base) as AST.Expr; + _expr.Arrow = expr.Arrow; + _expr.MemberLoc = VisitSourceLocation(expr.MemberLoc); + _expr.HadMultipleCandidates = expr.HadMultipleCandidates; + _expr.HasQualifier = expr.HasQualifier; + _expr.TemplateKeywordLoc = VisitSourceLocation(expr.TemplateKeywordLoc); + _expr.LAngleLoc = VisitSourceLocation(expr.LAngleLoc); + _expr.RAngleLoc = VisitSourceLocation(expr.RAngleLoc); + _expr.HasTemplateKeyword = expr.HasTemplateKeyword; + _expr.HasExplicitTemplateArgs = expr.HasExplicitTemplateArgs; + _expr.NumTemplateArgs = expr.NumTemplateArgs; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.IsImplicitAccess = expr.IsImplicitAccess; + return _expr; + } + + public override AST.Expr VisitCompoundLiteralExpr(CompoundLiteralExpr expr) + { + var _expr = new AST.CompoundLiteralExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Initializer = VisitExpression(expr.Initializer) as AST.Expr; + _expr.FileScope = expr.FileScope; + _expr.LParenLoc = VisitSourceLocation(expr.LParenLoc); + return _expr; + } + + public override AST.Expr VisitImplicitCastExpr(ImplicitCastExpr expr) + { + var _expr = new AST.ImplicitCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.IsPartOfExplicitCast = expr.IsPartOfExplicitCast; + return _expr; + } + + public override AST.Expr VisitCStyleCastExpr(CStyleCastExpr expr) + { + var _expr = new AST.CStyleCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.LParenLoc = VisitSourceLocation(expr.LParenLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitBinaryOperator(BinaryOperator expr) + { + var _expr = new AST.BinaryOperator(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.Opcode = (AST.BinaryOperatorKind) expr.Opcode; + _expr.LHS = VisitExpression(expr.LHS) as AST.Expr; + _expr.RHS = VisitExpression(expr.RHS) as AST.Expr; + _expr.IsFPContractableWithinStatement = expr.IsFPContractableWithinStatement; + _expr.IsFEnvAccessOn = expr.IsFEnvAccessOn; + return _expr; + } + + public override AST.Expr VisitCompoundAssignOperator(CompoundAssignOperator expr) + { + var _expr = new AST.CompoundAssignOperator(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.Opcode = (AST.BinaryOperatorKind) expr.Opcode; + _expr.LHS = VisitExpression(expr.LHS) as AST.Expr; + _expr.RHS = VisitExpression(expr.RHS) as AST.Expr; + _expr.IsFPContractableWithinStatement = expr.IsFPContractableWithinStatement; + _expr.IsFEnvAccessOn = expr.IsFEnvAccessOn; + _expr.ComputationLHSType = VisitQualifiedType(expr.ComputationLHSType); + _expr.ComputationResultType = VisitQualifiedType(expr.ComputationResultType); + return _expr; + } + + public override AST.Expr VisitConditionalOperator(ConditionalOperator expr) + { + var _expr = new AST.ConditionalOperator(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Cond = VisitExpression(expr.Cond) as AST.Expr; + _expr.TrueExpr = VisitExpression(expr.TrueExpr) as AST.Expr; + _expr.FalseExpr = VisitExpression(expr.FalseExpr) as AST.Expr; + _expr.QuestionLoc = VisitSourceLocation(expr.QuestionLoc); + _expr.ColonLoc = VisitSourceLocation(expr.ColonLoc); + _expr.LHS = VisitExpression(expr.LHS) as AST.Expr; + _expr.RHS = VisitExpression(expr.RHS) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitBinaryConditionalOperator(BinaryConditionalOperator expr) + { + var _expr = new AST.BinaryConditionalOperator(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Cond = VisitExpression(expr.Cond) as AST.Expr; + _expr.TrueExpr = VisitExpression(expr.TrueExpr) as AST.Expr; + _expr.FalseExpr = VisitExpression(expr.FalseExpr) as AST.Expr; + _expr.QuestionLoc = VisitSourceLocation(expr.QuestionLoc); + _expr.ColonLoc = VisitSourceLocation(expr.ColonLoc); + _expr.Common = VisitExpression(expr.Common) as AST.Expr; + _expr.OpaqueValue = VisitExpression(expr.OpaqueValue) as AST.OpaqueValueExpr; + return _expr; + } + + public override AST.Expr VisitAddrLabelExpr(AddrLabelExpr expr) + { + var _expr = new AST.AddrLabelExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.AmpAmpLoc = VisitSourceLocation(expr.AmpAmpLoc); + _expr.LabelLoc = VisitSourceLocation(expr.LabelLoc); + return _expr; + } + + public override AST.Expr VisitStmtExpr(StmtExpr expr) + { + var _expr = new AST.StmtExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubStmt = VisitStatement(expr.SubStmt) as AST.CompoundStmt; + _expr.LParenLoc = VisitSourceLocation(expr.LParenLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitShuffleVectorExpr(ShuffleVectorExpr expr) + { + var _expr = new AST.ShuffleVectorExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.BuiltinLoc = VisitSourceLocation(expr.BuiltinLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumSubExprs = expr.NumSubExprs; + return _expr; + } + + public override AST.Expr VisitConvertVectorExpr(ConvertVectorExpr expr) + { + var _expr = new AST.ConvertVectorExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SrcExpr = VisitExpression(expr.SrcExpr) as AST.Expr; + _expr.BuiltinLoc = VisitSourceLocation(expr.BuiltinLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitChooseExpr(ChooseExpr expr) + { + var _expr = new AST.ChooseExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.IsConditionTrue = expr.IsConditionTrue; + _expr.Cond = VisitExpression(expr.Cond) as AST.Expr; + _expr.LHS = VisitExpression(expr.LHS) as AST.Expr; + _expr.RHS = VisitExpression(expr.RHS) as AST.Expr; + _expr.BuiltinLoc = VisitSourceLocation(expr.BuiltinLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.IsConditionDependent = expr.IsConditionDependent; + _expr.ChosenSubExpr = VisitExpression(expr.ChosenSubExpr) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitGNUNullExpr(GNUNullExpr expr) + { + var _expr = new AST.GNUNullExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.TokenLocation = VisitSourceLocation(expr.TokenLocation); + return _expr; + } + + public override AST.Expr VisitVAArgExpr(VAArgExpr expr) + { + var _expr = new AST.VAArgExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.IsMicrosoftABI = expr.IsMicrosoftABI; + _expr.BuiltinLoc = VisitSourceLocation(expr.BuiltinLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitInitListExpr(InitListExpr expr) + { + var _expr = new AST.InitListExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ArrayFiller = VisitExpression(expr.ArrayFiller) as AST.Expr; + _expr.LBraceLoc = VisitSourceLocation(expr.LBraceLoc); + _expr.RBraceLoc = VisitSourceLocation(expr.RBraceLoc); + _expr.SyntacticForm = VisitExpression(expr.SyntacticForm) as AST.InitListExpr; + _expr.NumInits = expr.NumInits; + _expr.HasArrayFiller = expr.HasArrayFiller; + _expr.IsExplicit = expr.IsExplicit; + _expr.IsStringLiteralInit = expr.IsStringLiteralInit; + _expr.IsTransparent = expr.IsTransparent; + _expr.IsSemanticForm = expr.IsSemanticForm; + _expr.SemanticForm = VisitExpression(expr.SemanticForm) as AST.InitListExpr; + _expr.IsSyntacticForm = expr.IsSyntacticForm; + return _expr; + } + + public override AST.Expr VisitDesignatedInitExpr(DesignatedInitExpr expr) + { + var _expr = new AST.DesignatedInitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.EqualOrColonLoc = VisitSourceLocation(expr.EqualOrColonLoc); + _expr.Init = VisitExpression(expr.Init) as AST.Expr; + _expr.Size = expr.Size; + _expr.UsesGNUSyntax = expr.UsesGNUSyntax; + _expr.NumSubExprs = expr.NumSubExprs; + _expr.DesignatorsSourceRange = VisitSourceRange(expr.DesignatorsSourceRange); + return _expr; + } + + public override AST.Expr VisitNoInitExpr(NoInitExpr expr) + { + var _expr = new AST.NoInitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + return _expr; + } + + public override AST.Expr VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr expr) + { + var _expr = new AST.DesignatedInitUpdateExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Base = VisitExpression(expr.Base) as AST.Expr; + _expr.Updater = VisitExpression(expr.Updater) as AST.InitListExpr; + return _expr; + } + + public override AST.Expr VisitArrayInitLoopExpr(ArrayInitLoopExpr expr) + { + var _expr = new AST.ArrayInitLoopExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CommonExpr = VisitExpression(expr.CommonExpr) as AST.OpaqueValueExpr; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitArrayInitIndexExpr(ArrayInitIndexExpr expr) + { + var _expr = new AST.ArrayInitIndexExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + return _expr; + } + + public override AST.Expr VisitImplicitValueInitExpr(ImplicitValueInitExpr expr) + { + var _expr = new AST.ImplicitValueInitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + return _expr; + } + + public override AST.Expr VisitParenListExpr(ParenListExpr expr) + { + var _expr = new AST.ParenListExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.NumExprs = expr.NumExprs; + _expr.LParenLoc = VisitSourceLocation(expr.LParenLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitGenericSelectionExpr(GenericSelectionExpr expr) + { + var _expr = new AST.GenericSelectionExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.NumAssocs = expr.NumAssocs; + _expr.GenericLoc = VisitSourceLocation(expr.GenericLoc); + _expr.DefaultLoc = VisitSourceLocation(expr.DefaultLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.IsResultDependent = expr.IsResultDependent; + _expr.ResultIndex = expr.ResultIndex; + return _expr; + } + + public override AST.Expr VisitExtVectorElementExpr(ExtVectorElementExpr expr) + { + var _expr = new AST.ExtVectorElementExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Base = VisitExpression(expr.Base) as AST.Expr; + _expr.AccessorLoc = VisitSourceLocation(expr.AccessorLoc); + _expr.NumElements = expr.NumElements; + _expr.ContainsDuplicateElements = expr.ContainsDuplicateElements; + _expr.IsArrow = expr.IsArrow; + return _expr; + } + + public override AST.Expr VisitBlockExpr(BlockExpr expr) + { + var _expr = new AST.BlockExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CaretLocation = VisitSourceLocation(expr.CaretLocation); + return _expr; + } + + public override AST.Expr VisitAsTypeExpr(AsTypeExpr expr) + { + var _expr = new AST.AsTypeExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SrcExpr = VisitExpression(expr.SrcExpr) as AST.Expr; + _expr.BuiltinLoc = VisitSourceLocation(expr.BuiltinLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitPseudoObjectExpr(PseudoObjectExpr expr) + { + var _expr = new AST.PseudoObjectExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ResultExprIndex = expr.ResultExprIndex; + _expr.NumSemanticExprs = expr.NumSemanticExprs; + return _expr; + } + + public override AST.Expr VisitAtomicExpr(AtomicExpr expr) + { + var _expr = new AST.AtomicExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Ptr = VisitExpression(expr.Ptr) as AST.Expr; + _expr.Order = VisitExpression(expr.Order) as AST.Expr; + _expr.Scope = VisitExpression(expr.Scope) as AST.Expr; + _expr.Val1 = VisitExpression(expr.Val1) as AST.Expr; + _expr.OrderFail = VisitExpression(expr.OrderFail) as AST.Expr; + _expr.Val2 = VisitExpression(expr.Val2) as AST.Expr; + _expr.Weak = VisitExpression(expr.Weak) as AST.Expr; + _expr.ValueType = VisitQualifiedType(expr.ValueType); + _expr.Op = (AST.AtomicExpr.AtomicOp) expr.Op; + _expr.IsVolatile = expr.IsVolatile; + _expr.IsCmpXChg = expr.IsCmpXChg; + _expr.IsOpenCL = expr.IsOpenCL; + _expr.BuiltinLoc = VisitSourceLocation(expr.BuiltinLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitTypoExpr(TypoExpr expr) + { + var _expr = new AST.TypoExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + return _expr; + } + + public override AST.Expr VisitCXXOperatorCallExpr(CXXOperatorCallExpr expr) + { + var _expr = new AST.CXXOperatorCallExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Callee = VisitExpression(expr.Callee) as AST.Expr; + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumArgs = expr.NumArgs; + _expr.NumCommas = expr.NumCommas; + _expr.BuiltinCallee = expr.BuiltinCallee; + _expr.IsCallToStdMove = expr.IsCallToStdMove; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + _expr.Operator = (AST.OverloadedOperatorKind) expr.Operator; + _expr.IsInfixBinaryOp = expr.IsInfixBinaryOp; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.IsFPContractableWithinStatement = expr.IsFPContractableWithinStatement; + return _expr; + } + + public override AST.Expr VisitCXXMemberCallExpr(CXXMemberCallExpr expr) + { + var _expr = new AST.CXXMemberCallExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Callee = VisitExpression(expr.Callee) as AST.Expr; + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumArgs = expr.NumArgs; + _expr.NumCommas = expr.NumCommas; + _expr.BuiltinCallee = expr.BuiltinCallee; + _expr.IsCallToStdMove = expr.IsCallToStdMove; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + _expr.ImplicitObjectArgument = VisitExpression(expr.ImplicitObjectArgument) as AST.Expr; + _expr.MethodDecl = VisitDeclaration(expr.MethodDecl) as AST.Method; + return _expr; + } + + public override AST.Expr VisitCUDAKernelCallExpr(CUDAKernelCallExpr expr) + { + var _expr = new AST.CUDAKernelCallExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Callee = VisitExpression(expr.Callee) as AST.Expr; + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumArgs = expr.NumArgs; + _expr.NumCommas = expr.NumCommas; + _expr.BuiltinCallee = expr.BuiltinCallee; + _expr.IsCallToStdMove = expr.IsCallToStdMove; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + _expr.Config = VisitExpression(expr.Config) as AST.CallExpr; + return _expr; + } + + public override AST.Expr VisitCXXStaticCastExpr(CXXStaticCastExpr expr) + { + var _expr = new AST.CXXStaticCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.CastName = expr.CastName; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.AngleBrackets = VisitSourceRange(expr.AngleBrackets); + return _expr; + } + + public override AST.Expr VisitCXXDynamicCastExpr(CXXDynamicCastExpr expr) + { + var _expr = new AST.CXXDynamicCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.CastName = expr.CastName; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.AngleBrackets = VisitSourceRange(expr.AngleBrackets); + _expr.IsAlwaysNull = expr.IsAlwaysNull; + return _expr; + } + + public override AST.Expr VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr expr) + { + var _expr = new AST.CXXReinterpretCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.CastName = expr.CastName; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.AngleBrackets = VisitSourceRange(expr.AngleBrackets); + return _expr; + } + + public override AST.Expr VisitCXXConstCastExpr(CXXConstCastExpr expr) + { + var _expr = new AST.CXXConstCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.CastName = expr.CastName; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.AngleBrackets = VisitSourceRange(expr.AngleBrackets); + return _expr; + } + + public override AST.Expr VisitUserDefinedLiteral(UserDefinedLiteral expr) + { + var _expr = new AST.UserDefinedLiteral(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Callee = VisitExpression(expr.Callee) as AST.Expr; + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.NumArgs = expr.NumArgs; + _expr.NumCommas = expr.NumCommas; + _expr.BuiltinCallee = expr.BuiltinCallee; + _expr.IsCallToStdMove = expr.IsCallToStdMove; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + _expr.literalOperatorKind = (AST.UserDefinedLiteral.LiteralOperatorKind) expr.literalOperatorKind; + _expr.UDSuffixLoc = VisitSourceLocation(expr.UDSuffixLoc); + return _expr; + } + + public override AST.Expr VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr expr) + { + var _expr = new AST.CXXBoolLiteralExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Value = expr.Value; + _expr.Location = VisitSourceLocation(expr.Location); + return _expr; + } + + public override AST.Expr VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr expr) + { + var _expr = new AST.CXXNullPtrLiteralExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + return _expr; + } + + public override AST.Expr VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr expr) + { + var _expr = new AST.CXXStdInitializerListExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + return _expr; + } + + public override AST.Expr VisitCXXTypeidExpr(CXXTypeidExpr expr) + { + var _expr = new AST.CXXTypeidExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ExprOperand = VisitExpression(expr.ExprOperand) as AST.Expr; + _expr.IsPotentiallyEvaluated = expr.IsPotentiallyEvaluated; + _expr.IsTypeOperand = expr.IsTypeOperand; + return _expr; + } + + public override AST.Expr VisitMSPropertyRefExpr(MSPropertyRefExpr expr) + { + var _expr = new AST.MSPropertyRefExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.IsImplicitAccess = expr.IsImplicitAccess; + _expr.BaseExpr = VisitExpression(expr.BaseExpr) as AST.Expr; + _expr.IsArrow = expr.IsArrow; + _expr.MemberLoc = VisitSourceLocation(expr.MemberLoc); + return _expr; + } + + public override AST.Expr VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr expr) + { + var _expr = new AST.MSPropertySubscriptExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.RBracketLoc = VisitSourceLocation(expr.RBracketLoc); + return _expr; + } + + public override AST.Expr VisitCXXUuidofExpr(CXXUuidofExpr expr) + { + var _expr = new AST.CXXUuidofExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ExprOperand = VisitExpression(expr.ExprOperand) as AST.Expr; + _expr.UuidStr = expr.UuidStr; + _expr.IsTypeOperand = expr.IsTypeOperand; + return _expr; + } + + public override AST.Expr VisitCXXThisExpr(CXXThisExpr expr) + { + var _expr = new AST.CXXThisExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.Implicit = expr.Implicit; + return _expr; + } + + public override AST.Expr VisitCXXThrowExpr(CXXThrowExpr expr) + { + var _expr = new AST.CXXThrowExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ThrowLoc = VisitSourceLocation(expr.ThrowLoc); + _expr.IsThrownVariableInScope = expr.IsThrownVariableInScope; + return _expr; + } + + public override AST.Expr VisitCXXDefaultArgExpr(CXXDefaultArgExpr expr) + { + var _expr = new AST.CXXDefaultArgExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.UsedLocation = VisitSourceLocation(expr.UsedLocation); + return _expr; + } + + public override AST.Expr VisitCXXDefaultInitExpr(CXXDefaultInitExpr expr) + { + var _expr = new AST.CXXDefaultInitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + return _expr; + } + + public override AST.Expr VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr expr) + { + var _expr = new AST.CXXBindTemporaryExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitCXXConstructExpr(CXXConstructExpr expr) + { + var _expr = new AST.CXXConstructExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.Elidable = expr.Elidable; + _expr.HadMultipleCandidates = expr.HadMultipleCandidates; + _expr.ListInitialization = expr.ListInitialization; + _expr.StdInitListInitialization = expr.StdInitListInitialization; + _expr.RequiresZeroInitialization = expr.RequiresZeroInitialization; + _expr.ParenOrBraceRange = VisitSourceRange(expr.ParenOrBraceRange); + _expr.NumArgs = expr.NumArgs; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + return _expr; + } + + public override AST.Expr VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr expr) + { + var _expr = new AST.CXXInheritedCtorInitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ConstructsVBase = expr.ConstructsVBase; + _expr.InheritedFromVBase = expr.InheritedFromVBase; + _expr.Location = VisitSourceLocation(expr.Location); + return _expr; + } + + public override AST.Expr VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr expr) + { + var _expr = new AST.CXXFunctionalCastExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CastKind = (AST.CastKind) expr.CastKind; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.ConversionFunction = VisitDeclaration(expr.ConversionFunction) as AST.Declaration; + _expr.PathEmpty = expr.PathEmpty; + _expr.PathSize = expr.PathSize; + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.LParenLoc = VisitSourceLocation(expr.LParenLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.IsListInitialization = expr.IsListInitialization; + return _expr; + } + + public override AST.Expr VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr expr) + { + var _expr = new AST.CXXTemporaryObjectExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.Elidable = expr.Elidable; + _expr.HadMultipleCandidates = expr.HadMultipleCandidates; + _expr.ListInitialization = expr.ListInitialization; + _expr.StdInitListInitialization = expr.StdInitListInitialization; + _expr.RequiresZeroInitialization = expr.RequiresZeroInitialization; + _expr.ParenOrBraceRange = VisitSourceRange(expr.ParenOrBraceRange); + _expr.NumArgs = expr.NumArgs; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + return _expr; + } + + public override AST.Expr VisitLambdaExpr(LambdaExpr expr) + { + var _expr = new AST.LambdaExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.CaptureDefaultLoc = VisitSourceLocation(expr.CaptureDefaultLoc); + _expr.CaptureSize = expr.CaptureSize; + _expr.IntroducerRange = VisitSourceRange(expr.IntroducerRange); + _expr.CallOperator = VisitDeclaration(expr.CallOperator) as AST.Method; + _expr.IsGenericLambda = expr.IsGenericLambda; + _expr.Body = VisitStatement(expr.Body) as AST.CompoundStmt; + _expr.IsMutable = expr.IsMutable; + _expr.HasExplicitParameters = expr.HasExplicitParameters; + _expr.HasExplicitResultType = expr.HasExplicitResultType; + for (uint i = 0; i < expr.GetcaptureInitsCount; i++) + { + var _E = expr.GetcaptureInits(i); + _expr.CaptureInits.Add(VisitExpression(_E) as AST.Expr); + } + return _expr; + } + + public override AST.Expr VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr expr) + { + var _expr = new AST.CXXScalarValueInitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + return _expr; + } + + public override AST.Expr VisitCXXNewExpr(CXXNewExpr expr) + { + var _expr = new AST.CXXNewExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.OperatorNew = VisitDeclaration(expr.OperatorNew) as AST.Function; + _expr.OperatorDelete = VisitDeclaration(expr.OperatorDelete) as AST.Function; + _expr.AllocatedType = VisitQualifiedType(expr.AllocatedType); + _expr.IsArray = expr.IsArray; + _expr.NumPlacementArgs = expr.NumPlacementArgs; + _expr.IsParenTypeId = expr.IsParenTypeId; + _expr.TypeIdParens = VisitSourceRange(expr.TypeIdParens); + _expr.IsGlobalNew = expr.IsGlobalNew; + _expr.HasInitializer = expr.HasInitializer; + _expr.initializationStyle = (AST.CXXNewExpr.InitializationStyle) expr.initializationStyle; + _expr.ConstructExpr = VisitExpression(expr.ConstructExpr) as AST.CXXConstructExpr; + _expr.DirectInitRange = VisitSourceRange(expr.DirectInitRange); + for (uint i = 0; i < expr.GetplacementArgumentsCount; i++) + { + var _E = expr.GetplacementArguments(i); + _expr.PlacementArguments.Add(VisitExpression(_E) as AST.Expr); + } + return _expr; + } + + public override AST.Expr VisitCXXDeleteExpr(CXXDeleteExpr expr) + { + var _expr = new AST.CXXDeleteExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.IsGlobalDelete = expr.IsGlobalDelete; + _expr.IsArrayForm = expr.IsArrayForm; + _expr.IsArrayFormAsWritten = expr.IsArrayFormAsWritten; + _expr.OperatorDelete = VisitDeclaration(expr.OperatorDelete) as AST.Function; + _expr.DestroyedType = VisitQualifiedType(expr.DestroyedType); + return _expr; + } + + public override AST.Expr VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr expr) + { + var _expr = new AST.CXXPseudoDestructorExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Base = VisitExpression(expr.Base) as AST.Expr; + _expr.HasQualifier = expr.HasQualifier; + _expr.IsArrow = expr.IsArrow; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.ColonColonLoc = VisitSourceLocation(expr.ColonColonLoc); + _expr.TildeLoc = VisitSourceLocation(expr.TildeLoc); + _expr.DestroyedType = VisitQualifiedType(expr.DestroyedType); + _expr.DestroyedTypeLoc = VisitSourceLocation(expr.DestroyedTypeLoc); + return _expr; + } + + public override AST.Expr VisitTypeTraitExpr(TypeTraitExpr expr) + { + var _expr = new AST.TypeTraitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Value = expr.Value; + _expr.NumArgs = expr.NumArgs; + return _expr; + } + + public override AST.Expr VisitArrayTypeTraitExpr(ArrayTypeTraitExpr expr) + { + var _expr = new AST.ArrayTypeTraitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.QueriedType = VisitQualifiedType(expr.QueriedType); + _expr.Value = expr.Value; + _expr.DimensionExpression = VisitExpression(expr.DimensionExpression) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitExpressionTraitExpr(ExpressionTraitExpr expr) + { + var _expr = new AST.ExpressionTraitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.QueriedExpression = VisitExpression(expr.QueriedExpression) as AST.Expr; + _expr.Value = expr.Value; + return _expr; + } + + public override AST.Expr VisitUnresolvedLookupExpr(UnresolvedLookupExpr expr) + { + var _expr = new AST.UnresolvedLookupExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.NumDecls = expr.NumDecls; + _expr.NameLoc = VisitSourceLocation(expr.NameLoc); + _expr.TemplateKeywordLoc = VisitSourceLocation(expr.TemplateKeywordLoc); + _expr.LAngleLoc = VisitSourceLocation(expr.LAngleLoc); + _expr.RAngleLoc = VisitSourceLocation(expr.RAngleLoc); + _expr.HasTemplateKeyword = expr.HasTemplateKeyword; + _expr.HasExplicitTemplateArgs = expr.HasExplicitTemplateArgs; + _expr.NumTemplateArgs = expr.NumTemplateArgs; + _expr.RequiresADL = expr.RequiresADL; + _expr.IsOverloaded = expr.IsOverloaded; + return _expr; + } + + public override AST.Expr VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr expr) + { + var _expr = new AST.DependentScopeDeclRefExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Location = VisitSourceLocation(expr.Location); + _expr.TemplateKeywordLoc = VisitSourceLocation(expr.TemplateKeywordLoc); + _expr.LAngleLoc = VisitSourceLocation(expr.LAngleLoc); + _expr.RAngleLoc = VisitSourceLocation(expr.RAngleLoc); + _expr.HasTemplateKeyword = expr.HasTemplateKeyword; + _expr.HasExplicitTemplateArgs = expr.HasExplicitTemplateArgs; + _expr.NumTemplateArgs = expr.NumTemplateArgs; + return _expr; + } + + public override AST.Expr VisitExprWithCleanups(ExprWithCleanups expr) + { + var _expr = new AST.ExprWithCleanups(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.SubExpr = VisitExpression(expr.SubExpr) as AST.Expr; + _expr.NumObjects = expr.NumObjects; + _expr.CleanupsHaveSideEffects = expr.CleanupsHaveSideEffects; + return _expr; + } + + public override AST.Expr VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr expr) + { + var _expr = new AST.CXXUnresolvedConstructExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.LParenLoc = VisitSourceLocation(expr.LParenLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.TypeAsWritten = VisitQualifiedType(expr.TypeAsWritten); + _expr.IsListInitialization = expr.IsListInitialization; + _expr.ArgSize = expr.ArgSize; + for (uint i = 0; i < expr.GetargumentsCount; i++) + { + var _E = expr.Getarguments(i); + _expr.Arguments.Add(VisitExpression(_E) as AST.Expr); + } + return _expr; + } + + public override AST.Expr VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr expr) + { + var _expr = new AST.CXXDependentScopeMemberExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.IsImplicitAccess = expr.IsImplicitAccess; + _expr.Base = VisitExpression(expr.Base) as AST.Expr; + _expr.BaseType = VisitQualifiedType(expr.BaseType); + _expr.IsArrow = expr.IsArrow; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.FirstQualifierFoundInScope = VisitDeclaration(expr.FirstQualifierFoundInScope) as AST.Declaration; + _expr.MemberLoc = VisitSourceLocation(expr.MemberLoc); + _expr.TemplateKeywordLoc = VisitSourceLocation(expr.TemplateKeywordLoc); + _expr.LAngleLoc = VisitSourceLocation(expr.LAngleLoc); + _expr.RAngleLoc = VisitSourceLocation(expr.RAngleLoc); + _expr.HasTemplateKeyword = expr.HasTemplateKeyword; + _expr.HasExplicitTemplateArgs = expr.HasExplicitTemplateArgs; + _expr.NumTemplateArgs = expr.NumTemplateArgs; + return _expr; + } + + public override AST.Expr VisitUnresolvedMemberExpr(UnresolvedMemberExpr expr) + { + var _expr = new AST.UnresolvedMemberExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.NumDecls = expr.NumDecls; + _expr.NameLoc = VisitSourceLocation(expr.NameLoc); + _expr.TemplateKeywordLoc = VisitSourceLocation(expr.TemplateKeywordLoc); + _expr.LAngleLoc = VisitSourceLocation(expr.LAngleLoc); + _expr.RAngleLoc = VisitSourceLocation(expr.RAngleLoc); + _expr.HasTemplateKeyword = expr.HasTemplateKeyword; + _expr.HasExplicitTemplateArgs = expr.HasExplicitTemplateArgs; + _expr.NumTemplateArgs = expr.NumTemplateArgs; + _expr.IsImplicitAccess = expr.IsImplicitAccess; + _expr.BaseType = VisitQualifiedType(expr.BaseType); + _expr.HasUnresolvedUsing = expr.HasUnresolvedUsing; + _expr.IsArrow = expr.IsArrow; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.MemberLoc = VisitSourceLocation(expr.MemberLoc); + return _expr; + } + + public override AST.Expr VisitCXXNoexceptExpr(CXXNoexceptExpr expr) + { + var _expr = new AST.CXXNoexceptExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Operand = VisitExpression(expr.Operand) as AST.Expr; + _expr.Value = expr.Value; + return _expr; + } + + public override AST.Expr VisitPackExpansionExpr(PackExpansionExpr expr) + { + var _expr = new AST.PackExpansionExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.EllipsisLoc = VisitSourceLocation(expr.EllipsisLoc); + return _expr; + } + + public override AST.Expr VisitSizeOfPackExpr(SizeOfPackExpr expr) + { + var _expr = new AST.SizeOfPackExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.OperatorLoc = VisitSourceLocation(expr.OperatorLoc); + _expr.PackLoc = VisitSourceLocation(expr.PackLoc); + _expr.RParenLoc = VisitSourceLocation(expr.RParenLoc); + _expr.Pack = VisitDeclaration(expr.Pack) as AST.Declaration; + _expr.PackLength = expr.PackLength; + _expr.IsPartiallySubstituted = expr.IsPartiallySubstituted; + return _expr; + } + + public override AST.Expr VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr expr) + { + var _expr = new AST.SubstNonTypeTemplateParmExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.NameLoc = VisitSourceLocation(expr.NameLoc); + _expr.Replacement = VisitExpression(expr.Replacement) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr expr) + { + var _expr = new AST.SubstNonTypeTemplateParmPackExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ParameterPackLocation = VisitSourceLocation(expr.ParameterPackLocation); + _expr.ArgumentPack = VisitTemplateArgument(expr.ArgumentPack); + return _expr; + } + + public override AST.Expr VisitFunctionParmPackExpr(FunctionParmPackExpr expr) + { + var _expr = new AST.FunctionParmPackExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.ParameterPackLocation = VisitSourceLocation(expr.ParameterPackLocation); + _expr.NumExpansions = expr.NumExpansions; + return _expr; + } + + public override AST.Expr VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr expr) + { + var _expr = new AST.MaterializeTemporaryExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Temporary = VisitStatement(expr.Temporary) as AST.Stmt; + _expr.TemporaryExpr = VisitExpression(expr.TemporaryExpr) as AST.Expr; + _expr.ManglingNumber = expr.ManglingNumber; + _expr.IsBoundToLvalueReference = expr.IsBoundToLvalueReference; + return _expr; + } + + public override AST.Expr VisitCXXFoldExpr(CXXFoldExpr expr) + { + var _expr = new AST.CXXFoldExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.LHS = VisitExpression(expr.LHS) as AST.Expr; + _expr.RHS = VisitExpression(expr.RHS) as AST.Expr; + _expr.IsRightFold = expr.IsRightFold; + _expr.IsLeftFold = expr.IsLeftFold; + _expr.Pattern = VisitExpression(expr.Pattern) as AST.Expr; + _expr.Init = VisitExpression(expr.Init) as AST.Expr; + _expr.EllipsisLoc = VisitSourceLocation(expr.EllipsisLoc); + _expr.Operator = (AST.BinaryOperatorKind) expr.Operator; + return _expr; + } + + public override AST.Expr VisitCoawaitExpr(CoawaitExpr expr) + { + var _expr = new AST.CoawaitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.KeywordLoc = VisitSourceLocation(expr.KeywordLoc); + _expr.CommonExpr = VisitExpression(expr.CommonExpr) as AST.Expr; + _expr.OpaqueValue = VisitExpression(expr.OpaqueValue) as AST.OpaqueValueExpr; + _expr.ReadyExpr = VisitExpression(expr.ReadyExpr) as AST.Expr; + _expr.SuspendExpr = VisitExpression(expr.SuspendExpr) as AST.Expr; + _expr.ResumeExpr = VisitExpression(expr.ResumeExpr) as AST.Expr; + _expr.IsImplicit = expr.IsImplicit; + _expr.Operand = VisitExpression(expr.Operand) as AST.Expr; + return _expr; + } + + public override AST.Expr VisitDependentCoawaitExpr(DependentCoawaitExpr expr) + { + var _expr = new AST.DependentCoawaitExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.Operand = VisitExpression(expr.Operand) as AST.Expr; + _expr.OperatorCoawaitLookup = VisitExpression(expr.OperatorCoawaitLookup) as AST.UnresolvedLookupExpr; + _expr.KeywordLoc = VisitSourceLocation(expr.KeywordLoc); + return _expr; + } + + public override AST.Expr VisitCoyieldExpr(CoyieldExpr expr) + { + var _expr = new AST.CoyieldExpr(); + _expr.SourceRange = VisitSourceRange(expr.SourceRange); + _expr.EndLoc = VisitSourceLocation(expr.EndLoc); + _expr.Type = VisitQualifiedType(expr.Type); + _expr.ValueDependent = expr.ValueDependent; + _expr.TypeDependent = expr.TypeDependent; + _expr.InstantiationDependent = expr.InstantiationDependent; + _expr.ContainsUnexpandedParameterPack = expr.ContainsUnexpandedParameterPack; + _expr.ExprLoc = VisitSourceLocation(expr.ExprLoc); + _expr.IsLValue = expr.IsLValue; + _expr.IsRValue = expr.IsRValue; + _expr.IsXValue = expr.IsXValue; + _expr.IsGLValue = expr.IsGLValue; + _expr.IsOrdinaryOrBitFieldObject = expr.IsOrdinaryOrBitFieldObject; + _expr.KeywordLoc = VisitSourceLocation(expr.KeywordLoc); + _expr.CommonExpr = VisitExpression(expr.CommonExpr) as AST.Expr; + _expr.OpaqueValue = VisitExpression(expr.OpaqueValue) as AST.OpaqueValueExpr; + _expr.ReadyExpr = VisitExpression(expr.ReadyExpr) as AST.Expr; + _expr.SuspendExpr = VisitExpression(expr.SuspendExpr) as AST.Expr; + _expr.ResumeExpr = VisitExpression(expr.ResumeExpr) as AST.Expr; + _expr.Operand = VisitExpression(expr.Operand) as AST.Expr; + return _expr; + } + } +} diff --git a/src/Parser/ASTConverter.Stmt.cs b/src/Parser/ASTConverter.Stmt.cs new file mode 100644 index 00000000..60d512ae --- /dev/null +++ b/src/Parser/ASTConverter.Stmt.cs @@ -0,0 +1,1098 @@ +// ---------------------------------------------------------------------------- +// +// This is autogenerated code by CppSharp. +// Do not edit this file or all your changes will be lost after re-generation. +// +// ---------------------------------------------------------------------------- + +using CppSharp.Parser.AST; +using static CppSharp.ConversionUtils; + +namespace CppSharp +{ + // + // Implements the visitor pattern for the generated stmt bindings. + // + public abstract class StmtVisitor where TRet : class + { + public abstract TRet VisitDeclStmt(DeclStmt stmt); + public abstract TRet VisitNullStmt(NullStmt stmt); + public abstract TRet VisitCompoundStmt(CompoundStmt stmt); + public abstract TRet VisitCaseStmt(CaseStmt stmt); + public abstract TRet VisitDefaultStmt(DefaultStmt stmt); + public abstract TRet VisitLabelStmt(LabelStmt stmt); + public abstract TRet VisitAttributedStmt(AttributedStmt stmt); + public abstract TRet VisitIfStmt(IfStmt stmt); + public abstract TRet VisitSwitchStmt(SwitchStmt stmt); + public abstract TRet VisitWhileStmt(WhileStmt stmt); + public abstract TRet VisitDoStmt(DoStmt stmt); + public abstract TRet VisitForStmt(ForStmt stmt); + public abstract TRet VisitGotoStmt(GotoStmt stmt); + public abstract TRet VisitIndirectGotoStmt(IndirectGotoStmt stmt); + public abstract TRet VisitContinueStmt(ContinueStmt stmt); + public abstract TRet VisitBreakStmt(BreakStmt stmt); + public abstract TRet VisitReturnStmt(ReturnStmt stmt); + public abstract TRet VisitGCCAsmStmt(GCCAsmStmt stmt); + public abstract TRet VisitMSAsmStmt(MSAsmStmt stmt); + public abstract TRet VisitSEHExceptStmt(SEHExceptStmt stmt); + public abstract TRet VisitSEHFinallyStmt(SEHFinallyStmt stmt); + public abstract TRet VisitSEHTryStmt(SEHTryStmt stmt); + public abstract TRet VisitSEHLeaveStmt(SEHLeaveStmt stmt); + public abstract TRet VisitCapturedStmt(CapturedStmt stmt); + public abstract TRet VisitCXXCatchStmt(CXXCatchStmt stmt); + public abstract TRet VisitCXXTryStmt(CXXTryStmt stmt); + public abstract TRet VisitCXXForRangeStmt(CXXForRangeStmt stmt); + public abstract TRet VisitMSDependentExistsStmt(MSDependentExistsStmt stmt); + public abstract TRet VisitCoroutineBodyStmt(CoroutineBodyStmt stmt); + public abstract TRet VisitCoreturnStmt(CoreturnStmt stmt); + + public virtual TRet Visit(Parser.AST.Stmt stmt) + { + if (stmt == null) + return default(TRet); + + switch(stmt.StmtClass) + { + case StmtClass.GCCAsmStmt: + { + var _stmt = GCCAsmStmt.__CreateInstance(stmt.__Instance); + return VisitGCCAsmStmt(_stmt); + } + case StmtClass.MSAsmStmt: + { + var _stmt = MSAsmStmt.__CreateInstance(stmt.__Instance); + return VisitMSAsmStmt(_stmt); + } + case StmtClass.AttributedStmt: + { + var _stmt = AttributedStmt.__CreateInstance(stmt.__Instance); + return VisitAttributedStmt(_stmt); + } + case StmtClass.BreakStmt: + { + var _stmt = BreakStmt.__CreateInstance(stmt.__Instance); + return VisitBreakStmt(_stmt); + } + case StmtClass.CXXCatchStmt: + { + var _stmt = CXXCatchStmt.__CreateInstance(stmt.__Instance); + return VisitCXXCatchStmt(_stmt); + } + case StmtClass.CXXForRangeStmt: + { + var _stmt = CXXForRangeStmt.__CreateInstance(stmt.__Instance); + return VisitCXXForRangeStmt(_stmt); + } + case StmtClass.CXXTryStmt: + { + var _stmt = CXXTryStmt.__CreateInstance(stmt.__Instance); + return VisitCXXTryStmt(_stmt); + } + case StmtClass.CapturedStmt: + { + var _stmt = CapturedStmt.__CreateInstance(stmt.__Instance); + return VisitCapturedStmt(_stmt); + } + case StmtClass.CompoundStmt: + { + var _stmt = CompoundStmt.__CreateInstance(stmt.__Instance); + return VisitCompoundStmt(_stmt); + } + case StmtClass.ContinueStmt: + { + var _stmt = ContinueStmt.__CreateInstance(stmt.__Instance); + return VisitContinueStmt(_stmt); + } + case StmtClass.CoreturnStmt: + { + var _stmt = CoreturnStmt.__CreateInstance(stmt.__Instance); + return VisitCoreturnStmt(_stmt); + } + case StmtClass.CoroutineBodyStmt: + { + var _stmt = CoroutineBodyStmt.__CreateInstance(stmt.__Instance); + return VisitCoroutineBodyStmt(_stmt); + } + case StmtClass.DeclStmt: + { + var _stmt = DeclStmt.__CreateInstance(stmt.__Instance); + return VisitDeclStmt(_stmt); + } + case StmtClass.DoStmt: + { + var _stmt = DoStmt.__CreateInstance(stmt.__Instance); + return VisitDoStmt(_stmt); + } + case StmtClass.BinaryConditionalOperator: + { + var _stmt = BinaryConditionalOperator.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ConditionalOperator: + { + var _stmt = ConditionalOperator.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.AddrLabelExpr: + { + var _stmt = AddrLabelExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ArrayInitIndexExpr: + { + var _stmt = ArrayInitIndexExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ArrayInitLoopExpr: + { + var _stmt = ArrayInitLoopExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ArraySubscriptExpr: + { + var _stmt = ArraySubscriptExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ArrayTypeTraitExpr: + { + var _stmt = ArrayTypeTraitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.AsTypeExpr: + { + var _stmt = AsTypeExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.AtomicExpr: + { + var _stmt = AtomicExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.BinaryOperator: + { + var _stmt = BinaryOperator.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CompoundAssignOperator: + { + var _stmt = CompoundAssignOperator.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.BlockExpr: + { + var _stmt = BlockExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXBindTemporaryExpr: + { + var _stmt = CXXBindTemporaryExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXBoolLiteralExpr: + { + var _stmt = CXXBoolLiteralExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXConstructExpr: + { + var _stmt = CXXConstructExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXTemporaryObjectExpr: + { + var _stmt = CXXTemporaryObjectExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXDefaultArgExpr: + { + var _stmt = CXXDefaultArgExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXDefaultInitExpr: + { + var _stmt = CXXDefaultInitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXDeleteExpr: + { + var _stmt = CXXDeleteExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXDependentScopeMemberExpr: + { + var _stmt = CXXDependentScopeMemberExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXFoldExpr: + { + var _stmt = CXXFoldExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXInheritedCtorInitExpr: + { + var _stmt = CXXInheritedCtorInitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXNewExpr: + { + var _stmt = CXXNewExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXNoexceptExpr: + { + var _stmt = CXXNoexceptExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXNullPtrLiteralExpr: + { + var _stmt = CXXNullPtrLiteralExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXPseudoDestructorExpr: + { + var _stmt = CXXPseudoDestructorExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXScalarValueInitExpr: + { + var _stmt = CXXScalarValueInitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXStdInitializerListExpr: + { + var _stmt = CXXStdInitializerListExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXThisExpr: + { + var _stmt = CXXThisExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXThrowExpr: + { + var _stmt = CXXThrowExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXTypeidExpr: + { + var _stmt = CXXTypeidExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXUnresolvedConstructExpr: + { + var _stmt = CXXUnresolvedConstructExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXUuidofExpr: + { + var _stmt = CXXUuidofExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CallExpr: + { + var _stmt = CallExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CUDAKernelCallExpr: + { + var _stmt = CUDAKernelCallExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXMemberCallExpr: + { + var _stmt = CXXMemberCallExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXOperatorCallExpr: + { + var _stmt = CXXOperatorCallExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.UserDefinedLiteral: + { + var _stmt = UserDefinedLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CStyleCastExpr: + { + var _stmt = CStyleCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXFunctionalCastExpr: + { + var _stmt = CXXFunctionalCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXConstCastExpr: + { + var _stmt = CXXConstCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXDynamicCastExpr: + { + var _stmt = CXXDynamicCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXReinterpretCastExpr: + { + var _stmt = CXXReinterpretCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CXXStaticCastExpr: + { + var _stmt = CXXStaticCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ImplicitCastExpr: + { + var _stmt = ImplicitCastExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CharacterLiteral: + { + var _stmt = CharacterLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ChooseExpr: + { + var _stmt = ChooseExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CompoundLiteralExpr: + { + var _stmt = CompoundLiteralExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ConvertVectorExpr: + { + var _stmt = ConvertVectorExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CoawaitExpr: + { + var _stmt = CoawaitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.CoyieldExpr: + { + var _stmt = CoyieldExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.DeclRefExpr: + { + var _stmt = DeclRefExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.DependentCoawaitExpr: + { + var _stmt = DependentCoawaitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.DependentScopeDeclRefExpr: + { + var _stmt = DependentScopeDeclRefExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.DesignatedInitExpr: + { + var _stmt = DesignatedInitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.DesignatedInitUpdateExpr: + { + var _stmt = DesignatedInitUpdateExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ExpressionTraitExpr: + { + var _stmt = ExpressionTraitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ExtVectorElementExpr: + { + var _stmt = ExtVectorElementExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.FixedPointLiteral: + { + var _stmt = FixedPointLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.FloatingLiteral: + { + var _stmt = FloatingLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ConstantExpr: + { + var _stmt = ConstantExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ExprWithCleanups: + { + var _stmt = ExprWithCleanups.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.FunctionParmPackExpr: + { + var _stmt = FunctionParmPackExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.GNUNullExpr: + { + var _stmt = GNUNullExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.GenericSelectionExpr: + { + var _stmt = GenericSelectionExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ImaginaryLiteral: + { + var _stmt = ImaginaryLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ImplicitValueInitExpr: + { + var _stmt = ImplicitValueInitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.InitListExpr: + { + var _stmt = InitListExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.IntegerLiteral: + { + var _stmt = IntegerLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.LambdaExpr: + { + var _stmt = LambdaExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.MSPropertyRefExpr: + { + var _stmt = MSPropertyRefExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.MSPropertySubscriptExpr: + { + var _stmt = MSPropertySubscriptExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.MaterializeTemporaryExpr: + { + var _stmt = MaterializeTemporaryExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.MemberExpr: + { + var _stmt = MemberExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.NoInitExpr: + { + var _stmt = NoInitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.OffsetOfExpr: + { + var _stmt = OffsetOfExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.OpaqueValueExpr: + { + var _stmt = OpaqueValueExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.UnresolvedLookupExpr: + { + var _stmt = UnresolvedLookupExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.UnresolvedMemberExpr: + { + var _stmt = UnresolvedMemberExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.PackExpansionExpr: + { + var _stmt = PackExpansionExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ParenExpr: + { + var _stmt = ParenExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ParenListExpr: + { + var _stmt = ParenListExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.PredefinedExpr: + { + var _stmt = PredefinedExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.PseudoObjectExpr: + { + var _stmt = PseudoObjectExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ShuffleVectorExpr: + { + var _stmt = ShuffleVectorExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.SizeOfPackExpr: + { + var _stmt = SizeOfPackExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.StmtExpr: + { + var _stmt = StmtExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.StringLiteral: + { + var _stmt = StringLiteral.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.SubstNonTypeTemplateParmExpr: + { + var _stmt = SubstNonTypeTemplateParmExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.SubstNonTypeTemplateParmPackExpr: + { + var _stmt = SubstNonTypeTemplateParmPackExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.TypeTraitExpr: + { + var _stmt = TypeTraitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.TypoExpr: + { + var _stmt = TypoExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.UnaryExprOrTypeTraitExpr: + { + var _stmt = UnaryExprOrTypeTraitExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.UnaryOperator: + { + var _stmt = UnaryOperator.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.VAArgExpr: + { + var _stmt = VAArgExpr.__CreateInstance(stmt.__Instance); + return VisitExpression(_stmt as Expr) as TRet; + } + case StmtClass.ForStmt: + { + var _stmt = ForStmt.__CreateInstance(stmt.__Instance); + return VisitForStmt(_stmt); + } + case StmtClass.GotoStmt: + { + var _stmt = GotoStmt.__CreateInstance(stmt.__Instance); + return VisitGotoStmt(_stmt); + } + case StmtClass.IfStmt: + { + var _stmt = IfStmt.__CreateInstance(stmt.__Instance); + return VisitIfStmt(_stmt); + } + case StmtClass.IndirectGotoStmt: + { + var _stmt = IndirectGotoStmt.__CreateInstance(stmt.__Instance); + return VisitIndirectGotoStmt(_stmt); + } + case StmtClass.LabelStmt: + { + var _stmt = LabelStmt.__CreateInstance(stmt.__Instance); + return VisitLabelStmt(_stmt); + } + case StmtClass.MSDependentExistsStmt: + { + var _stmt = MSDependentExistsStmt.__CreateInstance(stmt.__Instance); + return VisitMSDependentExistsStmt(_stmt); + } + case StmtClass.NullStmt: + { + var _stmt = NullStmt.__CreateInstance(stmt.__Instance); + return VisitNullStmt(_stmt); + } + case StmtClass.ReturnStmt: + { + var _stmt = ReturnStmt.__CreateInstance(stmt.__Instance); + return VisitReturnStmt(_stmt); + } + case StmtClass.SEHExceptStmt: + { + var _stmt = SEHExceptStmt.__CreateInstance(stmt.__Instance); + return VisitSEHExceptStmt(_stmt); + } + case StmtClass.SEHFinallyStmt: + { + var _stmt = SEHFinallyStmt.__CreateInstance(stmt.__Instance); + return VisitSEHFinallyStmt(_stmt); + } + case StmtClass.SEHLeaveStmt: + { + var _stmt = SEHLeaveStmt.__CreateInstance(stmt.__Instance); + return VisitSEHLeaveStmt(_stmt); + } + case StmtClass.SEHTryStmt: + { + var _stmt = SEHTryStmt.__CreateInstance(stmt.__Instance); + return VisitSEHTryStmt(_stmt); + } + case StmtClass.CaseStmt: + { + var _stmt = CaseStmt.__CreateInstance(stmt.__Instance); + return VisitCaseStmt(_stmt); + } + case StmtClass.DefaultStmt: + { + var _stmt = DefaultStmt.__CreateInstance(stmt.__Instance); + return VisitDefaultStmt(_stmt); + } + case StmtClass.SwitchStmt: + { + var _stmt = SwitchStmt.__CreateInstance(stmt.__Instance); + return VisitSwitchStmt(_stmt); + } + case StmtClass.WhileStmt: + { + var _stmt = WhileStmt.__CreateInstance(stmt.__Instance); + return VisitWhileStmt(_stmt); + } + default: + throw new System.NotImplementedException(stmt.StmtClass.ToString()); + } + } + } + + public unsafe class StmtConverter : StmtVisitor + { + public override AST.Stmt VisitDeclStmt(DeclStmt stmt) + { + var _stmt = new AST.DeclStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.IsSingleDecl = stmt.IsSingleDecl; + for (uint i = 0; i < stmt.GetdeclsCount; i++) + { + var _E = stmt.Getdecls(i); + _stmt.Decls.Add(VisitDeclaration(_E) as AST.Declaration); + } + return _stmt; + } + + public override AST.Stmt VisitNullStmt(NullStmt stmt) + { + var _stmt = new AST.NullStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.SemiLoc = VisitSourceLocation(stmt.SemiLoc); + _stmt.HasLeadingEmptyMacro = stmt.HasLeadingEmptyMacro; + return _stmt; + } + + public override AST.Stmt VisitCompoundStmt(CompoundStmt stmt) + { + var _stmt = new AST.CompoundStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.BodyEmpty = stmt.BodyEmpty; + _stmt.Size = stmt.Size; + _stmt.LBracLoc = VisitSourceLocation(stmt.LBracLoc); + _stmt.RBracLoc = VisitSourceLocation(stmt.RBracLoc); + for (uint i = 0; i < stmt.GetbodyCount; i++) + { + var _E = stmt.Getbody(i); + _stmt.Body.Add(VisitStatement(_E) as AST.Stmt); + } + return _stmt; + } + + public override AST.Stmt VisitCaseStmt(CaseStmt stmt) + { + var _stmt = new AST.CaseStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.KeywordLoc = VisitSourceLocation(stmt.KeywordLoc); + _stmt.ColonLoc = VisitSourceLocation(stmt.ColonLoc); + _stmt.CaseLoc = VisitSourceLocation(stmt.CaseLoc); + _stmt.EllipsisLoc = VisitSourceLocation(stmt.EllipsisLoc); + _stmt.LHS = VisitExpression(stmt.LHS) as AST.Expr; + _stmt.RHS = VisitExpression(stmt.RHS) as AST.Expr; + _stmt.SubStmt = VisitStatement(stmt.SubStmt) as AST.Stmt; + _stmt.CaseStmtIsGNURange = stmt.CaseStmtIsGNURange; + return _stmt; + } + + public override AST.Stmt VisitDefaultStmt(DefaultStmt stmt) + { + var _stmt = new AST.DefaultStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.KeywordLoc = VisitSourceLocation(stmt.KeywordLoc); + _stmt.ColonLoc = VisitSourceLocation(stmt.ColonLoc); + _stmt.SubStmt = VisitStatement(stmt.SubStmt) as AST.Stmt; + _stmt.DefaultLoc = VisitSourceLocation(stmt.DefaultLoc); + return _stmt; + } + + public override AST.Stmt VisitLabelStmt(LabelStmt stmt) + { + var _stmt = new AST.LabelStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.IdentLoc = VisitSourceLocation(stmt.IdentLoc); + _stmt.SubStmt = VisitStatement(stmt.SubStmt) as AST.Stmt; + _stmt.Name = stmt.Name; + return _stmt; + } + + public override AST.Stmt VisitAttributedStmt(AttributedStmt stmt) + { + var _stmt = new AST.AttributedStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.AttrLoc = VisitSourceLocation(stmt.AttrLoc); + return _stmt; + } + + public override AST.Stmt VisitIfStmt(IfStmt stmt) + { + var _stmt = new AST.IfStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.Cond = VisitExpression(stmt.Cond) as AST.Expr; + _stmt.Then = VisitStatement(stmt.Then) as AST.Stmt; + _stmt.Else = VisitStatement(stmt.Else) as AST.Stmt; + _stmt.Init = VisitStatement(stmt.Init) as AST.Stmt; + _stmt.IfLoc = VisitSourceLocation(stmt.IfLoc); + _stmt.ElseLoc = VisitSourceLocation(stmt.ElseLoc); + _stmt.Constexpr = stmt.Constexpr; + _stmt.HasInitStorage = stmt.HasInitStorage; + _stmt.HasVarStorage = stmt.HasVarStorage; + _stmt.HasElseStorage = stmt.HasElseStorage; + _stmt.IsObjCAvailabilityCheck = stmt.IsObjCAvailabilityCheck; + return _stmt; + } + + public override AST.Stmt VisitSwitchStmt(SwitchStmt stmt) + { + var _stmt = new AST.SwitchStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.Cond = VisitExpression(stmt.Cond) as AST.Expr; + _stmt.Body = VisitStatement(stmt.Body) as AST.Stmt; + _stmt.Init = VisitStatement(stmt.Init) as AST.Stmt; + _stmt.SwitchLoc = VisitSourceLocation(stmt.SwitchLoc); + _stmt.HasInitStorage = stmt.HasInitStorage; + _stmt.HasVarStorage = stmt.HasVarStorage; + _stmt.IsAllEnumCasesCovered = stmt.IsAllEnumCasesCovered; + return _stmt; + } + + public override AST.Stmt VisitWhileStmt(WhileStmt stmt) + { + var _stmt = new AST.WhileStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.Cond = VisitExpression(stmt.Cond) as AST.Expr; + _stmt.Body = VisitStatement(stmt.Body) as AST.Stmt; + _stmt.WhileLoc = VisitSourceLocation(stmt.WhileLoc); + _stmt.HasVarStorage = stmt.HasVarStorage; + return _stmt; + } + + public override AST.Stmt VisitDoStmt(DoStmt stmt) + { + var _stmt = new AST.DoStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.Cond = VisitExpression(stmt.Cond) as AST.Expr; + _stmt.Body = VisitStatement(stmt.Body) as AST.Stmt; + _stmt.DoLoc = VisitSourceLocation(stmt.DoLoc); + _stmt.WhileLoc = VisitSourceLocation(stmt.WhileLoc); + _stmt.RParenLoc = VisitSourceLocation(stmt.RParenLoc); + return _stmt; + } + + public override AST.Stmt VisitForStmt(ForStmt stmt) + { + var _stmt = new AST.ForStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.Init = VisitStatement(stmt.Init) as AST.Stmt; + _stmt.Cond = VisitExpression(stmt.Cond) as AST.Expr; + _stmt.Inc = VisitExpression(stmt.Inc) as AST.Expr; + _stmt.Body = VisitStatement(stmt.Body) as AST.Stmt; + _stmt.ForLoc = VisitSourceLocation(stmt.ForLoc); + _stmt.LParenLoc = VisitSourceLocation(stmt.LParenLoc); + _stmt.RParenLoc = VisitSourceLocation(stmt.RParenLoc); + _stmt.ConditionVariableDeclStmt = VisitStatement(stmt.ConditionVariableDeclStmt) as AST.DeclStmt; + return _stmt; + } + + public override AST.Stmt VisitGotoStmt(GotoStmt stmt) + { + var _stmt = new AST.GotoStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.GotoLoc = VisitSourceLocation(stmt.GotoLoc); + _stmt.LabelLoc = VisitSourceLocation(stmt.LabelLoc); + return _stmt; + } + + public override AST.Stmt VisitIndirectGotoStmt(IndirectGotoStmt stmt) + { + var _stmt = new AST.IndirectGotoStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.GotoLoc = VisitSourceLocation(stmt.GotoLoc); + _stmt.StarLoc = VisitSourceLocation(stmt.StarLoc); + _stmt.Target = VisitExpression(stmt.Target) as AST.Expr; + return _stmt; + } + + public override AST.Stmt VisitContinueStmt(ContinueStmt stmt) + { + var _stmt = new AST.ContinueStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.ContinueLoc = VisitSourceLocation(stmt.ContinueLoc); + return _stmt; + } + + public override AST.Stmt VisitBreakStmt(BreakStmt stmt) + { + var _stmt = new AST.BreakStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.BreakLoc = VisitSourceLocation(stmt.BreakLoc); + return _stmt; + } + + public override AST.Stmt VisitReturnStmt(ReturnStmt stmt) + { + var _stmt = new AST.ReturnStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.RetValue = VisitExpression(stmt.RetValue) as AST.Expr; + _stmt.ReturnLoc = VisitSourceLocation(stmt.ReturnLoc); + return _stmt; + } + + public override AST.Stmt VisitGCCAsmStmt(GCCAsmStmt stmt) + { + var _stmt = new AST.GCCAsmStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.AsmLoc = VisitSourceLocation(stmt.AsmLoc); + _stmt.Simple = stmt.Simple; + _stmt.Volatile = stmt.Volatile; + _stmt.NumOutputs = stmt.NumOutputs; + _stmt.NumPlusOperands = stmt.NumPlusOperands; + _stmt.NumInputs = stmt.NumInputs; + _stmt.NumClobbers = stmt.NumClobbers; + for (uint i = 0; i < stmt.GetinputsCount; i++) + { + var _E = stmt.Getinputs(i); + _stmt.Inputs.Add(VisitExpression(_E) as AST.Expr); + } + for (uint i = 0; i < stmt.GetoutputsCount; i++) + { + var _E = stmt.Getoutputs(i); + _stmt.Outputs.Add(VisitExpression(_E) as AST.Expr); + } + _stmt.RParenLoc = VisitSourceLocation(stmt.RParenLoc); + return _stmt; + } + + public override AST.Stmt VisitMSAsmStmt(MSAsmStmt stmt) + { + var _stmt = new AST.MSAsmStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.AsmLoc = VisitSourceLocation(stmt.AsmLoc); + _stmt.Simple = stmt.Simple; + _stmt.Volatile = stmt.Volatile; + _stmt.NumOutputs = stmt.NumOutputs; + _stmt.NumPlusOperands = stmt.NumPlusOperands; + _stmt.NumInputs = stmt.NumInputs; + _stmt.NumClobbers = stmt.NumClobbers; + for (uint i = 0; i < stmt.GetinputsCount; i++) + { + var _E = stmt.Getinputs(i); + _stmt.Inputs.Add(VisitExpression(_E) as AST.Expr); + } + for (uint i = 0; i < stmt.GetoutputsCount; i++) + { + var _E = stmt.Getoutputs(i); + _stmt.Outputs.Add(VisitExpression(_E) as AST.Expr); + } + _stmt.LBraceLoc = VisitSourceLocation(stmt.LBraceLoc); + _stmt.HasBraces = stmt.HasBraces; + _stmt.NumAsmToks = stmt.NumAsmToks; + _stmt.AsmString = stmt.AsmString; + return _stmt; + } + + public override AST.Stmt VisitSEHExceptStmt(SEHExceptStmt stmt) + { + var _stmt = new AST.SEHExceptStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.ExceptLoc = VisitSourceLocation(stmt.ExceptLoc); + _stmt.FilterExpr = VisitExpression(stmt.FilterExpr) as AST.Expr; + _stmt.Block = VisitStatement(stmt.Block) as AST.CompoundStmt; + return _stmt; + } + + public override AST.Stmt VisitSEHFinallyStmt(SEHFinallyStmt stmt) + { + var _stmt = new AST.SEHFinallyStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.FinallyLoc = VisitSourceLocation(stmt.FinallyLoc); + _stmt.Block = VisitStatement(stmt.Block) as AST.CompoundStmt; + return _stmt; + } + + public override AST.Stmt VisitSEHTryStmt(SEHTryStmt stmt) + { + var _stmt = new AST.SEHTryStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.TryLoc = VisitSourceLocation(stmt.TryLoc); + _stmt.IsCXXTry = stmt.IsCXXTry; + _stmt.TryBlock = VisitStatement(stmt.TryBlock) as AST.CompoundStmt; + _stmt.Handler = VisitStatement(stmt.Handler) as AST.Stmt; + _stmt.ExceptHandler = VisitStatement(stmt.ExceptHandler) as AST.SEHExceptStmt; + _stmt.FinallyHandler = VisitStatement(stmt.FinallyHandler) as AST.SEHFinallyStmt; + return _stmt; + } + + public override AST.Stmt VisitSEHLeaveStmt(SEHLeaveStmt stmt) + { + var _stmt = new AST.SEHLeaveStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.LeaveLoc = VisitSourceLocation(stmt.LeaveLoc); + return _stmt; + } + + public override AST.Stmt VisitCapturedStmt(CapturedStmt stmt) + { + var _stmt = new AST.CapturedStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.CaptureSize = stmt.CaptureSize; + for (uint i = 0; i < stmt.GetcaptureInitsCount; i++) + { + var _E = stmt.GetcaptureInits(i); + _stmt.CaptureInits.Add(VisitExpression(_E) as AST.Expr); + } + return _stmt; + } + + public override AST.Stmt VisitCXXCatchStmt(CXXCatchStmt stmt) + { + var _stmt = new AST.CXXCatchStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.CatchLoc = VisitSourceLocation(stmt.CatchLoc); + _stmt.CaughtType = VisitQualifiedType(stmt.CaughtType); + _stmt.HandlerBlock = VisitStatement(stmt.HandlerBlock) as AST.Stmt; + return _stmt; + } + + public override AST.Stmt VisitCXXTryStmt(CXXTryStmt stmt) + { + var _stmt = new AST.CXXTryStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.TryLoc = VisitSourceLocation(stmt.TryLoc); + _stmt.NumHandlers = stmt.NumHandlers; + return _stmt; + } + + public override AST.Stmt VisitCXXForRangeStmt(CXXForRangeStmt stmt) + { + var _stmt = new AST.CXXForRangeStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.Init = VisitStatement(stmt.Init) as AST.Stmt; + _stmt.RangeInit = VisitExpression(stmt.RangeInit) as AST.Expr; + _stmt.Cond = VisitExpression(stmt.Cond) as AST.Expr; + _stmt.Inc = VisitExpression(stmt.Inc) as AST.Expr; + _stmt.Body = VisitStatement(stmt.Body) as AST.Stmt; + _stmt.ForLoc = VisitSourceLocation(stmt.ForLoc); + _stmt.CoawaitLoc = VisitSourceLocation(stmt.CoawaitLoc); + _stmt.ColonLoc = VisitSourceLocation(stmt.ColonLoc); + _stmt.RParenLoc = VisitSourceLocation(stmt.RParenLoc); + return _stmt; + } + + public override AST.Stmt VisitMSDependentExistsStmt(MSDependentExistsStmt stmt) + { + var _stmt = new AST.MSDependentExistsStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.KeywordLoc = VisitSourceLocation(stmt.KeywordLoc); + _stmt.IsIfExists = stmt.IsIfExists; + _stmt.IsIfNotExists = stmt.IsIfNotExists; + _stmt.SubStmt = VisitStatement(stmt.SubStmt) as AST.CompoundStmt; + return _stmt; + } + + public override AST.Stmt VisitCoroutineBodyStmt(CoroutineBodyStmt stmt) + { + var _stmt = new AST.CoroutineBodyStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.HasDependentPromiseType = stmt.HasDependentPromiseType; + _stmt.Body = VisitStatement(stmt.Body) as AST.Stmt; + _stmt.PromiseDeclStmt = VisitStatement(stmt.PromiseDeclStmt) as AST.Stmt; + _stmt.InitSuspendStmt = VisitStatement(stmt.InitSuspendStmt) as AST.Stmt; + _stmt.FinalSuspendStmt = VisitStatement(stmt.FinalSuspendStmt) as AST.Stmt; + _stmt.ExceptionHandler = VisitStatement(stmt.ExceptionHandler) as AST.Stmt; + _stmt.FallthroughHandler = VisitStatement(stmt.FallthroughHandler) as AST.Stmt; + _stmt.Allocate = VisitExpression(stmt.Allocate) as AST.Expr; + _stmt.Deallocate = VisitExpression(stmt.Deallocate) as AST.Expr; + _stmt.ReturnValueInit = VisitExpression(stmt.ReturnValueInit) as AST.Expr; + _stmt.ResultDecl = VisitStatement(stmt.ResultDecl) as AST.Stmt; + _stmt.ReturnStmt = VisitStatement(stmt.ReturnStmt) as AST.Stmt; + _stmt.ReturnStmtOnAllocFailure = VisitStatement(stmt.ReturnStmtOnAllocFailure) as AST.Stmt; + return _stmt; + } + + public override AST.Stmt VisitCoreturnStmt(CoreturnStmt stmt) + { + var _stmt = new AST.CoreturnStmt(); + _stmt.SourceRange = VisitSourceRange(stmt.SourceRange); + _stmt.EndLoc = VisitSourceLocation(stmt.EndLoc); + _stmt.IsImplicit = stmt.IsImplicit; + _stmt.KeywordLoc = VisitSourceLocation(stmt.KeywordLoc); + _stmt.Operand = VisitExpression(stmt.Operand) as AST.Expr; + _stmt.PromiseCall = VisitExpression(stmt.PromiseCall) as AST.Expr; + return _stmt; + } + } +} diff --git a/src/Parser/ASTConverter.cs b/src/Parser/ASTConverter.cs index e9ce642f..5d6ece61 100644 --- a/src/Parser/ASTConverter.cs +++ b/src/Parser/ASTConverter.cs @@ -381,14 +381,24 @@ namespace CppSharp readonly TypeConverter typeConverter; readonly DeclConverter declConverter; readonly CommentConverter commentConverter; + readonly StmtConverter stmtConverter; + readonly ExprConverter exprConverter; public ASTConverter(ASTContext context) { Context = context; typeConverter = new TypeConverter(); commentConverter = new CommentConverter(); - declConverter = new DeclConverter(typeConverter, commentConverter); + stmtConverter = new StmtConverter(); + declConverter = new DeclConverter(typeConverter, commentConverter, stmtConverter); typeConverter.declConverter = declConverter; + + exprConverter = new ExprConverter(); + + ConversionUtils.typeConverter = typeConverter; + ConversionUtils.declConverter = declConverter; + ConversionUtils.stmtConverter = stmtConverter; + ConversionUtils.exprConverter = exprConverter; } public AST.ASTContext Convert() @@ -813,16 +823,18 @@ namespace CppSharp { readonly TypeConverter typeConverter; readonly CommentConverter commentConverter; + readonly StmtConverter stmtConverter; readonly Dictionary Declarations; readonly Dictionary PreprocessedEntities; readonly Dictionary FunctionTemplateSpecializations; - public DeclConverter(TypeConverter type, CommentConverter comment) + public DeclConverter(TypeConverter type, CommentConverter comment, StmtConverter stmt) { NativeObjects = new HashSet(); typeConverter = type; commentConverter = comment; + stmtConverter = stmt; Declarations = new Dictionary(); PreprocessedEntities = new Dictionary(); FunctionTemplateSpecializations = new Dictionary(); @@ -1202,6 +1214,12 @@ namespace CppSharp _function.Parameters.Add(_param); } + if (function.BodyStmt != null) + { + var _stmt = stmtConverter.Visit(function.BodyStmt); + _function.BodyStmt = _stmt; + } + _function.FunctionType = typeConverter.VisitQualified(function.QualifiedType); if (function.SpecializationInfo != null) _function.SpecializationInfo = VisitFunctionTemplateSpecialization( @@ -2124,5 +2142,51 @@ namespace CppSharp } } + public static class ConversionUtils + { + public static TypeConverter typeConverter; + public static DeclConverter declConverter; + public static StmtConverter stmtConverter; + public static ExprConverter exprConverter; + + public static AST.QualifiedType VisitQualifiedType( + QualifiedType qualifiedType) + { + return typeConverter.VisitQualified(qualifiedType); + } + + public static AST.SourceRange VisitSourceRange(Parser.SourceRange loc) + { + return new AST.SourceRange(); + } + + public static AST.SourceLocation VisitSourceLocation( + Parser.SourceLocation loc) + { + return new AST.SourceLocation(loc.ID); + } + + public static AST.Declaration VisitDeclaration(Parser.AST.Declaration decl) + { + return declConverter.Visit(decl); + } + + public static AST.Stmt VisitStatement(Parser.AST.Stmt stmt) + { + return stmtConverter.Visit(stmt); + } + + public static AST.Expr VisitExpression(Parser.AST.Expr expr) + { + return exprConverter.Visit(expr); + } + + public static AST.TemplateArgument VisitTemplateArgument( + Parser.AST.TemplateArgument templateArg) + { + return new AST.TemplateArgument(); + } + } + #endregion }