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

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

@@ -31,9 +31,13 @@ from . import utils
 
 
 class Position(object):
-    """Represents a position in the source file which we
+    """
+    Represents a position in the source file which we
     want to inform about.
     """
+
+    __slots__ = ('filename', 'line', 'column')
+
     def __init__(self, filename=None, line=None, column=None):
         self.filename = filename
         self.line = line
@@ -44,15 +48,16 @@ class Position(object):
                    (other.filename, other.line, other.column))
 
     def __repr__(self):
-        return '<Position %s:%d:%d>' % (
-            os.path.basename(self.filename),
-            self.line or -1,
-            self.column or -1)
+        return '<Position %s:%d:%d>' % (os.path.basename(self.filename), self.line or -1,
+                                        self.column or -1)
 
     def format(self, cwd):
-        filename = self.filename
-        if filename.startswith(cwd):
-            filename = filename[len(cwd):]
+        filename = os.path.realpath(self.filename)
+        cwd = os.path.realpath(cwd)
+        common_prefix = os.path.commonprefix((filename, cwd))
+        if common_prefix:
+            filename = os.path.relpath(filename, common_prefix)
+
         if self.column is not None:
             return '%s:%d:%d' % (filename, self.line, self.column)
         elif self.line is not None:
@@ -60,9 +65,6 @@ class Position(object):
         else:
             return '%s:' % (filename, )
 
-    def offset(self, offset):
-        return Position(self.filename, self.line + offset, self.column)
-
 
 class MessageLogger(object):
     _instance = None
@@ -70,11 +72,12 @@ class MessageLogger(object):
     def __init__(self, namespace, output=None):
         if output is None:
             output = sys.stderr
-        self._cwd = os.getcwd() + os.sep
+        self._cwd = os.getcwd()
         self._output = output
         self._namespace = namespace
-        self._enable_warnings = False
+        self._enable_warnings = []
         self._warning_count = 0
+        self._error_count = 0
 
     @classmethod
     def get(cls, *args, **kwargs):
@@ -82,24 +85,27 @@ class MessageLogger(object):
             cls._instance = cls(*args, **kwargs)
         return cls._instance
 
-    def enable_warnings(self, enable):
-        self._enable_warnings = enable
+    def enable_warnings(self, log_types):
+        self._enable_warnings = log_types
 
     def get_warning_count(self):
         return self._warning_count
 
+    def get_error_count(self):
+        return self._error_count
+
     def log(self, log_type, text, positions=None, prefix=None):
-        """Log a warning, using optional file positioning information.
-If the warning is related to a ast.Node type, see log_node()."""
+        """
+        Log a warning, using optional file positioning information.
+        If the warning is related to a ast.Node type, see log_node().
+        """
         utils.break_on_debug_flag('warning')
 
         self._warning_count += 1
 
-        if not self._enable_warnings and log_type != FATAL:
+        if not log_type in self._enable_warnings:
             return
 
-        # Always drop through on fatal
-
         if type(positions) == set:
             positions = list(positions)
         if isinstance(positions, Position):
@@ -116,8 +122,10 @@ If the warning is related to a ast.Node type, see log_node()."""
             error_type = "Warning"
         elif log_type == ERROR:
             error_type = "Error"
+            self._error_count += 1
         elif log_type == FATAL:
             error_type = "Fatal"
+
         if prefix:
             text = ('%s: %s: %s: %s: %s\n' % (last_position, error_type,
                                               self._namespace.name, prefix, text))
@@ -129,16 +137,19 @@ If the warning is related to a ast.Node type, see log_node()."""
                 text = ('%s: %s: %s\n' % (last_position, error_type, text))
 
         self._output.write(text)
+
         if log_type == FATAL:
             utils.break_on_debug_flag('fatal')
             raise SystemExit(text)
 
     def log_node(self, log_type, node, text, context=None, positions=None):
-        """Log a warning, using information about file positions from
-the given node.  The optional context argument, if given, should be
-another ast.Node type which will also be displayed.  If no file position
-information is available from the node, the position data from the
-context will be used."""
+        """
+        Log a warning, using information about file positions from
+        the given node.  The optional context argument, if given, should be
+        another ast.Node type which will also be displayed.  If no file position
+        information is available from the node, the position data from the
+        context will be used.
+        """
         if positions:
             pass
         elif getattr(node, 'file_positions', None):
@@ -182,6 +193,11 @@ def warn_symbol(symbol, text):
     ml.log_symbol(WARNING, symbol, text)
 
 
+def error(text, positions=None, prefix=None):
+    ml = MessageLogger.get()
+    ml.log(ERROR, text, positions, prefix)
+
+
 def fatal(text, positions=None, prefix=None):
     ml = MessageLogger.get()
     ml.log(FATAL, text, positions, prefix)

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

@@ -27,9 +27,10 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import platform
 
 from giscanner import message
-from giscanner.annotationparser import AnnotationParser
+from giscanner.annotationparser import GtkDocCommentBlockParser
 from giscanner.ast import Include, Namespace
 from giscanner.dumper import compile_introspection_binary
 from giscanner.gdumpparser import GDumpParser, IntrospectionBinary
@@ -46,13 +47,22 @@ from . import utils
 def process_cflags_begin(option, opt, value, parser):
     cflags = getattr(parser.values, option.dest)
     while len(parser.rargs) > 0 and parser.rargs[0] != '--cflags-end':
-        cflags.append(parser.rargs.pop(0))
+        arg = parser.rargs.pop(0)
+        if arg == "-I" and parser.rargs and parser.rargs[0] != '--cflags-end':
+            # This is a special case where there's a space between -I and the path.
+            arg += parser.rargs.pop(0)
+        cflags.append(utils.cflag_real_include_path(arg))
 
 
 def process_cflags_end(option, opt, value, parser):
     pass
 
 
+def process_cpp_includes(option, opt, value, parser):
+    cpp_includes = getattr(parser.values, option.dest)
+    cpp_includes.append(os.path.realpath(value))
+
+
 def get_preprocessor_option_group(parser):
     group = optparse.OptionGroup(parser, "Preprocessor options")
     group.add_option("", "--cflags-begin",
@@ -63,8 +73,8 @@ def get_preprocessor_option_group(parser):
                      help="End preprocessor/compiler flags",
                      action="callback", callback=process_cflags_end)
     group.add_option("-I", help="Pre-processor include file",
-                     action="append", dest="cpp_includes",
-                     default=[])
+                     dest="cpp_includes", default=[], type="string",
+                     action="callback", callback=process_cpp_includes)
     group.add_option("-D", help="Pre-processor define",
                      action="append", dest="cpp_defines",
                      default=[])
@@ -146,6 +156,11 @@ and --symbol-prefix.""")
                       help="""Remove this prefix from C identifiers (structure typedefs, etc.).
 May be specified multiple times.  This is also used as the default for --symbol-prefix if
 the latter is not specified.""")
+    parser.add_option("", "--identifier-filter-cmd",
+                      action="store", dest="identifier_filter_cmd", default='',
+                      help='Filter identifiers (struct and union typedefs) through the given '
+                           'shell command which will receive the identifier name as input '
+                           'to stdin and is expected to output the filtered results to stdout.')
     parser.add_option("", "--symbol-prefix",
                       action="append", dest="symbol_prefixes", default=[],
                       help="Remove this prefix from C symbols (function names)")
@@ -184,7 +199,8 @@ match the namespace prefix.""")
     group = get_preprocessor_option_group(parser)
     parser.add_option_group(group)
 
-    if os.environ.get('MSYSTEM') == 'MINGW32':
+    msystemenv = os.environ.get('MSYSTEM')
+    if msystemenv and msystemenv.startswith('MINGW'):
         group = get_windows_option_group(parser)
         parser.add_option_group(group)
 
@@ -201,6 +217,21 @@ match the namespace prefix.""")
     parser.add_option("", "--typelib-xml",
                       action="store_true", dest="typelib_xml",
                       help=optparse.SUPPRESS_HELP)
+    parser.add_option("", "--function-decoration",
+                      action="append", dest="function_decoration", default=[],
+                      help="Macro to decorate functions in generated code")
+    parser.add_option("", "--include-first-in-header",
+                      action="append", dest="include_first_header", default=[],
+                      help="Header to include first in generated header")
+    parser.add_option("", "--include-last-in-header",
+                      action="append", dest="include_last_header", default=[],
+                      help="Header to include after the other headers in generated header")
+    parser.add_option("", "--include-first-in-src",
+                      action="append", dest="include_first_src", default=[],
+                      help="Header to include first in generated sources")
+    parser.add_option("", "--include-last-in-src",
+                      action="append", dest="include_last_src", default=[],
+                      help="Header to include after the other headers in generated sources")
 
     return parser
 
@@ -217,11 +248,22 @@ def passthrough_gir(path, f):
     f.write(writer.get_xml())
 
 
-def test_codegen(optstring):
+def test_codegen(optstring,
+                 function_decoration,
+                 include_first_header,
+                 include_last_header,
+                 include_first_src,
+                 include_last_src):
     (namespace, out_h_filename, out_c_filename) = optstring.split(',')
     if namespace == 'Everything':
         from .testcodegen import EverythingCodeGenerator
-        gen = EverythingCodeGenerator(out_h_filename, out_c_filename)
+        gen = EverythingCodeGenerator(out_h_filename,
+                                      out_c_filename,
+                                      function_decoration,
+                                      include_first_header,
+                                      include_last_header,
+                                      include_first_src,
+                                      include_last_src)
         gen.write()
     else:
         _error("Invaild namespace %r" % (namespace, ))
@@ -252,7 +294,7 @@ def process_packages(options, packages):
     filtered_output = list(process_options(output, options_whitelist))
     parser = _get_option_parser()
     pkg_options, unused = parser.parse_args(filtered_output)
-    options.cpp_includes.extend(pkg_options.cpp_includes)
+    options.cpp_includes.extend([os.path.realpath(f) for f in pkg_options.cpp_includes])
     options.cpp_defines.extend(pkg_options.cpp_defines)
     options.cpp_undefines.extend(pkg_options.cpp_undefines)
 
@@ -267,7 +309,7 @@ def extract_filenames(args):
                 _error('%s: no such a file or directory' % (arg, ))
             # Make absolute, because we do comparisons inside scannerparser.c
             # against the absolute path that cpp will give us
-            filenames.append(os.path.abspath(arg))
+            filenames.append(arg)
     return filenames
 
 
@@ -289,7 +331,7 @@ def extract_filelist(options):
                 _error('%s: Invalid filelist entry-no such file or directory' % (line, ))
             # Make absolute, because we do comparisons inside scannerparser.c
             # against the absolute path that cpp will give us
-            filenames.append(os.path.abspath(filename))
+            filenames.append(filename)
     return filenames
 
 
@@ -324,7 +366,8 @@ see --identifier-prefix and --symbol-prefix."""
 
 def create_transformer(namespace, options):
     transformer = Transformer(namespace,
-                              accept_unprefixed=options.accept_unprefixed)
+                              accept_unprefixed=options.accept_unprefixed,
+                              identifier_filter_cmd=options.identifier_filter_cmd)
     transformer.set_include_paths(options.include_paths)
     if options.passthrough_gir:
         transformer.disable_cache()
@@ -374,6 +417,9 @@ def create_source_scanner(options, args):
     else:
         filenames = extract_filenames(args)
 
+    if platform.system() == 'Darwin':
+        options.cpp_undefines.append('__BLOCKS__')
+
     # Run the preprocessor, tokenize and construct simple
     # objects representing the raw C symbols
     ss = SourceScanner()
@@ -430,7 +476,12 @@ def scanner_main(args):
     if options.passthrough_gir:
         passthrough_gir(options.passthrough_gir, sys.stdout)
     if options.test_codegen:
-        return test_codegen(options.test_codegen)
+        return test_codegen(options.test_codegen,
+                            options.function_decoration,
+                            options.include_first_header,
+                            options.include_last_header,
+                            options.include_first_src,
+                            options.include_last_src)
 
     if hasattr(options, 'filelist') and not options.filelist:
         if len(args) <= 1:
@@ -452,7 +503,8 @@ def scanner_main(args):
     namespace = create_namespace(options)
     logger = message.MessageLogger.get(namespace=namespace)
     if options.warn_all:
-        logger.enable_warnings(True)
+        logger.enable_warnings((message.WARNING, message.ERROR, message.FATAL))
+
     transformer = create_transformer(namespace, options)
 
     packages = set(options.packages)
@@ -464,8 +516,8 @@ def scanner_main(args):
 
     ss = create_source_scanner(options, args)
 
-    ap = AnnotationParser()
-    blocks = ap.parse(ss.get_comments())
+    cbp = GtkDocCommentBlockParser()
+    blocks = cbp.parse_comment_blocks(ss.get_comments())
 
     # Transform the C symbols into AST nodes
     transformer.parse(ss.get_symbols())

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

@@ -24,7 +24,8 @@ import platform
 import re
 import subprocess
 
-from .utils import get_libtool_command, extract_libtool_shlib
+from .utils import get_libtool_command, extract_libtool_shlib, which
+from .ccompiler import CCompiler
 
 
 # For .la files, the situation is easy.
@@ -49,9 +50,13 @@ def _resolve_libtool(options, binary, libraries):
 # 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):
-    return re.compile("(?<![A-Za-z0-9_-])(lib*%s[^A-Za-z0-9_-][^\s\(\)]*)"
-                      % re.escape(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
@@ -85,10 +90,9 @@ def _resolve_non_libtool(options, binary, libraries):
             binary.args[0] = old_argdir
 
     if os.name == 'nt':
-        shlibs = []
+        cc = CCompiler()
+        shlibs = cc.resolve_windows_libs(libraries, options)
 
-        for library in libraries:
-            shlibs.append(library + '.dll')
     else:
         args = []
         libtool = get_libtool_command(options)

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

@@ -154,8 +154,8 @@ class SourceType(object):
 
 
 class SourceSymbol(object):
-    __members__ = ['const_int', 'const_double', 'const_string', 'ident',
-                   'type', 'base_type']
+    __members__ = ['const_int', 'const_double', 'const_string', 'const_boolean',
+                   'ident', 'type', 'base_type']
 
     def __init__(self, scanner, symbol):
         self._scanner = scanner
@@ -185,6 +185,10 @@ class SourceSymbol(object):
     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
@@ -227,7 +231,7 @@ class SourceScanner(object):
 
     def set_cpp_options(self, includes, defines, undefines, cflags=[]):
         self._cpp_options.extend(cflags)
-        for prefix, args in [('-I', includes),
+        for prefix, args in [('-I', [os.path.realpath(f) for f in includes]),
                              ('-D', defines),
                              ('-U', undefines)]:
             for arg in (args or []):
@@ -237,14 +241,14 @@ class SourceScanner(object):
 
     def parse_files(self, filenames):
         for filename in filenames:
-            filename = os.path.abspath(filename)
+            # 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 filenames:
+        for filename in self._filenames:
             if os.path.splitext(filename)[1] in SOURCE_EXTS:
-                filename = os.path.abspath(filename)
                 self._scanner.lex_filename(filename)
             else:
                 headers.append(filename)
@@ -253,7 +257,8 @@ class SourceScanner(object):
 
     def parse_macros(self, filenames):
         self._scanner.set_macro_scan(True)
-        self._scanner.parse_macros(filenames)
+        # 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):
@@ -284,6 +289,8 @@ class SourceScanner(object):
             # 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
 
@@ -298,7 +305,6 @@ class SourceScanner(object):
         for undef in undefs:
             proc.stdin.write('#undef %s\n' % (undef, ))
         for filename in filenames:
-            filename = os.path.abspath(filename)
             proc.stdin.write('#include <%s>\n' % (filename, ))
         proc.stdin.close()
 

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

@@ -46,9 +46,23 @@ def uscore_from_type(typeval):
 
 class EverythingCodeGenerator(object):
 
-    def __init__(self, out_h_filename, out_c_filename):
+    def __init__(self,
+                 out_h_filename,
+                 out_c_filename,
+                 function_decoration,
+                 include_first_header,
+                 include_last_header,
+                 include_first_src,
+                 include_last_src):
         self.namespace = ast.Namespace('Everything', '1.0')
-        self.gen = CCodeGenerator(self.namespace, out_h_filename, out_c_filename)
+        self.gen = CCodeGenerator(self.namespace,
+                                  out_h_filename,
+                                  out_c_filename,
+                                  function_decoration,
+                                  include_first_header,
+                                  include_last_header,
+                                  include_first_src,
+                                  include_last_src)
 
     def write(self):
         func = ast.Function('nullfunc',