Apply Daniel's patch for array index strings.

src/objects.cc

 // 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 3872 matching lines @@
 
   // Check the hash code is there.
   ASSERT(length_field() & kHashComputedMask);
   return field >> kHashShift;
 }
 
 
 bool String::ComputeArrayIndex(unibrow::CharacterStream* buffer,
                                uint32_t* index,
                                int length) {
-  if (length == 0) return false;
+  if (length == 0 || length > kMaxArrayIndexSize) return false;
   uc32 ch = buffer->GetNext();
 
   // If the string begins with a '0' character, it must only consist
   // of it to be a legal array index.
   if (ch == '0') {
     *index = 0;
     return length == 1;
   }
 
   // Convert string to uint32 array index; character by character.
   int d = ch - '0';
   if (d < 0 || d > 9) return false;
   uint32_t result = d;
   while (buffer->has_more()) {
     d = buffer->GetNext() - '0';
     if (d < 0 || d > 9) return false;
     // Check that the new result is below the 32 bit limit.
     if (result > 429496729U - ((d > 5) ? 1 : 0)) return false;
     result = (result * 10) + d;
   }
 
   *index = result;
   return true;
 }
 
 
 bool String::SlowAsArrayIndex(uint32_t* index) {
-  StringInputBuffer buffer(this);
-  return ComputeArrayIndex(&buffer, index, length());
+  if (length() <= kMaxCachedArrayIndexLength) {
+    Hash();  // force computation of hash code

[bak, 2008/10/22 13:25:14]

Capitalize to Force and add period.

+    uint32_t field = length_field();
+    if ((field & kIsArrayIndexMask) == 0) return false;
+    *index = (field & ((1 << kShortLengthShift) - 1)) >> kLongLengthShift;
+    return true;
+  } else {
+    StringInputBuffer buffer(this);
+    return ComputeArrayIndex(&buffer, index, length());
+  }
 }
 
 
 static inline uint32_t HashField(uint32_t hash, bool is_array_index) {
   uint32_t result =
       (hash << String::kLongLengthShift) | String::kHashComputedMask;
   if (is_array_index) result |= String::kIsArrayIndexMask;
   return result;
 }
 
@@ skipping 16 matching lines @@
   }
 }
 
 
 uint32_t String::ComputeLengthAndHashField(unibrow::CharacterStream* buffer,
                                            int length) {
   StringHasher hasher(length);
 
   // Very long strings have a trivial hash that doesn't inspect the
   // string contents.
-  if (hasher.has_trivial_hash())
+  if (hasher.has_trivial_hash()) {
     return hasher.GetHashField();
+  }
 
   // Do the iterative array index computation as long as there is a
   // chance this is an array index.
-  while (buffer->has_more() && hasher.is_array_index())
+  while (buffer->has_more() && hasher.is_array_index()) {
     hasher.AddCharacter(buffer->GetNext());
+  }
 
   // Process the remaining characters without updating the array
   // index.
-  while (buffer->has_more())
+  while (buffer->has_more()) {
     hasher.AddCharacterNoIndex(buffer->GetNext());
+  }
 
   return hasher.GetHashField();
 }
 
 
 Object* String::Slice(int start, int end) {
   if (start == 0 && end == length()) return this;
   int representation = representation_tag();
   if (representation == kSlicedStringTag) {
     // Translate slices of a SlicedString into slices of the
@@ skipping 2570 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal