[Isolates] Static mutable data of Scanner class moved to ScannerCharacterClasses / Isolate.

src/scanner.h

 // Copyright 2006-2008 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 240 matching lines @@
       token_ = keyword_token;
       return true;
     }
     return false;
   }
 
   void Step(uc32 input);
 };
 
 
+class ScannerCharacterClasses;
+
+
 enum ParserMode { PARSE, PREPARSE };
 enum ParserLanguage { JAVASCRIPT, JSON };
 
 
 class Scanner {
  public:
   typedef unibrow::Utf8InputBuffer<1024> Utf8Decoder;
 
   // Construction
   explicit Scanner(ParserMode parse_mode);
@@ skipping 69 matching lines @@
   bool ScanRegExpFlags();
 
   // Seek forward to the given position.  This operation does not
   // work in general, for instance when there are pushed back
   // characters, but works for seeking forward until simple delimiter
   // tokens, which is what it is used for.
   void SeekForward(int pos);
 
   bool stack_overflow() { return stack_overflow_; }
 
-  static StaticResource<Utf8Decoder>* utf8_decoder() { return &utf8_decoder_; }
-
-  // Tells whether the buffer contains an identifier (no escapes).
-  // Used for checking if a property name is an identifier.
-  static bool IsIdentifier(unibrow::CharacterStream* buffer);
-
-  static unibrow::Predicate<IdentifierStart, 128> kIsIdentifierStart;
-  static unibrow::Predicate<IdentifierPart, 128> kIsIdentifierPart;
-  static unibrow::Predicate<unibrow::LineTerminator, 128> kIsLineTerminator;
-  static unibrow::Predicate<unibrow::WhiteSpace, 128> kIsWhiteSpace;
-
   static const int kCharacterLookaheadBufferSize = 1;
   static const int kNoEndPosition = 1;
 
  private:
   void Init(Handle<String> source,
             unibrow::CharacterStream* stream,
             int start_position, int end_position,
             ParserLanguage language);
 
 
@@ skipping 10 matching lines @@
   // Used to convert the source string into a character stream when a stream
   // is not passed to the scanner.
   SafeStringInputBuffer safe_string_input_buffer_;
 
   // Buffer to hold literal values (identifiers, strings, numbers)
   // using 0-terminated UTF-8 encoding.
   UTF8Buffer literal_buffer_1_;
   UTF8Buffer literal_buffer_2_;
 
   bool stack_overflow_;
-  static StaticResource<Utf8Decoder> utf8_decoder_;
 
   // One Unicode character look-ahead; c0_ < 0 at the end of the input.
   uc32 c0_;
 
   // The current and look-ahead token.
   struct TokenDesc {
     Token::Value token;
     Location location;
     UTF8Buffer* literal_buffer;
   };
 
   TokenDesc current_;  // desc for current token (as returned by Next())
   TokenDesc next_;     // desc for next token (one token look-ahead)
   bool has_line_terminator_before_next_;
   bool is_pre_parsing_;
   bool is_parsing_json_;
 
+  ScannerCharacterClasses* const character_classes_;
+
   // Literal buffer support
   void StartLiteral();
   void AddChar(uc32 ch);
   void AddCharAdvance();
   void TerminateLiteral();
 
   // Low-level scanning support.
   void Advance() { c0_ = source_->Advance(); }
   void PushBack(uc32 ch) {
     source_->PushBack(ch);
@@ skipping 65 matching lines @@
   // Return the current source position.
   int source_pos() {
     return source_->pos() - kCharacterLookaheadBufferSize;
   }
 
   // Decodes a unicode escape-sequence which is part of an identifier.
   // If the escape sequence cannot be decoded the result is kBadRune.
   uc32 ScanIdentifierUnicodeEscape();
 };
 
+
+class ScannerCharacterClasses {
+ public:
+  StaticResource<Scanner::Utf8Decoder>* utf8_decoder() {
+    return &utf8_decoder_;
+  }
+
+  // Tells whether the buffer contains an identifier (no escapes).
+  // Used for checking if a property name is an identifier.
+  bool IsIdentifier(unibrow::CharacterStream* buffer);
+
+  bool IsWhiteSpace(unibrow::uchar c) { return is_white_space_.get(c); }
+
+ private:
+  ScannerCharacterClasses() {}
+
+  // --------------------------------------------------------------------------
+  // Character predicates
+
+  unibrow::Predicate<IdentifierStart, 128> is_identifier_start_;
+  unibrow::Predicate<IdentifierPart, 128> is_identifier_part_;
+  unibrow::Predicate<unibrow::LineTerminator, 128> is_line_terminator_;
+  unibrow::Predicate<unibrow::WhiteSpace, 128> is_white_space_;
+
+  StaticResource<Scanner::Utf8Decoder> utf8_decoder_;
+
+  friend class Isolate;
+  friend class Scanner;
+
+  DISALLOW_COPY_AND_ASSIGN(ScannerCharacterClasses);
+};
+
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_