}
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;
+ }
}
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; }
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();
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) {
};
-std::ostream & operator <<(std::ostream &os, Value *value) {
- Dumper d(os);
- if (value) {
- value->visit(d);
- }
- return os;
+void Value::dump(std::ostream &os, bool color) {
+ Dumper d(os, color);
+ visit(d);
}
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);
}