gobject-introspection 2.2.0-x86-mingw32 → 2.2.1-x86-mingw32

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

@@ -20,6 +20,7 @@
 
 import os
 import sys
+import subprocess
 
 from . import ast
 from . import message
@@ -49,7 +50,7 @@ if os.name != 'nt':
 class Transformer(object):
     namespace = property(lambda self: self._namespace)
 
-    def __init__(self, namespace, accept_unprefixed=False):
+    def __init__(self, namespace, accept_unprefixed=False, identifier_filter_cmd=''):
         self._cachestore = CacheStore()
         self._accept_unprefixed = accept_unprefixed
         self._namespace = namespace
@@ -58,6 +59,12 @@ class Transformer(object):
         self._parsed_includes = {}  # <string namespace -> Namespace>
         self._includepaths = []
         self._passthrough_mode = False
+        self._identifier_filter_cmd = identifier_filter_cmd
+
+        # Cache a list of struct/unions in C's "tag namespace". This helps
+        # manage various orderings of typedefs and structs. See:
+        # https://bugzilla.gnome.org/show_bug.cgi?id=581525
+        self._tag_ns = {}
 
     def get_pkgconfig_packages(self):
         return self._pkg_config_packages
@@ -76,6 +83,12 @@ class Transformer(object):
         # modules will just depend on that.
         if isinstance(original, ast.Constant) and isinstance(node, ast.Constant):
             pass
+        elif original is node:
+            # Ignore attempts to add the same node to the namespace. This can
+            # happen when parsing typedefs and structs in particular orderings:
+            #   typedef struct _Foo Foo;
+            #   struct _Foo {...};
+            pass
         elif original:
             positions = set()
             positions.update(original.file_positions)
@@ -91,28 +104,30 @@ class Transformer(object):
             # https://bugzilla.gnome.org/show_bug.cgi?id=550616
             if symbol.ident in ['gst_g_error_get_type']:
                 continue
-            node = self._traverse_one(symbol)
-            if node:
-                self._append_new_node(node)
 
-        # Now look through the namespace for things like
-        # typedef struct _Foo Foo;
-        # where we've never seen the struct _Foo.  Just create
-        # an empty structure for these as "disguised"
-        # If we do have a class/interface, merge fields
-        for typedef, compound in self._typedefs_ns.iteritems():
-            ns_compound = self._namespace.get(compound.name)
-            if not ns_compound:
-                ns_compound = self._namespace.get('_' + compound.name)
-            if (not ns_compound and isinstance(compound, (ast.Record, ast.Union))
-            and len(compound.fields) == 0):
-                disguised = ast.Record(compound.name, typedef, disguised=True)
-                self._namespace.append(disguised)
-            elif not ns_compound:
-                self._namespace.append(compound)
-            elif isinstance(ns_compound, (ast.Record, ast.Union)) and len(ns_compound.fields) == 0:
-                ns_compound.fields = compound.fields
-        self._typedefs_ns = None
+            try:
+                node = self._traverse_one(symbol)
+            except TransformerException as e:
+                message.warn_symbol(symbol, e)
+                continue
+
+            if node and node.name:
+                self._append_new_node(node)
+            if isinstance(node, ast.Compound) and node.tag_name and \
+                    node.tag_name not in self._tag_ns:
+                self._tag_ns[node.tag_name] = node
+
+        # Run through the tag namespace looking for structs that have not been
+        # promoted into the main namespace. In this case we simply promote them
+        # with their struct tag.
+        for tag_name, struct in self._tag_ns.iteritems():
+            if not struct.name:
+                try:
+                    name = self.strip_identifier(tag_name)
+                    struct.name = name
+                    self._append_new_node(struct)
+                except TransformerException as e:
+                    message.warn_node(node, e)
 
     def set_include_paths(self, paths):
         self._includepaths = list(paths)
@@ -280,6 +295,17 @@ raise ValueError."""
         return matches[-1]
 
     def strip_identifier(self, ident):
+        if self._identifier_filter_cmd:
+            proc = subprocess.Popen(self._identifier_filter_cmd,
+                                    stdin=subprocess.PIPE,
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE,
+                                    shell=True)
+            ident, err = proc.communicate(ident)
+            if proc.returncode:
+                raise ValueError('filter: "%s" exited: %d with error: %s' %
+                                 (self._identifier_filter_cmd, proc.returncode, err))
+
         hidden = ident.startswith('_')
         if hidden:
             ident = ident[1:]
@@ -294,8 +320,7 @@ raise ValueError."""
                 return name
         (ns, name) = matches[-1]
         raise TransformerException(
-            "Skipping foreign identifier %r from namespace %s" % (
-            ident, ns.name, ))
+            "Skipping foreign identifier %r from namespace %s" % (ident, ns.name, ))
         return None
 
     def _strip_symbol(self, symbol):
@@ -324,13 +349,13 @@ raise ValueError."""
         elif stype == CSYMBOL_TYPE_TYPEDEF:
             return self._create_typedef(symbol)
         elif stype == CSYMBOL_TYPE_STRUCT:
-            return self._create_struct(symbol)
+            return self._create_tag_ns_compound(ast.Record, symbol)
         elif stype == CSYMBOL_TYPE_ENUM:
             return self._create_enum(symbol)
         elif stype == CSYMBOL_TYPE_MEMBER:
             return self._create_member(symbol, parent_symbol)
         elif stype == CSYMBOL_TYPE_UNION:
-            return self._create_union(symbol)
+            return self._create_tag_ns_compound(ast.Union, symbol)
         elif stype == CSYMBOL_TYPE_CONST:
             return self._create_const(symbol)
         # Ignore variable declarations in the header
@@ -377,21 +402,13 @@ raise ValueError."""
                 # Ok, the enum members don't have a consistent prefix
                 # among them, so let's just remove the global namespace
                 # prefix.
-                try:
-                    name = self._strip_symbol(child)
-                except TransformerException as e:
-                    message.warn_symbol(symbol, e)
-                    return None
+                name = self._strip_symbol(child)
             members.append(ast.Member(name.lower(),
                                       child.const_int,
                                       child.ident,
                                       None))
 
-        try:
-            enum_name = self.strip_identifier(symbol.ident)
-        except TransformerException as e:
-            message.warn_symbol(symbol, e)
-            return None
+        enum_name = self.strip_identifier(symbol.ident)
         if symbol.base_type.is_bitfield:
             klass = ast.Bitfield
         else:
@@ -406,11 +423,7 @@ raise ValueError."""
             return None
         parameters = list(self._create_parameters(symbol, symbol.base_type))
         return_ = self._create_return(symbol.base_type.base_type)
-        try:
-            name = self._strip_symbol(symbol)
-        except TransformerException as e:
-            message.warn_symbol(symbol, e)
-            return None
+        name = self._strip_symbol(symbol)
         func = ast.Function(name, return_, parameters, False, symbol.ident)
         func.add_symbol_reference(symbol)
         return func
@@ -506,9 +519,9 @@ raise ValueError."""
         and symbol.base_type.base_type.type == CTYPE_FUNCTION):
             node = self._create_callback(symbol, member=True)
         elif source_type.type == CTYPE_STRUCT and source_type.name is None:
-            node = self._create_struct(symbol, anonymous=True)
+            node = self._create_member_compound(ast.Record, symbol)
         elif source_type.type == CTYPE_UNION and source_type.name is None:
-            node = self._create_union(symbol, anonymous=True)
+            node = self._create_member_compound(ast.Union, symbol)
         else:
             # Special handling for fields; we don't have annotations on them
             # to apply later, yet.
@@ -561,22 +574,18 @@ raise ValueError."""
         if (ctype == CTYPE_POINTER and symbol.base_type.base_type.type == CTYPE_FUNCTION):
             node = self._create_typedef_callback(symbol)
         elif (ctype == CTYPE_POINTER and symbol.base_type.base_type.type == CTYPE_STRUCT):
-            node = self._create_typedef_struct(symbol, disguised=True)
+            node = self._create_typedef_compound(ast.Record, symbol, disguised=True)
         elif ctype == CTYPE_STRUCT:
-            node = self._create_typedef_struct(symbol)
+            node = self._create_typedef_compound(ast.Record, symbol)
         elif ctype == CTYPE_UNION:
-            node = self._create_typedef_union(symbol)
+            node = self._create_typedef_compound(ast.Union, symbol)
         elif ctype == CTYPE_ENUM:
             return self._create_enum(symbol)
         elif ctype in (CTYPE_TYPEDEF,
                        CTYPE_POINTER,
                        CTYPE_BASIC_TYPE,
                        CTYPE_VOID):
-            try:
-                name = self.strip_identifier(symbol.ident)
-            except TransformerException as e:
-                message.warn(e)
-                return None
+            name = self.strip_identifier(symbol.ident)
             if symbol.base_type.name:
                 complete_ctype = self._create_complete_source_type(symbol.base_type)
                 target = self.create_type_from_ctype_string(symbol.base_type.name,
@@ -616,20 +625,6 @@ raise ValueError."""
 
         return canonical
 
-    def parse_ctype(self, ctype, is_member=False):
-        canonical = self._canonicalize_ctype(ctype)
-
-        # Remove all pointers - we require standard calling
-        # conventions.  For example, an 'int' is always passed by
-        # value (unless it's out or inout).
-        derefed_typename = canonical.replace('*', '')
-
-        # Preserve "pointerness" of struct/union members
-        if (is_member and canonical.endswith('*') and derefed_typename in ast.basic_type_names):
-            return 'gpointer'
-        else:
-            return derefed_typename
-
     def _create_type_from_base(self, source_type, is_parameter=False, is_return=False):
         ctype = self._create_source_type(source_type)
         complete_ctype = self._create_complete_source_type(source_type)
@@ -688,18 +683,18 @@ raise ValueError."""
 
     def _create_parameter(self, parent_symbol, index, symbol):
         if symbol.type == CSYMBOL_TYPE_ELLIPSIS:
-            ptype = ast.Varargs()
+            return ast.Parameter('...', ast.Varargs())
         else:
             ptype = self._create_type_from_base(symbol.base_type, is_parameter=True)
 
-        if symbol.ident is None:
-            if symbol.base_type and symbol.base_type.type != CTYPE_VOID:
-                message.warn_symbol(parent_symbol, "missing parameter name; undocumentable")
-            ident = 'arg%d' % (index, )
-        else:
-            ident = symbol.ident
+            if symbol.ident is None:
+                if symbol.base_type and symbol.base_type.type != CTYPE_VOID:
+                    message.warn_symbol(parent_symbol, "missing parameter name; undocumentable")
+                ident = 'arg%d' % (index, )
+            else:
+                ident = symbol.ident
 
-        return ast.Parameter(ident, ptype)
+            return ast.Parameter(ident, ptype)
 
     def _create_return(self, source_type):
         typeval = self._create_type_from_base(source_type, is_return=True)
@@ -713,11 +708,7 @@ raise ValueError."""
         # http://bugzilla.gnome.org/show_bug.cgi?id=572790
         if (symbol.source_filename is None or not symbol.source_filename.endswith('.h')):
             return None
-        try:
-            name = self._strip_symbol(symbol)
-        except TransformerException as e:
-            message.warn_symbol(symbol, e)
-            return None
+        name = self._strip_symbol(symbol)
         if symbol.const_string is not None:
             typeval = ast.TYPE_STRING
             value = unicode(symbol.const_string, 'utf-8')
@@ -743,6 +734,9 @@ raise ValueError."""
                 value = str(symbol.const_int % 2 ** 16)
             else:
                 value = str(symbol.const_int)
+        elif symbol.const_boolean is not None:
+            typeval = ast.TYPE_BOOLEAN
+            value = "true" if symbol.const_boolean else "false"
         elif symbol.const_double is not None:
             typeval = ast.TYPE_DOUBLE
             value = '%f' % (symbol.const_double, )
@@ -754,35 +748,88 @@ raise ValueError."""
         const.add_symbol_reference(symbol)
         return const
 
-    def _create_typedef_struct(self, symbol, disguised=False):
-        try:
-            name = self.strip_identifier(symbol.ident)
-        except TransformerException as e:
-            message.warn_symbol(symbol, e)
-            return None
-        struct = ast.Record(name, symbol.ident, disguised=disguised)
-        self._parse_fields(symbol, struct)
-        struct.add_symbol_reference(symbol)
-        self._typedefs_ns[symbol.ident] = struct
-        return None
+    def _create_typedef_compound(self, compound_class, symbol, disguised=False):
+        name = self.strip_identifier(symbol.ident)
+        assert symbol.base_type
+        if symbol.base_type.name:
+            tag_name = symbol.base_type.name
+        else:
+            tag_name = None
+
+        # If the struct already exists in the tag namespace, use it.
+        if tag_name in self._tag_ns:
+            compound = self._tag_ns[tag_name]
+            if compound.name:
+                # If the struct name is set it means the struct has already been
+                # promoted from the tag namespace to the main namespace by a
+                # prior typedef struct. If we get here it means this is another
+                # typedef of that struct. Instead of creating an alias to the
+                # primary typedef that has been promoted, we create a new Record
+                # with shared fields. This handles the case where we want to
+                # give structs like GInitiallyUnowned its own Record:
+                #    typedef struct _GObject GObject;
+                #    typedef struct _GObject GInitiallyUnowned;
+                # See: http://bugzilla.gnome.org/show_bug.cgi?id=569408
+                new_compound = compound_class(name, symbol.ident, tag_name=tag_name)
+                new_compound.fields = compound.fields
+                new_compound.add_symbol_reference(symbol)
+                return new_compound
+            else:
+                # If the struct does not have its name set, it exists only in
+                # the tag namespace. Set it here and return it which will
+                # promote it to the main namespace. Essentially the first
+                # typedef for a struct clobbers its name and ctype which is what
+                # will be visible to GI.
+                compound.name = name
+                compound.ctype = symbol.ident
+        else:
+            # Create a new struct with a typedef name and tag name when available.
+            # Structs with a typedef name are promoted into the main namespace
+            # by it being returned to the "parse" function and are also added to
+            # the tag namespace if it has a tag_name set.
+            compound = compound_class(name, symbol.ident, disguised=disguised, tag_name=tag_name)
+            if tag_name:
+                # Force the struct as disguised for now since we do not yet know
+                # if it has fields that will be parsed. Note that this is using
+                # an erroneous definition of disguised and we should eventually
+                # only look at the field count when needed.
+                compound.disguised = True
+            else:
+                # Case where we have an anonymous struct which is typedef'd:
+                #   typedef struct {...} Struct;
+                # we need to parse the fields because we never get a struct
+                # in the tag namespace which is normally where fields are parsed.
+                self._parse_fields(symbol, compound)
 
-    def _create_typedef_union(self, symbol):
-        try:
-            name = self.strip_identifier(symbol.ident)
-        except TransformerException as e:
-            message.warn(e)
-            return None
-        union = ast.Union(name, symbol.ident)
-        self._parse_fields(symbol, union)
-        union.add_symbol_reference(symbol)
-        self._typedefs_ns[symbol.ident] = union
-        return None
+        compound.add_symbol_reference(symbol)
+        return compound
+
+    def _create_tag_ns_compound(self, compound_class, symbol):
+        # Get or create a struct from C's tag namespace
+        if symbol.ident in self._tag_ns:
+            compound = self._tag_ns[symbol.ident]
+        else:
+            compound = compound_class(None, symbol.ident, tag_name=symbol.ident)
+
+        # Make sure disguised is False as we are now about to parse the
+        # fields of the real struct.
+        compound.disguised = False
+        # Fields may need to be parsed in either of the above cases because the
+        # Record can be created with a typedef prior to the struct definition.
+        self._parse_fields(symbol, compound)
+        compound.add_symbol_reference(symbol)
+        return compound
+
+    def _create_member_compound(self, compound_class, symbol):
+        compound = compound_class(symbol.ident, symbol.ident)
+        self._parse_fields(symbol, compound)
+        compound.add_symbol_reference(symbol)
+        return compound
 
     def _create_typedef_callback(self, symbol):
         callback = self._create_callback(symbol)
         if not callback:
             return None
-        self._typedefs_ns[callback.name] = callback
         return callback
 
     def _parse_fields(self, symbol, compound):
@@ -797,41 +844,6 @@ raise ValueError."""
                               anonymous_node=child_node)
             compound.fields.append(field)
 
-    def _create_compound(self, klass, symbol, anonymous):
-        if symbol.ident is None:
-            # the compound is an anonymous member of another union or a struct
-            assert anonymous
-            compound = klass(None, None)
-        else:
-            compound = self._typedefs_ns.get(symbol.ident, None)
-
-        if compound is None:
-            # This is a bit of a hack; really we should try
-            # to resolve through the typedefs to find the real
-            # name
-            if symbol.ident.startswith('_'):
-                compound = self._typedefs_ns.get(symbol.ident[1:], None)
-            if compound is None:
-                if anonymous:
-                    name = symbol.ident
-                else:
-                    try:
-                        name = self.strip_identifier(symbol.ident)
-                    except TransformerException as e:
-                        message.warn(e)
-                        return None
-                compound = klass(name, symbol.ident)
-
-        self._parse_fields(symbol, compound)
-        compound.add_symbol_reference(symbol)
-        return compound
-
-    def _create_struct(self, symbol, anonymous=False):
-        return self._create_compound(ast.Record, symbol, anonymous)
-
-    def _create_union(self, symbol, anonymous=False):
-        return self._create_compound(ast.Union, symbol, anonymous)
-
     def _create_callback(self, symbol, member=False):
         parameters = list(self._create_parameters(symbol, symbol.base_type.base_type))
         retval = self._create_return(symbol.base_type.base_type.base_type)
@@ -844,17 +856,9 @@ raise ValueError."""
         if member:
             name = symbol.ident
         elif symbol.ident.find('_') > 0:
-            try:
-                name = self._strip_symbol(symbol)
-            except TransformerException as e:
-                message.warn_symbol(symbol, e)
-                return None
+            name = self._strip_symbol(symbol)
         else:
-            try:
-                name = self.strip_identifier(symbol.ident)
-            except TransformerException as e:
-                message.warn(e)
-                return None
+            name = self.strip_identifier(symbol.ident)
         callback = ast.Callback(name, retval, parameters, False,
                                 ctype=symbol.ident)
         callback.add_symbol_reference(symbol)
@@ -953,29 +957,6 @@ Note that type resolution may not succeed."""
 
         return typeval.resolved
 
-    def _typepair_to_str(self, item):
-        nsname, item = item
-        if nsname is None:
-            return item.name
-        return '%s.%s' % (nsname, item.name)
-
-    def gtypename_to_giname(self, gtname, names):
-        resolved = names.type_names.get(gtname)
-        if resolved:
-            return self._typepair_to_str(resolved)
-        resolved = self._names.type_names.get(gtname)
-        if resolved:
-            return self._typepair_to_str(resolved)
-        raise KeyError("Failed to resolve GType name: %r" % (gtname, ))
-
-    def ctype_of(self, obj):
-        if hasattr(obj, 'ctype'):
-            return obj.ctype
-        elif hasattr(obj, 'symbol'):
-            return obj.symbol
-        else:
-            return None
-
     def resolve_aliases(self, typenode):
         """Removes all aliases from typenode, returns first non-alias
         in the typenode alias chain.  Returns typenode argument if it

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

@@ -21,6 +21,7 @@
 import re
 import os
 import subprocess
+import platform
 
 
 _debugflags = None
@@ -88,6 +89,20 @@ def _extract_dlname_field(la_file):
         return None
 
 
+_libtool_libdir_pat = re.compile("libdir='([^']+)'")
+
+
+def _extract_libdir_field(la_file):
+    f = open(la_file)
+    data = f.read()
+    f.close()
+    m = _libtool_libdir_pat.search(data)
+    if m:
+        return m.groups()[0]
+    else:
+        return None
+
+
 # Returns the name that we would pass to dlopen() the library
 # corresponding to this .la file
 def extract_libtool_shlib(la_file):
@@ -95,6 +110,14 @@ def extract_libtool_shlib(la_file):
     if dlname is None:
         return None
 
+    # Darwin uses absolute paths where possible; since the libtool files never
+    # contain absolute paths, use the libdir field
+    if platform.system() == 'Darwin':
+        dlbasename = os.path.basename(dlname)
+        libdir = _extract_libdir_field(la_file)
+        if libdir is None:
+            return dlbasename
+        return libdir + '/' + dlbasename
     # From the comments in extract_libtool(), older libtools had
     # a path rather than the raw dlname
     return os.path.basename(dlname)
@@ -109,7 +132,7 @@ def extract_libtool(la_file):
     # FIXME: This hackish, but I'm not sure how to do this
     #        in a way which is compatible with both libtool 2.2
     #        and pre-2.2. Johan 2008-10-21
-    libname = libname.replace('.libs/.libs', '.libs')
+    libname = libname.replace('.libs/.libs', '.libs').replace('.libs\\.libs', '.libs')
     return libname
 
 
@@ -127,14 +150,18 @@ def get_libtool_command(options):
         # we simply split().
         return libtool_path.split(' ')
 
+    libtool_cmd = 'libtool'
+    if platform.system() == 'Darwin':
+        # libtool on OS X is a completely different program written by Apple
+        libtool_cmd = 'glibtool'
     try:
-        subprocess.check_call(['libtool', '--version'],
+        subprocess.check_call([libtool_cmd, '--version'],
                               stdout=open(os.devnull))
     except (subprocess.CalledProcessError, OSError):
         # If libtool's not installed, assume we don't need it
         return None
 
-    return ['libtool']
+    return [libtool_cmd]
 
 
 def files_are_identical(path1, path2):
@@ -148,3 +175,37 @@ def files_are_identical(path1, path2):
     f1.close()
     f2.close()
     return buf1 == buf2
+
+
+def cflag_real_include_path(cflag):
+    if not cflag.startswith("-I"):
+        return cflag
+
+    return "-I" + os.path.realpath(cflag[2:])
+
+
+def which(program):
+    def is_exe(fpath):
+        return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+
+    def is_nt_exe(fpath):
+        return not fpath.lower().endswith('.exe') and \
+            os.path.isfile(fpath + '.exe') and \
+            os.access(fpath + '.exe', os.X_OK)
+
+    fpath, fname = os.path.split(program)
+    if fpath:
+        if is_exe(program):
+            return program
+        if os.name == 'nt' and is_nt_exe(program):
+            return program + '.exe'
+    else:
+        for path in os.environ["PATH"].split(os.pathsep):
+            path = path.strip('"')
+            exe_file = os.path.join(path, program)
+            if is_exe(exe_file):
+                return exe_file
+            if os.name == 'nt' and is_nt_exe(exe_file):
+                return exe_file + '.exe'
+
+    return None

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

@@ -24,48 +24,16 @@ import os
 
 from contextlib import contextmanager
 from cStringIO import StringIO
-from xml.sax.saxutils import escape, quoteattr
+from xml.sax.saxutils import escape
 
 from .libtoolimporter import LibtoolImporter
 
 
-def _calc_attrs_length(attributes, indent, self_indent):
-    if indent == -1:
-        return -1
-    attr_length = 0
-    for attr, value in attributes:
-        # FIXME: actually, if we have attributes with None as value this
-        # should be considered a bug and raise an error. We are just
-        # ignoring them here while we fix GIRParser to create the right
-        # ast with the correct attributes.
-        if value is None:
-            continue
-        attr_length += 2 + len(attr) + len(quoteattr(value))
-    return attr_length + indent + self_indent
-
-
-def collect_attributes(tag_name, attributes, self_indent, self_indent_char, indent=-1):
-    if not attributes:
-        return ''
-    if _calc_attrs_length(attributes, indent, self_indent) > 79:
-        indent_len = self_indent + len(tag_name) + 1
+with LibtoolImporter(None, None):
+    if 'UNINSTALLED_INTROSPECTION_SRCDIR' in os.environ:
+        from _giscanner import collect_attributes
     else:
-        indent_len = 0
-    first = True
-    attr_value = ''
-    for attr, value in attributes:
-        # FIXME: actually, if we have attributes with None as value this
-        # should be considered a bug and raise an error. We are just
-        # ignoring them here while we fix GIRParser to create the right
-        # ast with the correct attributes.
-        if value is None:
-            continue
-        if indent_len and not first:
-            attr_value += '\n%s' % (self_indent_char * indent_len)
-        attr_value += ' %s=%s' % (attr, quoteattr(value))
-        if first:
-            first = False
-    return attr_value
+        from giscanner._giscanner import collect_attributes
 
 
 def build_xml_tag(tag_name, attributes=None, data=None, self_indent=0,
@@ -87,13 +55,6 @@ def build_xml_tag(tag_name, attributes=None, data=None, self_indent=0,
     return prefix + attrs + suffix
 
 
-with LibtoolImporter(None, None):
-    if 'UNINSTALLED_INTROSPECTION_SRCDIR' in os.environ:
-        from _giscanner import collect_attributes
-    else:
-        from giscanner._giscanner import collect_attributes
-
-
 class XMLWriter(object):
 
     def __init__(self):