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_FLOAT = 'float'
  51 TYPE_DOUBLE = 'double'
  52 TYPE_STRING = 'string' # requires zero-terminated
  53 TYPE_FILENAME = 'filename'
  54
  55 BASIC_GIR_TYPES = [TYPE_BOOLEAN, TYPE_INT8, TYPE_UINT8, TYPE_INT16,
  56                    TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64,
  57                    TYPE_UINT64, TYPE_INT, TYPE_UINT, TYPE_LONG,
  58                    TYPE_ULONG, TYPE_SSIZET, TYPE_SIZET, TYPE_FLOAT,
  59                    TYPE_DOUBLE]
  60 GIR_TYPES = [TYPE_NONE, TYPE_ANY]
  61 GIR_TYPES.extend(BASIC_GIR_TYPES)
  62 GIR_TYPES.extend([TYPE_STRING, TYPE_FILENAME])
  63
  64 # Higher-level data types
  65 TYPE_SEQUENCE = 'sequence' # Sequence of something
  66
  67 # Wide/Unicode
  68 TYPE_UCHAR = 'uchar'
  69 TYPE_USTRING = 'ustring'
  70
  71 ##
  72 ## Parameters
  73 ##
  74
  75 PARAM_DIRECTION_IN = 'in'
  76 PARAM_DIRECTION_OUT = 'out'
  77 PARAM_DIRECTION_INOUT = 'inout'
  78
  79 type_names = {}
  80 for name in GIR_TYPES:
  81     type_names[name] = name
  82
  83 # C
  84 type_names['char'] = TYPE_INT8
  85 type_names['unsigned char'] = TYPE_UINT8
  86 type_names['short'] = TYPE_INT16
  87 type_names['unsigned short'] = TYPE_UINT16
  88 type_names['int'] = TYPE_INT
  89 type_names['unsigned int'] = TYPE_UINT
  90 type_names['long'] = TYPE_LONG
  91 type_names['unsigned long'] = TYPE_ULONG
  92 type_names['float'] = TYPE_FLOAT
  93 type_names['double'] = TYPE_DOUBLE
  94 type_names['char*'] = TYPE_STRING
  95 type_names['void*'] = TYPE_ANY
  96 type_names['void'] = TYPE_NONE
  97 type_names['size_t'] = TYPE_SIZET
  98 type_names['ssize_t'] = TYPE_SSIZET
  99 type_names['time_t'] = TYPE_LONG
 100
 101 # Suppress some GLib names
 102 type_names['uchar'] = TYPE_UINT8
 103 type_names['ushort'] = TYPE_UINT16
 104 type_names['pointer'] = TYPE_ANY
 105 type_names['constpointer'] = TYPE_ANY
 106
 107 def type_name_from_ctype(ctype):
 108     return type_names.get(ctype, ctype)
 109
 110
 111 class Node(object):
 112
 113     def __init__(self, name=None):
 114         self.name = name
 115
 116     def __repr__(self):
 117         return '%s(%r)' % (self.__class__.__name__, self.name)
 118
 119
 120 class Namespace(Node):
 121
 122     def __init__(self, name):
 123         Node.__init__(self, name)
 124         self.nodes = []
 125
 126     def __repr__(self):
 127         return '%s(%r, %r)' % (self.__class__.__name__, self.name,
 128                                self.nodes)
 129
 130
 131 class Function(Node):
 132
 133     def __init__(self, name, retval, parameters, symbol):
 134         Node.__init__(self, name)
 135         self.retval = retval
 136         self.parameters = parameters
 137         self.symbol = symbol
 138
 139     def __repr__(self):
 140         return '%s(%r, %r, %r)' % (self.__class__.__name__,
 141                                    self.name, self.retval,
 142                                    self.parameters)
 143
 144
 145 class VFunction(Function):
 146     pass
 147
 148
 149 class Type(Node):
 150
 151     def __init__(self, name, ctype=None):
 152         Node.__init__(self, name)
 153         self.ctype = ctype
 154         self.resolved = False
 155
 156
 157 class Alias(Node):
 158
 159     def __init__(self, name, target, ctype=None):
 160         Node.__init__(self, name)
 161         self.target = target
 162         self.ctype = ctype
 163
 164     def __repr__(self):
 165         return 'Alias(%r, %r)' % (self.name, self.target)
 166
 167
 168 class Parameter(Node):
 169
 170     def __init__(self, name, typenode):
 171         Node.__init__(self, name)
 172         self.type = typenode
 173         self.direction = PARAM_DIRECTION_IN
 174         self.transfer = False
 175         self.allow_none = False
 176
 177     def __repr__(self):
 178         return 'Parameter(%r, %r)' % (self.name, self.type)
 179
 180
 181 class Enum(Node):
 182
 183     def __init__(self, name, symbol, members):
 184         Node.__init__(self, name)
 185         self.symbol = symbol
 186         self.members = members
 187
 188     def __repr__(self):
 189         return 'Enum(%r, %r)' % (self.name, self.members)
 190
 191
 192 class Member(Node):
 193
 194     def __init__(self, name, value, symbol):
 195         Node.__init__(self, name)
 196         self.value = value
 197         self.symbol = symbol
 198
 199     def __repr__(self):
 200         return 'Member(%r, %r)' % (self.name, self.value)
 201
 202
 203 class Struct(Node):
 204
 205     def __init__(self, name, symbol):
 206         Node.__init__(self, name)
 207         self.fields = []
 208         self.symbol = symbol
 209
 210
 211 class Field(Node):
 212
 213     def __init__(self, name, typenode, symbol):
 214         Node.__init__(self, name)
 215         self.type = typenode
 216         self.symbol = symbol
 217
 218     def __repr__(self):
 219         return 'Field(%r, %r)' % (self.name, self.type)
 220
 221
 222 class Return(Node):
 223
 224     def __init__(self, rtype):
 225         Node.__init__(self)
 226         self.type = rtype
 227         self.transfer = False
 228
 229     def __repr__(self):
 230         return 'Return(%r)' % (self.type, )
 231
 232
 233 class Class(Node):
 234
 235     def __init__(self, name, parent):
 236         Node.__init__(self, name)
 237         self.ctype = name
 238         self.parent = parent
 239         self.methods = []
 240         self.constructors = []
 241         self.properties = []
 242         self.fields = []
 243
 244     def __repr__(self):
 245         return '%s(%r, %r, %r)' % (
 246             self.__class__.__name__,
 247             self.name, self.parent, self.methods)
 248
 249
 250 class Interface(Node):
 251
 252     def __init__(self, name, parent):
 253         Node.__init__(self, name)
 254         self.parent = parent
 255         self.methods = []
 256         self.properties = []
 257         self.fields = []
 258
 259     def __repr__(self):
 260         return '%s(%r, %r)' % (
 261             self.__class__.__name__,
 262             self.name, self.methods)
 263
 264
 265 class Constant(Node):
 266
 267     def __init__(self, name, type_name, value):
 268         Node.__init__(self, name)
 269         self.type = Type(type_name)
 270         self.value = value
 271
 272     def __repr__(self):
 273         return 'Constant(%r, %r, %r)' % (
 274             self.name, self.type, self.value)
 275
 276
 277 class Property(Node):
 278
 279     def __init__(self, name, type_name, ctype=None):
 280         Node.__init__(self, name)
 281         self.type = Type(type_name, ctype)
 282
 283     def __repr__(self):
 284         return '%s(%r, %r, %r)' % (
 285             self.__class__.__name__,
 286             self.name, self.type, self.value)
 287
 288
 289 # FIXME: Inherit from Function
 290
 291
 292 class Callback(Node):
 293
 294     def __init__(self, name, retval, parameters, ctype=None):
 295         Node.__init__(self, name)
 296         self.retval = retval
 297         self.parameters = parameters
 298         self.ctype = ctype
 299
 300     def __repr__(self):
 301         return 'Callback(%r, %r, %r)' % (
 302             self.name, self.retval, self.parameters)
 303
 304
 305 class Sequence(Type):
 306     # Subclass, because a Sequence is a kind of Type
 307
 308     def __init__(self, name, ctype, element_type):
 309         Type.__init__(self, name, ctype)
 310         self.element_type = element_type
 311         self.transfer = False
 312
 313     def __repr__(self):
 314         return 'Sequence(%r of %r)' % (self.name, self.element_type, )
 315
 316
 317 class Union(Node):
 318
 319     def __init__(self, name, symbol):
 320         Node.__init__(self, name)
 321         self.fields = []
 322         self.symbol = symbol
 323
 324     def __repr__(self):
 325         return 'Union(%r, %r)' % (self.name, self.fields, )