Remove unnecessary buffer doubling and content copying.

src/scanner.cc

 // 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 31 matching lines @@
 unibrow::Predicate<unibrow::LineTerminator, 128> Scanner::kIsLineTerminator;
 unibrow::Predicate<unibrow::WhiteSpace, 128> Scanner::kIsWhiteSpace;
 
 
 StaticResource<Scanner::Utf8Decoder> Scanner::utf8_decoder_;
 
 
 // ----------------------------------------------------------------------------
 // UTF8Buffer
 
-UTF8Buffer::UTF8Buffer() {
-  static const int kInitialCapacity = 1 * KB;
-  data_ = NewArray<char>(kInitialCapacity);
-  limit_ = ComputeLimit(data_, kInitialCapacity);
-  Reset();
-  ASSERT(Capacity() == kInitialCapacity && pos() == 0);
-}
+UTF8Buffer::UTF8Buffer() : data_(NULL), limit_(NULL) { }
 
 
 UTF8Buffer::~UTF8Buffer() {
   DeleteArray(data_);
 }
 
 
 void UTF8Buffer::AddCharSlow(uc32 c) {
   static const int kCapacityGrowthLimit = 1 * MB;
   if (cursor_ > limit_) {
     int old_capacity = Capacity();
     int old_position = pos();
     int new_capacity =
-        Min(old_capacity * 2, old_capacity + kCapacityGrowthLimit);
+        Min(old_capacity * 3, old_capacity + kCapacityGrowthLimit);
     char* new_data = NewArray<char>(new_capacity);
     memcpy(new_data, data_, old_position);
     DeleteArray(data_);
     data_ = new_data;
     cursor_ = new_data + old_position;
     limit_ = ComputeLimit(new_data, new_capacity);
     ASSERT(Capacity() == new_capacity && pos() == old_position);
   }
   if (static_cast<unsigned>(c) <= unibrow::Utf8::kMaxOneByteChar) {
     *cursor_++ = c;  // Common case: 7-bit ASCII.
@@ skipping 256 matching lines @@
     two_byte_string_buffer_.Initialize(
         Handle<ExternalTwoByteString>::cast(source));
     source_ = &two_byte_string_buffer_;
   } else {
     char_stream_buffer_.Initialize(source, stream);
     source_ = &char_stream_buffer_;
   }
 
   position_ = position;
 
-  // Reset literals buffer
-  literals_.Reset();
-
   // Set c0_ (one character ahead)
   ASSERT(kCharacterLookaheadBufferSize == 1);
   Advance();
 
   // Skip initial whitespace allowing HTML comment ends just like
   // after a newline and scan first token.
   has_line_terminator_before_next_ = true;
   SkipWhiteSpace();
   Scan();
 }
 
 
 Handle<String> Scanner::SubString(int start, int end) {
   return source_->SubString(start - position_, end - position_);
 }
 
 
 Token::Value Scanner::Next() {
   // BUG 1215673: Find a thread safe way to set a stack limit in
   // pre-parse mode. Otherwise, we cannot safely pre-parse from other
   // threads.
   current_ = next_;
   // Check for stack-overflow before returning any tokens.
   StackLimitCheck check;
   if (check.HasOverflowed()) {
     stack_overflow_ = true;
     next_.token = Token::ILLEGAL;
+    next_.literal_buffer = NULL;
   } else {
     Scan();
   }
   return current_.token;
 }
 
 
 void Scanner::StartLiteral() {
-  next_.literal_pos = literals_.pos();
+  // Use the first buffer, unless it's currently in use by the current_ token.
+  // In most cases, we won't have two literals/identifiers in a row, so
+  // the second buffer won't be used very often and is unlikely to grow much.
+  UTF8Buffer* free_buffer =
+      (current_.literal_buffer != &literal_buffer_1_) ? &literal_buffer_1_
+                                                      : &literal_buffer_2_;
+  next_.literal_buffer = free_buffer;
+  free_buffer->Reset();
 }
 
 
 void Scanner::AddChar(uc32 c) {
-  literals_.AddChar(c);
+  next_.literal_buffer->AddChar(c);
 }
 
 
 void Scanner::TerminateLiteral() {
-  next_.literal_end = literals_.pos();
   AddChar(0);
 }
 
 
 void Scanner::AddCharAdvance() {
   AddChar(c0_);
   Advance();
 }
 
 
@@ skipping 681 matching lines @@
     }
     AddCharAdvance();
   }
   TerminateLiteral();
 
   next_.location.end_pos = source_pos() - 1;
   return true;
 }
 
 } }  // namespace v8::internal