Objective-C API for JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / API / JSContext.mm
1 /*
2  * Copyright (C) 2013 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 "JSContextInternal.h"
30 #import "JSGlobalObject.h"
31 #import "JSValueInternal.h"
32 #import "JSVirtualMachineInternal.h"
33 #import "JSWrapperMap.h"
34 #import "JavaScriptCore.h"
35 #import "ObjcRuntimeExtras.h"
36 #import <wtf/HashSet.h>
37
38 #if JS_OBJC_API_ENABLED
39
40 @implementation JSContext {
41     JSVirtualMachine *m_virtualMachine;
42     JSGlobalContextRef m_context;
43     JSWrapperMap *m_wrapperMap;
44     HashCountedSet<JSValueRef> m_protectCounts;
45 }
46
47 @synthesize exception;
48 @synthesize exceptionHandler;
49
50 - (id)init
51 {
52     return [self initWithVirtualMachine:[[[JSVirtualMachine alloc] init] autorelease]];
53 }
54
55 - (id)initWithVirtualMachine:(JSVirtualMachine *)virtualMachine
56 {
57     self = [super init];
58     if (!self)
59         return nil;
60
61     m_virtualMachine = [virtualMachine retain];
62     m_context = JSGlobalContextCreateInGroup(getGroupFromVirtualMachine(virtualMachine), 0);
63     m_wrapperMap = [[JSWrapperMap alloc] initWithContext:self];
64
65     self.exception = nil;
66     self.exceptionHandler = ^(JSContext *context, JSValue *exceptionValue) {
67         context.exception = exceptionValue;
68     };
69
70     toJS(m_context)->lexicalGlobalObject()->m_apiData = self;
71     return self;
72 }
73
74 - (JSValue *)evaluateScript:(NSString *)script
75 {
76     JSValueRef exceptionValue = 0;
77     JSStringRef scriptJS = JSStringCreateWithCFString((CFStringRef)script);
78     JSValueRef result = JSEvaluateScript(m_context, scriptJS, 0, 0, 0, &exceptionValue);
79     JSStringRelease(scriptJS);
80
81     if (exceptionValue)
82         return [self valueFromNotifyException:exceptionValue];
83
84     return [JSValue valueWithValue:result inContext:self];
85 }
86
87 - (JSValue *)globalObject
88 {
89     return [JSValue valueWithValue:JSContextGetGlobalObject(m_context) inContext:self];
90 }
91
92 + (JSContext *)currentContext
93 {
94     WTFThreadData& threadData = wtfThreadData();
95     CallbackData *entry = (CallbackData *)threadData.m_apiData;
96     return entry ? entry->context : nil;
97 }
98
99 + (JSValue *)currentThis
100 {
101     WTFThreadData& threadData = wtfThreadData();
102     CallbackData *entry = (CallbackData *)threadData.m_apiData;
103
104     if (!entry->currentThis)
105         entry->currentThis = [[JSValue alloc] initWithValue:entry->thisValue inContext:[JSContext currentContext]];
106
107     return entry->currentThis;
108 }
109
110 + (NSArray *)currentArguments
111 {
112     WTFThreadData& threadData = wtfThreadData();
113     CallbackData *entry = (CallbackData *)threadData.m_apiData;
114
115     if (!entry->currentArguments) {
116         JSContext *context = [JSContext currentContext];
117         size_t count = entry->argumentCount;
118         JSValue * argumentArray[count];
119         for (size_t i =0; i < count; ++i)
120             argumentArray[i] = [JSValue valueWithValue:entry->arguments[i] inContext:context];
121         entry->currentArguments = [[NSArray alloc] initWithObjects:argumentArray count:count];
122     }
123
124     return entry->currentArguments;
125 }
126
127 - (JSVirtualMachine *)virtualMachine
128 {
129     return m_virtualMachine;
130 }
131
132 @end
133
134 @implementation JSContext(SubscriptSupport)
135
136 - (JSValue *)objectForKeyedSubscript:(id)key
137 {
138     return [self globalObject][key];
139 }
140
141 - (void)setObject:(id)object forKeyedSubscript:(NSObject <NSCopying> *)key
142 {
143     [self globalObject][key] = object;
144 }
145
146 @end
147
148 @implementation JSContext(Internal)
149
150 JSGlobalContextRef contextInternalContext(JSContext *context)
151 {
152     return context->m_context;
153 }
154
155 - (void)dealloc
156 {
157     toJS(m_context)->lexicalGlobalObject()->m_apiData = 0;
158
159     HashCountedSet<JSValueRef>::iterator iterator = m_protectCounts.begin();
160     HashCountedSet<JSValueRef>::iterator end = m_protectCounts.end();
161     for (; iterator != end; ++iterator)
162         JSValueUnprotect(m_context, iterator->key);
163
164     [m_wrapperMap release];
165     JSGlobalContextRelease(m_context);
166     [m_virtualMachine release];
167     [super dealloc];
168 }
169
170 - (void)notifyException:(JSValueRef)exceptionValue
171 {
172     self.exceptionHandler(self, [JSValue valueWithValue:exceptionValue inContext:self]);
173 }
174
175 - (JSValue *)valueFromNotifyException:(JSValueRef)exceptionValue
176 {
177     [self notifyException:exceptionValue];
178     return [JSValue valueWithUndefinedInContext:self];
179 }
180
181 - (BOOL)boolFromNotifyException:(JSValueRef)exceptionValue
182 {
183     [self notifyException:exceptionValue];
184     return NO;
185 }
186
187 - (void)beginCallbackWithData:(CallbackData *)callbackData thisValue:(JSValueRef)thisValue argumentCount:(size_t)argumentCount arguments:(const JSValueRef *)arguments
188 {
189     WTFThreadData& threadData = wtfThreadData();
190     [self retain];
191     CallbackData *prevStack = (CallbackData *)threadData.m_apiData;
192     *callbackData = (CallbackData){ prevStack, self, [self.exception retain], thisValue, nil, argumentCount, arguments, nil };
193     threadData.m_apiData = callbackData;
194     self.exception = nil;
195 }
196
197 - (void)endCallbackWithData:(CallbackData *)callbackData
198 {
199     WTFThreadData& threadData = wtfThreadData();
200     self.exception = callbackData->preservedException;
201     [callbackData->preservedException release];
202     [callbackData->currentThis release];
203     [callbackData->currentArguments release];
204     threadData.m_apiData = callbackData->next;
205     [self release];
206 }
207
208 - (void)protect:(JSValueRef)value
209 {
210     // Lock access to m_protectCounts
211     JSC::JSLockHolder lock(toJS(m_context));
212
213     if (m_protectCounts.add(value).isNewEntry)
214         JSValueProtect(m_context, value);
215 }
216
217 - (void)unprotect:(JSValueRef)value
218 {
219     // Lock access to m_protectCounts
220     JSC::JSLockHolder lock(toJS(m_context));
221
222     if (m_protectCounts.remove(value))
223         JSValueUnprotect(m_context, value);
224 }
225
226 - (JSValue *)wrapperForObject:(id)object
227 {
228     // Lock access to m_wrapperMap
229     JSC::JSLockHolder lock(toJS(m_context));
230     return [m_wrapperMap wrapperForObject:object];
231 }
232
233 @end
234
235 WeakContextRef::WeakContextRef(JSContext *context)
236 {
237     objc_initWeak(&m_weakContext, context);
238 }
239
240 WeakContextRef::~WeakContextRef()
241 {
242     objc_destroyWeak(&m_weakContext);
243 }
244
245 JSContext * WeakContextRef::get()
246 {
247     return objc_loadWeak(&m_weakContext);
248 }
249
250 void WeakContextRef::set(JSContext *context)
251 {
252     objc_storeWeak(&m_weakContext, context);
253 }
254
255 #endif