Make LiteralBuffer + LiteralScope private.

src/parsing/scanner.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #ifndef V8_PARSING_SCANNER_H_
 #define V8_PARSING_SCANNER_H_
 
 #include "src/allocation.h"
@@ skipping 130 matching lines @@
   static const int kBufferSize = 100;
 
   UnicodeCache* unicode_constants_;
   // Backing store used to store strings used as hashmap keys.
   SequenceCollector<unsigned char> backing_store_;
   base::HashMap map_;
   // Buffer used for string->number->canonical string conversions.
   char number_buffer_[kBufferSize];
 };
 
-// ----------------------------------------------------------------------------
-// LiteralBuffer -  Collector of chars of literals.
-
-const int kMaxAscii = 127;
-
-class LiteralBuffer {
- public:
-  LiteralBuffer() : is_one_byte_(true), position_(0), backing_store_() { }
-
-  ~LiteralBuffer() { backing_store_.Dispose(); }
-
-  INLINE(void AddChar(char code_unit)) {
-    if (position_ >= backing_store_.length()) ExpandBuffer();
-    DCHECK(is_one_byte_);
-    DCHECK(IsValidAscii(code_unit));
-    backing_store_[position_] = static_cast<byte>(code_unit);
-    position_ += kOneByteSize;
-    return;
-  }
-
-  INLINE(void AddChar(uc32 code_unit)) {
-    if (position_ >= backing_store_.length()) ExpandBuffer();
-    if (is_one_byte_) {
-      if (code_unit <= unibrow::Latin1::kMaxChar) {
-        backing_store_[position_] = static_cast<byte>(code_unit);
-        position_ += kOneByteSize;
-        return;
-      }
-      ConvertToTwoByte();
-    }
-    if (code_unit <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
-      *reinterpret_cast<uint16_t*>(&backing_store_[position_]) = code_unit;
-      position_ += kUC16Size;
-    } else {
-      *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
-          unibrow::Utf16::LeadSurrogate(code_unit);
-      position_ += kUC16Size;
-      if (position_ >= backing_store_.length()) ExpandBuffer();
-      *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
-          unibrow::Utf16::TrailSurrogate(code_unit);
-      position_ += kUC16Size;
-    }
-  }
-
-  bool is_one_byte() const { return is_one_byte_; }
-
-  bool is_contextual_keyword(Vector<const char> keyword) const {
-    return is_one_byte() && keyword.length() == position_ &&
-        (memcmp(keyword.start(), backing_store_.start(), position_) == 0);
-  }
-
-  Vector<const uint16_t> two_byte_literal() const {
-    DCHECK(!is_one_byte_);
-    DCHECK((position_ & 0x1) == 0);
-    return Vector<const uint16_t>(
-        reinterpret_cast<const uint16_t*>(backing_store_.start()),
-        position_ >> 1);
-  }
-
-  Vector<const uint8_t> one_byte_literal() const {
-    DCHECK(is_one_byte_);
-    return Vector<const uint8_t>(
-        reinterpret_cast<const uint8_t*>(backing_store_.start()),
-        position_);
-  }
-
-  int length() const {
-    return is_one_byte_ ? position_ : (position_ >> 1);
-  }
-
-  void ReduceLength(int delta) {
-    position_ -= delta * (is_one_byte_ ? kOneByteSize : kUC16Size);
-  }
-
-  void Reset() {
-    position_ = 0;
-    is_one_byte_ = true;
-  }
-
-  Handle<String> Internalize(Isolate* isolate) const;
-
-  void CopyFrom(const LiteralBuffer* other) {
-    if (other == nullptr) {
-      Reset();
-    } else {
-      is_one_byte_ = other->is_one_byte_;
-      position_ = other->position_;
-      if (position_ < backing_store_.length()) {
-        std::copy(other->backing_store_.begin(),
-                  other->backing_store_.begin() + position_,
-                  backing_store_.begin());
-      } else {
-        backing_store_.Dispose();
-        backing_store_ = other->backing_store_.Clone();
-      }
-    }
-  }
-
- private:
-  static const int kInitialCapacity = 16;
-  static const int kGrowthFactory = 4;
-  static const int kMinConversionSlack = 256;
-  static const int kMaxGrowth = 1 * MB;
-
-  inline bool IsValidAscii(char code_unit) {
-    // Control characters and printable characters span the range of
-    // valid ASCII characters (0-127). Chars are unsigned on some
-    // platforms which causes compiler warnings if the validity check
-    // tests the lower bound >= 0 as it's always true.
-    return iscntrl(code_unit) || isprint(code_unit);
-  }
-
-  inline int NewCapacity(int min_capacity) {
-    int capacity = Max(min_capacity, backing_store_.length());
-    int new_capacity = Min(capacity * kGrowthFactory, capacity + kMaxGrowth);
-    return new_capacity;
-  }
-
-  void ExpandBuffer() {
-    Vector<byte> new_store = Vector<byte>::New(NewCapacity(kInitialCapacity));
-    MemCopy(new_store.start(), backing_store_.start(), position_);
-    backing_store_.Dispose();
-    backing_store_ = new_store;
-  }
-
-  void ConvertToTwoByte() {
-    DCHECK(is_one_byte_);
-    Vector<byte> new_store;
-    int new_content_size = position_ * kUC16Size;
-    if (new_content_size >= backing_store_.length()) {
-      // Ensure room for all currently read code units as UC16 as well
-      // as the code unit about to be stored.
-      new_store = Vector<byte>::New(NewCapacity(new_content_size));
-    } else {
-      new_store = backing_store_;
-    }
-    uint8_t* src = backing_store_.start();
-    uint16_t* dst = reinterpret_cast<uint16_t*>(new_store.start());
-    for (int i = position_ - 1; i >= 0; i--) {
-      dst[i] = src[i];
-    }
-    if (new_store.start() != backing_store_.start()) {
-      backing_store_.Dispose();
-      backing_store_ = new_store;
-    }
-    position_ = new_content_size;
-    is_one_byte_ = false;
-  }
-
-  bool is_one_byte_;
-  int position_;
-  Vector<byte> backing_store_;
-
-  DISALLOW_COPY_AND_ASSIGN(LiteralBuffer);
-};
-
 
 // ----------------------------------------------------------------------------
 // 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) : scanner_(self), complete_(false) {
-      scanner_->StartLiteral();
-    }
-     ~LiteralScope() {
-       if (!complete_) scanner_->DropLiteral();
-     }
-    void Complete() {
-      complete_ = true;
-    }
-
-   private:
-    Scanner* scanner_;
-    bool complete_;
-  };
-
   // Scoped helper for a re-settable bookmark.
   class BookmarkScope {
    public:
     explicit BookmarkScope(Scanner* scanner) : scanner_(scanner) {
       DCHECK_NOT_NULL(scanner_);
     }
     ~BookmarkScope() { scanner_->DropBookmark(); }
 
     bool Set() { return scanner_->SetBookmark(); }
     void Reset() { scanner_->ResetToBookmark(); }
@@ skipping 14 matching lines @@
     bool IsValid() const {
       return beg_pos >= 0 && end_pos >= beg_pos;
     }
 
     static Location invalid() { return Location(-1, -1); }
 
     int beg_pos;
     int end_pos;
   };
 
+ private:
+  class LiteralScope;   // Private helper class to start/end scanning literals.
+  class LiteralBuffer;  // Private helper class to hold scanned literals.
+
+ public:

[marja, 2016/08/05 07:05:46]

We had some discussions about this part and... what did we conclude?

[vogelheim, 2016/08/09 11:47:27]

We concluded that I shouldn't do this. Will update the CL.

[vogelheim, 2016/08/09 11:57:24]

Done. (As in: Removed this by reordering the declarations a bit.)

   // -1 is outside of the range of any real source code.
   static const int kNoOctalLocation = -1;
 
   explicit Scanner(UnicodeCache* scanner_contants);
 
   void Initialize(Utf16CharacterStream* source);
 
   // Returns the next token and advances input.
   Token::Value Next();
   // Returns the token following peek()
@@ skipping 101 matching lines @@
   // 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);
   // Scans the input as regular expression flags. Returns the flags on success.
   Maybe<RegExp::Flags> ScanRegExpFlags();
 
   // Scans the input as a template literal
   Token::Value ScanTemplateStart();
   Token::Value ScanTemplateContinuation();
 
-  const LiteralBuffer* source_url() const { return &source_url_; }
-  const LiteralBuffer* source_mapping_url() const {
-    return &source_mapping_url_;
+  Handle<String> SourceUrl(Isolate* isolate) const {
+    Handle<String> tmp;
+    if (source_url_.length() > 0) tmp = source_url_.Internalize(isolate);
+    return tmp;
+  }
+
+  Handle<String> SourceMappingUrl(Isolate* isolate) const {
+    Handle<String> tmp;
+    if (source_mapping_url_.length() > 0)
+      tmp = source_mapping_url_.Internalize(isolate);
+    return tmp;
   }
 
   bool IdentifierIsFutureStrictReserved(const AstRawString* string) const;
 
   bool FoundHtmlComment() const { return found_html_comment_; }
 
 #define DECLARE_ACCESSORS(name)                                \
   inline bool allow_##name() const { return allow_##name##_; } \
   inline void set_allow_##name(bool allow) { allow_##name##_ = allow; }
   DECLARE_ACCESSORS(harmony_exponentiation_operator)
 #undef ACCESSOR
 
  private:
   // The current and look-ahead token.
   struct TokenDesc {
     Token::Value token;
     Location location;
     LiteralBuffer* literal_chars;
     LiteralBuffer* raw_literal_chars;
     int smi_value_;
   };
 
+  // Scoped helper for literal recording. Automatically drops the literal
+  // if aborting the scanning before it's complete.
+  class LiteralScope {
+   public:
+    explicit LiteralScope(Scanner* self) : scanner_(self), complete_(false) {
+      scanner_->StartLiteral();
+    }
+    ~LiteralScope() {
+      if (!complete_) scanner_->DropLiteral();
+    }
+    void Complete() { complete_ = true; }
+
+   private:
+    Scanner* scanner_;
+    bool complete_;
+  };
+
+  // LiteralBuffer -  Collector of chars of literals.
+  class LiteralBuffer {
+   public:
+    LiteralBuffer() : is_one_byte_(true), position_(0), backing_store_() {}
+
+    ~LiteralBuffer() { backing_store_.Dispose(); }
+
+    INLINE(void AddChar(char code_unit)) {
+      if (position_ >= backing_store_.length()) ExpandBuffer();
+      DCHECK(is_one_byte_);
+      DCHECK(IsValidAscii(code_unit));
+      backing_store_[position_] = static_cast<byte>(code_unit);
+      position_ += kOneByteSize;
+      return;
+    }
+
+    INLINE(void AddChar(uc32 code_unit)) {
+      if (position_ >= backing_store_.length()) ExpandBuffer();
+      if (is_one_byte_) {
+        if (code_unit <= unibrow::Latin1::kMaxChar) {
+          backing_store_[position_] = static_cast<byte>(code_unit);
+          position_ += kOneByteSize;
+          return;
+        }
+        ConvertToTwoByte();
+      }
+      if (code_unit <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
+        *reinterpret_cast<uint16_t*>(&backing_store_[position_]) = code_unit;
+        position_ += kUC16Size;
+      } else {
+        *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
+            unibrow::Utf16::LeadSurrogate(code_unit);
+        position_ += kUC16Size;
+        if (position_ >= backing_store_.length()) ExpandBuffer();
+        *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
+            unibrow::Utf16::TrailSurrogate(code_unit);
+        position_ += kUC16Size;
+      }
+    }
+
+    bool is_one_byte() const { return is_one_byte_; }
+
+    bool is_contextual_keyword(Vector<const char> keyword) const {
+      return is_one_byte() && keyword.length() == position_ &&
+             (memcmp(keyword.start(), backing_store_.start(), position_) == 0);
+    }
+
+    Vector<const uint16_t> two_byte_literal() const {
+      DCHECK(!is_one_byte_);
+      DCHECK((position_ & 0x1) == 0);
+      return Vector<const uint16_t>(
+          reinterpret_cast<const uint16_t*>(backing_store_.start()),
+          position_ >> 1);
+    }
+
+    Vector<const uint8_t> one_byte_literal() const {
+      DCHECK(is_one_byte_);
+      return Vector<const uint8_t>(
+          reinterpret_cast<const uint8_t*>(backing_store_.start()), position_);
+    }
+
+    int length() const { return is_one_byte_ ? position_ : (position_ >> 1); }
+
+    void ReduceLength(int delta) {
+      position_ -= delta * (is_one_byte_ ? kOneByteSize : kUC16Size);
+    }
+
+    void Reset() {
+      position_ = 0;
+      is_one_byte_ = true;
+    }
+
+    Handle<String> Internalize(Isolate* isolate) const;
+
+    void CopyFrom(const LiteralBuffer* other) {
+      if (other == nullptr) {
+        Reset();
+      } else {
+        is_one_byte_ = other->is_one_byte_;
+        position_ = other->position_;
+        if (position_ < backing_store_.length()) {
+          std::copy(other->backing_store_.begin(),
+                    other->backing_store_.begin() + position_,
+                    backing_store_.begin());
+        } else {
+          backing_store_.Dispose();
+          backing_store_ = other->backing_store_.Clone();
+        }
+      }
+    }
+
+   private:
+    static const int kInitialCapacity = 16;
+    static const int kGrowthFactory = 4;
+    static const int kMinConversionSlack = 256;
+    static const int kMaxGrowth = 1 * MB;
+
+    inline bool IsValidAscii(char code_unit) {
+      // Control characters and printable characters span the range of
+      // valid ASCII characters (0-127). Chars are unsigned on some
+      // platforms which causes compiler warnings if the validity check
+      // tests the lower bound >= 0 as it's always true.
+      return iscntrl(code_unit) || isprint(code_unit);
+    }
+
+    inline int NewCapacity(int min_capacity) {
+      int capacity = Max(min_capacity, backing_store_.length());
+      int new_capacity = Min(capacity * kGrowthFactory, capacity + kMaxGrowth);
+      return new_capacity;
+    }
+
+    void ExpandBuffer() {
+      Vector<byte> new_store = Vector<byte>::New(NewCapacity(kInitialCapacity));
+      MemCopy(new_store.start(), backing_store_.start(), position_);
+      backing_store_.Dispose();
+      backing_store_ = new_store;
+    }
+
+    void ConvertToTwoByte() {
+      DCHECK(is_one_byte_);
+      Vector<byte> new_store;
+      int new_content_size = position_ * kUC16Size;
+      if (new_content_size >= backing_store_.length()) {
+        // Ensure room for all currently read code units as UC16 as well
+        // as the code unit about to be stored.
+        new_store = Vector<byte>::New(NewCapacity(new_content_size));
+      } else {
+        new_store = backing_store_;
+      }
+      uint8_t* src = backing_store_.start();
+      uint16_t* dst = reinterpret_cast<uint16_t*>(new_store.start());
+      for (int i = position_ - 1; i >= 0; i--) {
+        dst[i] = src[i];
+      }
+      if (new_store.start() != backing_store_.start()) {
+        backing_store_.Dispose();
+        backing_store_ = new_store;
+      }
+      position_ = new_content_size;
+      is_one_byte_ = false;
+    }
+
+    bool is_one_byte_;
+    int position_;
+    Vector<byte> backing_store_;
+
+    DISALLOW_COPY_AND_ASSIGN(LiteralBuffer);
+  };
+
   static const int kCharacterLookaheadBufferSize = 1;
+  const int kMaxAscii = 127;
 
   // Scans octal escape sequence. Also accepts "\0" decimal escape sequence.
   template <bool capture_raw>
   uc32 ScanOctalEscape(uc32 c, int length);
 
   // Call this after setting source_ to the input.
   void Init() {
     // Set c0_ (one character ahead)
     STATIC_ASSERT(kCharacterLookaheadBufferSize == 1);
     Advance();
@@ skipping 308 matching lines @@
   bool allow_harmony_exponentiation_operator_;
 
   MessageTemplate::Template scanner_error_;
   Location scanner_error_location_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_SCANNER_H_