Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/parsing/scanner-character-streams.h b/src/parsing/scanner-character-streams.h
new file mode 100644
index 0000000..603db93
--- /dev/null
+++ b/src/parsing/scanner-character-streams.h
@@ -0,0 +1,189 @@
+// 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.
+
+#ifndef V8_PARSING_SCANNER_CHARACTER_STREAMS_H_
+#define V8_PARSING_SCANNER_CHARACTER_STREAMS_H_
+
+#include "src/handles.h"
+#include "src/parsing/scanner.h"
+#include "src/vector.h"
+
+namespace v8 {
+namespace internal {
+
+// Forward declarations.
+class ExternalTwoByteString;
+
+// A buffered character stream based on a random access character
+// source (ReadBlock can be called with pos_ pointing to any position,
+// even positions before the current).
+class BufferedUtf16CharacterStream: public Utf16CharacterStream {
+ public:
+ BufferedUtf16CharacterStream();
+ ~BufferedUtf16CharacterStream() override;
+
+ void PushBack(uc32 character) override;
+
+ protected:
+ static const size_t kBufferSize = 512;
+ static const size_t kPushBackStepSize = 16;
+
+ size_t SlowSeekForward(size_t delta) override;
+ bool ReadBlock() override;
+ virtual void SlowPushBack(uc16 character);
+
+ virtual size_t BufferSeekForward(size_t delta) = 0;
+ virtual size_t FillBuffer(size_t position) = 0;
+
+ const uc16* pushback_limit_;
+ uc16 buffer_[kBufferSize];
+};
+
+
+// Generic string stream.
+class GenericStringUtf16CharacterStream: public BufferedUtf16CharacterStream {
+ public:
+ GenericStringUtf16CharacterStream(Handle<String> data, size_t start_position,
+ size_t end_position);
+ ~GenericStringUtf16CharacterStream() override;
+
+ bool SetBookmark() override;
+ void ResetToBookmark() override;
+
+ protected:
+ static const size_t kNoBookmark = -1;
+
+ size_t BufferSeekForward(size_t delta) override;
+ size_t FillBuffer(size_t position) override;
+
+ Handle<String> string_;
+ size_t length_;
+ size_t bookmark_;
+};
+
+
+// Utf16 stream based on a literal UTF-8 string.
+class Utf8ToUtf16CharacterStream: public BufferedUtf16CharacterStream {
+ public:
+ Utf8ToUtf16CharacterStream(const byte* data, size_t length);
+ ~Utf8ToUtf16CharacterStream() override;
+
+ static size_t CopyChars(uint16_t* dest, size_t length, const byte* src,
+ size_t* src_pos, size_t src_length);
+
+ protected:
+ size_t BufferSeekForward(size_t delta) override;
+ size_t FillBuffer(size_t char_position) override;
+ void SetRawPosition(size_t char_position);
+
+ const byte* raw_data_;
+ size_t raw_data_length_; // Measured in bytes, not characters.
+ size_t raw_data_pos_;
+ // The character position of the character at raw_data[raw_data_pos_].
+ // Not necessarily the same as pos_.
+ size_t raw_character_position_;
+};
+
+
+// ExternalStreamingStream is a wrapper around an ExternalSourceStream (see
+// include/v8.h) subclass implemented by the embedder.
+class ExternalStreamingStream : public BufferedUtf16CharacterStream {
+ public:
+ ExternalStreamingStream(ScriptCompiler::ExternalSourceStream* source_stream,
+ v8::ScriptCompiler::StreamedSource::Encoding encoding)
+ : source_stream_(source_stream),
+ encoding_(encoding),
+ current_data_(NULL),
+ current_data_offset_(0),
+ current_data_length_(0),
+ utf8_split_char_buffer_length_(0),
+ bookmark_(0),
+ bookmark_data_is_from_current_data_(false),
+ bookmark_data_offset_(0),
+ bookmark_utf8_split_char_buffer_length_(0) {}
+
+ ~ExternalStreamingStream() override {
+ delete[] current_data_;
+ bookmark_buffer_.Dispose();
+ bookmark_data_.Dispose();
+ }
+
+ size_t BufferSeekForward(size_t delta) override {
+ // We never need to seek forward when streaming scripts. We only seek
+ // forward when we want to parse a function whose location we already know,
+ // and when streaming, we don't know the locations of anything we haven't
+ // seen yet.
+ UNREACHABLE();
+ return 0;
+ }
+
+ size_t FillBuffer(size_t position) override;
+
+ bool SetBookmark() override;
+ void ResetToBookmark() override;
+
+ private:
+ void HandleUtf8SplitCharacters(size_t* data_in_buffer);
+ void FlushCurrent();
+
+ ScriptCompiler::ExternalSourceStream* source_stream_;
+ v8::ScriptCompiler::StreamedSource::Encoding encoding_;
+ const uint8_t* current_data_;
+ size_t current_data_offset_;
+ size_t current_data_length_;
+ // For converting UTF-8 characters which are split across two data chunks.
+ uint8_t utf8_split_char_buffer_[4];
+ size_t utf8_split_char_buffer_length_;
+
+ // Bookmark support. See comments in ExternalStreamingStream::SetBookmark
+ // for additional details.
+ size_t bookmark_;
+ Vector<uint16_t> bookmark_buffer_;
+ Vector<uint8_t> bookmark_data_;
+ bool bookmark_data_is_from_current_data_;
+ size_t bookmark_data_offset_;
+ uint8_t bookmark_utf8_split_char_buffer_[4];
+ size_t bookmark_utf8_split_char_buffer_length_;
+};
+
+
+// UTF16 buffer to read characters from an external string.
+class ExternalTwoByteStringUtf16CharacterStream: public Utf16CharacterStream {
+ public:
+ ExternalTwoByteStringUtf16CharacterStream(Handle<ExternalTwoByteString> data,
+ int start_position,
+ int end_position);
+ ~ExternalTwoByteStringUtf16CharacterStream() override;
+
+ void PushBack(uc32 character) override {
+ DCHECK(buffer_cursor_ > raw_data_);
+ buffer_cursor_--;
+ pos_--;
+ }
+
+ bool SetBookmark() override;
+ void ResetToBookmark() override;
+
+ protected:
+ size_t SlowSeekForward(size_t delta) override {
+ // Fast case always handles seeking.
+ return 0;
+ }
+ bool ReadBlock() override {
+ // Entire string is read at start.
+ return false;
+ }
+ Handle<ExternalTwoByteString> source_;
+ const uc16* raw_data_; // Pointer to the actual array of characters.
+
+ private:
+ static const size_t kNoBookmark = -1;
+
+ size_t bookmark_;
+};
+
+} // namespace internal
+} // namespace v8
+
+#endif // V8_PARSING_SCANNER_CHARACTER_STREAMS_H_