git.cworth.org Git - apitrace/blob - common/trace_model.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26
  27 #include "trace_model.hpp"
  28
  29
  30 namespace trace {
  31
  32
  33 Call::~Call() {
  34     for (unsigned i = 0; i < args.size(); ++i) {
  35         delete args[i].value;
  36     }
  37
  38     if (ret) {
  39         delete ret;
  40     }
  41 }
  42
  43
  44 String::~String() {
  45     delete [] value;
  46 }
  47
  48
  49 Struct::~Struct() {
  50     for (std::vector<Value *>::iterator it = members.begin(); it != members.end(); ++it) {
  51         delete *it;
  52     }
  53 }
  54
  55
  56 Array::~Array() {
  57     for (std::vector<Value *>::iterator it = values.begin(); it != values.end(); ++it) {
  58         delete *it;
  59     }
  60 }
  61
  62 Blob::~Blob() {
  63     // Blobs are often bound and referred during many calls, so we can't delete
  64     // them here in that case.
  65     //
  66     // Once bound there is no way to know when they were unbound, which
  67     // effectively means we have to leak them.  A better solution would be to
  68     // keep a list of bound pointers, and defer the destruction to when the
  69     // trace in question has been fully processed.
  70     if (!bound) {
  71         delete [] buf;
  72     }
  73 }
  74
  75
  76 // bool cast
  77 bool Null   ::toBool(void) const { return false; }
  78 bool Bool   ::toBool(void) const { return value; }
  79 bool SInt   ::toBool(void) const { return value != 0; }
  80 bool UInt   ::toBool(void) const { return value != 0; }
  81 bool Float  ::toBool(void) const { return value != 0; }
  82 bool Double ::toBool(void) const { return value != 0; }
  83 bool String ::toBool(void) const { return true; }
  84 bool Struct ::toBool(void) const { return true; }
  85 bool Array  ::toBool(void) const { return true; }
  86 bool Blob   ::toBool(void) const { return true; }
  87 bool Pointer::toBool(void) const { return value != 0; }
  88 bool Repr   ::toBool(void) const { return static_cast<bool>(machineValue); }
  89
  90
  91 // signed integer cast
  92 signed long long Value  ::toSInt(void) const { assert(0); return 0; }
  93 signed long long Null   ::toSInt(void) const { return 0; }
  94 signed long long Bool   ::toSInt(void) const { return static_cast<signed long long>(value); }
  95 signed long long SInt   ::toSInt(void) const { return value; }
  96 signed long long UInt   ::toSInt(void) const { assert(static_cast<signed long long>(value) >= 0); return static_cast<signed long long>(value); }
  97 signed long long Float  ::toSInt(void) const { return static_cast<signed long long>(value); }
  98 signed long long Double ::toSInt(void) const { return static_cast<signed long long>(value); }
  99 signed long long Repr   ::toSInt(void) const { return machineValue->toSInt(); }
 100
 101
 102 // unsigned integer cast
 103 unsigned long long Value  ::toUInt(void) const { assert(0); return 0; }
 104 unsigned long long Null   ::toUInt(void) const { return 0; }
 105 unsigned long long Bool   ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 106 unsigned long long SInt   ::toUInt(void) const { assert(value >= 0); return static_cast<signed long long>(value); }
 107 unsigned long long UInt   ::toUInt(void) const { return value; }
 108 unsigned long long Float  ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 109 unsigned long long Double ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 110 unsigned long long Repr   ::toUInt(void) const { return machineValue->toUInt(); }
 111
 112
 113 // floating point cast
 114 float Value  ::toFloat(void) const { assert(0); return 0; }
 115 float Null   ::toFloat(void) const { return 0; }
 116 float Bool   ::toFloat(void) const { return static_cast<float>(value); }
 117 float SInt   ::toFloat(void) const { return static_cast<float>(value); }
 118 float UInt   ::toFloat(void) const { return static_cast<float>(value); }
 119 float Float  ::toFloat(void) const { return value; }
 120 float Double ::toFloat(void) const { return value; }
 121 float Repr   ::toFloat(void) const { return machineValue->toFloat(); }
 122
 123
 124 // floating point cast
 125 double Value  ::toDouble(void) const { assert(0); return 0; }
 126 double Null   ::toDouble(void) const { return 0; }
 127 double Bool   ::toDouble(void) const { return static_cast<double>(value); }
 128 double SInt   ::toDouble(void) const { return static_cast<double>(value); }
 129 double UInt   ::toDouble(void) const { return static_cast<double>(value); }
 130 double Float  ::toDouble(void) const { return value; }
 131 double Double ::toDouble(void) const { return value; }
 132 double Repr   ::toDouble(void) const { return machineValue->toDouble(); }
 133
 134
 135 // pointer cast
 136 void * Value  ::toPointer(void) const { assert(0); return NULL; }
 137 void * Null   ::toPointer(void) const { return NULL; }
 138 void * Blob   ::toPointer(void) const { return buf; }
 139 void * Pointer::toPointer(void) const { return (void *)value; }
 140 void * Repr   ::toPointer(void) const { return machineValue->toPointer(); }
 141
 142 void * Value  ::toPointer(bool bind) { assert(0); return NULL; }
 143 void * Null   ::toPointer(bool bind) { return NULL; }
 144 void * Blob   ::toPointer(bool bind) { if (bind) bound = true; return buf; }
 145 void * Pointer::toPointer(bool bind) { return (void *)value; }
 146 void * Repr   ::toPointer(bool bind) { return machineValue->toPointer(bind); }
 147
 148
 149 // unsigned int pointer cast
 150 unsigned long long Value  ::toUIntPtr(void) const { assert(0); return 0; }
 151 unsigned long long Null   ::toUIntPtr(void) const { return 0; }
 152 unsigned long long Pointer::toUIntPtr(void) const { return value; }
 153 unsigned long long Repr   ::toUIntPtr(void) const { return machineValue->toUIntPtr(); }
 154
 155
 156 // string cast
 157 const char * Value ::toString(void) const { assert(0); return NULL; }
 158 const char * Null  ::toString(void) const { return NULL; }
 159 const char * String::toString(void) const { return value; }
 160 const char * Repr  ::toString(void) const { return machineValue->toString(); }
 161
 162
 163 // virtual Value::visit()
 164 void Null   ::visit(Visitor &visitor) { visitor.visit(this); }
 165 void Bool   ::visit(Visitor &visitor) { visitor.visit(this); }
 166 void SInt   ::visit(Visitor &visitor) { visitor.visit(this); }
 167 void UInt   ::visit(Visitor &visitor) { visitor.visit(this); }
 168 void Float  ::visit(Visitor &visitor) { visitor.visit(this); }
 169 void Double ::visit(Visitor &visitor) { visitor.visit(this); }
 170 void String ::visit(Visitor &visitor) { visitor.visit(this); }
 171 void Enum   ::visit(Visitor &visitor) { visitor.visit(this); }
 172 void Bitmask::visit(Visitor &visitor) { visitor.visit(this); }
 173 void Struct ::visit(Visitor &visitor) { visitor.visit(this); }
 174 void Array  ::visit(Visitor &visitor) { visitor.visit(this); }
 175 void Blob   ::visit(Visitor &visitor) { visitor.visit(this); }
 176 void Pointer::visit(Visitor &visitor) { visitor.visit(this); }
 177 void Repr   ::visit(Visitor &visitor) { visitor.visit(this); }
 178
 179
 180 void Visitor::visit(Null *) { assert(0); }
 181 void Visitor::visit(Bool *) { assert(0); }
 182 void Visitor::visit(SInt *) { assert(0); }
 183 void Visitor::visit(UInt *) { assert(0); }
 184 void Visitor::visit(Float *) { assert(0); }
 185 void Visitor::visit(Double *) { assert(0); }
 186 void Visitor::visit(String *) { assert(0); }
 187 void Visitor::visit(Enum *node) { assert(0); }
 188 void Visitor::visit(Bitmask *node) { visit(static_cast<UInt *>(node)); }
 189 void Visitor::visit(Struct *) { assert(0); }
 190 void Visitor::visit(Array *) { assert(0); }
 191 void Visitor::visit(Blob *) { assert(0); }
 192 void Visitor::visit(Pointer *) { assert(0); }
 193 void Visitor::visit(Repr *node) { node->machineValue->visit(*this); }
 194
 195
 196 static Null null;
 197
 198 const Value & Value::operator[](size_t index) const {
 199     const Array *array = dynamic_cast<const Array *>(this);
 200     if (array) {
 201         if (index < array->values.size()) {
 202             return *array->values[index];
 203         }
 204     }
 205     return null;
 206 }
 207
 208 } /* namespace trace */