Added support for a lot more driver options, including ignoring built-in and standard includes, target triple and ABIs, and system include directories.

src/Generator/Driver.cs

@@ -205,13 +205,18 @@ namespace CppSharp
         {
             Defines = new List<string>();
             IncludeDirs = new List<string>();
+            SystemIncludeDirs = new List<string>();
             Headers = new List<string>();
             Assembly = string.Empty;
+            NoStandardIncludes = false;
+            NoBuiltinIncludes = false;
             GeneratorKind = LanguageGeneratorKind.CSharp;
             GenerateLibraryNamespace = true;
             GenerateFunctionTemplates = false;
             WriteOnlyWhenChanged = false;
             GeneratePartialClasses = true;
+            MicrosoftMode = (Environment.OSVersion.Platform != PlatformID.MacOSX)
+                && (Environment.OSVersion.Platform != PlatformID.Unix);
 
             // Library options
             LibraryDirs = new List<string>();
@@ -232,12 +237,17 @@ namespace CppSharp
         public bool GenerateLibraryNamespace;
         public bool GenerateFunctionTemplates;
         public bool GeneratePartialClasses;
+        public bool NoStandardIncludes;
+        public bool NoBuiltinIncludes;
+        public bool MicrosoftMode;
+        public string TargetTriple;
         public string OutputNamespace;
         public string OutputDir;
         public string LibraryName;
         public CppAbi Abi;
         public List<string> Defines;
         public List<string> IncludeDirs;
+        public List<string> SystemIncludeDirs;
         public List<string> Headers;
         public string Template;
         public string Assembly;

src/Generator/Parser.cs

@@ -45,8 +45,13 @@ namespace CppSharp
                 FileName = file,
                 Verbose = false,
                 IncludeDirs = options.IncludeDirs,
+                SystemIncludeDirs = options.SystemIncludeDirs,
                 Defines = options.Defines,
-                ToolSetToUse = options.ToolsetToUse
+                NoStandardIncludes = options.NoStandardIncludes,
+                NoBuiltinIncludes = options.NoBuiltinIncludes,
+                MicrosoftMode = options.MicrosoftMode,
+                ToolSetToUse = options.ToolsetToUse,
+                TargetTriple = options.TargetTriple
             };
 
             var result = ClangParser.ParseHeader(parserOptions);

src/Parser/Parser.cpp

@@ -73,34 +73,60 @@ void Parser::SetupHeader()
     using namespace clang;
     using namespace clix;
 
-    const char* args[] =
-    {
+    std::vector<const char*> args;
+    args.push_back("-cc1");
+
     // Enable C++ language mode
-        "-xc++", "-std=c++11", "-fno-rtti",
+    args.push_back("-xc++");
+    args.push_back("-std=gnu++11");
+    //args.push_back("-Wno-undefined-inline");
+    args.push_back("-fno-rtti");
+
     // Enable the Microsoft parsing extensions
-        "-fms-extensions", "-fms-compatibility", "-fdelayed-template-parsing",
-        // Enable the Microsoft ABI
-        //"-Xclang", "-cxx-abi", "-Xclang", "microsoft"
-    };
+    if (Opts->MicrosoftMode)
+    {
+        args.push_back("-fms-extensions");
+        args.push_back("-fms-compatibility");
+        args.push_back("-fdelayed-template-parsing");
+    }
 
     C.reset(new CompilerInstance());
     C->createDiagnostics();
 
     CompilerInvocation* Inv = new CompilerInvocation();
-    CompilerInvocation::CreateFromArgs(*Inv, args, args + ARRAY_SIZE(args),
+    CompilerInvocation::CreateFromArgs(*Inv, args.data(), args.data() + args.size(),
       C->getDiagnostics());
     C->setInvocation(Inv);
 
     TargetOptions& TO = Inv->getTargetOpts();
+    if (!System::String::IsNullOrWhiteSpace(Opts->TargetTriple))
+        TO.Triple = marshalString<E_UTF8>(Opts->TargetTriple);
+    else
         TO.Triple = llvm::sys::getDefaultTargetTriple();
 
+    TargetABI = Opts->MicrosoftMode ? TargetCXXABI::Microsoft
+        : TargetCXXABI::GenericItanium;
+
     TargetInfo* TI = TargetInfo::CreateTargetInfo(C->getDiagnostics(), &TO);
-    TI->setCXXABI(TargetCXXABI::Microsoft);
+    TI->setCXXABI(TargetABI);
     C->setTarget(TI);
 
     C->createFileManager();
     C->createSourceManager(C->getFileManager());
 
+    if (Opts->NoStandardIncludes)
+    {
+        auto HSOpts = C->getHeaderSearchOpts();
+        HSOpts.UseStandardSystemIncludes = false;
+        HSOpts.UseStandardCXXIncludes = false;
+    }
+
+    if (Opts->NoBuiltinIncludes)
+    {
+        auto HSOpts = C->getHeaderSearchOpts();
+        HSOpts.UseBuiltinIncludes = false;
+    }
+
     if (Opts->Verbose)
         C->getHeaderSearchOpts().Verbose = true;
 
@@ -110,6 +136,12 @@ void Parser::SetupHeader()
         C->getHeaderSearchOpts().AddPath(s, frontend::Angled, false, false);
     }
 
+    for each(System::String^% include in Opts->SystemIncludeDirs)
+    {
+        String s = marshalString<E_UTF8>(include);
+        C->getHeaderSearchOpts().AddPath(s, frontend::System, false, false);
+    }
+
     for each(System::String^% def in Opts->Defines)
     {
         String s = marshalString<E_UTF8>(def);
@@ -123,6 +155,8 @@ void Parser::SetupHeader()
         clang::frontend::System, false, false);
 
 #ifdef _MSC_VER
+    if (!Opts->NoBuiltinIncludes)
+        {
         std::vector<std::string> SystemDirs = GetWindowsSystemIncludeDirs();
         clang::HeaderSearchOptions& HSOpts = C->getHeaderSearchOpts();
 
@@ -130,6 +164,7 @@ void Parser::SetupHeader()
         {
             HSOpts.AddPath(SystemDirs[i], frontend::System, false, false);
         }
+    }
 #endif
 
     C->createPreprocessor();
@@ -1165,7 +1200,7 @@ void Parser::WalkFunction(clang::FunctionDecl* FD, CppSharp::Function^ F,
     }
     F->ReturnType = WalkType(FD->getResultType(), &RTL);
 
-    String Mangled = GetDeclMangledName(FD, TargetCXXABI::Microsoft, IsDependent);
+    String Mangled = GetDeclMangledName(FD, TargetABI, IsDependent);
     F->Mangled = marshalString<E_UTF8>(Mangled);
 
     for(auto it = FD->param_begin(); it != FD->param_end(); ++it)
@@ -1374,7 +1409,7 @@ CppSharp::Variable^ Parser::WalkVariable(clang::VarDecl *VD)
     auto TL = VD->getTypeSourceInfo()->getTypeLoc();
     Var->QualifiedType = GetQualifiedType(VD->getType(), WalkType(VD->getType(), &TL));
 
-    auto Mangled = GetDeclMangledName(VD, TargetCXXABI::Microsoft, /*IsDependent=*/false);
+    auto Mangled = GetDeclMangledName(VD, TargetABI, /*IsDependent=*/false);
     Var->Mangled = marshalString<E_UTF8>(Mangled);
 
     return Var;

src/Parser/Parser.h

@@ -38,12 +38,17 @@ public ref struct ParserOptions
     ParserOptions()
     {
         IncludeDirs = gcnew List<System::String^>();
+        SystemIncludeDirs = gcnew List<System::String^>();
         Defines = gcnew List<System::String^>();
         LibraryDirs = gcnew List<System::String^>();
+        MicrosoftMode = false;
+        NoStandardIncludes = false;
+        NoBuiltinIncludes = false;
     }
 
     // Include directories
     List<System::String^>^ IncludeDirs;
+    List<System::String^>^ SystemIncludeDirs;
     List<System::String^>^ Defines;
     List<System::String^>^ LibraryDirs;
 
@@ -54,6 +59,11 @@ public ref struct ParserOptions
 
     // Toolset version - 2005 - 8, 2008 - 9, 2010 - 10, 0 - autoprobe for any.
     int ToolSetToUse;
+    System::String^ TargetTriple;
+
+    bool NoStandardIncludes;
+    bool NoBuiltinIncludes;
+    bool MicrosoftMode;
 
     bool Verbose;
 };
@@ -146,6 +156,7 @@ protected:
     gcroot<ParserOptions^> Opts;
     llvm::OwningPtr<clang::CompilerInstance> C;
     clang::ASTContext* AST;
+    clang::TargetCXXABI::Kind TargetABI;
 };
 
 //-----------------------------------//