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