gobject-introspection 2.2.4-x64-mingw32

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

@@ -0,0 +1,152 @@
+# -*- Mode: Python -*-
+# Copyright (C) 2013 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.
+#
+
+import re
+from . import ast
+from .utils import to_underscores
+
+
+class SectionsFile(object):
+    def __init__(self, sections):
+        self.sections = sections
+
+
+class Section(object):
+    def __init__(self):
+        self.file = None
+        self.title = None
+        self.includes = None
+        self.subsections = []
+
+
+class Subsection(object):
+    def __init__(self, name):
+        self.name = name
+        self.symbols = []
+
+
+def parse_sections_file(lines):
+    sections = []
+    current_section = None
+    current_subsection = None
+
+    for line in lines:
+        line = line.rstrip()
+
+        if not line or line.isspace():
+            continue
+
+        if line == "<SECTION>":
+            current_section = Section()
+            sections.append(current_section)
+            current_subsection = Subsection(None)
+            current_section.subsections.append(current_subsection)
+            continue
+
+        if line == "</SECTION>":
+            current_section = None
+            continue
+
+        match = re.match(r"<FILE>(?P<contents>.*)</FILE>", line)
+        if match:
+            current_section.file = match.groupdict['contents']
+            continue
+
+        match = re.match(r"<TITLE>(?P<contents>.*)</TITLE>", line)
+        if match:
+            current_section.title = match.groupdict['contents']
+            continue
+
+        match = re.match(r"<INCLUDE>(?P<contents>.*)</INCLUDE>", line)
+        if match:
+            current_section.includes = match.groupdict['contents']
+            continue
+
+        match = re.match(r"<SUBSECTION(?: (?P<name>.*))?>", line)
+        if match:
+            current_subsection = Subsection(match.groupdict.get('name', None))
+            current_section.subsections.append(current_subsection)
+            continue
+
+        if line.startswith("<") and line.endswith(">"):
+            # Other directive to gtk-doc, not a symbol.
+            continue
+
+        current_subsection.symbols.append(line)
+
+    return SectionsFile(sections)
+
+
+def write_sections_file(f, sections_file):
+    for section in sections_file.sections:
+        f.write("\n<SECTION>\n")
+        if section.file is not None:
+            f.write("<FILE>%s</FILE>\n" % (section.file, ))
+        if section.title is not None:
+            f.write("<TITLE>%s</TITLE>\n" % (section.title, ))
+        if section.includes is not None:
+            f.write("<INCLUDE>%s</INCLUDE>\n" % (section.includes, ))
+
+        is_first_subsection = True
+        for subsection in section.subsections:
+            if subsection.name is not None:
+                f.write("<SUBSECTION %s>\n" % (subsection.name, ))
+            elif not is_first_subsection:
+                f.write("\n<SUBSECTION>\n")
+
+            is_first_subsection = False
+
+            for symbol in subsection.symbols:
+                f.write(symbol + "\n")
+
+
+def generate_sections_file(transformer):
+    ns = transformer.namespace
+
+    sections = []
+
+    def new_section(file_, title):
+        section = Section()
+        section.file = file_
+        section.title = title
+        section.subsections.append(Subsection(None))
+        sections.append(section)
+        return section
+
+    def append_symbol(section, sym):
+        section.subsections[0].symbols.append(sym)
+
+    general_section = new_section("main", "Main")
+
+    for node in ns.itervalues():
+        if isinstance(node, ast.Function):
+            append_symbol(general_section, node.symbol)
+        elif isinstance(node, (ast.Class, ast.Interface)):
+            gtype_name = node.gtype_name
+            file_name = to_underscores(gtype_name).replace('_', '-').lower()
+            section = new_section(file_name, gtype_name)
+            append_symbol(section, gtype_name)
+            append_symbol(section, node.glib_type_struct.target_giname.replace('.', ''))
+
+            for meth in node.methods:
+                append_symbol(section, meth.symbol)
+            for meth in node.static_methods:
+                append_symbol(section, meth.symbol)
+
+    return SectionsFile(sections)

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

@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2009 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+
+import os
+import platform
+import re
+import subprocess
+
+from .utils import get_libtool_command, extract_libtool_shlib, which
+from .ccompiler import CCompiler
+
+
+# For .la files, the situation is easy.
+def _resolve_libtool(options, binary, libraries):
+    shlibs = []
+    for library in libraries:
+        shlib = extract_libtool_shlib(library)
+        if shlib:
+            shlibs.append(shlib)
+
+    return shlibs
+
+
+# Assume ldd output is something vaguely like
+#
+#  libpangoft2-1.0.so.0 => /usr/lib/libpangoft2-1.0.so.0 (0x006c1000)
+#
+# We say that if something in the output looks like libpangoft2<blah>
+# then the *first* such in the output is the soname. We require <blah>
+# to start with [^A-Za-z0-9_-] to avoid problems with libpango vs libpangoft2
+#
+# The negative lookbehind at the start is to avoid problems if someone
+# is crazy enough to name a library liblib<foo> when lib<foo> exists.
+#
+# Match absolute paths on OS X to conform to how libraries are usually
+# referenced on OS X systems.
+def _ldd_library_pattern(library_name):
+    pattern = "(?<![A-Za-z0-9_-])(lib*%s[^A-Za-z0-9_-][^\s\(\)]*)"
+    if platform.system() == 'Darwin':
+        pattern = "([^\s]*lib*%s[^A-Za-z0-9_-][^\s\(\)]*)"
+    return re.compile(pattern % re.escape(library_name))
+
+
+# This is a what we do for non-la files. We assume that we are on an
+# ELF-like system where ldd exists and the soname extracted with ldd is
+# a filename that can be opened with dlopen().
+#
+# On OS X this will need a straightforward alternate implementation
+# in terms of otool.
+#
+# Windows is more difficult, since there isn't always a straightforward
+# translation between library name (.lib) and the name of the .dll, so
+# extracting the dll names from the compiled app may not be sufficient.
+# We might need to hunt down the .lib in the compile-time path and
+# use that to figure out the name of the DLL.
+#
+def _resolve_non_libtool(options, binary, libraries):
+    if not libraries:
+        return []
+
+    if platform.platform().startswith('OpenBSD'):
+        # Hack for OpenBSD when using the ports' libtool which uses slightly
+        # different directories to store the libraries in. So rewite binary.args[0]
+        # by inserting '.libs/'.
+        old_argdir = binary.args[0]
+        new_libsdir = os.path.join(os.path.dirname(binary.args[0]), '.libs/')
+        new_lib = new_libsdir + os.path.basename(binary.args[0])
+        if os.path.exists(new_lib):
+            binary.args[0] = new_lib
+            os.putenv('LD_LIBRARY_PATH', new_libsdir)
+        else:
+            binary.args[0] = old_argdir
+
+    if os.name == 'nt':
+        cc = CCompiler()
+        shlibs = cc.resolve_windows_libs(libraries, options)
+
+    else:
+        args = []
+        libtool = get_libtool_command(options)
+        if libtool:
+            args.extend(libtool)
+            args.append('--mode=execute')
+        platform_system = platform.system()
+        if platform_system == 'Darwin':
+            args.extend(['otool', '-L', binary.args[0]])
+        else:
+            args.extend(['ldd', binary.args[0]])
+        proc = subprocess.Popen(args, stdout=subprocess.PIPE)
+        patterns = {}
+        for library in libraries:
+            patterns[library] = _ldd_library_pattern(library)
+
+        shlibs = []
+        for line in proc.stdout:
+            for library, pattern in patterns.iteritems():
+                m = pattern.search(line)
+                if m:
+                    del patterns[library]
+                    shlibs.append(m.group(1))
+                    break
+
+        if len(patterns) > 0:
+            raise SystemExit(
+                "ERROR: can't resolve libraries to shared libraries: " +
+                ", ".join(patterns.keys()))
+
+    return shlibs
+
+
+# We want to resolve a set of library names (the <foo> of -l<foo>)
+# against a library to find the shared library name. The shared
+# library name is suppose to be what you pass to dlopen() (or
+# equivalent). And we want to do this using the libraries that 'binary'
+# is linking against.
+#
+def resolve_shlibs(options, binary, libraries):
+    libtool = filter(lambda x: x.endswith(".la"), libraries)
+    non_libtool = filter(lambda x: not x.endswith(".la"), libraries)
+
+    return (_resolve_libtool(options, binary, libtool) +
+            _resolve_non_libtool(options, binary, non_libtool))

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

@@ -0,0 +1,329 @@
+# -*- Mode: Python -*-
+# GObject-Introspection - a framework for introspecting GObject libraries
+# Copyright (C) 2008  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.
+#
+
+from __future__ import with_statement
+import os
+import subprocess
+import tempfile
+
+from .libtoolimporter import LibtoolImporter
+from .message import Position
+
+with LibtoolImporter(None, None):
+    if 'UNINSTALLED_INTROSPECTION_SRCDIR' in os.environ:
+        from _giscanner import SourceScanner as CSourceScanner
+    else:
+        from giscanner._giscanner import SourceScanner as CSourceScanner
+
+HEADER_EXTS = ['.h', '.hpp', '.hxx']
+SOURCE_EXTS = ['.c', '.cpp', '.cc', '.cxx']
+ALL_EXTS = SOURCE_EXTS + HEADER_EXTS
+
+(CSYMBOL_TYPE_INVALID,
+ CSYMBOL_TYPE_ELLIPSIS,
+ CSYMBOL_TYPE_CONST,
+ CSYMBOL_TYPE_OBJECT,
+ CSYMBOL_TYPE_FUNCTION,
+ CSYMBOL_TYPE_STRUCT,
+ CSYMBOL_TYPE_UNION,
+ CSYMBOL_TYPE_ENUM,
+ CSYMBOL_TYPE_TYPEDEF,
+ CSYMBOL_TYPE_MEMBER) = range(10)
+
+(CTYPE_INVALID,
+ CTYPE_VOID,
+ CTYPE_BASIC_TYPE,
+ CTYPE_TYPEDEF,
+ CTYPE_STRUCT,
+ CTYPE_UNION,
+ CTYPE_ENUM,
+ CTYPE_POINTER,
+ CTYPE_ARRAY,
+ CTYPE_FUNCTION) = range(10)
+
+STORAGE_CLASS_NONE = 0
+STORAGE_CLASS_TYPEDEF = 1 << 1
+STORAGE_CLASS_EXTERN = 1 << 2
+STORAGE_CLASS_STATIC = 1 << 3
+STORAGE_CLASS_AUTO = 1 << 4
+STORAGE_CLASS_REGISTER = 1 << 5
+
+TYPE_QUALIFIER_NONE = 0
+TYPE_QUALIFIER_CONST = 1 << 1
+TYPE_QUALIFIER_RESTRICT = 1 << 2
+TYPE_QUALIFIER_VOLATILE = 1 << 3
+TYPE_QUALIFIER_EXTENSION = 1 << 4
+
+FUNCTION_NONE = 0
+FUNCTION_INLINE = 1 << 1
+
+(UNARY_ADDRESS_OF,
+ UNARY_POINTER_INDIRECTION,
+ UNARY_PLUS,
+ UNARY_MINUS,
+ UNARY_BITWISE_COMPLEMENT,
+ UNARY_LOGICAL_NEGATION) = range(6)
+
+
+def symbol_type_name(symbol_type):
+    return {
+        CSYMBOL_TYPE_INVALID: 'invalid',
+        CSYMBOL_TYPE_ELLIPSIS: 'ellipsis',
+        CSYMBOL_TYPE_CONST: 'const',
+        CSYMBOL_TYPE_OBJECT: 'object',
+        CSYMBOL_TYPE_FUNCTION: 'function',
+        CSYMBOL_TYPE_STRUCT: 'struct',
+        CSYMBOL_TYPE_UNION: 'union',
+        CSYMBOL_TYPE_ENUM: 'enum',
+        CSYMBOL_TYPE_TYPEDEF: 'typedef',
+        CSYMBOL_TYPE_MEMBER: 'member'}.get(symbol_type)
+
+
+def ctype_name(ctype):
+    return {
+        CTYPE_INVALID: 'invalid',
+        CTYPE_VOID: 'void',
+        CTYPE_BASIC_TYPE: 'basic',
+        CTYPE_TYPEDEF: 'typedef',
+        CTYPE_STRUCT: 'struct',
+        CTYPE_UNION: 'union',
+        CTYPE_ENUM: 'enum',
+        CTYPE_POINTER: 'pointer',
+        CTYPE_ARRAY: 'array',
+        CTYPE_FUNCTION: 'function'}.get(ctype)
+
+
+class SourceType(object):
+    __members__ = ['type', 'base_type', 'name', 'type_qualifier',
+                   'child_list', 'is_bitfield']
+
+    def __init__(self, scanner, stype):
+        self._scanner = scanner
+        self._stype = stype
+
+    def __repr__(self):
+        return '<%s type=%r name=%r>' % (
+            self.__class__.__name__,
+            ctype_name(self.type),
+            self.name)
+
+    @property
+    def type(self):
+        return self._stype.type
+
+    @property
+    def base_type(self):
+        if self._stype.base_type is not None:
+            return SourceType(self._scanner, self._stype.base_type)
+
+    @property
+    def name(self):
+        return self._stype.name
+
+    @property
+    def type_qualifier(self):
+        return self._stype.type_qualifier
+
+    @property
+    def child_list(self):
+        for symbol in self._stype.child_list:
+            if symbol is None:
+                continue
+            yield SourceSymbol(self._scanner, symbol)
+
+    @property
+    def is_bitfield(self):
+        return self._stype.is_bitfield
+
+
+class SourceSymbol(object):
+    __members__ = ['const_int', 'const_double', 'const_string', 'const_boolean',
+                   'ident', 'type', 'base_type']
+
+    def __init__(self, scanner, symbol):
+        self._scanner = scanner
+        self._symbol = symbol
+
+    def __repr__(self):
+        src = self.source_filename
+        if src:
+            line = self.line
+            if line:
+                src += ':%r' % (line, )
+        return '<%s type=%r ident=%r src=%r>' % (
+            self.__class__.__name__,
+            symbol_type_name(self.type),
+            self.ident,
+            src)
+
+    @property
+    def const_int(self):
+        return self._symbol.const_int
+
+    @property
+    def const_double(self):
+        return self._symbol.const_double
+
+    @property
+    def const_string(self):
+        return self._symbol.const_string
+
+    @property
+    def const_boolean(self):
+        return self._symbol.const_boolean
+
+    @property
+    def ident(self):
+        return self._symbol.ident
+
+    @property
+    def type(self):
+        return self._symbol.type
+
+    @property
+    def base_type(self):
+        if self._symbol.base_type is not None:
+            return SourceType(self._scanner, self._symbol.base_type)
+
+    @property
+    def source_filename(self):
+        return self._symbol.source_filename
+
+    @property
+    def line(self):
+        return self._symbol.line
+
+    @property
+    def private(self):
+        return self._symbol.private
+
+    @property
+    def position(self):
+        return Position(self._symbol.source_filename,
+                        self._symbol.line)
+
+
+class SourceScanner(object):
+
+    def __init__(self):
+        self._scanner = CSourceScanner()
+        self._filenames = []
+        self._cpp_options = []
+
+    # Public API
+
+    def set_cpp_options(self, includes, defines, undefines, cflags=[]):
+        self._cpp_options.extend(cflags)
+        for prefix, args in [('-I', [os.path.realpath(f) for f in includes]),
+                             ('-D', defines),
+                             ('-U', undefines)]:
+            for arg in (args or []):
+                opt = prefix + arg
+                if not opt in self._cpp_options:
+                    self._cpp_options.append(opt)
+
+    def parse_files(self, filenames):
+        for filename in filenames:
+            # self._scanner expects file names to be canonicalized and symlinks to be resolved
+            filename = os.path.realpath(filename)
+            self._scanner.append_filename(filename)
+            self._filenames.append(filename)
+
+        headers = []
+        for filename in self._filenames:
+            if os.path.splitext(filename)[1] in SOURCE_EXTS:
+                self._scanner.lex_filename(filename)
+            else:
+                headers.append(filename)
+
+        self._parse(headers)
+
+    def parse_macros(self, filenames):
+        self._scanner.set_macro_scan(True)
+        # self._scanner expects file names to be canonicalized and symlinks to be resolved
+        self._scanner.parse_macros([os.path.realpath(f) for f in filenames])
+        self._scanner.set_macro_scan(False)
+
+    def get_symbols(self):
+        for symbol in self._scanner.get_symbols():
+            yield SourceSymbol(self._scanner, symbol)
+
+    def get_comments(self):
+        return self._scanner.get_comments()
+
+    def dump(self):
+        print '-' * 30
+        for symbol in self._scanner.get_symbols():
+            print symbol.ident, symbol.base_type.name, symbol.type
+
+    # Private
+
+    def _parse(self, filenames):
+        if not filenames:
+            return
+
+        defines = ['__GI_SCANNER__']
+        undefs = []
+        cpp_args = os.environ.get('CC', 'cc').split()  # support CC="ccache gcc"
+        if 'cl' in cpp_args:
+            # The Microsoft compiler/preprocessor (cl) does not accept
+            # source input from stdin (the '-' flag), so we need
+            # some help from gcc from MinGW/Cygwin or so.
+            # Note that the generated dumper program is
+            # still built and linked by Visual C++.
+            cpp_args = ['gcc']
+        cpp_args += os.environ.get('CPPFLAGS', '').split()
+        cpp_args += os.environ.get('CFLAGS', '').split()
+        cpp_args += ['-E', '-C', '-I.', '-']
+        cpp_args += self._cpp_options
+
+        proc = subprocess.Popen(cpp_args,
+                                stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE)
+
+        for define in defines:
+            proc.stdin.write('#ifndef %s\n' % (define, ))
+            proc.stdin.write('# define %s\n' % (define, ))
+            proc.stdin.write('#endif\n')
+        for undef in undefs:
+            proc.stdin.write('#undef %s\n' % (undef, ))
+        for filename in filenames:
+            proc.stdin.write('#include <%s>\n' % (filename, ))
+        proc.stdin.close()
+
+        tmp_fd, tmp_name = tempfile.mkstemp()
+        fp = os.fdopen(tmp_fd, 'w+b')
+        while True:
+            data = proc.stdout.read(4096)
+            if data is None:
+                break
+            fp.write(data)
+            if len(data) < 4096:
+                break
+        fp.seek(0, 0)
+
+        assert proc, 'Proc was none'
+        proc.wait()
+        if proc.returncode != 0:
+            raise SystemExit('Error while processing the source.')
+
+        self._scanner.parse_file(fp.fileno())
+        fp.close()
+        os.unlink(tmp_name)