[json] move json parser and stringifier into own compilation units.

src/json-stringifier.cc

-// Copyright 2012 the V8 project authors. All rights reserved.
+// 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.
 
-#ifndef V8_JSON_STRINGIFIER_H_
-#define V8_JSON_STRINGIFIER_H_
+#include "src/json-stringifier.h"
 
 #include "src/conversions.h"
 #include "src/lookup.h"
 #include "src/messages.h"
-#include "src/string-builder.h"
+#include "src/objects-inl.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
-class BasicJsonStringifier BASE_EMBEDDED {
- public:
-  BasicJsonStringifier(Isolate* isolate, Handle<String> gap);
-
-  ~BasicJsonStringifier() { DeleteArray(gap_); }
-
-  MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object);
-
-  MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString(
-      Isolate* isolate,
-      Handle<String> object));
-
- private:
-  enum Result { UNCHANGED, SUCCESS, EXCEPTION };
-
-  MUST_USE_RESULT MaybeHandle<Object> ApplyToJsonFunction(
-      Handle<Object> object,
-      Handle<Object> key);
-
-  // Entry point to serialize the object.
-  INLINE(Result SerializeObject(Handle<Object> obj)) {
-    return Serialize_<false>(obj, false, factory()->empty_string());
-  }
-
-  // Serialize an array element.
-  // The index may serve as argument for the toJSON function.
-  INLINE(Result SerializeElement(Isolate* isolate,
-                                 Handle<Object> object,
-                                 int i)) {
-    return Serialize_<false>(object,
-                             false,
-                             Handle<Object>(Smi::FromInt(i), isolate));
-  }
-
-  // Serialize a object property.
-  // The key may or may not be serialized depending on the property.
-  // The key may also serve as argument for the toJSON function.
-  INLINE(Result SerializeProperty(Handle<Object> object,
-                                  bool deferred_comma,
-                                  Handle<String> deferred_key)) {
-    DCHECK(!deferred_key.is_null());
-    return Serialize_<true>(object, deferred_comma, deferred_key);
-  }
-
-  template <bool deferred_string_key>
-  Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key);
-
-  void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) {
-    Separator(!deferred_comma);
-    SerializeString(Handle<String>::cast(deferred_key));
-    builder_.AppendCharacter(':');
-    if (gap_ != nullptr) builder_.AppendCharacter(' ');
-  }
-
-  Result SerializeSmi(Smi* object);
-
-  Result SerializeDouble(double number);
-  INLINE(Result SerializeHeapNumber(Handle<HeapNumber> object)) {
-    return SerializeDouble(object->value());
-  }
-
-  Result SerializeJSValue(Handle<JSValue> object);
-
-  INLINE(Result SerializeJSArray(Handle<JSArray> object));
-  INLINE(Result SerializeJSObject(Handle<JSObject> object));
-
-  Result SerializeJSProxy(Handle<JSProxy> object);
-  Result SerializeJSReceiverSlow(Handle<JSReceiver> object);
-  Result SerializeArrayLikeSlow(Handle<JSReceiver> object, uint32_t start,
-                                uint32_t length);
-
-  void SerializeString(Handle<String> object);
-
-  template <typename SrcChar, typename DestChar>
-  INLINE(static void SerializeStringUnchecked_(
-      Vector<const SrcChar> src,
-      IncrementalStringBuilder::NoExtend<DestChar>* dest));
-
-  template <typename SrcChar, typename DestChar>
-  INLINE(void SerializeString_(Handle<String> string));
-
-  template <typename Char>
-  INLINE(static bool DoNotEscape(Char c));
-
-  INLINE(void NewLine());
-  INLINE(void Indent() { indent_++; });
-  INLINE(void Unindent() { indent_--; });
-  INLINE(void Separator(bool first) {
-    if (!first) builder_.AppendCharacter(',');
-    NewLine();
-  })
-
-  Result StackPush(Handle<Object> object);
-  void StackPop();
-
-  Factory* factory() { return isolate_->factory(); }
-
-  Isolate* isolate_;
-  IncrementalStringBuilder builder_;
-  Handle<String> tojson_string_;
-  Handle<JSArray> stack_;
-  Handle<String> gap_string_;
-  uc16* gap_;
-  int indent_;
-
-  static const int kJsonEscapeTableEntrySize = 8;
-  static const char* const JsonEscapeTable;
-};
-
-
 // Translation table to escape Latin1 characters.
 // Table entries start at a multiple of 8 and are null-terminated.
 const char* const BasicJsonStringifier::JsonEscapeTable =
     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
     "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 "
     "\\b\0     \\t\0     \\n\0     \\u000b\0 "
     "\\f\0     \\r\0     \\u000e\0 \\u000f\0 "
     "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 "
     "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 "
     "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 "
@@ skipping 70 matching lines @@
       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) {
   Result result = SerializeObject(object);
   if (result == UNCHANGED) return factory()->undefined_value();
   if (result == SUCCESS) return builder_.Finish();
   DCHECK(result == EXCEPTION);
   return MaybeHandle<Object>();
 }
 
-
 MaybeHandle<Object> BasicJsonStringifier::StringifyString(
-    Isolate* isolate,  Handle<String> object) {
+    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);
   }
@@ skipping 19 matching lines @@
     IncrementalStringBuilder::NoExtendString<uc16> no_extend(result,
                                                              worst_case_length);
     no_extend.Append('\"');
     SerializeStringUnchecked_(object->GetFlatContent().ToUC16Vector(),
                               &no_extend);
     no_extend.Append('\"');
     return no_extend.Finalize();
   }
 }
 
-
 MaybeHandle<Object> BasicJsonStringifier::ApplyToJsonFunction(
     Handle<Object> object, Handle<Object> key) {
   LookupIterator it(object, tojson_string_,
                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   Handle<Object> fun;
   ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object);
   if (!fun->IsCallable()) return object;
 
   // Call toJSON function.
   if (key->IsSmi()) key = factory()->NumberToString(key);
-  Handle<Object> argv[] = { key };
+  Handle<Object> argv[] = {key};
   HandleScope scope(isolate_);
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate_, object,
-      Execution::Call(isolate_, fun, object, 1, argv),
-      Object);
+  ASSIGN_RETURN_ON_EXCEPTION(isolate_, object,
+                             Execution::Call(isolate_, fun, object, 1, argv),
+                             Object);
   return scope.CloseAndEscape(object);
 }
 
-
 BasicJsonStringifier::Result BasicJsonStringifier::StackPush(
     Handle<Object> object) {
   StackLimitCheck check(isolate_);
   if (check.HasOverflowed()) {
     isolate_->StackOverflow();
     return EXCEPTION;
   }
 
   int length = Smi::cast(stack_->length())->value();
   {
     DisallowHeapAllocation no_allocation;
     FixedArray* elements = FixedArray::cast(stack_->elements());
     for (int i = 0; i < length; i++) {
       if (elements->get(i) == *object) {
         AllowHeapAllocation allow_to_return_error;
         Handle<Object> error =
             factory()->NewTypeError(MessageTemplate::kCircularStructure);
         isolate_->Throw(*error);
         return EXCEPTION;
       }
     }
   }
   JSArray::SetLength(stack_, length + 1);
   FixedArray::cast(stack_->elements())->set(length, *object);
   return SUCCESS;
 }
 
-
 void BasicJsonStringifier::StackPop() {
   int length = Smi::cast(stack_->length())->value();
   stack_->set_length(Smi::FromInt(length - 1));
 }
 
-
 template <bool deferred_string_key>
 BasicJsonStringifier::Result BasicJsonStringifier::Serialize_(
     Handle<Object> object, bool comma, Handle<Object> key) {
   if (object->IsJSReceiver()) {
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-        isolate_, object,
-        ApplyToJsonFunction(object, key),
-        EXCEPTION);
+        isolate_, object, ApplyToJsonFunction(object, key), EXCEPTION);
   }
 
   if (object->IsSmi()) {
     if (deferred_string_key) SerializeDeferredKey(comma, key);
     return SerializeSmi(Smi::cast(*object));
   }
 
   switch (HeapObject::cast(*object)->map()->instance_type()) {
     case HEAP_NUMBER_TYPE:
     case MUTABLE_HEAP_NUMBER_TYPE:
@@ skipping 39 matching lines @@
           return SerializeJSProxy(Handle<JSProxy>::cast(object));
         }
         return SerializeJSObject(Handle<JSObject>::cast(object));
       }
   }
 
   UNREACHABLE();
   return UNCHANGED;
 }
 
-
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue(
     Handle<JSValue> object) {
   String* class_name = object->class_name();
   if (class_name == isolate_->heap()->String_string()) {
     Handle<Object> value;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, value, Object::ToString(isolate_, object), EXCEPTION);
     SerializeString(Handle<String>::cast(value));
   } else if (class_name == isolate_->heap()->Number_string()) {
     Handle<Object> value;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, value, Object::ToNumber(object),
                                      EXCEPTION);
     if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
     SerializeHeapNumber(Handle<HeapNumber>::cast(value));
   } else if (class_name == isolate_->heap()->Boolean_string()) {
     Object* value = JSValue::cast(*object)->value();
     DCHECK(value->IsBoolean());
     builder_.AppendCString(value->IsTrue() ? "true" : "false");
   } else {
     // ES6 24.3.2.1 step 10.c, serialize as an ordinary JSObject.
     return SerializeJSObject(object);
   }
   return SUCCESS;
 }
 
-
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) {
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
   builder_.AppendCString(IntToCString(object->value(), buffer));
   return SUCCESS;
 }
 
-
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble(
     double number) {
   if (std::isinf(number) || std::isnan(number)) {
     builder_.AppendCString("null");
     return SUCCESS;
   }
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
   builder_.AppendCString(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;
   uint32_t length = 0;
   CHECK(object->length()->ToArrayLength(&length));
   DCHECK(!object->IsAccessCheckNeeded());
   builder_.AppendCharacter('[');
   Indent();
@@ skipping 201 matching lines @@
     if (length > 0) NewLine();
     builder_.AppendCharacter(']');
   } else {
     Result result = SerializeJSReceiverSlow(object);
     if (result != SUCCESS) return result;
   }
   StackPop();
   return SUCCESS;
 }
 
-
 template <typename SrcChar, typename DestChar>
 void BasicJsonStringifier::SerializeStringUnchecked_(
     Vector<const SrcChar> src,
     IncrementalStringBuilder::NoExtend<DestChar>* dest) {
   // Assert that uc16 character is not truncated down to 8 bit.
   // The <uc16, char> version of this method must not be called.
   DCHECK(sizeof(DestChar) >= sizeof(SrcChar));
 
   for (int i = 0; i < src.length(); i++) {
     SrcChar c = src[i];
     if (DoNotEscape(c)) {
       dest->Append(c);
     } else {
       dest->AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
     }
   }
 }
 
-
 template <typename SrcChar, typename DestChar>
 void BasicJsonStringifier::SerializeString_(Handle<String> string) {
   int length = string->length();
   builder_.Append<uint8_t, DestChar>('"');
   // We make a rough estimate to find out if the current string can be
   // serialized without allocating a new string part. The worst case length of
   // an escaped character is 6.  Shifting the remainin string length right by 3
   // is a more pessimistic estimate, but faster to calculate.
   int worst_case_length = length << 3;
   if (builder_.CurrentPartCanFit(worst_case_length)) {
@@ skipping 10 matching lines @@
         builder_.Append<SrcChar, DestChar>(c);
       } else {
         builder_.AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
       }
     }
   }
 
   builder_.Append<uint8_t, DestChar>('"');
 }
 
-
 template <>
 bool BasicJsonStringifier::DoNotEscape(uint8_t c) {
   return c >= '#' && c <= '~' && c != '\\';
 }
 
-
 template <>
 bool BasicJsonStringifier::DoNotEscape(uint16_t c) {
   return c >= '#' && c != '\\' && c != 0x7f;
 }
 
 void BasicJsonStringifier::NewLine() {
   if (gap_ == nullptr) return;
   builder_.AppendCharacter('\n');
   for (int i = 0; i < indent_; i++) builder_.AppendCString(gap_);
 }
 
+void BasicJsonStringifier::Separator(bool first) {
+  if (!first) builder_.AppendCharacter(',');
+  NewLine();
+}
+
+void BasicJsonStringifier::SerializeDeferredKey(bool deferred_comma,
+                                                Handle<Object> deferred_key) {
+  Separator(!deferred_comma);
+  SerializeString(Handle<String>::cast(deferred_key));
+  builder_.AppendCharacter(':');
+  if (gap_ != nullptr) builder_.AppendCharacter(' ');
+}
+
 void BasicJsonStringifier::SerializeString(Handle<String> object) {
   object = String::Flatten(object);
   if (builder_.CurrentEncoding() == String::ONE_BYTE_ENCODING) {
     if (object->IsOneByteRepresentationUnderneath()) {
       SerializeString_<uint8_t, uint8_t>(object);
     } else {
       builder_.ChangeEncoding();
       SerializeString(object);
     }
   } else {
     if (object->IsOneByteRepresentationUnderneath()) {
       SerializeString_<uint8_t, uc16>(object);
     } else {
       SerializeString_<uc16, uc16>(object);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8
-
-#endif  // V8_JSON_STRINGIFIER_H_