1// Copyright 2014 the V8 project authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef V8_VECTOR_H_ 6#define V8_VECTOR_H_ 7 8#include <string.h> 9#include <algorithm> 10 11#include "src/allocation.h" 12#include "src/checks.h" 13#include "src/globals.h" 14 15namespace v8 { 16namespace internal { 17 18 19template <typename T> 20class Vector { 21 public: 22 Vector() : start_(NULL), length_(0) {} 23 Vector(T* data, int length) : start_(data), length_(length) { 24 DCHECK(length == 0 || (length > 0 && data != NULL)); 25 } 26 27 static Vector<T> New(int length) { 28 return Vector<T>(NewArray<T>(length), length); 29 } 30 31 // Returns a vector using the same backing storage as this one, 32 // spanning from and including 'from', to but not including 'to'. 33 Vector<T> SubVector(int from, int to) { 34 SLOW_DCHECK(to <= length_); 35 SLOW_DCHECK(from < to); 36 DCHECK(0 <= from); 37 return Vector<T>(start() + from, to - from); 38 } 39 40 // Returns the length of the vector. 41 int length() const { return length_; } 42 43 // Returns whether or not the vector is empty. 44 bool is_empty() const { return length_ == 0; } 45 46 // Returns the pointer to the start of the data in the vector. 47 T* start() const { return start_; } 48 49 // Access individual vector elements - checks bounds in debug mode. 50 T& operator[](int index) const { 51 DCHECK(0 <= index && index < length_); 52 return start_[index]; 53 } 54 55 const T& at(int index) const { return operator[](index); } 56 57 T& first() { return start_[0]; } 58 59 T& last() { return start_[length_ - 1]; } 60 61 // Returns a clone of this vector with a new backing store. 62 Vector<T> Clone() const { 63 T* result = NewArray<T>(length_); 64 for (int i = 0; i < length_; i++) result[i] = start_[i]; 65 return Vector<T>(result, length_); 66 } 67 68 void Sort(int (*cmp)(const T*, const T*)) { 69 std::sort(start(), start() + length(), RawComparer(cmp)); 70 } 71 72 void Sort() { 73 std::sort(start(), start() + length()); 74 } 75 76 void Truncate(int length) { 77 DCHECK(length <= length_); 78 length_ = length; 79 } 80 81 // Releases the array underlying this vector. Once disposed the 82 // vector is empty. 83 void Dispose() { 84 DeleteArray(start_); 85 start_ = NULL; 86 length_ = 0; 87 } 88 89 inline Vector<T> operator+(int offset) { 90 DCHECK(offset < length_); 91 return Vector<T>(start_ + offset, length_ - offset); 92 } 93 94 // Factory method for creating empty vectors. 95 static Vector<T> empty() { return Vector<T>(NULL, 0); } 96 97 template<typename S> 98 static Vector<T> cast(Vector<S> input) { 99 return Vector<T>(reinterpret_cast<T*>(input.start()), 100 input.length() * sizeof(S) / sizeof(T)); 101 } 102 103 bool operator==(const Vector<T>& other) const { 104 if (length_ != other.length_) return false; 105 if (start_ == other.start_) return true; 106 for (int i = 0; i < length_; ++i) { 107 if (start_[i] != other.start_[i]) { 108 return false; 109 } 110 } 111 return true; 112 } 113 114 protected: 115 void set_start(T* start) { start_ = start; } 116 117 private: 118 T* start_; 119 int length_; 120 121 class RawComparer { 122 public: 123 explicit RawComparer(int (*cmp)(const T*, const T*)) : cmp_(cmp) {} 124 bool operator()(const T& a, const T& b) { 125 return cmp_(&a, &b) < 0; 126 } 127 128 private: 129 int (*cmp_)(const T*, const T*); 130 }; 131}; 132 133 134template <typename T> 135class ScopedVector : public Vector<T> { 136 public: 137 explicit ScopedVector(int length) : Vector<T>(NewArray<T>(length), length) { } 138 ~ScopedVector() { 139 DeleteArray(this->start()); 140 } 141 142 private: 143 DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedVector); 144}; 145 146 147inline int StrLength(const char* string) { 148 size_t length = strlen(string); 149 DCHECK(length == static_cast<size_t>(static_cast<int>(length))); 150 return static_cast<int>(length); 151} 152 153 154#define STATIC_CHAR_VECTOR(x) \ 155 v8::internal::Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(x), \ 156 arraysize(x) - 1) 157 158inline Vector<const char> CStrVector(const char* data) { 159 return Vector<const char>(data, StrLength(data)); 160} 161 162inline Vector<const uint8_t> OneByteVector(const char* data, int length) { 163 return Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), length); 164} 165 166inline Vector<const uint8_t> OneByteVector(const char* data) { 167 return OneByteVector(data, StrLength(data)); 168} 169 170inline Vector<char> MutableCStrVector(char* data) { 171 return Vector<char>(data, StrLength(data)); 172} 173 174inline Vector<char> MutableCStrVector(char* data, int max) { 175 int length = StrLength(data); 176 return Vector<char>(data, (length < max) ? length : max); 177} 178 179 180} } // namespace v8::internal 181 182#endif // V8_VECTOR_H_ 183