WriteString(name);
 }
 
-void EndArg(void) { }
-
 void BeginReturn(void) {
    WriteByte(Trace::CALL_RET);
 }
 
-void EndReturn(void) { }
-
 void BeginArray(size_t length) {
    WriteByte(Trace::TYPE_ARRAY);
    WriteUInt(length);
 }
 
-void EndArray(void) { }
-
-void BeginElement(void) { }
-
-void EndElement(void) { }
-
 void BeginStruct(const char *name) {
    WriteByte(Trace::TYPE_STRUCT);
    (void)name;
    WriteString(name);
 }
 
-void EndMember(void) { }
-
 void BeginBitmask(void) {
    WriteByte(Trace::TYPE_BITMASK);
 }
    WriteByte(Trace::TYPE_NULL);
 }
 
-void BeginPointer(const void *addr)
-{
-   WriteByte(Trace::TYPE_POINTER);
-   WriteUInt((size_t)addr);
-}
-
-void EndPointer(void) { }
-
 void LiteralBool(bool value) {
    WriteByte(value ? Trace::TYPE_TRUE : Trace::TYPE_FALSE);
 }
 
     void EndCall(void);
     
     void BeginArg(const char *name);
-    void EndArg(void);
+    inline void EndArg(void) {}
 
     void BeginReturn(void);
-    void EndReturn(void);
+    inline void EndReturn(void) {}
 
     void BeginArray(size_t length);
-    void EndArray(void);
+    inline void EndArray(void) {}
 
-    void BeginElement(void);
-    void EndElement(void);
+    inline void BeginElement(void) {}
+    inline void EndElement(void) {}
 
     void BeginStruct(const char *name);
     void EndStruct(void);
 
     void BeginMember(const char *name);
-    void EndMember(void);
+    inline void EndMember(void) {}
 
     void BeginBitmask(void);
     void EndBitmask(void);
 
-    void BeginPointer(const void *addr);
-    void EndPointer(void);
-
     void LiteralBool(bool value);
     void LiteralSInt(signed long long value);
     void LiteralUInt(unsigned long long value);
 
 
     def visit_pointer(self, pointer, instance):
         print '    if(%s) {' % instance
-        print '        Log::BeginPointer((const void *)%s);' % (instance,)
+        print '        Log::BeginArray(1);'
+        print '        Log::BeginElement();'
         dump_instance(pointer.type, "*" + instance)
-        print '        Log::EndPointer();'
+        print '        Log::EndElement();'
+        print '        Log::EndArray();'
         print '    }'
         print '    else'
         print '        Log::LiteralNull();'
 
    TYPE_BITMASK,
    TYPE_ARRAY,
    TYPE_STRUCT,
-   TYPE_POINTER,
    TYPE_OPAQUE,
 };
 
 
    void visit(Array *array) {
       if (array->values.size() == 1) {
          os << "&";
-         array->values[0]->visit(*this);
+         _visit(array->values[0]);
       }
       else {
          const char *sep = "";
          os << "{";
          for (std::vector<Value *>::iterator it = array->values.begin(); it != array->values.end(); ++it) {
             os << sep;
-            (*it)->visit(*this);
+            _visit(*it);
             sep = ", ";
          }
          os << "}";
       os << bold << call->name << normal << "(";
       for (std::list<Arg>::iterator it = call->args.begin(); it != call->args.end(); ++it) {
          os << sep << italic << it->first << normal << " = ";
-         it->second->visit(*this);
+         _visit(it->second);
          sep = ", ";
       }
       os << ")";
       if (call->ret) {
          os << " = ";
-         call->ret->visit(*this);
+         _visit(call->ret);
       }
       os << "\n";
    }
 
    virtual void visit(Const *) {assert(0);}
    virtual void visit(Array *) {assert(0);}
    virtual void visit(Blob *) {assert(0);}
+
+protected:
+   inline void _visit(Value *value) {
+      if (value) { 
+         value->visit(*this); 
+      }
+   }
 };
 
 
 
          return parse_struct();
       case Trace::TYPE_BLOB:
          return parse_blob();
-      case Trace::TYPE_POINTER:
-         return parse_pointer();
       case Trace::TYPE_OPAQUE:
          return parse_opaque();
       default:
       return blob;
    }
    
-   Value *parse_pointer() {
-      unsigned long long addr;
-      Value *value;
-      addr = read_uint();
-      value = parse_value();
-      if (!value)
-         value = new UInt(addr);
-      return value;
-   }
-   
    Value *parse_struct() {
       std::string name;
       /* XXX */