]> git.cworth.org Git - apitrace/blob - base.py
Strip trailing zeros from bitmasks.
[apitrace] / base.py
1 #############################################################################
2 #
3 # Copyright 2008 Tungsten Graphics, Inc.
4 #
5 # This program is free software: you can redistribute it and/or modify it
6 # under the terms of the GNU Lesser General Public License as published
7 # by the Free Software Foundation, either version 3 of the License, or
8 # (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 Lesser General Public License for more details.
14 #
15 # You should have received a copy of the GNU Lesser General Public License
16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 #
18 #############################################################################
19
20 """C basic types"""
21
22
23 import debug
24
25
26 all_types = {}
27
28 class Type:
29
30     def __init__(self, name):
31         self.name = name
32
33     def __str__(self):
34         return self.name
35
36     def identifier(self):
37         return self.name.replace(' ', '_')
38
39     def isoutput(self):
40         return False
41
42     def decl(self):
43         pass
44
45     def impl(self):
46         pass
47
48     def dump(self, instance):
49         raise NotImplementedError
50     
51     def wrap_instance(self, instance):
52         pass 
53
54     def unwrap_instance(self, instance):
55         pass
56
57
58 class _Void(Type):
59
60     def __init__(self):
61         Type.__init__(self, "void")
62
63 Void = _Void()
64
65
66 class Concrete(Type):
67
68     def __init__(self, name):
69         for char in name:
70             assert char.isalnum() or char in '_ '
71
72         Type.__init__(self, name)
73         
74         assert self.name not in all_types
75         if self.name not in all_types:
76             all_types[self.name] = self
77
78     def decl(self):
79         print 'void Dump%s(const %s &value);' % (self.identifier(), str(self))
80     
81     def impl(self):
82         print 'void Dump%s(const %s &value) {' % (self.identifier(), str(self))
83         self._dump("value");
84         print '}'
85         print
86     
87     def _dump(self, instance):
88         raise NotImplementedError
89     
90     def dump(self, instance):
91         print '    Dump%s(%s);' % (self.identifier(), instance)
92     
93
94 class Intrinsic(Concrete):
95
96     def __init__(self, expr, format, name = None):
97         if name is None:
98             name = expr
99         Concrete.__init__(self, name)
100         self.expr = expr
101         self.format = format
102
103     def _dump(self, instance):
104         print '    Log::TextF("%s", %s);' % (self.format, instance)
105         
106     def __str__(self):
107         return self.expr
108
109
110 class Const(Type):
111
112     def __init__(self, type):
113         Type.__init__(self, 'C' + type.name)
114         self.type = type
115
116     def dump(self, instance):
117         self.type.dump(instance)
118
119     def __str__(self):
120         return "const " + str(self.type)
121
122
123 class Pointer(Type):
124
125     def __init__(self, type):
126         Type.__init__(self, 'P' + type.name)
127         self.type = type
128
129     def __str__(self):
130         return str(self.type) + " *"
131     
132     def dump(self, instance):
133         print '    if(%s) {' % instance
134         print '        Log::BeginReference("%s", %s);' % (self.type, instance)
135         try:
136             self.type.dump("*" + instance)
137         except NotImplementedError:
138             pass
139         print '        Log::EndReference();'
140         print '    }'
141         print '    else'
142         print '        Log::Text("NULL");'
143
144     def wrap_instance(self, instance):
145         self.type.wrap_instance("*" + instance)
146
147     def unwrap_instance(self, instance):
148         self.type.wrap_instance("*" + instance)
149
150
151 def ConstPointer(type):
152     return Pointer(Const(type))
153
154
155 class OutPointer(Pointer):
156
157     def isoutput(self):
158         return True
159
160
161 class Enum(Concrete):
162
163     def __init__(self, name, values):
164         Concrete.__init__(self, name)
165         self.values = values
166     
167     def _dump(self, instance):
168         print '    switch(%s) {' % instance
169         for value in self.values:
170             print '    case %s:' % value
171             print '        Log::Text("%s");' % value
172             print '        break;'
173         print '    default:'
174         print '        Log::TextF("%%i", %s);' % instance
175         print '        break;'
176         print '    }'
177
178
179 class FakeEnum(Enum):
180
181     __seq = 0
182     
183     def __init__(self, type, values):
184         FakeEnum.__seq += 1
185         Enum.__init__(self, type.name + str(FakeEnum.__seq), values)
186         self.type = type
187     
188     def __str__(self):
189         return str(self.type)
190
191
192 class Flags(Concrete):
193
194     __seq = 0
195     
196     def __init__(self, type, values):
197         Flags.__seq += 1
198         Concrete.__init__(self, type.name + str(Flags.__seq))
199         self.type = type
200         self.values = values
201
202     def __str__(self):
203         return str(self.type)
204     
205     def _dump(self, instance):
206         print '    bool l_First = TRUE;'
207         print '    %s l_Value = %s;' % (self.type, instance)
208         for value in self.values:
209             print '    if((l_Value & %s) == %s) {' % (value, value)
210             print '        if(!l_First)'
211             print '            Log::Text(" | ");'
212             print '        Log::Text("%s");' % value
213             print '        l_Value &= ~%s;' % value
214             print '        l_First = FALSE;'
215             print '    }'
216         print '    if(l_Value || l_First) {'
217         print '        if(!l_First)'
218         print '            Log::Text(" | ");'
219         self.type.dump("l_Value");
220         print '    }'
221
222
223 class Struct(Concrete):
224
225     def __init__(self, name, members):
226         Concrete.__init__(self, name)
227         self.members = members
228
229     def _dump(self, instance):
230         for type, name in self.members:
231             print '    Log::BeginElement("%s", "%s");' % (type, name)
232             type.dump('(%s).%s' % (instance, name))
233             print '    Log::EndElement();'
234
235
236 class Alias(Type):
237
238     def __init__(self, name, type):
239         Type.__init__(self, name)
240         self.type = type
241
242     def dump(self, instance):
243         self.type.dump(instance)
244
245
246 class Function:
247
248     def __init__(self, type, name, args, call = '__stdcall', fail = None):
249         self.type = type
250         self.name = name
251         self.args = args
252         self.call = call
253         self.fail = fail
254
255     def prototype(self, name=None):
256         if name is not None:
257             name = name.strip()
258         else:
259             name = self.name
260         s = name
261         if self.call:
262             s = self.call + ' ' + s
263         if name.startswith('*'):
264             s = '(' + s + ')'
265         s = str(self.type) + ' ' + s
266         s += "("
267         if self.args:
268             s += ", ".join(["%s %s" % (type, name) for type, name in self.args])
269         else:
270             s += "void"
271         s += ")"
272         return s
273
274
275 class Interface(Type):
276
277     def __init__(self, name, base=None):
278         Type.__init__(self, name)
279         self.base = base
280         self.methods = []
281
282     def itermethods(self):
283         if self.base is not None:
284             for method in self.base.itermethods():
285                 yield method
286         for method in self.methods:
287             yield method
288         raise StopIteration
289
290     def wrap_name(self):
291         return "Wrap" + self.name
292
293     def wrap_pre_decl(self):
294         print "class %s;" % self.wrap_name()
295
296     def wrap_decl(self):
297         print "class %s : public %s " % (self.wrap_name(), self.name)
298         print "{"
299         print "public:"
300         print "    %s(%s * pInstance);" % (self.wrap_name(), self.name)
301         print "    virtual ~%s();" % self.wrap_name()
302         print
303         for method in self.itermethods():
304             print "    " + method.prototype() + ";"
305         print
306         #print "private:"
307         print "    %s * m_pInstance;" % (self.name,)
308         print "};"
309         print
310
311     def wrap_impl(self):
312         print '%s::%s(%s * pInstance) {' % (self.wrap_name(), self.wrap_name(), self.name)
313         print '    m_pInstance = pInstance;'
314         print '}'
315         print
316         print '%s::~%s() {' % (self.wrap_name(), self.wrap_name())
317         print '}'
318         print
319         for method in self.itermethods():
320             print method.prototype(self.wrap_name() + '::' + method.name) + ' {'
321             if method.type is Void:
322                 result = ''
323             else:
324                 print '    %s result;' % method.type
325                 result = 'result = '
326             print '    Log::BeginCall("%s");' % (self.name + '::' + method.name)
327             print '    Log::BeginArg("%s *", "this");' % self.name
328             print '    Log::BeginReference("%s", m_pInstance);' % self.name
329             print '    Log::EndReference();'
330             print '    Log::EndArg();'
331             for type, name in method.args:
332                 if not type.isoutput():
333                     type.unwrap_instance(name)
334                     print '    Log::BeginArg("%s", "%s");' % (type, name)
335                     type.dump(name)
336                     print '    Log::EndArg();'
337             print '    %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(name) for type, name in method.args]))
338             for type, name in method.args:
339                 if type.isoutput():
340                     print '    Log::BeginArg("%s", "%s");' % (type, name)
341                     type.dump(name)
342                     print '    Log::EndArg();'
343                     type.wrap_instance(name)
344             if method.type is not Void:
345                 print '    Log::BeginReturn("%s");' % method.type
346                 method.type.dump("result")
347                 print '    Log::EndReturn();'
348                 method.type.wrap_instance('result')
349             print '    Log::EndCall();'
350             if method.name == 'QueryInterface':
351                 print '    if(*ppvObj == m_pInstance)'
352                 print '        *ppvObj = this;'
353             if method.name == 'Release':
354                 assert method.type is not Void
355                 print '    if(!result)'
356                 print '        delete this;'
357             if method.type is not Void:
358                 print '    return result;'
359             print '}'
360             print
361         print
362
363
364 class Method(Function):
365
366     def __init__(self, type, name, args):
367         Function.__init__(self, type, name, args)
368
369
370 towrap = []
371
372 class WrapPointer(Pointer):
373
374     def __init__(self, type):
375         Pointer.__init__(self, type)
376         if type not in towrap:
377             towrap.append(type)
378
379     def wrap_instance(self, instance):
380         print "    if(%s)" % instance
381         print "        %s = new %s(%s);" % (instance, self.type.wrap_name(), instance)
382
383     def unwrap_instance(self, instance):
384         print "    if(%s)" % instance
385         print "        %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, self.type.wrap_name(), instance)
386
387
388 class _String(Type):
389
390     def __init__(self):
391         Type.__init__(self, "String")
392
393     def __str__(self):
394         return "char *"
395
396     def dump(self, instance):
397         print '    Log::DumpString((const char *)%s);' % instance
398
399 String = _String()
400
401
402 SChar = Intrinsic("signed char", "%i")
403 UChar = Intrinsic("unsigned char", "%u")
404 Short = Intrinsic("short", "%i")
405 Int = Intrinsic("int", "%i")
406 Long = Intrinsic("long", "%li")
407 UShort = Intrinsic("unsigned short", "%u")
408 UInt = Intrinsic("unsigned int", "%u")
409 ULong = Intrinsic("unsigned long", "%lu")
410 Float = Intrinsic("float", "%f")
411 Double = Intrinsic("double", "%f")
412
413
414 def wrap():
415     for type in all_types.itervalues():
416         type.decl()
417     print
418     for type in all_types.itervalues():
419         type.impl()
420     print
421     for type in towrap:
422         type.wrap_pre_decl()
423     print
424     for type in towrap:
425         type.wrap_decl()
426     print
427     for type in towrap:
428         type.wrap_impl()
429     print