Implement bookmarks for ExternalStreamingStream.

src/scanner-character-streams.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/scanner-character-streams.h"
 
 #include "include/v8.h"
 #include "src/handles.h"
@@ skipping 338 matching lines @@
 
       // A caveat: a data chunk might end with bytes from an incomplete UTF-8
       // character (the rest of the bytes will be in the next chunk).
       if (encoding_ == ScriptCompiler::StreamedSource::UTF8) {
         HandleUtf8SplitCharacters(&data_in_buffer);
         if (!data_ends && current_data_offset_ == current_data_length_) {
           // The data stream didn't end, but we used all the data in the
           // chunk. This will only happen when the chunk was really small. We
           // don't handle the case where a UTF-8 character is split over several
           // chunks; in that case V8 won't crash, but it will be a parse error.
-          delete[] current_data_;
-          current_data_ = NULL;
-          current_data_length_ = 0;
-          current_data_offset_ = 0;
+          FlushCurrent();
           continue;  // Request a new chunk.
         }
       }
 
       // Did the data stream end?
       if (data_ends) {
         DCHECK(utf8_split_char_buffer_length_ == 0);
         return data_in_buffer;
       }
     }
 
     // Fill the buffer from current_data_.
     size_t new_offset = 0;
     size_t new_chars_in_buffer =
         CopyCharsHelper(buffer_ + data_in_buffer, kBufferSize - data_in_buffer,
                         current_data_ + current_data_offset_, &new_offset,
                         current_data_length_ - current_data_offset_, encoding_);
     data_in_buffer += new_chars_in_buffer;
     current_data_offset_ += new_offset;
     DCHECK(data_in_buffer <= kBufferSize);
 
     // Did we use all the data in the data chunk?
     if (current_data_offset_ == current_data_length_) {
-      delete[] current_data_;
-      current_data_ = NULL;
-      current_data_length_ = 0;
-      current_data_offset_ = 0;
+      FlushCurrent();
     }
   }
   return data_in_buffer;
 }
 
+
+bool ExternalStreamingStream::SetBookmark() {
+  DCHECK(utf8_split_char_buffer_length_ == 0);  // We can't be within a char.
+
+  // Bookmarking for this stream is a bit more complex than expected, since
+  // the stream state is distributed over several places:
+  // - pos_ (inherited from Utf16CharacterStream)
+  // - buffer_cursor_ and buffer_end_ (also from Utf16CharacterStream)
+  // - buffer_ (from BufferedUtf16CharacterStream)
+  // - current_data_ (+ .._offset_ and .._length) (this class)
+  //
+  // The underlying source_stream_ instance likely could re-construct this
+  // local data for us, but with the given interfaces we have no way of
+  // accomplishing this. Thus, we'll have to save all data locally.
+  //
+  // What gets saved where:
+  // - pos_  =>  bookmark_
+  // - buffer_[buffer_cursor_ .. buffer_end_]  =>  bookmark_buffer_
+  // - current_data_[.._offset_ .. .._length_]  =>  bookmark_data_
+
+  bookmark_ = pos_;
+
+  int buffer_length = static_cast<int>(buffer_end_ - buffer_cursor_);
+  bookmark_buffer_.Dispose();
+  bookmark_buffer_ = Vector<uint16_t>::New(buffer_length);
+  std::copy(buffer_cursor_, buffer_end_, bookmark_buffer_.start());
+
+  int data_length =
+      static_cast<int>(current_data_length_ - current_data_offset_);
+  bookmark_data_.Dispose();
+  bookmark_data_ = Vector<uint8_t>::New(data_length);
+  std::copy(current_data_ + current_data_offset_,
+            current_data_ + current_data_length_, bookmark_data_.start());
+
+  return source_stream_->SetBookmark();
+}
+
+
+void ExternalStreamingStream::ResetToBookmark() {
+  source_stream_->ResetToBookmark();
+  FlushCurrent();
+
+  pos_ = bookmark_;
+
+  // current_data_ can point to bookmark_data_'s buffer.
+  current_data_ = bookmark_data_.start();
+  current_data_offset_ = 0;
+  current_data_length_ = bookmark_data_.length();
+
+  // bookmark_buffer_ needs to be copied to buffer_.
+  std::copy(bookmark_buffer_.begin(), bookmark_buffer_.end(), buffer_);
+  buffer_cursor_ = buffer_;
+  buffer_end_ = buffer_ + bookmark_buffer_.length();
+}
+
+
+void ExternalStreamingStream::FlushCurrent() {
+  delete[] current_data_;
+  current_data_ = NULL;
+  current_data_length_ = 0;
+  current_data_offset_ = 0;
+}
+
+
 void ExternalStreamingStream::HandleUtf8SplitCharacters(
     size_t* data_in_buffer) {
   // Note the following property of UTF-8 which makes this function possible:
   // Given any byte, we can always read its local environment (in both
   // directions) to find out the (possibly multi-byte) character it belongs
   // to. Single byte characters are of the form 0b0XXXXXXX. The first byte of a
   // multi-byte character is of the form 0b110XXXXX, 0b1110XXXX or
   // 0b11110XXX. The continuation bytes are of the form 0b10XXXXXX.
 
   // First check if we have leftover data from the last chunk.
@@ skipping 75 matching lines @@
   return true;
 }
 
 
 void ExternalTwoByteStringUtf16CharacterStream::ResetToBookmark() {
   DCHECK(bookmark_ != kNoBookmark);
   pos_ = bookmark_;
   buffer_cursor_ = raw_data_ + bookmark_;
 }
 } }  // namespace v8::internal