[Isolates] Merge from bleeding_edge, revisions 5934-6100.

src/scanner-base.cc

 // Copyright 2010 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 23 matching lines @@
 some classes (NativeAllocationChecker) are moved into isolate.h 
 #include "../include/v8stdint.h"
 */
 #include "scanner-base.h"
 #include "char-predicates-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
-// UTF16Buffer
-
-UTF16Buffer::UTF16Buffer()
-    : pos_(0), end_(kNoEndPosition) { }
-
-// ----------------------------------------------------------------------------
 // LiteralCollector
 
 LiteralCollector::LiteralCollector()
     : buffer_(kInitialCapacity), recording_(false) { }
 
 
 LiteralCollector::~LiteralCollector() {}
 
 
 void LiteralCollector::AddCharSlow(uc32 c) {
@@ skipping 20 matching lines @@
     if (!kIsIdentifierPart.get(buffer->GetNext())) {
       return false;
     }
   }
   return true;
 }
 
 // ----------------------------------------------------------------------------
 // Scanner
 
-Scanner::Scanner()
-    : scanner_constants_(Isolate::Current()->scanner_constants()),
-      source_(NULL) {
+Scanner::Scanner(Isolate* isolate)
+    : scanner_constants_(isolate->scanner_constants()) {
 }
 
 
 uc32 Scanner::ScanHexEscape(uc32 c, int length) {
   ASSERT(length <= 4);  // prevent overflow
 
   uc32 digits[4];
   uc32 x = 0;
   for (int i = 0; i < length; i++) {
     digits[i] = c0_;
@@ skipping 30 matching lines @@
     x = nx;
     Advance();
   }
   return x;
 }
 
 
 // ----------------------------------------------------------------------------
 // JavaScriptScanner
 
-JavaScriptScanner::JavaScriptScanner(ScannerConstants* scanner_constants)
-    : scanner_constants_(scanner_constants),
-      has_line_terminator_before_next_(false) {}
+JavaScriptScanner::JavaScriptScanner(Isolate* isolate) : Scanner(isolate) {}
 
 
 Token::Value JavaScriptScanner::Next() {
   current_ = next_;
   has_line_terminator_before_next_ = false;
   Scan();
   return current_.token;
 }
 
 
@@ skipping 339 matching lines @@
     // Continue scanning for tokens as long as we're just skipping
     // whitespace.
   } while (token == Token::WHITESPACE);
 
   next_.location.end_pos = source_pos();
   next_.token = token;
 }
 
 
 void JavaScriptScanner::SeekForward(int pos) {
-  source_->SeekForward(pos - 1);
-  Advance();
-  // This function is only called to seek to the location
-  // of the end of a function (at the "}" token). It doesn't matter
-  // whether there was a line terminator in the part we skip.
-  has_line_terminator_before_next_ = false;
+  // After this call, we will have the token at the given position as
+  // the "next" token. The "current" token will be invalid.
+  if (pos == next_.location.beg_pos) return;
+  int current_pos = source_pos();
+  ASSERT_EQ(next_.location.end_pos, current_pos);
+  // Positions inside the lookahead token aren't supported.
+  ASSERT(pos >= current_pos);
+  if (pos != current_pos) {
+    source_->SeekForward(pos - source_->pos());
+    Advance();
+    // This function is only called to seek to the location
+    // of the end of a function (at the "}" token). It doesn't matter
+    // whether there was a line terminator in the part we skip.
+    has_line_terminator_before_next_ = false;
+  }
   Scan();
 }
 
 
 void JavaScriptScanner::ScanEscape() {
   uc32 c = c0_;
   Advance();
 
   // Skip escaped newlines.
   if (scanner_constants_->IsLineTerminator(c)) {
@@ skipping 392 matching lines @@
       if (MatchKeywordStart(input, "with", 1, Token::WITH)) return;
       break;
     case UNMATCHABLE:
       break;
   }
   // On fallthrough, it's a failure.
   state_ = UNMATCHABLE;
 }
 
 } }  // namespace v8::internal