[TYPEDEF] transformer.py - function on typedef causes problems with GLib

[gnome.gobject-introspection] / giscanner / transformer.py

diff --git a/giscanner/transformer.py b/giscanner/transformer.py
index bc5d943..29753ad 100644 (file)
--- a/giscanner/transformer.py
+++ b/giscanner/transformer.py
@@ -19,6 +19,7 @@
 #
 
 import os
+import sys
 
 from .ast import (Bitfield, Callback, Enum, Function, Namespace, Member,
                   Parameter, Return, Struct, Field,
@@ -32,7 +33,7 @@ from .odict import odict
 from .sourcescanner import (
     SourceSymbol, ctype_name, CTYPE_POINTER,
     CTYPE_BASIC_TYPE, CTYPE_UNION, CTYPE_ARRAY, CTYPE_TYPEDEF,
-    CTYPE_VOID, CTYPE_ENUM, CTYPE_FUNCTION, CTYPE_STRUCT,
+    CTYPE_VOID, CTYPE_ENUM, CTYPE_FUNCTION, CTYPE_STRUCT, CTYPE_INVALID,
     CSYMBOL_TYPE_FUNCTION, CSYMBOL_TYPE_TYPEDEF, CSYMBOL_TYPE_STRUCT,
     CSYMBOL_TYPE_ENUM, CSYMBOL_TYPE_UNION, CSYMBOL_TYPE_OBJECT,
     CSYMBOL_TYPE_MEMBER, CSYMBOL_TYPE_ELLIPSIS, CSYMBOL_TYPE_CONST,
@@ -46,6 +47,8 @@ _xdg_data_dirs = [x for x in os.environ.get('XDG_DATA_DIRS', '').split(':') \
 class SkipError(Exception):
     pass
 
+class VaListSkipError(SkipError):
+    pass
 
 class Names(object):
     names = property(lambda self: self._names)
@@ -80,6 +83,9 @@ class Transformer(object):
     def get_includes(self):
         return self._includes
 
+    def set_strip_suffix(self, strip_suffix):
+        self._strip_suffix = strip_suffix
+
     def set_strip_prefix(self, strip_prefix):
         self._strip_prefix = strip_prefix
 
@@ -125,8 +131,9 @@ class Transformer(object):
             path = os.path.join(d, girname)
             if os.path.exists(path):
                 return path
-        raise ValueError("Couldn't find include %r (search path: %r)"\
+        sys.stderr.write("Couldn't find include %r (search path: %r)\n"\
                          % (girname, searchdirs))
+        sys.exit(1)
 
     def _parse_include(self, filename):
         parser = self._cachestore.load(filename)
@@ -177,14 +184,23 @@ class Transformer(object):
         # when --strip-prefix=g:
         #   GHashTable -> HashTable
         #   g_hash_table_new -> hash_table_new
+        stripped = False
         prefix = self._strip_prefix.lower()
-        if isfunction:
+        
+        if isfunction and '_' in name:
             prefix += '_'
         if len(name) > len(prefix) and name.lower().startswith(prefix):
             name = name[len(prefix):]
+            stripped = True
 
         while name.startswith('_'):
             name = name[1:]
+
+        if (stripped and self._strip_suffix and 
+            len(name) > len(self._strip_suffix) and
+            name.endswith(self._strip_suffix)):
+            name = name[:-1*len(self._strip_suffix)]
+            
         return name
 
     def _traverse_one(self, symbol, stype=None):
@@ -283,9 +299,8 @@ class Transformer(object):
         return False
 
     def _handle_destroy(self, param, destroy_idx, destroy_param):
-        if ((self._namespace.name == 'GLib' and
-             destroy_param.type.name == 'DestroyNotify') or
-            destroy_param.type.name == 'GLib.DestroyNotify'):
+        if (destroy_param.type.name == 'GLib.DestroyNotify' or
+            destroy_param.type.ctype == 'GDestroyNotify'):
             param.destroy_name = destroy_param.name
             param.destroy_index = destroy_idx
             return True
@@ -296,6 +311,10 @@ class Transformer(object):
             if not self._type_is_callback(param.type):
                 continue
 
+            # set a default scope
+            if param.scope is None:
+                param.scope = 'call'
+
             # j is the index where we look for closure/destroy to
             # group with the callback param
             j = i + 1
@@ -331,12 +350,21 @@ class Transformer(object):
             value = 'void'
         elif source_type.type == CTYPE_BASIC_TYPE:
             value = source_type.name
+            # skip adding invalid types.
+            if not source_type.base_type:
+                return value
+            value_add = self._create_source_type(source_type.base_type)
+            if len(value_add):
+                value += ' ' + value_add
         elif source_type.type == CTYPE_TYPEDEF:
             value = source_type.name
         elif source_type.type == CTYPE_ARRAY:
             return self._create_source_type(source_type.base_type)
         elif source_type.type == CTYPE_POINTER:
             value = self._create_source_type(source_type.base_type) + '*'
+        elif source_type.type == CTYPE_INVALID:
+            #this happens if const is after the type..
+            value = ''
         else:
             value = 'any'
         return value
@@ -352,7 +380,17 @@ class Transformer(object):
         source_type = symbol.base_type
         if (source_type.type == CTYPE_POINTER and
             symbol.base_type.base_type.type == CTYPE_FUNCTION):
-            node = self._create_callback(symbol)
+            try:
+                node = self._create_callback(symbol)
+            except VaListSkipError:
+                #this handles va_list members, and converts them
+                #to unwritable, unreadable void*
+                ftype = Type("any", "void*")
+                ftype = self.resolve_param_type(ftype)
+                node = Field(symbol.ident, ftype, ftype.name,
+                         readable=False, writable=False, bits=symbol.const_int)
+
+
         elif source_type.type == CTYPE_STRUCT and source_type.name is None:
             node = self._create_struct(symbol, anonymous=True)
         elif source_type.type == CTYPE_UNION and source_type.name is None:
@@ -388,6 +426,8 @@ class Transformer(object):
         if (ctype == CTYPE_POINTER and
             symbol.base_type.base_type.type == CTYPE_FUNCTION):
             node = self._create_typedef_callback(symbol)
+#        if (ctype ==  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)
@@ -404,6 +444,13 @@ class Transformer(object):
             name = self.remove_prefix(symbol.ident)
             if symbol.base_type.name:
                 target = self.remove_prefix(symbol.base_type.name)
+            elif (ctype == CTYPE_POINTER and
+                symbol.base_type.base_type.name):
+                target = self.remove_prefix(
+                    symbol.base_type.base_type.name) + '*'
+            elif (ctype == CTYPE_POINTER and
+                symbol.base_type.base_type.type == CTYPE_VOID):
+                target = 'any'
             else:
                 target = 'none'
             if name in type_names:
@@ -459,7 +506,7 @@ class Transformer(object):
     def _create_type(self, source_type, is_param, is_retval):
         ctype = self._create_source_type(source_type)
         if ctype.startswith('va_list'):
-            raise SkipError()
+            raise VaListSkipError()
         # FIXME: FILE* should not be skipped, it should be handled
         #        properly instead
         elif ctype == 'FILE*':
@@ -576,6 +623,10 @@ class Transformer(object):
     def _create_callback(self, symbol):
         parameters = list(self._create_parameters(symbol.base_type.base_type))
         retval = self._create_return(symbol.base_type.base_type.base_type)
+        ret_type = symbol.base_type.base_type.base_type
+        if not ret_type:
+            ret_type = symbol.base_type.base_type
+        retval = self._create_return(ret_type)
 
         # Mark the 'user_data' arguments
         for i, param in enumerate(parameters):
@@ -687,3 +738,8 @@ class Transformer(object):
             else:
                 break
         return type_name
+
+    def iter_enums(self):
+        for node in self._namespace.nodes:
+            if isinstance(node, Enum):
+                yield node