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

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

@@ -19,7 +19,13 @@
 # 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 copy
+import operator
 from itertools import chain
 
 from . import message
@@ -112,27 +118,43 @@ in contrast to the other create_type() functions."""
             return Array(None, bare_utf8, ctype=None, gtype_name=gtype_name,
                          is_const=False)
 
-        # Workaround for Gdk.Rectangle being boxed alias for
-        # cairo.RectangleInt.  G-I does not support boxing of aliases.
-        # See https://bugzilla.gnome.org/show_bug.cgi?id=655423
-        if gtype_name == 'GdkRectangle':
-            gtype_name = 'CairoRectangleInt'
-
         return cls(gtype_name=gtype_name)
 
     def get_giname(self):
         assert self.target_giname is not None
         return self.target_giname.split('.')[1]
 
-    def __cmp__(self, other):
+    def _compare(self, other, op):
         if self.target_fundamental:
-            return cmp(self.target_fundamental, other.target_fundamental)
+            return op(self.target_fundamental, other.target_fundamental)
         elif self.target_giname:
-            return cmp(self.target_giname, other.target_giname)
+            return op(self.target_giname, other.target_giname)
         elif self.target_foreign:
-            return cmp(self.target_foreign, other.target_foreign)
+            return op(self.target_foreign, other.target_foreign)
         else:
-            return cmp(self.ctype, other.ctype)
+            return op(self.ctype, other.ctype)
+
+    def __lt__(self, other):
+        return self._compare(other, operator.lt)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.gt)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.ge)
+
+    def __le__(self, other):
+        return self._compare(other, operator.le)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.eq)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.ne)
+
+    def __hash__(self):
+        return hash((self.target_fundamental, self.target_giname,
+                     self.target_foreign, self.ctype))
 
     def is_equiv(self, typeval):
         """Return True if the specified types are compatible at
@@ -178,13 +200,10 @@ class TypeUnknown(Type):
     def __init__(self):
         Type.__init__(self, _target_unknown=True)
 
-######
-## Fundamental types
-######
-# Two special ones
+# Fundamental types, two special ones
 TYPE_NONE = Type(target_fundamental='none', ctype='void')
 TYPE_ANY = Type(target_fundamental='gpointer', ctype='gpointer')
-# "Basic" types
+# Fundamental types, "Basic" types
 TYPE_BOOLEAN = Type(target_fundamental='gboolean', ctype='gboolean')
 TYPE_INT8 = Type(target_fundamental='gint8', ctype='gint8')
 TYPE_UINT8 = Type(target_fundamental='guint8', ctype='guint8')
@@ -223,13 +242,17 @@ TYPE_FILENAME = Type(target_fundamental='filename', ctype='gchar*')
 
 TYPE_VALIST = Type(target_fundamental='va_list', ctype='va_list')
 
-BASIC_GIR_TYPES = [TYPE_BOOLEAN, TYPE_INT8, TYPE_UINT8, TYPE_INT16,
-                   TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64,
-                   TYPE_UINT64, TYPE_CHAR, TYPE_SHORT, TYPE_USHORT, TYPE_INT,
-                   TYPE_UINT, TYPE_LONG, TYPE_ULONG, TYPE_SIZE, TYPE_SSIZE,
-                   TYPE_LONG_LONG, TYPE_LONG_ULONG, TYPE_INTPTR, TYPE_UINTPTR,
-                   TYPE_FLOAT, TYPE_DOUBLE,
-                   TYPE_LONG_DOUBLE, TYPE_UNICHAR, TYPE_GTYPE]
+BASIC_TYPES = [TYPE_BOOLEAN, TYPE_INT8, TYPE_UINT8, TYPE_INT16,
+               TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64,
+               TYPE_UINT64, TYPE_CHAR, TYPE_SHORT, TYPE_USHORT, TYPE_INT,
+               TYPE_UINT, TYPE_LONG, TYPE_ULONG, TYPE_SIZE, TYPE_SSIZE,
+               TYPE_LONG_LONG, TYPE_LONG_ULONG,
+               TYPE_FLOAT, TYPE_DOUBLE,
+               TYPE_LONG_DOUBLE, TYPE_UNICHAR, TYPE_GTYPE]
+
+BASIC_GIR_TYPES = [TYPE_INTPTR, TYPE_UINTPTR]
+BASIC_GIR_TYPES.extend(BASIC_TYPES)
+
 GIR_TYPES = [TYPE_NONE, TYPE_ANY]
 GIR_TYPES.extend(BASIC_GIR_TYPES)
 GIR_TYPES.extend([TYPE_STRING, TYPE_FILENAME, TYPE_VALIST])
@@ -321,6 +344,7 @@ type_names['FILE*'] = TYPE_ANY
 # the relevant methods, but on the other hand, since these types are just
 # integers it's easy enough to expand them.
 type_names['size_t'] = type_names['gsize']
+type_names['ssize_t'] = type_names['gssize']
 type_names['time_t'] = TYPE_LONG
 type_names['off_t'] = type_names['gsize']
 type_names['pid_t'] = TYPE_INT
@@ -328,16 +352,11 @@ type_names['uid_t'] = TYPE_UINT
 type_names['gid_t'] = TYPE_UINT
 type_names['dev_t'] = TYPE_INT
 type_names['socklen_t'] = TYPE_INT32
-type_names['size_t'] = TYPE_ULONG
-type_names['ssize_t'] = TYPE_LONG
 
 # Obj-C
 type_names['id'] = TYPE_ANY
 
-##
-## Parameters
-##
-
+# Parameters
 PARAM_DIRECTION_IN = 'in'
 PARAM_DIRECTION_OUT = 'out'
 PARAM_DIRECTION_INOUT = 'inout'
@@ -471,11 +490,11 @@ functions via get_by_symbol()."""
     def __iter__(self):
         return iter(self.names)
 
-    def iteritems(self):
-        return self.names.iteritems()
+    def items(self):
+        return self.names.items()
 
-    def itervalues(self):
-        return self.names.itervalues()
+    def values(self):
+        return self.names.values()
 
     def get(self, name):
         return self.names.get(name)
@@ -487,7 +506,7 @@ functions via get_by_symbol()."""
         return self.symbols.get(symbol)
 
     def walk(self, callback):
-        for node in self.itervalues():
+        for node in self.values():
             node.walk(callback, [])
 
 
@@ -501,11 +520,26 @@ class Include(object):
     def from_string(cls, string):
         return cls(*string.split('-', 1))
 
-    def __cmp__(self, other):
-        namecmp = cmp(self.name, other.name)
-        if namecmp != 0:
-            return namecmp
-        return cmp(self.version, other.version)
+    def _compare(self, other, op):
+        return op((self.name, self.version), (other.name, other.version))
+
+    def __lt__(self, other):
+        return self._compare(other, operator.lt)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.gt)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.ge)
+
+    def __le__(self, other):
+        return self._compare(other, operator.le)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.eq)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.ne)
 
     def __hash__(self):
         return hash(str(self))
@@ -561,14 +595,32 @@ GIName.  It's possible for nodes to contain or point to other nodes."""
         assert self.namespace is not None
         return Type(target_giname=('%s.%s' % (self.namespace.name, self.name)))
 
-    def __cmp__(self, other):
-        nscmp = cmp(self.namespace, other.namespace)
-        if nscmp != 0:
-            return nscmp
-        return cmp(self.name, other.name)
+    def _compare(self, other, op):
+        return op((self.namespace, self.name), (other.namespace, other.name))
+
+    def __lt__(self, other):
+        return self._compare(other, operator.lt)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.gt)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.ge)
+
+    def __le__(self, other):
+        return self._compare(other, operator.le)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.eq)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.ne)
+
+    def __hash__(self):
+        return hash((self.namespace, self.name))
 
     def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, self.name)
+        return "%s('%s')" % (self.__class__.__name__, self.name)
 
     def inherit_file_positions(self, node):
         self.file_positions.update(node.file_positions)
@@ -612,6 +664,34 @@ class Callable(Node):
         self.instance_parameter = None  # Parameter
         self.parent = None  # A Class or Interface
 
+    def _get_retval(self):
+        return self._retval
+
+    def _set_retval(self, value):
+        self._retval = value
+        if self._retval is not None:
+            self._retval.parent = self
+    retval = property(_get_retval, _set_retval)
+
+    def _get_instance_parameter(self):
+        return self._instance_parameter
+
+    def _set_instance_parameter(self, value):
+        self._instance_parameter = value
+        if value is not None:
+            value.parent = self
+    instance_parameter = property(_get_instance_parameter,
+                                  _set_instance_parameter)
+
+    def _get_parameters(self):
+        return self._parameters
+
+    def _set_parameters(self, value):
+        self._parameters = value
+        for param in self._parameters:
+            param.parent = self
+    parameters = property(_get_parameters, _set_parameters)
+
     # Returns all parameters, including the instance parameter
     @property
     def all_parameters(self):
@@ -650,6 +730,8 @@ class Function(Callable):
         # copy the parameters array so a change to self.parameters does not
         # influence clone.parameters.
         clone.parameters = self.parameters[:]
+        for param in clone.parameters:
+            param.parent = clone
         return clone
 
     def is_type_meta_function(self):
@@ -763,10 +845,12 @@ class Alias(Node):
 class TypeContainer(Annotated):
     """A fundamental base class for Return and Parameter."""
 
-    def __init__(self, typenode, nullable, transfer):
+    def __init__(self, typenode, nullable, not_nullable, transfer, direction):
         Annotated.__init__(self)
         self.type = typenode
         self.nullable = nullable
+        self.not_nullable = not_nullable
+        self.direction = direction
         if transfer is not None:
             self.transfer = transfer
         elif typenode.is_const:
@@ -781,11 +865,12 @@ class Parameter(TypeContainer):
     def __init__(self, argname, typenode, direction=None,
                  transfer=None, nullable=False, optional=False,
                  allow_none=False, scope=None,
-                 caller_allocates=False):
-        TypeContainer.__init__(self, typenode, nullable, transfer)
+                 caller_allocates=False, not_nullable=False):
+        TypeContainer.__init__(self, typenode, nullable, not_nullable,
+                               transfer, direction)
         self.argname = argname
-        self.direction = direction
         self.optional = optional
+        self.parent = None  # A Callable
 
         if allow_none:
             if self.direction == PARAM_DIRECTION_OUT:
@@ -798,13 +883,19 @@ class Parameter(TypeContainer):
         self.closure_name = None
         self.destroy_name = None
 
+    @property
+    def name(self):
+        return self.argname
+
 
 class Return(TypeContainer):
     """A return value from a function."""
 
-    def __init__(self, rtype, nullable=False, transfer=None):
-        TypeContainer.__init__(self, rtype, nullable, transfer)
-        self.direction = PARAM_DIRECTION_OUT
+    def __init__(self, rtype, nullable=False, not_nullable=False,
+                 transfer=None):
+        TypeContainer.__init__(self, rtype, nullable, not_nullable, transfer,
+                               direction=PARAM_DIRECTION_OUT)
+        self.parent = None  # A Callable
 
 
 class Enum(Node, Registered):
@@ -861,11 +952,32 @@ class Member(Annotated):
         self.nick = nick
         self.parent = None
 
-    def __cmp__(self, other):
-        return cmp(self.name, other.name)
+    def _compare(self, other, op):
+        return op(self.name, other.name)
+
+    def __lt__(self, other):
+        return self._compare(other, operator.lt)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.gt)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.ge)
+
+    def __le__(self, other):
+        return self._compare(other, operator.le)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.eq)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.ne)
+
+    def __hash__(self):
+        return hash(self.name)
 
     def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, self.name)
+        return "%s('%s')" % (self.__class__.__name__, self.name)
 
 
 class Compound(Node, Registered):
@@ -934,11 +1046,32 @@ class Field(Annotated):
         self.namespace = None
         self.parent = None  # a compound
 
-    def __cmp__(self, other):
-        return cmp(self.name, other.name)
+    def _compare(self, other, op):
+        return op(self.name, other.name)
+
+    def __lt__(self, other):
+        return self._compare(other, operator.lt)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.gt)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.ge)
+
+    def __le__(self, other):
+        return self._compare(other, operator.le)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.eq)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.ne)
+
+    def __hash__(self):
+        return hash(self.name)
 
     def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, self.name)
+        return "%s('%s')" % (self.__class__.__name__, self.name)
 
 
 class Record(Compound):

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

@@ -18,8 +18,12 @@
 # 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 errno
-import cPickle
 import glob
 import hashlib
 import os
@@ -27,61 +31,42 @@ import shutil
 import sys
 import tempfile
 
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
 import giscanner
 
+from . import utils
+
+
 _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 = glob.glob(os.path.join(toplevel, '*.py'))
     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
+    # ASCII encoding is sufficient since we are only dealing with numbers.
+    return hashlib.sha1(''.join(mtimes).encode('ascii')).hexdigest()
 
 
 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._directory = self._get_cachedir()
         self._check_cache_version()
 
+    def _get_cachedir(self):
+        if 'GI_SCANNER_DISABLE_CACHE' in os.environ:
+            return None
+        else:
+            cachedir = utils.get_user_cache_dir('g-ir-scanner')
+            return cachedir
+
     def _check_cache_version(self):
         if self._directory is None:
             return
@@ -89,7 +74,8 @@ class CacheStore(object):
         current_hash = _get_versionhash()
         version = os.path.join(self._directory, _CACHE_VERSION_FILENAME)
         try:
-            cache_hash = open(version).read()
+            with open(version, 'r') as version_file:
+                cache_hash = version_file.read()
         except IOError as e:
             # File does not exist
             if e.errno == errno.ENOENT:
@@ -100,11 +86,16 @@ class CacheStore(object):
         if current_hash == cache_hash:
             return
 
-        versiontmp = version + '.tmp'
-
         self._clean()
+
+        tmp_fd, tmp_filename = tempfile.mkstemp(prefix='g-ir-scanner-cache-version-')
         try:
-            fp = open(versiontmp, 'w')
+            with os.fdopen(tmp_fd, 'w') as tmp_file:
+                tmp_file.write(current_hash)
+
+            # On Unix, this would just be os.rename() but Windows
+            # doesn't allow that.
+            shutil.move(tmp_filename, version)
         except IOError as e:
             # Permission denied
             if e.errno == errno.EACCES:
@@ -112,19 +103,15 @@ class CacheStore(object):
             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()
+        # Assume UTF-8 encoding for the filenames. This doesn't matter so much
+        # as long as the results of this method always produce the same hash.
+        hexdigest = hashlib.sha1(filename.encode('utf-8')).hexdigest()
         return os.path.join(self._directory, hexdigest)
 
     def _cache_is_valid(self, store_filename, filename):
@@ -163,7 +150,8 @@ class CacheStore(object):
 
         tmp_fd, tmp_filename = tempfile.mkstemp(prefix='g-ir-scanner-cache-')
         try:
-            cPickle.dump(data, os.fdopen(tmp_fd, 'w'))
+            with os.fdopen(tmp_fd, 'wb') as tmp_file:
+                pickle.dump(data, tmp_file)
         except IOError as e:
             # No space left on device
             if e.errno == errno.ENOSPC:
@@ -186,7 +174,7 @@ class CacheStore(object):
         if store_filename is None:
             return
         try:
-            fd = open(store_filename)
+            fd = open(store_filename, 'rb')
         except IOError as e:
             if e.errno == errno.ENOENT:
                 return None
@@ -195,8 +183,8 @@ class CacheStore(object):
         if not self._cache_is_valid(store_filename, filename):
             return None
         try:
-            data = cPickle.load(fd)
-        except (AttributeError, EOFError, ValueError, cPickle.BadPickleGet):
+            data = pickle.load(fd)
+        except (AttributeError, EOFError, ValueError, pickle.BadPickleGet):
             # Broken cache entry, remove it
             self._remove_filename(store_filename)
             data = None