1 ##########################################################################
3 # Copyright 2008-2009 VMware, Inc.
6 # Permission is hereby granted, free of charge, to any person obtaining a copy
7 # of this software and associated documentation files (the "Software"), to deal
8 # in the Software without restriction, including without limitation the rights
9 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 # copies of the Software, and to permit persons to whom the Software is
11 # furnished to do so, subject to the following conditions:
13 # The above copyright notice and this permission notice shall be included in
14 # all copies or substantial portions of the Software.
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 ##########################################################################/
38 def __init__(self, expr, id = ''):
42 assert char.isalnum() or char in '_ '
44 id = id.replace(' ', '_')
50 assert id not in all_types
67 def dump(self, instance):
68 raise NotImplementedError
70 def wrap_instance(self, instance):
73 def unwrap_instance(self, instance):
80 Type.__init__(self, "void")
88 print 'static void Dump%s(const %s &value);' % (self.id, self.expr)
91 print 'static void Dump%s(const %s &value) {' % (self.id, self.expr)
96 def _dump(self, instance):
97 raise NotImplementedError
99 def dump(self, instance):
100 print ' Dump%s(%s);' % (self.id, instance)
103 class Intrinsic(Concrete):
105 def __init__(self, expr, format):
106 Concrete.__init__(self, expr)
109 def _dump(self, instance):
110 print ' Log::TextF("%s", %s);' % (self.format, instance)
115 def __init__(self, type):
117 if isinstance(type, Pointer):
118 expr = type.expr + " const"
120 expr = "const " + type.expr
122 Type.__init__(self, expr, 'C' + type.id)
126 def dump(self, instance):
127 self.type.dump(instance)
132 def __init__(self, type):
133 Type.__init__(self, type.expr + " *", 'P' + type.id)
136 def dump(self, instance):
137 print ' if(%s) {' % instance
138 print ' Log::BeginReference("%s", %s);' % (self.type, instance)
140 self.type.dump("*" + instance)
141 except NotImplementedError:
143 print ' Log::EndReference();'
146 print ' Log::Text("NULL");'
148 def wrap_instance(self, instance):
149 self.type.wrap_instance("*" + instance)
151 def unwrap_instance(self, instance):
152 self.type.wrap_instance("*" + instance)
155 def ConstPointer(type):
156 return Pointer(Const(type))
159 class OutPointer(Pointer):
165 class Enum(Concrete):
167 def __init__(self, name, values):
168 Concrete.__init__(self, name)
171 def _dump(self, instance):
172 print ' switch(%s) {' % instance
173 for value in self.values:
174 print ' case %s:' % value
175 print ' Log::Text("%s");' % value
178 print ' Log::TextF("%%i", %s);' % instance
183 class FakeEnum(Enum):
185 def __init__(self, type, values):
186 Enum.__init__(self, type.expr, values)
190 class Flags(Concrete):
192 def __init__(self, type, values):
193 Concrete.__init__(self, type.expr)
197 def _dump(self, instance):
198 print ' bool l_First = TRUE;'
199 print ' %s l_Value = %s;' % (self.type, instance)
200 for value in self.values:
201 print ' if((l_Value & %s) == %s) {' % (value, value)
202 print ' if(!l_First)'
203 print ' Log::Text(" | ");'
204 print ' Log::Text("%s");' % value
205 print ' l_Value &= ~%s;' % value
206 print ' l_First = FALSE;'
208 print ' if(l_Value || l_First) {'
209 print ' if(!l_First)'
210 print ' Log::Text(" | ");'
211 self.type.dump("l_Value");
217 def __init__(self, type, length):
218 Type.__init__(self, type.expr + " *", 'P' + type.id)
222 def dump(self, instance):
223 index = '__i' + self.type.id
224 print ' for (int %s = 0; %s < %s; ++%s) {' % (index, index, self.length, index)
225 print ' Log::BeginElement("%s");' % (self.type,)
226 self.type.dump('(%s)[%s]' % (instance, index))
227 print ' Log::EndElement();'
230 def wrap_instance(self, instance):
231 self.type.wrap_instance("*" + instance)
233 def unwrap_instance(self, instance):
234 self.type.wrap_instance("*" + instance)
237 class Struct(Concrete):
239 def __init__(self, name, members):
240 Concrete.__init__(self, name)
241 self.members = members
243 def _dump(self, instance):
244 for type, name in self.members:
245 print ' Log::BeginElement("%s", "%s");' % (type, name)
246 type.dump('(%s).%s' % (instance, name))
247 print ' Log::EndElement();'
252 def __init__(self, name, type):
253 Type.__init__(self, name)
256 def dump(self, instance):
257 self.type.dump(instance)
262 def __init__(self, type, name, args, call = '__stdcall', fail = None):
269 def prototype(self, name=None):
276 s = self.call + ' ' + s
277 if name.startswith('*'):
279 s = self.type.expr + ' ' + s
282 s += ", ".join(["%s %s" % (type, name) for type, name in self.args])
288 def pointer_type(self):
289 return 'P' + self.name
291 def pointer_value(self):
292 return 'p' + self.name
295 ptype = self.pointer_type()
296 pvalue = self.pointer_value()
297 print 'typedef ' + self.prototype('* %s' % ptype) + ';'
298 print 'static %s %s = NULL;' % (ptype, pvalue)
301 def get_true_pointer(self):
302 raise NotImplementedError
305 if self.fail is not None:
306 if self.type is Void:
307 assert self.fail == ''
310 assert self.fail != ''
311 print ' return %s;' % self.fail
313 print ' ExitProcess(0);'
316 pvalue = self.pointer_value()
317 print self.prototype() + ' {'
318 if self.type is Void:
321 print ' %s result;' % self.type
323 self.get_true_pointer()
324 print ' Log::BeginCall("%s");' % (self.name)
325 for type, name in self.args:
326 if not type.isoutput():
327 type.unwrap_instance(name)
328 print ' Log::BeginArg("%s", "%s");' % (type, name)
330 print ' Log::EndArg();'
331 print ' %s%s(%s);' % (result, pvalue, ', '.join([str(name) for type, name in self.args]))
332 for type, name in self.args:
334 print ' Log::BeginArg("%s", "%s");' % (type, name)
336 print ' Log::EndArg();'
337 type.wrap_instance(name)
338 if self.type is not Void:
339 print ' Log::BeginReturn("%s");' % self.type
340 self.type.dump("result")
341 print ' Log::EndReturn();'
342 self.type.wrap_instance('result')
343 print ' Log::EndCall();'
344 self.post_call_impl()
345 if self.type is not Void:
346 print ' return result;'
350 def post_call_impl(self):
354 class Interface(Type):
356 def __init__(self, name, base=None):
357 Type.__init__(self, name)
362 def itermethods(self):
363 if self.base is not None:
364 for method in self.base.itermethods():
366 for method in self.methods:
371 return "Wrap" + self.expr
373 def wrap_pre_decl(self):
374 print "class %s;" % self.wrap_name()
377 print "class %s : public %s " % (self.wrap_name(), self.name)
380 print " %s(%s * pInstance);" % (self.wrap_name(), self.name)
381 print " virtual ~%s();" % self.wrap_name()
383 for method in self.itermethods():
384 print " " + method.prototype() + ";"
387 print " %s * m_pInstance;" % (self.name,)
392 print '%s::%s(%s * pInstance) {' % (self.wrap_name(), self.wrap_name(), self.name)
393 print ' m_pInstance = pInstance;'
396 print '%s::~%s() {' % (self.wrap_name(), self.wrap_name())
399 for method in self.itermethods():
400 print method.prototype(self.wrap_name() + '::' + method.name) + ' {'
401 if method.type is Void:
404 print ' %s result;' % method.type
406 print ' Log::BeginCall("%s");' % (self.name + '::' + method.name)
407 print ' Log::BeginArg("%s *", "this");' % self.name
408 print ' Log::BeginReference("%s", m_pInstance);' % self.name
409 print ' Log::EndReference();'
410 print ' Log::EndArg();'
411 for type, name in method.args:
412 if not type.isoutput():
413 type.unwrap_instance(name)
414 print ' Log::BeginArg("%s", "%s");' % (type, name)
416 print ' Log::EndArg();'
417 print ' %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(name) for type, name in method.args]))
418 for type, name in method.args:
420 print ' Log::BeginArg("%s", "%s");' % (type, name)
422 print ' Log::EndArg();'
423 type.wrap_instance(name)
424 if method.type is not Void:
425 print ' Log::BeginReturn("%s");' % method.type
426 method.type.dump("result")
427 print ' Log::EndReturn();'
428 method.type.wrap_instance('result')
429 print ' Log::EndCall();'
430 if method.name == 'QueryInterface':
431 print ' if(*ppvObj == m_pInstance)'
432 print ' *ppvObj = this;'
433 if method.name == 'Release':
434 assert method.type is not Void
436 print ' delete this;'
437 if method.type is not Void:
438 print ' return result;'
444 class Method(Function):
446 def __init__(self, type, name, args):
447 Function.__init__(self, type, name, args)
452 class WrapPointer(Pointer):
454 def __init__(self, type):
455 Pointer.__init__(self, type)
456 if type not in towrap:
459 def wrap_instance(self, instance):
460 print " if(%s)" % instance
461 print " %s = new %s(%s);" % (instance, self.type.wrap_name(), instance)
463 def unwrap_instance(self, instance):
464 print " if(%s)" % instance
465 print " %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, self.type.wrap_name(), instance)
471 Type.__init__(self, "char *")
473 def dump(self, instance):
474 print ' Log::DumpString((const char *)%s);' % instance
478 class _WString(Type):
481 Type.__init__(self, "wchar_t *")
483 def dump(self, instance):
484 print ' Log::DumpWString(%s);' % instance
489 SChar = Intrinsic("signed char", "%i")
490 UChar = Intrinsic("unsigned char", "%u")
491 Short = Intrinsic("short", "%i")
492 Int = Intrinsic("int", "%i")
493 Long = Intrinsic("long", "%li")
494 UShort = Intrinsic("unsigned short", "%u")
495 UInt = Intrinsic("unsigned int", "%u")
496 ULong = Intrinsic("unsigned long", "%lu")
497 Float = Intrinsic("float", "%f")
498 Double = Intrinsic("double", "%f")
499 SizeT = Intrinsic("size_t", "%lu")
503 for type in all_types.itervalues():
506 for type in all_types.itervalues():