diff --git a/build/premake5-linux b/build/premake5-linux new file mode 100755 index 00000000..49777842 --- /dev/null +++ b/build/premake5-linux @@ -0,0 +1,8 @@ +#!/bin/sh + +if [ $(uname -m) = "x86_64" ]; then + ./premake5-linux-64 $* +else + ./premake5-linux-32 $* +fi + diff --git a/build/premake5-linux-32 b/build/premake5-linux-32 new file mode 100755 index 00000000..57a5c927 Binary files /dev/null and b/build/premake5-linux-32 differ diff --git a/build/premake5-linux-64 b/build/premake5-linux-64 new file mode 100755 index 00000000..ec0a205e Binary files /dev/null and b/build/premake5-linux-64 differ diff --git a/docs/GettingStarted.md b/docs/GettingStarted.md index 3b16c8fb..ff843bad 100644 --- a/docs/GettingStarted.md +++ b/docs/GettingStarted.md @@ -13,17 +13,24 @@ SVN repository urls found here: [http://clang.llvm.org/get_started.html](http:// Git repository urls found here: [http://llvm.org/docs/GettingStarted.html#git-mirror](http://llvm.org/docs/GettingStarted.html#git-mirror) -## Compiling on Windows/Visual Studio +## Common setup 1. Clone CppSharp to `` 2. Clone LLVM to `\deps\llvm` 3. Clone Clang to `\deps\llvm\tools\clang` -4. Run CMake in `\deps\llvm\build` and compile solution in *RelWithDebInfo* mode -5. Run `GenerateProjects.bat` in \build -6. Build generated solution in *Release*. +4. Create directory `\deps\llvm\build` -Building in *Release* is recommended because else the Clang parser will be -excruciatingly slow. +## Compiling on Windows/Visual Studio + +### Compiling LLVM on Windows/Visual Studio + +```shell +cd \deps\llvm\build + +cmake -G "Visual Studio 12" -DCLANG_BUILD_EXAMPLES=false -DCLANG_INCLUDE_DOCS=false -DCLANG_INCLUDE_TESTS=false -DCLANG_INCLUDE_DOCS=false -DCLANG_BUILD_EXAMPLES=false -DLLVM_TARGETS_TO_BUILD="X86" -DLLVM_INCLUDE_EXAMPLES=false -DLLVM_INCLUDE_DOCS=false -DLLVM_INCLUDE_TESTS=false .. + +msbuild LLVM.sln /p:Configuration=RelWithDebInfo;Platform=Win32 /m +``` Last revisions known to work: @@ -31,6 +38,19 @@ LLVM `r212459` / Git mirror revision `a15d70370edd030198cb42960b62e660b9288f25`. Clang `r212458` / Git mirror revision `c785591d768074e1666bc306086588b1242d156c`. +### Compiling CppSharp on Windows/Visual Studio + +```shell +cd \build + +generateprojects.bat + +msbuild vs2013\CppSharp.sln /p:Configuration=Release;Platform=x86 +``` + +Building in *Release* is recommended because else the Clang parser will be +excruciatingly slow. + It has been reported that running the solution upgrade process under VS 2013 breaks the build due to an incompatibility of .NET versions between projects (4.5 and 4.0). If you experience this problem you can change the targetted .NET version of the projects to be the same or just do not @@ -38,91 +58,82 @@ run the upgrade process after generation. ## Compiling on Mac OS X (experimental) -1. Clone CppSharp to `` -2. Clone LLVM to `\deps\llvm` -3. Clone Clang to `\deps\llvm\tools\clang` -4. Run CMake in `\deps\llvm\build` and compile solution in *RelWithDebInfo* mode +### Compiling LLVM on Mac OS X + +1. Compile LLVM solution in *RelWithDebInfo* mode The following CMake variables should be enabled: - LLVM_ENABLE_CXX11 (enables C++11 support) - LLVM_ENABLE_LIBCXX (enables libc++ standard library support) - LLVM_BUILD_32_BITS for 32-bit builds (defaults to 64-bit) -5. Run `premake5 gmake` in \build -6. Build generated makefiles: + +### Compiling CppSharp on Mac OS X + +1. Run `premake5-osx gmake` in \build +2. Build generated makefiles: - 32-bit builds: `config=release_x32 make` - 64-bit builds: `config=release_x64 make` ## Compiling on Linux (experimental) -### Build dependencies: +The Linux support is not complete, and these directions are included for developing CppSharp developers. + +Only 64bit build works at the moment. The build has been verified on Ubuntu 14.04. + +### Compiling LLVM on Linux If you do not have native build tools you can install them first with: ```shell -sudo apt-get install build-essential gcc-multilib g++-multilib -sudo apt-get install ninja-build cmake +sudo apt-get install cmake ninja-build build-essential ``` -Additionaly we depent on a somewhat recent version of Mono (.NET 4.5). If you're using an Ubuntu-based distribution you can install an up-to-date version from: https://launchpad.net/~directhex/+archive/monoxide ```shell -sudo add-apt-repository ppa:directhex/monoxide -sudo apt-get update -sudo apt-get install mono-devel -``` +cd deps/llvm/build -### Getting Premake: +cmake -G Ninja -DCLANG_BUILD_EXAMPLES=false -DCLANG_INCLUDE_DOCS=false -DCLANG_INCLUDE_TESTS=false -DCLANG_INCLUDE_DOCS=false -DCLANG_BUILD_EXAMPLES=false -DLLVM_TARGETS_TO_BUILD="X86" -DLLVM_INCLUDE_EXAMPLES=false -DLLVM_INCLUDE_DOCS=false -DLLVM_INCLUDE_TESTS=false .. -Download a recent Premake version from: http://sourceforge.net/projects/premake/files/Premake/nightlies/premake-dev-linux.zip/download +ninja +``` -Extract the binary inside `premake5` to `/build`. +### Compiling CppSharp on Linux -### Cloning CppSharp: +We depend on a somewhat recent version of Mono (.NET 4.5). Ubuntu 14.04 contains recent enough Mono by default. ```shell -git clone https://github.com/mono/CppSharp.git +sudo apt-get install mono-devel ``` -### Cloning and building LLVM/Clang: +If you're using a pre-14.04 Ubuntu-based distribution you can install an up-to-date version from: https://launchpad.net/~directhex/+archive/monoxide. ```shell -pushd && cd CppSharp/deps - -git clone https://github.com/llvm-mirror/llvm.git -git clone https://github.com/llvm-mirror/clang.git llvm/tools - -cd llvm && mkdir build && cd build - -cmake -G Ninja -DCLANG_BUILD_EXAMPLES=false -DCLANG_ENABLE_ARCMT=false \ - -DCLANG_ENABLE_REWRITER=false -DCLANG_ENABLE_STATIC_ANALYZER=false \ - -DCLANG_INCLUDE_DOCS=false -DCLANG_INCLUDE_TESTS=false \ - -DLLVM_BUILD_32_BITS=false -DCLANG_BUILD_DOCS=false \ - -DCLANG_BUILD_EXAMPLES=false -DLLVM_TARGETS_TO_BUILD="X86" .. - -ninja -popd +sudo add-apt-repository ppa:directhex/monoxide +sudo apt-get update +sudo apt-get install mono-devel ``` -### Building CppSharp: +Generate the makefiles, and build CppSharp: ```shell -cd CppSharp/build -./premake5 gmake -cd gmake -make +cd /build +./premake5-linux gmake +make -C gmake config=release_x64 ``` -This will compile the default target for the architecture, for instance, the `debug_x32` target for 32-bits X86. - -You can change the target by invoking `make` as: +If you need more verbosity from the builds invoke `make` as: ```shell -config=release_x32 make +verbose=true make -C gmake config=release_x64 ``` -Additionaly if you need more verbosity from the builds invoke `make` as: +Note that at the moment the build fails, as the CppSharp tests fail. However, the library itself has been built fine. + +Additionally, you may want to run a very simple test to see that it works. The test needs to find CppSharp library, so cppsharp-test needs to be clone in to the same directory where you cloned CppSharp. Also, the CppSharp directory needs to be named "cppsharp". ```shell -verbose=true make +git clone git://github.com/tomba/cppsharp-test.git +cd cppsharp-test +make runtest ``` ## Generating bindings diff --git a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs new file mode 100644 index 00000000..0fca2a83 --- /dev/null +++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs @@ -0,0 +1,7756 @@ +//---------------------------------------------------------------------------- +// This is autogenerated code by CppSharp. +// Do not edit this file or all your changes will be lost after re-generation. +//---------------------------------------------------------------------------- +using System; +using System.Runtime.InteropServices; +using System.Security; + +namespace CppSharp +{ + namespace Parser + { + namespace AST + { + public enum TypeKind + { + Tag = 0, + Array = 1, + Function = 2, + Pointer = 3, + MemberPointer = 4, + Typedef = 5, + Attributed = 6, + Decayed = 7, + TemplateSpecialization = 8, + TemplateParameter = 9, + TemplateParameterSubstitution = 10, + InjectedClassName = 11, + DependentName = 12, + PackExpansion = 13, + Builtin = 14 + } + + public enum DeclarationKind + { + DeclarationContext = 0, + Typedef = 1, + Parameter = 2, + Function = 3, + Method = 4, + Enumeration = 5, + EnumerationItem = 6, + Variable = 7, + Field = 8, + AccessSpecifier = 9, + Class = 10, + Template = 11, + ClassTemplate = 12, + ClassTemplateSpecialization = 13, + ClassTemplatePartialSpecialization = 14, + FunctionTemplate = 15, + Namespace = 16, + PreprocessedEntity = 17, + MacroDefinition = 18, + MacroExpansion = 19, + TranslationUnit = 20 + } + + public enum AccessSpecifier + { + Private = 0, + Protected = 1, + Public = 2 + } + + public enum CXXMethodKind + { + Normal = 0, + Constructor = 1, + Destructor = 2, + Conversion = 3, + Operator = 4, + UsingDirective = 5 + } + + public enum CXXOperatorKind + { + None = 0, + New = 1, + Delete = 2, + Array_New = 3, + Array_Delete = 4, + Plus = 5, + Minus = 6, + Star = 7, + Slash = 8, + Percent = 9, + Caret = 10, + Amp = 11, + Pipe = 12, + Tilde = 13, + Exclaim = 14, + Equal = 15, + Less = 16, + Greater = 17, + PlusEqual = 18, + MinusEqual = 19, + StarEqual = 20, + SlashEqual = 21, + PercentEqual = 22, + CaretEqual = 23, + AmpEqual = 24, + PipeEqual = 25, + LessLess = 26, + GreaterGreater = 27, + LessLessEqual = 28, + GreaterGreaterEqual = 29, + EqualEqual = 30, + ExclaimEqual = 31, + LessEqual = 32, + GreaterEqual = 33, + AmpAmp = 34, + PipePipe = 35, + PlusPlus = 36, + MinusMinus = 37, + Comma = 38, + ArrowStar = 39, + Arrow = 40, + Call = 41, + Subscript = 42, + Conditional = 43 + } + + public enum CallingConvention + { + Default = 0, + C = 1, + StdCall = 2, + ThisCall = 3, + FastCall = 4, + Unknown = 5 + } + + public enum StatementClass + { + Any = 0, + DeclRefExprClass = 1, + CXXConstructExprClass = 2 + } + + public enum TemplateSpecializationKind + { + Undeclared = 0, + ImplicitInstantiation = 1, + ExplicitSpecialization = 2, + ExplicitInstantiationDeclaration = 3, + ExplicitInstantiationDefinition = 4 + } + + public enum CppAbi + { + Itanium = 0, + Microsoft = 1, + ARM = 2 + } + + public enum VTableComponentKind + { + VCallOffset = 0, + VBaseOffset = 1, + OffsetToTop = 2, + RTTI = 3, + FunctionPointer = 4, + CompleteDtorPointer = 5, + DeletingDtorPointer = 6, + UnusedFunctionPointer = 7 + } + + public enum PrimitiveType + { + Null = 0, + Void = 1, + Bool = 2, + WideChar = 3, + Char = 4, + UChar = 5, + Short = 6, + UShort = 7, + Int = 8, + UInt = 9, + Long = 10, + ULong = 11, + LongLong = 12, + ULongLong = 13, + Float = 14, + Double = 15, + IntPtr = 16 + } + + public enum RawCommentKind + { + Invalid = 0, + OrdinaryBCPL = 1, + OrdinaryC = 2, + BCPLSlash = 3, + BCPLExcl = 4, + JavaDoc = 5, + Qt = 6, + Merged = 7 + } + + public enum CommentKind + { + FullComment = 0 + } + + public enum MacroLocation + { + Unknown = 0, + ClassHead = 1, + ClassBody = 2, + FunctionHead = 3, + FunctionParameters = 4, + FunctionBody = 5 + } + + public unsafe partial class Type : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 8)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST4TypeC2ENS1_8TypeKindE")] + internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.TypeKind kind); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST4TypeC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal Type(Type.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Type(Type.Internal native) + : this(&native) + { + } + + public Type(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public Type(CppSharp.Parser.AST.TypeKind kind) + { + __Instance = Marshal.AllocHGlobal(8); + var arg0 = kind; + Internal.ctor_0(__Instance, arg0); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.TypeKind Kind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Kind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Kind = value; + } + } + + public bool IsDependent + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsDependent; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsDependent = value; + } + } + } + + public unsafe partial class TypeQualifiers : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 3)] + public partial struct Internal + { + [FieldOffset(0)] + public bool IsConst; + + [FieldOffset(1)] + public bool IsVolatile; + + [FieldOffset(2)] + public bool IsRestrict; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14TypeQualifiersC2ERKS2_")] + internal static extern void cctor_0(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal TypeQualifiers(TypeQualifiers.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TypeQualifiers(TypeQualifiers.Internal native) + : this(&native) + { + } + + public TypeQualifiers(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public TypeQualifiers() + { + __Instance = Marshal.AllocHGlobal(3); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public bool IsConst + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsConst; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsConst = value; + } + } + + public bool IsVolatile + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsVolatile; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsVolatile = value; + } + } + + public bool IsRestrict + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsRestrict; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsRestrict = value; + } + } + } + + public unsafe partial class QualifiedType : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 16)] + public partial struct Internal + { + [FieldOffset(0)] + public global::System.IntPtr Type; + + [FieldOffset(8)] + public CppSharp.Parser.AST.TypeQualifiers.Internal Qualifiers; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13QualifiedTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13QualifiedTypeC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal QualifiedType(QualifiedType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal QualifiedType(QualifiedType.Internal native) + : this(&native) + { + } + + public QualifiedType(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public QualifiedType() + { + __Instance = Marshal.AllocHGlobal(16); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.Type Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Type == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Type(__ptr->Type); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Type = value == (CppSharp.Parser.AST.Type) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.TypeQualifiers Qualifiers + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(3); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Qualifiers), new UIntPtr(3)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TypeQualifiers(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Qualifiers = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.TypeQualifiers.Internal() : *(CppSharp.Parser.AST.TypeQualifiers.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class TagType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 16)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public global::System.IntPtr Declaration; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST7TagTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST7TagTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal TagType(TagType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TagType(TagType.Internal native) + : this(&native) + { + } + + public TagType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TagType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(16); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.Declaration Declaration + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Declaration == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Declaration(__ptr->Declaration); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Declaration = value == (CppSharp.Parser.AST.Declaration) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class ArrayType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 40)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType; + + [FieldOffset(24)] + public CppSharp.Parser.AST.ArrayType.ArraySize SizeType; + + [FieldOffset(32)] + public long Size; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9ArrayTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9ArrayTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public enum ArraySize + { + Constant = 0, + Variable = 1, + Dependent = 2, + Incomplete = 3 + } + + internal ArrayType(ArrayType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ArrayType(ArrayType.Internal native) + : this(&native) + { + } + + public ArrayType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public ArrayType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(40); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType QualifiedType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->QualifiedType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.ArrayType.ArraySize SizeType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->SizeType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->SizeType = value; + } + } + + public long Size + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Size; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Size = value; + } + } + } + + public unsafe partial class FunctionType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 56)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal ReturnType; + + [FieldOffset(24)] + public CppSharp.Parser.AST.CallingConvention CallingConvention; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionTypeD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType13getParametersEj")] + internal static extern global::System.IntPtr getParameters_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType13addParametersERPNS1_9ParameterE")] + internal static extern void addParameters_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType15clearParametersEv")] + internal static extern void clearParameters_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12FunctionType18getParametersCountEv")] + internal static extern uint getParametersCount_0(global::System.IntPtr instance); + } + + internal FunctionType(FunctionType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal FunctionType(FunctionType.Internal native) + : this(&native) + { + } + + public FunctionType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public FunctionType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(56); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.Parameter getParameters(uint i) + { + var __ret = Internal.getParameters_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Parameter(__ret); + } + + public void addParameters(CppSharp.Parser.AST.Parameter s) + { + var arg0 = s == (CppSharp.Parser.AST.Parameter) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addParameters_0(__Instance, arg0); + } + + public void clearParameters() + { + Internal.clearParameters_0(__Instance); + } + + public uint ParametersCount + { + get + { + var __ret = Internal.getParametersCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.QualifiedType ReturnType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->ReturnType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ReturnType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.CallingConvention CallingConvention + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->CallingConvention; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->CallingConvention = value; + } + } + } + + public unsafe partial class PointerType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 32)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal QualifiedPointee; + + [FieldOffset(24)] + public CppSharp.Parser.AST.PointerType.TypeModifier Modifier; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11PointerTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11PointerTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public enum TypeModifier + { + Value = 0, + Pointer = 1, + LVReference = 2, + RVReference = 3 + } + + internal PointerType(PointerType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal PointerType(PointerType.Internal native) + : this(&native) + { + } + + public PointerType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public PointerType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(32); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType QualifiedPointee + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->QualifiedPointee), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->QualifiedPointee = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.PointerType.TypeModifier Modifier + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Modifier; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Modifier = value; + } + } + } + + public unsafe partial class MemberPointerType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal Pointee; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17MemberPointerTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17MemberPointerTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal MemberPointerType(MemberPointerType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal MemberPointerType(MemberPointerType.Internal native) + : this(&native) + { + } + + public MemberPointerType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public MemberPointerType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(24); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType Pointee + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Pointee), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Pointee = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class TypedefType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 16)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public global::System.IntPtr Declaration; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal TypedefType(TypedefType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TypedefType(TypedefType.Internal native) + : this(&native) + { + } + + public TypedefType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TypedefType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(16); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.TypedefDecl Declaration + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Declaration == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TypedefDecl(__ptr->Declaration); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Declaration = value == (CppSharp.Parser.AST.TypedefDecl) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class AttributedType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 40)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal Modified; + + [FieldOffset(24)] + public CppSharp.Parser.AST.QualifiedType.Internal Equivalent; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14AttributedTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14AttributedTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal AttributedType(AttributedType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal AttributedType(AttributedType.Internal native) + : this(&native) + { + } + + public AttributedType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public AttributedType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(40); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType Modified + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Modified), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Modified = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.QualifiedType Equivalent + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Equivalent), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Equivalent = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class DecayedType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 56)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal Decayed; + + [FieldOffset(24)] + public CppSharp.Parser.AST.QualifiedType.Internal Original; + + [FieldOffset(40)] + public CppSharp.Parser.AST.QualifiedType.Internal Pointee; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11DecayedTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11DecayedTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal DecayedType(DecayedType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal DecayedType(DecayedType.Internal native) + : this(&native) + { + } + + public DecayedType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public DecayedType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(56); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType Decayed + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Decayed), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Decayed = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.QualifiedType Original + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Original), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Original = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.QualifiedType Pointee + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Pointee), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Pointee = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class TemplateArgument : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 40)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TemplateArgument.ArgumentKind Kind; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal Type; + + [FieldOffset(24)] + public global::System.IntPtr Declaration; + + [FieldOffset(32)] + public long Integral; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST16TemplateArgumentC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST16TemplateArgumentC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public enum ArgumentKind + { + Type = 0, + Declaration = 1, + NullPtr = 2, + Integral = 3, + Template = 4, + TemplateExpansion = 5, + Expression = 6, + Pack = 7 + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal TemplateArgument(TemplateArgument.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TemplateArgument(TemplateArgument.Internal native) + : this(&native) + { + } + + public TemplateArgument(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public TemplateArgument() + { + __Instance = Marshal.AllocHGlobal(40); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.TemplateArgument.ArgumentKind Kind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Kind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Kind = value; + } + } + + public CppSharp.Parser.AST.QualifiedType Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Type), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Type = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public CppSharp.Parser.AST.Declaration Declaration + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Declaration == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Declaration(__ptr->Declaration); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Declaration = value == (CppSharp.Parser.AST.Declaration) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public long Integral + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Integral; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Integral = value; + } + } + } + + public unsafe partial class TemplateSpecializationType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 48)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(32)] + public global::System.IntPtr Template; + + [FieldOffset(40)] + public global::System.IntPtr Desugared; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationTypeC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST26TemplateSpecializationTypeD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType12getArgumentsEj")] + 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="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType12addArgumentsERNS1_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="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST26TemplateSpecializationType17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + internal TemplateSpecializationType(TemplateSpecializationType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TemplateSpecializationType(TemplateSpecializationType.Internal native) + : this(&native) + { + } + + public TemplateSpecializationType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TemplateSpecializationType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(48); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.TemplateArgument getArguments(uint i) + { + var __ret = new CppSharp.Parser.AST.TemplateArgument.Internal(); + Internal.getArguments_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(40); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ret), new UIntPtr(40)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TemplateArgument(__instance); + } + + public void addArguments(CppSharp.Parser.AST.TemplateArgument s) + { + var arg0 = s == (CppSharp.Parser.AST.TemplateArgument) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0(__Instance, arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0(__Instance); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.Template Template + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Template == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Template(__ptr->Template); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Template = value == (CppSharp.Parser.AST.Template) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.Type Desugared + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Desugared == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Type(__ptr->Desugared); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Desugared = value == (CppSharp.Parser.AST.Type) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class TemplateParameter : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 16)] + public partial struct Internal + { + [FieldOffset(8)] + public bool IsTypeParameter; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameterC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameterC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST17TemplateParameterD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZNK8CppSharp9CppParser3AST17TemplateParametereqERKS2_")] + [return: MarshalAsAttribute(UnmanagedType.I1)] + internal static extern bool OperatorEqualEqual_0(global::System.IntPtr instance, global::System.IntPtr param); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameter7getNameEv")] + internal static extern global::System.IntPtr getName_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17TemplateParameter7setNameEPKc")] + internal static extern void setName_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal TemplateParameter(TemplateParameter.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TemplateParameter(TemplateParameter.Internal native) + : this(&native) + { + } + + public TemplateParameter(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public TemplateParameter() + { + __Instance = Marshal.AllocHGlobal(16); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public static bool operator !=(CppSharp.Parser.AST.TemplateParameter __op, CppSharp.Parser.AST.TemplateParameter param) + { + return !(__op == param); + } + + public static bool operator ==(CppSharp.Parser.AST.TemplateParameter __op, CppSharp.Parser.AST.TemplateParameter param) + { + var arg0 = __op == (CppSharp.Parser.AST.TemplateParameter) null ? global::System.IntPtr.Zero : __op.__Instance; + var arg1 = param == (CppSharp.Parser.AST.TemplateParameter) null ? global::System.IntPtr.Zero : param.__Instance; + var __ret = Internal.OperatorEqualEqual_0(__op.__Instance, arg1); + return __ret; + } + + public string Name + { + get + { + var __ret = Internal.getName_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setName_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public bool IsTypeParameter + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsTypeParameter; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsTypeParameter = value; + } + } + } + + public unsafe partial class TemplateParameterType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 40)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.TemplateParameter.Internal Parameter; + + [FieldOffset(24)] + public uint Depth; + + [FieldOffset(28)] + public uint Index; + + [FieldOffset(32)] + public bool IsParameterPack; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST21TemplateParameterTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST21TemplateParameterTypeC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST21TemplateParameterTypeD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal TemplateParameterType(TemplateParameterType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TemplateParameterType(TemplateParameterType.Internal native) + : this(&native) + { + } + + public TemplateParameterType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TemplateParameterType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(40); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.TemplateParameter Parameter + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Parser.AST.TemplateParameter.Internal.cctor_1(__instance, new global::System.IntPtr(&__ptr->Parameter)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TemplateParameter(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Parameter = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.TemplateParameter.Internal() : *(CppSharp.Parser.AST.TemplateParameter.Internal*) (value.__Instance); + } + } + + public uint Depth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Depth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Depth = value; + } + } + + public uint Index + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Index; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Index = value; + } + } + + public bool IsParameterPack + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsParameterPack; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsParameterPack = value; + } + } + } + + public unsafe partial class TemplateParameterSubstitutionType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.QualifiedType.Internal Replacement; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST33TemplateParameterSubstitutionTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST33TemplateParameterSubstitutionTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal TemplateParameterSubstitutionType(TemplateParameterSubstitutionType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TemplateParameterSubstitutionType(TemplateParameterSubstitutionType.Internal native) + : this(&native) + { + } + + public TemplateParameterSubstitutionType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TemplateParameterSubstitutionType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(24); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType Replacement + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->Replacement), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Replacement = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class InjectedClassNameType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public global::System.IntPtr TemplateSpecialization; + + [FieldOffset(16)] + public global::System.IntPtr Class; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST21InjectedClassNameTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST21InjectedClassNameTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal InjectedClassNameType(InjectedClassNameType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal InjectedClassNameType(InjectedClassNameType.Internal native) + : this(&native) + { + } + + public InjectedClassNameType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public InjectedClassNameType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(24); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.TemplateSpecializationType TemplateSpecialization + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->TemplateSpecialization == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TemplateSpecializationType(__ptr->TemplateSpecialization); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->TemplateSpecialization = value == (CppSharp.Parser.AST.TemplateSpecializationType) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.Class Class + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Class == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Class(__ptr->Class); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Class = value == (CppSharp.Parser.AST.Class) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class DependentNameType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 8)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17DependentNameTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17DependentNameTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal DependentNameType(DependentNameType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal DependentNameType(DependentNameType.Internal native) + : this(&native) + { + } + + public DependentNameType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public DependentNameType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(8); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + } + + public unsafe partial class PackExpansionType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 8)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17PackExpansionTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST17PackExpansionTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal PackExpansionType(PackExpansionType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal PackExpansionType(PackExpansionType.Internal native) + : this(&native) + { + } + + public PackExpansionType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public PackExpansionType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(8); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + } + + public unsafe partial class BuiltinType : CppSharp.Parser.AST.Type, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 12)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.TypeKind Kind; + + [FieldOffset(4)] + public bool IsDependent; + + [FieldOffset(8)] + public CppSharp.Parser.AST.PrimitiveType Type; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11BuiltinTypeC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11BuiltinTypeC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal BuiltinType(BuiltinType.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal BuiltinType(BuiltinType.Internal native) + : this(&native) + { + } + + public BuiltinType(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public BuiltinType() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(12); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.PrimitiveType Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Type; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Type = value; + } + } + } + + public unsafe partial class VTableComponent : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 16)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.VTableComponentKind Kind; + + [FieldOffset(4)] + public uint Offset; + + [FieldOffset(8)] + public global::System.IntPtr Declaration; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15VTableComponentC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15VTableComponentC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal VTableComponent(VTableComponent.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal VTableComponent(VTableComponent.Internal native) + : this(&native) + { + } + + public VTableComponent(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public VTableComponent() + { + __Instance = Marshal.AllocHGlobal(16); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.VTableComponentKind Kind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Kind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Kind = value; + } + } + + public uint Offset + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Offset; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Offset = value; + } + } + + public CppSharp.Parser.AST.Declaration Declaration + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Declaration == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Declaration(__ptr->Declaration); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Declaration = value == (CppSharp.Parser.AST.Declaration) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class VTableLayout : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public partial struct Internal + { + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayoutC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayoutC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST12VTableLayoutD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout13getComponentsEj")] + internal static extern CppSharp.Parser.AST.VTableComponent.Internal getComponents_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout13addComponentsERNS1_15VTableComponentE")] + internal static extern void addComponents_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout15clearComponentsEv")] + internal static extern void clearComponents_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST12VTableLayout18getComponentsCountEv")] + internal static extern uint getComponentsCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal VTableLayout(VTableLayout.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal VTableLayout(VTableLayout.Internal native) + : this(&native) + { + } + + public VTableLayout(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public VTableLayout() + { + __Instance = Marshal.AllocHGlobal(24); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.VTableComponent getComponents(uint i) + { + var __ret = Internal.getComponents_0(__Instance, i); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ret), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.VTableComponent(__instance); + } + + public void addComponents(CppSharp.Parser.AST.VTableComponent s) + { + var arg0 = s == (CppSharp.Parser.AST.VTableComponent) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addComponents_0(__Instance, arg0); + } + + public void clearComponents() + { + Internal.clearComponents_0(__Instance); + } + + public uint ComponentsCount + { + get + { + var __ret = Internal.getComponentsCount_0(__Instance); + return __ret; + } + } + } + + public unsafe partial class VFTableInfo : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 40)] + public partial struct Internal + { + [FieldOffset(0)] + public ulong VBTableIndex; + + [FieldOffset(8)] + public uint VFPtrOffset; + + [FieldOffset(12)] + public uint VFPtrFullOffset; + + [FieldOffset(16)] + public CppSharp.Parser.AST.VTableLayout.Internal Layout; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11VFTableInfoC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11VFTableInfoC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST11VFTableInfoD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal VFTableInfo(VFTableInfo.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal VFTableInfo(VFTableInfo.Internal native) + : this(&native) + { + } + + public VFTableInfo(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public VFTableInfo() + { + __Instance = Marshal.AllocHGlobal(40); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public ulong VBTableIndex + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->VBTableIndex; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->VBTableIndex = value; + } + } + + public uint VFPtrOffset + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->VFPtrOffset; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->VFPtrOffset = value; + } + } + + public uint VFPtrFullOffset + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->VFPtrFullOffset; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->VFPtrFullOffset = value; + } + } + + public CppSharp.Parser.AST.VTableLayout Layout + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(24); + CppSharp.Parser.AST.VTableLayout.Internal.cctor_1(__instance, new global::System.IntPtr(&__ptr->Layout)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.VTableLayout(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Layout = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.VTableLayout.Internal() : *(CppSharp.Parser.AST.VTableLayout.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class ClassLayout : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 88)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.CppAbi ABI; + + [FieldOffset(32)] + public CppSharp.Parser.AST.VTableLayout.Internal Layout; + + [FieldOffset(56)] + public bool HasOwnVFPtr; + + [FieldOffset(64)] + public long VBPtrOffset; + + [FieldOffset(72)] + public int Alignment; + + [FieldOffset(76)] + public int Size; + + [FieldOffset(80)] + public int DataSize; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayoutC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayoutC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayoutD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout11getVFTablesEj")] + internal static extern void getVFTables_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout11addVFTablesERNS1_11VFTableInfoE")] + internal static extern void addVFTables_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout13clearVFTablesEv")] + internal static extern void clearVFTables_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11ClassLayout16getVFTablesCountEv")] + internal static extern uint getVFTablesCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ClassLayout(ClassLayout.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ClassLayout(ClassLayout.Internal native) + : this(&native) + { + } + + public ClassLayout(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public ClassLayout() + { + __Instance = Marshal.AllocHGlobal(88); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.VFTableInfo getVFTables(uint i) + { + var __ret = new CppSharp.Parser.AST.VFTableInfo.Internal(); + Internal.getVFTables_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(40); + CppSharp.Parser.AST.VFTableInfo.Internal.cctor_1(__instance, new global::System.IntPtr(&__ret)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.VFTableInfo(__instance); + } + + public void addVFTables(CppSharp.Parser.AST.VFTableInfo s) + { + var arg0 = s == (CppSharp.Parser.AST.VFTableInfo) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addVFTables_0(__Instance, arg0); + } + + public void clearVFTables() + { + Internal.clearVFTables_0(__Instance); + } + + public uint VFTablesCount + { + get + { + var __ret = Internal.getVFTablesCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.CppAbi ABI + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->ABI; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ABI = value; + } + } + + public CppSharp.Parser.AST.VTableLayout Layout + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(24); + CppSharp.Parser.AST.VTableLayout.Internal.cctor_1(__instance, new global::System.IntPtr(&__ptr->Layout)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.VTableLayout(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Layout = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.VTableLayout.Internal() : *(CppSharp.Parser.AST.VTableLayout.Internal*) (value.__Instance); + } + } + + public bool HasOwnVFPtr + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HasOwnVFPtr; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HasOwnVFPtr = value; + } + } + + public long VBPtrOffset + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->VBPtrOffset; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->VBPtrOffset = value; + } + } + + public int Alignment + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Alignment; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Alignment = value; + } + } + + public int Size + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Size; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Size = value; + } + } + + public int DataSize + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->DataSize; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->DataSize = value; + } + } + } + + public unsafe partial class Declaration : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 112)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11DeclarationC2ENS1_15DeclarationKindE")] + internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.DeclarationKind kind); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11DeclarationC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST11DeclarationD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration23getPreprocessedEntitiesEj")] + internal static extern global::System.IntPtr getPreprocessedEntities_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration23addPreprocessedEntitiesERPNS1_18PreprocessedEntityE")] + internal static extern void addPreprocessedEntities_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration25clearPreprocessedEntitiesEv")] + internal static extern void clearPreprocessedEntities_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration7getNameEv")] + internal static extern global::System.IntPtr getName_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration7setNameEPKc")] + internal static extern void setName_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration12getDebugTextEv")] + internal static extern global::System.IntPtr getDebugText_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration12setDebugTextEPKc")] + internal static extern void setDebugText_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Declaration28getPreprocessedEntitiesCountEv")] + internal static extern uint getPreprocessedEntitiesCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal Declaration(Declaration.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Declaration(Declaration.Internal native) + : this(&native) + { + } + + public Declaration(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public Declaration(CppSharp.Parser.AST.DeclarationKind kind) + { + __Instance = Marshal.AllocHGlobal(112); + var arg0 = kind; + Internal.ctor_0(__Instance, arg0); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.PreprocessedEntity getPreprocessedEntities(uint i) + { + var __ret = Internal.getPreprocessedEntities_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.PreprocessedEntity(__ret); + } + + public void addPreprocessedEntities(CppSharp.Parser.AST.PreprocessedEntity s) + { + var arg0 = s == (CppSharp.Parser.AST.PreprocessedEntity) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addPreprocessedEntities_0(__Instance, arg0); + } + + public void clearPreprocessedEntities() + { + Internal.clearPreprocessedEntities_0(__Instance); + } + + public string Name + { + get + { + var __ret = Internal.getName_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setName_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public string DebugText + { + get + { + var __ret = Internal.getDebugText_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setDebugText_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public uint PreprocessedEntitiesCount + { + get + { + var __ret = Internal.getPreprocessedEntitiesCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.DeclarationKind Kind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Kind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Kind = value; + } + } + + public CppSharp.Parser.AST.AccessSpecifier Access + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Access; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Access = value; + } + } + + public CppSharp.Parser.AST.DeclarationContext _Namespace + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->_Namespace == IntPtr.Zero) ? null : new CppSharp.Parser.AST.DeclarationContext(__ptr->_Namespace); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->_Namespace = value == (CppSharp.Parser.AST.DeclarationContext) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.SourceLocation Location + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return new CppSharp.Parser.SourceLocation(__ptr->Location); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Location = value.ToInternal(); + } + } + + public CppSharp.Parser.AST.RawComment Comment + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Comment == IntPtr.Zero) ? null : new CppSharp.Parser.AST.RawComment(__ptr->Comment); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Comment = value == (CppSharp.Parser.AST.RawComment) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public bool IsIncomplete + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsIncomplete; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsIncomplete = value; + } + } + + public bool IsDependent + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsDependent; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsDependent = value; + } + } + + public CppSharp.Parser.AST.Declaration CompleteDeclaration + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->CompleteDeclaration == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Declaration(__ptr->CompleteDeclaration); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->CompleteDeclaration = value == (CppSharp.Parser.AST.Declaration) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public uint DefinitionOrder + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->DefinitionOrder; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->DefinitionOrder = value; + } + } + + public void* OriginalPtr + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->OriginalPtr; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->OriginalPtr = value; + } + } + } + + public unsafe partial class DeclarationContext : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 336)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContextC2ENS1_15DeclarationKindE")] + internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.DeclarationKind kind); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContextC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST18DeclarationContextD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13getNamespacesEj")] + internal static extern global::System.IntPtr getNamespaces_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13addNamespacesERPNS1_9NamespaceE")] + internal static extern void addNamespaces_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext15clearNamespacesEv")] + internal static extern void clearNamespaces_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext8getEnumsEj")] + internal static extern global::System.IntPtr getEnums_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext8addEnumsERPNS1_11EnumerationE")] + internal static extern void addEnums_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10clearEnumsEv")] + internal static extern void clearEnums_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12getFunctionsEj")] + internal static extern global::System.IntPtr getFunctions_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12addFunctionsERPNS1_8FunctionE")] + internal static extern void addFunctions_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext14clearFunctionsEv")] + internal static extern void clearFunctions_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10getClassesEj")] + internal static extern global::System.IntPtr getClasses_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext10addClassesERPNS1_5ClassE")] + internal static extern void addClasses_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12clearClassesEv")] + internal static extern void clearClasses_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12getTemplatesEj")] + internal static extern global::System.IntPtr getTemplates_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12addTemplatesERPNS1_8TemplateE")] + internal static extern void addTemplates_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext14clearTemplatesEv")] + internal static extern void clearTemplates_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext11getTypedefsEj")] + internal static extern global::System.IntPtr getTypedefs_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext11addTypedefsERPNS1_11TypedefDeclE")] + internal static extern void addTypedefs_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13clearTypedefsEv")] + internal static extern void clearTypedefs_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12getVariablesEj")] + internal static extern global::System.IntPtr getVariables_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext12addVariablesERPNS1_8VariableE")] + internal static extern void addVariables_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext14clearVariablesEv")] + internal static extern void clearVariables_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext18getNamespacesCountEv")] + internal static extern uint getNamespacesCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext13getEnumsCountEv")] + internal static extern uint getEnumsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext17getFunctionsCountEv")] + internal static extern uint getFunctionsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext15getClassesCountEv")] + internal static extern uint getClassesCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext17getTemplatesCountEv")] + internal static extern uint getTemplatesCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext16getTypedefsCountEv")] + internal static extern uint getTypedefsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18DeclarationContext17getVariablesCountEv")] + internal static extern uint getVariablesCount_0(global::System.IntPtr instance); + } + + internal DeclarationContext(DeclarationContext.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal DeclarationContext(DeclarationContext.Internal native) + : this(&native) + { + } + + public DeclarationContext(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public DeclarationContext(CppSharp.Parser.AST.DeclarationKind kind) + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(336); + var arg0 = kind; + Internal.ctor_0(__Instance, arg0); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.Namespace getNamespaces(uint i) + { + var __ret = Internal.getNamespaces_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Namespace(__ret); + } + + public void addNamespaces(CppSharp.Parser.AST.Namespace s) + { + var arg0 = s == (CppSharp.Parser.AST.Namespace) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addNamespaces_0(__Instance, arg0); + } + + public void clearNamespaces() + { + Internal.clearNamespaces_0(__Instance); + } + + public CppSharp.Parser.AST.Enumeration getEnums(uint i) + { + var __ret = Internal.getEnums_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Enumeration(__ret); + } + + public void addEnums(CppSharp.Parser.AST.Enumeration s) + { + var arg0 = s == (CppSharp.Parser.AST.Enumeration) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addEnums_0(__Instance, arg0); + } + + public void clearEnums() + { + Internal.clearEnums_0(__Instance); + } + + public CppSharp.Parser.AST.Function getFunctions(uint i) + { + var __ret = Internal.getFunctions_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Function(__ret); + } + + public void addFunctions(CppSharp.Parser.AST.Function s) + { + var arg0 = s == (CppSharp.Parser.AST.Function) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addFunctions_0(__Instance, arg0); + } + + public void clearFunctions() + { + Internal.clearFunctions_0(__Instance); + } + + public CppSharp.Parser.AST.Class getClasses(uint i) + { + var __ret = Internal.getClasses_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Class(__ret); + } + + public void addClasses(CppSharp.Parser.AST.Class s) + { + var arg0 = s == (CppSharp.Parser.AST.Class) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addClasses_0(__Instance, arg0); + } + + public void clearClasses() + { + Internal.clearClasses_0(__Instance); + } + + public CppSharp.Parser.AST.Template getTemplates(uint i) + { + var __ret = Internal.getTemplates_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Template(__ret); + } + + public void addTemplates(CppSharp.Parser.AST.Template s) + { + var arg0 = s == (CppSharp.Parser.AST.Template) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addTemplates_0(__Instance, arg0); + } + + public void clearTemplates() + { + Internal.clearTemplates_0(__Instance); + } + + public CppSharp.Parser.AST.TypedefDecl getTypedefs(uint i) + { + var __ret = Internal.getTypedefs_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TypedefDecl(__ret); + } + + public void addTypedefs(CppSharp.Parser.AST.TypedefDecl s) + { + var arg0 = s == (CppSharp.Parser.AST.TypedefDecl) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addTypedefs_0(__Instance, arg0); + } + + public void clearTypedefs() + { + Internal.clearTypedefs_0(__Instance); + } + + public CppSharp.Parser.AST.Variable getVariables(uint i) + { + var __ret = Internal.getVariables_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Variable(__ret); + } + + public void addVariables(CppSharp.Parser.AST.Variable s) + { + var arg0 = s == (CppSharp.Parser.AST.Variable) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addVariables_0(__Instance, arg0); + } + + public void clearVariables() + { + Internal.clearVariables_0(__Instance); + } + + public uint NamespacesCount + { + get + { + var __ret = Internal.getNamespacesCount_0(__Instance); + return __ret; + } + } + + public uint EnumsCount + { + get + { + var __ret = Internal.getEnumsCount_0(__Instance); + return __ret; + } + } + + public uint FunctionsCount + { + get + { + var __ret = Internal.getFunctionsCount_0(__Instance); + return __ret; + } + } + + public uint ClassesCount + { + get + { + var __ret = Internal.getClassesCount_0(__Instance); + return __ret; + } + } + + public uint TemplatesCount + { + get + { + var __ret = Internal.getTemplatesCount_0(__Instance); + return __ret; + } + } + + public uint TypedefsCount + { + get + { + var __ret = Internal.getTypedefsCount_0(__Instance); + return __ret; + } + } + + public uint VariablesCount + { + get + { + var __ret = Internal.getVariablesCount_0(__Instance); + return __ret; + } + } + + public bool IsAnonymous + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsAnonymous; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsAnonymous = value; + } + } + } + + public unsafe partial class TypedefDecl : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 128)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefDeclC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11TypedefDeclC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST11TypedefDeclD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal TypedefDecl(TypedefDecl.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TypedefDecl(TypedefDecl.Internal native) + : this(&native) + { + } + + public TypedefDecl(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TypedefDecl() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(128); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType QualifiedType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->QualifiedType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class Statement : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.StatementClass Class; + + [FieldOffset(8)] + public global::System.IntPtr Decl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9StatementC2ERKSsNS1_14StatementClassEPNS1_11DeclarationE")] + internal static extern void ctor_0(global::System.IntPtr instance, global::System.IntPtr str, CppSharp.Parser.AST.StatementClass Class, global::System.IntPtr decl); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9StatementC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST9StatementD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9Statement9getStringEv")] + internal static extern global::System.IntPtr getString_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9Statement9setStringEPKc")] + internal static extern void setString_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal Statement(Statement.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Statement(Statement.Internal native) + : this(&native) + { + } + + public Statement(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public string String + { + get + { + var __ret = Internal.getString_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setString_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public CppSharp.Parser.AST.StatementClass Class + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Class; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Class = value; + } + } + + public CppSharp.Parser.AST.Declaration Decl + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Decl == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Declaration(__ptr->Decl); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Decl = value == (CppSharp.Parser.AST.Declaration) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class Expression : CppSharp.Parser.AST.Statement, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.StatementClass Class; + + [FieldOffset(8)] + public global::System.IntPtr Decl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ExpressionC2ERKSsNS1_14StatementClassEPNS1_11DeclarationE")] + internal static extern void ctor_0(global::System.IntPtr instance, global::System.IntPtr str, CppSharp.Parser.AST.StatementClass Class, global::System.IntPtr decl); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ExpressionC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST10ExpressionD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal Expression(Expression.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Expression(Expression.Internal native) + : this(&native) + { + } + + public Expression(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + } + + public unsafe partial class Parameter : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 144)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType; + + [FieldOffset(128)] + public bool IsIndirect; + + [FieldOffset(129)] + public bool HasDefaultValue; + + [FieldOffset(132)] + public uint Index; + + [FieldOffset(136)] + public global::System.IntPtr DefaultArgument; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9ParameterC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9ParameterC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST9ParameterD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal Parameter(Parameter.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Parameter(Parameter.Internal native) + : this(&native) + { + } + + public Parameter(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Parameter() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(144); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType QualifiedType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->QualifiedType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public bool IsIndirect + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsIndirect; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsIndirect = value; + } + } + + public bool HasDefaultValue + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HasDefaultValue; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HasDefaultValue = value; + } + } + + public uint Index + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Index; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Index = value; + } + } + + public CppSharp.Parser.AST.Expression DefaultArgument + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->DefaultArgument == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Expression(__ptr->DefaultArgument); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->DefaultArgument = value == (CppSharp.Parser.AST.Expression) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class Function : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 200)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.QualifiedType.Internal ReturnType; + + [FieldOffset(128)] + public bool IsReturnIndirect; + + [FieldOffset(129)] + public bool IsVariadic; + + [FieldOffset(130)] + public bool IsInline; + + [FieldOffset(131)] + public bool IsPure; + + [FieldOffset(132)] + public bool IsDeleted; + + [FieldOffset(136)] + public CppSharp.Parser.AST.CXXOperatorKind OperatorKind; + + [FieldOffset(160)] + public CppSharp.Parser.AST.CallingConvention CallingConvention; + + [FieldOffset(192)] + public global::System.IntPtr SpecializationInfo; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8FunctionC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8FunctionC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST8FunctionD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function13getParametersEj")] + internal static extern global::System.IntPtr getParameters_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function13addParametersERPNS1_9ParameterE")] + internal static extern void addParameters_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function15clearParametersEv")] + internal static extern void clearParameters_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function10getMangledEv")] + internal static extern global::System.IntPtr getMangled_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function10setMangledEPKc")] + internal static extern void setMangled_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function12getSignatureEv")] + internal static extern global::System.IntPtr getSignature_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function12setSignatureEPKc")] + internal static extern void setSignature_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Function18getParametersCountEv")] + internal static extern uint getParametersCount_0(global::System.IntPtr instance); + } + + internal Function(Function.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Function(Function.Internal native) + : this(&native) + { + } + + public Function(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Function() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(200); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.Parameter getParameters(uint i) + { + var __ret = Internal.getParameters_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Parameter(__ret); + } + + public void addParameters(CppSharp.Parser.AST.Parameter s) + { + var arg0 = s == (CppSharp.Parser.AST.Parameter) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addParameters_0(__Instance, arg0); + } + + public void clearParameters() + { + Internal.clearParameters_0(__Instance); + } + + public string Mangled + { + get + { + var __ret = Internal.getMangled_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setMangled_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public string Signature + { + get + { + var __ret = Internal.getSignature_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setSignature_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public uint ParametersCount + { + get + { + var __ret = Internal.getParametersCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.QualifiedType ReturnType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->ReturnType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ReturnType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public bool IsReturnIndirect + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsReturnIndirect; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsReturnIndirect = value; + } + } + + public bool IsVariadic + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsVariadic; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsVariadic = value; + } + } + + public bool IsInline + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsInline; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsInline = value; + } + } + + public bool IsPure + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsPure; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsPure = value; + } + } + + public bool IsDeleted + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsDeleted; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsDeleted = value; + } + } + + public CppSharp.Parser.AST.CXXOperatorKind OperatorKind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->OperatorKind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->OperatorKind = value; + } + } + + public CppSharp.Parser.AST.CallingConvention CallingConvention + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->CallingConvention; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->CallingConvention = value; + } + } + + public CppSharp.Parser.AST.FunctionTemplateSpecialization SpecializationInfo + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->SpecializationInfo == IntPtr.Zero) ? null : new CppSharp.Parser.AST.FunctionTemplateSpecialization(__ptr->SpecializationInfo); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->SpecializationInfo = value == (CppSharp.Parser.AST.FunctionTemplateSpecialization) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class Method : CppSharp.Parser.AST.Function, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 240)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.QualifiedType.Internal ReturnType; + + [FieldOffset(128)] + public bool IsReturnIndirect; + + [FieldOffset(129)] + public bool IsVariadic; + + [FieldOffset(130)] + public bool IsInline; + + [FieldOffset(131)] + public bool IsPure; + + [FieldOffset(132)] + public bool IsDeleted; + + [FieldOffset(136)] + public CppSharp.Parser.AST.CXXOperatorKind OperatorKind; + + [FieldOffset(160)] + public CppSharp.Parser.AST.CallingConvention CallingConvention; + + [FieldOffset(192)] + public global::System.IntPtr SpecializationInfo; + + [FieldOffset(200)] + public global::System.IntPtr AccessDecl; + + [FieldOffset(208)] + public bool IsVirtual; + + [FieldOffset(209)] + public bool IsStatic; + + [FieldOffset(210)] + public bool IsConst; + + [FieldOffset(211)] + public bool IsImplicit; + + [FieldOffset(212)] + public bool IsExplicit; + + [FieldOffset(213)] + public bool IsOverride; + + [FieldOffset(216)] + public CppSharp.Parser.AST.CXXMethodKind MethodKind; + + [FieldOffset(220)] + public bool IsDefaultConstructor; + + [FieldOffset(221)] + public bool IsCopyConstructor; + + [FieldOffset(222)] + public bool IsMoveConstructor; + + [FieldOffset(224)] + public CppSharp.Parser.AST.QualifiedType.Internal ConversionType; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST6MethodC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST6MethodC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST6MethodD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal Method(Method.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Method(Method.Internal native) + : this(&native) + { + } + + public Method(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Method() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(240); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.AccessSpecifierDecl AccessDecl + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->AccessDecl == IntPtr.Zero) ? null : new CppSharp.Parser.AST.AccessSpecifierDecl(__ptr->AccessDecl); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->AccessDecl = value == (CppSharp.Parser.AST.AccessSpecifierDecl) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public bool IsVirtual + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsVirtual; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsVirtual = value; + } + } + + public bool IsStatic + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsStatic; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsStatic = value; + } + } + + public bool IsConst + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsConst; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsConst = value; + } + } + + public bool IsImplicit + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsImplicit; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsImplicit = value; + } + } + + public bool IsExplicit + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsExplicit; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsExplicit = value; + } + } + + public bool IsOverride + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsOverride; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsOverride = value; + } + } + + public CppSharp.Parser.AST.CXXMethodKind MethodKind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->MethodKind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->MethodKind = value; + } + } + + public bool IsDefaultConstructor + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsDefaultConstructor; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsDefaultConstructor = value; + } + } + + public bool IsCopyConstructor + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsCopyConstructor; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsCopyConstructor = value; + } + } + + public bool IsMoveConstructor + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsMoveConstructor; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsMoveConstructor = value; + } + } + + public CppSharp.Parser.AST.QualifiedType ConversionType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->ConversionType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ConversionType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class Enumeration : CppSharp.Parser.AST.DeclarationContext, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 376)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [FieldOffset(332)] + public CppSharp.Parser.AST.Enumeration.EnumModifiers Modifiers; + + [FieldOffset(336)] + public global::System.IntPtr Type; + + [FieldOffset(344)] + public global::System.IntPtr BuiltinType; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11EnumerationC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11EnumerationC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST11EnumerationD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration8getItemsEj")] + internal static extern void getItems_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration8addItemsERNS2_4ItemE")] + internal static extern void addItems_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration10clearItemsEv")] + internal static extern void clearItems_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration13getItemsCountEv")] + internal static extern uint getItemsCount_0(global::System.IntPtr instance); + } + + [Flags] + public enum EnumModifiers + { + Anonymous = 1, + Scoped = 2, + Flags = 4 + } + + public unsafe partial class Item : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 128)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(120)] + public ulong Value; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4ItemC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4ItemC2ERKS3_")] + 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="_ZN8CppSharp9CppParser3AST11Enumeration4ItemD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4Item13getExpressionEv")] + internal static extern global::System.IntPtr getExpression_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11Enumeration4Item13setExpressionEPKc")] + internal static extern void setExpression_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + internal Item(Item.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Item(Item.Internal native) + : this(&native) + { + } + + public Item(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Item() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(128); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public string Expression + { + get + { + var __ret = Internal.getExpression_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setExpression_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public ulong Value + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Value; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Value = value; + } + } + } + + internal Enumeration(Enumeration.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Enumeration(Enumeration.Internal native) + : this(&native) + { + } + + public Enumeration(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Enumeration() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(376); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.Enumeration.Item getItems(uint i) + { + var __ret = new CppSharp.Parser.AST.Enumeration.Item.Internal(); + Internal.getItems_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(128); + CppSharp.Parser.AST.Enumeration.Item.Internal.cctor_1(__instance, new global::System.IntPtr(&__ret)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Enumeration.Item(__instance); + } + + public void addItems(CppSharp.Parser.AST.Enumeration.Item s) + { + var arg0 = s == (CppSharp.Parser.AST.Enumeration.Item) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addItems_0(__Instance, arg0); + } + + public void clearItems() + { + Internal.clearItems_0(__Instance); + } + + public uint ItemsCount + { + get + { + var __ret = Internal.getItemsCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.Enumeration.EnumModifiers Modifiers + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Modifiers; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Modifiers = value; + } + } + + public CppSharp.Parser.AST.Type Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Type == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Type(__ptr->Type); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Type = value == (CppSharp.Parser.AST.Type) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.BuiltinType BuiltinType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->BuiltinType == IntPtr.Zero) ? null : new CppSharp.Parser.AST.BuiltinType(__ptr->BuiltinType); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->BuiltinType = value == (CppSharp.Parser.AST.BuiltinType) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class Variable : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 136)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(120)] + public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8VariableC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8VariableC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST8VariableD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Variable10getMangledEv")] + internal static extern global::System.IntPtr getMangled_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Variable10setMangledEPKc")] + internal static extern void setMangled_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + internal Variable(Variable.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Variable(Variable.Internal native) + : this(&native) + { + } + + public Variable(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Variable() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(136); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public string Mangled + { + get + { + var __ret = Internal.getMangled_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setMangled_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public CppSharp.Parser.AST.QualifiedType QualifiedType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->QualifiedType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + } + + public unsafe partial class BaseClassSpecifier : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 16)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(4)] + public bool IsVirtual; + + [FieldOffset(8)] + public global::System.IntPtr Type; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18BaseClassSpecifierC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18BaseClassSpecifierC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal BaseClassSpecifier(BaseClassSpecifier.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal BaseClassSpecifier(BaseClassSpecifier.Internal native) + : this(&native) + { + } + + public BaseClassSpecifier(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public BaseClassSpecifier() + { + __Instance = Marshal.AllocHGlobal(16); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.AccessSpecifier Access + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Access; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Access = value; + } + } + + public bool IsVirtual + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsVirtual; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsVirtual = value; + } + } + + public CppSharp.Parser.AST.Type Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Type == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Type(__ptr->Type); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Type = value == (CppSharp.Parser.AST.Type) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class Field : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 144)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.QualifiedType.Internal QualifiedType; + + [FieldOffset(128)] + public uint Offset; + + [FieldOffset(136)] + public global::System.IntPtr Class; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5FieldC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5FieldC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST5FieldD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal Field(Field.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Field(Field.Internal native) + : this(&native) + { + } + + public Field(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Field() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(144); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.QualifiedType QualifiedType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ptr->QualifiedType), new UIntPtr(16)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.QualifiedType(__instance); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->QualifiedType = ReferenceEquals(value, null) ? new CppSharp.Parser.AST.QualifiedType.Internal() : *(CppSharp.Parser.AST.QualifiedType.Internal*) (value.__Instance); + } + } + + public uint Offset + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Offset; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Offset = value; + } + } + + public CppSharp.Parser.AST.Class Class + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Class == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Class(__ptr->Class); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Class = value == (CppSharp.Parser.AST.Class) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class AccessSpecifierDecl : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 112)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST19AccessSpecifierDeclC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST19AccessSpecifierDeclC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST19AccessSpecifierDeclD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal AccessSpecifierDecl(AccessSpecifierDecl.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal AccessSpecifierDecl(AccessSpecifierDecl.Internal native) + : this(&native) + { + } + + public AccessSpecifierDecl(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public AccessSpecifierDecl() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(112); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + } + + public unsafe partial class Class : CppSharp.Parser.AST.DeclarationContext, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 456)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [FieldOffset(432)] + public bool IsPOD; + + [FieldOffset(433)] + public bool IsAbstract; + + [FieldOffset(434)] + public bool IsUnion; + + [FieldOffset(435)] + public bool IsDynamic; + + [FieldOffset(436)] + public bool IsPolymorphic; + + [FieldOffset(437)] + public bool HasNonTrivialDefaultConstructor; + + [FieldOffset(438)] + public bool HasNonTrivialCopyConstructor; + + [FieldOffset(439)] + public bool HasNonTrivialDestructor; + + [FieldOffset(440)] + public bool IsExternCContext; + + [FieldOffset(448)] + public global::System.IntPtr Layout; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5ClassC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5ClassC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST5ClassD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class8getBasesEj")] + internal static extern global::System.IntPtr getBases_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class8addBasesERPNS1_18BaseClassSpecifierE")] + internal static extern void addBases_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class10clearBasesEv")] + internal static extern void clearBases_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class9getFieldsEj")] + internal static extern global::System.IntPtr getFields_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class9addFieldsERPNS1_5FieldE")] + internal static extern void addFields_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class11clearFieldsEv")] + internal static extern void clearFields_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class10getMethodsEj")] + internal static extern global::System.IntPtr getMethods_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class10addMethodsERPNS1_6MethodE")] + internal static extern void addMethods_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class12clearMethodsEv")] + internal static extern void clearMethods_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class13getSpecifiersEj")] + internal static extern global::System.IntPtr getSpecifiers_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class13addSpecifiersERPNS1_19AccessSpecifierDeclE")] + internal static extern void addSpecifiers_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class15clearSpecifiersEv")] + internal static extern void clearSpecifiers_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class13getBasesCountEv")] + internal static extern uint getBasesCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class14getFieldsCountEv")] + internal static extern uint getFieldsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class15getMethodsCountEv")] + internal static extern uint getMethodsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST5Class18getSpecifiersCountEv")] + internal static extern uint getSpecifiersCount_0(global::System.IntPtr instance); + } + + internal Class(Class.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Class(Class.Internal native) + : this(&native) + { + } + + public Class(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Class() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(456); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.BaseClassSpecifier getBases(uint i) + { + var __ret = Internal.getBases_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.BaseClassSpecifier(__ret); + } + + public void addBases(CppSharp.Parser.AST.BaseClassSpecifier s) + { + var arg0 = s == (CppSharp.Parser.AST.BaseClassSpecifier) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addBases_0(__Instance, arg0); + } + + public void clearBases() + { + Internal.clearBases_0(__Instance); + } + + public CppSharp.Parser.AST.Field getFields(uint i) + { + var __ret = Internal.getFields_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Field(__ret); + } + + public void addFields(CppSharp.Parser.AST.Field s) + { + var arg0 = s == (CppSharp.Parser.AST.Field) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addFields_0(__Instance, arg0); + } + + public void clearFields() + { + Internal.clearFields_0(__Instance); + } + + public CppSharp.Parser.AST.Method getMethods(uint i) + { + var __ret = Internal.getMethods_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Method(__ret); + } + + public void addMethods(CppSharp.Parser.AST.Method s) + { + var arg0 = s == (CppSharp.Parser.AST.Method) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addMethods_0(__Instance, arg0); + } + + public void clearMethods() + { + Internal.clearMethods_0(__Instance); + } + + public CppSharp.Parser.AST.AccessSpecifierDecl getSpecifiers(uint i) + { + var __ret = Internal.getSpecifiers_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.AccessSpecifierDecl(__ret); + } + + public void addSpecifiers(CppSharp.Parser.AST.AccessSpecifierDecl s) + { + var arg0 = s == (CppSharp.Parser.AST.AccessSpecifierDecl) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addSpecifiers_0(__Instance, arg0); + } + + public void clearSpecifiers() + { + Internal.clearSpecifiers_0(__Instance); + } + + public uint BasesCount + { + get + { + var __ret = Internal.getBasesCount_0(__Instance); + return __ret; + } + } + + public uint FieldsCount + { + get + { + var __ret = Internal.getFieldsCount_0(__Instance); + return __ret; + } + } + + public uint MethodsCount + { + get + { + var __ret = Internal.getMethodsCount_0(__Instance); + return __ret; + } + } + + public uint SpecifiersCount + { + get + { + var __ret = Internal.getSpecifiersCount_0(__Instance); + return __ret; + } + } + + public bool IsPOD + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsPOD; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsPOD = value; + } + } + + public bool IsAbstract + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsAbstract; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsAbstract = value; + } + } + + public bool IsUnion + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsUnion; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsUnion = value; + } + } + + public bool IsDynamic + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsDynamic; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsDynamic = value; + } + } + + public bool IsPolymorphic + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsPolymorphic; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsPolymorphic = value; + } + } + + public bool HasNonTrivialDefaultConstructor + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HasNonTrivialDefaultConstructor; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HasNonTrivialDefaultConstructor = value; + } + } + + public bool HasNonTrivialCopyConstructor + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HasNonTrivialCopyConstructor; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HasNonTrivialCopyConstructor = value; + } + } + + public bool HasNonTrivialDestructor + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HasNonTrivialDestructor; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HasNonTrivialDestructor = value; + } + } + + public bool IsExternCContext + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsExternCContext; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsExternCContext = value; + } + } + + public CppSharp.Parser.AST.ClassLayout Layout + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Layout == IntPtr.Zero) ? null : new CppSharp.Parser.AST.ClassLayout(__ptr->Layout); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Layout = value == (CppSharp.Parser.AST.ClassLayout) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class Template : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 144)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public global::System.IntPtr TemplatedDecl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateC2ENS1_15DeclarationKindE")] + internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.DeclarationKind kind); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateC2Ev")] + internal static extern void ctor_1(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8TemplateD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Template13getParametersEj")] + internal static extern void getParameters_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Template13addParametersERNS1_17TemplateParameterE")] + internal static extern void addParameters_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Template15clearParametersEv")] + internal static extern void clearParameters_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST8Template18getParametersCountEv")] + internal static extern uint getParametersCount_0(global::System.IntPtr instance); + } + + internal Template(Template.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Template(Template.Internal native) + : this(&native) + { + } + + public Template(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Template(CppSharp.Parser.AST.DeclarationKind kind) + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(144); + var arg0 = kind; + Internal.ctor_0(__Instance, arg0); + } + + public Template() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(144); + Internal.ctor_1(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.TemplateParameter getParameters(uint i) + { + var __ret = new CppSharp.Parser.AST.TemplateParameter.Internal(); + Internal.getParameters_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(16); + CppSharp.Parser.AST.TemplateParameter.Internal.cctor_1(__instance, new global::System.IntPtr(&__ret)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TemplateParameter(__instance); + } + + public void addParameters(CppSharp.Parser.AST.TemplateParameter s) + { + var arg0 = s == (CppSharp.Parser.AST.TemplateParameter) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addParameters_0(__Instance, arg0); + } + + public void clearParameters() + { + Internal.clearParameters_0(__Instance); + } + + public uint ParametersCount + { + get + { + var __ret = Internal.getParametersCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.Declaration TemplatedDecl + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->TemplatedDecl == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Declaration(__ptr->TemplatedDecl); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->TemplatedDecl = value == (CppSharp.Parser.AST.Declaration) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class ClassTemplate : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 168)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public global::System.IntPtr TemplatedDecl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplateC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplateC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST13ClassTemplateD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplate18getSpecializationsEj")] + 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="_ZN8CppSharp9CppParser3AST13ClassTemplate18addSpecializationsERPNS1_27ClassTemplateSpecializationE")] + 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="_ZN8CppSharp9CppParser3AST13ClassTemplate20clearSpecializationsEv")] + internal static extern void clearSpecializations_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13ClassTemplate23getSpecializationsCountEv")] + internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance); + } + + internal ClassTemplate(ClassTemplate.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ClassTemplate(ClassTemplate.Internal native) + : this(&native) + { + } + + public ClassTemplate(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public ClassTemplate() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(168); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.ClassTemplateSpecialization getSpecializations(uint i) + { + var __ret = Internal.getSpecializations_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.ClassTemplateSpecialization(__ret); + } + + public void addSpecializations(CppSharp.Parser.AST.ClassTemplateSpecialization s) + { + var arg0 = s == (CppSharp.Parser.AST.ClassTemplateSpecialization) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addSpecializations_0(__Instance, arg0); + } + + public void clearSpecializations() + { + Internal.clearSpecializations_0(__Instance); + } + + public uint SpecializationsCount + { + get + { + var __ret = Internal.getSpecializationsCount_0(__Instance); + return __ret; + } + } + } + + public unsafe partial class ClassTemplateSpecialization : CppSharp.Parser.AST.Class, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 496)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [FieldOffset(432)] + public bool IsPOD; + + [FieldOffset(433)] + public bool IsAbstract; + + [FieldOffset(434)] + public bool IsUnion; + + [FieldOffset(435)] + public bool IsDynamic; + + [FieldOffset(436)] + public bool IsPolymorphic; + + [FieldOffset(437)] + public bool HasNonTrivialDefaultConstructor; + + [FieldOffset(438)] + public bool HasNonTrivialCopyConstructor; + + [FieldOffset(439)] + public bool HasNonTrivialDestructor; + + [FieldOffset(440)] + public bool IsExternCContext; + + [FieldOffset(448)] + public global::System.IntPtr Layout; + + [FieldOffset(456)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(488)] + public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecializationC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecializationC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecializationD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization12getArgumentsEj")] + 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="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization12addArgumentsERNS1_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="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST27ClassTemplateSpecialization17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ClassTemplateSpecialization(ClassTemplateSpecialization.Internal native) + : this(&native) + { + } + + public ClassTemplateSpecialization(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public ClassTemplateSpecialization() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(496); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.TemplateArgument getArguments(uint i) + { + var __ret = new CppSharp.Parser.AST.TemplateArgument.Internal(); + Internal.getArguments_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(40); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ret), new UIntPtr(40)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TemplateArgument(__instance); + } + + public void addArguments(CppSharp.Parser.AST.TemplateArgument s) + { + var arg0 = s == (CppSharp.Parser.AST.TemplateArgument) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0(__Instance, arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0(__Instance); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.ClassTemplate TemplatedDecl + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->TemplatedDecl == IntPtr.Zero) ? null : new CppSharp.Parser.AST.ClassTemplate(__ptr->TemplatedDecl); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->TemplatedDecl = value == (CppSharp.Parser.AST.ClassTemplate) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->SpecializationKind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->SpecializationKind = value; + } + } + } + + public unsafe partial class ClassTemplatePartialSpecialization : CppSharp.Parser.AST.ClassTemplateSpecialization, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 496)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [FieldOffset(432)] + public bool IsPOD; + + [FieldOffset(433)] + public bool IsAbstract; + + [FieldOffset(434)] + public bool IsUnion; + + [FieldOffset(435)] + public bool IsDynamic; + + [FieldOffset(436)] + public bool IsPolymorphic; + + [FieldOffset(437)] + public bool HasNonTrivialDefaultConstructor; + + [FieldOffset(438)] + public bool HasNonTrivialCopyConstructor; + + [FieldOffset(439)] + public bool HasNonTrivialDestructor; + + [FieldOffset(440)] + public bool IsExternCContext; + + [FieldOffset(448)] + public global::System.IntPtr Layout; + + [FieldOffset(456)] + public global::System.IntPtr TemplatedDecl; + + [FieldOffset(488)] + public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST34ClassTemplatePartialSpecializationC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST34ClassTemplatePartialSpecializationC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST34ClassTemplatePartialSpecializationD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal ClassTemplatePartialSpecialization(ClassTemplatePartialSpecialization.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ClassTemplatePartialSpecialization(ClassTemplatePartialSpecialization.Internal native) + : this(&native) + { + } + + public ClassTemplatePartialSpecialization(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public ClassTemplatePartialSpecialization() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(496); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + } + + public unsafe partial class FunctionTemplate : CppSharp.Parser.AST.Template, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 168)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public global::System.IntPtr TemplatedDecl; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplateC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplateC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST16FunctionTemplateD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplate18getSpecializationsEj")] + 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="_ZN8CppSharp9CppParser3AST16FunctionTemplate18addSpecializationsERPNS1_30FunctionTemplateSpecializationE")] + 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="_ZN8CppSharp9CppParser3AST16FunctionTemplate20clearSpecializationsEv")] + internal static extern void clearSpecializations_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST16FunctionTemplate23getSpecializationsCountEv")] + internal static extern uint getSpecializationsCount_0(global::System.IntPtr instance); + } + + internal FunctionTemplate(FunctionTemplate.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal FunctionTemplate(FunctionTemplate.Internal native) + : this(&native) + { + } + + public FunctionTemplate(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public FunctionTemplate() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(168); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.FunctionTemplateSpecialization getSpecializations(uint i) + { + var __ret = Internal.getSpecializations_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.FunctionTemplateSpecialization(__ret); + } + + public void addSpecializations(CppSharp.Parser.AST.FunctionTemplateSpecialization s) + { + var arg0 = s == (CppSharp.Parser.AST.FunctionTemplateSpecialization) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addSpecializations_0(__Instance, arg0); + } + + public void clearSpecializations() + { + Internal.clearSpecializations_0(__Instance); + } + + public uint SpecializationsCount + { + get + { + var __ret = Internal.getSpecializationsCount_0(__Instance); + return __ret; + } + } + } + + public unsafe partial class FunctionTemplateSpecialization : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 48)] + public partial struct Internal + { + [FieldOffset(0)] + public global::System.IntPtr Template; + + [FieldOffset(32)] + public global::System.IntPtr SpecializedFunction; + + [FieldOffset(40)] + public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecializationC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecializationC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecializationD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization12getArgumentsEj")] + 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="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization12addArgumentsERNS1_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="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST30FunctionTemplateSpecialization17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal FunctionTemplateSpecialization(FunctionTemplateSpecialization.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal FunctionTemplateSpecialization(FunctionTemplateSpecialization.Internal native) + : this(&native) + { + } + + public FunctionTemplateSpecialization(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public FunctionTemplateSpecialization() + { + __Instance = Marshal.AllocHGlobal(48); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.TemplateArgument getArguments(uint i) + { + var __ret = new CppSharp.Parser.AST.TemplateArgument.Internal(); + Internal.getArguments_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(40); + CppSharp.Runtime.Helpers.memcpy(__instance, new IntPtr(&__ret), new UIntPtr(40)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TemplateArgument(__instance); + } + + public void addArguments(CppSharp.Parser.AST.TemplateArgument s) + { + var arg0 = s == (CppSharp.Parser.AST.TemplateArgument) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addArguments_0(__Instance, arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0(__Instance); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0(__Instance); + return __ret; + } + } + + public CppSharp.Parser.AST.FunctionTemplate Template + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Template == IntPtr.Zero) ? null : new CppSharp.Parser.AST.FunctionTemplate(__ptr->Template); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Template = value == (CppSharp.Parser.AST.FunctionTemplate) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.Function SpecializedFunction + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->SpecializedFunction == IntPtr.Zero) ? null : new CppSharp.Parser.AST.Function(__ptr->SpecializedFunction); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->SpecializedFunction = value == (CppSharp.Parser.AST.Function) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.TemplateSpecializationKind SpecializationKind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->SpecializationKind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->SpecializationKind = value; + } + } + } + + public unsafe partial class Namespace : CppSharp.Parser.AST.DeclarationContext, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 336)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [FieldOffset(329)] + public bool IsInline; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9NamespaceC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST9NamespaceC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST9NamespaceD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal Namespace(Namespace.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Namespace(Namespace.Internal native) + : this(&native) + { + } + + public Namespace(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public Namespace() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(336); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public bool IsInline + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsInline; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsInline = value; + } + } + } + + public unsafe partial class PreprocessedEntity : CppSharp.Parser.AST.Declaration, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 120)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.MacroLocation MacroLocation; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18PreprocessedEntityC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST18PreprocessedEntityC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST18PreprocessedEntityD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + } + + internal PreprocessedEntity(PreprocessedEntity.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal PreprocessedEntity(PreprocessedEntity.Internal native) + : this(&native) + { + } + + public PreprocessedEntity(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public PreprocessedEntity() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(120); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.MacroLocation MacroLocation + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->MacroLocation; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->MacroLocation = value; + } + } + } + + public unsafe partial class MacroDefinition : CppSharp.Parser.AST.PreprocessedEntity, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 128)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.MacroLocation MacroLocation; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinitionC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinitionC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST15MacroDefinitionD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinition13getExpressionEv")] + internal static extern global::System.IntPtr getExpression_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15MacroDefinition13setExpressionEPKc")] + internal static extern void setExpression_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + internal MacroDefinition(MacroDefinition.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal MacroDefinition(MacroDefinition.Internal native) + : this(&native) + { + } + + public MacroDefinition(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public MacroDefinition() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(128); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public string Expression + { + get + { + var __ret = Internal.getExpression_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setExpression_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + } + + public unsafe partial class MacroExpansion : CppSharp.Parser.AST.PreprocessedEntity, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 136)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(112)] + public CppSharp.Parser.AST.MacroLocation MacroLocation; + + [FieldOffset(128)] + public global::System.IntPtr Definition; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansionC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansionC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST14MacroExpansionD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansion7getTextEv")] + internal static extern global::System.IntPtr getText_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST14MacroExpansion7setTextEPKc")] + internal static extern void setText_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + internal MacroExpansion(MacroExpansion.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal MacroExpansion(MacroExpansion.Internal native) + : this(&native) + { + } + + public MacroExpansion(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public MacroExpansion() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(136); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public string Text + { + get + { + var __ret = Internal.getText_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setText_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public CppSharp.Parser.AST.MacroDefinition Definition + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Definition == IntPtr.Zero) ? null : new CppSharp.Parser.AST.MacroDefinition(__ptr->Definition); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Definition = value == (CppSharp.Parser.AST.MacroDefinition) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class TranslationUnit : CppSharp.Parser.AST.Namespace, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 376)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.DeclarationKind Kind; + + [FieldOffset(4)] + public CppSharp.Parser.AST.AccessSpecifier Access; + + [FieldOffset(8)] + public global::System.IntPtr _Namespace; + + [FieldOffset(16)] + public CppSharp.Parser.SourceLocation.Internal Location; + + [FieldOffset(32)] + public global::System.IntPtr Comment; + + [FieldOffset(48)] + public bool IsIncomplete; + + [FieldOffset(49)] + public bool IsDependent; + + [FieldOffset(56)] + public global::System.IntPtr CompleteDeclaration; + + [FieldOffset(64)] + public uint DefinitionOrder; + + [FieldOffset(96)] + public void* OriginalPtr; + + [FieldOffset(328)] + public bool IsAnonymous; + + [FieldOffset(329)] + public bool IsInline; + + [FieldOffset(344)] + public bool IsSystemHeader; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnitC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnitC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST15TranslationUnitD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit9getMacrosEj")] + internal static extern global::System.IntPtr getMacros_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit9addMacrosERPNS1_15MacroDefinitionE")] + internal static extern void addMacros_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit11clearMacrosEv")] + internal static extern void clearMacros_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit11getFileNameEv")] + internal static extern global::System.IntPtr getFileName_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit11setFileNameEPKc")] + internal static extern void setFileName_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST15TranslationUnit14getMacrosCountEv")] + internal static extern uint getMacrosCount_0(global::System.IntPtr instance); + } + + internal TranslationUnit(TranslationUnit.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal TranslationUnit(TranslationUnit.Internal native) + : this(&native) + { + } + + public TranslationUnit(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public TranslationUnit() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(376); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + + public CppSharp.Parser.AST.MacroDefinition getMacros(uint i) + { + var __ret = Internal.getMacros_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.MacroDefinition(__ret); + } + + public void addMacros(CppSharp.Parser.AST.MacroDefinition s) + { + var arg0 = s == (CppSharp.Parser.AST.MacroDefinition) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addMacros_0(__Instance, arg0); + } + + public void clearMacros() + { + Internal.clearMacros_0(__Instance); + } + + public string FileName + { + get + { + var __ret = Internal.getFileName_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setFileName_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public uint MacrosCount + { + get + { + var __ret = Internal.getMacrosCount_0(__Instance); + return __ret; + } + } + + public bool IsSystemHeader + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IsSystemHeader; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IsSystemHeader = value; + } + } + } + + public unsafe partial class NativeLibrary : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 32)] + public partial struct Internal + { + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibraryC2ERKS2_")] + internal static extern void cctor_0(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibraryC2Ev")] + internal static extern void ctor_2(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibraryD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary10getSymbolsEj")] + internal static extern global::System.IntPtr getSymbols_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary10addSymbolsEPKc")] + internal static extern void addSymbols_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary12clearSymbolsEv")] + internal static extern void clearSymbols_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary11getFileNameEv")] + internal static extern global::System.IntPtr getFileName_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary11setFileNameEPKc")] + internal static extern void setFileName_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST13NativeLibrary15getSymbolsCountEv")] + internal static extern uint getSymbolsCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal NativeLibrary(NativeLibrary.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal NativeLibrary(NativeLibrary.Internal native) + : this(&native) + { + } + + public NativeLibrary(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public NativeLibrary() + { + __Instance = Marshal.AllocHGlobal(32); + Internal.ctor_2(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public string getSymbols(uint i) + { + var __ret = Internal.getSymbols_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + public void addSymbols(string s) + { + var arg0 = Marshal.StringToHGlobalAnsi(s); + Internal.addSymbols_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + + public void clearSymbols() + { + Internal.clearSymbols_0(__Instance); + } + + public string FileName + { + get + { + var __ret = Internal.getFileName_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setFileName_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public uint SymbolsCount + { + get + { + var __ret = Internal.getSymbolsCount_0(__Instance); + return __ret; + } + } + } + + public unsafe partial class ASTContext : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 24)] + public partial struct Internal + { + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContextC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContextC2ERKS2_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContextD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext19getTranslationUnitsEj")] + internal static extern global::System.IntPtr getTranslationUnits_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext19addTranslationUnitsERPNS1_15TranslationUnitE")] + internal static extern void addTranslationUnits_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext21clearTranslationUnitsEv")] + internal static extern void clearTranslationUnits_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10ASTContext24getTranslationUnitsCountEv")] + internal static extern uint getTranslationUnitsCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ASTContext(ASTContext.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ASTContext(ASTContext.Internal native) + : this(&native) + { + } + + public ASTContext(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public ASTContext() + { + __Instance = Marshal.AllocHGlobal(24); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.TranslationUnit getTranslationUnits(uint i) + { + var __ret = Internal.getTranslationUnits_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.AST.TranslationUnit(__ret); + } + + public void addTranslationUnits(CppSharp.Parser.AST.TranslationUnit s) + { + var arg0 = s == (CppSharp.Parser.AST.TranslationUnit) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addTranslationUnits_0(__Instance, arg0); + } + + public void clearTranslationUnits() + { + Internal.clearTranslationUnits_0(__Instance); + } + + public uint TranslationUnitsCount + { + get + { + var __ret = Internal.getTranslationUnitsCount_0(__Instance); + return __ret; + } + } + } + + public unsafe partial class Comment : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 4)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.CommentKind Kind; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST7CommentC2ENS1_11CommentKindE")] + internal static extern void ctor_0(global::System.IntPtr instance, CppSharp.Parser.AST.CommentKind kind); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST7CommentC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal Comment(Comment.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal Comment(Comment.Internal native) + : this(&native) + { + } + + public Comment(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public Comment(CppSharp.Parser.AST.CommentKind kind) + { + __Instance = Marshal.AllocHGlobal(4); + var arg0 = kind; + Internal.ctor_0(__Instance, arg0); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.AST.CommentKind Kind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Kind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Kind = value; + } + } + } + + public unsafe partial class FullComment : CppSharp.Parser.AST.Comment, IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 4)] + public new partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.CommentKind Kind; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11FullCommentC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST11FullCommentC2ERKS2_")] + internal static extern void cctor_1(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal FullComment(FullComment.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal FullComment(FullComment.Internal native) + : this(&native) + { + } + + public FullComment(global::System.IntPtr native, bool isInternalImpl = false) + : base(native) + { + } + + public FullComment() + : this(IntPtr.Zero) + { + __Instance = Marshal.AllocHGlobal(4); + Internal.ctor_0(__Instance); + } + + protected override void Dispose(bool disposing) + { + base.Dispose(disposing); + } + } + + public unsafe partial class RawComment : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 32)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.AST.RawCommentKind Kind; + + [FieldOffset(24)] + public global::System.IntPtr FullCommentBlock; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10RawCommentC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10RawCommentC2ERKS2_")] + 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="_ZN8CppSharp9CppParser3AST10RawCommentD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment7getTextEv")] + internal static extern global::System.IntPtr getText_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment7setTextEPKc")] + internal static extern void setText_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment12getBriefTextEv")] + internal static extern global::System.IntPtr getBriefText_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser3AST10RawComment12setBriefTextEPKc")] + internal static extern void setBriefText_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal RawComment(RawComment.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal RawComment(RawComment.Internal native) + : this(&native) + { + } + + public RawComment(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public RawComment() + { + __Instance = Marshal.AllocHGlobal(32); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public string Text + { + get + { + var __ret = Internal.getText_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setText_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public string BriefText + { + get + { + var __ret = Internal.getBriefText_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setBriefText_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public CppSharp.Parser.AST.RawCommentKind Kind + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Kind; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Kind = value; + } + } + + public CppSharp.Parser.AST.FullComment FullCommentBlock + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->FullCommentBlock == IntPtr.Zero) ? null : new CppSharp.Parser.AST.FullComment(__ptr->FullCommentBlock); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->FullCommentBlock = value == (CppSharp.Parser.AST.FullComment) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + } + } +} diff --git a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppParser.cs b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppParser.cs new file mode 100644 index 00000000..e07dc7cf --- /dev/null +++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppParser.cs @@ -0,0 +1,924 @@ +//---------------------------------------------------------------------------- +// This is autogenerated code by CppSharp. +// Do not edit this file or all your changes will be lost after re-generation. +//---------------------------------------------------------------------------- +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 + { + [StructLayout(LayoutKind.Explicit, Size = 160)] + public partial struct Internal + { + [FieldOffset(128)] + public global::System.IntPtr ASTContext; + + [FieldOffset(136)] + public int ToolSetToUse; + + [FieldOffset(152)] + public CppSharp.Parser.AST.CppAbi Abi; + + [FieldOffset(156)] + public bool NoStandardIncludes; + + [FieldOffset(157)] + public bool NoBuiltinIncludes; + + [FieldOffset(158)] + public bool MicrosoftMode; + + [FieldOffset(159)] + public bool Verbose; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptionsC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptionsC2ERKS1_")] + 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="_ZN8CppSharp9CppParser13ParserOptionsD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions12getArgumentsEj")] + internal static extern global::System.IntPtr getArguments_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions12addArgumentsEPKc")] + 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="_ZN8CppSharp9CppParser13ParserOptions14clearArgumentsEv")] + internal static extern void clearArguments_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions14getIncludeDirsEj")] + internal static extern global::System.IntPtr getIncludeDirs_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions14addIncludeDirsEPKc")] + internal static extern void addIncludeDirs_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions16clearIncludeDirsEv")] + internal static extern void clearIncludeDirs_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions20getSystemIncludeDirsEj")] + internal static extern global::System.IntPtr getSystemIncludeDirs_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions20addSystemIncludeDirsEPKc")] + internal static extern void addSystemIncludeDirs_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions22clearSystemIncludeDirsEv")] + internal static extern void clearSystemIncludeDirs_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions10getDefinesEj")] + internal static extern global::System.IntPtr getDefines_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions10addDefinesEPKc")] + internal static extern void addDefines_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions12clearDefinesEv")] + internal static extern void clearDefines_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions14getLibraryDirsEj")] + internal static extern global::System.IntPtr getLibraryDirs_0(global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions14addLibraryDirsEPKc")] + internal static extern void addLibraryDirs_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions16clearLibraryDirsEv")] + internal static extern void clearLibraryDirs_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions17getArgumentsCountEv")] + internal static extern uint getArgumentsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions11getFileNameEv")] + internal static extern global::System.IntPtr getFileName_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions11setFileNameEPKc")] + internal static extern void setFileName_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions19getIncludeDirsCountEv")] + internal static extern uint getIncludeDirsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions25getSystemIncludeDirsCountEv")] + internal static extern uint getSystemIncludeDirsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions15getDefinesCountEv")] + internal static extern uint getDefinesCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions19getLibraryDirsCountEv")] + internal static extern uint getLibraryDirsCount_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions15getTargetTripleEv")] + internal static extern global::System.IntPtr getTargetTriple_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser13ParserOptions15setTargetTripleEPKc")] + internal static extern void setTargetTriple_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ParserOptions(ParserOptions.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ParserOptions(ParserOptions.Internal native) + : this(&native) + { + } + + public ParserOptions(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public ParserOptions() + { + __Instance = Marshal.AllocHGlobal(160); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public string getArguments(uint i) + { + var __ret = Internal.getArguments_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + public void addArguments(string s) + { + var arg0 = Marshal.StringToHGlobalAnsi(s); + Internal.addArguments_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + + public void clearArguments() + { + Internal.clearArguments_0(__Instance); + } + + public string getIncludeDirs(uint i) + { + var __ret = Internal.getIncludeDirs_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + public void addIncludeDirs(string s) + { + var arg0 = Marshal.StringToHGlobalAnsi(s); + Internal.addIncludeDirs_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + + public void clearIncludeDirs() + { + Internal.clearIncludeDirs_0(__Instance); + } + + public string getSystemIncludeDirs(uint i) + { + var __ret = Internal.getSystemIncludeDirs_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + public void addSystemIncludeDirs(string s) + { + var arg0 = Marshal.StringToHGlobalAnsi(s); + Internal.addSystemIncludeDirs_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + + public void clearSystemIncludeDirs() + { + Internal.clearSystemIncludeDirs_0(__Instance); + } + + public string getDefines(uint i) + { + var __ret = Internal.getDefines_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + public void addDefines(string s) + { + var arg0 = Marshal.StringToHGlobalAnsi(s); + Internal.addDefines_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + + public void clearDefines() + { + Internal.clearDefines_0(__Instance); + } + + public string getLibraryDirs(uint i) + { + var __ret = Internal.getLibraryDirs_0(__Instance, i); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + public void addLibraryDirs(string s) + { + var arg0 = Marshal.StringToHGlobalAnsi(s); + Internal.addLibraryDirs_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + + public void clearLibraryDirs() + { + Internal.clearLibraryDirs_0(__Instance); + } + + public uint ArgumentsCount + { + get + { + var __ret = Internal.getArgumentsCount_0(__Instance); + return __ret; + } + } + + public string FileName + { + get + { + var __ret = Internal.getFileName_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setFileName_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public uint IncludeDirsCount + { + get + { + var __ret = Internal.getIncludeDirsCount_0(__Instance); + return __ret; + } + } + + public uint SystemIncludeDirsCount + { + get + { + var __ret = Internal.getSystemIncludeDirsCount_0(__Instance); + return __ret; + } + } + + public uint DefinesCount + { + get + { + var __ret = Internal.getDefinesCount_0(__Instance); + return __ret; + } + } + + public uint LibraryDirsCount + { + get + { + var __ret = Internal.getLibraryDirsCount_0(__Instance); + return __ret; + } + } + + public string TargetTriple + { + get + { + var __ret = Internal.getTargetTriple_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setTargetTriple_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public CppSharp.Parser.AST.ASTContext ASTContext + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->ASTContext == IntPtr.Zero) ? null : new CppSharp.Parser.AST.ASTContext(__ptr->ASTContext); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ASTContext = value == (CppSharp.Parser.AST.ASTContext) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public int ToolSetToUse + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->ToolSetToUse; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ToolSetToUse = value; + } + } + + public CppSharp.Parser.AST.CppAbi Abi + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Abi; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Abi = value; + } + } + + 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 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 + { + [StructLayout(LayoutKind.Explicit, Size = 32)] + public partial struct Internal + { + [FieldOffset(16)] + public CppSharp.Parser.ParserDiagnosticLevel Level; + + [FieldOffset(20)] + public int LineNumber; + + [FieldOffset(24)] + public int ColumnNumber; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserDiagnosticC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserDiagnosticC2ERKS1_")] + 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="_ZN8CppSharp9CppParser16ParserDiagnosticD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserDiagnostic11getFileNameEv")] + internal static extern global::System.IntPtr getFileName_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserDiagnostic11setFileNameEPKc")] + internal static extern void setFileName_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserDiagnostic10getMessageEv")] + internal static extern global::System.IntPtr getMessage_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserDiagnostic10setMessageEPKc")] + internal static extern void setMessage_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ParserDiagnostic(ParserDiagnostic.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ParserDiagnostic(ParserDiagnostic.Internal native) + : this(&native) + { + } + + public ParserDiagnostic(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public ParserDiagnostic() + { + __Instance = Marshal.AllocHGlobal(32); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public string FileName + { + get + { + var __ret = Internal.getFileName_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setFileName_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public string Message + { + get + { + var __ret = Internal.getMessage_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setMessage_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + 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 + { + [StructLayout(LayoutKind.Explicit, Size = 56)] + public partial struct Internal + { + [FieldOffset(0)] + public CppSharp.Parser.ParserResultKind Kind; + + [FieldOffset(32)] + public global::System.IntPtr ASTContext; + + [FieldOffset(40)] + public global::System.IntPtr Library; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser12ParserResultC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser12ParserResultC2ERKS1_")] + 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="_ZN8CppSharp9CppParser12ParserResultD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser12ParserResult14getDiagnosticsEj")] + internal static extern void getDiagnostics_0(global::System.IntPtr @return, global::System.IntPtr instance, uint i); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser12ParserResult14addDiagnosticsERNS0_16ParserDiagnosticE")] + internal static extern void addDiagnostics_0(global::System.IntPtr instance, global::System.IntPtr s); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser12ParserResult16clearDiagnosticsEv")] + internal static extern void clearDiagnostics_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser12ParserResult19getDiagnosticsCountEv")] + internal static extern uint getDiagnosticsCount_0(global::System.IntPtr instance); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ParserResult(ParserResult.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ParserResult(ParserResult.Internal native) + : this(&native) + { + } + + public ParserResult(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public ParserResult() + { + __Instance = Marshal.AllocHGlobal(56); + Internal.ctor_0(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public CppSharp.Parser.ParserDiagnostic getDiagnostics(uint i) + { + var __ret = new CppSharp.Parser.ParserDiagnostic.Internal(); + Internal.getDiagnostics_0(new IntPtr(&__ret), __Instance, i); + var __instance = Marshal.AllocHGlobal(32); + CppSharp.Parser.ParserDiagnostic.Internal.cctor_1(__instance, new global::System.IntPtr(&__ret)); + return (__instance == IntPtr.Zero) ? null : new CppSharp.Parser.ParserDiagnostic(__instance); + } + + public void addDiagnostics(CppSharp.Parser.ParserDiagnostic s) + { + var arg0 = s == (CppSharp.Parser.ParserDiagnostic) null ? global::System.IntPtr.Zero : s.__Instance; + Internal.addDiagnostics_0(__Instance, arg0); + } + + public void clearDiagnostics() + { + Internal.clearDiagnostics_0(__Instance); + } + + public uint DiagnosticsCount + { + get + { + var __ret = Internal.getDiagnosticsCount_0(__Instance); + return __ret; + } + } + + 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.AST.ASTContext ASTContext + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->ASTContext == IntPtr.Zero) ? null : new CppSharp.Parser.AST.ASTContext(__ptr->ASTContext); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ASTContext = value == (CppSharp.Parser.AST.ASTContext) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + + public CppSharp.Parser.AST.NativeLibrary Library + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return (__ptr->Library == IntPtr.Zero) ? null : new CppSharp.Parser.AST.NativeLibrary(__ptr->Library); + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Library = value == (CppSharp.Parser.AST.NativeLibrary) null ? global::System.IntPtr.Zero : value.__Instance; + } + } + } + + public unsafe partial class ClangParser : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 1)] + public partial struct Internal + { + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser11ClangParserC2ERKS1_")] + 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="_ZN8CppSharp9CppParser11ClangParser11ParseHeaderEPNS0_13ParserOptionsE")] + internal static extern global::System.IntPtr ParseHeader_0(global::System.IntPtr Opts); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser11ClangParser12ParseLibraryEPNS0_13ParserOptionsE")] + internal static extern global::System.IntPtr ParseLibrary_0(global::System.IntPtr Opts); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser11ClangParser13GetTargetInfoEPNS0_13ParserOptionsE")] + internal static extern global::System.IntPtr GetTargetInfo_0(global::System.IntPtr Opts); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ClangParser(ClangParser.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ClangParser(ClangParser.Internal native) + : this(&native) + { + } + + public ClangParser(global::System.IntPtr native, bool isInternalImpl = false) + { + __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 == (CppSharp.Parser.ParserOptions) null ? global::System.IntPtr.Zero : Opts.__Instance; + var __ret = Internal.ParseHeader_0(arg0); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.ParserResult(__ret); + } + + public static CppSharp.Parser.ParserResult ParseLibrary(CppSharp.Parser.ParserOptions Opts) + { + var arg0 = Opts == (CppSharp.Parser.ParserOptions) null ? global::System.IntPtr.Zero : Opts.__Instance; + var __ret = Internal.ParseLibrary_0(arg0); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.ParserResult(__ret); + } + + public static CppSharp.Parser.ParserTargetInfo GetTargetInfo(CppSharp.Parser.ParserOptions Opts) + { + var arg0 = Opts == (CppSharp.Parser.ParserOptions) null ? global::System.IntPtr.Zero : Opts.__Instance; + var __ret = Internal.GetTargetInfo_0(arg0); + if (__ret == global::System.IntPtr.Zero) return null; + return (__ret == IntPtr.Zero) ? null : new CppSharp.Parser.ParserTargetInfo(__ret); + } + } + } +} diff --git a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Sources.cs b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Sources.cs new file mode 100644 index 00000000..b0451379 --- /dev/null +++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Sources.cs @@ -0,0 +1,84 @@ +//---------------------------------------------------------------------------- +// This is autogenerated code by CppSharp. +// Do not edit this file or all your changes will be lost after re-generation. +//---------------------------------------------------------------------------- +using System; +using System.Runtime.InteropServices; +using System.Security; + +namespace CppSharp +{ + namespace Parser + { + public unsafe partial struct SourceLocation + { + [StructLayout(LayoutKind.Explicit, Size = 4)] + public partial struct Internal + { + [FieldOffset(0)] + public uint ID; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser14SourceLocationC2Ev")] + internal static extern void ctor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser14SourceLocationC2Ej")] + internal static extern void ctor_1(global::System.IntPtr instance, uint ID); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser14SourceLocationC2ERKS1_")] + internal static extern void cctor_2(global::System.IntPtr instance, global::System.IntPtr _0); + } + + internal SourceLocation(SourceLocation.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal SourceLocation(SourceLocation.Internal native) + : this(&native) + { + } + + public SourceLocation(global::System.IntPtr native, bool isInternalImpl = false) : this() + { + var __ptr = (Internal*)native.ToPointer(); + ID = __ptr->ID; + } + + internal Internal ToInternal() + { + var __native = new CppSharp.Parser.SourceLocation.Internal(); + var __ptr = &__native; + __native.ID = ID; + return __native; + } + + internal void FromInternal(Internal* native) + { + var __ptr = native; + ID = __ptr->ID; + } + + public SourceLocation(uint ID) + : this() + { + var __fixedInstance = ToInternal(); + Internal.ctor_1(new global::System.IntPtr(&__fixedInstance), ID); + FromInternal(&__fixedInstance); + } + + public uint ID + { + get; + + set + ; + } + } + } +} diff --git a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Target.cs b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Target.cs new file mode 100644 index 00000000..4e17444f --- /dev/null +++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Target.cs @@ -0,0 +1,796 @@ +//---------------------------------------------------------------------------- +// This is autogenerated code by CppSharp. +// Do not edit this file or all your changes will be lost after re-generation. +//---------------------------------------------------------------------------- +using System; +using System.Runtime.InteropServices; +using System.Security; + +namespace CppSharp +{ + namespace Parser + { + public enum ParserIntType + { + NoInt = 0, + SignedChar = 1, + UnsignedChar = 2, + SignedShort = 3, + UnsignedShort = 4, + SignedInt = 5, + UnsignedInt = 6, + SignedLong = 7, + UnsignedLong = 8, + SignedLongLong = 9, + UnsignedLongLong = 10 + } + + public unsafe partial class ParserTargetInfo : IDisposable + { + [StructLayout(LayoutKind.Explicit, Size = 160)] + public partial struct Internal + { + [FieldOffset(8)] + public CppSharp.Parser.ParserIntType Char16Type; + + [FieldOffset(12)] + public CppSharp.Parser.ParserIntType Char32Type; + + [FieldOffset(16)] + public CppSharp.Parser.ParserIntType Int64Type; + + [FieldOffset(20)] + public CppSharp.Parser.ParserIntType IntMaxType; + + [FieldOffset(24)] + public CppSharp.Parser.ParserIntType IntPtrType; + + [FieldOffset(28)] + public CppSharp.Parser.ParserIntType SizeType; + + [FieldOffset(32)] + public CppSharp.Parser.ParserIntType UIntMaxType; + + [FieldOffset(36)] + public CppSharp.Parser.ParserIntType WCharType; + + [FieldOffset(40)] + public CppSharp.Parser.ParserIntType WIntType; + + [FieldOffset(44)] + public uint BoolAlign; + + [FieldOffset(48)] + public uint BoolWidth; + + [FieldOffset(52)] + public uint CharAlign; + + [FieldOffset(56)] + public uint CharWidth; + + [FieldOffset(60)] + public uint Char16Align; + + [FieldOffset(64)] + public uint Char16Width; + + [FieldOffset(68)] + public uint Char32Align; + + [FieldOffset(72)] + public uint Char32Width; + + [FieldOffset(76)] + public uint HalfAlign; + + [FieldOffset(80)] + public uint HalfWidth; + + [FieldOffset(84)] + public uint FloatAlign; + + [FieldOffset(88)] + public uint FloatWidth; + + [FieldOffset(92)] + public uint DoubleAlign; + + [FieldOffset(96)] + public uint DoubleWidth; + + [FieldOffset(100)] + public uint ShortAlign; + + [FieldOffset(104)] + public uint ShortWidth; + + [FieldOffset(108)] + public uint IntAlign; + + [FieldOffset(112)] + public uint IntWidth; + + [FieldOffset(116)] + public uint IntMaxTWidth; + + [FieldOffset(120)] + public uint LongAlign; + + [FieldOffset(124)] + public uint LongWidth; + + [FieldOffset(128)] + public uint LongDoubleAlign; + + [FieldOffset(132)] + public uint LongDoubleWidth; + + [FieldOffset(136)] + public uint LongLongAlign; + + [FieldOffset(140)] + public uint LongLongWidth; + + [FieldOffset(144)] + public uint PointerAlign; + + [FieldOffset(148)] + public uint PointerWidth; + + [FieldOffset(152)] + public uint WCharAlign; + + [FieldOffset(156)] + public uint WCharWidth; + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserTargetInfoC2ERKS1_")] + internal static extern void cctor_0(global::System.IntPtr instance, global::System.IntPtr _0); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserTargetInfoC2Ev")] + internal static extern void ctor_2(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserTargetInfoD2Ev")] + internal static extern void dtor_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserTargetInfo6getABIEv")] + internal static extern global::System.IntPtr getABI_0(global::System.IntPtr instance); + + [SuppressUnmanagedCodeSecurity] + [DllImport("CppSharp.CppParser.dll", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl, + EntryPoint="_ZN8CppSharp9CppParser16ParserTargetInfo6setABIEPKc")] + internal static extern void setABI_0(global::System.IntPtr instance, global::System.IntPtr s); + } + + public global::System.IntPtr __Instance { get; protected set; } + + internal ParserTargetInfo(ParserTargetInfo.Internal* native) + : this(new global::System.IntPtr(native)) + { + } + + internal ParserTargetInfo(ParserTargetInfo.Internal native) + : this(&native) + { + } + + public ParserTargetInfo(global::System.IntPtr native, bool isInternalImpl = false) + { + __Instance = native; + } + + public ParserTargetInfo() + { + __Instance = Marshal.AllocHGlobal(160); + Internal.ctor_2(__Instance); + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + Internal.dtor_0(__Instance); + Marshal.FreeHGlobal(__Instance); + } + + public string ABI + { + get + { + var __ret = Internal.getABI_0(__Instance); + if (__ret == global::System.IntPtr.Zero) return null; + return Marshal.PtrToStringAnsi(__ret); + } + + set + { + var arg0 = Marshal.StringToHGlobalAnsi(value); + Internal.setABI_0(__Instance, arg0); + Marshal.FreeHGlobal(arg0); + } + } + + public CppSharp.Parser.ParserIntType Char16Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Char16Type; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Char16Type = value; + } + } + + public CppSharp.Parser.ParserIntType Char32Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Char32Type; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Char32Type = value; + } + } + + public CppSharp.Parser.ParserIntType Int64Type + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Int64Type; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Int64Type = value; + } + } + + public CppSharp.Parser.ParserIntType IntMaxType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IntMaxType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IntMaxType = value; + } + } + + public CppSharp.Parser.ParserIntType IntPtrType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IntPtrType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IntPtrType = value; + } + } + + public CppSharp.Parser.ParserIntType SizeType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->SizeType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->SizeType = value; + } + } + + public CppSharp.Parser.ParserIntType UIntMaxType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->UIntMaxType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->UIntMaxType = value; + } + } + + public CppSharp.Parser.ParserIntType WCharType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->WCharType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->WCharType = value; + } + } + + public CppSharp.Parser.ParserIntType WIntType + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->WIntType; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->WIntType = value; + } + } + + public uint BoolAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->BoolAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->BoolAlign = value; + } + } + + public uint BoolWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->BoolWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->BoolWidth = value; + } + } + + public uint CharAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->CharAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->CharAlign = value; + } + } + + public uint CharWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->CharWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->CharWidth = value; + } + } + + public uint Char16Align + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Char16Align; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Char16Align = value; + } + } + + public uint Char16Width + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Char16Width; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Char16Width = value; + } + } + + public uint Char32Align + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Char32Align; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Char32Align = value; + } + } + + public uint Char32Width + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->Char32Width; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->Char32Width = value; + } + } + + public uint HalfAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HalfAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HalfAlign = value; + } + } + + public uint HalfWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->HalfWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->HalfWidth = value; + } + } + + public uint FloatAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->FloatAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->FloatAlign = value; + } + } + + public uint FloatWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->FloatWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->FloatWidth = value; + } + } + + public uint DoubleAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->DoubleAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->DoubleAlign = value; + } + } + + public uint DoubleWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->DoubleWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->DoubleWidth = value; + } + } + + public uint ShortAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->ShortAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ShortAlign = value; + } + } + + public uint ShortWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->ShortWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->ShortWidth = value; + } + } + + public uint IntAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IntAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IntAlign = value; + } + } + + public uint IntWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IntWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IntWidth = value; + } + } + + public uint IntMaxTWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->IntMaxTWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->IntMaxTWidth = value; + } + } + + public uint LongAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->LongAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->LongAlign = value; + } + } + + public uint LongWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->LongWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->LongWidth = value; + } + } + + public uint LongDoubleAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->LongDoubleAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->LongDoubleAlign = value; + } + } + + public uint LongDoubleWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->LongDoubleWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->LongDoubleWidth = value; + } + } + + public uint LongLongAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->LongLongAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->LongLongAlign = value; + } + } + + public uint LongLongWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->LongLongWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->LongLongWidth = value; + } + } + + public uint PointerAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->PointerAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->PointerAlign = value; + } + } + + public uint PointerWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->PointerWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->PointerWidth = value; + } + } + + public uint WCharAlign + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->WCharAlign; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->WCharAlign = value; + } + } + + public uint WCharWidth + { + get + { + var __ptr = (Internal*)__Instance.ToPointer(); + return __ptr->WCharWidth; + } + + set + { + var __ptr = (Internal*)__Instance.ToPointer(); + __ptr->WCharWidth = value; + } + } + } + } +} diff --git a/src/CppParser/Bindings/ParserGen.cs b/src/CppParser/Bindings/ParserGen.cs index 608dfc6a..83cae6f3 100644 --- a/src/CppParser/Bindings/ParserGen.cs +++ b/src/CppParser/Bindings/ParserGen.cs @@ -14,6 +14,8 @@ namespace CppSharp /// class ParserGen : ILibrary { + const string LINUX_INCLUDE_BASE_DIR = "../../../../deps/x86_64-linux-gnu"; + internal readonly GeneratorKind Kind; internal readonly string Triple; internal readonly CppAbi Abi; @@ -63,6 +65,9 @@ namespace CppSharp if (Triple.Contains("apple")) SetupMacOptions(options); + if (Triple.Contains("linux")) + SetupLinuxOptions(options); + var basePath = Path.Combine(GetSourceDirectory("src"), "CppParser"); options.addIncludeDirs(basePath); options.addLibraryDirs("."); @@ -77,6 +82,26 @@ namespace CppSharp options.CheckSymbols = false; } + private static void SetupLinuxOptions(DriverOptions options) + { + options.MicrosoftMode = false; + options.NoBuiltinIncludes = true; + + string[] sysincdirs = new[] { + "/usr/include/c++/4.8", + "/usr/include/x86_64-linux-gnu/c++/4.8", + "/usr/include/c++/4.8/backward", + "/usr/lib/gcc/x86_64-linux-gnu/4.8/include", + "/usr/include/x86_64-linux-gnu", + "/usr/include", + }; + + foreach (var dir in sysincdirs) + { + options.addSystemIncludeDirs(LINUX_INCLUDE_BASE_DIR + dir); + } + } + private static void SetupMacOptions(DriverOptions options) { options.MicrosoftMode = false; @@ -131,6 +156,14 @@ namespace CppSharp CppAbi.Itanium)); Console.WriteLine(); } + + if (Directory.Exists(LINUX_INCLUDE_BASE_DIR)) + { + Console.WriteLine("Generating the C# parser bindings for Linux..."); + ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "x86_64-linux-gnu", + CppAbi.Itanium)); + Console.WriteLine(); + } } } diff --git a/src/CppParser/Bindings/premake4.lua b/src/CppParser/Bindings/premake4.lua index 85da406e..cc3e4b16 100644 --- a/src/CppParser/Bindings/premake4.lua +++ b/src/CppParser/Bindings/premake4.lua @@ -30,6 +30,8 @@ project "CppSharp.Parser.CSharp" files { "CSharp/i686-pc-win32-msvc/**.cs" } elseif os.is_osx() then files { "CSharp/i686-apple-darwin12.4.0/**.cs" } + elseif os.is_linux() then + files { "CSharp/x86_64-linux-gnu/**.cs" } else print "Unknown architecture" end