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

src/objects-inl.h

 // 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 19 matching lines @@
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
 
 #ifndef V8_OBJECTS_INL_H_
 #define V8_OBJECTS_INL_H_
 
 #include "elements.h"
 #include "objects.h"
+#include "char-predicates-inl.h"
 #include "contexts.h"
 #include "conversions-inl.h"
 #include "heap.h"
 #include "isolate.h"
 #include "property.h"
 #include "spaces.h"
 #include "store-buffer.h"
 #include "v8memory.h"
 
 #include "incremental-marking.h"
@@ skipping 4037 matching lines @@
   // Slow case: compute hash code and set it.
   return ComputeAndSetHash();
 }
 
 
 StringHasher::StringHasher(int length)
   : length_(length),
     raw_running_hash_(0),
     array_index_(0),
     is_array_index_(0 < length_ && length_ <= String::kMaxArrayIndexSize),
-    is_first_char_(true),
     is_valid_(true) { }
 
 
 bool StringHasher::has_trivial_hash() {
   return length_ > String::kMaxHashCalcLength;
 }
 
 
 void StringHasher::AddCharacter(uc32 c) {
   // Use the Jenkins one-at-a-time hash function to update the hash
   // for the given character.
-  raw_running_hash_ += c;
-  raw_running_hash_ += (raw_running_hash_ << 10);
+  raw_running_hash_ = (raw_running_hash_ + c) * 1025;
   raw_running_hash_ ^= (raw_running_hash_ >> 6);
   // Incremental array index computation.
-  if (is_array_index_) {
-    if (c < '0' || c > '9') {
+  ASSERT(is_array_index_);

[Rico, 2011/09/23 07:06:52]

I think the name of this function is not descriptive anymore when this is the
case? Additionally, why no just have this method and call AddCharacterNoIndex if
is_array_index_ is false? This will make the code using this easier to read

[Lasse Reichstein, 2011/09/23 09:54:39]

I'll change this back to be an if. The *NoIndex function will be called in
almost all cases anyway, so it's better to be readable than fast here.

+  unsigned digit = static_cast<unsigned>(c) - '0';
+  if (digit > 9 || array_index_ > 429496729U - ((digit + 2) >> 3)) {
+    is_array_index_ = false;
+  } else {
+    array_index_ = array_index_ * 10 + digit;
+    // Check for overflows or prefixed zeros (lengths > 0).
+    if (array_index_ == 0 && length_ > 1) {
       is_array_index_ = false;
-    } else {
-      int d = c - '0';
-      if (is_first_char_) {
-        is_first_char_ = false;
-        if (c == '0' && length_ > 1) {
-          is_array_index_ = false;
-          return;
-        }
-      }
-      if (array_index_ > 429496729U - ((d + 2) >> 3)) {
-        is_array_index_ = false;
-      } else {
-        array_index_ = array_index_ * 10 + d;
-      }
     }
   }
 }
 
 
 void StringHasher::AddCharacterNoIndex(uc32 c) {
   ASSERT(!is_array_index());
-  raw_running_hash_ += c;
-  raw_running_hash_ += (raw_running_hash_ << 10);
+  raw_running_hash_ = (raw_running_hash_ + c) * 1025;
   raw_running_hash_ ^= (raw_running_hash_ >> 6);
 }
 
 
 uint32_t StringHasher::GetHash() {
   // Get the calculated raw hash value and do some more bit ops to distribute
   // the hash further. Ensure that we never return zero as the hash value.
   uint32_t result = raw_running_hash_;
   result += (result << 3);
   result ^= (result >> 11);
@@ skipping 392 matching lines @@
 #undef WRITE_INT_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_