Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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/utils.h" |
| 12 | |
| 13 | namespace v8 { |
| 14 | namespace internal { |
| 15 | |
| 16 | class BasicJsonStringifier BASE_EMBEDDED { |
| 17 | public: |
| 18 | explicit BasicJsonStringifier(Isolate* isolate); |
| 19 | |
| 20 | MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object); |
| 21 | |
| 22 | MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString( |
| 23 | Isolate* isolate, |
| 24 | Handle<String> object)); |
| 25 | |
| 26 | private: |
| 27 | static const int kInitialPartLength = 32; |
| 28 | static const int kMaxPartLength = 16 * 1024; |
| 29 | static const int kPartLengthGrowthFactor = 2; |
| 30 | |
| 31 | enum Result { UNCHANGED, SUCCESS, EXCEPTION }; |
| 32 | |
| 33 | void Accumulate(); |
| 34 | |
| 35 | void Extend(); |
| 36 | |
| 37 | void ChangeEncoding(); |
| 38 | |
| 39 | INLINE(void ShrinkCurrentPart()); |
| 40 | |
| 41 | template <bool is_one_byte, typename Char> |
| 42 | INLINE(void Append_(Char c)); |
| 43 | |
| 44 | template <bool is_one_byte, typename Char> |
| 45 | INLINE(void Append_(const Char* chars)); |
| 46 | |
| 47 | INLINE(void Append(uint8_t c)) { |
| 48 | if (is_one_byte_) { |
| 49 | Append_<true>(c); |
| 50 | } else { |
| 51 | Append_<false>(c); |
| 52 | } |
| 53 | } |
| 54 | |
| 55 | INLINE(void AppendOneByte(const char* chars)) { |
| 56 | if (is_one_byte_) { |
| 57 | Append_<true>(reinterpret_cast<const uint8_t*>(chars)); |
| 58 | } else { |
| 59 | Append_<false>(reinterpret_cast<const uint8_t*>(chars)); |
| 60 | } |
| 61 | } |
| 62 | |
| 63 | MUST_USE_RESULT MaybeHandle<Object> ApplyToJsonFunction( |
| 64 | Handle<Object> object, |
| 65 | Handle<Object> key); |
| 66 | |
| 67 | Result SerializeGeneric(Handle<Object> object, |
| 68 | Handle<Object> key, |
| 69 | bool deferred_comma, |
| 70 | bool deferred_key); |
| 71 | |
| 72 | template <typename ResultType, typename Char> |
| 73 | INLINE(static Handle<String> StringifyString_(Isolate* isolate, |
| 74 | Vector<Char> vector, |
| 75 | Handle<String> result)); |
| 76 | |
| 77 | // Entry point to serialize the object. |
| 78 | INLINE(Result SerializeObject(Handle<Object> obj)) { |
| 79 | return Serialize_<false>(obj, false, factory_->empty_string()); |
| 80 | } |
| 81 | |
| 82 | // Serialize an array element. |
| 83 | // The index may serve as argument for the toJSON function. |
| 84 | INLINE(Result SerializeElement(Isolate* isolate, |
| 85 | Handle<Object> object, |
| 86 | int i)) { |
| 87 | return Serialize_<false>(object, |
| 88 | false, |
| 89 | Handle<Object>(Smi::FromInt(i), isolate)); |
| 90 | } |
| 91 | |
| 92 | // Serialize a object property. |
| 93 | // The key may or may not be serialized depending on the property. |
| 94 | // The key may also serve as argument for the toJSON function. |
| 95 | INLINE(Result SerializeProperty(Handle<Object> object, |
| 96 | bool deferred_comma, |
| 97 | Handle<String> deferred_key)) { |
| 98 | DCHECK(!deferred_key.is_null()); |
| 99 | return Serialize_<true>(object, deferred_comma, deferred_key); |
| 100 | } |
| 101 | |
| 102 | template <bool deferred_string_key> |
| 103 | Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key); |
| 104 | |
| 105 | void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) { |
| 106 | if (deferred_comma) Append(','); |
| 107 | SerializeString(Handle<String>::cast(deferred_key)); |
| 108 | Append(':'); |
| 109 | } |
| 110 | |
| 111 | Result SerializeSmi(Smi* object); |
| 112 | |
| 113 | Result SerializeDouble(double number); |
| 114 | INLINE(Result SerializeHeapNumber(Handle<HeapNumber> object)) { |
| 115 | return SerializeDouble(object->value()); |
| 116 | } |
| 117 | |
| 118 | Result SerializeJSValue(Handle<JSValue> object); |
| 119 | |
| 120 | INLINE(Result SerializeJSArray(Handle<JSArray> object)); |
| 121 | INLINE(Result SerializeJSObject(Handle<JSObject> object)); |
| 122 | |
| 123 | Result SerializeJSArraySlow(Handle<JSArray> object, uint32_t length); |
| 124 | |
| 125 | void SerializeString(Handle<String> object); |
| 126 | |
| 127 | template <typename SrcChar, typename DestChar> |
| 128 | INLINE(static int SerializeStringUnchecked_(const SrcChar* src, |
| 129 | DestChar* dest, |
| 130 | int length)); |
| 131 | |
| 132 | template <bool is_one_byte, typename Char> |
| 133 | INLINE(void SerializeString_(Handle<String> string)); |
| 134 | |
| 135 | template <typename Char> |
| 136 | INLINE(static bool DoNotEscape(Char c)); |
| 137 | |
| 138 | template <typename Char> |
| 139 | INLINE(static Vector<const Char> GetCharVector(Handle<String> string)); |
| 140 | |
| 141 | Result StackPush(Handle<Object> object); |
| 142 | void StackPop(); |
| 143 | |
| 144 | INLINE(Handle<String> accumulator()) { |
| 145 | return Handle<String>(String::cast(accumulator_store_->value()), isolate_); |
| 146 | } |
| 147 | |
| 148 | INLINE(void set_accumulator(Handle<String> string)) { |
| 149 | return accumulator_store_->set_value(*string); |
| 150 | } |
| 151 | |
| 152 | Isolate* isolate_; |
| 153 | Factory* factory_; |
| 154 | // We use a value wrapper for the string accumulator to keep the |
| 155 | // (indirect) handle to it in the outermost handle scope. |
| 156 | Handle<JSValue> accumulator_store_; |
| 157 | Handle<String> current_part_; |
| 158 | Handle<String> tojson_string_; |
| 159 | Handle<JSArray> stack_; |
| 160 | int current_index_; |
| 161 | int part_length_; |
| 162 | bool is_one_byte_; |
| 163 | bool overflowed_; |
| 164 | |
| 165 | static const int kJsonEscapeTableEntrySize = 8; |
| 166 | static const char* const JsonEscapeTable; |
| 167 | }; |
| 168 | |
| 169 | |
| 170 | // Translation table to escape Latin1 characters. |
| 171 | // Table entries start at a multiple of 8 and are null-terminated. |
| 172 | const char* const BasicJsonStringifier::JsonEscapeTable = |
| 173 | "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 " |
| 174 | "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 " |
| 175 | "\\b\0 \\t\0 \\n\0 \\u000b\0 " |
| 176 | "\\f\0 \\r\0 \\u000e\0 \\u000f\0 " |
| 177 | "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 " |
| 178 | "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 " |
| 179 | "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 " |
| 180 | "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 " |
| 181 | " \0 !\0 \\\"\0 #\0 " |
| 182 | "$\0 %\0 &\0 '\0 " |
| 183 | "(\0 )\0 *\0 +\0 " |
| 184 | ",\0 -\0 .\0 /\0 " |
| 185 | "0\0 1\0 2\0 3\0 " |
| 186 | "4\0 5\0 6\0 7\0 " |
| 187 | "8\0 9\0 :\0 ;\0 " |
| 188 | "<\0 =\0 >\0 ?\0 " |
| 189 | "@\0 A\0 B\0 C\0 " |
| 190 | "D\0 E\0 F\0 G\0 " |
| 191 | "H\0 I\0 J\0 K\0 " |
| 192 | "L\0 M\0 N\0 O\0 " |
| 193 | "P\0 Q\0 R\0 S\0 " |
| 194 | "T\0 U\0 V\0 W\0 " |
| 195 | "X\0 Y\0 Z\0 [\0 " |
| 196 | "\\\\\0 ]\0 ^\0 _\0 " |
| 197 | "`\0 a\0 b\0 c\0 " |
| 198 | "d\0 e\0 f\0 g\0 " |
| 199 | "h\0 i\0 j\0 k\0 " |
| 200 | "l\0 m\0 n\0 o\0 " |
| 201 | "p\0 q\0 r\0 s\0 " |
| 202 | "t\0 u\0 v\0 w\0 " |
| 203 | "x\0 y\0 z\0 {\0 " |
| 204 | "|\0 }\0 ~\0 \177\0 " |
| 205 | "\200\0 \201\0 \202\0 \203\0 " |
| 206 | "\204\0 \205\0 \206\0 \207\0 " |
| 207 | "\210\0 \211\0 \212\0 \213\0 " |
| 208 | "\214\0 \215\0 \216\0 \217\0 " |
| 209 | "\220\0 \221\0 \222\0 \223\0 " |
| 210 | "\224\0 \225\0 \226\0 \227\0 " |
| 211 | "\230\0 \231\0 \232\0 \233\0 " |
| 212 | "\234\0 \235\0 \236\0 \237\0 " |
| 213 | "\240\0 \241\0 \242\0 \243\0 " |
| 214 | "\244\0 \245\0 \246\0 \247\0 " |
| 215 | "\250\0 \251\0 \252\0 \253\0 " |
| 216 | "\254\0 \255\0 \256\0 \257\0 " |
| 217 | "\260\0 \261\0 \262\0 \263\0 " |
| 218 | "\264\0 \265\0 \266\0 \267\0 " |
| 219 | "\270\0 \271\0 \272\0 \273\0 " |
| 220 | "\274\0 \275\0 \276\0 \277\0 " |
| 221 | "\300\0 \301\0 \302\0 \303\0 " |
| 222 | "\304\0 \305\0 \306\0 \307\0 " |
| 223 | "\310\0 \311\0 \312\0 \313\0 " |
| 224 | "\314\0 \315\0 \316\0 \317\0 " |
| 225 | "\320\0 \321\0 \322\0 \323\0 " |
| 226 | "\324\0 \325\0 \326\0 \327\0 " |
| 227 | "\330\0 \331\0 \332\0 \333\0 " |
| 228 | "\334\0 \335\0 \336\0 \337\0 " |
| 229 | "\340\0 \341\0 \342\0 \343\0 " |
| 230 | "\344\0 \345\0 \346\0 \347\0 " |
| 231 | "\350\0 \351\0 \352\0 \353\0 " |
| 232 | "\354\0 \355\0 \356\0 \357\0 " |
| 233 | "\360\0 \361\0 \362\0 \363\0 " |
| 234 | "\364\0 \365\0 \366\0 \367\0 " |
| 235 | "\370\0 \371\0 \372\0 \373\0 " |
| 236 | "\374\0 \375\0 \376\0 \377\0 "; |
| 237 | |
| 238 | |
| 239 | BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate) |
| 240 | : isolate_(isolate), |
| 241 | current_index_(0), |
| 242 | is_one_byte_(true), |
| 243 | overflowed_(false) { |
| 244 | factory_ = isolate_->factory(); |
| 245 | accumulator_store_ = Handle<JSValue>::cast( |
| 246 | Object::ToObject(isolate, factory_->empty_string()).ToHandleChecked()); |
| 247 | part_length_ = kInitialPartLength; |
| 248 | current_part_ = factory_->NewRawOneByteString(part_length_).ToHandleChecked(); |
| 249 | tojson_string_ = factory_->toJSON_string(); |
| 250 | stack_ = factory_->NewJSArray(8); |
| 251 | } |
| 252 | |
| 253 | |
| 254 | MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object) { |
| 255 | Result result = SerializeObject(object); |
| 256 | if (result == UNCHANGED) return isolate_->factory()->undefined_value(); |
| 257 | if (result == SUCCESS) { |
| 258 | ShrinkCurrentPart(); |
| 259 | Accumulate(); |
| 260 | if (overflowed_) { |
| 261 | THROW_NEW_ERROR(isolate_, NewInvalidStringLengthError(), Object); |
| 262 | } |
| 263 | return accumulator(); |
| 264 | } |
| 265 | DCHECK(result == EXCEPTION); |
| 266 | return MaybeHandle<Object>(); |
| 267 | } |
| 268 | |
| 269 | |
| 270 | MaybeHandle<Object> BasicJsonStringifier::StringifyString( |
| 271 | Isolate* isolate, Handle<String> object) { |
| 272 | static const int kJsonQuoteWorstCaseBlowup = 6; |
| 273 | static const int kSpaceForQuotes = 2; |
| 274 | int worst_case_length = |
| 275 | object->length() * kJsonQuoteWorstCaseBlowup + kSpaceForQuotes; |
| 276 | |
| 277 | if (worst_case_length > 32 * KB) { // Slow path if too large. |
| 278 | BasicJsonStringifier stringifier(isolate); |
| 279 | return stringifier.Stringify(object); |
| 280 | } |
| 281 | |
| 282 | object = String::Flatten(object); |
| 283 | DCHECK(object->IsFlat()); |
| 284 | if (object->IsOneByteRepresentationUnderneath()) { |
| 285 | Handle<String> result = isolate->factory()->NewRawOneByteString( |
| 286 | worst_case_length).ToHandleChecked(); |
| 287 | DisallowHeapAllocation no_gc; |
| 288 | return StringifyString_<SeqOneByteString>( |
| 289 | isolate, |
| 290 | object->GetFlatContent().ToOneByteVector(), |
| 291 | result); |
| 292 | } else { |
| 293 | Handle<String> result = isolate->factory()->NewRawTwoByteString( |
| 294 | worst_case_length).ToHandleChecked(); |
| 295 | DisallowHeapAllocation no_gc; |
| 296 | return StringifyString_<SeqTwoByteString>( |
| 297 | isolate, |
| 298 | object->GetFlatContent().ToUC16Vector(), |
| 299 | result); |
| 300 | } |
| 301 | } |
| 302 | |
| 303 | |
| 304 | template <typename ResultType, typename Char> |
| 305 | Handle<String> BasicJsonStringifier::StringifyString_(Isolate* isolate, |
| 306 | Vector<Char> vector, |
| 307 | Handle<String> result) { |
| 308 | DisallowHeapAllocation no_gc; |
| 309 | int final_size = 0; |
| 310 | ResultType* dest = ResultType::cast(*result); |
| 311 | dest->Set(final_size++, '\"'); |
| 312 | final_size += SerializeStringUnchecked_(vector.start(), |
| 313 | dest->GetChars() + 1, |
| 314 | vector.length()); |
| 315 | dest->Set(final_size++, '\"'); |
| 316 | return SeqString::Truncate(Handle<SeqString>::cast(result), final_size); |
| 317 | } |
| 318 | |
| 319 | |
| 320 | template <bool is_one_byte, typename Char> |
| 321 | void BasicJsonStringifier::Append_(Char c) { |
| 322 | if (is_one_byte) { |
| 323 | SeqOneByteString::cast(*current_part_)->SeqOneByteStringSet( |
| 324 | current_index_++, c); |
| 325 | } else { |
| 326 | SeqTwoByteString::cast(*current_part_)->SeqTwoByteStringSet( |
| 327 | current_index_++, c); |
| 328 | } |
| 329 | if (current_index_ == part_length_) Extend(); |
| 330 | } |
| 331 | |
| 332 | |
| 333 | template <bool is_one_byte, typename Char> |
| 334 | void BasicJsonStringifier::Append_(const Char* chars) { |
| 335 | for (; *chars != '\0'; chars++) Append_<is_one_byte, Char>(*chars); |
| 336 | } |
| 337 | |
| 338 | |
| 339 | MaybeHandle<Object> BasicJsonStringifier::ApplyToJsonFunction( |
| 340 | Handle<Object> object, Handle<Object> key) { |
| 341 | LookupIterator it(object, tojson_string_, |
| 342 | LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR); |
| 343 | Handle<Object> fun; |
| 344 | ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object); |
| 345 | if (!fun->IsJSFunction()) return object; |
| 346 | |
| 347 | // Call toJSON function. |
| 348 | if (key->IsSmi()) key = factory_->NumberToString(key); |
| 349 | Handle<Object> argv[] = { key }; |
| 350 | HandleScope scope(isolate_); |
| 351 | ASSIGN_RETURN_ON_EXCEPTION( |
| 352 | isolate_, object, |
| 353 | Execution::Call(isolate_, fun, object, 1, argv), |
| 354 | Object); |
| 355 | return scope.CloseAndEscape(object); |
| 356 | } |
| 357 | |
| 358 | |
| 359 | BasicJsonStringifier::Result BasicJsonStringifier::StackPush( |
| 360 | Handle<Object> object) { |
| 361 | StackLimitCheck check(isolate_); |
| 362 | if (check.HasOverflowed()) { |
| 363 | isolate_->StackOverflow(); |
| 364 | return EXCEPTION; |
| 365 | } |
| 366 | |
| 367 | int length = Smi::cast(stack_->length())->value(); |
| 368 | { |
| 369 | DisallowHeapAllocation no_allocation; |
| 370 | FixedArray* elements = FixedArray::cast(stack_->elements()); |
| 371 | for (int i = 0; i < length; i++) { |
| 372 | if (elements->get(i) == *object) { |
| 373 | AllowHeapAllocation allow_to_return_error; |
| 374 | Handle<Object> error; |
| 375 | MaybeHandle<Object> maybe_error = factory_->NewTypeError( |
| 376 | "circular_structure", HandleVector<Object>(NULL, 0)); |
| 377 | if (maybe_error.ToHandle(&error)) isolate_->Throw(*error); |
| 378 | return EXCEPTION; |
| 379 | } |
| 380 | } |
| 381 | } |
| 382 | JSArray::EnsureSize(stack_, length + 1); |
| 383 | FixedArray::cast(stack_->elements())->set(length, *object); |
| 384 | stack_->set_length(Smi::FromInt(length + 1)); |
| 385 | return SUCCESS; |
| 386 | } |
| 387 | |
| 388 | |
| 389 | void BasicJsonStringifier::StackPop() { |
| 390 | int length = Smi::cast(stack_->length())->value(); |
| 391 | stack_->set_length(Smi::FromInt(length - 1)); |
| 392 | } |
| 393 | |
| 394 | |
| 395 | template <bool deferred_string_key> |
| 396 | BasicJsonStringifier::Result BasicJsonStringifier::Serialize_( |
| 397 | Handle<Object> object, bool comma, Handle<Object> key) { |
| 398 | if (object->IsJSObject()) { |
| 399 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 400 | isolate_, object, |
| 401 | ApplyToJsonFunction(object, key), |
| 402 | EXCEPTION); |
| 403 | } |
| 404 | |
| 405 | if (object->IsSmi()) { |
| 406 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 407 | return SerializeSmi(Smi::cast(*object)); |
| 408 | } |
| 409 | |
| 410 | switch (HeapObject::cast(*object)->map()->instance_type()) { |
| 411 | case HEAP_NUMBER_TYPE: |
| 412 | case MUTABLE_HEAP_NUMBER_TYPE: |
| 413 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 414 | return SerializeHeapNumber(Handle<HeapNumber>::cast(object)); |
| 415 | case ODDBALL_TYPE: |
| 416 | switch (Oddball::cast(*object)->kind()) { |
| 417 | case Oddball::kFalse: |
| 418 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 419 | AppendOneByte("false"); |
| 420 | return SUCCESS; |
| 421 | case Oddball::kTrue: |
| 422 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 423 | AppendOneByte("true"); |
| 424 | return SUCCESS; |
| 425 | case Oddball::kNull: |
| 426 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 427 | AppendOneByte("null"); |
| 428 | return SUCCESS; |
| 429 | default: |
| 430 | return UNCHANGED; |
| 431 | } |
| 432 | case JS_ARRAY_TYPE: |
| 433 | if (object->IsAccessCheckNeeded()) break; |
| 434 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 435 | return SerializeJSArray(Handle<JSArray>::cast(object)); |
| 436 | case JS_VALUE_TYPE: |
| 437 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 438 | return SerializeJSValue(Handle<JSValue>::cast(object)); |
| 439 | case JS_FUNCTION_TYPE: |
| 440 | return UNCHANGED; |
| 441 | default: |
| 442 | if (object->IsString()) { |
| 443 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 444 | SerializeString(Handle<String>::cast(object)); |
| 445 | return SUCCESS; |
| 446 | } else if (object->IsJSObject()) { |
| 447 | // Go to slow path for global proxy and objects requiring access checks. |
| 448 | if (object->IsAccessCheckNeeded() || object->IsJSGlobalProxy()) break; |
| 449 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 450 | return SerializeJSObject(Handle<JSObject>::cast(object)); |
| 451 | } |
| 452 | } |
| 453 | |
| 454 | return SerializeGeneric(object, key, comma, deferred_string_key); |
| 455 | } |
| 456 | |
| 457 | |
| 458 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeGeneric( |
| 459 | Handle<Object> object, |
| 460 | Handle<Object> key, |
| 461 | bool deferred_comma, |
| 462 | bool deferred_key) { |
| 463 | Handle<JSObject> builtins(isolate_->native_context()->builtins(), isolate_); |
| 464 | Handle<JSFunction> builtin = Handle<JSFunction>::cast(Object::GetProperty( |
| 465 | isolate_, builtins, "JSONSerializeAdapter").ToHandleChecked()); |
| 466 | |
| 467 | Handle<Object> argv[] = { key, object }; |
| 468 | Handle<Object> result; |
| 469 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 470 | isolate_, result, |
| 471 | Execution::Call(isolate_, builtin, object, 2, argv), |
| 472 | EXCEPTION); |
| 473 | if (result->IsUndefined()) return UNCHANGED; |
| 474 | if (deferred_key) { |
| 475 | if (key->IsSmi()) key = factory_->NumberToString(key); |
| 476 | SerializeDeferredKey(deferred_comma, key); |
| 477 | } |
| 478 | |
| 479 | Handle<String> result_string = Handle<String>::cast(result); |
| 480 | // Shrink current part, attach it to the accumulator, also attach the result |
| 481 | // string to the accumulator, and allocate a new part. |
| 482 | ShrinkCurrentPart(); // Shrink. |
| 483 | part_length_ = kInitialPartLength; // Allocate conservatively. |
| 484 | Extend(); // Attach current part and allocate new part. |
| 485 | // Attach result string to the accumulator. |
| 486 | Handle<String> cons; |
| 487 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 488 | isolate_, cons, |
| 489 | factory_->NewConsString(accumulator(), result_string), |
| 490 | EXCEPTION); |
| 491 | set_accumulator(cons); |
| 492 | return SUCCESS; |
| 493 | } |
| 494 | |
| 495 | |
| 496 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue( |
| 497 | Handle<JSValue> object) { |
| 498 | String* class_name = object->class_name(); |
| 499 | if (class_name == isolate_->heap()->String_string()) { |
| 500 | Handle<Object> value; |
| 501 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 502 | isolate_, value, Execution::ToString(isolate_, object), EXCEPTION); |
| 503 | SerializeString(Handle<String>::cast(value)); |
| 504 | } else if (class_name == isolate_->heap()->Number_string()) { |
| 505 | Handle<Object> value; |
| 506 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 507 | isolate_, value, Execution::ToNumber(isolate_, object), EXCEPTION); |
| 508 | if (value->IsSmi()) return SerializeSmi(Smi::cast(*value)); |
| 509 | SerializeHeapNumber(Handle<HeapNumber>::cast(value)); |
| 510 | } else { |
| 511 | DCHECK(class_name == isolate_->heap()->Boolean_string()); |
| 512 | Object* value = JSValue::cast(*object)->value(); |
| 513 | DCHECK(value->IsBoolean()); |
| 514 | AppendOneByte(value->IsTrue() ? "true" : "false"); |
| 515 | } |
| 516 | return SUCCESS; |
| 517 | } |
| 518 | |
| 519 | |
| 520 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) { |
| 521 | static const int kBufferSize = 100; |
| 522 | char chars[kBufferSize]; |
| 523 | Vector<char> buffer(chars, kBufferSize); |
| 524 | AppendOneByte(IntToCString(object->value(), buffer)); |
| 525 | return SUCCESS; |
| 526 | } |
| 527 | |
| 528 | |
| 529 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble( |
| 530 | double number) { |
| 531 | if (std::isinf(number) || std::isnan(number)) { |
| 532 | AppendOneByte("null"); |
| 533 | return SUCCESS; |
| 534 | } |
| 535 | static const int kBufferSize = 100; |
| 536 | char chars[kBufferSize]; |
| 537 | Vector<char> buffer(chars, kBufferSize); |
| 538 | AppendOneByte(DoubleToCString(number, buffer)); |
| 539 | return SUCCESS; |
| 540 | } |
| 541 | |
| 542 | |
| 543 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray( |
| 544 | Handle<JSArray> object) { |
| 545 | HandleScope handle_scope(isolate_); |
| 546 | Result stack_push = StackPush(object); |
| 547 | if (stack_push != SUCCESS) return stack_push; |
| 548 | uint32_t length = 0; |
| 549 | CHECK(object->length()->ToArrayIndex(&length)); |
| 550 | Append('['); |
| 551 | switch (object->GetElementsKind()) { |
| 552 | case FAST_SMI_ELEMENTS: { |
| 553 | Handle<FixedArray> elements( |
| 554 | FixedArray::cast(object->elements()), isolate_); |
| 555 | for (uint32_t i = 0; i < length; i++) { |
| 556 | if (i > 0) Append(','); |
| 557 | SerializeSmi(Smi::cast(elements->get(i))); |
| 558 | } |
| 559 | break; |
| 560 | } |
| 561 | case FAST_DOUBLE_ELEMENTS: { |
| 562 | // Empty array is FixedArray but not FixedDoubleArray. |
| 563 | if (length == 0) break; |
| 564 | Handle<FixedDoubleArray> elements( |
| 565 | FixedDoubleArray::cast(object->elements()), isolate_); |
| 566 | for (uint32_t i = 0; i < length; i++) { |
| 567 | if (i > 0) Append(','); |
| 568 | SerializeDouble(elements->get_scalar(i)); |
| 569 | } |
| 570 | break; |
| 571 | } |
| 572 | case FAST_ELEMENTS: { |
| 573 | Handle<FixedArray> elements( |
| 574 | FixedArray::cast(object->elements()), isolate_); |
| 575 | for (uint32_t i = 0; i < length; i++) { |
| 576 | if (i > 0) Append(','); |
| 577 | Result result = |
| 578 | SerializeElement(isolate_, |
| 579 | Handle<Object>(elements->get(i), isolate_), |
| 580 | i); |
| 581 | if (result == SUCCESS) continue; |
| 582 | if (result == UNCHANGED) { |
| 583 | AppendOneByte("null"); |
| 584 | } else { |
| 585 | return result; |
| 586 | } |
| 587 | } |
| 588 | break; |
| 589 | } |
| 590 | // TODO(yangguo): The FAST_HOLEY_* cases could be handled in a faster way. |
| 591 | // They resemble the non-holey cases except that a prototype chain lookup |
| 592 | // is necessary for holes. |
| 593 | default: { |
| 594 | Result result = SerializeJSArraySlow(object, length); |
| 595 | if (result != SUCCESS) return result; |
| 596 | break; |
| 597 | } |
| 598 | } |
| 599 | Append(']'); |
| 600 | StackPop(); |
| 601 | current_part_ = handle_scope.CloseAndEscape(current_part_); |
| 602 | return SUCCESS; |
| 603 | } |
| 604 | |
| 605 | |
| 606 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArraySlow( |
| 607 | Handle<JSArray> object, uint32_t length) { |
| 608 | for (uint32_t i = 0; i < length; i++) { |
| 609 | if (i > 0) Append(','); |
| 610 | Handle<Object> element; |
| 611 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 612 | isolate_, element, |
| 613 | Object::GetElement(isolate_, object, i), |
| 614 | EXCEPTION); |
| 615 | if (element->IsUndefined()) { |
| 616 | AppendOneByte("null"); |
| 617 | } else { |
| 618 | Result result = SerializeElement(isolate_, element, i); |
| 619 | if (result == SUCCESS) continue; |
| 620 | if (result == UNCHANGED) { |
| 621 | AppendOneByte("null"); |
| 622 | } else { |
| 623 | return result; |
| 624 | } |
| 625 | } |
| 626 | } |
| 627 | return SUCCESS; |
| 628 | } |
| 629 | |
| 630 | |
| 631 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject( |
| 632 | Handle<JSObject> object) { |
| 633 | HandleScope handle_scope(isolate_); |
| 634 | Result stack_push = StackPush(object); |
| 635 | if (stack_push != SUCCESS) return stack_push; |
| 636 | DCHECK(!object->IsJSGlobalProxy() && !object->IsGlobalObject()); |
| 637 | |
| 638 | Append('{'); |
| 639 | bool comma = false; |
| 640 | |
| 641 | if (object->HasFastProperties() && |
| 642 | !object->HasIndexedInterceptor() && |
| 643 | !object->HasNamedInterceptor() && |
| 644 | object->elements()->length() == 0) { |
| 645 | Handle<Map> map(object->map()); |
| 646 | for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) { |
| 647 | Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_); |
| 648 | // TODO(rossberg): Should this throw? |
| 649 | if (!name->IsString()) continue; |
| 650 | Handle<String> key = Handle<String>::cast(name); |
| 651 | PropertyDetails details = map->instance_descriptors()->GetDetails(i); |
| 652 | if (details.IsDontEnum()) continue; |
| 653 | Handle<Object> property; |
| 654 | if (details.type() == FIELD && *map == object->map()) { |
| 655 | property = Handle<Object>(object->RawFastPropertyAt( |
| 656 | FieldIndex::ForDescriptor(*map, i)), isolate_); |
| 657 | } else { |
| 658 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 659 | isolate_, property, |
| 660 | Object::GetPropertyOrElement(object, key), |
| 661 | EXCEPTION); |
| 662 | } |
| 663 | Result result = SerializeProperty(property, comma, key); |
| 664 | if (!comma && result == SUCCESS) comma = true; |
| 665 | if (result == EXCEPTION) return result; |
| 666 | } |
| 667 | } else { |
| 668 | Handle<FixedArray> contents; |
| 669 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 670 | isolate_, contents, |
| 671 | JSReceiver::GetKeys(object, JSReceiver::OWN_ONLY), |
| 672 | EXCEPTION); |
| 673 | |
| 674 | for (int i = 0; i < contents->length(); i++) { |
| 675 | Object* key = contents->get(i); |
| 676 | Handle<String> key_handle; |
| 677 | MaybeHandle<Object> maybe_property; |
| 678 | if (key->IsString()) { |
| 679 | key_handle = Handle<String>(String::cast(key), isolate_); |
| 680 | maybe_property = Object::GetPropertyOrElement(object, key_handle); |
| 681 | } else { |
| 682 | DCHECK(key->IsNumber()); |
| 683 | key_handle = factory_->NumberToString(Handle<Object>(key, isolate_)); |
| 684 | uint32_t index; |
| 685 | if (key->IsSmi()) { |
| 686 | maybe_property = Object::GetElement( |
| 687 | isolate_, object, Smi::cast(key)->value()); |
| 688 | } else if (key_handle->AsArrayIndex(&index)) { |
| 689 | maybe_property = Object::GetElement(isolate_, object, index); |
| 690 | } else { |
| 691 | maybe_property = Object::GetPropertyOrElement(object, key_handle); |
| 692 | } |
| 693 | } |
| 694 | Handle<Object> property; |
| 695 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 696 | isolate_, property, maybe_property, EXCEPTION); |
| 697 | Result result = SerializeProperty(property, comma, key_handle); |
| 698 | if (!comma && result == SUCCESS) comma = true; |
| 699 | if (result == EXCEPTION) return result; |
| 700 | } |
| 701 | } |
| 702 | |
| 703 | Append('}'); |
| 704 | StackPop(); |
| 705 | current_part_ = handle_scope.CloseAndEscape(current_part_); |
| 706 | return SUCCESS; |
| 707 | } |
| 708 | |
| 709 | |
| 710 | void BasicJsonStringifier::ShrinkCurrentPart() { |
| 711 | DCHECK(current_index_ < part_length_); |
| 712 | current_part_ = SeqString::Truncate(Handle<SeqString>::cast(current_part_), |
| 713 | current_index_); |
| 714 | } |
| 715 | |
| 716 | |
| 717 | void BasicJsonStringifier::Accumulate() { |
| 718 | if (accumulator()->length() + current_part_->length() > String::kMaxLength) { |
| 719 | // Screw it. Simply set the flag and carry on. Throw exception at the end. |
| 720 | set_accumulator(factory_->empty_string()); |
| 721 | overflowed_ = true; |
| 722 | } else { |
| 723 | set_accumulator(factory_->NewConsString(accumulator(), |
| 724 | current_part_).ToHandleChecked()); |
| 725 | } |
| 726 | } |
| 727 | |
| 728 | |
| 729 | void BasicJsonStringifier::Extend() { |
| 730 | Accumulate(); |
| 731 | if (part_length_ <= kMaxPartLength / kPartLengthGrowthFactor) { |
| 732 | part_length_ *= kPartLengthGrowthFactor; |
| 733 | } |
| 734 | if (is_one_byte_) { |
| 735 | current_part_ = |
| 736 | factory_->NewRawOneByteString(part_length_).ToHandleChecked(); |
| 737 | } else { |
| 738 | current_part_ = |
| 739 | factory_->NewRawTwoByteString(part_length_).ToHandleChecked(); |
| 740 | } |
| 741 | DCHECK(!current_part_.is_null()); |
| 742 | current_index_ = 0; |
| 743 | } |
| 744 | |
| 745 | |
| 746 | void BasicJsonStringifier::ChangeEncoding() { |
| 747 | ShrinkCurrentPart(); |
| 748 | Accumulate(); |
| 749 | current_part_ = |
| 750 | factory_->NewRawTwoByteString(part_length_).ToHandleChecked(); |
| 751 | DCHECK(!current_part_.is_null()); |
| 752 | current_index_ = 0; |
| 753 | is_one_byte_ = false; |
| 754 | } |
| 755 | |
| 756 | |
| 757 | template <typename SrcChar, typename DestChar> |
| 758 | int BasicJsonStringifier::SerializeStringUnchecked_(const SrcChar* src, |
| 759 | DestChar* dest, |
| 760 | int length) { |
| 761 | DestChar* dest_start = dest; |
| 762 | |
| 763 | // Assert that uc16 character is not truncated down to 8 bit. |
| 764 | // The <uc16, char> version of this method must not be called. |
| 765 | DCHECK(sizeof(*dest) >= sizeof(*src)); |
| 766 | |
| 767 | for (int i = 0; i < length; i++) { |
| 768 | SrcChar c = src[i]; |
| 769 | if (DoNotEscape(c)) { |
| 770 | *(dest++) = static_cast<DestChar>(c); |
| 771 | } else { |
| 772 | const uint8_t* chars = reinterpret_cast<const uint8_t*>( |
| 773 | &JsonEscapeTable[c * kJsonEscapeTableEntrySize]); |
| 774 | while (*chars != '\0') *(dest++) = *(chars++); |
| 775 | } |
| 776 | } |
| 777 | |
| 778 | return static_cast<int>(dest - dest_start); |
| 779 | } |
| 780 | |
| 781 | |
| 782 | template <bool is_one_byte, typename Char> |
| 783 | void BasicJsonStringifier::SerializeString_(Handle<String> string) { |
| 784 | int length = string->length(); |
| 785 | Append_<is_one_byte, char>('"'); |
| 786 | // We make a rough estimate to find out if the current string can be |
| 787 | // serialized without allocating a new string part. The worst case length of |
| 788 | // an escaped character is 6. Shifting the remainin string length right by 3 |
| 789 | // is a more pessimistic estimate, but faster to calculate. |
| 790 | |
| 791 | if (((part_length_ - current_index_) >> 3) > length) { |
| 792 | DisallowHeapAllocation no_gc; |
| 793 | Vector<const Char> vector = GetCharVector<Char>(string); |
| 794 | if (is_one_byte) { |
| 795 | current_index_ += SerializeStringUnchecked_( |
| 796 | vector.start(), |
| 797 | SeqOneByteString::cast(*current_part_)->GetChars() + current_index_, |
| 798 | length); |
| 799 | } else { |
| 800 | current_index_ += SerializeStringUnchecked_( |
| 801 | vector.start(), |
| 802 | SeqTwoByteString::cast(*current_part_)->GetChars() + current_index_, |
| 803 | length); |
| 804 | } |
| 805 | } else { |
| 806 | String* string_location = NULL; |
| 807 | Vector<const Char> vector(NULL, 0); |
| 808 | for (int i = 0; i < length; i++) { |
| 809 | // If GC moved the string, we need to refresh the vector. |
| 810 | if (*string != string_location) { |
| 811 | DisallowHeapAllocation no_gc; |
| 812 | // This does not actually prevent the string from being relocated later. |
| 813 | vector = GetCharVector<Char>(string); |
| 814 | string_location = *string; |
| 815 | } |
| 816 | Char c = vector[i]; |
| 817 | if (DoNotEscape(c)) { |
| 818 | Append_<is_one_byte, Char>(c); |
| 819 | } else { |
| 820 | Append_<is_one_byte, uint8_t>(reinterpret_cast<const uint8_t*>( |
| 821 | &JsonEscapeTable[c * kJsonEscapeTableEntrySize])); |
| 822 | } |
| 823 | } |
| 824 | } |
| 825 | |
| 826 | Append_<is_one_byte, uint8_t>('"'); |
| 827 | } |
| 828 | |
| 829 | |
| 830 | template <> |
| 831 | bool BasicJsonStringifier::DoNotEscape(uint8_t c) { |
| 832 | return c >= '#' && c <= '~' && c != '\\'; |
| 833 | } |
| 834 | |
| 835 | |
| 836 | template <> |
| 837 | bool BasicJsonStringifier::DoNotEscape(uint16_t c) { |
| 838 | return c >= '#' && c != '\\' && c != 0x7f; |
| 839 | } |
| 840 | |
| 841 | |
| 842 | template <> |
| 843 | Vector<const uint8_t> BasicJsonStringifier::GetCharVector( |
| 844 | Handle<String> string) { |
| 845 | String::FlatContent flat = string->GetFlatContent(); |
| 846 | DCHECK(flat.IsOneByte()); |
| 847 | return flat.ToOneByteVector(); |
| 848 | } |
| 849 | |
| 850 | |
| 851 | template <> |
| 852 | Vector<const uc16> BasicJsonStringifier::GetCharVector(Handle<String> string) { |
| 853 | String::FlatContent flat = string->GetFlatContent(); |
| 854 | DCHECK(flat.IsTwoByte()); |
| 855 | return flat.ToUC16Vector(); |
| 856 | } |
| 857 | |
| 858 | |
| 859 | void BasicJsonStringifier::SerializeString(Handle<String> object) { |
| 860 | object = String::Flatten(object); |
| 861 | if (is_one_byte_) { |
| 862 | if (object->IsOneByteRepresentationUnderneath()) { |
| 863 | SerializeString_<true, uint8_t>(object); |
| 864 | } else { |
| 865 | ChangeEncoding(); |
| 866 | SerializeString(object); |
| 867 | } |
| 868 | } else { |
| 869 | if (object->IsOneByteRepresentationUnderneath()) { |
| 870 | SerializeString_<false, uint8_t>(object); |
| 871 | } else { |
| 872 | SerializeString_<false, uc16>(object); |
| 873 | } |
| 874 | } |
| 875 | } |
| 876 | |
| 877 | } } // namespace v8::internal |
| 878 | |
| 879 | #endif // V8_JSON_STRINGIFIER_H_ |