d2d: Make it actually work.

[apitrace] / wrappers / trace.py

diff --git a/wrappers/trace.py b/wrappers/trace.py
index 0064d86667afe5d48337b1fa23a56c6c022e1c80..79156acafbd328086f6ea021c41bf5c64a8ce2d7 100644 (file)
--- a/wrappers/trace.py
+++ b/wrappers/trace.py
@@ -39,6 +39,45 @@ def getWrapperInterfaceName(interface):
     return "Wrap" + interface.expr
 
 
     return "Wrap" + interface.expr
 
 

+
+class ExpanderMixin:
+    '''Mixin class that provides a bunch of methods to expand C expressions
+    from the specifications.'''
+
+    __structs = None
+    __indices = None
+
+    def expand(self, expr):
+        # Expand a C expression, replacing certain variables
+        if not isinstance(expr, basestring):
+            return expr
+        variables = {}
+
+        if self.__structs is not None:
+            variables['self'] = '(%s)' % self.__structs[0]
+        if self.__indices is not None:
+            variables['i'] = self.__indices[0]
+
+        expandedExpr = expr.format(**variables)
+        if expandedExpr != expr and 0:
+            sys.stderr.write("  %r -> %r\n" % (expr, expandedExpr))
+        return expandedExpr
+
+    def visitMember(self, structInstance, member_type, *args, **kwargs):
+        self.__structs = (structInstance, self.__structs)
+        try:
+            return self.visit(member_type, *args, **kwargs)
+        finally:
+            _, self.__structs = self.__structs
+
+    def visitElement(self, element_index, element_type, *args, **kwargs):
+        self.__indices = (element_index, self.__indices)
+        try:
+            return self.visit(element_type, *args, **kwargs)
+        finally:
+            _, self.__indices = self.__indices
+
+

 class ComplexValueSerializer(stdapi.OnceVisitor):
     '''Type visitors which generates serialization functions for
     complex types.
 class ComplexValueSerializer(stdapi.OnceVisitor):
     '''Type visitors which generates serialization functions for
     complex types.


@@ -63,21 +102,13 @@ class ComplexValueSerializer(stdapi.OnceVisitor):
         self.visit(const.type)
 
     def visitStruct(self, struct):
         self.visit(const.type)
 
     def visitStruct(self, struct):

-        for type, name in struct.members:
-            self.visit(type)
-        print 'static void _write__%s(const %s &value) {' % (struct.tag, struct.expr)
-        print '    static const char * members[%u] = {' % (len(struct.members),)
+        print 'static const char * _struct%s_members[%u] = {' % (struct.tag, len(struct.members))

         for type, name,  in struct.members:
         for type, name,  in struct.members:

-            print '        "%s",' % (name,)
-        print '    };'
-        print '    static const trace::StructSig sig = {'
-        print '       %u, "%s", %u, members' % (struct.id, struct.name, len(struct.members))
-        print '    };'
-        print '    trace::localWriter.beginStruct(&sig);'
-        for type, name in struct.members:
-            self.serializer.visit(type, 'value.%s' % (name,))
-        print '    trace::localWriter.endStruct();'
-        print '}'
+            print '    "%s",' % (name,)
+        print '};'
+        print 'static const trace::StructSig _struct%s_sig = {' % (struct.tag,)
+        print '   %u, "%s", %u, _struct%s_members' % (struct.id, struct.name, len(struct.members), struct.tag)
+        print '};'

         print
 
     def visitArray(self, array):
         print
 
     def visitArray(self, array):


@@ -87,24 +118,24 @@ class ComplexValueSerializer(stdapi.OnceVisitor):
         pass
 
     def visitEnum(self, enum):
         pass
 
     def visitEnum(self, enum):

-        print 'static const trace::EnumValue __enum%s_values[] = {' % (enum.tag)
+        print 'static const trace::EnumValue _enum%s_values[] = {' % (enum.tag)

         for value in enum.values:
             print '   {"%s", %s},' % (value, value)
         print '};'
         print
         for value in enum.values:
             print '   {"%s", %s},' % (value, value)
         print '};'
         print

-        print 'static const trace::EnumSig __enum%s_sig = {' % (enum.tag)
-        print '   %u, %u, __enum%s_values' % (enum.id, len(enum.values), enum.tag)
+        print 'static const trace::EnumSig _enum%s_sig = {' % (enum.tag)
+        print '   %u, %u, _enum%s_values' % (enum.id, len(enum.values), enum.tag)

         print '};'
         print
 
     def visitBitmask(self, bitmask):
         print '};'
         print
 
     def visitBitmask(self, bitmask):

-        print 'static const trace::BitmaskFlag __bitmask%s_flags[] = {' % (bitmask.tag)
+        print 'static const trace::BitmaskFlag _bitmask%s_flags[] = {' % (bitmask.tag)

         for value in bitmask.values:
             print '   {"%s", %s},' % (value, value)
         print '};'
         print
         for value in bitmask.values:
             print '   {"%s", %s},' % (value, value)
         print '};'
         print

-        print 'static const trace::BitmaskSig __bitmask%s_sig = {' % (bitmask.tag)
-        print '   %u, %u, __bitmask%s_flags' % (bitmask.id, len(bitmask.values), bitmask.tag)
+        print 'static const trace::BitmaskSig _bitmask%s_sig = {' % (bitmask.tag)
+        print '   %u, %u, _bitmask%s_flags' % (bitmask.id, len(bitmask.values), bitmask.tag)

         print '};'
         print
 
         print '};'
         print
 


@@ -150,7 +181,7 @@ class ComplexValueSerializer(stdapi.OnceVisitor):
         print
 
 
         print
 
 

-class ValueSerializer(stdapi.Visitor):
+class ValueSerializer(stdapi.Visitor, ExpanderMixin):

     '''Visitor which generates code to serialize any type.
     
     Simple types are serialized inline here, whereas the serialization of
     '''Visitor which generates code to serialize any type.
     
     Simple types are serialized inline here, whereas the serialization of


@@ -158,16 +189,21 @@ class ValueSerializer(stdapi.Visitor):
     ComplexValueSerializer visitor above.
     '''
 
     ComplexValueSerializer visitor above.
     '''
 

+    def __init__(self):
+        #stdapi.Visitor.__init__(self)
+        self.indices = []
+        self.instances = []
+

     def visitLiteral(self, literal, instance):
         print '    trace::localWriter.write%s(%s);' % (literal.kind, instance)
 
     def visitString(self, string, instance):
     def visitLiteral(self, literal, instance):
         print '    trace::localWriter.write%s(%s);' % (literal.kind, instance)
 
     def visitString(self, string, instance):

-        if string.kind == 'String':
+        if not string.wide:

             cast = 'const char *'
             cast = 'const char *'

-        elif string.kind == 'WString':
-            cast = 'const wchar_t *'
+            suffix = 'String'

         else:
         else:

-            assert False
+            cast = 'const wchar_t *'
+            suffix = 'WString'

         if cast != string.expr:
             # reinterpret_cast is necessary for GLubyte * <=> char *
             instance = 'reinterpret_cast<%s>(%s)' % (cast, instance)
         if cast != string.expr:
             # reinterpret_cast is necessary for GLubyte * <=> char *
             instance = 'reinterpret_cast<%s>(%s)' % (cast, instance)


@@ -175,23 +211,27 @@ class ValueSerializer(stdapi.Visitor):
             length = ', %s' % string.length
         else:
             length = ''
             length = ', %s' % string.length
         else:
             length = ''

-        print '    trace::localWriter.write%s(%s%s);' % (string.kind, instance, length)
+        print '    trace::localWriter.write%s(%s%s);' % (suffix, instance, length)

 
     def visitConst(self, const, instance):
         self.visit(const.type, instance)
 
     def visitStruct(self, struct, instance):
 
     def visitConst(self, const, instance):
         self.visit(const.type, instance)
 
     def visitStruct(self, struct, instance):

-        print '    _write__%s(%s);' % (struct.tag, instance)
+        print '    trace::localWriter.beginStruct(&_struct%s_sig);' % (struct.tag,)
+        for type, name in struct.members:
+            self.visitMember(instance, type, '(%s).%s' % (instance, name,))
+        print '    trace::localWriter.endStruct();'

 
     def visitArray(self, array, instance):
 
     def visitArray(self, array, instance):

-        length = '__c' + array.type.tag
-        index = '__i' + array.type.tag
+        length = '_c' + array.type.tag
+        index = '_i' + array.type.tag
+        array_length = self.expand(array.length)

         print '    if (%s) {' % instance
         print '    if (%s) {' % instance

-        print '        size_t %s = %s;' % (length, array.length)
+        print '        size_t %s = %s > 0 ? %s : 0;' % (length, array_length, array_length)

         print '        trace::localWriter.beginArray(%s);' % length
         print '        for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index)
         print '            trace::localWriter.beginElement();'
         print '        trace::localWriter.beginArray(%s);' % length
         print '        for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index)
         print '            trace::localWriter.beginElement();'

-        self.visit(array.type, '(%s)[%s]' % (instance, index))
+        self.visitElement(index, array.type, '(%s)[%s]' % (instance, index))

         print '            trace::localWriter.endElement();'
         print '        }'
         print '        trace::localWriter.endArray();'
         print '            trace::localWriter.endElement();'
         print '        }'
         print '        trace::localWriter.endArray();'


@@ -200,13 +240,13 @@ class ValueSerializer(stdapi.Visitor):
         print '    }'
 
     def visitBlob(self, blob, instance):
         print '    }'
 
     def visitBlob(self, blob, instance):

-        print '    trace::localWriter.writeBlob(%s, %s);' % (instance, blob.size)
+        print '    trace::localWriter.writeBlob(%s, %s);' % (instance, self.expand(blob.size))

 
     def visitEnum(self, enum, instance):
 
     def visitEnum(self, enum, instance):

-        print '    trace::localWriter.writeEnum(&__enum%s_sig, %s);' % (enum.tag, instance)
+        print '    trace::localWriter.writeEnum(&_enum%s_sig, %s);' % (enum.tag, instance)

 
     def visitBitmask(self, bitmask, instance):
 
     def visitBitmask(self, bitmask, instance):

-        print '    trace::localWriter.writeBitmask(&__bitmask%s_sig, %s);' % (bitmask.tag, instance)
+        print '    trace::localWriter.writeBitmask(&_bitmask%s_sig, %s);' % (bitmask.tag, instance)

 
     def visitPointer(self, pointer, instance):
         print '    if (%s) {' % instance
 
     def visitPointer(self, pointer, instance):
         print '    if (%s) {' % instance


@@ -272,7 +312,7 @@ class WrapDecider(stdapi.Traverser):
         self.needsWrapping = True
 
 
         self.needsWrapping = True
 
 

-class ValueWrapper(stdapi.Traverser):
+class ValueWrapper(stdapi.Traverser, ExpanderMixin):

     '''Type visitor which will generate the code to wrap an instance.
     
     Wrapping is necessary mostly for interfaces, however interface pointers can
     '''Type visitor which will generate the code to wrap an instance.
     
     Wrapping is necessary mostly for interfaces, however interface pointers can


@@ -281,12 +321,13 @@ class ValueWrapper(stdapi.Traverser):
 
     def visitStruct(self, struct, instance):
         for type, name in struct.members:
 
     def visitStruct(self, struct, instance):
         for type, name in struct.members:

-            self.visit(type, "(%s).%s" % (instance, name))
+            self.visitMember(instance, type, "(%s).%s" % (instance, name))

 
     def visitArray(self, array, instance):
 
     def visitArray(self, array, instance):

+        array_length = self.expand(array.length)

         print "    if (%s) {" % instance
         print "    if (%s) {" % instance

-        print "        for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array.length
-        self.visit(array.type, instance + "[_i]")
+        print "        for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array_length
+        self.visitElement('_i', array.type, instance + "[_i]")

         print "        }"
         print "    }"
 
         print "        }"
         print "    }"
 


@@ -299,8 +340,10 @@ class ValueWrapper(stdapi.Traverser):
         elem_type = pointer.type.mutable()
         if isinstance(elem_type, stdapi.Interface):
             self.visitInterfacePointer(elem_type, instance)
         elem_type = pointer.type.mutable()
         if isinstance(elem_type, stdapi.Interface):
             self.visitInterfacePointer(elem_type, instance)

+        elif isinstance(elem_type, stdapi.Alias) and isinstance(elem_type.type, stdapi.Interface):
+            self.visitInterfacePointer(elem_type.type, instance)

         else:
         else:

-            self.visitPointer(self, pointer, instance)
+            self.visitPointer(pointer, instance)

     
     def visitInterface(self, interface, instance):
         raise NotImplementedError
     
     def visitInterface(self, interface, instance):
         raise NotImplementedError


@@ -320,13 +363,31 @@ class ValueUnwrapper(ValueWrapper):
 
     allocated = False
 
 
     allocated = False
 

+    def visitStruct(self, struct, instance):
+        if not self.allocated:
+            # Argument is constant. We need to create a non const
+            print '    {'
+            print "        %s * _t = static_cast<%s *>(alloca(sizeof *_t));" % (struct, struct)
+            print '        *_t = %s;' % (instance,)
+            assert instance.startswith('*')
+            print '        %s = _t;' % (instance[1:],)
+            instance = '*_t'
+            self.allocated = True
+            try:
+                return ValueWrapper.visitStruct(self, struct, instance)
+            finally:
+                print '    }'
+        else:
+            return ValueWrapper.visitStruct(self, struct, instance)
+

     def visitArray(self, array, instance):
         if self.allocated or isinstance(instance, stdapi.Interface):
             return ValueWrapper.visitArray(self, array, instance)
     def visitArray(self, array, instance):
         if self.allocated or isinstance(instance, stdapi.Interface):
             return ValueWrapper.visitArray(self, array, instance)

+        array_length = self.expand(array.length)

         elem_type = array.type.mutable()
         elem_type = array.type.mutable()

-        print "    if (%s && %s) {" % (instance, array.length)
-        print "        %s * _t = static_cast<%s *>(alloca(%s * sizeof *_t));" % (elem_type, elem_type, array.length)
-        print "        for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array.length
+        print "    if (%s && %s) {" % (instance, array_length)
+        print "        %s * _t = static_cast<%s *>(alloca(%s * sizeof *_t));" % (elem_type, elem_type, array_length)
+        print "        for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array_length

         print "            _t[_i] = %s[_i];" % instance 
         self.allocated = True
         self.visit(array.type, "_t[_i]")
         print "            _t[_i] = %s[_i];" % instance 
         self.allocated = True
         self.visit(array.type, "_t[_i]")


@@ -365,8 +426,9 @@ class Tracer:
         self.header(api)
 
         # Includes
         self.header(api)
 
         # Includes

-        for header in api.headers:
-            print header
+        for module in api.modules:
+            for header in module.headers:
+                print header

         print
 
         # Generate the serializer functions
         print
 
         # Generate the serializer functions


@@ -381,14 +443,26 @@ class Tracer:
         # Function wrappers
         self.interface = None
         self.base = None
         # Function wrappers
         self.interface = None
         self.base = None

-        map(self.traceFunctionDecl, api.functions)
-        map(self.traceFunctionImpl, api.functions)
+        for function in api.getAllFunctions():
+            self.traceFunctionDecl(function)
+        for function in api.getAllFunctions():
+            self.traceFunctionImpl(function)

         print
 
         self.footer(api)
 
     def header(self, api):
         print
 
         self.footer(api)
 
     def header(self, api):

-        pass
+        print '#ifdef _WIN32'
+        print '#  include <malloc.h> // alloca'
+        print '#  ifndef alloca'
+        print '#    define alloca _alloca'
+        print '#  endif'
+        print '#else'
+        print '#  include <alloca.h> // alloca'
+        print '#endif'
+        print
+        print '#include "trace.hpp"'
+        print

 
     def footer(self, api):
         pass
 
     def footer(self, api):
         pass


@@ -396,12 +470,13 @@ class Tracer:
     def traceFunctionDecl(self, function):
         # Per-function declarations
 
     def traceFunctionDecl(self, function):
         # Per-function declarations
 

-        if function.args:
-            print 'static const char * __%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
-        else:
-            print 'static const char ** __%s_args = NULL;' % (function.name,)
-        print 'static const trace::FunctionSig __%s_sig = {%u, "%s", %u, __%s_args};' % (function.name, function.id, function.name, len(function.args), function.name)
-        print
+        if not function.internal:
+            if function.args:
+                print 'static const char * _%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
+            else:
+                print 'static const char ** _%s_args = NULL;' % (function.name,)
+            print 'static const trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, function.id, function.name, len(function.args), function.name)
+            print

 
     def isFunctionPublic(self, function):
         return True
 
     def isFunctionPublic(self, function):
         return True


@@ -413,39 +488,61 @@ class Tracer:
             print 'extern "C" PRIVATE'
         print function.prototype() + ' {'
         if function.type is not stdapi.Void:
             print 'extern "C" PRIVATE'
         print function.prototype() + ' {'
         if function.type is not stdapi.Void:

-            print '    %s __result;' % function.type
+            print '    %s _result;' % function.type
+
+        # No-op if tracing is disabled
+        print '    if (!trace::isTracingEnabled()) {'
+        Tracer.invokeFunction(self, function)
+        if function.type is not stdapi.Void:
+            print '        return _result;'
+        else:
+            print '        return;'
+        print '    }'
+

         self.traceFunctionImplBody(function)
         if function.type is not stdapi.Void:
         self.traceFunctionImplBody(function)
         if function.type is not stdapi.Void:

-            self.wrapRet(function, "__result")
-            print '    return __result;'
+            print '    return _result;'

         print '}'
         print
 
     def traceFunctionImplBody(self, function):
         print '}'
         print
 
     def traceFunctionImplBody(self, function):

-        print '    unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
-        for arg in function.args:
-            if not arg.output:
-                self.unwrapArg(function, arg)
-                self.serializeArg(function, arg)
-        print '    trace::localWriter.endEnter();'
+        if not function.internal:
+            print '    unsigned _call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
+            for arg in function.args:
+                if not arg.output:
+                    self.unwrapArg(function, arg)
+                    self.serializeArg(function, arg)
+            print '    trace::localWriter.endEnter();'

         self.invokeFunction(function)
         self.invokeFunction(function)

-        print '    trace::localWriter.beginLeave(__call);'
-        for arg in function.args:
-            if arg.output:
-                self.serializeArg(function, arg)
-                self.wrapArg(function, arg)
-        if function.type is not stdapi.Void:
-            self.serializeRet(function, "__result")
-        print '    trace::localWriter.endLeave();'
+        if not function.internal:
+            print '    trace::localWriter.beginLeave(_call);'
+            print '    if (%s) {' % self.wasFunctionSuccessful(function)
+            for arg in function.args:
+                if arg.output:
+                    self.serializeArg(function, arg)
+                    self.wrapArg(function, arg)
+            print '    }'
+            if function.type is not stdapi.Void:
+                self.serializeRet(function, "_result")
+            print '    trace::localWriter.endLeave();'
+            if function.type is not stdapi.Void:
+                self.wrapRet(function, "_result")

 
 

-    def invokeFunction(self, function, prefix='__', suffix=''):
+    def invokeFunction(self, function, prefix='_', suffix=''):

         if function.type is stdapi.Void:
             result = ''
         else:
         if function.type is stdapi.Void:
             result = ''
         else:

-            result = '__result = '
+            result = '_result = '

         dispatch = prefix + function.name + suffix
         print '    %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args]))
 
         dispatch = prefix + function.name + suffix
         print '    %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args]))
 

+    def wasFunctionSuccessful(self, function):
+        if function.type is stdapi.Void:
+            return 'true'
+        if str(function.type) == 'HRESULT':
+            return 'SUCCEEDED(_result)'
+        return 'false'
+

     def serializeArg(self, function, arg):
         print '    trace::localWriter.beginArg(%u);' % (arg.index,)
         self.serializeArgValue(function, arg)
     def serializeArg(self, function, arg):
         print '    trace::localWriter.beginArg(%u);' % (arg.index,)
         self.serializeArgValue(function, arg)


@@ -462,10 +559,9 @@ class Tracer:
         for other_arg in function.args:
             if not other_arg.output and other_arg.type is REFIID:
                 riid = other_arg
         for other_arg in function.args:
             if not other_arg.output and other_arg.type is REFIID:
                 riid = other_arg

-        if riid is not None and isinstance(arg.type, stdapi.Pointer):
-            assert isinstance(arg.type.type, stdapi.ObjPointer)
-            obj_type = arg.type.type.type
-            assert obj_type is stdapi.Void
+        if riid is not None \
+           and isinstance(arg.type, stdapi.Pointer) \
+           and isinstance(arg.type.type, stdapi.ObjPointer):

             self.wrapIid(function, riid, arg)
             return
 
             self.wrapIid(function, riid, arg)
             return
 


@@ -523,21 +619,24 @@ class Tracer:
         for method in interface.iterMethods():
             print "    " + method.prototype() + ";"
         print
         for method in interface.iterMethods():
             print "    " + method.prototype() + ";"
         print

-        self.declareWrapperInterfaceVariables(interface)
+        #print "private:"
+        for type, name, value in self.enumWrapperInterfaceVariables(interface):
+            print '    %s %s;' % (type, name)

         print "};"
         print
 
         print "};"
         print
 

-    def declareWrapperInterfaceVariables(self, interface):
-        #print "private:"
-        print "    DWORD m_dwMagic;"
-        print "    %s * m_pInstance;" % (interface.name,)
+    def enumWrapperInterfaceVariables(self, interface):
+        return [
+            ("DWORD", "m_dwMagic", "0xd8365d6c"),
+            ("%s *" % interface.name, "m_pInstance", "pInstance"),
+        ] 

 
     def implementWrapperInterface(self, interface):
         self.interface = interface
 
         print '%s::%s(%s * pInstance) {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface), interface.name)
 
     def implementWrapperInterface(self, interface):
         self.interface = interface
 
         print '%s::%s(%s * pInstance) {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface), interface.name)

-        print '    m_dwMagic = 0xd8365d6c;'
-        print '    m_pInstance = pInstance;'
+        for type, name, value in self.enumWrapperInterfaceVariables(interface):
+            print '    %s = %s;' % (name, value)

         print '}'
         print
         print '%s::~%s() {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface))
         print '}'
         print
         print '%s::~%s() {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface))


@@ -553,19 +652,24 @@ class Tracer:
     def implementWrapperInterfaceMethod(self, interface, base, method):
         print method.prototype(getWrapperInterfaceName(interface) + '::' + method.name) + ' {'
         if method.type is not stdapi.Void:
     def implementWrapperInterfaceMethod(self, interface, base, method):
         print method.prototype(getWrapperInterfaceName(interface) + '::' + method.name) + ' {'
         if method.type is not stdapi.Void:

-            print '    %s __result;' % method.type
+            print '    %s _result;' % method.type

     
         self.implementWrapperInterfaceMethodBody(interface, base, method)
     
         if method.type is not stdapi.Void:
     
         self.implementWrapperInterfaceMethodBody(interface, base, method)
     
         if method.type is not stdapi.Void:

-            print '    return __result;'
+            print '    return _result;'

         print '}'
         print
 
     def implementWrapperInterfaceMethodBody(self, interface, base, method):
         print '}'
         print
 
     def implementWrapperInterfaceMethodBody(self, interface, base, method):

-        print '    static const char * __args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))
-        print '    static const trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (method.id, interface.name + '::' + method.name, len(method.args) + 1)
-        print '    unsigned __call = trace::localWriter.beginEnter(&__sig);'
+        assert not method.internal
+
+        print '    static const char * _args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))
+        print '    static const trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (method.id, interface.name + '::' + method.name, len(method.args) + 1)
+
+        print '    %s *_this = static_cast<%s *>(m_pInstance);' % (base, base)
+
+        print '    unsigned _call = trace::localWriter.beginEnter(&_sig);'

         print '    trace::localWriter.beginArg(0);'
         print '    trace::localWriter.writePointer((uintptr_t)m_pInstance);'
         print '    trace::localWriter.endArg();'
         print '    trace::localWriter.beginArg(0);'
         print '    trace::localWriter.writePointer((uintptr_t)m_pInstance);'
         print '    trace::localWriter.endArg();'


@@ -577,21 +681,24 @@ class Tracer:
         
         self.invokeMethod(interface, base, method)
 
         
         self.invokeMethod(interface, base, method)
 

-        print '    trace::localWriter.beginLeave(__call);'
+        print '    trace::localWriter.beginLeave(_call);'
+
+        print '    if (%s) {' % self.wasFunctionSuccessful(method)

         for arg in method.args:
             if arg.output:
                 self.serializeArg(method, arg)
                 self.wrapArg(method, arg)
         for arg in method.args:
             if arg.output:
                 self.serializeArg(method, arg)
                 self.wrapArg(method, arg)

+        print '    }'

 
         if method.type is not stdapi.Void:
 
         if method.type is not stdapi.Void:

-            print '    trace::localWriter.beginReturn();'
-            self.serializeValue(method.type, "__result")
-            print '    trace::localWriter.endReturn();'
-            self.wrapValue(method.type, '__result')
+            self.serializeRet(method, '_result')

         print '    trace::localWriter.endLeave();'
         print '    trace::localWriter.endLeave();'

+        if method.type is not stdapi.Void:
+            self.wrapRet(method, '_result')
+

         if method.name == 'Release':
             assert method.type is not stdapi.Void
         if method.name == 'Release':
             assert method.type is not stdapi.Void

-            print '    if (!__result)'
+            print '    if (!_result)'

             print '        delete this;'
 
     def implementIidWrapper(self, api):
             print '        delete this;'
 
     def implementIidWrapper(self, api):


@@ -621,20 +728,25 @@ class Tracer:
         print
 
     def wrapIid(self, function, riid, out):
         print
 
     def wrapIid(self, function, riid, out):

+        # Cast output arg to `void **` if necessary
+        out_name = out.name
+        obj_type = out.type.type.type
+        if not obj_type is stdapi.Void:
+            assert isinstance(obj_type, stdapi.Interface)
+            out_name = 'reinterpret_cast<void * *>(%s)' % out_name
+

         print r'    if (%s && *%s) {' % (out.name, out.name)
         functionName = function.name
         else_ = ''
         if self.interface is not None:
             functionName = self.interface.name + '::' + functionName
         print r'    if (%s && *%s) {' % (out.name, out.name)
         functionName = function.name
         else_ = ''
         if self.interface is not None:
             functionName = self.interface.name + '::' + functionName

-            print r'        %sif (*%s == m_pInstance) {' % (else_, out.name,)
-            print r'            *%s = this;' % (out.name,)
-            print r'            if (%s) {' % ' && '.join('%s != IID_%s' % (riid.name, iface.name) for iface in self.interface.iterBases()) 
-            print r'                warnIID("%s", %s, "unexpected");' % (functionName, riid.name)
-            print r'            }'
+            print r'        if (*%s == m_pInstance &&' % (out_name,)
+            print r'            (%s)) {' % ' || '.join('%s == IID_%s' % (riid.name, iface.name) for iface in self.interface.iterBases())
+            print r'            *%s = this;' % (out_name,)

             print r'        }'
             else_ = 'else '
         print r'        %s{' % else_
             print r'        }'
             else_ = 'else '
         print r'        %s{' % else_

-        print r'             wrapIID("%s", %s, %s);' % (functionName, riid.name, out.name) 
+        print r'             wrapIID("%s", %s, %s);' % (functionName, riid.name, out_name)

         print r'        }'
         print r'    }'
 
         print r'        }'
         print r'    }'
 


@@ -642,11 +754,11 @@ class Tracer:
         if method.type is stdapi.Void:
             result = ''
         else:
         if method.type is stdapi.Void:
             result = ''
         else:

-            result = '__result = '
-        print '    %sstatic_cast<%s *>(m_pInstance)->%s(%s);' % (result, base, method.name, ', '.join([str(arg.name) for arg in method.args]))
+            result = '_result = '
+        print '    %s_this->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args]))

     
     def emit_memcpy(self, dest, src, length):
     
     def emit_memcpy(self, dest, src, length):

-        print '        unsigned __call = trace::localWriter.beginEnter(&trace::memcpy_sig);'
+        print '        unsigned _call = trace::localWriter.beginEnter(&trace::memcpy_sig);'

         print '        trace::localWriter.beginArg(0);'
         print '        trace::localWriter.writePointer((uintptr_t)%s);' % dest
         print '        trace::localWriter.endArg();'
         print '        trace::localWriter.beginArg(0);'
         print '        trace::localWriter.writePointer((uintptr_t)%s);' % dest
         print '        trace::localWriter.endArg();'


@@ -657,6 +769,17 @@ class Tracer:
         print '        trace::localWriter.writeUInt(%s);' % length
         print '        trace::localWriter.endArg();'
         print '        trace::localWriter.endEnter();'
         print '        trace::localWriter.writeUInt(%s);' % length
         print '        trace::localWriter.endArg();'
         print '        trace::localWriter.endEnter();'

-        print '        trace::localWriter.beginLeave(__call);'
+        print '        trace::localWriter.beginLeave(_call);'

         print '        trace::localWriter.endLeave();'
         print '        trace::localWriter.endLeave();'

+    
+    def fake_call(self, function, args):
+        print '            unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
+        for arg, instance in zip(function.args, args):
+            assert not arg.output
+            print '            trace::localWriter.beginArg(%u);' % (arg.index,)
+            self.serializeValue(arg.type, instance)
+            print '            trace::localWriter.endArg();'
+        print '            trace::localWriter.endEnter();'
+        print '            trace::localWriter.beginLeave(_fake_call);'
+        print '            trace::localWriter.endLeave();'