Fixed bug 114

src/runtime.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 2114 matching lines @@
 
   // Convert all characters to upper case, assuming that they will fit
   // in the buffer
   Access<StringInputBuffer> buffer(&string_input_buffer);
   buffer->Reset(s);
   unibrow::uchar chars[unibrow::kMaxCaseConvertedSize];
   int i = 0;
   // We can assume that the string is not empty
   uc32 current = buffer->GetNext();
   while (i < length) {
-    uc32 next = buffer->has_more() ? buffer->GetNext() : 0;
+    bool has_next = buffer->has_more();
+    uc32 next = has_next ? buffer->GetNext() : 0;
     int char_length = mapping->get(current, next, chars);
     if (char_length == 0) {
       // The case conversion of this character is the character itself.
       result->Set(i, current);
       i++;
     } else if (char_length == 1) {
       // Common case: converting the letter resulted in one character.
       ASSERT(static_cast<uc32>(chars[0]) != current);
       result->Set(i, chars[0]);
       has_changed_character = true;
       i++;
     } else if (length == raw_string_length) {
       // We've assumed that the result would be as long as the
       // input but here is a character that converts to several
       // characters.  No matter, we calculate the exact length
       // of the result and try the whole thing again.
       //
       // Note that this leaves room for optimization.  We could just
       // memcpy what we already have to the result string.  Also,
       // the result string is the last object allocated we could
       // "realloc" it and probably, in the vast majority of cases,
       // extend the existing string to be able to hold the full
       // result.
-      int current_length = i + char_length + mapping->get(next, 0, chars);
+      int next_length = 0;
+      if (has_next) {
+        next_length = mapping->get(next, 0, chars);

[Erik Corry, 2008/10/14 09:01:53]

Missing comment here to explain why 0 is OK.

+        if (next_length == 0) next_length = 1;
+      }
+      int current_length = i + char_length + next_length;
       while (buffer->has_more()) {
         current = buffer->GetNext();
         int char_length = mapping->get(current, 0, chars);
         if (char_length == 0) char_length = 1;
-        current += char_length;
+        current_length += char_length;
       }
       length = current_length;
       goto try_convert;
     } else {
       for (int j = 0; j < char_length; j++) {
         result->Set(i, chars[j]);
         i++;
       }
       has_changed_character = true;
     }
@@ skipping 3047 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   // Try to do a garbage collection; ignore it if it fails. The C
   // entry stub will throw an out-of-memory exception in that case.
   Heap::CollectGarbage(failure->requested(), failure->allocation_space());
 }
 
 
 } }  // namespace v8::internal