#include "config.h"

#import "APICast.h"

#import "APIShims.h"

#import "DateInstance.h"

#import "Error.h"

#import "JavaScriptCore.h"

#import "JSContextInternal.h"

#import "JSVirtualMachineInternal.h"

#import "JSValueInternal.h"

#import "JSWrapperMap.h"

#import "ObjcRuntimeExtras.h"

#import "Operations.h"

#import "JSCJSValue.h"

#import <wtf/HashMap.h>

#import <wtf/HashSet.h>

#import <wtf/ObjcRuntimeExtras.h>

#import <wtf/Vector.h>

#import <wtf/TCSpinLock.h>

#import <wtf/text/WTFString.h>

#import <wtf/text/StringHash.h>

#if JSC_OBJC_API_ENABLED

NSString * const JSPropertyDescriptorWritableKey = @"writable";

NSString * const JSPropertyDescriptorEnumerableKey = @"enumerable";

NSString * const JSPropertyDescriptorConfigurableKey = @"configurable";

NSString * const JSPropertyDescriptorValueKey = @"value";

NSString * const JSPropertyDescriptorGetKey = @"get";

NSString * const JSPropertyDescriptorSetKey = @"set";

@implementation JSValue {

JSValueRef m_value;

}

- (JSValueRef)JSValueRef

{

return m_value;

}

+ (JSValue *)valueWithObject:(id)value inContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:objectToValue(context, value) inContext:context];

}

+ (JSValue *)valueWithBool:(BOOL)value inContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSValueMakeBoolean([context JSGlobalContextRef], value) inContext:context];

}

+ (JSValue *)valueWithDouble:(double)value inContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSValueMakeNumber([context JSGlobalContextRef], value) inContext:context];

}

+ (JSValue *)valueWithInt32:(int32_t)value inContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSValueMakeNumber([context JSGlobalContextRef], value) inContext:context];

}

+ (JSValue *)valueWithUInt32:(uint32_t)value inContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSValueMakeNumber([context JSGlobalContextRef], value) inContext:context];

}

+ (JSValue *)valueWithNewObjectInContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSObjectMake([context JSGlobalContextRef], 0, 0) inContext:context];

}

+ (JSValue *)valueWithNewArrayInContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSObjectMakeArray([context JSGlobalContextRef], 0, NULL, 0) inContext:context];

}

+ (JSValue *)valueWithNewRegularExpressionFromPattern:(NSString *)pattern flags:(NSString *)flags inContext:(JSContext *)context

{

JSStringRef patternString = JSStringCreateWithCFString((CFStringRef)pattern);

JSStringRef flagsString = JSStringCreateWithCFString((CFStringRef)flags);

JSValueRef arguments[2] = { JSValueMakeString([context JSGlobalContextRef], patternString), JSValueMakeString([context JSGlobalContextRef], flagsString) };

JSStringRelease(patternString);

JSStringRelease(flagsString);

return [JSValue valueWithJSValueRef:JSObjectMakeRegExp([context JSGlobalContextRef], 2, arguments, 0) inContext:context];

}

+ (JSValue *)valueWithNewErrorFromMessage:(NSString *)message inContext:(JSContext *)context

{

JSStringRef string = JSStringCreateWithCFString((CFStringRef)message);

JSValueRef argument = JSValueMakeString([context JSGlobalContextRef], string);

JSStringRelease(string);

return [JSValue valueWithJSValueRef:JSObjectMakeError([context JSGlobalContextRef], 1, &argument, 0) inContext:context];

}

+ (JSValue *)valueWithNullInContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSValueMakeNull([context JSGlobalContextRef]) inContext:context];

}

+ (JSValue *)valueWithUndefinedInContext:(JSContext *)context

{

return [JSValue valueWithJSValueRef:JSValueMakeUndefined([context JSGlobalContextRef]) inContext:context];

}

- (id)toObject

{

return valueToObject(_context, m_value);

}

- (id)toObjectOfClass:(Class)expectedClass

{

id result = [self toObject];

return [result isKindOfClass:expectedClass] ? result : nil;

}

- (BOOL)toBool

{

return JSValueToBoolean([_context JSGlobalContextRef], m_value);

}

- (double)toDouble

{

JSValueRef exception = 0;

double result = JSValueToNumber([_context JSGlobalContextRef], m_value, &exception);

if (exception) {

[_context notifyException:exception];

return std::numeric_limits<double>::quiet_NaN();

}

return result;

}

- (int32_t)toInt32

{

return JSC::toInt32([self toDouble]);

}

- (uint32_t)toUInt32

{

return JSC::toUInt32([self toDouble]);

}

- (NSNumber *)toNumber

{

JSValueRef exception = 0;

id result = valueToNumber([_context JSGlobalContextRef], m_value, &exception);

if (exception)

[_context notifyException:exception];

return result;

}

- (NSString *)toString

{

JSValueRef exception = 0;

id result = valueToString([_context JSGlobalContextRef], m_value, &exception);

if (exception)

[_context notifyException:exception];

return result;

}

- (NSDate *)toDate

{

JSValueRef exception = 0;

id result = valueToDate([_context JSGlobalContextRef], m_value, &exception);

if (exception)

[_context notifyException:exception];

return result;

}

- (NSArray *)toArray

{

JSValueRef exception = 0;

id result = valueToArray([_context JSGlobalContextRef], m_value, &exception);

if (exception)

[_context notifyException:exception];

return result;

}

- (NSDictionary *)toDictionary

{

JSValueRef exception = 0;

id result = valueToDictionary([_context JSGlobalContextRef], m_value, &exception);

if (exception)

[_context notifyException:exception];

return result;

}

- (JSValue *)valueForProperty:(NSString *)propertyName

{

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

JSStringRef name = JSStringCreateWithCFString((CFStringRef)propertyName);

JSValueRef result = JSObjectGetProperty([_context JSGlobalContextRef], object, name, &exception);

JSStringRelease(name);

if (exception)

return [_context valueFromNotifyException:exception];

return [JSValue valueWithJSValueRef:result inContext:_context];

}

- (void)setValue:(id)value forProperty:(NSString *)propertyName

{

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception) {

[_context notifyException:exception];

return;

}

JSStringRef name = JSStringCreateWithCFString((CFStringRef)propertyName);

JSObjectSetProperty([_context JSGlobalContextRef], object, name, objectToValue(_context, value), 0, &exception);

JSStringRelease(name);

if (exception) {

[_context notifyException:exception];

return;

}

}

- (BOOL)deleteProperty:(NSString *)propertyName

{

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context boolFromNotifyException:exception];

JSStringRef name = JSStringCreateWithCFString((CFStringRef)propertyName);

BOOL result = JSObjectDeleteProperty([_context JSGlobalContextRef], object, name, &exception);

JSStringRelease(name);

if (exception)

return [_context boolFromNotifyException:exception];

return result;

}

- (BOOL)hasProperty:(NSString *)propertyName

{

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context boolFromNotifyException:exception];

JSStringRef name = JSStringCreateWithCFString((CFStringRef)propertyName);

BOOL result = JSObjectHasProperty([_context JSGlobalContextRef], object, name);

JSStringRelease(name);

return result;

}

- (void)defineProperty:(NSString *)property descriptor:(id)descriptor

{

[[_context globalObject][@"Object"] invokeMethod:@"defineProperty" withArguments:@[ self, property, descriptor ]];

}

- (JSValue *)valueAtIndex:(NSUInteger)index

{

// Properties that are higher than an unsigned value can hold are converted to a double then inserted as a normal property.

// Indices that are bigger than the max allowed index size (UINT_MAX - 1) will be handled internally in get().

if (index != (unsigned)index)

return [self valueForProperty:[[JSValue valueWithDouble:index inContext:_context] toString]];

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

JSValueRef result = JSObjectGetPropertyAtIndex([_context JSGlobalContextRef], object, (unsigned)index, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

return [JSValue valueWithJSValueRef:result inContext:_context];

}

- (void)setValue:(id)value atIndex:(NSUInteger)index

{

// Properties that are higher than an unsigned value can hold are converted to a double, then inserted as a normal property.

// Indices that are bigger than the max allowed index size (UINT_MAX - 1) will be handled internally in putByIndex().

if (index != (unsigned)index)

return [self setValue:value forProperty:[[JSValue valueWithDouble:index inContext:_context] toString]];

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception) {

[_context notifyException:exception];

return;

}

JSObjectSetPropertyAtIndex([_context JSGlobalContextRef], object, (unsigned)index, objectToValue(_context, value), &exception);

if (exception) {

[_context notifyException:exception];

return;

}

}

- (BOOL)isUndefined

{

return JSValueIsUndefined([_context JSGlobalContextRef], m_value);

}

- (BOOL)isNull

{

return JSValueIsNull([_context JSGlobalContextRef], m_value);

}

- (BOOL)isBoolean

{

return JSValueIsBoolean([_context JSGlobalContextRef], m_value);

}

- (BOOL)isNumber

{

return JSValueIsNumber([_context JSGlobalContextRef], m_value);

}

- (BOOL)isString

{

return JSValueIsString([_context JSGlobalContextRef], m_value);

}

- (BOOL)isObject

{

return JSValueIsObject([_context JSGlobalContextRef], m_value);

}

- (BOOL)isEqualToObject:(id)value

{

return JSValueIsStrictEqual([_context JSGlobalContextRef], m_value, objectToValue(_context, value));

}

- (BOOL)isEqualWithTypeCoercionToObject:(id)value

{

JSValueRef exception = 0;

BOOL result = JSValueIsEqual([_context JSGlobalContextRef], m_value, objectToValue(_context, value), &exception);

if (exception)

return [_context boolFromNotifyException:exception];

return result;

}

- (BOOL)isInstanceOf:(id)value

{

JSValueRef exception = 0;

JSObjectRef constructor = JSValueToObject([_context JSGlobalContextRef], objectToValue(_context, value), &exception);

if (exception)

return [_context boolFromNotifyException:exception];

BOOL result = JSValueIsInstanceOfConstructor([_context JSGlobalContextRef], m_value, constructor, &exception);

if (exception)

return [_context boolFromNotifyException:exception];

return result;

}

- (JSValue *)callWithArguments:(NSArray *)argumentArray

{

NSUInteger argumentCount = [argumentArray count];

JSValueRef arguments[argumentCount];

for (unsigned i = 0; i < argumentCount; ++i)

arguments[i] = objectToValue(_context, [argumentArray objectAtIndex:i]);

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, 0, argumentCount, arguments, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

return [JSValue valueWithJSValueRef:result inContext:_context];

}

- (JSValue *)constructWithArguments:(NSArray *)argumentArray

{

NSUInteger argumentCount = [argumentArray count];

JSValueRef arguments[argumentCount];

for (unsigned i = 0; i < argumentCount; ++i)

arguments[i] = objectToValue(_context, [argumentArray objectAtIndex:i]);

JSValueRef exception = 0;

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

JSObjectRef result = JSObjectCallAsConstructor([_context JSGlobalContextRef], object, argumentCount, arguments, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

return [JSValue valueWithJSValueRef:result inContext:_context];

}

- (JSValue *)invokeMethod:(NSString *)method withArguments:(NSArray *)arguments

{

NSUInteger argumentCount = [arguments count];

JSValueRef argumentArray[argumentCount];

for (unsigned i = 0; i < argumentCount; ++i)

argumentArray[i] = objectToValue(_context, [arguments objectAtIndex:i]);

JSValueRef exception = 0;

JSObjectRef thisObject = JSValueToObject([_context JSGlobalContextRef], m_value, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

JSStringRef name = JSStringCreateWithCFString((CFStringRef)method);

JSValueRef function = JSObjectGetProperty([_context JSGlobalContextRef], thisObject, name, &exception);

JSStringRelease(name);

if (exception)

return [_context valueFromNotifyException:exception];

JSObjectRef object = JSValueToObject([_context JSGlobalContextRef], function, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, thisObject, argumentCount, argumentArray, &exception);

if (exception)

return [_context valueFromNotifyException:exception];

return [JSValue valueWithJSValueRef:result inContext:_context];

}

@implementation JSValue(StructSupport)

- (CGPoint)toPoint

{

return (CGPoint){

static_cast<CGFloat>([self[@"x"] toDouble]),

static_cast<CGFloat>([self[@"y"] toDouble])

};

}

- (NSRange)toRange

{

return (NSRange){

[[self[@"location"] toNumber] unsignedIntegerValue],

[[self[@"length"] toNumber] unsignedIntegerValue]

};

}

- (CGRect)toRect

{

return (CGRect){

[self toPoint],

[self toSize]

};

}

- (CGSize)toSize

{

return (CGSize){

static_cast<CGFloat>([self[@"width"] toDouble]),

static_cast<CGFloat>([self[@"height"] toDouble])

};

}

+ (JSValue *)valueWithPoint:(CGPoint)point inContext:(JSContext *)context

{

return [JSValue valueWithObject:@{

@"x":@(point.x),

@"y":@(point.y)

} inContext:context];

}

+ (JSValue *)valueWithRange:(NSRange)range inContext:(JSContext *)context

{

return [JSValue valueWithObject:@{

@"location":@(range.location),

@"length":@(range.length)

} inContext:context];

}

+ (JSValue *)valueWithRect:(CGRect)rect inContext:(JSContext *)context

{

return [JSValue valueWithObject:@{

@"x":@(rect.origin.x),

@"y":@(rect.origin.y),

@"width":@(rect.size.width),

@"height":@(rect.size.height)

} inContext:context];

}

+ (JSValue *)valueWithSize:(CGSize)size inContext:(JSContext *)context

{

return [JSValue valueWithObject:@{

@"width":@(size.width),

@"height":@(size.height)

} inContext:context];

}

@implementation JSValue(SubscriptSupport)

- (JSValue *)objectForKeyedSubscript:(id)key

{

if (![key isKindOfClass:[NSString class]]) {

key = [[JSValue valueWithObject:key inContext:_context] toString];

if (!key)

return [JSValue valueWithUndefinedInContext:_context];

}

return [self valueForProperty:(NSString *)key];

}

- (JSValue *)objectAtIndexedSubscript:(NSUInteger)index

{

return [self valueAtIndex:index];

}

- (void)setObject:(id)object forKeyedSubscript:(NSObject <NSCopying> *)key

{

if (![key isKindOfClass:[NSString class]]) {

key = [[JSValue valueWithObject:key inContext:_context] toString];

if (!key)

return;

}

[self setValue:object forProperty:(NSString *)key];

}

- (void)setObject:(id)object atIndexedSubscript:(NSUInteger)index

{

[self setValue:object atIndex:index];

}

inline bool isDate(JSObjectRef object, JSGlobalContextRef context)

{

JSC::APIEntryShim entryShim(toJS(context));

return toJS(object)->inherits(JSC::DateInstance::info());

}

inline bool isArray(JSObjectRef object, JSGlobalContextRef context)

{

JSC::APIEntryShim entryShim(toJS(context));

return toJS(object)->inherits(JSC::JSArray::info());

}

@implementation JSValue(Internal)

enum ConversionType {

ContainerNone,

ContainerArray,

ContainerDictionary

};

class JSContainerConvertor {

struct Task {

JSValueRef js;

id objc;

ConversionType type;

};

JSContainerConvertor(JSGlobalContextRef context)

: m_context(context)

{

}

id convert(JSValueRef property);

void add(Task);

Task take();

bool isWorkListEmpty() const { return !m_worklist.size(); }

JSGlobalContextRef m_context;

HashMap<JSValueRef, id> m_objectMap;

Vector<Task> m_worklist;

};

inline id JSContainerConvertor::convert(JSValueRef value)

{

HashMap<JSValueRef, id>::iterator iter = m_objectMap.find(value);

if (iter != m_objectMap.end())

return iter->value;

Task result = valueToObjectWithoutCopy(m_context, value);

if (result.js)

add(result);

return result.objc;

}

void JSContainerConvertor::add(Task task)

{

m_objectMap.add(task.js, task.objc);

if (task.type != ContainerNone)

m_worklist.append(task);

}

JSContainerConvertor::Task JSContainerConvertor::take()

{

ASSERT(!isWorkListEmpty());

Task last = m_worklist.last();

m_worklist.removeLast();

return last;

}

static JSContainerConvertor::Task valueToObjectWithoutCopy(JSGlobalContextRef context, JSValueRef value)

{

if (!JSValueIsObject(context, value)) {

id primitive;

if (JSValueIsBoolean(context, value))

primitive = JSValueToBoolean(context, value) ? @YES : @NO;

else if (JSValueIsNumber(context, value)) {

// Normalize the number, so it will unique correctly in the hash map -

// it's nicer not to leak this internal implementation detail!

value = JSValueMakeNumber(context, JSValueToNumber(context, value, 0));

primitive = [NSNumber numberWithDouble:JSValueToNumber(context, value, 0)];

} else if (JSValueIsString(context, value)) {

// Would be nice to unique strings, too.

JSStringRef jsstring = JSValueToStringCopy(context, value, 0);

NSString * stringNS = (NSString *)JSStringCopyCFString(kCFAllocatorDefault, jsstring);

JSStringRelease(jsstring);

primitive = [stringNS autorelease];

} else if (JSValueIsNull(context, value))

primitive = [NSNull null];

else {

ASSERT(JSValueIsUndefined(context, value));

primitive = nil;

}

return (JSContainerConvertor::Task){ value, primitive, ContainerNone };

}

JSObjectRef object = JSValueToObject(context, value, 0);

if (id wrapped = tryUnwrapObjcObject(context, object))

return (JSContainerConvertor::Task){ object, wrapped, ContainerNone };

if (isDate(object, context))

return (JSContainerConvertor::Task){ object, [NSDate dateWithTimeIntervalSince1970:JSValueToNumber(context, object, 0)], ContainerNone };

if (isArray(object, context))

return (JSContainerConvertor::Task){ object, [NSMutableArray array], ContainerArray };

return (JSContainerConvertor::Task){ object, [NSMutableDictionary dictionary], ContainerDictionary };

}

static id containerValueToObject(JSGlobalContextRef context, JSContainerConvertor::Task task)

{

ASSERT(task.type != ContainerNone);

JSContainerConvertor convertor(context);

convertor.add(task);

ASSERT(!convertor.isWorkListEmpty());

do {

JSContainerConvertor::Task current = convertor.take();

ASSERT(JSValueIsObject(context, current.js));

JSObjectRef js = JSValueToObject(context, current.js, 0);

if (current.type == ContainerArray) {

ASSERT([current.objc isKindOfClass:[NSMutableArray class]]);

NSMutableArray *array = (NSMutableArray *)current.objc;

JSStringRef lengthString = JSStringCreateWithUTF8CString("length");

unsigned length = JSC::toUInt32(JSValueToNumber(context, JSObjectGetProperty(context, js, lengthString, 0), 0));

JSStringRelease(lengthString);

for (unsigned i = 0; i < length; ++i) {

id objc = convertor.convert(JSObjectGetPropertyAtIndex(context, js, i, 0));

[array addObject:objc ? objc : [NSNull null]];

}

} else {

ASSERT([current.objc isKindOfClass:[NSMutableDictionary class]]);

NSMutableDictionary *dictionary = (NSMutableDictionary *)current.objc;

JSPropertyNameArrayRef propertyNameArray = JSObjectCopyPropertyNames(context, js);

size_t length = JSPropertyNameArrayGetCount(propertyNameArray);

for (size_t i = 0; i < length; ++i) {

JSStringRef propertyName = JSPropertyNameArrayGetNameAtIndex(propertyNameArray, i);

if (id objc = convertor.convert(JSObjectGetProperty(context, js, propertyName, 0)))

dictionary[[(NSString *)JSStringCopyCFString(kCFAllocatorDefault, propertyName) autorelease]] = objc;

}

JSPropertyNameArrayRelease(propertyNameArray);

}

} while (!convertor.isWorkListEmpty());

return task.objc;

}

id valueToObject(JSContext *context, JSValueRef value)

{

JSContainerConvertor::Task result = valueToObjectWithoutCopy([context JSGlobalContextRef], value);

if (result.type == ContainerNone)

return result.objc;

return containerValueToObject([context JSGlobalContextRef], result);

}

id valueToNumber(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)

{

ASSERT(!*exception);

if (id wrapped = tryUnwrapObjcObject(context, value)) {

if ([wrapped isKindOfClass:[NSNumber class]])

return wrapped;

}

if (JSValueIsBoolean(context, value))

return JSValueToBoolean(context, value) ? @YES : @NO;

double result = JSValueToNumber(context, value, exception);

return [NSNumber numberWithDouble:*exception ? std::numeric_limits<double>::quiet_NaN() : result];

}

id valueToString(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)

{

ASSERT(!*exception);

if (id wrapped = tryUnwrapObjcObject(context, value)) {

if ([wrapped isKindOfClass:[NSString class]])

return wrapped;

}

JSStringRef jsstring = JSValueToStringCopy(context, value, exception);

if (*exception) {

ASSERT(!jsstring);

return nil;

}

NSString *stringNS = CFBridgingRelease(JSStringCopyCFString(kCFAllocatorDefault, jsstring));

JSStringRelease(jsstring);

return stringNS;

}

id valueToDate(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)

{

ASSERT(!*exception);

if (id wrapped = tryUnwrapObjcObject(context, value)) {

if ([wrapped isKindOfClass:[NSDate class]])

return wrapped;

}

double result = JSValueToNumber(context, value, exception);

return *exception ? nil : [NSDate dateWithTimeIntervalSince1970:result];

}

id valueToArray(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)

{

ASSERT(!*exception);

if (id wrapped = tryUnwrapObjcObject(context, value)) {

if ([wrapped isKindOfClass:[NSArray class]])

return wrapped;

}

if (JSValueIsObject(context, value))

return containerValueToObject(context, (JSContainerConvertor::Task){ value, [NSMutableArray array], ContainerArray});

if (!(JSValueIsNull(context, value) || JSValueIsUndefined(context, value)))

*exception = toRef(JSC::createTypeError(toJS(context), "Cannot convert primitive to NSArray"));

return nil;

}

id valueToDictionary(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)

{

ASSERT(!*exception);

if (id wrapped = tryUnwrapObjcObject(context, value)) {

if ([wrapped isKindOfClass:[NSDictionary class]])

return wrapped;

}

if (JSValueIsObject(context, value))

return containerValueToObject(context, (JSContainerConvertor::Task){ value, [NSMutableDictionary dictionary], ContainerDictionary});

if (!(JSValueIsNull(context, value) || JSValueIsUndefined(context, value)))

*exception = toRef(JSC::createTypeError(toJS(context), "Cannot convert primitive to NSDictionary"));

return nil;

}

class ObjcContainerConvertor {

struct Task {

id objc;

JSValueRef js;

ConversionType type;

};

ObjcContainerConvertor(JSContext *context)

: m_context(context)

{

}

JSValueRef convert(id object);

void add(Task);

Task take();

bool isWorkListEmpty() const { return !m_worklist.size(); }

JSContext *m_context;

HashMap<id, JSValueRef> m_objectMap;

Vector<Task> m_worklist;

};

JSValueRef ObjcContainerConvertor::convert(id object)

{

ASSERT(object);

auto it = m_objectMap.find(object);

if (it != m_objectMap.end())

return it->value;

ObjcContainerConvertor::Task task = objectToValueWithoutCopy(m_context, object);

add(task);

return task.js;

}

void ObjcContainerConvertor::add(ObjcContainerConvertor::Task task)

{

m_objectMap.add(task.objc, task.js);

if (task.type != ContainerNone)

m_worklist.append(task);

}

ObjcContainerConvertor::Task ObjcContainerConvertor::take()

{

ASSERT(!isWorkListEmpty());

Task last = m_worklist.last();

m_worklist.removeLast();

return last;

}

inline bool isNSBoolean(id object)

{

ASSERT([@YES class] == [@NO class]);

ASSERT([@YES class] != [NSNumber class]);

ASSERT([[@YES class] isSubclassOfClass:[NSNumber class]]);

return [object isKindOfClass:[@YES class]];

}

static ObjcContainerConvertor::Task objectToValueWithoutCopy(JSContext *context, id object)

{

JSGlobalContextRef contextRef = [context JSGlobalContextRef];

if (!object)

return (ObjcContainerConvertor::Task){ object, JSValueMakeUndefined(contextRef), ContainerNone };

if (!class_conformsToProtocol(object_getClass(object), getJSExportProtocol())) {

if ([object isKindOfClass:[NSArray class]])

return (ObjcContainerConvertor::Task){ object, JSObjectMakeArray(contextRef, 0, NULL, 0), ContainerArray };

if ([object isKindOfClass:[NSDictionary class]])

return (ObjcContainerConvertor::Task){ object, JSObjectMake(contextRef, 0, 0), ContainerDictionary };

if ([object isKindOfClass:[NSNull class]])

return (ObjcContainerConvertor::Task){ object, JSValueMakeNull(contextRef), ContainerNone };

if ([object isKindOfClass:[JSValue class]])

return (ObjcContainerConvertor::Task){ object, ((JSValue *)object)->m_value, ContainerNone };

if ([object isKindOfClass:[NSString class]]) {

JSStringRef string = JSStringCreateWithCFString((CFStringRef)object);

JSValueRef js = JSValueMakeString(contextRef, string);

JSStringRelease(string);

return (ObjcContainerConvertor::Task){ object, js, ContainerNone };

}

if ([object isKindOfClass:[NSNumber class]]) {

if (isNSBoolean(object))

return (ObjcContainerConvertor::Task){ object, JSValueMakeBoolean(contextRef, [object boolValue]), ContainerNone };

return (ObjcContainerConvertor::Task){ object, JSValueMakeNumber(contextRef, [object doubleValue]), ContainerNone };

}

if ([object isKindOfClass:[NSDate class]]) {

JSValueRef argument = JSValueMakeNumber(contextRef, [object timeIntervalSince1970]);

JSObjectRef result = JSObjectMakeDate(contextRef, 1, &argument, 0);

return (ObjcContainerConvertor::Task){ object, result, ContainerNone };

}

if ([object isKindOfClass:[JSManagedValue class]]) {

JSValue *value = [static_cast<JSManagedValue *>(object) value];

if (!value)

return (ObjcContainerConvertor::Task) { object, JSValueMakeUndefined(contextRef), ContainerNone };

return (ObjcContainerConvertor::Task){ object, value->m_value, ContainerNone };

}

}

return (ObjcContainerConvertor::Task){ object, valueInternalValue([context wrapperForObjCObject:object]), ContainerNone };

}

JSValueRef objectToValue(JSContext *context, id object)

{

JSGlobalContextRef contextRef = [context JSGlobalContextRef];

ObjcContainerConvertor::Task task = objectToValueWithoutCopy(context, object);

if (task.type == ContainerNone)

return task.js;

ObjcContainerConvertor convertor(context);

convertor.add(task);

ASSERT(!convertor.isWorkListEmpty());

do {

ObjcContainerConvertor::Task current = convertor.take();

ASSERT(JSValueIsObject(contextRef, current.js));

JSObjectRef js = JSValueToObject(contextRef, current.js, 0);

if (current.type == ContainerArray) {

ASSERT([current.objc isKindOfClass:[NSArray class]]);

NSArray *array = (NSArray *)current.objc;

NSUInteger count = [array count];

for (NSUInteger index = 0; index < count; ++index)

JSObjectSetPropertyAtIndex(contextRef, js, index, convertor.convert([array objectAtIndex:index]), 0);

} else {

ASSERT(current.type == ContainerDictionary);

ASSERT([current.objc isKindOfClass:[NSDictionary class]]);

NSDictionary *dictionary = (NSDictionary *)current.objc;

for (id key in [dictionary keyEnumerator]) {

if ([key isKindOfClass:[NSString class]]) {

JSStringRef propertyName = JSStringCreateWithCFString((CFStringRef)key);

JSObjectSetProperty(contextRef, js, propertyName, convertor.convert([dictionary objectForKey:key]), 0, 0);

JSStringRelease(propertyName);

}

}

}

} while (!convertor.isWorkListEmpty());

return task.js;

}

JSValueRef valueInternalValue(JSValue * value)

{

return value->m_value;

}

+ (JSValue *)valueWithJSValueRef:(JSValueRef)value inContext:(JSContext *)context

{

return [context wrapperForJSObject:value];

}

- (JSValue *)init

{

return nil;

}

- (JSValue *)initWithValue:(JSValueRef)value inContext:(JSContext *)context

{

if (!value || !context)

return nil;

self = [super init];

if (!self)

return nil;

_context = [context retain];

m_value = value;

JSValueProtect([_context JSGlobalContextRef], m_value);

return self;

}

struct StructTagHandler {

SEL typeToValueSEL;

SEL valueToTypeSEL;

};

typedef HashMap<String, StructTagHandler> StructHandlers;

static StructHandlers* createStructHandlerMap()

{

StructHandlers* structHandlers = new StructHandlers();

size_t valueWithXinContextLength = strlen("valueWithX:inContext:");

size_t toXLength = strlen("toX");

// Step 1: find all valueWith<Foo>:inContext: class methods in JSValue.

forEachMethodInClass(object_getClass([JSValue class]), ^(Method method){

SEL selector = method_getName(method);

const char* name = sel_getName(selector);

size_t nameLength = strlen(name);

// Check for valueWith<Foo>:context:

if (nameLength < valueWithXinContextLength || memcmp(name, "valueWith", 9) || memcmp(name + nameLength - 11, ":inContext:", 11))

return;

// Check for [ id, SEL, <type>, <contextType> ]