# -*- Mode: Python -*- # GObject-Introspection - a framework for introspecting GObject libraries # Copyright (C) 2008 Johan Dahlin # Copyright (C) 2008, 2009 Red 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. # from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import copy import operator from itertools import chain from . import message from .collections import OrderedDict from .message import Position from .utils import to_underscores class Type(object): """ A Type can be either: * A reference to a node (target_giname) * A reference to a "fundamental" type like 'utf8' * A "foreign" type - this can be any string." If none are specified, then it's in an "unresolved" state. An unresolved type can have two data sources; a "ctype" which comes from a C type string, or a gtype_name (from g_type_name()). """ def __init__(self, ctype=None, gtype_name=None, target_fundamental=None, target_giname=None, target_foreign=None, _target_unknown=False, is_const=False, origin_symbol=None, complete_ctype=None): self.ctype = ctype self.gtype_name = gtype_name self.origin_symbol = origin_symbol if _target_unknown: assert isinstance(self, TypeUnknown) elif target_fundamental: assert target_giname is None assert target_foreign is None elif target_giname: assert '.' in target_giname assert target_fundamental is None assert target_foreign is None elif target_foreign: assert ctype is not None assert target_giname is None assert target_fundamental is None else: assert (ctype is not None) or (gtype_name is not None) self.target_fundamental = target_fundamental self.target_giname = target_giname self.target_foreign = target_foreign self.is_const = is_const self.complete_ctype = complete_ctype @property def resolved(self): return (self.target_fundamental or self.target_giname or self.target_foreign) @property def unresolved_string(self): if self.ctype: return self.ctype elif self.gtype_name: return self.gtype_name elif self.target_giname: return self.target_giname else: assert False @classmethod def create_from_gtype_name(cls, gtype_name): """Parse a GType name (as from g_type_name()), and return a Type instance. Note that this function performs namespace lookup, in contrast to the other create_type() functions.""" # First, is it a fundamental? fundamental = type_names.get(gtype_name) if fundamental is not None: return cls(target_fundamental=fundamental.target_fundamental, ctype=fundamental.ctype) if gtype_name == 'GHashTable': return Map(TYPE_ANY, TYPE_ANY, gtype_name=gtype_name) elif gtype_name in ('GArray', 'GPtrArray', 'GByteArray'): return Array('GLib.' + gtype_name[1:], TYPE_ANY, gtype_name=gtype_name) elif gtype_name == 'GStrv': bare_utf8 = TYPE_STRING.clone() bare_utf8.ctype = None return Array(None, bare_utf8, ctype=None, gtype_name=gtype_name, is_const=False) return cls(gtype_name=gtype_name) def get_giname(self): assert self.target_giname is not None return self.target_giname.split('.')[1] def _compare(self, other, op): if self.target_fundamental: return op(self.target_fundamental, other.target_fundamental) elif self.target_giname: return op(self.target_giname, other.target_giname) elif self.target_foreign: return op(self.target_foreign, other.target_foreign) else: return op(self.ctype, other.ctype) def __lt__(self, other): return self._compare(other, operator.lt) def __gt__(self, other): return self._compare(other, operator.gt) def __ge__(self, other): return self._compare(other, operator.ge) def __le__(self, other): return self._compare(other, operator.le) def __eq__(self, other): return self._compare(other, operator.eq) def __ne__(self, other): return self._compare(other, operator.ne) def __hash__(self): return hash((self.target_fundamental, self.target_giname, self.target_foreign, self.ctype)) def is_equiv(self, typeval): """Return True if the specified types are compatible at an introspection level, disregarding their C types. A sequence may be given for typeval, in which case this function returns True if the type is compatible with any.""" if isinstance(typeval, (list, tuple)): for val in typeval: if self.is_equiv(val): return True return False return self == typeval def clone(self): return Type(target_fundamental=self.target_fundamental, target_giname=self.target_giname, target_foreign=self.target_foreign, ctype=self.ctype, is_const=self.is_const) def __str__(self): if self.target_fundamental: return self.target_fundamental elif self.target_giname: return self.target_giname elif self.target_foreign: return self.target_foreign def __repr__(self): if self.target_fundamental: data = 'target_fundamental=%s, ' % (self.target_fundamental, ) elif self.target_giname: data = 'target_giname=%s, ' % (self.target_giname, ) elif self.target_foreign: data = 'target_foreign=%s, ' % (self.target_foreign, ) else: data = '' return '%s(%sctype=%s)' % (self.__class__.__name__, data, self.ctype) class TypeUnknown(Type): def __init__(self): Type.__init__(self, _target_unknown=True) # Fundamental types, two special ones TYPE_NONE = Type(target_fundamental='none', ctype='void') TYPE_ANY = Type(target_fundamental='gpointer', ctype='gpointer') # Fundamental types, "Basic" types TYPE_BOOLEAN = Type(target_fundamental='gboolean', ctype='gboolean') TYPE_INT8 = Type(target_fundamental='gint8', ctype='gint8') TYPE_UINT8 = Type(target_fundamental='guint8', ctype='guint8') TYPE_INT16 = Type(target_fundamental='gint16', ctype='gint16') TYPE_UINT16 = Type(target_fundamental='guint16', ctype='guint16') TYPE_INT32 = Type(target_fundamental='gint32', ctype='gint32') TYPE_UINT32 = Type(target_fundamental='guint32', ctype='guint32') TYPE_INT64 = Type(target_fundamental='gint64', ctype='gint64') TYPE_UINT64 = Type(target_fundamental='guint64', ctype='guint64') TYPE_CHAR = Type(target_fundamental='gchar', ctype='gchar') TYPE_SHORT = Type(target_fundamental='gshort', ctype='gshort') TYPE_USHORT = Type(target_fundamental='gushort', ctype='gushort') TYPE_INT = Type(target_fundamental='gint', ctype='gint') TYPE_UINT = Type(target_fundamental='guint', ctype='guint') TYPE_LONG = Type(target_fundamental='glong', ctype='glong') TYPE_ULONG = Type(target_fundamental='gulong', ctype='gulong') TYPE_SIZE = Type(target_fundamental='gsize', ctype='gsize') TYPE_SSIZE = Type(target_fundamental='gssize', ctype='gssize') TYPE_INTPTR = Type(target_fundamental='gintptr', ctype='gintptr') TYPE_UINTPTR = Type(target_fundamental='guintptr', ctype='guintptr') # C99 types TYPE_LONG_LONG = Type(target_fundamental='long long', ctype='long long') TYPE_LONG_ULONG = Type(target_fundamental='unsigned long long', ctype='unsigned long long') TYPE_FLOAT = Type(target_fundamental='gfloat', ctype='gfloat') TYPE_DOUBLE = Type(target_fundamental='gdouble', ctype='gdouble') # ? TYPE_LONG_DOUBLE = Type(target_fundamental='long double', ctype='long double') TYPE_UNICHAR = Type(target_fundamental='gunichar', ctype='gunichar') # C types with semantics overlaid TYPE_GTYPE = Type(target_fundamental='GType', ctype='GType') TYPE_STRING = Type(target_fundamental='utf8', ctype='gchar*') TYPE_FILENAME = Type(target_fundamental='filename', ctype='gchar*') TYPE_VALIST = Type(target_fundamental='va_list', ctype='va_list') BASIC_TYPES = [TYPE_BOOLEAN, TYPE_INT8, TYPE_UINT8, TYPE_INT16, TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64, TYPE_UINT64, TYPE_CHAR, TYPE_SHORT, TYPE_USHORT, TYPE_INT, TYPE_UINT, TYPE_LONG, TYPE_ULONG, TYPE_SIZE, TYPE_SSIZE, TYPE_LONG_LONG, TYPE_LONG_ULONG, TYPE_FLOAT, TYPE_DOUBLE, TYPE_LONG_DOUBLE, TYPE_UNICHAR, TYPE_GTYPE] BASIC_GIR_TYPES = [TYPE_INTPTR, TYPE_UINTPTR] BASIC_GIR_TYPES.extend(BASIC_TYPES) GIR_TYPES = [TYPE_NONE, TYPE_ANY] GIR_TYPES.extend(BASIC_GIR_TYPES) GIR_TYPES.extend([TYPE_STRING, TYPE_FILENAME, TYPE_VALIST]) # These are the only basic types that are guaranteed to # be as big as a pointer (and thus are allowed in GPtrArray) POINTER_TYPES = [TYPE_ANY, TYPE_INTPTR, TYPE_UINTPTR] INTROSPECTABLE_BASIC = list(GIR_TYPES) for v in [TYPE_NONE, TYPE_ANY, TYPE_LONG_LONG, TYPE_LONG_ULONG, TYPE_LONG_DOUBLE, TYPE_VALIST]: INTROSPECTABLE_BASIC.remove(v) type_names = {} for typeval in GIR_TYPES: type_names[typeval.target_fundamental] = typeval basic_type_names = {} for typeval in BASIC_GIR_TYPES: basic_type_names[typeval.target_fundamental] = typeval # C builtin type_names['char'] = TYPE_CHAR type_names['signed char'] = TYPE_INT8 type_names['unsigned char'] = TYPE_UINT8 type_names['short'] = TYPE_SHORT type_names['signed short'] = TYPE_SHORT type_names['unsigned short'] = TYPE_USHORT type_names['int'] = TYPE_INT type_names['signed int'] = TYPE_INT type_names['unsigned short int'] = TYPE_USHORT type_names['signed'] = TYPE_INT type_names['unsigned int'] = TYPE_UINT type_names['unsigned'] = TYPE_UINT type_names['long'] = TYPE_LONG type_names['signed long'] = TYPE_LONG type_names['unsigned long'] = TYPE_ULONG type_names['unsigned long int'] = TYPE_ULONG type_names['float'] = TYPE_FLOAT type_names['double'] = TYPE_DOUBLE type_names['char*'] = TYPE_STRING type_names['void*'] = TYPE_ANY type_names['void'] = TYPE_NONE # Also alias the signed one here type_names['signed long long'] = TYPE_LONG_LONG # C99 stdint exact width types type_names['int8_t'] = TYPE_INT8 type_names['uint8_t'] = TYPE_UINT8 type_names['int16_t'] = TYPE_INT16 type_names['uint16_t'] = TYPE_UINT16 type_names['int32_t'] = TYPE_INT32 type_names['uint32_t'] = TYPE_UINT32 type_names['int64_t'] = TYPE_INT64 type_names['uint64_t'] = TYPE_UINT64 # C99 stdbool type_names['bool'] = TYPE_BOOLEAN # A few additional GLib type aliases type_names['guchar'] = TYPE_UINT8 type_names['gchararray'] = TYPE_STRING type_names['gchar*'] = TYPE_STRING type_names['goffset'] = TYPE_INT64 type_names['gunichar2'] = TYPE_UINT16 type_names['gsize'] = TYPE_SIZE type_names['gssize'] = TYPE_SSIZE type_names['gintptr'] = TYPE_INTPTR type_names['guintptr'] = TYPE_UINTPTR type_names['gconstpointer'] = TYPE_ANY # We used to support these; continue to do so type_names['any'] = TYPE_ANY type_names['boolean'] = TYPE_BOOLEAN type_names['uint'] = TYPE_UINT type_names['ulong'] = TYPE_ULONG # C stdio, used in GLib public headers; squash this for now here # until we move scanning into GLib and can (skip) type_names['FILE*'] = TYPE_ANY # One off C unix type definitions; note some of these may be GNU Libc # specific. If someone is actually bitten by this, feel free to do # the required configure goop to determine their size and replace # here. # # We don't want to encourage people to use these in their APIs because # they compromise the platform-independence that GLib gives you. # These are here mostly to avoid blowing when random platform-specific # methods are added under #ifdefs inside GLib itself. We could just (skip) # the relevant methods, but on the other hand, since these types are just # integers it's easy enough to expand them. type_names['size_t'] = type_names['gsize'] type_names['ssize_t'] = type_names['gssize'] type_names['time_t'] = TYPE_LONG type_names['off_t'] = type_names['gsize'] type_names['pid_t'] = TYPE_INT type_names['uid_t'] = TYPE_UINT type_names['gid_t'] = TYPE_UINT type_names['dev_t'] = TYPE_INT type_names['socklen_t'] = TYPE_INT32 # Obj-C type_names['id'] = TYPE_ANY # Parameters PARAM_DIRECTION_IN = 'in' PARAM_DIRECTION_OUT = 'out' PARAM_DIRECTION_INOUT = 'inout' PARAM_SCOPE_CALL = 'call' PARAM_SCOPE_ASYNC = 'async' PARAM_SCOPE_NOTIFIED = 'notified' PARAM_TRANSFER_NONE = 'none' PARAM_TRANSFER_CONTAINER = 'container' PARAM_TRANSFER_FULL = 'full' SIGNAL_FIRST = 'first' SIGNAL_LAST = 'last' SIGNAL_CLEANUP = 'cleanup' SIGNAL_MUST_COLLECT = 'must-collect' class Namespace(object): def __init__(self, name, version, identifier_prefixes=None, symbol_prefixes=None): self.name = name self.version = version if identifier_prefixes is not None: self.identifier_prefixes = identifier_prefixes else: self.identifier_prefixes = [name] if symbol_prefixes is not None: self.symbol_prefixes = symbol_prefixes else: ps = self.identifier_prefixes self.symbol_prefixes = [to_underscores(p).lower() for p in ps] # cache upper-cased versions self._ucase_symbol_prefixes = [p.upper() for p in self.symbol_prefixes] self.names = OrderedDict() # Maps from GIName -> node self.aliases = {} # Maps from GIName -> GIName self.type_names = {} # Maps from GTName -> node self.ctypes = {} # Maps from CType -> node self.symbols = {} # Maps from function symbols -> Function # Immediate includes only, not their transitive closure: self.includes = set() # Include self.shared_libraries = [] # str self.c_includes = [] # str self.exported_packages = [] # str def type_from_name(self, name, ctype=None): """Backwards compatibility method for older .gir files, which only use the 'name' attribute. If name refers to a fundamental type, create a Type object referncing it. If name is already a fully-qualified GIName like 'Foo.Bar', returns a Type targeting it . Otherwise a Type targeting name qualififed with the namespace name is returned.""" if name in type_names: return Type(target_fundamental=name, ctype=ctype) if '.' in name: target = name else: target = '%s.%s' % (self.name, name) return Type(target_giname=target, ctype=ctype) def track(self, node): """Doesn't directly append the function to our own namespace, but adds it to things like ctypes, symbols, and type_names. """ assert isinstance(node, Node) if node.namespace is self: return assert node.namespace is None node.namespace = self if isinstance(node, Alias): self.aliases[node.name] = node elif isinstance(node, Registered) and node.gtype_name is not None: self.type_names[node.gtype_name] = node elif isinstance(node, Function): self.symbols[node.symbol] = node if isinstance(node, (Compound, Class, Interface, Boxed)): for fn in chain(node.methods, node.static_methods, node.constructors): if not isinstance(fn, Function): continue fn.namespace = self self.symbols[fn.symbol] = fn if isinstance(node, (Compound, Class, Interface)): for f in node.fields: f.namespace = self if isinstance(node, (Class, Interface)): for m in chain(node.signals, node.properties): m.namespace = self if isinstance(node, (Enum, Bitfield)): for fn in node.static_methods: if not isinstance(fn, Function): continue fn.namespace = self self.symbols[fn.symbol] = fn for member in node.members: member.namespace = self self.symbols[member.symbol] = member if hasattr(node, 'ctype'): self.ctypes[node.ctype] = node def append(self, node, replace=False): previous = self.names.get(node.name) if previous is not None: if not replace: raise ValueError("Namespace conflict: %r" % (node, )) self.remove(previous) self.track(node) self.names[node.name] = node def remove(self, node): if isinstance(node, Alias): del self.aliases[node.name] elif isinstance(node, Registered) and node.gtype_name is not None: del self.type_names[node.gtype_name] if hasattr(node, 'ctype'): del self.ctypes[node.ctype] if isinstance(node, Function): del self.symbols[node.symbol] node.namespace = None self.names.pop(node.name, None) def float(self, node): """Like remove(), but doesn't unset the node's namespace back-reference, and it's still possible to look up functions via get_by_symbol().""" if isinstance(node, Function): symbol = node.symbol self.remove(node) self.symbols[symbol] = node node.namespace = self def __iter__(self): return iter(self.names) def items(self): return self.names.items() def values(self): return self.names.values() def get(self, name): return self.names.get(name) def get_by_ctype(self, ctype): return self.ctypes.get(ctype) def get_by_symbol(self, symbol): return self.symbols.get(symbol) def walk(self, callback): for node in self.values(): node.walk(callback, []) class Include(object): def __init__(self, name, version): self.name = name self.version = version @classmethod def from_string(cls, string): return cls(*string.split('-', 1)) def _compare(self, other, op): return op((self.name, self.version), (other.name, other.version)) def __lt__(self, other): return self._compare(other, operator.lt) def __gt__(self, other): return self._compare(other, operator.gt) def __ge__(self, other): return self._compare(other, operator.ge) def __le__(self, other): return self._compare(other, operator.le) def __eq__(self, other): return self._compare(other, operator.eq) def __ne__(self, other): return self._compare(other, operator.ne) def __hash__(self): return hash(str(self)) def __str__(self): return '%s-%s' % (self.name, self.version) class Annotated(object): """An object which has a few generic metadata properties.""" def __init__(self): self.version = None self.version_doc = None self.skip = False self.introspectable = True self.attributes = OrderedDict() self.stability = None self.stability_doc = None self.deprecated = None self.deprecated_doc = None self.doc = None class Node(Annotated): """A node is a type of object which is uniquely identified by its (namespace, name) pair. When combined with a ., this is called a GIName. It's possible for nodes to contain or point to other nodes.""" c_name = property(lambda self: self.namespace.name + self.name if self.namespace else self.name) gi_name = property(lambda self: '%s.%s' % (self.namespace.name, self.name)) def __init__(self, name=None): Annotated.__init__(self) self.namespace = None # Should be set later by Namespace.append() self.name = name self.foreign = False self.file_positions = set() self._parent = None def _get_parent(self): if self._parent is not None: return self._parent else: return self.namespace def _set_parent(self, value): self._parent = value parent = property(_get_parent, _set_parent) def create_type(self): """Create a Type object referencing this node.""" assert self.namespace is not None return Type(target_giname=('%s.%s' % (self.namespace.name, self.name))) def _compare(self, other, op): return op((self.namespace, self.name), (other.namespace, other.name)) def __lt__(self, other): return self._compare(other, operator.lt) def __gt__(self, other): return self._compare(other, operator.gt) def __ge__(self, other): return self._compare(other, operator.ge) def __le__(self, other): return self._compare(other, operator.le) def __eq__(self, other): return self._compare(other, operator.eq) def __ne__(self, other): return self._compare(other, operator.ne) def __hash__(self): return hash((self.namespace, self.name)) def __repr__(self): return "%s('%s')" % (self.__class__.__name__, self.name) def inherit_file_positions(self, node): self.file_positions.update(node.file_positions) def add_file_position(self, position): self.file_positions.add(position) def add_symbol_reference(self, symbol): if symbol.source_filename: self.add_file_position(Position(symbol.source_filename, symbol.line)) def walk(self, callback, chain): res = callback(self, chain) assert res in (True, False), "Walk function must return boolean, not %r" % (res, ) if not res: return False chain.append(self) self._walk(callback, chain) chain.pop() def _walk(self, callback, chain): pass class Registered: """A node that (possibly) has gtype_name and get_type.""" def __init__(self, gtype_name, get_type): assert (gtype_name is None and get_type is None) or \ (gtype_name is not None and get_type is not None) self.gtype_name = gtype_name self.get_type = get_type class Callable(Node): def __init__(self, name, retval, parameters, throws): Node.__init__(self, name) self.retval = retval self.parameters = parameters self.throws = not not throws self.instance_parameter = None # Parameter self.parent = None # A Class or Interface def _get_retval(self): return self._retval def _set_retval(self, value): self._retval = value if self._retval is not None: self._retval.parent = self retval = property(_get_retval, _set_retval) def _get_instance_parameter(self): return self._instance_parameter def _set_instance_parameter(self, value): self._instance_parameter = value if value is not None: value.parent = self instance_parameter = property(_get_instance_parameter, _set_instance_parameter) def _get_parameters(self): return self._parameters def _set_parameters(self, value): self._parameters = value for param in self._parameters: param.parent = self parameters = property(_get_parameters, _set_parameters) # Returns all parameters, including the instance parameter @property def all_parameters(self): if self.instance_parameter is not None: return [self.instance_parameter] + self.parameters else: return self.parameters def get_parameter_index(self, name): for i, parameter in enumerate(self.parameters): if parameter.argname == name: return i raise ValueError("Unknown argument %s" % (name, )) def get_parameter(self, name): for parameter in self.all_parameters: if parameter.argname == name: return parameter raise ValueError("Unknown argument %s" % (name, )) class Function(Callable): def __init__(self, name, retval, parameters, throws, symbol): Callable.__init__(self, name, retval, parameters, throws) self.symbol = symbol self.is_method = False self.is_constructor = False self.shadowed_by = None # C symbol string self.shadows = None # C symbol string self.moved_to = None # namespaced function name string self.internal_skipped = False # if True, this func will not be written to GIR def clone(self): clone = copy.copy(self) # copy the parameters array so a change to self.parameters does not # influence clone.parameters. clone.parameters = self.parameters[:] for param in clone.parameters: param.parent = clone return clone def is_type_meta_function(self): # Named correctly if not (self.name.endswith('_get_type') or self.name.endswith('_get_gtype')): return False # Doesn't have any parameters if self.parameters: return False # Returns GType rettype = self.retval.type if (not rettype.is_equiv(TYPE_GTYPE) and rettype.target_giname != 'Gtk.Type'): message.warn("function '%s' returns '%r', not a GType" % (self.name, rettype)) return False return True class ErrorQuarkFunction(Function): def __init__(self, name, retval, parameters, throws, symbol, error_domain): Function.__init__(self, name, retval, parameters, throws, symbol) self.error_domain = error_domain class VFunction(Callable): def __init__(self, name, retval, parameters, throws): Callable.__init__(self, name, retval, parameters, throws) self.invoker = None @classmethod def from_callback(cls, name, cb): obj = cls(name, cb.retval, cb.parameters[1:], cb.throws) return obj class Varargs(Type): def __init__(self): Type.__init__(self, '', target_fundamental='') class Array(Type): C = '' GLIB_ARRAY = 'GLib.Array' GLIB_BYTEARRAY = 'GLib.ByteArray' GLIB_PTRARRAY = 'GLib.PtrArray' def __init__(self, array_type, element_type, **kwargs): Type.__init__(self, target_fundamental='', **kwargs) if (array_type is None or array_type == self.C): self.array_type = self.C else: assert array_type in (self.GLIB_ARRAY, self.GLIB_BYTEARRAY, self.GLIB_PTRARRAY), array_type self.array_type = array_type assert isinstance(element_type, Type) self.element_type = element_type self.zeroterminated = True self.length_param_name = None self.size = None def clone(self): arr = Array(self.array_type, self.element_type) arr.zeroterminated = self.zeroterminated arr.length_param_name = self.length_param_name arr.size = self.size return arr class List(Type): def __init__(self, name, element_type, **kwargs): Type.__init__(self, target_fundamental='', **kwargs) self.name = name assert isinstance(element_type, Type) self.element_type = element_type def clone(self): return List(self.name, self.element_type) class Map(Type): def __init__(self, key_type, value_type, **kwargs): Type.__init__(self, target_fundamental='', **kwargs) assert isinstance(key_type, Type) self.key_type = key_type assert isinstance(value_type, Type) self.value_type = value_type def clone(self): return Map(self.key_type, self.value_type) class Alias(Node): def __init__(self, name, target, ctype=None): Node.__init__(self, name) self.target = target self.ctype = ctype class TypeContainer(Annotated): """A fundamental base class for Return and Parameter.""" def __init__(self, typenode, nullable, not_nullable, transfer, direction): Annotated.__init__(self) self.type = typenode self.nullable = nullable self.not_nullable = not_nullable self.direction = direction if transfer is not None: self.transfer = transfer elif typenode.is_const: self.transfer = PARAM_TRANSFER_NONE else: self.transfer = None class Parameter(TypeContainer): """An argument to a function.""" def __init__(self, argname, typenode, direction=None, transfer=None, nullable=False, optional=False, allow_none=False, scope=None, caller_allocates=False, not_nullable=False): TypeContainer.__init__(self, typenode, nullable, not_nullable, transfer, direction) self.argname = argname self.optional = optional self.parent = None # A Callable if allow_none: if self.direction == PARAM_DIRECTION_OUT: self.optional = True else: self.nullable = True self.scope = scope self.caller_allocates = caller_allocates self.closure_name = None self.destroy_name = None @property def name(self): return self.argname class Return(TypeContainer): """A return value from a function.""" def __init__(self, rtype, nullable=False, not_nullable=False, transfer=None): TypeContainer.__init__(self, rtype, nullable, not_nullable, transfer, direction=PARAM_DIRECTION_OUT) self.parent = None # A Callable class Enum(Node, Registered): def __init__(self, name, ctype, gtype_name=None, get_type=None, c_symbol_prefix=None, members=None): Node.__init__(self, name) Registered.__init__(self, gtype_name, get_type) self.c_symbol_prefix = c_symbol_prefix self.ctype = ctype self.members = members for member in members: member.parent = self # Associated error domain name self.error_domain = None self.static_methods = [] def _walk(self, callback, chain): for meth in self.static_methods: meth.walk(callback, chain) class Bitfield(Node, Registered): def __init__(self, name, ctype, gtype_name=None, c_symbol_prefix=None, get_type=None, members=None): Node.__init__(self, name) Registered.__init__(self, gtype_name, get_type) self.ctype = ctype self.c_symbol_prefix = c_symbol_prefix self.members = members for member in members: member.parent = self self.static_methods = [] def _walk(self, callback, chain): for meth in self.static_methods: meth.walk(callback, chain) class Member(Annotated): def __init__(self, name, value, symbol, nick): Annotated.__init__(self) self.name = name self.value = value self.symbol = symbol self.nick = nick self.parent = None def _compare(self, other, op): return op(self.name, other.name) def __lt__(self, other): return self._compare(other, operator.lt) def __gt__(self, other): return self._compare(other, operator.gt) def __ge__(self, other): return self._compare(other, operator.ge) def __le__(self, other): return self._compare(other, operator.le) def __eq__(self, other): return self._compare(other, operator.eq) def __ne__(self, other): return self._compare(other, operator.ne) def __hash__(self): return hash(self.name) def __repr__(self): return "%s('%s')" % (self.__class__.__name__, self.name) class Compound(Node, Registered): def __init__(self, name, ctype=None, gtype_name=None, get_type=None, c_symbol_prefix=None, disguised=False, tag_name=None): Node.__init__(self, name) Registered.__init__(self, gtype_name, get_type) self.ctype = ctype self.methods = [] self.static_methods = [] self.fields = [] self.constructors = [] self.disguised = disguised self.gtype_name = gtype_name self.get_type = get_type self.c_symbol_prefix = c_symbol_prefix self.tag_name = tag_name def add_gtype(self, gtype_name, get_type): self.gtype_name = gtype_name self.get_type = get_type self.namespace.type_names[gtype_name] = self def _walk(self, callback, chain): for ctor in self.constructors: ctor.walk(callback, chain) for func in self.methods: func.walk(callback, chain) for func in self.static_methods: func.walk(callback, chain) for field in self.fields: if field.anonymous_node is not None: field.anonymous_node.walk(callback, chain) def get_field(self, name): for field in self.fields: if field.name == name: return field raise ValueError("Unknown field %s" % (name, )) def get_field_index(self, name): for i, field in enumerate(self.fields): if field.name == name: return i raise ValueError("Unknown field %s" % (name, )) class Field(Annotated): def __init__(self, name, typenode, readable, writable, bits=None, anonymous_node=None): Annotated.__init__(self) assert (typenode or anonymous_node) self.name = name self.type = typenode self.readable = readable self.writable = writable self.bits = bits self.anonymous_node = anonymous_node self.private = False self.namespace = None self.parent = None # a compound def _compare(self, other, op): return op(self.name, other.name) def __lt__(self, other): return self._compare(other, operator.lt) def __gt__(self, other): return self._compare(other, operator.gt) def __ge__(self, other): return self._compare(other, operator.ge) def __le__(self, other): return self._compare(other, operator.le) def __eq__(self, other): return self._compare(other, operator.eq) def __ne__(self, other): return self._compare(other, operator.ne) def __hash__(self): return hash(self.name) def __repr__(self): return "%s('%s')" % (self.__class__.__name__, self.name) class Record(Compound): def __init__(self, name, ctype=None, gtype_name=None, get_type=None, c_symbol_prefix=None, disguised=False, tag_name=None): Compound.__init__(self, name, ctype=ctype, gtype_name=gtype_name, get_type=get_type, c_symbol_prefix=c_symbol_prefix, disguised=disguised, tag_name=tag_name) # If non-None, this record defines the FooClass C structure # for some Foo GObject (or similar for GInterface) self.is_gtype_struct_for = None class Union(Compound): def __init__(self, name, ctype=None, gtype_name=None, get_type=None, c_symbol_prefix=None, disguised=False, tag_name=None): Compound.__init__(self, name, ctype=ctype, gtype_name=gtype_name, get_type=get_type, c_symbol_prefix=c_symbol_prefix, disguised=disguised, tag_name=tag_name) class Boxed(Node, Registered): """A boxed type with no known associated structure/union.""" def __init__(self, name, gtype_name=None, get_type=None, c_symbol_prefix=None): assert gtype_name is not None assert get_type is not None Node.__init__(self, name) Registered.__init__(self, gtype_name, get_type) if get_type is not None: assert c_symbol_prefix is not None self.c_symbol_prefix = c_symbol_prefix self.constructors = [] self.methods = [] self.static_methods = [] def _walk(self, callback, chain): for ctor in self.constructors: ctor.walk(callback, chain) for meth in self.methods: meth.walk(callback, chain) for meth in self.static_methods: meth.walk(callback, chain) class Signal(Callable): def __init__(self, name, retval, parameters, when=None, no_recurse=False, detailed=False, action=False, no_hooks=False): Callable.__init__(self, name, retval, parameters, False) self.when = when self.no_recurse = no_recurse self.detailed = detailed self.action = action self.no_hooks = no_hooks class Class(Node, Registered): def __init__(self, name, parent_type, ctype=None, gtype_name=None, get_type=None, c_symbol_prefix=None, is_abstract=False): Node.__init__(self, name) Registered.__init__(self, gtype_name, get_type) self.ctype = ctype self.c_symbol_prefix = c_symbol_prefix self.parent_type = parent_type self.fundamental = False self.unref_func = None self.ref_func = None self.set_value_func = None self.get_value_func = None # When we're in the scanner, we keep around a list # of parents so that we can transparently fall back # if there are 'hidden' parents self.parent_chain = [] self.glib_type_struct = None self.is_abstract = is_abstract self.methods = [] self.virtual_methods = [] self.static_methods = [] self.interfaces = [] self.constructors = [] self.properties = [] self.fields = [] self.signals = [] def _walk(self, callback, chain): for meth in self.methods: meth.walk(callback, chain) for meth in self.virtual_methods: meth.walk(callback, chain) for meth in self.static_methods: meth.walk(callback, chain) for ctor in self.constructors: ctor.walk(callback, chain) for field in self.fields: if field.anonymous_node: field.anonymous_node.walk(callback, chain) for sig in self.signals: sig.walk(callback, chain) for prop in self.properties: prop.walk(callback, chain) class Interface(Node, Registered): def __init__(self, name, parent_type, ctype=None, gtype_name=None, get_type=None, c_symbol_prefix=None): Node.__init__(self, name) Registered.__init__(self, gtype_name, get_type) self.ctype = ctype self.c_symbol_prefix = c_symbol_prefix self.parent_type = parent_type self.parent_chain = [] self.methods = [] self.signals = [] self.static_methods = [] self.virtual_methods = [] self.glib_type_struct = None self.properties = [] self.fields = [] self.prerequisites = [] # Not used yet, exists just to avoid an exception in # Namespace.append() self.constructors = [] def _walk(self, callback, chain): for meth in self.methods: meth.walk(callback, chain) for meth in self.static_methods: meth.walk(callback, chain) for meth in self.virtual_methods: meth.walk(callback, chain) for field in self.fields: if field.anonymous_node: field.anonymous_node.walk(callback, chain) for sig in self.signals: sig.walk(callback, chain) class Constant(Node): def __init__(self, name, value_type, value, ctype): Node.__init__(self, name) self.value_type = value_type self.value = value self.ctype = ctype class Property(Node): def __init__(self, name, typeobj, readable, writable, construct, construct_only, transfer=None): Node.__init__(self, name) self.type = typeobj self.readable = readable self.writable = writable self.construct = construct self.construct_only = construct_only if transfer is None: self.transfer = PARAM_TRANSFER_NONE else: self.transfer = transfer self.parent = None # A Class or Interface class Callback(Callable): def __init__(self, name, retval, parameters, throws, ctype=None): Callable.__init__(self, name, retval, parameters, throws) self.ctype = ctype