gobject-introspection 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32

data/vendor/local/lib/gobject-introspection/giscanner/collections/__init__.py

@@ -18,6 +18,10 @@
 # 02110-1301, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 
 from .counter import Counter
 from .ordereddict import OrderedDict

data/vendor/local/lib/gobject-introspection/giscanner/collections/ordereddict.py

@@ -30,9 +30,20 @@
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 
+import sys
+
+
+py2k = sys.version_info < (3, 0)
+
+
 class OrderedDict(dict):
     """A dict that returns keys/values/items in the order they were added."""
 
+    __slots__ = '_list',
+
+    def __reduce__(self):
+        return OrderedDict, (self.items(),)
+
     def __init__(self, ____sequence=None, **kwargs):
         self._list = []
         if ____sequence is None:
@@ -75,25 +86,26 @@ class OrderedDict(dict):
     def __iter__(self):
         return iter(self._list)
 
+    def keys(self):
+        return list(self)
+
     def values(self):
         return [self[key] for key in self._list]
 
-    def itervalues(self):
-        return iter([self[key] for key in self._list])
-
-    def keys(self):
-        return list(self._list)
+    def items(self):
+        return [(key, self[key]) for key in self._list]
 
-    def iterkeys(self):
-        return iter(self.keys())
+    if py2k:
+        def itervalues(self):
+            return iter(self.values())
 
-    def items(self):
-        return [(key, self[key]) for key in self.keys()]
+        def iterkeys(self):
+            return iter(self)
 
-    def iteritems(self):
-        return iter(self.items())
+        def iteritems(self):
+            return iter(self.items())
 
-    def __setitem__(self, key, obj):
+    def __setitem__(self, key, object):
         if key not in self:
             try:
                 self._list.append(key)
@@ -101,7 +113,7 @@ class OrderedDict(dict):
                 # work around Python pickle loads() with
                 # dict subclass (seems to ignore __setstate__?)
                 self._list = [key]
-        dict.__setitem__(self, key, obj)
+        dict.__setitem__(self, key, object)
 
     def __delitem__(self, key):
         dict.__delitem__(self, key)

data/vendor/local/lib/gobject-introspection/giscanner/docmain.py

@@ -18,8 +18,13 @@
 # 02110-1301, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import os
-import optparse
+import argparse
 
 from .docwriter import DocWriter
 from .sectionparser import generate_sections_file, write_sections_file
@@ -27,46 +32,43 @@ from .transformer import Transformer
 
 
 def doc_main(args):
-    parser = optparse.OptionParser('%prog [options] GIR-file')
+    parser = argparse.ArgumentParser()
 
-    parser.add_option("-o", "--output",
+    parser.add_argument("girfile")
+    parser.add_argument("-o", "--output",
                       action="store", dest="output",
                       help="Directory to write output to")
-    parser.add_option("-l", "--language",
+    parser.add_argument("-l", "--language",
                       action="store", dest="language",
                       default="c",
                       help="Output language")
-    parser.add_option("", "--add-include-path",
+    parser.add_argument("-I", "--add-include-path",
                       action="append", dest="include_paths", default=[],
                       help="include paths for other GIR files")
-    parser.add_option("", "--write-sections-file",
+    parser.add_argument("-s", "--write-sections-file",
                       action="store_true", dest="write_sections",
                       help="Generate and write out a sections file")
 
-    options, args = parser.parse_args(args)
-    if not options.output:
+    args = parser.parse_args(args[1:])
+    if not args.output:
         raise SystemExit("missing output parameter")
 
-    if len(args) < 2:
-        raise SystemExit("Need an input GIR filename")
-
     if 'UNINSTALLED_INTROSPECTION_SRCDIR' in os.environ:
         top_srcdir = os.environ['UNINSTALLED_INTROSPECTION_SRCDIR']
         top_builddir = os.environ['UNINSTALLED_INTROSPECTION_BUILDDIR']
         extra_include_dirs = [os.path.join(top_srcdir, 'gir'), top_builddir]
     else:
         extra_include_dirs = []
-    extra_include_dirs.extend(options.include_paths)
-    transformer = Transformer.parse_from_gir(args[1], extra_include_dirs)
+    extra_include_dirs.extend(args.include_paths)
+    transformer = Transformer.parse_from_gir(args.girfile, extra_include_dirs)
 
-    if options.write_sections:
+    if args.write_sections:
         sections_file = generate_sections_file(transformer)
 
-        fp = open(options.output, 'w')
-        write_sections_file(fp, sections_file)
-        fp.close()
+        with open(args.output, 'w') as fp:
+            write_sections_file(fp, sections_file)
     else:
-        writer = DocWriter(transformer, options.language)
-        writer.write(options.output)
+        writer = DocWriter(transformer, args.language)
+        writer.write(args.output)
 
     return 0

data/vendor/local/lib/gobject-introspection/giscanner/docwriter.py

@@ -21,6 +21,11 @@
 # 02110-1301, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import os
 import re
 import tempfile
@@ -131,7 +136,7 @@ class TemplatedScanner(object):
         groupdict = match.groupdict()
         properties = {name: groupdict.pop(name)}
         name = name + "_"
-        for group, value in groupdict.iteritems():
+        for group, value in groupdict.items():
             if group.startswith(name):
                 key = group[len(name):]
                 properties[key] = value
@@ -349,7 +354,7 @@ class DocFormatter(object):
 
     def format_xref(self, node, **attrdict):
         if node is None or not hasattr(node, 'namespace'):
-            attrs = [('xref', 'index')] + attrdict.items()
+            attrs = [('xref', 'index')] + list(sorted(attrdict.items()))
             return xmlwriter.build_xml_tag('link', attrs)
         elif isinstance(node, ast.Member):
             # Enum/BitField members are linked to the main enum page.
@@ -360,14 +365,14 @@ class DocFormatter(object):
             return self.format_external_xref(node, attrdict)
 
     def format_internal_xref(self, node, attrdict):
-        attrs = [('xref', make_page_id(node))] + attrdict.items()
+        attrs = [('xref', make_page_id(node))] + list(sorted(attrdict.items()))
         return xmlwriter.build_xml_tag('link', attrs)
 
     def format_external_xref(self, node, attrdict):
         ns = node.namespace
         attrs = [('href', '../%s-%s/%s.html' % (ns.name, str(ns.version),
                                                 make_page_id(node)))]
-        attrs += attrdict.items()
+        attrs += list(sorted(attrdict.items()))
         return xmlwriter.build_xml_tag('link', attrs, self.format_page_name(node))
 
     def field_is_writable(self, field):
@@ -435,7 +440,7 @@ class DocFormatter(object):
         node_name = node.namespace.name + '.' + node.name
         impl = []
 
-        for c in node.namespace.itervalues():
+        for c in node.namespace.values():
             if not isinstance(c, ast.Class):
                 continue
             for implemented in c.interfaces:
@@ -601,8 +606,8 @@ class DocFormatterGjs(DocFormatterIntrospectableBase):
         default_constructor = None
 
         introspectable_constructors = \
-            filter(lambda c: getattr(c, 'introspectable', True),
-                   node.constructors)
+            list(filter(lambda c: getattr(c, 'introspectable', True),
+                   node.constructors))
         for c in introspectable_constructors:
             if zero_args_constructor is None and \
                len(c.parameters) == 0:
@@ -859,12 +864,11 @@ class DocFormatterGjs(DocFormatterIntrospectableBase):
             if isinstance(node, ast.Compound):
                 fields = filter(self.field_is_writable, node.fields)
                 out = ''
-                if len(fields) > 0:
-                    out += "{\n"
-                    for f in fields:
-                        out += "    <link xref='%s.%s-%s'>%s</link>: value\n" % \
-                               (node.namespace.name, node.name, f.name, f.name)
-                    out += "}"
+                for f in fields:
+                    out += "    <link xref='%s.%s-%s'>%s</link>: value\n" % \
+                           (node.namespace.name, node.name, f.name, f.name)
+                if out:
+                    out = "{\n" + out + "}"
                 return out
             else:
                 return ''
@@ -953,6 +957,5 @@ class DocWriter(object):
 
         output_file_name = os.path.join(os.path.abspath(output),
                                         page_id + '.page')
-        fp = open(output_file_name, 'w')
-        fp.write(result)
-        fp.close()
+        with open(output_file_name, 'wb') as fp:
+            fp.write(result)

data/vendor/local/lib/gobject-introspection/giscanner/dumper.py

@@ -19,11 +19,17 @@
 # Boston, MA 02111-1307, USA.
 #
 
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
 import os
 import sys
 import subprocess
 import shutil
 import tempfile
+from distutils.errors import LinkError
 
 from .gdumpparser import IntrospectionBinary
 from . import utils
@@ -78,25 +84,24 @@ class LinkerError(Exception):
 
 class DumpCompiler(object):
 
+    _compiler = None
+
     def __init__(self, options, get_type_functions, error_quark_functions):
         self._options = options
         self._get_type_functions = get_type_functions
         self._error_quark_functions = error_quark_functions
 
-        self._compiler_cmd = os.environ.get('CC', 'cc')
-        self._linker_cmd = os.environ.get('CC', self._compiler_cmd)
+        # Acquire the compiler (and linker) commands via the CCompiler class in ccompiler.py
+        self._compiler = CCompiler()
+
         self._pkgconfig_cmd = os.environ.get('PKG_CONFIG', 'pkg-config')
-        self._pkgconfig_msvc_flags = ''
-        # Enable the --msvc-syntax pkg-config flag when
-        # the Microsoft compiler is used
-        # (This is the other way to check whether Visual C++ is used subsequently)
-        args = self._compiler_cmd.split()
-        if 'cl.exe' in args or 'cl' in args:
-            self._pkgconfig_msvc_flags = '--msvc-syntax'
-        self._uninst_srcdir = os.environ.get(
-            'UNINSTALLED_INTROSPECTION_SRCDIR')
+        self._uninst_srcdir = os.environ.get('UNINSTALLED_INTROSPECTION_SRCDIR')
         self._packages = ['gio-2.0 gmodule-2.0']
         self._packages.extend(options.packages)
+        if hasattr(self._compiler.compiler, 'linker_exe'):
+            self._linker_cmd = self._compiler.compiler.linker_exe
+        else:
+            self._linker_cmd = []
 
     # Public API
 
@@ -114,68 +119,59 @@ class DumpCompiler(object):
                                       'gdump.c')
         if not os.path.isfile(gdump_path):
             raise SystemExit("Couldn't find %r" % (gdump_path, ))
-        gdump_file = open(gdump_path)
-        gdump_contents = gdump_file.read()
-        gdump_file.close()
+        with open(gdump_path) as gdump_file:
+            gdump_contents = gdump_file.read()
         tpl_args['gdump_include'] = gdump_contents
         tpl_args['init_sections'] = "\n".join(self._options.init_sections)
 
         c_path = self._generate_tempfile(tmpdir, '.c')
-        f = open(c_path, 'w')
-        f.write(_PROGRAM_TEMPLATE % tpl_args)
-
-        # We need to reference our get_type and error_quark functions
-        # to make sure they are pulled in at the linking stage if the
-        # library is a static library rather than a shared library.
-        if len(self._get_type_functions) > 0:
-            for func in self._get_type_functions:
-                f.write("extern GType " + func + "(void);\n")
-            f.write("GType (*GI_GET_TYPE_FUNCS_[])(void) = {\n")
-            first = True
-            for func in self._get_type_functions:
-                if first:
-                    first = False
-                else:
-                    f.write(",\n")
-                f.write("  " + func)
-            f.write("\n};\n")
-        if len(self._error_quark_functions) > 0:
-            for func in self._error_quark_functions:
-                f.write("extern GQuark " + func + "(void);\n")
-            f.write("GQuark (*GI_ERROR_QUARK_FUNCS_[])(void) = {\n")
-            first = True
-            for func in self._error_quark_functions:
-                if first:
-                    first = False
-                else:
-                    f.write(",\n")
-                f.write("  " + func)
-            f.write("\n};\n")
-        f.close()
-
-        # Microsoft compilers generate intermediate .obj files
-        # during compilation, unlike .o files like GCC and others
-        if self._pkgconfig_msvc_flags:
-            o_path = self._generate_tempfile(tmpdir, '.obj')
-        else:
-            o_path = self._generate_tempfile(tmpdir, '.o')
-
-        if os.name == 'nt':
-            ext = '.exe'
+        with open(c_path, 'w') as f:
+            f.write(_PROGRAM_TEMPLATE % tpl_args)
+
+            # We need to reference our get_type and error_quark functions
+            # to make sure they are pulled in at the linking stage if the
+            # library is a static library rather than a shared library.
+            if len(self._get_type_functions) > 0:
+                for func in self._get_type_functions:
+                    f.write("extern GType " + func + "(void);\n")
+                f.write("GType (*GI_GET_TYPE_FUNCS_[])(void) = {\n")
+                first = True
+                for func in self._get_type_functions:
+                    if first:
+                        first = False
+                    else:
+                        f.write(",\n")
+                    f.write("  " + func)
+                f.write("\n};\n")
+            if len(self._error_quark_functions) > 0:
+                for func in self._error_quark_functions:
+                    f.write("extern GQuark " + func + "(void);\n")
+                f.write("GQuark (*GI_ERROR_QUARK_FUNCS_[])(void) = {\n")
+                first = True
+                for func in self._error_quark_functions:
+                    if first:
+                        first = False
+                    else:
+                        f.write(",\n")
+                    f.write("  " + func)
+                f.write("\n};\n")
+
+        if self._compiler.compiler.exe_extension:
+            ext = self._compiler.compiler.exe_extension
         else:
             ext = ''
 
         bin_path = self._generate_tempfile(tmpdir, ext)
 
         try:
-            self._compile(o_path, c_path)
+            introspection_obj = self._compile(c_path)
         except CompilerError as e:
             if not utils.have_debug_flag('save-temps'):
                 shutil.rmtree(tmpdir)
             raise SystemExit('compilation of temporary binary failed:' + str(e))
 
         try:
-            self._link(bin_path, o_path)
+            self._link(bin_path, introspection_obj)
         except LinkerError as e:
             if not utils.have_debug_flag('save-temps'):
                 shutil.rmtree(tmpdir)
@@ -193,143 +189,137 @@ class DumpCompiler(object):
     def _run_pkgconfig(self, flag):
         # Enable the --msvc-syntax pkg-config flag when
         # the Microsoft compiler is used
-        if self._pkgconfig_msvc_flags:
-            cmd = [self._pkgconfig_cmd, self._pkgconfig_msvc_flags, flag]
+        if self._compiler.check_is_msvc():
+            cmd = [self._pkgconfig_cmd, '--msvc-syntax', flag]
         else:
             cmd = [self._pkgconfig_cmd, flag]
         proc = subprocess.Popen(
             cmd + self._packages,
             stdout=subprocess.PIPE)
-        return proc.communicate()[0].split()
-
-    def _compile(self, output, *sources):
-        # Not strictly speaking correct, but easier than parsing shell
-        args = self._compiler_cmd.split()
-        # Do not add -Wall when using init code as we do not include any
-        # header of the library being introspected
-        if self._compiler_cmd == 'gcc' and not self._options.init_sections:
-            args.append('-Wall')
-        # The Microsoft compiler uses different option flags for
-        # silencing warnings on deprecated function usage
-        if self._pkgconfig_msvc_flags:
-            args.append("-wd4996")
-        else:
-            args.append("-Wno-deprecated-declarations")
+        out, err = proc.communicate()
+        return out.decode('ascii').split()
+
+    def _compile(self, *sources):
         pkgconfig_flags = self._run_pkgconfig('--cflags')
-        args.extend([utils.cflag_real_include_path(f) for f in pkgconfig_flags])
-        cppflags = os.environ.get('CPPFLAGS', '')
-        for cppflag in cppflags.split():
-            args.append(cppflag)
-        cflags = os.environ.get('CFLAGS', '')
-        for cflag in cflags.split():
-            args.append(cflag)
-        for include in self._options.cpp_includes:
-            args.append('-I' + include)
-        # The Microsoft compiler uses different option flags for
-        # compilation result output
-        if self._pkgconfig_msvc_flags:
-            args.extend(['-c', '-Fe' + output, '-Fo' + output])
-        else:
-            args.extend(['-c', '-o', output])
-        for source in sources:
-            if not os.path.exists(source):
-                raise CompilerError(
-                    "Could not find c source file: %s" % (source, ))
-        args.extend(list(sources))
-        if not self._options.quiet:
-            print "g-ir-scanner: compile: %s" % (
-                subprocess.list2cmdline(args), )
-            sys.stdout.flush()
-        try:
-            subprocess.check_call(args)
-        except subprocess.CalledProcessError as e:
-            raise CompilerError(e)
+        return self._compiler.compile(pkgconfig_flags,
+                                      self._options.cpp_includes,
+                                      sources,
+                                      self._options.init_sections)
 
-    def _link(self, output, *sources):
+    def _link(self, output, sources):
         args = []
         libtool = utils.get_libtool_command(self._options)
         if libtool:
+            # Note: MSVC Builds do not use libtool!
+            # In the libtool case, put together the linker command, as we did before.
+            # We aren't using distutils to link in this case.
             args.extend(libtool)
             args.append('--mode=link')
             args.append('--tag=CC')
             if self._options.quiet:
                 args.append('--silent')
 
-        args.extend(self._linker_cmd.split())
-        # We can use -o for the Microsoft compiler/linker,
-        # but it is considered deprecated usage with that
-        if self._pkgconfig_msvc_flags:
-            args.extend(['-Fe' + output])
-        else:
+            args.extend(self._linker_cmd)
+
             args.extend(['-o', output])
-        if libtool:
             if os.name == 'nt':
                 args.append('-Wl,--export-all-symbols')
             else:
                 args.append('-export-dynamic')
 
-        cppflags = os.environ.get('CPPFLAGS', '')
-        for cppflag in cppflags.split():
-            args.append(cppflag)
-        cflags = os.environ.get('CFLAGS', '')
-        for cflag in cflags.split():
-            args.append(cflag)
-        ldflags = os.environ.get('LDFLAGS', '')
-        for ldflag in ldflags.split():
-            args.append(ldflag)
+        if not self._compiler.check_is_msvc():
+            # These envvars are not used for MSVC Builds!
+            # MSVC Builds use the INCLUDE, LIB envvars,
+            # which are automatically picked up during
+            # compilation and linking
+            cppflags = os.environ.get('CPPFLAGS', '')
+            for cppflag in cppflags.split():
+                args.append(cppflag)
+            cflags = os.environ.get('CFLAGS', '')
+            for cflag in cflags.split():
+                args.append(cflag)
+            ldflags = os.environ.get('LDFLAGS', '')
+            for ldflag in ldflags.split():
+                args.append(ldflag)
 
         # Make sure to list the library to be introspected first since it's
         # likely to be uninstalled yet and we want the uninstalled RPATHs have
         # priority (or we might run with installed library that is older)
-
         for source in sources:
             if not os.path.exists(source):
                 raise CompilerError(
                     "Could not find object file: %s" % (source, ))
-        args.extend(list(sources))
 
-        cc = CCompiler()
+        if libtool:
+            args.extend(sources)
+
+        pkg_config_libs = self._run_pkgconfig('--libs')
 
         if not self._options.external_library:
-            cc.get_internal_link_flags(args,
-                                       libtool,
-                                       self._options.libraries,
-                                       self._options.library_paths,
-                                       self._pkgconfig_msvc_flags,
-                                       self._options.namespace_name,
-                                       self._options.namespace_version)
-            args.extend(self._run_pkgconfig('--libs'))
+            self._compiler.get_internal_link_flags(args,
+                                                   libtool,
+                                                   self._options.libraries,
+                                                   self._options.library_paths)
+            args.extend(pkg_config_libs)
 
         else:
-            args.extend(self._run_pkgconfig('--libs'))
-            cc.get_external_link_flags(args,
-                                       self._options.libraries,
-                                       self._pkgconfig_msvc_flags)
-
-        if not self._options.quiet:
-            print "g-ir-scanner: link: %s" % (
-                subprocess.list2cmdline(args), )
-            sys.stdout.flush()
-        msys = os.environ.get('MSYSTEM', None)
-        if msys:
-            shell = os.environ.get('SHELL', 'sh.exe')
-            # Create a temporary script file that
-            # runs the command we want
-            tf, tf_name = tempfile.mkstemp()
-            f = os.fdopen(tf, 'wb')
-            shellcontents = ' '.join([x.replace('\\', '/') for x in args])
-            fcontents = '#!/bin/sh\nunset PWD\n{}\n'.format(shellcontents)
-            f.write(fcontents)
-            f.close()
-            shell = utils.which(shell)
-            args = [shell, tf_name.replace('\\', '/')]
-        try:
-            subprocess.check_call(args)
-        except subprocess.CalledProcessError as e:
-            raise LinkerError(e)
-        finally:
+            args.extend(pkg_config_libs)
+            self._compiler.get_external_link_flags(args,
+                                                   libtool,
+                                                   self._options.libraries)
+
+        if not libtool:
+            # non-libtool: prepare distutils for linking the introspection
+            # dumper program...
+            try:
+                self._compiler.link(output,
+                                    sources,
+                                    args)
+
+            # Ignore failing to embed the manifest files, when the manifest
+            # file does not exist, especially for MSVC 2010 and later builds.
+            # If we are on Visual C++ 2005/2008, where
+            # this embedding is required, the build will fail anyway, as
+            # the dumper program will likely fail to run, and this means
+            # something went wrong with the build.
+            except LinkError as e:
+                if self._compiler.check_is_msvc():
+                    msg = str(e)
+
+                    if msg[msg.rfind('mt.exe'):] == 'mt.exe\' failed with exit status 31':
+                        if sys.version_info < (3, 0):
+                            sys.exc_clear()
+                        pass
+                    else:
+                        raise LinkError(e)
+                else:
+                    raise LinkError(e)
+        else:
+            # libtool: Run the assembled link command, we don't use distutils
+            # for linking here.
+            if not self._options.quiet:
+                print("g-ir-scanner: link: %s" % (
+                    subprocess.list2cmdline(args), ))
+                sys.stdout.flush()
+            msys = os.environ.get('MSYSTEM', None)
             if msys:
-                os.remove(tf_name)
+                shell = os.environ.get('SHELL', 'sh.exe')
+                # Create a temporary script file that
+                # runs the command we want
+                tf, tf_name = tempfile.mkstemp()
+                with os.fdopen(tf, 'wb') as f:
+                    shellcontents = ' '.join([x.replace('\\', '/') for x in args])
+                    fcontents = '#!/bin/sh\nunset PWD\n{}\n'.format(shellcontents)
+                    f.write(fcontents)
+                shell = utils.which(shell)
+                args = [shell, tf_name.replace('\\', '/')]
+            try:
+                subprocess.check_call(args)
+            except subprocess.CalledProcessError as e:
+                raise LinkerError(e)
+            finally:
+                if msys:
+                    os.remove(tf_name)
 
 
 def compile_introspection_binary(options, get_type_functions,