giscanner/ast.py

   1 # -*- Mode: Python -*-
   2 # GObject-Introspection - a framework for introspecting GObject libraries
   3 # Copyright (C) 2008  Johan Dahlin
   4 #
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18 # 02110-1301, USA.
  19 #
  20
  21 """AST nodes
  22 This file descbribes abstract data type nodes independent on the
  23 implementation language.
  24
  25 These can later on be extended (eg subclassed) with additional information
  26 which is language/library/domain specific.
  27 """
  28
  29 ##
  30 ## Basic types, modeled on GITypeTag but not equivalent
  31 ##
  32
  33 TYPE_NONE = 'none' # We differ from repository on these first two
  34 TYPE_ANY = 'any'
  35 TYPE_BOOLEAN = 'boolean'
  36 TYPE_INT8 = 'int8'
  37 TYPE_UINT8 = 'uint8'
  38 TYPE_INT16 = 'int16'
  39 TYPE_UINT16 = 'uint16'
  40 TYPE_INT = 'int'
  41 TYPE_UINT = 'uint'
  42 TYPE_INT32 = 'int32'
  43 TYPE_UINT32 = 'uint32'
  44 TYPE_INT64 = 'int64'
  45 TYPE_UINT64 = 'uint64'
  46 TYPE_LONG = 'long'
  47 TYPE_ULONG = 'ulong'
  48 TYPE_SSIZET = 'ssize_t'
  49 TYPE_SIZET = 'size_t'
  50 TYPE_TIMET = 'time_t'
  51 TYPE_GTYPE = 'GType'
  52 TYPE_FLOAT = 'float'
  53 TYPE_DOUBLE = 'double'
  54 TYPE_STRING = 'utf8' # requires zero-terminated
  55 TYPE_FILENAME = 'filename'
  56
  57 BASIC_GIR_TYPES = [TYPE_BOOLEAN, TYPE_INT8, TYPE_UINT8, TYPE_INT16,
  58                    TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64,
  59                    TYPE_UINT64, TYPE_INT, TYPE_UINT, TYPE_LONG,
  60                    TYPE_ULONG, TYPE_SSIZET, TYPE_SIZET, TYPE_FLOAT,
  61                    TYPE_DOUBLE, TYPE_TIMET, TYPE_GTYPE]
  62 GIR_TYPES = [TYPE_NONE, TYPE_ANY]
  63 GIR_TYPES.extend(BASIC_GIR_TYPES)
  64 GIR_TYPES.extend([TYPE_STRING, TYPE_FILENAME])
  65
  66 # Higher-level data types
  67 TYPE_SEQUENCE = 'sequence' # Sequence of something
  68
  69 # Wide/Unicode
  70 TYPE_UCHAR = 'uchar'
  71 TYPE_USTRING = 'ustring'
  72
  73 ##
  74 ## Parameters
  75 ##
  76
  77 PARAM_DIRECTION_IN = 'in'
  78 PARAM_DIRECTION_OUT = 'out'
  79 PARAM_DIRECTION_INOUT = 'inout'
  80
  81 PARAM_TRANSFER_NONE = 'none'
  82 PARAM_TRANSFER_CONTAINER = 'container'
  83 PARAM_TRANSFER_FULL = 'full'
  84
  85 type_names = {}
  86 for name in GIR_TYPES:
  87     type_names[name] = name
  88
  89 # C
  90 type_names['char'] = TYPE_INT8
  91 type_names['signed char'] = TYPE_INT8
  92 type_names['unsigned char'] = TYPE_UINT8
  93 type_names['short'] = TYPE_INT16
  94 type_names['signed short'] = TYPE_INT16
  95 type_names['unsigned short'] = TYPE_UINT16
  96 type_names['int'] = TYPE_INT
  97 type_names['signed int'] = TYPE_INT
  98 type_names['signed'] = TYPE_INT
  99 type_names['unsigned int'] = TYPE_UINT
 100 type_names['unsigned'] = TYPE_UINT
 101 type_names['long'] = TYPE_LONG
 102 type_names['signed long'] = TYPE_LONG
 103 type_names['unsigned long'] = TYPE_ULONG
 104 type_names['float'] = TYPE_FLOAT
 105 type_names['double'] = TYPE_DOUBLE
 106 type_names['char*'] = TYPE_STRING
 107 type_names['void*'] = TYPE_ANY
 108 type_names['void'] = TYPE_NONE
 109 type_names['size_t'] = TYPE_SIZET
 110 type_names['ssize_t'] = TYPE_SSIZET
 111 type_names['off_t'] = TYPE_SIZET
 112 # FIXME - can we make libraries use GPid?
 113 type_names['pid_t'] = TYPE_INT
 114
 115 # Obj-C
 116 type_names['id'] = TYPE_ANY
 117
 118 # Suppress some GLib names
 119 type_names['uchar'] = TYPE_UINT8
 120 type_names['ushort'] = TYPE_UINT16
 121 type_names['size'] = TYPE_SIZET
 122 type_names['ssize'] = TYPE_SSIZET
 123 type_names['pointer'] = TYPE_ANY
 124 type_names['constpointer'] = TYPE_ANY
 125
 126
 127 # These types, when seen by reference, are converted into an Array()
 128 # by default
 129 # If you add/change these, be sure to update glibast.py too
 130 default_array_types = {}
 131 default_array_types['uint8*'] = TYPE_UINT8
 132 default_array_types['char**'] = TYPE_STRING
 133
 134 # These types, when seen by reference, are interpreted as out parameters
 135 default_out_types = (TYPE_INT, TYPE_UINT, TYPE_LONG, TYPE_ULONG,
 136                      TYPE_FLOAT, TYPE_DOUBLE, TYPE_SIZET, TYPE_SSIZET)
 137
 138
 139 def type_name_from_ctype(ctype):
 140     return type_names.get(ctype, ctype)
 141
 142
 143 class Node(object):
 144
 145     def __init__(self, name=None):
 146         self.name = name
 147         self.deprecated = None
 148         self.deprecated_version = None
 149
 150     def __repr__(self):
 151         return '%s(%r)' % (self.__class__.__name__, self.name)
 152
 153
 154 class Namespace(Node):
 155
 156     def __init__(self, name, version):
 157         Node.__init__(self, name)
 158         self.version = version
 159         self.nodes = []
 160
 161     def __repr__(self):
 162         return '%s(%r, %r, %r)' % (self.__class__.__name__, self.name,
 163                                    self.version, self.nodes)
 164
 165
 166 class Include(Node):
 167
 168     def __init__(self, name, version):
 169         Node.__init__(self, 'include')
 170         self.name = name
 171         self.version = version
 172
 173     @classmethod
 174     def from_string(self, string):
 175         return Include(*string.split('-', 1))
 176
 177     def __cmp__(self, other):
 178         if not isinstance(other, Include):
 179             return cmp(self, other)
 180         namecmp = cmp(self.name, other.name)
 181         if namecmp != 0:
 182             return namecmp
 183         return cmp(self.version, other.version)
 184
 185     def __hash__(self):
 186         return hash((self.name, self.version))
 187
 188     def __str__(self):
 189         return '%s-%s' % (self.name, self.version)
 190
 191
 192 class Function(Node):
 193
 194     def __init__(self, name, retval, parameters, symbol, throws=None):
 195         Node.__init__(self, name)
 196         self.retval = retval
 197         self.parameters = parameters
 198         self.symbol = symbol
 199         self.throws = not not throws
 200
 201     def __repr__(self):
 202         return '%s(%r, %r, %r)' % (self.__class__.__name__,
 203                                    self.name, self.retval,
 204                                    self.parameters)
 205
 206
 207 class VFunction(Function):
 208     pass
 209
 210
 211 class Type(Node):
 212
 213     def __init__(self, name, ctype=None):
 214         Node.__init__(self, name)
 215         self.ctype = ctype
 216         self.resolved = False
 217
 218
 219 class Varargs(Type):
 220
 221     def __init__(self):
 222         Type.__init__(self, '<varargs>')
 223
 224
 225 class Array(Type):
 226
 227     def __init__(self, ctype, element_type):
 228         Type.__init__(self, '<carray>', ctype)
 229         self.element_type = element_type
 230         self.zeroterminated = True
 231         self.length_param_index = -1
 232         self.length_param_name = None
 233         self.size = None
 234
 235     def __repr__(self):
 236         return 'Array(%r of %r)' % (self.name, self.element_type, )
 237
 238
 239 class List(Type):
 240
 241     def __init__(self, name, ctype, element_type):
 242         Type.__init__(self, name, ctype)
 243         self.element_type = element_type
 244
 245     def __repr__(self):
 246         return 'List(%r of %r)' % (self.name, self.element_type, )
 247
 248
 249 class Map(Type):
 250
 251     def __init__(self, name, ctype, key_type, value_type):
 252         Type.__init__(self, name, ctype)
 253         self.key_type = key_type
 254         self.value_type = value_type
 255
 256     def __repr__(self):
 257         return 'Map(%r <%r,%r.)' % (self.name, self.key_type, self.value_type)
 258
 259
 260 class Alias(Node):
 261
 262     def __init__(self, name, target, ctype=None):
 263         Node.__init__(self, name)
 264         self.target = target
 265         self.ctype = ctype
 266
 267     def __repr__(self):
 268         return 'Alias(%r, %r)' % (self.name, self.target)
 269
 270
 271 class TypeContainer(Node):
 272
 273     def __init__(self, name, typenode, transfer):
 274         Node.__init__(self, name)
 275         self.type = typenode
 276         if transfer in [PARAM_TRANSFER_NONE, PARAM_TRANSFER_CONTAINER,
 277                         PARAM_TRANSFER_FULL]:
 278             self.transfer = transfer
 279         else:
 280             self.transfer = None
 281
 282         # transformer.py overrides this as needed
 283         self.transfer_inferred = False
 284
 285
 286 class Parameter(TypeContainer):
 287
 288     def __init__(self, name, typenode, direction=PARAM_DIRECTION_IN,
 289                  transfer=None, allow_none=False):
 290         TypeContainer.__init__(self, name, typenode, transfer)
 291         if direction in [PARAM_DIRECTION_IN, PARAM_DIRECTION_OUT,
 292                          PARAM_DIRECTION_INOUT]:
 293             self.direction = direction
 294         else:
 295             self.direction = PARAM_DIRECTION_IN
 296
 297         self.allow_none = not not allow_none
 298
 299     def __repr__(self):
 300         return 'Parameter(%r, %r)' % (self.name, self.type)
 301
 302
 303 class Enum(Node):
 304
 305     def __init__(self, name, symbol, members):
 306         Node.__init__(self, name)
 307         self.symbol = symbol
 308         self.members = members
 309
 310     def __repr__(self):
 311         return 'Enum(%r, %r)' % (self.name, self.members)
 312
 313
 314 class Member(Node):
 315
 316     def __init__(self, name, value, symbol):
 317         Node.__init__(self, name)
 318         self.value = value
 319         self.symbol = symbol
 320
 321     def __repr__(self):
 322         return 'Member(%r, %r)' % (self.name, self.value)
 323
 324
 325 class Struct(Node):
 326
 327     def __init__(self, name, symbol):
 328         Node.__init__(self, name)
 329         self.fields = []
 330         self.constructors = []
 331         self.symbol = symbol
 332
 333
 334 class Field(Node):
 335
 336     def __init__(self, name, typenode, symbol, readable, writable, bits=None):
 337         Node.__init__(self, name)
 338         self.type = typenode
 339         self.symbol = symbol
 340         self.readable = readable
 341         self.writable = writable
 342         self.bits = bits
 343
 344     def __repr__(self):
 345         if self.bits:
 346             return 'Field(%r, %r, %r)' % (self.name, self.type, self.bits)
 347         else:
 348             return 'Field(%r, %r)' % (self.name, self.type)
 349
 350
 351 class Return(TypeContainer):
 352
 353     def __init__(self, rtype, transfer=None):
 354         TypeContainer.__init__(self, None, rtype, transfer)
 355
 356     def __repr__(self):
 357         return 'Return(%r)' % (self.type, )
 358
 359
 360 class Class(Node):
 361
 362     def __init__(self, name, parent, is_abstract):
 363         Node.__init__(self, name)
 364         self.ctype = name
 365         self.parent = parent
 366         self.is_abstract = is_abstract
 367         self.methods = []
 368         self.interfaces = []
 369         self.constructors = []
 370         self.properties = []
 371         self.fields = []
 372
 373     def __repr__(self):
 374         return '%s(%r, %r, %r)' % (
 375             self.__class__.__name__,
 376             self.name, self.parent, self.methods)
 377
 378
 379 class Interface(Node):
 380
 381     def __init__(self, name, parent):
 382         Node.__init__(self, name)
 383         self.parent = parent
 384         self.methods = []
 385         self.properties = []
 386         self.fields = []
 387
 388     def __repr__(self):
 389         return '%s(%r, %r)' % (
 390             self.__class__.__name__,
 391             self.name, self.methods)
 392
 393
 394 class Constant(Node):
 395
 396     def __init__(self, name, type_name, value):
 397         Node.__init__(self, name)
 398         self.type = Type(type_name)
 399         self.value = value
 400
 401     def __repr__(self):
 402         return 'Constant(%r, %r, %r)' % (
 403             self.name, self.type, self.value)
 404
 405
 406 class Property(Node):
 407
 408     def __init__(self, name, type_name, readable, writable,
 409                  construct, construct_only, ctype=None):
 410         Node.__init__(self, name)
 411         self.type = Type(type_name, ctype)
 412         self.readable = readable
 413         self.writable = writable
 414         self.construct = construct
 415         self.construct_only = construct_only
 416
 417     def __repr__(self):
 418         return '%s(%r, %r)' % (
 419             self.__class__.__name__,
 420             self.name, self.type)
 421
 422
 423 # FIXME: Inherit from Function
 424
 425
 426 class Callback(Node):
 427
 428     def __init__(self, name, retval, parameters, ctype=None):
 429         Node.__init__(self, name)
 430         self.retval = retval
 431         self.parameters = parameters
 432         self.ctype = ctype
 433
 434     def __repr__(self):
 435         return 'Callback(%r, %r, %r)' % (
 436             self.name, self.retval, self.parameters)
 437
 438
 439 class Union(Node):
 440
 441     def __init__(self, name, symbol):
 442         Node.__init__(self, name)
 443         self.fields = []
 444         self.constructors = []
 445         self.symbol = symbol
 446
 447     def __repr__(self):
 448         return 'Union(%r, %r)' % (self.name, self.fields, )