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
  89
  90 // signed integer cast
  91 signed long long Value  ::toSInt(void) const { assert(0); return 0; }
  92 signed long long Null   ::toSInt(void) const { return 0; }
  93 signed long long Bool   ::toSInt(void) const { return static_cast<signed long long>(value); }
  94 signed long long SInt   ::toSInt(void) const { return value; }
  95 signed long long UInt   ::toSInt(void) const { assert(static_cast<signed long long>(value) >= 0); return static_cast<signed long long>(value); }
  96 signed long long Float  ::toSInt(void) const { return static_cast<signed long long>(value); }
  97 signed long long Double ::toSInt(void) const { return static_cast<signed long long>(value); }
  98
  99
 100 // unsigned integer cast
 101 unsigned long long Value  ::toUInt(void) const { assert(0); return 0; }
 102 unsigned long long Null   ::toUInt(void) const { return 0; }
 103 unsigned long long Bool   ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 104 unsigned long long SInt   ::toUInt(void) const { assert(value >= 0); return static_cast<signed long long>(value); }
 105 unsigned long long UInt   ::toUInt(void) const { return value; }
 106 unsigned long long Float  ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 107 unsigned long long Double ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 108
 109
 110 // floating point cast
 111 float Value  ::toFloat(void) const { assert(0); return 0; }
 112 float Null   ::toFloat(void) const { return 0; }
 113 float Bool   ::toFloat(void) const { return static_cast<float>(value); }
 114 float SInt   ::toFloat(void) const { return static_cast<float>(value); }
 115 float UInt   ::toFloat(void) const { return static_cast<float>(value); }
 116 float Float  ::toFloat(void) const { return value; }
 117 float Double ::toFloat(void) const { return value; }
 118
 119
 120 // floating point cast
 121 double Value  ::toDouble(void) const { assert(0); return 0; }
 122 double Null   ::toDouble(void) const { return 0; }
 123 double Bool   ::toDouble(void) const { return static_cast<double>(value); }
 124 double SInt   ::toDouble(void) const { return static_cast<double>(value); }
 125 double UInt   ::toDouble(void) const { return static_cast<double>(value); }
 126 double Float  ::toDouble(void) const { return value; }
 127 double Double ::toDouble(void) const { return value; }
 128
 129
 130 // pointer cast
 131 void * Value  ::toPointer(void) const { assert(0); return NULL; }
 132 void * Null   ::toPointer(void) const { return NULL; }
 133 void * Blob   ::toPointer(void) const { return buf; }
 134 void * Pointer::toPointer(void) const { return (void *)value; }
 135
 136 void * Value  ::toPointer(bool bind) { assert(0); return NULL; }
 137 void * Null   ::toPointer(bool bind) { return NULL; }
 138 void * Blob   ::toPointer(bool bind) { if (bind) bound = true; return buf; }
 139 void * Pointer::toPointer(bool bind) { return (void *)value; }
 140
 141
 142 // pointer cast
 143 unsigned long long Value  ::toUIntPtr(void) const { assert(0); return 0; }
 144 unsigned long long Null   ::toUIntPtr(void) const { return 0; }
 145 unsigned long long Pointer::toUIntPtr(void) const { return value; }
 146
 147
 148 // string cast
 149 const char * Value ::toString(void) const { assert(0); return NULL; }
 150 const char * Null  ::toString(void) const { return NULL; }
 151 const char * String::toString(void) const { return value; }
 152
 153
 154 // virtual Value::visit()
 155 void Null   ::visit(Visitor &visitor) { visitor.visit(this); }
 156 void Bool   ::visit(Visitor &visitor) { visitor.visit(this); }
 157 void SInt   ::visit(Visitor &visitor) { visitor.visit(this); }
 158 void UInt   ::visit(Visitor &visitor) { visitor.visit(this); }
 159 void Float  ::visit(Visitor &visitor) { visitor.visit(this); }
 160 void Double ::visit(Visitor &visitor) { visitor.visit(this); }
 161 void String ::visit(Visitor &visitor) { visitor.visit(this); }
 162 void Enum   ::visit(Visitor &visitor) { visitor.visit(this); }
 163 void Bitmask::visit(Visitor &visitor) { visitor.visit(this); }
 164 void Struct ::visit(Visitor &visitor) { visitor.visit(this); }
 165 void Array  ::visit(Visitor &visitor) { visitor.visit(this); }
 166 void Blob   ::visit(Visitor &visitor) { visitor.visit(this); }
 167 void Pointer::visit(Visitor &visitor) { visitor.visit(this); }
 168
 169
 170 void Visitor::visit(Null *) { assert(0); }
 171 void Visitor::visit(Bool *) { assert(0); }
 172 void Visitor::visit(SInt *) { assert(0); }
 173 void Visitor::visit(UInt *) { assert(0); }
 174 void Visitor::visit(Float *) { assert(0); }
 175 void Visitor::visit(Double *) { assert(0); }
 176 void Visitor::visit(String *) { assert(0); }
 177 void Visitor::visit(Enum *node) { assert(0); }
 178 void Visitor::visit(Bitmask *node) { visit(static_cast<UInt *>(node)); }
 179 void Visitor::visit(Struct *) { assert(0); }
 180 void Visitor::visit(Array *) { assert(0); }
 181 void Visitor::visit(Blob *) { assert(0); }
 182 void Visitor::visit(Pointer *) { assert(0); }
 183
 184
 185 static Null null;
 186
 187 const Value & Value::operator[](size_t index) const {
 188     const Array *array = dynamic_cast<const Array *>(this);
 189     if (array) {
 190         if (index < array->values.size()) {
 191             return *array->values[index];
 192         }
 193     }
 194     return null;
 195 }
 196
 197 } /* namespace trace */