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" |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 11 | #include "src/string-builder.h" |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 12 | #include "src/utils.h" |
| 13 | |
| 14 | namespace v8 { |
| 15 | namespace internal { |
| 16 | |
| 17 | class BasicJsonStringifier BASE_EMBEDDED { |
| 18 | public: |
| 19 | explicit BasicJsonStringifier(Isolate* isolate); |
| 20 | |
| 21 | MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object); |
| 22 | |
| 23 | MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString( |
| 24 | Isolate* isolate, |
| 25 | Handle<String> object)); |
| 26 | |
| 27 | private: |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 28 | enum Result { UNCHANGED, SUCCESS, EXCEPTION }; |
| 29 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 30 | MUST_USE_RESULT MaybeHandle<Object> ApplyToJsonFunction( |
| 31 | Handle<Object> object, |
| 32 | Handle<Object> key); |
| 33 | |
| 34 | Result SerializeGeneric(Handle<Object> object, |
| 35 | Handle<Object> key, |
| 36 | bool deferred_comma, |
| 37 | bool deferred_key); |
| 38 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 39 | // Entry point to serialize the object. |
| 40 | INLINE(Result SerializeObject(Handle<Object> obj)) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 41 | return Serialize_<false>(obj, false, factory()->empty_string()); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | // Serialize an array element. |
| 45 | // The index may serve as argument for the toJSON function. |
| 46 | INLINE(Result SerializeElement(Isolate* isolate, |
| 47 | Handle<Object> object, |
| 48 | int i)) { |
| 49 | return Serialize_<false>(object, |
| 50 | false, |
| 51 | Handle<Object>(Smi::FromInt(i), isolate)); |
| 52 | } |
| 53 | |
| 54 | // Serialize a object property. |
| 55 | // The key may or may not be serialized depending on the property. |
| 56 | // The key may also serve as argument for the toJSON function. |
| 57 | INLINE(Result SerializeProperty(Handle<Object> object, |
| 58 | bool deferred_comma, |
| 59 | Handle<String> deferred_key)) { |
| 60 | DCHECK(!deferred_key.is_null()); |
| 61 | return Serialize_<true>(object, deferred_comma, deferred_key); |
| 62 | } |
| 63 | |
| 64 | template <bool deferred_string_key> |
| 65 | Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key); |
| 66 | |
| 67 | void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 68 | if (deferred_comma) builder_.AppendCharacter(','); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 69 | SerializeString(Handle<String>::cast(deferred_key)); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 70 | builder_.AppendCharacter(':'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | Result SerializeSmi(Smi* object); |
| 74 | |
| 75 | Result SerializeDouble(double number); |
| 76 | INLINE(Result SerializeHeapNumber(Handle<HeapNumber> object)) { |
| 77 | return SerializeDouble(object->value()); |
| 78 | } |
| 79 | |
| 80 | Result SerializeJSValue(Handle<JSValue> object); |
| 81 | |
| 82 | INLINE(Result SerializeJSArray(Handle<JSArray> object)); |
| 83 | INLINE(Result SerializeJSObject(Handle<JSObject> object)); |
| 84 | |
| 85 | Result SerializeJSArraySlow(Handle<JSArray> object, uint32_t length); |
| 86 | |
| 87 | void SerializeString(Handle<String> object); |
| 88 | |
| 89 | template <typename SrcChar, typename DestChar> |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 90 | INLINE(static void SerializeStringUnchecked_( |
| 91 | Vector<const SrcChar> src, |
| 92 | IncrementalStringBuilder::NoExtend<DestChar>* dest)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 93 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 94 | template <typename SrcChar, typename DestChar> |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 95 | INLINE(void SerializeString_(Handle<String> string)); |
| 96 | |
| 97 | template <typename Char> |
| 98 | INLINE(static bool DoNotEscape(Char c)); |
| 99 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 100 | Result StackPush(Handle<Object> object); |
| 101 | void StackPop(); |
| 102 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 103 | Factory* factory() { return isolate_->factory(); } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 104 | |
| 105 | Isolate* isolate_; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 106 | IncrementalStringBuilder builder_; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 107 | Handle<String> tojson_string_; |
| 108 | Handle<JSArray> stack_; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 109 | |
| 110 | static const int kJsonEscapeTableEntrySize = 8; |
| 111 | static const char* const JsonEscapeTable; |
| 112 | }; |
| 113 | |
| 114 | |
| 115 | // Translation table to escape Latin1 characters. |
| 116 | // Table entries start at a multiple of 8 and are null-terminated. |
| 117 | const char* const BasicJsonStringifier::JsonEscapeTable = |
| 118 | "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 " |
| 119 | "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 " |
| 120 | "\\b\0 \\t\0 \\n\0 \\u000b\0 " |
| 121 | "\\f\0 \\r\0 \\u000e\0 \\u000f\0 " |
| 122 | "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 " |
| 123 | "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 " |
| 124 | "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 " |
| 125 | "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 " |
| 126 | " \0 !\0 \\\"\0 #\0 " |
| 127 | "$\0 %\0 &\0 '\0 " |
| 128 | "(\0 )\0 *\0 +\0 " |
| 129 | ",\0 -\0 .\0 /\0 " |
| 130 | "0\0 1\0 2\0 3\0 " |
| 131 | "4\0 5\0 6\0 7\0 " |
| 132 | "8\0 9\0 :\0 ;\0 " |
| 133 | "<\0 =\0 >\0 ?\0 " |
| 134 | "@\0 A\0 B\0 C\0 " |
| 135 | "D\0 E\0 F\0 G\0 " |
| 136 | "H\0 I\0 J\0 K\0 " |
| 137 | "L\0 M\0 N\0 O\0 " |
| 138 | "P\0 Q\0 R\0 S\0 " |
| 139 | "T\0 U\0 V\0 W\0 " |
| 140 | "X\0 Y\0 Z\0 [\0 " |
| 141 | "\\\\\0 ]\0 ^\0 _\0 " |
| 142 | "`\0 a\0 b\0 c\0 " |
| 143 | "d\0 e\0 f\0 g\0 " |
| 144 | "h\0 i\0 j\0 k\0 " |
| 145 | "l\0 m\0 n\0 o\0 " |
| 146 | "p\0 q\0 r\0 s\0 " |
| 147 | "t\0 u\0 v\0 w\0 " |
| 148 | "x\0 y\0 z\0 {\0 " |
| 149 | "|\0 }\0 ~\0 \177\0 " |
| 150 | "\200\0 \201\0 \202\0 \203\0 " |
| 151 | "\204\0 \205\0 \206\0 \207\0 " |
| 152 | "\210\0 \211\0 \212\0 \213\0 " |
| 153 | "\214\0 \215\0 \216\0 \217\0 " |
| 154 | "\220\0 \221\0 \222\0 \223\0 " |
| 155 | "\224\0 \225\0 \226\0 \227\0 " |
| 156 | "\230\0 \231\0 \232\0 \233\0 " |
| 157 | "\234\0 \235\0 \236\0 \237\0 " |
| 158 | "\240\0 \241\0 \242\0 \243\0 " |
| 159 | "\244\0 \245\0 \246\0 \247\0 " |
| 160 | "\250\0 \251\0 \252\0 \253\0 " |
| 161 | "\254\0 \255\0 \256\0 \257\0 " |
| 162 | "\260\0 \261\0 \262\0 \263\0 " |
| 163 | "\264\0 \265\0 \266\0 \267\0 " |
| 164 | "\270\0 \271\0 \272\0 \273\0 " |
| 165 | "\274\0 \275\0 \276\0 \277\0 " |
| 166 | "\300\0 \301\0 \302\0 \303\0 " |
| 167 | "\304\0 \305\0 \306\0 \307\0 " |
| 168 | "\310\0 \311\0 \312\0 \313\0 " |
| 169 | "\314\0 \315\0 \316\0 \317\0 " |
| 170 | "\320\0 \321\0 \322\0 \323\0 " |
| 171 | "\324\0 \325\0 \326\0 \327\0 " |
| 172 | "\330\0 \331\0 \332\0 \333\0 " |
| 173 | "\334\0 \335\0 \336\0 \337\0 " |
| 174 | "\340\0 \341\0 \342\0 \343\0 " |
| 175 | "\344\0 \345\0 \346\0 \347\0 " |
| 176 | "\350\0 \351\0 \352\0 \353\0 " |
| 177 | "\354\0 \355\0 \356\0 \357\0 " |
| 178 | "\360\0 \361\0 \362\0 \363\0 " |
| 179 | "\364\0 \365\0 \366\0 \367\0 " |
| 180 | "\370\0 \371\0 \372\0 \373\0 " |
| 181 | "\374\0 \375\0 \376\0 \377\0 "; |
| 182 | |
| 183 | |
| 184 | BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate) |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 185 | : isolate_(isolate), builder_(isolate) { |
| 186 | tojson_string_ = factory()->toJSON_string(); |
| 187 | stack_ = factory()->NewJSArray(8); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | |
| 191 | MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object) { |
| 192 | Result result = SerializeObject(object); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 193 | if (result == UNCHANGED) return factory()->undefined_value(); |
| 194 | if (result == SUCCESS) return builder_.Finish(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 195 | DCHECK(result == EXCEPTION); |
| 196 | return MaybeHandle<Object>(); |
| 197 | } |
| 198 | |
| 199 | |
| 200 | MaybeHandle<Object> BasicJsonStringifier::StringifyString( |
| 201 | Isolate* isolate, Handle<String> object) { |
| 202 | static const int kJsonQuoteWorstCaseBlowup = 6; |
| 203 | static const int kSpaceForQuotes = 2; |
| 204 | int worst_case_length = |
| 205 | object->length() * kJsonQuoteWorstCaseBlowup + kSpaceForQuotes; |
| 206 | |
| 207 | if (worst_case_length > 32 * KB) { // Slow path if too large. |
| 208 | BasicJsonStringifier stringifier(isolate); |
| 209 | return stringifier.Stringify(object); |
| 210 | } |
| 211 | |
| 212 | object = String::Flatten(object); |
| 213 | DCHECK(object->IsFlat()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 214 | Handle<SeqString> result; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 215 | if (object->IsOneByteRepresentationUnderneath()) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 216 | result = isolate->factory() |
| 217 | ->NewRawOneByteString(worst_case_length) |
| 218 | .ToHandleChecked(); |
| 219 | IncrementalStringBuilder::NoExtendString<uint8_t> no_extend( |
| 220 | result, worst_case_length); |
| 221 | no_extend.Append('\"'); |
| 222 | SerializeStringUnchecked_(object->GetFlatContent().ToOneByteVector(), |
| 223 | &no_extend); |
| 224 | no_extend.Append('\"'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 225 | } else { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 226 | result = isolate->factory() |
| 227 | ->NewRawTwoByteString(worst_case_length) |
| 228 | .ToHandleChecked(); |
| 229 | IncrementalStringBuilder::NoExtendString<uc16> no_extend(result, |
| 230 | worst_case_length); |
| 231 | no_extend.Append('\"'); |
| 232 | SerializeStringUnchecked_(object->GetFlatContent().ToUC16Vector(), |
| 233 | &no_extend); |
| 234 | no_extend.Append('\"'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 235 | } |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 236 | return result; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | |
| 240 | MaybeHandle<Object> BasicJsonStringifier::ApplyToJsonFunction( |
| 241 | Handle<Object> object, Handle<Object> key) { |
| 242 | LookupIterator it(object, tojson_string_, |
| 243 | LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR); |
| 244 | Handle<Object> fun; |
| 245 | ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object); |
| 246 | if (!fun->IsJSFunction()) return object; |
| 247 | |
| 248 | // Call toJSON function. |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 249 | if (key->IsSmi()) key = factory()->NumberToString(key); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 250 | Handle<Object> argv[] = { key }; |
| 251 | HandleScope scope(isolate_); |
| 252 | ASSIGN_RETURN_ON_EXCEPTION( |
| 253 | isolate_, object, |
| 254 | Execution::Call(isolate_, fun, object, 1, argv), |
| 255 | Object); |
| 256 | return scope.CloseAndEscape(object); |
| 257 | } |
| 258 | |
| 259 | |
| 260 | BasicJsonStringifier::Result BasicJsonStringifier::StackPush( |
| 261 | Handle<Object> object) { |
| 262 | StackLimitCheck check(isolate_); |
| 263 | if (check.HasOverflowed()) { |
| 264 | isolate_->StackOverflow(); |
| 265 | return EXCEPTION; |
| 266 | } |
| 267 | |
| 268 | int length = Smi::cast(stack_->length())->value(); |
| 269 | { |
| 270 | DisallowHeapAllocation no_allocation; |
| 271 | FixedArray* elements = FixedArray::cast(stack_->elements()); |
| 272 | for (int i = 0; i < length; i++) { |
| 273 | if (elements->get(i) == *object) { |
| 274 | AllowHeapAllocation allow_to_return_error; |
| 275 | Handle<Object> error; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 276 | MaybeHandle<Object> maybe_error = factory()->NewTypeError( |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 277 | "circular_structure", HandleVector<Object>(NULL, 0)); |
| 278 | if (maybe_error.ToHandle(&error)) isolate_->Throw(*error); |
| 279 | return EXCEPTION; |
| 280 | } |
| 281 | } |
| 282 | } |
| 283 | JSArray::EnsureSize(stack_, length + 1); |
| 284 | FixedArray::cast(stack_->elements())->set(length, *object); |
| 285 | stack_->set_length(Smi::FromInt(length + 1)); |
| 286 | return SUCCESS; |
| 287 | } |
| 288 | |
| 289 | |
| 290 | void BasicJsonStringifier::StackPop() { |
| 291 | int length = Smi::cast(stack_->length())->value(); |
| 292 | stack_->set_length(Smi::FromInt(length - 1)); |
| 293 | } |
| 294 | |
| 295 | |
| 296 | template <bool deferred_string_key> |
| 297 | BasicJsonStringifier::Result BasicJsonStringifier::Serialize_( |
| 298 | Handle<Object> object, bool comma, Handle<Object> key) { |
| 299 | if (object->IsJSObject()) { |
| 300 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 301 | isolate_, object, |
| 302 | ApplyToJsonFunction(object, key), |
| 303 | EXCEPTION); |
| 304 | } |
| 305 | |
| 306 | if (object->IsSmi()) { |
| 307 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 308 | return SerializeSmi(Smi::cast(*object)); |
| 309 | } |
| 310 | |
| 311 | switch (HeapObject::cast(*object)->map()->instance_type()) { |
| 312 | case HEAP_NUMBER_TYPE: |
| 313 | case MUTABLE_HEAP_NUMBER_TYPE: |
| 314 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 315 | return SerializeHeapNumber(Handle<HeapNumber>::cast(object)); |
| 316 | case ODDBALL_TYPE: |
| 317 | switch (Oddball::cast(*object)->kind()) { |
| 318 | case Oddball::kFalse: |
| 319 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 320 | builder_.AppendCString("false"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 321 | return SUCCESS; |
| 322 | case Oddball::kTrue: |
| 323 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 324 | builder_.AppendCString("true"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 325 | return SUCCESS; |
| 326 | case Oddball::kNull: |
| 327 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 328 | builder_.AppendCString("null"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 329 | return SUCCESS; |
| 330 | default: |
| 331 | return UNCHANGED; |
| 332 | } |
| 333 | case JS_ARRAY_TYPE: |
| 334 | if (object->IsAccessCheckNeeded()) break; |
| 335 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 336 | return SerializeJSArray(Handle<JSArray>::cast(object)); |
| 337 | case JS_VALUE_TYPE: |
| 338 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 339 | return SerializeJSValue(Handle<JSValue>::cast(object)); |
| 340 | case JS_FUNCTION_TYPE: |
| 341 | return UNCHANGED; |
| 342 | default: |
| 343 | if (object->IsString()) { |
| 344 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 345 | SerializeString(Handle<String>::cast(object)); |
| 346 | return SUCCESS; |
| 347 | } else if (object->IsJSObject()) { |
| 348 | // Go to slow path for global proxy and objects requiring access checks. |
| 349 | if (object->IsAccessCheckNeeded() || object->IsJSGlobalProxy()) break; |
| 350 | if (deferred_string_key) SerializeDeferredKey(comma, key); |
| 351 | return SerializeJSObject(Handle<JSObject>::cast(object)); |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | return SerializeGeneric(object, key, comma, deferred_string_key); |
| 356 | } |
| 357 | |
| 358 | |
| 359 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeGeneric( |
| 360 | Handle<Object> object, |
| 361 | Handle<Object> key, |
| 362 | bool deferred_comma, |
| 363 | bool deferred_key) { |
| 364 | Handle<JSObject> builtins(isolate_->native_context()->builtins(), isolate_); |
| 365 | Handle<JSFunction> builtin = Handle<JSFunction>::cast(Object::GetProperty( |
| 366 | isolate_, builtins, "JSONSerializeAdapter").ToHandleChecked()); |
| 367 | |
| 368 | Handle<Object> argv[] = { key, object }; |
| 369 | Handle<Object> result; |
| 370 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 371 | isolate_, result, |
| 372 | Execution::Call(isolate_, builtin, object, 2, argv), |
| 373 | EXCEPTION); |
| 374 | if (result->IsUndefined()) return UNCHANGED; |
| 375 | if (deferred_key) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 376 | if (key->IsSmi()) key = factory()->NumberToString(key); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 377 | SerializeDeferredKey(deferred_comma, key); |
| 378 | } |
| 379 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 380 | builder_.AppendString(Handle<String>::cast(result)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 381 | return SUCCESS; |
| 382 | } |
| 383 | |
| 384 | |
| 385 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue( |
| 386 | Handle<JSValue> object) { |
| 387 | String* class_name = object->class_name(); |
| 388 | if (class_name == isolate_->heap()->String_string()) { |
| 389 | Handle<Object> value; |
| 390 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 391 | isolate_, value, Execution::ToString(isolate_, object), EXCEPTION); |
| 392 | SerializeString(Handle<String>::cast(value)); |
| 393 | } else if (class_name == isolate_->heap()->Number_string()) { |
| 394 | Handle<Object> value; |
| 395 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 396 | isolate_, value, Execution::ToNumber(isolate_, object), EXCEPTION); |
| 397 | if (value->IsSmi()) return SerializeSmi(Smi::cast(*value)); |
| 398 | SerializeHeapNumber(Handle<HeapNumber>::cast(value)); |
| 399 | } else { |
| 400 | DCHECK(class_name == isolate_->heap()->Boolean_string()); |
| 401 | Object* value = JSValue::cast(*object)->value(); |
| 402 | DCHECK(value->IsBoolean()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 403 | builder_.AppendCString(value->IsTrue() ? "true" : "false"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 404 | } |
| 405 | return SUCCESS; |
| 406 | } |
| 407 | |
| 408 | |
| 409 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) { |
| 410 | static const int kBufferSize = 100; |
| 411 | char chars[kBufferSize]; |
| 412 | Vector<char> buffer(chars, kBufferSize); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 413 | builder_.AppendCString(IntToCString(object->value(), buffer)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 414 | return SUCCESS; |
| 415 | } |
| 416 | |
| 417 | |
| 418 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble( |
| 419 | double number) { |
| 420 | if (std::isinf(number) || std::isnan(number)) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 421 | builder_.AppendCString("null"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 422 | return SUCCESS; |
| 423 | } |
| 424 | static const int kBufferSize = 100; |
| 425 | char chars[kBufferSize]; |
| 426 | Vector<char> buffer(chars, kBufferSize); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 427 | builder_.AppendCString(DoubleToCString(number, buffer)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 428 | return SUCCESS; |
| 429 | } |
| 430 | |
| 431 | |
| 432 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray( |
| 433 | Handle<JSArray> object) { |
| 434 | HandleScope handle_scope(isolate_); |
| 435 | Result stack_push = StackPush(object); |
| 436 | if (stack_push != SUCCESS) return stack_push; |
| 437 | uint32_t length = 0; |
| 438 | CHECK(object->length()->ToArrayIndex(&length)); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 439 | builder_.AppendCharacter('['); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 440 | switch (object->GetElementsKind()) { |
| 441 | case FAST_SMI_ELEMENTS: { |
| 442 | Handle<FixedArray> elements( |
| 443 | FixedArray::cast(object->elements()), isolate_); |
| 444 | for (uint32_t i = 0; i < length; i++) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 445 | if (i > 0) builder_.AppendCharacter(','); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 446 | SerializeSmi(Smi::cast(elements->get(i))); |
| 447 | } |
| 448 | break; |
| 449 | } |
| 450 | case FAST_DOUBLE_ELEMENTS: { |
| 451 | // Empty array is FixedArray but not FixedDoubleArray. |
| 452 | if (length == 0) break; |
| 453 | Handle<FixedDoubleArray> elements( |
| 454 | FixedDoubleArray::cast(object->elements()), isolate_); |
| 455 | for (uint32_t i = 0; i < length; i++) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 456 | if (i > 0) builder_.AppendCharacter(','); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 457 | SerializeDouble(elements->get_scalar(i)); |
| 458 | } |
| 459 | break; |
| 460 | } |
| 461 | case FAST_ELEMENTS: { |
| 462 | Handle<FixedArray> elements( |
| 463 | FixedArray::cast(object->elements()), isolate_); |
| 464 | for (uint32_t i = 0; i < length; i++) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 465 | if (i > 0) builder_.AppendCharacter(','); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 466 | Result result = |
| 467 | SerializeElement(isolate_, |
| 468 | Handle<Object>(elements->get(i), isolate_), |
| 469 | i); |
| 470 | if (result == SUCCESS) continue; |
| 471 | if (result == UNCHANGED) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 472 | builder_.AppendCString("null"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 473 | } else { |
| 474 | return result; |
| 475 | } |
| 476 | } |
| 477 | break; |
| 478 | } |
| 479 | // TODO(yangguo): The FAST_HOLEY_* cases could be handled in a faster way. |
| 480 | // They resemble the non-holey cases except that a prototype chain lookup |
| 481 | // is necessary for holes. |
| 482 | default: { |
| 483 | Result result = SerializeJSArraySlow(object, length); |
| 484 | if (result != SUCCESS) return result; |
| 485 | break; |
| 486 | } |
| 487 | } |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 488 | builder_.AppendCharacter(']'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 489 | StackPop(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 490 | return SUCCESS; |
| 491 | } |
| 492 | |
| 493 | |
| 494 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArraySlow( |
| 495 | Handle<JSArray> object, uint32_t length) { |
| 496 | for (uint32_t i = 0; i < length; i++) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 497 | if (i > 0) builder_.AppendCharacter(','); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 498 | Handle<Object> element; |
| 499 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 500 | isolate_, element, |
| 501 | Object::GetElement(isolate_, object, i), |
| 502 | EXCEPTION); |
| 503 | if (element->IsUndefined()) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 504 | builder_.AppendCString("null"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 505 | } else { |
| 506 | Result result = SerializeElement(isolate_, element, i); |
| 507 | if (result == SUCCESS) continue; |
| 508 | if (result == UNCHANGED) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 509 | builder_.AppendCString("null"); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 510 | } else { |
| 511 | return result; |
| 512 | } |
| 513 | } |
| 514 | } |
| 515 | return SUCCESS; |
| 516 | } |
| 517 | |
| 518 | |
| 519 | BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject( |
| 520 | Handle<JSObject> object) { |
| 521 | HandleScope handle_scope(isolate_); |
| 522 | Result stack_push = StackPush(object); |
| 523 | if (stack_push != SUCCESS) return stack_push; |
| 524 | DCHECK(!object->IsJSGlobalProxy() && !object->IsGlobalObject()); |
| 525 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 526 | builder_.AppendCharacter('{'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 527 | bool comma = false; |
| 528 | |
| 529 | if (object->HasFastProperties() && |
| 530 | !object->HasIndexedInterceptor() && |
| 531 | !object->HasNamedInterceptor() && |
| 532 | object->elements()->length() == 0) { |
| 533 | Handle<Map> map(object->map()); |
| 534 | for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) { |
| 535 | Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_); |
| 536 | // TODO(rossberg): Should this throw? |
| 537 | if (!name->IsString()) continue; |
| 538 | Handle<String> key = Handle<String>::cast(name); |
| 539 | PropertyDetails details = map->instance_descriptors()->GetDetails(i); |
| 540 | if (details.IsDontEnum()) continue; |
| 541 | Handle<Object> property; |
| 542 | if (details.type() == FIELD && *map == object->map()) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 543 | FieldIndex field_index = FieldIndex::ForDescriptor(*map, i); |
| 544 | Isolate* isolate = object->GetIsolate(); |
| 545 | if (object->IsUnboxedDoubleField(field_index)) { |
| 546 | double value = object->RawFastDoublePropertyAt(field_index); |
| 547 | property = isolate->factory()->NewHeapNumber(value); |
| 548 | |
| 549 | } else { |
| 550 | property = handle(object->RawFastPropertyAt(field_index), isolate); |
| 551 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 552 | } else { |
| 553 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 554 | isolate_, property, |
| 555 | Object::GetPropertyOrElement(object, key), |
| 556 | EXCEPTION); |
| 557 | } |
| 558 | Result result = SerializeProperty(property, comma, key); |
| 559 | if (!comma && result == SUCCESS) comma = true; |
| 560 | if (result == EXCEPTION) return result; |
| 561 | } |
| 562 | } else { |
| 563 | Handle<FixedArray> contents; |
| 564 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 565 | isolate_, contents, |
| 566 | JSReceiver::GetKeys(object, JSReceiver::OWN_ONLY), |
| 567 | EXCEPTION); |
| 568 | |
| 569 | for (int i = 0; i < contents->length(); i++) { |
| 570 | Object* key = contents->get(i); |
| 571 | Handle<String> key_handle; |
| 572 | MaybeHandle<Object> maybe_property; |
| 573 | if (key->IsString()) { |
| 574 | key_handle = Handle<String>(String::cast(key), isolate_); |
| 575 | maybe_property = Object::GetPropertyOrElement(object, key_handle); |
| 576 | } else { |
| 577 | DCHECK(key->IsNumber()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 578 | key_handle = factory()->NumberToString(Handle<Object>(key, isolate_)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 579 | uint32_t index; |
| 580 | if (key->IsSmi()) { |
| 581 | maybe_property = Object::GetElement( |
| 582 | isolate_, object, Smi::cast(key)->value()); |
| 583 | } else if (key_handle->AsArrayIndex(&index)) { |
| 584 | maybe_property = Object::GetElement(isolate_, object, index); |
| 585 | } else { |
| 586 | maybe_property = Object::GetPropertyOrElement(object, key_handle); |
| 587 | } |
| 588 | } |
| 589 | Handle<Object> property; |
| 590 | ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
| 591 | isolate_, property, maybe_property, EXCEPTION); |
| 592 | Result result = SerializeProperty(property, comma, key_handle); |
| 593 | if (!comma && result == SUCCESS) comma = true; |
| 594 | if (result == EXCEPTION) return result; |
| 595 | } |
| 596 | } |
| 597 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 598 | builder_.AppendCharacter('}'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 599 | StackPop(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 600 | return SUCCESS; |
| 601 | } |
| 602 | |
| 603 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 604 | template <typename SrcChar, typename DestChar> |
| 605 | void BasicJsonStringifier::SerializeStringUnchecked_( |
| 606 | Vector<const SrcChar> src, |
| 607 | IncrementalStringBuilder::NoExtend<DestChar>* dest) { |
| 608 | // Assert that uc16 character is not truncated down to 8 bit. |
| 609 | // The <uc16, char> version of this method must not be called. |
| 610 | DCHECK(sizeof(DestChar) >= sizeof(SrcChar)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 611 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 612 | for (int i = 0; i < src.length(); i++) { |
| 613 | SrcChar c = src[i]; |
| 614 | if (DoNotEscape(c)) { |
| 615 | dest->Append(c); |
| 616 | } else { |
| 617 | dest->AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]); |
| 618 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 619 | } |
| 620 | } |
| 621 | |
| 622 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 623 | template <typename SrcChar, typename DestChar> |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 624 | void BasicJsonStringifier::SerializeString_(Handle<String> string) { |
| 625 | int length = string->length(); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 626 | builder_.Append<uint8_t, DestChar>('"'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 627 | // We make a rough estimate to find out if the current string can be |
| 628 | // serialized without allocating a new string part. The worst case length of |
| 629 | // an escaped character is 6. Shifting the remainin string length right by 3 |
| 630 | // is a more pessimistic estimate, but faster to calculate. |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 631 | int worst_case_length = length << 3; |
| 632 | if (builder_.CurrentPartCanFit(worst_case_length)) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 633 | DisallowHeapAllocation no_gc; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 634 | Vector<const SrcChar> vector = string->GetCharVector<SrcChar>(); |
| 635 | IncrementalStringBuilder::NoExtendBuilder<DestChar> no_extend( |
| 636 | &builder_, worst_case_length); |
| 637 | SerializeStringUnchecked_(vector, &no_extend); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 638 | } else { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 639 | FlatStringReader reader(isolate_, string); |
| 640 | for (int i = 0; i < reader.length(); i++) { |
| 641 | SrcChar c = reader.Get<SrcChar>(i); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 642 | if (DoNotEscape(c)) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 643 | builder_.Append<SrcChar, DestChar>(c); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 644 | } else { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 645 | builder_.AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 646 | } |
| 647 | } |
| 648 | } |
| 649 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 650 | builder_.Append<uint8_t, DestChar>('"'); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 651 | } |
| 652 | |
| 653 | |
| 654 | template <> |
| 655 | bool BasicJsonStringifier::DoNotEscape(uint8_t c) { |
| 656 | return c >= '#' && c <= '~' && c != '\\'; |
| 657 | } |
| 658 | |
| 659 | |
| 660 | template <> |
| 661 | bool BasicJsonStringifier::DoNotEscape(uint16_t c) { |
| 662 | return c >= '#' && c != '\\' && c != 0x7f; |
| 663 | } |
| 664 | |
| 665 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 666 | void BasicJsonStringifier::SerializeString(Handle<String> object) { |
| 667 | object = String::Flatten(object); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 668 | if (builder_.CurrentEncoding() == String::ONE_BYTE_ENCODING) { |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 669 | if (object->IsOneByteRepresentationUnderneath()) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 670 | SerializeString_<uint8_t, uint8_t>(object); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 671 | } else { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 672 | builder_.ChangeEncoding(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 673 | SerializeString(object); |
| 674 | } |
| 675 | } else { |
| 676 | if (object->IsOneByteRepresentationUnderneath()) { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 677 | SerializeString_<uint8_t, uc16>(object); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 678 | } else { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame^] | 679 | SerializeString_<uc16, uc16>(object); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 680 | } |
| 681 | } |
| 682 | } |
| 683 | |
| 684 | } } // namespace v8::internal |
| 685 | |
| 686 | #endif // V8_JSON_STRINGIFIER_H_ |