git.roojs.org Git - gnome.gobject-introspection/blob - 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 type_names = {}
  82 for name in GIR_TYPES:
  83     type_names[name] = name
  84
  85 # C
  86 type_names['char'] = TYPE_INT8
  87 type_names['unsigned char'] = TYPE_UINT8
  88 type_names['short'] = TYPE_INT16
  89 type_names['unsigned short'] = TYPE_UINT16
  90 type_names['int'] = TYPE_INT
  91 type_names['unsigned int'] = TYPE_UINT
  92 type_names['unsigned'] = TYPE_UINT
  93 type_names['long'] = TYPE_LONG
  94 type_names['unsigned long'] = TYPE_ULONG
  95 type_names['float'] = TYPE_FLOAT
  96 type_names['double'] = TYPE_DOUBLE
  97 type_names['char*'] = TYPE_STRING
  98 type_names['void*'] = TYPE_ANY
  99 type_names['void'] = TYPE_NONE
 100 type_names['size_t'] = TYPE_SIZET
 101 type_names['ssize_t'] = TYPE_SSIZET
 102 # FIXME - can we make libraries use GPid?
 103 type_names['pid_t'] = TYPE_INT
 104
 105 # Suppress some GLib names
 106 type_names['uchar'] = TYPE_UINT8
 107 type_names['ushort'] = TYPE_UINT16
 108 type_names['size'] = TYPE_SIZET
 109 type_names['ssize'] = TYPE_SSIZET
 110 type_names['pointer'] = TYPE_ANY
 111 type_names['constpointer'] = TYPE_ANY
 112
 113
 114 # These types, when seen by reference, are converted into an Array()
 115 # by default
 116 default_array_types = {}
 117 default_array_types['uint8*'] = TYPE_UINT8
 118 default_array_types['char**'] = TYPE_STRING
 119
 120
 121 def type_name_from_ctype(ctype):
 122     return type_names.get(ctype, ctype)
 123
 124
 125 class Node(object):
 126
 127     def __init__(self, name=None):
 128         self.name = name
 129         self.deprecated = None
 130         self.deprecated_version = None
 131
 132     def __repr__(self):
 133         return '%s(%r)' % (self.__class__.__name__, self.name)
 134
 135
 136 class Namespace(Node):
 137
 138     def __init__(self, name):
 139         Node.__init__(self, name)
 140         self.nodes = []
 141
 142     def __repr__(self):
 143         return '%s(%r, %r)' % (self.__class__.__name__, self.name,
 144                                self.nodes)
 145
 146
 147 class Function(Node):
 148
 149     def __init__(self, name, retval, parameters, symbol):
 150         Node.__init__(self, name)
 151         self.retval = retval
 152         self.parameters = parameters
 153         self.symbol = symbol
 154
 155     def __repr__(self):
 156         return '%s(%r, %r, %r)' % (self.__class__.__name__,
 157                                    self.name, self.retval,
 158                                    self.parameters)
 159
 160
 161 class VFunction(Function):
 162     pass
 163
 164
 165 class Type(Node):
 166
 167     def __init__(self, name, ctype=None):
 168         Node.__init__(self, name)
 169         self.ctype = ctype
 170         self.resolved = False
 171
 172
 173 class Varargs(Type):
 174
 175     def __init__(self):
 176         Type.__init__(self, '<varargs>')
 177
 178
 179 class Array(Type):
 180
 181     def __init__(self, ctype, element_type):
 182         Type.__init__(self, '<carray>', ctype)
 183         self.element_type = element_type
 184         self.zeroterminated = True
 185         self.length_param_index = -1
 186         self.length_param_name = None
 187
 188     def __repr__(self):
 189         return 'Array(%r of %r)' % (self.name, self.element_type, )
 190
 191
 192 class List(Type):
 193
 194     def __init__(self, name, ctype, element_type):
 195         Type.__init__(self, name, ctype)
 196         self.element_type = element_type
 197
 198     def __repr__(self):
 199         return 'List(%r of %r)' % (self.name, self.element_type, )
 200
 201
 202 class Map(Type):
 203
 204     def __init__(self, name, ctype, key_type, value_type):
 205         Type.__init__(self, name, ctype)
 206         self.key_type = key_type
 207         self.value_type = value_type
 208
 209     def __repr__(self):
 210         return 'Map(%r <%r,%r.)' % (self.name, self.key_type, self.value_type)
 211
 212
 213 class Alias(Node):
 214
 215     def __init__(self, name, target, ctype=None):
 216         Node.__init__(self, name)
 217         self.target = target
 218         self.ctype = ctype
 219
 220     def __repr__(self):
 221         return 'Alias(%r, %r)' % (self.name, self.target)
 222
 223
 224 class Parameter(Node):
 225
 226     def __init__(self, name, typenode):
 227         Node.__init__(self, name)
 228         self.type = typenode
 229         self.direction = PARAM_DIRECTION_IN
 230         self.transfer = None
 231         self.allow_none = False
 232
 233     def __repr__(self):
 234         return 'Parameter(%r, %r)' % (self.name, self.type)
 235
 236
 237 class Enum(Node):
 238
 239     def __init__(self, name, symbol, members):
 240         Node.__init__(self, name)
 241         self.symbol = symbol
 242         self.members = members
 243
 244     def __repr__(self):
 245         return 'Enum(%r, %r)' % (self.name, self.members)
 246
 247
 248 class Member(Node):
 249
 250     def __init__(self, name, value, symbol):
 251         Node.__init__(self, name)
 252         self.value = value
 253         self.symbol = symbol
 254
 255     def __repr__(self):
 256         return 'Member(%r, %r)' % (self.name, self.value)
 257
 258
 259 class Struct(Node):
 260
 261     def __init__(self, name, symbol):
 262         Node.__init__(self, name)
 263         self.fields = []
 264         self.constructors = []
 265         self.symbol = symbol
 266
 267
 268 class Field(Node):
 269
 270     def __init__(self, name, typenode, symbol, bits=None):
 271         Node.__init__(self, name)
 272         self.type = typenode
 273         self.symbol = symbol
 274         self.bits = bits
 275
 276     def __repr__(self):
 277         if self.bits:
 278             return 'Field(%r, %r, %r)' % (self.name, self.type, self.bits)
 279         else:
 280             return 'Field(%r, %r)' % (self.name, self.type)
 281
 282
 283 class Return(Node):
 284
 285     def __init__(self, rtype, transfer=None):
 286         Node.__init__(self)
 287         self.type = rtype
 288         if transfer is None and rtype.name in ['utf8', 'filename']:
 289             self.transfer = 'full'
 290         else:
 291             self.transfer = transfer
 292
 293     def __repr__(self):
 294         return 'Return(%r)' % (self.type, )
 295
 296
 297 class Class(Node):
 298
 299     def __init__(self, name, parent):
 300         Node.__init__(self, name)
 301         self.ctype = name
 302         self.parent = parent
 303         self.methods = []
 304         self.interfaces = []
 305         self.constructors = []
 306         self.properties = []
 307         self.fields = []
 308
 309     def __repr__(self):
 310         return '%s(%r, %r, %r)' % (
 311             self.__class__.__name__,
 312             self.name, self.parent, self.methods)
 313
 314
 315 class Interface(Node):
 316
 317     def __init__(self, name, parent):
 318         Node.__init__(self, name)
 319         self.parent = parent
 320         self.methods = []
 321         self.properties = []
 322         self.fields = []
 323
 324     def __repr__(self):
 325         return '%s(%r, %r)' % (
 326             self.__class__.__name__,
 327             self.name, self.methods)
 328
 329
 330 class Constant(Node):
 331
 332     def __init__(self, name, type_name, value):
 333         Node.__init__(self, name)
 334         self.type = Type(type_name)
 335         self.value = value
 336
 337     def __repr__(self):
 338         return 'Constant(%r, %r, %r)' % (
 339             self.name, self.type, self.value)
 340
 341
 342 class Property(Node):
 343
 344     def __init__(self, name, type_name, readable, writable,
 345                  construct, construct_only, ctype=None):
 346         Node.__init__(self, name)
 347         self.type = Type(type_name, ctype)
 348         self.readable = readable
 349         self.writable = writable
 350         self.construct = construct
 351         self.construct_only = construct_only
 352
 353     def __repr__(self):
 354         return '%s(%r, %r, %r)' % (
 355             self.__class__.__name__,
 356             self.name, self.type, self.value)
 357
 358
 359 # FIXME: Inherit from Function
 360
 361
 362 class Callback(Node):
 363
 364     def __init__(self, name, retval, parameters, ctype=None):
 365         Node.__init__(self, name)
 366         self.retval = retval
 367         self.parameters = parameters
 368         self.ctype = ctype
 369
 370     def __repr__(self):
 371         return 'Callback(%r, %r, %r)' % (
 372             self.name, self.retval, self.parameters)
 373
 374
 375 class Union(Node):
 376
 377     def __init__(self, name, symbol):
 378         Node.__init__(self, name)
 379         self.fields = []
 380         self.constructors = []
 381         self.symbol = symbol
 382
 383     def __repr__(self):
 384         return 'Union(%r, %r)' % (self.name, self.fields, )