public override void Preprocess(Driver driver, ASTContext ctx)
{
driver.AddTranslationUnitPass(new GetterSetterToPropertyPass());
driver.AddTranslationUnitPass(new CheckMacroPass());
ctx.SetClassAsValueType("Bar");
ctx.SetClassAsValueType("Bar2");
}
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 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 override void Preprocess(Driver driver, ASTContext ctx)
{
ctx.SetClassAsValueType("Bar");
ctx.SetClassAsValueType("Bar2");
ctx.SetMethodParameterUsage("Hello", "TestPrimitiveOut", 1, ParameterUsage.Out);
ctx.SetMethodParameterUsage("Hello", "TestPrimitiveOutRef", 1, ParameterUsage.Out);
}
public virtual bool VisitASTContext(ASTContext context)
{
foreach (var unit in context.TranslationUnits)
VisitTranslationUnit(unit);
return true;
}
public override bool VisitLibrary(ASTContext context)
{
bool result = base.VisitLibrary(context);
Directory.CreateDirectory(Driver.Options.OutputDir);
WriteInlinesIncludes();
WriteInlinedSymbols();
return result;
}
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 virtual bool VisitLibrary(ASTContext context)
{
AstContext = context;
foreach (var unit in context.TranslationUnits)
VisitTranslationUnit(unit);
return true;
}
public override void Preprocess(Driver driver, ASTContext ctx)
{
ctx.SetClassAsValueType("TestCopyConstructorVal");
ctx.SetClassAsValueType("QGenericArgument");
ctx.SetClassAsValueType("StructWithPrivateFields");
ctx.SetClassAsValueType("QSize");
ctx.IgnoreClassWithName("IgnoredTypeInheritingNonIgnoredWithNoEmptyCtor");
}
public override void Preprocess(Driver driver, ASTContext ctx)
{
foreach (TranslationUnit unit in ctx.TranslationUnits)
{
if (unit.FileName != "NamespacesDerived.h")
{
unit.GenerationKind = GenerationKind.Link;
}
}
}
public override void Preprocess(Driver driver, ASTContext ctx)
{
driver.AddTranslationUnitPass(new CheckMacroPass());
ctx.SetClassAsValueType("Bar");
ctx.SetClassAsValueType("Bar2");
ctx.IgnoreClassWithName("IgnoredType");
ctx.FindCompleteClass("Foo").Enums.First(
e => string.IsNullOrEmpty(e.Name)).Name = "RenamedEmptyEnum";
}
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 override void Postprocess(Driver driver, ASTContext ctx)
{
// HACK: as seen above, GetterSetterToPropertyPass is called before all other passes
// that is a hack in order for the pass to generate properties in Common.h
// it is incapable of generating them in the proper manner
// so it generates a property in system type from a member which is later ignored
// so let's ignore that property manually
var @class = ctx.FindCompleteClass("basic_string");
foreach (var property in @class.Specializations.SelectMany(c => c.Properties))
property.ExplicitlyIgnore();
}
public override void Preprocess(Driver driver, ASTContext ctx)
{
driver.AddTranslationUnitPass(new GetterSetterToPropertyPass());
ctx.SetClassAsValueType("Bar");
ctx.SetClassAsValueType("Bar2");
ctx.SetMethodParameterUsage("Hello", "TestPrimitiveOut", 1, ParameterUsage.Out);
ctx.SetMethodParameterUsage("Hello", "TestPrimitiveOutRef", 1, ParameterUsage.Out);
ctx.SetMethodParameterUsage("Hello", "TestPrimitiveInOut", 1, ParameterUsage.InOut);
ctx.SetMethodParameterUsage("Hello", "TestPrimitiveInOutRef", 1, ParameterUsage.InOut);
ctx.SetMethodParameterUsage("Hello", "EnumOut", 2, ParameterUsage.Out);
ctx.SetMethodParameterUsage("Hello", "EnumOutRef", 2, ParameterUsage.Out);
}
public Driver(DriverOptions options, IDiagnosticConsumer diagnostics)
{
Options = options;
Diagnostics = diagnostics;
Project = new Project();
ASTContext = new ASTContext();
Symbols = new SymbolContext();
Delegates = new Dictionary<Function, DelegatesPass.DelegateDefinition>();
TypeDatabase = new TypeMapDatabase();
TranslationUnitPasses = new PassBuilder<TranslationUnitPass>(this);
GeneratorOutputPasses = new PassBuilder<GeneratorOutputPass>(this);
}
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";
}
}
}
protected void ParseLibrary(string file)
{
Options = new DriverOptions();
var testsPath = LibraryTest.GetTestsDirectory("Native");
Options.IncludeDirs.Add(testsPath);
Options.Headers.Add(file);
Driver = new Driver(Options, new TextDiagnosticPrinter());
if (!Driver.ParseCode())
throw new Exception("Error parsing the code");
AstContext = Driver.ASTContext;
}
public override bool VisitASTContext(ASTContext context)
{
bool result = base.VisitASTContext(context);
foreach (var typedef in allTypedefs)
{
foreach (var foo in typedef.Value)
{
foo.Context.Declarations.Add(foo.Declaration);
}
}
allTypedefs.Clear();
return result;
}
protected void ParseLibrary(params string[] files)
{
Options = new DriverOptions();
var testsPath = GeneratorTest.GetTestsDirectory("Native");
Options.addIncludeDirs(testsPath);
Options.Headers.AddRange(files);
Driver = new Driver(Options, new TextDiagnosticPrinter());
Driver.BuildParseOptions();
if (!Driver.ParseCode())
throw new Exception("Error parsing the code");
AstContext = Driver.ASTContext;
}
public override bool VisitLibrary(ASTContext context)
{
foreach (var library in Driver.Options.Libraries.Where(l => !libsDelegates.ContainsKey(l)))
libsDelegates.Add(library, new Dictionary<string, DelegateDefinition>());
var unit = context.TranslationUnits.Last(u => u.IsValid && u.IsGenerated &&
!u.IsSystemHeader && u.HasDeclarations);
namespaceDelegates = new Namespace { Name = DelegatesNamespace, Namespace = unit };
var result = base.VisitLibrary(context);
if (namespaceDelegates.Declarations.Count > 0)
unit.Declarations.Add(namespaceDelegates);
return result;
}
public override bool VisitLibrary(ASTContext library)
{
bool result = base.VisitLibrary(library);
string pro = string.Format("{0}.pro", this.Driver.Options.InlinesLibraryName);
string path = Path.Combine(this.Driver.Options.OutputDir, pro);
StringBuilder proBuilder = new StringBuilder();
proBuilder.Append("QT += widgets\n");
// HACK: work around https://bugreports.qt.io/browse/QTBUG-47569
if (this.Driver.Options.InlinesLibraryName.StartsWith("QtWidgets"))
{
proBuilder.Append("DEFINES += QT_NO_ACCESSIBILITY\n");
}
proBuilder.Append("QMAKE_CXXFLAGS += -fkeep-inline-functions -std=c++0x\n");
proBuilder.AppendFormat("TARGET = {0}\n", this.Driver.Options.InlinesLibraryName);
proBuilder.Append("TEMPLATE = lib\n");
proBuilder.AppendFormat("SOURCES += {0}\n", Path.ChangeExtension(pro, "cpp"));
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
proBuilder.Append("LIBS += -loleaut32 -lole32");
}
File.WriteAllText(path, proBuilder.ToString());
string error;
ProcessHelper.Run(this.qmake, string.Format("\"{0}\"", path), out error);
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
return false;
}
ProcessHelper.Run(this.make, "-f Makefile.Release", out error, true);
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
return false;
}
var parserOptions = new ParserOptions();
parserOptions.addLibraryDirs(Path.Combine(this.Driver.Options.OutputDir, "release"));
parserOptions.FileName = Path.GetFileName(string.Format("lib{0}.a", Path.GetFileNameWithoutExtension(pro)));
var parserResult = ClangParser.ParseLibrary(parserOptions);
if (parserResult.Kind == ParserResultKind.Success)
{
var nativeLibrary = CppSharp.ClangParser.ConvertLibrary(parserResult.Library);
this.Driver.Symbols.Libraries.Add(nativeLibrary);
this.Driver.Symbols.IndexSymbols();
}
return result;
}
public override bool VisitASTContext(ASTContext context)
{
foreach (var library in Options.Modules.SelectMany(m => m.Libraries))
libsDelegates[library] = new Dictionary<string, DelegateDefinition>();
var unit = context.TranslationUnits.GetGenerated().LastOrDefault();
if (unit == null)
return false;
var result = base.VisitASTContext(context);
foreach (var module in Options.Modules.Where(m => namespacesDelegates.ContainsKey(m)))
module.Units.Last(u => u.HasDeclarations).Declarations.Add(namespacesDelegates[module]);
return result;
}
public override bool VisitLibrary(ASTContext context)
{
var result = base.VisitLibrary(context);
foreach (var entry in movedClassTemplates)
{
foreach (var template in entry.Value)
{
foreach (var decl in new[] { template, template.TemplatedDecl })
{
int index = entry.Key.Declarations.IndexOf(decl.Namespace);
decl.Namespace.Declarations.Remove(decl);
decl.Namespace = entry.Key;
entry.Key.Declarations.Insert(index, decl);
}
}
}
return result;
}
public override bool VisitASTContext(ASTContext context)
{
string error;
const string qtVersionVariable = "QT_VERSION";
var qtVersion = ProcessHelper.Run(this.qmake, string.Format("-query {0}", qtVersionVariable), out error);
var qtVersionFile = Path.Combine(this.Context.Options.OutputDir, qtVersionVariable);
var qtVersionFileInfo = new FileInfo(qtVersionFile);
var text = string.Empty;
if (!qtVersionFileInfo.Exists || (text = File.ReadAllText(qtVersionFile)) != qtVersion)
{
File.WriteAllText(qtVersionFile, qtVersion);
qtVersionFileInfo = new FileInfo(qtVersionFile);
}
var dir = Platform.IsMacOS ? this.Context.Options.OutputDir : Path.Combine(this.Context.Options.OutputDir, "release");
foreach (var module in this.Context.Options.Modules)
{
var inlines = Path.GetFileName(string.Format("{0}{1}.{2}", Platform.IsWindows ? string.Empty : "lib",
module.InlinesLibraryName, Platform.IsMacOS ? "dylib" : "dll"));
var libFile = Path.Combine(dir, inlines);
var inlinesFileInfo = new FileInfo(libFile);
if (!inlinesFileInfo.Exists || qtVersionFileInfo.LastWriteTimeUtc > inlinesFileInfo.LastWriteTimeUtc)
{
if (!this.CompileInlines(module))
{
continue;
}
}
var parserOptions = new ParserOptions();
parserOptions.AddLibraryDirs(dir);
parserOptions.LibraryFile = inlines;
using (var parserResult = CppSharp.Parser.ClangParser.ParseLibrary(parserOptions))
{
if (parserResult.Kind == ParserResultKind.Success)
{
var nativeLibrary = CppSharp.ClangParser.ConvertLibrary(parserResult.Library);
this.Context.Symbols.Libraries.Add(nativeLibrary);
this.Context.Symbols.IndexSymbols();
parserResult.Library.Dispose();
}
}
}
return 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 override bool VisitLibrary(ASTContext library)
{
bool result = base.VisitLibrary(library);
string pro = string.Format("{0}.pro", this.Driver.Options.InlinesLibraryName);
string path = Path.Combine(this.Driver.Options.OutputDir, pro);
StringBuilder proBuilder = new StringBuilder();
proBuilder.Append("QMAKE_CXXFLAGS += -fkeep-inline-functions -std=c++0x\n");
proBuilder.AppendFormat("TARGET = {0}\n", Path.GetFileNameWithoutExtension(pro));
proBuilder.Append("TEMPLATE = lib\n");
string cpp = Path.ChangeExtension(pro, "cpp");
string inlinesCode = File.ReadAllText(cpp);
File.WriteAllText(cpp, inlinesCode.Replace("#include \"qatomic_msvc.h\"", string.Empty));
proBuilder.AppendFormat("SOURCES += {0}\n", cpp);
File.WriteAllText(path, proBuilder.ToString());
string error;
ProcessHelper.Run(this.qmake, string.Format("\"{0}\"", path), out error);
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
return false;
}
ProcessHelper.Run(this.make, "-f Makefile.Release", out error);
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
return false;
}
this.Driver.Options.LibraryDirs.Add(Path.Combine(this.Driver.Options.OutputDir, "release"));
this.Driver.Options.Libraries.Add(string.Format("lib{0}.a", Path.GetFileNameWithoutExtension(pro)));
this.Driver.ParseLibraries();
NativeLibrary inlines = this.Driver.Symbols.Libraries.Last();
foreach (string symbol in this.Driver.Symbols.Libraries.Take(
this.Driver.Symbols.Libraries.Count - 1).SelectMany(
nativeLibrary => nativeLibrary.Symbols))
{
inlines.Symbols.Remove(symbol);
}
this.Driver.Symbols.IndexSymbols();
return result;
}
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 Preprocess(Driver driver, ASTContext ctx)
{
ctx.IgnoreHeadersWithName("lldb/lldb-forward.h");
ctx.IgnoreHeadersWithName("lldb/API/SBDefines.h");
ctx.SetMethodParameterUsage("lldb::SBTarget", "Launch", 2, 2, ParameterUsage.Out);
ctx.SetMethodParameterUsage("lldb::SBTarget", "Launch", 10, 10, ParameterUsage.Out);
ctx.RemoveEnumItemsPrefix("lldb::StateType", "eState");
ctx.RemoveEnumItemsPrefix("lldb::LaunchFlags", "eLaunchFlag");
ctx.RemoveEnumItemsPrefix("lldb::RunMode", "e");
ctx.RemoveEnumItemsPrefix("lldb::ExpressionResults", "eExpression");
ctx.RemoveEnumItemsPrefix("lldb::SymbolContextItem", "eSymbolContext");
ctx.RemoveEnumItemsPrefix("lldb::InputReaderAction", "eInputReader");
ctx.RemoveEnumItemsPrefix("lldb::DynamicValueType", "e");
ctx.RemoveEnumItemsPrefix("lldb::InputReaderAction", "eInputReader");
ctx.RemoveEnumItemsPrefix("lldb::AccessType", "eAccess");
ctx.RemoveEnumItemsPrefix("lldb::CommandArgumentType", "eArgType");
ctx.RemoveEnumItemsPrefix("lldb::EmulateInstructionOptions", "eEmulateInstructionOption");
ctx.RemoveEnumItemsPrefix("lldb::TypeOptions", "eTypeOption");
ctx.RemoveEnumItemsPrefix("lldb::FrameComparison", "eFrameCompare");
ctx.RemoveEnumItemsPrefix("lldb::ExpressionEvaluationPhase", "eExpressionEvaluation");
ctx.RemoveEnumItemsPrefix("lldb::TypeFlags", "eType");
ctx.RemoveEnumItemsPrefix("lldb::CommandFlags", "eCommand");
ctx.RemoveEnumItemsPrefix("lldb::TypeSummaryCapping", "eTypeSummary");
ctx.SetNameOfClassMethod("lldb::SBError", "GetError", "GetErrorCode");
ctx.SetNameOfClassMethod("lldb::SBValue", "GetValue", "GetValueAsString");
ctx.GenerateEnumFromMacros("BreakpointId", "LLDB_BREAK_*", "LLDB_INVALID_BREAK_ID",
"LLDB_DEFAULT_BREAK_SIZE");
ctx.GenerateEnumFromMacros("WatchpointId", "LLDB_WATCH_*", "LLDB_INVALID_WATCH_ID");
ctx.GenerateEnumFromMacros("GenericRegister", "LLDB_REGNUM_GENERIC_*");
ctx.GenerateEnumFromMacros("InvalidValue", "LLDB_INVALID_*");
ctx.GenerateEnumFromMacros("CPUType", "LLDB_ARCH_*", "LLDB_INVALID_CPUTYPE");
ctx.GenerateEnumFromMacros("OptionSet", "LDB_OPT_SET_*", "LLDB_MAX_NUM_OPTION_SETS");
ctx.RenameNamespace("lldb", "LLDB");
}
public static void SetNameOfFunction(this ASTContext context, string name, string newName)
{
foreach (var function in context.FindFunction(name))
function.Name = newName;
}
public void Preprocess(Driver driver, ASTContext lib)
{
foreach (var unit in lib.TranslationUnits.Where(u => u.IsValid))
{
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
if (lib.FindCompleteClass("QGraphicsItem") != null)
{
lib.FindCompleteClass("QGraphicsItem").FindEnum("Extension").Access = AccessSpecifier.Public;
}
if (lib.FindCompleteClass("QAbstractSlider") != null)
{
lib.FindCompleteClass("QAbstractSlider").FindEnum("SliderChange").Access = AccessSpecifier.Public;
}
if (lib.FindCompleteClass("QAbstractItemView") != null)
{
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
where lib.FindCompleteClass(@class) != null
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);
if (@class != null)
{
var drawItems = @class.Methods.FirstOrDefault(m => m.OriginalName == "drawItems");
if (drawItems != null)
{
drawItems.ExplicitlyIgnore();
}
}
}
if (lib.FindCompleteClass("QAbstractPlanarVideoBuffer") != null)
{
lib.FindCompleteClass("QAbstractPlanarVideoBuffer").ExplicitlyIgnore();
}
var qAbstractVideoBuffer = lib.FindCompleteClass("QAbstractVideoBuffer");
if (qAbstractVideoBuffer != null)
{
var mapPlanes = qAbstractVideoBuffer.Methods.FirstOrDefault(m => m.OriginalName == "mapPlanes");
if (mapPlanes != null)
{
mapPlanes.ExplicitlyIgnore();
}
}
}
public void Preprocess(Driver driver, ASTContext ctx)
{
//throw new NotImplementedException();
}
public void Preprocess(ASTContext ctx)
{
Driver.TypePrinter = new LibLLVMTypePrinter(Driver.Context);
return;
}
public override void Postprocess(Driver driver, ASTContext ctx)
{
new CaseRenamePass(
RenameTargets.Function | RenameTargets.Method | RenameTargets.Property | RenameTargets.Delegate | RenameTargets.Variable,
RenameCasePattern.UpperCamelCase).VisitLibrary(driver.ASTContext);
}
public static void SetClassAsValueType(this ASTContext context, string className)
{
foreach (var @class in context.FindClass(className))
@class.Type = ClassType.ValueType;
}
public static void SetClassAsOpaque(this ASTContext context, string name)
{
foreach (var @class in context.FindClass(name))
@class.IsOpaque = true;
}
/// <summary>
/// Sets the parameter usage for a method parameter.
/// </summary>
/// <param name="parameterIndex">first parameter has index 1</param>
public static void SetMethodParameterUsage(this ASTContext context,
string className, string methodName, int parameterIndex, ParameterUsage usage)
{
SetMethodParameterUsage(context, className, methodName, -1, parameterIndex, usage);
}
private bool VerifyAnonymousEnums(ASTContext context)
{
bool retVal = true;
foreach (var anonEnum in Configuration.AnonymousEnums)
{
var typeDefs = context.FindTypedef(anonEnum.Value).ToList();
if (typeDefs.Count == 0)
{
retVal = false;
Diagnostics.Warning("typedef {0} for anonymous enum not found in source"
, anonEnum.Value
);
}
else if (typeDefs.Count > 1)
{
retVal = false;
Diagnostics.Warning("Multiple type definitions for Anonymous enum ({0},{1}) found in source"
, anonEnum.Key
, anonEnum.Value
);
foreach (var td in typeDefs)
{
Diagnostics.Warning("\t{0} in {1}@{2}", td.Name, td.TranslationUnit.FileRelativePath, td.LineNumberStart);
}
}
/*At this point: typdefs.Count == 1 && typedefs[0] is the matching type - so good to go on that front */
var sourceEnums = (from unit in context.TranslationUnits
let @enum = unit.FindEnumWithItem(anonEnum.Key)
where @enum != null
select @enum
).ToList();
if (sourceEnums.Count == 0)
{
retVal = false;
Diagnostics.Warning("no enum found in source with first item matching {0}"
, anonEnum.Key
);
}
else if (sourceEnums.Count > 1)
{
retVal = false;
Diagnostics.Warning("Multiple enums found in source with first item matching {0}"
, anonEnum.Key
);
foreach (var e in sourceEnums)
{
Diagnostics.Warning("\t{1}@{2}", e.TranslationUnit.FileRelativePath, e.LineNumberStart);
}
}
else if (!string.IsNullOrEmpty(sourceEnums[0].Name))
{
retVal = false;
var wrongEnum = sourceEnums[0];
Diagnostics.Warning("Found enum {0} in {1}@{2} with value {3} but expected an anonymous enum"
, wrongEnum.Name
, wrongEnum.TranslationUnit.FileRelativePath
, wrongEnum.LineNumberStart
, anonEnum.Key
);
}
}
return(retVal);
}
public void Preprocess(Driver driver, ASTContext ctx)
{
ctx.RenameNamespace("CppSharp::CppParser", "Parser");
}
public override void Preprocess(Driver driver, ASTContext ctx)
{
ctx.SetClassAsValueType("TestCopyConstructorVal");
}
public virtual void Postprocess(Driver driver, ASTContext lib)
{
}
public override bool VisitLibrary(ASTContext context)
{
WriteInlinesIncludes();
return(true);
}
public static void IgnoreFunctionWithName(this ASTContext context, string name)
{
foreach (var function in context.FindFunction(name))
function.ExplicitlyIgnore();
}
public static Enumeration Enum(this ASTContext context, string name)
{
return(context.FindEnum(name).ToList().First());
}
public override Type CSharpSignatureType(TypePrinterContext ctx)
{
return(new TagType(flags ?? (flags = ASTContext.FindEnum("Flags").First())));
}
public static void IgnoreClassWithName(this ASTContext context, string name)
{
foreach (var @class in context.FindClass(name))
@class.GenerationKind = GenerationKind.Internal;
}
public static Class Class(this ASTContext context, string name)
{
return(context.FindClass(name).ToList().First());
}
public static void SetClassBindName(this ASTContext context, string className, string name)
{
foreach (var @class in context.FindClass(className))
@class.Name = name;
}
public static TypedefDecl Typedef(this ASTContext context, string name)
{
return(context.FindTypedef(name).ToList().First());
}
public void Postprocess(ASTContext ctx)
{
return;
}
public static void IgnoreEnumWithMatchingItem(this ASTContext context, string pattern)
{
Enumeration @enum = context.GetEnumWithMatchingItem(pattern);
if (@enum != null)
@enum.ExplicitlyIgnore();
}
public static Function Function(this ASTContext context, string name)
{
return(context.FindFunction(name).ToList().First());
}
public static void IgnoreHeadersWithName(this ASTContext context, IEnumerable<string> patterns)
{
foreach(var pattern in patterns)
context.IgnoreHeadersWithName(pattern);
}
public override bool VisitFunctionDecl(Function function)
{
if (!function.IsGenerated)
{
return(false);
}
var types = StringHelpers.SplitCamelCase(function.Name);
if (types.Length == 0)
{
return(false);
}
var @class = ASTContext.FindCompleteClass(types[0]);
if (@class == null)
{
return(false);
}
// TODO: If the translation units of the declarations are different,
// and we apply the pass, we might need additional includes in the
// generated translation unit of the class.
if (@class.TranslationUnit != function.TranslationUnit)
{
return(false);
}
// Clean up the name of the function now that it will be a static method.
var name = function.Name.Substring(@class.Name.Length);
function.ExplicitlyIgnore();
// Create a new fake method so it acts as a static method.
var method = new Method
{
Namespace = @class,
OriginalNamespace = function.Namespace,
Name = name,
OriginalName = function.OriginalName,
Mangled = function.Mangled,
Access = AccessSpecifier.Public,
Kind = CXXMethodKind.Normal,
ReturnType = function.ReturnType,
CallingConvention = function.CallingConvention,
IsVariadic = function.IsVariadic,
IsInline = function.IsInline,
IsStatic = true,
Conversion = MethodConversionKind.FunctionToStaticMethod
};
method.Parameters.AddRange(function.Parameters.Select(
p => new Parameter(p)
{
Namespace = method
}));
@class.Methods.Add(method);
Diagnostics.Debug("Function converted to static method: {0}::{1}",
@class.Name, function.Name);
return(true);
}
public static IEnumerable <Function> FindFunction(this ASTContext context, string name)
{
return(context.TranslationUnits
.Select(module => module.FindFunction(name))
.Where(function => function != null));
}
public void Postprocess(Driver driver, ASTContext ctx)
{
}
public void Preprocess(Driver driver, ASTContext lib)
{
foreach (var unit in lib.TranslationUnits.Where(u => u.IsValid))
{
IgnorePrivateDeclarations(unit);
}
lib.FindFunction("QtSharedPointer::weakPointerFromVariant_internal").First().ExplicitlyIgnore();
lib.FindFunction("QtSharedPointer::sharedPointerFromVariant_internal").First().ExplicitlyIgnore();
// 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();
}
foreach (var template in lib.FindDecl <ClassTemplate>("QList"))
{
var qListQVariant = template.Specializations.FirstOrDefault(
s =>
{
var type = s.Arguments[0].Type.Type;
if (type == null)
{
return(false);
}
Class @class;
return(s.Arguments[0].Type.Type.TryGetClass(out @class) && @class.Name == "QVariant");
});
if (qListQVariant != null)
{
qListQVariant.Methods.First(m => m.OriginalName == "toSet").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";
}
}
public virtual void Preprocess(Driver driver, ASTContext ctx)
{
}
public ASTGenerator(ASTContext context, Options options)
{
ASTContext = context;
Options = options;
}
