Show number of calls per frame.

[apitrace] / trace_model.cpp

diff --git a/trace_model.cpp b/trace_model.cpp
index 03f633b4cf33b47c114b11c6c24a9905dc86a132..306b9e7a64da745384f06ee050eeddc97e9a1b4b 100644 (file)
--- a/trace_model.cpp
+++ b/trace_model.cpp
@@ -42,6 +42,11 @@ Call::~Call() {
 }
 
 
+String::~String() {
+    delete [] value;
+}
+
+
 Struct::~Struct() {
     for (std::vector<Value *>::iterator it = members.begin(); it != members.end(); ++it) {
         delete *it;
@@ -56,9 +61,16 @@ Array::~Array() {
 }
 
 Blob::~Blob() {
-    // TODO: Don't leak blobs.  Blobs are often bound and accessed during many
-    // calls, so we can't delete them here.
-    //delete [] buf;
+    // Blobs are often bound and referred during many calls, so we can't delete
+    // them here in that case.
+    //
+    // Once bound there is no way to know when they were unbound, which
+    // effectively means we have to leak them.  A better solution would be to
+    // keep a list of bound pointers, and defer the destruction to when the
+    // trace in question has been fully processed.
+    if (!bound) {
+        delete [] buf;
+    }
 }
 
 
@@ -69,7 +81,7 @@ bool SInt   ::toBool(void) const { return value != 0; }
 bool UInt   ::toBool(void) const { return value != 0; }
 bool Float  ::toBool(void) const { return value != 0; }
 bool String ::toBool(void) const { return true; }
-bool Enum   ::toBool(void) const { return sig->second->toBool(); }
+bool Enum   ::toBool(void) const { return sig->value != 0; }
 bool Struct ::toBool(void) const { return true; }
 bool Array  ::toBool(void) const { return true; }
 bool Blob   ::toBool(void) const { return true; }
@@ -83,7 +95,7 @@ signed long long Bool   ::toSInt(void) const { return static_cast<signed long lo
 signed long long SInt   ::toSInt(void) const { return value; }
 signed long long UInt   ::toSInt(void) const { assert(static_cast<signed long long>(value) >= 0); return static_cast<signed long long>(value); }
 signed long long Float  ::toSInt(void) const { return static_cast<signed long long>(value); }
-signed long long Enum   ::toSInt(void) const { return sig->second->toSInt(); }
+signed long long Enum   ::toSInt(void) const { return sig->value; }
 
 
 // unsigned integer cast
@@ -93,7 +105,7 @@ unsigned long long Bool   ::toUInt(void) const { return static_cast<unsigned lon
 unsigned long long SInt   ::toUInt(void) const { assert(value >= 0); return static_cast<signed long long>(value); }
 unsigned long long UInt   ::toUInt(void) const { return value; }
 unsigned long long Float  ::toUInt(void) const { return static_cast<unsigned long long>(value); }
-unsigned long long Enum   ::toUInt(void) const { return sig->second->toUInt(); }
+unsigned long long Enum   ::toUInt(void) const { assert(sig->value >= 0); return sig->value; }
 
 
 // floating point cast
@@ -103,7 +115,7 @@ float Bool   ::toFloat(void) const { return static_cast<float>(value); }
 float SInt   ::toFloat(void) const { return static_cast<float>(value); }
 float UInt   ::toFloat(void) const { return static_cast<float>(value); }
 float Float  ::toFloat(void) const { return value; }
-float Enum   ::toFloat(void) const { return sig->second->toFloat(); }
+float Enum   ::toFloat(void) const { return static_cast<float>(sig->value); }
 
 
 // floating point cast
@@ -113,7 +125,7 @@ double Bool   ::toDouble(void) const { return static_cast<double>(value); }
 double SInt   ::toDouble(void) const { return static_cast<double>(value); }
 double UInt   ::toDouble(void) const { return static_cast<double>(value); }
 double Float  ::toDouble(void) const { return value; }
-double Enum   ::toDouble(void) const { return sig->second->toDouble(); }
+double Enum   ::toDouble(void) const { return static_cast<double>(sig->value); }
 
 
 // pointer cast
@@ -122,6 +134,11 @@ void * Null   ::toPointer(void) const { return NULL; }
 void * Blob   ::toPointer(void) const { return buf; }
 void * Pointer::toPointer(void) const { return (void *)value; }
 
+void * Value  ::toPointer(bool bind) { assert(0); return NULL; }
+void * Null   ::toPointer(bool bind) { return NULL; }
+void * Blob   ::toPointer(bool bind) { if (bind) bound = true; return buf; }
+void * Pointer::toPointer(bool bind) { return (void *)value; }
+
 
 // pointer cast
 unsigned long long Value  ::toUIntPtr(void) const { assert(0); return 0; }
@@ -156,7 +173,7 @@ void Visitor::visit(SInt *) { assert(0); }
 void Visitor::visit(UInt *) { assert(0); }
 void Visitor::visit(Float *) { assert(0); }
 void Visitor::visit(String *) { assert(0); }
-void Visitor::visit(Enum *node) { _visit(node->sig->second); }
+void Visitor::visit(Enum *node) { assert(0); }
 void Visitor::visit(Bitmask *node) { visit(static_cast<UInt *>(node)); }
 void Visitor::visit(Struct *) { assert(0); }
 void Visitor::visit(Array *) { assert(0); }
@@ -177,8 +194,8 @@ protected:
     Formatter::Attribute *literal;
 
 public:
-    Dumper(std::ostream &_os) : os(_os) {
-        formatter = Formatter::defaultFormatter();
+    Dumper(std::ostream &_os, bool color) : os(_os) {
+        formatter = Formatter::defaultFormatter(color);
         normal = formatter->normal();
         bold = formatter->bold();
         italic = formatter->italic();
@@ -250,14 +267,14 @@ public:
     }
 
     void visit(Enum *node) {
-        os << literal << node->sig->first << normal;
+        os << literal << node->sig->name << normal;
     }
 
     void visit(Bitmask *bitmask) {
         unsigned long long value = bitmask->value;
         const BitmaskSig *sig = bitmask->sig;
         bool first = true;
-        for (const BitmaskVal *it = sig->values; value != 0 && it != sig->values + sig->count; ++it) {
+        for (const BitmaskFlag *it = sig->flags; value != 0 && it != sig->flags + sig->num_flags; ++it) {
             if ((it->value && (value & it->value) == it->value) ||
                 (!it->value && value == 0)) {
                 if (!first) {
@@ -334,27 +351,16 @@ public:
 };
 
 
-std::ostream & operator <<(std::ostream &os, Value *value) {
-    Dumper d(os);
-    if (value) {
-        value->visit(d);
-    }
-    return os;
-}
-
-
-static inline const Value *unwrap(const Value *node) {
-    const Enum *c = dynamic_cast<const Enum *>(node);
-    if (c)
-        return c->sig->second;
-    return node;
+void Value::dump(std::ostream &os, bool color) {
+    Dumper d(os, color);
+    visit(d);
 }
 
 
 static Null null;
 
 const Value & Value::operator[](size_t index) const {
-    const Array *array = dynamic_cast<const Array *>(unwrap(this));
+    const Array *array = dynamic_cast<const Array *>(this);
     if (array) {
         if (index < array->values.size()) {
             return *array->values[index];
@@ -363,11 +369,10 @@ const Value & Value::operator[](size_t index) const {
     return null;
 }
 
-std::ostream & operator <<(std::ostream &os, Call &call) {
-    Dumper d(os);
-    os << call.no << " ";
-    d.visit(&call);
-    return os;
+void Call::dump(std::ostream &os, bool color) {
+    Dumper d(os, color);
+    os << no << " ";
+    d.visit(this);
 }