1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #ifdef _MSC_VER
29 #define V8_WIN32_LEAN_AND_MEAN
30 #include "win32-headers.h"
31 #endif
32
33 #include "../include/v8-preparser.h"
34
35 #include "globals.h"
36 #include "checks.h"
37 #include "allocation.h"
38 #include "utils.h"
39 #include "list.h"
40 #include "hashmap.h"
41 #include "preparse-data-format.h"
42 #include "preparse-data.h"
43 #include "preparser.h"
44
45 namespace v8 {
46 namespace internal {
47
48 // UTF16Buffer based on a v8::UnicodeInputStream.
49 class InputStreamUtf16Buffer : public Utf16CharacterStream {
50 public:
51 /* The InputStreamUtf16Buffer maintains an internal buffer
52 * that is filled in chunks from the Utf16CharacterStream.
53 * It also maintains unlimited pushback capability, but optimized
54 * for small pushbacks.
55 * The pushback_buffer_ pointer points to the limit of pushbacks
56 * in the current buffer. There is room for a few pushback'ed chars before
57 * the buffer containing the most recently read chunk. If this is overflowed,
58 * an external buffer is allocated/reused to hold further pushbacks, and
59 * pushback_buffer_ and buffer_cursor_/buffer_end_ now points to the
60 * new buffer. When this buffer is read to the end again, the cursor is
61 * switched back to the internal buffer
62 */
InputStreamUtf16Buffer(v8::UnicodeInputStream * stream)63 explicit InputStreamUtf16Buffer(v8::UnicodeInputStream* stream)
64 : Utf16CharacterStream(),
65 stream_(stream),
66 pushback_buffer_(buffer_),
67 pushback_buffer_end_cache_(NULL),
68 pushback_buffer_backing_(NULL),
69 pushback_buffer_backing_size_(0) {
70 buffer_cursor_ = buffer_end_ = buffer_ + kPushBackSize;
71 }
72
~InputStreamUtf16Buffer()73 virtual ~InputStreamUtf16Buffer() {
74 if (pushback_buffer_backing_ != NULL) {
75 DeleteArray(pushback_buffer_backing_);
76 }
77 }
78
PushBack(uc32 ch)79 virtual void PushBack(uc32 ch) {
80 ASSERT(pos_ > 0);
81 if (ch == kEndOfInput) {
82 pos_--;
83 return;
84 }
85 if (buffer_cursor_ <= pushback_buffer_) {
86 // No more room in the current buffer to do pushbacks.
87 if (pushback_buffer_end_cache_ == NULL) {
88 // We have overflowed the pushback space at the beginning of buffer_.
89 // Switch to using a separate allocated pushback buffer.
90 if (pushback_buffer_backing_ == NULL) {
91 // Allocate a buffer the first time we need it.
92 pushback_buffer_backing_ = NewArray<uc16>(kPushBackSize);
93 pushback_buffer_backing_size_ = kPushBackSize;
94 }
95 pushback_buffer_ = pushback_buffer_backing_;
96 pushback_buffer_end_cache_ = buffer_end_;
97 buffer_end_ = pushback_buffer_backing_ + pushback_buffer_backing_size_;
98 buffer_cursor_ = buffer_end_ - 1;
99 } else {
100 // Hit the bottom of the allocated pushback buffer.
101 // Double the buffer and continue.
102 uc16* new_buffer = NewArray<uc16>(pushback_buffer_backing_size_ * 2);
103 memcpy(new_buffer + pushback_buffer_backing_size_,
104 pushback_buffer_backing_,
105 pushback_buffer_backing_size_);
106 DeleteArray(pushback_buffer_backing_);
107 buffer_cursor_ = new_buffer + pushback_buffer_backing_size_;
108 pushback_buffer_backing_ = pushback_buffer_ = new_buffer;
109 buffer_end_ = pushback_buffer_backing_ + pushback_buffer_backing_size_;
110 }
111 }
112 pushback_buffer_[buffer_cursor_ - pushback_buffer_- 1] =
113 static_cast<uc16>(ch);
114 pos_--;
115 }
116
117 protected:
ReadBlock()118 virtual bool ReadBlock() {
119 if (pushback_buffer_end_cache_ != NULL) {
120 buffer_cursor_ = buffer_;
121 buffer_end_ = pushback_buffer_end_cache_;
122 pushback_buffer_end_cache_ = NULL;
123 return buffer_end_ > buffer_cursor_;
124 }
125 // Copy the top of the buffer into the pushback area.
126 int32_t value;
127 uc16* buffer_start = buffer_ + kPushBackSize;
128 buffer_cursor_ = buffer_end_ = buffer_start;
129 while ((value = stream_->Next()) >= 0) {
130 if (value >
131 static_cast<int32_t>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
132 buffer_start[buffer_end_++ - buffer_start] =
133 unibrow::Utf16::LeadSurrogate(value);
134 buffer_start[buffer_end_++ - buffer_start] =
135 unibrow::Utf16::TrailSurrogate(value);
136 } else {
137 // buffer_end_ is a const pointer, but buffer_ is writable.
138 buffer_start[buffer_end_++ - buffer_start] = static_cast<uc16>(value);
139 }
140 // Stop one before the end of the buffer in case we get a surrogate pair.
141 if (buffer_end_ <= buffer_ + 1 + kPushBackSize + kBufferSize) break;
142 }
143 return buffer_end_ > buffer_start;
144 }
145
SlowSeekForward(unsigned pos)146 virtual unsigned SlowSeekForward(unsigned pos) {
147 // Seeking in the input is not used by preparsing.
148 // It's only used by the real parser based on preparser data.
149 UNIMPLEMENTED();
150 return 0;
151 }
152
153 private:
154 static const unsigned kBufferSize = 512;
155 static const unsigned kPushBackSize = 16;
156 v8::UnicodeInputStream* const stream_;
157 // Buffer holding first kPushBackSize characters of pushback buffer,
158 // then kBufferSize chars of read-ahead.
159 // The pushback buffer is only used if pushing back characters past
160 // the start of a block.
161 uc16 buffer_[kPushBackSize + kBufferSize];
162 // Limit of pushbacks before new allocation is necessary.
163 uc16* pushback_buffer_;
164 // Only if that pushback buffer at the start of buffer_ isn't sufficient
165 // is the following used.
166 const uc16* pushback_buffer_end_cache_;
167 uc16* pushback_buffer_backing_;
168 unsigned pushback_buffer_backing_size_;
169 };
170
171
172 // Functions declared by allocation.h and implemented in both api.cc (for v8)
173 // or here (for a stand-alone preparser).
174
FatalProcessOutOfMemory(const char * reason)175 void FatalProcessOutOfMemory(const char* reason) {
176 V8_Fatal(__FILE__, __LINE__, reason);
177 }
178
EnableSlowAsserts()179 bool EnableSlowAsserts() { return true; }
180
181 } // namespace internal.
182
183
~UnicodeInputStream()184 UnicodeInputStream::~UnicodeInputStream() { }
185
186
Preparse(UnicodeInputStream * input,size_t max_stack)187 PreParserData Preparse(UnicodeInputStream* input, size_t max_stack) {
188 internal::InputStreamUtf16Buffer buffer(input);
189 uintptr_t stack_limit = reinterpret_cast<uintptr_t>(&buffer) - max_stack;
190 internal::UnicodeCache unicode_cache;
191 internal::Scanner scanner(&unicode_cache);
192 scanner.Initialize(&buffer);
193 internal::CompleteParserRecorder recorder;
194 preparser::PreParser::PreParseResult result =
195 preparser::PreParser::PreParseProgram(&scanner,
196 &recorder,
197 internal::kAllowLazy,
198 stack_limit);
199 if (result == preparser::PreParser::kPreParseStackOverflow) {
200 return PreParserData::StackOverflow();
201 }
202 internal::Vector<unsigned> pre_data = recorder.ExtractData();
203 size_t size = pre_data.length() * sizeof(pre_data[0]);
204 unsigned char* data = reinterpret_cast<unsigned char*>(pre_data.start());
205 return PreParserData(size, data);
206 }
207
208 } // namespace v8.
209
210
211 // Used by ASSERT macros and other immediate exits.
V8_Fatal(const char * file,int line,const char * format,...)212 extern "C" void V8_Fatal(const char* file, int line, const char* format, ...) {
213 exit(EXIT_FAILURE);
214 }
215