Added ability to lock strings to prevent their representation or encoding from changing.

src/objects.cc

 // 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 2570 matching lines @@
   if (IsJSGlobalProxy()) {
     Object* proto = GetPrototype();
     if (proto->IsNull()) return value;
     ASSERT(proto->IsJSGlobalObject());
     return JSObject::cast(proto)->SetLocalPropertyIgnoreAttributes(
         name,
         value,
         attributes);
   }
 
-  // Check for accessor in prototype chain removed here in clone.
+  // Unlike SetLocalProperty, we ignore the prototype chain and
+  // any accessors in it.
   if (!result.IsFound()) {
     // Neither properties nor transitions found.
     return AddProperty(name, value, attributes, kNonStrictMode);
   }
 
   PropertyDetails details = PropertyDetails(attributes, NORMAL);
 
   // Check of IsReadOnly removed from here in clone.
   switch (result.type()) {
     case NORMAL:
@@ skipping 7095 matching lines @@
  public:
   explicit SubStringAsciiSymbolKey(Handle<SeqAsciiString> string,
                                    int from,
                                    int length)
       : string_(string), from_(from), length_(length) { }
 
   uint32_t Hash() {
     ASSERT(length_ >= 0);
     ASSERT(from_ + length_ <= string_->length());
     StringHasher hasher(length_);
+    AssertNoAllocation no_alloc;
+    const char* chars = string_->GetChars() + from_;
 
     // Very long strings have a trivial hash that doesn't inspect the
     // string contents.
     if (hasher.has_trivial_hash()) {
       hash_field_ = hasher.GetHashField();
     } else {
       int i = 0;
       // Do the iterative array index computation as long as there is a
       // chance this is an array index.
       while (i < length_ && hasher.is_array_index()) {
-        hasher.AddCharacter(static_cast<uc32>(
-            string_->SeqAsciiStringGet(i + from_)));
+        hasher.AddCharacter(static_cast<uc32>(chars[i]));
         i++;
       }
 
       // Process the remaining characters without updating the array
       // index.
       while (i < length_) {
-        hasher.AddCharacterNoIndex(static_cast<uc32>(
-            string_->SeqAsciiStringGet(i + from_)));
+        hasher.AddCharacterNoIndex(static_cast<uc32>(chars[i]));
         i++;
       }
       hash_field_ = hasher.GetHashField();
     }
 
     uint32_t result = hash_field_ >> String::kHashShift;
     ASSERT(result != 0);  // Ensure that the hash value of 0 is never computed.
     return result;
   }
 
@@ skipping 806 matching lines @@
     hash += hash << 10;
     hash ^= hash >> 6;
     // GetHash.
     hash += hash << 3;
     hash ^= hash >> 11;
     hash += hash << 15;
     if (hash == 0) hash = 27;
 #ifdef DEBUG
     StringHasher hasher(2);
     hasher.AddCharacter(c1);
-    hasher.AddCharacter(c2);
+    if (hasher.is_array_index()) {
+      hasher.AddCharacter(c2);
+    } else {
+      hasher.AddCharacterNoIndex(c2);
+    }
     // If this assert fails then we failed to reproduce the two-character
     // version of the string hashing algorithm above.  One reason could be
     // that we were passed two digits as characters, since the hash
     // algorithm is different in that case.
     ASSERT_EQ(static_cast<int>(hasher.GetHash()), static_cast<int>(hash));
 #endif
     hash_ = hash;
   }
 
   bool IsMatch(Object* o) {
@@ skipping 1088 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal