Specialized string equality based on representation

src/objects.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 43 matching lines @@
 //         - ByteArray
 //         - FixedArray
 //           - DescriptorArray
 //           - HashTable
 //             - Dictionary
 //             - SymbolTable
 //           - Context
 //           - GlobalContext
 //       - String
 //         - SeqString
-//           - AsciiString
-//           - TwoByteString
+//           - SeqAsciiString
+//           - SeqTwoByteString
 //         - ConsString
 //         - SlicedString
 //         - ExternalString
 //           - ExternalAsciiString
 //           - ExternalTwoByteString
 //       - HeapNumber
 //       - Code
 //       - Map
 //       - Oddball
 //       - Proxy
@@ skipping 189 matching lines @@
   V(JS_BUILTINS_OBJECT_TYPE)                    \
   V(JS_ARRAY_TYPE)                              \
   V(JS_REGEXP_TYPE)                             \
                                                 \
   V(JS_FUNCTION_TYPE)                           \
 
 
 // Since string types are not consecutive, this macro is used to
 // iterate over them.
 #define STRING_TYPE_LIST(V)                                                    \
-  V(SHORT_SYMBOL_TYPE, TwoByteString::kHeaderSize, short_symbol)               \
-  V(MEDIUM_SYMBOL_TYPE, TwoByteString::kHeaderSize, medium_symbol)             \
-  V(LONG_SYMBOL_TYPE, TwoByteString::kHeaderSize, long_symbol)                 \
-  V(SHORT_ASCII_SYMBOL_TYPE, AsciiString::kHeaderSize, short_ascii_symbol)     \
-  V(MEDIUM_ASCII_SYMBOL_TYPE, AsciiString::kHeaderSize, medium_ascii_symbol)   \
-  V(LONG_ASCII_SYMBOL_TYPE, AsciiString::kHeaderSize, long_ascii_symbol)       \
+  V(SHORT_SYMBOL_TYPE, SeqTwoByteString::kHeaderSize, short_symbol)            \
+  V(MEDIUM_SYMBOL_TYPE, SeqTwoByteString::kHeaderSize, medium_symbol)          \
+  V(LONG_SYMBOL_TYPE, SeqTwoByteString::kHeaderSize, long_symbol)              \
+  V(SHORT_ASCII_SYMBOL_TYPE, SeqAsciiString::kHeaderSize, short_ascii_symbol)  \
+  V(MEDIUM_ASCII_SYMBOL_TYPE, SeqAsciiString::kHeaderSize, medium_ascii_symbol)\
+  V(LONG_ASCII_SYMBOL_TYPE, SeqAsciiString::kHeaderSize, long_ascii_symbol)    \
   V(SHORT_CONS_SYMBOL_TYPE, ConsString::kSize, short_cons_symbol)              \
   V(MEDIUM_CONS_SYMBOL_TYPE, ConsString::kSize, medium_cons_symbol)            \
   V(LONG_CONS_SYMBOL_TYPE, ConsString::kSize, long_cons_symbol)                \
   V(SHORT_CONS_ASCII_SYMBOL_TYPE, ConsString::kSize, short_cons_ascii_symbol)  \
   V(MEDIUM_CONS_ASCII_SYMBOL_TYPE, ConsString::kSize, medium_cons_ascii_symbol)\
   V(LONG_CONS_ASCII_SYMBOL_TYPE, ConsString::kSize, long_cons_ascii_symbol)    \
   V(SHORT_SLICED_SYMBOL_TYPE, SlicedString::kSize, short_sliced_symbol)        \
   V(MEDIUM_SLICED_SYMBOL_TYPE, SlicedString::kSize, medium_sliced_symbol)      \
   V(LONG_SLICED_SYMBOL_TYPE, SlicedString::kSize, long_sliced_symbol)          \
   V(SHORT_SLICED_ASCII_SYMBOL_TYPE,                                            \
@@ skipping 16 matching lines @@
     long_external_symbol)                                                      \
   V(SHORT_EXTERNAL_ASCII_SYMBOL_TYPE,                                          \
     ExternalAsciiString::kSize,                                                \
     short_external_ascii_symbol)                                               \
   V(MEDIUM_EXTERNAL_ASCII_SYMBOL_TYPE,                                         \
     ExternalAsciiString::kSize,                                                \
     medium_external_ascii_symbol)                                              \
   V(LONG_EXTERNAL_ASCII_SYMBOL_TYPE,                                           \
     ExternalAsciiString::kSize,                                                \
     long_external_ascii_symbol)                                                \
-  V(SHORT_STRING_TYPE, TwoByteString::kHeaderSize, short_string)               \
-  V(MEDIUM_STRING_TYPE, TwoByteString::kHeaderSize, medium_string)             \
-  V(LONG_STRING_TYPE, TwoByteString::kHeaderSize, long_string)                 \
-  V(SHORT_ASCII_STRING_TYPE, AsciiString::kHeaderSize, short_ascii_string)     \
-  V(MEDIUM_ASCII_STRING_TYPE, AsciiString::kHeaderSize, medium_ascii_string)   \
-  V(LONG_ASCII_STRING_TYPE, AsciiString::kHeaderSize, long_ascii_string)       \
+  V(SHORT_STRING_TYPE, SeqTwoByteString::kHeaderSize, short_string)            \
+  V(MEDIUM_STRING_TYPE, SeqTwoByteString::kHeaderSize, medium_string)          \
+  V(LONG_STRING_TYPE, SeqTwoByteString::kHeaderSize, long_string)              \
+  V(SHORT_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize, short_ascii_string)  \
+  V(MEDIUM_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize, medium_ascii_string)\
+  V(LONG_ASCII_STRING_TYPE, SeqAsciiString::kHeaderSize, long_ascii_string)    \
   V(SHORT_CONS_STRING_TYPE, ConsString::kSize, short_cons_string)              \
   V(MEDIUM_CONS_STRING_TYPE, ConsString::kSize, medium_cons_string)            \
   V(LONG_CONS_STRING_TYPE, ConsString::kSize, long_cons_string)                \
   V(SHORT_CONS_ASCII_STRING_TYPE, ConsString::kSize, short_cons_ascii_string)  \
   V(MEDIUM_CONS_ASCII_STRING_TYPE, ConsString::kSize, medium_cons_ascii_string)\
   V(LONG_CONS_ASCII_STRING_TYPE, ConsString::kSize, long_cons_ascii_string)    \
   V(SHORT_SLICED_STRING_TYPE, SlicedString::kSize, short_sliced_string)        \
   V(MEDIUM_SLICED_STRING_TYPE, SlicedString::kSize, medium_sliced_string)      \
   V(LONG_SLICED_STRING_TYPE, SlicedString::kSize, long_sliced_string)          \
   V(SHORT_SLICED_ASCII_STRING_TYPE,                                            \
@@ skipping 244 matching lines @@
 // Since Smi and Failure are subclasses of Object no
 // data members can be present in Object.
 class Object BASE_EMBEDDED {
  public:
   // Type testing.
   inline bool IsSmi();
   inline bool IsHeapObject();
   inline bool IsHeapNumber();
   inline bool IsString();
   inline bool IsSeqString();
-  inline bool IsAsciiString();
-  inline bool IsTwoByteString();
+  inline bool IsAsciiStringRepresentation();
+  inline bool IsTwoByteStringRepresentation();
+  inline bool IsSeqAsciiString();
+  inline bool IsSeqTwoByteString();
   inline bool IsConsString();
   inline bool IsSlicedString();
   inline bool IsExternalString();
   inline bool IsExternalAsciiString();
   inline bool IsExternalTwoByteString();
   inline bool IsShortString();
   inline bool IsMediumString();
   inline bool IsLongString();
   inline bool IsSymbol();
   inline bool IsNumber();
@@ skipping 2322 matching lines @@
   // string.  This is a no-op unless the string is a ConsString or a
   // SlicedString.  Flatten mutates the ConsString and might return a
   // failure.
   Object* Flatten();
   // Try to flatten the string.  Do not allow handling of allocation
   // failures.  After calling TryFlatten, the string could still be a
   // ConsString.
   inline void TryFlatten();
 
   // Is this string an ascii string.
-  inline bool IsAscii();
+  inline bool IsAsciiRepresentation();
 
   // Fast testing routines that assume the receiver is a string and
   // just check whether it is a certain kind of string.
   inline bool StringIsSlicedString();
   inline bool StringIsConsString();
 
+  Vector<const char> ToAsciiVector();
+  Vector<const uc16> ToUC16Vector();
+
   // Mark the string as an undetectable object. It only applies to
   // ascii and two byte string types.
   bool MarkAsUndetectable();
 
   // Slice the string and return a substring.
   Object* Slice(int from, int to);
 
   // String equality operations.
   inline bool Equals(String* other);
   bool IsEqualTo(Vector<const char> str);
@@ skipping 50 matching lines @@
 
   // Get the size tag.
   inline uint32_t size_tag();
   static inline uint32_t map_size_tag(Map* map);
 
   // True if the string is a symbol.
   inline bool is_symbol();
   static inline bool is_symbol_map(Map* map);
 
   // True if the string is ASCII.
-  inline bool is_ascii();
-  static inline bool is_ascii_map(Map* map);
+  inline bool is_ascii_representation();
+  static inline bool is_ascii_representation_map(Map* map);
 
   // Get the representation tag.
   inline StringRepresentationTag representation_tag();
   static inline StringRepresentationTag map_representation_tag(Map* map);
 
   // For use during stack traces.  Performs rudimentary sanity check.
   bool LooksValid();
 
   // Dispatched behavior.
   void StringShortPrint(StringStream* accumulator);
@@ skipping 118 matching lines @@
   // For regexp code.
   uint16_t* SeqStringGetTwoByteAddress();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
 };
 
 
 // The AsciiString class captures sequential ascii string objects.
 // Each character in the AsciiString is an ascii character.
-class AsciiString: public SeqString {
+class SeqAsciiString: public SeqString {
  public:
   // Dispatched behavior.
   inline uint16_t AsciiStringGet(int index);
   inline void AsciiStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
   // Casting
-  static inline AsciiString* cast(Object* obj);
+  static inline SeqAsciiString* cast(Object* obj);
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of an AsciiString
   // instance.
   inline int AsciiStringSize(Map* map);

[Erik Corry, 2008/10/08 12:59:53]

Needs renaming

 
   // Computes the size for an AsciiString instance of a given length.
   static int SizeFor(int length) {
     return kHeaderSize + OBJECT_SIZE_ALIGN(length * kCharSize);
   }
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Support for StringInputBuffer.
   inline void AsciiStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,

[Erik Corry, 2008/10/08 12:59:53]

Ditto

                                              unsigned* offset,
                                              unsigned chars);
   inline const unibrow::byte* AsciiStringReadBlock(unsigned* remaining,

[Erik Corry, 2008/10/08 12:59:53]

Ditto

                                                    unsigned* offset,
                                                    unsigned chars);
 
  private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(AsciiString);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(SeqAsciiString);
 };
 
 
 // The TwoByteString class captures sequential unicode string objects.
 // Each character in the TwoByteString is a two-byte uint16_t.
-class TwoByteString: public SeqString {
+class SeqTwoByteString: public SeqString {
  public:
   // Dispatched behavior.
   inline uint16_t TwoByteStringGet(int index);
   inline void TwoByteStringSet(int index, uint16_t value);
 
   // Get the address of the characters in this string.
   inline Address GetCharsAddress();
 
   // For regexp code.
   const uint16_t* TwoByteStringGetData(unsigned start);

[Erik Corry, 2008/10/08 12:59:53]

Ditto

 
   // Casting
-  static inline TwoByteString* cast(Object* obj);
+  static inline SeqTwoByteString* cast(Object* obj);
 
   // Garbage collection support.  This method is called by the
   // garbage collector to compute the actual size of a TwoByteString
   // instance.
   inline int TwoByteStringSize(Map* map);

[Erik Corry, 2008/10/08 12:59:53]

Ditto

 
   // Computes the size for a TwoByteString instance of a given length.
   static int SizeFor(int length) {
     return kHeaderSize + OBJECT_SIZE_ALIGN(length * kShortSize);
   }
 
   // Layout description.
   static const int kHeaderSize = String::kSize;
 
   // Support for StringInputBuffer.
   inline void TwoByteStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,

[Erik Corry, 2008/10/08 12:59:53]

Ditto

                                                unsigned* offset_ptr,
                                                unsigned chars);
 
  private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(TwoByteString);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(SeqTwoByteString);
 };
 
 
 // The ConsString class describes string values built by using the
 // addition operator on strings.  A ConsString is a pair where the
 // first and second components are pointers to other string values.
 // One or both components of a ConsString can be pointers to other
 // ConsStrings, creating a binary tree of ConsStrings where the leaves
 // are non-ConsString string values.  The string value represented by
 // a ConsString can be obtained by concatenating the leaf string
@@ skipping 191 matching lines @@
   : public unibrow::InputBuffer<String, String**, 256> {
  public:
   virtual void Seek(unsigned pos);
   inline SafeStringInputBuffer()
       : unibrow::InputBuffer<String, String**, 256>() {}
   inline SafeStringInputBuffer(String** backing)
       : unibrow::InputBuffer<String, String**, 256>(backing) {}
 };
 
 
+template <typename T>
+class VectorIterator {
+ public:
+  VectorIterator(T* d, int l) : data_(Vector<T>(d, l)), index_(0) { }
+  explicit VectorIterator(Vector<T> data) : data_(data), index_(0) { }
+  T GetNext() { return data_[index_++]; }
+  bool has_more() { return index_ < data_.length(); }
+ private:
+  Vector<T> data_;
+  int index_;
+};
+
+
 // The Oddball describes objects null, undefined, true, and false.
 class Oddball: public HeapObject {
  public:
   // [to_string]: Cached to_string computed at startup.
   DECL_ACCESSORS(to_string, String)
 
   // [to_number]: Cached to_number computed at startup.
   DECL_ACCESSORS(to_number, Object)
 
   // Casting.
@@ skipping 528 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_