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

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

@@ -20,10 +20,13 @@
 
 import os
 import subprocess
+import tempfile
+
 import sys
 import distutils
 
 from distutils.msvccompiler import MSVCCompiler
+from distutils.unixccompiler import UnixCCompiler
 from distutils.cygwinccompiler import Mingw32CCompiler
 from distutils.sysconfig import customize_compiler
 
@@ -36,118 +39,260 @@ class CCompiler(object):
     compiler = None
     _cflags_no_deprecation_warnings = ''
 
-    def __init__(self, compiler_name=None):
-        pass
-
-    def get_internal_link_flags(self,
-                                args,
-                                libtool,
-                                libraries,
-                                libpaths,
-                                pkgconfig_msvc_flags,
-                                ns,
-                                ns_version):
+    def __init__(self,
+                 environ=os.environ,
+                 osname=os.name,
+                 compiler_name=None):
+
+        if osname == 'nt':
+            # The compiler used here on Windows may well not be
+            # the same compiler that was used to build Python,
+            # as the official Python binaries are built with
+            # Visual Studio
+            if compiler_name is None:
+                if environ.get('MSYSTEM') == 'MINGW32' or environ.get('MSYSTEM') == 'MINGW64':
+                    compiler_name = 'mingw32'
+                else:
+                    compiler_name = distutils.ccompiler.get_default_compiler()
+            if compiler_name != 'msvc' and \
+               compiler_name != 'mingw32':
+                raise SystemExit('Specified Compiler \'%s\' is unsupported.' % compiler_name)
+        else:
+            # XXX: Is it common practice to use a non-Unix compiler
+            #      class instance on non-Windows on platforms g-i supports?
+            compiler_name = distutils.ccompiler.get_default_compiler()
+
+        # Now, create the distutils ccompiler instance based on the info we have.
+        if compiler_name == 'msvc':
+            # For MSVC, we need to create a instance of a subclass of distutil's
+            # MSVC9Compiler class, as it does not provide a preprocess()
+            # implementation
+            from . import msvccompiler
+            self.compiler = msvccompiler.get_msvc_compiler()
+
+        else:
+            self.compiler = distutils.ccompiler.new_compiler(compiler=compiler_name)
+        customize_compiler(self.compiler)
+
+        # customize_compiler() from distutils only does customization
+        # for 'unix' compiler type.  Also, avoid linking to msvcrxx.dll
+        # for MinGW builds as the dumper binary does not link to the
+        # Python DLL, but link to msvcrt.dll if necessary.
+        if isinstance(self.compiler, Mingw32CCompiler):
+            if self.compiler.dll_libraries != ['msvcrt']:
+                self.compiler.dll_libraries = []
+            if self.compiler.preprocessor is None:
+                self.compiler.preprocessor = self.compiler.compiler + ['-E']
+
+        if self.check_is_msvc():
+            # We trick distutils to believe that we are (always) using a
+            # compiler supplied by a Windows SDK, so that we avoid launching
+            # a new build environment to detect the compiler that is used to
+            # build Python itself, which is not desirable, so that we use the
+            # compiler commands (and env) as-is.
+            os.environ['DISTUTILS_USE_SDK'] = '1'
+            if 'MSSdk' not in os.environ:
+                if 'WindowsSDKDir' in os.environ:
+                    os.environ['MSSdk'] = os.environ.get('WindowsSDKDir')
+                elif os.environ.get('VCInstallDir'):
+                    os.environ['MSSdk'] = os.environ.get('VCInstallDir')
+
+            self.compiler_cmd = 'cl.exe'
+
+            self._cflags_no_deprecation_warnings = "-wd4996"
+        else:
+            if (isinstance(self.compiler, Mingw32CCompiler)):
+                self.compiler_cmd = self.compiler.compiler[0]
+            else:
+                self.compiler_cmd = ' '.join(self.compiler.compiler)
+
+            self._cflags_no_deprecation_warnings = "-Wno-deprecated-declarations"
+
+    def get_internal_link_flags(self, args, libtool, libraries, libpaths):
         # An "internal" link is where the library to be introspected
         # is being built in the current directory.
 
-        # Search the current directory first
-        # (This flag is not supported nor needed for Visual C++)
-        if pkgconfig_msvc_flags == '':
-            args.append('-L.')
-
-        # https://bugzilla.gnome.org/show_bug.cgi?id=625195
         if not libtool:
-            # We don't have -Wl,-rpath for Visual C++, and that's
-            # going to cause a problem.  Instead, link to internal
-            # libraries by deducing the .lib file name using
-            # the namespace name and version
-            if pkgconfig_msvc_flags:
-                if ns_version:
-                    args.append(str.lower(ns) +
-                                '-' +
-                                ns_version + '.lib')
-                else:
-                    args.append(str.lower(ns) + '.lib')
+            # non-libtool case: prepare distutils use
+            if self.check_is_msvc():
+                for library in libraries:
+                    # MSVC Builds don't use libtool, so no .la libraries,
+                    # so just add the library directly.
+                    self.compiler.add_library(library)
+                    for libpath in libpaths:
+                        self.compiler.add_library_dir(libpath)
             else:
-                args.append('-Wl,-rpath=.')
+                # Search the current directory first
+                # (This flag is not supported nor needed for Visual C++)
+                self.compiler.add_library_dir('.')
+                if os.name != 'nt':
+                    self.compiler.add_runtime_library_dir('.')
 
-        # Ensure libraries are always linked as we are going to use ldd to work
-        # out their names later
-        if not libtool and pkgconfig_msvc_flags == '':
-            args.append('-Wl,--no-as-needed')
+                # https://bugzilla.gnome.org/show_bug.cgi?id=625195
+                args.append('-Wl,-rpath,.')
 
-        for library in libraries:
-            # Visual C++: We have the needed .lib files now, and we need to link
-            # to .lib files, not the .dll as the --library option specifies the
-            # .dll(s) the .gir file refers to
-            if pkgconfig_msvc_flags == '':
+                # Ensure libraries are always linked as we are going to use ldd to work
+                # out their names later
+                if sys.platform != 'darwin':
+                    args.append('-Wl,--no-as-needed')
+
+            for library in libraries:
+                self.compiler.add_library(library)
+            if not self.check_is_msvc():
+                for library_path in libpaths:
+                    args.append('-L' + library_path)
+                    if os.path.isabs(library_path):
+                        args.append('-Wl,-rpath,' + library_path)
+
+        else:
+            # libtool case: assemble linker command arguments, like we did before
+            args.append('-L.')
+            for library in libraries:
                 if library.endswith(".la"):  # explicitly specified libtool library
                     args.append(library)
                 else:
                     args.append('-l' + library)
 
-        for library_path in libpaths:
-            # Not used/needed on Visual C++, and -Wl,-rpath options
-            # will cause grief
-            if pkgconfig_msvc_flags == '':
+            for library_path in libpaths:
                 args.append('-L' + library_path)
                 if os.path.isabs(library_path):
-                    if libtool:
-                        args.append('-rpath')
-                        args.append(library_path)
-                    else:
-                        args.append('-Wl,-rpath=' + library_path)
+                    args.append('-rpath')
+                    args.append(library_path)
 
-    def get_external_link_flags(self, args, libraries, pkgconfig_msvc_flags):
+    def get_external_link_flags(self, args, libtool, libraries):
         # An "external" link is where the library to be introspected
         # is installed on the system; this case is used for the scanning
         # of GLib in gobject-introspection itself.
 
         for library in libraries:
-            # The --library option on Windows pass in the .dll file(s) the
-            # .gir files refer to, so don't link to them on Visual C++
-            if pkgconfig_msvc_flags == '':
+            if not libtool:
+                self.compiler.add_library(library)
+            else:
                 if library.endswith(".la"):  # explicitly specified libtool library
                     args.append(library)
                 else:
                     args.append('-l' + library)
 
+    def preprocess(self, source, output, cpp_options):
+        extra_postargs = ['-C']
+        (include_paths, macros, postargs) = self._set_cpp_options(cpp_options)
+
+        # We always want to include the current path
+        include_dirs = ['.']
+
+        include_dirs.extend(include_paths)
+        extra_postargs.extend(postargs)
+
+        # Define these macros when using Visual C++ to silence many warnings,
+        # and prevent stepping on many Visual Studio-specific items, so that
+        # we don't have to handle them specifically in scannerlexer.l
+        if self.check_is_msvc():
+            macros.append(('_USE_DECLSPECS_FOR_SAL', None))
+            macros.append(('_CRT_SECURE_NO_WARNINGS', None))
+            macros.append(('_CRT_NONSTDC_NO_WARNINGS', None))
+            macros.append(('SAL_NO_ATTRIBUTE_DECLARATIONS', None))
+
+        self.compiler.preprocess(source=source,
+                                 output_file=output,
+                                 macros=macros,
+                                 include_dirs=include_dirs,
+                                 extra_postargs=extra_postargs)
+
+    def compile(self, pkg_config_cflags, cpp_includes, source, init_sections):
+        extra_postargs = []
+        includes = []
+        source_str = ''.join(source)
+        tmpdir_idx = source_str.rfind(os.sep, 0, source_str.rfind(os.sep))
+        (include_paths, macros, extra_args) = \
+            self._set_cpp_options(pkg_config_cflags)
+
+        for include in cpp_includes:
+            includes.append(include)
+
+        if isinstance(self.compiler, UnixCCompiler):
+            # This is to handle the case where macros are defined in CFLAGS
+            cflags = os.environ.get('CFLAGS')
+            if cflags:
+                for i, cflag in enumerate(cflags.split()):
+                    if cflag.startswith('-D'):
+                        stridx = cflag.find('=')
+                        if stridx > -1:
+                            macroset = (cflag[2:stridx],
+                                        cflag[stridx + 1:])
+                        else:
+                            macroset = (cflag[2:], None)
+                        if macroset not in macros:
+                            macros.append(macroset)
+
+        # 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 init_sections:
+            extra_postargs.append('-Wall')
+        extra_postargs.append(self._cflags_no_deprecation_warnings)
+
+        includes.extend(include_paths)
+        extra_postargs.extend(extra_args)
+
+        return self.compiler.compile(sources=source,
+                                     macros=macros,
+                                     include_dirs=includes,
+                                     extra_postargs=extra_postargs,
+                                     output_dir=str(source_str[tmpdir_idx + 1:
+                                                    source_str.rfind(os.sep)]))
+
+    def link(self, output, objects, lib_args):
+        # Note: This is used for non-libtool builds only!
+        extra_preargs = []
+        extra_postargs = []
+        library_dirs = []
+        libraries = []
+
+        for arg in lib_args:
+            extra_postargs.append(arg)
+
+        self.compiler.link(target_desc=self.compiler.EXECUTABLE,
+                           objects=objects,
+                           output_filename=output,
+                           extra_preargs=extra_preargs,
+                           extra_postargs=extra_postargs)
+
     def resolve_windows_libs(self, libraries, options):
         args = []
-        compiler_cmd = os.environ.get('CC', 'cc')
         libsearch = []
 
         # When we are using Visual C++...
-        if 'cl.exe' in compiler_cmd or 'cl' in compiler_cmd:
+        if self.check_is_msvc():
             # The search path of the .lib's on Visual C++
             # is dependent on the LIB environmental variable,
             # so just query for that
-            is_msvc = True
             libpath = os.environ.get('LIB')
             libsearch = libpath.split(';')
 
             # Use the dumpbin utility that's included in
             # every Visual C++ installation to find out which
-            # DLL the library gets linked to
+            # DLL the .lib gets linked to.
+            # dumpbin -symbols something.lib gives the
+            # filename of DLL without the '.dll' extension that something.lib
+            # links to, in the line that contains
+            # __IMPORT_DESCRIPTOR_<dll_filename_that_something.lib_links_to>
             args.append('dumpbin.exe')
             args.append('-symbols')
 
         # When we are not using Visual C++ (i.e. we are using GCC)...
         else:
-            is_msvc = False
             libtool = utils.get_libtool_command(options)
             if libtool:
-                args.append(utils.which(os.environ.get('SHELL', 'sh.exe')))
+                if os.name == 'nt':
+                    args.append(utils.which(os.environ.get('SHELL', 'sh.exe')))
                 args.extend(libtool)
                 args.append('--mode=execute')
-            # FIXME: it could have prefix (i686-w64-mingw32-dlltool.exe)
-            args.extend(['dlltool.exe', '--identify'])
-            proc = subprocess.Popen([compiler_cmd, '-print-search-dirs'],
+            args.extend([os.environ.get('DLLTOOL', 'dlltool.exe'), '--identify'])
+            proc = subprocess.Popen([self.compiler_cmd, '-print-search-dirs'],
                                     stdout=subprocess.PIPE)
             o, e = proc.communicate()
-            for line in o.splitlines():
+            for line in o.decode('ascii').splitlines():
                 if line.startswith('libraries: '):
-                    libsearch = line[len('libraries: '):].split(';')
+                    libsearch = line[len('libraries: '):].split(os.pathsep)
 
         shlibs = []
         not_resolved = []
@@ -170,26 +315,36 @@ class CCompiler(object):
                         break
                     implib = os.path.join(l, c)
                     if os.path.exists(implib):
-                        proc = subprocess.Popen(args + [implib],
-                                                stdout=subprocess.PIPE)
-                        o, e = proc.communicate()
-                        for line in o.splitlines():
-                            if is_msvc:
-                                # On Visual Studio, dumpbin -symbols something.lib gives the
-                                # filename of DLL without the '.dll' extension that something.lib
-                                # links to, in the line that contains
-                                # __IMPORT_DESCRIPTOR_<dll_filename_that_something.lib_links_to>
-
-                                if '__IMPORT_DESCRIPTOR_' in line:
-                                    line_tokens = line.split()
-                                    for item in line_tokens:
-                                        if item.startswith('__IMPORT_DESCRIPTOR_'):
-                                            shlibs.append(item[20:] + '.dll')
-                                            found = True
-                                            break
-                                if found:
-                                    break
-                            else:
+                        if self.check_is_msvc():
+                            tmp_fd, tmp_filename = \
+                                tempfile.mkstemp(prefix='g-ir-win32-resolve-lib-')
+
+                            # This is dumb, but it is life... Windows does not like one
+                            # trying to write to a file when its FD is not closed first,
+                            # when we use a flag in a program to do so.  So, close,
+                            # write to temp file with dumpbin and *then* re-open the
+                            # file for reading.
+                            os.close(tmp_fd)
+                            output_flag = ['-out:' + tmp_filename]
+                            proc = subprocess.call(args + [implib] + output_flag,
+                                                   stdout=subprocess.PIPE)
+                            with open(tmp_filename, 'r') as tmp_fileobj:
+                                for line in tmp_fileobj.read().splitlines():
+
+                                    if '__IMPORT_DESCRIPTOR_' in line:
+                                        line_tokens = line.split()
+                                        for item in line_tokens:
+                                            if item.startswith('__IMPORT_DESCRIPTOR_'):
+                                                shlibs.append(item[20:] + '.dll')
+                                                found = True
+                                                break
+                            tmp_fileobj.close()
+                            os.unlink(tmp_filename)
+                        else:
+                            proc = subprocess.Popen(args + [implib],
+                                                    stdout=subprocess.PIPE)
+                            o, e = proc.communicate()
+                            for line in o.decode('ascii').splitlines():
                                 shlibs.append(line)
                                 found = True
                                 break
@@ -200,3 +355,38 @@ class CCompiler(object):
                 "ERROR: can't resolve libraries to shared libraries: " +
                 ", ".join(not_resolved))
         return shlibs
+
+    def check_is_msvc(self):
+        if isinstance(self.compiler, MSVCCompiler):
+            return True
+        else:
+            return False
+
+    # Private APIs
+    def _set_cpp_options(self, options):
+        includes = []
+        macros = []
+        other_options = []
+
+        for o in options:
+            option = utils.cflag_real_include_path(o)
+            if option.startswith('-I'):
+                includes.append(option[len('-I'):])
+            elif option.startswith('-D'):
+                macro = option[len('-D'):]
+                macro_index = macro.find('=')
+                if macro_index == -1:
+                    macro_name = macro
+                    macro_value = None
+                else:
+                    macro_name = macro[:macro_index]
+                    macro_value = macro[macro_index + 1:]
+                macros.append((macro_name, macro_value))
+            elif option.startswith('-U'):
+                macros.append((option[len('-U'):],))
+            else:
+                # We expect the preprocessor to remove macros. If debugging is turned
+                # up high enough that won't happen, so don't add those flags. Bug #720504
+                if option not in ['-g3', '-ggdb3', '-gstabs3', '-gcoff3', '-gxcoff3', '-gvms3']:
+                    other_options.append(option)
+        return (includes, macros, other_options)

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

@@ -19,6 +19,10 @@
 #
 
 from __future__ import with_statement
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
 
 from contextlib import contextmanager
 
@@ -84,28 +88,31 @@ class CCodeGenerator(object):
         self._write_prelude(self.out_h, func)
         self.out_h.write(";\n\n")
 
-    def _write_annotation_transfer(self, transfer):
-        self.out_c.write("(transfer %s)" % (transfer, ))
+    def _write_annotation_transfer(self, node):
+        if (node.type not in ast.BASIC_TYPES or
+                node.type.ctype.endswith('*')):
+            self.out_c.write(" (transfer %s)" % (node.transfer, ))
 
     def _write_docs(self, func):
         self.out_c.write("/**\n * %s:\n" % (func.symbol, ))
         for param in func.parameters:
-            self.out_c.write(" * @%s: " % (param.argname, ))
+            self.out_c.write(" * @%s" % (param.argname, ))
             if param.direction in (ast.PARAM_DIRECTION_OUT,
                                    ast.PARAM_DIRECTION_INOUT):
                 if param.caller_allocates:
                     allocate_string = ' caller-allocates'
                 else:
                     allocate_string = ''
-                self.out_c.write("(%s%s) " % (param.direction,
-                                              allocate_string))
-                self._write_annotation_transfer(param.transfer)
+                self.out_c.write(": (%s%s) " % (param.direction,
+                                                allocate_string))
+                self._write_annotation_transfer(param)
             self.out_c.write(":\n")
         self.out_c.write(' *\n')
-        self.out_c.write(' * Undocumented.\n')
-        self.out_c.write(' *\n')
-        self.out_c.write(' * Returns: ')
-        self._write_annotation_transfer(func.retval.transfer)
+        self.out_c.write(' * Undocumented.')
+        if func.retval.type != ast.TYPE_NONE:
+            self.out_c.write('\n *\n')
+            self.out_c.write(' * Returns: ')
+            self._write_annotation_transfer(func.retval)
         self.out_c.write('\n */')
 
     @contextmanager
@@ -162,7 +169,7 @@ class CCodeGenerator(object):
 
         self._codegen_start()
 
-        for node in self.namespace.itervalues():
+        for node in self.namespace.values():
             if isinstance(node, ast.Function):
                 with self._function(node):
                     body = self._function_bodies.get(node)