Added C# and C++/CLI bindings to the new parser APIs.

src/CppParser/Bindings/CLI/CppParser.cpp

@@ -0,0 +1,396 @@
+#include "CppParser.h"
+#include "AST.h"
+
+using namespace System;
+using namespace System::Runtime::InteropServices;
+
+CppSharp::Parser::ParserOptions::ParserOptions(::CppSharp::CppParser::ParserOptions* native)
+{
+    NativePtr = native;
+}
+
+CppSharp::Parser::ParserOptions::ParserOptions(System::IntPtr native)
+{
+    auto __native = (::CppSharp::CppParser::ParserOptions*)native.ToPointer();
+    NativePtr = __native;
+}
+
+CppSharp::Parser::ParserOptions::ParserOptions()
+{
+    NativePtr = new ::CppSharp::CppParser::ParserOptions();
+}
+
+System::IntPtr CppSharp::Parser::ParserOptions::Instance::get()
+{
+    return System::IntPtr(NativePtr);
+}
+
+void CppSharp::Parser::ParserOptions::Instance::set(System::IntPtr object)
+{
+    NativePtr = (::CppSharp::CppParser::ParserOptions*)object.ToPointer();
+}
+
+System::Collections::Generic::List<System::String^>^ CppSharp::Parser::ParserOptions::IncludeDirs::get()
+{
+    auto _tmpIncludeDirs = gcnew System::Collections::Generic::List<System::String^>();
+    for(auto _element : ((::CppSharp::CppParser::ParserOptions*)NativePtr)->IncludeDirs)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpIncludeDirs->Add(_marshalElement);
+    }
+    return _tmpIncludeDirs;
+}
+
+void CppSharp::Parser::ParserOptions::IncludeDirs::set(System::Collections::Generic::List<System::String^>^ value)
+{
+    auto _tmpvalue = std::vector<::std::string>();
+    for each(System::String^ _element in value)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpvalue.push_back(_marshalElement);
+    }
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->IncludeDirs = _tmpvalue;
+}
+
+System::Collections::Generic::List<System::String^>^ CppSharp::Parser::ParserOptions::SystemIncludeDirs::get()
+{
+    auto _tmpSystemIncludeDirs = gcnew System::Collections::Generic::List<System::String^>();
+    for(auto _element : ((::CppSharp::CppParser::ParserOptions*)NativePtr)->SystemIncludeDirs)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpSystemIncludeDirs->Add(_marshalElement);
+    }
+    return _tmpSystemIncludeDirs;
+}
+
+void CppSharp::Parser::ParserOptions::SystemIncludeDirs::set(System::Collections::Generic::List<System::String^>^ value)
+{
+    auto _tmpvalue = std::vector<::std::string>();
+    for each(System::String^ _element in value)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpvalue.push_back(_marshalElement);
+    }
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->SystemIncludeDirs = _tmpvalue;
+}
+
+System::Collections::Generic::List<System::String^>^ CppSharp::Parser::ParserOptions::Defines::get()
+{
+    auto _tmpDefines = gcnew System::Collections::Generic::List<System::String^>();
+    for(auto _element : ((::CppSharp::CppParser::ParserOptions*)NativePtr)->Defines)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpDefines->Add(_marshalElement);
+    }
+    return _tmpDefines;
+}
+
+void CppSharp::Parser::ParserOptions::Defines::set(System::Collections::Generic::List<System::String^>^ value)
+{
+    auto _tmpvalue = std::vector<::std::string>();
+    for each(System::String^ _element in value)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpvalue.push_back(_marshalElement);
+    }
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->Defines = _tmpvalue;
+}
+
+System::Collections::Generic::List<System::String^>^ CppSharp::Parser::ParserOptions::LibraryDirs::get()
+{
+    auto _tmpLibraryDirs = gcnew System::Collections::Generic::List<System::String^>();
+    for(auto _element : ((::CppSharp::CppParser::ParserOptions*)NativePtr)->LibraryDirs)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpLibraryDirs->Add(_marshalElement);
+    }
+    return _tmpLibraryDirs;
+}
+
+void CppSharp::Parser::ParserOptions::LibraryDirs::set(System::Collections::Generic::List<System::String^>^ value)
+{
+    auto _tmpvalue = std::vector<::std::string>();
+    for each(System::String^ _element in value)
+    {
+        auto _marshalElement = clix::marshalString<clix::E_UTF8>(_element);
+        _tmpvalue.push_back(_marshalElement);
+    }
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->LibraryDirs = _tmpvalue;
+}
+
+System::String^ CppSharp::Parser::ParserOptions::FileName::get()
+{
+    return clix::marshalString<clix::E_UTF8>(((::CppSharp::CppParser::ParserOptions*)NativePtr)->FileName);
+}
+
+void CppSharp::Parser::ParserOptions::FileName::set(System::String^ value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->FileName = clix::marshalString<clix::E_UTF8>(value);
+}
+
+CppSharp::Parser::Library^ CppSharp::Parser::ParserOptions::Library::get()
+{
+    return gcnew CppSharp::Parser::Library((::CppSharp::CppParser::Library*)((::CppSharp::CppParser::ParserOptions*)NativePtr)->Library);
+}
+
+void CppSharp::Parser::ParserOptions::Library::set(CppSharp::Parser::Library^ value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->Library = (::CppSharp::CppParser::Library*)value->NativePtr;
+}
+
+int CppSharp::Parser::ParserOptions::ToolSetToUse::get()
+{
+    return ((::CppSharp::CppParser::ParserOptions*)NativePtr)->ToolSetToUse;
+}
+
+void CppSharp::Parser::ParserOptions::ToolSetToUse::set(int value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->ToolSetToUse = value;
+}
+
+System::String^ CppSharp::Parser::ParserOptions::TargetTriple::get()
+{
+    return clix::marshalString<clix::E_UTF8>(((::CppSharp::CppParser::ParserOptions*)NativePtr)->TargetTriple);
+}
+
+void CppSharp::Parser::ParserOptions::TargetTriple::set(System::String^ value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->TargetTriple = clix::marshalString<clix::E_UTF8>(value);
+}
+
+bool CppSharp::Parser::ParserOptions::NoStandardIncludes::get()
+{
+    return ((::CppSharp::CppParser::ParserOptions*)NativePtr)->NoStandardIncludes;
+}
+
+void CppSharp::Parser::ParserOptions::NoStandardIncludes::set(bool value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->NoStandardIncludes = value;
+}
+
+bool CppSharp::Parser::ParserOptions::NoBuiltinIncludes::get()
+{
+    return ((::CppSharp::CppParser::ParserOptions*)NativePtr)->NoBuiltinIncludes;
+}
+
+void CppSharp::Parser::ParserOptions::NoBuiltinIncludes::set(bool value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->NoBuiltinIncludes = value;
+}
+
+bool CppSharp::Parser::ParserOptions::MicrosoftMode::get()
+{
+    return ((::CppSharp::CppParser::ParserOptions*)NativePtr)->MicrosoftMode;
+}
+
+void CppSharp::Parser::ParserOptions::MicrosoftMode::set(bool value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->MicrosoftMode = value;
+}
+
+CppSharp::Parser::CppAbi CppSharp::Parser::ParserOptions::Abi::get()
+{
+    return (CppSharp::Parser::CppAbi)((::CppSharp::CppParser::ParserOptions*)NativePtr)->Abi;
+}
+
+void CppSharp::Parser::ParserOptions::Abi::set(CppSharp::Parser::CppAbi value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->Abi = (::CppSharp::CppParser::CppAbi)value;
+}
+
+bool CppSharp::Parser::ParserOptions::Verbose::get()
+{
+    return ((::CppSharp::CppParser::ParserOptions*)NativePtr)->Verbose;
+}
+
+void CppSharp::Parser::ParserOptions::Verbose::set(bool value)
+{
+    ((::CppSharp::CppParser::ParserOptions*)NativePtr)->Verbose = value;
+}
+
+CppSharp::Parser::ParserDiagnostic::ParserDiagnostic(::CppSharp::CppParser::ParserDiagnostic* native)
+{
+    NativePtr = native;
+}
+
+CppSharp::Parser::ParserDiagnostic::ParserDiagnostic(System::IntPtr native)
+{
+    auto __native = (::CppSharp::CppParser::ParserDiagnostic*)native.ToPointer();
+    NativePtr = __native;
+}
+
+CppSharp::Parser::ParserDiagnostic::ParserDiagnostic()
+{
+    NativePtr = new ::CppSharp::CppParser::ParserDiagnostic();
+}
+
+System::IntPtr CppSharp::Parser::ParserDiagnostic::Instance::get()
+{
+    return System::IntPtr(NativePtr);
+}
+
+void CppSharp::Parser::ParserDiagnostic::Instance::set(System::IntPtr object)
+{
+    NativePtr = (::CppSharp::CppParser::ParserDiagnostic*)object.ToPointer();
+}
+
+System::String^ CppSharp::Parser::ParserDiagnostic::FileName::get()
+{
+    return clix::marshalString<clix::E_UTF8>(((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->FileName);
+}
+
+void CppSharp::Parser::ParserDiagnostic::FileName::set(System::String^ value)
+{
+    ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->FileName = clix::marshalString<clix::E_UTF8>(value);
+}
+
+System::String^ CppSharp::Parser::ParserDiagnostic::Message::get()
+{
+    return clix::marshalString<clix::E_UTF8>(((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->Message);
+}
+
+void CppSharp::Parser::ParserDiagnostic::Message::set(System::String^ value)
+{
+    ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->Message = clix::marshalString<clix::E_UTF8>(value);
+}
+
+CppSharp::Parser::ParserDiagnosticLevel CppSharp::Parser::ParserDiagnostic::Level::get()
+{
+    return (CppSharp::Parser::ParserDiagnosticLevel)((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->Level;
+}
+
+void CppSharp::Parser::ParserDiagnostic::Level::set(CppSharp::Parser::ParserDiagnosticLevel value)
+{
+    ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->Level = (::CppSharp::CppParser::ParserDiagnosticLevel)value;
+}
+
+int CppSharp::Parser::ParserDiagnostic::LineNumber::get()
+{
+    return ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->LineNumber;
+}
+
+void CppSharp::Parser::ParserDiagnostic::LineNumber::set(int value)
+{
+    ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->LineNumber = value;
+}
+
+int CppSharp::Parser::ParserDiagnostic::ColumnNumber::get()
+{
+    return ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->ColumnNumber;
+}
+
+void CppSharp::Parser::ParserDiagnostic::ColumnNumber::set(int value)
+{
+    ((::CppSharp::CppParser::ParserDiagnostic*)NativePtr)->ColumnNumber = value;
+}
+
+CppSharp::Parser::ParserResult::ParserResult(::CppSharp::CppParser::ParserResult* native)
+{
+    NativePtr = native;
+}
+
+CppSharp::Parser::ParserResult::ParserResult(System::IntPtr native)
+{
+    auto __native = (::CppSharp::CppParser::ParserResult*)native.ToPointer();
+    NativePtr = __native;
+}
+
+CppSharp::Parser::ParserResult::ParserResult()
+{
+    NativePtr = new ::CppSharp::CppParser::ParserResult();
+}
+
+System::IntPtr CppSharp::Parser::ParserResult::Instance::get()
+{
+    return System::IntPtr(NativePtr);
+}
+
+void CppSharp::Parser::ParserResult::Instance::set(System::IntPtr object)
+{
+    NativePtr = (::CppSharp::CppParser::ParserResult*)object.ToPointer();
+}
+
+CppSharp::Parser::ParserResultKind CppSharp::Parser::ParserResult::Kind::get()
+{
+    return (CppSharp::Parser::ParserResultKind)((::CppSharp::CppParser::ParserResult*)NativePtr)->Kind;
+}
+
+void CppSharp::Parser::ParserResult::Kind::set(CppSharp::Parser::ParserResultKind value)
+{
+    ((::CppSharp::CppParser::ParserResult*)NativePtr)->Kind = (::CppSharp::CppParser::ParserResultKind)value;
+}
+
+CppSharp::Parser::Library^ CppSharp::Parser::ParserResult::Library::get()
+{
+    return gcnew CppSharp::Parser::Library((::CppSharp::CppParser::Library*)((::CppSharp::CppParser::ParserResult*)NativePtr)->Library);
+}
+
+void CppSharp::Parser::ParserResult::Library::set(CppSharp::Parser::Library^ value)
+{
+    ((::CppSharp::CppParser::ParserResult*)NativePtr)->Library = (::CppSharp::CppParser::Library*)value->NativePtr;
+}
+
+System::Collections::Generic::List<CppSharp::Parser::ParserDiagnostic^>^ CppSharp::Parser::ParserResult::Diagnostics::get()
+{
+    auto _tmpDiagnostics = gcnew System::Collections::Generic::List<CppSharp::Parser::ParserDiagnostic^>();
+    for(auto _element : ((::CppSharp::CppParser::ParserResult*)NativePtr)->Diagnostics)
+    {
+        auto ___element = new ::CppSharp::CppParser::ParserDiagnostic(_element);
+        auto _marshalElement = gcnew CppSharp::Parser::ParserDiagnostic((::CppSharp::CppParser::ParserDiagnostic*)___element);
+        _tmpDiagnostics->Add(_marshalElement);
+    }
+    return _tmpDiagnostics;
+}
+
+void CppSharp::Parser::ParserResult::Diagnostics::set(System::Collections::Generic::List<CppSharp::Parser::ParserDiagnostic^>^ value)
+{
+    auto _tmpvalue = std::vector<::CppSharp::CppParser::ParserDiagnostic>();
+    for each(CppSharp::Parser::ParserDiagnostic^ _element in value)
+    {
+        auto _marshalElement = *(::CppSharp::CppParser::ParserDiagnostic*)_element->NativePtr;
+        _tmpvalue.push_back(_marshalElement);
+    }
+    ((::CppSharp::CppParser::ParserResult*)NativePtr)->Diagnostics = _tmpvalue;
+}
+
+CppSharp::Parser::ClangParser::ClangParser(::CppSharp::CppParser::ClangParser* native)
+{
+    NativePtr = native;
+}
+
+CppSharp::Parser::ClangParser::ClangParser(System::IntPtr native)
+{
+    auto __native = (::CppSharp::CppParser::ClangParser*)native.ToPointer();
+    NativePtr = __native;
+}
+
+CppSharp::Parser::ParserResult^ CppSharp::Parser::ClangParser::ParseHeader(CppSharp::Parser::ParserOptions^ Opts)
+{
+    auto arg0 = (::CppSharp::CppParser::ParserOptions*)Opts->NativePtr;
+    auto __ret = ::CppSharp::CppParser::ClangParser::ParseHeader(arg0);
+    if (__ret == nullptr) return nullptr;
+    return gcnew CppSharp::Parser::ParserResult((::CppSharp::CppParser::ParserResult*)__ret);
+}
+
+CppSharp::Parser::ParserResult^ CppSharp::Parser::ClangParser::ParseLibrary(CppSharp::Parser::ParserOptions^ Opts)
+{
+    auto arg0 = (::CppSharp::CppParser::ParserOptions*)Opts->NativePtr;
+    auto __ret = ::CppSharp::CppParser::ClangParser::ParseLibrary(arg0);
+    if (__ret == nullptr) return nullptr;
+    return gcnew CppSharp::Parser::ParserResult((::CppSharp::CppParser::ParserResult*)__ret);
+}
+
+CppSharp::Parser::ClangParser::ClangParser()
+{
+    NativePtr = new ::CppSharp::CppParser::ClangParser();
+}
+
+System::IntPtr CppSharp::Parser::ClangParser::Instance::get()
+{
+    return System::IntPtr(NativePtr);
+}
+
+void CppSharp::Parser::ClangParser::Instance::set(System::IntPtr object)
+{
+    NativePtr = (::CppSharp::CppParser::ClangParser*)object.ToPointer();
+}

src/CppParser/Bindings/CLI/CppParser.h

@@ -0,0 +1,231 @@
+#pragma once
+
+#include "CppSharp.h"
+#include <CppParser.h>
+
+namespace CppSharp
+{
+    enum struct CppAbi;
+    enum struct ParserDiagnosticLevel;
+    enum struct ParserResultKind;
+    enum struct SourceLocationKind;
+    ref class ClangParser;
+    ref class Library;
+    ref class ParserDiagnostic;
+    ref class ParserOptions;
+    ref class ParserResult;
+
+    namespace Parser
+    {
+        enum struct CppAbi;
+        enum struct ParserDiagnosticLevel;
+        enum struct ParserResultKind;
+        ref class ClangParser;
+        ref class Library;
+        ref class ParserDiagnostic;
+        ref class ParserOptions;
+        ref class ParserResult;
+
+        public enum struct ParserDiagnosticLevel
+        {
+            Ignored = 0,
+            Note = 1,
+            Warning = 2,
+            Error = 3,
+            Fatal = 4
+        };
+
+        public enum struct ParserResultKind
+        {
+            Success = 0,
+            Error = 1,
+            FileNotFound = 2
+        };
+
+        public enum struct SourceLocationKind
+        {
+            Invalid = 0,
+            Builtin = 1,
+            CommandLine = 2,
+            System = 3,
+            User = 4
+        };
+
+        public ref class ParserOptions : ICppInstance
+        {
+        public:
+
+            property ::CppSharp::CppParser::ParserOptions* NativePtr;
+            property System::IntPtr Instance
+            {
+                virtual System::IntPtr get();
+                virtual void set(System::IntPtr instance);
+            }
+
+            ParserOptions(::CppSharp::CppParser::ParserOptions* native);
+            ParserOptions(System::IntPtr native);
+            ParserOptions();
+
+            property System::Collections::Generic::List<System::String^>^ IncludeDirs
+            {
+                System::Collections::Generic::List<System::String^>^ get();
+                void set(System::Collections::Generic::List<System::String^>^);
+            }
+            property System::Collections::Generic::List<System::String^>^ SystemIncludeDirs
+            {
+                System::Collections::Generic::List<System::String^>^ get();
+                void set(System::Collections::Generic::List<System::String^>^);
+            }
+            property System::Collections::Generic::List<System::String^>^ Defines
+            {
+                System::Collections::Generic::List<System::String^>^ get();
+                void set(System::Collections::Generic::List<System::String^>^);
+            }
+            property System::Collections::Generic::List<System::String^>^ LibraryDirs
+            {
+                System::Collections::Generic::List<System::String^>^ get();
+                void set(System::Collections::Generic::List<System::String^>^);
+            }
+            property System::String^ FileName
+            {
+                System::String^ get();
+                void set(System::String^);
+            }
+            property CppSharp::Parser::Library^ Library
+            {
+                CppSharp::Parser::Library^ get();
+                void set(CppSharp::Parser::Library^);
+            }
+            property int ToolSetToUse
+            {
+                int get();
+                void set(int);
+            }
+            property System::String^ TargetTriple
+            {
+                System::String^ get();
+                void set(System::String^);
+            }
+            property bool NoStandardIncludes
+            {
+                bool get();
+                void set(bool);
+            }
+            property bool NoBuiltinIncludes
+            {
+                bool get();
+                void set(bool);
+            }
+            property bool MicrosoftMode
+            {
+                bool get();
+                void set(bool);
+            }
+            property CppSharp::Parser::CppAbi Abi
+            {
+                CppSharp::Parser::CppAbi get();
+                void set(CppSharp::Parser::CppAbi);
+            }
+            property bool Verbose
+            {
+                bool get();
+                void set(bool);
+            }
+        };
+
+        public ref class ParserDiagnostic : ICppInstance
+        {
+        public:
+
+            property ::CppSharp::CppParser::ParserDiagnostic* NativePtr;
+            property System::IntPtr Instance
+            {
+                virtual System::IntPtr get();
+                virtual void set(System::IntPtr instance);
+            }
+
+            ParserDiagnostic(::CppSharp::CppParser::ParserDiagnostic* native);
+            ParserDiagnostic(System::IntPtr native);
+            ParserDiagnostic();
+
+            property System::String^ FileName
+            {
+                System::String^ get();
+                void set(System::String^);
+            }
+            property System::String^ Message
+            {
+                System::String^ get();
+                void set(System::String^);
+            }
+            property CppSharp::Parser::ParserDiagnosticLevel Level
+            {
+                CppSharp::Parser::ParserDiagnosticLevel get();
+                void set(CppSharp::Parser::ParserDiagnosticLevel);
+            }
+            property int LineNumber
+            {
+                int get();
+                void set(int);
+            }
+            property int ColumnNumber
+            {
+                int get();
+                void set(int);
+            }
+        };
+
+        public ref class ParserResult : ICppInstance
+        {
+        public:
+
+            property ::CppSharp::CppParser::ParserResult* NativePtr;
+            property System::IntPtr Instance
+            {
+                virtual System::IntPtr get();
+                virtual void set(System::IntPtr instance);
+            }
+
+            ParserResult(::CppSharp::CppParser::ParserResult* native);
+            ParserResult(System::IntPtr native);
+            ParserResult();
+
+            property CppSharp::Parser::ParserResultKind Kind
+            {
+                CppSharp::Parser::ParserResultKind get();
+                void set(CppSharp::Parser::ParserResultKind);
+            }
+            property CppSharp::Parser::Library^ Library
+            {
+                CppSharp::Parser::Library^ get();
+                void set(CppSharp::Parser::Library^);
+            }
+            property System::Collections::Generic::List<CppSharp::Parser::ParserDiagnostic^>^ Diagnostics
+            {
+                System::Collections::Generic::List<CppSharp::Parser::ParserDiagnostic^>^ get();
+                void set(System::Collections::Generic::List<CppSharp::Parser::ParserDiagnostic^>^);
+            }
+        };
+
+        public ref class ClangParser : ICppInstance
+        {
+        public:
+
+            property ::CppSharp::CppParser::ClangParser* NativePtr;
+            property System::IntPtr Instance
+            {
+                virtual System::IntPtr get();
+                virtual void set(System::IntPtr instance);
+            }
+
+            ClangParser(::CppSharp::CppParser::ClangParser* native);
+            ClangParser(System::IntPtr native);
+            ClangParser();
+
+            static CppSharp::Parser::ParserResult^ ParseHeader(CppSharp::Parser::ParserOptions^ Opts);
+
+            static CppSharp::Parser::ParserResult^ ParseLibrary(CppSharp::Parser::ParserOptions^ Opts);
+
+        };
+    }
+}

src/CppParser/Bindings/CSharp/CppParser.cs

@@ -0,0 +1,675 @@
+//----------------------------------------------------------------------------
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+//----------------------------------------------------------------------------
+using CppSharp.Runtime;
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace CppSharp
+{
+    namespace Parser
+    {
+        public enum ParserDiagnosticLevel
+        {
+            Ignored = 0,
+            Note = 1,
+            Warning = 2,
+            Error = 3,
+            Fatal = 4
+        }
+
+        public enum ParserResultKind
+        {
+            Success = 0,
+            Error = 1,
+            FileNotFound = 2
+        }
+
+        public enum SourceLocationKind
+        {
+            Invalid = 0,
+            Builtin = 1,
+            CommandLine = 2,
+            System = 3,
+            User = 4
+        }
+
+        public unsafe partial class ParserOptions : IDisposable, ICppMarshal
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 116)]
+            public struct Internal
+            {
+                [FieldOffset(0)]
+                public Std.Vector IncludeDirs;
+
+                [FieldOffset(12)]
+                public Std.Vector SystemIncludeDirs;
+
+                [FieldOffset(24)]
+                public Std.Vector Defines;
+
+                [FieldOffset(36)]
+                public Std.Vector LibraryDirs;
+
+                [FieldOffset(48)]
+                public Std.String FileName;
+
+                [FieldOffset(72)]
+                public global::System.IntPtr Library;
+
+                [FieldOffset(76)]
+                public int ToolSetToUse;
+
+                [FieldOffset(80)]
+                public Std.String TargetTriple;
+
+                [FieldOffset(104)]
+                public bool NoStandardIncludes;
+
+                [FieldOffset(105)]
+                public bool NoBuiltinIncludes;
+
+                [FieldOffset(106)]
+                public bool MicrosoftMode;
+
+                [FieldOffset(108)]
+                public CppSharp.Parser.CppAbi Abi;
+
+                [FieldOffset(112)]
+                public bool Verbose;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ParserOptions@CppParser@CppSharp@@QAE@XZ")]
+                public static extern global::System.IntPtr ParserOptions0(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ParserOptions@CppParser@CppSharp@@QAE@ABU012@@Z")]
+                public static extern global::System.IntPtr ParserOptions2(global::System.IntPtr instance, global::System.IntPtr _0);
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            void ICppMarshal.MarshalManagedToNative(IntPtr instance)
+            {
+            }
+
+            void ICppMarshal.MarshalNativeToManaged(IntPtr instance)
+            {
+            }
+
+            internal ParserOptions(ParserOptions.Internal* native)
+                : this(new global::System.IntPtr(native))
+            {
+            }
+
+            internal ParserOptions(ParserOptions.Internal native)
+                : this(&native)
+            {
+            }
+
+            internal ParserOptions(global::System.IntPtr native)
+            {
+                __Instance = native;
+            }
+
+            public ParserOptions()
+            {
+                __Instance = Marshal.AllocHGlobal(116);
+                Internal.ParserOptions0(__Instance);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                Marshal.FreeHGlobal(__Instance);
+            }
+
+            public Std.Vector<Std.String> IncludeDirs
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return new Std.Vector<Std.String>(__ptr->IncludeDirs);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->IncludeDirs = value.Internal;
+                }
+            }
+
+            public Std.Vector<Std.String> SystemIncludeDirs
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return new Std.Vector<Std.String>(__ptr->SystemIncludeDirs);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->SystemIncludeDirs = value.Internal;
+                }
+            }
+
+            public Std.Vector<Std.String> Defines
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return new Std.Vector<Std.String>(__ptr->Defines);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Defines = value.Internal;
+                }
+            }
+
+            public Std.Vector<Std.String> LibraryDirs
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return new Std.Vector<Std.String>(__ptr->LibraryDirs);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->LibraryDirs = value.Internal;
+                }
+            }
+
+            public Std.String FileName
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->FileName;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->FileName = new Std.String();
+                }
+            }
+
+            public CppSharp.Parser.Library Library
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    var __copy = new global::System.IntPtr(&__ptr->Library);
+                    return new CppSharp.Parser.Library(__copy);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Library = value.__Instance;
+                }
+            }
+
+            public int ToolSetToUse
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->ToolSetToUse;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->ToolSetToUse = value;
+                }
+            }
+
+            public Std.String TargetTriple
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->TargetTriple;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->TargetTriple = new Std.String();
+                }
+            }
+
+            public bool NoStandardIncludes
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->NoStandardIncludes;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->NoStandardIncludes = value;
+                }
+            }
+
+            public bool NoBuiltinIncludes
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->NoBuiltinIncludes;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->NoBuiltinIncludes = value;
+                }
+            }
+
+            public bool MicrosoftMode
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->MicrosoftMode;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->MicrosoftMode = value;
+                }
+            }
+
+            public CppSharp.Parser.CppAbi Abi
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->Abi;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Abi = value;
+                }
+            }
+
+            public bool Verbose
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->Verbose;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Verbose = value;
+                }
+            }
+        }
+
+        public unsafe partial class ParserDiagnostic : IDisposable, ICppMarshal
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 60)]
+            public struct Internal
+            {
+                [FieldOffset(0)]
+                public Std.String FileName;
+
+                [FieldOffset(24)]
+                public Std.String Message;
+
+                [FieldOffset(48)]
+                public CppSharp.Parser.ParserDiagnosticLevel Level;
+
+                [FieldOffset(52)]
+                public int LineNumber;
+
+                [FieldOffset(56)]
+                public int ColumnNumber;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ParserDiagnostic@CppParser@CppSharp@@QAE@XZ")]
+                public static extern global::System.IntPtr ParserDiagnostic1(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ParserDiagnostic@CppParser@CppSharp@@QAE@ABU012@@Z")]
+                public static extern global::System.IntPtr ParserDiagnostic2(global::System.IntPtr instance, global::System.IntPtr _0);
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            void ICppMarshal.MarshalManagedToNative(IntPtr instance)
+            {
+            }
+
+            void ICppMarshal.MarshalNativeToManaged(IntPtr instance)
+            {
+            }
+
+            internal ParserDiagnostic(ParserDiagnostic.Internal* native)
+                : this(new global::System.IntPtr(native))
+            {
+            }
+
+            internal ParserDiagnostic(ParserDiagnostic.Internal native)
+                : this(&native)
+            {
+            }
+
+            internal ParserDiagnostic(global::System.IntPtr native)
+            {
+                __Instance = native;
+            }
+
+            public ParserDiagnostic()
+            {
+                __Instance = Marshal.AllocHGlobal(60);
+                Internal.ParserDiagnostic1(__Instance);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                Marshal.FreeHGlobal(__Instance);
+            }
+
+            public Std.String FileName
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->FileName;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->FileName = new Std.String();
+                }
+            }
+
+            public Std.String Message
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->Message;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Message = new Std.String();
+                }
+            }
+
+            public CppSharp.Parser.ParserDiagnosticLevel Level
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->Level;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Level = value;
+                }
+            }
+
+            public int LineNumber
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->LineNumber;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->LineNumber = value;
+                }
+            }
+
+            public int ColumnNumber
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->ColumnNumber;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->ColumnNumber = value;
+                }
+            }
+        }
+
+        public unsafe partial class ParserResult : IDisposable, ICppMarshal
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 20)]
+            public struct Internal
+            {
+                [FieldOffset(0)]
+                public CppSharp.Parser.ParserResultKind Kind;
+
+                [FieldOffset(4)]
+                public global::System.IntPtr Library;
+
+                [FieldOffset(8)]
+                public Std.Vector Diagnostics;
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ParserResult@CppParser@CppSharp@@QAE@XZ")]
+                public static extern global::System.IntPtr ParserResult1(global::System.IntPtr instance);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ParserResult@CppParser@CppSharp@@QAE@ABU012@@Z")]
+                public static extern global::System.IntPtr ParserResult2(global::System.IntPtr instance, global::System.IntPtr _0);
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            void ICppMarshal.MarshalManagedToNative(IntPtr instance)
+            {
+            }
+
+            void ICppMarshal.MarshalNativeToManaged(IntPtr instance)
+            {
+            }
+
+            internal ParserResult(ParserResult.Internal* native)
+                : this(new global::System.IntPtr(native))
+            {
+            }
+
+            internal ParserResult(ParserResult.Internal native)
+                : this(&native)
+            {
+            }
+
+            internal ParserResult(global::System.IntPtr native)
+            {
+                __Instance = native;
+            }
+
+            public ParserResult()
+            {
+                __Instance = Marshal.AllocHGlobal(20);
+                Internal.ParserResult1(__Instance);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                Marshal.FreeHGlobal(__Instance);
+            }
+
+            public CppSharp.Parser.ParserResultKind Kind
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return __ptr->Kind;
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Kind = value;
+                }
+            }
+
+            public CppSharp.Parser.Library Library
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    var __copy = new global::System.IntPtr(&__ptr->Library);
+                    return new CppSharp.Parser.Library(__copy);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Library = value.__Instance;
+                }
+            }
+
+            public Std.Vector<CppSharp.Parser.ParserDiagnostic> Diagnostics
+            {
+                get
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    return new Std.Vector<CppSharp.Parser.ParserDiagnostic>(__ptr->Diagnostics);
+                }
+
+                set
+                {
+                    var __ptr = (Internal*)__Instance.ToPointer();
+                    __ptr->Diagnostics = value.Internal;
+                }
+            }
+        }
+
+        public unsafe partial class ClangParser : IDisposable, ICppMarshal
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 1)]
+            public struct Internal
+            {
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall,
+                    EntryPoint="??0ClangParser@CppParser@CppSharp@@QAE@ABV012@@Z")]
+                public static extern global::System.IntPtr ClangParser1(global::System.IntPtr instance, global::System.IntPtr _0);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="?ParseHeader@ClangParser@CppParser@CppSharp@@SAPAUParserResult@23@PAUParserOptions@23@@Z")]
+                public static extern global::System.IntPtr ParseHeader0(global::System.IntPtr Opts);
+
+                [SuppressUnmanagedCodeSecurity]
+                [DllImport("CppSharp", CallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl,
+                    EntryPoint="?ParseLibrary@ClangParser@CppParser@CppSharp@@SAPAUParserResult@23@PAUParserOptions@23@@Z")]
+                public static extern global::System.IntPtr ParseLibrary0(global::System.IntPtr Opts);
+            }
+
+            public global::System.IntPtr __Instance { get; protected set; }
+
+            void ICppMarshal.MarshalManagedToNative(IntPtr instance)
+            {
+            }
+
+            void ICppMarshal.MarshalNativeToManaged(IntPtr instance)
+            {
+            }
+
+            internal ClangParser(ClangParser.Internal* native)
+                : this(new global::System.IntPtr(native))
+            {
+            }
+
+            internal ClangParser(ClangParser.Internal native)
+                : this(&native)
+            {
+            }
+
+            internal ClangParser(global::System.IntPtr native)
+            {
+                __Instance = native;
+            }
+
+            public ClangParser()
+            {
+                __Instance = Marshal.AllocHGlobal(1);
+            }
+
+            public void Dispose()
+            {
+                Dispose(disposing: true);
+                GC.SuppressFinalize(this);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                Marshal.FreeHGlobal(__Instance);
+            }
+
+            public static CppSharp.Parser.ParserResult ParseHeader(CppSharp.Parser.ParserOptions Opts)
+            {
+                var arg0 = Opts.__Instance;
+                var __ret = Internal.ParseHeader0(arg0);
+                if (__ret == global::System.IntPtr.Zero) return null;
+                return new CppSharp.Parser.ParserResult(__ret);
+            }
+
+            public static CppSharp.Parser.ParserResult ParseLibrary(CppSharp.Parser.ParserOptions Opts)
+            {
+                var arg0 = Opts.__Instance;
+                var __ret = Internal.ParseLibrary0(arg0);
+                if (__ret == global::System.IntPtr.Zero) return null;
+                return new CppSharp.Parser.ParserResult(__ret);
+            }
+        }
+    }
+}