Revert 20962 "Break cyclic reference between utils and platform."

src/utils.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_UTILS_H_
 #define V8_UTILS_H_
 
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
+#include <algorithm>
 
 #include "allocation.h"
 #include "checks.h"
 #include "globals.h"
-#include "platform.h"
-#include "vector.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // General helper functions
 
 #define IS_POWER_OF_TWO(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))
 
 // Returns true iff x is a power of 2. Cannot be used with the maximally
@@ skipping 193 matching lines @@
 }
 
 
 // Returns the negative absolute value of its argument.
 template <typename T>
 T NegAbs(T a) {
   return a < 0 ? a : -a;
 }
 
 
+inline int StrLength(const char* string) {
+  size_t length = strlen(string);
+  ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
+  return static_cast<int>(length);
+}
+
+
 // TODO(svenpanne) Clean up the whole power-of-2 mess.
 inline int32_t WhichPowerOf2Abs(int32_t x) {
   return (x == kMinInt) ? 31 : WhichPowerOf2(Abs(x));
 }
 
 
 // ----------------------------------------------------------------------------
 // BitField is a help template for encoding and decode bitfield with
 // unsigned content.
 
@@ skipping 118 matching lines @@
 
   T* value()  { return instance_; }
   T* operator -> ()  { return instance_; }
 
  private:
   StaticResource<T>* resource_;
   T* instance_;
 };
 
 
+template <typename T>
+class Vector {
+ public:
+  Vector() : start_(NULL), length_(0) {}
+  Vector(T* data, int length) : start_(data), length_(length) {
+    ASSERT(length == 0 || (length > 0 && data != NULL));
+  }
+
+  static Vector<T> New(int length) {
+    return Vector<T>(NewArray<T>(length), length);
+  }
+
+  // Returns a vector using the same backing storage as this one,
+  // spanning from and including 'from', to but not including 'to'.
+  Vector<T> SubVector(int from, int to) {
+    SLOW_ASSERT(to <= length_);
+    SLOW_ASSERT(from < to);
+    ASSERT(0 <= from);
+    return Vector<T>(start() + from, to - from);
+  }
+
+  // Returns the length of the vector.
+  int length() const { return length_; }
+
+  // Returns whether or not the vector is empty.
+  bool is_empty() const { return length_ == 0; }
+
+  // Returns the pointer to the start of the data in the vector.
+  T* start() const { return start_; }
+
+  // Access individual vector elements - checks bounds in debug mode.
+  T& operator[](int index) const {
+    ASSERT(0 <= index && index < length_);
+    return start_[index];
+  }
+
+  const T& at(int index) const { return operator[](index); }
+
+  T& first() { return start_[0]; }
+
+  T& last() { return start_[length_ - 1]; }
+
+  // Returns a clone of this vector with a new backing store.
+  Vector<T> Clone() const {
+    T* result = NewArray<T>(length_);
+    for (int i = 0; i < length_; i++) result[i] = start_[i];
+    return Vector<T>(result, length_);
+  }
+
+  void Sort(int (*cmp)(const T*, const T*)) {
+    std::sort(start(), start() + length(), RawComparer(cmp));
+  }
+
+  void Sort() {
+    std::sort(start(), start() + length());
+  }
+
+  void Truncate(int length) {
+    ASSERT(length <= length_);
+    length_ = length;
+  }
+
+  // Releases the array underlying this vector. Once disposed the
+  // vector is empty.
+  void Dispose() {
+    DeleteArray(start_);
+    start_ = NULL;
+    length_ = 0;
+  }
+
+  inline Vector<T> operator+(int offset) {
+    ASSERT(offset < length_);
+    return Vector<T>(start_ + offset, length_ - offset);
+  }
+
+  // Factory method for creating empty vectors.
+  static Vector<T> empty() { return Vector<T>(NULL, 0); }
+
+  template<typename S>
+  static Vector<T> cast(Vector<S> input) {
+    return Vector<T>(reinterpret_cast<T*>(input.start()),
+                     input.length() * sizeof(S) / sizeof(T));
+  }
+
+ protected:
+  void set_start(T* start) { start_ = start; }
+
+ private:
+  T* start_;
+  int length_;
+
+  class RawComparer {
+   public:
+    explicit RawComparer(int (*cmp)(const T*, const T*)) : cmp_(cmp) {}
+    bool operator()(const T& a, const T& b) {
+      return cmp_(&a, &b) < 0;
+    }
+
+   private:
+    int (*cmp_)(const T*, const T*);
+  };
+};
+
+
 // A pointer that can only be set once and doesn't allow NULL values.
 template<typename T>
 class SetOncePointer {
  public:
   SetOncePointer() : pointer_(NULL) { }
 
   bool is_set() const { return pointer_ != NULL; }
 
   T* get() const {
     ASSERT(pointer_ != NULL);
@@ skipping 17 matching lines @@
 
   explicit EmbeddedVector(T initial_value) : Vector<T>(buffer_, kSize) {
     for (int i = 0; i < kSize; ++i) {
       buffer_[i] = initial_value;
     }
   }
 
   // When copying, make underlying Vector to reference our buffer.
   EmbeddedVector(const EmbeddedVector& rhs)
       : Vector<T>(rhs) {
-    OS::MemCopy(buffer_, rhs.buffer_, sizeof(T) * kSize);
+    // TODO(jkummerow): Refactor #includes and use OS::MemCopy() instead.
+    memcpy(buffer_, rhs.buffer_, sizeof(T) * kSize);
     set_start(buffer_);
   }
 
   EmbeddedVector& operator=(const EmbeddedVector& rhs) {
     if (this == &rhs) return *this;
     Vector<T>::operator=(rhs);
-    OS::MemCopy(buffer_, rhs.buffer_, sizeof(T) * kSize);
+    // TODO(jkummerow): Refactor #includes and use OS::MemCopy() instead.
+    memcpy(buffer_, rhs.buffer_, sizeof(T) * kSize);
     this->set_start(buffer_);
     return *this;
   }
 
  private:
   T buffer_[kSize];
 };
 
 
+template <typename T>
+class ScopedVector : public Vector<T> {
+ public:
+  explicit ScopedVector(int length) : Vector<T>(NewArray<T>(length), length) { }
+  ~ScopedVector() {
+    DeleteArray(this->start());
+  }
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedVector);
+};
+
+#define STATIC_ASCII_VECTOR(x)                        \
+  v8::internal::Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(x), \
+                                      ARRAY_SIZE(x)-1)
+
+inline Vector<const char> CStrVector(const char* data) {
+  return Vector<const char>(data, StrLength(data));
+}
+
+inline Vector<const uint8_t> OneByteVector(const char* data, int length) {
+  return Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), length);
+}
+
+inline Vector<const uint8_t> OneByteVector(const char* data) {
+  return OneByteVector(data, StrLength(data));
+}
+
+inline Vector<char> MutableCStrVector(char* data) {
+  return Vector<char>(data, StrLength(data));
+}
+
+inline Vector<char> MutableCStrVector(char* data, int max) {
+  int length = StrLength(data);
+  return Vector<char>(data, (length < max) ? length : max);
+}
+
+
 /*
  * A class that collects values into a backing store.
  * Specialized versions of the class can allow access to the backing store
  * in different ways.
  * There is no guarantee that the backing store is contiguous (and, as a
  * consequence, no guarantees that consecutively added elements are adjacent
  * in memory). The collector may move elements unless it has guaranteed not
  * to.
  */
 template <typename T, int growth_factor = 2, int max_growth = 1 * MB>
@@ skipping 307 matching lines @@
 
 // We need different implementations of BitCast for pointer and non-pointer
 // values. We use partial specialization of auxiliary struct to work around
 // issues with template functions overloading.
 template <class Dest, class Source>
 struct BitCastHelper {
   STATIC_ASSERT(sizeof(Dest) == sizeof(Source));
 
   INLINE(static Dest cast(const Source& source)) {
     Dest dest;
-    OS::MemCopy(&dest, &source, sizeof(dest));
+    // TODO(jkummerow): Refactor #includes and use OS::MemCopy() instead.
+    memcpy(&dest, &source, sizeof(dest));
     return dest;
   }
 };
 
 template <class Dest, class Source>
 struct BitCastHelper<Dest, Source*> {
   INLINE(static Dest cast(Source* source)) {
     return BitCastHelper<Dest, uintptr_t>::
         cast(reinterpret_cast<uintptr_t>(source));
   }
@@ skipping 267 matching lines @@
   iterator end() { return container_->end(); }
   reverse_iterator rbegin() { return container_->rbegin(); }
   reverse_iterator rend() { return container_->rend(); }
  private:
   C* container_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_