Continues Latin-1 support. All tests pass with ENABLE_LATIN_1 flag.

src/json-stringifier.h

 // Copyright 2012 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 42 matching lines @@
   void ChangeEncoding();
 
   void ShrinkCurrentPart();
 
   template <bool is_ascii, typename Char>
   INLINE(void Append_(Char c));
 
   template <bool is_ascii, typename Char>
   INLINE(void Append_(const Char* chars));
 
-  INLINE(void Append(char c)) {
+  INLINE(void Append(uint8_t c)) {
     if (is_ascii_) {
       Append_<true>(c);
     } else {
       Append_<false>(c);
     }
   }
 
-  INLINE(void Append(const char* chars)) {
+  INLINE(void AppendAscii(const char* chars)) {
     if (is_ascii_) {
-      Append_<true>(chars);
+      Append_<true>(reinterpret_cast<const uint8_t*>(chars));
     } else {
-      Append_<false>(chars);
+      Append_<false>(reinterpret_cast<const uint8_t*>(chars));
     }
   }
 
   Handle<Object> ApplyToJsonFunction(Handle<Object> object,
                                      Handle<Object> key);
 
   Result SerializeGeneric(Handle<Object> object,
                           Handle<Object> key,
                           bool deferred_comma,
                           bool deferred_key);
@@ skipping 234 matching lines @@
   }
 
   switch (HeapObject::cast(*object)->map()->instance_type()) {
     case HEAP_NUMBER_TYPE:
       if (deferred_string_key) SerializeDeferredKey(comma, key);
       return SerializeHeapNumber(Handle<HeapNumber>::cast(object));
     case ODDBALL_TYPE:
       switch (Oddball::cast(*object)->kind()) {
         case Oddball::kFalse:
           if (deferred_string_key) SerializeDeferredKey(comma, key);
-          Append("false");
+          AppendAscii("false");
           return SUCCESS;
         case Oddball::kTrue:
           if (deferred_string_key) SerializeDeferredKey(comma, key);
-          Append("true");
+          AppendAscii("true");
           return SUCCESS;
         case Oddball::kNull:
           if (deferred_string_key) SerializeDeferredKey(comma, key);
-          Append("null");
+          AppendAscii("null");
           return SUCCESS;
         default:
           return UNCHANGED;
       }
     case JS_ARRAY_TYPE:
       if (deferred_string_key) SerializeDeferredKey(comma, key);
       return SerializeJSArray(Handle<JSArray>::cast(object));
     case JS_VALUE_TYPE:
       if (deferred_string_key) SerializeDeferredKey(comma, key);
       return SerializeJSValue(Handle<JSValue>::cast(object));
@@ skipping 56 matching lines @@
     SerializeString(Handle<String>::cast(value));
   } else if (class_name == isolate_->heap()->Number_symbol()) {
     Handle<Object> value = Execution::ToNumber(object, &has_exception);
     if (has_exception) return EXCEPTION;
     if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
     SerializeHeapNumber(Handle<HeapNumber>::cast(value));
   } else {
     ASSERT(class_name == isolate_->heap()->Boolean_symbol());
     Object* value = JSValue::cast(*object)->value();
     ASSERT(value->IsBoolean());
-    Append(value->IsTrue() ? "true" : "false");
+    AppendAscii(value->IsTrue() ? "true" : "false");
   }
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) {
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
-  Append(IntToCString(object->value(), buffer));
+  AppendAscii(IntToCString(object->value(), buffer));
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble(
     double number) {
   if (isinf(number) || isnan(number)) {
-    Append("null");
+    AppendAscii("null");
     return SUCCESS;
   }
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
-  Append(DoubleToCString(number, buffer));
+  AppendAscii(DoubleToCString(number, buffer));
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray(
     Handle<JSArray> object) {
   HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   int length = Smi::cast(object->length())->value();
@@ skipping 19 matching lines @@
     }
     case FAST_ELEMENTS: {
       Handle<FixedArray> elements(
           FixedArray::cast(object->elements()), isolate_);
       for (int i = 0; i < length; i++) {
         if (i > 0) Append(',');
         Result result =
             SerializeElement(Handle<Object>(elements->get(i), isolate_), i);
         if (result == SUCCESS) continue;
         if (result == UNCHANGED) {
-          Append("null");
+          AppendAscii("null");
         } else {
           return result;
         }
       }
       break;
     }
     // TODO(yangguo):  The FAST_HOLEY_* cases could be handled in a faster way.
     // They resemble the non-holey cases except that a prototype chain lookup
     // is necessary for holes.
     default: {
       Result result = SerializeJSArraySlow(object, length);
       if (result != SUCCESS) return result;
       break;
     }
   }
   Append(']');
   StackPop();
   current_part_ = handle_scope.CloseAndEscape(current_part_);
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArraySlow(
     Handle<JSArray> object, int length) {
   for (int i = 0; i < length; i++) {
     if (i > 0) Append(',');
     Handle<Object> element = Object::GetElement(object, i);
     if (element->IsUndefined()) {
-      Append("null");
+      AppendAscii("null");
     } else {
       Result result = SerializeElement(element, i);
       if (result == SUCCESS) continue;
       if (result == UNCHANGED) {
-        Append("null");
+        AppendAscii("null");
       } else {
         return result;
       }
     }
   }
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject(
@@ skipping 151 matching lines @@
           length);
     }
   } else {
     String* string_location = *string;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = 0; i < length; i++) {
       Char c = vector[i];
       if (DoNotEscape(c)) {
         Append_<is_ascii, Char>(c);
       } else {
-        Append_<is_ascii, char>(
-            &JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
+        Append_<is_ascii, uint8_t>(
+            reinterpret_cast<const uint8_t*>(
+                &JsonEscapeTable[c * kJsonEscapeTableEntrySize]));
       }
       // If GC moved the string, we need to refresh the vector.
       if (*string != string_location) {
         vector = GetCharVector<Char>(string);
         string_location = *string;
       }
     }
   }
 
-  Append_<is_ascii, char>('"');
+  Append_<is_ascii, uint8_t>('"');
 }
 
 
-template <>
-bool BasicJsonStringifier::DoNotEscape(char c) {
-  return c >= '#' && c <= '~' && c != '\\';
-}
-
-
-template <>
-bool BasicJsonStringifier::DoNotEscape(uc16 c) {
+template <typename Char>
+bool BasicJsonStringifier::DoNotEscape(Char c) {
   return (c >= 0x80) || (c >= '#' && c <= '~' && c != '\\');
 }
 
 
 template <>
-Vector<const char> BasicJsonStringifier::GetCharVector(Handle<String> string) {
+Vector<const uint8_t> BasicJsonStringifier::GetCharVector(
+    Handle<String> string) {
   String::FlatContent flat = string->GetFlatContent();
   ASSERT(flat.IsAscii());
-  return flat.ToAsciiVector();
+  return flat.ToOneByteVector();
 }
 
 
 template <>
 Vector<const uc16> BasicJsonStringifier::GetCharVector(Handle<String> string) {
   String::FlatContent flat = string->GetFlatContent();
   ASSERT(flat.IsTwoByte());
   return flat.ToUC16Vector();
 }
 
 
 void BasicJsonStringifier::SerializeString(Handle<String> object) {
   FlattenString(object);
   String::FlatContent flat = object->GetFlatContent();
   if (is_ascii_) {
     if (flat.IsAscii()) {
-      SerializeString_<true, char>(object);
+      SerializeString_<true, uint8_t>(object);
     } else {
       ChangeEncoding();
       SerializeString(object);
     }
   } else {
     if (flat.IsAscii()) {
-      SerializeString_<false, char>(object);
+      SerializeString_<false, uint8_t>(object);
     } else {
       SerializeString_<false, uc16>(object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_