Experimental parser: merge to r19637

src/scanner.h

 // Copyright 2011 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 37 matching lines @@
 // If c is not a legal hexadecimal character, returns a value < 0.
 inline int HexValue(uc32 c) {
   c -= '0';
   if (static_cast<unsigned>(c) <= 9) return c;
   c = (c | 0x20) - ('a' - '0');  // detect 0x11..0x16 and 0x31..0x36.
   if (static_cast<unsigned>(c) <= 5) return c + 10;
   return -1;
 }
 
 
+#ifndef V8_USE_GENERATED_LEXER
+
+
 // ---------------------------------------------------------------------
 // Buffered stream of UTF-16 code units, using an internal UTF-16 buffer.
 // A code unit is a 16 bit value representing either a 16 bit code point
 // or one part of a surrogate pair that make a single 21 bit code point.
 
 class Utf16CharacterStream {
  public:
   Utf16CharacterStream() : pos_(0) { }
   virtual ~Utf16CharacterStream() { }
 
@@ skipping 48 matching lines @@
   // are more code_units available, return true.
   virtual bool ReadBlock() = 0;
   virtual unsigned SlowSeekForward(unsigned code_unit_count) = 0;
 
   const uc16* buffer_cursor_;
   const uc16* buffer_end_;
   unsigned pos_;
 };
 
 
+#else
+
+class Utf16CharacterStream {
+ public:
+  enum StreamType {
+    kUtf8ToUtf16, kGenericStringUtf16, kExternalTwoByteStringUtf16
+  };
+
+  explicit Utf16CharacterStream(StreamType stream_type)
+      : stream_type_(stream_type) {}
+
+  const StreamType stream_type_;
+};
+
+#endif
+
+
 // ---------------------------------------------------------------------
 // Caching predicates used by scanners.
 
 class UnicodeCache {
  public:
   UnicodeCache() {}
   typedef unibrow::Utf8Decoder<512> Utf8Decoder;
 
   StaticResource<Utf8Decoder>* utf8_decoder() {
     return &utf8_decoder_;
   }
 
   bool IsIdentifierStart(unibrow::uchar c) { return kIsIdentifierStart.get(c); }
   bool IsIdentifierPart(unibrow::uchar c) { return kIsIdentifierPart.get(c); }
   bool IsLineTerminator(unibrow::uchar c) { return kIsLineTerminator.get(c); }
   bool IsWhiteSpace(unibrow::uchar c) { return kIsWhiteSpace.get(c); }
+  bool IsWhiteSpaceOrLineTerminator(unibrow::uchar c) {
+    return kIsWhiteSpaceOrLineTerminator.get(c);
+  }
   bool IsByteOrderMark(unibrow::uchar c) { return c == 0xfffe || c == 0xfeff; }
   bool IsWhiteSpaceNotLineTerminator(unibrow::uchar c) {
     return (kIsWhiteSpace.get(c) && !kIsLineTerminator.get(c)) ||
         IsByteOrderMark(c);
   }
   bool IsLetter(unibrow::uchar c) { return kIsLetter.get(c); }
   bool IsIdentifierPartNotLetter(unibrow::uchar c) {
     return kIsIdentifierPartNotLetter.get(c);
   }
 
  private:
   unibrow::Predicate<IdentifierStart, 128> kIsIdentifierStart;
   unibrow::Predicate<IdentifierPart, 128> kIsIdentifierPart;
   unibrow::Predicate<unibrow::LineTerminator, 128> kIsLineTerminator;
-  unibrow::Predicate<unibrow::WhiteSpace, 128> kIsWhiteSpace;
+  unibrow::Predicate<WhiteSpace, 128> kIsWhiteSpace;
   unibrow::Predicate<unibrow::Letter, 128> kIsLetter;
   unibrow::Predicate<IdentifierPartNotLetter, 128> kIsIdentifierPartNotLetter;
+  unibrow::Predicate<WhiteSpaceOrLineTerminator, 128>
+      kIsWhiteSpaceOrLineTerminator;
   StaticResource<Utf8Decoder> utf8_decoder_;
 
   DISALLOW_COPY_AND_ASSIGN(UnicodeCache);
 };
 
 
 // ---------------------------------------------------------------------
 // DuplicateFinder discovers duplicate symbols.
 
 class DuplicateFinder {
@@ skipping 145 matching lines @@
   }
 
   bool is_ascii_;
   int position_;
   Vector<byte> backing_store_;
 
   DISALLOW_COPY_AND_ASSIGN(LiteralBuffer);
 };
 
 
+#ifndef V8_USE_GENERATED_LEXER
+
+
 // ----------------------------------------------------------------------------
 // JavaScript Scanner.
 
 class Scanner {
  public:
   // Scoped helper for literal recording. Automatically drops the literal
   // if aborting the scanning before it's complete.
   class LiteralScope {
    public:
     explicit LiteralScope(Scanner* self)
@@ skipping 289 matching lines @@
   // line-terminator after the current token, and before the next.
   bool has_multiline_comment_before_next_;
   // Whether we scan 'let' as a keyword for harmony block-scoped let bindings.
   bool harmony_scoping_;
   // Whether we scan 'module', 'import', 'export' as keywords.
   bool harmony_modules_;
   // Whether we scan 0o777 and 0b111 as numbers.
   bool harmony_numeric_literals_;
 };
 
+
+#endif
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_