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 Literal(Concrete):
105 def __init__(self, expr, format, base=10):
106 Concrete.__init__(self, expr)
109 def _dump(self, instance):
110 print ' Log::Literal%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::BeginPointer("%s", (const void *)%s);' % (self.type, instance)
140 self.type.dump("*" + instance)
141 except NotImplementedError:
143 print ' Log::EndPointer();'
146 print ' Log::LiteralNull();'
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::LiteralNamedConstant("%s");' % value
178 print ' Log::LiteralSInt(%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 ' %s l_Value = %s;' % (self.type, instance)
199 print ' Log::BeginBitmask("%s");' % (self.type,)
200 for value in self.values:
201 print ' if((l_Value & %s) == %s) {' % (value, value)
202 print ' Log::LiteralNamedConstant("%s");' % value
203 print ' l_Value &= ~%s;' % value
205 print ' if(l_Value) {'
206 self.type.dump("l_Value");
208 print ' Log::EndBitmask();'
213 def __init__(self, type, length):
214 Type.__init__(self, type.expr + " *", 'P' + type.id)
218 def dump(self, instance):
219 index = '__i' + self.type.id
220 print ' Log::BeginArray("%s", %s);' % (self.type, self.length)
221 print ' for (int %s = 0; %s < %s; ++%s) {' % (index, index, self.length, index)
222 print ' Log::BeginElement("%s");' % (self.type,)
223 self.type.dump('(%s)[%s]' % (instance, index))
224 print ' Log::EndElement();'
226 print ' Log::EndArray();'
228 def wrap_instance(self, instance):
229 self.type.wrap_instance("*" + instance)
231 def unwrap_instance(self, instance):
232 self.type.wrap_instance("*" + instance)
235 class OutArray(Array):
241 class Struct(Concrete):
243 def __init__(self, name, members):
244 Concrete.__init__(self, name)
246 self.members = members
248 def _dump(self, instance):
249 print ' Log::BeginStruct("%s");' % (self.name,)
250 for type, name in self.members:
251 print ' Log::BeginMember("%s", "%s");' % (type, name)
252 type.dump('(%s).%s' % (instance, name))
253 print ' Log::EndMember();'
254 print ' Log::EndStruct();'
259 def __init__(self, name, type):
260 Type.__init__(self, name)
263 def dump(self, instance):
264 self.type.dump(instance)
269 def __init__(self, type):
270 Type.__init__(self, type.expr)
282 def dump(self, instance):
283 self.type.dump(instance)
285 def wrap_instance(self, instance):
286 self.type.wrap_instance(instance)
288 def unwrap_instance(self, instance):
289 self.type.unwrap_instance(instance)
294 def __init__(self, type, name, args, call = '__stdcall', fail = None):
301 def prototype(self, name=None):
308 s = self.call + ' ' + s
309 if name.startswith('*'):
311 s = self.type.expr + ' ' + s
314 s += ", ".join(["%s %s" % (type, name) for type, name in self.args])
320 def pointer_type(self):
321 return 'P' + self.name
323 def pointer_value(self):
324 return 'p' + self.name
327 ptype = self.pointer_type()
328 pvalue = self.pointer_value()
329 print 'typedef ' + self.prototype('* %s' % ptype) + ';'
330 print 'static %s %s = NULL;' % (ptype, pvalue)
333 def get_true_pointer(self):
334 raise NotImplementedError
337 print ' ExitProcess(0);'
340 if self.fail is not None:
341 if self.type is Void:
342 assert self.fail == ''
345 assert self.fail != ''
346 print ' return %s;' % self.fail
351 pvalue = self.pointer_value()
352 print self.prototype() + ' {'
353 if self.type is Void:
356 print ' %s result;' % self.type
358 self.get_true_pointer()
359 print ' Log::BeginCall("%s");' % (self.name)
360 for type, name in self.args:
361 if not type.isoutput():
362 type.unwrap_instance(name)
363 print ' Log::BeginArg("%s", "%s");' % (type, name)
365 print ' Log::EndArg();'
366 print ' %s%s(%s);' % (result, pvalue, ', '.join([str(name) for type, name in self.args]))
367 for type, name in self.args:
369 print ' Log::BeginArg("%s", "%s");' % (type, name)
371 print ' Log::EndArg();'
372 type.wrap_instance(name)
373 if self.type is not Void:
374 print ' Log::BeginReturn("%s");' % self.type
375 self.type.dump("result")
376 print ' Log::EndReturn();'
377 self.type.wrap_instance('result')
378 print ' Log::EndCall();'
379 self.post_call_impl()
380 if self.type is not Void:
381 print ' return result;'
385 def post_call_impl(self):
389 class Interface(Type):
391 def __init__(self, name, base=None):
392 Type.__init__(self, name)
397 def itermethods(self):
398 if self.base is not None:
399 for method in self.base.itermethods():
401 for method in self.methods:
406 return "Wrap" + self.expr
408 def wrap_pre_decl(self):
409 print "class %s;" % self.wrap_name()
412 print "class %s : public %s " % (self.wrap_name(), self.name)
415 print " %s(%s * pInstance);" % (self.wrap_name(), self.name)
416 print " virtual ~%s();" % self.wrap_name()
418 for method in self.itermethods():
419 print " " + method.prototype() + ";"
422 print " %s * m_pInstance;" % (self.name,)
427 print '%s::%s(%s * pInstance) {' % (self.wrap_name(), self.wrap_name(), self.name)
428 print ' m_pInstance = pInstance;'
431 print '%s::~%s() {' % (self.wrap_name(), self.wrap_name())
434 for method in self.itermethods():
435 print method.prototype(self.wrap_name() + '::' + method.name) + ' {'
436 if method.type is Void:
439 print ' %s result;' % method.type
441 print ' Log::BeginCall("%s");' % (self.name + '::' + method.name)
442 print ' Log::BeginArg("%s *", "this");' % self.name
443 print ' Log::BeginPointer("%s", (const void *)m_pInstance);' % self.name
444 print ' Log::EndPointer();'
445 print ' Log::EndArg();'
446 for type, name in method.args:
447 if not type.isoutput():
448 type.unwrap_instance(name)
449 print ' Log::BeginArg("%s", "%s");' % (type, name)
451 print ' Log::EndArg();'
452 print ' %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(name) for type, name in method.args]))
453 for type, name in method.args:
455 print ' Log::BeginArg("%s", "%s");' % (type, name)
457 print ' Log::EndArg();'
458 type.wrap_instance(name)
459 if method.type is not Void:
460 print ' Log::BeginReturn("%s");' % method.type
461 method.type.dump("result")
462 print ' Log::EndReturn();'
463 method.type.wrap_instance('result')
464 print ' Log::EndCall();'
465 if method.name == 'QueryInterface':
466 print ' if(*ppvObj == m_pInstance)'
467 print ' *ppvObj = this;'
468 if method.name == 'Release':
469 assert method.type is not Void
471 print ' delete this;'
472 if method.type is not Void:
473 print ' return result;'
479 class Method(Function):
481 def __init__(self, type, name, args):
482 Function.__init__(self, type, name, args, call = '__stdcall')
487 class WrapPointer(Pointer):
489 def __init__(self, type):
490 Pointer.__init__(self, type)
491 if type not in towrap:
494 def wrap_instance(self, instance):
495 print " if(%s)" % instance
496 print " %s = new %s(%s);" % (instance, self.type.wrap_name(), instance)
498 def unwrap_instance(self, instance):
499 print " if(%s)" % instance
500 print " %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, self.type.wrap_name(), instance)
506 Type.__init__(self, "char *")
508 def dump(self, instance):
509 print ' Log::LiteralString((const char *)%s);' % instance
517 Type.__init__(self, "void")
519 def dump(self, instance):
520 print ' Log::LiteralOpaque();'
522 Opaque = Pointer(_Opaque())
525 Bool = Literal("bool", "Bool")
526 SChar = Literal("signed char", "SInt")
527 UChar = Literal("unsigned char", "UInt")
528 Short = Literal("short", "SInt")
529 Int = Literal("int", "SInt")
530 Long = Literal("long", "SInt")
531 LongLong = Literal("long long", "SInt")
532 UShort = Literal("unsigned short", "UInt")
533 UInt = Literal("unsigned int", "UInt")
534 ULong = Literal("unsigned long", "UInt")
535 Float = Literal("float", "Float")
536 Double = Literal("double", "Float")
537 SizeT = Literal("size_t", "UInt")
538 WString = Literal("wchar_t *", "WString")
542 for type in all_types.itervalues():
545 for type in all_types.itervalues():