Experimental parser: mock implementation for the rest of the Scanner API funcs.

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 20 matching lines @@
 #include "token.h"
 #include "flags.h"
 #include "v8stdint.h"
 
 // FIXME: some of this is probably not needed.
 #include "allocation.h"
 #include "ast.h"
 #include "preparse-data-format.h"
 #include "preparse-data.h"
 #include "scopes.h"
-#include "preparser.h"
 #include "api.h"
 #include "ast.h"
 #include "bootstrapper.h"
 #include "char-predicates-inl.h"
-#include "codegen.h"
 #include "compiler.h"
 #include "func-name-inferrer.h"
 #include "messages.h"
 #include "parser.h"
 #include "platform.h"
-#include "preparser.h"
 #include "runtime.h"
 #include "scanner-character-streams.h"
 #include "scopeinfo.h"
 #include "string-stream.h"
 
 namespace v8 {
 namespace internal {
 
 class UnicodeCache;
 
+struct ScannerLocation {
+  ScannerLocation(int b, int e) : beg_pos(b), end_pos(e) { }
+  ScannerLocation() : beg_pos(0), end_pos(0) { }
+
+  bool IsValid() const {
+    return beg_pos >= 0 && end_pos >= beg_pos;
+  }
+
+  static ScannerLocation invalid() { return ScannerLocation(-1, -1); }
+
+  int beg_pos;
+  int end_pos;
+};
+
 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();
 
   // Returns the next token and advances input.
   Token::Value Next() {
     has_line_terminator_before_next_ = false;
     current_ = next_;
     Scan();  // will fill in next_.
     return current_.token;
   }
 
   // Returns the current token again.
   Token::Value current_token() { return current_.token; }
 
   // Returns the location information for the current token
   // (the token last returned by Next()).
-  Location location() {
-    return Location(current_.beg_pos, current_.end_pos);
+  ScannerLocation location() {
+    return ScannerLocation(current_.beg_pos, current_.end_pos);
   }
 
   // One token look-ahead (past the token returned by Next()).
   Token::Value peek() const { return next_.token; }
 
-  Location peek_location() const { return next_.location; }
+  ScannerLocation peek_location() const { return next_.location; }
 
   UnicodeCache* unicode_cache() { return unicode_cache_; }
 
   bool HarmonyScoping() const {
     return harmony_scoping_;
   }
   void SetHarmonyScoping(bool scoping) {
     harmony_scoping_ = scoping;
   }
   bool HarmonyModules() const {
@@ skipping 10 matching lines @@
   }
 
   // Returns true if there was a line terminator before the peek'ed token,
   // possibly inside a multi-line comment.
   bool HasAnyLineTerminatorBeforeNext() const {
     return has_line_terminator_before_next_;
     // FIXME: do we need to distinguish between newlines inside and outside
     // multiline comments? Atm doesn't look like we need to.
   }
 
+  // FIXME: implement these
+  Vector<const char> literal_ascii_string() {
+    return Vector<const char>();  // FIXME
+  }
+  Vector<const uc16> literal_utf16_string() {
+    return Vector<const uc16>();  // FIXME
+  }
+  bool is_literal_ascii() {
+    return true;  // FIXME
+  }
+  bool is_literal_contextual_keyword(Vector<const char> keyword) {
+    return false;  // FIXME
+  }
+  int literal_length() const {
+    return 0;  // FIXME
+  }
+  bool literal_contains_escapes() const {
+    return false;  // FIXME
+  }
+
+  Vector<const char> next_literal_ascii_string() {
+    return Vector<const char>();  // FIXME
+  }
+  Vector<const uc16> next_literal_utf16_string() {
+    return Vector<const uc16>();  // FIXME
+  }
+  bool is_next_literal_ascii() {
+    return true;  // FIXME
+  }
+  bool is_next_contextual_keyword(Vector<const char> keyword) {
+    return false;  // FIXME
+  }
+  int next_literal_length() const {
+    return 0;  // FIXME
+  }
+
+  uc32 ScanOctalEscape(uc32 c, int length) { return 0; }  // FIXME
+
+  ScannerLocation octal_position() const {
+    return ScannerLocation(0, 0);  // FIXME
+  }
+  void clear_octal_position() { }  // FIXME
+
+  void SeekForward(int pos) { }  // FIXME
+
+  // Scans the input as a regular expression pattern, previous
+  // character(s) must be /(=). Returns true if a pattern is scanned.
+  bool ScanRegExpPattern(bool seen_equal) { return false; }  // FIXME
+  // Returns true if regexp flags are scanned (always since flags can
+  // be empty).
+  bool ScanRegExpFlags() { return false; }  // FIXME
+
  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_;
 
@@ skipping 65 matching lines @@
 
 
 template<typename YYCTYPE>
 bool ExperimentalScanner<YYCTYPE>::ValidIdentifierStart() {
   return unicode_cache_->IsIdentifierStart(ScanHexNumber(4));
 }
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H