Rename some JSC API functions/types.
[WebKit-https.git] / Source / JavaScriptCore / API / JSValue.mm
1 /*
2  * Copyright (C) 2013-2018 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
28 #import "APICast.h"
29 #import "DateInstance.h"
30 #import "Error.h"
31 #import "Exception.h"
32 #import "JavaScriptCore.h"
33 #import "JSContextInternal.h"
34 #import "JSVirtualMachineInternal.h"
35 #import "JSValueInternal.h"
36 #import "JSWrapperMap.h"
37 #import "ObjcRuntimeExtras.h"
38 #import "JSCInlines.h"
39 #import "JSCJSValue.h"
40 #import "Strong.h"
41 #import "StrongInlines.h"
42 #import <wtf/Expected.h>
43 #import <wtf/HashMap.h>
44 #import <wtf/HashSet.h>
45 #import <wtf/Lock.h>
46 #import <wtf/ObjcRuntimeExtras.h>
47 #import <wtf/Vector.h>
48 #import <wtf/text/WTFString.h>
49 #import <wtf/text/StringHash.h>
50
51 #if ENABLE(REMOTE_INSPECTOR)
52 #import "CallFrame.h"
53 #import "JSGlobalObject.h"
54 #import "JSGlobalObjectInspectorController.h"
55 #endif
56
57 #if JSC_OBJC_API_ENABLED
58
59 NSString * const JSPropertyDescriptorWritableKey = @"writable";
60 NSString * const JSPropertyDescriptorEnumerableKey = @"enumerable";
61 NSString * const JSPropertyDescriptorConfigurableKey = @"configurable";
62 NSString * const JSPropertyDescriptorValueKey = @"value";
63 NSString * const JSPropertyDescriptorGetKey = @"get";
64 NSString * const JSPropertyDescriptorSetKey = @"set";
65
66 @implementation JSValue {
67     JSValueRef m_value;
68 }
69
70 - (void)dealloc
71 {
72     JSValueUnprotect([_context JSGlobalContextRef], m_value);
73     [_context release];
74     _context = nil;
75     [super dealloc];
76 }
77
78 - (NSString *)description
79 {
80     if (id wrapped = tryUnwrapObjcObject([_context JSGlobalContextRef], m_value))
81         return [wrapped description];
82     return [self toString];
83 }
84
85 - (JSValueRef)JSValueRef
86 {
87     return m_value;
88 }
89
90 + (JSValue *)valueWithObject:(id)value inContext:(JSContext *)context
91 {
92     return [JSValue valueWithJSValueRef:objectToValue(context, value) inContext:context];
93 }
94
95 + (JSValue *)valueWithBool:(BOOL)value inContext:(JSContext *)context
96 {
97     return [JSValue valueWithJSValueRef:JSValueMakeBoolean([context JSGlobalContextRef], value) inContext:context];
98 }
99
100 + (JSValue *)valueWithDouble:(double)value inContext:(JSContext *)context
101 {
102     return [JSValue valueWithJSValueRef:JSValueMakeNumber([context JSGlobalContextRef], value) inContext:context];
103 }
104
105 + (JSValue *)valueWithInt32:(int32_t)value inContext:(JSContext *)context
106 {
107     return [JSValue valueWithJSValueRef:JSValueMakeNumber([context JSGlobalContextRef], value) inContext:context];
108 }
109
110 + (JSValue *)valueWithUInt32:(uint32_t)value inContext:(JSContext *)context
111 {
112     return [JSValue valueWithJSValueRef:JSValueMakeNumber([context JSGlobalContextRef], value) inContext:context];
113 }
114
115 + (JSValue *)valueWithNewObjectInContext:(JSContext *)context
116 {
117     return [JSValue valueWithJSValueRef:JSObjectMake([context JSGlobalContextRef], 0, 0) inContext:context];
118 }
119
120 + (JSValue *)valueWithNewArrayInContext:(JSContext *)context
121 {
122     return [JSValue valueWithJSValueRef:JSObjectMakeArray([context JSGlobalContextRef], 0, NULL, 0) inContext:context];
123 }
124
125 + (JSValue *)valueWithNewRegularExpressionFromPattern:(NSString *)pattern flags:(NSString *)flags inContext:(JSContext *)context
126 {
127     JSStringRef patternString = JSStringCreateWithCFString((__bridge CFStringRef)pattern);
128     JSStringRef flagsString = JSStringCreateWithCFString((__bridge CFStringRef)flags);
129     JSValueRef arguments[2] = { JSValueMakeString([context JSGlobalContextRef], patternString), JSValueMakeString([context JSGlobalContextRef], flagsString) };
130     JSStringRelease(patternString);
131     JSStringRelease(flagsString);
132
133     return [JSValue valueWithJSValueRef:JSObjectMakeRegExp([context JSGlobalContextRef], 2, arguments, 0) inContext:context];
134 }
135
136 + (JSValue *)valueWithNewErrorFromMessage:(NSString *)message inContext:(JSContext *)context
137 {
138     JSStringRef string = JSStringCreateWithCFString((__bridge CFStringRef)message);
139     JSValueRef argument = JSValueMakeString([context JSGlobalContextRef], string);
140     JSStringRelease(string);
141
142     return [JSValue valueWithJSValueRef:JSObjectMakeError([context JSGlobalContextRef], 1, &argument, 0) inContext:context];
143 }
144
145 + (JSValue *)valueWithNullInContext:(JSContext *)context
146 {
147     return [JSValue valueWithJSValueRef:JSValueMakeNull([context JSGlobalContextRef]) inContext:context];
148 }
149
150 + (JSValue *)valueWithUndefinedInContext:(JSContext *)context
151 {
152     return [JSValue valueWithJSValueRef:JSValueMakeUndefined([context JSGlobalContextRef]) inContext:context];
153 }
154
155 + (JSValue *)valueWithNewSymbolFromDescription:(NSString *)description inContext:(JSContext *)context
156 {
157     JSStringRef string = JSStringCreateWithCFString(reinterpret_cast<CFStringRef>(description));
158     return [JSValue valueWithJSValueRef:JSValueMakeSymbol([context JSGlobalContextRef], string) inContext:context];
159 }
160
161
162 - (id)toObject
163 {
164     return valueToObject(_context, m_value);
165 }
166
167 - (id)toObjectOfClass:(Class)expectedClass
168 {
169     id result = [self toObject];
170     return [result isKindOfClass:expectedClass] ? result : nil;
171 }
172
173 - (BOOL)toBool
174 {
175     return JSValueToBoolean([_context JSGlobalContextRef], m_value);
176 }
177
178 - (double)toDouble
179 {
180     JSValueRef exception = 0;
181     double result = JSValueToNumber([_context JSGlobalContextRef], m_value, &exception);
182     if (exception) {
183         [_context notifyException:exception];
184         return std::numeric_limits<double>::quiet_NaN();
185     }
186
187     return result;
188 }
189
190 - (int32_t)toInt32
191 {
192     return JSC::toInt32([self toDouble]);
193 }
194
195 - (uint32_t)toUInt32
196 {
197     return JSC::toUInt32([self toDouble]);
198 }
199
200 - (NSNumber *)toNumber
201 {
202     JSValueRef exception = 0;
203     id result = valueToNumber([_context JSGlobalContextRef], m_value, &exception);
204     if (exception)
205         [_context notifyException:exception];
206     return result;
207 }
208
209 - (NSString *)toString
210 {
211     JSValueRef exception = 0;
212     id result = valueToString([_context JSGlobalContextRef], m_value, &exception);
213     if (exception)
214         [_context notifyException:exception];
215     return result;
216 }
217
218 - (NSDate *)toDate
219 {
220     JSValueRef exception = 0;
221     id result = valueToDate([_context JSGlobalContextRef], m_value, &exception);
222     if (exception)
223         [_context notifyException:exception];
224     return result;
225 }
226
227 - (NSArray *)toArray
228 {
229     JSValueRef exception = 0;
230     id result = valueToArray([_context JSGlobalContextRef], m_value, &exception);
231     if (exception)
232         [_context notifyException:exception];
233     return result;
234 }
235
236 - (NSDictionary *)toDictionary
237 {
238     JSValueRef exception = 0;
239     id result = valueToDictionary([_context JSGlobalContextRef], m_value, &exception);
240     if (exception)
241         [_context notifyException:exception];
242     return result;
243 }
244
245 template<typename Result, typename NSStringFunction, typename JSValueFunction, typename... Types>
246 inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction stringFunction, JSValueFunction jsFunction, JSValue* value, id propertyKey, Types... arguments)
247 {
248     JSContext* context = [value context];
249     JSValueRef exception = nullptr;
250     JSObjectRef object = JSValueToObject([context JSGlobalContextRef], [value JSValueRef], &exception);
251     if (exception)
252         return Unexpected<JSValueRef>(exception);
253
254     Result result;
255     // If it's a NSString already, reduce indirection and just pass the NSString.
256     if ([propertyKey isKindOfClass:[NSString class]]) {
257         JSStringRef name = JSStringCreateWithCFString((__bridge CFStringRef)propertyKey);
258         result = stringFunction([context JSGlobalContextRef], object, name, arguments..., &exception);
259         JSStringRelease(name);
260     } else
261         result = jsFunction([context JSGlobalContextRef], object, [[JSValue valueWithObject:propertyKey inContext:context] JSValueRef], arguments..., &exception);
262     return Expected<Result, JSValueRef>(result);
263 }
264
265 - (JSValue *)valueForProperty:(id)key
266 {
267     auto result = performPropertyOperation<JSValueRef>(JSObjectGetProperty, JSObjectGetPropertyForKey, self, key);
268     if (!result)
269         return [_context valueFromNotifyException:result.error()];
270
271     return [JSValue valueWithJSValueRef:result.value() inContext:_context];
272 }
273
274
275 - (void)setValue:(id)value forProperty:(JSValueProperty)key
276 {
277     // We need Unit business because void can't be assigned to in performPropertyOperation and I don't want to duplicate the code...
278     using Unit = std::tuple<>;
279     auto stringSetProperty = [] (auto... args) -> Unit {
280         JSObjectSetProperty(args...);
281         return { };
282     };
283
284     auto jsValueSetProperty = [] (auto... args) -> Unit {
285         JSObjectSetPropertyForKey(args...);
286         return { };
287     };
288
289     auto result = performPropertyOperation<Unit>(stringSetProperty, jsValueSetProperty, self, key, objectToValue(_context, value), kJSPropertyAttributeNone);
290     if (!result) {
291         [_context notifyException:result.error()];
292         return;
293     }
294 }
295
296 - (BOOL)deleteProperty:(JSValueProperty)key
297 {
298     Expected<BOOL, JSValueRef> result = performPropertyOperation<BOOL>(JSObjectDeleteProperty, JSObjectDeletePropertyForKey, self, key);
299     if (!result)
300         return [_context boolFromNotifyException:result.error()];
301     return result.value();
302 }
303
304 - (BOOL)hasProperty:(JSValueProperty)key
305 {
306     // The C-api doesn't return an exception value for the string version of has property.
307     auto stringHasProperty = [] (JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef*) -> BOOL {
308         return JSObjectHasProperty(ctx, object, propertyName);
309     };
310
311     Expected<BOOL, JSValueRef> result = performPropertyOperation<BOOL>(stringHasProperty, JSObjectHasPropertyForKey, self, key);
312     if (!result)
313         return [_context boolFromNotifyException:result.error()];
314     return result.value();
315 }
316
317 - (void)defineProperty:(JSValueProperty)key descriptor:(id)descriptor
318 {
319     [[_context globalObject][@"Object"] invokeMethod:@"defineProperty" withArguments:@[ self, key, descriptor ]];
320 }
321
322 - (JSValue *)valueAtIndex:(NSUInteger)index
323 {
324     // Properties that are higher than an unsigned value can hold are converted to a double then inserted as a normal property.
325     // Indices that are bigger than the max allowed index size (UINT_MAX - 1) will be handled internally in get().
326     if (index != (unsigned)index)
327         return [self valueForProperty:[[JSValue valueWithDouble:index inContext:_context] toString]];
328
329     JSValueRef exception = 0;
330     JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);
331     if (exception)
332         return [_context valueFromNotifyException:exception];
333
334     JSValueRef result = JSObjectGetPropertyAtIndex([_context JSGlobalContextRef], object, (unsigned)index, &exception);
335     if (exception)
336         return [_context valueFromNotifyException:exception];
337
338     return [JSValue valueWithJSValueRef:result inContext:_context];
339 }
340
341 - (void)setValue:(id)value atIndex:(NSUInteger)index
342 {
343     // Properties that are higher than an unsigned value can hold are converted to a double, then inserted as a normal property.
344     // Indices that are bigger than the max allowed index size (UINT_MAX - 1) will be handled internally in putByIndex().
345     if (index != (unsigned)index)
346         return [self setValue:value forProperty:[[JSValue valueWithDouble:index inContext:_context] toString]];
347
348     JSValueRef exception = 0;
349     JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);
350     if (exception) {
351         [_context notifyException:exception];
352         return;
353     }
354
355     JSObjectSetPropertyAtIndex([_context JSGlobalContextRef], object, (unsigned)index, objectToValue(_context, value), &exception);
356     if (exception) {
357         [_context notifyException:exception];
358         return;
359     }
360 }
361
362 - (BOOL)isUndefined
363 {
364     return JSValueIsUndefined([_context JSGlobalContextRef], m_value);
365 }
366
367 - (BOOL)isNull
368 {
369     return JSValueIsNull([_context JSGlobalContextRef], m_value);
370 }
371
372 - (BOOL)isBoolean
373 {
374     return JSValueIsBoolean([_context JSGlobalContextRef], m_value);
375 }
376
377 - (BOOL)isNumber
378 {
379     return JSValueIsNumber([_context JSGlobalContextRef], m_value);
380 }
381
382 - (BOOL)isString
383 {
384     return JSValueIsString([_context JSGlobalContextRef], m_value);
385 }
386
387 - (BOOL)isObject
388 {
389     return JSValueIsObject([_context JSGlobalContextRef], m_value);
390 }
391
392 - (BOOL)isSymbol
393 {
394     return JSValueIsSymbol([_context JSGlobalContextRef], m_value);
395 }
396
397 - (BOOL)isArray
398 {
399     return JSValueIsArray([_context JSGlobalContextRef], m_value);
400 }
401
402 - (BOOL)isDate
403 {
404     return JSValueIsDate([_context JSGlobalContextRef], m_value);
405 }
406
407 - (BOOL)isEqualToObject:(id)value
408 {
409     return JSValueIsStrictEqual([_context JSGlobalContextRef], m_value, objectToValue(_context, value));
410 }
411
412 - (BOOL)isEqualWithTypeCoercionToObject:(id)value
413 {
414     JSValueRef exception = 0;
415     BOOL result = JSValueIsEqual([_context JSGlobalContextRef], m_value, objectToValue(_context, value), &exception);
416     if (exception)
417         return [_context boolFromNotifyException:exception];
418
419     return result;
420 }
421
422 - (BOOL)isInstanceOf:(id)value
423 {
424     JSValueRef exception = 0;
425     JSObjectRef constructor = JSValueToObject([_context JSGlobalContextRef], objectToValue(_context, value), &exception);
426     if (exception)
427         return [_context boolFromNotifyException:exception];
428
429     BOOL result = JSValueIsInstanceOfConstructor([_context JSGlobalContextRef], m_value, constructor, &exception);
430     if (exception)
431         return [_context boolFromNotifyException:exception];
432
433     return result;
434 }
435
436 - (JSValue *)callWithArguments:(NSArray *)argumentArray
437 {
438     NSUInteger argumentCount = [argumentArray count];
439     JSValueRef arguments[argumentCount];
440     for (unsigned i = 0; i < argumentCount; ++i)
441         arguments[i] = objectToValue(_context, [argumentArray objectAtIndex:i]);
442
443     JSValueRef exception = 0;
444     JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);
445     if (exception)
446         return [_context valueFromNotifyException:exception];
447
448     JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, 0, argumentCount, arguments, &exception);
449     if (exception)
450         return [_context valueFromNotifyException:exception];
451
452     return [JSValue valueWithJSValueRef:result inContext:_context];
453 }
454
455 - (JSValue *)constructWithArguments:(NSArray *)argumentArray
456 {
457     NSUInteger argumentCount = [argumentArray count];
458     JSValueRef arguments[argumentCount];
459     for (unsigned i = 0; i < argumentCount; ++i)
460         arguments[i] = objectToValue(_context, [argumentArray objectAtIndex:i]);
461
462     JSValueRef exception = 0;
463     JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);
464     if (exception)
465         return [_context valueFromNotifyException:exception];
466
467     JSObjectRef result = JSObjectCallAsConstructor([_context JSGlobalContextRef], object, argumentCount, arguments, &exception);
468     if (exception)
469         return [_context valueFromNotifyException:exception];
470
471     return [JSValue valueWithJSValueRef:result inContext:_context];
472 }
473
474 - (JSValue *)invokeMethod:(NSString *)method withArguments:(NSArray *)arguments
475 {
476     NSUInteger argumentCount = [arguments count];
477     JSValueRef argumentArray[argumentCount];
478     for (unsigned i = 0; i < argumentCount; ++i)
479         argumentArray[i] = objectToValue(_context, [arguments objectAtIndex:i]);
480
481     JSValueRef exception = 0;
482     JSObjectRef thisObject = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);
483     if (exception)
484         return [_context valueFromNotifyException:exception];
485
486     JSStringRef name = JSStringCreateWithCFString((__bridge CFStringRef)method);
487     JSValueRef function = JSObjectGetProperty([_context JSGlobalContextRef], thisObject, name, &exception);
488     JSStringRelease(name);
489     if (exception)
490         return [_context valueFromNotifyException:exception];
491
492     JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], function, &exception);
493     if (exception)
494         return [_context valueFromNotifyException:exception];
495
496     JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, thisObject, argumentCount, argumentArray, &exception);
497     if (exception)
498         return [_context valueFromNotifyException:exception];
499
500     return [JSValue valueWithJSValueRef:result inContext:_context];
501 }
502
503 @end
504
505 @implementation JSValue(StructSupport)
506
507 - (CGPoint)toPoint
508 {
509     return (CGPoint){
510         static_cast<CGFloat>([self[@"x"] toDouble]),
511         static_cast<CGFloat>([self[@"y"] toDouble])
512     };
513 }
514
515 - (NSRange)toRange
516 {
517     return (NSRange){
518         [[self[@"location"] toNumber] unsignedIntegerValue],
519         [[self[@"length"] toNumber] unsignedIntegerValue]
520     };
521 }
522
523 - (CGRect)toRect
524 {
525     return (CGRect){
526         [self toPoint],
527         [self toSize]
528     };
529 }
530
531 - (CGSize)toSize
532 {
533     return (CGSize){
534         static_cast<CGFloat>([self[@"width"] toDouble]),
535         static_cast<CGFloat>([self[@"height"] toDouble])
536     };
537 }
538
539 + (JSValue *)valueWithPoint:(CGPoint)point inContext:(JSContext *)context
540 {
541     return [JSValue valueWithObject:@{
542         @"x":@(point.x),
543         @"y":@(point.y)
544     } inContext:context];
545 }
546
547 + (JSValue *)valueWithRange:(NSRange)range inContext:(JSContext *)context
548 {
549     return [JSValue valueWithObject:@{
550         @"location":@(range.location),
551         @"length":@(range.length)
552     } inContext:context];
553 }
554
555 + (JSValue *)valueWithRect:(CGRect)rect inContext:(JSContext *)context
556 {
557     return [JSValue valueWithObject:@{
558         @"x":@(rect.origin.x),
559         @"y":@(rect.origin.y),
560         @"width":@(rect.size.width),
561         @"height":@(rect.size.height)
562     } inContext:context];
563 }
564
565 + (JSValue *)valueWithSize:(CGSize)size inContext:(JSContext *)context
566 {
567     return [JSValue valueWithObject:@{
568         @"width":@(size.width),
569         @"height":@(size.height)
570     } inContext:context];
571 }
572
573 @end
574
575 @implementation JSValue(SubscriptSupport)
576
577 - (JSValue *)objectForKeyedSubscript:(id)key
578 {
579     return [self valueForProperty:key];
580 }
581
582 - (JSValue *)objectAtIndexedSubscript:(NSUInteger)index
583 {
584     return [self valueAtIndex:index];
585 }
586
587 - (void)setObject:(id)object forKeyedSubscript:(id)key
588 {
589     [self setValue:object forProperty:key];
590 }
591
592 - (void)setObject:(id)object atIndexedSubscript:(NSUInteger)index
593 {
594     [self setValue:object atIndex:index];
595 }
596
597 @end
598
599 inline bool isDate(JSC::VM& vm, JSObjectRef object, JSGlobalContextRef context)
600 {
601     JSC::JSLockHolder locker(toJS(context));
602     return toJS(object)->inherits<JSC::DateInstance>(vm);
603 }
604
605 inline bool isArray(JSC::VM& vm, JSObjectRef object, JSGlobalContextRef context)
606 {
607     JSC::JSLockHolder locker(toJS(context));
608     return toJS(object)->inherits<JSC::JSArray>(vm);
609 }
610
611 @implementation JSValue(Internal)
612
613 enum ConversionType {
614     ContainerNone,
615     ContainerArray,
616     ContainerDictionary
617 };
618
619 class JSContainerConvertor {
620 public:
621     struct Task {
622         JSValueRef js;
623         id objc;
624         ConversionType type;
625     };
626
627     JSContainerConvertor(JSGlobalContextRef context)
628         : m_context(context)
629     {
630     }
631
632     id convert(JSValueRef property);
633     void add(Task);
634     Task take();
635     bool isWorkListEmpty() const { return !m_worklist.size(); }
636
637 private:
638     JSGlobalContextRef m_context;
639     HashMap<JSValueRef, id> m_objectMap;
640     Vector<Task> m_worklist;
641     Vector<JSC::Strong<JSC::Unknown>> m_jsValues;
642 };
643
644 inline id JSContainerConvertor::convert(JSValueRef value)
645 {
646     HashMap<JSValueRef, id>::iterator iter = m_objectMap.find(value);
647     if (iter != m_objectMap.end())
648         return iter->value;
649
650     Task result = valueToObjectWithoutCopy(m_context, value);
651     if (result.js)
652         add(result);
653     return result.objc;
654 }
655
656 void JSContainerConvertor::add(Task task)
657 {
658     JSC::ExecState* exec = toJS(m_context);
659     m_jsValues.append(JSC::Strong<JSC::Unknown>(exec->vm(), toJSForGC(exec, task.js)));
660     m_objectMap.add(task.js, task.objc);
661     if (task.type != ContainerNone)
662         m_worklist.append(task);
663 }
664
665 JSContainerConvertor::Task JSContainerConvertor::take()
666 {
667     ASSERT(!isWorkListEmpty());
668     Task last = m_worklist.last();
669     m_worklist.removeLast();
670     return last;
671 }
672
673 #if ENABLE(REMOTE_INSPECTOR)
674 static void reportExceptionToInspector(JSGlobalContextRef context, JSC::JSValue exceptionValue)
675 {
676     JSC::ExecState* exec = toJS(context);
677     JSC::Exception* exception = JSC::Exception::create(exec->vm(), exceptionValue);
678     exec->vmEntryGlobalObject()->inspectorController().reportAPIException(exec, exception);
679 }
680 #endif
681
682 static JSContainerConvertor::Task valueToObjectWithoutCopy(JSGlobalContextRef context, JSValueRef value)
683 {
684     JSC::ExecState* exec = toJS(context);
685     JSC::VM& vm = exec->vm();
686
687     if (!JSValueIsObject(context, value)) {
688         id primitive;
689         if (JSValueIsBoolean(context, value))
690             primitive = JSValueToBoolean(context, value) ? @YES : @NO;
691         else if (JSValueIsNumber(context, value)) {
692             // Normalize the number, so it will unique correctly in the hash map -
693             // it's nicer not to leak this internal implementation detail!
694             value = JSValueMakeNumber(context, JSValueToNumber(context, value, 0));
695             primitive = [NSNumber numberWithDouble:JSValueToNumber(context, value, 0)];
696         } else if (JSValueIsString(context, value)) {
697             // Would be nice to unique strings, too.
698             JSStringRef jsstring = JSValueToStringCopy(context, value, 0);
699             primitive = CFBridgingRelease(JSStringCopyCFString(kCFAllocatorDefault, jsstring));
700             JSStringRelease(jsstring);
701         } else if (JSValueIsNull(context, value))
702             primitive = [NSNull null];
703         else {
704             ASSERT(JSValueIsUndefined(context, value));
705             primitive = nil;
706         }
707         return { value, primitive, ContainerNone };
708     }
709
710     JSObjectRef object = JSValueToObject(context, value, 0);
711
712     if (id wrapped = tryUnwrapObjcObject(context, object))
713         return { object, wrapped, ContainerNone };
714
715     if (isDate(vm, object, context))
716         return { object, [NSDate dateWithTimeIntervalSince1970:JSValueToNumber(context, object, 0) / 1000.0], ContainerNone };
717
718     if (isArray(vm, object, context))
719         return { object, [NSMutableArray array], ContainerArray };
720
721     return { object, [NSMutableDictionary dictionary], ContainerDictionary };
722 }
723
724 static id containerValueToObject(JSGlobalContextRef context, JSContainerConvertor::Task task)
725 {
726     ASSERT(task.type != ContainerNone);
727     JSC::JSLockHolder locker(toJS(context));
728     JSContainerConvertor convertor(context);
729     convertor.add(task);
730     ASSERT(!convertor.isWorkListEmpty());
731     
732     do {
733         JSContainerConvertor::Task current = convertor.take();
734         ASSERT(JSValueIsObject(context, current.js));
735         JSObjectRef js = JSValueToObject(context, current.js, 0);
736
737         if (current.type == ContainerArray) {
738             ASSERT([current.objc isKindOfClass:[NSMutableArray class]]);
739             NSMutableArray *array = (NSMutableArray *)current.objc;
740         
741             JSStringRef lengthString = JSStringCreateWithUTF8CString("length");
742             unsigned length = JSC::toUInt32(JSValueToNumber(context, JSObjectGetProperty(context, js, lengthString, 0), 0));
743             JSStringRelease(lengthString);
744
745             for (unsigned i = 0; i < length; ++i) {
746                 id objc = convertor.convert(JSObjectGetPropertyAtIndex(context, js, i, 0));
747                 [array addObject:objc ? objc : [NSNull null]];
748             }
749         } else {
750             ASSERT([current.objc isKindOfClass:[NSMutableDictionary class]]);
751             NSMutableDictionary *dictionary = (NSMutableDictionary *)current.objc;
752
753             JSC::JSLockHolder locker(toJS(context));
754
755             JSPropertyNameArrayRef propertyNameArray = JSObjectCopyPropertyNames(context, js);
756             size_t length = JSPropertyNameArrayGetCount(propertyNameArray);
757
758             for (size_t i = 0; i < length; ++i) {
759                 JSStringRef propertyName = JSPropertyNameArrayGetNameAtIndex(propertyNameArray, i);
760                 if (id objc = convertor.convert(JSObjectGetProperty(context, js, propertyName, 0)))
761                     dictionary[(__bridge NSString *)adoptCF(JSStringCopyCFString(kCFAllocatorDefault, propertyName)).get()] = objc;
762             }
763
764             JSPropertyNameArrayRelease(propertyNameArray);
765         }
766
767     } while (!convertor.isWorkListEmpty());
768
769     return task.objc;
770 }
771
772 id valueToObject(JSContext *context, JSValueRef value)
773 {
774     JSContainerConvertor::Task result = valueToObjectWithoutCopy([context JSGlobalContextRef], value);
775     if (result.type == ContainerNone)
776         return result.objc;
777     return containerValueToObject([context JSGlobalContextRef], result);
778 }
779
780 id valueToNumber(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)
781 {
782     ASSERT(!*exception);
783     if (id wrapped = tryUnwrapObjcObject(context, value)) {
784         if ([wrapped isKindOfClass:[NSNumber class]])
785             return wrapped;
786     }
787
788     if (JSValueIsBoolean(context, value))
789         return JSValueToBoolean(context, value) ? @YES : @NO;
790
791     double result = JSValueToNumber(context, value, exception);
792     return [NSNumber numberWithDouble:*exception ? std::numeric_limits<double>::quiet_NaN() : result];
793 }
794
795 id valueToString(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)
796 {
797     ASSERT(!*exception);
798     if (id wrapped = tryUnwrapObjcObject(context, value)) {
799         if ([wrapped isKindOfClass:[NSString class]])
800             return wrapped;
801     }
802
803     JSStringRef jsstring = JSValueToStringCopy(context, value, exception);
804     if (*exception) {
805         ASSERT(!jsstring);
806         return nil;
807     }
808
809     NSString *string = CFBridgingRelease(JSStringCopyCFString(kCFAllocatorDefault, jsstring));
810     JSStringRelease(jsstring);
811     return string;
812 }
813
814 id valueToDate(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)
815 {
816     ASSERT(!*exception);
817     if (id wrapped = tryUnwrapObjcObject(context, value)) {
818         if ([wrapped isKindOfClass:[NSDate class]])
819             return wrapped;
820     }
821
822     double result = JSValueToNumber(context, value, exception) / 1000.0;
823     return *exception ? nil : [NSDate dateWithTimeIntervalSince1970:result];
824 }
825
826 id valueToArray(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)
827 {
828     ASSERT(!*exception);
829     if (id wrapped = tryUnwrapObjcObject(context, value)) {
830         if ([wrapped isKindOfClass:[NSArray class]])
831             return wrapped;
832     }
833
834     if (JSValueIsObject(context, value))
835         return containerValueToObject(context, { value, [NSMutableArray array], ContainerArray});
836
837     JSC::JSLockHolder locker(toJS(context));
838     if (!(JSValueIsNull(context, value) || JSValueIsUndefined(context, value))) {
839         JSC::JSObject* exceptionObject = JSC::createTypeError(toJS(context), "Cannot convert primitive to NSArray"_s);
840         *exception = toRef(exceptionObject);
841 #if ENABLE(REMOTE_INSPECTOR)
842         reportExceptionToInspector(context, exceptionObject);
843 #endif
844     }
845     return nil;
846 }
847
848 id valueToDictionary(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)
849 {
850     ASSERT(!*exception);
851     if (id wrapped = tryUnwrapObjcObject(context, value)) {
852         if ([wrapped isKindOfClass:[NSDictionary class]])
853             return wrapped;
854     }
855
856     if (JSValueIsObject(context, value))
857         return containerValueToObject(context, { value, [NSMutableDictionary dictionary], ContainerDictionary});
858
859     JSC::JSLockHolder locker(toJS(context));
860     if (!(JSValueIsNull(context, value) || JSValueIsUndefined(context, value))) {
861         JSC::JSObject* exceptionObject = JSC::createTypeError(toJS(context), "Cannot convert primitive to NSDictionary"_s);
862         *exception = toRef(exceptionObject);
863 #if ENABLE(REMOTE_INSPECTOR)
864         reportExceptionToInspector(context, exceptionObject);
865 #endif
866     }
867     return nil;
868 }
869
870 class ObjcContainerConvertor {
871 public:
872     struct Task {
873         id objc;
874         JSValueRef js;
875         ConversionType type;
876     };
877
878     ObjcContainerConvertor(JSContext *context)
879         : m_context(context)
880     {
881     }
882
883     JSValueRef convert(id object);
884     void add(Task);
885     Task take();
886     bool isWorkListEmpty() const { return !m_worklist.size(); }
887
888 private:
889     JSContext *m_context;
890     HashMap<id, JSValueRef> m_objectMap;
891     Vector<Task> m_worklist;
892     Vector<JSC::Strong<JSC::Unknown>> m_jsValues;
893 };
894
895 JSValueRef ObjcContainerConvertor::convert(id object)
896 {
897     ASSERT(object);
898
899     auto it = m_objectMap.find(object);
900     if (it != m_objectMap.end())
901         return it->value;
902
903     ObjcContainerConvertor::Task task = objectToValueWithoutCopy(m_context, object);
904     add(task);
905     return task.js;
906 }
907
908 void ObjcContainerConvertor::add(ObjcContainerConvertor::Task task)
909 {
910     JSC::ExecState* exec = toJS(m_context.JSGlobalContextRef);
911     m_jsValues.append(JSC::Strong<JSC::Unknown>(exec->vm(), toJSForGC(exec, task.js)));
912     m_objectMap.add(task.objc, task.js);
913     if (task.type != ContainerNone)
914         m_worklist.append(task);
915 }
916
917 ObjcContainerConvertor::Task ObjcContainerConvertor::take()
918 {
919     ASSERT(!isWorkListEmpty());
920     Task last = m_worklist.last();
921     m_worklist.removeLast();
922     return last;
923 }
924
925 inline bool isNSBoolean(id object)
926 {
927     ASSERT([@YES class] == [@NO class]);
928     ASSERT([@YES class] != [NSNumber class]);
929     ASSERT([[@YES class] isSubclassOfClass:[NSNumber class]]);
930     return [object isKindOfClass:[@YES class]];
931 }
932
933 static ObjcContainerConvertor::Task objectToValueWithoutCopy(JSContext *context, id object)
934 {
935     JSGlobalContextRef contextRef = [context JSGlobalContextRef];
936
937     if (!object)
938         return { object, JSValueMakeUndefined(contextRef), ContainerNone };
939
940     if (!class_conformsToProtocol(object_getClass(object), getJSExportProtocol())) {
941         if ([object isKindOfClass:[NSArray class]])
942             return { object, JSObjectMakeArray(contextRef, 0, NULL, 0), ContainerArray };
943
944         if ([object isKindOfClass:[NSDictionary class]])
945             return { object, JSObjectMake(contextRef, 0, 0), ContainerDictionary };
946
947         if ([object isKindOfClass:[NSNull class]])
948             return { object, JSValueMakeNull(contextRef), ContainerNone };
949
950         if ([object isKindOfClass:[JSValue class]])
951             return { object, ((JSValue *)object)->m_value, ContainerNone };
952
953         if ([object isKindOfClass:[NSString class]]) {
954             JSStringRef string = JSStringCreateWithCFString((__bridge CFStringRef)object);
955             JSValueRef js = JSValueMakeString(contextRef, string);
956             JSStringRelease(string);
957             return { object, js, ContainerNone };
958         }
959
960         if ([object isKindOfClass:[NSNumber class]]) {
961             if (isNSBoolean(object))
962                 return { object, JSValueMakeBoolean(contextRef, [object boolValue]), ContainerNone };
963             return { object, JSValueMakeNumber(contextRef, [object doubleValue]), ContainerNone };
964         }
965
966         if ([object isKindOfClass:[NSDate class]]) {
967             JSValueRef argument = JSValueMakeNumber(contextRef, [object timeIntervalSince1970] * 1000.0);
968             JSObjectRef result = JSObjectMakeDate(contextRef, 1, &argument, 0);
969             return { object, result, ContainerNone };
970         }
971
972         if ([object isKindOfClass:[JSManagedValue class]]) {
973             JSValue *value = [static_cast<JSManagedValue *>(object) value];
974             if (!value)
975                 return  { object, JSValueMakeUndefined(contextRef), ContainerNone };
976             return { object, value->m_value, ContainerNone };
977         }
978     }
979
980     return { object, valueInternalValue([context wrapperForObjCObject:object]), ContainerNone };
981 }
982
983 JSValueRef objectToValue(JSContext *context, id object)
984 {
985     JSGlobalContextRef contextRef = [context JSGlobalContextRef];
986
987     ObjcContainerConvertor::Task task = objectToValueWithoutCopy(context, object);
988     if (task.type == ContainerNone)
989         return task.js;
990
991     JSC::JSLockHolder locker(toJS(contextRef));
992     ObjcContainerConvertor convertor(context);
993     convertor.add(task);
994     ASSERT(!convertor.isWorkListEmpty());
995
996     do {
997         ObjcContainerConvertor::Task current = convertor.take();
998         ASSERT(JSValueIsObject(contextRef, current.js));
999         JSObjectRef js = JSValueToObject(contextRef, current.js, 0);
1000
1001         if (current.type == ContainerArray) {
1002             ASSERT([current.objc isKindOfClass:[NSArray class]]);
1003             NSArray *array = (NSArray *)current.objc;
1004             NSUInteger count = [array count];
1005             for (NSUInteger index = 0; index < count; ++index)
1006                 JSObjectSetPropertyAtIndex(contextRef, js, index, convertor.convert([array objectAtIndex:index]), 0);
1007         } else {
1008             ASSERT(current.type == ContainerDictionary);
1009             ASSERT([current.objc isKindOfClass:[NSDictionary class]]);
1010             NSDictionary *dictionary = (NSDictionary *)current.objc;
1011             for (id key in [dictionary keyEnumerator]) {
1012                 if ([key isKindOfClass:[NSString class]]) {
1013                     JSStringRef propertyName = JSStringCreateWithCFString((__bridge CFStringRef)key);
1014                     JSObjectSetProperty(contextRef, js, propertyName, convertor.convert([dictionary objectForKey:key]), 0, 0);
1015                     JSStringRelease(propertyName);
1016                 }
1017             }
1018         }
1019         
1020     } while (!convertor.isWorkListEmpty());
1021
1022     return task.js;
1023 }
1024
1025 JSValueRef valueInternalValue(JSValue * value)
1026 {
1027     return value->m_value;
1028 }
1029
1030 + (JSValue *)valueWithJSValueRef:(JSValueRef)value inContext:(JSContext *)context
1031 {
1032     return [context wrapperForJSObject:value];
1033 }
1034
1035 - (JSValue *)init
1036 {
1037     return nil;
1038 }
1039
1040 - (JSValue *)initWithValue:(JSValueRef)value inContext:(JSContext *)context
1041 {
1042     if (!value || !context)
1043         return nil;
1044
1045     self = [super init];
1046     if (!self)
1047         return nil;
1048
1049     _context = [context retain];
1050     m_value = value;
1051     JSValueProtect([_context JSGlobalContextRef], m_value);
1052     return self;
1053 }
1054
1055 struct StructTagHandler {
1056     SEL typeToValueSEL;
1057     SEL valueToTypeSEL;
1058 };
1059 typedef HashMap<String, StructTagHandler> StructHandlers;
1060
1061 static StructHandlers* createStructHandlerMap()
1062 {
1063     StructHandlers* structHandlers = new StructHandlers();
1064
1065     size_t valueWithXinContextLength = strlen("valueWithX:inContext:");
1066     size_t toXLength = strlen("toX");
1067
1068     // Step 1: find all valueWith<Foo>:inContext: class methods in JSValue.
1069     forEachMethodInClass(object_getClass([JSValue class]), ^(Method method){
1070         SEL selector = method_getName(method);
1071         const char* name = sel_getName(selector);
1072         size_t nameLength = strlen(name);
1073         // Check for valueWith<Foo>:context:
1074         if (nameLength < valueWithXinContextLength || memcmp(name, "valueWith", 9) || memcmp(name + nameLength - 11, ":inContext:", 11))
1075             return;
1076         // Check for [ id, SEL, <type>, <contextType> ]
1077         if (method_getNumberOfArguments(method) != 4)
1078             return;
1079         char idType[3];
1080         // Check 2nd argument type is "@"
1081         {
1082             auto secondType = adoptSystem<char[]>(method_copyArgumentType(method, 3));
1083             if (strcmp(secondType.get(), "@") != 0)
1084                 return;
1085         }
1086         // Check result type is also "@"
1087         method_getReturnType(method, idType, 3);
1088         if (strcmp(idType, "@") != 0)
1089             return;
1090         {
1091             auto type = adoptSystem<char[]>(method_copyArgumentType(method, 2));
1092             structHandlers->add(StringImpl::create(type.get()), (StructTagHandler) { selector, 0 });
1093         }
1094     });
1095
1096     // Step 2: find all to<Foo> instance methods in JSValue.
1097     forEachMethodInClass([JSValue class], ^(Method method){
1098         SEL selector = method_getName(method);
1099         const char* name = sel_getName(selector);
1100         size_t nameLength = strlen(name);
1101         // Check for to<Foo>
1102         if (nameLength < toXLength || memcmp(name, "to", 2))
1103             return;
1104         // Check for [ id, SEL ]
1105         if (method_getNumberOfArguments(method) != 2)
1106             return;
1107         // Try to find a matching valueWith<Foo>:context: method.
1108         auto type = adoptSystem<char[]>(method_copyReturnType(method));
1109         StructHandlers::iterator iter = structHandlers->find(type.get());
1110         if (iter == structHandlers->end())
1111             return;
1112         StructTagHandler& handler = iter->value;
1113
1114         // check that strlen(<foo>) == strlen(<Foo>)
1115         const char* valueWithName = sel_getName(handler.typeToValueSEL);
1116         size_t valueWithLength = strlen(valueWithName);
1117         if (valueWithLength - valueWithXinContextLength != nameLength - toXLength)
1118             return;
1119         // Check that <Foo> == <Foo>
1120         if (memcmp(valueWithName + 9, name + 2, nameLength - toXLength - 1))
1121             return;
1122         handler.valueToTypeSEL = selector;
1123     });
1124
1125     // Step 3: clean up - remove entries where we found prospective valueWith<Foo>:inContext: conversions, but no matching to<Foo> methods.
1126     typedef HashSet<String> RemoveSet;
1127     RemoveSet removeSet;
1128     for (StructHandlers::iterator iter = structHandlers->begin(); iter != structHandlers->end(); ++iter) {
1129         StructTagHandler& handler = iter->value;
1130         if (!handler.valueToTypeSEL)
1131             removeSet.add(iter->key);
1132     }
1133
1134     for (RemoveSet::iterator iter = removeSet.begin(); iter != removeSet.end(); ++iter)
1135         structHandlers->remove(*iter);
1136
1137     return structHandlers;
1138 }
1139
1140 static StructTagHandler* handerForStructTag(const char* encodedType)
1141 {
1142     static Lock handerForStructTagLock;
1143     LockHolder lockHolder(&handerForStructTagLock);
1144
1145     static StructHandlers* structHandlers = createStructHandlerMap();
1146
1147     StructHandlers::iterator iter = structHandlers->find(encodedType);
1148     if (iter == structHandlers->end())
1149         return 0;
1150     return &iter->value;
1151 }
1152
1153 + (SEL)selectorForStructToValue:(const char *)structTag
1154 {
1155     StructTagHandler* handler = handerForStructTag(structTag);
1156     return handler ? handler->typeToValueSEL : nil;
1157 }
1158
1159 + (SEL)selectorForValueToStruct:(const char *)structTag
1160 {
1161     StructTagHandler* handler = handerForStructTag(structTag);
1162     return handler ? handler->valueToTypeSEL : nil;
1163 }
1164
1165 NSInvocation *typeToValueInvocationFor(const char* encodedType)
1166 {
1167     SEL selector = [JSValue selectorForStructToValue:encodedType];
1168     if (!selector)
1169         return 0;
1170
1171     const char* methodTypes = method_getTypeEncoding(class_getClassMethod([JSValue class], selector));
1172     NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[NSMethodSignature signatureWithObjCTypes:methodTypes]];
1173     [invocation setSelector:selector];
1174     return invocation;
1175 }
1176
1177 NSInvocation *valueToTypeInvocationFor(const char* encodedType)
1178 {
1179     SEL selector = [JSValue selectorForValueToStruct:encodedType];
1180     if (!selector)
1181         return 0;
1182
1183     const char* methodTypes = method_getTypeEncoding(class_getInstanceMethod([JSValue class], selector));
1184     NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[NSMethodSignature signatureWithObjCTypes:methodTypes]];
1185     [invocation setSelector:selector];
1186     return invocation;
1187 }
1188
1189 @end
1190
1191 #endif