Merge regexp2000 back into bleeding_edge

src/utils.h

 // Copyright 2006-2008 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 65 matching lines @@
 }
 
 
 // Return the smallest multiple of m which is >= x.
 template <typename T>
 static inline T RoundUp(T x, int m) {
   return RoundDown(x + m - 1, m);
 }
 
 
+template <typename T>
+static int Spaceship(const T& a, const T& b) {

[iposva, 2008/11/26 06:56:22]

Comments please. What kind of spaceship is this? To me this looks like a
comparison, but what do I know?

[Christian Plesner Hansen, 2008/11/26 07:49:51]

I'll rename it.  The name "spaceship" is apparently not as well known as I
thought.  http://en.wikipedia.org/wiki/Spaceship_operator

+  if (a == b)
+    return 0;
+  else if (a < b)
+    return -1;
+  else
+    return 1;
+}
+
+
+template <typename T>
+static int PointerSpaceship(const T* a, const T* b) {
+  return Spaceship<T>(*a, *b);
+}
+
+
 // Returns the smallest power of two which is >= x. If you pass in a
 // number that is already a power of two, it is returned as is.
 uint32_t RoundUpToPowerOf2(uint32_t x);
 
 
 template <typename T>
 static inline bool IsAligned(T value, T alignment) {
   ASSERT(IsPowerOf2(alignment));
   return (value & (alignment - 1)) == 0;
 }
@@ skipping 180 matching lines @@
  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) {
+    ASSERT(from < length_);
+    ASSERT(to <= length_);
+    ASSERT(from < to);
+    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];
   }
 
+  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*)) {
+    typedef int (*RawComparer)(const void*, const void*);
+    qsort(start(),
+          length(),
+          sizeof(T),
+          reinterpret_cast<RawComparer>(cmp));
+  }
+
+  void Sort() {
+    Sort(PointerSpaceship<T>);
+  }
+
   // Releases the array underlying this vector. Once disposed the
   // vector is empty.
   void Dispose() {
     if (is_empty()) return;
     DeleteArray(start_);
     start_ = NULL;
     length_ = 0;
   }
 
   inline Vector<T> operator+(int offset) {
@@ skipping 140 matching lines @@
       dest += kStepSize;
       src += kStepSize;
     }
   }
 #endif
   while (dest < limit) {
     *dest++ = static_cast<sinkchar>(*src++);
   }
 }
 
+
+static inline int Load16(const byte* pc) {

[iposva, 2008/11/26 06:56:22]

I understand that this is most likely used when accessing multi-byte values in
generated code or bytecodes, but using ptr insted of pc would probably be more
appropriate.

[Erik Corry, 2008/11/26 12:18:36]

Yes, that's what it's used for and in this context it has the correct name.

+#ifdef CAN_READ_UNALIGNED
+  return *reinterpret_cast<const uint16_t*>(pc);
+#else
+  uint32_t word;
+  word  = pc[1];
+  word |= pc[0] << 8;
+  return word;
+#endif
+}
+
+
+static inline int Load32(const byte* pc) {
+#ifdef CAN_READ_UNALIGNED
+  return *reinterpret_cast<const uint32_t*>(pc);
+#else
+  uint32_t word;
+  word  = pc[3];
+  word |= pc[2] << 8;
+  word |= pc[1] << 16;
+  word |= pc[0] << 24;
+  return word;
+#endif
+}
+
+
+static inline void Store16(byte* pc, uint16_t value) {
+#ifdef CAN_READ_UNALIGNED
+  *reinterpret_cast<uint16_t*>(pc) = value;
+#else
+  pc[1] = value;
+  pc[0] = value >> 8;
+#endif
+}
+
+
+static inline void Store32(byte* pc, uint32_t value) {
+#ifdef CAN_READ_UNALIGNED
+  *reinterpret_cast<uint32_t*>(pc) = value;
+#else
+  pc[3] = value;
+  pc[2] = value >> 8;
+  pc[1] = value >> 16;
+  pc[0] = value >> 24;
+#endif
+}
+
+
+
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_