LCOV - code coverage report
Current view: top level - src - json-stringifier.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 275 285 96.5 %
Date: 2017-04-26 Functions: 20 20 100.0 %

          Line data    Source code
       1             : // Copyright 2016 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             : #include "src/json-stringifier.h"
       6             : 
       7             : #include "src/conversions.h"
       8             : #include "src/lookup.h"
       9             : #include "src/messages.h"
      10             : #include "src/objects-inl.h"
      11             : #include "src/utils.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16             : // Translation table to escape Latin1 characters.
      17             : // Table entries start at a multiple of 8 and are null-terminated.
      18             : const char* const JsonStringifier::JsonEscapeTable =
      19             :     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
      20             :     "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 "
      21             :     "\\b\0     \\t\0     \\n\0     \\u000b\0 "
      22             :     "\\f\0     \\r\0     \\u000e\0 \\u000f\0 "
      23             :     "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 "
      24             :     "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 "
      25             :     "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 "
      26             :     "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 "
      27             :     " \0      !\0      \\\"\0     #\0      "
      28             :     "$\0      %\0      &\0      '\0      "
      29             :     "(\0      )\0      *\0      +\0      "
      30             :     ",\0      -\0      .\0      /\0      "
      31             :     "0\0      1\0      2\0      3\0      "
      32             :     "4\0      5\0      6\0      7\0      "
      33             :     "8\0      9\0      :\0      ;\0      "
      34             :     "<\0      =\0      >\0      ?\0      "
      35             :     "@\0      A\0      B\0      C\0      "
      36             :     "D\0      E\0      F\0      G\0      "
      37             :     "H\0      I\0      J\0      K\0      "
      38             :     "L\0      M\0      N\0      O\0      "
      39             :     "P\0      Q\0      R\0      S\0      "
      40             :     "T\0      U\0      V\0      W\0      "
      41             :     "X\0      Y\0      Z\0      [\0      "
      42             :     "\\\\\0     ]\0      ^\0      _\0      "
      43             :     "`\0      a\0      b\0      c\0      "
      44             :     "d\0      e\0      f\0      g\0      "
      45             :     "h\0      i\0      j\0      k\0      "
      46             :     "l\0      m\0      n\0      o\0      "
      47             :     "p\0      q\0      r\0      s\0      "
      48             :     "t\0      u\0      v\0      w\0      "
      49             :     "x\0      y\0      z\0      {\0      "
      50             :     "|\0      }\0      ~\0      \177\0      "
      51             :     "\200\0      \201\0      \202\0      \203\0      "
      52             :     "\204\0      \205\0      \206\0      \207\0      "
      53             :     "\210\0      \211\0      \212\0      \213\0      "
      54             :     "\214\0      \215\0      \216\0      \217\0      "
      55             :     "\220\0      \221\0      \222\0      \223\0      "
      56             :     "\224\0      \225\0      \226\0      \227\0      "
      57             :     "\230\0      \231\0      \232\0      \233\0      "
      58             :     "\234\0      \235\0      \236\0      \237\0      "
      59             :     "\240\0      \241\0      \242\0      \243\0      "
      60             :     "\244\0      \245\0      \246\0      \247\0      "
      61             :     "\250\0      \251\0      \252\0      \253\0      "
      62             :     "\254\0      \255\0      \256\0      \257\0      "
      63             :     "\260\0      \261\0      \262\0      \263\0      "
      64             :     "\264\0      \265\0      \266\0      \267\0      "
      65             :     "\270\0      \271\0      \272\0      \273\0      "
      66             :     "\274\0      \275\0      \276\0      \277\0      "
      67             :     "\300\0      \301\0      \302\0      \303\0      "
      68             :     "\304\0      \305\0      \306\0      \307\0      "
      69             :     "\310\0      \311\0      \312\0      \313\0      "
      70             :     "\314\0      \315\0      \316\0      \317\0      "
      71             :     "\320\0      \321\0      \322\0      \323\0      "
      72             :     "\324\0      \325\0      \326\0      \327\0      "
      73             :     "\330\0      \331\0      \332\0      \333\0      "
      74             :     "\334\0      \335\0      \336\0      \337\0      "
      75             :     "\340\0      \341\0      \342\0      \343\0      "
      76             :     "\344\0      \345\0      \346\0      \347\0      "
      77             :     "\350\0      \351\0      \352\0      \353\0      "
      78             :     "\354\0      \355\0      \356\0      \357\0      "
      79             :     "\360\0      \361\0      \362\0      \363\0      "
      80             :     "\364\0      \365\0      \366\0      \367\0      "
      81             :     "\370\0      \371\0      \372\0      \373\0      "
      82             :     "\374\0      \375\0      \376\0      \377\0      ";
      83             : 
      84     3471988 : JsonStringifier::JsonStringifier(Isolate* isolate)
      85     3471988 :     : isolate_(isolate), builder_(isolate), gap_(nullptr), indent_(0) {
      86     1735994 :   tojson_string_ = factory()->toJSON_string();
      87     1735994 :   stack_ = factory()->NewJSArray(8);
      88     1735994 : }
      89             : 
      90     1735994 : MaybeHandle<Object> JsonStringifier::Stringify(Handle<Object> object,
      91             :                                                Handle<Object> replacer,
      92         423 :                                                Handle<Object> gap) {
      93     1735994 :   if (!InitializeReplacer(replacer)) return MaybeHandle<Object>();
      94     3471960 :   if (!gap->IsUndefined(isolate_) && !InitializeGap(gap)) {
      95             :     return MaybeHandle<Object>();
      96             :   }
      97             :   Result result = SerializeObject(object);
      98     1735980 :   if (result == UNCHANGED) return factory()->undefined_value();
      99     3470846 :   if (result == SUCCESS) return builder_.Finish();
     100             :   DCHECK(result == EXCEPTION);
     101             :   return MaybeHandle<Object>();
     102             : }
     103             : 
     104     1736816 : bool JsonStringifier::InitializeReplacer(Handle<Object> replacer) {
     105             :   DCHECK(property_list_.is_null());
     106             :   DCHECK(replacer_function_.is_null());
     107     1735994 :   Maybe<bool> is_array = Object::IsArray(replacer);
     108     1735994 :   if (is_array.IsNothing()) return false;
     109     1735994 :   if (is_array.FromJust()) {
     110         476 :     HandleScope handle_scope(isolate_);
     111         476 :     Handle<OrderedHashSet> set = factory()->NewOrderedHashSet();
     112             :     Handle<Object> length_obj;
     113         952 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     114             :         isolate_, length_obj,
     115             :         Object::GetLengthFromArrayLike(isolate_, replacer), false);
     116             :     uint32_t length;
     117         462 :     if (!length_obj->ToUint32(&length)) length = kMaxUInt32;
     118        1501 :     for (uint32_t i = 0; i < length; i++) {
     119             :       Handle<Object> element;
     120             :       Handle<String> key;
     121        3002 :       ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     122             :           isolate_, element, Object::GetElement(isolate_, replacer, i), false);
     123        2719 :       if (element->IsNumber() || element->IsString()) {
     124        1554 :         ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     125             :             isolate_, key, Object::ToString(isolate_, element), false);
     126         724 :       } else if (element->IsJSValue()) {
     127          45 :         Handle<Object> value(Handle<JSValue>::cast(element)->value(), isolate_);
     128          60 :         if (value->IsNumber() || value->IsString()) {
     129          90 :           ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     130             :               isolate_, key, Object::ToString(isolate_, element), false);
     131             :         }
     132             :       }
     133        1501 :       if (key.is_null()) continue;
     134             :       // Object keys are internalized, so do it here.
     135         822 :       key = factory()->InternalizeString(key);
     136         822 :       set = OrderedHashSet::Add(set, key);
     137             :     }
     138             :     property_list_ = OrderedHashSet::ConvertToKeysArray(
     139         462 :         set, GetKeysConversion::kKeepNumbers);
     140         462 :     property_list_ = handle_scope.CloseAndEscape(property_list_);
     141     1735518 :   } else if (replacer->IsCallable()) {
     142        2636 :     replacer_function_ = Handle<JSReceiver>::cast(replacer);
     143             :   }
     144             :   return true;
     145             : }
     146             : 
     147      302636 : bool JsonStringifier::InitializeGap(Handle<Object> gap) {
     148             :   DCHECK_NULL(gap_);
     149      302636 :   HandleScope scope(isolate_);
     150      302636 :   if (gap->IsJSValue()) {
     151          45 :     Handle<Object> value(Handle<JSValue>::cast(gap)->value(), isolate_);
     152          45 :     if (value->IsString()) {
     153          60 :       ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap,
     154             :                                        Object::ToString(isolate_, gap), false);
     155          15 :     } else if (value->IsNumber()) {
     156          30 :       ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap, Object::ToNumber(gap),
     157             :                                        false);
     158             :     }
     159             :   }
     160             : 
     161      302636 :   if (gap->IsString()) {
     162             :     Handle<String> gap_string = Handle<String>::cast(gap);
     163        2268 :     if (gap_string->length() > 0) {
     164        4488 :       int gap_length = std::min(gap_string->length(), 10);
     165        2244 :       gap_ = NewArray<uc16>(gap_length + 1);
     166        2244 :       String::WriteToFlat(*gap_string, gap_, 0, gap_length);
     167        4626 :       for (int i = 0; i < gap_length; i++) {
     168        2397 :         if (gap_[i] > String::kMaxOneByteCharCode) {
     169          15 :           builder_.ChangeEncoding();
     170             :           break;
     171             :         }
     172             :       }
     173        2244 :       gap_[gap_length] = '\0';
     174             :     }
     175      300368 :   } else if (gap->IsNumber()) {
     176      300353 :     int num_value = DoubleToInt32(gap->Number());
     177      300353 :     if (num_value > 0) {
     178         318 :       int gap_length = std::min(num_value, 10);
     179         159 :       gap_ = NewArray<uc16>(gap_length + 1);
     180         159 :       for (int i = 0; i < gap_length; i++) gap_[i] = ' ';
     181         159 :       gap_[gap_length] = '\0';
     182             :     }
     183             :   }
     184             :   return true;
     185             : }
     186             : 
     187      556088 : MaybeHandle<Object> JsonStringifier::ApplyToJsonFunction(Handle<Object> object,
     188         371 :                                                          Handle<Object> key) {
     189      556088 :   HandleScope scope(isolate_);
     190             :   LookupIterator it(object, tojson_string_,
     191      556088 :                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
     192             :   Handle<Object> fun;
     193     1112176 :   ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object);
     194      556031 :   if (!fun->IsCallable()) return object;
     195             : 
     196             :   // Call toJSON function.
     197        1663 :   if (key->IsSmi()) key = factory()->NumberToString(key);
     198        1292 :   Handle<Object> argv[] = {key};
     199        2584 :   ASSIGN_RETURN_ON_EXCEPTION(isolate_, object,
     200             :                              Execution::Call(isolate_, fun, object, 1, argv),
     201             :                              Object);
     202        1262 :   return scope.CloseAndEscape(object);
     203             : }
     204             : 
     205     8171562 : MaybeHandle<Object> JsonStringifier::ApplyReplacerFunction(
     206             :     Handle<Object> value, Handle<Object> key, Handle<Object> initial_holder) {
     207     8171562 :   HandleScope scope(isolate_);
     208     8171562 :   if (key->IsSmi()) key = factory()->NumberToString(key);
     209     8171562 :   Handle<Object> argv[] = {key, value};
     210     8171562 :   Handle<JSReceiver> holder = CurrentHolder(value, initial_holder);
     211    16343124 :   ASSIGN_RETURN_ON_EXCEPTION(
     212             :       isolate_, value,
     213             :       Execution::Call(isolate_, replacer_function_, holder, 2, argv), Object);
     214     8171562 :   return scope.CloseAndEscape(value);
     215             : }
     216             : 
     217     8171562 : Handle<JSReceiver> JsonStringifier::CurrentHolder(
     218        5272 :     Handle<Object> value, Handle<Object> initial_holder) {
     219             :   int length = Smi::cast(stack_->length())->value();
     220     8171562 :   if (length == 0) {
     221             :     Handle<JSObject> holder =
     222        5272 :         factory()->NewJSObject(isolate_->object_function());
     223             :     JSObject::AddProperty(holder, factory()->empty_string(), initial_holder,
     224        2636 :                           NONE);
     225        2636 :     return holder;
     226             :   } else {
     227             :     FixedArray* elements = FixedArray::cast(stack_->elements());
     228             :     return Handle<JSReceiver>(JSReceiver::cast(elements->get(length - 1)),
     229    16337852 :                               isolate_);
     230             :   }
     231             : }
     232             : 
     233      550902 : JsonStringifier::Result JsonStringifier::StackPush(Handle<Object> object) {
     234      550801 :   StackLimitCheck check(isolate_);
     235      550801 :   if (check.HasOverflowed()) {
     236          30 :     isolate_->StackOverflow();
     237          30 :     return EXCEPTION;
     238             :   }
     239             : 
     240             :   int length = Smi::cast(stack_->length())->value();
     241             :   {
     242             :     DisallowHeapAllocation no_allocation;
     243             :     FixedArray* elements = FixedArray::cast(stack_->elements());
     244     5338644 :     for (int i = 0; i < length; i++) {
     245     4787974 :       if (elements->get(i) == *object) {
     246             :         AllowHeapAllocation allow_to_return_error;
     247             :         Handle<Object> error =
     248         101 :             factory()->NewTypeError(MessageTemplate::kCircularStructure);
     249         101 :         isolate_->Throw(*error);
     250             :         return EXCEPTION;
     251             :       }
     252             :     }
     253             :   }
     254      550670 :   JSArray::SetLength(stack_, length + 1);
     255      550670 :   FixedArray::cast(stack_->elements())->set(length, *object);
     256      550670 :   return SUCCESS;
     257             : }
     258             : 
     259      533837 : void JsonStringifier::StackPop() {
     260             :   int length = Smi::cast(stack_->length())->value();
     261      533837 :   stack_->set_length(Smi::FromInt(length - 1));
     262      533837 : }
     263             : 
     264             : template <bool deferred_string_key>
     265    19533400 : JsonStringifier::Result JsonStringifier::Serialize_(Handle<Object> object,
     266             :                                                     bool comma,
     267             :                                                     Handle<Object> key) {
     268    19533400 :   StackLimitCheck interrupt_check(isolate_);
     269    19533400 :   Handle<Object> initial_value = object;
     270    19533505 :   if (interrupt_check.InterruptRequested() &&
     271         105 :       isolate_->stack_guard()->HandleInterrupts()->IsException(isolate_)) {
     272             :     return EXCEPTION;
     273             :   }
     274    19533398 :   if (object->IsJSReceiver()) {
     275     1112176 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     276             :         isolate_, object, ApplyToJsonFunction(object, key), EXCEPTION);
     277             :   }
     278    19533311 :   if (!replacer_function_.is_null()) {
     279    16343124 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     280             :         isolate_, object, ApplyReplacerFunction(object, key, initial_value),
     281             :         EXCEPTION);
     282             :   }
     283             : 
     284    19533311 :   if (object->IsSmi()) {
     285             :     if (deferred_string_key) SerializeDeferredKey(comma, key);
     286      266481 :     return SerializeSmi(Smi::cast(*object));
     287             :   }
     288             : 
     289    20172029 :   switch (HeapObject::cast(*object)->map()->instance_type()) {
     290             :     case HEAP_NUMBER_TYPE:
     291             :     case MUTABLE_HEAP_NUMBER_TYPE:
     292             :       if (deferred_string_key) SerializeDeferredKey(comma, key);
     293        1257 :       return SerializeHeapNumber(Handle<HeapNumber>::cast(object));
     294             :     case ODDBALL_TYPE:
     295    16077058 :       switch (Oddball::cast(*object)->kind()) {
     296             :         case Oddball::kFalse:
     297             :           if (deferred_string_key) SerializeDeferredKey(comma, key);
     298         134 :           builder_.AppendCString("false");
     299             :           return SUCCESS;
     300             :         case Oddball::kTrue:
     301             :           if (deferred_string_key) SerializeDeferredKey(comma, key);
     302         247 :           builder_.AppendCString("true");
     303             :           return SUCCESS;
     304             :         case Oddball::kNull:
     305             :           if (deferred_string_key) SerializeDeferredKey(comma, key);
     306          74 :           builder_.AppendCString("null");
     307             :           return SUCCESS;
     308             :         default:
     309             :           return UNCHANGED;
     310             :       }
     311             :     case JS_ARRAY_TYPE:
     312             :       if (deferred_string_key) SerializeDeferredKey(comma, key);
     313       15218 :       return SerializeJSArray(Handle<JSArray>::cast(object));
     314             :     case JS_VALUE_TYPE:
     315             :       if (deferred_string_key) SerializeDeferredKey(comma, key);
     316        1068 :       return SerializeJSValue(Handle<JSValue>::cast(object));
     317             :     case SYMBOL_TYPE:
     318             :       return UNCHANGED;
     319             :     default:
     320     3172173 :       if (object->IsString()) {
     321             :         if (deferred_string_key) SerializeDeferredKey(comma, key);
     322     2633271 :         SerializeString(Handle<String>::cast(object));
     323     2633271 :         return SUCCESS;
     324             :       } else {
     325             :         DCHECK(object->IsJSReceiver());
     326      538902 :         if (object->IsCallable()) return UNCHANGED;
     327             :         // Go to slow path for global proxy and objects requiring access checks.
     328             :         if (deferred_string_key) SerializeDeferredKey(comma, key);
     329      535415 :         if (object->IsJSProxy()) {
     330         630 :           return SerializeJSProxy(Handle<JSProxy>::cast(object));
     331             :         }
     332      534785 :         return SerializeJSObject(Handle<JSObject>::cast(object));
     333             :       }
     334             :   }
     335             : 
     336             :   UNREACHABLE();
     337             :   return UNCHANGED;
     338             : }
     339             : 
     340        1068 : JsonStringifier::Result JsonStringifier::SerializeJSValue(
     341             :     Handle<JSValue> object) {
     342        1068 :   String* class_name = object->class_name();
     343        1068 :   if (class_name == isolate_->heap()->String_string()) {
     344             :     Handle<Object> value;
     345         870 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     346             :         isolate_, value, Object::ToString(isolate_, object), EXCEPTION);
     347         435 :     SerializeString(Handle<String>::cast(value));
     348         633 :   } else if (class_name == isolate_->heap()->Number_string()) {
     349             :     Handle<Object> value;
     350         750 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, value, Object::ToNumber(object),
     351             :                                      EXCEPTION);
     352         375 :     if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
     353             :     SerializeHeapNumber(Handle<HeapNumber>::cast(value));
     354         258 :   } else if (class_name == isolate_->heap()->Boolean_string()) {
     355             :     Object* value = JSValue::cast(*object)->value();
     356             :     DCHECK(value->IsBoolean());
     357          90 :     builder_.AppendCString(value->IsTrue(isolate_) ? "true" : "false");
     358             :   } else {
     359             :     // ES6 24.3.2.1 step 10.c, serialize as an ordinary JSObject.
     360             :     return SerializeJSObject(object);
     361             :   }
     362             :   return SUCCESS;
     363             : }
     364             : 
     365      271035 : JsonStringifier::Result JsonStringifier::SerializeSmi(Smi* object) {
     366             :   static const int kBufferSize = 100;
     367             :   char chars[kBufferSize];
     368             :   Vector<char> buffer(chars, kBufferSize);
     369      271035 :   builder_.AppendCString(IntToCString(object->value(), buffer));
     370      271035 :   return SUCCESS;
     371             : }
     372             : 
     373        1317 : JsonStringifier::Result JsonStringifier::SerializeDouble(double number) {
     374        1317 :   if (std::isinf(number) || std::isnan(number)) {
     375         268 :     builder_.AppendCString("null");
     376             :     return SUCCESS;
     377             :   }
     378             :   static const int kBufferSize = 100;
     379             :   char chars[kBufferSize];
     380             :   Vector<char> buffer(chars, kBufferSize);
     381        1049 :   builder_.AppendCString(DoubleToCString(number, buffer));
     382             :   return SUCCESS;
     383             : }
     384             : 
     385             : JsonStringifier::Result JsonStringifier::SerializeJSArray(
     386             :     Handle<JSArray> object) {
     387       15218 :   HandleScope handle_scope(isolate_);
     388       15218 :   Result stack_push = StackPush(object);
     389       15218 :   if (stack_push != SUCCESS) return stack_push;
     390       15145 :   uint32_t length = 0;
     391       15145 :   CHECK(object->length()->ToArrayLength(&length));
     392             :   DCHECK(!object->IsAccessCheckNeeded());
     393       11580 :   builder_.AppendCharacter('[');
     394             :   Indent();
     395             :   uint32_t i = 0;
     396       15145 :   if (replacer_function_.is_null()) {
     397       14209 :     switch (object->GetElementsKind()) {
     398             :       case FAST_SMI_ELEMENTS: {
     399         933 :         Handle<FixedArray> elements(FixedArray::cast(object->elements()),
     400         933 :                                     isolate_);
     401         933 :         StackLimitCheck interrupt_check(isolate_);
     402        5172 :         while (i < length) {
     403        4239 :           if (interrupt_check.InterruptRequested() &&
     404             :               isolate_->stack_guard()->HandleInterrupts()->IsException(
     405           0 :                   isolate_)) {
     406           0 :             return EXCEPTION;
     407             :           }
     408             :           Separator(i == 0);
     409        8478 :           SerializeSmi(Smi::cast(elements->get(i)));
     410        4239 :           i++;
     411             :         }
     412         933 :         break;
     413             :       }
     414             :       case FAST_DOUBLE_ELEMENTS: {
     415             :         // Empty array is FixedArray but not FixedDoubleArray.
     416          15 :         if (length == 0) break;
     417             :         Handle<FixedDoubleArray> elements(
     418           0 :             FixedDoubleArray::cast(object->elements()), isolate_);
     419           0 :         StackLimitCheck interrupt_check(isolate_);
     420           0 :         while (i < length) {
     421           0 :           if (interrupt_check.InterruptRequested() &&
     422             :               isolate_->stack_guard()->HandleInterrupts()->IsException(
     423           0 :                   isolate_)) {
     424           0 :             return EXCEPTION;
     425             :           }
     426             :           Separator(i == 0);
     427           0 :           SerializeDouble(elements->get_scalar(i));
     428           0 :           i++;
     429             :         }
     430             :         break;
     431             :       }
     432             :       case FAST_ELEMENTS: {
     433       25374 :         Handle<Object> old_length(object->length(), isolate_);
     434      622747 :         while (i < length) {
     435     1856574 :           if (object->length() != *old_length ||
     436      618808 :               object->GetElementsKind() != FAST_ELEMENTS) {
     437             :             // Fall back to slow path.
     438             :             break;
     439             :           }
     440             :           Separator(i == 0);
     441             :           Result result = SerializeElement(
     442             :               isolate_,
     443      618778 :               Handle<Object>(FixedArray::cast(object->elements())->get(i),
     444             :                              isolate_),
     445     1856334 :               i);
     446      618778 :           if (result == UNCHANGED) {
     447             :             builder_.AppendCString("null");
     448      618604 :           } else if (result != SUCCESS) {
     449             :             return result;
     450             :           }
     451      610060 :           i++;
     452             :         }
     453             :         break;
     454             :       }
     455             :       // The FAST_HOLEY_* cases could be handled in a faster way. They resemble
     456             :       // the non-holey cases except that a lookup is necessary for holes.
     457             :       default:
     458             :         break;
     459             :     }
     460             :   }
     461        6427 :   if (i < length) {
     462             :     // Slow path for non-fast elements and fall-back in edge case.
     463        1452 :     Result result = SerializeArrayLikeSlow(object, i, length);
     464        1452 :     if (result != SUCCESS) return result;
     465             :   }
     466             :   Unindent();
     467        6365 :   if (length > 0) NewLine();
     468             :   builder_.AppendCharacter(']');
     469        6365 :   StackPop();
     470       15218 :   return SUCCESS;
     471             : }
     472             : 
     473        1508 : JsonStringifier::Result JsonStringifier::SerializeArrayLikeSlow(
     474             :     Handle<JSReceiver> object, uint32_t start, uint32_t length) {
     475             :   // We need to write out at least two characters per array element.
     476             :   static const int kMaxSerializableArrayLength = String::kMaxLength / 2;
     477        1508 :   if (length > kMaxSerializableArrayLength) {
     478          10 :     isolate_->Throw(*isolate_->factory()->NewInvalidStringLengthError());
     479           5 :     return EXCEPTION;
     480             :   }
     481    16033549 :   for (uint32_t i = start; i < length; i++) {
     482             :     Separator(i == 0);
     483             :     Handle<Object> element;
     484    32067212 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     485             :         isolate_, element, JSReceiver::GetElement(isolate_, object, i),
     486             :         EXCEPTION);
     487    16033591 :     Result result = SerializeElement(isolate_, element, i);
     488    16033591 :     if (result == SUCCESS) continue;
     489    15729521 :     if (result == UNCHANGED) {
     490             :       // Detect overflow sooner for large sparse arrays.
     491    15729479 :       if (builder_.HasOverflowed()) return EXCEPTION;
     492    15729479 :       builder_.AppendCString("null");
     493             :     } else {
     494             :       return result;
     495             :     }
     496             :   }
     497             :   return SUCCESS;
     498             : }
     499             : 
     500             : JsonStringifier::Result JsonStringifier::SerializeJSObject(
     501             :     Handle<JSObject> object) {
     502      534953 :   HandleScope handle_scope(isolate_);
     503      534953 :   Result stack_push = StackPush(object);
     504      534953 :   if (stack_push != SUCCESS) return stack_push;
     505             : 
     506     1069342 :   if (property_list_.is_null() &&
     507     1068668 :       object->map()->instance_type() > LAST_CUSTOM_ELEMENTS_RECEIVER &&
     508     1602873 :       object->HasFastProperties() &&
     509     1602409 :       Handle<JSObject>::cast(object)->elements()->length() == 0) {
     510             :     DCHECK(object->IsJSObject());
     511             :     DCHECK(!object->IsJSGlobalProxy());
     512      533471 :     Handle<JSObject> js_obj = Handle<JSObject>::cast(object);
     513             :     DCHECK(!js_obj->HasIndexedInterceptor());
     514             :     DCHECK(!js_obj->HasNamedInterceptor());
     515      533471 :     Handle<Map> map(js_obj->map());
     516      371212 :     builder_.AppendCharacter('{');
     517             :     Indent();
     518             :     bool comma = false;
     519     2795761 :     for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
     520     1139128 :       Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
     521             :       // TODO(rossberg): Should this throw?
     522     1139365 :       if (!name->IsString()) continue;
     523     1139128 :       Handle<String> key = Handle<String>::cast(name);
     524     1139128 :       PropertyDetails details = map->instance_descriptors()->GetDetails(i);
     525     1139128 :       if (details.IsDontEnum()) continue;
     526             :       Handle<Object> property;
     527     2276972 :       if (details.location() == kField && *map == js_obj->map()) {
     528             :         DCHECK_EQ(kData, details.kind());
     529     1138039 :         FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
     530             :         property = JSObject::FastPropertyAt(js_obj, details.representation(),
     531     1138039 :                                             field_index);
     532             :       } else {
     533        9687 :         ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     534             :             isolate_, property, Object::GetPropertyOrElement(js_obj, key),
     535             :             EXCEPTION);
     536             :       }
     537             :       Result result = SerializeProperty(property, comma, key);
     538     1138891 :       if (!comma && result == SUCCESS) comma = true;
     539     1138891 :       if (result == EXCEPTION) return result;
     540             :     }
     541             :     Unindent();
     542      525488 :     if (comma) NewLine();
     543             :     builder_.AppendCharacter('}');
     544             :   } else {
     545        1424 :     Result result = SerializeJSReceiverSlow(object);
     546        1424 :     if (result != SUCCESS) return result;
     547             :   }
     548      526870 :   StackPop();
     549      534953 :   return SUCCESS;
     550             : }
     551             : 
     552        1970 : JsonStringifier::Result JsonStringifier::SerializeJSReceiverSlow(
     553             :     Handle<JSReceiver> object) {
     554        1970 :   Handle<FixedArray> contents = property_list_;
     555        1970 :   if (contents.is_null()) {
     556        3044 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     557             :         isolate_, contents,
     558             :         KeyAccumulator::GetKeys(object, KeyCollectionMode::kOwnOnly,
     559             :                                 ENUMERABLE_STRINGS,
     560             :                                 GetKeysConversion::kConvertToString),
     561             :         EXCEPTION);
     562             :   }
     563        1970 :   builder_.AppendCharacter('{');
     564             :   Indent();
     565             :   bool comma = false;
     566       16176 :   for (int i = 0; i < contents->length(); i++) {
     567        6160 :     Handle<String> key(String::cast(contents->get(i)), isolate_);
     568             :     Handle<Object> property;
     569       12320 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, property,
     570             :                                      Object::GetPropertyOrElement(object, key),
     571             :                                      EXCEPTION);
     572             :     Result result = SerializeProperty(property, comma, key);
     573        6160 :     if (!comma && result == SUCCESS) comma = true;
     574        6160 :     if (result == EXCEPTION) return result;
     575             :   }
     576             :   Unindent();
     577        1928 :   if (comma) NewLine();
     578             :   builder_.AppendCharacter('}');
     579             :   return SUCCESS;
     580             : }
     581             : 
     582         630 : JsonStringifier::Result JsonStringifier::SerializeJSProxy(
     583             :     Handle<JSProxy> object) {
     584         630 :   HandleScope scope(isolate_);
     585         630 :   Result stack_push = StackPush(object);
     586         630 :   if (stack_push != SUCCESS) return stack_push;
     587         630 :   Maybe<bool> is_array = Object::IsArray(object);
     588         630 :   if (is_array.IsNothing()) return EXCEPTION;
     589         630 :   if (is_array.FromJust()) {
     590             :     Handle<Object> length_object;
     591         196 :     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
     592             :         isolate_, length_object,
     593             :         Object::GetLengthFromArrayLike(isolate_, object), EXCEPTION);
     594             :     uint32_t length;
     595          70 :     if (!length_object->ToUint32(&length)) {
     596             :       // Technically, we need to be able to handle lengths outside the
     597             :       // uint32_t range. However, we would run into string size overflow
     598             :       // if we tried to stringify such an array.
     599          28 :       isolate_->Throw(*isolate_->factory()->NewInvalidStringLengthError());
     600          14 :       return EXCEPTION;
     601             :     }
     602          56 :     builder_.AppendCharacter('[');
     603             :     Indent();
     604         112 :     Result result = SerializeArrayLikeSlow(object, 0, length);
     605          56 :     if (result != SUCCESS) return result;
     606             :     Unindent();
     607          56 :     if (length > 0) NewLine();
     608             :     builder_.AppendCharacter(']');
     609             :   } else {
     610         546 :     Result result = SerializeJSReceiverSlow(object);
     611         546 :     if (result != SUCCESS) return result;
     612             :   }
     613         602 :   StackPop();
     614         602 :   return SUCCESS;
     615             : }
     616             : 
     617             : template <typename SrcChar, typename DestChar>
     618             : void JsonStringifier::SerializeStringUnchecked_(
     619             :     Vector<const SrcChar> src,
     620             :     IncrementalStringBuilder::NoExtend<DestChar>* dest) {
     621             :   // Assert that uc16 character is not truncated down to 8 bit.
     622             :   // The <uc16, char> version of this method must not be called.
     623             :   DCHECK(sizeof(DestChar) >= sizeof(SrcChar));
     624             : 
     625    72014675 :   for (int i = 0; i < src.length(); i++) {
     626    72014675 :     SrcChar c = src[i];
     627    72014675 :     if (DoNotEscape(c)) {
     628             :       dest->Append(c);
     629             :     } else {
     630        6891 :       dest->AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
     631             :     }
     632             :   }
     633             : }
     634             : 
     635             : template <typename SrcChar, typename DestChar>
     636             : void JsonStringifier::SerializeString_(Handle<String> string) {
     637     3709783 :   int length = string->length();
     638     7419566 :   builder_.Append<uint8_t, DestChar>('"');
     639             :   // We make a rough estimate to find out if the current string can be
     640             :   // serialized without allocating a new string part. The worst case length of
     641             :   // an escaped character is 6.  Shifting the remainin string length right by 3
     642             :   // is a more pessimistic estimate, but faster to calculate.
     643     3709783 :   int worst_case_length = length << 3;
     644     3709783 :   if (builder_.CurrentPartCanFit(worst_case_length)) {
     645             :     DisallowHeapAllocation no_gc;
     646             :     Vector<const SrcChar> vector = string->GetCharVector<SrcChar>();
     647             :     IncrementalStringBuilder::NoExtendBuilder<DestChar> no_extend(
     648     2707211 :         &builder_, worst_case_length);
     649     2707211 :     SerializeStringUnchecked_(vector, &no_extend);
     650             :   } else {
     651     1002572 :     FlatStringReader reader(isolate_, string);
     652    38301209 :     for (int i = 0; i < reader.length(); i++) {
     653    38301209 :       SrcChar c = reader.Get<SrcChar>(i);
     654    38301209 :       if (DoNotEscape(c)) {
     655             :         builder_.Append<SrcChar, DestChar>(c);
     656             :       } else {
     657    16257783 :         builder_.AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
     658             :       }
     659     1002572 :     }
     660             :   }
     661             : 
     662             :   builder_.Append<uint8_t, DestChar>('"');
     663             : }
     664             : 
     665             : template <>
     666   108585946 : bool JsonStringifier::DoNotEscape(uint8_t c) {
     667   108585946 :   return c >= '#' && c <= '~' && c != '\\';
     668             : }
     669             : 
     670             : template <>
     671     1729938 : bool JsonStringifier::DoNotEscape(uint16_t c) {
     672     1729938 :   return c >= '#' && c != '\\' && c != 0x7f;
     673             : }
     674             : 
     675             : void JsonStringifier::NewLine() {
     676    18256780 :   if (gap_ == nullptr) return;
     677     8017200 :   builder_.AppendCharacter('\n');
     678    16339824 :   for (int i = 0; i < indent_; i++) builder_.AppendCString(gap_);
     679             : }
     680             : 
     681             : void JsonStringifier::Separator(bool first) {
     682    17732700 :   if (!first) builder_.AppendCharacter(',');
     683             :   NewLine();
     684             : }
     685             : 
     686             : void JsonStringifier::SerializeDeferredKey(bool deferred_comma,
     687             :                                            Handle<Object> deferred_key) {
     688             :   Separator(!deferred_comma);
     689     1076077 :   SerializeString(Handle<String>::cast(deferred_key));
     690     1076077 :   builder_.AppendCharacter(':');
     691     1076077 :   if (gap_ != nullptr) builder_.AppendCharacter(' ');
     692             : }
     693             : 
     694     4839358 : void JsonStringifier::SerializeString(Handle<String> object) {
     695     4839358 :   object = String::Flatten(object);
     696     4839358 :   if (builder_.CurrentEncoding() == String::ONE_BYTE_ENCODING) {
     697     3709533 :     if (object->IsOneByteRepresentationUnderneath()) {
     698             :       SerializeString_<uint8_t, uint8_t>(object);
     699             :     } else {
     700     1129575 :       builder_.ChangeEncoding();
     701     1129575 :       SerializeString(object);
     702             :     }
     703             :   } else {
     704     1129825 :     if (object->IsOneByteRepresentationUnderneath()) {
     705             :       SerializeString_<uint8_t, uc16>(object);
     706             :     } else {
     707             :       SerializeString_<uc16, uc16>(object);
     708             :     }
     709             :   }
     710     4839358 : }
     711             : 
     712             : }  // namespace internal
     713             : }  // namespace v8

Generated by: LCOV version 1.10