Move const qualifies around to avoid GCC warnings. (GCC 4.3.2)...

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 3659 matching lines @@
 }
 
 
 static StringInputBuffer string_compare_buffer_b;
 
 
 template <typename IteratorA>
 static inline bool CompareStringContentsPartial(IteratorA* ia, String* b) {
   if (b->IsFlat()) {
     if (b->IsAsciiRepresentation()) {
-      VectorIterator<const char> ib(b->ToAsciiVector());
+      VectorIterator<char> ib(b->ToAsciiVector());
       return CompareStringContents(ia, &ib);
     } else {
-      VectorIterator<const uc16> ib(b->ToUC16Vector());
+      VectorIterator<uc16> ib(b->ToUC16Vector());
       return CompareStringContents(ia, &ib);
     }
   } else {
     string_compare_buffer_b.Reset(0, b);
     return CompareStringContents(ia, &string_compare_buffer_b);
   }
 }
 
 
 static StringInputBuffer string_compare_buffer_a;
 
 
 bool String::SlowEquals(String* other) {
   // Fast check: negative check with lengths.
   int len = length();
   if (len != other->length()) return false;
   if (len == 0) return true;
 
   // Fast check: if hash code is computed for both strings
   // a fast negative check can be performed.
   if (HasHashCode() && other->HasHashCode()) {
     if (Hash() != other->Hash()) return false;
   }
 
   if (this->IsFlat()) {
     if (this->IsAsciiRepresentation()) {
-      VectorIterator<const char> buf1(this->ToAsciiVector());
+      VectorIterator<char> buf1(this->ToAsciiVector());
       return CompareStringContentsPartial(&buf1, other);
     } else {
-      VectorIterator<const uc16> buf1(this->ToUC16Vector());
+      VectorIterator<uc16> buf1(this->ToUC16Vector());
       return CompareStringContentsPartial(&buf1, other);
     }
   } else {
     string_compare_buffer_a.Reset(0, this);
     return CompareStringContentsPartial(&string_compare_buffer_a, other);
   }
 }
 
 
 bool String::MarkAsUndetectable() {
@@ skipping 2718 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