gobject-introspection 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

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

@@ -35,9 +35,8 @@ from .annotationparser import (OPT_ALLOW_NONE, OPT_ARRAY, OPT_ATTRIBUTE,
                                OPT_ARRAY_LENGTH, OPT_ARRAY_ZERO_TERMINATED,
                                OPT_CONSTRUCTOR, OPT_METHOD,
                                OPT_TRANSFER_NONE, OPT_TRANSFER_FLOATING)
-from .annotationparser import AnnotationParser
-from .transformer import TransformerException
-from .utils import to_underscores, to_underscores_noprefix
+from .utils import to_underscores_noprefix
+
 
 class MainTransformer(object):
 
@@ -50,12 +49,10 @@ class MainTransformer(object):
     # Public API
 
     def transform(self):
-        contents = list(self._namespace.itervalues())
-        if len(contents) == 0:
-            message.fatal("""Namespace is empty; likely causes are:
-* Not including .h files to be scanned
-* Broken --identifier-prefix
-""")
+        if not self._namespace.names:
+            message.fatal('Namespace is empty; likely causes are:\n'
+                          '* Not including .h files to be scanned\n'
+                          '* Broken --identifier-prefix')
 
         # Some initial namespace surgery
         self._namespace.walk(self._pass_fixup_hidden_fields)
@@ -109,17 +106,14 @@ class MainTransformer(object):
 
     def _pass_fixup_hidden_fields(self, node, chain):
         """Hide all callbacks starting with _; the typical
-usage is void (*_gtk_reserved1)(void);"""
-        if not isinstance(node, (ast.Class, ast.Interface,
-                                 ast.Record, ast.Union)):
-            return True
-        for field in node.fields:
-            if field is None:
-                continue
-            if (field.name.startswith('_')
+        usage is void (*_gtk_reserved1)(void);"""
+        if isinstance(node, (ast.Class, ast.Interface, ast.Record, ast.Union)):
+            for field in node.fields:
+                if (field
+                and field.name.startswith('_')
                 and field.anonymous_node is not None
                 and isinstance(field.anonymous_node, ast.Callback)):
-                field.introspectable = False
+                    field.introspectable = False
         return True
 
     def _get_validate_parameter_name(self, parent, param_name, origin):
@@ -142,7 +136,7 @@ usage is void (*_gtk_reserved1)(void);"""
     def _apply_annotation_rename_to(self, node, chain, block):
         if not block:
             return
-        rename_to = block.get_tag(TAG_RENAME_TO)
+        rename_to = block.tags.get(TAG_RENAME_TO)
         if not rename_to:
             return
         rename_to = rename_to.value
@@ -211,7 +205,7 @@ usage is void (*_gtk_reserved1)(void);"""
         if isinstance(node, ast.Function):
             self._apply_annotations_function(node, chain)
         if isinstance(node, ast.Callback):
-            self._apply_annotations_callable(node, chain, block = self._get_block(node))
+            self._apply_annotations_callable(node, chain, block=self._get_block(node))
         if isinstance(node, (ast.Class, ast.Interface, ast.Union, ast.Enum,
                              ast.Bitfield, ast.Callback)):
             self._apply_annotations_annotated(node, self._get_block(node))
@@ -234,13 +228,13 @@ usage is void (*_gtk_reserved1)(void);"""
         if isinstance(node, ast.Class):
             block = self._get_block(node)
             if block:
-                tag = block.get_tag(TAG_UNREF_FUNC)
+                tag = block.tags.get(TAG_UNREF_FUNC)
                 node.unref_func = tag.value if tag else None
-                tag = block.get_tag(TAG_REF_FUNC)
+                tag = block.tags.get(TAG_REF_FUNC)
                 node.ref_func = tag.value if tag else None
-                tag = block.get_tag(TAG_SET_VALUE_FUNC)
+                tag = block.tags.get(TAG_SET_VALUE_FUNC)
                 node.set_value_func = tag.value if tag else None
-                tag = block.get_tag(TAG_GET_VALUE_FUNC)
+                tag = block.tags.get(TAG_GET_VALUE_FUNC)
                 node.get_value_func = tag.value if tag else None
         if isinstance(node, ast.Constant):
             self._apply_annotations_constant(node)
@@ -264,7 +258,7 @@ usage is void (*_gtk_reserved1)(void);"""
             Use resolver() on each identifier, and combiner() on the parts of
             each complete type. (top_combiner is used on the top-most type.)"""
             bits = re.split(r'([,<>()])', type_str, 1)
-            first, sep, rest = [bits[0], '', ''] if (len(bits)==1) else bits
+            first, sep, rest = [bits[0], '', ''] if (len(bits) == 1) else bits
             args = [resolver(first)]
             if sep == '<' or sep == '(':
                 lastsep = '>' if (sep == '<') else ')'
@@ -275,9 +269,11 @@ usage is void (*_gtk_reserved1)(void);"""
             else:
                 rest = sep + rest
             return top_combiner(*args), rest
+
         def resolver(ident):
             res = self._transformer.create_type_from_user_string(ident)
             return res
+
         def combiner(base, *rest):
             if not rest:
                 return base
@@ -288,6 +284,7 @@ usage is void (*_gtk_reserved1)(void);"""
             message.warn(
                 "Too many parameters in type specification %r" % (type_str, ))
             return base
+
         def top_combiner(base, *rest):
             if type_node is not None and isinstance(type_node, ast.Type):
                 base.is_const = type_node.is_const
@@ -334,24 +331,23 @@ usage is void (*_gtk_reserved1)(void);"""
         return block.position
 
     def _check_array_element_type(self, array, options):
+        array_type = array.array_type
+        element_type = array.element_type
+
         # GPtrArrays are allowed to contain non basic types
         # (except enums and flags) or basic types that are
         # as big as a gpointer
-        if array.array_type == ast.Array.GLIB_PTRARRAY and \
-           ((array.element_type in ast.BASIC_GIR_TYPES
-             and not array.element_type in ast.POINTER_TYPES) or
-            isinstance(array.element_type, ast.Enum) or
-            isinstance(array.element_type, ast.Bitfield)):
-            message.warn("invalid (element-type) for a GPtrArray, "
-                        "must be a pointer", options.position)
+        if array_type == ast.Array.GLIB_PTRARRAY:
+            if ((element_type in ast.BASIC_GIR_TYPES and not element_type in ast.POINTER_TYPES)
+            or isinstance(element_type, (ast.Enum, ast.Bitfield))):
+                message.warn("invalid (element-type) for a GPtrArray, "
+                             "must be a pointer", options.position)
 
         # GByteArrays have (element-type) guint8 by default
-        if array.array_type == ast.Array.GLIB_BYTEARRAY:
-            if array.element_type == ast.TYPE_ANY:
+        if array_type == ast.Array.GLIB_BYTEARRAY:
+            if element_type == ast.TYPE_ANY:
                 array.element_type = ast.TYPE_UINT8
-            elif not array.element_type in [ast.TYPE_UINT8,
-                                            ast.TYPE_INT8,
-                                            ast.TYPE_CHAR]:
+            elif not element_type in [ast.TYPE_UINT8, ast.TYPE_INT8, ast.TYPE_CHAR]:
                 message.warn("invalid (element-type) for a GByteArray, "
                              "must be one of guint8, gint8 or gchar",
                              options.position)
@@ -461,8 +457,8 @@ usage is void (*_gtk_reserved1)(void);"""
 
     def _get_transfer_default_returntype_basic(self, typeval):
         if (typeval.is_equiv(ast.BASIC_GIR_TYPES)
-            or typeval.is_const
-            or typeval.is_equiv(ast.TYPE_NONE)):
+        or typeval.is_const
+        or typeval.is_equiv(ast.TYPE_NONE)):
             return ast.PARAM_TRANSFER_NONE
         elif typeval.is_equiv(ast.TYPE_STRING):
             # Non-const strings default to FULL
@@ -542,8 +538,7 @@ usage is void (*_gtk_reserved1)(void);"""
 
         caller_allocates = False
         annotated_direction = None
-        if (OPT_INOUT in options or
-            OPT_INOUT_ALT in options):
+        if (OPT_INOUT in options or OPT_INOUT_ALT in options):
             annotated_direction = ast.PARAM_DIRECTION_INOUT
         elif OPT_OUT in options:
             subtype = options[OPT_OUT]
@@ -581,9 +576,9 @@ usage is void (*_gtk_reserved1)(void);"""
 
         self._adjust_container_type(parent, node, options)
 
-        if (OPT_ALLOW_NONE in options or
-            node.type.target_giname == 'Gio.AsyncReadyCallback' or
-            node.type.target_giname == 'Gio.Cancellable'):
+        if (OPT_ALLOW_NONE in options
+        or node.type.target_giname == 'Gio.AsyncReadyCallback'
+        or node.type.target_giname == 'Gio.Cancellable'):
             node.allow_none = True
 
         if tag is not None and tag.comment is not None:
@@ -602,17 +597,17 @@ usage is void (*_gtk_reserved1)(void);"""
 
         node.doc = block.comment if block.comment else ''
 
-        since_tag = block.get_tag(TAG_SINCE)
+        since_tag = block.tags.get(TAG_SINCE)
         if since_tag is not None:
             node.version = since_tag.value
 
-        deprecated_tag = block.get_tag(TAG_DEPRECATED)
+        deprecated_tag = block.tags.get(TAG_DEPRECATED)
         if deprecated_tag is not None:
             value = deprecated_tag.value
             if ': ' in value:
                 colon = value.find(': ')
                 version = value[:colon]
-                desc = value[colon+2:]
+                desc = value[colon + 2:]
             else:
                 desc = value
                 version = None
@@ -620,7 +615,7 @@ usage is void (*_gtk_reserved1)(void);"""
             if version is not None:
                 node.deprecated_version = version
 
-        stability_tag = block.get_tag(TAG_STABILITY)
+        stability_tag = block.tags.get(TAG_STABILITY)
         if stability_tag is not None:
             stability = stability_tag.value.capitalize()
             if stability in ["Stable", "Unstable", "Private", "Internal"]:
@@ -629,7 +624,7 @@ usage is void (*_gtk_reserved1)(void);"""
                 message.warn('unknown value "%s" for Stability tag' % (
                     stability_tag.value), stability_tag.position)
 
-        annos_tag = block.get_tag(TAG_ATTRIBUTES)
+        annos_tag = block.tags.get(TAG_ATTRIBUTES)
         if annos_tag is not None:
             for key, value in annos_tag.options.items():
                 if value:
@@ -691,7 +686,7 @@ usage is void (*_gtk_reserved1)(void);"""
 
     def _apply_annotations_return(self, parent, return_, block):
         if block:
-            tag = block.get_tag(TAG_RETURNS)
+            tag = block.tags.get(TAG_RETURNS)
         else:
             tag = None
         self._apply_annotations_param_ret_common(parent, return_, tag)
@@ -702,7 +697,7 @@ usage is void (*_gtk_reserved1)(void);"""
             declparams.add(parent.instance_parameter.argname)
         for param in params:
             if block:
-                tag = block.get_param(param.argname)
+                tag = block.params.get(param.argname)
             else:
                 tag = None
             self._apply_annotations_param(parent, param, tag)
@@ -725,10 +720,9 @@ usage is void (*_gtk_reserved1)(void);"""
                 (param, ) = unused
                 text = ', should be %r' % (param, )
             else:
-                text = ', should be one of %s' % (
-                ', '.join(repr(p) for p in unused), )
+                text = ', should be one of %s' % (', '.join(repr(p) for p in unused), )
 
-            tag = block.get_param(doc_name)
+            tag = block.params.get(doc_name)
             message.warn(
                 '%s: unknown parameter %r in documentation comment%s' % (
                 block.name, doc_name, text),
@@ -756,7 +750,7 @@ usage is void (*_gtk_reserved1)(void);"""
     def _apply_annotations_field(self, parent, block, field):
         if not block:
             return
-        tag = block.get_param(field.name)
+        tag = block.params.get(field.name)
         if not tag:
             return
         t = tag.options.get(OPT_TYPE)
@@ -774,7 +768,7 @@ usage is void (*_gtk_reserved1)(void);"""
         self._apply_annotations_annotated(prop, block)
         if not block:
             return
-        transfer_tag = block.get_tag(TAG_TRANSFER)
+        transfer_tag = block.tags.get(TAG_TRANSFER)
         if transfer_tag is not None:
             transfer = transfer_tag.value
             if transfer == OPT_TRANSFER_FLOATING:
@@ -782,28 +776,36 @@ usage is void (*_gtk_reserved1)(void);"""
             prop.transfer = transfer
         else:
             prop.transfer = self._get_transfer_default(parent, prop)
-        type_tag = block.get_tag(TAG_TYPE)
+        type_tag = block.tags.get(TAG_TYPE)
         if type_tag:
             prop.type = self._resolve_toplevel(type_tag.value, prop.type, prop, parent)
 
     def _apply_annotations_signal(self, parent, signal):
+        names = []
         prefix = self._get_annotation_name(parent)
         block = self._blocks.get('%s::%s' % (prefix, signal.name))
-        self._apply_annotations_annotated(signal, block)
-        # We're only attempting to name the signal parameters if
-        # the number of parameters (@foo) is the same or greater
-        # than the number of signal parameters
-        if block and len(block.params) > len(signal.parameters):
-            names = block.params.items()
-            # Resolve real parameter names early, so that in later
-            # phase we can refer to them while resolving annotations.
-            for i, param in enumerate(signal.parameters):
-                param.argname, tag = names[i+1]
-        else:
-            names = []
+
+        if block:
+            self._apply_annotations_annotated(signal, block)
+
+            # We're only attempting to name the signal parameters if
+            # the number of parameters (@foo) is the same or greater
+            # than the number of signal parameters
+            if len(block.params) > len(signal.parameters):
+                names = block.params.items()
+                # Resolve real parameter names early, so that in later
+                # phase we can refer to them while resolving annotations.
+                for i, param in enumerate(signal.parameters):
+                    param.argname, tag = names[i + 1]
+            elif len(signal.parameters) != 0:
+                # Only warn about missing params if there are actually parameters
+                # besides implicit self.
+                message.warn("incorrect number of parameters in comment block, "
+                             "parameter annotations will be ignored.", block.position)
+
         for i, param in enumerate(signal.parameters):
             if names:
-                name, tag = names[i+1]
+                name, tag = names[i + 1]
                 options = getattr(tag, 'options', {})
                 param_type = options.get(OPT_TYPE)
                 if param_type:
@@ -821,7 +823,7 @@ usage is void (*_gtk_reserved1)(void);"""
 
         self._apply_annotations_annotated(node, block)
 
-        tag = block.get_tag(TAG_VALUE)
+        tag = block.tags.get(TAG_VALUE)
         if tag:
             node.value = tag.value
 
@@ -836,34 +838,30 @@ usage is void (*_gtk_reserved1)(void);"""
 
     def _pass_read_annotations2(self, node, chain):
         if isinstance(node, ast.Function):
-            self._apply_annotations2_function(node, chain)
+            block = self._blocks.get(node.symbol)
+
+            self._apply_annotation_rename_to(node, chain, block)
+
+            # Handle virtual invokers
+            parent = chain[-1] if chain else None
+            if (block and parent):
+                virtual_annotation = block.tags.get(TAG_VFUNC)
+                if virtual_annotation:
+                    invoker_name = virtual_annotation.value
+                    matched = False
+                    for vfunc in parent.virtual_methods:
+                        if vfunc.name == invoker_name:
+                            matched = True
+                            vfunc.invoker = node.name
+                            # Also merge in annotations
+                            self._apply_annotations_callable(vfunc, [parent], block)
+                            break
+                    if not matched:
+                        message.warn_node(node,
+                            "Virtual slot %r not found for %r annotation" % (invoker_name,
+                                                                             TAG_VFUNC))
         return True
 
-    def _apply_annotations2_function(self, node, chain):
-        block = self._blocks.get(node.symbol)
-
-        self._apply_annotation_rename_to(node, chain, block)
-
-        # Handle virtual invokers
-        parent = chain[-1] if chain else None
-        if not (block and parent):
-            return
-        virtual = block.get_tag(TAG_VFUNC)
-        if not virtual:
-            return
-        invoker_name = virtual.value
-        matched = False
-        for vfunc in parent.virtual_methods:
-            if vfunc.name == invoker_name:
-                matched = True
-                vfunc.invoker = node.name
-                # Also merge in annotations
-                self._apply_annotations_callable(vfunc, [parent], block)
-                break
-        if not matched:
-            message.warn_node(node,
-                "Virtual slot %r not found for %r annotation" % (invoker_name, TAG_VFUNC))
-
     def _resolve_and_filter_type_list(self, typelist):
         """Given a list of Type instances, return a new list of types with
 the ones that failed to resolve removed."""
@@ -1169,9 +1167,9 @@ method or constructor of some type."""
         origin_node = self._get_constructor_class(func, subsymbol)
         if origin_node is None:
             if func.is_constructor:
-                message.warn_node(func,
-                    "Can't find matching type for constructor; symbol=%r" \
-                    % (func.symbol, ))
+                message.warn_node(
+                    func,
+                    "Can't find matching type for constructor; symbol=%r" % (func.symbol, ))
             return False
 
         # Some sanity checks; only objects and boxeds can have ctors

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

@@ -61,7 +61,7 @@ class Position(object):
             return '%s:' % (filename, )
 
     def offset(self, offset):
-        return Position(self.filename, self.line+offset, self.column)
+        return Position(self.filename, self.line + offset, self.column)
 
 
 class MessageLogger(object):
@@ -119,16 +119,14 @@ If the warning is related to a ast.Node type, see log_node()."""
         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))
+            text = ('%s: %s: %s: %s: %s\n' % (last_position, error_type,
+                                              self._namespace.name, prefix, text))
         else:
             if self._namespace:
-                text = (
-'''%s: %s: %s: %s\n''' % (last_position, error_type, self._namespace.name, text))
+                text = ('%s: %s: %s: %s\n' % (last_position, error_type,
+                                              self._namespace.name, text))
             else:
-                text = (
-'''%s: %s: %s\n''' % (last_position, error_type, text))
+                text = ('%s: %s: %s\n' % (last_position, error_type, text))
 
         self._output.write(text)
         if log_type == FATAL:
@@ -169,17 +167,21 @@ def log_node(log_type, node, text, context=None, positions=None):
     ml = MessageLogger.get()
     ml.log_node(log_type, node, text, context=context, positions=positions)
 
+
 def warn(text, positions=None, prefix=None):
     ml = MessageLogger.get()
     ml.log(WARNING, text, positions, prefix)
 
+
 def warn_node(node, text, context=None, positions=None):
     log_node(WARNING, node, text, context=context, positions=positions)
 
+
 def warn_symbol(symbol, text):
     ml = MessageLogger.get()
     ml.log_symbol(WARNING, symbol, text)
 
+
 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

@@ -38,18 +38,21 @@ from giscanner.girparser import GIRParser
 from giscanner.girwriter import GIRWriter
 from giscanner.maintransformer import MainTransformer
 from giscanner.shlibs import resolve_shlibs
-from giscanner.sourcescanner import SourceScanner
+from giscanner.sourcescanner import SourceScanner, ALL_EXTS
 from giscanner.transformer import Transformer
 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))
 
+
 def process_cflags_end(option, opt, value, parser):
     pass
 
+
 def get_preprocessor_option_group(parser):
     group = optparse.OptionGroup(parser, "Preprocessor options")
     group.add_option("", "--cflags-begin",
@@ -71,6 +74,7 @@ def get_preprocessor_option_group(parser):
     group.add_option("-p", dest="", help="Ignored")
     return group
 
+
 def get_windows_option_group(parser):
     group = optparse.OptionGroup(parser, "Machine Dependent Options")
     group.add_option("-m", help="some machine dependent option",
@@ -79,13 +83,13 @@ def get_windows_option_group(parser):
 
     return group
 
+
 def _get_option_parser():
     parser = optparse.OptionParser('%prog [options] sources')
     parser.add_option('', "--quiet",
                       action="store_true", dest="quiet",
                       default=False,
-                      help="If passed, do not print details of normal" \
-                          + " operation")
+                      help="If passed, do not print details of normal operation")
     parser.add_option("", "--format",
                       action="store", dest="format",
                       default="gir",
@@ -204,6 +208,7 @@ match the namespace prefix.""")
 def _error(msg):
     raise SystemExit('ERROR: %s' % (msg, ))
 
+
 def passthrough_gir(path, f):
     parser = GIRParser()
     parser.parse(path)
@@ -211,6 +216,7 @@ def passthrough_gir(path, f):
     writer = GIRWriter(parser.get_namespace())
     f.write(writer.get_xml())
 
+
 def test_codegen(optstring):
     (namespace, out_h_filename, out_c_filename) = optstring.split(',')
     if namespace == 'Everything':
@@ -221,6 +227,7 @@ def test_codegen(optstring):
         _error("Invaild namespace %r" % (namespace, ))
     return 0
 
+
 def process_options(output, allowed_flags):
     for option in output.split():
         for flag in allowed_flags:
@@ -229,6 +236,7 @@ def process_options(output, allowed_flags):
             yield option
             break
 
+
 def process_packages(options, packages):
     args = ['pkg-config', '--cflags']
     args.extend(packages)
@@ -248,15 +256,13 @@ def process_packages(options, packages):
     options.cpp_defines.extend(pkg_options.cpp_defines)
     options.cpp_undefines.extend(pkg_options.cpp_undefines)
 
+
 def extract_filenames(args):
     filenames = []
     for arg in args:
         # We don't support real C++ parsing yet, but we should be able
         # to understand C API implemented in C++ files.
-        if (arg.endswith('.c') or arg.endswith('.cpp') or
-            arg.endswith('.cc') or arg.endswith('.cxx') or
-            arg.endswith('.h') or arg.endswith('.hpp') or
-            arg.endswith('.hxx')):
+        if os.path.splitext(arg)[1] in ALL_EXTS:
             if not os.path.exists(arg):
                 _error('%s: no such a file or directory' % (arg, ))
             # Make absolute, because we do comparisons inside scannerparser.c
@@ -264,6 +270,7 @@ def extract_filenames(args):
             filenames.append(os.path.abspath(arg))
     return filenames
 
+
 def extract_filelist(options):
     filenames = []
     if not os.path.exists(options.filelist):
@@ -274,10 +281,10 @@ def extract_filelist(options):
         # We don't support real C++ parsing yet, but we should be able
         # to understand C API implemented in C++ files.
         filename = line.strip()
-        if (filename.endswith('.c') or filename.endswith('.cpp') or
-            filename.endswith('.cc') or filename.endswith('.cxx') or
-            filename.endswith('.h') or filename.endswith('.hpp') or
-            filename.endswith('.hxx')):
+        if (filename.endswith('.c') or filename.endswith('.cpp')
+        or filename.endswith('.cc') or filename.endswith('.cxx')
+        or filename.endswith('.h') or filename.endswith('.hpp')
+        or filename.endswith('.hxx')):
             if not os.path.exists(filename):
                 _error('%s: Invalid filelist entry-no such file or directory' % (line, ))
             # Make absolute, because we do comparisons inside scannerparser.c
@@ -285,6 +292,7 @@ def extract_filelist(options):
             filenames.append(os.path.abspath(filename))
     return filenames
 
+
 def create_namespace(options):
     if options.strip_prefix:
         print """g-ir-scanner: warning: Option --strip-prefix has been deprecated;
@@ -313,6 +321,7 @@ see --identifier-prefix and --symbol-prefix."""
                      identifier_prefixes=identifier_prefixes,
                      symbol_prefixes=symbol_prefixes)
 
+
 def create_transformer(namespace, options):
     transformer = Transformer(namespace,
                               accept_unprefixed=options.accept_unprefixed)
@@ -334,6 +343,7 @@ def create_transformer(namespace, options):
 
     return transformer
 
+
 def create_binary(transformer, options, args):
     # Transform the C AST nodes into higher level
     # GLib/GObject nodes
@@ -344,7 +354,7 @@ def create_binary(transformer, options, args):
     gdump_parser.init_parse()
 
     if options.program:
-        args=[options.program]
+        args = [options.program]
         args.extend(options.program_args)
         binary = IntrospectionBinary(args)
     else:
@@ -357,6 +367,7 @@ def create_binary(transformer, options, args):
     gdump_parser.parse()
     return shlibs
 
+
 def create_source_scanner(options, args):
     if hasattr(options, 'filelist') and options.filelist:
         filenames = extract_filelist(options)
@@ -374,6 +385,7 @@ def create_source_scanner(options, args):
     ss.parse_macros(filenames)
     return ss
 
+
 def write_output(data, options):
     if options.output == "-":
         output = sys.stdout
@@ -393,7 +405,7 @@ def write_output(data, options):
         os.unlink(temp_f_name)
         try:
             shutil.move(main_f_name, options.output)
-        except OSError, e:
+        except OSError as e:
             if e.errno == errno.EPERM:
                 os.unlink(main_f_name)
                 return 0
@@ -402,14 +414,15 @@ def write_output(data, options):
     else:
         try:
             output = open(options.output, "w")
-        except IOError, e:
+        except IOError as e:
             _error("opening output for writing: %s" % (e.strerror, ))
 
     try:
         output.write(data)
-    except IOError, e:
+    except IOError as e:
         _error("while writing output: %s" % (e.strerror, ))
 
+
 def scanner_main(args):
     parser = _get_option_parser()
     (options, args) = parser.parse_args(args)
@@ -455,7 +468,6 @@ def scanner_main(args):
     blocks = ap.parse(ss.get_comments())
 
     # Transform the C symbols into AST nodes
-    transformer.set_annotations(blocks)
     transformer.parse(ss.get_symbols())
 
     if not options.header_only: