Return kBadChar for longest subpart of incomplete utf-8 character.

src/unicode.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file was generated at 2014-10-08 15:25:47.940335
 
 #include "src/unicode.h"
 #include "src/unicode-inl.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ skipping 210 matching lines @@
 
 
 static inline bool IsContinuationCharacter(byte chr) {
   return chr >= 0x80 && chr <= 0xBF;
 }
 
 
 // This method decodes an UTF-8 value according to RFC 3629.
 uchar Utf8::CalculateValue(const byte* str, size_t max_length, size_t* cursor) {
   size_t length = NonASCIISequenceLength(str[0]);
-  if (length == 0 || max_length < length) {
-    *cursor += 1;
+
+  // Check continuation characters.
+  size_t max_count = std::min(length, max_length);
+  size_t count = 1;
+  while (count < max_count && IsContinuationCharacter(str[count])) {
+    count++;
+  }
+
+  // Check overly long sequences & other conditions. Use length as error
+  // indicator.
+  if (length == 3) {
+    if (str[0] == 0xE0 && (str[1] < 0xA0 || str[1] > 0xBF)) {
+      // Overlong three-byte sequence?
+      length = 0;
+    } else if (str[0] == 0xED && (str[1] < 0x80 || str[1] > 0x9F)) {
+      // High and low surrogate halves?
+      length = 0;
+    }
+  } else if (length == 4) {
+    if (str[0] == 0xF0 && (str[1] < 0x90 || str[1] > 0xBF)) {
+      // Overlong four-byte sequence.
+      length = 0;
+    } else if (str[0] == 0xF4 && (str[1] < 0x80 || str[1] > 0x8F)) {
+      // Code points outside of the unicode range.
+      length = 0;
+    }
+  }
+
+  if (count != length) {
+    // All invalid encodings should land here.
+    *cursor += count;
     return kBadChar;
   }
-  if (length == 2) {
-    if (!IsContinuationCharacter(str[1])) {
-      *cursor += 1;
-      return kBadChar;
-    }
-    *cursor += 2;
-    return ((str[0] << 6) + str[1]) - 0x00003080;
+
+  // All errors have been handled, so we only have to assemble the result.
+  *cursor += length;
+  switch (length) {
+    case 1:
+      return str[0];
+    case 2:
+      return ((str[0] << 6) + str[1]) - 0x00003080;
+    case 3:
+      return ((str[0] << 12) + (str[1] << 6) + str[2]) - 0x000E2080;
+    case 4:
+      return ((str[0] << 18) + (str[1] << 12) + (str[2] << 6) + str[3]) -
+             0x03C82080;
   }
-  if (length == 3) {
-    switch (str[0]) {
-      case 0xE0:
-        // Overlong three-byte sequence.
-        if (str[1] < 0xA0 || str[1] > 0xBF) {
-          *cursor += 1;
-          return kBadChar;
-        }
-        break;
-      case 0xED:
-        // High and low surrogate halves.
-        if (str[1] < 0x80 || str[1] > 0x9F) {
-          *cursor += 1;
-          return kBadChar;
-        }
-        break;
-      default:
-        if (!IsContinuationCharacter(str[1])) {
-          *cursor += 1;
-          return kBadChar;
-        }
-    }
-    if (!IsContinuationCharacter(str[2])) {
-      *cursor += 1;
-      return kBadChar;
-    }
-    *cursor += 3;
-    return ((str[0] << 12) + (str[1] << 6) + str[2]) - 0x000E2080;
-  }
-  DCHECK(length == 4);
-  switch (str[0]) {
-    case 0xF0:
-      // Overlong four-byte sequence.
-      if (str[1] < 0x90 || str[1] > 0xBF) {
-        *cursor += 1;
-        return kBadChar;
-      }
-      break;
-    case 0xF4:
-      // Code points outside of the unicode range.
-      if (str[1] < 0x80 || str[1] > 0x8F) {
-        *cursor += 1;
-        return kBadChar;
-      }
-      break;
-    default:
-      if (!IsContinuationCharacter(str[1])) {
-        *cursor += 1;
-        return kBadChar;
-      }
-  }
-  if (!IsContinuationCharacter(str[2])) {
-    *cursor += 1;
-    return kBadChar;
-  }
-  if (!IsContinuationCharacter(str[3])) {
-    *cursor += 1;
-    return kBadChar;
-  }
-  *cursor += 4;
-  return ((str[0] << 18) + (str[1] << 12) + (str[2] << 6) + str[3]) -
-         0x03C82080;
+
+  UNREACHABLE();
+  return kBadChar;
 }
 
 uchar Utf8::ValueOfIncremental(byte next, Utf8IncrementalBuffer* buffer) {
   DCHECK_NOT_NULL(buffer);
 
   // The common case: 1-byte Utf8 (and no incomplete char in the buffer)
   if (V8_LIKELY(next <= kMaxOneByteChar && *buffer == 0)) {
     return static_cast<uchar>(next);
   }
 
   if (*buffer == 0) {
     // We're at the start of a new character.
     uint32_t kind = NonASCIISequenceLength(next);
     if (kind >= 2 && kind <= 4) {
       // Start of 2..4 byte character, and no buffer.
 
       // The mask for the lower bits depends on the kind, and is
       // 0x1F, 0x0F, 0x07 for kinds 2, 3, 4 respectively. We can get that
       // with one shift.
       uint8_t mask = 0x7f >> kind;
 
-      // Store the kind - 1 (i.e., remaining bytes) in the top byte, value
-      // in the bottom three.
-      *buffer = (kind - 1) << 24 | (next & mask);
+      // Store the kind in the top nibble, and kind - 1 (i.e., remaining bytes)
+      // in 2nd nibble, and the value  in the bottom three. The 2nd nibble is
+      // intended as a counter about how many bytes are still needed.
+      *buffer = kind << 28 | (kind - 1) << 24 | (next & mask);
       return kIncomplete;
     } else {
       // No buffer, and not the start of a 1-byte char (handled at the
       // beginning), and not the start of a 2..4 byte char? Bad char.
       *buffer = 0;
       return kBadChar;
     }
   } else if (*buffer <= 0xff) {
     // We have one unprocessed byte left (from the last else case in this if
     // statement).
     uchar previous = *buffer;
     *buffer = 0;
     uchar t = ValueOfIncremental(previous, buffer);
     if (t == kIncomplete) {
       // If we have an incomplete character, process both the previous and the
       // next byte at once.
       return ValueOfIncremental(next, buffer);
     } else {
       // Otherwise, process the previous byte and save the next byte for next
       // time.
       DCHECK_EQ(0, *buffer);
       *buffer = next;
       return t;
     }
   } else if (IsContinuationCharacter(next)) {
     // We're inside of a character, as described by buffer.
 
     // How many bytes (excluding this one) do we still expect?
-    uint8_t count = (*buffer >> 24) - 1;
+    uint8_t bytes_expected = *buffer >> 28;
+    uint8_t bytes_left = (*buffer >> 24) & 0x0f;
+    bytes_left--;
     // Update the value.
     uint32_t value = ((*buffer & 0xffffff) << 6) | (next & 0x3F);
-    if (count) {
-      *buffer = count << 24 | value;
+    if (bytes_left) {
+      *buffer = (bytes_expected << 28 | bytes_left << 24 | value);
       return kIncomplete;
     } else {
       *buffer = 0;
-      return value;
+      bool sequence_was_too_long = (bytes_expected == 2 && value < 0x80) ||
+                                   (bytes_expected == 3 && value < 0x800);
+      return sequence_was_too_long ? kBadChar : value;
     }
   } else {
     // Within a character, but not a continuation character? Then the
     // previous char was a bad char. But we need to save the current
     // one.
     *buffer = next;
     return kBadChar;
   }
 }
 
@@ skipping 3150 matching lines @@
              sizeof(MultiCharacterSpecialCase<1>)  // NOLINT
          +
          kCanonicalizationRangeMultiStrings1Size *
              sizeof(MultiCharacterSpecialCase<1>)  // NOLINT
          +
          kCanonicalizationRangeMultiStrings7Size *
              sizeof(MultiCharacterSpecialCase<1>);  // NOLINT
 }
 
 }  // namespace unibrow