diff --git a/src/AST/ASTVisitor.cs b/src/AST/ASTVisitor.cs index dbbf9ecf..1538a942 100644 --- a/src/AST/ASTVisitor.cs +++ b/src/AST/ASTVisitor.cs @@ -1,4 +1,5 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; namespace CppSharp.AST { @@ -453,7 +454,18 @@ namespace CppSharp.AST return true; } - public virtual bool VisitTemplateParameter(TypeTemplateParameter templateParameter) + public bool VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter) + { + if (!VisitDeclaration(templateTemplateParameter)) + return false; + + foreach (var templateParameter in templateTemplateParameter.Parameters) + templateParameter.Visit(this); + + return true; + } + + public virtual bool VisitTemplateParameterDecl(TypeTemplateParameter templateParameter) { if (!VisitDeclaration(templateParameter)) return false; @@ -461,7 +473,7 @@ namespace CppSharp.AST return true; } - public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter) + public bool VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter) { if (!VisitDeclaration(nonTypeTemplateParameter)) return false; diff --git a/src/AST/Declaration.cs b/src/AST/Declaration.cs index 9bc7f553..e810ee02 100644 --- a/src/AST/Declaration.cs +++ b/src/AST/Declaration.cs @@ -386,7 +386,8 @@ namespace CppSharp.AST T VisitEvent(Event @event); T VisitProperty(Property @property); T VisitFriend(Friend friend); - T VisitTemplateParameter(TypeTemplateParameter templateParameter); - T VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter); + T VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter); + T VisitTemplateParameterDecl(TypeTemplateParameter templateParameter); + T VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter); } } diff --git a/src/AST/Template.cs b/src/AST/Template.cs index f29cd771..9b036326 100644 --- a/src/AST/Template.cs +++ b/src/AST/Template.cs @@ -1,9 +1,43 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; using System.Linq; namespace CppSharp.AST { - public abstract class TemplateParameter : Declaration + public class TemplateTemplateParameter : Template + { + /// + /// Whether this template template parameter is a template parameter pack. + /// template<template<class T> ...MetaFunctions> struct Apply; + /// + public bool IsParameterPack { get; set; } + + /// + /// Whether this parameter pack is a pack expansion. + /// A template template parameter pack is a pack expansion if its template parameter list contains an unexpanded parameter pack. + /// + public bool IsPackExpansion { get; set; } + + /// + /// Whether this parameter is a template template parameter pack that has a known list of different template parameter lists at different positions. + /// A parameter pack is an expanded parameter pack when the original parameter pack's template parameter list was itself a pack expansion, and that expansion has already been expanded. For exampe, given: + /// + /// template<typename...Types> struct Outer { template<template<Types> class...Templates> struct Inner; }; + /// + /// The parameter pack Templates is a pack expansion, which expands the pack Types.When Types is supplied with template arguments by instantiating Outer, the instantiation of Templates is an expanded parameter pack. + /// + public bool IsExpandedParameterPack { get; set; } + + public override T Visit(IDeclVisitor visitor) + { + return visitor.VisitTemplateTemplateParameterDecl(this); + } + } + + /// + /// Represents a template parameter + /// + public class TypeTemplateParameter : Declaration { /// /// Get the nesting depth of the template parameter. @@ -23,13 +57,7 @@ namespace CppSharp.AST /// /// public bool IsParameterPack { get; set; } - } - /// - /// Represents a template parameter - /// - public class TypeTemplateParameter : TemplateParameter - { // Generic type constraint public string Constraint; @@ -37,15 +65,34 @@ namespace CppSharp.AST public override T Visit(IDeclVisitor visitor) { - return visitor.VisitTemplateParameter(this); + return visitor.VisitTemplateParameterDecl(this); } } /// /// Represents a hard-coded template parameter /// - public class NonTypeTemplateParameter : TemplateParameter + public class NonTypeTemplateParameter : Declaration { + /// + /// Get the nesting depth of the template parameter. + /// + public uint Depth { get; set; } + + /// + /// Get the index of the template parameter within its parameter list. + /// + public uint Index { get; set; } + + /// + /// Whether this parameter is a non-type template parameter pack. + /// + /// If the parameter is a parameter pack, the type may be a PackExpansionType.In the following example, the Dims parameter is a parameter pack (whose type is 'unsigned'). + /// template<typename T, unsigned...Dims> struct multi_array; + /// + /// + public bool IsParameterPack { get; set; } + public Expression DefaultArgument { get; set; } /// @@ -79,7 +126,7 @@ namespace CppSharp.AST public override T Visit(IDeclVisitor visitor) { - return visitor.VisitNonTypeTemplateParameter(this); + return visitor.VisitNonTypeTemplateParameterDecl(this); } } @@ -108,18 +155,18 @@ namespace CppSharp.AST protected Template() { - Parameters = new List(); + Parameters = new List(); } protected Template(Declaration decl) { TemplatedDecl = decl; - Parameters = new List(); + Parameters = new List(); } public Declaration TemplatedDecl; - public List Parameters; + public List Parameters; public override string ToString() { diff --git a/src/Core/Parser/ASTConverter.cs b/src/Core/Parser/ASTConverter.cs index afadeabe..b80fca6f 100644 --- a/src/Core/Parser/ASTConverter.cs +++ b/src/Core/Parser/ASTConverter.cs @@ -139,7 +139,8 @@ namespace CppSharp public abstract TRet VisitClassTemplatePartialSpecialization( ClassTemplatePartialSpecialization decl); public abstract TRet VisitFunctionTemplate(FunctionTemplate decl); - public abstract TRet VisitTemplateParameter(TypeTemplateParameter decl); + public abstract TRet VisitTemplateTemplateParameter(TemplateTemplateParameter decl); + public abstract TRet VisitTypeTemplateParameter(TypeTemplateParameter decl); public abstract TRet VisitNonTypeTemplateParameter(NonTypeTemplateParameter decl); public virtual TRet Visit(Parser.AST.Declaration decl) @@ -231,10 +232,15 @@ namespace CppSharp var _decl = FunctionTemplate.__CreateInstance(decl.__Instance); return VisitFunctionTemplate(_decl); } + case DeclarationKind.TemplateTemplateParm: + { + var _decl = TemplateTemplateParameter.__CreateInstance(decl.__Instance); + return VisitTemplateTemplateParameter(_decl); + } case DeclarationKind.TemplateTypeParm: { var _decl = TypeTemplateParameter.__CreateInstance(decl.__Instance); - return VisitTemplateParameter(_decl); + return VisitTypeTemplateParameter(_decl); } case DeclarationKind.NonTypeTemplateParm: { @@ -1439,7 +1445,7 @@ namespace CppSharp for (uint i = 0; i < template.ParametersCount; ++i) { var param = template.getParameters(i); - var _param = (AST.TemplateParameter) Visit(param); + var _param = Visit(param); _template.Parameters.Add(_param); } } @@ -1641,7 +1647,7 @@ namespace CppSharp return _macro; } - public override AST.Declaration VisitTemplateParameter(TypeTemplateParameter decl) + public override AST.Declaration VisitTypeTemplateParameter(TypeTemplateParameter decl) { var templateParameter = new AST.TypeTemplateParameter(); VisitDeclaration(decl, templateParameter); @@ -1665,6 +1671,16 @@ namespace CppSharp nonTypeTemplateParameter.IsExpandedParameterPack = decl.IsExpandedParameterPack; return nonTypeTemplateParameter; } + + public override AST.Declaration VisitTemplateTemplateParameter(TemplateTemplateParameter decl) + { + var templateTemplateParameter = new AST.TemplateTemplateParameter(); + VisitTemplate(decl, templateTemplateParameter); + templateTemplateParameter.IsParameterPack = decl.IsParameterPack; + templateTemplateParameter.IsPackExpansion = decl.IsPackExpansion; + templateTemplateParameter.IsExpandedParameterPack = decl.IsExpandedParameterPack; + return templateTemplateParameter; + } } public unsafe class CommentConverter : CommentsVisitor diff --git a/src/CppParser/AST.cpp b/src/CppParser/AST.cpp index 875e86e3..bef34b91 100644 --- a/src/CppParser/AST.cpp +++ b/src/CppParser/AST.cpp @@ -98,6 +98,18 @@ TemplateParameter::~TemplateParameter() { } +TemplateTemplateParameter::TemplateTemplateParameter() + : Template(DeclarationKind::TemplateTemplateParm) + , IsParameterPack(false) + , IsPackExpansion(false) + , IsExpandedParameterPack(false) +{ +} + +TemplateTemplateParameter::~TemplateTemplateParameter() +{ +} + // TemplateParameter TypeTemplateParameter::TypeTemplateParameter() : TemplateParameter(DeclarationKind::TemplateTypeParm) diff --git a/src/CppParser/AST.h b/src/CppParser/AST.h index 980160cb..3c369f3f 100644 --- a/src/CppParser/AST.h +++ b/src/CppParser/AST.h @@ -356,6 +356,7 @@ enum class DeclarationKind MacroExpansion, TranslationUnit, Friend, + TemplateTemplateParm, TemplateTypeParm, NonTypeTemplateParm }; @@ -761,6 +762,17 @@ public: bool IsParameterPack; }; +class CS_API TemplateTemplateParameter : public Template +{ +public: + TemplateTemplateParameter(); + ~TemplateTemplateParameter(); + + bool IsParameterPack; + bool IsPackExpansion; + bool IsExpandedParameterPack; +}; + class CS_API TypeTemplateParameter : public TemplateParameter { public: diff --git a/src/CppParser/Bindings/CLI/AST.cpp b/src/CppParser/Bindings/CLI/AST.cpp index 0c4619c1..81354151 100644 --- a/src/CppParser/Bindings/CLI/AST.cpp +++ b/src/CppParser/Bindings/CLI/AST.cpp @@ -3531,6 +3531,73 @@ void CppSharp::Parser::AST::TemplateParameter::IsParameterPack::set(bool value) ((::CppSharp::CppParser::AST::TemplateParameter*)NativePtr)->IsParameterPack = value; } +CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(::CppSharp::CppParser::AST::TemplateTemplateParameter* native) + : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native) +{ +} + +CppSharp::Parser::AST::TemplateTemplateParameter^ CppSharp::Parser::AST::TemplateTemplateParameter::__CreateInstance(::System::IntPtr native) +{ + return gcnew ::CppSharp::Parser::AST::TemplateTemplateParameter((::CppSharp::CppParser::AST::TemplateTemplateParameter*) native.ToPointer()); +} + +CppSharp::Parser::AST::TemplateTemplateParameter::~TemplateTemplateParameter() +{ + if (NativePtr) + { + auto __nativePtr = NativePtr; + NativePtr = 0; + delete (::CppSharp::CppParser::AST::TemplateTemplateParameter*) __nativePtr; + } +} + +CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter() + : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr) +{ + __ownsNativeInstance = true; + NativePtr = new ::CppSharp::CppParser::AST::TemplateTemplateParameter(); +} + +CppSharp::Parser::AST::TemplateTemplateParameter::TemplateTemplateParameter(CppSharp::Parser::AST::TemplateTemplateParameter^ _0) + : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr) +{ + __ownsNativeInstance = true; + if (ReferenceEquals(_0, nullptr)) + throw gcnew ::System::ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&)."); + auto &arg0 = *(::CppSharp::CppParser::AST::TemplateTemplateParameter*)_0->NativePtr; + NativePtr = new ::CppSharp::CppParser::AST::TemplateTemplateParameter(arg0); +} + +bool CppSharp::Parser::AST::TemplateTemplateParameter::IsParameterPack::get() +{ + return ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsParameterPack; +} + +void CppSharp::Parser::AST::TemplateTemplateParameter::IsParameterPack::set(bool value) +{ + ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsParameterPack = value; +} + +bool CppSharp::Parser::AST::TemplateTemplateParameter::IsPackExpansion::get() +{ + return ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsPackExpansion; +} + +void CppSharp::Parser::AST::TemplateTemplateParameter::IsPackExpansion::set(bool value) +{ + ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsPackExpansion = value; +} + +bool CppSharp::Parser::AST::TemplateTemplateParameter::IsExpandedParameterPack::get() +{ + return ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsExpandedParameterPack; +} + +void CppSharp::Parser::AST::TemplateTemplateParameter::IsExpandedParameterPack::set(bool value) +{ + ((::CppSharp::CppParser::AST::TemplateTemplateParameter*)NativePtr)->IsExpandedParameterPack = value; +} + CppSharp::Parser::AST::TypeTemplateParameter::TypeTemplateParameter(::CppSharp::CppParser::AST::TypeTemplateParameter* native) : CppSharp::Parser::AST::TemplateParameter((::CppSharp::CppParser::AST::TemplateParameter*)native) { diff --git a/src/CppParser/Bindings/CLI/AST.h b/src/CppParser/Bindings/CLI/AST.h index 2ca89c05..1115f1c9 100644 --- a/src/CppParser/Bindings/CLI/AST.h +++ b/src/CppParser/Bindings/CLI/AST.h @@ -85,6 +85,7 @@ namespace CppSharp ref class TemplateParameterSubstitutionType; ref class TemplateParameterType; ref class TemplateSpecializationType; + ref class TemplateTemplateParameter; ref class TextComment; ref class TranslationUnit; ref class Type; @@ -152,8 +153,9 @@ namespace CppSharp MacroExpansion = 19, TranslationUnit = 20, Friend = 21, - TemplateTypeParm = 22, - NonTypeTemplateParm = 23 + TemplateTemplateParm = 22, + TemplateTypeParm = 23, + NonTypeTemplateParm = 24 }; public enum struct AccessSpecifier @@ -2099,6 +2101,37 @@ namespace CppSharp } }; + public ref class TemplateTemplateParameter : CppSharp::Parser::AST::Template + { + public: + + TemplateTemplateParameter(::CppSharp::CppParser::AST::TemplateTemplateParameter* native); + static TemplateTemplateParameter^ __CreateInstance(::System::IntPtr native); + TemplateTemplateParameter(); + + TemplateTemplateParameter(CppSharp::Parser::AST::TemplateTemplateParameter^ _0); + + ~TemplateTemplateParameter(); + + property bool IsParameterPack + { + bool get(); + void set(bool); + } + + property bool IsPackExpansion + { + bool get(); + void set(bool); + } + + property bool IsExpandedParameterPack + { + bool get(); + void set(bool); + } + }; + public ref class TypeTemplateParameter : CppSharp::Parser::AST::TemplateParameter { 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 e8926c70..75e62563 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 @@ -57,8 +57,9 @@ namespace CppSharp MacroExpansion = 19, TranslationUnit = 20, Friend = 21, - TemplateTypeParm = 22, - NonTypeTemplateParm = 23 + TemplateTemplateParm = 22, + TemplateTypeParm = 23, + NonTypeTemplateParm = 24 } public enum AccessSpecifier @@ -8060,6 +8061,181 @@ namespace CppSharp } } + public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 112)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(12)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(16)] + public int LineNumberStart; + + [FieldOffset(20)] + public int LineNumberEnd; + + [FieldOffset(60)] + public byte IsIncomplete; + + [FieldOffset(61)] + public byte IsDependent; + + [FieldOffset(62)] + public byte IsImplicit; + + [FieldOffset(64)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(68)] + public uint DefinitionOrder; + + [FieldOffset(84)] + public global::System.IntPtr OriginalPtr; + + [FieldOffset(88)] + public global::System.IntPtr Comment; + + [FieldOffset(92)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(108)] + public byte IsParameterPack; + + [FieldOffset(109)] + public byte IsPackExpansion; + + [FieldOffset(110)] + public byte IsExpandedParameterPack; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native.ToPointer(), skipVTables); + } + + public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native, skipVTables); + } + + private static void* __CopyValue(TemplateTemplateParameter.Internal native) + { + var ret = Marshal.AllocHGlobal(112); + CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native)); + return ret.ToPointer(); + } + + private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected TemplateTemplateParameter(void* native, bool skipVTables = false) + : base((void*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public TemplateTemplateParameter() + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(112); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + Internal.ctor_0((__Instance + __PointerAdjustment)); + } + + public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0) + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(112); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + if (ReferenceEquals(_0, null)) + throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&)."); + var arg0 = _0.__Instance; + Internal.cctor_1((__Instance + __PointerAdjustment), arg0); + } + + protected override void Dispose(bool disposing) + { + CppSharp.Parser.AST.Declaration __dummy; + NativeToManagedMap.TryRemove(__Instance, out __dummy); + Internal.dtor_0((__Instance + __PointerAdjustment)); + if (__ownsNativeInstance) + Marshal.FreeHGlobal(__Instance); + } + + public bool IsParameterPack + { + get + { + return ((Internal*) __Instance)->IsParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0); + } + } + + public bool IsPackExpansion + { + get + { + return ((Internal*) __Instance)->IsPackExpansion != 0; + } + + set + { + ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0); + } + } + + public bool IsExpandedParameterPack + { + get + { + return ((Internal*) __Instance)->IsExpandedParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0); + } + } + } + public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 112)] 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 3d5520d2..01a3133a 100644 --- a/src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs +++ b/src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/AST.cs @@ -57,8 +57,9 @@ namespace CppSharp MacroExpansion = 19, TranslationUnit = 20, Friend = 21, - TemplateTypeParm = 22, - NonTypeTemplateParm = 23 + TemplateTemplateParm = 22, + TemplateTypeParm = 23, + NonTypeTemplateParm = 24 } public enum AccessSpecifier @@ -8060,6 +8061,181 @@ namespace CppSharp } } + public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 148)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(12)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(16)] + public int LineNumberStart; + + [FieldOffset(20)] + public int LineNumberEnd; + + [FieldOffset(96)] + public byte IsIncomplete; + + [FieldOffset(97)] + public byte IsDependent; + + [FieldOffset(98)] + public byte IsImplicit; + + [FieldOffset(100)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(104)] + public uint DefinitionOrder; + + [FieldOffset(120)] + public global::System.IntPtr OriginalPtr; + + [FieldOffset(124)] + public global::System.IntPtr Comment; + + [FieldOffset(128)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(144)] + public byte IsParameterPack; + + [FieldOffset(145)] + public byte IsPackExpansion; + + [FieldOffset(146)] + public byte IsExpandedParameterPack; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QAE@XZ")] + internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QAE@ABV0123@@Z")] + internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall, + EntryPoint="??1TemplateTemplateParameter@AST@CppParser@CppSharp@@QAE@XZ")] + internal static extern void dtor_0(global::System.IntPtr instance, int delete); + } + + public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native.ToPointer(), skipVTables); + } + + public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native, skipVTables); + } + + private static void* __CopyValue(TemplateTemplateParameter.Internal native) + { + var ret = Marshal.AllocHGlobal(148); + CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native)); + return ret.ToPointer(); + } + + private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected TemplateTemplateParameter(void* native, bool skipVTables = false) + : base((void*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public TemplateTemplateParameter() + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(148); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + Internal.ctor_0((__Instance + __PointerAdjustment)); + } + + public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0) + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(148); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + if (ReferenceEquals(_0, null)) + throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&)."); + var arg0 = _0.__Instance; + Internal.cctor_1((__Instance + __PointerAdjustment), arg0); + } + + protected override void Dispose(bool disposing) + { + CppSharp.Parser.AST.Declaration __dummy; + NativeToManagedMap.TryRemove(__Instance, out __dummy); + Internal.dtor_0((__Instance + __PointerAdjustment), 0); + if (__ownsNativeInstance) + Marshal.FreeHGlobal(__Instance); + } + + public bool IsParameterPack + { + get + { + return ((Internal*) __Instance)->IsParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0); + } + } + + public bool IsPackExpansion + { + get + { + return ((Internal*) __Instance)->IsPackExpansion != 0; + } + + set + { + ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0); + } + } + + public bool IsExpandedParameterPack + { + get + { + return ((Internal*) __Instance)->IsExpandedParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0); + } + } + } + public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 148)] 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 6ef403c6..215befed 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 @@ -57,8 +57,9 @@ namespace CppSharp MacroExpansion = 19, TranslationUnit = 20, Friend = 21, - TemplateTypeParm = 22, - NonTypeTemplateParm = 23 + TemplateTemplateParm = 22, + TemplateTypeParm = 23, + NonTypeTemplateParm = 24 } public enum AccessSpecifier @@ -8059,6 +8060,181 @@ namespace CppSharp } } + public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 208)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(20)] + public int LineNumberStart; + + [FieldOffset(24)] + public int LineNumberEnd; + + [FieldOffset(104)] + public byte IsIncomplete; + + [FieldOffset(105)] + public byte IsDependent; + + [FieldOffset(106)] + public byte IsImplicit; + + [FieldOffset(112)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(120)] + public uint DefinitionOrder; + + [FieldOffset(152)] + public global::System.IntPtr OriginalPtr; + + [FieldOffset(160)] + public global::System.IntPtr Comment; + + [FieldOffset(168)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(200)] + public byte IsParameterPack; + + [FieldOffset(201)] + public byte IsPackExpansion; + + [FieldOffset(202)] + public byte IsExpandedParameterPack; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native.ToPointer(), skipVTables); + } + + public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native, skipVTables); + } + + private static void* __CopyValue(TemplateTemplateParameter.Internal native) + { + var ret = Marshal.AllocHGlobal(208); + CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native)); + return ret.ToPointer(); + } + + private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected TemplateTemplateParameter(void* native, bool skipVTables = false) + : base((void*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public TemplateTemplateParameter() + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(208); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + Internal.ctor_0((__Instance + __PointerAdjustment)); + } + + public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0) + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(208); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + if (ReferenceEquals(_0, null)) + throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&)."); + var arg0 = _0.__Instance; + Internal.cctor_1((__Instance + __PointerAdjustment), arg0); + } + + protected override void Dispose(bool disposing) + { + CppSharp.Parser.AST.Declaration __dummy; + NativeToManagedMap.TryRemove(__Instance, out __dummy); + Internal.dtor_0((__Instance + __PointerAdjustment)); + if (__ownsNativeInstance) + Marshal.FreeHGlobal(__Instance); + } + + public bool IsParameterPack + { + get + { + return ((Internal*) __Instance)->IsParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0); + } + } + + public bool IsPackExpansion + { + get + { + return ((Internal*) __Instance)->IsPackExpansion != 0; + } + + set + { + ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0); + } + } + + public bool IsExpandedParameterPack + { + get + { + return ((Internal*) __Instance)->IsExpandedParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0); + } + } + } + public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 200)] 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 518a0fc6..d3da6892 100644 --- a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs +++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs @@ -57,8 +57,9 @@ namespace CppSharp MacroExpansion = 19, TranslationUnit = 20, Friend = 21, - TemplateTypeParm = 22, - NonTypeTemplateParm = 23 + TemplateTemplateParm = 22, + TemplateTypeParm = 23, + NonTypeTemplateParm = 24 } public enum AccessSpecifier @@ -8059,6 +8060,181 @@ namespace CppSharp } } + public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 160)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(20)] + public int LineNumberStart; + + [FieldOffset(24)] + public int LineNumberEnd; + + [FieldOffset(56)] + public byte IsIncomplete; + + [FieldOffset(57)] + public byte IsDependent; + + [FieldOffset(58)] + public byte IsImplicit; + + [FieldOffset(64)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(72)] + public uint DefinitionOrder; + + [FieldOffset(104)] + public global::System.IntPtr OriginalPtr; + + [FieldOffset(112)] + public global::System.IntPtr Comment; + + [FieldOffset(120)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(152)] + public byte IsParameterPack; + + [FieldOffset(153)] + public byte IsPackExpansion; + + [FieldOffset(154)] + public byte IsExpandedParameterPack; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST25TemplateTemplateParameterD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native.ToPointer(), skipVTables); + } + + public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native, skipVTables); + } + + private static void* __CopyValue(TemplateTemplateParameter.Internal native) + { + var ret = Marshal.AllocHGlobal(160); + CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native)); + return ret.ToPointer(); + } + + private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected TemplateTemplateParameter(void* native, bool skipVTables = false) + : base((void*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public TemplateTemplateParameter() + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(160); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + Internal.ctor_0((__Instance + __PointerAdjustment)); + } + + public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0) + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(160); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + if (ReferenceEquals(_0, null)) + throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&)."); + var arg0 = _0.__Instance; + Internal.cctor_1((__Instance + __PointerAdjustment), arg0); + } + + protected override void Dispose(bool disposing) + { + CppSharp.Parser.AST.Declaration __dummy; + NativeToManagedMap.TryRemove(__Instance, out __dummy); + Internal.dtor_0((__Instance + __PointerAdjustment)); + if (__ownsNativeInstance) + Marshal.FreeHGlobal(__Instance); + } + + public bool IsParameterPack + { + get + { + return ((Internal*) __Instance)->IsParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0); + } + } + + public bool IsPackExpansion + { + get + { + return ((Internal*) __Instance)->IsPackExpansion != 0; + } + + set + { + ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0); + } + } + + public bool IsExpandedParameterPack + { + get + { + return ((Internal*) __Instance)->IsExpandedParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0); + } + } + } + public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 152)] diff --git a/src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/AST.cs b/src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/AST.cs index df0bcc19..d38943c9 100644 --- a/src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/AST.cs +++ b/src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/AST.cs @@ -57,8 +57,9 @@ namespace CppSharp MacroExpansion = 19, TranslationUnit = 20, Friend = 21, - TemplateTypeParm = 22, - NonTypeTemplateParm = 23 + TemplateTemplateParm = 22, + TemplateTypeParm = 23, + NonTypeTemplateParm = 24 } public enum AccessSpecifier @@ -8060,6 +8061,181 @@ namespace CppSharp } } + public unsafe partial class TemplateTemplateParameter : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 232)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(20)] + public int LineNumberStart; + + [FieldOffset(24)] + public int LineNumberEnd; + + [FieldOffset(128)] + public byte IsIncomplete; + + [FieldOffset(129)] + public byte IsDependent; + + [FieldOffset(130)] + public byte IsImplicit; + + [FieldOffset(136)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(144)] + public uint DefinitionOrder; + + [FieldOffset(176)] + public global::System.IntPtr OriginalPtr; + + [FieldOffset(184)] + public global::System.IntPtr Comment; + + [FieldOffset(192)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(224)] + public byte IsParameterPack; + + [FieldOffset(225)] + public byte IsPackExpansion; + + [FieldOffset(226)] + public byte IsExpandedParameterPack; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QEAA@XZ")] + internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="??0TemplateTemplateParameter@AST@CppParser@CppSharp@@QEAA@AEBV0123@@Z")] + internal static extern global::System.IntPtr cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="??1TemplateTemplateParameter@AST@CppParser@CppSharp@@QEAA@XZ")] + internal static extern void dtor_0(global::System.IntPtr instance, int delete); + } + + public static new TemplateTemplateParameter __CreateInstance(global::System.IntPtr native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native.ToPointer(), skipVTables); + } + + public static TemplateTemplateParameter __CreateInstance(TemplateTemplateParameter.Internal native, bool skipVTables = false) + { + return new TemplateTemplateParameter(native, skipVTables); + } + + private static void* __CopyValue(TemplateTemplateParameter.Internal native) + { + var ret = Marshal.AllocHGlobal(232); + CppSharp.Parser.AST.TemplateTemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native)); + return ret.ToPointer(); + } + + private TemplateTemplateParameter(TemplateTemplateParameter.Internal native, bool skipVTables = false) + : this(__CopyValue(native), skipVTables) + { + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + } + + protected TemplateTemplateParameter(void* native, bool skipVTables = false) + : base((void*) null) + { + __PointerAdjustment = 0; + if (native == null) + return; + __Instance = new global::System.IntPtr(native); + } + + public TemplateTemplateParameter() + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(232); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + Internal.ctor_0((__Instance + __PointerAdjustment)); + } + + public TemplateTemplateParameter(CppSharp.Parser.AST.TemplateTemplateParameter _0) + : this((void*) null) + { + __Instance = Marshal.AllocHGlobal(232); + __ownsNativeInstance = true; + NativeToManagedMap[__Instance] = this; + if (ReferenceEquals(_0, null)) + throw new global::System.ArgumentNullException("_0", "Cannot be null because it is a C++ reference (&)."); + var arg0 = _0.__Instance; + Internal.cctor_1((__Instance + __PointerAdjustment), arg0); + } + + protected override void Dispose(bool disposing) + { + CppSharp.Parser.AST.Declaration __dummy; + NativeToManagedMap.TryRemove(__Instance, out __dummy); + Internal.dtor_0((__Instance + __PointerAdjustment), 0); + if (__ownsNativeInstance) + Marshal.FreeHGlobal(__Instance); + } + + public bool IsParameterPack + { + get + { + return ((Internal*) __Instance)->IsParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsParameterPack = (byte) (value ? 1 : 0); + } + } + + public bool IsPackExpansion + { + get + { + return ((Internal*) __Instance)->IsPackExpansion != 0; + } + + set + { + ((Internal*) __Instance)->IsPackExpansion = (byte) (value ? 1 : 0); + } + } + + public bool IsExpandedParameterPack + { + get + { + return ((Internal*) __Instance)->IsExpandedParameterPack != 0; + } + + set + { + ((Internal*) __Instance)->IsExpandedParameterPack = (byte) (value ? 1 : 0); + } + } + } + public unsafe partial class TypeTemplateParameter : CppSharp.Parser.AST.TemplateParameter, IDisposable { [StructLayout(LayoutKind.Explicit, Size = 224)] diff --git a/src/CppParser/Parser.cpp b/src/CppParser/Parser.cpp index b26b7524..596fde10 100644 --- a/src/CppParser/Parser.cpp +++ b/src/CppParser/Parser.cpp @@ -397,7 +397,7 @@ static clang::SourceLocation GetDeclStartLocation(clang::CompilerInstance* C, auto startLoc = SM.getExpansionLoc(D->getLocStart()); auto startOffset = SM.getFileOffset(startLoc); - if (clang::dyn_cast_or_null(D)) + if (clang::dyn_cast_or_null(D) || !startLoc.isValid()) return startLoc; auto lineNo = SM.getExpansionLineNumber(startLoc); @@ -1008,6 +1008,24 @@ ClassTemplate* Parser::WalkClassTemplate(clang::ClassTemplateDecl* TD) //-----------------------------------// +TemplateTemplateParameter* Parser::WalkTemplateTemplateParameter(clang::TemplateTemplateParmDecl* TTP) +{ + auto TP = new TemplateTemplateParameter(); + HandleDeclaration(TTP, TP); + TP->Parameters = WalkTemplateParameterList(TTP->getTemplateParameters()); + TP->IsParameterPack = TTP->isParameterPack(); + TP->IsPackExpansion = TTP->isPackExpansion(); + TP->IsExpandedParameterPack = TTP->isExpandedParameterPack(); + if (TTP->getTemplatedDecl()) + { + auto TD = WalkDeclaration(TTP->getTemplatedDecl(), /*IgnoreSystemDecls=*/false); + TP->TemplatedDecl = TD; + } + return TP; +} + +//-----------------------------------// + TypeTemplateParameter* Parser::WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD) { using namespace clang; @@ -2917,17 +2935,20 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D, if (IgnoreSystemDecls && !IsValidDeclaration(D->getLocation())) return nullptr; - for(auto it = D->attr_begin(); it != D->attr_end(); ++it) + if (D->hasAttrs()) { - Attr* Attr = (*it); + for (auto it = D->attr_begin(); it != D->attr_end(); ++it) + { + Attr* Attr = (*it); - if(Attr->getKind() != clang::attr::Annotate) - continue; + if (Attr->getKind() != clang::attr::Annotate) + continue; - AnnotateAttr* Annotation = cast(Attr); - assert(Annotation != nullptr); + AnnotateAttr* Annotation = cast(Attr); + assert(Annotation != nullptr); - StringRef AnnotationText = Annotation->getAnnotation(); + StringRef AnnotationText = Annotation->getAnnotation(); + } } Declaration* Decl = nullptr; @@ -3101,6 +3122,12 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D, Decl = WalkFriend(FD); break; } + case Decl::TemplateTemplateParm: + { + auto TTP = cast(D); + Decl = WalkTemplateTemplateParameter(TTP); + break; + } case Decl::TemplateTypeParm: { auto TTPD = cast(D); diff --git a/src/CppParser/Parser.h b/src/CppParser/Parser.h index 5f23845e..5c19fa1d 100644 --- a/src/CppParser/Parser.h +++ b/src/CppParser/Parser.h @@ -88,6 +88,7 @@ protected: Type* WalkType(clang::QualType QualType, clang::TypeLoc* TL = 0, bool DesugarType = false); TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc); + TemplateTemplateParameter* WalkTemplateTemplateParameter(clang::TemplateTemplateParmDecl* TTP); TypeTemplateParameter* WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD); NonTypeTemplateParameter* WalkNonTypeTemplateParameter(clang::NonTypeTemplateParmDecl* TTPD); std::vector WalkTemplateParameterList(const clang::TemplateParameterList* TPL); diff --git a/src/Generator.Tests/AST/TestAST.cs b/src/Generator.Tests/AST/TestAST.cs index 2b1d8ecb..edfd633a 100644 --- a/src/Generator.Tests/AST/TestAST.cs +++ b/src/Generator.Tests/AST/TestAST.cs @@ -151,12 +151,17 @@ namespace CppSharp.Generator.Tests.AST throw new System.NotImplementedException(); } - public bool VisitTemplateParameter(TypeTemplateParameter templateParameter) + public bool VisitTemplateParameterDecl(TypeTemplateParameter templateParameter) { throw new NotImplementedException(); } - public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter) + public bool VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter) + { + throw new NotImplementedException(); + } + + public bool VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter) { throw new NotImplementedException(); } diff --git a/src/Generator/Generators/CLI/CLITypePrinter.cs b/src/Generator/Generators/CLI/CLITypePrinter.cs index 326f7b07..cc766ddb 100644 --- a/src/Generator/Generators/CLI/CLITypePrinter.cs +++ b/src/Generator/Generators/CLI/CLITypePrinter.cs @@ -430,12 +430,17 @@ namespace CppSharp.Generators.CLI return type.Visit(this); } - public string VisitTemplateParameter(TypeTemplateParameter templateParameter) + public string VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter) + { + return templateTemplateParameter.Name; + } + + public string VisitTemplateParameterDecl(TypeTemplateParameter templateParameter) { return templateParameter.Name; } - public string VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter) + public string VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter) { return nonTypeTemplateParameter.Name; } diff --git a/src/Generator/Generators/CSharp/CSharpTypePrinter.cs b/src/Generator/Generators/CSharp/CSharpTypePrinter.cs index 55988016..07d34881 100644 --- a/src/Generator/Generators/CSharp/CSharpTypePrinter.cs +++ b/src/Generator/Generators/CSharp/CSharpTypePrinter.cs @@ -727,12 +727,17 @@ namespace CppSharp.Generators.CSharp return type.Visit(this).Type; } - public CSharpTypePrinterResult VisitTemplateParameter(TypeTemplateParameter templateParameter) + public CSharpTypePrinterResult VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter) + { + return templateTemplateParameter.Name; + } + + public CSharpTypePrinterResult VisitTemplateParameterDecl(TypeTemplateParameter templateParameter) { return templateParameter.Name; } - public CSharpTypePrinterResult VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter) + public CSharpTypePrinterResult VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter) { return nonTypeTemplateParameter.Name; } diff --git a/src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs b/src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs index 71a3d4ea..696cc2b2 100644 --- a/src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs +++ b/src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs @@ -1,4 +1,5 @@ -using CppSharp.AST; +using System; +using CppSharp.AST; using CppSharp.AST.Extensions; namespace CppSharp.Passes @@ -242,12 +243,17 @@ namespace CppSharp.Passes return false; } - public bool VisitTemplateParameter(TypeTemplateParameter templateParameter) + public bool VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter) { return false; } - public bool VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter) + public bool VisitTemplateParameterDecl(TypeTemplateParameter templateParameter) + { + return false; + } + + public bool VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter) { return false; } diff --git a/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs b/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs index 294298cf..1c894dab 100644 --- a/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs +++ b/src/Generator/Passes/GenerateAnonymousDelegatesPass.cs @@ -63,6 +63,9 @@ namespace CppSharp.Passes /// The new type. private QualifiedType CheckType(DeclarationContext @namespace, QualifiedType type) { + if (type.Type.IsDependent) + return type; + var pointerType = type.Type as PointerType; if (pointerType == null) return type; diff --git a/src/Generator/Types/CppTypePrinter.cs b/src/Generator/Types/CppTypePrinter.cs index cc5734fd..8c2314fa 100644 --- a/src/Generator/Types/CppTypePrinter.cs +++ b/src/Generator/Types/CppTypePrinter.cs @@ -150,6 +150,9 @@ namespace CppSharp.Types public string VisitTemplateSpecializationType(TemplateSpecializationType template, TypeQualifiers quals) { + if (template.Template.TemplatedDecl == null) + return string.Empty; + return string.Format("{0}<{1}>", template.Template.TemplatedDecl.Visit(this), string.Join(", ", template.Arguments.Where( @@ -343,7 +346,12 @@ namespace CppSharp.Types return type.Visit(this); } - public string VisitTemplateParameter(TypeTemplateParameter templateParameter) + public string VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter) + { + return templateTemplateParameter.Name; + } + + public string VisitTemplateParameterDecl(TypeTemplateParameter templateParameter) { if (templateParameter.DefaultArgument.Type == null) return templateParameter.Name; @@ -352,7 +360,7 @@ namespace CppSharp.Types templateParameter.DefaultArgument.Visit(this)); } - public string VisitNonTypeTemplateParameter(NonTypeTemplateParameter nonTypeTemplateParameter) + public string VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter) { if (nonTypeTemplateParameter.DefaultArgument == null) return nonTypeTemplateParameter.Name; diff --git a/src/Generator/Types/TypeMap.cs b/src/Generator/Types/TypeMap.cs index a6965782..84b97f7a 100644 --- a/src/Generator/Types/TypeMap.cs +++ b/src/Generator/Types/TypeMap.cs @@ -199,7 +199,7 @@ namespace CppSharp.Types var typePrinter = new CppTypePrinter(); var template = type as TemplateSpecializationType; - if (template != null) + if (template != null && template.Template.TemplatedDecl != null) return FindTypeMap(template.Template.TemplatedDecl, type, out typeMap); diff --git a/tests/CSharp/CSharpTemplates.h b/tests/CSharp/CSharpTemplates.h index b93343eb..5d9bd72d 100644 --- a/tests/CSharp/CSharpTemplates.h +++ b/tests/CSharp/CSharpTemplates.h @@ -91,3 +91,30 @@ class PartiallySpecialized float f; }; }; + +template +class HasResultType { + typedef char Yes; + typedef void *No; + template static Yes test(int, const typename U::result_type * = 0); + template static No test(double); +public: + enum { Value = (sizeof(test(0)) == sizeof(Yes)) }; +}; + +template ::Value> +struct LazyResultType { typedef typename Functor::result_type Type; }; +template +struct LazyResultType { typedef void Type; }; + +template +struct MapResultType +{ + typedef typename LazyResultType::Type ResultType; +}; + +template