Experimental parser: continue unifying the API with Scanner.

src/lexer/lexer-shell.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 138 matching lines @@
     scanner_->Initialize(stream_);
   }
 
   ~BaselineScanner() {
     delete scanner_;
     delete stream_;
     delete unicode_cache_;
     delete[] source_;
   }
 
-  Token::Value Next(int* beg_pos, int* end_pos) {
-    Token::Value res = scanner_->Next();
-    *beg_pos = scanner_->location().beg_pos;
-    *end_pos = scanner_->location().end_pos;
-    return res;
-  }
+  Scanner* scanner_;
 
  private:
   UnicodeCache* unicode_cache_;
-  Scanner* scanner_;
   const byte* source_;
   BufferedUtf16CharacterStream* stream_;
 };
 
 
 struct TokenWithLocation {
   Token::Value value;
   size_t beg;
   size_t end;
   TokenWithLocation() : value(Token::ILLEGAL), beg(0), end(0) { }
@@ skipping 19 matching lines @@
                              bool dump_tokens,
                              std::vector<TokenWithLocation>* tokens,
                              int repeat,
                              HarmonySettings harmony_settings) {
   ElapsedTimer timer;
   BaselineScanner scanner(
       fname, isolate, encoding, &timer, repeat, harmony_settings);
   Token::Value token;
   int beg, end;
   do {
-    token = scanner.Next(&beg, &end);
+    token = scanner.scanner_->Next();
+    beg = scanner.scanner_->location().beg_pos;
+    end = scanner.scanner_->location().end_pos;
     if (dump_tokens) {
       tokens->push_back(TokenWithLocation(token, beg, end));
     }
   } while (token != Token::EOS);
   return timer.Elapsed();
 }
 
 
 template<typename YYCTYPE>
 TimeDelta RunExperimentalScanner(const char* fname,
                                  Isolate* isolate,
                                  Encoding encoding,
                                  bool dump_tokens,
                                  std::vector<TokenWithLocation>* tokens,
                                  int repeat,
                                  HarmonySettings harmony_settings) {
   ElapsedTimer timer;
   byte* buffer_end = 0;
   YYCTYPE* buffer = reinterpret_cast<YYCTYPE*>(
       ReadFile(fname, &buffer_end, repeat, encoding == UTF8TO16));
 
+  timer.Start();
   ExperimentalScanner<YYCTYPE> scanner(
       buffer, reinterpret_cast<YYCTYPE*>(buffer_end), isolate);
   scanner.SetHarmonyNumericLiterals(harmony_settings.numeric_literals);
   scanner.SetHarmonyModules(harmony_settings.modules);
   scanner.SetHarmonyScoping(harmony_settings.scoping);
 
-  timer.Start();
   Token::Value token;
   int beg, end;
   do {
-    token = scanner.Next(&beg, &end);
+    token = scanner.Next();
+    beg = scanner.location().beg_pos;
+    end = scanner.location().end_pos;
     if (dump_tokens) {
       tokens->push_back(TokenWithLocation(token, beg, end));
     }
   } while (token != Token::EOS);
   return timer.Elapsed();
 }
 
 
 void PrintTokens(const char* name,
                  const std::vector<TokenWithLocation>& tokens) {
@@ skipping 168 matching lines @@
       if (run_experimental) {
         if (benchmark.empty()) benchmark = "Experimental";
         printf("%s(RunTime): %.f ms\n", benchmark.c_str(),
                experimental_total);
       }
     }
   }
   v8::V8::Dispose();
   return 0;
 }