gobject-introspection 2.2.4-x64-mingw32

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

@@ -0,0 +1,203 @@
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2008-2010  Johan Dahlin
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+#
+
+import errno
+import cPickle
+import glob
+import hashlib
+import os
+import shutil
+import sys
+import tempfile
+
+import giscanner
+
+_CACHE_VERSION_FILENAME = '.cache-version'
+
+
+def _get_versionhash():
+    toplevel = os.path.dirname(giscanner.__file__)
+    # Use pyc instead of py to avoid extra IO
+    sources = glob.glob(os.path.join(toplevel, '*.pyc'))
+    sources.append(sys.argv[0])
+    # Using mtimes is a bit (5x) faster than hashing the file contents
+    mtimes = (str(os.stat(source).st_mtime) for source in sources)
+    return hashlib.sha1(''.join(mtimes)).hexdigest()
+
+
+def _get_cachedir():
+    if 'GI_SCANNER_DISABLE_CACHE' in os.environ:
+        return None
+    homedir = os.path.expanduser('~')
+    if homedir is None:
+        return None
+    if not os.path.exists(homedir):
+        return None
+
+    cachedir = os.path.join(homedir, '.cache')
+    if not os.path.exists(cachedir):
+        try:
+            os.mkdir(cachedir, 0o755)
+        except OSError:
+            return None
+
+    scannerdir = os.path.join(cachedir, 'g-ir-scanner')
+    if not os.path.exists(scannerdir):
+        try:
+            os.mkdir(scannerdir, 0o755)
+        except OSError:
+            return None
+    # If it exists and is a file, don't cache at all
+    elif not os.path.isdir(scannerdir):
+        return None
+    return scannerdir
+
+
+class CacheStore(object):
+
+    def __init__(self):
+        try:
+            self._directory = _get_cachedir()
+        except OSError as e:
+            if e.errno != errno.EPERM:
+                raise
+            self._directory = None
+
+        self._check_cache_version()
+
+    def _check_cache_version(self):
+        if self._directory is None:
+            return
+
+        current_hash = _get_versionhash()
+        version = os.path.join(self._directory, _CACHE_VERSION_FILENAME)
+        try:
+            cache_hash = open(version).read()
+        except IOError as e:
+            # File does not exist
+            if e.errno == errno.ENOENT:
+                cache_hash = 0
+            else:
+                raise
+
+        if current_hash == cache_hash:
+            return
+
+        versiontmp = version + '.tmp'
+
+        self._clean()
+        try:
+            fp = open(versiontmp, 'w')
+        except IOError as e:
+            # Permission denied
+            if e.errno == errno.EACCES:
+                return
+            else:
+                raise
+
+        fp.write(current_hash)
+        fp.close()
+        # On Unix, this would just be os.rename() but Windows
+        # doesn't allow that.
+        shutil.move(versiontmp, version)
+
+    def _get_filename(self, filename):
+        # If we couldn't create the directory we're probably
+        # on a read only home directory where we just disable
+        # the cache all together.
+        if self._directory is None:
+            return
+        hexdigest = hashlib.sha1(filename).hexdigest()
+        return os.path.join(self._directory, hexdigest)
+
+    def _cache_is_valid(self, store_filename, filename):
+        return (os.stat(store_filename).st_mtime >=
+                os.stat(filename).st_mtime)
+
+    def _remove_filename(self, filename):
+        try:
+            os.unlink(filename)
+        except IOError as e:
+            # Permission denied
+            if e.errno == errno.EACCES:
+                return
+            else:
+                raise
+        except OSError as e:
+            # File does not exist
+            if e.errno == errno.ENOENT:
+                return
+            else:
+                raise
+
+    def _clean(self):
+        for filename in os.listdir(self._directory):
+            if filename == _CACHE_VERSION_FILENAME:
+                continue
+            self._remove_filename(os.path.join(self._directory, filename))
+
+    def store(self, filename, data):
+        store_filename = self._get_filename(filename)
+        if store_filename is None:
+            return
+
+        if (os.path.exists(store_filename) and self._cache_is_valid(store_filename, filename)):
+            return None
+
+        tmp_fd, tmp_filename = tempfile.mkstemp(prefix='g-ir-scanner-cache-')
+        try:
+            cPickle.dump(data, os.fdopen(tmp_fd, 'w'))
+        except IOError as e:
+            # No space left on device
+            if e.errno == errno.ENOSPC:
+                self._remove_filename(tmp_filename)
+                return
+            else:
+                raise
+
+        try:
+            shutil.move(tmp_filename, store_filename)
+        except IOError as e:
+            # Permission denied
+            if e.errno == errno.EACCES:
+                self._remove_filename(tmp_filename)
+            else:
+                raise
+
+    def load(self, filename):
+        store_filename = self._get_filename(filename)
+        if store_filename is None:
+            return
+        try:
+            fd = open(store_filename)
+        except IOError as e:
+            if e.errno == errno.ENOENT:
+                return None
+            else:
+                raise
+        if not self._cache_is_valid(store_filename, filename):
+            return None
+        try:
+            data = cPickle.load(fd)
+        except (AttributeError, EOFError, ValueError, cPickle.BadPickleGet):
+            # Broken cache entry, remove it
+            self._remove_filename(store_filename)
+            data = None
+        return data

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

@@ -0,0 +1,202 @@
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2014  Chun-wei Fan
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+#
+
+import os
+import subprocess
+import sys
+import distutils
+
+from distutils.msvccompiler import MSVCCompiler
+from distutils.cygwinccompiler import Mingw32CCompiler
+from distutils.sysconfig import customize_compiler
+
+from . import utils
+
+
+class CCompiler(object):
+
+    compiler_cmd = ''
+    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):
+        # 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')
+            else:
+                args.append('-Wl,-rpath=.')
+
+        # 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')
+
+        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 == '':
+                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 == '':
+                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)
+
+    def get_external_link_flags(self, args, libraries, pkgconfig_msvc_flags):
+        # 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 library.endswith(".la"):  # explicitly specified libtool library
+                    args.append(library)
+                else:
+                    args.append('-l' + library)
+
+    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:
+            # 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
+            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')))
+                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'],
+                                    stdout=subprocess.PIPE)
+            o, e = proc.communicate()
+            for line in o.splitlines():
+                if line.startswith('libraries: '):
+                    libsearch = line[len('libraries: '):].split(';')
+
+        shlibs = []
+        not_resolved = []
+        for lib in libraries:
+            found = False
+            candidates = [
+                'lib%s.dll.a' % lib,
+                'lib%s.a' % lib,
+                '%s.dll.a' % lib,
+                '%s.a' % lib,
+                '%s.lib' % lib,
+            ]
+            for l in libsearch:
+                if found:
+                    break
+                if l.startswith('='):
+                    l = l[1:]
+                for c in candidates:
+                    if found:
+                        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:
+                                shlibs.append(line)
+                                found = True
+                                break
+            if not found:
+                not_resolved.append(lib)
+        if len(not_resolved) > 0:
+            raise SystemExit(
+                "ERROR: can't resolve libraries to shared libraries: " +
+                ", ".join(not_resolved))
+        return shlibs

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

@@ -0,0 +1,173 @@
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2010  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+#
+
+from __future__ import with_statement
+
+from contextlib import contextmanager
+
+from . import ast
+
+
+class CCodeGenerator(object):
+    def __init__(self, namespace,
+                 out_h_filename,
+                 out_c_filename,
+                 function_decoration=[],
+                 include_first_header=[],
+                 include_last_header=[],
+                 include_first_src=[],
+                 include_last_src=[]):
+        self.out_h_filename = out_h_filename
+        self.out_c_filename = out_c_filename
+        self.function_decoration = function_decoration
+        self.include_first_header = include_first_header
+        self.include_last_header = include_last_header
+        self.include_first_src = include_first_src
+        self.include_last_src = include_last_src
+        self._function_bodies = {}
+        self.namespace = namespace
+
+    def gen_symbol(self, name):
+        name = name.replace(' ', '_')
+        return '%s_%s' % (self.namespace.symbol_prefixes[0], name)
+
+    def _typecontainer_to_ctype(self, param):
+        if (isinstance(param, ast.Parameter)
+        and param.direction in (ast.PARAM_DIRECTION_OUT, ast.PARAM_DIRECTION_INOUT)):
+            suffix = '*'
+        else:
+            suffix = ''
+
+        if (param.type.is_equiv((ast.TYPE_STRING, ast.TYPE_FILENAME))
+        and param.transfer == ast.PARAM_TRANSFER_NONE):
+            return "const gchar*" + suffix
+
+        return param.type.ctype + suffix
+
+    def _write_prelude(self, out, func):
+        if self.function_decoration:
+            out.write("""
+%s""" % " ".join(self.function_decoration))
+
+        out.write("""
+%s
+%s (""" % (self._typecontainer_to_ctype(func.retval), func.symbol))
+        l = len(func.parameters)
+        if func.parameters:
+            for i, param in enumerate(func.parameters):
+                ctype = self._typecontainer_to_ctype(param)
+                out.write('%s %s' % (ctype, param.argname))
+                if i < l - 1:
+                    out.write(", ")
+        else:
+            out.write('void')
+        out.write(")")
+
+    def _write_prototype(self, func):
+        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_docs(self, func):
+        self.out_c.write("/**\n * %s:\n" % (func.symbol, ))
+        for param in func.parameters:
+            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(":\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('\n */')
+
+    @contextmanager
+    def _function(self, func):
+        self._write_prototype(func)
+        self._write_docs(func)
+        self._write_prelude(self.out_c, func)
+        self.out_c.write("\n{\n")
+        yield
+        self.out_c.write("}\n\n")
+
+    def _codegen_start(self):
+        warning = '/* GENERATED BY testcodegen.py; DO NOT EDIT */\n\n'
+        self.out_h.write(warning)
+        nsupper = self.namespace.name.upper()
+
+        for header in self.include_first_header:
+            self.out_h.write("""#include "%s"\n""" % header)
+
+        self.out_h.write("""
+#ifndef __%s_H__
+#define __%s_H__
+
+#include <glib-object.h>
+
+""" % (nsupper, nsupper))
+
+        for header in self.include_last_header:
+            self.out_h.write("""#include "%s"\n""" % header)
+
+        self.out_c.write(warning)
+
+        for header in self.include_first_src:
+            self.out_c.write("""#include "%s"\n""" % header)
+
+        self.out_c.write("""#include "%s"\n\n""" % (self.out_h_filename, ))
+
+        for header in self.include_last_src:
+            self.out_c.write("""#include "%s"\n""" % header)
+
+    def _codegen_end(self):
+        self.out_h.write("""#endif\n""")
+
+        self.out_h.close()
+        self.out_c.close()
+
+    def set_function_body(self, node, body):
+        assert isinstance(node, ast.Function)
+        self._function_bodies[node] = body
+
+    def codegen(self):
+        self.out_h = open(self.out_h_filename, 'w')
+        self.out_c = open(self.out_c_filename, 'w')
+
+        self._codegen_start()
+
+        for node in self.namespace.itervalues():
+            if isinstance(node, ast.Function):
+                with self._function(node):
+                    body = self._function_bodies.get(node)
+                    if not body:
+                        body = ''
+                    self.out_c.write(body)
+
+        self._codegen_end()