therubyracer 0.5.0-x86-linux → 0.11.0beta5-x86-linux

data/ext/v8/upstream/2.0.6/src/list-inl.h

@@ -1,166 +0,0 @@
-// Copyright 2006-2009 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
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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_LIST_INL_H_
-#define V8_LIST_INL_H_
-
-#include "list.h"
-
-namespace v8 {
-namespace internal {
-
-
-template<typename T, class P>
-void List<T, P>::Add(const T& element) {
-  if (length_ < capacity_) {
-    data_[length_++] = element;
-  } else {
-    List<T, P>::ResizeAdd(element);
-  }
-}
-
-
-template<typename T, class P>
-void List<T, P>::AddAll(const List<T, P>& other) {
-  int result_length = length_ + other.length_;
-  if (capacity_ < result_length) Resize(result_length);
-  for (int i = 0; i < other.length_; i++) {
-    data_[length_ + i] = other.data_[i];
-  }
-  length_ = result_length;
-}
-
-
-// Use two layers of inlining so that the non-inlined function can
-// use the same implementation as the inlined version.
-template<typename T, class P>
-void List<T, P>::ResizeAdd(const T& element) {
-  ResizeAddInternal(element);
-}
-
-
-template<typename T, class P>
-void List<T, P>::ResizeAddInternal(const T& element) {
-  ASSERT(length_ >= capacity_);
-  // Grow the list capacity by 50%, but make sure to let it grow
-  // even when the capacity is zero (possible initial case).
-  int new_capacity = 1 + capacity_ + (capacity_ >> 1);
-  // Since the element reference could be an element of the list, copy
-  // it out of the old backing storage before resizing.
-  T temp = element;
-  Resize(new_capacity);
-  data_[length_++] = temp;
-}
-
-
-template<typename T, class P>
-void List<T, P>::Resize(int new_capacity) {
-  T* new_data = List<T, P>::NewData(new_capacity);
-  memcpy(new_data, data_, capacity_ * sizeof(T));
-  List<T, P>::DeleteData(data_);
-  data_ = new_data;
-  capacity_ = new_capacity;
-}
-
-
-template<typename T, class P>
-Vector<T> List<T, P>::AddBlock(T value, int count) {
-  int start = length_;
-  for (int i = 0; i < count; i++) Add(value);
-  return Vector<T>(&data_[start], count);
-}
-
-
-template<typename T, class P>
-T List<T, P>::Remove(int i) {
-  T element = at(i);
-  length_--;
-  while (i < length_) {
-    data_[i] = data_[i + 1];
-    i++;
-  }
-  return element;
-}
-
-
-template<typename T, class P>
-void List<T, P>::Clear() {
-  DeleteData(data_);
-  Initialize(0);
-}
-
-
-template<typename T, class P>
-void List<T, P>::Rewind(int pos) {
-  length_ = pos;
-}
-
-
-template<typename T, class P>
-void List<T, P>::Iterate(void (*callback)(T* x)) {
-  for (int i = 0; i < length_; i++) callback(&data_[i]);
-}
-
-
-template<typename T, class P>
-bool List<T, P>::Contains(const T& elm) {
-  for (int i = 0; i < length_; i++) {
-    if (data_[i] == elm)
-      return true;
-  }
-  return false;
-}
-
-
-template<typename T, class P>
-void List<T, P>::Sort(int (*cmp)(const T* x, const T* y)) {
-  ToVector().Sort(cmp);
-#ifdef DEBUG
-  for (int i = 1; i < length_; i++)
-    ASSERT(cmp(&data_[i - 1], &data_[i]) <= 0);
-#endif
-}
-
-
-template<typename T, class P>
-void List<T, P>::Sort() {
-  Sort(PointerValueCompare<T>);
-}
-
-
-template<typename T, class P>
-void List<T, P>::Initialize(int capacity) {
-  ASSERT(capacity >= 0);
-  data_ = (capacity > 0) ? NewData(capacity) : NULL;
-  capacity_ = capacity;
-  length_ = 0;
-}
-
-
-} }  // namespace v8::internal
-
-#endif  // V8_LIST_INL_H_

data/ext/v8/upstream/2.0.6/src/list.h

@@ -1,158 +0,0 @@
-// Copyright 2006-2009 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
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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_LIST_H_
-#define V8_LIST_H_
-
-namespace v8 {
-namespace internal {
-
-
-// ----------------------------------------------------------------------------
-// The list is a template for very light-weight lists. We are not
-// using the STL because we want full control over space and speed of
-// the code. This implementation is based on code by Robert Griesemer
-// and Rob Pike.
-//
-// The list is parameterized by the type of its elements (T) and by an
-// allocation policy (P). The policy is used for allocating lists in
-// the C free store or the zone; see zone.h.
-
-// Forward defined as
-// template <typename T, class P = FreeStoreAllocationPolicy> class List;
-template <typename T, class P>
-class List {
- public:
-
-  List() { Initialize(0); }
-  INLINE(explicit List(int capacity)) { Initialize(capacity); }
-  INLINE(~List()) { DeleteData(data_); }
-
-  // Deallocates memory used by the list and leaves the list in a consistent
-  // empty state.
-  void Free() {
-    DeleteData(data_);
-    Initialize(0);
-  }
-
-  INLINE(void* operator new(size_t size)) {
-      return P::New(static_cast<int>(size));
-  }
-  INLINE(void operator delete(void* p, size_t)) { return P::Delete(p); }
-
-  // Returns a reference to the element at index i.  This reference is
-  // not safe to use after operations that can change the list's
-  // backing store (eg, Add).
-  inline T& operator[](int i) const  {
-    ASSERT(0 <= i && i < length_);
-    return data_[i];
-  }
-  inline T& at(int i) const  { return operator[](i); }
-  inline T& last() const { return at(length_ - 1); }
-  inline T& first() const { return at(0); }
-
-  INLINE(bool is_empty() const) { return length_ == 0; }
-  INLINE(int length() const) { return length_; }
-  INLINE(int capacity() const) { return capacity_; }
-
-  Vector<T> ToVector() { return Vector<T>(data_, length_); }
-
-  Vector<const T> ToConstVector() { return Vector<const T>(data_, length_); }
-
-  // Adds a copy of the given 'element' to the end of the list,
-  // expanding the list if necessary.
-  void Add(const T& element);
-
-  // Add all the elements from the argument list to this list.
-  void AddAll(const List<T, P>& other);
-
-  // Added 'count' elements with the value 'value' and returns a
-  // vector that allows access to the elements.  The vector is valid
-  // until the next change is made to this list.
-  Vector<T> AddBlock(T value, int count);
-
-  // Removes the i'th element without deleting it even if T is a
-  // pointer type; moves all elements above i "down". Returns the
-  // removed element.  This function's complexity is linear in the
-  // size of the list.
-  T Remove(int i);
-
-  // Removes the last element without deleting it even if T is a
-  // pointer type. Returns the removed element.
-  INLINE(T RemoveLast()) { return Remove(length_ - 1); }
-
-  // Clears the list by setting the length to zero. Even if T is a
-  // pointer type, clearing the list doesn't delete the entries.
-  INLINE(void Clear());
-
-  // Drops all but the first 'pos' elements from the list.
-  INLINE(void Rewind(int pos));
-
-  bool Contains(const T& elm);
-
-  // Iterate through all list entries, starting at index 0.
-  void Iterate(void (*callback)(T* x));
-
-  // Sort all list entries (using QuickSort)
-  void Sort(int (*cmp)(const T* x, const T* y));
-  void Sort();
-
-  INLINE(void Initialize(int capacity));
-
- private:
-  T* data_;
-  int capacity_;
-  int length_;
-
-  INLINE(T* NewData(int n))  { return static_cast<T*>(P::New(n * sizeof(T))); }
-  INLINE(void DeleteData(T* data))  { P::Delete(data); }
-
-  // Increase the capacity of a full list, and add an element.
-  // List must be full already.
-  void ResizeAdd(const T& element);
-
-  // Inlined implementation of ResizeAdd, shared by inlined and
-  // non-inlined versions of ResizeAdd.
-  void ResizeAddInternal(const T& element);
-
-  // Resize the list.
-  void Resize(int new_capacity);
-
-  DISALLOW_COPY_AND_ASSIGN(List);
-};
-
-class FrameElement;
-
-// Add() is inlined, ResizeAdd() called by Add() is inlined except for
-// Lists of FrameElements, and ResizeAddInternal() is inlined in ResizeAdd().
-template <>
-void List<FrameElement,
-          FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element);
-
-} }  // namespace v8::internal
-
-#endif  // V8_LIST_H_

data/ext/v8/upstream/2.0.6/src/log-inl.h

@@ -1,126 +0,0 @@
-// Copyright 2006-2009 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
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// 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_LOG_INL_H_
-#define V8_LOG_INL_H_
-
-#include "log.h"
-
-namespace v8 {
-namespace internal {
-
-//
-// VMState class implementation.  A simple stack of VM states held by the
-// logger and partially threaded through the call stack.  States are pushed by
-// VMState construction and popped by destruction.
-//
-#ifdef ENABLE_LOGGING_AND_PROFILING
-inline const char* StateToString(StateTag state) {
-  switch (state) {
-    case JS:
-      return "JS";
-    case GC:
-      return "GC";
-    case COMPILER:
-      return "COMPILER";
-    case OTHER:
-      return "OTHER";
-    default:
-      UNREACHABLE();
-      return NULL;
-  }
-}
-
-VMState::VMState(StateTag state) : disabled_(true), external_callback_(NULL) {
-  if (!Logger::is_logging()) {
-    return;
-  }
-
-  disabled_ = false;
-#if !defined(ENABLE_HEAP_PROTECTION)
-  // When not protecting the heap, there is no difference between
-  // EXTERNAL and OTHER.  As an optimization in that case, we will not
-  // perform EXTERNAL->OTHER transitions through the API.  We thus
-  // compress the two states into one.
-  if (state == EXTERNAL) state = OTHER;
-#endif
-  state_ = state;
-  previous_ = Logger::current_state_;
-  Logger::current_state_ = this;
-
-  if (FLAG_log_state_changes) {
-    LOG(UncheckedStringEvent("Entering", StateToString(state_)));
-    if (previous_ != NULL) {
-      LOG(UncheckedStringEvent("From", StateToString(previous_->state_)));
-    }
-  }
-
-#ifdef ENABLE_HEAP_PROTECTION
-  if (FLAG_protect_heap && previous_ != NULL) {
-    if (state_ == EXTERNAL) {
-      // We are leaving V8.
-      ASSERT(previous_->state_ != EXTERNAL);
-      Heap::Protect();
-    } else if (previous_->state_ == EXTERNAL) {
-      // We are entering V8.
-      Heap::Unprotect();
-    }
-  }
-#endif
-}
-
-
-VMState::~VMState() {
-  if (disabled_) return;
-  Logger::current_state_ = previous_;
-
-  if (FLAG_log_state_changes) {
-    LOG(UncheckedStringEvent("Leaving", StateToString(state_)));
-    if (previous_ != NULL) {
-      LOG(UncheckedStringEvent("To", StateToString(previous_->state_)));
-    }
-  }
-
-#ifdef ENABLE_HEAP_PROTECTION
-  if (FLAG_protect_heap && previous_ != NULL) {
-    if (state_ == EXTERNAL) {
-      // We are reentering V8.
-      ASSERT(previous_->state_ != EXTERNAL);
-      Heap::Unprotect();
-    } else if (previous_->state_ == EXTERNAL) {
-      // We are leaving V8.
-      Heap::Protect();
-    }
-  }
-#endif
-}
-#endif
-
-
-} }  // namespace v8::internal
-
-#endif  // V8_LOG_INL_H_