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