[json] implement JSON.stringify gap pre-processing in C++.

src/json-stringifier.cc

 // Copyright 2016 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.
 
 #include "src/json-stringifier.h"
 
 #include "src/conversions.h"
 #include "src/lookup.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
@@ skipping 63 matching lines @@
     "\334\0      \335\0      \336\0      \337\0      "
     "\340\0      \341\0      \342\0      \343\0      "
     "\344\0      \345\0      \346\0      \347\0      "
     "\350\0      \351\0      \352\0      \353\0      "
     "\354\0      \355\0      \356\0      \357\0      "
     "\360\0      \361\0      \362\0      \363\0      "
     "\364\0      \365\0      \366\0      \367\0      "
     "\370\0      \371\0      \372\0      \373\0      "
     "\374\0      \375\0      \376\0      \377\0      ";
 
-BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate, Handle<String> gap)
-    : isolate_(isolate), builder_(isolate), gap_string_(gap), indent_(0) {
+BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
+    : isolate_(isolate), builder_(isolate), gap_(nullptr), indent_(0) {
   tojson_string_ = factory()->toJSON_string();
   stack_ = factory()->NewJSArray(8);
-  int gap_length = gap->length();
-  if (gap_length != 0) {
-    gap = String::Flatten(gap);
-    if (gap->IsTwoByteRepresentation()) builder_.ChangeEncoding();
-    DisallowHeapAllocation no_gc;
-    String::FlatContent flat = gap->GetFlatContent();
-    gap_ = NewArray<uc16>(gap_length + 1);
-    if (flat.IsOneByte()) {
-      CopyChars(gap_, flat.ToOneByteVector().start(), gap_length);
-    } else {
-      CopyChars(gap_, flat.ToUC16Vector().start(), gap_length);
-    }
-    gap_[gap_length] = '\0';
-  } else {
-    gap_ = nullptr;
-  }
 }
 
-MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object) {
+MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object,
+                                                    Handle<Object> gap) {
+  if (!gap->IsUndefined() && !InitializeGap(gap)) return MaybeHandle<Object>();
   Result result = SerializeObject(object);
   if (result == UNCHANGED) return factory()->undefined_value();
   if (result == SUCCESS) return builder_.Finish();
   DCHECK(result == EXCEPTION);
   return MaybeHandle<Object>();
 }
 
+bool BasicJsonStringifier::InitializeGap(Handle<Object> gap) {
+  DCHECK_NULL(gap_);
+  HandleScope scope(isolate_);
+  if (gap->IsJSReceiver()) {
+    Handle<String> class_name(Handle<JSReceiver>::cast(gap)->class_name());
+    if (class_name.is_identical_to(factory()->String_string())) {

[Camillo Bruni, 2016/05/23 14:08:25]

argh :D we should have a IsNumberLike() somewhere :P.

[Yang, 2016/05/23 18:19:07]

Actually, the string case and the number case are different. The number
specifies the gap length, with whitespace. The string specifies the actual
indent string (which can be anything, up to 10 characters).

+      ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap,
+                                       Object::ToString(isolate_, gap), false);
+    } else if (class_name.is_identical_to(factory()->number_string())) {
+      ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap, Object::ToNumber(gap),
+                                       false);
+    }
+  }
+
+  if (gap->IsString()) {
+    Handle<String> gap_string = Handle<String>::cast(gap);
+    if (gap_string->length() > 0) {
+      int gap_length = std::min(gap_string->length(), 10);
+      gap_ = NewArray<uc16>(gap_length + 1);
+      String::WriteToFlat(*gap_string, gap_, 0, gap_length);
+      for (int i = 0; i < gap_length; i++) {
+        if (gap_[i] > String::kMaxOneByteCharCode) {
+          builder_.ChangeEncoding();
+          break;
+        }
+      }
+      gap_[gap_length] = '\0';
+    }
+  } else if (gap->IsNumber()) {
+    int num_value = DoubleToInt32(gap->Number());
+    if (num_value > 0) {
+      int gap_length = std::min(num_value, 10);

[Camillo Bruni, 2016/05/23 14:08:25]

just read the spec, wut? :D

[Yang, 2016/05/23 18:19:07]

Yeah. Magic numbers ftw.

+      gap_ = NewArray<uc16>(gap_length + 1);
+      for (int i = 0; i < gap_length; i++) gap_[i] = ' ';
+      gap_[gap_length] = '\0';
+    }
+  }
+  return true;
+}
+
 MaybeHandle<Object> BasicJsonStringifier::StringifyString(
     Isolate* isolate, Handle<String> object) {
   static const int kJsonQuoteWorstCaseBlowup = 6;
   static const int kSpaceForQuotes = 2;
   int worst_case_length =
       object->length() * kJsonQuoteWorstCaseBlowup + kSpaceForQuotes;
 
   if (worst_case_length > 32 * KB) {  // Slow path if too large.
-    BasicJsonStringifier stringifier(isolate,
-                                     isolate->factory()->empty_string());
-    return stringifier.Stringify(object);
+    BasicJsonStringifier stringifier(isolate);
+    return stringifier.Stringify(object, isolate->factory()->undefined_value());
   }
 
   object = String::Flatten(object);
   DCHECK(object->IsFlat());
   Handle<SeqString> result;
   if (object->IsOneByteRepresentationUnderneath()) {
     result = isolate->factory()
                  ->NewRawOneByteString(worst_case_length)
                  .ToHandleChecked();
     IncrementalStringBuilder::NoExtendString<uint8_t> no_extend(
@@ skipping 489 matching lines @@
     if (object->IsOneByteRepresentationUnderneath()) {
       SerializeString_<uint8_t, uc16>(object);
     } else {
       SerializeString_<uc16, uc16>(object);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8