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

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

@@ -1,425 +0,0 @@
-// 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
-//       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_SCANNER_H_
-#define V8_SCANNER_H_
-
-#include "token.h"
-#include "char-predicates-inl.h"
-
-namespace v8 {
-namespace internal {
-
-
-class UTF8Buffer {
- public:
-  UTF8Buffer();
-  ~UTF8Buffer();
-
-  void AddChar(uc32 c) {
-    ASSERT_NOT_NULL(data_);
-    if (cursor_ <= limit_ &&
-        static_cast<unsigned>(c) <= unibrow::Utf8::kMaxOneByteChar) {
-      *cursor_++ = static_cast<char>(c);
-    } else {
-      AddCharSlow(c);
-    }
-  }
-
-  void Reset() {
-    if (data_ == NULL) {
-      data_ = NewArray<char>(kInitialCapacity);
-      limit_ = ComputeLimit(data_, kInitialCapacity);
-    }
-    cursor_ = data_;
-  }
-
-  int pos() const {
-    ASSERT_NOT_NULL(data_);
-    return static_cast<int>(cursor_ - data_);
-  }
-
-  char* data() const { return data_; }
-
- private:
-  static const int kInitialCapacity = 256;
-  char* data_;
-  char* cursor_;
-  char* limit_;
-
-  int Capacity() const {
-    ASSERT_NOT_NULL(data_);
-    return static_cast<int>(limit_ - data_) + unibrow::Utf8::kMaxEncodedSize;
-  }
-
-  static char* ComputeLimit(char* data, int capacity) {
-    return (data + capacity) - unibrow::Utf8::kMaxEncodedSize;
-  }
-
-  void AddCharSlow(uc32 c);
-};
-
-
-class UTF16Buffer {
- public:
-  UTF16Buffer();
-  virtual ~UTF16Buffer() {}
-
-  virtual void PushBack(uc32 ch) = 0;
-  // returns a value < 0 when the buffer end is reached
-  virtual uc32 Advance() = 0;
-  virtual void SeekForward(int pos) = 0;
-
-  int pos() const { return pos_; }
-  int size() const { return size_; }
-  Handle<String> SubString(int start, int end);
-
- protected:
-  Handle<String> data_;
-  int pos_;
-  int size_;
-};
-
-
-class CharacterStreamUTF16Buffer: public UTF16Buffer {
- public:
-  CharacterStreamUTF16Buffer();
-  virtual ~CharacterStreamUTF16Buffer() {}
-  void Initialize(Handle<String> data, unibrow::CharacterStream* stream);
-  virtual void PushBack(uc32 ch);
-  virtual uc32 Advance();
-  virtual void SeekForward(int pos);
-
- private:
-  List<uc32> pushback_buffer_;
-  uc32 last_;
-  unibrow::CharacterStream* stream_;
-
-  List<uc32>* pushback_buffer() { return &pushback_buffer_; }
-};
-
-
-class TwoByteStringUTF16Buffer: public UTF16Buffer {
- public:
-  TwoByteStringUTF16Buffer();
-  virtual ~TwoByteStringUTF16Buffer() {}
-  void Initialize(Handle<ExternalTwoByteString> data);
-  virtual void PushBack(uc32 ch);
-  virtual uc32 Advance();
-  virtual void SeekForward(int pos);
-
- private:
-  const uint16_t* raw_data_;
-};
-
-
-class KeywordMatcher {
-//  Incrementally recognize keywords.
-//
-//  Recognized keywords:
-//      break case catch const* continue debugger* default delete do else
-//      finally false for function if in instanceof native* new null
-//      return switch this throw true try typeof var void while with
-//
-//  *: Actually "future reserved keywords". These are the only ones we
-//     recognized, the remaining are allowed as identifiers.
- public:
-  KeywordMatcher() : state_(INITIAL), token_(Token::IDENTIFIER) {}
-
-  Token::Value token() { return token_; }
-
-  inline void AddChar(uc32 input) {
-    if (state_ != UNMATCHABLE) {
-      Step(input);
-    }
-  }
-
-  void Fail() {
-    token_ = Token::IDENTIFIER;
-    state_ = UNMATCHABLE;
-  }
-
- private:
-  enum State {
-    UNMATCHABLE,
-    INITIAL,
-    KEYWORD_PREFIX,
-    KEYWORD_MATCHED,
-    C,
-    CA,
-    CO,
-    CON,
-    D,
-    DE,
-    F,
-    I,
-    IN,
-    N,
-    T,
-    TH,
-    TR,
-    V,
-    W
-  };
-
-  struct FirstState {
-    const char* keyword;
-    State state;
-    Token::Value token;
-  };
-
-  // Range of possible first characters of a keyword.
-  static const unsigned int kFirstCharRangeMin = 'b';
-  static const unsigned int kFirstCharRangeMax = 'w';
-  static const unsigned int kFirstCharRangeLength =
-      kFirstCharRangeMax - kFirstCharRangeMin + 1;
-  // State map for first keyword character range.
-  static FirstState first_states_[kFirstCharRangeLength];
-
-  // Current state.
-  State state_;
-  // Token for currently added characters.
-  Token::Value token_;
-
-  // Matching a specific keyword string (there is only one possible valid
-  // keyword with the current prefix).
-  const char* keyword_;
-  int counter_;
-  Token::Value keyword_token_;
-
-  // If input equals keyword's character at position, continue matching keyword
-  // from that position.
-  inline bool MatchKeywordStart(uc32 input,
-                                const char* keyword,
-                                int position,
-                                Token::Value token_if_match) {
-    if (input == keyword[position]) {
-      state_ = KEYWORD_PREFIX;
-      this->keyword_ = keyword;
-      this->counter_ = position + 1;
-      this->keyword_token_ = token_if_match;
-      return true;
-    }
-    return false;
-  }
-
-  // If input equals match character, transition to new state and return true.
-  inline bool MatchState(uc32 input, char match, State new_state) {
-    if (input == match) {
-      state_ = new_state;
-      return true;
-    }
-    return false;
-  }
-
-  inline bool MatchKeyword(uc32 input,
-                           char match,
-                           State new_state,
-                           Token::Value keyword_token) {
-    if (input == match) {  // Matched "do".
-      state_ = new_state;
-      token_ = keyword_token;
-      return true;
-    }
-    return false;
-  }
-
-  void Step(uc32 input);
-};
-
-
-class Scanner {
- public:
-
-  typedef unibrow::Utf8InputBuffer<1024> Utf8Decoder;
-
-  // Construction
-  explicit Scanner(bool is_pre_parsing);
-
-  // Initialize the Scanner to scan source:
-  void Init(Handle<String> source,
-            unibrow::CharacterStream* stream,
-            int position);
-
-  // Returns the next token.
-  Token::Value Next();
-
-  // One token look-ahead (past the token returned by Next()).
-  Token::Value peek() const  { return next_.token; }
-
-  // Returns true if there was a line terminator before the peek'ed token.
-  bool has_line_terminator_before_next() const {
-    return has_line_terminator_before_next_;
-  }
-
-  struct Location {
-    Location(int b, int e) : beg_pos(b), end_pos(e) { }
-    Location() : beg_pos(0), end_pos(0) { }
-    int beg_pos;
-    int end_pos;
-  };
-
-  // Returns the location information for the current token
-  // (the token returned by Next()).
-  Location location() const  { return current_.location; }
-  Location peek_location() const  { return next_.location; }
-
-  // Returns the literal string, if any, for the current token (the
-  // token returned by Next()). The string is 0-terminated and in
-  // UTF-8 format; they may contain 0-characters. Literal strings are
-  // collected for identifiers, strings, and numbers.
-  // These functions only give the correct result if the literal
-  // was scanned between calls to StartLiteral() and TerminateLiteral().
-  const char* literal_string() const {
-    return current_.literal_buffer->data();
-  }
-  int literal_length() const {
-    // Excluding terminal '\0' added by TerminateLiteral().
-    return current_.literal_buffer->pos() - 1;
-  }
-
-  // Returns the literal string for the next token (the token that
-  // would be returned if Next() were called).
-  const char* next_literal_string() const {
-    return next_.literal_buffer->data();
-  }
-  // Returns the length of the next token (that would be returned if
-  // Next() were called).
-  int next_literal_length() const {
-    return next_.literal_buffer->pos() - 1;
-  }
-
-  Vector<const char> next_literal() const {
-    return Vector<const char>(next_literal_string(),
-                              next_literal_length());
-  }
-
-  // Scans the input as a regular expression pattern, previous
-  // character(s) must be /(=). Returns true if a pattern is scanned.
-  bool ScanRegExpPattern(bool seen_equal);
-  // Returns true if regexp flags are scanned (always since flags can
-  // be empty).
-  bool ScanRegExpFlags();
-
-  // Seek forward to the given position.  This operation does not
-  // work in general, for instance when there are pushed back
-  // characters, but works for seeking forward until simple delimiter
-  // tokens, which is what it is used for.
-  void SeekForward(int pos);
-
-  Handle<String> SubString(int start_pos, int end_pos);
-  bool stack_overflow() { return stack_overflow_; }
-
-  static StaticResource<Utf8Decoder>* utf8_decoder() { return &utf8_decoder_; }
-
-  // Tells whether the buffer contains an identifier (no escapes).
-  // Used for checking if a property name is an identifier.
-  static bool IsIdentifier(unibrow::CharacterStream* buffer);
-
-  static unibrow::Predicate<IdentifierStart, 128> kIsIdentifierStart;
-  static unibrow::Predicate<IdentifierPart, 128> kIsIdentifierPart;
-  static unibrow::Predicate<unibrow::LineTerminator, 128> kIsLineTerminator;
-  static unibrow::Predicate<unibrow::WhiteSpace, 128> kIsWhiteSpace;
-
-  static const int kCharacterLookaheadBufferSize = 1;
-
- private:
-  CharacterStreamUTF16Buffer char_stream_buffer_;
-  TwoByteStringUTF16Buffer two_byte_string_buffer_;
-
-  // Source.
-  UTF16Buffer* source_;
-  int position_;
-
-  // Buffer to hold literal values (identifiers, strings, numbers)
-  // using 0-terminated UTF-8 encoding.
-  UTF8Buffer literal_buffer_1_;
-  UTF8Buffer literal_buffer_2_;
-
-  bool stack_overflow_;
-  static StaticResource<Utf8Decoder> utf8_decoder_;
-
-  // One Unicode character look-ahead; c0_ < 0 at the end of the input.
-  uc32 c0_;
-
-  // The current and look-ahead token.
-  struct TokenDesc {
-    Token::Value token;
-    Location location;
-    UTF8Buffer* literal_buffer;
-  };
-
-  TokenDesc current_;  // desc for current token (as returned by Next())
-  TokenDesc next_;     // desc for next token (one token look-ahead)
-  bool has_line_terminator_before_next_;
-  bool is_pre_parsing_;
-
-  // Literal buffer support
-  void StartLiteral();
-  void AddChar(uc32 ch);
-  void AddCharAdvance();
-  void TerminateLiteral();
-
-  // Low-level scanning support.
-  void Advance() { c0_ = source_->Advance(); }
-  void PushBack(uc32 ch) {
-    source_->PushBack(ch);
-    c0_ = ch;
-  }
-
-  bool SkipWhiteSpace();
-  Token::Value SkipSingleLineComment();
-  Token::Value SkipMultiLineComment();
-
-  inline Token::Value Select(Token::Value tok);
-  inline Token::Value Select(uc32 next, Token::Value then, Token::Value else_);
-
-  void Scan();
-  void ScanDecimalDigits();
-  Token::Value ScanNumber(bool seen_period);
-  Token::Value ScanIdentifier();
-  uc32 ScanHexEscape(uc32 c, int length);
-  uc32 ScanOctalEscape(uc32 c, int length);
-  void ScanEscape();
-  Token::Value ScanString();
-
-  // Scans a possible HTML comment -- begins with '<!'.
-  Token::Value ScanHtmlComment();
-
-  // Return the current source position.
-  int source_pos() {
-    return source_->pos() - kCharacterLookaheadBufferSize + position_;
-  }
-
-  // Decodes a unicode escape-sequence which is part of an identifier.
-  // If the escape sequence cannot be decoded the result is kBadRune.
-  uc32 ScanIdentifierUnicodeEscape();
-};
-
-} }  // namespace v8::internal
-
-#endif  // V8_SCANNER_H_

data/ext/v8/upstream/2.0.6/src/scopeinfo.cc

@@ -1,649 +0,0 @@
-// 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
-//       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.
-
-#include <stdlib.h>
-
-#include "v8.h"
-
-#include "scopeinfo.h"
-#include "scopes.h"
-
-namespace v8 {
-namespace internal {
-
-
-static int CompareLocal(Variable* const* v, Variable* const* w) {
-  Slot* s = (*v)->slot();
-  Slot* t = (*w)->slot();
-  // We may have rewritten parameters (that are in the arguments object)
-  // and which may have a NULL slot... - find a better solution...
-  int x = (s != NULL ? s->index() : 0);
-  int y = (t != NULL ? t->index() : 0);
-  // Consider sorting them according to type as well?
-  return x - y;
-}
-
-
-template<class Allocator>
-ScopeInfo<Allocator>::ScopeInfo(Scope* scope)
-    : function_name_(Factory::empty_symbol()),
-      calls_eval_(scope->calls_eval()),
-      parameters_(scope->num_parameters()),
-      stack_slots_(scope->num_stack_slots()),
-      context_slots_(scope->num_heap_slots()),
-      context_modes_(scope->num_heap_slots()) {
-  // Add parameters.
-  for (int i = 0; i < scope->num_parameters(); i++) {
-    ASSERT(parameters_.length() == i);
-    parameters_.Add(scope->parameter(i)->name());
-  }
-
-  // Add stack locals and collect heap locals.
-  // We are assuming that the locals' slots are allocated in
-  // increasing order, so we can simply add them to the
-  // ScopeInfo lists. However, due to usage analysis, this is
-  // not true for context-allocated locals: Some of them
-  // may be parameters which are allocated before the
-  // non-parameter locals. When the non-parameter locals are
-  // sorted according to usage, the allocated slot indices may
-  // not be in increasing order with the variable list anymore.
-  // Thus, we first collect the context-allocated locals, and then
-  // sort them by context slot index before adding them to the
-  // ScopeInfo list.
-  List<Variable*, Allocator> locals(32);  // 32 is a wild guess
-  ASSERT(locals.is_empty());
-  scope->CollectUsedVariables(&locals);
-  locals.Sort(&CompareLocal);
-
-  List<Variable*, Allocator> heap_locals(locals.length());
-  for (int i = 0; i < locals.length(); i++) {
-    Variable* var = locals[i];
-    if (var->var_uses()->is_used()) {
-      Slot* slot = var->slot();
-      if (slot != NULL) {
-        switch (slot->type()) {
-          case Slot::PARAMETER:
-            // explicitly added to parameters_ above - ignore
-            break;
-
-          case Slot::LOCAL:
-            ASSERT(stack_slots_.length() == slot->index());
-            stack_slots_.Add(var->name());
-            break;
-
-          case Slot::CONTEXT:
-            heap_locals.Add(var);
-            break;
-
-          case Slot::LOOKUP:
-            // This is currently not used.
-            UNREACHABLE();
-            break;
-        }
-      }
-    }
-  }
-
-  // Add heap locals.
-  if (scope->num_heap_slots() > 0) {
-    // Add user-defined slots.
-    for (int i = 0; i < heap_locals.length(); i++) {
-      ASSERT(heap_locals[i]->slot()->index() - Context::MIN_CONTEXT_SLOTS ==
-             context_slots_.length());
-      ASSERT(heap_locals[i]->slot()->index() - Context::MIN_CONTEXT_SLOTS ==
-             context_modes_.length());
-      context_slots_.Add(heap_locals[i]->name());
-      context_modes_.Add(heap_locals[i]->mode());
-    }
-
-  } else {
-    ASSERT(heap_locals.length() == 0);
-  }
-
-  // Add the function context slot, if present.
-  // For now, this must happen at the very end because of the
-  // ordering of the scope info slots and the respective slot indices.
-  if (scope->is_function_scope()) {
-    Variable* var = scope->function();
-    if (var != NULL &&
-        var->var_uses()->is_used() &&
-        var->slot()->type() == Slot::CONTEXT) {
-      function_name_ = var->name();
-      // Note that we must not find the function name in the context slot
-      // list - instead it must be handled separately in the
-      // Contexts::Lookup() function. Thus record an empty symbol here so we
-      // get the correct number of context slots.
-      ASSERT(var->slot()->index() - Context::MIN_CONTEXT_SLOTS ==
-             context_slots_.length());
-      ASSERT(var->slot()->index() - Context::MIN_CONTEXT_SLOTS ==
-             context_modes_.length());
-      context_slots_.Add(Factory::empty_symbol());
-      context_modes_.Add(Variable::INTERNAL);
-    }
-  }
-}
-
-
-// Encoding format in the Code object:
-//
-// - function name
-//
-// - number of variables in the context object (smi) (= function context
-//   slot index + 1)
-// - list of pairs (name, Var mode) of context-allocated variables (starting
-//   with context slot 0)
-// - NULL (sentinel)
-//
-// - number of parameters (smi)
-// - list of parameter names (starting with parameter 0 first)
-// - NULL (sentinel)
-//
-// - number of variables on the stack (smi)
-// - list of names of stack-allocated variables (starting with stack slot 0)
-// - NULL (sentinel)
-
-// The ScopeInfo representation could be simplified and the ScopeInfo
-// re-implemented (with almost the same interface). Here is a
-// suggestion for the new format:
-//
-// - have a single list with all variable names (parameters, stack locals,
-//   context locals), followed by a list of non-Object* values containing
-//   the variables information (what kind, index, attributes)
-// - searching the linear list of names is fast and yields an index into the
-//   list if the variable name is found
-// - that list index is then used to find the variable information in the
-//   subsequent list
-// - the list entries don't have to be in any particular order, so all the
-//   current sorting business can go away
-// - the ScopeInfo lookup routines can be reduced to perhaps a single lookup
-//   which returns all information at once
-// - when gathering the information from a Scope, we only need to iterate
-//   through the local variables (parameters and context info is already
-//   present)
-
-
-static inline Object** ReadInt(Object** p, int* x) {
-  *x = (reinterpret_cast<Smi*>(*p++))->value();
-  return p;
-}
-
-
-static inline Object** ReadBool(Object** p, bool* x) {
-  *x = (reinterpret_cast<Smi*>(*p++))->value() != 0;
-  return p;
-}
-
-
-static inline Object** ReadSymbol(Object** p, Handle<String>* s) {
-  *s = Handle<String>(reinterpret_cast<String*>(*p++));
-  return p;
-}
-
-
-static inline Object** ReadSentinel(Object** p) {
-  ASSERT(*p == NULL);
-  return p + 1;
-}
-
-
-template <class Allocator>
-static Object** ReadList(Object** p, List<Handle<String>, Allocator >* list) {
-  ASSERT(list->is_empty());
-  int n;
-  p = ReadInt(p, &n);
-  while (n-- > 0) {
-    Handle<String> s;
-    p = ReadSymbol(p, &s);
-    list->Add(s);
-  }
-  return ReadSentinel(p);
-}
-
-
-template <class Allocator>
-static Object** ReadList(Object** p,
-                         List<Handle<String>, Allocator>* list,
-                         List<Variable::Mode, Allocator>* modes) {
-  ASSERT(list->is_empty());
-  int n;
-  p = ReadInt(p, &n);
-  while (n-- > 0) {
-    Handle<String> s;
-    int m;
-    p = ReadSymbol(p, &s);
-    p = ReadInt(p, &m);
-    list->Add(s);
-    modes->Add(static_cast<Variable::Mode>(m));
-  }
-  return ReadSentinel(p);
-}
-
-
-template<class Allocator>
-ScopeInfo<Allocator>::ScopeInfo(Code* code)
-  : function_name_(Factory::empty_symbol()),
-    parameters_(4),
-    stack_slots_(8),
-    context_slots_(8),
-    context_modes_(8) {
-  if (code == NULL || code->sinfo_size() == 0) return;
-
-  Object** p0 = &Memory::Object_at(code->sinfo_start());
-  Object** p = p0;
-  p = ReadSymbol(p, &function_name_);
-  p = ReadBool(p, &calls_eval_);
-  p = ReadList<Allocator>(p, &context_slots_, &context_modes_);
-  p = ReadList<Allocator>(p, &parameters_);
-  p = ReadList<Allocator>(p, &stack_slots_);
-  ASSERT((p - p0) * kPointerSize == code->sinfo_size());
-}
-
-
-static inline Object** WriteInt(Object** p, int x) {
-  *p++ = Smi::FromInt(x);
-  return p;
-}
-
-
-static inline Object** WriteBool(Object** p, bool b) {
-  *p++ = Smi::FromInt(b ? 1 : 0);
-  return p;
-}
-
-
-static inline Object** WriteSymbol(Object** p, Handle<String> s) {
-  *p++ = *s;
-  return p;
-}
-
-
-static inline Object** WriteSentinel(Object** p) {
-  *p++ = NULL;
-  return p;
-}
-
-
-template <class Allocator>
-static Object** WriteList(Object** p, List<Handle<String>, Allocator >* list) {
-  const int n = list->length();
-  p = WriteInt(p, n);
-  for (int i = 0; i < n; i++) {
-    p = WriteSymbol(p, list->at(i));
-  }
-  return WriteSentinel(p);
-}
-
-
-template <class Allocator>
-static Object** WriteList(Object** p,
-                          List<Handle<String>, Allocator>* list,
-                          List<Variable::Mode, Allocator>* modes) {
-  const int n = list->length();
-  p = WriteInt(p, n);
-  for (int i = 0; i < n; i++) {
-    p = WriteSymbol(p, list->at(i));
-    p = WriteInt(p, modes->at(i));
-  }
-  return WriteSentinel(p);
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::Serialize(Code* code) {
-  // function name, calls eval, length & sentinel for 3 tables:
-  const int extra_slots = 1 + 1 + 2 * 3;
-  int size = (extra_slots +
-              context_slots_.length() * 2 +
-              parameters_.length() +
-              stack_slots_.length()) * kPointerSize;
-
-  if (code != NULL) {
-    CHECK(code->sinfo_size() == size);
-    Object** p0 = &Memory::Object_at(code->sinfo_start());
-    Object** p = p0;
-    p = WriteSymbol(p, function_name_);
-    p = WriteBool(p, calls_eval_);
-    p = WriteList(p, &context_slots_, &context_modes_);
-    p = WriteList(p, &parameters_);
-    p = WriteList(p, &stack_slots_);
-    ASSERT((p - p0) * kPointerSize == size);
-  }
-
-  return size;
-}
-
-
-template<class Allocator>
-void ScopeInfo<Allocator>::IterateScopeInfo(Code* code, ObjectVisitor* v) {
-  Object** start = &Memory::Object_at(code->sinfo_start());
-  Object** end = &Memory::Object_at(code->sinfo_start() + code->sinfo_size());
-  v->VisitPointers(start, end);
-}
-
-
-static Object** ContextEntriesAddr(Code* code) {
-  ASSERT(code->sinfo_size() > 0);
-  // +2 for function name and calls eval:
-  return &Memory::Object_at(code->sinfo_start()) + 2;
-}
-
-
-static Object** ParameterEntriesAddr(Code* code) {
-  ASSERT(code->sinfo_size() > 0);
-  Object** p = ContextEntriesAddr(code);
-  int n;  // number of context slots;
-  p = ReadInt(p, &n);
-  return p + n*2 + 1;  // *2 for pairs, +1 for sentinel
-}
-
-
-static Object** StackSlotEntriesAddr(Code* code) {
-  ASSERT(code->sinfo_size() > 0);
-  Object** p = ParameterEntriesAddr(code);
-  int n;  // number of parameter slots;
-  p = ReadInt(p, &n);
-  return p + n + 1;  // +1 for sentinel
-}
-
-
-template<class Allocator>
-bool ScopeInfo<Allocator>::CallsEval(Code* code) {
-  if (code->sinfo_size() > 0) {
-    // +1 for function name:
-    Object** p = &Memory::Object_at(code->sinfo_start()) + 1;
-    bool calls_eval;
-    p = ReadBool(p, &calls_eval);
-    return calls_eval;
-  }
-  return true;
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::NumberOfStackSlots(Code* code) {
-  if (code->sinfo_size() > 0) {
-    Object** p = StackSlotEntriesAddr(code);
-    int n;  // number of stack slots;
-    ReadInt(p, &n);
-    return n;
-  }
-  return 0;
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::NumberOfContextSlots(Code* code) {
-  if (code->sinfo_size() > 0) {
-    Object** p = ContextEntriesAddr(code);
-    int n;  // number of context slots;
-    ReadInt(p, &n);
-    return n + Context::MIN_CONTEXT_SLOTS;
-  }
-  return 0;
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::StackSlotIndex(Code* code, String* name) {
-  ASSERT(name->IsSymbol());
-  if (code->sinfo_size() > 0) {
-    // Loop below depends on the NULL sentinel after the stack slot names.
-    ASSERT(NumberOfStackSlots(code) > 0 ||
-           *(StackSlotEntriesAddr(code) + 1) == NULL);
-    // slots start after length entry
-    Object** p0 = StackSlotEntriesAddr(code) + 1;
-    Object** p = p0;
-    while (*p != NULL) {
-      if (*p == name) return static_cast<int>(p - p0);
-      p++;
-    }
-  }
-  return -1;
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::ContextSlotIndex(Code* code,
-                                           String* name,
-                                           Variable::Mode* mode) {
-  ASSERT(name->IsSymbol());
-  int result = ContextSlotCache::Lookup(code, name, mode);
-  if (result != ContextSlotCache::kNotFound) return result;
-  if (code->sinfo_size() > 0) {
-    // Loop below depends on the NULL sentinel after the context slot names.
-    ASSERT(NumberOfContextSlots(code) >= Context::MIN_CONTEXT_SLOTS ||
-           *(ContextEntriesAddr(code) + 1) == NULL);
-
-    // slots start after length entry
-    Object** p0 = ContextEntriesAddr(code) + 1;
-    Object** p = p0;
-    // contexts may have no variable slots (in the presence of eval()).
-    while (*p != NULL) {
-      if (*p == name) {
-        ASSERT(((p - p0) & 1) == 0);
-        int v;
-        ReadInt(p + 1, &v);
-        Variable::Mode mode_value = static_cast<Variable::Mode>(v);
-        if (mode != NULL) *mode = mode_value;
-        result = static_cast<int>((p - p0) >> 1) + Context::MIN_CONTEXT_SLOTS;
-        ContextSlotCache::Update(code, name, mode_value, result);
-        return result;
-      }
-      p += 2;
-    }
-  }
-  ContextSlotCache::Update(code, name, Variable::INTERNAL, -1);
-  return -1;
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::ParameterIndex(Code* code, String* name) {
-  ASSERT(name->IsSymbol());
-  if (code->sinfo_size() > 0) {
-    // We must read parameters from the end since for
-    // multiply declared parameters the value of the
-    // last declaration of that parameter is used
-    // inside a function (and thus we need to look
-    // at the last index). Was bug# 1110337.
-    //
-    // Eventually, we should only register such parameters
-    // once, with corresponding index. This requires a new
-    // implementation of the ScopeInfo code. See also other
-    // comments in this file regarding this.
-    Object** p = ParameterEntriesAddr(code);
-    int n;  // number of parameters
-    Object** p0 = ReadInt(p, &n);
-    p = p0 + n;
-    while (p > p0) {
-      p--;
-      if (*p == name) return static_cast<int>(p - p0);
-    }
-  }
-  return -1;
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::FunctionContextSlotIndex(Code* code, String* name) {
-  ASSERT(name->IsSymbol());
-  if (code->sinfo_size() > 0) {
-    Object** p = &Memory::Object_at(code->sinfo_start());
-    if (*p == name) {
-      p = ContextEntriesAddr(code);
-      int n;  // number of context slots
-      ReadInt(p, &n);
-      ASSERT(n != 0);
-      // The function context slot is the last entry.
-      return n + Context::MIN_CONTEXT_SLOTS - 1;
-    }
-  }
-  return -1;
-}
-
-
-template<class Allocator>
-Handle<String> ScopeInfo<Allocator>::LocalName(int i) const {
-  // A local variable can be allocated either on the stack or in the context.
-  // For variables allocated in the context they are always preceded by the
-  // number Context::MIN_CONTEXT_SLOTS number of fixed allocated slots in the
-  // context.
-  if (i < number_of_stack_slots()) {
-    return stack_slot_name(i);
-  } else {
-    return context_slot_name(i - number_of_stack_slots() +
-                             Context::MIN_CONTEXT_SLOTS);
-  }
-}
-
-
-template<class Allocator>
-int ScopeInfo<Allocator>::NumberOfLocals() const {
-  int number_of_locals = number_of_stack_slots();
-  if (number_of_context_slots() > 0) {
-    ASSERT(number_of_context_slots() >= Context::MIN_CONTEXT_SLOTS);
-    number_of_locals += number_of_context_slots() - Context::MIN_CONTEXT_SLOTS;
-  }
-  return number_of_locals;
-}
-
-
-int ContextSlotCache::Hash(Code* code, String* name) {
-  // Uses only lower 32 bits if pointers are larger.
-  uintptr_t addr_hash =
-      static_cast<uint32_t>(reinterpret_cast<uintptr_t>(code)) >> 2;
-  return (addr_hash ^ name->Hash()) % kLength;
-}
-
-
-int ContextSlotCache::Lookup(Code* code,
-                             String* name,
-                             Variable::Mode* mode) {
-  int index = Hash(code, name);
-  Key& key = keys_[index];
-  if ((key.code == code) && key.name->Equals(name)) {
-    Value result(values_[index]);
-    if (mode != NULL) *mode = result.mode();
-    return result.index() + kNotFound;
-  }
-  return kNotFound;
-}
-
-
-void ContextSlotCache::Update(Code* code,
-                              String* name,
-                              Variable::Mode mode,
-                              int slot_index) {
-  String* symbol;
-  ASSERT(slot_index > kNotFound);
-  if (Heap::LookupSymbolIfExists(name, &symbol)) {
-    int index = Hash(code, symbol);
-    Key& key = keys_[index];
-    key.code = code;
-    key.name = symbol;
-    // Please note value only takes a uint as index.
-    values_[index] = Value(mode, slot_index - kNotFound).raw();
-#ifdef DEBUG
-    ValidateEntry(code, name, mode, slot_index);
-#endif
-  }
-}
-
-
-void ContextSlotCache::Clear() {
-  for (int index = 0; index < kLength; index++) keys_[index].code = NULL;
-}
-
-
-ContextSlotCache::Key ContextSlotCache::keys_[ContextSlotCache::kLength];
-
-
-uint32_t ContextSlotCache::values_[ContextSlotCache::kLength];
-
-
-#ifdef DEBUG
-
-void ContextSlotCache::ValidateEntry(Code* code,
-                                     String* name,
-                                     Variable::Mode mode,
-                                     int slot_index) {
-  String* symbol;
-  if (Heap::LookupSymbolIfExists(name, &symbol)) {
-    int index = Hash(code, name);
-    Key& key = keys_[index];
-    ASSERT(key.code == code);
-    ASSERT(key.name->Equals(name));
-    Value result(values_[index]);
-    ASSERT(result.mode() == mode);
-    ASSERT(result.index() + kNotFound == slot_index);
-  }
-}
-
-
-template <class Allocator>
-static void PrintList(const char* list_name,
-                      int nof_internal_slots,
-                      List<Handle<String>, Allocator>& list) {
-  if (list.length() > 0) {
-    PrintF("\n  // %s\n", list_name);
-    if (nof_internal_slots > 0) {
-      PrintF("  %2d - %2d [internal slots]\n", 0 , nof_internal_slots - 1);
-    }
-    for (int i = 0; i < list.length(); i++) {
-      PrintF("  %2d ", i + nof_internal_slots);
-      list[i]->ShortPrint();
-      PrintF("\n");
-    }
-  }
-}
-
-
-template<class Allocator>
-void ScopeInfo<Allocator>::Print() {
-  PrintF("ScopeInfo ");
-  if (function_name_->length() > 0)
-    function_name_->ShortPrint();
-  else
-    PrintF("/* no function name */");
-  PrintF("{");
-
-  PrintList<Allocator>("parameters", 0, parameters_);
-  PrintList<Allocator>("stack slots", 0, stack_slots_);
-  PrintList<Allocator>("context slots", Context::MIN_CONTEXT_SLOTS,
-                       context_slots_);
-
-  PrintF("}\n");
-}
-#endif  // DEBUG
-
-
-// Make sure the classes get instantiated by the template system.
-template class ScopeInfo<FreeStoreAllocationPolicy>;
-template class ScopeInfo<PreallocatedStorage>;
-template class ScopeInfo<ZoneListAllocationPolicy>;
-
-} }  // namespace v8::internal