X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=trace.py;h=4e9a28d0b8ae8722c6c693c29246eadd59b45132;hb=b25c4b9fccc76976d633bc5b183a84553ab01998;hp=8c4eb75b10c00efc0652a341d118bb07d3dda5ff;hpb=268ff80e175c4187c1b734cce98b886e8df88b16;p=apitrace

diff --git a/trace.py b/trace.py
index 8c4eb75..4e9a28d 100644
--- a/trace.py
+++ b/trace.py
@@ -23,13 +23,15 @@
 #
 ##########################################################################/
 
-"""C basic types"""
+"""Common trace code generation."""
 
 
-import stdapi
+import specs.stdapi as stdapi
+from dispatch import Dispatcher
 
 
-all_types = {}
+def interface_wrap_name(interface):
+    return "Wrap" + interface.expr
 
 
 class DumpDeclarator(stdapi.OnceVisitor):
@@ -50,18 +52,18 @@ class DumpDeclarator(stdapi.OnceVisitor):
     def visit_struct(self, struct):
         for type, name in struct.members:
             self.visit(type)
-        print 'static void __traceStruct%s(const %s &value) {' % (struct.id, struct.expr)
+        print 'static void _write__%s(const %s &value) {' % (struct.tag, struct.expr)
         print '    static const char * members[%u] = {' % (len(struct.members),)
         for type, name,  in struct.members:
             print '        "%s",' % (name,)
         print '    };'
-        print '    static const Trace::StructSig sig = {'
-        print '       %u, "%s", %u, members' % (int(struct.id), struct.name, len(struct.members))
+        print '    static const trace::StructSig sig = {'
+        print '       %u, "%s", %u, members' % (struct.id, struct.name, len(struct.members))
         print '    };'
-        print '    Trace::BeginStruct(&sig);'
+        print '    trace::localWriter.beginStruct(&sig);'
         for type, name in struct.members:
             dump_instance(type, 'value.%s' % (name,))
-        print '    Trace::EndStruct();'
+        print '    trace::localWriter.endStruct();'
         print '}'
         print
 
@@ -71,35 +73,38 @@ class DumpDeclarator(stdapi.OnceVisitor):
     def visit_blob(self, array):
         pass
 
+    __enum_id = 0
+
     def visit_enum(self, enum):
-        print 'static void __traceEnum%s(const %s value) {' % (enum.id, enum.expr)
+        print 'static void _write__%s(const %s value) {' % (enum.tag, enum.expr)
         n = len(enum.values)
         for i in range(n):
             value = enum.values[i]
-            print '    static const Trace::EnumSig sig%u = {%u, "%s", %s};' % (i, enum.vid + i, value, value)
-        print '    const Trace::EnumSig *sig;'
-        print '    switch(value) {'
+            print '    static const trace::EnumSig sig%u = {%u, "%s", %s};' % (i, DumpDeclarator.__enum_id, value, value)
+            DumpDeclarator.__enum_id += 1
+        print '    const trace::EnumSig *sig;'
+        print '    switch (value) {'
         for i in range(n):
             value = enum.values[i]
             print '    case %s:' % value
             print '        sig = &sig%u;' % i
             print '        break;'
         print '    default:'
-        print '        Trace::LiteralSInt(value);'
+        print '        trace::localWriter.writeSInt(value);'
         print '        return;'
         print '    }'
-        print '        Trace::LiteralEnum(sig);'
+        print '    trace::localWriter.writeEnum(sig);'
         print '}'
         print
 
     def visit_bitmask(self, bitmask):
-        print 'static const Trace::BitmaskVal __bitmask%s_vals[] = {' % (bitmask.id)
+        print 'static const trace::BitmaskFlag __bitmask%s_flags[] = {' % (bitmask.tag)
         for value in bitmask.values:
             print '   {"%s", %s},' % (value, value)
         print '};'
         print
-        print 'static const Trace::BitmaskSig __bitmask%s_sig = {' % (bitmask.id)
-        print '   %u, %u, __bitmask%s_vals' % (int(bitmask.id), len(bitmask.values), bitmask.id)
+        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
 
@@ -116,60 +121,86 @@ class DumpDeclarator(stdapi.OnceVisitor):
         pass
 
     def visit_interface(self, interface):
-        pass
+        print "class %s : public %s " % (interface_wrap_name(interface), interface.name)
+        print "{"
+        print "public:"
+        print "    %s(%s * pInstance);" % (interface_wrap_name(interface), interface.name)
+        print "    virtual ~%s();" % interface_wrap_name(interface)
+        print
+        for method in interface.itermethods():
+            print "    " + method.prototype() + ";"
+        print
+        #print "private:"
+        print "    %s * m_pInstance;" % (interface.name,)
+        print "};"
+        print
+
+    def visit_polymorphic(self, polymorphic):
+        print 'static void _write__%s(int selector, const %s & value) {' % (polymorphic.tag, polymorphic.expr)
+        print '    switch (selector) {'
+        for cases, type in polymorphic.iterswitch():
+            for case in cases:
+                print '    %s:' % case
+            dump_instance(type, 'static_cast<%s>(value)' % (type,))
+            print '        break;'
+        print '    }'
+        print '}'
+        print
 
 
 class DumpImplementer(stdapi.Visitor):
     '''Dump an instance.'''
 
     def visit_literal(self, literal, instance):
-        print '    Trace::Literal%s(%s);' % (literal.format, instance)
+        print '    trace::localWriter.write%s(%s);' % (literal.kind, instance)
 
     def visit_string(self, string, instance):
         if string.length is not None:
-            print '    Trace::LiteralString((const char *)%s, %s);' % (instance, string.length)
+            print '    trace::localWriter.writeString((const char *)%s, %s);' % (instance, string.length)
         else:
-            print '    Trace::LiteralString((const char *)%s);' % instance
+            print '    trace::localWriter.writeString((const char *)%s);' % instance
 
     def visit_const(self, const, instance):
         self.visit(const.type, instance)
 
     def visit_struct(self, struct, instance):
-        print '    __traceStruct%s(%s);' % (struct.id, instance)
+        print '    _write__%s(%s);' % (struct.tag, instance)
 
     def visit_array(self, array, instance):
-        print '    if(%s) {' % instance
-        index = '__i' + array.type.id
-        print '        Trace::BeginArray(%s);' % (array.length,)
-        print '        for (int %s = 0; %s < %s; ++%s) {' % (index, index, array.length, index)
-        print '            Trace::BeginElement();'
+        length = '__c' + array.type.tag
+        index = '__i' + array.type.tag
+        print '    if (%s) {' % instance
+        print '        size_t %s = %s;' % (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();'
         self.visit(array.type, '(%s)[%s]' % (instance, index))
-        print '            Trace::EndElement();'
+        print '            trace::localWriter.endElement();'
         print '        }'
-        print '        Trace::EndArray();'
+        print '        trace::localWriter.endArray();'
+        print '    } else {'
+        print '        trace::localWriter.writeNull();'
         print '    }'
-        print '    else'
-        print '        Trace::LiteralNull();'
 
     def visit_blob(self, blob, instance):
-        print '    Trace::LiteralBlob(%s, %s);' % (instance, blob.size)
+        print '    trace::localWriter.writeBlob(%s, %s);' % (instance, blob.size)
 
     def visit_enum(self, enum, instance):
-        print '    __traceEnum%s(%s);' % (enum.id, instance)
+        print '    _write__%s(%s);' % (enum.tag, instance)
 
     def visit_bitmask(self, bitmask, instance):
-        print '    Trace::LiteralBitmask(__bitmask%s_sig, %s);' % (bitmask.id, instance)
+        print '    trace::localWriter.writeBitmask(&__bitmask%s_sig, %s);' % (bitmask.tag, instance)
 
     def visit_pointer(self, pointer, instance):
-        print '    if(%s) {' % instance
-        print '        Trace::BeginArray(1);'
-        print '        Trace::BeginElement();'
+        print '    if (%s) {' % instance
+        print '        trace::localWriter.beginArray(1);'
+        print '        trace::localWriter.beginElement();'
         dump_instance(pointer.type, "*" + instance)
-        print '        Trace::EndElement();'
-        print '        Trace::EndArray();'
+        print '        trace::localWriter.endElement();'
+        print '        trace::localWriter.endArray();'
+        print '    } else {'
+        print '        trace::localWriter.writeNull();'
         print '    }'
-        print '    else'
-        print '        Trace::LiteralNull();'
 
     def visit_handle(self, handle, instance):
         self.visit(handle.type, instance)
@@ -178,10 +209,13 @@ class DumpImplementer(stdapi.Visitor):
         self.visit(alias.type, instance)
 
     def visit_opaque(self, opaque, instance):
-        print '    Trace::LiteralOpaque((const void *)%s);' % instance
+        print '    trace::localWriter.writeOpaque((const void *)%s);' % instance
 
     def visit_interface(self, interface, instance):
-        print '    Trace::LiteralOpaque((const void *)%s);' % instance
+        print '    trace::localWriter.writeOpaque((const void *)&%s);' % instance
+
+    def visit_polymorphic(self, polymorphic, instance):
+        print '    _write__%s(%s, %s);' % (polymorphic.tag, polymorphic.switch_expr, instance)
 
 
 dump_instance = DumpImplementer().visit
@@ -221,7 +255,9 @@ class Wrapper(stdapi.Visitor):
         pass
 
     def visit_pointer(self, pointer, instance):
+        print "    if (%s) {" % instance
         self.visit(pointer.type, "*" + instance)
+        print "    }"
 
     def visit_handle(self, handle, instance):
         self.visit(handle.type, instance)
@@ -233,15 +269,26 @@ class Wrapper(stdapi.Visitor):
         pass
     
     def visit_interface(self, interface, instance):
-        print "    if(%s)" % instance
-        print "        %s = new %s(%s);" % (instance, interface.type.wrap_name(), instance)
+        assert instance.startswith('*')
+        instance = instance[1:]
+        print "    if (%s) {" % instance
+        print "        %s = new %s(%s);" % (instance, interface_wrap_name(interface), instance)
+        print "    }"
+    
+    def visit_polymorphic(self, type, instance):
+        # XXX: There might be polymorphic values that need wrapping in the future
+        pass
 
 
 class Unwrapper(Wrapper):
 
     def visit_interface(self, interface, instance):
-        print "    if(%s)" % instance
-        print "        %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, interface.type.wrap_name(), instance)
+        assert instance.startswith('*')
+        instance = instance[1:]
+        print "    if (%s) {" % instance
+        print "        %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, interface_wrap_name(interface), instance)
+        print "    }"
+
 
 wrap_instance = Wrapper().visit
 unwrap_instance = Unwrapper().visit
@@ -249,7 +296,12 @@ unwrap_instance = Unwrapper().visit
 
 class Tracer:
 
+    def __init__(self):
+        self.api = None
+
     def trace_api(self, api):
+        self.api = api
+
         self.header(api)
 
         # Includes
@@ -264,10 +316,8 @@ class Tracer:
         print
 
         # Interfaces wrapers
-        map(self.interface_wrap_name, api.interfaces)
-        map(self.interface_pre_decl, api.interfaces)
-        map(self.interface_decl, api.interfaces)
-        map(self.interface_wrap_impl, api.interfaces)
+        interfaces = [type for type in types if isinstance(type, stdapi.Interface)]
+        map(self.interface_wrap_impl, interfaces)
         print
 
         # Function wrappers
@@ -283,78 +333,66 @@ class Tracer:
     def footer(self, api):
         pass
 
-    def function_pointer_type(self, function):
-        return 'P' + function.name
-
-    def function_pointer_value(self, function):
-        return 'p' + function.name
-
     def trace_function_decl(self, function):
-        ptype = self.function_pointer_type(function)
-        pvalue = self.function_pointer_value(function)
-        print 'typedef ' + function.prototype('* %s' % ptype) + ';'
-        print 'static %s %s = NULL;' % (ptype, pvalue)
-        print
+        # Per-function declarations
 
-    def trace_function_fail(self, function):
-        if function.fail is not None:
-            if function.type is stdapi.Void:
-                assert function.fail == ''
-                print '            return;' 
-            else:
-                assert function.fail != ''
-                print '            return %s;' % function.fail
+        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 '            Trace::Abort();'
-
-    def get_function_address(self, function):
-        raise NotImplementedError
+            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 _get_true_pointer(self, function):
-        ptype = self.function_pointer_type(function)
-        pvalue = self.function_pointer_value(function)
-        print '    if(!%s) {' % (pvalue,)
-        print '        %s = (%s)%s;' % (pvalue, ptype, self.get_function_address(function))
-        print '        if(!%s)' % (pvalue,)
-        self.trace_function_fail(function)
-        print '    }'
+    def is_public_function(self, function):
+        return True
 
     def trace_function_impl(self, function):
-        pvalue = self.function_pointer_value(function)
-        print function.prototype() + ' {'
-        print '    static const char * __args[%u] = {%s};' % (len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
-        print '    static const Trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (int(function.id), function.name, len(function.args))
-        if function.type is stdapi.Void:
-            result = ''
+        if self.is_public_function(function):
+            print 'extern "C" PUBLIC'
         else:
+            print 'extern "C" PRIVATE'
+        print function.prototype() + ' {'
+        if function.type is not stdapi.Void:
             print '    %s __result;' % function.type
-            result = '__result = '
-        self._get_true_pointer(function)
-        print '    unsigned __call = Trace::BeginEnter(__sig);'
+        self.trace_function_impl_body(function)
+        if function.type is not stdapi.Void:
+            self.wrap_ret(function, "__result")
+            print '    return __result;'
+        print '}'
+        print
+
+    def trace_function_impl_body(self, function):
+        print '    unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
         for arg in function.args:
             if not arg.output:
                 self.unwrap_arg(function, arg)
                 self.dump_arg(function, arg)
-        print '    Trace::EndEnter();'
-        print '    %s%s(%s);' % (result, pvalue, ', '.join([str(arg.name) for arg in function.args]))
-        print '    Trace::BeginLeave(__call);'
+        print '    trace::localWriter.endEnter();'
+        self.dispatch_function(function)
+        print '    trace::localWriter.beginLeave(__call);'
         for arg in function.args:
             if arg.output:
                 self.dump_arg(function, arg)
                 self.wrap_arg(function, arg)
         if function.type is not stdapi.Void:
             self.dump_ret(function, "__result")
-        print '    Trace::EndLeave();'
-        if function.type is not stdapi.Void:
-            self.wrap_ret(function, "__result")
-            print '    return __result;'
-        print '}'
-        print
+        print '    trace::localWriter.endLeave();'
+
+    def dispatch_function(self, function, prefix='__', suffix=''):
+        if function.type is stdapi.Void:
+            result = ''
+        else:
+            result = '__result = '
+        dispatch = prefix + function.name + suffix
+        print '    %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args]))
 
     def dump_arg(self, function, arg):
-        print '    Trace::BeginArg(%u);' % (arg.index,)
+        print '    trace::localWriter.beginArg(%u);' % (arg.index,)
+        self.dump_arg_instance(function, arg)
+        print '    trace::localWriter.endArg();'
+
+    def dump_arg_instance(self, function, arg):
         dump_instance(arg.type, arg.name)
-        print '    Trace::EndArg();'
 
     def wrap_arg(self, function, arg):
         wrap_instance(arg.type, arg.name)
@@ -363,9 +401,9 @@ class Tracer:
         unwrap_instance(arg.type, arg.name)
 
     def dump_ret(self, function, instance):
-        print '    Trace::BeginReturn();'
+        print '    trace::localWriter.beginReturn();'
         dump_instance(function.type, instance)
-        print '    Trace::EndReturn();'
+        print '    trace::localWriter.endReturn();'
 
     def wrap_ret(self, function, instance):
         wrap_instance(function.type, instance)
@@ -373,33 +411,12 @@ class Tracer:
     def unwrap_ret(self, function, instance):
         unwrap_instance(function.type, instance)
 
-    def interface_wrap_name(self, interface):
-        return "Wrap" + interface.expr
-
-    def interface_pre_decl(self, interface):
-        print "class %s;" % interface.wrap_name()
-
-    def interface_decl(self, interface):
-        print "class %s : public %s " % (interface.wrap_name(), interface.name)
-        print "{"
-        print "public:"
-        print "    %s(%s * pInstance);" % (interface.wrap_name(), interface.name)
-        print "    virtual ~%s();" % interface.wrap_name()
-        print
-        for method in interface.itermethods():
-            print "    " + method.prototype() + ";"
-        print
-        #print "private:"
-        print "    %s * m_pInstance;" % (interface.name,)
-        print "};"
-        print
-
     def interface_wrap_impl(self, interface):
-        print '%s::%s(%s * pInstance) {' % (interface.wrap_name(), interface.wrap_name(), interface.name)
+        print '%s::%s(%s * pInstance) {' % (interface_wrap_name(interface), interface_wrap_name(interface), interface.name)
         print '    m_pInstance = pInstance;'
         print '}'
         print
-        print '%s::~%s() {' % (interface.wrap_name(), interface.wrap_name())
+        print '%s::~%s() {' % (interface_wrap_name(interface), interface_wrap_name(interface))
         print '}'
         print
         for method in interface.itermethods():
@@ -407,41 +424,101 @@ class Tracer:
         print
 
     def trace_method(self, interface, method):
-        print method.prototype(interface.wrap_name() + '::' + method.name) + ' {'
-        if method.type is Void:
-            result = ''
-        else:
-            print '    %s __result;' % method.type
-            result = '__result = '
-        print '    Trace::BeginCall("%s");' % (interface.name + '::' + method.name)
-        print '    Trace::BeginArg(0);'
-        print '    Trace::LiteralOpaque((const void *)m_pInstance);'
-        print '    Trace::EndArg();'
+        print method.prototype(interface_wrap_name(interface) + '::' + method.name) + ' {'
+        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);'
+        print '    trace::localWriter.beginArg(0);'
+        print '    trace::localWriter.writeOpaque((const void *)m_pInstance);'
+        print '    trace::localWriter.endArg();'
         for arg in method.args:
             if not arg.output:
                 self.unwrap_arg(method, arg)
                 self.dump_arg(method, arg)
+        if method.type is stdapi.Void:
+            result = ''
+        else:
+            print '    %s __result;' % method.type
+            result = '__result = '
+        print '    trace::localWriter.endEnter();'
         print '    %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args]))
+        print '    trace::localWriter.beginLeave(__call);'
         for arg in method.args:
             if arg.output:
                 self.dump_arg(method, arg)
                 self.wrap_arg(method, arg)
-        if method.type is not Void:
-            print '    Trace::BeginReturn("%s");' % method.type
+        if method.type is not stdapi.Void:
+            print '    trace::localWriter.beginReturn();'
             dump_instance(method.type, "__result")
-            print '    Trace::EndReturn();'
+            print '    trace::localWriter.endReturn();'
             wrap_instance(method.type, '__result')
-        print '    Trace::EndCall();'
+        print '    trace::localWriter.endLeave();'
         if method.name == 'QueryInterface':
-            print '    if (*ppvObj == m_pInstance)'
-            print '        *ppvObj = this;'
+            print '    if (ppvObj && *ppvObj) {'
+            print '        if (*ppvObj == m_pInstance) {'
+            print '            *ppvObj = this;'
+            print '        }'
+            for iface in self.api.interfaces:
+                print r'        else if (riid == IID_%s) {' % iface.name
+                print r'            *ppvObj = new Wrap%s((%s *) *ppvObj);' % (iface.name, iface.name)
+                print r'        }'
+            print r'        else {'
+            print r'            os::log("apitrace: warning: unknown REFIID {0x%08lX,0x%04X,0x%04X,{0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X}}\n",'
+            print r'                    riid.Data1, riid.Data2, riid.Data3,'
+            print r'                    riid.Data4[0],'
+            print r'                    riid.Data4[1],'
+            print r'                    riid.Data4[2],'
+            print r'                    riid.Data4[3],'
+            print r'                    riid.Data4[4],'
+            print r'                    riid.Data4[5],'
+            print r'                    riid.Data4[6],'
+            print r'                    riid.Data4[7]);'
+            print r'        }'
+            print '    }'
         if method.name == 'Release':
-            assert method.type is not Void
+            assert method.type is not stdapi.Void
             print '    if (!__result)'
             print '        delete this;'
-        if method.type is not Void:
+        if method.type is not stdapi.Void:
             print '    return __result;'
         print '}'
         print
 
 
+class DllTracer(Tracer):
+
+    def __init__(self, dllname):
+        self.dllname = dllname
+    
+    def header(self, api):
+        print '''
+static HINSTANCE g_hDll = NULL;
+
+static PROC
+__getPublicProcAddress(LPCSTR lpProcName)
+{
+    if (!g_hDll) {
+        char szDll[MAX_PATH] = {0};
+        
+        if (!GetSystemDirectoryA(szDll, MAX_PATH)) {
+            return NULL;
+        }
+        
+        strcat(szDll, "\\\\%s");
+        
+        g_hDll = LoadLibraryA(szDll);
+        if (!g_hDll) {
+            return NULL;
+        }
+    }
+        
+    return GetProcAddress(g_hDll, lpProcName);
+}
+
+''' % self.dllname
+
+        dispatcher = Dispatcher()
+        dispatcher.dispatch_api(api)
+
+        Tracer.header(self, api)
+