Merge pull request #293 from tomba/linux-support

Linux support
11 years ago · 611779fdfc
10 changed files with 9666 additions and 52 deletions
--- a/build/premake5-linux
+++ b/build/premake5-linux
@ -0,0 +1,8 @@
				@@ -0,0 +1,8 @@
+#!/bin/sh
+
+if [ $(uname -m) = "x86_64" ]; then
+	./premake5-linux-64 $*
+else
+	./premake5-linux-32 $*
+fi
+
--- a/build/premake5-linux-32
+++ b/build/premake5-linux-32
--- a/build/premake5-linux-64
+++ b/build/premake5-linux-64
--- 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://
				@@ -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 `<CppSharp>`
 2. Clone LLVM to `<CppSharp>\deps\llvm`
 3. Clone Clang to `<CppSharp>\deps\llvm\tools\clang`
-4. Run CMake in `<CppSharp>\deps\llvm\build` and compile solution in *RelWithDebInfo* mode
-5. Run `GenerateProjects.bat` in <CppSharp>\build
-6. Build generated solution in *Release*.
+4. Create directory `<CppSharp>\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 <CppSharp>\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`.
				@@ -31,6 +38,19 @@ LLVM `r212459` / Git mirror revision `a15d70370edd030198cb42960b62e660b9288f25`.

 Clang `r212458` / Git mirror revision `c785591d768074e1666bc306086588b1242d156c`.

+### Compiling CppSharp on Windows/Visual Studio
+
+```shell
+cd <CppSharp>\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.
				@@ -38,91 +58,82 @@ run the upgrade process after generation.

 ## Compiling on Mac OS X (experimental)

-1. Clone CppSharp to `<CppSharp>`
-2. Clone LLVM to `<CppSharp>\deps\llvm`
-3. Clone Clang to `<CppSharp>\deps\llvm\tools\clang`
-4. Run CMake in `<CppSharp>\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 <CppSharp>\build
-6. Build generated makefiles:
+
+### Compiling CppSharp on Mac OS X
+
+1. Run `premake5-osx gmake` in <CppSharp>\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 `<CppSharp>/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 <CppSharp>/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
--- a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs
+++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/AST.cs
--- a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppParser.cs
+++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/CppParser.cs
@ -0,0 +1,924 @@
				@@ -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);
+            }
+        }
+    }
+}
--- a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Sources.cs
+++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Sources.cs
@ -0,0 +1,84 @@
				@@ -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
+                ;
+            }
+        }
+    }
+}
--- a/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Target.cs
+++ b/src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Target.cs
@ -0,0 +1,796 @@
				@@ -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;
+                }
+            }
+        }
+    }
+}
--- a/src/CppParser/Bindings/ParserGen.cs
+++ b/src/CppParser/Bindings/ParserGen.cs
@ -14,6 +14,8 @@ namespace CppSharp
				@@ -14,6 +14,8 @@ namespace CppSharp
    /// </summary>
    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
				@@ -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
				@@ -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
				@@ -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();
+            }
        }
    }

--- a/src/CppParser/Bindings/premake4.lua
+++ b/src/CppParser/Bindings/premake4.lua
@ -30,6 +30,8 @@ project "CppSharp.Parser.CSharp"
				@@ -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