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 # FIXME - we should be evaluating these per-platform; maybe check glibconfig.h?
 100 type_names['time_t'] = TYPE_LONG
 101 type_names['pid_t'] = TYPE_INT
 102
 103 # Suppress some GLib names
 104 type_names['uchar'] = TYPE_UINT8
 105 type_names['ushort'] = TYPE_UINT16
 106 type_names['size'] = TYPE_SIZET
 107 type_names['ssize'] = TYPE_SSIZET
 108 type_names['pointer'] = TYPE_ANY
 109 type_names['constpointer'] = TYPE_ANY
 110
 111
 112 def type_name_from_ctype(ctype):
 113     return type_names.get(ctype, ctype)
 114
 115
 116 class Node(object):
 117
 118     def __init__(self, name=None):
 119         self.name = name
 120         self.deprecated = None
 121         self.deprecated_version = None
 122
 123     def __repr__(self):
 124         return '%s(%r)' % (self.__class__.__name__, self.name)
 125
 126
 127 class Namespace(Node):
 128
 129     def __init__(self, name):
 130         Node.__init__(self, name)
 131         self.nodes = []
 132
 133     def __repr__(self):
 134         return '%s(%r, %r)' % (self.__class__.__name__, self.name,
 135                                self.nodes)
 136
 137
 138 class Function(Node):
 139
 140     def __init__(self, name, retval, parameters, symbol):
 141         Node.__init__(self, name)
 142         self.retval = retval
 143         self.parameters = parameters
 144         self.symbol = symbol
 145
 146     def __repr__(self):
 147         return '%s(%r, %r, %r)' % (self.__class__.__name__,
 148                                    self.name, self.retval,
 149                                    self.parameters)
 150
 151
 152 class VFunction(Function):
 153     pass
 154
 155
 156 class Type(Node):
 157
 158     def __init__(self, name, ctype=None):
 159         Node.__init__(self, name)
 160         self.ctype = ctype
 161         self.resolved = False
 162
 163
 164 class Alias(Node):
 165
 166     def __init__(self, name, target, ctype=None):
 167         Node.__init__(self, name)
 168         self.target = target
 169         self.ctype = ctype
 170
 171     def __repr__(self):
 172         return 'Alias(%r, %r)' % (self.name, self.target)
 173
 174
 175 class Parameter(Node):
 176
 177     def __init__(self, name, typenode):
 178         Node.__init__(self, name)
 179         self.type = typenode
 180         self.direction = PARAM_DIRECTION_IN
 181         self.transfer = False
 182         self.allow_none = False
 183
 184     def __repr__(self):
 185         return 'Parameter(%r, %r)' % (self.name, self.type)
 186
 187
 188 class Enum(Node):
 189
 190     def __init__(self, name, symbol, members):
 191         Node.__init__(self, name)
 192         self.symbol = symbol
 193         self.members = members
 194
 195     def __repr__(self):
 196         return 'Enum(%r, %r)' % (self.name, self.members)
 197
 198
 199 class Member(Node):
 200
 201     def __init__(self, name, value, symbol):
 202         Node.__init__(self, name)
 203         self.value = value
 204         self.symbol = symbol
 205
 206     def __repr__(self):
 207         return 'Member(%r, %r)' % (self.name, self.value)
 208
 209
 210 class Struct(Node):
 211
 212     def __init__(self, name, symbol):
 213         Node.__init__(self, name)
 214         self.fields = []
 215         self.symbol = symbol
 216
 217
 218 class Field(Node):
 219
 220     def __init__(self, name, typenode, symbol):
 221         Node.__init__(self, name)
 222         self.type = typenode
 223         self.symbol = symbol
 224
 225     def __repr__(self):
 226         return 'Field(%r, %r)' % (self.name, self.type)
 227
 228
 229 class Return(Node):
 230
 231     def __init__(self, rtype):
 232         Node.__init__(self)
 233         self.type = rtype
 234         self.transfer = False
 235
 236     def __repr__(self):
 237         return 'Return(%r)' % (self.type, )
 238
 239
 240 class Class(Node):
 241
 242     def __init__(self, name, parent):
 243         Node.__init__(self, name)
 244         self.ctype = name
 245         self.parent = parent
 246         self.methods = []
 247         self.interfaces = []
 248         self.constructors = []
 249         self.properties = []
 250         self.fields = []
 251
 252     def __repr__(self):
 253         return '%s(%r, %r, %r)' % (
 254             self.__class__.__name__,
 255             self.name, self.parent, self.methods)
 256
 257
 258 class Interface(Node):
 259
 260     def __init__(self, name, parent):
 261         Node.__init__(self, name)
 262         self.parent = parent
 263         self.methods = []
 264         self.properties = []
 265         self.fields = []
 266
 267     def __repr__(self):
 268         return '%s(%r, %r)' % (
 269             self.__class__.__name__,
 270             self.name, self.methods)
 271
 272
 273 class Constant(Node):
 274
 275     def __init__(self, name, type_name, value):
 276         Node.__init__(self, name)
 277         self.type = Type(type_name)
 278         self.value = value
 279
 280     def __repr__(self):
 281         return 'Constant(%r, %r, %r)' % (
 282             self.name, self.type, self.value)
 283
 284
 285 class Property(Node):
 286
 287     def __init__(self, name, type_name, readable, writable,
 288                  construct, construct_only, ctype=None):
 289         Node.__init__(self, name)
 290         self.type = Type(type_name, ctype)
 291         self.readable = readable
 292         self.writable = writable
 293         self.construct = construct
 294         self.construct_only = construct_only
 295
 296     def __repr__(self):
 297         return '%s(%r, %r, %r)' % (
 298             self.__class__.__name__,
 299             self.name, self.type, self.value)
 300
 301
 302 # FIXME: Inherit from Function
 303
 304
 305 class Callback(Node):
 306
 307     def __init__(self, name, retval, parameters, ctype=None):
 308         Node.__init__(self, name)
 309         self.retval = retval
 310         self.parameters = parameters
 311         self.ctype = ctype
 312
 313     def __repr__(self):
 314         return 'Callback(%r, %r, %r)' % (
 315             self.name, self.retval, self.parameters)
 316
 317
 318 class Sequence(Type):
 319     # Subclass, because a Sequence is a kind of Type
 320
 321     def __init__(self, name, ctype, element_type):
 322         Type.__init__(self, name, ctype)
 323         self.element_type = element_type
 324         self.transfer = False
 325
 326     def __repr__(self):
 327         return 'Sequence(%r of %r)' % (self.name, self.element_type, )
 328
 329
 330 class Union(Node):
 331
 332     def __init__(self, name, symbol):
 333         Node.__init__(self, name)
 334         self.fields = []
 335         self.symbol = symbol
 336
 337     def __repr__(self):
 338         return 'Union(%r, %r)' % (self.name, self.fields, )