Experimental parser: continue unifying the API with Scanner.

src/lexer/experimental-scanner.h

 // 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 45 matching lines @@
 #include "string-stream.h"
 
 namespace v8 {
 namespace internal {
 
 class UnicodeCache;
 
 template<typename YYCTYPE>
 class ExperimentalScanner {
  public:
+  struct Location {
+    Location(int b, int e) : beg_pos(b), end_pos(e) { }
+    Location() : beg_pos(0), end_pos(0) { }
+
+    bool IsValid() const {
+      return beg_pos >= 0 && end_pos >= beg_pos;
+    }
+
+    static Location invalid() { return Location(-1, -1); }
+
+    int beg_pos;
+    int end_pos;
+  };
+
   explicit ExperimentalScanner(
       YYCTYPE* source,
       YYCTYPE* source_end,
       Isolate* isolate);
 
   ~ExperimentalScanner();
 
-  Token::Value Next(int* beg_pos, int* end_pos);
+  Token::Value Next() {
+    current_ = next_;
+    Scan();  // will fill in next_.
+    return current_.token;
+  }
+
+  Location location() {
+    return Location(current_.beg_pos, current_.end_pos);
+  }
 
   void SetHarmonyNumericLiterals(bool numeric_literals) {
     harmony_numeric_literals_ = numeric_literals;
   }
 
   void SetHarmonyModules(bool modules) {
     harmony_modules_ = modules;
   }
 
   void SetHarmonyScoping(bool scoping) {
     harmony_scoping_ = scoping;
   }
 
  private:
+  struct TokenDesc {
+    Token::Value token;
+    int beg_pos;
+    int end_pos;
+    LiteralBuffer* literal_chars;
+  };
+
+  void Scan();
+
   bool ValidIdentifierStart();
   bool ValidIdentifierPart();
   uc32 ScanHexNumber(int length);
 
   UnicodeCache* unicode_cache_;
 
   YYCTYPE* buffer_;
   YYCTYPE* buffer_end_;
   YYCTYPE* start_;
   YYCTYPE* cursor_;
   YYCTYPE* marker_;
   bool just_seen_line_terminator_;
 
   YYCTYPE yych;
 
+  TokenDesc current_;  // desc for current token (as returned by Next())
+  TokenDesc next_;     // desc for next token (one token look-ahead)
+
   bool harmony_numeric_literals_;
   bool harmony_modules_;
   bool harmony_scoping_;
 };
 
 const byte* ReadFile(const char* name, Isolate* isolate, int* size, int repeat);
 
 template<typename YYCTYPE>
 ExperimentalScanner<YYCTYPE>::ExperimentalScanner(
     YYCTYPE* source,
     YYCTYPE* source_end,
     Isolate* isolate)
     : unicode_cache_(isolate->unicode_cache()),
       just_seen_line_terminator_(true),
       harmony_numeric_literals_(false),
       harmony_modules_(false),
       harmony_scoping_(false) {
   buffer_ = source;
   buffer_end_ = source_end;
   start_ = buffer_;
   cursor_ = buffer_;
   marker_ = buffer_;
+  Scan();
 }
 
 
 template<typename YYCTYPE>
 ExperimentalScanner<YYCTYPE>::~ExperimentalScanner() {
   delete[] buffer_;
 }
 
 
 template<typename YYCTYPE>
@@ skipping 20 matching lines @@
 
 
 template<typename YYCTYPE>
 bool ExperimentalScanner<YYCTYPE>::ValidIdentifierStart() {
   return unicode_cache_->IsIdentifierStart(ScanHexNumber(4));
 }
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H