Various API changes

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 3701 matching lines @@
       return false;
   }
   return true;
 }
 
 
 // Compares the contents of two strings by reading and comparing
 // int-sized blocks of characters.
 template <typename Char>
 static inline bool CompareRawStringContents(Vector<Char> a, Vector<Char> b) {
-  // Lint complains about taking sizeof a type rather than a variable.
-  // That's just stupid in this case so I'm turning it off.
-  const int kStepSize = sizeof(int) / sizeof(Char);  // NOLINT
   int length = a.length();
   ASSERT_EQ(length, b.length());
-  int endpoint = length - kStepSize;
   const Char* pa = a.start();
   const Char* pb = b.start();
+  int i = 0;
 #ifndef CAN_READ_UNALIGNED
   // If this architecture isn't comfortable reading unaligned ints
-  // then we have to check that the strings are alingned and fall back
-  // to the standard comparison if they are not.
+  // then we have to check that the strings are aligned before
+  // comparing them blockwise.
   const int kAlignmentMask = sizeof(uint32_t) - 1;  // NOLINT
   uint32_t pa_addr = reinterpret_cast<uint32_t>(pa);
   uint32_t pb_addr = reinterpret_cast<uint32_t>(pb);
-  if ((pa_addr & kAlignmentMask) | (pb_addr & kAlignmentMask) != 0) {
-    VectorIterator<Char> ia(a);
-    VectorIterator<Char> ib(b);
-    return CompareStringContents(&ia, &ib);
+  if ((pa_addr & kAlignmentMask) | (pb_addr & kAlignmentMask) == 0) {
+#endif
+    const int kStepSize = sizeof(int) / sizeof(Char);  // NOLINT
+    int endpoint = length - kStepSize;
+    // Compare blocks until we reach near the end of the string.
+    for (; i <= endpoint; i += kStepSize) {
+      uint32_t wa = *reinterpret_cast<const uint32_t*>(pa + i);
+      uint32_t wb = *reinterpret_cast<const uint32_t*>(pb + i);
+      if (wa != wb) {
+        return false;
+      }
+    }
+#ifndef CAN_READ_UNALIGNED
   }
 #endif
-  int i;
-  // Compare blocks until we reach near the end of the string.
-  for (i = 0; i <= endpoint; i += kStepSize) {
-    uint32_t wa = *reinterpret_cast<const uint32_t*>(pa + i);
-    uint32_t wb = *reinterpret_cast<const uint32_t*>(pb + i);
-    if (wa != wb) {
-      return false;
-    }
-  }
   // Compare the remaining characters that didn't fit into a block.
   for (; i < length; i++) {
     if (a[i] != b[i]) {
       return false;
     }
   }
   return true;
 }
 
 
@@ skipping 2880 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