Merge V8 5.3.332.45. DO NOT MERGE
Test: Manual
FPIIM-449
Change-Id: Id3254828b068abdea3cb10442e0172a8c9a98e03
(cherry picked from commit 13e2dadd00298019ed862f2b2fc5068bba730bcf)
diff --git a/src/json-stringifier.h b/src/json-stringifier.h
index b40a782..e72bd9d 100644
--- a/src/json-stringifier.h
+++ b/src/json-stringifier.h
@@ -5,36 +5,33 @@
#ifndef V8_JSON_STRINGIFIER_H_
#define V8_JSON_STRINGIFIER_H_
-#include "src/conversions.h"
-#include "src/lookup.h"
-#include "src/messages.h"
+#include "src/objects.h"
#include "src/string-builder.h"
-#include "src/utils.h"
namespace v8 {
namespace internal {
-class BasicJsonStringifier BASE_EMBEDDED {
+class JsonStringifier BASE_EMBEDDED {
public:
- explicit BasicJsonStringifier(Isolate* isolate);
+ explicit JsonStringifier(Isolate* isolate);
- MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object);
+ ~JsonStringifier() { DeleteArray(gap_); }
- MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString(
- Isolate* isolate,
- Handle<String> object));
+ MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object,
+ Handle<Object> replacer,
+ Handle<Object> gap);
private:
enum Result { UNCHANGED, SUCCESS, EXCEPTION };
+ bool InitializeReplacer(Handle<Object> replacer);
+ bool InitializeGap(Handle<Object> gap);
+
MUST_USE_RESULT MaybeHandle<Object> ApplyToJsonFunction(
Handle<Object> object,
Handle<Object> key);
-
- Result SerializeGeneric(Handle<Object> object,
- Handle<Object> key,
- bool deferred_comma,
- bool deferred_key);
+ MUST_USE_RESULT MaybeHandle<Object> ApplyReplacerFunction(
+ Handle<Object> value, Handle<Object> key, Handle<Object> initial_holder);
// Entry point to serialize the object.
INLINE(Result SerializeObject(Handle<Object> obj)) {
@@ -64,11 +61,8 @@
template <bool deferred_string_key>
Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key);
- void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) {
- if (deferred_comma) builder_.AppendCharacter(',');
- SerializeString(Handle<String>::cast(deferred_key));
- builder_.AppendCharacter(':');
- }
+ INLINE(void SerializeDeferredKey(bool deferred_comma,
+ Handle<Object> deferred_key));
Result SerializeSmi(Smi* object);
@@ -82,8 +76,10 @@
INLINE(Result SerializeJSArray(Handle<JSArray> object));
INLINE(Result SerializeJSObject(Handle<JSObject> object));
- Result SerializeJSArraySlow(Handle<JSArray> object, uint32_t start,
- uint32_t length);
+ 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);
@@ -98,6 +94,14 @@
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));
+
+ Handle<JSReceiver> CurrentHolder(Handle<Object> value,
+ Handle<Object> inital_holder);
+
Result StackPush(Handle<Object> object);
void StackPop();
@@ -107,579 +111,15 @@
IncrementalStringBuilder builder_;
Handle<String> tojson_string_;
Handle<JSArray> stack_;
+ Handle<FixedArray> property_list_;
+ Handle<JSReceiver> replacer_function_;
+ 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 "
- "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 "
- " \0 !\0 \\\"\0 #\0 "
- "$\0 %\0 &\0 '\0 "
- "(\0 )\0 *\0 +\0 "
- ",\0 -\0 .\0 /\0 "
- "0\0 1\0 2\0 3\0 "
- "4\0 5\0 6\0 7\0 "
- "8\0 9\0 :\0 ;\0 "
- "<\0 =\0 >\0 ?\0 "
- "@\0 A\0 B\0 C\0 "
- "D\0 E\0 F\0 G\0 "
- "H\0 I\0 J\0 K\0 "
- "L\0 M\0 N\0 O\0 "
- "P\0 Q\0 R\0 S\0 "
- "T\0 U\0 V\0 W\0 "
- "X\0 Y\0 Z\0 [\0 "
- "\\\\\0 ]\0 ^\0 _\0 "
- "`\0 a\0 b\0 c\0 "
- "d\0 e\0 f\0 g\0 "
- "h\0 i\0 j\0 k\0 "
- "l\0 m\0 n\0 o\0 "
- "p\0 q\0 r\0 s\0 "
- "t\0 u\0 v\0 w\0 "
- "x\0 y\0 z\0 {\0 "
- "|\0 }\0 ~\0 \177\0 "
- "\200\0 \201\0 \202\0 \203\0 "
- "\204\0 \205\0 \206\0 \207\0 "
- "\210\0 \211\0 \212\0 \213\0 "
- "\214\0 \215\0 \216\0 \217\0 "
- "\220\0 \221\0 \222\0 \223\0 "
- "\224\0 \225\0 \226\0 \227\0 "
- "\230\0 \231\0 \232\0 \233\0 "
- "\234\0 \235\0 \236\0 \237\0 "
- "\240\0 \241\0 \242\0 \243\0 "
- "\244\0 \245\0 \246\0 \247\0 "
- "\250\0 \251\0 \252\0 \253\0 "
- "\254\0 \255\0 \256\0 \257\0 "
- "\260\0 \261\0 \262\0 \263\0 "
- "\264\0 \265\0 \266\0 \267\0 "
- "\270\0 \271\0 \272\0 \273\0 "
- "\274\0 \275\0 \276\0 \277\0 "
- "\300\0 \301\0 \302\0 \303\0 "
- "\304\0 \305\0 \306\0 \307\0 "
- "\310\0 \311\0 \312\0 \313\0 "
- "\314\0 \315\0 \316\0 \317\0 "
- "\320\0 \321\0 \322\0 \323\0 "
- "\324\0 \325\0 \326\0 \327\0 "
- "\330\0 \331\0 \332\0 \333\0 "
- "\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)
- : isolate_(isolate), builder_(isolate) {
- tojson_string_ = factory()->toJSON_string();
- stack_ = factory()->NewJSArray(8);
-}
-
-
-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) {
- 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);
- return stringifier.Stringify(object);
- }
-
- 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(
- result, worst_case_length);
- no_extend.Append('\"');
- SerializeStringUnchecked_(object->GetFlatContent().ToOneByteVector(),
- &no_extend);
- no_extend.Append('\"');
- return no_extend.Finalize();
- } else {
- result = isolate->factory()
- ->NewRawTwoByteString(worst_case_length)
- .ToHandleChecked();
- 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 };
- HandleScope scope(isolate_);
- 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->IsJSObject()) {
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- 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:
- 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);
- builder_.AppendCString("false");
- return SUCCESS;
- case Oddball::kTrue:
- if (deferred_string_key) SerializeDeferredKey(comma, key);
- builder_.AppendCString("true");
- return SUCCESS;
- case Oddball::kNull:
- if (deferred_string_key) SerializeDeferredKey(comma, key);
- builder_.AppendCString("null");
- return SUCCESS;
- default:
- return UNCHANGED;
- }
- case JS_ARRAY_TYPE:
- if (object->IsAccessCheckNeeded()) break;
- 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));
- default:
- if (object->IsString()) {
- if (deferred_string_key) SerializeDeferredKey(comma, key);
- SerializeString(Handle<String>::cast(object));
- return SUCCESS;
- } else if (object->IsJSObject()) {
- if (object->IsCallable()) return UNCHANGED;
- // Go to slow path for global proxy and objects requiring access checks.
- if (object->IsAccessCheckNeeded() || object->IsJSGlobalProxy()) break;
- if (deferred_string_key) SerializeDeferredKey(comma, key);
- return SerializeJSObject(Handle<JSObject>::cast(object));
- }
- }
-
- return SerializeGeneric(object, key, comma, deferred_string_key);
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeGeneric(
- Handle<Object> object,
- Handle<Object> key,
- bool deferred_comma,
- bool deferred_key) {
- Handle<JSFunction> fun = isolate_->json_serialize_adapter();
- Handle<Object> argv[] = { key, object };
- Handle<Object> result;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate_, result, Execution::Call(isolate_, fun, object, 2, argv),
- EXCEPTION);
- if (result->IsUndefined()) return UNCHANGED;
- if (deferred_key) {
- if (key->IsSmi()) key = factory()->NumberToString(key);
- SerializeDeferredKey(deferred_comma, key);
- }
-
- builder_.AppendString(Handle<String>::cast(result));
- return SUCCESS;
-}
-
-
-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.
- CHECK(!object->IsAccessCheckNeeded());
- CHECK(!object->IsJSGlobalProxy());
- 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));
- builder_.AppendCharacter('[');
- switch (object->GetElementsKind()) {
- case FAST_SMI_ELEMENTS: {
- Handle<FixedArray> elements(FixedArray::cast(object->elements()),
- isolate_);
- for (uint32_t i = 0; i < length; i++) {
- if (i > 0) builder_.AppendCharacter(',');
- SerializeSmi(Smi::cast(elements->get(i)));
- }
- break;
- }
- case FAST_DOUBLE_ELEMENTS: {
- // Empty array is FixedArray but not FixedDoubleArray.
- if (length == 0) break;
- Handle<FixedDoubleArray> elements(
- FixedDoubleArray::cast(object->elements()), isolate_);
- for (uint32_t i = 0; i < length; i++) {
- if (i > 0) builder_.AppendCharacter(',');
- SerializeDouble(elements->get_scalar(i));
- }
- break;
- }
- case FAST_ELEMENTS: {
- Handle<Object> old_length(object->length(), isolate_);
- for (uint32_t i = 0; i < length; i++) {
- if (object->length() != *old_length ||
- object->GetElementsKind() != FAST_ELEMENTS) {
- Result result = SerializeJSArraySlow(object, i, length);
- if (result != SUCCESS) return result;
- break;
- }
- if (i > 0) builder_.AppendCharacter(',');
- Result result = SerializeElement(
- isolate_,
- Handle<Object>(FixedArray::cast(object->elements())->get(i),
- isolate_),
- i);
- if (result == SUCCESS) continue;
- if (result == UNCHANGED) {
- builder_.AppendCString("null");
- } else {
- return result;
- }
- }
- break;
- }
- // The FAST_HOLEY_* cases could be handled in a faster way. They resemble
- // the non-holey cases except that a lookup is necessary for holes.
- default: {
- Result result = SerializeJSArraySlow(object, 0, length);
- if (result != SUCCESS) return result;
- break;
- }
- }
- builder_.AppendCharacter(']');
- StackPop();
- return SUCCESS;
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArraySlow(
- Handle<JSArray> object, uint32_t start, uint32_t length) {
- for (uint32_t i = start; i < length; i++) {
- if (i > 0) builder_.AppendCharacter(',');
- Handle<Object> element;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate_, element, JSReceiver::GetElement(isolate_, object, i),
- EXCEPTION);
- if (element->IsUndefined()) {
- builder_.AppendCString("null");
- } else {
- Result result = SerializeElement(isolate_, element, i);
- if (result == SUCCESS) continue;
- if (result == UNCHANGED) {
- builder_.AppendCString("null");
- } else {
- return result;
- }
- }
- }
- return SUCCESS;
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject(
- Handle<JSObject> object) {
- HandleScope handle_scope(isolate_);
- Result stack_push = StackPush(object);
- if (stack_push != SUCCESS) return stack_push;
- DCHECK(!object->IsJSGlobalProxy() && !object->IsJSGlobalObject());
-
- builder_.AppendCharacter('{');
- bool comma = false;
-
- if (object->HasFastProperties() &&
- !object->HasIndexedInterceptor() &&
- !object->HasNamedInterceptor() &&
- object->elements()->length() == 0) {
- Handle<Map> map(object->map());
- for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
- Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
- // TODO(rossberg): Should this throw?
- if (!name->IsString()) continue;
- Handle<String> key = Handle<String>::cast(name);
- PropertyDetails details = map->instance_descriptors()->GetDetails(i);
- if (details.IsDontEnum()) continue;
- Handle<Object> property;
- if (details.type() == DATA && *map == object->map()) {
- FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
- Isolate* isolate = object->GetIsolate();
- if (object->IsUnboxedDoubleField(field_index)) {
- double value = object->RawFastDoublePropertyAt(field_index);
- property = isolate->factory()->NewHeapNumber(value);
-
- } else {
- property = handle(object->RawFastPropertyAt(field_index), isolate);
- }
- } else {
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate_, property,
- Object::GetPropertyOrElement(object, key),
- EXCEPTION);
- }
- Result result = SerializeProperty(property, comma, key);
- if (!comma && result == SUCCESS) comma = true;
- if (result == EXCEPTION) return result;
- }
- } else {
- Handle<FixedArray> contents;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate_, contents,
- JSReceiver::GetKeys(object, OWN_ONLY, ENUMERABLE_STRINGS), EXCEPTION);
-
- for (int i = 0; i < contents->length(); i++) {
- Object* key = contents->get(i);
- Handle<String> key_handle;
- MaybeHandle<Object> maybe_property;
- if (key->IsString()) {
- key_handle = Handle<String>(String::cast(key), isolate_);
- maybe_property = Object::GetPropertyOrElement(object, key_handle);
- } else {
- DCHECK(key->IsNumber());
- key_handle = factory()->NumberToString(Handle<Object>(key, isolate_));
- if (key->IsSmi()) {
- maybe_property =
- JSReceiver::GetElement(isolate_, object, Smi::cast(key)->value());
- } else {
- maybe_property = Object::GetPropertyOrElement(object, key_handle);
- }
- }
- Handle<Object> property;
- ASSIGN_RETURN_ON_EXCEPTION_VALUE(
- isolate_, property, maybe_property, EXCEPTION);
- Result result = SerializeProperty(property, comma, key_handle);
- if (!comma && result == SUCCESS) comma = true;
- if (result == EXCEPTION) return result;
- }
- }
-
- builder_.AppendCharacter('}');
- 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)) {
- DisallowHeapAllocation no_gc;
- Vector<const SrcChar> vector = string->GetCharVector<SrcChar>();
- IncrementalStringBuilder::NoExtendBuilder<DestChar> no_extend(
- &builder_, worst_case_length);
- SerializeStringUnchecked_(vector, &no_extend);
- } else {
- FlatStringReader reader(isolate_, string);
- for (int i = 0; i < reader.length(); i++) {
- SrcChar c = reader.Get<SrcChar>(i);
- if (DoNotEscape(c)) {
- 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::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