public void Preprocess(Driver driver, ASTContext ctx)
{
ctx.IgnoreEnumWithMatchingItem("SDL_FALSE");
ctx.IgnoreEnumWithMatchingItem("DUMMY_ENUM_VALUE");
ctx.SetNameOfEnumWithMatchingItem("SDL_SCANCODE_UNKNOWN", "ScanCode");
ctx.SetNameOfEnumWithMatchingItem("SDLK_UNKNOWN", "Key");
ctx.SetNameOfEnumWithMatchingItem("KMOD_NONE", "KeyModifier");
ctx.SetNameOfEnumWithMatchingItem("SDL_LOG_CATEGORY_CUSTOM", "LogCategory");
ctx.GenerateEnumFromMacros("InitFlags", "SDL_INIT_(.*)").SetFlags();
ctx.GenerateEnumFromMacros("Endianness", "SDL_(.*)_ENDIAN");
ctx.GenerateEnumFromMacros("InputState", "SDL_RELEASED", "SDL_PRESSED");
ctx.GenerateEnumFromMacros("AlphaState", "SDL_ALPHA_(.*)");
ctx.GenerateEnumFromMacros("HatState", "SDL_HAT_(.*)");
ctx.IgnoreHeadersWithName("SDL_atomic*");
ctx.IgnoreHeadersWithName("SDL_endian*");
ctx.IgnoreHeadersWithName("SDL_main*");
ctx.IgnoreHeadersWithName("SDL_mutex*");
ctx.IgnoreHeadersWithName("SDL_stdinc*");
ctx.IgnoreHeadersWithName("SDL_error");
ctx.IgnoreEnumWithMatchingItem("SDL_ENOMEM");
ctx.IgnoreFunctionWithName("SDL_Error");
}
public static void Run(ILibrary library)
{
var options = new DriverOptions();
var Log = new TextDiagnosticPrinter();
var driver = new Driver(options, Log);
library.Setup(driver);
driver.Setup();
if(driver.Options.Verbose)
Log.Level = DiagnosticKind.Debug;
if (!options.Quiet)
Log.EmitMessage("Parsing libraries...");
if (!driver.ParseLibraries())
return;
if (!options.Quiet)
Log.EmitMessage("Indexing library symbols...");
driver.Symbols.IndexSymbols();
if (!options.Quiet)
Log.EmitMessage("Parsing code...");
if (!driver.ParseCode())
return;
if (!options.Quiet)
Log.EmitMessage("Processing code...");
library.Preprocess(driver, driver.ASTContext);
driver.SetupPasses(library);
driver.ProcessCode();
library.Postprocess(driver, driver.ASTContext);
if (!options.Quiet)
Log.EmitMessage("Generating code...");
var outputs = driver.GenerateCode();
foreach (var output in outputs)
{
foreach (var pass in driver.GeneratorOutputPasses.Passes)
{
pass.Driver = driver;
pass.VisitGeneratorOutput(output);
}
}
if (!driver.Options.DryRun)
driver.WriteCode(outputs);
if (driver.Options.IsCSharpGenerator)
driver.CompileCode();
}
public void Preprocess(Driver driver, ASTContext lib)
{
string qtModule = "Qt" + this.module;
string moduleIncludes = Path.Combine(this.includePath, qtModule);
foreach (TranslationUnit unit in lib.TranslationUnits.Where(u => u.FilePath != "<invalid>"))
{
if (Path.GetDirectoryName(unit.FilePath) != moduleIncludes)
{
unit.ExplicityIgnored = true;
}
else
{
IgnorePrivateDeclarations(unit);
}
}
lib.SetClassAsValueType("QByteArray");
lib.SetClassAsValueType("QListData");
lib.SetClassAsValueType("QListData::Data");
lib.SetClassAsValueType("QLocale");
lib.SetClassAsValueType("QModelIndex");
lib.SetClassAsValueType("QPoint");
lib.SetClassAsValueType("QPointF");
lib.SetClassAsValueType("QSize");
lib.SetClassAsValueType("QSizeF");
lib.SetClassAsValueType("QRect");
lib.SetClassAsValueType("QRectF");
lib.SetClassAsValueType("QGenericArgument");
lib.SetClassAsValueType("QVariant");
// TODO: remove these when their symbols have been replaced or included
lib.IgnoreClassMethodWithName("QXmlStreamReader", "attributes");
lib.IgnoreClassMethodWithName("QTimeZone", "offsetData");
lib.IgnoreClassMethodWithName("QTimeZone", "nextTransition");
lib.IgnoreClassMethodWithName("QTimeZone", "previousTransition");
}
public void Setup(Driver driver)
{
var options = driver.Options;
options.LibraryName = "CppSharp";
options.DryRun = true;
options.Headers.AddRange(new string[]
{
"clang/AST/Expr.h",
});
options.SetupXcode();
options.MicrosoftMode = false;
options.TargetTriple = "i686-apple-darwin12.4.0";
options.addDefines ("__STDC_LIMIT_MACROS");
options.addDefines ("__STDC_CONSTANT_MACROS");
var llvmPath = Path.Combine (GetSourceDirectory ("deps"), "llvm");
var clangPath = Path.Combine(llvmPath, "tools", "clang");
options.addIncludeDirs(Path.Combine(llvmPath, "include"));
options.addIncludeDirs(Path.Combine(llvmPath, "build", "include"));
options.addIncludeDirs (Path.Combine (llvmPath, "build", "tools", "clang", "include"));
options.addIncludeDirs(Path.Combine(clangPath, "include"));
}
public void SetupPasses(Driver driver)
{
driver.TranslationUnitPasses.RemovePrefix("SDL_");
driver.TranslationUnitPasses.RemovePrefix("SCANCODE_");
driver.TranslationUnitPasses.RemovePrefix("SDLK_");
driver.TranslationUnitPasses.RemovePrefix("KMOD_");
driver.TranslationUnitPasses.RemovePrefix("LOG_CATEGORY_");
}
public void Setup(Driver driver)
{
var options = driver.Options;
options.LibraryName = "SDL";
options.Headers.Add("SDL.h");
options.addIncludeDirs("../../../examples/SDL/SDL-2.0/include");
options.OutputDir = "SDL";
}
public void Preprocess(Driver driver, ASTContext lib)
{
lib.SetClassAsValueType("CppSharp::ParserOptions");
lib.SetClassAsValueType("CppSharp::ParserDiagnostic");
lib.SetClassAsValueType("CppSharp::ParserResult");
lib.RenameNamespace("CppSharp::CppParser", "Parser");
}
public void Setup(Driver driver)
{
var options = driver.Options;
options.LibraryName = "SDL";
options.Headers.Add("SDL.h");
var sdlPath = Path.Combine(GetExamplesDirectory("SDL"), "SDL-2.0/include");
options.addIncludeDirs(sdlPath);
options.OutputDir = "SDL";
}
public void Postprocess(Driver driver, ASTContext lib)
{
CollectTypeDefsPerTypePass collectTypeDefsPerTypePass = new CollectTypeDefsPerTypePass();
collectTypeDefsPerTypePass.VisitLibrary(driver.ASTContext);
new ClearCommentsPass().VisitLibrary(driver.ASTContext);
new GetCommentsFromQtDocsPass(this.docs, this.module, collectTypeDefsPerTypePass.TypeDefsPerType).VisitLibrary(driver.ASTContext);
new CaseRenamePass(
RenameTargets.Function | RenameTargets.Method | RenameTargets.Property | RenameTargets.Delegate | RenameTargets.Field,
RenameCasePattern.UpperCamelCase).VisitLibrary(driver.ASTContext);
}
public void Preprocess(Driver driver, ASTContext ctx)
{
ctx.RenameNamespace("CppSharp::CppParser", "Parser");
var exprClass = ctx.FindCompleteClass ("clang::Expr");
var exprUnit = ctx.TranslationUnits [0];
var subclassVisitor = new SubclassVisitor (exprClass);
exprUnit.Visit (subclassVisitor);
var subclasses = subclassVisitor.Classes;
}
public void Postprocess(Driver driver, ASTContext ctx)
{
ctx.SetNameOfEnumWithName("PIXELTYPE", "PixelType");
ctx.SetNameOfEnumWithName("BITMAPORDER", "BitmapOrder");
ctx.SetNameOfEnumWithName("PACKEDORDER", "PackedOrder");
ctx.SetNameOfEnumWithName("ARRAYORDER", "ArrayOrder");
ctx.SetNameOfEnumWithName("PACKEDLAYOUT", "PackedLayout");
ctx.SetNameOfEnumWithName("PIXELFORMAT", "PixelFormats");
ctx.SetNameOfEnumWithName("assert_state", "AssertState");
ctx.SetClassBindName("assert_data", "AssertData");
ctx.SetNameOfEnumWithName("eventaction", "EventAction");
ctx.SetNameOfEnumWithName("LOG_CATEGORY", "LogCategory");
}
public void Preprocess(Driver driver, ASTContext lib)
{
var qtModule = "Qt" + this.module;
var moduleIncludes = Path.Combine(this.includePath, qtModule);
foreach (var unit in lib.TranslationUnits.Where(u => u.FilePath != "<invalid>"))
{
if (Path.GetDirectoryName(unit.FilePath) != moduleIncludes)
{
LinkDeclaration(unit);
}
else
{
IgnorePrivateDeclarations(unit);
}
}
lib.SetClassAsValueType("QByteArray");
lib.SetClassAsValueType("QListData");
lib.SetClassAsValueType("QListData::Data");
lib.SetClassAsValueType("QLocale");
lib.SetClassAsValueType("QModelIndex");
lib.SetClassAsValueType("QPoint");
lib.SetClassAsValueType("QPointF");
lib.SetClassAsValueType("QSize");
lib.SetClassAsValueType("QSizeF");
lib.SetClassAsValueType("QRect");
lib.SetClassAsValueType("QRectF");
lib.SetClassAsValueType("QGenericArgument");
lib.SetClassAsValueType("QGenericReturnArgument");
lib.SetClassAsValueType("QVariant");
lib.IgnoreClassMethodWithName("QString", "fromStdWString");
lib.IgnoreClassMethodWithName("QString", "toStdWString");
if (this.module == "Widgets")
{
// HACK: work around https://llvm.org/bugs/show_bug.cgi?id=24655
foreach (var method in lib.FindCompleteClass("QAbstractSlider").Methods.Where(m => m.Access == AccessSpecifier.Protected))
{
method.AccessDecl.PreprocessedEntities.Clear();
}
string[] classesWithTypeEnums =
{
"QGraphicsEllipseItem", "QGraphicsItemGroup", "QGraphicsLineItem",
"QGraphicsPathItem", "QGraphicsPixmapItem", "QGraphicsPolygonItem", "QGraphicsProxyWidget",
"QGraphicsRectItem", "QGraphicsSimpleTextItem", "QGraphicsTextItem", "QGraphicsWidget"
};
foreach (var enumeration in classesWithTypeEnums.Select(c => lib.FindCompleteClass(c)).SelectMany(
@class => @class.Enums.Where(e => string.IsNullOrEmpty(e.Name))))
{
enumeration.Name = "TypeEnum";
}
}
}
void ILibrary.Setup(Driver driver)
{
// 现在先写死的路径,以方便 测试功能是否使,后面真正用到时,再写命令行来更灵活的处理绑定吧
// 估计以后要区分 32位与64位
// 擦: 现在的 CppSharp 只支持32位,估计以后可能支持吧
var options = driver.Options;
options.GeneratorKind = GeneratorKind.CSharp;
options.LibraryName = "Common";
options.Headers.Add(@"D:\GitSourceCode\TempCode\XunLongJiMobileServer\Common\Include\TestExportClass.h");
options.Libraries.Add(@"D:\GitSourceCode\TempCode\XunLongJiMobileServer\Lib/Win32/Debug\Common.lib");
options.ShowHelpText = true;
options.OutputDir = @"d:\CppWrapper";
options.OutputNamespace = "XLJCommon";
}
public void Setup(Driver driver)
{
var options = driver.Options;
options.LibraryName = "CppSharp.CppParser.dll";
options.GeneratorKind = Kind;
options.Headers.Add("AST.h");
options.Headers.Add("CppParser.h");
var basePath = Path.Combine(GetSourceDirectory(), "CppParser");
options.IncludeDirs.Add(basePath);
options.Libraries.Add("CppSharp.CppParser.lib");
options.LibraryDirs.Add(".");
options.OutputDir = "../../../../src/CppParser/Bindings/";
options.OutputDir += Kind.ToString();
options.GenerateLibraryNamespace = false;
options.CheckSymbols = false;
}
public void Preprocess(Driver driver, Library lib)
{
// FBase.h is just an aggregrating header file, which also contains
// a block-comment for the Base namespace. We don't need to generate
// any code for it.
lib.IgnoreHeadersWithName("FBase.h");
// We are mapping Tizen::Base::String to a standard .NET string class,
// so don't need to generate any code for that either.
//lib.IgnoreHeadersWithName("FBaseString.h");
// Don't know why we are ignoring these. Ask Joao.
//lib.IgnoreHeadersWithName("FBaseObject.h");
//lib.IgnoreHeadersWithName("FOspCompat.h");
//lib.IgnoreClassWithName("Tizen::Base::Object");
}
public void Setup(Driver driver)
{
var parserOptions = driver.ParserOptions;
parserOptions.TargetTriple = Triple;
parserOptions.Abi = Abi;
var options = driver.Options;
options.LibraryName = "CppSharp.CppParser";
options.SharedLibraryName = "CppSharp.CppParser.dll";
options.GeneratorKind = Kind;
options.Headers.AddRange(new[]
{
"AST.h",
"Sources.h",
"CppParser.h"
});
options.Libraries.Add("CppSharp.CppParser.lib");
if (Abi == CppAbi.Microsoft)
parserOptions.MicrosoftMode = true;
if (Triple.Contains("apple"))
SetupMacOptions(parserOptions);
if (Triple.Contains("linux"))
SetupLinuxOptions(parserOptions);
var basePath = Path.Combine(GetSourceDirectory("src"), "CppParser");
parserOptions.AddIncludeDirs(basePath);
parserOptions.AddLibraryDirs(".");
options.OutputDir = Path.Combine(GetSourceDirectory("src"), "CppParser",
"Bindings", Kind.ToString());
var extraTriple = IsGnuCpp11Abi ? "-cxx11abi" : string.Empty;
if (Kind == GeneratorKind.CSharp)
options.OutputDir = Path.Combine(options.OutputDir, parserOptions.TargetTriple + extraTriple);
options.OutputNamespace = string.Empty;
options.CheckSymbols = false;
//options.Verbose = true;
options.UnityBuild = true;
}
public void Postprocess(Driver driver, ASTContext lib)
{
new ClearCommentsPass().VisitLibrary(driver.ASTContext);
new GetCommentsFromQtDocsPass(this.docs, this.module).VisitLibrary(driver.ASTContext);
new CaseRenamePass(
RenameTargets.Function | RenameTargets.Method | RenameTargets.Property | RenameTargets.Delegate |
RenameTargets.Field | RenameTargets.Variable,
RenameCasePattern.UpperCamelCase).VisitLibrary(driver.ASTContext);
switch (this.module)
{
case "Core":
var qChar = lib.FindCompleteClass("QChar");
qChar.FindOperator(CXXOperatorKind.ExplicitConversion)
.First(o => o.Parameters[0].Type.IsPrimitiveType(PrimitiveType.Char))
.ExplicitlyIgnore();
qChar.FindOperator(CXXOperatorKind.Conversion)
.First(o => o.Parameters[0].Type.IsPrimitiveType(PrimitiveType.Int))
.ExplicitlyIgnore();
break;
}
}
public static void Main(string[] args)
{
ParseCommandLineArgs(args);
Console.WriteLine();
Console.WriteLine("Parsing Mono's source code...");
var options = new DriverOptions();
var log = new TextDiagnosticPrinter();
var driver = new Driver(options, log);
Setup(driver);
driver.Setup();
BuildParseOptions(driver);
if (!driver.ParseCode())
return;
Check(driver.ASTContext);
}
public void Postprocess(Driver driver, ASTContext lib)
{
new ClearCommentsPass().VisitASTContext(driver.Context.ASTContext);
var modules = this.qtInfo.LibFiles.Select(l => GetModuleNameFromLibFile(l));
var s = System.Diagnostics.Stopwatch.StartNew();
new GetCommentsFromQtDocsPass(this.qtInfo.Docs, modules).VisitASTContext(driver.Context.ASTContext);
System.Console.WriteLine("Documentation done in: {0}", s.Elapsed);
new CaseRenamePass(
RenameTargets.Function | RenameTargets.Method | RenameTargets.Property | RenameTargets.Delegate |
RenameTargets.Field | RenameTargets.Variable,
RenameCasePattern.UpperCamelCase).VisitASTContext(driver.Context.ASTContext);
var qChar = lib.FindCompleteClass("QChar");
var op = qChar.FindOperator(CXXOperatorKind.ExplicitConversion)
.FirstOrDefault(o => o.Parameters[0].Type.IsPrimitiveType(PrimitiveType.Char));
if (op != null)
op.ExplicitlyIgnore();
op = qChar.FindOperator(CXXOperatorKind.Conversion)
.FirstOrDefault(o => o.Parameters[0].Type.IsPrimitiveType(PrimitiveType.Int));
if (op != null)
op.ExplicitlyIgnore();
// QString is type-mapped to string so we only need two methods for the conversion
// go through the methods a second time to ignore free operators moved to the class
var qString = lib.FindCompleteClass("QString");
foreach (var method in qString.Methods.Where(
m => !m.Ignore && m.OriginalName != "utf16" && m.OriginalName != "fromUtf16"))
{
method.ExplicitlyIgnore();
}
foreach (var module in driver.Options.Modules)
{
var prefix = Platform.IsWindows ? string.Empty : "lib";
var extension = Platform.IsWindows ? ".dll" : Platform.IsMacOS ? ".dylib" : ".so";
var inlinesLibraryFile = string.Format("{0}{1}{2}", prefix, module.InlinesLibraryName, extension);
var inlinesLibraryPath = Path.Combine(driver.Options.OutputDir, Platform.IsWindows ? "release" : string.Empty, inlinesLibraryFile);
this.wrappedModules.Add(new KeyValuePair<string, string>(module.LibraryName + ".dll", inlinesLibraryPath));
}
}
public void Setup(Driver driver)
{
var options = driver.Options;
options.TargetTriple = Triple;
options.Abi = Abi;
options.LibraryName = "CppSharp.CppParser.dll";
options.GeneratorKind = Kind;
options.Headers.AddRange(new[]
{
"AST.h",
"Sources.h",
"CppParser.h"
});
options.Libraries.Add("CppSharp.CppParser.lib");
if (Abi == CppAbi.Microsoft)
options.MicrosoftMode = true;
if (Triple.Contains("apple"))
SetupMacOptions(options);
if (Triple.Contains("linux"))
SetupLinuxOptions(options);
var basePath = Path.Combine(GetSourceDirectory("src"), "CppParser");
options.addIncludeDirs(basePath);
options.addLibraryDirs(".");
options.OutputDir = Path.Combine(GetSourceDirectory("src"), "CppParser",
"Bindings", Kind.ToString());
if (Kind == GeneratorKind.CSharp)
options.OutputDir = Path.Combine(options.OutputDir, options.TargetTriple);
options.GenerateLibraryNamespace = false;
options.CheckSymbols = false;
}
static void SetupAndroidNDK(Driver driver, Target target)
{
var options = driver.Options;
var parserOptions = driver.ParserOptions;
var builtinsPath = GetAndroidBuiltinIncludesFolder();
parserOptions.AddSystemIncludeDirs(builtinsPath);
var androidNdkRoot = GetAndroidNdkPath ();
const int androidNdkApiLevel = 21;
var toolchainPath = Path.Combine(androidNdkRoot, "platforms",
"android-" + androidNdkApiLevel, "arch-" + GetArchFromTriple(target.Triple),
"usr", "include");
parserOptions.AddSystemIncludeDirs(toolchainPath);
parserOptions.NoBuiltinIncludes = true;
parserOptions.NoStandardIncludes = true;
parserOptions.TargetTriple = target.Triple;
}
static void SetupXcode(Driver driver, Target target)
{
var parserOptions = driver.ParserOptions;
var builtinsPath = GetXcodeBuiltinIncludesFolder();
string includePath;
switch (target.Platform) {
case TargetPlatform.iOS:
includePath = GetXcodeiOSIncludesFolder();
break;
case TargetPlatform.WatchOS:
includePath = GetXcodeWatchOSIncludesFolder();
break;
default:
throw new ArgumentOutOfRangeException ();
}
parserOptions.AddSystemIncludeDirs(builtinsPath);
parserOptions.AddSystemIncludeDirs(includePath);
parserOptions.NoBuiltinIncludes = true;
parserOptions.NoStandardIncludes = true;
parserOptions.TargetTriple = target.Triple;
}
static void SetupToolchainPaths(Driver driver, Target target)
{
switch (target.Platform) {
case TargetPlatform.Android:
SetupAndroidNDK(driver, target);
break;
case TargetPlatform.iOS:
case TargetPlatform.WatchOS:
SetupXcode(driver, target);
break;
default:
throw new ArgumentOutOfRangeException ();
}
}
static void SetupMSVC(Driver driver, string triple)
{
var parserOptions = driver.ParserOptions;
parserOptions.Abi = Parser.AST.CppAbi.Microsoft;
parserOptions.MicrosoftMode = true;
var systemIncludeDirs = new[]
{
@"C:\Program Files (x86)\Windows Kits\8.1\Include\um",
@"C:\Program Files (x86)\Windows Kits\8.1\Include\shared"
};
foreach (var inc in systemIncludeDirs)
parserOptions.AddSystemIncludeDirs(inc);
parserOptions.AddDefines("HOST_WIN32");
}
static void SetupMono(Driver driver, Target target)
{
string targetPath;
switch (target.Platform) {
case TargetPlatform.Android:
targetPath = Path.Combine (MonodroidDir, XamarinAndroid ? "build-tools/mono-runtimes/obj/Debug" : "builds");
break;
case TargetPlatform.WatchOS:
case TargetPlatform.iOS:
targetPath = Path.Combine (MaccoreDir, "builds");
break;
default:
throw new ArgumentOutOfRangeException ();
}
if (!Directory.Exists (MonoDir)) {
MonoDir = Path.GetFullPath (Path.Combine (targetPath, "../../mono"));
}
var targetBuild = Path.Combine(targetPath, target.Build);
if (!Directory.Exists(targetBuild))
throw new Exception(string.Format("Could not find the target build directory: {0}", targetBuild));
var includeDirs = new[]
{
targetBuild,
Path.Combine(targetBuild, "eglib", "src"),
MonoDir,
Path.Combine(MonoDir, "mono"),
Path.Combine(MonoDir, "mono", "mini"),
Path.Combine(MonoDir, "eglib", "src")
};
foreach (var inc in includeDirs)
driver.ParserOptions.AddIncludeDirs(inc);
var filesToParse = new[]
{
Path.Combine(MonoDir, "mono", "metadata", "metadata-cross-helpers.c"),
Path.Combine(MonoDir, "mono", "mini", "mini-cross-helpers.c"),
};
foreach (var file in filesToParse)
driver.Options.Headers.Add(file);
}
static void Setup(Driver driver, Target target)
{
var options = driver.Options;
options.DryRun = true;
options.LibraryName = "Mono";
var parserOptions = driver.ParserOptions;
parserOptions.Verbose = false;
parserOptions.MicrosoftMode = false;
parserOptions.AddArguments("-xc");
parserOptions.AddArguments("-std=gnu99");
parserOptions.AddDefines("CPPSHARP");
foreach (var define in target.Defines)
parserOptions.AddDefines(define);
SetupToolchainPaths(driver, target);
SetupMono(driver, target);
}
static void BuildParseOptions(Driver driver, Target target)
{
foreach (var header in driver.Options.Headers)
{
var source = driver.Project.AddFile(header);
source.Options = driver.BuildParserOptions(source);
if (header.Contains ("mini"))
continue;
source.Options.AddDefines ("HAVE_SGEN_GC");
source.Options.AddDefines ("HAVE_MOVING_COLLECTOR");
}
}
public static void Main(string[] args)
{
ParseCommandLineArgs(args);
string monodroidDir;
if (!Directory.Exists (MonodroidDir) &&
GetParentSubDirectoryPath ("monodroid", out monodroidDir)) {
MonodroidDir = Path.Combine (monodroidDir);
}
if (Directory.Exists (MonodroidDir))
SetupAndroidTargets();
string maccoreDir;
if (!Directory.Exists (MaccoreDir) &&
GetParentSubDirectoryPath ("maccore", out maccoreDir)) {
MaccoreDir = Path.Combine (maccoreDir);
}
if (Directory.Exists(MaccoreDir))
SetupiOSTargets();
foreach (var target in Targets)
{
if (Abis.Any() && !Abis.Any (target.Triple.Contains))
continue;
Console.WriteLine();
Console.WriteLine("Processing triple: {0}", target.Triple);
var options = new DriverOptions();
var log = new TextDiagnosticPrinter();
var driver = new Driver(options, log);
Setup(driver, target);
driver.Setup();
BuildParseOptions(driver, target);
if (!driver.ParseCode())
return;
Dump(driver.Context.ASTContext, driver.Context.TargetInfo, target);
}
}
public void Preprocess(Driver driver, ASTContext lib)
{
foreach (var unit in lib.TranslationUnits.Where(u => u.IsValid))
{
// HACK: work around https://github.com/mono/CppSharp/issues/677
if (unit.FileName == "locale_classes.tcc" || unit.FileName == "locale_facets.tcc")
{
unit.ExplicitlyIgnore();
}
else
{
IgnorePrivateDeclarations(unit);
}
}
// QString is type-mapped to string so we only need two methods for the conversion
var qString = lib.FindCompleteClass("QString");
foreach (var @class in qString.Declarations)
{
@class.ExplicitlyIgnore();
}
foreach (var method in qString.Methods.Where(m => m.OriginalName != "utf16" && m.OriginalName != "fromUtf16"))
{
method.ExplicitlyIgnore();
}
// HACK: work around https://github.com/mono/CppSharp/issues/594
lib.FindCompleteClass("QGraphicsItem").FindEnum("Extension").Access = AccessSpecifier.Public;
lib.FindCompleteClass("QAbstractSlider").FindEnum("SliderChange").Access = AccessSpecifier.Public;
lib.FindCompleteClass("QAbstractItemView").FindEnum("CursorAction").Access = AccessSpecifier.Public;
lib.FindCompleteClass("QAbstractItemView").FindEnum("State").Access = AccessSpecifier.Public;
lib.FindCompleteClass("QAbstractItemView").FindEnum("DropIndicatorPosition").Access = AccessSpecifier.Public;
var classesWithTypeEnums = new[]
{
"QGraphicsEllipseItem", "QGraphicsItemGroup", "QGraphicsLineItem",
"QGraphicsPathItem", "QGraphicsPixmapItem", "QGraphicsPolygonItem",
"QGraphicsProxyWidget", "QGraphicsRectItem", "QGraphicsSimpleTextItem",
"QGraphicsTextItem", "QGraphicsWidget", "QGraphicsSvgItem"
};
foreach (var enumeration in from @class in classesWithTypeEnums
from @enum in lib.FindCompleteClass(@class).Enums
where string.IsNullOrEmpty(@enum.Name)
select @enum)
{
enumeration.Name = "TypeEnum";
}
// HACK: work around https://github.com/mono/CppSharp/issues/692
foreach (var name in new[] { "QImage", "QPixmap" })
{
var @class = lib.FindCompleteClass(name);
var ctorWithArray = @class.Constructors.FirstOrDefault(
c => c.Parameters.Count == 1 && c.Parameters[0].Type.Desugar() is ArrayType);
if (ctorWithArray != null)
{
ctorWithArray.ExplicitlyIgnore();
}
}
foreach (var name in new[] { "QGraphicsScene", "QGraphicsView" })
{
var @class = lib.FindCompleteClass(name);
var drawItems = @class.Methods.FirstOrDefault(m => m.OriginalName == "drawItems");
if (drawItems != null)
{
drawItems.ExplicitlyIgnore();
}
}
lib.FindCompleteClass("QAbstractPlanarVideoBuffer").ExplicitlyIgnore();
var qAbstractVideoBuffer = lib.FindCompleteClass("QAbstractVideoBuffer");
var mapPlanes = qAbstractVideoBuffer.Methods.FirstOrDefault(m => m.OriginalName == "mapPlanes");
if (mapPlanes != null)
{
mapPlanes.ExplicitlyIgnore();
}
}
public void SetupPasses(Driver driver)
{
driver.Context.TranslationUnitPasses.AddPass(new CompileInlinesPass(this.qtInfo.QMake, this.qtInfo.Make));
driver.Context.TranslationUnitPasses.AddPass(new GenerateSignalEventsPass(driver.Generator));
driver.Context.TranslationUnitPasses.AddPass(new GenerateEventEventsPass(driver.Generator));
driver.Context.TranslationUnitPasses.AddPass(new RemoveQObjectMembersPass());
}
