Example #1
0
        static void DumpClasses(TextWriter writer, ASTContext ctx, IEnumerable <string> types,
                                bool optional = false)
        {
            foreach (var @struct in types)
            {
                var @class = ctx.FindCompleteClass(@struct);
                if (@class == null)
                {
                    @class = ctx.FindCompleteClass("_" + @struct);
                }

                if (@class == null)
                {
                    var typedef = ctx.FindTypedef(@struct).FirstOrDefault(
                        decl => !decl.IsIncomplete);

                    if (typedef != null)
                    {
                        @class = GetClassFromTypedef(typedef);
                    }
                }

                if (@class == null && optional)
                {
                    continue;
                }

                if (@class == null)
                {
                    throw new Exception("Expected to find struct definition for " + @struct);
                }

                DumpStruct(writer, @class);
            }
        }
Example #2
0
        public static void CopyClassFields(this ASTContext context, string source,
            string destination)
        {
            var @class = context.FindCompleteClass(source);
            var dest = context.FindCompleteClass(destination);

            dest.Fields.AddRange(@class.Fields);
            foreach (var field in dest.Fields)
                field.Namespace = dest;
        }
        private void EnsureCompleteDeclaration(Declaration declaration)
        {
            if (!declaration.IsIncomplete)
            {
                return;
            }

            if (declaration.CompleteDeclaration != null)
            {
                return;
            }

            declaration.CompleteDeclaration =
                ASTContext.FindCompleteClass(declaration.QualifiedName);

            var @class = declaration as Class;

            if (CheckForDuplicateForwardClass(@class))
            {
                return;
            }

            if (declaration.CompleteDeclaration == null)
            {
                declaration.GenerationKind = GenerationKind.Internal;
                Diagnostics.Debug("Unresolved declaration: {0}",
                                  declaration.Name);
            }
        }
Example #4
0
        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,
                Parameters        = function.Parameters,
                CallingConvention = function.CallingConvention,
                IsVariadic        = function.IsVariadic,
                IsInline          = function.IsInline,
                IsStatic          = true,
                Conversion        = MethodConversionKind.FunctionToStaticMethod
            };

            @class.Methods.Add(method);

            Diagnostics.Debug("Function converted to static method: {0}::{1}",
                              @class.Name, function.Name);

            return(true);
        }
        private void EnsureCompleteDeclaration(Declaration declaration)
        {
            if (!declaration.IsIncomplete)
                return;

            if (declaration.CompleteDeclaration != null)
                return;

            var @class = declaration as Class;
            var redecls = @class?.Redeclarations;
            if (@class != null && @class.IsOpaque)
            {
                if (redecls.Count == 0 ||
                   (redecls.Last() == @class && !redecls.Exists(decl => !decl.IsIncomplete)))
                    return;
                duplicateClasses.Add(@class);
            }
                
            
            declaration.CompleteDeclaration =
                ASTContext.FindCompleteClass(declaration.QualifiedName);

            if (declaration.CompleteDeclaration == null)
            {
                declaration.GenerationKind = GenerationKind.Internal;
                Diagnostics.Debug("Unresolved declaration: {0}",
                    declaration.Name);
            }
        }
Example #6
0
        /// <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 parameterCount, int parameterIndex,
                                                   ParameterUsage usage)
        {
            if (parameterIndex <= 0)
            {
                throw new ArgumentException("parameterIndex");
            }

            var @class = context.FindCompleteClass(className);

            Method method;

            if (parameterCount >= 0)
            {
                method = @class.Methods.Find(m => m.Name == methodName &&
                                             m.Parameters.Count == parameterCount);
            }
            else
            {
                method = @class.Methods.Find(m => m.Name == methodName);
            }

            if (method == null)
            {
                throw new ArgumentException("methodName");
            }

            if (method.Parameters.Count < parameterIndex)
            {
                throw new ArgumentException("parameterIndex");
            }

            method.Parameters[parameterIndex - 1].Usage = usage;
        }
Example #7
0
        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");

            lib.FindCompleteClass("QString").GenerationKind = GenerationKind.Internal;
        }
Example #8
0
        private Class FindClassToMoveFunctionTo(Function function)
        {
            Class @class = null;

            if (function.IsOperator)
            {
                foreach (var param in function.Parameters)
                {
                    if (FunctionToInstanceMethodPass.GetClassParameter(param, out @class))
                    {
                        break;
                    }
                }
                if (@class == null)
                {
                    function.ExplicitlyIgnore();
                }
            }
            else
            {
                var unit = function.Namespace as TranslationUnit;
                @class = unit == null
                    ? ASTContext.FindClass(
                    function.Namespace.Name, ignoreCase : true).FirstOrDefault()
                    : ASTContext.FindCompleteClass(
                    unit.FileNameWithoutExtension.ToLowerInvariant(), true);
            }

            return(@class);
        }
Example #9
0
        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));
            }
        }
Example #10
0
        public override void Preprocess(Driver driver, ASTContext ctx)
        {
            ctx.SetClassAsValueType("Bar");
            ctx.SetClassAsValueType("Bar2");
            ctx.IgnoreClassWithName("IgnoredType");

            ctx.FindCompleteClass("Foo").Enums.First(
                e => string.IsNullOrEmpty(e.Name)).Name = "RenamedEmptyEnum";
        }
Example #11
0
        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";
        }
Example #12
0
 public override void Preprocess(Driver driver, ASTContext ctx)
 {
     ctx.IgnoreClassWithName("Ignored");
     // operator= for this type isn't necessary for testing
     // while also requiring a large amount of C++ to get valid symbols; better ignore
     foreach (Method @operator in ctx.FindCompleteClass("StdFields").Operators)
     {
         @operator.ExplicitlyIgnore();
     }
 }
Example #13
0
        public override void Preprocess(Driver driver, ASTContext ctx)
        {
            driver.AddTranslationUnitPass(new GetterSetterToPropertyPass());
            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";
        }
Example #14
0
        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;
        }
        private Class FindClassToMoveFunctionTo(INamedDecl @namespace)
        {
            var unit = @namespace as TranslationUnit;

            if (unit == null)
            {
                return(ASTContext.FindClass(
                           @namespace.Name, ignoreCase: true).FirstOrDefault());
            }
            return(ASTContext.FindCompleteClass(
                       unit.FileNameWithoutExtension.ToLowerInvariant(), true));
        }
Example #16
0
        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));
            }
        }
Example #17
0
        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;
        }
Example #18
0
        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();
            }
        }
        private void EnsureCompleteDeclaration(Declaration declaration)
        {
            if (!declaration.IsIncomplete)
            {
                return;
            }

            if (declaration.CompleteDeclaration != null)
            {
                return;
            }

            declaration.CompleteDeclaration =
                ASTContext.FindCompleteClass(declaration.QualifiedName);

            if (declaration.CompleteDeclaration != null)
            {
                return;
            }

            if (Context.ParserOptions.UnityBuild)
            {
                if (declaration.IsGenerated)
                {
                    foreach (var redecl in declaration.Redeclarations)
                    {
                        redecl.GenerationKind = GenerationKind.None;
                    }
                }
                return;
            }

            var @class = declaration as Class;

            if (CheckForDuplicateForwardClass(@class))
            {
                return;
            }

            if (declaration.IsGenerated)
            {
                declaration.GenerationKind = GenerationKind.Internal;
            }
            Diagnostics.Debug("Unresolved declaration: {0}",
                              declaration.Name);
        }
        public override bool VisitMethodDecl(Method method)
        {
            if (method.DebugText.StartsWith(ExportMacroName))
            {
                return(base.VisitMethodDecl(method));
            }

            method.GenerationKind = GenerationKind.None;

            var @class = ASTContext.FindCompleteClass(method.QualifiedLogicalName.Split(new String[] { "::" }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault());

            if (@class == null)
            {
                return(false);
            }

            VisitClassDecl(@class);

            return(false);
        }
Example #21
0
 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;
     }
 }
Example #22
0
 public override void Preprocess(Driver driver, ASTContext ctx)
 {
     ctx.SetClassAsValueType("HasQList");
     ctx.FindCompleteClass("QList").Constructors.First(c => c.IsCopyConstructor).GenerationKind = GenerationKind.None;
     ctx.IgnoreClassWithName("IgnoredType");
 }
Example #23
0
        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";
            }
        }
        static void DumpClasses(TextWriter writer, ASTContext ctx, IEnumerable<string> types,
            bool optional = false)
        {
            foreach (var @struct in types)
            {
                var @class = ctx.FindCompleteClass(@struct);
                if (@class == null)
                    @class = ctx.FindCompleteClass("_" + @struct);

                if (@class == null)
                {
                    var typedef = ctx.FindTypedef(@struct).FirstOrDefault(
                        decl => !decl.IsIncomplete);

                    if (typedef != null)
                        @class = GetClassFromTypedef(typedef);
                }

                if (@class == null && optional)
                    continue;

                if (@class == null)
                    throw new Exception("Expected to find struct definition for " + @struct);

                DumpStruct(writer, @class);
            }
        }
Example #25
0
        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
            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();
            }
        }
Example #26
0
        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();
            }
        }
Example #27
0
 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";
         }
     }
 }
Example #28
0
 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();
 }
Example #29
0
 public override void Preprocess(Driver driver, ASTContext ctx)
 {
     ctx.SetClassAsValueType("HasQList");
     ctx.FindCompleteClass("QList").Constructors.First(c => c.IsCopyConstructor).GenerationKind = GenerationKind.None;
     ctx.IgnoreClassWithName("IgnoredType");
 }