From d0ad681a6100612623eb18a3e65682641adf8681 Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Sat, 7 Nov 2015 01:17:41 +0200 Subject: [PATCH] Extended the AST and the parser to support call expressions in default args. Signed-off-by: Dimitar Dobrev --- src/AST/Expression.cs | 37 +++-- src/Core/Parser/ASTConverter.cs | 10 ++ src/CppParser/AST.cpp | 5 + src/CppParser/AST.h | 8 ++ src/CppParser/Bindings/CLI/AST.cpp | 53 ++++++++ src/CppParser/Bindings/CLI/AST.h | 35 ++++- .../CSharp/i686-apple-darwin12.4.0/AST.cs | 128 +++++++++++++++++- .../Bindings/CSharp/i686-pc-win32-msvc/AST.cs | 128 +++++++++++++++++- .../CSharp/x86_64-apple-darwin12.4.0/AST.cs | 128 +++++++++++++++++- .../Bindings/CSharp/x86_64-linux-gnu/AST.cs | 128 +++++++++++++++++- src/CppParser/Parser.cpp | 13 +- 11 files changed, 636 insertions(+), 37 deletions(-) diff --git a/src/AST/Expression.cs b/src/AST/Expression.cs index 865f54a1..e5b71728 100644 --- a/src/AST/Expression.cs +++ b/src/AST/Expression.cs @@ -42,9 +42,29 @@ namespace CppSharp.AST } } - public class CXXConstructExpr : Expression + public class BinaryOperator : Expression { - public CXXConstructExpr() + public BinaryOperator(Expression lhs, Expression rhs, string opcodeStr) + { + Class = StatementClass.BinaryOperator; + LHS = lhs; + RHS = rhs; + OpcodeStr = opcodeStr; + } + + public Expression LHS { get; set; } + public Expression RHS { get; set; } + public string OpcodeStr { get; set; } + + public override T Visit(IExpressionVisitor visitor) + { + return visitor.VisitExpression(this); + } + } + + public class CallExpr : Expression + { + public CallExpr() { Arguments = new List(); } @@ -57,19 +77,14 @@ namespace CppSharp.AST } } - public class BinaryOperator : Expression + public class CXXConstructExpr : Expression { - public BinaryOperator(Expression lhs, Expression rhs, string opcodeStr) + public CXXConstructExpr() { - Class = StatementClass.BinaryOperator; - this.LHS = lhs; - this.RHS = rhs; - this.OpcodeStr = opcodeStr; + Arguments = new List(); } - public Expression LHS { get; set; } - public Expression RHS { get; set; } - public string OpcodeStr { get; set; } + public List Arguments { get; private set; } public override T Visit(IExpressionVisitor visitor) { diff --git a/src/Core/Parser/ASTConverter.cs b/src/Core/Parser/ASTConverter.cs index 8da4fa1f..86ef7f73 100644 --- a/src/Core/Parser/ASTConverter.cs +++ b/src/Core/Parser/ASTConverter.cs @@ -932,6 +932,16 @@ namespace CppSharp expression = new AST.BinaryOperator(VisitStatement(binaryOperator.LHS), VisitStatement(binaryOperator.RHS), binaryOperator.OpcodeStr); break; + case StatementClass.CallExprClass: + var callExpression = new AST.CallExpr(); + var callExpr = CallExpr.__CreateInstance(statement.__Instance); + for (uint i = 0; i < callExpr.ArgumentsCount; i++) + { + var argument = VisitStatement(callExpr.getArguments(i)); + callExpression.Arguments.Add(argument); + } + expression = callExpression; + break; case StatementClass.DeclRefExprClass: expression = new AST.BuiltinTypeExpression(); expression.Class = AST.StatementClass.DeclarationReference; diff --git a/src/CppParser/AST.cpp b/src/CppParser/AST.cpp index a03eb9b0..2e7aeea2 100644 --- a/src/CppParser/AST.cpp +++ b/src/CppParser/AST.cpp @@ -488,6 +488,11 @@ BinaryOperator::BinaryOperator(const std::string& str, Expression* lhs, Expressi DEF_STRING(BinaryOperator, OpcodeStr) +CallExpr::CallExpr(const std::string& str, Declaration* decl) + : Expression(str, StatementClass::CallExprClass, decl) {} + +DEF_VECTOR(CallExpr, Expression*, Arguments) + CXXConstructExpr::CXXConstructExpr(const std::string& str, Declaration* decl) : Expression(str, StatementClass::CXXConstructExprClass, decl) {} diff --git a/src/CppParser/AST.h b/src/CppParser/AST.h index 37772206..f6630f0e 100644 --- a/src/CppParser/AST.h +++ b/src/CppParser/AST.h @@ -481,6 +481,7 @@ enum class StatementClass { Any, BinaryOperator, + CallExprClass, DeclRefExprClass, CXXConstructExprClass, CXXOperatorCallExpr, @@ -512,6 +513,13 @@ public: STRING(OpcodeStr) }; +class CS_API CallExpr : public Expression +{ +public: + CallExpr(const std::string& str, Declaration* decl); + VECTOR(Expression*, Arguments) +}; + class CS_API CXXConstructExpr : public Expression { public: diff --git a/src/CppParser/Bindings/CLI/AST.cpp b/src/CppParser/Bindings/CLI/AST.cpp index 499a8d21..6280ac7a 100644 --- a/src/CppParser/Bindings/CLI/AST.cpp +++ b/src/CppParser/Bindings/CLI/AST.cpp @@ -2330,6 +2330,59 @@ void CppSharp::Parser::AST::BinaryOperator::RHS::set(CppSharp::Parser::AST::Expr ((::CppSharp::CppParser::AST::BinaryOperator*)NativePtr)->RHS = (::CppSharp::CppParser::AST::Expression*)value->NativePtr; } +CppSharp::Parser::AST::CallExpr::CallExpr(::CppSharp::CppParser::AST::CallExpr* native) + : CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)native) +{ +} + +CppSharp::Parser::AST::CallExpr^ CppSharp::Parser::AST::CallExpr::__CreateInstance(::System::IntPtr native) +{ + return ::CppSharp::Parser::AST::CallExpr::__CreateInstance(native, false); +} + +CppSharp::Parser::AST::CallExpr^ CppSharp::Parser::AST::CallExpr::__CreateInstance(::System::IntPtr native, bool __ownsNativeInstance) +{ + ::CppSharp::Parser::AST::CallExpr^ result = gcnew ::CppSharp::Parser::AST::CallExpr((::CppSharp::CppParser::AST::CallExpr*) native.ToPointer()); + result->__ownsNativeInstance = __ownsNativeInstance; + return result; +} + +CppSharp::Parser::AST::CallExpr::~CallExpr() +{ +} + +CppSharp::Parser::AST::Expression^ CppSharp::Parser::AST::CallExpr::getArguments(unsigned int i) +{ + auto __ret = ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->getArguments(i); + if (__ret == nullptr) return nullptr; + return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)__ret); +} + +void CppSharp::Parser::AST::CallExpr::addArguments(CppSharp::Parser::AST::Expression^ s) +{ + auto arg0 = (::CppSharp::CppParser::AST::Expression*)s->NativePtr; + ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->addArguments(arg0); +} + +void CppSharp::Parser::AST::CallExpr::clearArguments() +{ + ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->clearArguments(); +} + +CppSharp::Parser::AST::CallExpr::CallExpr(CppSharp::Parser::AST::CallExpr^ _0) + : CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)nullptr) +{ + __ownsNativeInstance = true; + auto &arg0 = *(::CppSharp::CppParser::AST::CallExpr*)_0->NativePtr; + NativePtr = new ::CppSharp::CppParser::AST::CallExpr(arg0); +} + +unsigned int CppSharp::Parser::AST::CallExpr::ArgumentsCount::get() +{ + auto __ret = ((::CppSharp::CppParser::AST::CallExpr*)NativePtr)->getArgumentsCount(); + return __ret; +} + CppSharp::Parser::AST::CXXConstructExpr::CXXConstructExpr(::CppSharp::CppParser::AST::CXXConstructExpr* native) : CppSharp::Parser::AST::Expression((::CppSharp::CppParser::AST::Expression*)native) { diff --git a/src/CppParser/Bindings/CLI/AST.h b/src/CppParser/Bindings/CLI/AST.h index 9489a6a9..5f028824 100644 --- a/src/CppParser/Bindings/CLI/AST.h +++ b/src/CppParser/Bindings/CLI/AST.h @@ -35,6 +35,7 @@ namespace CppSharp ref class BlockContentComment; ref class BuiltinType; ref class CXXConstructExpr; + ref class CallExpr; ref class Class; ref class ClassLayout; ref class ClassTemplate; @@ -230,11 +231,12 @@ namespace CppSharp { Any = 0, BinaryOperator = 1, - DeclRefExprClass = 2, - CXXConstructExprClass = 3, - CXXOperatorCallExpr = 4, - ImplicitCastExpr = 5, - ExplicitCastExpr = 6 + CallExprClass = 2, + DeclRefExprClass = 3, + CXXConstructExprClass = 4, + CXXOperatorCallExpr = 5, + ImplicitCastExpr = 6, + ExplicitCastExpr = 7 }; public enum struct TemplateSpecializationKind @@ -1505,6 +1507,29 @@ namespace CppSharp } }; + public ref class CallExpr : CppSharp::Parser::AST::Expression + { + public: + + CallExpr(::CppSharp::CppParser::AST::CallExpr* native); + static CallExpr^ __CreateInstance(::System::IntPtr native); + static CallExpr^ __CreateInstance(::System::IntPtr native, bool __ownsNativeInstance); + CallExpr(CppSharp::Parser::AST::CallExpr^ _0); + + ~CallExpr(); + + property unsigned int ArgumentsCount + { + unsigned int get(); + } + + CppSharp::Parser::AST::Expression^ getArguments(unsigned int i); + + void addArguments(CppSharp::Parser::AST::Expression^ s); + + void clearArguments(); + }; + public ref class CXXConstructExpr : CppSharp::Parser::AST::Expression { public: diff --git a/src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/AST.cs b/src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/AST.cs index 05acb356..bae25cd9 100644 --- a/src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/AST.cs +++ b/src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/AST.cs @@ -136,11 +136,12 @@ namespace CppSharp { Any = 0, BinaryOperator = 1, - DeclRefExprClass = 2, - CXXConstructExprClass = 3, - CXXOperatorCallExpr = 4, - ImplicitCastExpr = 5, - ExplicitCastExpr = 6 + CallExprClass = 2, + DeclRefExprClass = 3, + CXXConstructExprClass = 4, + CXXOperatorCallExpr = 5, + ImplicitCastExpr = 6, + ExplicitCastExpr = 7 } public enum TemplateSpecializationKind @@ -4888,6 +4889,123 @@ namespace CppSharp } } + public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 32)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.StatementClass Class; + + [FieldOffset(4)] + public global::System.IntPtr Decl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12getArgumentsEj")] + internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12addArgumentsERPNS1_10ExpressionE")] + internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false) + { + return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance }; + } + + public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false) + { + return new CallExpr(native, skipVTables); + } + + private static CallExpr.Internal* __CopyValue(CallExpr.Internal native) + { + var ret = Marshal.AllocHGlobal(32); + CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native)); + return (CallExpr.Internal*) ret; + } + + private CallExpr(CallExpr.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected CallExpr(CallExpr.Internal* native, bool skipVTables = false) + : base((CppSharp.Parser.AST.Expression.Internal*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public CallExpr(CppSharp.Parser.AST.CallExpr _0) + : this((Internal*) null) + { + __Instance = Marshal.AllocHGlobal(32); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance; + Internal.cctor_2((__Instance + __PointerAdjustment), arg0); + } + + public CppSharp.Parser.AST.Expression getArguments(uint i) + { + var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i); + CppSharp.Parser.AST.Expression __result0; + if (__ret == IntPtr.Zero) __result0 = null; + else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret)) + __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret]; + else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret); + return __result0; + } + + public void addArguments(CppSharp.Parser.AST.Expression s) + { + var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0((__Instance + __PointerAdjustment), arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0((__Instance + __PointerAdjustment)); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment)); + return __ret; + } + } + } + public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 32)] diff --git a/src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs b/src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs index 2658cfe9..f2ef1138 100644 --- a/src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs +++ b/src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs @@ -136,11 +136,12 @@ namespace CppSharp { Any = 0, BinaryOperator = 1, - DeclRefExprClass = 2, - CXXConstructExprClass = 3, - CXXOperatorCallExpr = 4, - ImplicitCastExpr = 5, - ExplicitCastExpr = 6 + CallExprClass = 2, + DeclRefExprClass = 3, + CXXConstructExprClass = 4, + CXXOperatorCallExpr = 5, + ImplicitCastExpr = 6, + ExplicitCastExpr = 7 } public enum TemplateSpecializationKind @@ -4888,6 +4889,123 @@ namespace CppSharp } } + public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 44)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.StatementClass Class; + + [FieldOffset(4)] + public global::System.IntPtr Decl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="??0CallExpr@AST@CppParser@CppSharp@@QAE@ABV0123@@Z")] + internal static extern global::System.IntPtr cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="??1CallExpr@AST@CppParser@CppSharp@@QAE@XZ")] + internal static extern void dtor_0(global::System.IntPtr instance, int delete); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="?getArguments@CallExpr@AST@CppParser@CppSharp@@QAEPAVExpression@234@I@Z")] + internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="?addArguments@CallExpr@AST@CppParser@CppSharp@@QAEXAAPAVExpression@234@@Z")] + internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="?clearArguments@CallExpr@AST@CppParser@CppSharp@@QAEXXZ")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="?getArgumentsCount@CallExpr@AST@CppParser@CppSharp@@QAEIXZ")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false) + { + return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance }; + } + + public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false) + { + return new CallExpr(native, skipVTables); + } + + private static CallExpr.Internal* __CopyValue(CallExpr.Internal native) + { + var ret = Marshal.AllocHGlobal(44); + CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native)); + return (CallExpr.Internal*) ret; + } + + private CallExpr(CallExpr.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected CallExpr(CallExpr.Internal* native, bool skipVTables = false) + : base((CppSharp.Parser.AST.Expression.Internal*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public CallExpr(CppSharp.Parser.AST.CallExpr _0) + : this((Internal*) null) + { + __Instance = Marshal.AllocHGlobal(44); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance; + Internal.cctor_2((__Instance + __PointerAdjustment), arg0); + } + + public CppSharp.Parser.AST.Expression getArguments(uint i) + { + var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i); + CppSharp.Parser.AST.Expression __result0; + if (__ret == IntPtr.Zero) __result0 = null; + else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret)) + __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret]; + else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret); + return __result0; + } + + public void addArguments(CppSharp.Parser.AST.Expression s) + { + var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0((__Instance + __PointerAdjustment), arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0((__Instance + __PointerAdjustment)); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment)); + return __ret; + } + } + } + public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 44)] diff --git a/src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/AST.cs b/src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/AST.cs index 148dffbd..b05d4916 100644 --- a/src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/AST.cs +++ b/src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/AST.cs @@ -136,11 +136,12 @@ namespace CppSharp { Any = 0, BinaryOperator = 1, - DeclRefExprClass = 2, - CXXConstructExprClass = 3, - CXXOperatorCallExpr = 4, - ImplicitCastExpr = 5, - ExplicitCastExpr = 6 + CallExprClass = 2, + DeclRefExprClass = 3, + CXXConstructExprClass = 4, + CXXOperatorCallExpr = 5, + ImplicitCastExpr = 6, + ExplicitCastExpr = 7 } public enum TemplateSpecializationKind @@ -4887,6 +4888,123 @@ namespace CppSharp } } + public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 64)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.StatementClass Class; + + [FieldOffset(8)] + public global::System.IntPtr Decl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12getArgumentsEj")] + internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12addArgumentsERPNS1_10ExpressionE")] + internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false) + { + return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance }; + } + + public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false) + { + return new CallExpr(native, skipVTables); + } + + private static CallExpr.Internal* __CopyValue(CallExpr.Internal native) + { + var ret = Marshal.AllocHGlobal(64); + CppSharp.Parser.AST.CallExpr.Internal.cctor_2(ret, new global::System.IntPtr(&native)); + return (CallExpr.Internal*) ret; + } + + private CallExpr(CallExpr.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected CallExpr(CallExpr.Internal* native, bool skipVTables = false) + : base((CppSharp.Parser.AST.Expression.Internal*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public CallExpr(CppSharp.Parser.AST.CallExpr _0) + : this((Internal*) null) + { + __Instance = Marshal.AllocHGlobal(64); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance; + Internal.cctor_2((__Instance + __PointerAdjustment), arg0); + } + + public CppSharp.Parser.AST.Expression getArguments(uint i) + { + var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i); + CppSharp.Parser.AST.Expression __result0; + if (__ret == IntPtr.Zero) __result0 = null; + else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret)) + __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret]; + else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret); + return __result0; + } + + public void addArguments(CppSharp.Parser.AST.Expression s) + { + var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0((__Instance + __PointerAdjustment), arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0((__Instance + __PointerAdjustment)); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment)); + return __ret; + } + } + } + public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 64)] diff --git a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs index 49921841..3bb4d2a9 100644 --- a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs +++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs @@ -136,11 +136,12 @@ namespace CppSharp { Any = 0, BinaryOperator = 1, - DeclRefExprClass = 2, - CXXConstructExprClass = 3, - CXXOperatorCallExpr = 4, - ImplicitCastExpr = 5, - ExplicitCastExpr = 6 + CallExprClass = 2, + DeclRefExprClass = 3, + CXXConstructExprClass = 4, + CXXOperatorCallExpr = 5, + ImplicitCastExpr = 6, + ExplicitCastExpr = 7 } public enum TemplateSpecializationKind @@ -4887,6 +4888,123 @@ namespace CppSharp } } + public unsafe partial class CallExpr : CppSharp.Parser.AST.Expression, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 48)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.StatementClass Class; + + [FieldOffset(8)] + public global::System.IntPtr Decl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExprD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12getArgumentsEj")] + internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr12addArgumentsERPNS1_10ExpressionE")] + internal static extern void addArguments_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8CallExpr17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + public static new CallExpr __CreateInstance(global::System.IntPtr native, bool ownsNativeInstance = false, bool skipVTables = false) + { + return new CallExpr((CallExpr.Internal*) native, skipVTables) { __ownsNativeInstance = ownsNativeInstance }; + } + + public static CallExpr __CreateInstance(CallExpr.Internal native, bool skipVTables = false) + { + return new CallExpr(native, skipVTables); + } + + private static CallExpr.Internal* __CopyValue(CallExpr.Internal native) + { + var ret = Marshal.AllocHGlobal(48); + CppSharp.Parser.AST.CallExpr.Internal.cctor_1(ret, new global::System.IntPtr(&native)); + return (CallExpr.Internal*) ret; + } + + private CallExpr(CallExpr.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected CallExpr(CallExpr.Internal* native, bool skipVTables = false) + : base((CppSharp.Parser.AST.Expression.Internal*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public CallExpr(CppSharp.Parser.AST.CallExpr _0) + : this((Internal*) null) + { + __Instance = Marshal.AllocHGlobal(48); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + var arg0 = ReferenceEquals(_0, null) ? global::System.IntPtr.Zero : _0.__Instance; + Internal.cctor_1((__Instance + __PointerAdjustment), arg0); + } + + public CppSharp.Parser.AST.Expression getArguments(uint i) + { + var __ret = Internal.getArguments_0((__Instance + __PointerAdjustment), i); + CppSharp.Parser.AST.Expression __result0; + if (__ret == IntPtr.Zero) __result0 = null; + else if (CppSharp.Parser.AST.Expression.NativeToManagedMap.ContainsKey(__ret)) + __result0 = (CppSharp.Parser.AST.Expression) CppSharp.Parser.AST.Expression.NativeToManagedMap[__ret]; + else __result0 = CppSharp.Parser.AST.Expression.__CreateInstance(__ret); + return __result0; + } + + public void addArguments(CppSharp.Parser.AST.Expression s) + { + var arg0 = ReferenceEquals(s, null) ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0((__Instance + __PointerAdjustment), arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0((__Instance + __PointerAdjustment)); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0((__Instance + __PointerAdjustment)); + return __ret; + } + } + } + public unsafe partial class CXXConstructExpr : CppSharp.Parser.AST.Expression, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 48)] diff --git a/src/CppParser/Parser.cpp b/src/CppParser/Parser.cpp index f0669494..97d8cdef 100644 --- a/src/CppParser/Parser.cpp +++ b/src/CppParser/Parser.cpp @@ -2625,6 +2625,17 @@ AST::Expression* Parser::WalkExpression(clang::Expr* Expr) WalkExpression(BinaryOperator->getLHS()), WalkExpression(BinaryOperator->getRHS()), BinaryOperator->getOpcodeStr().str()); } + case Stmt::CallExprClass: + { + auto CallExpr = cast(Expr); + auto CallExpression = new AST::CallExpr(GetStringFromStatement(Expr), + WalkDeclaration(CallExpr->getCalleeDecl())); + for (auto arg : CallExpr->arguments()) + { + CallExpression->Arguments.push_back(WalkExpression(arg)); + } + return CallExpression; + } case Stmt::DeclRefExprClass: return new AST::Expression(GetStringFromStatement(Expr), StatementClass::DeclRefExprClass, WalkDeclaration(cast(Expr)->getDecl())); @@ -2965,6 +2976,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D, break; } case Decl::CXXConstructor: + case Decl::CXXMethod: { auto MD = cast(D); Decl = WalkMethodCXX(MD); @@ -2983,7 +2995,6 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D, // a class already. case Decl::CXXDestructor: case Decl::CXXConversion: - case Decl::CXXMethod: break; case Decl::Empty: case Decl::AccessSpec: