Experimental scanner: Add base class ScannerBase.

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 39 matching lines @@
 #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) { }
+// Base class for scanners for different encodings. The meat is the pure virtual
+// Scan() which each of them specializes.
+class ScannerBase {
+ 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;
+    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 ScannerBase(Isolate* isolate)
+    : unicode_cache_(isolate->unicode_cache()),
+      has_line_terminator_before_next_(true),
+      harmony_numeric_literals_(false),
+      harmony_modules_(false),
+      harmony_scoping_(false) {
   }
 
-  static ScannerLocation invalid() { return ScannerLocation(-1, -1); }
-
-  int beg_pos;
-  int end_pos;
-};
-
-template<typename YYCTYPE>
-class ExperimentalScanner {
- public:
-  explicit ExperimentalScanner(
-      YYCTYPE* source,
-      YYCTYPE* source_end,
-      Isolate* isolate);
-
-  ~ExperimentalScanner();
+  virtual ~ScannerBase() { }
 
   // Returns the next token and advances input.
   Token::Value Next() {
     has_line_terminator_before_next_ = false;
     current_ = next_;
-    Scan();  // will fill in next_.
+    Scan();  // Virtual! 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()).
-  ScannerLocation location() {
-    return ScannerLocation(current_.beg_pos, current_.end_pos);
+  Location location() {
+    return Location(current_.beg_pos, current_.end_pos);
   }
 
   // One token look-ahead (past the token returned by Next()).
   Token::Value peek() const { return next_.token; }
 
-  ScannerLocation peek_location() const { return next_.location; }
+  Location peek_location() const {
+    return Location(next_.beg_pos, next_.end_pos);
+  }
 
   UnicodeCache* unicode_cache() { return unicode_cache_; }
 
   bool HarmonyScoping() const {
     return harmony_scoping_;
   }
   void SetHarmonyScoping(bool scoping) {
     harmony_scoping_ = scoping;
   }
   bool HarmonyModules() const {
@@ skipping 48 matching lines @@
   }
   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
+  Location octal_position() const {
+    return Location(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:
+ protected:
   struct TokenDesc {
     Token::Value token;
     int beg_pos;
     int end_pos;
   };
 
-  void Scan();
+  virtual void Scan() = 0;
+  virtual uc32 ScanHexNumber(int length) = 0;
 
-  bool ValidIdentifierStart();
-  bool ValidIdentifierPart();
-  uc32 ScanHexNumber(int length);
+  bool ValidIdentifierPart() {
+      return unicode_cache_->IsIdentifierPart(ScanHexNumber(4));
+  }
+
+  bool ValidIdentifierStart() {
+    return unicode_cache_->IsIdentifierStart(ScanHexNumber(4));
+  }
 
   UnicodeCache* unicode_cache_;
 
-  YYCTYPE* buffer_;
-  YYCTYPE* buffer_end_;
-  YYCTYPE* start_;
-  YYCTYPE* cursor_;
-  YYCTYPE* marker_;
   bool has_line_terminator_before_next_;
 
-  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>
+class ExperimentalScanner : public ScannerBase {
+ public:
+  explicit ExperimentalScanner(
+      YYCTYPE* source,
+      YYCTYPE* source_end,
+      Isolate* isolate);
+
+  virtual ~ExperimentalScanner();
+
+  virtual void Scan();
+  virtual uc32 ScanHexNumber(int length);
+
+ private:
+  YYCTYPE yych;
+  YYCTYPE* buffer_;
+  YYCTYPE* buffer_end_;
+  YYCTYPE* start_;
+  YYCTYPE* cursor_;
+  YYCTYPE* marker_;
+};
+
 
 template<typename YYCTYPE>
 ExperimentalScanner<YYCTYPE>::ExperimentalScanner(
     YYCTYPE* source,
     YYCTYPE* source_end,
     Isolate* isolate)
-    : unicode_cache_(isolate->unicode_cache()),
-      has_line_terminator_before_next_(true),
-      harmony_numeric_literals_(false),
-      harmony_modules_(false),
-      harmony_scoping_(false) {
-  buffer_ = source;
-  buffer_end_ = source_end;
-  start_ = buffer_;
-  cursor_ = buffer_;
-  marker_ = buffer_;
+    : ScannerBase(isolate),
+      buffer_(source),
+      buffer_end_(source_end),
+      start_(source),
+      cursor_(source),
+      marker_(source) {
   Scan();
 }
 
 
 template<typename YYCTYPE>
 ExperimentalScanner<YYCTYPE>::~ExperimentalScanner() {
   delete[] buffer_;
 }
 
 
 template<typename YYCTYPE>
 uc32 ExperimentalScanner<YYCTYPE>::ScanHexNumber(int length) {
   // We have seen \uXXXX, let's see what it is.
   // FIXME: we never end up in here if only a subset of the 4 chars are valid
   // hex digits -> handle the case where they're not.
   uc32 x = 0;
   for (YYCTYPE* s = cursor_ - length; s != cursor_; ++s) {
     int d = HexValue(*s);
     if (d < 0) {
       return -1;
     }
     x = x * 16 + d;
   }
   return x;
 }
 
 
-template<typename YYCTYPE>
-bool ExperimentalScanner<YYCTYPE>::ValidIdentifierPart() {
-  return unicode_cache_->IsIdentifierPart(ScanHexNumber(4));
-}
-
-
-template<typename YYCTYPE>
-bool ExperimentalScanner<YYCTYPE>::ValidIdentifierStart() {
-  return unicode_cache_->IsIdentifierStart(ScanHexNumber(4));
-}
-
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H