Ignore assertion failure on Mac OS X.

[apitrace] / trace_model.cpp

diff --git a/trace_model.cpp b/trace_model.cpp
index c74aaaeee998d3c6afdf51543cd1ab8652e0886f..e8bb3e41ce761302678f4dea889a07289184b805 100644 (file)
--- a/trace_model.cpp
+++ b/trace_model.cpp
@@ -63,54 +63,76 @@ Blob::~Blob() {
 
 
 // bool cast
-Null   ::operator bool(void) const { return false; }
-Bool   ::operator bool(void) const { return value; }
-SInt   ::operator bool(void) const { return value != 0; }
-UInt   ::operator bool(void) const { return value != 0; }
-Float  ::operator bool(void) const { return value != 0; }
-String ::operator bool(void) const { return true; }
-Enum   ::operator bool(void) const { return static_cast<bool>(*sig->second); }
-Struct ::operator bool(void) const { return true; }
-Array  ::operator bool(void) const { return true; }
-Blob   ::operator bool(void) const { return true; }
-Pointer::operator bool(void) const { return value != 0; }
+bool Null   ::toBool(void) const { return false; }
+bool Bool   ::toBool(void) const { return value; }
+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 Struct ::toBool(void) const { return true; }
+bool Array  ::toBool(void) const { return true; }
+bool Blob   ::toBool(void) const { return true; }
+bool Pointer::toBool(void) const { return value != 0; }
 
 
 // signed integer cast
-Value  ::operator signed long long (void) const { assert(0); return 0; }
-Null   ::operator signed long long (void) const { return 0; }
-Bool   ::operator signed long long (void) const { return static_cast<signed long long>(value); }
-SInt   ::operator signed long long (void) const { return value; }
-UInt   ::operator signed long long (void) const { assert(static_cast<signed long long>(value) >= 0); return static_cast<signed long long>(value); }
-Float  ::operator signed long long (void) const { return static_cast<signed long long>(value); }
-Enum   ::operator signed long long (void) const { return static_cast<signed long long>(*sig->second); }
+signed long long Value  ::toSInt(void) const { assert(0); return 0; }
+signed long long Null   ::toSInt(void) const { return 0; }
+signed long long Bool   ::toSInt(void) const { return static_cast<signed long long>(value); }
+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(); }
 
 
 // unsigned integer cast
-Value  ::operator unsigned long long (void) const { assert(0); return 0; }
-Null   ::operator unsigned long long (void) const { return 0; }
-Bool   ::operator unsigned long long (void) const { return static_cast<unsigned long long>(value); }
-SInt   ::operator unsigned long long (void) const { assert(value >= 0); return static_cast<signed long long>(value); }
-UInt   ::operator unsigned long long (void) const { return value; }
-Float  ::operator unsigned long long (void) const { return static_cast<unsigned long long>(value); }
-Enum   ::operator unsigned long long (void) const { return static_cast<unsigned long long>(*sig->second); }
+unsigned long long Value  ::toUInt(void) const { assert(0); return 0; }
+unsigned long long Null   ::toUInt(void) const { return 0; }
+unsigned long long Bool   ::toUInt(void) const { return static_cast<unsigned long long>(value); }
+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(); }
 
 
 // floating point cast
-Value  ::operator double (void) const { assert(0); return 0; }
-Null   ::operator double (void) const { return 0; }
-Bool   ::operator double (void) const { return static_cast<double>(value); }
-SInt   ::operator double (void) const { return static_cast<double>(value); }
-UInt   ::operator double (void) const { return static_cast<double>(value); }
-Float  ::operator double (void) const { return value; }
-Enum   ::operator double (void) const { return static_cast<unsigned long long>(*sig->second); }
+float Value  ::toFloat(void) const { assert(0); return 0; }
+float Null   ::toFloat(void) const { return 0; }
+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(); }
 
 
-// blob cast
-void * Value  ::blob(void) const { assert(0); return NULL; }
-void * Null   ::blob(void) const { return NULL; }
-void * Blob   ::blob(void) const { return buf; }
-void * Pointer::blob(void) const { assert(value < 0x100000ULL); return (void *)value; }
+// floating point cast
+double Value  ::toDouble(void) const { assert(0); return 0; }
+double Null   ::toDouble(void) const { return 0; }
+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(); }
+
+
+// pointer cast
+void * Value  ::toPointer(void) const { assert(0); return NULL; }
+void * Null   ::toPointer(void) const { return NULL; }
+void * Blob   ::toPointer(void) const { return buf; }
+void * Pointer::toPointer(void) const { return (void *)value; }
+
+
+// pointer cast
+unsigned long long Value  ::toUIntPtr(void) const { assert(0); return 0; }
+unsigned long long Null   ::toUIntPtr(void) const { return 0; }
+unsigned long long Pointer::toUIntPtr(void) const { return value; }
+
+
+// string cast
+const char * Value ::toString(void) const { assert(0); return NULL; }
+const char * Null  ::toString(void) const { return NULL; }
+const char * String::toString(void) const { return value.c_str(); }
 
 
 // virtual Value::visit()
@@ -236,8 +258,8 @@ public:
         const Bitmask::Signature *sig = bitmask->sig;
         bool first = true;
         for (Bitmask::Signature::const_iterator it = sig->begin(); value != 0 && it != sig->end(); ++it) {
-            assert(it->second);
-            if ((value & it->second) == it->second) {
+            if ((it->second && (value & it->second) == it->second) ||
+                (!it->second && value == 0)) {
                 if (!first) {
                     os << " | ";
                 }
@@ -295,7 +317,11 @@ public:
         os << bold << call->sig->name << normal << "(";
         for (unsigned i = 0; i < call->args.size(); ++i) {
             os << sep << italic << call->sig->arg_names[i] << normal << " = ";
-            _visit(call->args[i]);
+            if (call->args[i]) {
+                _visit(call->args[i]);
+            } else {
+               os << "?";
+            }
             sep = ", ";
         }
         os << ")";
@@ -337,17 +363,6 @@ const Value & Value::operator[](size_t index) const {
     return null;
 }
 
-const char * Value::string(void) const {
-    const String *string = dynamic_cast<const String *>(unwrap(this));
-    if (string)
-        return string->value.c_str();
-    const Null *null = dynamic_cast<const Null *>(unwrap(this));
-    if (null)
-        return NULL;
-    assert(0);
-    return NULL;
-}
-
 std::ostream & operator <<(std::ostream &os, Call &call) {
     Dumper d(os);
     os << call.no << " ";