deps/v8/src/json-stringifier.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_JSON_STRINGIFIER_H_
   6 #define V8_JSON_STRINGIFIER_H_
   7
   8 #include "src/v8.h"
   9
  10 #include "src/conversions.h"
  11 #include "src/string-builder.h"
  12 #include "src/utils.h"
  13
  14 namespace v8 {
  15 namespace internal {
  16
  17 class BasicJsonStringifier BASE_EMBEDDED {
  18  public:
  19   explicit BasicJsonStringifier(Isolate* isolate);
  20
  21   MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object);
  22
  23   MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString(
  24       Isolate* isolate,
  25       Handle<String> object));
  26
  27  private:
  28   enum Result { UNCHANGED, SUCCESS, EXCEPTION };
  29
  30   MUST_USE_RESULT MaybeHandle<Object> ApplyToJsonFunction(
  31       Handle<Object> object,
  32       Handle<Object> key);
  33
  34   Result SerializeGeneric(Handle<Object> object,
  35                           Handle<Object> key,
  36                           bool deferred_comma,
  37                           bool deferred_key);
  38
  39   // Entry point to serialize the object.
  40   INLINE(Result SerializeObject(Handle<Object> obj)) {
  41     return Serialize_<false>(obj, false, factory()->empty_string());
  42   }
  43
  44   // Serialize an array element.
  45   // The index may serve as argument for the toJSON function.
  46   INLINE(Result SerializeElement(Isolate* isolate,
  47                                  Handle<Object> object,
  48                                  int i)) {
  49     return Serialize_<false>(object,
  50                              false,
  51                              Handle<Object>(Smi::FromInt(i), isolate));
  52   }
  53
  54   // Serialize a object property.
  55   // The key may or may not be serialized depending on the property.
  56   // The key may also serve as argument for the toJSON function.
  57   INLINE(Result SerializeProperty(Handle<Object> object,
  58                                   bool deferred_comma,
  59                                   Handle<String> deferred_key)) {
  60     DCHECK(!deferred_key.is_null());
  61     return Serialize_<true>(object, deferred_comma, deferred_key);
  62   }
  63
  64   template <bool deferred_string_key>
  65   Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key);
  66
  67   void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) {
  68     if (deferred_comma) builder_.AppendCharacter(',');
  69     SerializeString(Handle<String>::cast(deferred_key));
  70     builder_.AppendCharacter(':');
  71   }
  72
  73   Result SerializeSmi(Smi* object);
  74
  75   Result SerializeDouble(double number);
  76   INLINE(Result SerializeHeapNumber(Handle<HeapNumber> object)) {
  77     return SerializeDouble(object->value());
  78   }
  79
  80   Result SerializeJSValue(Handle<JSValue> object);
  81
  82   INLINE(Result SerializeJSArray(Handle<JSArray> object));
  83   INLINE(Result SerializeJSObject(Handle<JSObject> object));
  84
  85   Result SerializeJSArraySlow(Handle<JSArray> object, uint32_t length);
  86
  87   void SerializeString(Handle<String> object);
  88
  89   template <typename SrcChar, typename DestChar>
  90   INLINE(static void SerializeStringUnchecked_(
  91       Vector<const SrcChar> src,
  92       IncrementalStringBuilder::NoExtend<DestChar>* dest));
  93
  94   template <typename SrcChar, typename DestChar>
  95   INLINE(void SerializeString_(Handle<String> string));
  96
  97   template <typename Char>
  98   INLINE(static bool DoNotEscape(Char c));
  99
 100   Result StackPush(Handle<Object> object);
 101   void StackPop();
 102
 103   Factory* factory() { return isolate_->factory(); }
 104
 105   Isolate* isolate_;
 106   IncrementalStringBuilder builder_;
 107   Handle<String> tojson_string_;
 108   Handle<JSArray> stack_;
 109
 110   static const int kJsonEscapeTableEntrySize = 8;
 111   static const char* const JsonEscapeTable;
 112 };
 113
 114
 115 // Translation table to escape Latin1 characters.
 116 // Table entries start at a multiple of 8 and are null-terminated.
 117 const char* const BasicJsonStringifier::JsonEscapeTable =
 118     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
 119     "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 "
 120     "\\b\0     \\t\0     \\n\0     \\u000b\0 "
 121     "\\f\0     \\r\0     \\u000e\0 \\u000f\0 "
 122     "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 "
 123     "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 "
 124     "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 "
 125     "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 "
 126     " \0      !\0      \\\"\0     #\0      "
 127     "$\0      %\0      &\0      '\0      "
 128     "(\0      )\0      *\0      +\0      "
 129     ",\0      -\0      .\0      /\0      "
 130     "0\0      1\0      2\0      3\0      "
 131     "4\0      5\0      6\0      7\0      "
 132     "8\0      9\0      :\0      ;\0      "
 133     "<\0      =\0      >\0      ?\0      "
 134     "@\0      A\0      B\0      C\0      "
 135     "D\0      E\0      F\0      G\0      "
 136     "H\0      I\0      J\0      K\0      "
 137     "L\0      M\0      N\0      O\0      "
 138     "P\0      Q\0      R\0      S\0      "
 139     "T\0      U\0      V\0      W\0      "
 140     "X\0      Y\0      Z\0      [\0      "
 141     "\\\\\0     ]\0      ^\0      _\0      "
 142     "`\0      a\0      b\0      c\0      "
 143     "d\0      e\0      f\0      g\0      "
 144     "h\0      i\0      j\0      k\0      "
 145     "l\0      m\0      n\0      o\0      "
 146     "p\0      q\0      r\0      s\0      "
 147     "t\0      u\0      v\0      w\0      "
 148     "x\0      y\0      z\0      {\0      "
 149     "|\0      }\0      ~\0      \177\0      "
 150     "\200\0      \201\0      \202\0      \203\0      "
 151     "\204\0      \205\0      \206\0      \207\0      "
 152     "\210\0      \211\0      \212\0      \213\0      "
 153     "\214\0      \215\0      \216\0      \217\0      "
 154     "\220\0      \221\0      \222\0      \223\0      "
 155     "\224\0      \225\0      \226\0      \227\0      "
 156     "\230\0      \231\0      \232\0      \233\0      "
 157     "\234\0      \235\0      \236\0      \237\0      "
 158     "\240\0      \241\0      \242\0      \243\0      "
 159     "\244\0      \245\0      \246\0      \247\0      "
 160     "\250\0      \251\0      \252\0      \253\0      "
 161     "\254\0      \255\0      \256\0      \257\0      "
 162     "\260\0      \261\0      \262\0      \263\0      "
 163     "\264\0      \265\0      \266\0      \267\0      "
 164     "\270\0      \271\0      \272\0      \273\0      "
 165     "\274\0      \275\0      \276\0      \277\0      "
 166     "\300\0      \301\0      \302\0      \303\0      "
 167     "\304\0      \305\0      \306\0      \307\0      "
 168     "\310\0      \311\0      \312\0      \313\0      "
 169     "\314\0      \315\0      \316\0      \317\0      "
 170     "\320\0      \321\0      \322\0      \323\0      "
 171     "\324\0      \325\0      \326\0      \327\0      "
 172     "\330\0      \331\0      \332\0      \333\0      "
 173     "\334\0      \335\0      \336\0      \337\0      "
 174     "\340\0      \341\0      \342\0      \343\0      "
 175     "\344\0      \345\0      \346\0      \347\0      "
 176     "\350\0      \351\0      \352\0      \353\0      "
 177     "\354\0      \355\0      \356\0      \357\0      "
 178     "\360\0      \361\0      \362\0      \363\0      "
 179     "\364\0      \365\0      \366\0      \367\0      "
 180     "\370\0      \371\0      \372\0      \373\0      "
 181     "\374\0      \375\0      \376\0      \377\0      ";
 182
 183
 184 BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
 185     : isolate_(isolate), builder_(isolate) {
 186   tojson_string_ = factory()->toJSON_string();
 187   stack_ = factory()->NewJSArray(8);
 188 }
 189
 190
 191 MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object) {
 192   Result result = SerializeObject(object);
 193   if (result == UNCHANGED) return factory()->undefined_value();
 194   if (result == SUCCESS) return builder_.Finish();
 195   DCHECK(result == EXCEPTION);
 196   return MaybeHandle<Object>();
 197 }
 198
 199
 200 MaybeHandle<Object> BasicJsonStringifier::StringifyString(
 201     Isolate* isolate,  Handle<String> object) {
 202   static const int kJsonQuoteWorstCaseBlowup = 6;
 203   static const int kSpaceForQuotes = 2;
 204   int worst_case_length =
 205       object->length() * kJsonQuoteWorstCaseBlowup + kSpaceForQuotes;
 206
 207   if (worst_case_length > 32 * KB) {  // Slow path if too large.
 208     BasicJsonStringifier stringifier(isolate);
 209     return stringifier.Stringify(object);
 210   }
 211
 212   object = String::Flatten(object);
 213   DCHECK(object->IsFlat());
 214   Handle<SeqString> result;
 215   if (object->IsOneByteRepresentationUnderneath()) {
 216     result = isolate->factory()
 217                  ->NewRawOneByteString(worst_case_length)
 218                  .ToHandleChecked();
 219     IncrementalStringBuilder::NoExtendString<uint8_t> no_extend(
 220         result, worst_case_length);
 221     no_extend.Append('\"');
 222     SerializeStringUnchecked_(object->GetFlatContent().ToOneByteVector(),
 223                               &no_extend);
 224     no_extend.Append('\"');
 225   } else {
 226     result = isolate->factory()
 227                  ->NewRawTwoByteString(worst_case_length)
 228                  .ToHandleChecked();
 229     IncrementalStringBuilder::NoExtendString<uc16> no_extend(result,
 230                                                              worst_case_length);
 231     no_extend.Append('\"');
 232     SerializeStringUnchecked_(object->GetFlatContent().ToUC16Vector(),
 233                               &no_extend);
 234     no_extend.Append('\"');
 235   }
 236   return result;
 237 }
 238
 239
 240 MaybeHandle<Object> BasicJsonStringifier::ApplyToJsonFunction(
 241     Handle<Object> object, Handle<Object> key) {
 242   LookupIterator it(object, tojson_string_,
 243                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
 244   Handle<Object> fun;
 245   ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object);
 246   if (!fun->IsJSFunction()) return object;
 247
 248   // Call toJSON function.
 249   if (key->IsSmi()) key = factory()->NumberToString(key);
 250   Handle<Object> argv[] = { key };
 251   HandleScope scope(isolate_);
 252   ASSIGN_RETURN_ON_EXCEPTION(
 253       isolate_, object,
 254       Execution::Call(isolate_, fun, object, 1, argv),
 255       Object);
 256   return scope.CloseAndEscape(object);
 257 }
 258
 259
 260 BasicJsonStringifier::Result BasicJsonStringifier::StackPush(
 261     Handle<Object> object) {
 262   StackLimitCheck check(isolate_);
 263   if (check.HasOverflowed()) {
 264     isolate_->StackOverflow();
 265     return EXCEPTION;
 266   }
 267
 268   int length = Smi::cast(stack_->length())->value();
 269   {
 270     DisallowHeapAllocation no_allocation;
 271     FixedArray* elements = FixedArray::cast(stack_->elements());
 272     for (int i = 0; i < length; i++) {
 273       if (elements->get(i) == *object) {
 274         AllowHeapAllocation allow_to_return_error;
 275         Handle<Object> error;
 276         MaybeHandle<Object> maybe_error = factory()->NewTypeError(
 277             "circular_structure", HandleVector<Object>(NULL, 0));
 278         if (maybe_error.ToHandle(&error)) isolate_->Throw(*error);
 279         return EXCEPTION;
 280       }
 281     }
 282   }
 283   JSArray::EnsureSize(stack_, length + 1);
 284   FixedArray::cast(stack_->elements())->set(length, *object);
 285   stack_->set_length(Smi::FromInt(length + 1));
 286   return SUCCESS;
 287 }
 288
 289
 290 void BasicJsonStringifier::StackPop() {
 291   int length = Smi::cast(stack_->length())->value();
 292   stack_->set_length(Smi::FromInt(length - 1));
 293 }
 294
 295
 296 template <bool deferred_string_key>
 297 BasicJsonStringifier::Result BasicJsonStringifier::Serialize_(
 298     Handle<Object> object, bool comma, Handle<Object> key) {
 299   if (object->IsJSObject()) {
 300     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 301         isolate_, object,
 302         ApplyToJsonFunction(object, key),
 303         EXCEPTION);
 304   }
 305
 306   if (object->IsSmi()) {
 307     if (deferred_string_key) SerializeDeferredKey(comma, key);
 308     return SerializeSmi(Smi::cast(*object));
 309   }
 310
 311   switch (HeapObject::cast(*object)->map()->instance_type()) {
 312     case HEAP_NUMBER_TYPE:
 313     case MUTABLE_HEAP_NUMBER_TYPE:
 314       if (deferred_string_key) SerializeDeferredKey(comma, key);
 315       return SerializeHeapNumber(Handle<HeapNumber>::cast(object));
 316     case ODDBALL_TYPE:
 317       switch (Oddball::cast(*object)->kind()) {
 318         case Oddball::kFalse:
 319           if (deferred_string_key) SerializeDeferredKey(comma, key);
 320           builder_.AppendCString("false");
 321           return SUCCESS;
 322         case Oddball::kTrue:
 323           if (deferred_string_key) SerializeDeferredKey(comma, key);
 324           builder_.AppendCString("true");
 325           return SUCCESS;
 326         case Oddball::kNull:
 327           if (deferred_string_key) SerializeDeferredKey(comma, key);
 328           builder_.AppendCString("null");
 329           return SUCCESS;
 330         default:
 331           return UNCHANGED;
 332       }
 333     case JS_ARRAY_TYPE:
 334       if (object->IsAccessCheckNeeded()) break;
 335       if (deferred_string_key) SerializeDeferredKey(comma, key);
 336       return SerializeJSArray(Handle<JSArray>::cast(object));
 337     case JS_VALUE_TYPE:
 338       if (deferred_string_key) SerializeDeferredKey(comma, key);
 339       return SerializeJSValue(Handle<JSValue>::cast(object));
 340     case JS_FUNCTION_TYPE:
 341       return UNCHANGED;
 342     default:
 343       if (object->IsString()) {
 344         if (deferred_string_key) SerializeDeferredKey(comma, key);
 345         SerializeString(Handle<String>::cast(object));
 346         return SUCCESS;
 347       } else if (object->IsJSObject()) {
 348         // Go to slow path for global proxy and objects requiring access checks.
 349         if (object->IsAccessCheckNeeded() || object->IsJSGlobalProxy()) break;
 350         if (deferred_string_key) SerializeDeferredKey(comma, key);
 351         return SerializeJSObject(Handle<JSObject>::cast(object));
 352       }
 353   }
 354
 355   return SerializeGeneric(object, key, comma, deferred_string_key);
 356 }
 357
 358
 359 BasicJsonStringifier::Result BasicJsonStringifier::SerializeGeneric(
 360     Handle<Object> object,
 361     Handle<Object> key,
 362     bool deferred_comma,
 363     bool deferred_key) {
 364   Handle<JSObject> builtins(isolate_->native_context()->builtins(), isolate_);
 365   Handle<JSFunction> builtin = Handle<JSFunction>::cast(Object::GetProperty(
 366       isolate_, builtins, "JSONSerializeAdapter").ToHandleChecked());
 367
 368   Handle<Object> argv[] = { key, object };
 369   Handle<Object> result;
 370   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 371       isolate_, result,
 372       Execution::Call(isolate_, builtin, object, 2, argv),
 373       EXCEPTION);
 374   if (result->IsUndefined()) return UNCHANGED;
 375   if (deferred_key) {
 376     if (key->IsSmi()) key = factory()->NumberToString(key);
 377     SerializeDeferredKey(deferred_comma, key);
 378   }
 379
 380   builder_.AppendString(Handle<String>::cast(result));
 381   return SUCCESS;
 382 }
 383
 384
 385 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue(
 386     Handle<JSValue> object) {
 387   String* class_name = object->class_name();
 388   if (class_name == isolate_->heap()->String_string()) {
 389     Handle<Object> value;
 390     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 391         isolate_, value, Execution::ToString(isolate_, object), EXCEPTION);
 392     SerializeString(Handle<String>::cast(value));
 393   } else if (class_name == isolate_->heap()->Number_string()) {
 394     Handle<Object> value;
 395     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 396         isolate_, value, Execution::ToNumber(isolate_, object), EXCEPTION);
 397     if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
 398     SerializeHeapNumber(Handle<HeapNumber>::cast(value));
 399   } else {
 400     DCHECK(class_name == isolate_->heap()->Boolean_string());
 401     Object* value = JSValue::cast(*object)->value();
 402     DCHECK(value->IsBoolean());
 403     builder_.AppendCString(value->IsTrue() ? "true" : "false");
 404   }
 405   return SUCCESS;
 406 }
 407
 408
 409 BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) {
 410   static const int kBufferSize = 100;
 411   char chars[kBufferSize];
 412   Vector<char> buffer(chars, kBufferSize);
 413   builder_.AppendCString(IntToCString(object->value(), buffer));
 414   return SUCCESS;
 415 }
 416
 417
 418 BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble(
 419     double number) {
 420   if (std::isinf(number) || std::isnan(number)) {
 421     builder_.AppendCString("null");
 422     return SUCCESS;
 423   }
 424   static const int kBufferSize = 100;
 425   char chars[kBufferSize];
 426   Vector<char> buffer(chars, kBufferSize);
 427   builder_.AppendCString(DoubleToCString(number, buffer));
 428   return SUCCESS;
 429 }
 430
 431
 432 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray(
 433     Handle<JSArray> object) {
 434   HandleScope handle_scope(isolate_);
 435   Result stack_push = StackPush(object);
 436   if (stack_push != SUCCESS) return stack_push;
 437   uint32_t length = 0;
 438   CHECK(object->length()->ToArrayIndex(&length));
 439   builder_.AppendCharacter('[');
 440   switch (object->GetElementsKind()) {
 441     case FAST_SMI_ELEMENTS: {
 442       Handle<FixedArray> elements(
 443           FixedArray::cast(object->elements()), isolate_);
 444       for (uint32_t i = 0; i < length; i++) {
 445         if (i > 0) builder_.AppendCharacter(',');
 446         SerializeSmi(Smi::cast(elements->get(i)));
 447       }
 448       break;
 449     }
 450     case FAST_DOUBLE_ELEMENTS: {
 451       // Empty array is FixedArray but not FixedDoubleArray.
 452       if (length == 0) break;
 453       Handle<FixedDoubleArray> elements(
 454           FixedDoubleArray::cast(object->elements()), isolate_);
 455       for (uint32_t i = 0; i < length; i++) {
 456         if (i > 0) builder_.AppendCharacter(',');
 457         SerializeDouble(elements->get_scalar(i));
 458       }
 459       break;
 460     }
 461     case FAST_ELEMENTS: {
 462       Handle<FixedArray> elements(
 463           FixedArray::cast(object->elements()), isolate_);
 464       for (uint32_t i = 0; i < length; i++) {
 465         if (i > 0) builder_.AppendCharacter(',');
 466         Result result =
 467             SerializeElement(isolate_,
 468                              Handle<Object>(elements->get(i), isolate_),
 469                              i);
 470         if (result == SUCCESS) continue;
 471         if (result == UNCHANGED) {
 472           builder_.AppendCString("null");
 473         } else {
 474           return result;
 475         }
 476       }
 477       break;
 478     }
 479     // TODO(yangguo):  The FAST_HOLEY_* cases could be handled in a faster way.
 480     // They resemble the non-holey cases except that a prototype chain lookup
 481     // is necessary for holes.
 482     default: {
 483       Result result = SerializeJSArraySlow(object, length);
 484       if (result != SUCCESS) return result;
 485       break;
 486     }
 487   }
 488   builder_.AppendCharacter(']');
 489   StackPop();
 490   return SUCCESS;
 491 }
 492
 493
 494 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArraySlow(
 495     Handle<JSArray> object, uint32_t length) {
 496   for (uint32_t i = 0; i < length; i++) {
 497     if (i > 0) builder_.AppendCharacter(',');
 498     Handle<Object> element;
 499     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 500         isolate_, element,
 501         Object::GetElement(isolate_, object, i),
 502         EXCEPTION);
 503     if (element->IsUndefined()) {
 504       builder_.AppendCString("null");
 505     } else {
 506       Result result = SerializeElement(isolate_, element, i);
 507       if (result == SUCCESS) continue;
 508       if (result == UNCHANGED) {
 509         builder_.AppendCString("null");
 510       } else {
 511         return result;
 512       }
 513     }
 514   }
 515   return SUCCESS;
 516 }
 517
 518
 519 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject(
 520     Handle<JSObject> object) {
 521   HandleScope handle_scope(isolate_);
 522   Result stack_push = StackPush(object);
 523   if (stack_push != SUCCESS) return stack_push;
 524   DCHECK(!object->IsJSGlobalProxy() && !object->IsGlobalObject());
 525
 526   builder_.AppendCharacter('{');
 527   bool comma = false;
 528
 529   if (object->HasFastProperties() &&
 530       !object->HasIndexedInterceptor() &&
 531       !object->HasNamedInterceptor() &&
 532       object->elements()->length() == 0) {
 533     Handle<Map> map(object->map());
 534     for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
 535       Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
 536       // TODO(rossberg): Should this throw?
 537       if (!name->IsString()) continue;
 538       Handle<String> key = Handle<String>::cast(name);
 539       PropertyDetails details = map->instance_descriptors()->GetDetails(i);
 540       if (details.IsDontEnum()) continue;
 541       Handle<Object> property;
 542       if (details.type() == DATA && *map == object->map()) {
 543         FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
 544         Isolate* isolate = object->GetIsolate();
 545         if (object->IsUnboxedDoubleField(field_index)) {
 546           double value = object->RawFastDoublePropertyAt(field_index);
 547           property = isolate->factory()->NewHeapNumber(value);
 548
 549         } else {
 550           property = handle(object->RawFastPropertyAt(field_index), isolate);
 551         }
 552       } else {
 553         ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 554             isolate_, property,
 555             Object::GetPropertyOrElement(object, key),
 556             EXCEPTION);
 557       }
 558       Result result = SerializeProperty(property, comma, key);
 559       if (!comma && result == SUCCESS) comma = true;
 560       if (result == EXCEPTION) return result;
 561     }
 562   } else {
 563     Handle<FixedArray> contents;
 564     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 565         isolate_, contents,
 566         JSReceiver::GetKeys(object, JSReceiver::OWN_ONLY),
 567         EXCEPTION);
 568
 569     for (int i = 0; i < contents->length(); i++) {
 570       Object* key = contents->get(i);
 571       Handle<String> key_handle;
 572       MaybeHandle<Object> maybe_property;
 573       if (key->IsString()) {
 574         key_handle = Handle<String>(String::cast(key), isolate_);
 575         maybe_property = Object::GetPropertyOrElement(object, key_handle);
 576       } else {
 577         DCHECK(key->IsNumber());
 578         key_handle = factory()->NumberToString(Handle<Object>(key, isolate_));
 579         uint32_t index;
 580         if (key->IsSmi()) {
 581           maybe_property = Object::GetElement(
 582               isolate_, object, Smi::cast(key)->value());
 583         } else if (key_handle->AsArrayIndex(&index)) {
 584           maybe_property = Object::GetElement(isolate_, object, index);
 585         } else {
 586           maybe_property = Object::GetPropertyOrElement(object, key_handle);
 587         }
 588       }
 589       Handle<Object> property;
 590       ASSIGN_RETURN_ON_EXCEPTION_VALUE(
 591           isolate_, property, maybe_property, EXCEPTION);
 592       Result result = SerializeProperty(property, comma, key_handle);
 593       if (!comma && result == SUCCESS) comma = true;
 594       if (result == EXCEPTION) return result;
 595     }
 596   }
 597
 598   builder_.AppendCharacter('}');
 599   StackPop();
 600   return SUCCESS;
 601 }
 602
 603
 604 template <typename SrcChar, typename DestChar>
 605 void BasicJsonStringifier::SerializeStringUnchecked_(
 606     Vector<const SrcChar> src,
 607     IncrementalStringBuilder::NoExtend<DestChar>* dest) {
 608   // Assert that uc16 character is not truncated down to 8 bit.
 609   // The <uc16, char> version of this method must not be called.
 610   DCHECK(sizeof(DestChar) >= sizeof(SrcChar));
 611
 612   for (int i = 0; i < src.length(); i++) {
 613     SrcChar c = src[i];
 614     if (DoNotEscape(c)) {
 615       dest->Append(c);
 616     } else {
 617       dest->AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
 618     }
 619   }
 620 }
 621
 622
 623 template <typename SrcChar, typename DestChar>
 624 void BasicJsonStringifier::SerializeString_(Handle<String> string) {
 625   int length = string->length();
 626   builder_.Append<uint8_t, DestChar>('"');
 627   // We make a rough estimate to find out if the current string can be
 628   // serialized without allocating a new string part. The worst case length of
 629   // an escaped character is 6.  Shifting the remainin string length right by 3
 630   // is a more pessimistic estimate, but faster to calculate.
 631   int worst_case_length = length << 3;
 632   if (builder_.CurrentPartCanFit(worst_case_length)) {
 633     DisallowHeapAllocation no_gc;
 634     Vector<const SrcChar> vector = string->GetCharVector<SrcChar>();
 635     IncrementalStringBuilder::NoExtendBuilder<DestChar> no_extend(
 636         &builder_, worst_case_length);
 637     SerializeStringUnchecked_(vector, &no_extend);
 638   } else {
 639     FlatStringReader reader(isolate_, string);
 640     for (int i = 0; i < reader.length(); i++) {
 641       SrcChar c = reader.Get<SrcChar>(i);
 642       if (DoNotEscape(c)) {
 643         builder_.Append<SrcChar, DestChar>(c);
 644       } else {
 645         builder_.AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
 646       }
 647     }
 648   }
 649
 650   builder_.Append<uint8_t, DestChar>('"');
 651 }
 652
 653
 654 template <>
 655 bool BasicJsonStringifier::DoNotEscape(uint8_t c) {
 656   return c >= '#' && c <= '~' && c != '\\';
 657 }
 658
 659
 660 template <>
 661 bool BasicJsonStringifier::DoNotEscape(uint16_t c) {
 662   return c >= '#' && c != '\\' && c != 0x7f;
 663 }
 664
 665
 666 void BasicJsonStringifier::SerializeString(Handle<String> object) {
 667   object = String::Flatten(object);
 668   if (builder_.CurrentEncoding() == String::ONE_BYTE_ENCODING) {
 669     if (object->IsOneByteRepresentationUnderneath()) {
 670       SerializeString_<uint8_t, uint8_t>(object);
 671     } else {
 672       builder_.ChangeEncoding();
 673       SerializeString(object);
 674     }
 675   } else {
 676     if (object->IsOneByteRepresentationUnderneath()) {
 677       SerializeString_<uint8_t, uc16>(object);
 678     } else {
 679       SerializeString_<uc16, uc16>(object);
 680     }
 681   }
 682 }
 683
 684 } }  // namespace v8::internal
 685
 686 #endif  // V8_JSON_STRINGIFIER_H_