1 /*
2 * Copyright (C) 2009 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "config.h"
27 #include "JSONObject.h"
28
29 #include "BooleanObject.h"
30 #include "Error.h"
31 #include "ExceptionHelpers.h"
32 #include "JSArray.h"
33 #include "LiteralParser.h"
34 #include "PropertyNameArray.h"
35 #include <wtf/MathExtras.h>
36
37 namespace JSC {
38
39 ASSERT_CLASS_FITS_IN_CELL(JSONObject);
40
41 static JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState*, JSObject*, JSValue, const ArgList&);
42 static JSValue JSC_HOST_CALL JSONProtoFuncStringify(ExecState*, JSObject*, JSValue, const ArgList&);
43
44 }
45
46 #include "JSONObject.lut.h"
47
48 namespace JSC {
49
50 // PropertyNameForFunctionCall objects must be on the stack, since the JSValue that they create is not marked.
51 class PropertyNameForFunctionCall {
52 public:
53 PropertyNameForFunctionCall(const Identifier&);
54 PropertyNameForFunctionCall(unsigned);
55
56 JSValue value(ExecState*) const;
57
58 private:
59 const Identifier* m_identifier;
60 unsigned m_number;
61 mutable JSValue m_value;
62 };
63
64 class Stringifier : public Noncopyable {
65 public:
66 Stringifier(ExecState*, JSValue replacer, JSValue space);
67 ~Stringifier();
68 JSValue stringify(JSValue);
69
70 void markAggregate(MarkStack&);
71
72 private:
73 typedef UString StringBuilder;
74
75 class Holder {
76 public:
77 Holder(JSObject*);
78
object() const79 JSObject* object() const { return m_object; }
80
81 bool appendNextProperty(Stringifier&, StringBuilder&);
82
83 private:
84 JSObject* const m_object;
85 const bool m_isArray;
86 bool m_isJSArray;
87 unsigned m_index;
88 unsigned m_size;
89 RefPtr<PropertyNameArrayData> m_propertyNames;
90 };
91
92 friend class Holder;
93
94 static void appendQuotedString(StringBuilder&, const UString&);
95
96 JSValue toJSON(JSValue, const PropertyNameForFunctionCall&);
97
98 enum StringifyResult { StringifyFailed, StringifySucceeded, StringifyFailedDueToUndefinedValue };
99 StringifyResult appendStringifiedValue(StringBuilder&, JSValue, JSObject* holder, const PropertyNameForFunctionCall&);
100
101 bool willIndent() const;
102 void indent();
103 void unindent();
104 void startNewLine(StringBuilder&) const;
105
106 Stringifier* const m_nextStringifierToMark;
107 ExecState* const m_exec;
108 const JSValue m_replacer;
109 bool m_usingArrayReplacer;
110 PropertyNameArray m_arrayReplacerPropertyNames;
111 CallType m_replacerCallType;
112 CallData m_replacerCallData;
113 const UString m_gap;
114
115 HashSet<JSObject*> m_holderCycleDetector;
116 Vector<Holder, 16> m_holderStack;
117 UString m_repeatedGap;
118 UString m_indent;
119 };
120
121 // ------------------------------ helper functions --------------------------------
122
unwrapBoxedPrimitive(JSValue value)123 static inline JSValue unwrapBoxedPrimitive(JSValue value)
124 {
125 if (!value.isObject())
126 return value;
127 if (!asObject(value)->inherits(&NumberObject::info) && !asObject(value)->inherits(&StringObject::info) && !asObject(value)->inherits(&BooleanObject::info))
128 return value;
129 return static_cast<JSWrapperObject*>(asObject(value))->internalValue();
130 }
131
gap(JSValue space)132 static inline UString gap(JSValue space)
133 {
134 space = unwrapBoxedPrimitive(space);
135
136 // If the space value is a number, create a gap string with that number of spaces.
137 double spaceCount;
138 if (space.getNumber(spaceCount)) {
139 const int maxSpaceCount = 100;
140 int count;
141 if (spaceCount > maxSpaceCount)
142 count = maxSpaceCount;
143 else if (!(spaceCount > 0))
144 count = 0;
145 else
146 count = static_cast<int>(spaceCount);
147 UChar spaces[maxSpaceCount];
148 for (int i = 0; i < count; ++i)
149 spaces[i] = ' ';
150 return UString(spaces, count);
151 }
152
153 // If the space value is a string, use it as the gap string, otherwise use no gap string.
154 return space.getString();
155 }
156
157 // ------------------------------ PropertyNameForFunctionCall --------------------------------
158
PropertyNameForFunctionCall(const Identifier & identifier)159 inline PropertyNameForFunctionCall::PropertyNameForFunctionCall(const Identifier& identifier)
160 : m_identifier(&identifier)
161 {
162 }
163
PropertyNameForFunctionCall(unsigned number)164 inline PropertyNameForFunctionCall::PropertyNameForFunctionCall(unsigned number)
165 : m_identifier(0)
166 , m_number(number)
167 {
168 }
169
value(ExecState * exec) const170 JSValue PropertyNameForFunctionCall::value(ExecState* exec) const
171 {
172 if (!m_value) {
173 if (m_identifier)
174 m_value = jsString(exec, m_identifier->ustring());
175 else
176 m_value = jsNumber(exec, m_number);
177 }
178 return m_value;
179 }
180
181 // ------------------------------ Stringifier --------------------------------
182
Stringifier(ExecState * exec,JSValue replacer,JSValue space)183 Stringifier::Stringifier(ExecState* exec, JSValue replacer, JSValue space)
184 : m_nextStringifierToMark(exec->globalData().firstStringifierToMark)
185 , m_exec(exec)
186 , m_replacer(replacer)
187 , m_usingArrayReplacer(false)
188 , m_arrayReplacerPropertyNames(exec)
189 , m_replacerCallType(CallTypeNone)
190 , m_gap(gap(space))
191 {
192 exec->globalData().firstStringifierToMark = this;
193
194 if (!m_replacer.isObject())
195 return;
196
197 if (asObject(m_replacer)->inherits(&JSArray::info)) {
198 m_usingArrayReplacer = true;
199 JSObject* array = asObject(m_replacer);
200 unsigned length = array->get(exec, exec->globalData().propertyNames->length).toUInt32(exec);
201 for (unsigned i = 0; i < length; ++i) {
202 JSValue name = array->get(exec, i);
203 if (exec->hadException())
204 break;
205 UString propertyName;
206 if (!name.getString(propertyName))
207 continue;
208 if (exec->hadException())
209 return;
210 m_arrayReplacerPropertyNames.add(Identifier(exec, propertyName));
211 }
212 return;
213 }
214
215 m_replacerCallType = asObject(m_replacer)->getCallData(m_replacerCallData);
216 }
217
~Stringifier()218 Stringifier::~Stringifier()
219 {
220 ASSERT(m_exec->globalData().firstStringifierToMark == this);
221 m_exec->globalData().firstStringifierToMark = m_nextStringifierToMark;
222 }
223
markAggregate(MarkStack & markStack)224 void Stringifier::markAggregate(MarkStack& markStack)
225 {
226 for (Stringifier* stringifier = this; stringifier; stringifier = stringifier->m_nextStringifierToMark) {
227 size_t size = m_holderStack.size();
228 for (size_t i = 0; i < size; ++i)
229 markStack.append(m_holderStack[i].object());
230 }
231 }
232
stringify(JSValue value)233 JSValue Stringifier::stringify(JSValue value)
234 {
235 JSObject* object = constructEmptyObject(m_exec);
236 if (m_exec->hadException())
237 return jsNull();
238
239 PropertyNameForFunctionCall emptyPropertyName(m_exec->globalData().propertyNames->emptyIdentifier);
240 object->putDirect(m_exec->globalData().propertyNames->emptyIdentifier, value);
241
242 StringBuilder result;
243 if (appendStringifiedValue(result, value, object, emptyPropertyName) != StringifySucceeded)
244 return jsUndefined();
245 if (m_exec->hadException())
246 return jsNull();
247
248 return jsString(m_exec, result);
249 }
250
appendQuotedString(StringBuilder & builder,const UString & value)251 void Stringifier::appendQuotedString(StringBuilder& builder, const UString& value)
252 {
253 int length = value.size();
254
255 // String length plus 2 for quote marks plus 8 so we can accomodate a few escaped characters.
256 builder.reserveCapacity(builder.size() + length + 2 + 8);
257
258 builder.append('"');
259
260 const UChar* data = value.data();
261 for (int i = 0; i < length; ++i) {
262 int start = i;
263 while (i < length && (data[i] > 0x1F && data[i] != '"' && data[i] != '\\'))
264 ++i;
265 builder.append(data + start, i - start);
266 if (i >= length)
267 break;
268 switch (data[i]) {
269 case '\t':
270 builder.append('\\');
271 builder.append('t');
272 break;
273 case '\r':
274 builder.append('\\');
275 builder.append('r');
276 break;
277 case '\n':
278 builder.append('\\');
279 builder.append('n');
280 break;
281 case '\f':
282 builder.append('\\');
283 builder.append('f');
284 break;
285 case '\b':
286 builder.append('\\');
287 builder.append('b');
288 break;
289 case '"':
290 builder.append('\\');
291 builder.append('"');
292 break;
293 case '\\':
294 builder.append('\\');
295 builder.append('\\');
296 break;
297 default:
298 static const char hexDigits[] = "0123456789abcdef";
299 UChar ch = data[i];
300 UChar hex[] = { '\\', 'u', hexDigits[(ch >> 12) & 0xF], hexDigits[(ch >> 8) & 0xF], hexDigits[(ch >> 4) & 0xF], hexDigits[ch & 0xF] };
301 builder.append(hex, sizeof(hex) / sizeof(UChar));
302 break;
303 }
304 }
305
306 builder.append('"');
307 }
308
toJSON(JSValue value,const PropertyNameForFunctionCall & propertyName)309 inline JSValue Stringifier::toJSON(JSValue value, const PropertyNameForFunctionCall& propertyName)
310 {
311 ASSERT(!m_exec->hadException());
312 if (!value.isObject() || !asObject(value)->hasProperty(m_exec, m_exec->globalData().propertyNames->toJSON))
313 return value;
314
315 JSValue toJSONFunction = asObject(value)->get(m_exec, m_exec->globalData().propertyNames->toJSON);
316 if (m_exec->hadException())
317 return jsNull();
318
319 if (!toJSONFunction.isObject())
320 return value;
321
322 JSObject* object = asObject(toJSONFunction);
323 CallData callData;
324 CallType callType = object->getCallData(callData);
325 if (callType == CallTypeNone)
326 return value;
327
328 JSValue list[] = { propertyName.value(m_exec) };
329 ArgList args(list, sizeof(list) / sizeof(JSValue));
330 return call(m_exec, object, callType, callData, value, args);
331 }
332
appendStringifiedValue(StringBuilder & builder,JSValue value,JSObject * holder,const PropertyNameForFunctionCall & propertyName)333 Stringifier::StringifyResult Stringifier::appendStringifiedValue(StringBuilder& builder, JSValue value, JSObject* holder, const PropertyNameForFunctionCall& propertyName)
334 {
335 // Call the toJSON function.
336 value = toJSON(value, propertyName);
337 if (m_exec->hadException())
338 return StringifyFailed;
339
340 // Call the replacer function.
341 if (m_replacerCallType != CallTypeNone) {
342 JSValue list[] = { propertyName.value(m_exec), value };
343 ArgList args(list, sizeof(list) / sizeof(JSValue));
344 value = call(m_exec, m_replacer, m_replacerCallType, m_replacerCallData, holder, args);
345 if (m_exec->hadException())
346 return StringifyFailed;
347 }
348
349 if (value.isUndefined() && !holder->inherits(&JSArray::info))
350 return StringifyFailedDueToUndefinedValue;
351
352 if (value.isNull()) {
353 builder.append("null");
354 return StringifySucceeded;
355 }
356
357 value = unwrapBoxedPrimitive(value);
358
359 if (value.isBoolean()) {
360 builder.append(value.getBoolean() ? "true" : "false");
361 return StringifySucceeded;
362 }
363
364 UString stringValue;
365 if (value.getString(stringValue)) {
366 appendQuotedString(builder, stringValue);
367 return StringifySucceeded;
368 }
369
370 double numericValue;
371 if (value.getNumber(numericValue)) {
372 if (!isfinite(numericValue))
373 builder.append("null");
374 else
375 builder.append(UString::from(numericValue));
376 return StringifySucceeded;
377 }
378
379 if (!value.isObject())
380 return StringifyFailed;
381
382 JSObject* object = asObject(value);
383
384 // Handle cycle detection, and put the holder on the stack.
385 if (!m_holderCycleDetector.add(object).second) {
386 throwError(m_exec, TypeError, "JSON.stringify cannot serialize cyclic structures.");
387 return StringifyFailed;
388 }
389 bool holderStackWasEmpty = m_holderStack.isEmpty();
390 m_holderStack.append(object);
391 if (!holderStackWasEmpty)
392 return StringifySucceeded;
393
394 // If this is the outermost call, then loop to handle everything on the holder stack.
395 TimeoutChecker localTimeoutChecker(m_exec->globalData().timeoutChecker);
396 localTimeoutChecker.reset();
397 unsigned tickCount = localTimeoutChecker.ticksUntilNextCheck();
398 do {
399 while (m_holderStack.last().appendNextProperty(*this, builder)) {
400 if (m_exec->hadException())
401 return StringifyFailed;
402 if (!--tickCount) {
403 if (localTimeoutChecker.didTimeOut(m_exec)) {
404 m_exec->setException(createInterruptedExecutionException(&m_exec->globalData()));
405 return StringifyFailed;
406 }
407 tickCount = localTimeoutChecker.ticksUntilNextCheck();
408 }
409 }
410 m_holderCycleDetector.remove(m_holderStack.last().object());
411 m_holderStack.removeLast();
412 } while (!m_holderStack.isEmpty());
413 return StringifySucceeded;
414 }
415
willIndent() const416 inline bool Stringifier::willIndent() const
417 {
418 return !m_gap.isEmpty();
419 }
420
indent()421 inline void Stringifier::indent()
422 {
423 // Use a single shared string, m_repeatedGap, so we don't keep allocating new ones as we indent and unindent.
424 int newSize = m_indent.size() + m_gap.size();
425 if (newSize > m_repeatedGap.size())
426 m_repeatedGap.append(m_gap);
427 ASSERT(newSize <= m_repeatedGap.size());
428 m_indent = m_repeatedGap.substr(0, newSize);
429 }
430
unindent()431 inline void Stringifier::unindent()
432 {
433 ASSERT(m_indent.size() >= m_gap.size());
434 m_indent = m_repeatedGap.substr(0, m_indent.size() - m_gap.size());
435 }
436
startNewLine(StringBuilder & builder) const437 inline void Stringifier::startNewLine(StringBuilder& builder) const
438 {
439 if (m_gap.isEmpty())
440 return;
441 builder.append('\n');
442 builder.append(m_indent);
443 }
444
Holder(JSObject * object)445 inline Stringifier::Holder::Holder(JSObject* object)
446 : m_object(object)
447 , m_isArray(object->inherits(&JSArray::info))
448 , m_index(0)
449 {
450 }
451
appendNextProperty(Stringifier & stringifier,StringBuilder & builder)452 bool Stringifier::Holder::appendNextProperty(Stringifier& stringifier, StringBuilder& builder)
453 {
454 ASSERT(m_index <= m_size);
455
456 ExecState* exec = stringifier.m_exec;
457
458 // First time through, initialize.
459 if (!m_index) {
460 if (m_isArray) {
461 m_isJSArray = isJSArray(&exec->globalData(), m_object);
462 m_size = m_object->get(exec, exec->globalData().propertyNames->length).toUInt32(exec);
463 builder.append('[');
464 } else {
465 if (stringifier.m_usingArrayReplacer)
466 m_propertyNames = stringifier.m_arrayReplacerPropertyNames.data();
467 else {
468 PropertyNameArray objectPropertyNames(exec);
469 m_object->getPropertyNames(exec, objectPropertyNames);
470 m_propertyNames = objectPropertyNames.releaseData();
471 }
472 m_size = m_propertyNames->propertyNameVector().size();
473 builder.append('{');
474 }
475 stringifier.indent();
476 }
477
478 // Last time through, finish up and return false.
479 if (m_index == m_size) {
480 stringifier.unindent();
481 if (m_size && builder[builder.size() - 1] != '{')
482 stringifier.startNewLine(builder);
483 builder.append(m_isArray ? ']' : '}');
484 return false;
485 }
486
487 // Handle a single element of the array or object.
488 unsigned index = m_index++;
489 unsigned rollBackPoint = 0;
490 StringifyResult stringifyResult;
491 if (m_isArray) {
492 // Get the value.
493 JSValue value;
494 if (m_isJSArray && asArray(m_object)->canGetIndex(index))
495 value = asArray(m_object)->getIndex(index);
496 else {
497 PropertySlot slot(m_object);
498 if (!m_object->getOwnPropertySlot(exec, index, slot))
499 slot.setUndefined();
500 if (exec->hadException())
501 return false;
502 value = slot.getValue(exec, index);
503 }
504
505 // Append the separator string.
506 if (index)
507 builder.append(',');
508 stringifier.startNewLine(builder);
509
510 // Append the stringified value.
511 stringifyResult = stringifier.appendStringifiedValue(builder, value, m_object, index);
512 } else {
513 // Get the value.
514 PropertySlot slot(m_object);
515 Identifier& propertyName = m_propertyNames->propertyNameVector()[index];
516 if (!m_object->getOwnPropertySlot(exec, propertyName, slot))
517 return true;
518 JSValue value = slot.getValue(exec, propertyName);
519 if (exec->hadException())
520 return false;
521
522 rollBackPoint = builder.size();
523
524 // Append the separator string.
525 if (builder[rollBackPoint - 1] != '{')
526 builder.append(',');
527 stringifier.startNewLine(builder);
528
529 // Append the property name.
530 appendQuotedString(builder, propertyName.ustring());
531 builder.append(':');
532 if (stringifier.willIndent())
533 builder.append(' ');
534
535 // Append the stringified value.
536 stringifyResult = stringifier.appendStringifiedValue(builder, value, m_object, propertyName);
537 }
538
539 // From this point on, no access to the this pointer or to any members, because the
540 // Holder object may have moved if the call to stringify pushed a new Holder onto
541 // m_holderStack.
542
543 switch (stringifyResult) {
544 case StringifyFailed:
545 builder.append("null");
546 break;
547 case StringifySucceeded:
548 break;
549 case StringifyFailedDueToUndefinedValue:
550 // This only occurs when get an undefined value for an object property.
551 // In this case we don't want the separator and property name that we
552 // already appended, so roll back.
553 builder = builder.substr(0, rollBackPoint);
554 break;
555 }
556
557 return true;
558 }
559
560 // ------------------------------ JSONObject --------------------------------
561
562 const ClassInfo JSONObject::info = { "JSON", 0, 0, ExecState::jsonTable };
563
564 /* Source for JSONObject.lut.h
565 @begin jsonTable
566 parse JSONProtoFuncParse DontEnum|Function 1
567 stringify JSONProtoFuncStringify DontEnum|Function 1
568 @end
569 */
570
571 // ECMA 15.8
572
getOwnPropertySlot(ExecState * exec,const Identifier & propertyName,PropertySlot & slot)573 bool JSONObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
574 {
575 const HashEntry* entry = ExecState::jsonTable(exec)->entry(exec, propertyName);
576 if (!entry)
577 return JSObject::getOwnPropertySlot(exec, propertyName, slot);
578
579 ASSERT(entry->attributes() & Function);
580 setUpStaticFunctionSlot(exec, entry, this, propertyName, slot);
581 return true;
582 }
583
markStringifiers(MarkStack & markStack,Stringifier * stringifier)584 void JSONObject::markStringifiers(MarkStack& markStack, Stringifier* stringifier)
585 {
586 stringifier->markAggregate(markStack);
587 }
588
589 class Walker {
590 public:
Walker(ExecState * exec,JSObject * function,CallType callType,CallData callData)591 Walker(ExecState* exec, JSObject* function, CallType callType, CallData callData)
592 : m_exec(exec)
593 , m_function(function)
594 , m_callType(callType)
595 , m_callData(callData)
596 {
597 }
598 JSValue walk(JSValue unfiltered);
599 private:
callReviver(JSValue property,JSValue unfiltered)600 JSValue callReviver(JSValue property, JSValue unfiltered)
601 {
602 JSValue args[] = { property, unfiltered };
603 ArgList argList(args, 2);
604 return call(m_exec, m_function, m_callType, m_callData, jsNull(), argList);
605 }
606
607 friend class Holder;
608
609 ExecState* m_exec;
610 JSObject* m_function;
611 CallType m_callType;
612 CallData m_callData;
613 };
614
615 enum WalkerState { StateUnknown, ArrayStartState, ArrayStartVisitMember, ArrayEndVisitMember,
616 ObjectStartState, ObjectStartVisitMember, ObjectEndVisitMember };
walk(JSValue unfiltered)617 NEVER_INLINE JSValue Walker::walk(JSValue unfiltered)
618 {
619 Vector<PropertyNameArray, 16> propertyStack;
620 Vector<uint32_t, 16> indexStack;
621 Vector<JSObject*, 16> objectStack;
622 Vector<JSArray*, 16> arrayStack;
623
624 Vector<WalkerState, 16> stateStack;
625 WalkerState state = StateUnknown;
626 JSValue inValue = unfiltered;
627 JSValue outValue = jsNull();
628 while (1) {
629 switch (state) {
630 arrayStartState:
631 case ArrayStartState: {
632 ASSERT(inValue.isObject());
633 ASSERT(isJSArray(&m_exec->globalData(), asObject(inValue)));
634 JSArray* array = asArray(inValue);
635 arrayStack.append(array);
636 indexStack.append(0);
637 // fallthrough
638 }
639 arrayStartVisitMember:
640 case ArrayStartVisitMember: {
641 JSArray* array = arrayStack.last();
642 uint32_t index = indexStack.last();
643 if (index == array->length()) {
644 outValue = array;
645 arrayStack.removeLast();
646 indexStack.removeLast();
647 break;
648 }
649 inValue = array->getIndex(index);
650 if (inValue.isObject()) {
651 stateStack.append(ArrayEndVisitMember);
652 goto stateUnknown;
653 } else
654 outValue = inValue;
655 // fallthrough
656 }
657 case ArrayEndVisitMember: {
658 JSArray* array = arrayStack.last();
659 array->setIndex(indexStack.last(), callReviver(jsString(m_exec, UString::from(indexStack.last())), outValue));
660 if (m_exec->hadException())
661 return jsNull();
662 indexStack.last()++;
663 goto arrayStartVisitMember;
664 }
665 objectStartState:
666 case ObjectStartState: {
667 ASSERT(inValue.isObject());
668 ASSERT(!isJSArray(&m_exec->globalData(), asObject(inValue)));
669 JSObject* object = asObject(inValue);
670 objectStack.append(object);
671 indexStack.append(0);
672 propertyStack.append(PropertyNameArray(m_exec));
673 object->getPropertyNames(m_exec, propertyStack.last());
674 // fallthrough
675 }
676 objectStartVisitMember:
677 case ObjectStartVisitMember: {
678 JSObject* object = objectStack.last();
679 uint32_t index = indexStack.last();
680 PropertyNameArray& properties = propertyStack.last();
681 if (index == properties.size()) {
682 outValue = object;
683 objectStack.removeLast();
684 indexStack.removeLast();
685 propertyStack.removeLast();
686 break;
687 }
688 PropertySlot slot;
689 object->getOwnPropertySlot(m_exec, properties[index], slot);
690 inValue = slot.getValue(m_exec, properties[index]);
691 ASSERT(!m_exec->hadException());
692 if (inValue.isObject()) {
693 stateStack.append(ObjectEndVisitMember);
694 goto stateUnknown;
695 } else
696 outValue = inValue;
697 // fallthrough
698 }
699 case ObjectEndVisitMember: {
700 JSObject* object = objectStack.last();
701 Identifier prop = propertyStack.last()[indexStack.last()];
702 PutPropertySlot slot;
703 object->put(m_exec, prop, callReviver(jsString(m_exec, prop.ustring()), outValue), slot);
704 if (m_exec->hadException())
705 return jsNull();
706 indexStack.last()++;
707 goto objectStartVisitMember;
708 }
709 stateUnknown:
710 case StateUnknown:
711 if (!inValue.isObject()) {
712 outValue = inValue;
713 break;
714 }
715 if (isJSArray(&m_exec->globalData(), asObject(inValue)))
716 goto arrayStartState;
717 goto objectStartState;
718 }
719 if (stateStack.isEmpty())
720 break;
721 state = stateStack.last();
722 stateStack.removeLast();
723 }
724 return callReviver(jsEmptyString(m_exec), outValue);
725 }
726
727 // ECMA-262 v5 15.12.2
JSONProtoFuncParse(ExecState * exec,JSObject *,JSValue,const ArgList & args)728 JSValue JSC_HOST_CALL JSONProtoFuncParse(ExecState* exec, JSObject*, JSValue, const ArgList& args)
729 {
730 if (args.isEmpty())
731 return throwError(exec, GeneralError, "JSON.parse requires at least one parameter");
732 JSValue value = args.at(0);
733 UString source = value.toString(exec);
734 if (exec->hadException())
735 return jsNull();
736
737 LiteralParser jsonParser(exec, source, LiteralParser::StrictJSON);
738 JSValue unfiltered = jsonParser.tryLiteralParse();
739 if (!unfiltered)
740 return throwError(exec, SyntaxError, "Unable to parse JSON string");
741
742 if (args.size() < 2)
743 return unfiltered;
744
745 JSValue function = args.at(1);
746 CallData callData;
747 CallType callType = function.getCallData(callData);
748 if (callType == CallTypeNone)
749 return unfiltered;
750 return Walker(exec, asObject(function), callType, callData).walk(unfiltered);
751 }
752
753 // ECMA-262 v5 15.12.3
JSONProtoFuncStringify(ExecState * exec,JSObject *,JSValue,const ArgList & args)754 JSValue JSC_HOST_CALL JSONProtoFuncStringify(ExecState* exec, JSObject*, JSValue, const ArgList& args)
755 {
756 if (args.isEmpty())
757 return throwError(exec, GeneralError, "No input to stringify");
758 JSValue value = args.at(0);
759 JSValue replacer = args.at(1);
760 JSValue space = args.at(2);
761 return Stringifier(exec, replacer, space).stringify(value);
762 }
763
764 } // namespace JSC
765