Experimental parser: more cleanup after rebase

src/lexer/lexer.cc

 // Copyright 2013 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 95 matching lines @@
   reinterpret_cast<i::Isolate*>(isolate)->
       lexer_gc_handler()->UpdateLexersAfterGC();
 }
 
 
 void LexerGCHandler::AddLexer(LexerBase* lexer) {
   if (lexers_.empty()) {
     isolate_->heap()->AddGCEpilogueCallback(
         &i::UpdateLexersAfterGC, kGCTypeAll, true);
   }
-  lexers_.insert(lexer);
+  std::pair<LexerSet::iterator, bool> res = lexers_.insert(lexer);
+  USE(res);
+  ASSERT(res.second);
 }
 
 
 void LexerGCHandler::RemoveLexer(LexerBase* lexer) {
-  lexers_.erase(lexer);
+  LexerSet::iterator it = lexers_.find(lexer);
+  ASSERT(it != lexers_.end());
+  lexers_.erase(it);
   if (lexers_.empty()) {
     isolate_->heap()->RemoveGCEpilogueCallback(&i::UpdateLexersAfterGC);
   }
 }
 
 
 void LexerGCHandler::UpdateLexersAfterGC() {
   typedef std::set<LexerBase*>::const_iterator It;
   for (It it = lexers_.begin(); it != lexers_.end(); ++it) {
     (*it)->UpdateBufferBasedOnHandle();
   }
 }
 
 
+LexerBase::LexerBase(UnicodeCache* unicode_cache)
+    : unicode_cache_(unicode_cache),
+      has_line_terminator_before_next_(true),
+      has_multiline_comment_before_next_(false),
+      current_literal_(&literals_[0]),
+      next_literal_(&literals_[1]),
+      harmony_numeric_literals_(false),
+      harmony_modules_(false),
+      harmony_scoping_(false) {
+}
+
+
 LexerBase::~LexerBase() {}
 
 
 // Returns the next token and advances input.
 Token::Value LexerBase::Next() {
   has_line_terminator_before_next_ = false;
   has_multiline_comment_before_next_ = false;
   current_ = next_;
   std::swap(current_literal_, next_literal_);
   Scan();
@@ skipping 35 matching lines @@
       start_(NULL),
       cursor_(NULL),
       last_octal_end_(NULL) {
   UpdateBufferBasedOnHandle();
   current_.beg_pos = current_.end_pos = next_.beg_pos = next_.end_pos = 0;
   isolate_->lexer_gc_handler()->AddLexer(this);
   // TODO(dcarney): move this to UpdateBufferBasedOnHandle
   cursor_ = buffer_ + start_position;
   buffer_end_ = buffer_ + end_position;
   start_ = cursor_;
-  has_line_terminator_before_next_ = false;
-  has_multiline_comment_before_next_ = false;
 }
 
 
 template<typename Char>
 Lexer<Char>::~Lexer() {
   if (!source_handle_.is_null()) {
     isolate_->lexer_gc_handler()->RemoveLexer(this);
   }
 }
 
 
 template<typename Char>
 void Lexer<Char>::SeekForward(int pos) {
   cursor_ = buffer_ + pos;
   start_ = cursor_;
   has_line_terminator_before_next_ = false;
   has_multiline_comment_before_next_ = false;
   Scan();  // Fills in next_.
 }
 
 
 template<typename Char>
-void Lexer<Char>::SetEnd(int pos) {
-  buffer_end_ = buffer_ + pos;
-}
-
-
-template<typename Char>
 bool Lexer<Char>::ScanRegExpPattern(bool seen_equal) {
   // Scan: ('/' | '/=') RegularExpressionBody '/' RegularExpressionFlags
   bool in_character_class = false;
 
   // Previous token is either '/' or '/=', in the second case, the
   // pattern starts at =.
   next_.beg_pos = next_.end_pos = (cursor_ - buffer_) - (seen_equal ? 1 : 0);
 
   // Scan regular expression body: According to ECMA-262, 3rd, 7.8.5,
   // the scanner should pass uninterpreted bodies to the RegExp
@@ skipping 280 matching lines @@
 bool Lexer<uint8_t>::FillLiteral(
     const TokenDesc& token, LiteralDesc* literal) {
   literal->beg_pos = token.beg_pos;
   const uint8_t* start = buffer_ + token.beg_pos;
   const uint8_t* end = buffer_ + token.end_pos;
   if (token.token == Token::STRING) {
     ++start;
     --end;
   }
   if (IsSubstringOfSource(token)) {
-    literal->is_ascii = true;
+    literal->is_one_byte = true;
     literal->is_in_buffer = false;
     literal->offset = start - buffer_;
     literal->length = end - start;
-    literal->ascii_string = Vector<const char>(
-        reinterpret_cast<const char*>(start), literal->length);
+    literal->one_byte_string = Vector<const uint8_t>(start, literal->length);
     return true;
   }
   return CopyToLiteralBuffer(start, end, token, literal);
 }
 
 
 template<>
 bool Lexer<uint16_t>::FillLiteral(
     const TokenDesc& token, LiteralDesc* literal) {
   literal->beg_pos = token.beg_pos;
   const uint16_t* start = buffer_ + token.beg_pos;
   const uint16_t* end = buffer_ + token.end_pos;
   if (token.token == Token::STRING) {
     ++start;
     --end;
   }
   if (IsSubstringOfSource(token)) {
-    literal->is_ascii = false;
+    literal->is_one_byte = false;
     literal->is_in_buffer = false;
     literal->offset = start - buffer_;
     literal->length = end - start;
-    literal->utf16_string = Vector<const uint16_t>(start, literal->length);
+    literal->two_byte_string = Vector<const uint16_t>(start, literal->length);
     return true;
   }
   return CopyToLiteralBuffer(start, end, token, literal);
 }
 
 
 template<>
 bool Lexer<int8_t>::FillLiteral(
     const TokenDesc& token, LiteralDesc* literal) {
   // FIXME: implement.
@@ skipping 22 matching lines @@
         cursor = ScanEscape(cursor, end, &literal->buffer);
         ASSERT(cursor != NULL);
         if (cursor == NULL) return false;
       }
     }
   } else {
     for (const Char* cursor = start; cursor != end;) {
         literal->buffer.AddChar(*cursor++);
     }
   }
-  literal->is_ascii = literal->buffer.is_ascii();
+  literal->is_one_byte = literal->buffer.is_ascii();
   literal->is_in_buffer = true;
   literal->length = literal->buffer.length();
-  if (literal->is_ascii) {
-    literal->ascii_string = literal->buffer.ascii_literal();
+  if (literal->is_one_byte) {
+    literal->one_byte_string =
+        Vector<const uint8_t>::cast(literal->buffer.ascii_literal());
   } else {
-    literal->utf16_string = literal->buffer.utf16_literal();
+    literal->two_byte_string = literal->buffer.utf16_literal();
   }
   return true;
 }
 
 
 template<class Char>
 Handle<String> Lexer<Char>::InternalizeLiteral(
     LiteralDesc* literal) {
   Factory* factory = isolate_->factory();
   if (literal->is_in_buffer) {
-    return literal->is_ascii
+    return literal->is_one_byte
         ? factory->InternalizeOneByteString(
-            Vector<const uint8_t>::cast(literal->ascii_string))
-        : factory->InternalizeTwoByteString(literal->utf16_string);
+            Vector<const uint8_t>::cast(literal->one_byte_string))
+        : factory->InternalizeTwoByteString(literal->two_byte_string);
   }
   if (sizeof(Char) == 1) {
     SubStringKey<uint8_t> key(
         source_handle_, literal->offset, literal->length);
     return factory->InternalizeStringWithKey(&key);
   } else {
     SubStringKey<uint16_t> key(
         source_handle_, literal->offset, literal->length);
     return factory->InternalizeStringWithKey(&key);
   }
 }
 
 
 template<>
 Handle<String> Lexer<uint8_t>::AllocateLiteral(
     LiteralDesc* literal, PretenureFlag pretenured) {
   Factory* factory = isolate_->factory();
   if (literal->is_in_buffer) {
-    return literal->is_ascii
-        ? factory->NewStringFromAscii(literal->ascii_string, pretenured)
-        : factory->NewStringFromTwoByte(literal->utf16_string, pretenured);
+    return literal->is_one_byte
+        ? factory->NewStringFromOneByte(literal->one_byte_string, pretenured)
+        : factory->NewStringFromTwoByte(literal->two_byte_string, pretenured);
   }
   int from = literal->offset;
   int length = literal->length;
   // Save the offset and the length before allocating the string as it may
   // cause a GC, invalidate the literal, and move the source.
   Handle<String> result = factory->NewRawOneByteString(length, pretenured);
   uint8_t* chars = SeqOneByteString::cast(*result)->GetChars();
   String::WriteToFlat(*source_handle_, chars, from, from + length);
   return result;
 }
 
 
 template<>
 Handle<String> Lexer<uint16_t>::AllocateLiteral(
     LiteralDesc* literal, PretenureFlag pretenured) {
   Factory* factory = isolate_->factory();
   if (literal->is_in_buffer) {
-    return literal->is_ascii
-        ? factory->NewStringFromAscii(literal->ascii_string, pretenured)
-        : factory->NewStringFromTwoByte(literal->utf16_string, pretenured);
+    return literal->is_one_byte
+        ? factory->NewStringFromOneByte(literal->one_byte_string, pretenured)
+        : factory->NewStringFromTwoByte(literal->two_byte_string, pretenured);
   }
   // Save the offset and the length before allocating the string as it may
   // cause a GC, invalidate the literal, and move the source.
   int from = literal->offset;
   int length = literal->length;
   Handle<String> result = factory->NewRawTwoByteString(length, pretenured);
   uint16_t* chars = SeqTwoByteString::cast(*result)->GetChars();
   String::WriteToFlat(*source_handle_, chars, from, from + length);
   return result;
 }
 
 
 template<>
 Handle<String> Lexer<int8_t>::AllocateLiteral(
     LiteralDesc* literal, PretenureFlag pretenured) {
   // FIXME: implement
   UNREACHABLE();
   return Handle<String>();
 }
 
 template class Lexer<uint8_t>;
 template class Lexer<uint16_t>;
 template class Lexer<int8_t>;
 
 } }  // v8::internal