Ensure that scanner state is correctly reset when an error is encountered.

src/utils.h

 // 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 542 matching lines @@
         position++;
       }
     }
     for (int i = 0; i < index_; i++) {
       new_store[position] = current_chunk_[i];
       position++;
     }
     return Vector<T>(new_store, total_length);
   }
 
+  // Resets the collector to be empty.
+  virtual void Reset() {
+    for (int i = chunks_.length() - 1; i >= 0; i--) {
+      chunks_.at(i).Dispose();
+    }
+    chunks_.Rewind(0);
+    index_ = 0;
+  }
+
  protected:
   static const int kMinCapacity = 16;
   List<Vector<T> > chunks_;
   T* current_chunk_;
   int growth_factor_;
   int max_growth_;
   int current_capacity_;
   int index_;
 
   // Creates a new current chunk, and stores the old chunk in the chunks_ list.
@@ skipping 52 matching lines @@
   }
 
   Vector<T> EndSequence() {
     ASSERT(sequence_start_ != kNoSequence);
     int sequence_start = sequence_start_;
     sequence_start_ = kNoSequence;
     return Vector<T>(this->current_chunk_ + sequence_start,
                      this->index_ - sequence_start);
   }
 
+  // Drops the currently added sequence, and all collected elements in it.
+  void DropSequence() {
+    ASSERT(sequence_start_ != kNoSequence);
+    this->index_ = sequence_start_;
+    sequence_start_ = kNoSequence;
+  }
+
+  virtual void Reset() {
+    sequence_start_ = kNoSequence;
+    this->Collector<T>::Reset();
+  }
+
  private:
   static const int kNoSequence = -1;
   int sequence_start_;
 
   // Move the currently active sequence to the new chunk.
   virtual int PrepareGrow(Vector<T> new_chunk) {
     if (sequence_start_ != kNoSequence) {
       int sequence_length = this->index_ - sequence_start_;
       // The new chunk is always larger than the current chunk, so there
       // is room for the copy.
@@ skipping 274 matching lines @@
 }
 
 template <class Dest, class Source>
 inline Dest BitCast(Source* source) {
   return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_