Added support for C++11 variable templates and specializations.

src/AST/ASTVisitor.cs

@@ -466,6 +466,27 @@ namespace CppSharp.AST
             return specialization.SpecializedFunction.Visit(this);
         }
 
+        public bool VisitVarTemplateDecl(VarTemplate template)
+        {
+            if (!VisitDeclaration(template))
+                return false;
+
+            foreach (var templateParameter in template.Parameters)
+                templateParameter.Visit(this);
+
+            foreach (var specialization in template.Specializations)
+                specialization.Visit(this);
+
+            template.TemplatedVariable.Visit(this);
+
+            return true; 
+        }
+
+        public bool VisitVarTemplateSpecializationDecl(VarTemplateSpecialization specialization)
+        {
+            return VisitVariableDecl(specialization);
+        }
+
         public virtual bool VisitMacroDefinition(MacroDefinition macro)
         {
             return false;

src/AST/Declaration.cs

@@ -419,6 +419,8 @@ namespace CppSharp.AST
         T VisitClassTemplateSpecializationDecl(ClassTemplateSpecialization specialization);
         T VisitFunctionTemplateDecl(FunctionTemplate template);
         T VisitFunctionTemplateSpecializationDecl(FunctionTemplateSpecialization specialization);
+        T VisitVarTemplateDecl(VarTemplate template);
+        T VisitVarTemplateSpecializationDecl(VarTemplateSpecialization template);
         T VisitTemplateTemplateParameterDecl(TemplateTemplateParameter templateTemplateParameter);
         T VisitTemplateParameterDecl(TypeTemplateParameter templateParameter);
         T VisitNonTypeTemplateParameterDecl(NonTypeTemplateParameter nonTypeTemplateParameter);

src/AST/Template.cs

@@ -378,4 +378,58 @@ namespace CppSharp.AST
             return visitor.VisitFunctionTemplateSpecializationDecl(this);
         }
     }
+
+    /// <summary>
+    /// Represents a declaration of a variable template.
+    /// </summary>
+    public class VarTemplate : Template
+    {
+        public List<VarTemplateSpecialization> Specializations;
+
+        public Variable TemplatedVariable
+        {
+            get { return TemplatedDecl as Variable; }
+        }
+
+        public VarTemplate()
+        {
+            Specializations = new List<VarTemplateSpecialization>();
+        }
+
+        public VarTemplate(Variable var) : base(var)
+        {
+            Specializations = new List<VarTemplateSpecialization>();
+        }
+
+        public override T Visit<T>(IDeclVisitor<T> visitor)
+        {
+            return visitor.VisitVarTemplateDecl(this);
+        }
+    }
+
+    /// <summary>
+    /// Represents a var template specialization, which refers to a var
+    /// template with a given set of template arguments.
+    /// </summary>
+    public class VarTemplateSpecialization : Variable
+    {
+        public VarTemplate TemplatedDecl;
+
+        public List<TemplateArgument> Arguments;
+
+        public TemplateSpecializationKind SpecializationKind;
+
+        public VarTemplateSpecialization()
+        {
+            Arguments = new List<TemplateArgument>();
+        }
+    }
+
+    /// <summary>
+    /// Represents a variable template partial specialization, which refers to
+    /// a variable template with a given partial set of template arguments.
+    /// </summary>
+    public class VarTemplatePartialSpecialization : VarTemplateSpecialization
+    {
+    }
 }

src/Core/Parser/ASTConverter.cs

@@ -147,6 +147,11 @@ namespace CppSharp
         public abstract TRet VisitClassTemplatePartialSpecialization(
             ClassTemplatePartialSpecialization decl);
         public abstract TRet VisitFunctionTemplate(FunctionTemplate decl);
+        public abstract TRet VisitVarTemplate(VarTemplate decl);
+        public abstract TRet VisitVarTemplateSpecialization(
+            VarTemplateSpecialization decl);
+        public abstract TRet VisitVarTemplatePartialSpecialization(
+            VarTemplatePartialSpecialization decl);
         public abstract TRet VisitTemplateTemplateParameter(TemplateTemplateParameter decl);
         public abstract TRet VisitTypeTemplateParameter(TypeTemplateParameter decl);
         public abstract TRet VisitNonTypeTemplateParameter(NonTypeTemplateParameter decl);
@@ -1278,13 +1283,18 @@ namespace CppSharp
             return _item;
         }
 
-        public override AST.Declaration VisitVariable(Variable decl)
+        public void VisitVariable(Variable decl, AST.Variable _variable)
         {
-            var _variable = new AST.Variable();
             VisitDeclaration(decl, _variable);
             _variable.Mangled = decl.Mangled;
             _variable.QualifiedType = typeConverter.VisitQualified(
                 decl.QualifiedType);
+        }
+
+        public override AST.Declaration VisitVariable(Variable decl)
+        {
+            var _variable = new AST.Variable();
+            VisitVariable(decl, _variable);
 
             return _variable;
         }
@@ -1656,6 +1666,48 @@ namespace CppSharp
             return _spec;
         }
 
+        public override AST.Declaration VisitVarTemplate(VarTemplate decl)
+        {
+            var _decl = new AST.VarTemplate();
+            VisitTemplate(decl, _decl);
+            for (uint i = 0; i < decl.SpecializationsCount; ++i)
+            {
+                var spec = decl.getSpecializations(i);
+                var _spec = (AST.VarTemplateSpecialization)Visit(spec);
+                _decl.Specializations.Add(_spec);
+            }
+            return _decl;
+        }
+
+        public override AST.Declaration VisitVarTemplateSpecialization(
+            VarTemplateSpecialization decl)
+        {
+            var _decl = new AST.VarTemplateSpecialization();
+            VisitVarTemplateSpecialization(decl, _decl);
+            return _decl;
+        }
+
+        private void VisitVarTemplateSpecialization(VarTemplateSpecialization decl, AST.VarTemplateSpecialization _decl)
+        {
+            VisitVariable(decl, _decl);
+            _decl.SpecializationKind = VisitSpecializationKind(decl.SpecializationKind);
+            _decl.TemplatedDecl = (AST.VarTemplate)Visit(decl.TemplatedDecl);
+            for (uint i = 0; i < decl.ArgumentsCount; ++i)
+            {
+                var arg = decl.getArguments(i);
+                var _arg = VisitTemplateArgument(arg);
+                _decl.Arguments.Add(_arg);
+            }
+        }
+
+        public override AST.Declaration VisitVarTemplatePartialSpecialization(
+            VarTemplatePartialSpecialization decl)
+        {
+            var _decl = new AST.VarTemplatePartialSpecialization();
+            VisitVarTemplateSpecialization(decl, _decl);
+            return _decl;
+        }
+
         void VisitPreprocessedEntity(PreprocessedEntity entity, AST.PreprocessedEntity _entity)
         {
             if (PreprocessedEntities.ContainsKey(entity.__Instance))

src/CppParser/AST.cpp

@@ -785,6 +785,52 @@ FunctionTemplateSpecialization::~FunctionTemplateSpecialization()
 
 DEF_VECTOR(FunctionTemplateSpecialization, TemplateArgument, Arguments)
 
+VarTemplate::VarTemplate() : Template(DeclarationKind::VarTemplate) {}
+
+VarTemplate::~VarTemplate() {}
+
+DEF_VECTOR(VarTemplate, VarTemplateSpecialization*, Specializations)
+
+VarTemplateSpecialization* VarTemplate::FindSpecialization(const std::string& usr)
+{
+    auto foundSpec = std::find_if(Specializations.begin(), Specializations.end(),
+        [&](VarTemplateSpecialization* cts) { return cts->USR == usr; });
+
+    if (foundSpec != Specializations.end())
+        return static_cast<VarTemplateSpecialization*>(*foundSpec);
+
+    return nullptr;
+}
+
+VarTemplatePartialSpecialization* VarTemplate::FindPartialSpecialization(const std::string& usr)
+{
+    auto foundSpec = FindSpecialization(usr);
+    if (foundSpec != nullptr)
+        return static_cast<VarTemplatePartialSpecialization*>(foundSpec);
+    return nullptr;
+}
+
+VarTemplateSpecialization::VarTemplateSpecialization()
+    : Variable()
+    , TemplatedDecl(0)
+{
+    Kind = DeclarationKind::VarTemplateSpecialization;
+}
+
+VarTemplateSpecialization::~VarTemplateSpecialization() {}
+
+DEF_VECTOR(VarTemplateSpecialization, TemplateArgument, Arguments)
+
+VarTemplatePartialSpecialization::VarTemplatePartialSpecialization()
+    : VarTemplateSpecialization()
+{
+    Kind = DeclarationKind::VarTemplatePartialSpecialization;
+}
+
+VarTemplatePartialSpecialization::~VarTemplatePartialSpecialization()
+{
+}
+
 Namespace::Namespace() 
     : DeclarationContext(DeclarationKind::Namespace)
     , IsInline(false) 

src/CppParser/AST.h

@@ -400,7 +400,10 @@ enum class DeclarationKind
     Friend,
     TemplateTemplateParm,
     TemplateTypeParm,
-    NonTypeTemplateParm
+    NonTypeTemplateParm,
+    VarTemplate,
+    VarTemplateSpecialization,
+    VarTemplatePartialSpecialization,
 };
 
 #define DECLARE_DECL_KIND(klass, kind) \
@@ -503,18 +506,6 @@ public:
     bool IsAnonymous;
 };
 
-template<typename T>
-T* DeclarationContext::FindTemplate(const std::string& USR)
-{
-    auto foundTemplate = std::find_if(Templates.begin(), Templates.end(),
-        [&](Template* t) { return t->USR == USR; });
-
-    if (foundTemplate != Templates.end())
-        return static_cast<T*>(*foundTemplate);
-
-    return nullptr;
-}
-
 class CS_API TypedefNameDecl : public Declaration
 {
 public:
@@ -824,6 +815,18 @@ public:
     VECTOR(Declaration*, Parameters)
 };
 
+template<typename T>
+T* DeclarationContext::FindTemplate(const std::string& USR)
+{
+    auto foundTemplate = std::find_if(Templates.begin(), Templates.end(),
+        [&](Template* t) { return t->USR == USR; });
+
+    if (foundTemplate != Templates.end())
+        return static_cast<T*>(*foundTemplate);
+
+    return nullptr;
+}
+
 class CS_API TypeAliasTemplate : public Template
 {
 public:
@@ -934,6 +937,36 @@ public:
     TemplateSpecializationKind SpecializationKind;
 };
 
+class VarTemplateSpecialization;
+class VarTemplatePartialSpecialization;
+
+class CS_API VarTemplate : public Template
+{
+public:
+    VarTemplate();
+    ~VarTemplate();
+    VECTOR(VarTemplateSpecialization*, Specializations)
+    VarTemplateSpecialization* FindSpecialization(const std::string& usr);
+    VarTemplatePartialSpecialization* FindPartialSpecialization(const std::string& usr);
+};
+
+class CS_API VarTemplateSpecialization : public Variable
+{
+public:
+    VarTemplateSpecialization();
+    ~VarTemplateSpecialization();
+    VarTemplate* TemplatedDecl;
+    VECTOR(TemplateArgument, Arguments)
+    TemplateSpecializationKind SpecializationKind;
+};
+
+class CS_API VarTemplatePartialSpecialization : public VarTemplateSpecialization
+{
+public:
+    VarTemplatePartialSpecialization();
+    ~VarTemplatePartialSpecialization();
+};
+
 class CS_API Namespace : public DeclarationContext
 {
 public:

src/CppParser/Bindings/CLI/AST.cpp

@@ -4484,6 +4484,189 @@ void CppSharp::Parser::AST::FunctionTemplateSpecialization::SpecializationKind::
     ((::CppSharp::CppParser::AST::FunctionTemplateSpecialization*)NativePtr)->SpecializationKind = (::CppSharp::CppParser::AST::TemplateSpecializationKind)value;
 }
 
+CppSharp::Parser::AST::VarTemplate::VarTemplate(::CppSharp::CppParser::AST::VarTemplate* native)
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)native)
+{
+}
+
+CppSharp::Parser::AST::VarTemplate^ CppSharp::Parser::AST::VarTemplate::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::VarTemplate((::CppSharp::CppParser::AST::VarTemplate*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::VarTemplate::~VarTemplate()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::VarTemplate*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::VarTemplate::VarTemplate()
+    : CppSharp::Parser::AST::Template((::CppSharp::CppParser::AST::Template*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::VarTemplate();
+}
+
+CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplate::getSpecializations(unsigned int i)
+{
+    auto __ret = ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->getSpecializations(i);
+    if (__ret == nullptr) return nullptr;
+    return (__ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)__ret);
+}
+
+void CppSharp::Parser::AST::VarTemplate::addSpecializations(CppSharp::Parser::AST::VarTemplateSpecialization^ s)
+{
+    if (ReferenceEquals(s, nullptr))
+        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+    auto __arg0 = (::CppSharp::CppParser::AST::VarTemplateSpecialization*)s->NativePtr;
+    ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->addSpecializations(__arg0);
+}
+
+void CppSharp::Parser::AST::VarTemplate::clearSpecializations()
+{
+    ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->clearSpecializations();
+}
+
+CppSharp::Parser::AST::VarTemplate::VarTemplate(CppSharp::Parser::AST::VarTemplate^ _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::VarTemplate*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::VarTemplate(__arg0);
+}
+
+unsigned int CppSharp::Parser::AST::VarTemplate::SpecializationsCount::get()
+{
+    auto __ret = ((::CppSharp::CppParser::AST::VarTemplate*)NativePtr)->getSpecializationsCount();
+    return __ret;
+}
+
+CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization(::CppSharp::CppParser::AST::VarTemplateSpecialization* native)
+    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)native)
+{
+}
+
+CppSharp::Parser::AST::VarTemplateSpecialization^ CppSharp::Parser::AST::VarTemplateSpecialization::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::VarTemplateSpecialization::~VarTemplateSpecialization()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::VarTemplateSpecialization*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization()
+    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::VarTemplateSpecialization();
+}
+
+CppSharp::Parser::AST::TemplateArgument^ CppSharp::Parser::AST::VarTemplateSpecialization::getArguments(unsigned int i)
+{
+    auto __ret = ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->getArguments(i);
+    auto ____ret = new ::CppSharp::CppParser::AST::TemplateArgument(__ret);
+    return (____ret == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::TemplateArgument((::CppSharp::CppParser::AST::TemplateArgument*)____ret);
+}
+
+void CppSharp::Parser::AST::VarTemplateSpecialization::addArguments(CppSharp::Parser::AST::TemplateArgument^ s)
+{
+    if (ReferenceEquals(s, nullptr))
+        throw gcnew ::System::ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+    auto &__arg0 = *(::CppSharp::CppParser::AST::TemplateArgument*)s->NativePtr;
+    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->addArguments(__arg0);
+}
+
+void CppSharp::Parser::AST::VarTemplateSpecialization::clearArguments()
+{
+    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->clearArguments();
+}
+
+CppSharp::Parser::AST::VarTemplateSpecialization::VarTemplateSpecialization(CppSharp::Parser::AST::VarTemplateSpecialization^ _0)
+    : CppSharp::Parser::AST::Variable((::CppSharp::CppParser::AST::Variable*)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::VarTemplateSpecialization*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::VarTemplateSpecialization(__arg0);
+}
+
+unsigned int CppSharp::Parser::AST::VarTemplateSpecialization::ArgumentsCount::get()
+{
+    auto __ret = ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->getArgumentsCount();
+    return __ret;
+}
+
+CppSharp::Parser::AST::VarTemplate^ CppSharp::Parser::AST::VarTemplateSpecialization::TemplatedDecl::get()
+{
+    return (((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->TemplatedDecl == nullptr) ? nullptr : gcnew CppSharp::Parser::AST::VarTemplate((::CppSharp::CppParser::AST::VarTemplate*)((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->TemplatedDecl);
+}
+
+void CppSharp::Parser::AST::VarTemplateSpecialization::TemplatedDecl::set(CppSharp::Parser::AST::VarTemplate^ value)
+{
+    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->TemplatedDecl = (::CppSharp::CppParser::AST::VarTemplate*)value->NativePtr;
+}
+
+CppSharp::Parser::AST::TemplateSpecializationKind CppSharp::Parser::AST::VarTemplateSpecialization::SpecializationKind::get()
+{
+    return (CppSharp::Parser::AST::TemplateSpecializationKind)((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->SpecializationKind;
+}
+
+void CppSharp::Parser::AST::VarTemplateSpecialization::SpecializationKind::set(CppSharp::Parser::AST::TemplateSpecializationKind value)
+{
+    ((::CppSharp::CppParser::AST::VarTemplateSpecialization*)NativePtr)->SpecializationKind = (::CppSharp::CppParser::AST::TemplateSpecializationKind)value;
+}
+
+CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization(::CppSharp::CppParser::AST::VarTemplatePartialSpecialization* native)
+    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)native)
+{
+}
+
+CppSharp::Parser::AST::VarTemplatePartialSpecialization^ CppSharp::Parser::AST::VarTemplatePartialSpecialization::__CreateInstance(::System::IntPtr native)
+{
+    return gcnew ::CppSharp::Parser::AST::VarTemplatePartialSpecialization((::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*) native.ToPointer());
+}
+
+CppSharp::Parser::AST::VarTemplatePartialSpecialization::~VarTemplatePartialSpecialization()
+{
+    if (NativePtr)
+    {
+        auto __nativePtr = NativePtr;
+        NativePtr = 0;
+        delete (::CppSharp::CppParser::AST::VarTemplatePartialSpecialization*) __nativePtr;
+    }
+}
+
+CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization()
+    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)nullptr)
+{
+    __ownsNativeInstance = true;
+    NativePtr = new ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization();
+}
+
+CppSharp::Parser::AST::VarTemplatePartialSpecialization::VarTemplatePartialSpecialization(CppSharp::Parser::AST::VarTemplatePartialSpecialization^ _0)
+    : CppSharp::Parser::AST::VarTemplateSpecialization((::CppSharp::CppParser::AST::VarTemplateSpecialization*)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::VarTemplatePartialSpecialization*)_0->NativePtr;
+    NativePtr = new ::CppSharp::CppParser::AST::VarTemplatePartialSpecialization(__arg0);
+}
+
 CppSharp::Parser::AST::Namespace::Namespace(::CppSharp::CppParser::AST::Namespace* native)
     : CppSharp::Parser::AST::DeclarationContext((::CppSharp::CppParser::AST::DeclarationContext*)native)
 {

src/CppParser/Bindings/CLI/AST.h

@@ -102,6 +102,9 @@ namespace CppSharp
             ref class VFTableInfo;
             ref class VTableComponent;
             ref class VTableLayout;
+            ref class VarTemplate;
+            ref class VarTemplatePartialSpecialization;
+            ref class VarTemplateSpecialization;
             ref class Variable;
             ref class VerbatimBlockComment;
             ref class VerbatimBlockLineComment;
@@ -164,7 +167,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             };
 
             public enum struct AccessSpecifier
@@ -2537,6 +2543,79 @@ namespace CppSharp
                 bool __ownsNativeInstance;
             };
 
+            public ref class VarTemplate : CppSharp::Parser::AST::Template
+            {
+            public:
+
+                VarTemplate(::CppSharp::CppParser::AST::VarTemplate* native);
+                static VarTemplate^ __CreateInstance(::System::IntPtr native);
+                VarTemplate();
+
+                VarTemplate(CppSharp::Parser::AST::VarTemplate^ _0);
+
+                ~VarTemplate();
+
+                property unsigned int SpecializationsCount
+                {
+                    unsigned int get();
+                }
+
+                CppSharp::Parser::AST::VarTemplateSpecialization^ getSpecializations(unsigned int i);
+
+                void addSpecializations(CppSharp::Parser::AST::VarTemplateSpecialization^ s);
+
+                void clearSpecializations();
+            };
+
+            public ref class VarTemplateSpecialization : CppSharp::Parser::AST::Variable
+            {
+            public:
+
+                VarTemplateSpecialization(::CppSharp::CppParser::AST::VarTemplateSpecialization* native);
+                static VarTemplateSpecialization^ __CreateInstance(::System::IntPtr native);
+                VarTemplateSpecialization();
+
+                VarTemplateSpecialization(CppSharp::Parser::AST::VarTemplateSpecialization^ _0);
+
+                ~VarTemplateSpecialization();
+
+                property unsigned int ArgumentsCount
+                {
+                    unsigned int get();
+                }
+
+                property CppSharp::Parser::AST::VarTemplate^ TemplatedDecl
+                {
+                    CppSharp::Parser::AST::VarTemplate^ get();
+                    void set(CppSharp::Parser::AST::VarTemplate^);
+                }
+
+                property CppSharp::Parser::AST::TemplateSpecializationKind SpecializationKind
+                {
+                    CppSharp::Parser::AST::TemplateSpecializationKind get();
+                    void set(CppSharp::Parser::AST::TemplateSpecializationKind);
+                }
+
+                CppSharp::Parser::AST::TemplateArgument^ getArguments(unsigned int i);
+
+                void addArguments(CppSharp::Parser::AST::TemplateArgument^ s);
+
+                void clearArguments();
+            };
+
+            public ref class VarTemplatePartialSpecialization : CppSharp::Parser::AST::VarTemplateSpecialization
+            {
+            public:
+
+                VarTemplatePartialSpecialization(::CppSharp::CppParser::AST::VarTemplatePartialSpecialization* native);
+                static VarTemplatePartialSpecialization^ __CreateInstance(::System::IntPtr native);
+                VarTemplatePartialSpecialization();
+
+                VarTemplatePartialSpecialization(CppSharp::Parser::AST::VarTemplatePartialSpecialization^ _0);
+
+                ~VarTemplatePartialSpecialization();
+            };
+
             public ref class Namespace : CppSharp::Parser::AST::DeclarationContext
             {
             public:

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/CppSharp.CppParser.cs

@@ -62,7 +62,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             }
 
             public enum AccessSpecifier
@@ -10841,6 +10844,565 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class VarTemplate : global::CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 120)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(24)]
+                    public global::std.__1.basic_string.Internal Name;
+
+                    [FieldOffset(36)]
+                    public global::std.__1.basic_string.Internal USR;
+
+                    [FieldOffset(48)]
+                    public global::std.__1.basic_string.Internal DebugText;
+
+                    [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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST11VarTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18getSpecializationsEj")]
+                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18addSpecializationsERPNS1_25VarTemplateSpecializationE")]
+                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate20clearSpecializationsEv")]
+                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate23getSpecializationsCountEv")]
+                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplate __CreateInstance(VarTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(120);
+                    global::CppSharp.Parser.AST.VarTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplate(VarTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(120);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplate(global::CppSharp.Parser.AST.VarTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(120);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.VarTemplateSpecialization getSpecializations(uint i)
+                {
+                    var __ret = Internal.getSpecializations_0((__Instance + __PointerAdjustment), i);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (global::CppSharp.Parser.AST.VarTemplateSpecialization) global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap[__ret];
+                    else __result0 = global::CppSharp.Parser.AST.VarTemplateSpecialization.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addSpecializations(global::CppSharp.Parser.AST.VarTemplateSpecialization s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = s.__Instance;
+                    Internal.addSpecializations_0((__Instance + __PointerAdjustment), __arg0);
+                }
+
+                public void clearSpecializations()
+                {
+                    Internal.clearSpecializations_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint SpecializationsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getSpecializationsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplateSpecialization : global::CppSharp.Parser.AST.Variable, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 132)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(24)]
+                    public global::std.__1.basic_string.Internal Name;
+
+                    [FieldOffset(36)]
+                    public global::std.__1.basic_string.Internal USR;
+
+                    [FieldOffset(48)]
+                    public global::std.__1.basic_string.Internal DebugText;
+
+                    [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::std.__1.basic_string.Internal Mangled;
+
+                    [FieldOffset(104)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(112)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(128)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12getArgumentsEj")]
+                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12addArgumentsERNS1_16TemplateArgumentE")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplateSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplateSpecialization __CreateInstance(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplateSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(132);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplateSpecialization(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplateSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplateSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(132);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplateSpecialization(global::CppSharp.Parser.AST.VarTemplateSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(132);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
+                {
+                    var __ret = new global::CppSharp.Parser.AST.TemplateArgument.Internal();
+                    Internal.getArguments_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), i);
+                    return global::CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
+                }
+
+                public void addArguments(global::CppSharp.Parser.AST.TemplateArgument s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = 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 global::CppSharp.Parser.AST.VarTemplate TemplatedDecl
+                {
+                    get
+                    {
+                        global::CppSharp.Parser.AST.VarTemplate __result0;
+                        if (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) __result0 = null;
+                        else if (global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap.ContainsKey(((Internal*) __Instance)->TemplatedDecl))
+                            __result0 = (global::CppSharp.Parser.AST.VarTemplate) global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap[((Internal*) __Instance)->TemplatedDecl];
+                        else __result0 = global::CppSharp.Parser.AST.VarTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
+                        return __result0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
+                    }
+                }
+
+                public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->SpecializationKind;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->SpecializationKind = value;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplatePartialSpecialization : global::CppSharp.Parser.AST.VarTemplateSpecialization, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 132)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(24)]
+                    public global::std.__1.basic_string.Internal Name;
+
+                    [FieldOffset(36)]
+                    public global::std.__1.basic_string.Internal USR;
+
+                    [FieldOffset(48)]
+                    public global::std.__1.basic_string.Internal DebugText;
+
+                    [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::std.__1.basic_string.Internal Mangled;
+
+                    [FieldOffset(104)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(112)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(128)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplatePartialSpecialization __CreateInstance(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplatePartialSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(132);
+                    global::CppSharp.Parser.AST.VarTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplatePartialSpecialization(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplatePartialSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplatePartialSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(132);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplatePartialSpecialization(global::CppSharp.Parser.AST.VarTemplatePartialSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(132);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
             public unsafe partial class Namespace : global::CppSharp.Parser.AST.DeclarationContext, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 216)]

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/CppSharp.CppParser.dll-templates.cpp

@@ -0,0 +1,29 @@
+#include <AST.h>
+#include <Sources.h>
+#include <CppParser.h>
+
+template class vector<CppSharp::CppParser::AST::Namespace*>;
+template class vector<CppSharp::CppParser::AST::Enumeration*>;
+template class vector<CppSharp::CppParser::AST::Function*>;
+template class vector<CppSharp::CppParser::AST::Class*>;
+template class vector<CppSharp::CppParser::AST::Template*>;
+template class vector<CppSharp::CppParser::AST::TypedefDecl*>;
+template class vector<CppSharp::CppParser::AST::TypeAlias*>;
+template class vector<CppSharp::CppParser::AST::Variable*>;
+template class vector<CppSharp::CppParser::AST::Friend*>;
+template class vector<CppSharp::CppParser::AST::BaseClassSpecifier*>;
+template class vector<CppSharp::CppParser::AST::Field*>;
+template class vector<CppSharp::CppParser::AST::Method*>;
+template class vector<CppSharp::CppParser::AST::AccessSpecifierDecl*>;
+template class vector<CppSharp::CppParser::AST::Declaration*>;
+template class vector<CppSharp::CppParser::AST::FunctionTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Parameter*>;
+template class vector<CppSharp::CppParser::AST::ClassTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Enumeration::Item*>;
+template class vector<CppSharp::CppParser::AST::BlockContentComment*>;
+template class vector<CppSharp::CppParser::AST::PreprocessedEntity*>;
+template class vector<CppSharp::CppParser::AST::Expression*>;
+template class vector<CppSharp::CppParser::AST::MacroDefinition*>;
+template class vector<CppSharp::CppParser::AST::TranslationUnit*>;
+template class vector<CppSharp::CppParser::AST::InlineContentComment*>;
+template class vector<CppSharp::CppParser::AST::VerbatimBlockLineComment*>;

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/Std-templates.cpp

@@ -0,0 +1,4 @@
+#include <string>
+
+template class __declspec(dllexport) std::allocator<char>;
+template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char>>;

src/CppParser/Bindings/CSharp/i686-apple-darwin12.4.0/Std.cs

@@ -0,0 +1,701 @@
+//----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+//----------------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace std
+{
+    namespace __1
+    {
+        public unsafe partial class allocator : IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 0)]
+            public unsafe partial struct Internal
+            {
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSt3__19allocatorIcEC2Ev")]
+                internal static extern void ctor_0(global::System.IntPtr instance);
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            protected int __PointerAdjustment;
+            public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator>();
+            protected void*[] __OriginalVTables;
+
+            protected bool __ownsNativeInstance;
+
+            public static allocator __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new allocator(native.ToPointer(), skipVTables);
+            }
+
+            public static allocator __CreateInstance(allocator.Internal native, bool skipVTables = false)
+            {
+                return new allocator(native, skipVTables);
+            }
+
+            private static void* __CopyValue(allocator.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(0);
+                *(allocator.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private allocator(allocator.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected allocator(void* native, bool skipVTables = false)
+            {
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public allocator()
+            {
+                __Instance = Marshal.AllocHGlobal(0);
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                Internal.ctor_0((__Instance + __PointerAdjustment));
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                global::std.__1.allocator __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+        }
+
+        public unsafe partial class __destruct_n
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 4)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public uint size;
+            }
+        }
+
+        public unsafe partial class bad_weak_ptr
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 4)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr vptr_exception;
+            }
+        }
+
+        public unsafe abstract partial class __shared_count
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr vptr___shared_count;
+
+                [FieldOffset(4)]
+                public int __shared_owners_;
+            }
+        }
+
+        public unsafe abstract partial class __shared_weak_count
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 12)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr vptr___shared_count;
+
+                [FieldOffset(4)]
+                public int __shared_owners_;
+
+                [FieldOffset(8)]
+                public int __shared_weak_owners_;
+            }
+        }
+
+        public unsafe partial class __sp_mut
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 4)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr __lx;
+            }
+        }
+
+        public unsafe partial class pointer_safety
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 4)]
+            public partial struct Internal
+            {
+            }
+        }
+
+        namespace __pointer_type_imp
+        {
+        }
+    }
+}
+
+namespace std
+{
+    namespace __1
+    {
+        public unsafe partial class basic_string : IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 12)]
+            public unsafe partial struct Internal
+            {
+                [FieldOffset(0)]
+                public uint __cap_;
+
+                [FieldOffset(4)]
+                public uint __size_;
+
+                [FieldOffset(8)]
+                public global::System.IntPtr __data_;
+
+                [FieldOffset(0)]
+                public byte __size_1;
+
+                [FieldOffset(0)]
+                public sbyte __lx;
+
+                [FieldOffset(1)]
+                public fixed sbyte __data_1[11];
+
+                [FieldOffset(2)]
+                public sbyte __dummy___data_1_1;
+
+                [FieldOffset(3)]
+                public sbyte __dummy___data_1_2;
+
+                [FieldOffset(4)]
+                public sbyte __dummy___data_1_3;
+
+                [FieldOffset(5)]
+                public sbyte __dummy___data_1_4;
+
+                [FieldOffset(6)]
+                public sbyte __dummy___data_1_5;
+
+                [FieldOffset(7)]
+                public sbyte __dummy___data_1_6;
+
+                [FieldOffset(8)]
+                public sbyte __dummy___data_1_7;
+
+                [FieldOffset(9)]
+                public sbyte __dummy___data_1_8;
+
+                [FieldOffset(10)]
+                public sbyte __dummy___data_1_9;
+
+                [FieldOffset(11)]
+                public sbyte __dummy___data_1_10;
+
+                [FieldOffset(0)]
+                public fixed uint __words[3];
+
+                [FieldOffset(4)]
+                public uint __dummy___words_1;
+
+                [FieldOffset(8)]
+                public uint __dummy___words_2;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev")]
+                internal static extern void dtor_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv")]
+                internal static extern global::System.IntPtr c_str_0(global::System.IntPtr instance);
+            }
+
+            internal enum short_mask : uint
+            {
+                __short_mask = 0x1
+            }
+
+            internal enum long_mask : uint
+            {
+                __long_mask = 0x1
+            }
+
+            internal enum min_cap : uint
+            {
+                __min_cap = 11
+            }
+
+            internal enum n_words : uint
+            {
+                __n_words = 3
+            }
+
+            [Flags]
+            internal enum alignment : uint
+            {
+                __alignment = 16
+            }
+
+            public unsafe partial class __rep : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 12)]
+                public partial struct Internal
+                {
+                }
+
+                public unsafe partial struct _
+                {
+                    [StructLayout(LayoutKind.Explicit, Size = 12)]
+                    public partial struct Internal
+                    {
+                    }
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __rep> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __rep>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __rep __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __rep(native.ToPointer(), skipVTables);
+                }
+
+                public static __rep __CreateInstance(__rep.Internal native, bool skipVTables = false)
+                {
+                    return new __rep(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__rep.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(12);
+                    *(__rep.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __rep(__rep.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __rep(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __rep()
+                {
+                    __Instance = Marshal.AllocHGlobal(12);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__rep __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial class __long : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 12)]
+                public partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public uint __cap_;
+
+                    [FieldOffset(4)]
+                    public uint __size_;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr __data_;
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __long> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __long>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __long __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __long(native.ToPointer(), skipVTables);
+                }
+
+                public static __long __CreateInstance(__long.Internal native, bool skipVTables = false)
+                {
+                    return new __long(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__long.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(12);
+                    *(__long.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __long(__long.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __long(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __long()
+                {
+                    __Instance = Marshal.AllocHGlobal(12);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__long __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial class __short : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 12)]
+                public partial struct Internal
+                {
+                    [FieldOffset(1)]
+                    public fixed sbyte __data_[11];
+
+                    [FieldOffset(2)]
+                    public sbyte __dummy___data__1;
+
+                    [FieldOffset(3)]
+                    public sbyte __dummy___data__2;
+
+                    [FieldOffset(4)]
+                    public sbyte __dummy___data__3;
+
+                    [FieldOffset(5)]
+                    public sbyte __dummy___data__4;
+
+                    [FieldOffset(6)]
+                    public sbyte __dummy___data__5;
+
+                    [FieldOffset(7)]
+                    public sbyte __dummy___data__6;
+
+                    [FieldOffset(8)]
+                    public sbyte __dummy___data__7;
+
+                    [FieldOffset(9)]
+                    public sbyte __dummy___data__8;
+
+                    [FieldOffset(10)]
+                    public sbyte __dummy___data__9;
+
+                    [FieldOffset(11)]
+                    public sbyte __dummy___data__10;
+                }
+
+                public unsafe partial struct _
+                {
+                    [StructLayout(LayoutKind.Explicit, Size = 1)]
+                    public partial struct Internal
+                    {
+                        [FieldOffset(0)]
+                        public byte __size_;
+
+                        [FieldOffset(0)]
+                        public sbyte __lx;
+                    }
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __short> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __short>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __short __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __short(native.ToPointer(), skipVTables);
+                }
+
+                public static __short __CreateInstance(__short.Internal native, bool skipVTables = false)
+                {
+                    return new __short(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__short.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(12);
+                    *(__short.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __short(__short.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __short(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __short()
+                {
+                    __Instance = Marshal.AllocHGlobal(12);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__short __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial class __raw : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 12)]
+                public partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public fixed uint __words[3];
+
+                    [FieldOffset(4)]
+                    public uint __dummy___words_1;
+
+                    [FieldOffset(8)]
+                    public uint __dummy___words_2;
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __raw> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __raw>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __raw __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __raw(native.ToPointer(), skipVTables);
+                }
+
+                public static __raw __CreateInstance(__raw.Internal native, bool skipVTables = false)
+                {
+                    return new __raw(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__raw.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(12);
+                    *(__raw.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __raw(__raw.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __raw(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __raw()
+                {
+                    __Instance = Marshal.AllocHGlobal(12);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__raw __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial struct __ulx
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 12)]
+                public partial struct Internal
+                {
+                }
+
+                private __ulx.Internal __instance;
+                public __ulx.Internal __Instance { get { return __instance; } }
+
+                public static __ulx __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __ulx(native.ToPointer(), skipVTables);
+                }
+
+                public static __ulx __CreateInstance(__ulx.Internal native, bool skipVTables = false)
+                {
+                    return new __ulx(native, skipVTables);
+                }
+
+                private __ulx(__ulx.Internal native, bool skipVTables = false)
+                    : this()
+                {
+                    __instance = native;
+                }
+
+                private __ulx(void* native, bool skipVTables = false) : this()
+                {
+                    __instance = *(Internal*) native;
+                }
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            protected int __PointerAdjustment;
+            public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string>();
+            protected void*[] __OriginalVTables;
+
+            protected bool __ownsNativeInstance;
+
+            public static basic_string __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new basic_string(native.ToPointer(), skipVTables);
+            }
+
+            public static basic_string __CreateInstance(basic_string.Internal native, bool skipVTables = false)
+            {
+                return new basic_string(native, skipVTables);
+            }
+
+            private static void* __CopyValue(basic_string.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(12);
+                *(basic_string.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private basic_string(basic_string.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected basic_string(void* native, bool skipVTables = false)
+            {
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                global::std.__1.basic_string __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                Internal.dtor_0((__Instance + __PointerAdjustment));
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+
+            public string c_str()
+            {
+                var __ret = Internal.c_str_0((__Instance + __PointerAdjustment));
+                return Marshal.PtrToStringAnsi(__ret);
+            }
+
+            public static uint npos
+            {
+                get
+                {
+                    var __ptr = (uint*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE");
+                    return *__ptr;
+                }
+            }
+        }
+    }
+}

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/CppSharp.CppParser.cs

@@ -62,7 +62,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             }
 
             public enum AccessSpecifier
@@ -10841,6 +10844,565 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class VarTemplate : global::CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 156)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(24)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(48)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(72)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0VarTemplate@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="??0VarTemplate@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="??1VarTemplate@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="?getSpecializations@VarTemplate@AST@CppParser@CppSharp@@QAEPAVVarTemplateSpecialization@234@I@Z")]
+                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?addSpecializations@VarTemplate@AST@CppParser@CppSharp@@QAEXAAPAVVarTemplateSpecialization@234@@Z")]
+                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?clearSpecializations@VarTemplate@AST@CppParser@CppSharp@@QAEXXZ")]
+                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?getSpecializationsCount@VarTemplate@AST@CppParser@CppSharp@@QAEIXZ")]
+                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplate __CreateInstance(VarTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(156);
+                    global::CppSharp.Parser.AST.VarTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplate(VarTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(156);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplate(global::CppSharp.Parser.AST.VarTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(156);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.VarTemplateSpecialization getSpecializations(uint i)
+                {
+                    var __ret = Internal.getSpecializations_0((__Instance + __PointerAdjustment), i);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (global::CppSharp.Parser.AST.VarTemplateSpecialization) global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap[__ret];
+                    else __result0 = global::CppSharp.Parser.AST.VarTemplateSpecialization.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addSpecializations(global::CppSharp.Parser.AST.VarTemplateSpecialization s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = s.__Instance;
+                    Internal.addSpecializations_0((__Instance + __PointerAdjustment), __arg0);
+                }
+
+                public void clearSpecializations()
+                {
+                    Internal.clearSpecializations_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint SpecializationsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getSpecializationsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplateSpecialization : global::CppSharp.Parser.AST.Variable, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 180)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(24)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(48)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(72)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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::std.basic_string.Internal Mangled;
+
+                    [FieldOffset(152)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(160)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(176)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0VarTemplateSpecialization@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="??0VarTemplateSpecialization@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="??1VarTemplateSpecialization@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@VarTemplateSpecialization@AST@CppParser@CppSharp@@QAE?AUTemplateArgument@234@I@Z")]
+                    internal static extern void getArguments_0(global::System.IntPtr instance, global::System.IntPtr @return, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="?addArguments@VarTemplateSpecialization@AST@CppParser@CppSharp@@QAEXAAUTemplateArgument@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@VarTemplateSpecialization@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@VarTemplateSpecialization@AST@CppParser@CppSharp@@QAEIXZ")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplateSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplateSpecialization __CreateInstance(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplateSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(180);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplateSpecialization(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplateSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplateSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(180);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplateSpecialization(global::CppSharp.Parser.AST.VarTemplateSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(180);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
+                {
+                    var __ret = new global::CppSharp.Parser.AST.TemplateArgument.Internal();
+                    Internal.getArguments_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), i);
+                    return global::CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
+                }
+
+                public void addArguments(global::CppSharp.Parser.AST.TemplateArgument s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = 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 global::CppSharp.Parser.AST.VarTemplate TemplatedDecl
+                {
+                    get
+                    {
+                        global::CppSharp.Parser.AST.VarTemplate __result0;
+                        if (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) __result0 = null;
+                        else if (global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap.ContainsKey(((Internal*) __Instance)->TemplatedDecl))
+                            __result0 = (global::CppSharp.Parser.AST.VarTemplate) global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap[((Internal*) __Instance)->TemplatedDecl];
+                        else __result0 = global::CppSharp.Parser.AST.VarTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
+                        return __result0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
+                    }
+                }
+
+                public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->SpecializationKind;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->SpecializationKind = value;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplatePartialSpecialization : global::CppSharp.Parser.AST.VarTemplateSpecialization, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 180)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(12)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(16)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(20)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(24)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(48)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(72)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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::std.basic_string.Internal Mangled;
+
+                    [FieldOffset(152)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(160)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(176)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                        EntryPoint="??0VarTemplatePartialSpecialization@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="??0VarTemplatePartialSpecialization@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="??1VarTemplatePartialSpecialization@AST@CppParser@CppSharp@@QAE@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+                }
+
+                public static new VarTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplatePartialSpecialization __CreateInstance(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplatePartialSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(180);
+                    global::CppSharp.Parser.AST.VarTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplatePartialSpecialization(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplatePartialSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplatePartialSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(180);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplatePartialSpecialization(global::CppSharp.Parser.AST.VarTemplatePartialSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(180);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
             public unsafe partial class Namespace : global::CppSharp.Parser.AST.DeclarationContext, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 252)]

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/CppSharp.CppParser.dll-templates.cpp

@@ -0,0 +1,30 @@
+#include <AST.h>
+#include <Sources.h>
+#include <CppParser.h>
+
+template class vector<CppSharp::CppParser::AST::Namespace*>;
+template class vector<CppSharp::CppParser::AST::Enumeration*>;
+template class vector<CppSharp::CppParser::AST::Function*>;
+template class vector<CppSharp::CppParser::AST::Class*>;
+template class vector<CppSharp::CppParser::AST::Template*>;
+template class vector<CppSharp::CppParser::AST::TypedefDecl*>;
+template class vector<CppSharp::CppParser::AST::TypeAlias*>;
+template class vector<CppSharp::CppParser::AST::Variable*>;
+template class vector<CppSharp::CppParser::AST::Friend*>;
+template class vector<CppSharp::CppParser::AST::BaseClassSpecifier*>;
+template class vector<CppSharp::CppParser::AST::Field*>;
+template class vector<CppSharp::CppParser::AST::Method*>;
+template class vector<CppSharp::CppParser::AST::AccessSpecifierDecl*>;
+template class vector<CppSharp::CppParser::AST::Declaration*>;
+template class vector<CppSharp::CppParser::AST::FunctionTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Parameter*>;
+template class vector<CppSharp::CppParser::AST::Enumeration::Item*>;
+template class vector<CppSharp::CppParser::AST::BlockContentComment*>;
+template class vector<CppSharp::CppParser::AST::PreprocessedEntity*>;
+template class vector<CppSharp::CppParser::AST::Expression*>;
+template class vector<CppSharp::CppParser::AST::ClassTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::VarTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::MacroDefinition*>;
+template class vector<CppSharp::CppParser::AST::TranslationUnit*>;
+template class vector<CppSharp::CppParser::AST::InlineContentComment*>;
+template class vector<CppSharp::CppParser::AST::VerbatimBlockLineComment*>;

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/Std-templates.cpp

@@ -0,0 +1,4 @@
+#include <string>
+
+template class __declspec(dllexport) std::allocator<char>;
+template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char>>;

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/Std.cs

@@ -0,0 +1,317 @@
+//----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+//----------------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace std
+{
+    public unsafe partial class allocator : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public unsafe partial struct Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                EntryPoint="??0?$allocator@D@std@@QAE@XZ")]
+            internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance);
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static allocator __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new allocator(native.ToPointer(), skipVTables);
+        }
+
+        public static allocator __CreateInstance(allocator.Internal native, bool skipVTables = false)
+        {
+            return new allocator(native, skipVTables);
+        }
+
+        private static void* __CopyValue(allocator.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(0);
+            *(allocator.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private allocator(allocator.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected allocator(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public allocator()
+        {
+            __Instance = Marshal.AllocHGlobal(0);
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+            Internal.ctor_0((__Instance + __PointerAdjustment));
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.allocator __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+    }
+
+    public unsafe partial class _Alloc_allocate
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_construct
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_destroy
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_max_size
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_select
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+}
+
+namespace std
+{
+    public unsafe partial class basic_string : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct Internal
+        {
+            [FieldOffset(0)]
+            public fixed sbyte _Buf[16];
+
+            [FieldOffset(1)]
+            public sbyte __dummy__Buf_1;
+
+            [FieldOffset(2)]
+            public sbyte __dummy__Buf_2;
+
+            [FieldOffset(3)]
+            public sbyte __dummy__Buf_3;
+
+            [FieldOffset(4)]
+            public sbyte __dummy__Buf_4;
+
+            [FieldOffset(5)]
+            public sbyte __dummy__Buf_5;
+
+            [FieldOffset(6)]
+            public sbyte __dummy__Buf_6;
+
+            [FieldOffset(7)]
+            public sbyte __dummy__Buf_7;
+
+            [FieldOffset(8)]
+            public sbyte __dummy__Buf_8;
+
+            [FieldOffset(9)]
+            public sbyte __dummy__Buf_9;
+
+            [FieldOffset(10)]
+            public sbyte __dummy__Buf_10;
+
+            [FieldOffset(11)]
+            public sbyte __dummy__Buf_11;
+
+            [FieldOffset(12)]
+            public sbyte __dummy__Buf_12;
+
+            [FieldOffset(13)]
+            public sbyte __dummy__Buf_13;
+
+            [FieldOffset(14)]
+            public sbyte __dummy__Buf_14;
+
+            [FieldOffset(15)]
+            public sbyte __dummy__Buf_15;
+
+            [FieldOffset(0)]
+            public global::System.IntPtr _Ptr;
+
+            [FieldOffset(0)]
+            public fixed sbyte _Alias[16];
+
+            [FieldOffset(1)]
+            public sbyte __dummy__Alias_1;
+
+            [FieldOffset(2)]
+            public sbyte __dummy__Alias_2;
+
+            [FieldOffset(3)]
+            public sbyte __dummy__Alias_3;
+
+            [FieldOffset(4)]
+            public sbyte __dummy__Alias_4;
+
+            [FieldOffset(5)]
+            public sbyte __dummy__Alias_5;
+
+            [FieldOffset(6)]
+            public sbyte __dummy__Alias_6;
+
+            [FieldOffset(7)]
+            public sbyte __dummy__Alias_7;
+
+            [FieldOffset(8)]
+            public sbyte __dummy__Alias_8;
+
+            [FieldOffset(9)]
+            public sbyte __dummy__Alias_9;
+
+            [FieldOffset(10)]
+            public sbyte __dummy__Alias_10;
+
+            [FieldOffset(11)]
+            public sbyte __dummy__Alias_11;
+
+            [FieldOffset(12)]
+            public sbyte __dummy__Alias_12;
+
+            [FieldOffset(13)]
+            public sbyte __dummy__Alias_13;
+
+            [FieldOffset(14)]
+            public sbyte __dummy__Alias_14;
+
+            [FieldOffset(15)]
+            public sbyte __dummy__Alias_15;
+
+            [FieldOffset(16)]
+            public uint _Mysize;
+
+            [FieldOffset(20)]
+            public uint _Myres;
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                EntryPoint="??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ")]
+            internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
+                EntryPoint="?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ")]
+            internal static extern global::System.IntPtr c_str_0(global::System.IntPtr instance);
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static basic_string __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new basic_string(native.ToPointer(), skipVTables);
+        }
+
+        public static basic_string __CreateInstance(basic_string.Internal native, bool skipVTables = false)
+        {
+            return new basic_string(native, skipVTables);
+        }
+
+        private static void* __CopyValue(basic_string.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(24);
+            *(basic_string.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private basic_string(basic_string.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected basic_string(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.basic_string __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+
+        public string c_str()
+        {
+            var __ret = Internal.c_str_0((__Instance + __PointerAdjustment));
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+
+        public static uint npos
+        {
+            get
+            {
+                var __ptr = (uint*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "?npos@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@2IB");
+                return *__ptr;
+            }
+        }
+    }
+}

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/CppSharp.CppParser.cs

@@ -62,7 +62,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             }
 
             public enum AccessSpecifier
@@ -10840,6 +10843,565 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class VarTemplate : global::CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 224)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.__1.basic_string.Internal Name;
+
+                    [FieldOffset(56)]
+                    public global::std.__1.basic_string.Internal USR;
+
+                    [FieldOffset(80)]
+                    public global::std.__1.basic_string.Internal DebugText;
+
+                    [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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST11VarTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18getSpecializationsEj")]
+                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18addSpecializationsERPNS1_25VarTemplateSpecializationE")]
+                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate20clearSpecializationsEv")]
+                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate23getSpecializationsCountEv")]
+                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplate __CreateInstance(VarTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(224);
+                    global::CppSharp.Parser.AST.VarTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplate(VarTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(224);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplate(global::CppSharp.Parser.AST.VarTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(224);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.VarTemplateSpecialization getSpecializations(uint i)
+                {
+                    var __ret = Internal.getSpecializations_0((__Instance + __PointerAdjustment), i);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (global::CppSharp.Parser.AST.VarTemplateSpecialization) global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap[__ret];
+                    else __result0 = global::CppSharp.Parser.AST.VarTemplateSpecialization.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addSpecializations(global::CppSharp.Parser.AST.VarTemplateSpecialization s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = s.__Instance;
+                    Internal.addSpecializations_0((__Instance + __PointerAdjustment), __arg0);
+                }
+
+                public void clearSpecializations()
+                {
+                    Internal.clearSpecializations_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint SpecializationsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getSpecializationsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplateSpecialization : global::CppSharp.Parser.AST.Variable, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 248)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.__1.basic_string.Internal Name;
+
+                    [FieldOffset(56)]
+                    public global::std.__1.basic_string.Internal USR;
+
+                    [FieldOffset(80)]
+                    public global::std.__1.basic_string.Internal DebugText;
+
+                    [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::std.__1.basic_string.Internal Mangled;
+
+                    [FieldOffset(192)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(208)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(240)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12getArgumentsEj")]
+                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12addArgumentsERNS1_16TemplateArgumentE")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplateSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplateSpecialization __CreateInstance(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplateSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(248);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplateSpecialization(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplateSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplateSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplateSpecialization(global::CppSharp.Parser.AST.VarTemplateSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
+                {
+                    var __ret = new global::CppSharp.Parser.AST.TemplateArgument.Internal();
+                    Internal.getArguments_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), i);
+                    return global::CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
+                }
+
+                public void addArguments(global::CppSharp.Parser.AST.TemplateArgument s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = 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 global::CppSharp.Parser.AST.VarTemplate TemplatedDecl
+                {
+                    get
+                    {
+                        global::CppSharp.Parser.AST.VarTemplate __result0;
+                        if (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) __result0 = null;
+                        else if (global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap.ContainsKey(((Internal*) __Instance)->TemplatedDecl))
+                            __result0 = (global::CppSharp.Parser.AST.VarTemplate) global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap[((Internal*) __Instance)->TemplatedDecl];
+                        else __result0 = global::CppSharp.Parser.AST.VarTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
+                        return __result0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
+                    }
+                }
+
+                public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->SpecializationKind;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->SpecializationKind = value;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplatePartialSpecialization : global::CppSharp.Parser.AST.VarTemplateSpecialization, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 248)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.__1.basic_string.Internal Name;
+
+                    [FieldOffset(56)]
+                    public global::std.__1.basic_string.Internal USR;
+
+                    [FieldOffset(80)]
+                    public global::std.__1.basic_string.Internal DebugText;
+
+                    [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::std.__1.basic_string.Internal Mangled;
+
+                    [FieldOffset(192)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(208)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(240)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplatePartialSpecialization __CreateInstance(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplatePartialSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(248);
+                    global::CppSharp.Parser.AST.VarTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplatePartialSpecialization(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplatePartialSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplatePartialSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplatePartialSpecialization(global::CppSharp.Parser.AST.VarTemplatePartialSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
             public unsafe partial class Namespace : global::CppSharp.Parser.AST.DeclarationContext, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 416)]

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/CppSharp.CppParser.dll-templates.cpp

@@ -0,0 +1,29 @@
+#include <AST.h>
+#include <Sources.h>
+#include <CppParser.h>
+
+template class vector<CppSharp::CppParser::AST::Namespace*>;
+template class vector<CppSharp::CppParser::AST::Enumeration*>;
+template class vector<CppSharp::CppParser::AST::Function*>;
+template class vector<CppSharp::CppParser::AST::Class*>;
+template class vector<CppSharp::CppParser::AST::Template*>;
+template class vector<CppSharp::CppParser::AST::TypedefDecl*>;
+template class vector<CppSharp::CppParser::AST::TypeAlias*>;
+template class vector<CppSharp::CppParser::AST::Variable*>;
+template class vector<CppSharp::CppParser::AST::Friend*>;
+template class vector<CppSharp::CppParser::AST::BaseClassSpecifier*>;
+template class vector<CppSharp::CppParser::AST::Field*>;
+template class vector<CppSharp::CppParser::AST::Method*>;
+template class vector<CppSharp::CppParser::AST::AccessSpecifierDecl*>;
+template class vector<CppSharp::CppParser::AST::Declaration*>;
+template class vector<CppSharp::CppParser::AST::FunctionTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Parameter*>;
+template class vector<CppSharp::CppParser::AST::ClassTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Enumeration::Item*>;
+template class vector<CppSharp::CppParser::AST::BlockContentComment*>;
+template class vector<CppSharp::CppParser::AST::PreprocessedEntity*>;
+template class vector<CppSharp::CppParser::AST::Expression*>;
+template class vector<CppSharp::CppParser::AST::MacroDefinition*>;
+template class vector<CppSharp::CppParser::AST::TranslationUnit*>;
+template class vector<CppSharp::CppParser::AST::InlineContentComment*>;
+template class vector<CppSharp::CppParser::AST::VerbatimBlockLineComment*>;

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/Std-templates.cpp

@@ -0,0 +1,4 @@
+#include <string>
+
+template class __declspec(dllexport) std::allocator<char>;
+template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char>>;

src/CppParser/Bindings/CSharp/x86_64-apple-darwin12.4.0/Std.cs

@@ -0,0 +1,773 @@
+//----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+//----------------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace std
+{
+    namespace __1
+    {
+        public unsafe partial class allocator : IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 0)]
+            public unsafe partial struct Internal
+            {
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSt3__19allocatorIcEC2Ev")]
+                internal static extern void ctor_0(global::System.IntPtr instance);
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            protected int __PointerAdjustment;
+            public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator>();
+            protected void*[] __OriginalVTables;
+
+            protected bool __ownsNativeInstance;
+
+            public static allocator __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new allocator(native.ToPointer(), skipVTables);
+            }
+
+            public static allocator __CreateInstance(allocator.Internal native, bool skipVTables = false)
+            {
+                return new allocator(native, skipVTables);
+            }
+
+            private static void* __CopyValue(allocator.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(0);
+                *(allocator.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private allocator(allocator.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected allocator(void* native, bool skipVTables = false)
+            {
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public allocator()
+            {
+                __Instance = Marshal.AllocHGlobal(0);
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+                Internal.ctor_0((__Instance + __PointerAdjustment));
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                global::std.__1.allocator __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+        }
+
+        public unsafe partial class __destruct_n
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public ulong size;
+            }
+        }
+
+        public unsafe partial class bad_weak_ptr
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr vptr_exception;
+            }
+        }
+
+        public unsafe abstract partial class __shared_count
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 16)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr vptr___shared_count;
+
+                [FieldOffset(8)]
+                public long __shared_owners_;
+            }
+        }
+
+        public unsafe abstract partial class __shared_weak_count
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr vptr___shared_count;
+
+                [FieldOffset(8)]
+                public long __shared_owners_;
+
+                [FieldOffset(16)]
+                public long __shared_weak_owners_;
+            }
+        }
+
+        public unsafe partial class __sp_mut
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr __lx;
+            }
+        }
+
+        public unsafe partial class pointer_safety
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 4)]
+            public partial struct Internal
+            {
+            }
+        }
+
+        namespace __pointer_type_imp
+        {
+        }
+    }
+}
+
+namespace std
+{
+    namespace __1
+    {
+        public unsafe partial class basic_string : IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public unsafe partial struct Internal
+            {
+                [FieldOffset(0)]
+                public ulong __cap_;
+
+                [FieldOffset(8)]
+                public ulong __size_;
+
+                [FieldOffset(16)]
+                public global::System.IntPtr __data_;
+
+                [FieldOffset(0)]
+                public byte __size_1;
+
+                [FieldOffset(0)]
+                public sbyte __lx;
+
+                [FieldOffset(1)]
+                public fixed sbyte __data_1[23];
+
+                [FieldOffset(2)]
+                public sbyte __dummy___data_1_1;
+
+                [FieldOffset(3)]
+                public sbyte __dummy___data_1_2;
+
+                [FieldOffset(4)]
+                public sbyte __dummy___data_1_3;
+
+                [FieldOffset(5)]
+                public sbyte __dummy___data_1_4;
+
+                [FieldOffset(6)]
+                public sbyte __dummy___data_1_5;
+
+                [FieldOffset(7)]
+                public sbyte __dummy___data_1_6;
+
+                [FieldOffset(8)]
+                public sbyte __dummy___data_1_7;
+
+                [FieldOffset(9)]
+                public sbyte __dummy___data_1_8;
+
+                [FieldOffset(10)]
+                public sbyte __dummy___data_1_9;
+
+                [FieldOffset(11)]
+                public sbyte __dummy___data_1_10;
+
+                [FieldOffset(12)]
+                public sbyte __dummy___data_1_11;
+
+                [FieldOffset(13)]
+                public sbyte __dummy___data_1_12;
+
+                [FieldOffset(14)]
+                public sbyte __dummy___data_1_13;
+
+                [FieldOffset(15)]
+                public sbyte __dummy___data_1_14;
+
+                [FieldOffset(16)]
+                public sbyte __dummy___data_1_15;
+
+                [FieldOffset(17)]
+                public sbyte __dummy___data_1_16;
+
+                [FieldOffset(18)]
+                public sbyte __dummy___data_1_17;
+
+                [FieldOffset(19)]
+                public sbyte __dummy___data_1_18;
+
+                [FieldOffset(20)]
+                public sbyte __dummy___data_1_19;
+
+                [FieldOffset(21)]
+                public sbyte __dummy___data_1_20;
+
+                [FieldOffset(22)]
+                public sbyte __dummy___data_1_21;
+
+                [FieldOffset(23)]
+                public sbyte __dummy___data_1_22;
+
+                [FieldOffset(0)]
+                public fixed ulong __words[3];
+
+                [FieldOffset(8)]
+                public ulong __dummy___words_1;
+
+                [FieldOffset(16)]
+                public ulong __dummy___words_2;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev")]
+                internal static extern void dtor_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv")]
+                internal static extern global::System.IntPtr c_str_0(global::System.IntPtr instance);
+            }
+
+            internal enum short_mask : uint
+            {
+                __short_mask = 0x1
+            }
+
+            internal enum long_mask : uint
+            {
+                __long_mask = 0x1
+            }
+
+            internal enum min_cap : uint
+            {
+                __min_cap = 23
+            }
+
+            internal enum n_words : uint
+            {
+                __n_words = 3
+            }
+
+            [Flags]
+            internal enum alignment : uint
+            {
+                __alignment = 16
+            }
+
+            public unsafe partial class __rep : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 24)]
+                public partial struct Internal
+                {
+                }
+
+                public unsafe partial struct _
+                {
+                    [StructLayout(LayoutKind.Explicit, Size = 24)]
+                    public partial struct Internal
+                    {
+                    }
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __rep> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __rep>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __rep __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __rep(native.ToPointer(), skipVTables);
+                }
+
+                public static __rep __CreateInstance(__rep.Internal native, bool skipVTables = false)
+                {
+                    return new __rep(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__rep.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(24);
+                    *(__rep.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __rep(__rep.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __rep(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __rep()
+                {
+                    __Instance = Marshal.AllocHGlobal(24);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__rep __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial class __long : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 24)]
+                public partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public ulong __cap_;
+
+                    [FieldOffset(8)]
+                    public ulong __size_;
+
+                    [FieldOffset(16)]
+                    public global::System.IntPtr __data_;
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __long> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __long>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __long __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __long(native.ToPointer(), skipVTables);
+                }
+
+                public static __long __CreateInstance(__long.Internal native, bool skipVTables = false)
+                {
+                    return new __long(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__long.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(24);
+                    *(__long.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __long(__long.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __long(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __long()
+                {
+                    __Instance = Marshal.AllocHGlobal(24);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__long __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial class __short : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 24)]
+                public partial struct Internal
+                {
+                    [FieldOffset(1)]
+                    public fixed sbyte __data_[23];
+
+                    [FieldOffset(2)]
+                    public sbyte __dummy___data__1;
+
+                    [FieldOffset(3)]
+                    public sbyte __dummy___data__2;
+
+                    [FieldOffset(4)]
+                    public sbyte __dummy___data__3;
+
+                    [FieldOffset(5)]
+                    public sbyte __dummy___data__4;
+
+                    [FieldOffset(6)]
+                    public sbyte __dummy___data__5;
+
+                    [FieldOffset(7)]
+                    public sbyte __dummy___data__6;
+
+                    [FieldOffset(8)]
+                    public sbyte __dummy___data__7;
+
+                    [FieldOffset(9)]
+                    public sbyte __dummy___data__8;
+
+                    [FieldOffset(10)]
+                    public sbyte __dummy___data__9;
+
+                    [FieldOffset(11)]
+                    public sbyte __dummy___data__10;
+
+                    [FieldOffset(12)]
+                    public sbyte __dummy___data__11;
+
+                    [FieldOffset(13)]
+                    public sbyte __dummy___data__12;
+
+                    [FieldOffset(14)]
+                    public sbyte __dummy___data__13;
+
+                    [FieldOffset(15)]
+                    public sbyte __dummy___data__14;
+
+                    [FieldOffset(16)]
+                    public sbyte __dummy___data__15;
+
+                    [FieldOffset(17)]
+                    public sbyte __dummy___data__16;
+
+                    [FieldOffset(18)]
+                    public sbyte __dummy___data__17;
+
+                    [FieldOffset(19)]
+                    public sbyte __dummy___data__18;
+
+                    [FieldOffset(20)]
+                    public sbyte __dummy___data__19;
+
+                    [FieldOffset(21)]
+                    public sbyte __dummy___data__20;
+
+                    [FieldOffset(22)]
+                    public sbyte __dummy___data__21;
+
+                    [FieldOffset(23)]
+                    public sbyte __dummy___data__22;
+                }
+
+                public unsafe partial struct _
+                {
+                    [StructLayout(LayoutKind.Explicit, Size = 1)]
+                    public partial struct Internal
+                    {
+                        [FieldOffset(0)]
+                        public byte __size_;
+
+                        [FieldOffset(0)]
+                        public sbyte __lx;
+                    }
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __short> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __short>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __short __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __short(native.ToPointer(), skipVTables);
+                }
+
+                public static __short __CreateInstance(__short.Internal native, bool skipVTables = false)
+                {
+                    return new __short(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__short.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(24);
+                    *(__short.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __short(__short.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __short(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __short()
+                {
+                    __Instance = Marshal.AllocHGlobal(24);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__short __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial class __raw : IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 24)]
+                public partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public fixed ulong __words[3];
+
+                    [FieldOffset(8)]
+                    public ulong __dummy___words_1;
+
+                    [FieldOffset(16)]
+                    public ulong __dummy___words_2;
+                }
+
+                public global::System.IntPtr __Instance { get; protected set; }
+
+                protected int __PointerAdjustment;
+                public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __raw> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, __raw>();
+                protected void*[] __OriginalVTables;
+
+                protected bool __ownsNativeInstance;
+
+                public static __raw __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __raw(native.ToPointer(), skipVTables);
+                }
+
+                public static __raw __CreateInstance(__raw.Internal native, bool skipVTables = false)
+                {
+                    return new __raw(native, skipVTables);
+                }
+
+                private static void* __CopyValue(__raw.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(24);
+                    *(__raw.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private __raw(__raw.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected __raw(void* native, bool skipVTables = false)
+                {
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public __raw()
+                {
+                    __Instance = Marshal.AllocHGlobal(24);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                public void Dispose()
+                {
+                    Dispose(disposing: true);
+                }
+
+                protected virtual void Dispose(bool disposing)
+                {
+                    global::std.__1.basic_string.__raw __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial struct __ulx
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 24)]
+                public partial struct Internal
+                {
+                }
+
+                private __ulx.Internal __instance;
+                public __ulx.Internal __Instance { get { return __instance; } }
+
+                public static __ulx __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new __ulx(native.ToPointer(), skipVTables);
+                }
+
+                public static __ulx __CreateInstance(__ulx.Internal native, bool skipVTables = false)
+                {
+                    return new __ulx(native, skipVTables);
+                }
+
+                private __ulx(__ulx.Internal native, bool skipVTables = false)
+                    : this()
+                {
+                    __instance = native;
+                }
+
+                private __ulx(void* native, bool skipVTables = false) : this()
+                {
+                    __instance = *(Internal*) native;
+                }
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            protected int __PointerAdjustment;
+            public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string>();
+            protected void*[] __OriginalVTables;
+
+            protected bool __ownsNativeInstance;
+
+            public static basic_string __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new basic_string(native.ToPointer(), skipVTables);
+            }
+
+            public static basic_string __CreateInstance(basic_string.Internal native, bool skipVTables = false)
+            {
+                return new basic_string(native, skipVTables);
+            }
+
+            private static void* __CopyValue(basic_string.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(24);
+                *(basic_string.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private basic_string(basic_string.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected basic_string(void* native, bool skipVTables = false)
+            {
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                global::std.__1.basic_string __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                Internal.dtor_0((__Instance + __PointerAdjustment));
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+
+            public string c_str()
+            {
+                var __ret = Internal.c_str_0((__Instance + __PointerAdjustment));
+                return Marshal.PtrToStringAnsi(__ret);
+            }
+
+            public static ulong npos
+            {
+                get
+                {
+                    var __ptr = (ulong*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE");
+                    return *__ptr;
+                }
+            }
+        }
+    }
+}

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/CppSharp.CppParser.cs

@@ -62,7 +62,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             }
 
             public enum AccessSpecifier
@@ -10840,6 +10843,565 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class VarTemplate : global::CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 248)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.__cxx11.basic_string.Internal Name;
+
+                    [FieldOffset(64)]
+                    public global::std.__cxx11.basic_string.Internal USR;
+
+                    [FieldOffset(96)]
+                    public global::std.__cxx11.basic_string.Internal DebugText;
+
+                    [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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST11VarTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18getSpecializationsEj")]
+                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18addSpecializationsERPNS1_25VarTemplateSpecializationE")]
+                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate20clearSpecializationsEv")]
+                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate23getSpecializationsCountEv")]
+                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplate __CreateInstance(VarTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(248);
+                    global::CppSharp.Parser.AST.VarTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplate(VarTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplate(global::CppSharp.Parser.AST.VarTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.VarTemplateSpecialization getSpecializations(uint i)
+                {
+                    var __ret = Internal.getSpecializations_0((__Instance + __PointerAdjustment), i);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (global::CppSharp.Parser.AST.VarTemplateSpecialization) global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap[__ret];
+                    else __result0 = global::CppSharp.Parser.AST.VarTemplateSpecialization.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addSpecializations(global::CppSharp.Parser.AST.VarTemplateSpecialization s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = s.__Instance;
+                    Internal.addSpecializations_0((__Instance + __PointerAdjustment), __arg0);
+                }
+
+                public void clearSpecializations()
+                {
+                    Internal.clearSpecializations_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint SpecializationsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getSpecializationsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplateSpecialization : global::CppSharp.Parser.AST.Variable, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 280)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.__cxx11.basic_string.Internal Name;
+
+                    [FieldOffset(64)]
+                    public global::std.__cxx11.basic_string.Internal USR;
+
+                    [FieldOffset(96)]
+                    public global::std.__cxx11.basic_string.Internal DebugText;
+
+                    [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::std.__cxx11.basic_string.Internal Mangled;
+
+                    [FieldOffset(224)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(240)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(272)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12getArgumentsEj")]
+                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12addArgumentsERNS1_16TemplateArgumentE")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplateSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplateSpecialization __CreateInstance(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplateSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(280);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplateSpecialization(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplateSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplateSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplateSpecialization(global::CppSharp.Parser.AST.VarTemplateSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
+                {
+                    var __ret = new global::CppSharp.Parser.AST.TemplateArgument.Internal();
+                    Internal.getArguments_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), i);
+                    return global::CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
+                }
+
+                public void addArguments(global::CppSharp.Parser.AST.TemplateArgument s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = 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 global::CppSharp.Parser.AST.VarTemplate TemplatedDecl
+                {
+                    get
+                    {
+                        global::CppSharp.Parser.AST.VarTemplate __result0;
+                        if (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) __result0 = null;
+                        else if (global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap.ContainsKey(((Internal*) __Instance)->TemplatedDecl))
+                            __result0 = (global::CppSharp.Parser.AST.VarTemplate) global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap[((Internal*) __Instance)->TemplatedDecl];
+                        else __result0 = global::CppSharp.Parser.AST.VarTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
+                        return __result0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
+                    }
+                }
+
+                public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->SpecializationKind;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->SpecializationKind = value;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplatePartialSpecialization : global::CppSharp.Parser.AST.VarTemplateSpecialization, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 280)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.__cxx11.basic_string.Internal Name;
+
+                    [FieldOffset(64)]
+                    public global::std.__cxx11.basic_string.Internal USR;
+
+                    [FieldOffset(96)]
+                    public global::std.__cxx11.basic_string.Internal DebugText;
+
+                    [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::std.__cxx11.basic_string.Internal Mangled;
+
+                    [FieldOffset(224)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(240)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(272)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplatePartialSpecialization __CreateInstance(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplatePartialSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(280);
+                    global::CppSharp.Parser.AST.VarTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplatePartialSpecialization(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplatePartialSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplatePartialSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplatePartialSpecialization(global::CppSharp.Parser.AST.VarTemplatePartialSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
             public unsafe partial class Namespace : global::CppSharp.Parser.AST.DeclarationContext, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 464)]

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/Std-templates.cpp

@@ -0,0 +1,4 @@
+#include <string>
+
+template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char>>;
+template class __declspec(dllexport) std::allocator<char>;

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/Std.cs

@@ -0,0 +1,358 @@
+//----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+//----------------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace std
+{
+    public unsafe partial class allocator : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public unsafe partial struct Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSaIcEC2Ev")]
+            internal static extern void ctor_0(global::System.IntPtr instance);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSaIcED2Ev")]
+            internal static extern void dtor_0(global::System.IntPtr instance);
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static allocator __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new allocator(native.ToPointer(), skipVTables);
+        }
+
+        public static allocator __CreateInstance(allocator.Internal native, bool skipVTables = false)
+        {
+            return new allocator(native, skipVTables);
+        }
+
+        private static void* __CopyValue(allocator.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(0);
+            *(allocator.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private allocator(allocator.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected allocator(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public allocator()
+        {
+            __Instance = Marshal.AllocHGlobal(0);
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+            Internal.ctor_0((__Instance + __PointerAdjustment));
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.allocator __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            Internal.dtor_0((__Instance + __PointerAdjustment));
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+    }
+}
+
+namespace std
+{
+    namespace __cxx11
+    {
+        public unsafe partial class basic_string : IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 32)]
+            public unsafe partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr _M_p;
+
+                [FieldOffset(8)]
+                public ulong _M_string_length;
+
+                [FieldOffset(16)]
+                public fixed sbyte _M_local_buf[16];
+
+                [FieldOffset(17)]
+                public sbyte __dummy__M_local_buf_1;
+
+                [FieldOffset(18)]
+                public sbyte __dummy__M_local_buf_2;
+
+                [FieldOffset(19)]
+                public sbyte __dummy__M_local_buf_3;
+
+                [FieldOffset(20)]
+                public sbyte __dummy__M_local_buf_4;
+
+                [FieldOffset(21)]
+                public sbyte __dummy__M_local_buf_5;
+
+                [FieldOffset(22)]
+                public sbyte __dummy__M_local_buf_6;
+
+                [FieldOffset(23)]
+                public sbyte __dummy__M_local_buf_7;
+
+                [FieldOffset(24)]
+                public sbyte __dummy__M_local_buf_8;
+
+                [FieldOffset(25)]
+                public sbyte __dummy__M_local_buf_9;
+
+                [FieldOffset(26)]
+                public sbyte __dummy__M_local_buf_10;
+
+                [FieldOffset(27)]
+                public sbyte __dummy__M_local_buf_11;
+
+                [FieldOffset(28)]
+                public sbyte __dummy__M_local_buf_12;
+
+                [FieldOffset(29)]
+                public sbyte __dummy__M_local_buf_13;
+
+                [FieldOffset(30)]
+                public sbyte __dummy__M_local_buf_14;
+
+                [FieldOffset(31)]
+                public sbyte __dummy__M_local_buf_15;
+
+                [FieldOffset(16)]
+                public ulong _M_allocated_capacity;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev")]
+                internal static extern void dtor_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv")]
+                internal static extern global::System.IntPtr c_str_0(global::System.IntPtr instance);
+            }
+
+            internal enum S_local_capacity : uint
+            {
+                _S_local_capacity = 15
+            }
+
+            public unsafe partial class _Alloc_hider : global::std.allocator, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 8)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::System.IntPtr _M_p;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new _Alloc_hider __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new _Alloc_hider(native.ToPointer(), skipVTables);
+                }
+
+                public static _Alloc_hider __CreateInstance(_Alloc_hider.Internal native, bool skipVTables = false)
+                {
+                    return new _Alloc_hider(native, skipVTables);
+                }
+
+                private static void* __CopyValue(_Alloc_hider.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(8);
+                    *(_Alloc_hider.Internal*) ret = native;
+                    return ret.ToPointer();
+                }
+
+                private _Alloc_hider(_Alloc_hider.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected _Alloc_hider(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                protected override void Dispose(bool disposing)
+                {
+                    global::std.allocator __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
+            public unsafe partial struct _
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 16)]
+                public partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public fixed sbyte _M_local_buf[16];
+
+                    [FieldOffset(1)]
+                    public sbyte __dummy__M_local_buf_1;
+
+                    [FieldOffset(2)]
+                    public sbyte __dummy__M_local_buf_2;
+
+                    [FieldOffset(3)]
+                    public sbyte __dummy__M_local_buf_3;
+
+                    [FieldOffset(4)]
+                    public sbyte __dummy__M_local_buf_4;
+
+                    [FieldOffset(5)]
+                    public sbyte __dummy__M_local_buf_5;
+
+                    [FieldOffset(6)]
+                    public sbyte __dummy__M_local_buf_6;
+
+                    [FieldOffset(7)]
+                    public sbyte __dummy__M_local_buf_7;
+
+                    [FieldOffset(8)]
+                    public sbyte __dummy__M_local_buf_8;
+
+                    [FieldOffset(9)]
+                    public sbyte __dummy__M_local_buf_9;
+
+                    [FieldOffset(10)]
+                    public sbyte __dummy__M_local_buf_10;
+
+                    [FieldOffset(11)]
+                    public sbyte __dummy__M_local_buf_11;
+
+                    [FieldOffset(12)]
+                    public sbyte __dummy__M_local_buf_12;
+
+                    [FieldOffset(13)]
+                    public sbyte __dummy__M_local_buf_13;
+
+                    [FieldOffset(14)]
+                    public sbyte __dummy__M_local_buf_14;
+
+                    [FieldOffset(15)]
+                    public sbyte __dummy__M_local_buf_15;
+
+                    [FieldOffset(0)]
+                    public ulong _M_allocated_capacity;
+                }
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            protected int __PointerAdjustment;
+            public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string>();
+            protected void*[] __OriginalVTables;
+
+            protected bool __ownsNativeInstance;
+
+            public static basic_string __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new basic_string(native.ToPointer(), skipVTables);
+            }
+
+            public static basic_string __CreateInstance(basic_string.Internal native, bool skipVTables = false)
+            {
+                return new basic_string(native, skipVTables);
+            }
+
+            private static void* __CopyValue(basic_string.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(32);
+                *(basic_string.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private basic_string(basic_string.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected basic_string(void* native, bool skipVTables = false)
+            {
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                global::std.__cxx11.basic_string __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                Internal.dtor_0((__Instance + __PointerAdjustment));
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+
+            public string c_str()
+            {
+                var __ret = Internal.c_str_0((__Instance + __PointerAdjustment));
+                return Marshal.PtrToStringAnsi(__ret);
+            }
+
+            public static ulong npos
+            {
+                get
+                {
+                    var __ptr = (ulong*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4nposE");
+                    return *__ptr;
+                }
+            }
+        }
+    }
+}

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppSharp.CppParser.cs

@@ -62,7 +62,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             }
 
             public enum AccessSpecifier
@@ -10840,6 +10843,565 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class VarTemplate : global::CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 176)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(40)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(48)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplateC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST11VarTemplateD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18getSpecializationsEj")]
+                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate18addSpecializationsERPNS1_25VarTemplateSpecializationE")]
+                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate20clearSpecializationsEv")]
+                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST11VarTemplate23getSpecializationsCountEv")]
+                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplate __CreateInstance(VarTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(176);
+                    global::CppSharp.Parser.AST.VarTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplate(VarTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(176);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplate(global::CppSharp.Parser.AST.VarTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(176);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.VarTemplateSpecialization getSpecializations(uint i)
+                {
+                    var __ret = Internal.getSpecializations_0((__Instance + __PointerAdjustment), i);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (global::CppSharp.Parser.AST.VarTemplateSpecialization) global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap[__ret];
+                    else __result0 = global::CppSharp.Parser.AST.VarTemplateSpecialization.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addSpecializations(global::CppSharp.Parser.AST.VarTemplateSpecialization s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = s.__Instance;
+                    Internal.addSpecializations_0((__Instance + __PointerAdjustment), __arg0);
+                }
+
+                public void clearSpecializations()
+                {
+                    Internal.clearSpecializations_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint SpecializationsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getSpecializationsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplateSpecialization : global::CppSharp.Parser.AST.Variable, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 184)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(40)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(48)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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::std.basic_string.Internal Mangled;
+
+                    [FieldOffset(128)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(144)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(176)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12getArgumentsEj")]
+                    internal static extern void getArguments_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization12addArgumentsERNS1_16TemplateArgumentE")]
+                    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="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization14clearArgumentsEv")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST25VarTemplateSpecialization17getArgumentsCountEv")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplateSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplateSpecialization __CreateInstance(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplateSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(184);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplateSpecialization(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplateSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplateSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(184);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplateSpecialization(global::CppSharp.Parser.AST.VarTemplateSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(184);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
+                {
+                    var __ret = new global::CppSharp.Parser.AST.TemplateArgument.Internal();
+                    Internal.getArguments_0(new IntPtr(&__ret), (__Instance + __PointerAdjustment), i);
+                    return global::CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
+                }
+
+                public void addArguments(global::CppSharp.Parser.AST.TemplateArgument s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = 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 global::CppSharp.Parser.AST.VarTemplate TemplatedDecl
+                {
+                    get
+                    {
+                        global::CppSharp.Parser.AST.VarTemplate __result0;
+                        if (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) __result0 = null;
+                        else if (global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap.ContainsKey(((Internal*) __Instance)->TemplatedDecl))
+                            __result0 = (global::CppSharp.Parser.AST.VarTemplate) global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap[((Internal*) __Instance)->TemplatedDecl];
+                        else __result0 = global::CppSharp.Parser.AST.VarTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
+                        return __result0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
+                    }
+                }
+
+                public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->SpecializationKind;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->SpecializationKind = value;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplatePartialSpecialization : global::CppSharp.Parser.AST.VarTemplateSpecialization, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 184)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(40)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(48)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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::std.basic_string.Internal Mangled;
+
+                    [FieldOffset(128)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(144)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(176)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2Ev")]
+                    internal static extern void ctor_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationC2ERKS2_")]
+                    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="_ZN8CppSharp9CppParser3AST32VarTemplatePartialSpecializationD2Ev")]
+                    internal static extern void dtor_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplatePartialSpecialization __CreateInstance(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplatePartialSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(184);
+                    global::CppSharp.Parser.AST.VarTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplatePartialSpecialization(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplatePartialSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplatePartialSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(184);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplatePartialSpecialization(global::CppSharp.Parser.AST.VarTemplatePartialSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(184);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment));
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
             public unsafe partial class Namespace : global::CppSharp.Parser.AST.DeclarationContext, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 392)]

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppSharp.CppParser.dll-templates.cpp

@@ -0,0 +1,29 @@
+#include <AST.h>
+#include <Sources.h>
+#include <CppParser.h>
+
+template class vector<CppSharp::CppParser::AST::Namespace*>;
+template class vector<CppSharp::CppParser::AST::Enumeration*>;
+template class vector<CppSharp::CppParser::AST::Function*>;
+template class vector<CppSharp::CppParser::AST::Class*>;
+template class vector<CppSharp::CppParser::AST::Template*>;
+template class vector<CppSharp::CppParser::AST::TypedefDecl*>;
+template class vector<CppSharp::CppParser::AST::TypeAlias*>;
+template class vector<CppSharp::CppParser::AST::Variable*>;
+template class vector<CppSharp::CppParser::AST::Friend*>;
+template class vector<CppSharp::CppParser::AST::BaseClassSpecifier*>;
+template class vector<CppSharp::CppParser::AST::Field*>;
+template class vector<CppSharp::CppParser::AST::Method*>;
+template class vector<CppSharp::CppParser::AST::AccessSpecifierDecl*>;
+template class vector<CppSharp::CppParser::AST::Declaration*>;
+template class vector<CppSharp::CppParser::AST::FunctionTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Parameter*>;
+template class vector<CppSharp::CppParser::AST::ClassTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Enumeration::Item*>;
+template class vector<CppSharp::CppParser::AST::BlockContentComment*>;
+template class vector<CppSharp::CppParser::AST::PreprocessedEntity*>;
+template class vector<CppSharp::CppParser::AST::Expression*>;
+template class vector<CppSharp::CppParser::AST::MacroDefinition*>;
+template class vector<CppSharp::CppParser::AST::TranslationUnit*>;
+template class vector<CppSharp::CppParser::AST::InlineContentComment*>;
+template class vector<CppSharp::CppParser::AST::VerbatimBlockLineComment*>;

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Std-templates.cpp

@@ -0,0 +1,4 @@
+#include <string>
+
+template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char>>;
+template class __declspec(dllexport) std::allocator<char>;

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Std.cs

@@ -0,0 +1,505 @@
+//----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+//----------------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace std
+{
+    public unsafe partial class allocator : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public unsafe partial struct Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSaIcEC2Ev")]
+            internal static extern void ctor_0(global::System.IntPtr instance);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSaIcED2Ev")]
+            internal static extern void dtor_0(global::System.IntPtr instance);
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static allocator __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new allocator(native.ToPointer(), skipVTables);
+        }
+
+        public static allocator __CreateInstance(allocator.Internal native, bool skipVTables = false)
+        {
+            return new allocator(native, skipVTables);
+        }
+
+        private static void* __CopyValue(allocator.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(0);
+            *(allocator.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private allocator(allocator.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected allocator(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public allocator()
+        {
+            __Instance = Marshal.AllocHGlobal(0);
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+            Internal.ctor_0((__Instance + __PointerAdjustment));
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.allocator __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            Internal.dtor_0((__Instance + __PointerAdjustment));
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+    }
+}
+
+namespace std
+{
+    public unsafe partial class basic_string : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct Internal
+        {
+            [FieldOffset(0)]
+            public global::System.IntPtr _M_p;
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNSsD2Ev")]
+            internal static extern void dtor_0(global::System.IntPtr instance);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="_ZNKSs5c_strEv")]
+            internal static extern global::System.IntPtr c_str_0(global::System.IntPtr instance);
+        }
+
+        public unsafe partial class _Alloc_hider : global::std.allocator, IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
+            public new partial struct Internal
+            {
+                [FieldOffset(0)]
+                public global::System.IntPtr _M_p;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSs12_Alloc_hiderD2Ev")]
+                internal static extern void dtor_0(global::System.IntPtr instance);
+            }
+
+            public static new _Alloc_hider __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new _Alloc_hider(native.ToPointer(), skipVTables);
+            }
+
+            public static _Alloc_hider __CreateInstance(_Alloc_hider.Internal native, bool skipVTables = false)
+            {
+                return new _Alloc_hider(native, skipVTables);
+            }
+
+            private static void* __CopyValue(_Alloc_hider.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(8);
+                *(_Alloc_hider.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private _Alloc_hider(_Alloc_hider.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected _Alloc_hider(void* native, bool skipVTables = false)
+                : base((void*) null)
+            {
+                __PointerAdjustment = 0;
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                global::std.allocator __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                Internal.dtor_0((__Instance + __PointerAdjustment));
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+
+            public sbyte* _M_p
+            {
+                get
+                {
+                    return ((Internal*) __Instance)->_M_p;
+                }
+
+                set
+                {
+                    ((Internal*) __Instance)->_M_p = (global::System.IntPtr) value;
+                }
+            }
+        }
+
+        public unsafe partial class _Rep_base : IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public partial struct Internal
+            {
+                [FieldOffset(0)]
+                public ulong _M_length;
+
+                [FieldOffset(8)]
+                public ulong _M_capacity;
+
+                [FieldOffset(16)]
+                public int _M_refcount;
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            protected int __PointerAdjustment;
+            public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, _Rep_base> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, _Rep_base>();
+            protected void*[] __OriginalVTables;
+
+            protected bool __ownsNativeInstance;
+
+            public static _Rep_base __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new _Rep_base(native.ToPointer(), skipVTables);
+            }
+
+            public static _Rep_base __CreateInstance(_Rep_base.Internal native, bool skipVTables = false)
+            {
+                return new _Rep_base(native, skipVTables);
+            }
+
+            private static void* __CopyValue(_Rep_base.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(24);
+                *(_Rep_base.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private _Rep_base(_Rep_base.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected _Rep_base(void* native, bool skipVTables = false)
+            {
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public _Rep_base()
+            {
+                __Instance = Marshal.AllocHGlobal(24);
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                global::std.basic_string._Rep_base __dummy;
+                NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                if (__ownsNativeInstance)
+                    Marshal.FreeHGlobal(__Instance);
+            }
+
+            public int _M_refcount
+            {
+                get
+                {
+                    return ((Internal*) __Instance)->_M_refcount;
+                }
+
+                set
+                {
+                    ((Internal*) __Instance)->_M_refcount = value;
+                }
+            }
+        }
+
+        public unsafe partial class _Rep : global::std.basic_string._Rep_base, IDisposable
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public new partial struct Internal
+            {
+                [FieldOffset(0)]
+                public ulong _M_length;
+
+                [FieldOffset(8)]
+                public ulong _M_capacity;
+
+                [FieldOffset(16)]
+                public int _M_refcount;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSs4_Rep12_S_empty_repEv")]
+                internal static extern global::System.IntPtr _S_empty_rep_0();
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNKSs4_Rep12_M_is_leakedEv")]
+                [return: MarshalAsAttribute(UnmanagedType.I1)]
+                internal static extern bool _M_is_leaked_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNKSs4_Rep12_M_is_sharedEv")]
+                [return: MarshalAsAttribute(UnmanagedType.I1)]
+                internal static extern bool _M_is_shared_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSs4_Rep13_M_set_leakedEv")]
+                internal static extern void _M_set_leaked_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSs4_Rep15_M_set_sharableEv")]
+                internal static extern void _M_set_sharable_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSs4_Rep10_M_refdataEv")]
+                internal static extern sbyte* _M_refdata_0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="_ZNSs4_Rep10_M_refcopyEv")]
+                internal static extern sbyte* _M_refcopy_0(global::System.IntPtr instance);
+            }
+
+            public static new _Rep __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+            {
+                return new _Rep(native.ToPointer(), skipVTables);
+            }
+
+            public static _Rep __CreateInstance(_Rep.Internal native, bool skipVTables = false)
+            {
+                return new _Rep(native, skipVTables);
+            }
+
+            private static void* __CopyValue(_Rep.Internal native)
+            {
+                var ret = Marshal.AllocHGlobal(24);
+                *(_Rep.Internal*) ret = native;
+                return ret.ToPointer();
+            }
+
+            private _Rep(_Rep.Internal native, bool skipVTables = false)
+                : this(__CopyValue(native), skipVTables)
+            {
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            protected _Rep(void* native, bool skipVTables = false)
+                : base((void*) null)
+            {
+                __PointerAdjustment = 0;
+                if (native == null)
+                    return;
+                __Instance = new global::System.IntPtr(native);
+            }
+
+            public _Rep()
+                : this((void*) null)
+            {
+                __Instance = Marshal.AllocHGlobal(24);
+                __ownsNativeInstance = true;
+                NativeToManagedMap[__Instance] = this;
+            }
+
+            public bool _M_is_leaked()
+            {
+                var __ret = Internal._M_is_leaked_0((__Instance + __PointerAdjustment));
+                return __ret;
+            }
+
+            public bool _M_is_shared()
+            {
+                var __ret = Internal._M_is_shared_0((__Instance + __PointerAdjustment));
+                return __ret;
+            }
+
+            public void _M_set_leaked()
+            {
+                Internal._M_set_leaked_0((__Instance + __PointerAdjustment));
+            }
+
+            public void _M_set_sharable()
+            {
+                Internal._M_set_sharable_0((__Instance + __PointerAdjustment));
+            }
+
+            public sbyte* _M_refdata()
+            {
+                var __ret = Internal._M_refdata_0((__Instance + __PointerAdjustment));
+                return __ret;
+            }
+
+            public sbyte* _M_refcopy()
+            {
+                var __ret = Internal._M_refcopy_0((__Instance + __PointerAdjustment));
+                return __ret;
+            }
+
+            public static global::std.basic_string._Rep _S_empty_rep()
+            {
+                var __ret = Internal._S_empty_rep_0();
+                global::std.basic_string._Rep __result0;
+                if (__ret == IntPtr.Zero) __result0 = null;
+                else if (global::std.basic_string._Rep.NativeToManagedMap.ContainsKey(__ret))
+                    __result0 = (global::std.basic_string._Rep) global::std.basic_string._Rep.NativeToManagedMap[__ret];
+                else __result0 = global::std.basic_string._Rep.__CreateInstance(__ret);
+                return __result0;
+            }
+
+            public static ulong _S_max_size
+            {
+                get
+                {
+                    var __ptr = (ulong*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSs4_Rep11_S_max_sizeE");
+                    return *__ptr;
+                }
+            }
+
+            public static sbyte _S_terminal
+            {
+                get
+                {
+                    var __ptr = (sbyte*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSs4_Rep11_S_terminalE");
+                    return *__ptr;
+                }
+            }
+
+            public static ulong[] _S_empty_rep_storage
+            {
+                get
+                {
+                    var __ptr = (byte*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSs4_Rep20_S_empty_rep_storageE");
+                    return null;
+                }
+            }
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static basic_string __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new basic_string(native.ToPointer(), skipVTables);
+        }
+
+        public static basic_string __CreateInstance(basic_string.Internal native, bool skipVTables = false)
+        {
+            return new basic_string(native, skipVTables);
+        }
+
+        private static void* __CopyValue(basic_string.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(8);
+            *(basic_string.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private basic_string(basic_string.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected basic_string(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.basic_string __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            Internal.dtor_0((__Instance + __PointerAdjustment));
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+
+        public string c_str()
+        {
+            var __ret = Internal.c_str_0((__Instance + __PointerAdjustment));
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+
+        public static ulong npos
+        {
+            get
+            {
+                var __ptr = (ulong*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "_ZNSs4nposE");
+                return *__ptr;
+            }
+        }
+    }
+}

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/CppSharp.CppParser.cs

@@ -62,7 +62,10 @@ namespace CppSharp
                 Friend = 23,
                 TemplateTemplateParm = 24,
                 TemplateTypeParm = 25,
-                NonTypeTemplateParm = 26
+                NonTypeTemplateParm = 26,
+                VarTemplate = 27,
+                VarTemplateSpecialization = 28,
+                VarTemplatePartialSpecialization = 29
             }
 
             public enum AccessSpecifier
@@ -10841,6 +10844,565 @@ namespace CppSharp
                 }
             }
 
+            public unsafe partial class VarTemplate : global::CppSharp.Parser.AST.Template, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 248)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(64)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(96)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??0VarTemplate@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="??0VarTemplate@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="??1VarTemplate@AST@CppParser@CppSharp@@QEAA@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?getSpecializations@VarTemplate@AST@CppParser@CppSharp@@QEAAPEAVVarTemplateSpecialization@234@I@Z")]
+                    internal static extern global::System.IntPtr getSpecializations_0(global::System.IntPtr instance, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?addSpecializations@VarTemplate@AST@CppParser@CppSharp@@QEAAXAEAPEAVVarTemplateSpecialization@234@@Z")]
+                    internal static extern void addSpecializations_0(global::System.IntPtr instance, global::System.IntPtr s);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?clearSpecializations@VarTemplate@AST@CppParser@CppSharp@@QEAAXXZ")]
+                    internal static extern void clearSpecializations_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?getSpecializationsCount@VarTemplate@AST@CppParser@CppSharp@@QEAAIXZ")]
+                    internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplate __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplate __CreateInstance(VarTemplate.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplate(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplate.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(248);
+                    global::CppSharp.Parser.AST.VarTemplate.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplate(VarTemplate.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplate(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplate()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplate(global::CppSharp.Parser.AST.VarTemplate _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(248);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.VarTemplateSpecialization getSpecializations(uint i)
+                {
+                    var __ret = Internal.getSpecializations_0((__Instance + __PointerAdjustment), i);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization __result0;
+                    if (__ret == IntPtr.Zero) __result0 = null;
+                    else if (global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap.ContainsKey(__ret))
+                        __result0 = (global::CppSharp.Parser.AST.VarTemplateSpecialization) global::CppSharp.Parser.AST.VarTemplateSpecialization.NativeToManagedMap[__ret];
+                    else __result0 = global::CppSharp.Parser.AST.VarTemplateSpecialization.__CreateInstance(__ret);
+                    return __result0;
+                }
+
+                public void addSpecializations(global::CppSharp.Parser.AST.VarTemplateSpecialization s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = s.__Instance;
+                    Internal.addSpecializations_0((__Instance + __PointerAdjustment), __arg0);
+                }
+
+                public void clearSpecializations()
+                {
+                    Internal.clearSpecializations_0((__Instance + __PointerAdjustment));
+                }
+
+                public uint SpecializationsCount
+                {
+                    get
+                    {
+                        var __ret = Internal.getSpecializationsCount_0((__Instance + __PointerAdjustment));
+                        return __ret;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplateSpecialization : global::CppSharp.Parser.AST.Variable, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 280)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(64)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(96)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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::std.basic_string.Internal Mangled;
+
+                    [FieldOffset(224)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(240)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(272)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??0VarTemplateSpecialization@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="??0VarTemplateSpecialization@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="??1VarTemplateSpecialization@AST@CppParser@CppSharp@@QEAA@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?getArguments@VarTemplateSpecialization@AST@CppParser@CppSharp@@QEAA?AUTemplateArgument@234@I@Z")]
+                    internal static extern void getArguments_0(global::System.IntPtr instance, global::System.IntPtr @return, uint i);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?addArguments@VarTemplateSpecialization@AST@CppParser@CppSharp@@QEAAXAEAUTemplateArgument@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.Cdecl,
+                        EntryPoint="?clearArguments@VarTemplateSpecialization@AST@CppParser@CppSharp@@QEAAXXZ")]
+                    internal static extern void clearArguments_0(global::System.IntPtr instance);
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="?getArgumentsCount@VarTemplateSpecialization@AST@CppParser@CppSharp@@QEAAIXZ")]
+                    internal static extern uint getArgumentsCount_0(global::System.IntPtr instance);
+                }
+
+                public static new VarTemplateSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplateSpecialization __CreateInstance(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplateSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplateSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(280);
+                    global::CppSharp.Parser.AST.VarTemplateSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplateSpecialization(VarTemplateSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplateSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplateSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplateSpecialization(global::CppSharp.Parser.AST.VarTemplateSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+
+                public global::CppSharp.Parser.AST.TemplateArgument getArguments(uint i)
+                {
+                    var __ret = new global::CppSharp.Parser.AST.TemplateArgument.Internal();
+                    Internal.getArguments_0((__Instance + __PointerAdjustment), new IntPtr(&__ret), i);
+                    return global::CppSharp.Parser.AST.TemplateArgument.__CreateInstance(__ret);
+                }
+
+                public void addArguments(global::CppSharp.Parser.AST.TemplateArgument s)
+                {
+                    if (ReferenceEquals(s, null))
+                        throw new global::System.ArgumentNullException("s", "Cannot be null because it is a C++ reference (&).");
+                    var __arg0 = 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 global::CppSharp.Parser.AST.VarTemplate TemplatedDecl
+                {
+                    get
+                    {
+                        global::CppSharp.Parser.AST.VarTemplate __result0;
+                        if (((Internal*) __Instance)->TemplatedDecl == IntPtr.Zero) __result0 = null;
+                        else if (global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap.ContainsKey(((Internal*) __Instance)->TemplatedDecl))
+                            __result0 = (global::CppSharp.Parser.AST.VarTemplate) global::CppSharp.Parser.AST.VarTemplate.NativeToManagedMap[((Internal*) __Instance)->TemplatedDecl];
+                        else __result0 = global::CppSharp.Parser.AST.VarTemplate.__CreateInstance(((Internal*) __Instance)->TemplatedDecl);
+                        return __result0;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->TemplatedDecl = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
+                    }
+                }
+
+                public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind
+                {
+                    get
+                    {
+                        return ((Internal*) __Instance)->SpecializationKind;
+                    }
+
+                    set
+                    {
+                        ((Internal*) __Instance)->SpecializationKind = value;
+                    }
+                }
+            }
+
+            public unsafe partial class VarTemplatePartialSpecialization : global::CppSharp.Parser.AST.VarTemplateSpecialization, IDisposable
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 280)]
+                public new partial struct Internal
+                {
+                    [FieldOffset(0)]
+                    public global::CppSharp.Parser.AST.DeclarationKind Kind;
+
+                    [FieldOffset(4)]
+                    public global::CppSharp.Parser.AST.AccessSpecifier Access;
+
+                    [FieldOffset(8)]
+                    public global::System.IntPtr _Namespace;
+
+                    [FieldOffset(16)]
+                    public global::CppSharp.Parser.SourceLocation.Internal Location;
+
+                    [FieldOffset(20)]
+                    public int LineNumberStart;
+
+                    [FieldOffset(24)]
+                    public int LineNumberEnd;
+
+                    [FieldOffset(32)]
+                    public global::std.basic_string.Internal Name;
+
+                    [FieldOffset(64)]
+                    public global::std.basic_string.Internal USR;
+
+                    [FieldOffset(96)]
+                    public global::std.basic_string.Internal DebugText;
+
+                    [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::std.basic_string.Internal Mangled;
+
+                    [FieldOffset(224)]
+                    public global::CppSharp.Parser.AST.QualifiedType.Internal QualifiedType;
+
+                    [FieldOffset(240)]
+                    public global::System.IntPtr TemplatedDecl;
+
+                    [FieldOffset(272)]
+                    public global::CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind;
+
+                    [SuppressUnmanagedCodeSecurity]
+                    [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                        EntryPoint="??0VarTemplatePartialSpecialization@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="??0VarTemplatePartialSpecialization@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="??1VarTemplatePartialSpecialization@AST@CppParser@CppSharp@@QEAA@XZ")]
+                    internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+                }
+
+                public static new VarTemplatePartialSpecialization __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native.ToPointer(), skipVTables);
+                }
+
+                public static VarTemplatePartialSpecialization __CreateInstance(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                {
+                    return new VarTemplatePartialSpecialization(native, skipVTables);
+                }
+
+                private static void* __CopyValue(VarTemplatePartialSpecialization.Internal native)
+                {
+                    var ret = Marshal.AllocHGlobal(280);
+                    global::CppSharp.Parser.AST.VarTemplatePartialSpecialization.Internal.cctor_1(ret, new global::System.IntPtr(&native));
+                    return ret.ToPointer();
+                }
+
+                private VarTemplatePartialSpecialization(VarTemplatePartialSpecialization.Internal native, bool skipVTables = false)
+                    : this(__CopyValue(native), skipVTables)
+                {
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                }
+
+                protected VarTemplatePartialSpecialization(void* native, bool skipVTables = false)
+                    : base((void*) null)
+                {
+                    __PointerAdjustment = 0;
+                    if (native == null)
+                        return;
+                    __Instance = new global::System.IntPtr(native);
+                }
+
+                public VarTemplatePartialSpecialization()
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __ownsNativeInstance = true;
+                    NativeToManagedMap[__Instance] = this;
+                    Internal.ctor_0((__Instance + __PointerAdjustment));
+                }
+
+                public VarTemplatePartialSpecialization(global::CppSharp.Parser.AST.VarTemplatePartialSpecialization _0)
+                    : this((void*) null)
+                {
+                    __Instance = Marshal.AllocHGlobal(280);
+                    __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)
+                {
+                    global::CppSharp.Parser.AST.Declaration __dummy;
+                    NativeToManagedMap.TryRemove(__Instance, out __dummy);
+                    Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+                    if (__ownsNativeInstance)
+                        Marshal.FreeHGlobal(__Instance);
+                }
+            }
+
             public unsafe partial class Namespace : global::CppSharp.Parser.AST.DeclarationContext, IDisposable
             {
                 [StructLayout(LayoutKind.Explicit, Size = 440)]

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/CppSharp.CppParser.dll-templates.cpp

@@ -0,0 +1,29 @@
+#include <AST.h>
+#include <Sources.h>
+#include <CppParser.h>
+
+template class vector<CppSharp::CppParser::AST::Namespace*>;
+template class vector<CppSharp::CppParser::AST::Enumeration*>;
+template class vector<CppSharp::CppParser::AST::Function*>;
+template class vector<CppSharp::CppParser::AST::Class*>;
+template class vector<CppSharp::CppParser::AST::Template*>;
+template class vector<CppSharp::CppParser::AST::TypedefDecl*>;
+template class vector<CppSharp::CppParser::AST::TypeAlias*>;
+template class vector<CppSharp::CppParser::AST::Variable*>;
+template class vector<CppSharp::CppParser::AST::Friend*>;
+template class vector<CppSharp::CppParser::AST::BaseClassSpecifier*>;
+template class vector<CppSharp::CppParser::AST::Field*>;
+template class vector<CppSharp::CppParser::AST::Method*>;
+template class vector<CppSharp::CppParser::AST::AccessSpecifierDecl*>;
+template class vector<CppSharp::CppParser::AST::Declaration*>;
+template class vector<CppSharp::CppParser::AST::FunctionTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Parameter*>;
+template class vector<CppSharp::CppParser::AST::ClassTemplateSpecialization*>;
+template class vector<CppSharp::CppParser::AST::Enumeration::Item*>;
+template class vector<CppSharp::CppParser::AST::BlockContentComment*>;
+template class vector<CppSharp::CppParser::AST::PreprocessedEntity*>;
+template class vector<CppSharp::CppParser::AST::Expression*>;
+template class vector<CppSharp::CppParser::AST::MacroDefinition*>;
+template class vector<CppSharp::CppParser::AST::TranslationUnit*>;
+template class vector<CppSharp::CppParser::AST::InlineContentComment*>;
+template class vector<CppSharp::CppParser::AST::VerbatimBlockLineComment*>;

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/Std-templates.cpp

@@ -0,0 +1,4 @@
+#include <string>
+
+template class __declspec(dllexport) std::allocator<char>;
+template class __declspec(dllexport) std::basic_string<char, std::char_traits<char>, std::allocator<char>>;

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/Std.cs

@@ -0,0 +1,317 @@
+//----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+//----------------------------------------------------------------------------
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace std
+{
+    public unsafe partial class allocator : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public unsafe partial struct Internal
+        {
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="??0?$allocator@D@std@@QEAA@XZ")]
+            internal static extern global::System.IntPtr ctor_0(global::System.IntPtr instance);
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, allocator>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static allocator __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new allocator(native.ToPointer(), skipVTables);
+        }
+
+        public static allocator __CreateInstance(allocator.Internal native, bool skipVTables = false)
+        {
+            return new allocator(native, skipVTables);
+        }
+
+        private static void* __CopyValue(allocator.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(0);
+            *(allocator.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private allocator(allocator.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected allocator(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public allocator()
+        {
+            __Instance = Marshal.AllocHGlobal(0);
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+            Internal.ctor_0((__Instance + __PointerAdjustment));
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.allocator __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+    }
+
+    public unsafe partial class _Alloc_allocate
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_construct
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_destroy
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_max_size
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+
+    public unsafe partial class _Alloc_select
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 0)]
+        public partial struct Internal
+        {
+        }
+    }
+}
+
+namespace std
+{
+    public unsafe partial class basic_string : IDisposable
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 32)]
+        public unsafe partial struct Internal
+        {
+            [FieldOffset(0)]
+            public fixed sbyte _Buf[16];
+
+            [FieldOffset(1)]
+            public sbyte __dummy__Buf_1;
+
+            [FieldOffset(2)]
+            public sbyte __dummy__Buf_2;
+
+            [FieldOffset(3)]
+            public sbyte __dummy__Buf_3;
+
+            [FieldOffset(4)]
+            public sbyte __dummy__Buf_4;
+
+            [FieldOffset(5)]
+            public sbyte __dummy__Buf_5;
+
+            [FieldOffset(6)]
+            public sbyte __dummy__Buf_6;
+
+            [FieldOffset(7)]
+            public sbyte __dummy__Buf_7;
+
+            [FieldOffset(8)]
+            public sbyte __dummy__Buf_8;
+
+            [FieldOffset(9)]
+            public sbyte __dummy__Buf_9;
+
+            [FieldOffset(10)]
+            public sbyte __dummy__Buf_10;
+
+            [FieldOffset(11)]
+            public sbyte __dummy__Buf_11;
+
+            [FieldOffset(12)]
+            public sbyte __dummy__Buf_12;
+
+            [FieldOffset(13)]
+            public sbyte __dummy__Buf_13;
+
+            [FieldOffset(14)]
+            public sbyte __dummy__Buf_14;
+
+            [FieldOffset(15)]
+            public sbyte __dummy__Buf_15;
+
+            [FieldOffset(0)]
+            public global::System.IntPtr _Ptr;
+
+            [FieldOffset(0)]
+            public fixed sbyte _Alias[16];
+
+            [FieldOffset(1)]
+            public sbyte __dummy__Alias_1;
+
+            [FieldOffset(2)]
+            public sbyte __dummy__Alias_2;
+
+            [FieldOffset(3)]
+            public sbyte __dummy__Alias_3;
+
+            [FieldOffset(4)]
+            public sbyte __dummy__Alias_4;
+
+            [FieldOffset(5)]
+            public sbyte __dummy__Alias_5;
+
+            [FieldOffset(6)]
+            public sbyte __dummy__Alias_6;
+
+            [FieldOffset(7)]
+            public sbyte __dummy__Alias_7;
+
+            [FieldOffset(8)]
+            public sbyte __dummy__Alias_8;
+
+            [FieldOffset(9)]
+            public sbyte __dummy__Alias_9;
+
+            [FieldOffset(10)]
+            public sbyte __dummy__Alias_10;
+
+            [FieldOffset(11)]
+            public sbyte __dummy__Alias_11;
+
+            [FieldOffset(12)]
+            public sbyte __dummy__Alias_12;
+
+            [FieldOffset(13)]
+            public sbyte __dummy__Alias_13;
+
+            [FieldOffset(14)]
+            public sbyte __dummy__Alias_14;
+
+            [FieldOffset(15)]
+            public sbyte __dummy__Alias_15;
+
+            [FieldOffset(16)]
+            public ulong _Mysize;
+
+            [FieldOffset(24)]
+            public ulong _Myres;
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEAA@XZ")]
+            internal static extern void dtor_0(global::System.IntPtr instance, int delete);
+
+            [SuppressUnmanagedCodeSecurity]
+            [DllImport("Std-templates", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
+                EntryPoint="?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QEBAPEBDXZ")]
+            internal static extern global::System.IntPtr c_str_0(global::System.IntPtr instance);
+        }
+
+        public global::System.IntPtr __Instance { get; protected set; }
+
+        protected int __PointerAdjustment;
+        public static readonly System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string> NativeToManagedMap = new System.Collections.Concurrent.ConcurrentDictionary<IntPtr, basic_string>();
+        protected void*[] __OriginalVTables;
+
+        protected bool __ownsNativeInstance;
+
+        public static basic_string __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
+        {
+            return new basic_string(native.ToPointer(), skipVTables);
+        }
+
+        public static basic_string __CreateInstance(basic_string.Internal native, bool skipVTables = false)
+        {
+            return new basic_string(native, skipVTables);
+        }
+
+        private static void* __CopyValue(basic_string.Internal native)
+        {
+            var ret = Marshal.AllocHGlobal(32);
+            *(basic_string.Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private basic_string(basic_string.Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            NativeToManagedMap[__Instance] = this;
+        }
+
+        protected basic_string(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new global::System.IntPtr(native);
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            global::std.basic_string __dummy;
+            NativeToManagedMap.TryRemove(__Instance, out __dummy);
+            Internal.dtor_0((__Instance + __PointerAdjustment), 0);
+            if (__ownsNativeInstance)
+                Marshal.FreeHGlobal(__Instance);
+        }
+
+        public string c_str()
+        {
+            var __ret = Internal.c_str_0((__Instance + __PointerAdjustment));
+            return Marshal.PtrToStringAnsi(__ret);
+        }
+
+        public static ulong npos
+        {
+            get
+            {
+                var __ptr = (ulong*)CppSharp.SymbolResolver.ResolveSymbol("Std-templates", "?npos@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@2_KB");
+                return *__ptr;
+            }
+        }
+    }
+}

src/CppParser/Bindings/ParserGen.cs

@@ -86,6 +86,7 @@ namespace CppSharp
 
             options.OutputNamespace = string.Empty;
             options.CheckSymbols = false;
+            options.Verbose = true;
         }
 
         private void SetupLinuxOptions(DriverOptions options)

src/CppParser/Parser.cpp

@@ -1425,6 +1425,108 @@ Parser::WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTSI
 
     return FTS;
 }
+
+//-----------------------------------//
+
+VarTemplate* Parser::WalkVarTemplate(const clang::VarTemplateDecl* TD)
+{
+    auto NS = GetNamespace(TD);
+    assert(NS && "Expected a valid namespace");
+
+    auto USR = GetDeclUSR(TD);
+    auto VT = NS->FindTemplate<VarTemplate>(USR);
+    if (VT != nullptr)
+        return VT;
+
+    VT = new VarTemplate();
+    HandleDeclaration(TD, VT);
+
+    VT->Name = GetDeclName(TD);
+    VT->_Namespace = NS;
+    NS->Templates.push_back(VT);
+
+    auto RC = WalkVariable(TD->getTemplatedDecl());
+    VT->TemplatedDecl = RC;
+    VT->Parameters = WalkTemplateParameterList(TD->getTemplateParameters());
+
+    return VT;
+}
+
+VarTemplateSpecialization*
+Parser::WalkVarTemplateSpecialization(const clang::VarTemplateSpecializationDecl* VTS)
+{
+    using namespace clang;
+
+    auto VT = WalkVarTemplate(VTS->getSpecializedTemplate());
+    auto USR = GetDeclUSR(VTS);
+    auto TS = VT->FindSpecialization(USR);
+    if (TS != nullptr)
+        return TS;
+
+    TS = new VarTemplateSpecialization();
+    HandleDeclaration(VTS, TS);
+
+    auto NS = GetNamespace(VTS);
+    assert(NS && "Expected a valid namespace");
+    TS->_Namespace = NS;
+    TS->Name = VTS->getName();
+    TS->TemplatedDecl = VT;
+    TS->SpecializationKind = WalkTemplateSpecializationKind(VTS->getSpecializationKind());
+    VT->Specializations.push_back(TS);
+
+    auto& TAL = VTS->getTemplateArgs();
+    auto TSI = VTS->getTypeAsWritten();
+    if (TSI)
+    {
+        auto TL = TSI->getTypeLoc();
+        auto TSL = TL.getAs<TemplateSpecializationTypeLoc>();
+        TS->Arguments = WalkTemplateArgumentList(&TAL, &TSL);
+    }
+    else
+    {
+        TS->Arguments = WalkTemplateArgumentList(&TAL, (clang::TemplateSpecializationTypeLoc*) 0);
+    }
+
+    WalkVariable(VTS, TS);
+
+    return TS;
+}
+
+VarTemplatePartialSpecialization*
+Parser::WalkVarTemplatePartialSpecialization(const clang::VarTemplatePartialSpecializationDecl* VTS)
+{
+    using namespace clang;
+
+    auto VT = WalkVarTemplate(VTS->getSpecializedTemplate());
+    auto USR = GetDeclUSR(VTS);
+    auto TS = VT->FindPartialSpecialization(USR);
+    if (TS != nullptr)
+        return TS;
+
+    TS = new VarTemplatePartialSpecialization();
+    HandleDeclaration(VTS, TS);
+
+    auto NS = GetNamespace(VTS);
+    assert(NS && "Expected a valid namespace");
+    TS->_Namespace = NS;
+    TS->Name = VTS->getName();
+    TS->TemplatedDecl = VT;
+    TS->SpecializationKind = WalkTemplateSpecializationKind(VTS->getSpecializationKind());
+    VT->Specializations.push_back(TS);
+
+    auto& TAL = VTS->getTemplateArgs();
+    if (auto TSI = VTS->getTypeAsWritten())
+    {
+        auto TL = TSI->getTypeLoc();
+        auto TSL = TL.getAs<TemplateSpecializationTypeLoc>();
+        TS->Arguments = WalkTemplateArgumentList(&TAL, &TSL);
+    }
+
+    WalkVariable(VTS, TS);
+
+    return TS;
+}
+
 //-----------------------------------//
 
 static CXXMethodKind GetMethodKindFromDecl(clang::DeclarationName Name)
@@ -2803,22 +2905,11 @@ void Parser::WalkAST()
 
 //-----------------------------------//
 
-Variable* Parser::WalkVariable(const clang::VarDecl *VD)
+void Parser::WalkVariable(const clang::VarDecl* VD, Variable* Var)
 {
-    using namespace clang;
-
-    auto NS = GetNamespace(VD);
-    assert(NS && "Expected a valid namespace");
-
-    auto USR = GetDeclUSR(VD);
-    if (auto Var = NS->FindVariable(USR))
-       return Var;
-
-    auto Var = new Variable();
     HandleDeclaration(VD, Var);
 
     Var->Name = VD->getName();
-    Var->_Namespace = NS;
     Var->Access = ConvertToAccess(VD->getAccess());
 
     auto TL = VD->getTypeSourceInfo()->getTypeLoc();
@@ -2826,6 +2917,19 @@ Variable* Parser::WalkVariable(const clang::VarDecl *VD)
 
     auto Mangled = GetDeclMangledName(VD);
     Var->Mangled = Mangled;
+}
+
+Variable* Parser::WalkVariable(const clang::VarDecl *VD)
+{
+    using namespace clang;
+
+    auto NS = GetNamespace(VD);
+    assert(NS && "Expected a valid namespace");
+
+    auto Var = new Variable();
+    Var->_Namespace = NS;
+
+    WalkVariable(VD, Var);
 
     NS->Variables.push_back(Var);
 
@@ -3284,6 +3388,30 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D,
         Decl = FT;
         break;
     }
+    case Decl::VarTemplate:
+    {
+        auto TD = cast<VarTemplateDecl>(D);
+        auto Template = WalkVarTemplate(TD);
+
+        Decl = Template;
+        break;
+    }
+    case Decl::VarTemplateSpecialization:
+    {
+        auto TS = cast<VarTemplateSpecializationDecl>(D);
+        auto CT = WalkVarTemplateSpecialization(TS);
+
+        Decl = CT;
+        break;
+    }
+    case Decl::VarTemplatePartialSpecialization:
+    {
+        auto TS = cast<VarTemplatePartialSpecializationDecl>(D);
+        auto CT = WalkVarTemplatePartialSpecialization(TS);
+
+        Decl = CT;
+        break;
+    }
     case Decl::TypeAliasTemplate:
     {
         auto TD = cast<TypeAliasTemplateDecl>(D);
@@ -3439,11 +3567,14 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D,
     case Decl::CXXDestructor:
     case Decl::CXXConversion:
         break;
+    case Decl::PragmaComment:
+    case Decl::PragmaDetectMismatch:
     case Decl::Empty:
     case Decl::AccessSpec:
     case Decl::Using:
     case Decl::UsingDirective:
     case Decl::UsingShadow:
+    case Decl::ConstructorUsingShadow:
     case Decl::UnresolvedUsingTypename:
     case Decl::UnresolvedUsingValue:
     case Decl::IndirectField:

src/CppParser/Parser.h

@@ -82,6 +82,7 @@ private:
     Field* WalkFieldCXX(const clang::FieldDecl* FD, Class* Class);
     FunctionTemplateSpecialization* WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTS, Function* Function);
     Variable* WalkVariable(const clang::VarDecl* VD);
+    void WalkVariable(const clang::VarDecl* VD, Variable* Var);
     Friend* WalkFriend(const clang::FriendDecl* FD);
     RawComment* WalkRawComment(const clang::RawComment* RC);
     bool ShouldCompleteType(const clang::QualType& QualType, bool LocValid);
@@ -95,6 +96,11 @@ private:
     TypeAliasTemplate* WalkTypeAliasTemplate(const clang::TypeAliasTemplateDecl* TD);
     ClassTemplate* WalkClassTemplate(const clang::ClassTemplateDecl* TD);
     FunctionTemplate* WalkFunctionTemplate(const clang::FunctionTemplateDecl* TD);
+    VarTemplate* WalkVarTemplate(const clang::VarTemplateDecl* VT);
+    VarTemplateSpecialization*
+    WalkVarTemplateSpecialization(const clang::VarTemplateSpecializationDecl* VTS);
+    VarTemplatePartialSpecialization*
+    WalkVarTemplatePartialSpecialization(const clang::VarTemplatePartialSpecializationDecl* VTS);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, clang::TemplateSpecializationTypeLoc* TSTL);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, const clang::ASTTemplateArgumentListInfo* TSTL);
     void WalkVTable(const clang::CXXRecordDecl* RD, Class* C);

src/Generator.Tests/AST/TestAST.cs

@@ -195,6 +195,16 @@ namespace CppSharp.Generator.Tests.AST
             {
                 throw new NotImplementedException();
             }
+
+            public bool VisitVarTemplateDecl(VarTemplate template)
+            {
+                throw new NotImplementedException();
+            }
+
+            public bool VisitVarTemplateSpecializationDecl(VarTemplateSpecialization template)
+            {
+                throw new NotImplementedException();
+            }
         }
         #endregion
 

src/Generator/Generators/CLI/CLITypePrinter.cs

@@ -479,5 +479,15 @@ namespace CppSharp.Generators.CLI
         {
             throw new NotImplementedException();
         }
+
+        public string VisitVarTemplateDecl(VarTemplate template)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string VisitVarTemplateSpecializationDecl(VarTemplateSpecialization template)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -795,6 +795,16 @@ namespace CppSharp.Generators.CSharp
         {
             throw new NotImplementedException();
         }
+
+        public CSharpTypePrinterResult VisitVarTemplateDecl(VarTemplate template)
+        {
+            throw new NotImplementedException();
+        }
+
+        public CSharpTypePrinterResult VisitVarTemplateSpecializationDecl(VarTemplateSpecialization template)
+        {
+            throw new NotImplementedException();
+        }
     }
 
     public static class CSharpTypePrinterExtensions

src/Generator/Passes/CheckVirtualOverrideReturnCovariance.cs

@@ -288,6 +288,16 @@ namespace CppSharp.Passes
             throw new NotImplementedException();
         }
 
+        public bool VisitVarTemplateDecl(VarTemplate template)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool VisitVarTemplateSpecializationDecl(VarTemplateSpecialization template)
+        {
+            throw new NotImplementedException();
+        }
+
         #endregion
     }
 

src/Generator/Types/CppTypePrinter.cs

@@ -403,5 +403,15 @@ namespace CppSharp.Types
         {
             throw new NotImplementedException();
         }
+
+        public string VisitVarTemplateDecl(VarTemplate template)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string VisitVarTemplateSpecializationDecl(VarTemplateSpecialization template)
+        {
+            throw new NotImplementedException();
+        }
     }
 }