darlinghq/darling-JavaScriptCore
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-JavaScriptCore.git synced 2025-04-05 16:31:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update Sources To JavaScriptCore-7611.3.10.1.3

Browse Source
This commit is contained in:
Thomas A 2022-10-22 19:55:20 -07:00
parent 72c9cf7923
commit 45a14ab7ba
2646 changed files with 237855 additions and 410789 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +0,0 @@
LLIntOffsets

81
API/APICallbackFunction.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013, 2016 Apple Inc. All rights reserved.
* Copyright (C) 2013-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -35,77 +35,96 @@
namespace JSC {
struct APICallbackFunction {
template <typename T> static EncodedJSValue JSC_HOST_CALL call(ExecState*);
template <typename T> static EncodedJSValue JSC_HOST_CALL construct(ExecState*);
template <typename T> static EncodedJSValue callImpl(JSGlobalObject*, CallFrame*);
template <typename T> static EncodedJSValue constructImpl(JSGlobalObject*, CallFrame*);
};
template <typename T>
EncodedJSValue JSC_HOST_CALL APICallbackFunction::call(ExecState* exec)
EncodedJSValue APICallbackFunction::callImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSContextRef execRef = toRef(exec);
JSObjectRef functionRef = toRef(exec->jsCallee());
JSObjectRef thisObjRef = toRef(jsCast<JSObject*>(exec->thisValue().toThis(exec, NotStrictMode)));
JSContextRef execRef = toRef(globalObject);
JSObjectRef functionRef = toRef(callFrame->jsCallee());
JSObjectRef thisObjRef = toRef(jsCast<JSObject*>(callFrame->thisValue().toThis(globalObject, ECMAMode::sloppy())));
int argumentCount = static_cast<int>(exec->argumentCount());
int argumentCount = static_cast<int>(callFrame->argumentCount());
Vector<JSValueRef, 16> arguments;
arguments.reserveInitialCapacity(argumentCount);
for (int i = 0; i < argumentCount; i++)
arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
arguments.uncheckedAppend(toRef(globalObject, callFrame->uncheckedArgument(i)));
JSValueRef exception = 0;
JSValueRef exception = nullptr;
JSValueRef result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = jsCast<T*>(toJS(functionRef))->functionCallback()(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
if (exception) {
throwException(globalObject, scope, toJS(globalObject, exception));
return JSValue::encode(jsUndefined());
}
// result must be a valid JSValue.
if (!result)
return JSValue::encode(jsUndefined());
return JSValue::encode(toJS(exec, result));
return JSValue::encode(toJS(globalObject, result));
}
template <typename T>
EncodedJSValue JSC_HOST_CALL APICallbackFunction::construct(ExecState* exec)
EncodedJSValue APICallbackFunction::constructImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* constructor = exec->jsCallee();
JSContextRef ctx = toRef(exec);
JSValue callee = callFrame->jsCallee();
T* constructor = jsCast<T*>(callFrame->jsCallee());
JSContextRef ctx = toRef(globalObject);
JSObjectRef constructorRef = toRef(constructor);
JSObjectCallAsConstructorCallback callback = jsCast<T*>(constructor)->constructCallback();
JSObjectCallAsConstructorCallback callback = constructor->constructCallback();
if (callback) {
size_t argumentCount = exec->argumentCount();
JSValue prototype;
JSValue newTarget = callFrame->newTarget();
// If we are doing a derived class construction get the .prototype property off the new target first so we behave closer to normal JS.
if (newTarget != constructor) {
prototype = newTarget.get(globalObject, vm.propertyNames->prototype);
RETURN_IF_EXCEPTION(scope, { });
}
size_t argumentCount = callFrame->argumentCount();
Vector<JSValueRef, 16> arguments;
arguments.reserveInitialCapacity(argumentCount);
for (size_t i = 0; i < argumentCount; ++i)
arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
arguments.uncheckedAppend(toRef(globalObject, callFrame->uncheckedArgument(i)));
JSValueRef exception = 0;
JSValueRef exception = nullptr;
JSObjectRef result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = callback(ctx, constructorRef, argumentCount, arguments.data(), &exception);
}
if (exception) {
throwException(exec, scope, toJS(exec, exception));
return JSValue::encode(toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
return JSValue::encode(jsUndefined());
}
// result must be a valid JSValue.
if (!result)
return throwVMTypeError(exec, scope);
return JSValue::encode(toJS(result));
return throwVMTypeError(globalObject, scope);
JSObject* newObject = toJS(result);
// This won't trigger proxy traps on newObject's prototype handler but that's probably desirable here anyway.
if (newTarget != constructor && newObject->getPrototypeDirect(vm) == constructor->get(globalObject, vm.propertyNames->prototype)) {
RETURN_IF_EXCEPTION(scope, { });
newObject->setPrototype(vm, globalObject, prototype);
RETURN_IF_EXCEPTION(scope, { });
}
return JSValue::encode(newObject);
}
return JSValue::encode(toJS(JSObjectMake(ctx, jsCast<JSCallbackConstructor*>(constructor)->classRef(), 0)));
return JSValue::encode(toJS(JSObjectMake(ctx, jsCast<JSCallbackConstructor*>(callee)->classRef(), nullptr)));
}
} // namespace JSC

59
API/APICast.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006 Apple Inc. All rights reserved.
* Copyright (C) 2006-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -33,7 +33,7 @@
#include "HeapCellInlines.h"
namespace JSC {
class ExecState;
class CallFrame;
class PropertyNameArray;
class VM;
class JSObject;
@ -49,26 +49,26 @@ typedef struct OpaqueJSValue* JSObjectRef;
/* Opaque typing convenience methods */
inline JSC::ExecState* toJS(JSContextRef c)
inline JSC::JSGlobalObject* toJS(JSContextRef context)
{
ASSERT(c);
return reinterpret_cast<JSC::ExecState*>(const_cast<OpaqueJSContext*>(c));
ASSERT(context);
return reinterpret_cast<JSC::JSGlobalObject*>(const_cast<OpaqueJSContext*>(context));
}
inline JSC::ExecState* toJS(JSGlobalContextRef c)
inline JSC::JSGlobalObject* toJS(JSGlobalContextRef context)
{
ASSERT(c);
return reinterpret_cast<JSC::ExecState*>(c);
ASSERT(context);
return reinterpret_cast<JSC::JSGlobalObject*>(context);
}
inline JSC::JSGlobalObject* toJSGlobalObject(JSGlobalContextRef context)
{
return toJS(context)->lexicalGlobalObject();
return toJS(context);
}
inline JSC::JSValue toJS(JSC::ExecState* exec, JSValueRef v)
inline JSC::JSValue toJS(JSC::JSGlobalObject* globalObject, JSValueRef v)
{
ASSERT_UNUSED(exec, exec);
ASSERT_UNUSED(globalObject, globalObject);
#if !CPU(ADDRESS64)
JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(const_cast<OpaqueJSValue*>(v));
if (!jsCell)
@ -84,13 +84,20 @@ inline JSC::JSValue toJS(JSC::ExecState* exec, JSValueRef v)
if (!result)
return JSC::jsNull();
if (result.isCell())
RELEASE_ASSERT(result.asCell()->methodTable(exec->vm()));
RELEASE_ASSERT(result.asCell()->methodTable(getVM(globalObject)));
return result;
}
inline JSC::JSValue toJSForGC(JSC::ExecState* exec, JSValueRef v)
#if CPU(ADDRESS64)
inline JSC::JSValue toJS(JSValueRef value)
{
ASSERT_UNUSED(exec, exec);
return bitwise_cast<JSC::JSValue>(value);
}
#endif
inline JSC::JSValue toJSForGC(JSC::JSGlobalObject* globalObject, JSValueRef v)
{
ASSERT_UNUSED(globalObject, globalObject);
#if !CPU(ADDRESS64)
JSC::JSCell* jsCell = reinterpret_cast<JSC::JSCell*>(const_cast<OpaqueJSValue*>(v));
if (!jsCell)
@ -100,7 +107,7 @@ inline JSC::JSValue toJSForGC(JSC::ExecState* exec, JSValueRef v)
JSC::JSValue result = bitwise_cast<JSC::JSValue>(v);
#endif
if (result && result.isCell())
RELEASE_ASSERT(result.asCell()->methodTable(exec->vm()));
RELEASE_ASSERT(result.asCell()->methodTable(getVM(globalObject)));
return result;
}
@ -114,7 +121,7 @@ inline JSC::JSObject* toJS(JSObjectRef o)
{
JSC::JSObject* object = uncheckedToJS(o);
if (object)
RELEASE_ASSERT(object->methodTable(*object->vm()));
RELEASE_ASSERT(object->methodTable(object->vm()));
return object;
}
@ -143,11 +150,18 @@ inline JSValueRef toRef(JSC::VM& vm, JSC::JSValue v)
#endif
}
inline JSValueRef toRef(JSC::ExecState* exec, JSC::JSValue v)
inline JSValueRef toRef(JSC::JSGlobalObject* globalObject, JSC::JSValue v)
{
return toRef(exec->vm(), v);
return toRef(getVM(globalObject), v);
}
#if CPU(ADDRESS64)
inline JSValueRef toRef(JSC::JSValue v)
{
return bitwise_cast<JSValueRef>(v);
}
#endif
inline JSObjectRef toRef(JSC::JSObject* o)
{
return reinterpret_cast<JSObjectRef>(o);
@ -158,15 +172,14 @@ inline JSObjectRef toRef(const JSC::JSObject* o)
return reinterpret_cast<JSObjectRef>(const_cast<JSC::JSObject*>(o));
}
inline JSContextRef toRef(JSC::ExecState* e)
inline JSContextRef toRef(JSC::JSGlobalObject* globalObject)
{
return reinterpret_cast<JSContextRef>(e);
return reinterpret_cast<JSContextRef>(globalObject);
}
inline JSGlobalContextRef toGlobalRef(JSC::ExecState* e)
inline JSGlobalContextRef toGlobalRef(JSC::JSGlobalObject* globalObject)
{
ASSERT(e == e->lexicalGlobalObject()->globalExec());
return reinterpret_cast<JSGlobalContextRef>(e);
return reinterpret_cast<JSGlobalContextRef>(globalObject);
}
inline JSPropertyNameAccumulatorRef toRef(JSC::PropertyNameArray* l)

16
API/APIUtils.h
View File

@ -37,28 +37,30 @@ enum class ExceptionStatus {
DidNotThrow
};
inline ExceptionStatus handleExceptionIfNeeded(JSC::CatchScope& scope, JSC::ExecState* exec, JSValueRef* returnedExceptionRef)
inline ExceptionStatus handleExceptionIfNeeded(JSC::CatchScope& scope, JSContextRef ctx, JSValueRef* returnedExceptionRef)
{
JSC::JSGlobalObject* globalObject = toJS(ctx);
if (UNLIKELY(scope.exception())) {
JSC::Exception* exception = scope.exception();
if (returnedExceptionRef)
*returnedExceptionRef = toRef(exec, exception->value());
*returnedExceptionRef = toRef(globalObject, exception->value());
scope.clearException();
#if ENABLE(REMOTE_INSPECTOR)
scope.vm().vmEntryGlobalObject(exec)->inspectorController().reportAPIException(exec, exception);
globalObject->inspectorController().reportAPIException(globalObject, exception);
#endif
return ExceptionStatus::DidThrow;
}
return ExceptionStatus::DidNotThrow;
}
inline void setException(JSC::ExecState* exec, JSValueRef* returnedExceptionRef, JSC::JSValue exception)
inline void setException(JSContextRef ctx, JSValueRef* returnedExceptionRef, JSC::JSValue exception)
{
JSC::JSGlobalObject* globalObject = toJS(ctx);
if (returnedExceptionRef)
*returnedExceptionRef = toRef(exec, exception);
*returnedExceptionRef = toRef(globalObject, exception);
#if ENABLE(REMOTE_INSPECTOR)
JSC::VM& vm = exec->vm();
vm.vmEntryGlobalObject(exec)->inspectorController().reportAPIException(exec, JSC::Exception::create(vm, exception));
JSC::VM& vm = getVM(globalObject);
globalObject->inspectorController().reportAPIException(globalObject, JSC::Exception::create(vm, exception));
#endif
}

8
API/JSAPIGlobalObject.cpp
View File

@ -44,11 +44,19 @@ const GlobalObjectMethodTable JSAPIGlobalObject::s_globalObjectMethodTable = {
nullptr, // moduleLoaderCreateImportMetaProperties
nullptr, // moduleLoaderEvaluate
nullptr, // promiseRejectionTracker
&reportUncaughtExceptionAtEventLoop,
&currentScriptExecutionOwner,
&scriptExecutionStatus,
nullptr, // defaultLanguage
nullptr, // compileStreaming
nullptr, // instantiateStreaming
};
void JSAPIGlobalObject::reportUncaughtExceptionAtEventLoop(JSGlobalObject* globalObject, Exception* exception)
{
Base::reportUncaughtExceptionAtEventLoop(globalObject, exception);
}
}
#endif

23
API/JSAPIGlobalObject.h
View File

@ -31,13 +31,20 @@ OBJC_CLASS JSScript;
namespace JSC {
class JSAPIGlobalObject : public JSGlobalObject {
class JSAPIGlobalObject final : public JSGlobalObject {
public:
using Base = JSGlobalObject;
DECLARE_EXPORT_INFO;
static const GlobalObjectMethodTable s_globalObjectMethodTable;
static constexpr bool needsDestruction = true;
template<typename CellType, SubspaceAccess mode>
static IsoSubspace* subspaceFor(VM& vm)
{
return vm.apiGlobalObjectSpace<mode>();
}
static JSAPIGlobalObject* create(VM& vm, Structure* structure)
{
auto* object = new (NotNull, allocateCell<JSAPIGlobalObject>(vm.heap)) JSAPIGlobalObject(vm, structure);
@ -47,16 +54,18 @@ public:
static Structure* createStructure(VM& vm, JSValue prototype)
{
auto* result = Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
auto* result = Structure::create(vm, nullptr, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
result->setTransitionWatchpointIsLikelyToBeFired(true);
return result;
}
static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, ExecState*, JSModuleLoader*, JSString* moduleNameValue, JSValue parameters, const SourceOrigin&);
static Identifier moduleLoaderResolve(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue);
static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
static JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSModuleRecord*, JSValue);
static JSValue moduleLoaderEvaluate(JSGlobalObject*, ExecState*, JSModuleLoader*, JSValue, JSValue, JSValue);
static void reportUncaughtExceptionAtEventLoop(JSGlobalObject*, Exception*);
static JSInternalPromise* moduleLoaderImportModule(JSGlobalObject*, JSModuleLoader*, JSString* moduleNameValue, JSValue parameters, const SourceOrigin&);
static Identifier moduleLoaderResolve(JSGlobalObject*, JSModuleLoader*, JSValue keyValue, JSValue referrerValue, JSValue);
static JSInternalPromise* moduleLoaderFetch(JSGlobalObject*, JSModuleLoader*, JSValue, JSValue, JSValue);
static JSObject* moduleLoaderCreateImportMetaProperties(JSGlobalObject*, JSModuleLoader*, JSValue, JSModuleRecord*, JSValue);
static JSValue moduleLoaderEvaluate(JSGlobalObject*, JSModuleLoader*, JSValue, JSValue, JSValue);
JSValue loadAndEvaluateJSScriptModule(const JSLockHolder&, JSScript *);

156
API/JSAPIGlobalObject.mm
View File

@ -29,16 +29,16 @@
#if JSC_OBJC_API_ENABLED
#import "APICast.h"
#import "CallFrameInlines.h"
#import "CatchScope.h"
#import "Completion.h"
#import "Error.h"
#import "Exception.h"
#import "JSContextInternal.h"
#import "JSInternalPromise.h"
#import "JSInternalPromiseDeferred.h"
#import "JSModuleLoader.h"
#import "JSNativeStdFunction.h"
#import "JSPromiseDeferred.h"
#import "JSPromise.h"
#import "JSScriptInternal.h"
#import "JSSourceCode.h"
#import "JSValueInternal.h"
@ -47,11 +47,6 @@
#import "ObjectConstructor.h"
#import "SourceOrigin.h"
#import <wtf/URL.h>
#ifdef DARLING_NONUNIFIED_BUILD
#include "IdentifierInlines.h"
#include "AuxiliaryBarrierInlines.h"
#include "StrongInlines.h"
#endif
namespace JSC {
@ -67,13 +62,22 @@ const GlobalObjectMethodTable JSAPIGlobalObject::s_globalObjectMethodTable = {
&moduleLoaderResolve, // moduleLoaderResolve
&moduleLoaderFetch, // moduleLoaderFetch
&moduleLoaderCreateImportMetaProperties, // moduleLoaderCreateImportMetaProperties
moduleLoaderEvaluate, // moduleLoaderEvaluate
&moduleLoaderEvaluate, // moduleLoaderEvaluate
nullptr, // promiseRejectionTracker
&reportUncaughtExceptionAtEventLoop,
&currentScriptExecutionOwner,
&scriptExecutionStatus,
nullptr, // defaultLanguage
nullptr, // compileStreaming
nullptr, // instantiateStreaming
};
void JSAPIGlobalObject::reportUncaughtExceptionAtEventLoop(JSGlobalObject* globalObject, Exception* exception)
{
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];
[context notifyException:toRef(globalObject->vm(), exception->value())];
}
static Expected<URL, String> computeValidImportSpecifier(const URL& base, const String& specifier)
{
URL absoluteURL(URL(), specifier);
@ -81,7 +85,7 @@ static Expected<URL, String> computeValidImportSpecifier(const URL& base, const
return absoluteURL;
if (!specifier.startsWith('/') && !specifier.startsWith("./") && !specifier.startsWith("../"))
return makeUnexpected(makeString("Module specifier: "_s, specifier, " does not start with \"/\", \"./\", or \"../\"."_s));
return makeUnexpected(makeString("Module specifier: "_s, specifier, " does not start with \"/\", \"./\", or \"../\". Referenced from: "_s, base.string()));
if (specifier.startsWith('/')) {
absoluteURL = URL(URL({ }, "file://"), specifier);
@ -101,18 +105,18 @@ static Expected<URL, String> computeValidImportSpecifier(const URL& base, const
return makeUnexpected(makeString("Could not form valid URL from identifier and base. Tried:"_s, absoluteURL.string()));
}
Identifier JSAPIGlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue key, JSValue referrer, JSValue)
Identifier JSAPIGlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject, JSModuleLoader*, JSValue key, JSValue referrer, JSValue)
{
VM& vm = exec->vm();
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
ASSERT_UNUSED(globalObject, globalObject == exec->lexicalGlobalObject());
ASSERT_UNUSED(globalObject, globalObject == globalObject);
ASSERT(key.isString() || key.isSymbol());
String name = key.toWTFString(exec);
String name = key.toWTFString(globalObject);
RETURN_IF_EXCEPTION(scope, { });
URL base;
if (JSString* referrerString = jsDynamicCast<JSString*>(vm, referrer)) {
String value = referrerString->value(exec);
String value = referrerString->value(globalObject);
RETURN_IF_EXCEPTION(scope, { });
URL referrerURL({ }, value);
RELEASE_ASSERT(referrerURL.isValid());
@ -121,78 +125,85 @@ Identifier JSAPIGlobalObject::moduleLoaderResolve(JSGlobalObject* globalObject,
auto result = computeValidImportSpecifier(base, name);
if (result)
return Identifier::fromString(&vm, result.value());
return Identifier::fromString(vm, result.value().string());
throwVMError(exec, scope, createError(exec, result.error()));
throwVMError(globalObject, scope, createError(globalObject, result.error()));
return { };
}
JSInternalPromise* JSAPIGlobalObject::moduleLoaderImportModule(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSString* specifierValue, JSValue, const SourceOrigin& sourceOrigin)
JSInternalPromise* JSAPIGlobalObject::moduleLoaderImportModule(JSGlobalObject* globalObject, JSModuleLoader*, JSString* specifierValue, JSValue, const SourceOrigin& sourceOrigin)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
auto reject = [&] (JSValue exception) -> JSInternalPromise* {
auto reject = [&] (Exception* exception) -> JSInternalPromise* {
auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
if (UNLIKELY(isTerminatedExecutionException(vm, exception)))
return promise;
JSValue error = exception->value();
scope.clearException();
auto* promise = JSInternalPromiseDeferred::tryCreate(exec, globalObject);
scope.clearException();
return promise->reject(exec, exception);
// FIXME: We could have error since any JS call can throw stack-overflow errors.
// https://bugs.webkit.org/show_bug.cgi?id=203402
promise->reject(globalObject, error);
return promise;
};
auto import = [&] (URL& url) {
auto result = importModule(exec, Identifier::fromString(&vm, url), jsUndefined(), jsUndefined());
auto result = importModule(globalObject, Identifier::fromString(vm, url.string()), jsUndefined(), jsUndefined());
if (UNLIKELY(scope.exception()))
return reject(scope.exception());
return result;
};
auto specifier = specifierValue->value(exec);
if (UNLIKELY(scope.exception())) {
JSValue exception = scope.exception();
scope.clearException();
return reject(exception);
}
auto specifier = specifierValue->value(globalObject);
if (UNLIKELY(scope.exception()))
return reject(scope.exception());
String referrer = !sourceOrigin.isNull() ? sourceOrigin.string() : String();
URL baseURL(URL(), referrer);
auto result = computeValidImportSpecifier(baseURL, specifier);
auto result = computeValidImportSpecifier(sourceOrigin.url(), specifier);
if (result)
return import(result.value());
return reject(createError(exec, result.error()));
auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
// FIXME: We could have error since any JS call can throw stack-overflow errors.
// https://bugs.webkit.org/show_bug.cgi?id=203402
promise->reject(globalObject, createError(globalObject, result.error()));
return promise;
}
JSInternalPromise* JSAPIGlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue key, JSValue, JSValue)
JSInternalPromise* JSAPIGlobalObject::moduleLoaderFetch(JSGlobalObject* globalObject, JSModuleLoader*, JSValue key, JSValue, JSValue)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
ASSERT(globalObject == exec->lexicalGlobalObject());
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject->globalExec())];
ASSERT(globalObject == globalObject);
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];
JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(exec, globalObject);
RETURN_IF_EXCEPTION(scope, nullptr);
JSInternalPromise* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
Identifier moduleKey = key.toPropertyKey(exec);
Identifier moduleKey = key.toPropertyKey(globalObject);
if (UNLIKELY(scope.exception())) {
JSValue exception = scope.exception();
Exception* exception = scope.exception();
if (UNLIKELY(isTerminatedExecutionException(vm, exception)))
return promise;
scope.clearException();
return deferred->reject(exec, exception);
promise->reject(globalObject, exception->value());
return promise;
}
if (UNLIKELY(![context moduleLoaderDelegate]))
return deferred->reject(exec, createError(exec, "No module loader provided."));
if (UNLIKELY(![context moduleLoaderDelegate])) {
promise->reject(globalObject, createError(globalObject, "No module loader provided."));
return promise;
}
auto deferredPromise = Strong<JSInternalPromiseDeferred>(vm, deferred);
auto* resolve = JSNativeStdFunction::create(vm, globalObject, 1, "resolve", [=] (ExecState* exec) {
auto strongPromise = Strong<JSInternalPromise>(vm, promise);
auto* resolve = JSNativeStdFunction::create(vm, globalObject, 1, "resolve", [=] (JSGlobalObject* globalObject, CallFrame* callFrame) {
// This captures the globalObject but that's ok because our structure keeps it alive anyway.
VM& vm = exec->vm();
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject->globalExec())];
id script = valueToObject(context, toRef(exec, exec->argument(0)));
VM& vm = globalObject->vm();
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];
id script = valueToObject(context, toRef(globalObject, callFrame->argument(0)));
MarkedArgumentBuffer args;
auto rejectPromise = [&] (String message) {
args.append(createTypeError(exec, message));
call(exec, deferredPromise->JSPromiseDeferred::reject(), args, "This should never be seen...");
strongPromise.get()->reject(globalObject, createTypeError(globalObject, message));
return encodedJSUndefined();
};
@ -207,55 +218,51 @@ JSInternalPromise* JSAPIGlobalObject::moduleLoaderFetch(JSGlobalObject* globalOb
NSURL *sourceURL = [jsScript sourceURL];
String oldModuleKey { [sourceURL absoluteString] };
if (UNLIKELY(Identifier::fromString(&vm, oldModuleKey) != moduleKey))
if (UNLIKELY(Identifier::fromString(vm, oldModuleKey) != moduleKey))
return rejectPromise(makeString("The same JSScript was provided for two different identifiers, previously: ", oldModuleKey, " and now: ", moduleKey.string()));
args.append(source);
call(exec, deferredPromise->JSPromiseDeferred::resolve(), args, "This should never be seen...");
strongPromise.get()->resolve(globalObject, source);
return encodedJSUndefined();
});
auto* reject = JSNativeStdFunction::create(vm, globalObject, 1, "reject", [=] (ExecState* exec) {
MarkedArgumentBuffer args;
args.append(exec->argument(0));
call(exec, deferredPromise->JSPromiseDeferred::reject(), args, "This should never be seen...");
auto* reject = JSNativeStdFunction::create(vm, globalObject, 1, "reject", [=] (JSGlobalObject*, CallFrame* callFrame) {
strongPromise.get()->reject(globalObject, callFrame->argument(0));
return encodedJSUndefined();
});
[[context moduleLoaderDelegate] context:context fetchModuleForIdentifier:[::JSValue valueWithJSValueRef:toRef(exec, key) inContext:context] withResolveHandler:[::JSValue valueWithJSValueRef:toRef(exec, resolve) inContext:context] andRejectHandler:[::JSValue valueWithJSValueRef:toRef(exec, reject) inContext:context]];
[[context moduleLoaderDelegate] context:context fetchModuleForIdentifier:[::JSValue valueWithJSValueRef:toRef(globalObject, key) inContext:context] withResolveHandler:[::JSValue valueWithJSValueRef:toRef(globalObject, resolve) inContext:context] andRejectHandler:[::JSValue valueWithJSValueRef:toRef(globalObject, reject) inContext:context]];
if (context.exception) {
deferred->reject(exec, toJS(exec, [context.exception JSValueRef]));
promise->reject(globalObject, toJS(globalObject, [context.exception JSValueRef]));
context.exception = nil;
}
return deferred->promise();
return promise;
}
JSObject* JSAPIGlobalObject::moduleLoaderCreateImportMetaProperties(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader*, JSValue key, JSModuleRecord*, JSValue)
JSObject* JSAPIGlobalObject::moduleLoaderCreateImportMetaProperties(JSGlobalObject* globalObject, JSModuleLoader*, JSValue key, JSModuleRecord*, JSValue)
{
VM& vm = exec->vm();
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* metaProperties = constructEmptyObject(exec, globalObject->nullPrototypeObjectStructure());
JSObject* metaProperties = constructEmptyObject(vm, globalObject->nullPrototypeObjectStructure());
RETURN_IF_EXCEPTION(scope, nullptr);
metaProperties->putDirect(vm, Identifier::fromString(&vm, "filename"), key);
metaProperties->putDirect(vm, Identifier::fromString(vm, "filename"), key);
RETURN_IF_EXCEPTION(scope, nullptr);
return metaProperties;
}
JSValue JSAPIGlobalObject::moduleLoaderEvaluate(JSGlobalObject* globalObject, ExecState* exec, JSModuleLoader* moduleLoader, JSValue key, JSValue moduleRecordValue, JSValue scriptFetcher)
JSValue JSAPIGlobalObject::moduleLoaderEvaluate(JSGlobalObject* globalObject, JSModuleLoader* moduleLoader, JSValue key, JSValue moduleRecordValue, JSValue scriptFetcher)
{
VM& vm = exec->vm();
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject->globalExec())];
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];
id <JSModuleLoaderDelegate> moduleLoaderDelegate = [context moduleLoaderDelegate];
NSURL *url = nil;
if ([moduleLoaderDelegate respondsToSelector:@selector(willEvaluateModule:)] || [moduleLoaderDelegate respondsToSelector:@selector(didEvaluateModule:)]) {
String moduleKey = key.toWTFString(exec);
String moduleKey = key.toWTFString(globalObject);
RETURN_IF_EXCEPTION(scope, { });
url = [NSURL URLWithString:static_cast<NSString *>(moduleKey)];
}
@ -264,7 +271,7 @@ JSValue JSAPIGlobalObject::moduleLoaderEvaluate(JSGlobalObject* globalObject, Ex
[moduleLoaderDelegate willEvaluateModule:url];
scope.release();
JSValue result = moduleLoader->evaluateNonVirtual(exec, key, moduleRecordValue, scriptFetcher);
JSValue result = moduleLoader->evaluateNonVirtual(globalObject, key, moduleRecordValue, scriptFetcher);
if ([moduleLoaderDelegate respondsToSelector:@selector(didEvaluateModule:)])
[moduleLoaderDelegate didEvaluateModule:url];
@ -276,16 +283,15 @@ JSValue JSAPIGlobalObject::loadAndEvaluateJSScriptModule(const JSLockHolder&, JS
{
ASSERT(script.type == kJSScriptTypeModule);
VM& vm = this->vm();
ExecState* exec = globalExec();
auto scope = DECLARE_THROW_SCOPE(vm);
Identifier key = Identifier::fromString(exec, String { [[script sourceURL] absoluteString] });
JSInternalPromise* promise = importModule(exec, key, jsUndefined(), jsUndefined());
Identifier key = Identifier::fromString(vm, String { [[script sourceURL] absoluteString] });
JSInternalPromise* promise = importModule(this, key, jsUndefined(), jsUndefined());
RETURN_IF_EXCEPTION(scope, { });
auto result = JSPromiseDeferred::tryCreate(exec, this);
auto* result = JSPromise::create(vm, this->promiseStructure());
result->resolve(this, promise);
RETURN_IF_EXCEPTION(scope, { });
result->resolve(exec, promise);
return result->promise();
return result;
}
}

2
API/JSAPIValueWrapper.cpp
View File

@ -23,8 +23,6 @@
#include "config.h"
#include "JSAPIValueWrapper.h"
#include "NumberObject.h"
namespace JSC {
STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSAPIValueWrapper);

19
API/JSAPIValueWrapper.h
View File

@ -1,7 +1,7 @@
/*
* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
* Copyright (C) 2003-2019 Apple Inc. All rights reserved.
* Copyright (C) 2003-2020 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
@ -30,16 +30,22 @@
namespace JSC {
class JSAPIValueWrapper final : public JSCell {
friend JSValue jsAPIValueWrapper(ExecState*, JSValue);
friend JSValue jsAPIValueWrapper(JSGlobalObject*, JSValue);
public:
typedef JSCell Base;
static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;
using Base = JSCell;
static constexpr unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;
template<typename CellType, SubspaceAccess mode>
static IsoSubspace* subspaceFor(VM& vm)
{
return vm.apiValueWrapperSpace<mode>();
}
JSValue value() const { return m_value.get(); }
static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(vm, globalObject, prototype, TypeInfo(APIValueWrapperType, OverridesGetPropertyNames), info());
return Structure::create(vm, globalObject, prototype, TypeInfo(APIValueWrapperType, StructureFlags), info());
}
DECLARE_EXPORT_INFO;
@ -51,7 +57,7 @@ public:
return wrapper;
}
protected:
private:
void finishCreation(VM& vm, JSValue value)
{
Base::finishCreation(vm);
@ -59,7 +65,6 @@ protected:
ASSERT(!value.isCell());
}
private:
JSAPIValueWrapper(VM& vm)
: JSCell(vm, vm.apiWrapperStructure.get())
{

7
API/JSAPIWrapperObject.h
View File

@ -33,9 +33,12 @@
namespace JSC {
class JSAPIWrapperObject : public JSDestructibleObject {
class JSAPIWrapperObject : public JSNonFinalObject {
public:
typedef JSDestructibleObject Base;
using Base = JSNonFinalObject;
template<typename, SubspaceAccess>
static void subspaceFor(VM&) { RELEASE_ASSERT_NOT_REACHED(); }
void finishCreation(VM&);
static void visitChildren(JSCell*, JSC::SlotVisitor&);

87
API/JSAPIWrapperObject.mm
View File

@ -23,21 +23,21 @@
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "JSAPIWrapperObject.h"
#import "config.h"
#import "JSAPIWrapperObject.h"
#include "JSCInlines.h"
#include "JSCallbackObject.h"
#include "JSVirtualMachineInternal.h"
#include "Structure.h"
#include <wtf/NeverDestroyed.h>
#import "JSCInlines.h"
#import "JSCallbackObject.h"
#import "JSVirtualMachineInternal.h"
#import "Structure.h"
#import <wtf/NeverDestroyed.h>
#if JSC_OBJC_API_ENABLED
class JSAPIWrapperObjectHandleOwner : public JSC::WeakHandleOwner {
class JSAPIWrapperObjectHandleOwner final : public JSC::WeakHandleOwner {
public:
void finalize(JSC::Handle<JSC::Unknown>, void*) override;
bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**) override;
void finalize(JSC::Handle<JSC::Unknown>, void*) final;
bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**) final;
};
static JSAPIWrapperObjectHandleOwner* jsAPIWrapperObjectHandleOwner()
@ -67,10 +67,38 @@ bool JSAPIWrapperObjectHandleOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::
}
namespace JSC {
template <> const ClassInfo JSCallbackObject<JSAPIWrapperObject>::s_info = { "JSAPIWrapperObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template<> const bool JSCallbackObject<JSAPIWrapperObject>::needsDestruction = true;
static JSC_DECLARE_HOST_FUNCTION(callJSAPIWrapperObjectCallbackObject);
static JSC_DECLARE_HOST_FUNCTION(constructJSAPIWrapperObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(callbackGetterJSAPIWrapperObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(staticFunctionGetterJSAPIWrapperObjectCallbackObject);
template <> const ClassInfo JSCallbackObject<JSAPIWrapperObject>::s_info = { "JSAPIWrapperObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template <> const bool JSCallbackObject<JSAPIWrapperObject>::needsDestruction = true;
template <>
RawNativeFunction JSCallbackObject<JSAPIWrapperObject>::getCallFunction()
{
return callJSAPIWrapperObjectCallbackObject;
}
template <>
RawNativeFunction JSCallbackObject<JSAPIWrapperObject>::getConstructFunction()
{
return constructJSAPIWrapperObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSAPIWrapperObject>::getCallbackGetter()
{
return callbackGetterJSAPIWrapperObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSAPIWrapperObject>::getStaticFunctionGetter()
{
return staticFunctionGetterJSAPIWrapperObjectCallbackObject;
}
template <>
Structure* JSCallbackObject<JSAPIWrapperObject>::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
@ -105,6 +133,39 @@ void JSAPIWrapperObject::visitChildren(JSCell* cell, JSC::SlotVisitor& visitor)
scanExternalObjectGraph(visitor.vm(), visitor, wrappedObject);
}
template <>
IsoSubspace* JSCallbackObject<JSAPIWrapperObject>::subspaceForImpl(VM& vm, SubspaceAccess mode)
{
switch (mode) {
case SubspaceAccess::OnMainThread:
return vm.apiWrapperObjectSpace<SubspaceAccess::OnMainThread>();
case SubspaceAccess::Concurrently:
return vm.apiWrapperObjectSpace<SubspaceAccess::Concurrently>();
}
RELEASE_ASSERT_NOT_REACHED();
return nullptr;
}
JSC_DEFINE_HOST_FUNCTION(callJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSAPIWrapperObject>::callImpl(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSAPIWrapperObject>::constructImpl(globalObject, callFrame);
}
JSC_DEFINE_CUSTOM_GETTER(callbackGetterJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSAPIWrapperObject>::callbackGetterImpl(globalObject, thisValue, propertyName);
}
JSC_DEFINE_CUSTOM_GETTER(staticFunctionGetterJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSAPIWrapperObject>::staticFunctionGetterImpl(globalObject, thisValue, propertyName);
}
} // namespace JSC
#endif // JSC_OBJC_API_ENABLED

95
API/JSBase.cpp
View File

@ -29,18 +29,13 @@
#include "JSBasePrivate.h"
#include "APICast.h"
#include "CallFrame.h"
#include "Completion.h"
#include "Exception.h"
#include "GCActivityCallback.h"
#include "InitializeThreading.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSObject.h"
#include "OpaqueJSString.h"
#include "JSCInlines.h"
#include "JSLock.h"
#include "ObjectConstructor.h"
#include "OpaqueJSString.h"
#include "SourceCode.h"
#include <wtf/text/StringHash.h>
#if ENABLE(REMOTE_INSPECTOR)
#include "JSGlobalObjectInspectorController.h"
@ -48,81 +43,78 @@
using namespace JSC;
JSValueRef JSEvaluateScriptInternal(const JSLockHolder&, ExecState* exec, JSContextRef ctx, JSObjectRef thisObject, const SourceCode& source, JSValueRef* exception)
JSValueRef JSEvaluateScriptInternal(const JSLockHolder&, JSContextRef ctx, JSObjectRef thisObject, const SourceCode& source, JSValueRef* exception)
{
UNUSED_PARAM(ctx);
JSObject* jsThisObject = toJS(thisObject);
// evaluate sets "this" to the global object if it is NULL
VM& vm = exec->vm();
JSGlobalObject* globalObject = vm.vmEntryGlobalObject(exec);
JSGlobalObject* globalObject = toJS(ctx);
NakedPtr<Exception> evaluationException;
JSValue returnValue = profiledEvaluate(globalObject->globalExec(), ProfilingReason::API, source, jsThisObject, evaluationException);
JSValue returnValue = profiledEvaluate(globalObject, ProfilingReason::API, source, jsThisObject, evaluationException);
if (evaluationException) {
if (exception)
*exception = toRef(exec, evaluationException->value());
*exception = toRef(globalObject, evaluationException->value());
#if ENABLE(REMOTE_INSPECTOR)
// FIXME: If we have a debugger attached we could learn about ParseError exceptions through
// ScriptDebugServer::sourceParsed and this path could produce a duplicate warning. The
// Debugger path is currently ignored by inspector.
// NOTE: If we don't have a debugger, this SourceCode will be forever lost to the inspector.
// We could stash it in the inspector in case an inspector is ever opened.
globalObject->inspectorController().reportAPIException(exec, evaluationException);
globalObject->inspectorController().reportAPIException(globalObject, evaluationException);
#endif
return nullptr;
}
if (returnValue)
return toRef(exec, returnValue);
return toRef(globalObject, returnValue);
// happens, for example, when the only statement is an empty (';') statement
return toRef(exec, jsUndefined());
return toRef(globalObject, jsUndefined());
}
JSValueRef JSEvaluateScript(JSContextRef ctx, JSStringRef script, JSObjectRef thisObject, JSStringRef sourceURL, int startingLineNumber, JSValueRef* exception)
JSValueRef JSEvaluateScript(JSContextRef ctx, JSStringRef script, JSObjectRef thisObject, JSStringRef sourceURLString, int startingLineNumber, JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
startingLineNumber = std::max(1, startingLineNumber);
auto sourceURLString = sourceURL ? sourceURL->string() : String();
SourceCode source = makeSource(script->string(), SourceOrigin { sourceURLString }, URL({ }, sourceURLString), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()));
auto sourceURL = sourceURLString ? URL({ }, sourceURLString->string()) : URL();
SourceCode source = makeSource(script->string(), SourceOrigin { sourceURL }, sourceURL.string(), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()));
return JSEvaluateScriptInternal(locker, exec, ctx, thisObject, source, exception);
return JSEvaluateScriptInternal(locker, ctx, thisObject, source, exception);
}
bool JSCheckScriptSyntax(JSContextRef ctx, JSStringRef script, JSStringRef sourceURL, int startingLineNumber, JSValueRef* exception)
bool JSCheckScriptSyntax(JSContextRef ctx, JSStringRef script, JSStringRef sourceURLString, int startingLineNumber, JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
startingLineNumber = std::max(1, startingLineNumber);
auto sourceURLString = sourceURL ? sourceURL->string() : String();
SourceCode source = makeSource(script->string(), SourceOrigin { sourceURLString }, URL({ }, sourceURLString), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()));
auto sourceURL = sourceURLString ? URL({ }, sourceURLString->string()) : URL();
SourceCode source = makeSource(script->string(), SourceOrigin { sourceURL }, sourceURL.string(), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()));
JSValue syntaxException;
bool isValidSyntax = checkSyntax(vm.vmEntryGlobalObject(exec)->globalExec(), source, &syntaxException);
bool isValidSyntax = checkSyntax(globalObject, source, &syntaxException);
if (!isValidSyntax) {
if (exception)
*exception = toRef(exec, syntaxException);
*exception = toRef(globalObject, syntaxException);
#if ENABLE(REMOTE_INSPECTOR)
Exception* exception = Exception::create(vm, syntaxException);
vm.vmEntryGlobalObject(exec)->inspectorController().reportAPIException(exec, exception);
globalObject->inspectorController().reportAPIException(globalObject, exception);
#endif
return false;
}
@ -140,8 +132,8 @@ void JSGarbageCollect(JSContextRef ctx)
if (!ctx)
return;
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
vm.heap.reportAbandonedObjectGraph();
@ -153,8 +145,8 @@ void JSReportExtraMemoryCost(JSContextRef ctx, size_t size)
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
vm.heap.deprecatedReportExtraMemory(size);
@ -168,8 +160,8 @@ void JSSynchronousGarbageCollectForDebugging(JSContextRef ctx)
if (!ctx)
return;
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
vm.heap.collectNow(Sync, CollectionScope::Full);
}
@ -179,8 +171,8 @@ void JSSynchronousEdenCollectForDebugging(JSContextRef ctx)
if (!ctx)
return;
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
vm.heap.collectSync(CollectionScope::Eden);
}
@ -190,6 +182,29 @@ void JSDisableGCTimer(void)
GCActivityCallback::s_shouldCreateGCTimer = false;
}
JSObjectRef JSGetMemoryUsageStatistics(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return nullptr;
}
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* object = constructEmptyObject(globalObject);
object->putDirect(vm, Identifier::fromString(vm, "heapSize"), jsNumber(vm.heap.size()));
object->putDirect(vm, Identifier::fromString(vm, "heapCapacity"), jsNumber(vm.heap.capacity()));
object->putDirect(vm, Identifier::fromString(vm, "extraMemorySize"), jsNumber(vm.heap.extraMemorySize()));
object->putDirect(vm, Identifier::fromString(vm, "objectCount"), jsNumber(vm.heap.objectCount()));
object->putDirect(vm, Identifier::fromString(vm, "protectedObjectCount"), jsNumber(vm.heap.protectedObjectCount()));
object->putDirect(vm, Identifier::fromString(vm, "globalObjectCount"), jsNumber(vm.heap.globalObjectCount()));
object->putDirect(vm, Identifier::fromString(vm, "protectedGlobalObjectCount"), jsNumber(vm.heap.protectedGlobalObjectCount()));
return toRef(object);
}
#if PLATFORM(IOS_FAMILY) && TARGET_OS_IOS
// FIXME: Expose symbols to tell dyld where to find JavaScriptCore on older versions of
// iOS (< 7.0). We should remove these symbols once we no longer need to support such

2
API/JSBase.h
View File

@ -145,7 +145,7 @@ JS_EXPORT void JSGarbageCollect(JSContextRef ctx);
/* Enable the Objective-C API for platforms with a modern runtime. NOTE: This is duplicated in VM.h. */
#if !defined(JSC_OBJC_API_ENABLED)
#if (defined(__clang__) && defined(__APPLE__) && ((defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && !defined(__i386__)) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)))
#if (defined(__clang__) && defined(__APPLE__) && (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)))
#define JSC_OBJC_API_ENABLED 1
#else
#define JSC_OBJC_API_ENABLED 0

4
API/JSBaseInternal.h
View File

@ -29,9 +29,9 @@
#include <JavaScriptCore/WebKitAvailability.h>
namespace JSC {
class CallFrame;
class JSLockHolder;
class ExecState;
class SourceCode;
}
extern "C" JSValueRef JSEvaluateScriptInternal(const JSC::JSLockHolder&, JSC::ExecState*, JSContextRef, JSObjectRef thisObject, const JSC::SourceCode&, JSValueRef* exception);
extern "C" JSValueRef JSEvaluateScriptInternal(const JSC::JSLockHolder&, JSContextRef, JSObjectRef thisObject, const JSC::SourceCode&, JSValueRef* exception);

16
API/JSBasePrivate.h
View File

@ -47,6 +47,22 @@ JS_EXPORT void JSReportExtraMemoryCost(JSContextRef ctx, size_t size) JSC_API_AV
JS_EXPORT void JSDisableGCTimer(void);
/*!
@function
@abstract Produces an object with various statistics about current memory usage.
@param ctx The execution context to use.
@result An object containing GC heap status data.
@discussion Specifically, the result object has the following integer-valued fields:
heapSize: current size of heap
heapCapacity: current capacity of heap
extraMemorySize: amount of non-GC memory referenced by GC objects (included in heap size / capacity)
objectCount: current count of GC objects
protectedObjectCount: current count of protected GC objects
globalObjectCount: current count of global GC objects
protectedGlobalObjectCount: current count of protected global GC objects
*/
JS_EXPORT JSObjectRef JSGetMemoryUsageStatistics(JSContextRef ctx);
#ifdef __cplusplus
}
#endif

26
API/JSCTestRunnerUtils.cpp
View File

@ -27,7 +27,7 @@
#include "JSCTestRunnerUtils.h"
#include "APICast.h"
#include "JSCInlines.h"
#include "JSGlobalObjectInlines.h"
#include "TestRunnerUtils.h"
namespace JSC {
@ -35,30 +35,30 @@ namespace JSC {
JSValueRef failNextNewCodeBlock(JSContextRef context)
{
ExecState* exec= toJS(context);
JSLockHolder holder(exec);
return toRef(exec, failNextNewCodeBlock(exec));
JSGlobalObject* globalObject= toJS(context);
JSLockHolder holder(globalObject);
return toRef(globalObject, failNextNewCodeBlock(globalObject));
}
JSValueRef numberOfDFGCompiles(JSContextRef context, JSValueRef theFunctionValueRef)
{
ExecState* exec= toJS(context);
JSLockHolder holder(exec);
return toRef(exec, numberOfDFGCompiles(toJS(exec, theFunctionValueRef)));
JSGlobalObject* globalObject= toJS(context);
JSLockHolder holder(globalObject);
return toRef(globalObject, numberOfDFGCompiles(toJS(globalObject, theFunctionValueRef)));
}
JSValueRef setNeverInline(JSContextRef context, JSValueRef theFunctionValueRef)
{
ExecState* exec= toJS(context);
JSLockHolder holder(exec);
return toRef(exec, setNeverInline(toJS(exec, theFunctionValueRef)));
JSGlobalObject* globalObject= toJS(context);
JSLockHolder holder(globalObject);
return toRef(globalObject, setNeverInline(toJS(globalObject, theFunctionValueRef)));
}
JSValueRef setNeverOptimize(JSContextRef context, JSValueRef theFunctionValueRef)
{
ExecState* exec= toJS(context);
JSLockHolder holder(exec);
return toRef(exec, setNeverOptimize(toJS(exec, theFunctionValueRef)));
JSGlobalObject* globalObject= toJS(context);
JSLockHolder holder(globalObject);
return toRef(globalObject, setNeverOptimize(toJS(globalObject, theFunctionValueRef)));
}
} // namespace JSC

26
API/JSCallbackConstructor.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
* Copyright (C) 2006-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -28,18 +28,15 @@
#include "APICallbackFunction.h"
#include "APICast.h"
#include "Error.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"
#include "JSLock.h"
namespace JSC {
const ClassInfo JSCallbackConstructor::s_info = { "CallbackConstructor", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackConstructor) };
JSCallbackConstructor::JSCallbackConstructor(JSGlobalObject* globalObject, Structure* structure, JSClassRef jsClass, JSObjectCallAsConstructorCallback callback)
: JSDestructibleObject(globalObject->vm(), structure)
: Base(globalObject->vm(), structure)
, m_class(jsClass)
, m_callback(callback)
{
@ -48,7 +45,7 @@ JSCallbackConstructor::JSCallbackConstructor(JSGlobalObject* globalObject, Struc
void JSCallbackConstructor::finishCreation(JSGlobalObject* globalObject, JSClassRef jsClass)
{
Base::finishCreation(globalObject->vm());
ASSERT(inherits(*vm(), info()));
ASSERT(inherits(vm(), info()));
if (m_class)
JSClassRetain(jsClass);
}
@ -64,10 +61,19 @@ void JSCallbackConstructor::destroy(JSCell* cell)
static_cast<JSCallbackConstructor*>(cell)->JSCallbackConstructor::~JSCallbackConstructor();
}
ConstructType JSCallbackConstructor::getConstructData(JSCell*, ConstructData& constructData)
static JSC_DECLARE_HOST_FUNCTION(constructJSCallbackConstructor);
JSC_DEFINE_HOST_FUNCTION(constructJSCallbackConstructor, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
constructData.native.function = APICallbackFunction::construct<JSCallbackConstructor>;
return ConstructType::Host;
return APICallbackFunction::constructImpl<JSCallbackConstructor>(globalObject, callFrame);
}
CallData JSCallbackConstructor::getConstructData(JSCell*)
{
CallData constructData;
constructData.type = CallData::Type::Native;
constructData.native.function = constructJSCallbackConstructor;
return constructData;
}
} // namespace JSC

26
API/JSCallbackConstructor.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
* Copyright (C) 2006-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -26,19 +26,26 @@
#ifndef JSCallbackConstructor_h
#define JSCallbackConstructor_h
#include "JSDestructibleObject.h"
#include "JSObject.h"
#include "JSObjectRef.h"
namespace JSC {
class JSCallbackConstructor final : public JSDestructibleObject {
class JSCallbackConstructor final : public JSNonFinalObject {
public:
typedef JSDestructibleObject Base;
static const unsigned StructureFlags = Base::StructureFlags | ImplementsHasInstance | ImplementsDefaultHasInstance;
using Base = JSNonFinalObject;
static constexpr unsigned StructureFlags = Base::StructureFlags | ImplementsHasInstance | ImplementsDefaultHasInstance;
static constexpr bool needsDestruction = true;
static JSCallbackConstructor* create(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, JSClassRef classRef, JSObjectCallAsConstructorCallback callback)
template<typename CellType, SubspaceAccess mode>
static IsoSubspace* subspaceFor(VM& vm)
{
VM& vm = exec->vm();
return vm.callbackConstructorSpace<mode>();
}
static JSCallbackConstructor* create(JSGlobalObject* globalObject, Structure* structure, JSClassRef classRef, JSObjectCallAsConstructorCallback callback)
{
VM& vm = getVM(globalObject);
JSCallbackConstructor* constructor = new (NotNull, allocateCell<JSCallbackConstructor>(vm.heap)) JSCallbackConstructor(globalObject, structure, classRef, callback);
constructor->finishCreation(globalObject, classRef);
return constructor;
@ -55,14 +62,13 @@ public:
return Structure::create(vm, globalObject, proto, TypeInfo(ObjectType, StructureFlags), info());
}
protected:
private:
JSCallbackConstructor(JSGlobalObject*, Structure*, JSClassRef, JSObjectCallAsConstructorCallback);
void finishCreation(JSGlobalObject*, JSClassRef);
private:
friend struct APICallbackFunction;
static ConstructType getConstructData(JSCell*, ConstructData&);
static CallData getConstructData(JSCell*);
JSObjectCallAsConstructorCallback constructCallback() { return m_callback; }

19
API/JSCallbackFunction.cpp
View File

@ -27,14 +27,6 @@
#include "JSCallbackFunction.h"
#include "APICallbackFunction.h"
#include "APICast.h"
#include "CodeBlock.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "FunctionPrototype.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSCInlines.h"
namespace JSC {
@ -43,15 +35,22 @@ STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSCallbackFunction);
const ClassInfo JSCallbackFunction::s_info = { "CallbackFunction", &InternalFunction::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackFunction) };
static JSC_DECLARE_HOST_FUNCTION(callJSCallbackFunction);
JSC_DEFINE_HOST_FUNCTION(callJSCallbackFunction, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return APICallbackFunction::callImpl<JSCallbackFunction>(globalObject, callFrame);
}
JSCallbackFunction::JSCallbackFunction(VM& vm, Structure* structure, JSObjectCallAsFunctionCallback callback)
: InternalFunction(vm, structure, APICallbackFunction::call<JSCallbackFunction>, nullptr)
: InternalFunction(vm, structure, callJSCallbackFunction, nullptr)
, m_callback(callback)
{
}
void JSCallbackFunction::finishCreation(VM& vm, const String& name)
{
Base::finishCreation(vm, name);
Base::finishCreation(vm, 0, name);
ASSERT(inherits(vm, info()));
}

138
API/JSCallbackObject.cpp
View File

@ -27,18 +27,74 @@
#include "config.h"
#include "JSCallbackObject.h"
#include "Heap.h"
#include "JSCInlines.h"
#include <wtf/text/StringHash.h>
namespace JSC {
// Define the two types of JSCallbackObjects we support.
template <> const ClassInfo JSCallbackObject<JSDestructibleObject>::s_info = { "CallbackObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template <> const ClassInfo JSCallbackObject<JSGlobalObject>::s_info = { "CallbackGlobalObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
static JSC_DECLARE_HOST_FUNCTION(callJSNonFinalObjectCallbackObject);
static JSC_DECLARE_HOST_FUNCTION(constructJSNonFinalObjectCallbackObject);
static JSC_DECLARE_HOST_FUNCTION(callJSGlobalObjectCallbackObject);
static JSC_DECLARE_HOST_FUNCTION(constructJSGlobalObjectCallbackObject);
template<> const bool JSCallbackObject<JSDestructibleObject>::needsDestruction = true;
template<> const bool JSCallbackObject<JSGlobalObject>::needsDestruction = false;
static JSC_DECLARE_CUSTOM_GETTER(callbackGetterJSNonFinalObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(staticFunctionGetterJSNonFinalObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(callbackGetterJSGlobalObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(staticFunctionGetterJSGlobalObjectCallbackObject);
// Define the two types of JSCallbackObjects we support.
template <> const ClassInfo JSCallbackObject<JSNonFinalObject>::s_info = { "CallbackObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template <> const ClassInfo JSCallbackObject<JSGlobalObject>::s_info = { "CallbackGlobalObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template<> const bool JSCallbackObject<JSNonFinalObject>::needsDestruction = true;
template<> const bool JSCallbackObject<JSGlobalObject>::needsDestruction = true;
template<>
RawNativeFunction JSCallbackObject<JSNonFinalObject>::getCallFunction()
{
return callJSNonFinalObjectCallbackObject;
}
template<>
RawNativeFunction JSCallbackObject<JSNonFinalObject>::getConstructFunction()
{
return constructJSNonFinalObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSNonFinalObject>::getCallbackGetter()
{
return callbackGetterJSNonFinalObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSNonFinalObject>::getStaticFunctionGetter()
{
return staticFunctionGetterJSNonFinalObjectCallbackObject;
}
template<>
RawNativeFunction JSCallbackObject<JSGlobalObject>::getCallFunction()
{
return callJSGlobalObjectCallbackObject;
}
template<>
RawNativeFunction JSCallbackObject<JSGlobalObject>::getConstructFunction()
{
return constructJSGlobalObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSGlobalObject>::getCallbackGetter()
{
return callbackGetterJSGlobalObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSGlobalObject>::getStaticFunctionGetter()
{
return staticFunctionGetterJSGlobalObjectCallbackObject;
}
template<>
JSCallbackObject<JSGlobalObject>* JSCallbackObject<JSGlobalObject>::create(VM& vm, JSClassRef classRef, Structure* structure)
@ -49,7 +105,7 @@ JSCallbackObject<JSGlobalObject>* JSCallbackObject<JSGlobalObject>::create(VM& v
}
template <>
Structure* JSCallbackObject<JSDestructibleObject>::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
Structure* JSCallbackObject<JSNonFinalObject>::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
{
return Structure::create(vm, globalObject, proto, TypeInfo(ObjectType, StructureFlags), info());
}
@ -60,4 +116,70 @@ Structure* JSCallbackObject<JSGlobalObject>::createStructure(VM& vm, JSGlobalObj
return Structure::create(vm, globalObject, proto, TypeInfo(GlobalObjectType, StructureFlags), info());
}
template <>
IsoSubspace* JSCallbackObject<JSNonFinalObject>::subspaceForImpl(VM& vm, SubspaceAccess mode)
{
switch (mode) {
case SubspaceAccess::OnMainThread:
return vm.callbackObjectSpace<SubspaceAccess::OnMainThread>();
case SubspaceAccess::Concurrently:
return vm.callbackObjectSpace<SubspaceAccess::Concurrently>();
}
RELEASE_ASSERT_NOT_REACHED();
return nullptr;
}
template <>
IsoSubspace* JSCallbackObject<JSGlobalObject>::subspaceForImpl(VM& vm, SubspaceAccess mode)
{
switch (mode) {
case SubspaceAccess::OnMainThread:
return vm.callbackGlobalObjectSpace<SubspaceAccess::OnMainThread>();
case SubspaceAccess::Concurrently:
return vm.callbackGlobalObjectSpace<SubspaceAccess::Concurrently>();
}
RELEASE_ASSERT_NOT_REACHED();
return nullptr;
}
JSC_DEFINE_HOST_FUNCTION(callJSNonFinalObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSNonFinalObject>::callImpl(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructJSNonFinalObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSNonFinalObject>::constructImpl(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(callJSGlobalObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSGlobalObject>::callImpl(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructJSGlobalObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSGlobalObject>::constructImpl(globalObject, callFrame);
}
JSC_DEFINE_CUSTOM_GETTER(callbackGetterJSNonFinalObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSNonFinalObject>::callbackGetterImpl(globalObject, thisValue, propertyName);
}
JSC_DEFINE_CUSTOM_GETTER(staticFunctionGetterJSNonFinalObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSNonFinalObject>::staticFunctionGetterImpl(globalObject, thisValue, propertyName);
}
JSC_DEFINE_CUSTOM_GETTER(callbackGetterJSGlobalObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSGlobalObject>::callbackGetterImpl(globalObject, thisValue, propertyName);
}
JSC_DEFINE_CUSTOM_GETTER(staticFunctionGetterJSGlobalObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSGlobalObject>::staticFunctionGetterImpl(globalObject, thisValue, propertyName);
}
} // namespace JSC

84
API/JSCallbackObject.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006-2019 Apple Inc. All rights reserved.
* Copyright (C) 2006-2020 Apple Inc. All rights reserved.
* Copyright (C) 2007 Eric Seidel <eric@webkit.org>
*
* Redistribution and use in source and binary forms, with or without
@ -58,7 +58,7 @@ public:
void setPrivateProperty(VM& vm, JSCell* owner, const Identifier& propertyName, JSValue value)
{
if (!m_privateProperties)
m_privateProperties = std::make_unique<JSPrivatePropertyMap>();
m_privateProperties = makeUnique<JSPrivatePropertyMap>();
m_privateProperties->setPrivateProperty(vm, owner, propertyName, value);
}
@ -123,26 +123,19 @@ public:
template <class Parent>
class JSCallbackObject final : public Parent {
protected:
JSCallbackObject(ExecState*, Structure*, JSClassRef, void* data);
JSCallbackObject(VM&, JSClassRef, Structure*);
void finishCreation(ExecState*);
void finishCreation(VM&);
public:
typedef Parent Base;
static const unsigned StructureFlags = Base::StructureFlags | ProhibitsPropertyCaching | OverridesGetOwnPropertySlot | InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | ImplementsHasInstance | OverridesGetPropertyNames | OverridesGetCallData;
using Base = Parent;
static constexpr unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetOwnSpecialPropertyNames | OverridesGetCallData | InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | ImplementsHasInstance | ProhibitsPropertyCaching | GetOwnPropertySlotMayBeWrongAboutDontEnum;
static_assert(!(StructureFlags & ImplementsDefaultHasInstance), "using customHasInstance");
~JSCallbackObject();
static JSCallbackObject* create(ExecState* exec, JSGlobalObject* globalObject, Structure* structure, JSClassRef classRef, void* data)
static JSCallbackObject* create(JSGlobalObject* globalObject, Structure* structure, JSClassRef classRef, void* data)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
ASSERT_UNUSED(globalObject, !structure->globalObject() || structure->globalObject() == globalObject);
JSCallbackObject* callbackObject = new (NotNull, allocateCell<JSCallbackObject>(vm.heap)) JSCallbackObject(exec, structure, classRef, data);
callbackObject->finishCreation(exec);
JSCallbackObject* callbackObject = new (NotNull, allocateCell<JSCallbackObject>(vm.heap)) JSCallbackObject(globalObject, structure, classRef, data);
callbackObject->finishCreation(globalObject);
return callbackObject;
}
static JSCallbackObject<Parent>* create(VM&, JSClassRef, Structure*);
@ -153,6 +146,12 @@ public:
static_cast<JSCallbackObject*>(cell)->JSCallbackObject::~JSCallbackObject();
}
template<typename CellType, SubspaceAccess mode>
static IsoSubspace* subspaceFor(VM& vm)
{
return subspaceForImpl(vm, mode);
}
void setPrivate(void* data);
void* getPrivate();
@ -183,27 +182,39 @@ public:
using Parent::methodTable;
static EncodedJSValue callImpl(JSGlobalObject*, CallFrame*);
static EncodedJSValue constructImpl(JSGlobalObject*, CallFrame*);
static EncodedJSValue staticFunctionGetterImpl(JSGlobalObject*, EncodedJSValue, PropertyName);
static EncodedJSValue callbackGetterImpl(JSGlobalObject*, EncodedJSValue, PropertyName);
private:
JSCallbackObject(JSGlobalObject*, Structure*, JSClassRef, void* data);
JSCallbackObject(VM&, JSClassRef, Structure*);
void finishCreation(JSGlobalObject*);
void finishCreation(VM&);
static IsoSubspace* subspaceForImpl(VM&, SubspaceAccess);
static String className(const JSObject*, VM&);
static String toStringName(const JSObject*, ExecState*);
static String toStringName(const JSObject*, JSGlobalObject*);
static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
static JSValue defaultValue(const JSObject*, JSGlobalObject*, PreferredPrimitiveType);
static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
static bool getOwnPropertySlotByIndex(JSObject*, ExecState*, unsigned propertyName, PropertySlot&);
static bool getOwnPropertySlot(JSObject*, JSGlobalObject*, PropertyName, PropertySlot&);
static bool getOwnPropertySlotByIndex(JSObject*, JSGlobalObject*, unsigned propertyName, PropertySlot&);
static bool put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
static bool putByIndex(JSCell*, ExecState*, unsigned, JSValue, bool shouldThrow);
static bool put(JSCell*, JSGlobalObject*, PropertyName, JSValue, PutPropertySlot&);
static bool putByIndex(JSCell*, JSGlobalObject*, unsigned, JSValue, bool shouldThrow);
static bool deleteProperty(JSCell*, ExecState*, PropertyName);
static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned);
static bool deleteProperty(JSCell*, JSGlobalObject*, PropertyName, DeletePropertySlot&);
static bool deletePropertyByIndex(JSCell*, JSGlobalObject*, unsigned);
static bool customHasInstance(JSObject*, ExecState*, JSValue);
static bool customHasInstance(JSObject*, JSGlobalObject*, JSValue);
static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
static void getOwnSpecialPropertyNames(JSObject*, JSGlobalObject*, PropertyNameArray&, DontEnumPropertiesMode);
static ConstructType getConstructData(JSCell*, ConstructData&);
static CallType getCallData(JSCell*, CallData&);
static CallData getConstructData(JSCell*);
static CallData getCallData(JSCell*);
static void visitChildren(JSCell* cell, SlotVisitor& visitor)
{
@ -213,17 +224,22 @@ private:
thisObject->m_callbackObjectData->visitChildren(visitor);
}
void init(ExecState*);
void init(JSGlobalObject*);
static JSCallbackObject* asCallbackObject(JSValue);
static JSCallbackObject* asCallbackObject(EncodedJSValue);
using RawNativeFunction = EncodedJSValue(JSC_HOST_CALL_ATTRIBUTES*)(JSGlobalObject*, CallFrame*);
static RawNativeFunction getCallFunction();
static RawNativeFunction getConstructFunction();
using GetValueFunc = EncodedJSValue(JIT_OPERATION_ATTRIBUTES*)(JSGlobalObject*, EncodedJSValue, PropertyName);
static GetValueFunc getStaticFunctionGetter();
static GetValueFunc getCallbackGetter();
static EncodedJSValue JSC_HOST_CALL call(ExecState*);
static EncodedJSValue JSC_HOST_CALL construct(ExecState*);
JSValue getStaticValue(ExecState*, PropertyName);
static EncodedJSValue staticFunctionGetter(ExecState*, EncodedJSValue, PropertyName);
static EncodedJSValue callbackGetter(ExecState*, EncodedJSValue, PropertyName);
JSValue getStaticValue(JSGlobalObject*, PropertyName);
std::unique_ptr<JSCallbackObjectData> m_callbackObjectData;
const ClassInfo* m_classInfo { nullptr };

360
API/JSCallbackObjectFunctions.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006, 2008, 2016 Apple Inc. All rights reserved.
* Copyright (C) 2006-2020 Apple Inc. All rights reserved.
* Copyright (C) 2007 Eric Seidel <eric@webkit.org>
*
* Redistribution and use in source and binary forms, with or without
@ -24,6 +24,8 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "APICast.h"
#include "Error.h"
#include "ExceptionHelpers.h"
@ -43,7 +45,7 @@ namespace JSC {
template <class Parent>
inline JSCallbackObject<Parent>* JSCallbackObject<Parent>::asCallbackObject(JSValue value)
{
ASSERT(asObject(value)->inherits(*value.getObject()->vm(), info()));
ASSERT(asObject(value)->inherits(value.getObject()->vm(), info()));
return jsCast<JSCallbackObject*>(asObject(value));
}
@ -51,14 +53,14 @@ template <class Parent>
inline JSCallbackObject<Parent>* JSCallbackObject<Parent>::asCallbackObject(EncodedJSValue encodedValue)
{
JSValue value = JSValue::decode(encodedValue);
ASSERT(asObject(value)->inherits(*value.getObject()->vm(), info()));
ASSERT(asObject(value)->inherits(value.getObject()->vm(), info()));
return jsCast<JSCallbackObject*>(asObject(value));
}
template <class Parent>
JSCallbackObject<Parent>::JSCallbackObject(ExecState* exec, Structure* structure, JSClassRef jsClass, void* data)
: Parent(exec->vm(), structure)
, m_callbackObjectData(std::make_unique<JSCallbackObjectData>(data, jsClass))
JSCallbackObject<Parent>::JSCallbackObject(JSGlobalObject* globalObject, Structure* structure, JSClassRef jsClass, void* data)
: Parent(getVM(globalObject), structure)
, m_callbackObjectData(makeUnique<JSCallbackObjectData>(data, jsClass))
{
}
@ -67,33 +69,33 @@ JSCallbackObject<Parent>::JSCallbackObject(ExecState* exec, Structure* structure
template <class Parent>
JSCallbackObject<Parent>::JSCallbackObject(VM& vm, JSClassRef jsClass, Structure* structure)
: Parent(vm, structure)
, m_callbackObjectData(std::make_unique<JSCallbackObjectData>(nullptr, jsClass))
, m_callbackObjectData(makeUnique<JSCallbackObjectData>(nullptr, jsClass))
{
}
template <class Parent>
JSCallbackObject<Parent>::~JSCallbackObject()
{
VM* vm = this->HeapCell::vm();
vm->currentlyDestructingCallbackObject = this;
VM& vm = this->HeapCell::vm();
vm.currentlyDestructingCallbackObject = this;
ASSERT(m_classInfo);
vm->currentlyDestructingCallbackObjectClassInfo = m_classInfo;
vm.currentlyDestructingCallbackObjectClassInfo = m_classInfo;
JSObjectRef thisRef = toRef(static_cast<JSObject*>(this));
for (JSClassRef jsClass = classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectFinalizeCallback finalize = jsClass->finalize)
finalize(thisRef);
}
vm->currentlyDestructingCallbackObject = nullptr;
vm->currentlyDestructingCallbackObjectClassInfo = nullptr;
vm.currentlyDestructingCallbackObject = nullptr;
vm.currentlyDestructingCallbackObjectClassInfo = nullptr;
}
template <class Parent>
void JSCallbackObject<Parent>::finishCreation(ExecState* exec)
void JSCallbackObject<Parent>::finishCreation(JSGlobalObject* globalObject)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
Base::finishCreation(vm);
ASSERT(Parent::inherits(vm, info()));
init(exec);
init(globalObject);
}
// This is just for Global object, so we can assume that Base::finishCreation is JSGlobalObject::finishCreation.
@ -103,13 +105,13 @@ void JSCallbackObject<Parent>::finishCreation(VM& vm)
ASSERT(Parent::inherits(vm, info()));
ASSERT(Parent::isGlobalObject());
Base::finishCreation(vm);
init(jsCast<JSGlobalObject*>(this)->globalExec());
init(jsCast<JSGlobalObject*>(this));
}
template <class Parent>
void JSCallbackObject<Parent>::init(ExecState* exec)
void JSCallbackObject<Parent>::init(JSGlobalObject* globalObject)
{
ASSERT(exec);
ASSERT(globalObject);
Vector<JSObjectInitializeCallback, 16> initRoutines;
JSClassRef jsClass = classRef();
@ -120,12 +122,12 @@ void JSCallbackObject<Parent>::init(ExecState* exec)
// initialize from base to derived
for (int i = static_cast<int>(initRoutines.size()) - 1; i >= 0; i--) {
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
JSObjectInitializeCallback initialize = initRoutines[i];
initialize(toRef(exec), toRef(this));
initialize(toRef(globalObject), toRef(jsCast<JSObject*>(this)));
}
m_classInfo = this->classInfo();
m_classInfo = this->classInfo(getVM(globalObject));
}
template <class Parent>
@ -140,164 +142,170 @@ String JSCallbackObject<Parent>::className(const JSObject* object, VM& vm)
}
template <class Parent>
String JSCallbackObject<Parent>::toStringName(const JSObject* object, ExecState* exec)
String JSCallbackObject<Parent>::toStringName(const JSObject* object, JSGlobalObject* globalObject)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
const ClassInfo* info = object->classInfo(vm);
ASSERT(info);
return info->methodTable.className(object, vm);
}
template <class Parent>
bool JSCallbackObject<Parent>::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
bool JSCallbackObject<Parent>::getOwnPropertySlot(JSObject* object, JSGlobalObject* globalObject, PropertyName propertyName, PropertySlot& slot)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(object);
JSContextRef ctx = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef ctx = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObject));
RefPtr<OpaqueJSString> propertyNameRef;
if (StringImpl* name = propertyName.uid()) {
unsigned attributes = PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum;
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
// optional optimization to bypass getProperty in cases when we only need to know if the property exists
if (JSObjectHasPropertyCallback hasProperty = jsClass->hasProperty) {
if (!propertyNameRef)
propertyNameRef = OpaqueJSString::tryCreate(name);
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
if (hasProperty(ctx, thisRef, propertyNameRef.get())) {
slot.setCustom(thisObject, PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum, callbackGetter);
slot.setCustom(thisObject, attributes, getCallbackGetter());
return true;
}
} else if (JSObjectGetPropertyCallback getProperty = jsClass->getProperty) {
if (!propertyNameRef)
propertyNameRef = OpaqueJSString::tryCreate(name);
JSValueRef exception = 0;
JSValueRef exception = nullptr;
JSValueRef value;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
value = getProperty(ctx, thisRef, propertyNameRef.get(), &exception);
}
if (exception) {
throwException(exec, scope, toJS(exec, exception));
slot.setValue(thisObject, PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum, jsUndefined());
throwException(globalObject, scope, toJS(globalObject, exception));
slot.setValue(thisObject, attributes, jsUndefined());
return true;
}
if (value) {
slot.setValue(thisObject, PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum, toJS(exec, value));
slot.setValue(thisObject, attributes, toJS(globalObject, value));
return true;
}
}
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {
if (staticValues->contains(name)) {
JSValue value = thisObject->getStaticValue(exec, propertyName);
JSValue value = thisObject->getStaticValue(globalObject, propertyName);
RETURN_IF_EXCEPTION(scope, false);
if (value) {
slot.setValue(thisObject, PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum, value);
slot.setValue(thisObject, attributes, value);
return true;
}
}
}
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(exec)) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {
if (staticFunctions->contains(name)) {
slot.setCustom(thisObject, PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum, staticFunctionGetter);
slot.setCustom(thisObject, attributes, getStaticFunctionGetter());
return true;
}
}
}
}
return Parent::getOwnPropertySlot(thisObject, exec, propertyName, slot);
RELEASE_AND_RETURN(scope, Parent::getOwnPropertySlot(thisObject, globalObject, propertyName, slot));
}
template <class Parent>
bool JSCallbackObject<Parent>::getOwnPropertySlotByIndex(JSObject* object, ExecState* exec, unsigned propertyName, PropertySlot& slot)
bool JSCallbackObject<Parent>::getOwnPropertySlotByIndex(JSObject* object, JSGlobalObject* globalObject, unsigned propertyName, PropertySlot& slot)
{
return object->methodTable(exec->vm())->getOwnPropertySlot(object, exec, Identifier::from(exec, propertyName), slot);
VM& vm = getVM(globalObject);
return object->methodTable(vm)->getOwnPropertySlot(object, globalObject, Identifier::from(vm, propertyName), slot);
}
template <class Parent>
JSValue JSCallbackObject<Parent>::defaultValue(const JSObject* object, ExecState* exec, PreferredPrimitiveType hint)
JSValue JSCallbackObject<Parent>::defaultValue(const JSObject* object, JSGlobalObject* globalObject, PreferredPrimitiveType hint)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
const JSCallbackObject* thisObject = jsCast<const JSCallbackObject*>(object);
JSContextRef ctx = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef ctx = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<const JSObject*>(thisObject));
::JSType jsHint = hint == PreferString ? kJSTypeString : kJSTypeNumber;
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectConvertToTypeCallback convertToType = jsClass->convertToType) {
JSValueRef exception = 0;
JSValueRef exception = nullptr;
JSValueRef result = convertToType(ctx, thisRef, jsHint, &exception);
if (exception) {
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
return jsUndefined();
}
if (result)
return toJS(exec, result);
return toJS(globalObject, result);
}
}
return Parent::defaultValue(object, exec, hint);
RELEASE_AND_RETURN(scope, Parent::defaultValue(object, globalObject, hint));
}
template <class Parent>
bool JSCallbackObject<Parent>::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
bool JSCallbackObject<Parent>::put(JSCell* cell, JSGlobalObject* globalObject, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
JSContextRef ctx = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef ctx = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObject));
RefPtr<OpaqueJSString> propertyNameRef;
JSValueRef valueRef = toRef(exec, value);
JSValueRef valueRef = toRef(globalObject, value);
if (StringImpl* name = propertyName.uid()) {
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectSetPropertyCallback setProperty = jsClass->setProperty) {
if (!propertyNameRef)
propertyNameRef = OpaqueJSString::tryCreate(name);
JSValueRef exception = 0;
JSValueRef exception = nullptr;
bool result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = setProperty(ctx, thisRef, propertyNameRef.get(), valueRef, &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
if (result || exception)
return result;
}
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {
if (StaticValueEntry* entry = staticValues->get(name)) {
if (entry->attributes & kJSPropertyAttributeReadOnly)
return false;
if (JSObjectSetPropertyCallback setProperty = entry->setProperty) {
JSValueRef exception = 0;
JSValueRef exception = nullptr;
bool result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = setProperty(ctx, thisRef, entry->propertyNameRef.get(), valueRef, &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
if (result || exception)
return result;
}
}
}
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(exec)) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {
if (StaticFunctionEntry* entry = staticFunctions->get(name)) {
PropertySlot getSlot(thisObject, PropertySlot::InternalMethodType::VMInquiry);
if (Parent::getOwnPropertySlot(thisObject, exec, propertyName, getSlot))
return Parent::put(thisObject, exec, propertyName, value, slot);
PropertySlot getSlot(thisObject, PropertySlot::InternalMethodType::VMInquiry, &vm);
bool found = Parent::getOwnPropertySlot(thisObject, globalObject, propertyName, getSlot);
RETURN_IF_EXCEPTION(scope, false);
getSlot.disallowVMEntry.reset();
if (found)
RELEASE_AND_RETURN(scope, Parent::put(thisObject, globalObject, propertyName, value, slot));
if (entry->attributes & kJSPropertyAttributeReadOnly)
return false;
return thisObject->JSCallbackObject<Parent>::putDirect(vm, propertyName, value); // put as override property
@ -306,58 +314,58 @@ bool JSCallbackObject<Parent>::put(JSCell* cell, ExecState* exec, PropertyName p
}
}
return Parent::put(thisObject, exec, propertyName, value, slot);
RELEASE_AND_RETURN(scope, Parent::put(thisObject, globalObject, propertyName, value, slot));
}
template <class Parent>
bool JSCallbackObject<Parent>::putByIndex(JSCell* cell, ExecState* exec, unsigned propertyIndex, JSValue value, bool shouldThrow)
bool JSCallbackObject<Parent>::putByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned propertyIndex, JSValue value, bool shouldThrow)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
JSContextRef ctx = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef ctx = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObject));
RefPtr<OpaqueJSString> propertyNameRef;
JSValueRef valueRef = toRef(exec, value);
Identifier propertyName = Identifier::from(exec, propertyIndex);
JSValueRef valueRef = toRef(globalObject, value);
Identifier propertyName = Identifier::from(vm, propertyIndex);
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectSetPropertyCallback setProperty = jsClass->setProperty) {
if (!propertyNameRef)
propertyNameRef = OpaqueJSString::tryCreate(propertyName.impl());
JSValueRef exception = 0;
JSValueRef exception = nullptr;
bool result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = setProperty(ctx, thisRef, propertyNameRef.get(), valueRef, &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
if (result || exception)
return result;
}
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {
if (StaticValueEntry* entry = staticValues->get(propertyName.impl())) {
if (entry->attributes & kJSPropertyAttributeReadOnly)
return false;
if (JSObjectSetPropertyCallback setProperty = entry->setProperty) {
JSValueRef exception = 0;
JSValueRef exception = nullptr;
bool result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = setProperty(ctx, thisRef, entry->propertyNameRef.get(), valueRef, &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
if (result || exception)
return result;
}
}
}
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(exec)) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {
if (StaticFunctionEntry* entry = staticFunctions->get(propertyName.impl())) {
if (entry->attributes & kJSPropertyAttributeReadOnly)
return false;
@ -366,18 +374,18 @@ bool JSCallbackObject<Parent>::putByIndex(JSCell* cell, ExecState* exec, unsigne
}
}
return Parent::putByIndex(thisObject, exec, propertyIndex, value, shouldThrow);
RELEASE_AND_RETURN(scope, Parent::putByIndex(thisObject, globalObject, propertyIndex, value, shouldThrow));
}
template <class Parent>
bool JSCallbackObject<Parent>::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName)
bool JSCallbackObject<Parent>::deleteProperty(JSCell* cell, JSGlobalObject* globalObject, PropertyName propertyName, DeletePropertySlot& slot)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
JSContextRef ctx = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef ctx = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObject));
RefPtr<OpaqueJSString> propertyNameRef;
if (StringImpl* name = propertyName.uid()) {
@ -385,19 +393,19 @@ bool JSCallbackObject<Parent>::deleteProperty(JSCell* cell, ExecState* exec, Pro
if (JSObjectDeletePropertyCallback deleteProperty = jsClass->deleteProperty) {
if (!propertyNameRef)
propertyNameRef = OpaqueJSString::tryCreate(name);
JSValueRef exception = 0;
JSValueRef exception = nullptr;
bool result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = deleteProperty(ctx, thisRef, propertyNameRef.get(), &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
if (result || exception)
return true;
}
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {
if (StaticValueEntry* entry = staticValues->get(name)) {
if (entry->attributes & kJSPropertyAttributeDontDelete)
return false;
@ -405,7 +413,7 @@ bool JSCallbackObject<Parent>::deleteProperty(JSCell* cell, ExecState* exec, Pro
}
}
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(exec)) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {
if (StaticFunctionEntry* entry = staticFunctions->get(name)) {
if (entry->attributes & kJSPropertyAttributeDontDelete)
return false;
@ -415,54 +423,62 @@ bool JSCallbackObject<Parent>::deleteProperty(JSCell* cell, ExecState* exec, Pro
}
}
return Parent::deleteProperty(thisObject, exec, propertyName);
static_assert(std::is_final_v<JSCallbackObject<Parent>>, "Ensure no derived classes have custom deletePropertyByIndex implementation");
if (Optional<uint32_t> index = parseIndex(propertyName))
RELEASE_AND_RETURN(scope, Parent::deletePropertyByIndex(thisObject, globalObject, index.value()));
RELEASE_AND_RETURN(scope, Parent::deleteProperty(thisObject, globalObject, propertyName, slot));
}
template <class Parent>
bool JSCallbackObject<Parent>::deletePropertyByIndex(JSCell* cell, ExecState* exec, unsigned propertyName)
bool JSCallbackObject<Parent>::deletePropertyByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned propertyName)
{
VM& vm = getVM(globalObject);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
return thisObject->methodTable(exec->vm())->deleteProperty(thisObject, exec, Identifier::from(exec, propertyName));
return JSCell::deleteProperty(thisObject, globalObject, Identifier::from(vm, propertyName));
}
template <class Parent>
ConstructType JSCallbackObject<Parent>::getConstructData(JSCell* cell, ConstructData& constructData)
CallData JSCallbackObject<Parent>::getConstructData(JSCell* cell)
{
CallData constructData;
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (jsClass->callAsConstructor) {
constructData.native.function = construct;
return ConstructType::Host;
constructData.type = CallData::Type::Native;
constructData.native.function = getConstructFunction();
break;
}
}
return ConstructType::None;
return constructData;
}
template <class Parent>
EncodedJSValue JSCallbackObject<Parent>::construct(ExecState* exec)
EncodedJSValue JSCallbackObject<Parent>::constructImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSObject* constructor = exec->jsCallee();
JSContextRef execRef = toRef(exec);
JSObject* constructor = callFrame->jsCallee();
JSContextRef execRef = toRef(globalObject);
JSObjectRef constructorRef = toRef(constructor);
for (JSClassRef jsClass = jsCast<JSCallbackObject<Parent>*>(constructor)->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectCallAsConstructorCallback callAsConstructor = jsClass->callAsConstructor) {
size_t argumentCount = exec->argumentCount();
size_t argumentCount = callFrame->argumentCount();
Vector<JSValueRef, 16> arguments;
arguments.reserveInitialCapacity(argumentCount);
for (size_t i = 0; i < argumentCount; ++i)
arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
JSValueRef exception = 0;
arguments.uncheckedAppend(toRef(globalObject, callFrame->uncheckedArgument(i)));
JSValueRef exception = nullptr;
JSObject* result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = toJS(callAsConstructor(execRef, constructorRef, argumentCount, arguments.data(), &exception));
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
if (exception) {
throwException(globalObject, scope, toJS(globalObject, exception));
return JSValue::encode(jsUndefined());
}
return JSValue::encode(result);
}
}
@ -472,26 +488,26 @@ EncodedJSValue JSCallbackObject<Parent>::construct(ExecState* exec)
}
template <class Parent>
bool JSCallbackObject<Parent>::customHasInstance(JSObject* object, ExecState* exec, JSValue value)
bool JSCallbackObject<Parent>::customHasInstance(JSObject* object, JSGlobalObject* globalObject, JSValue value)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(object);
JSContextRef execRef = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef execRef = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObject));
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectHasInstanceCallback hasInstance = jsClass->hasInstance) {
JSValueRef valueRef = toRef(exec, value);
JSValueRef exception = 0;
JSValueRef valueRef = toRef(globalObject, value);
JSValueRef exception = nullptr;
bool result;
{
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
result = hasInstance(execRef, thisRef, valueRef, &exception);
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
return result;
}
}
@ -499,43 +515,47 @@ bool JSCallbackObject<Parent>::customHasInstance(JSObject* object, ExecState* ex
}
template <class Parent>
CallType JSCallbackObject<Parent>::getCallData(JSCell* cell, CallData& callData)
CallData JSCallbackObject<Parent>::getCallData(JSCell* cell)
{
CallData callData;
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(cell);
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (jsClass->callAsFunction) {
callData.native.function = call;
return CallType::Host;
callData.type = CallData::Type::Native;
callData.native.function = getCallFunction();
break;
}
}
return CallType::None;
return callData;
}
template <class Parent>
EncodedJSValue JSCallbackObject<Parent>::call(ExecState* exec)
EncodedJSValue JSCallbackObject<Parent>::callImpl(JSGlobalObject* globalObject, CallFrame* callFrame)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSContextRef execRef = toRef(exec);
JSObjectRef functionRef = toRef(exec->jsCallee());
JSObjectRef thisObjRef = toRef(jsCast<JSObject*>(exec->thisValue().toThis(exec, NotStrictMode)));
JSContextRef execRef = toRef(globalObject);
JSObjectRef functionRef = toRef(callFrame->jsCallee());
JSObjectRef thisObjRef = toRef(jsCast<JSObject*>(callFrame->thisValue().toThis(globalObject, ECMAMode::sloppy())));
for (JSClassRef jsClass = jsCast<JSCallbackObject<Parent>*>(toJS(functionRef))->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectCallAsFunctionCallback callAsFunction = jsClass->callAsFunction) {
size_t argumentCount = exec->argumentCount();
size_t argumentCount = callFrame->argumentCount();
Vector<JSValueRef, 16> arguments;
arguments.reserveInitialCapacity(argumentCount);
for (size_t i = 0; i < argumentCount; ++i)
arguments.uncheckedAppend(toRef(exec, exec->uncheckedArgument(i)));
JSValueRef exception = 0;
arguments.uncheckedAppend(toRef(globalObject, callFrame->uncheckedArgument(i)));
JSValueRef exception = nullptr;
JSValue result;
{
JSLock::DropAllLocks dropAllLocks(exec);
result = toJS(exec, callAsFunction(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception));
JSLock::DropAllLocks dropAllLocks(globalObject);
result = toJS(globalObject, callAsFunction(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), &exception));
}
if (exception) {
throwException(globalObject, scope, toJS(globalObject, exception));
return JSValue::encode(jsUndefined());
}
if (exception)
throwException(exec, scope, toJS(exec, exception));
return JSValue::encode(result);
}
}
@ -545,46 +565,45 @@ EncodedJSValue JSCallbackObject<Parent>::call(ExecState* exec)
}
template <class Parent>
void JSCallbackObject<Parent>::getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
void JSCallbackObject<Parent>::getOwnSpecialPropertyNames(JSObject* object, JSGlobalObject* globalObject, PropertyNameArray& propertyNames, DontEnumPropertiesMode mode)
{
VM& vm = getVM(globalObject);
JSCallbackObject* thisObject = jsCast<JSCallbackObject*>(object);
JSContextRef execRef = toRef(exec);
JSObjectRef thisRef = toRef(thisObject);
JSContextRef execRef = toRef(globalObject);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObject));
for (JSClassRef jsClass = thisObject->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (JSObjectGetPropertyNamesCallback getPropertyNames = jsClass->getPropertyNames) {
JSLock::DropAllLocks dropAllLocks(exec);
JSLock::DropAllLocks dropAllLocks(globalObject);
getPropertyNames(execRef, thisRef, toRef(&propertyNames));
}
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {
typedef OpaqueJSClassStaticValuesTable::const_iterator iterator;
iterator end = staticValues->end();
for (iterator it = staticValues->begin(); it != end; ++it) {
StringImpl* name = it->key.get();
StaticValueEntry* entry = it->value.get();
if (entry->getProperty && (!(entry->attributes & kJSPropertyAttributeDontEnum) || mode.includeDontEnumProperties())) {
if (entry->getProperty && (mode == DontEnumPropertiesMode::Include || !(entry->attributes & kJSPropertyAttributeDontEnum))) {
ASSERT(!name->isSymbol());
propertyNames.add(Identifier::fromString(exec, String(name)));
propertyNames.add(Identifier::fromString(vm, String(name)));
}
}
}
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(exec)) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {
typedef OpaqueJSClassStaticFunctionsTable::const_iterator iterator;
iterator end = staticFunctions->end();
for (iterator it = staticFunctions->begin(); it != end; ++it) {
StringImpl* name = it->key.get();
StaticFunctionEntry* entry = it->value.get();
if (!(entry->attributes & kJSPropertyAttributeDontEnum) || mode.includeDontEnumProperties()) {
if (mode == DontEnumPropertiesMode::Include || !(entry->attributes & kJSPropertyAttributeDontEnum)) {
ASSERT(!name->isSymbol());
propertyNames.add(Identifier::fromString(exec, String(name)));
propertyNames.add(Identifier::fromString(vm, String(name)));
}
}
}
}
Parent::getOwnNonIndexPropertyNames(thisObject, exec, propertyNames, mode);
}
template <class Parent>
@ -610,30 +629,30 @@ bool JSCallbackObject<Parent>::inherits(JSClassRef c) const
}
template <class Parent>
JSValue JSCallbackObject<Parent>::getStaticValue(ExecState* exec, PropertyName propertyName)
JSValue JSCallbackObject<Parent>::getStaticValue(JSGlobalObject* globalObject, PropertyName propertyName)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSObjectRef thisRef = toRef(this);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(this));
if (StringImpl* name = propertyName.uid()) {
for (JSClassRef jsClass = classRef(); jsClass; jsClass = jsClass->parentClass) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(globalObject)) {
if (StaticValueEntry* entry = staticValues->get(name)) {
if (JSObjectGetPropertyCallback getProperty = entry->getProperty) {
JSValueRef exception = 0;
JSValueRef exception = nullptr;
JSValueRef value;
{
JSLock::DropAllLocks dropAllLocks(exec);
value = getProperty(toRef(exec), thisRef, entry->propertyNameRef.get(), &exception);
JSLock::DropAllLocks dropAllLocks(globalObject);
value = getProperty(toRef(globalObject), thisRef, entry->propertyNameRef.get(), &exception);
}
if (exception) {
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
return jsUndefined();
}
if (value)
return toJS(exec, value);
return toJS(globalObject, value);
}
}
}
@ -644,21 +663,24 @@ JSValue JSCallbackObject<Parent>::getStaticValue(ExecState* exec, PropertyName p
}
template <class Parent>
EncodedJSValue JSCallbackObject<Parent>::staticFunctionGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName propertyName)
EncodedJSValue JSCallbackObject<Parent>::staticFunctionGetterImpl(JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObj = asCallbackObject(thisValue);
// Check for cached or override property.
PropertySlot slot2(thisObj, PropertySlot::InternalMethodType::VMInquiry);
if (Parent::getOwnPropertySlot(thisObj, exec, propertyName, slot2))
return JSValue::encode(slot2.getValue(exec, propertyName));
PropertySlot slot2(thisObj, PropertySlot::InternalMethodType::VMInquiry, &vm);
bool found = Parent::getOwnPropertySlot(thisObj, globalObject, propertyName, slot2);
RETURN_IF_EXCEPTION(scope, { });
slot2.disallowVMEntry.reset();
if (found)
return JSValue::encode(slot2.getValue(globalObject, propertyName));
if (StringImpl* name = propertyName.uid()) {
for (JSClassRef jsClass = thisObj->classRef(); jsClass; jsClass = jsClass->parentClass) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(exec)) {
if (OpaqueJSClassStaticFunctionsTable* staticFunctions = jsClass->staticFunctions(globalObject)) {
if (StaticFunctionEntry* entry = staticFunctions->get(name)) {
if (JSObjectCallAsFunctionCallback callAsFunction = entry->callAsFunction) {
JSObject* o = JSCallbackFunction::create(vm, thisObj->globalObject(vm), callAsFunction, name);
@ -670,18 +692,18 @@ EncodedJSValue JSCallbackObject<Parent>::staticFunctionGetter(ExecState* exec, E
}
}
return JSValue::encode(throwException(exec, scope, createReferenceError(exec, "Static function property defined with NULL callAsFunction callback."_s)));
return JSValue::encode(throwException(globalObject, scope, createReferenceError(globalObject, "Static function property defined with NULL callAsFunction callback."_s)));
}
template <class Parent>
EncodedJSValue JSCallbackObject<Parent>::callbackGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName propertyName)
EncodedJSValue JSCallbackObject<Parent>::callbackGetterImpl(JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName)
{
VM& vm = exec->vm();
VM& vm = getVM(globalObject);
auto scope = DECLARE_THROW_SCOPE(vm);
JSCallbackObject* thisObj = asCallbackObject(thisValue);
JSObjectRef thisRef = toRef(thisObj);
JSObjectRef thisRef = toRef(jsCast<JSObject*>(thisObj));
RefPtr<OpaqueJSString> propertyNameRef;
if (StringImpl* name = propertyName.uid()) {
@ -689,23 +711,23 @@ EncodedJSValue JSCallbackObject<Parent>::callbackGetter(ExecState* exec, Encoded
if (JSObjectGetPropertyCallback getProperty = jsClass->getProperty) {
if (!propertyNameRef)
propertyNameRef = OpaqueJSString::tryCreate(name);
JSValueRef exception = 0;
JSValueRef exception = nullptr;
JSValueRef value;
{
JSLock::DropAllLocks dropAllLocks(exec);
value = getProperty(toRef(exec), thisRef, propertyNameRef.get(), &exception);
JSLock::DropAllLocks dropAllLocks(globalObject);
value = getProperty(toRef(globalObject), thisRef, propertyNameRef.get(), &exception);
}
if (exception) {
throwException(exec, scope, toJS(exec, exception));
throwException(globalObject, scope, toJS(globalObject, exception));
return JSValue::encode(jsUndefined());
}
if (value)
return JSValue::encode(toJS(exec, value));
return JSValue::encode(toJS(globalObject, value));
}
}
}
return JSValue::encode(throwException(exec, scope, createReferenceError(exec, "hasProperty callback returned true for a property that doesn't exist."_s)));
return JSValue::encode(throwException(globalObject, scope, createReferenceError(globalObject, "hasProperty callback returned true for a property that doesn't exist."_s)));
}
} // namespace JSC

61
API/JSClassRef.cpp
View File

@ -27,22 +27,17 @@
#include "JSClassRef.h"
#include "APICast.h"
#include "Identifier.h"
#include "InitializeThreading.h"
#include "JSCallbackObject.h"
#include "JSGlobalObject.h"
#include "JSObjectRef.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"
#include <wtf/text/StringHash.h>
#include "JSCallbackObject.h"
using namespace JSC;
const JSClassDefinition kJSClassDefinitionEmpty = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const JSClassDefinition kJSClassDefinitionEmpty = { 0, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
OpaqueJSClass::OpaqueJSClass(const JSClassDefinition* definition, OpaqueJSClass* protoClass)
: parentClass(definition->parentClass)
, prototypeClass(0)
, prototypeClass(nullptr)
, initialize(definition->initialize)
, finalize(definition->finalize)
, hasProperty(definition->hasProperty)
@ -56,24 +51,24 @@ OpaqueJSClass::OpaqueJSClass(const JSClassDefinition* definition, OpaqueJSClass*
, convertToType(definition->convertToType)
, m_className(String::fromUTF8(definition->className))
{
initializeThreading();
JSC::initialize();
if (const JSStaticValue* staticValue = definition->staticValues) {
m_staticValues = std::make_unique<OpaqueJSClassStaticValuesTable>();
m_staticValues = makeUnique<OpaqueJSClassStaticValuesTable>();
while (staticValue->name) {
String valueName = String::fromUTF8(staticValue->name);
if (!valueName.isNull())
m_staticValues->set(valueName.impl(), std::make_unique<StaticValueEntry>(staticValue->getProperty, staticValue->setProperty, staticValue->attributes, valueName));
m_staticValues->set(valueName.impl(), makeUnique<StaticValueEntry>(staticValue->getProperty, staticValue->setProperty, staticValue->attributes, valueName));
++staticValue;
}
}
if (const JSStaticFunction* staticFunction = definition->staticFunctions) {
m_staticFunctions = std::make_unique<OpaqueJSClassStaticFunctionsTable>();
m_staticFunctions = makeUnique<OpaqueJSClassStaticFunctionsTable>();
while (staticFunction->name) {
String functionName = String::fromUTF8(staticFunction->name);
if (!functionName.isNull())
m_staticFunctions->set(functionName.impl(), std::make_unique<StaticFunctionEntry>(staticFunction->callAsFunction, staticFunction->attributes));
m_staticFunctions->set(functionName.impl(), makeUnique<StaticFunctionEntry>(staticFunction->callAsFunction, staticFunction->attributes));
++staticFunction;
}
}
@ -107,7 +102,7 @@ OpaqueJSClass::~OpaqueJSClass()
Ref<OpaqueJSClass> OpaqueJSClass::createNoAutomaticPrototype(const JSClassDefinition* definition)
{
return adoptRef(*new OpaqueJSClass(definition, 0));
return adoptRef(*new OpaqueJSClass(definition, nullptr));
}
Ref<OpaqueJSClass> OpaqueJSClass::create(const JSClassDefinition* clientDefinition)
@ -115,12 +110,12 @@ Ref<OpaqueJSClass> OpaqueJSClass::create(const JSClassDefinition* clientDefiniti
JSClassDefinition definition = *clientDefinition; // Avoid modifying client copy.
JSClassDefinition protoDefinition = kJSClassDefinitionEmpty;
protoDefinition.finalize = 0;
protoDefinition.finalize = nullptr;
std::swap(definition.staticFunctions, protoDefinition.staticFunctions); // Move static functions to the prototype.
// We are supposed to use JSClassRetain/Release but since we know that we currently have
// the only reference to this class object we cheat and use a RefPtr instead.
RefPtr<OpaqueJSClass> protoClass = adoptRef(new OpaqueJSClass(&protoDefinition, 0));
RefPtr<OpaqueJSClass> protoClass = adoptRef(new OpaqueJSClass(&protoDefinition, nullptr));
return adoptRef(*new OpaqueJSClass(&definition, protoClass.get()));
}
@ -128,30 +123,30 @@ OpaqueJSClassContextData::OpaqueJSClassContextData(JSC::VM&, OpaqueJSClass* jsCl
: m_class(jsClass)
{
if (jsClass->m_staticValues) {
staticValues = std::make_unique<OpaqueJSClassStaticValuesTable>();
staticValues = makeUnique<OpaqueJSClassStaticValuesTable>();
OpaqueJSClassStaticValuesTable::const_iterator end = jsClass->m_staticValues->end();
for (OpaqueJSClassStaticValuesTable::const_iterator it = jsClass->m_staticValues->begin(); it != end; ++it) {
ASSERT(!it->key->isAtom());
String valueName = it->key->isolatedCopy();
staticValues->add(valueName.impl(), std::make_unique<StaticValueEntry>(it->value->getProperty, it->value->setProperty, it->value->attributes, valueName));
staticValues->add(valueName.impl(), makeUnique<StaticValueEntry>(it->value->getProperty, it->value->setProperty, it->value->attributes, valueName));
}
}
if (jsClass->m_staticFunctions) {
staticFunctions = std::make_unique<OpaqueJSClassStaticFunctionsTable>();
staticFunctions = makeUnique<OpaqueJSClassStaticFunctionsTable>();
OpaqueJSClassStaticFunctionsTable::const_iterator end = jsClass->m_staticFunctions->end();
for (OpaqueJSClassStaticFunctionsTable::const_iterator it = jsClass->m_staticFunctions->begin(); it != end; ++it) {
ASSERT(!it->key->isAtom());
staticFunctions->add(it->key->isolatedCopy(), std::make_unique<StaticFunctionEntry>(it->value->callAsFunction, it->value->attributes));
staticFunctions->add(it->key->isolatedCopy(), makeUnique<StaticFunctionEntry>(it->value->callAsFunction, it->value->attributes));
}
}
}
OpaqueJSClassContextData& OpaqueJSClass::contextData(ExecState* exec)
OpaqueJSClassContextData& OpaqueJSClass::contextData(JSGlobalObject* globalObject)
{
std::unique_ptr<OpaqueJSClassContextData>& contextData = exec->lexicalGlobalObject()->opaqueJSClassData().add(this, nullptr).iterator->value;
std::unique_ptr<OpaqueJSClassContextData>& contextData = globalObject->opaqueJSClassData().add(this, nullptr).iterator->value;
if (!contextData)
contextData = std::make_unique<OpaqueJSClassContextData>(exec->vm(), this);
contextData = makeUnique<OpaqueJSClassContextData>(globalObject->vm(), this);
return *contextData;
}
@ -161,17 +156,17 @@ String OpaqueJSClass::className()
return m_className.isolatedCopy();
}
OpaqueJSClassStaticValuesTable* OpaqueJSClass::staticValues(JSC::ExecState* exec)
OpaqueJSClassStaticValuesTable* OpaqueJSClass::staticValues(JSC::JSGlobalObject* globalObject)
{
return contextData(exec).staticValues.get();
return contextData(globalObject).staticValues.get();
}
OpaqueJSClassStaticFunctionsTable* OpaqueJSClass::staticFunctions(JSC::ExecState* exec)
OpaqueJSClassStaticFunctionsTable* OpaqueJSClass::staticFunctions(JSC::JSGlobalObject* globalObject)
{
return contextData(exec).staticFunctions.get();
return contextData(globalObject).staticFunctions.get();
}
JSObject* OpaqueJSClass::prototype(ExecState* exec)
JSObject* OpaqueJSClass::prototype(JSGlobalObject* globalObject)
{
/* Class (C++) and prototype (JS) inheritance are parallel, so:
* (C++) | (JS)
@ -182,18 +177,18 @@ JSObject* OpaqueJSClass::prototype(ExecState* exec)
*/
if (!prototypeClass)
return 0;
return nullptr;
OpaqueJSClassContextData& jsClassData = contextData(exec);
OpaqueJSClassContextData& jsClassData = contextData(globalObject);
if (JSObject* prototype = jsClassData.cachedPrototype.get())
return prototype;
// Recursive, but should be good enough for our purposes
JSObject* prototype = JSCallbackObject<JSDestructibleObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->callbackObjectStructure(), prototypeClass, &jsClassData); // set jsClassData as the object's private data, so it can clear our reference on destruction
JSObject* prototype = JSCallbackObject<JSNonFinalObject>::create(globalObject, globalObject->callbackObjectStructure(), prototypeClass, &jsClassData); // set jsClassData as the object's private data, so it can clear our reference on destruction
if (parentClass) {
if (JSObject* parentPrototype = parentClass->prototype(exec))
prototype->setPrototypeDirect(exec->vm(), parentPrototype);
if (JSObject* parentPrototype = parentClass->prototype(globalObject))
prototype->setPrototypeDirect(globalObject->vm(), parentPrototype);
}
jsClassData.cachedPrototype = Weak<JSObject>(prototype);

8
API/JSClassRef.h
View File

@ -93,9 +93,9 @@ struct OpaqueJSClass : public ThreadSafeRefCounted<OpaqueJSClass> {
JS_EXPORT_PRIVATE ~OpaqueJSClass();
String className();
OpaqueJSClassStaticValuesTable* staticValues(JSC::ExecState*);
OpaqueJSClassStaticFunctionsTable* staticFunctions(JSC::ExecState*);
JSC::JSObject* prototype(JSC::ExecState*);
OpaqueJSClassStaticValuesTable* staticValues(JSC::JSGlobalObject*);
OpaqueJSClassStaticFunctionsTable* staticFunctions(JSC::JSGlobalObject*);
JSC::JSObject* prototype(JSC::JSGlobalObject*);
OpaqueJSClass* parentClass;
OpaqueJSClass* prototypeClass;
@ -119,7 +119,7 @@ private:
OpaqueJSClass(const OpaqueJSClass&);
OpaqueJSClass(const JSClassDefinition*, OpaqueJSClass* protoClass);
OpaqueJSClassContextData& contextData(JSC::ExecState*);
OpaqueJSClassContextData& contextData(JSC::JSGlobalObject*);
// Strings in these data members should not be put into any AtomStringTable.
String m_className;

9
API/JSContext.h
View File

@ -23,11 +23,8 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef JSContext_h
#define JSContext_h
#include <JavaScriptCore/JavaScript.h>
#include <JavaScriptCore/WebKitAvailability.h>
#import <JavaScriptCore/JavaScript.h>
#import <JavaScriptCore/WebKitAvailability.h>
#if JSC_OBJC_API_ENABLED
@ -234,5 +231,3 @@ JSC_CLASS_AVAILABLE(macos(10.9), ios(7.0))
@end
#endif
#endif // JSContext_h

61
API/JSContext.mm
View File

@ -23,7 +23,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#import "config.h"
#import "APICast.h"
#import "Completion.h"
@ -39,16 +39,8 @@
#import "JSVirtualMachineInternal.h"
#import "JSWrapperMap.h"
#import "JavaScriptCore.h"
#ifdef DARLING
#import "ObjCRuntimeExtras.h"
#else
#import "ObjcRuntimeExtras.h"
#endif
#import "StrongInlines.h"
#ifdef DARLING_NONUNIFIED_BUILD
#include "JSScriptInternal.h"
#include "JSAPIGlobalObject.h"
#endif
#import <wtf/WeakObjCPtr.h>
@ -68,7 +60,7 @@
- (void)ensureWrapperMap
{
if (!toJS([self JSGlobalContextRef])->lexicalGlobalObject()->wrapperMap()) {
if (!toJS([self JSGlobalContextRef])->wrapperMap()) {
// The map will be retained by the GlobalObject in initialization.
[[[JSWrapperMap alloc] initWithGlobalContextRef:[self JSGlobalContextRef]] release];
}
@ -126,29 +118,31 @@
- (JSValue *)evaluateJSScript:(JSScript *)script
{
JSC::ExecState* exec = toJS(m_context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(m_context);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
if (script.type == kJSScriptTypeProgram) {
JSValueRef exceptionValue = nullptr;
JSC::SourceCode sourceCode = [script sourceCode];
JSValueRef result = JSEvaluateScriptInternal(locker, exec, m_context, nullptr, sourceCode, &exceptionValue);
JSValueRef result = JSEvaluateScriptInternal(locker, m_context, nullptr, sourceCode, &exceptionValue);
if (exceptionValue)
return [self valueFromNotifyException:exceptionValue];
return [JSValue valueWithJSValueRef:result inContext:self];
}
auto* globalObject = JSC::jsDynamicCast<JSC::JSAPIGlobalObject*>(vm, exec->lexicalGlobalObject());
if (!globalObject)
auto* apiGlobalObject = JSC::jsDynamicCast<JSC::JSAPIGlobalObject*>(vm, globalObject);
if (!apiGlobalObject)
return [JSValue valueWithNewPromiseRejectedWithReason:[JSValue valueWithNewErrorFromMessage:@"Context does not support module loading" inContext:self] inContext:self];
auto scope = DECLARE_CATCH_SCOPE(vm);
JSC::JSValue result = globalObject->loadAndEvaluateJSScriptModule(locker, script);
JSC::JSValue result = apiGlobalObject->loadAndEvaluateJSScriptModule(locker, script);
if (scope.exception()) {
JSValueRef exceptionValue = toRef(exec, scope.exception()->value());
JSValueRef exceptionValue = toRef(apiGlobalObject, scope.exception()->value());
scope.clearException();
// FIXME: We should not clearException if it is TerminatedExecutionError.
// https://bugs.webkit.org/show_bug.cgi?id=220821
return [JSValue valueWithNewPromiseRejectedWithReason:[JSValue valueWithJSValueRef:exceptionValue inContext:self] inContext:self];
}
return [JSValue valueWithJSValueRef:toRef(vm, result) inContext:self];
@ -156,8 +150,8 @@
- (JSValue *)dependencyIdentifiersForModuleJSScript:(JSScript *)script
{
JSC::ExecState* exec = toJS(m_context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(m_context);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
if (script.type != kJSScriptTypeModule) {
@ -166,9 +160,9 @@
}
auto scope = DECLARE_CATCH_SCOPE(vm);
JSC::JSArray* result = exec->lexicalGlobalObject()->moduleLoader()->dependencyKeysIfEvaluated(exec, JSC::jsString(&vm, [[script sourceURL] absoluteString]));
JSC::JSArray* result = globalObject->moduleLoader()->dependencyKeysIfEvaluated(globalObject, JSC::jsString(vm, [[script sourceURL] absoluteString]));
if (scope.exception()) {
JSValueRef exceptionValue = toRef(exec, scope.exception()->value());
JSValueRef exceptionValue = toRef(globalObject, scope.exception()->value());
scope.clearException();
return [self valueFromNotifyException:exceptionValue];
}
@ -180,10 +174,19 @@
return [JSValue valueWithJSValueRef:toRef(vm, result) inContext:self];
}
- (void)_setITMLDebuggableType
{
JSC::JSGlobalObject* globalObject = toJS(m_context);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
globalObject->setIsITML();
}
- (void)setException:(JSValue *)value
{
JSC::ExecState* exec = toJS(m_context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(m_context);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
if (value)
m_exception.set(vm, toJS(JSValueToObject(m_context, valueInternalValue(value), 0)));
@ -240,10 +243,10 @@
if (!entry->currentArguments) {
JSContext *context = [JSContext currentContext];
size_t count = entry->argumentCount;
JSValue * argumentArray[count];
for (size_t i =0; i < count; ++i)
argumentArray[i] = [JSValue valueWithJSValueRef:entry->arguments[i] inContext:context];
entry->currentArguments = [[NSArray alloc] initWithObjects:argumentArray count:count];
NSMutableArray *arguments = [[NSMutableArray alloc] initWithCapacity:count];
for (size_t i = 0; i < count; ++i)
[arguments setObject:[JSValue valueWithJSValueRef:entry->arguments[i] inContext:context] atIndexedSubscript:i];
entry->currentArguments = arguments;
}
return entry->currentArguments;
@ -332,7 +335,7 @@
if (!self)
return nil;
JSC::JSGlobalObject* globalObject = toJS(context)->lexicalGlobalObject();
JSC::JSGlobalObject* globalObject = toJS(context);
m_virtualMachine = [[JSVirtualMachine virtualMachineWithContextGroupRef:toRef(&globalObject->vm())] retain];
ASSERT(m_virtualMachine);
m_context = JSGlobalContextRetain(context);
@ -392,7 +395,7 @@
- (JSWrapperMap *)wrapperMap
{
return toJS(m_context)->lexicalGlobalObject()->wrapperMap();
return toJS(m_context)->wrapperMap();
}
- (JSValue *)wrapperForJSObject:(JSValueRef)value

6
API/JSContextPrivate.h
View File

@ -106,6 +106,12 @@
*/
- (JSValue *)dependencyIdentifiersForModuleJSScript:(JSScript *)script JSC_API_AVAILABLE(macos(10.15), ios(13.0));
/*!
@method
@abstract Mark this JSContext as an ITMLKit context for the purposes of remote inspection capabilities.
*/
- (void)_setITMLDebuggableType JSC_API_AVAILABLE(macos(11.0), ios(14.0));
@end
#endif

150
API/JSContextRef.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006, 2007, 2013, 2016 Apple Inc. All rights reserved.
* Copyright (C) 2006-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -31,15 +31,15 @@
#include "CallFrame.h"
#include "InitializeThreading.h"
#include "JSAPIGlobalObject.h"
#include "JSAPIWrapperObject.h"
#include "JSCallbackObject.h"
#include "JSClassRef.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "SourceProvider.h"
#include "JSObjectInlines.h"
#include "StackVisitor.h"
#include "StrongInlines.h"
#include "StructureInlines.h"
#include "Watchdog.h"
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringHash.h>
#if ENABLE(REMOTE_INSPECTOR)
#include "JSGlobalObjectDebuggable.h"
@ -54,7 +54,7 @@
#if OS(DARWIN)
#include <mach-o/dyld.h>
static const int32_t webkitFirstVersionWithConcurrentGlobalContexts = 0x2100500; // 528.5.0
static constexpr int32_t webkitFirstVersionWithConcurrentGlobalContexts = 0x2100500; // 528.5.0
#endif
using namespace JSC;
@ -66,7 +66,7 @@ using namespace JSC;
JSContextGroupRef JSContextGroupCreate()
{
initializeThreading();
JSC::initialize();
return toRef(&VM::createContextGroup().leakRef());
}
@ -84,10 +84,10 @@ void JSContextGroupRelease(JSContextGroupRef group)
vm.deref();
}
static bool internalScriptTimeoutCallback(ExecState* exec, void* callbackPtr, void* callbackData)
static bool internalScriptTimeoutCallback(JSGlobalObject* globalObject, void* callbackPtr, void* callbackData)
{
JSShouldTerminateCallback callback = reinterpret_cast<JSShouldTerminateCallback>(callbackPtr);
JSContextRef contextRef = toRef(exec);
JSContextRef contextRef = toRef(globalObject);
ASSERT(callback);
return callback(contextRef, callbackData);
}
@ -116,7 +116,7 @@ void JSContextGroupClearExecutionTimeLimit(JSContextGroupRef group)
JSGlobalContextRef JSGlobalContextCreate(JSClassRef globalObjectClass)
{
initializeThreading();
JSC::initialize();
#if OS(DARWIN)
// If the application was linked before JSGlobalContextCreate was changed to use a unique VM,
@ -126,12 +126,12 @@ JSGlobalContextRef JSGlobalContextCreate(JSClassRef globalObjectClass)
}
#endif // OS(DARWIN)
return JSGlobalContextCreateInGroup(0, globalObjectClass);
return JSGlobalContextCreateInGroup(nullptr, globalObjectClass);
}
JSGlobalContextRef JSGlobalContextCreateInGroup(JSContextGroupRef group, JSClassRef globalObjectClass)
{
initializeThreading();
JSC::initialize();
Ref<VM> vm = group ? Ref<VM>(*toJS(group)) : VM::createContextGroup();
@ -143,12 +143,11 @@ JSGlobalContextRef JSGlobalContextCreateInGroup(JSContextGroupRef group, JSClass
if (JSRemoteInspectorGetInspectionEnabledByDefault())
globalObject->setRemoteDebuggingEnabled(true);
#endif
return JSGlobalContextRetain(toGlobalRef(globalObject->globalExec()));
return JSGlobalContextRetain(toGlobalRef(globalObject));
}
JSGlobalObject* globalObject = JSCallbackObject<JSGlobalObject>::create(vm.get(), globalObjectClass, JSCallbackObject<JSGlobalObject>::createStructure(vm.get(), 0, jsNull()));
ExecState* exec = globalObject->globalExec();
JSValue prototype = globalObjectClass->prototype(exec);
JSGlobalObject* globalObject = JSCallbackObject<JSGlobalObject>::create(vm.get(), globalObjectClass, JSCallbackObject<JSGlobalObject>::createStructure(vm.get(), nullptr, jsNull()));
JSValue prototype = globalObjectClass->prototype(globalObject);
if (!prototype)
prototype = jsNull();
globalObject->resetPrototype(vm.get(), prototype);
@ -156,27 +155,27 @@ JSGlobalContextRef JSGlobalContextCreateInGroup(JSContextGroupRef group, JSClass
if (JSRemoteInspectorGetInspectionEnabledByDefault())
globalObject->setRemoteDebuggingEnabled(true);
#endif
return JSGlobalContextRetain(toGlobalRef(exec));
return JSGlobalContextRetain(toGlobalRef(globalObject));
}
JSGlobalContextRef JSGlobalContextRetain(JSGlobalContextRef ctx)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
gcProtect(vm.vmEntryGlobalObject(exec));
gcProtect(globalObject);
vm.ref();
return ctx;
}
void JSGlobalContextRelease(JSGlobalContextRef ctx)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
bool protectCountIsZero = vm.heap.unprotect(vm.vmEntryGlobalObject(exec));
bool protectCountIsZero = vm.heap.unprotect(globalObject);
if (protectCountIsZero)
vm.heap.reportAbandonedObjectGraph();
vm.deref();
@ -186,51 +185,51 @@ JSObjectRef JSContextGetGlobalObject(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
return toRef(jsCast<JSObject*>(exec->lexicalGlobalObject()->methodTable(vm)->toThis(exec->lexicalGlobalObject(), exec, NotStrictMode)));
return toRef(jsCast<JSObject*>(globalObject->methodTable(vm)->toThis(globalObject, globalObject, ECMAMode::sloppy())));
}
JSContextGroupRef JSContextGetGroup(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
return toRef(&exec->vm());
JSGlobalObject* globalObject = toJS(ctx);
return toRef(&globalObject->vm());
}
JSGlobalContextRef JSContextGetGlobalContext(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toGlobalRef(exec->lexicalGlobalObject()->globalExec());
return toGlobalRef(globalObject);
}
JSStringRef JSGlobalContextCopyName(JSGlobalContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
String name = vm.vmEntryGlobalObject(exec)->name();
String name = globalObject->name();
if (name.isNull())
return 0;
return nullptr;
return OpaqueJSString::tryCreate(name).leakRef();
}
@ -242,13 +241,32 @@ void JSGlobalContextSetName(JSGlobalContextRef ctx, JSStringRef name)
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
vm.vmEntryGlobalObject(exec)->setName(name ? name->string() : String());
globalObject->setName(name ? name->string() : String());
}
void JSGlobalContextSetUnhandledRejectionCallback(JSGlobalContextRef ctx, JSObjectRef function, JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return;
}
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* object = toJS(function);
if (!object->isCallable(vm)) {
*exception = toRef(createTypeError(globalObject));
return;
}
globalObject->setUnhandledRejectionCallback(vm, object);
}
class BacktraceFunctor {
public:
@ -304,17 +322,17 @@ JSStringRef JSContextCreateBacktrace(JSContextRef ctx, unsigned maxStackSize)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
StringBuilder builder;
CallFrame* frame = vm.topCallFrame;
ASSERT(maxStackSize);
BacktraceFunctor functor(builder, maxStackSize);
frame->iterate(functor);
frame->iterate(vm, functor);
return OpaqueJSString::tryCreate(builder.toString()).leakRef();
}
@ -326,11 +344,11 @@ bool JSGlobalContextGetRemoteInspectionEnabled(JSGlobalContextRef ctx)
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
return vm.vmEntryGlobalObject(exec)->remoteDebuggingEnabled();
return globalObject->remoteDebuggingEnabled();
}
void JSGlobalContextSetRemoteInspectionEnabled(JSGlobalContextRef ctx, bool enabled)
@ -340,11 +358,11 @@ void JSGlobalContextSetRemoteInspectionEnabled(JSGlobalContextRef ctx, bool enab
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
vm.vmEntryGlobalObject(exec)->setRemoteDebuggingEnabled(enabled);
globalObject->setRemoteDebuggingEnabled(enabled);
}
bool JSGlobalContextGetIncludesNativeCallStackWhenReportingExceptions(JSGlobalContextRef ctx)
@ -355,11 +373,10 @@ bool JSGlobalContextGetIncludesNativeCallStackWhenReportingExceptions(JSGlobalCo
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
JSGlobalObject* globalObject = vm.vmEntryGlobalObject(exec);
return globalObject->inspectorController().includesNativeCallStackWhenReportingExceptions();
#else
UNUSED_PARAM(ctx);
@ -375,11 +392,10 @@ void JSGlobalContextSetIncludesNativeCallStackWhenReportingExceptions(JSGlobalCo
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
JSGlobalObject* globalObject = vm.vmEntryGlobalObject(exec);
globalObject->inspectorController().setIncludesNativeCallStackWhenReportingExceptions(includesNativeCallStack);
#else
UNUSED_PARAM(ctx);
@ -396,11 +412,11 @@ CFRunLoopRef JSGlobalContextGetDebuggerRunLoop(JSGlobalContextRef ctx)
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
return vm.vmEntryGlobalObject(exec)->inspectorDebuggable().targetRunLoop();
return globalObject->inspectorDebuggable().targetRunLoop();
#else
UNUSED_PARAM(ctx);
return nullptr;
@ -415,11 +431,11 @@ void JSGlobalContextSetDebuggerRunLoop(JSGlobalContextRef ctx, CFRunLoopRef runL
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
vm.vmEntryGlobalObject(exec)->inspectorDebuggable().setTargetRunLoop(runLoop);
globalObject->inspectorDebuggable().setTargetRunLoop(runLoop);
#else
UNUSED_PARAM(ctx);
UNUSED_PARAM(runLoop);
@ -435,10 +451,10 @@ Inspector::AugmentableInspectorController* JSGlobalContextGetAugmentableInspecto
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder lock(vm);
return &vm.vmEntryGlobalObject(exec)->inspectorController();
return &globalObject->inspectorController();
}
#endif

10
API/JSContextRefPrivate.h
View File

@ -128,6 +128,16 @@ JS_EXPORT bool JSGlobalContextGetIncludesNativeCallStackWhenReportingExceptions(
*/
JS_EXPORT void JSGlobalContextSetIncludesNativeCallStackWhenReportingExceptions(JSGlobalContextRef ctx, bool includesNativeCallStack) JSC_API_AVAILABLE(macos(10.10), ios(8.0));
/*!
@function
@abstract Sets the unhandled promise rejection callback for a context.
@discussion Similar to window.addEventListener('unhandledrejection'), but for contexts not associated with a web view.
@param ctx The JSGlobalContext to set the callback on.
@param function The callback function to set, which receives the promise and rejection reason as arguments.
@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
*/
JS_EXPORT void JSGlobalContextSetUnhandledRejectionCallback(JSGlobalContextRef ctx, JSObjectRef function, JSValueRef* exception) JSC_API_AVAILABLE(macos(10.15.4), ios(13.4));
#ifdef __cplusplus
}
#endif

15
API/JSHeapFinalizerPrivate.cpp
View File

@ -27,20 +27,17 @@
#include "JSHeapFinalizerPrivate.h"
#include "APICast.h"
#include "JSCInlines.h"
using namespace JSC;
void JSContextGroupAddHeapFinalizer(JSContextGroupRef group, JSHeapFinalizer finalizer, void *userData)
{
VM* vm = toJS(group);
JSLockHolder locker(vm);
vm->heap.addHeapFinalizerCallback(HeapFinalizerCallback(finalizer, userData));
JSC::VM* vm = toJS(group);
JSC::JSLockHolder locker(vm);
vm->heap.addHeapFinalizerCallback(JSC::HeapFinalizerCallback(finalizer, userData));
}
void JSContextGroupRemoveHeapFinalizer(JSContextGroupRef group, JSHeapFinalizer finalizer, void *userData)
{
VM* vm = toJS(group);
JSLockHolder locker(vm);
vm->heap.removeHeapFinalizerCallback(HeapFinalizerCallback(finalizer, userData));
JSC::VM* vm = toJS(group);
JSC::JSLockHolder locker(vm);
vm->heap.removeHeapFinalizerCallback(JSC::HeapFinalizerCallback(finalizer, userData));
}

2
API/JSHeapFinalizerPrivate.h
View File

@ -26,7 +26,7 @@
#ifndef JSHeapFinalizerPrivate_h
#define JSHeapFinalizerPrivate_h
#include <JavaScriptCore/JSContextRef.h>
#include <JavaScriptCore/JSBase.h>
#include <stdbool.h>
#ifdef __cplusplus

48
inspector/EventLoop.h → API/JSLockRef.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2008 Apple Inc. All Rights Reserved.
* Copyright (C) 2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -23,33 +23,29 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "config.h"
#include "JSLockRefPrivate.h"
#include <wtf/Noncopyable.h>
#include "JSLock.h"
#if USE(CF) && !OS(WINDOWS)
#include <CoreFoundation/CFRunLoop.h>
#endif
using namespace JSC;
namespace Inspector {
class EventLoop {
WTF_MAKE_NONCOPYABLE(EventLoop);
public:
EventLoop()
: m_ended(false)
{
void JSLock(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return;
}
JSGlobalObject* globalObject = toJS(ctx);
globalObject->vm().apiLock().lock();
}
void cycle();
bool ended() const { return m_ended; }
#if USE(CF) && !OS(WINDOWS)
static CFStringRef remoteInspectorRunLoopMode();
#endif
private:
bool m_ended;
};
} // namespace Inspector
void JSUnlock(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return;
}
JSGlobalObject* globalObject = toJS(ctx);
globalObject->vm().apiLock().unlock();
}

52
API/JSLockRefPrivate.h Normal file
View File

@ -0,0 +1,52 @@
/*
* Copyright (C) 2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <JavaScriptCore/JSBase.h>
#ifdef __cplusplus
extern "C" {
#endif
/*!
@function
@abstract Acquire the API lock for the given JSContextRef.
@param ctx The execution context to be locked.
@discussion The lock has to be held to perform any interactions with the JSContextRef. This function allows holding the lock across multiple interactions to amortize the cost. This lock is a recursive lock.
*/
JS_EXPORT void JSLock(JSContextRef ctx);
/*!
@function
@abstract Release the API lock for the given JSContextRef.
@param ctx The execution context to be unlocked.
@discussion Releases the lock that was previously acquired using JSLock.
*/
JS_EXPORT void JSUnlock(JSContextRef ctx);
#ifdef __cplusplus
}
#endif

23
API/JSManagedValue.mm
View File

@ -35,18 +35,14 @@
#import "JSValueInternal.h"
#import "JSWeakValue.h"
#import "WeakHandleOwner.h"
#ifdef DARLING
#import "ObjCRuntimeExtras.h"
#else
#import "ObjcRuntimeExtras.h"
#endif
#import "JSCInlines.h"
#import <wtf/NeverDestroyed.h>
class JSManagedValueHandleOwner : public JSC::WeakHandleOwner {
class JSManagedValueHandleOwner final : public JSC::WeakHandleOwner {
public:
void finalize(JSC::Handle<JSC::Unknown>, void* context) override;
bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**) override;
void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**) final;
};
static JSManagedValueHandleOwner& managedValueHandleOwner()
@ -88,19 +84,18 @@ static JSManagedValueHandleOwner& managedValueHandleOwner()
if (!value)
return self;
JSC::ExecState* exec = toJS([value.context JSGlobalContextRef]);
JSC::JSGlobalObject* globalObject = exec->lexicalGlobalObject();
JSC::JSGlobalObject* globalObject = toJS([value.context JSGlobalContextRef]);
auto& owner = managedValueHandleOwner();
JSC::Weak<JSC::JSGlobalObject> weak(globalObject, &owner, (__bridge void*)self);
m_globalObject.swap(weak);
m_lock = &exec->vm().apiLock();
m_lock = &globalObject->vm().apiLock();
NSPointerFunctionsOptions weakIDOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
NSPointerFunctionsOptions integerOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsIntegerPersonality;
m_owners = [[NSMapTable alloc] initWithKeyOptions:weakIDOptions valueOptions:integerOptions capacity:1];
JSC::JSValue jsValue = toJS(exec, [value JSValueRef]);
JSC::JSValue jsValue = toJS(globalObject, [value JSValueRef]);
if (jsValue.isObject())
m_weakValue.setObject(JSC::jsCast<JSC::JSObject*>(jsValue.asCell()), owner, (__bridge void*)self);
else if (jsValue.isString())
@ -161,8 +156,8 @@ static JSManagedValueHandleOwner& managedValueHandleOwner()
return nil;
if (m_weakValue.isClear())
return nil;
JSC::ExecState* exec = m_globalObject->globalExec();
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(exec)];
JSC::JSGlobalObject* globalObject = m_globalObject.get();
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];
JSC::JSValue value;
if (m_weakValue.isPrimitive())
value = m_weakValue.primitive();
@ -170,7 +165,7 @@ static JSManagedValueHandleOwner& managedValueHandleOwner()
value = m_weakValue.string();
else
value = m_weakValue.object();
return [JSValue valueWithJSValueRef:toRef(exec, value) inContext:context];
return [JSValue valueWithJSValueRef:toRef(globalObject, value) inContext:context];
}
- (void)disconnectValue

3
API/JSMarkingConstraintPrivate.cpp
View File

@ -27,7 +27,6 @@
#include "JSMarkingConstraintPrivate.h"
#include "APICast.h"
#include "JSCInlines.h"
#include "SimpleMarkingConstraint.h"
using namespace JSC;
@ -71,7 +70,7 @@ void JSContextGroupAddMarkingConstraint(JSContextGroupRef group, JSMarkingConstr
// else gets marked.
ConstraintVolatility volatility = ConstraintVolatility::GreyedByMarking;
auto constraint = std::make_unique<SimpleMarkingConstraint>(
auto constraint = makeUnique<SimpleMarkingConstraint>(
toCString("Amc", constraintIndex, "(", RawPointer(bitwise_cast<void*>(constraintCallback)), ")"),
toCString("API Marking Constraint #", constraintIndex, " (", RawPointer(bitwise_cast<void*>(constraintCallback)), ", ", RawPointer(userData), ")"),
[constraintCallback, userData]

437
API/JSObjectRef.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006-2019 Apple Inc. All rights reserved.
* Copyright (C) 2006-2020 Apple Inc. All rights reserved.
* Copyright (C) 2008 Kelvin W Sherlock (ksherlock@gmail.com)
*
* Redistribution and use in source and binary forms, with or without
@ -31,26 +31,17 @@
#include "APICast.h"
#include "APIUtils.h"
#include "DateConstructor.h"
#include "ErrorConstructor.h"
#include "Exception.h"
#include "FunctionConstructor.h"
#include "Identifier.h"
#include "InitializeThreading.h"
#include "JSAPIWrapperObject.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSCallbackConstructor.h"
#include "JSCallbackFunction.h"
#include "JSCallbackObject.h"
#include "JSClassRef.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSObject.h"
#include "JSPromise.h"
#include "JSPromiseDeferred.h"
#include "JSRetainPtr.h"
#include "JSString.h"
#include "JSValueRef.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"
#include "PropertyNameArray.h"
@ -65,7 +56,7 @@ using namespace JSC;
JSClassRef JSClassCreate(const JSClassDefinition* definition)
{
initializeThreading();
JSC::initialize();
auto jsClass = (definition->attributes & kJSClassAttributeNoAutomaticPrototype)
? OpaqueJSClass::createNoAutomaticPrototype(definition)
: OpaqueJSClass::create(definition);
@ -88,17 +79,17 @@ JSObjectRef JSObjectMake(JSContextRef ctx, JSClassRef jsClass, void* data)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
if (!jsClass)
return toRef(constructEmptyObject(exec));
return toRef(constructEmptyObject(globalObject));
JSCallbackObject<JSDestructibleObject>* object = JSCallbackObject<JSDestructibleObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->callbackObjectStructure(), jsClass, data);
if (JSObject* prototype = jsClass->prototype(exec))
JSCallbackObject<JSNonFinalObject>* object = JSCallbackObject<JSNonFinalObject>::create(globalObject, globalObject->callbackObjectStructure(), jsClass, data);
if (JSObject* prototype = jsClass->prototype(globalObject))
object->setPrototypeDirect(vm, prototype);
return toRef(object);
@ -108,62 +99,62 @@ JSObjectRef JSObjectMakeFunctionWithCallback(JSContextRef ctx, JSStringRef name,
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
return toRef(JSCallbackFunction::create(vm, exec->lexicalGlobalObject(), callAsFunction, name ? name->string() : "anonymous"_s));
return toRef(JSCallbackFunction::create(vm, globalObject, callAsFunction, name ? name->string() : "anonymous"_s));
}
JSObjectRef JSObjectMakeConstructor(JSContextRef ctx, JSClassRef jsClass, JSObjectCallAsConstructorCallback callAsConstructor)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSValue jsPrototype = jsClass ? jsClass->prototype(exec) : 0;
JSValue jsPrototype = jsClass ? jsClass->prototype(globalObject) : nullptr;
if (!jsPrototype)
jsPrototype = exec->lexicalGlobalObject()->objectPrototype();
jsPrototype = globalObject->objectPrototype();
JSCallbackConstructor* constructor = JSCallbackConstructor::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->callbackConstructorStructure(), jsClass, callAsConstructor);
JSCallbackConstructor* constructor = JSCallbackConstructor::create(globalObject, globalObject->callbackConstructorStructure(), jsClass, callAsConstructor);
constructor->putDirect(vm, vm.propertyNames->prototype, jsPrototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
return toRef(constructor);
}
JSObjectRef JSObjectMakeFunction(JSContextRef ctx, JSStringRef name, unsigned parameterCount, const JSStringRef parameterNames[], JSStringRef body, JSStringRef sourceURL, int startingLineNumber, JSValueRef* exception)
JSObjectRef JSObjectMakeFunction(JSContextRef ctx, JSStringRef name, unsigned parameterCount, const JSStringRef parameterNames[], JSStringRef body, JSStringRef sourceURLString, int startingLineNumber, JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
startingLineNumber = std::max(1, startingLineNumber);
Identifier nameID = name ? name->identifier(&vm) : Identifier::fromString(exec, "anonymous");
Identifier nameID = name ? name->identifier(&vm) : Identifier::fromString(vm, "anonymous");
MarkedArgumentBuffer args;
for (unsigned i = 0; i < parameterCount; i++)
args.append(jsString(exec, parameterNames[i]->string()));
args.append(jsString(exec, body->string()));
args.append(jsString(vm, parameterNames[i]->string()));
args.append(jsString(vm, body->string()));
if (UNLIKELY(args.hasOverflowed())) {
auto throwScope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(exec, throwScope);
handleExceptionIfNeeded(scope, exec, exception);
return 0;
throwOutOfMemoryError(globalObject, throwScope);
handleExceptionIfNeeded(scope, ctx, exception);
return nullptr;
}
auto sourceURLString = sourceURL ? sourceURL->string() : String();
JSObject* result = constructFunction(exec, exec->lexicalGlobalObject(), args, nameID, SourceOrigin { sourceURLString }, sourceURLString, TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()));
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
auto sourceURL = sourceURLString ? URL({ }, sourceURLString->string()) : URL();
JSObject* result = constructFunction(globalObject, args, nameID, SourceOrigin { sourceURL }, sourceURL.string(), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return toRef(result);
}
@ -171,10 +162,10 @@ JSObjectRef JSObjectMakeArray(JSContextRef ctx, size_t argumentCount, const JSVa
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
@ -182,20 +173,20 @@ JSObjectRef JSObjectMakeArray(JSContextRef ctx, size_t argumentCount, const JSVa
if (argumentCount) {
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
argList.append(toJS(globalObject, arguments[i]));
if (UNLIKELY(argList.hasOverflowed())) {
auto throwScope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(exec, throwScope);
handleExceptionIfNeeded(scope, exec, exception);
return 0;
throwOutOfMemoryError(globalObject, throwScope);
handleExceptionIfNeeded(scope, ctx, exception);
return nullptr;
}
result = constructArray(exec, static_cast<ArrayAllocationProfile*>(0), argList);
result = constructArray(globalObject, static_cast<ArrayAllocationProfile*>(nullptr), argList);
} else
result = constructEmptyArray(exec, 0);
result = constructEmptyArray(globalObject, nullptr);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return toRef(result);
}
@ -204,26 +195,26 @@ JSObjectRef JSObjectMakeDate(JSContextRef ctx, size_t argumentCount, const JSVal
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
argList.append(toJS(globalObject, arguments[i]));
if (UNLIKELY(argList.hasOverflowed())) {
auto throwScope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(exec, throwScope);
handleExceptionIfNeeded(scope, exec, exception);
return 0;
throwOutOfMemoryError(globalObject, throwScope);
handleExceptionIfNeeded(scope, ctx, exception);
return nullptr;
}
JSObject* result = constructDate(exec, exec->lexicalGlobalObject(), JSValue(), argList);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
JSObject* result = constructDate(globalObject, JSValue(), argList);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return toRef(result);
}
@ -232,19 +223,19 @@ JSObjectRef JSObjectMakeError(JSContextRef ctx, size_t argumentCount, const JSVa
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue message = argumentCount ? toJS(exec, arguments[0]) : jsUndefined();
Structure* errorStructure = exec->lexicalGlobalObject()->errorStructure();
JSObject* result = ErrorInstance::create(exec, errorStructure, message);
JSValue message = argumentCount ? toJS(globalObject, arguments[0]) : jsUndefined();
Structure* errorStructure = globalObject->errorStructure();
JSObject* result = ErrorInstance::create(globalObject, errorStructure, message);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return toRef(result);
}
@ -253,26 +244,26 @@ JSObjectRef JSObjectMakeRegExp(JSContextRef ctx, size_t argumentCount, const JSV
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
argList.append(toJS(globalObject, arguments[i]));
if (UNLIKELY(argList.hasOverflowed())) {
auto throwScope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(exec, throwScope);
handleExceptionIfNeeded(scope, exec, exception);
return 0;
throwOutOfMemoryError(globalObject, throwScope);
handleExceptionIfNeeded(scope, ctx, exception);
return nullptr;
}
JSObject* result = constructRegExp(exec, exec->lexicalGlobalObject(), argList);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
JSObject* result = constructRegExp(globalObject, argList);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return toRef(result);
}
@ -284,14 +275,13 @@ JSObjectRef JSObjectMakeDeferredPromise(JSContextRef ctx, JSObjectRef* resolve,
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(globalObject);
auto scope = DECLARE_CATCH_SCOPE(vm);
auto* globalObject = exec->lexicalGlobalObject();
JSPromiseDeferred::DeferredData data = JSPromiseDeferred::createDeferredData(exec, globalObject, globalObject->promiseConstructor());
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
JSPromise::DeferredData data = JSPromise::createDeferredData(globalObject, globalObject->promiseConstructor());
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
if (resolve)
@ -305,13 +295,13 @@ JSValueRef JSObjectGetPrototype(JSContextRef ctx, JSObjectRef object)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
JSObject* jsObject = toJS(object);
return toRef(exec, jsObject->getPrototypeDirect(exec->vm()));
return toRef(globalObject, jsObject->getPrototypeDirect(globalObject->vm()));
}
void JSObjectSetPrototype(JSContextRef ctx, JSObjectRef object, JSValueRef value)
@ -320,15 +310,15 @@ void JSObjectSetPrototype(JSContextRef ctx, JSObjectRef object, JSValueRef value
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
JSValue jsValue = toJS(exec, value);
jsObject->setPrototype(vm, exec, jsValue.isObject() ? jsValue : jsNull());
handleExceptionIfNeeded(scope, exec, nullptr);
JSValue jsValue = toJS(globalObject, value);
jsObject->setPrototype(vm, globalObject, jsValue.isObject() ? jsValue : jsNull());
handleExceptionIfNeeded(scope, ctx, nullptr);
}
bool JSObjectHasProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName)
@ -337,31 +327,32 @@ bool JSObjectHasProperty(JSContextRef ctx, JSObjectRef object, JSStringRef prope
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* jsObject = toJS(object);
return jsObject->hasProperty(exec, propertyName->identifier(&vm));
return jsObject->hasProperty(globalObject, propertyName->identifier(&vm));
}
JSValueRef JSObjectGetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
{
if (!ctx) {
if (!ctx || !object) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
JSValue jsValue = jsObject->get(exec, propertyName->identifier(&vm));
handleExceptionIfNeeded(scope, exec, exception);
return toRef(exec, jsValue);
JSValue jsValue = jsObject->get(globalObject, propertyName->identifier(&vm));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(globalObject, jsValue);
}
void JSObjectSetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSPropertyAttributes attributes, JSValueRef* exception)
@ -370,26 +361,26 @@ void JSObjectSetProperty(JSContextRef ctx, JSObjectRef object, JSStringRef prope
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
Identifier name(propertyName->identifier(&vm));
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
bool doesNotHaveProperty = attributes && !jsObject->hasProperty(exec, name);
bool doesNotHaveProperty = attributes && !jsObject->hasProperty(globalObject, name);
if (LIKELY(!scope.exception())) {
if (doesNotHaveProperty) {
PropertyDescriptor desc(jsValue, attributes);
jsObject->methodTable(vm)->defineOwnProperty(jsObject, exec, name, desc, false);
jsObject->methodTable(vm)->defineOwnProperty(jsObject, globalObject, name, desc, false);
} else {
PutPropertySlot slot(jsObject);
jsObject->methodTable(vm)->put(jsObject, exec, name, jsValue, slot);
jsObject->methodTable(vm)->put(jsObject, globalObject, name, jsValue, slot);
}
}
handleExceptionIfNeeded(scope, exec, exception);
handleExceptionIfNeeded(scope, ctx, exception);
}
bool JSObjectHasPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef key, JSValueRef* exception)
@ -398,18 +389,19 @@ bool JSObjectHasPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
Identifier ident = toJS(exec, key).toPropertyKey(exec);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
Identifier ident = toJS(globalObject, key).toPropertyKey(globalObject);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
bool result = jsObject->hasProperty(exec, ident);
handleExceptionIfNeeded(scope, exec, exception);
bool result = jsObject->hasProperty(globalObject, ident);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
return result;
}
@ -419,19 +411,20 @@ JSValueRef JSObjectGetPropertyForKey(JSContextRef ctx, JSObjectRef object, JSVal
ASSERT_NOT_REACHED();
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
Identifier ident = toJS(exec, key).toPropertyKey(exec);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
Identifier ident = toJS(globalObject, key).toPropertyKey(globalObject);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
JSValue jsValue = jsObject->get(exec, ident);
handleExceptionIfNeeded(scope, exec, exception);
return toRef(exec, jsValue);
JSValue jsValue = jsObject->get(globalObject, ident);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(globalObject, jsValue);
}
void JSObjectSetPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef key, JSValueRef value, JSPropertyAttributes attributes, JSValueRef* exception)
@ -440,29 +433,29 @@ void JSObjectSetPropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
Identifier ident = toJS(exec, key).toPropertyKey(exec);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
Identifier ident = toJS(globalObject, key).toPropertyKey(globalObject);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return;
bool doesNotHaveProperty = attributes && !jsObject->hasProperty(exec, ident);
bool doesNotHaveProperty = attributes && !jsObject->hasProperty(globalObject, ident);
if (LIKELY(!scope.exception())) {
if (doesNotHaveProperty) {
PropertyDescriptor desc(jsValue, attributes);
jsObject->methodTable(vm)->defineOwnProperty(jsObject, exec, ident, desc, false);
jsObject->methodTable(vm)->defineOwnProperty(jsObject, globalObject, ident, desc, false);
} else {
PutPropertySlot slot(jsObject);
jsObject->methodTable(vm)->put(jsObject, exec, ident, jsValue, slot);
jsObject->methodTable(vm)->put(jsObject, globalObject, ident, jsValue, slot);
}
}
handleExceptionIfNeeded(scope, exec, exception);
handleExceptionIfNeeded(scope, ctx, exception);
}
bool JSObjectDeletePropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueRef key, JSValueRef* exception)
@ -471,18 +464,19 @@ bool JSObjectDeletePropertyForKey(JSContextRef ctx, JSObjectRef object, JSValueR
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
Identifier ident = toJS(exec, key).toPropertyKey(exec);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
Identifier ident = toJS(globalObject, key).toPropertyKey(globalObject);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
bool result = jsObject->methodTable(vm)->deleteProperty(jsObject, exec, ident);
handleExceptionIfNeeded(scope, exec, exception);
bool result = JSCell::deleteProperty(jsObject, globalObject, ident);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
return result;
}
@ -490,18 +484,19 @@ JSValueRef JSObjectGetPropertyAtIndex(JSContextRef ctx, JSObjectRef object, unsi
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
JSValue jsValue = jsObject->get(exec, propertyIndex);
handleExceptionIfNeeded(scope, exec, exception);
return toRef(exec, jsValue);
JSValue jsValue = jsObject->get(globalObject, propertyIndex);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(globalObject, jsValue);
}
@ -511,16 +506,16 @@ void JSObjectSetPropertyAtIndex(JSContextRef ctx, JSObjectRef object, unsigned p
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
jsObject->methodTable(vm)->putByIndex(jsObject, exec, propertyIndex, jsValue, false);
handleExceptionIfNeeded(scope, exec, exception);
jsObject->methodTable(vm)->putByIndex(jsObject, globalObject, propertyIndex, jsValue, false);
handleExceptionIfNeeded(scope, ctx, exception);
}
bool JSObjectDeleteProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
@ -529,15 +524,16 @@ bool JSObjectDeleteProperty(JSContextRef ctx, JSObjectRef object, JSStringRef pr
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSObject* jsObject = toJS(object);
bool result = jsObject->methodTable(vm)->deleteProperty(jsObject, exec, propertyName->identifier(&vm));
handleExceptionIfNeeded(scope, exec, exception);
bool result = JSCell::deleteProperty(jsObject, globalObject, propertyName->identifier(&vm));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
return result;
}
@ -546,7 +542,7 @@ bool JSObjectDeleteProperty(JSContextRef ctx, JSObjectRef object, JSStringRef pr
// during destruction.
static const ClassInfo* classInfoPrivate(JSObject* jsObject)
{
VM& vm = *jsObject->vm();
VM& vm = jsObject->vm();
if (vm.currentlyDestructingCallbackObject != jsObject)
return jsObject->classInfo(vm);
@ -557,7 +553,7 @@ static const ClassInfo* classInfoPrivate(JSObject* jsObject)
void* JSObjectGetPrivate(JSObjectRef object)
{
JSObject* jsObject = uncheckedToJS(object);
VM& vm = *jsObject->vm();
VM& vm = jsObject->vm();
const ClassInfo* classInfo = classInfoPrivate(jsObject);
@ -569,20 +565,20 @@ void* JSObjectGetPrivate(JSObjectRef object)
if (classInfo->isSubClassOf(JSCallbackObject<JSGlobalObject>::info()))
return static_cast<JSCallbackObject<JSGlobalObject>*>(jsObject)->getPrivate();
if (classInfo->isSubClassOf(JSCallbackObject<JSDestructibleObject>::info()))
return static_cast<JSCallbackObject<JSDestructibleObject>*>(jsObject)->getPrivate();
if (classInfo->isSubClassOf(JSCallbackObject<JSNonFinalObject>::info()))
return static_cast<JSCallbackObject<JSNonFinalObject>*>(jsObject)->getPrivate();
#if JSC_OBJC_API_ENABLED
if (classInfo->isSubClassOf(JSCallbackObject<JSAPIWrapperObject>::info()))
return static_cast<JSCallbackObject<JSAPIWrapperObject>*>(jsObject)->getPrivate();
#endif
return 0;
return nullptr;
}
bool JSObjectSetPrivate(JSObjectRef object, void* data)
{
JSObject* jsObject = uncheckedToJS(object);
VM& vm = *jsObject->vm();
VM& vm = jsObject->vm();
const ClassInfo* classInfo = classInfoPrivate(jsObject);
@ -596,8 +592,8 @@ bool JSObjectSetPrivate(JSObjectRef object, void* data)
static_cast<JSCallbackObject<JSGlobalObject>*>(jsObject)->setPrivate(data);
return true;
}
if (classInfo->isSubClassOf(JSCallbackObject<JSDestructibleObject>::info())) {
static_cast<JSCallbackObject<JSDestructibleObject>*>(jsObject)->setPrivate(data);
if (classInfo->isSubClassOf(JSCallbackObject<JSNonFinalObject>::info())) {
static_cast<JSCallbackObject<JSNonFinalObject>*>(jsObject)->setPrivate(data);
return true;
}
#if JSC_OBJC_API_ENABLED
@ -612,8 +608,8 @@ bool JSObjectSetPrivate(JSObjectRef object, void* data)
JSValueRef JSObjectGetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* jsObject = toJS(object);
JSValue result;
@ -626,22 +622,22 @@ JSValueRef JSObjectGetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSSt
if (jsObject->inherits<JSCallbackObject<JSGlobalObject>>(vm))
result = jsCast<JSCallbackObject<JSGlobalObject>*>(jsObject)->getPrivateProperty(name);
else if (jsObject->inherits<JSCallbackObject<JSDestructibleObject>>(vm))
result = jsCast<JSCallbackObject<JSDestructibleObject>*>(jsObject)->getPrivateProperty(name);
else if (jsObject->inherits<JSCallbackObject<JSNonFinalObject>>(vm))
result = jsCast<JSCallbackObject<JSNonFinalObject>*>(jsObject)->getPrivateProperty(name);
#if JSC_OBJC_API_ENABLED
else if (jsObject->inherits<JSCallbackObject<JSAPIWrapperObject>>(vm))
result = jsCast<JSCallbackObject<JSAPIWrapperObject>*>(jsObject)->getPrivateProperty(name);
#endif
return toRef(exec, result);
return toRef(globalObject, result);
}
bool JSObjectSetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* jsObject = toJS(object);
JSValue jsValue = value ? toJS(exec, value) : JSValue();
JSValue jsValue = value ? toJS(globalObject, value) : JSValue();
Identifier name(propertyName->identifier(&vm));
// Get wrapped object if proxied
@ -652,8 +648,8 @@ bool JSObjectSetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRe
jsCast<JSCallbackObject<JSGlobalObject>*>(jsObject)->setPrivateProperty(vm, name, jsValue);
return true;
}
if (jsObject->inherits<JSCallbackObject<JSDestructibleObject>>(vm)) {
jsCast<JSCallbackObject<JSDestructibleObject>*>(jsObject)->setPrivateProperty(vm, name, jsValue);
if (jsObject->inherits<JSCallbackObject<JSNonFinalObject>>(vm)) {
jsCast<JSCallbackObject<JSNonFinalObject>*>(jsObject)->setPrivateProperty(vm, name, jsValue);
return true;
}
#if JSC_OBJC_API_ENABLED
@ -667,8 +663,8 @@ bool JSObjectSetPrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRe
bool JSObjectDeletePrivateProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* jsObject = toJS(object);
Identifier name(propertyName->identifier(&vm));
@ -681,8 +677,8 @@ bool JSObjectDeletePrivateProperty(JSContextRef ctx, JSObjectRef object, JSStrin
jsCast<JSCallbackObject<JSGlobalObject>*>(jsObject)->deletePrivateProperty(name);
return true;
}
if (jsObject->inherits<JSCallbackObject<JSDestructibleObject>>(vm)) {
jsCast<JSCallbackObject<JSDestructibleObject>*>(jsObject)->deletePrivateProperty(name);
if (jsObject->inherits<JSCallbackObject<JSNonFinalObject>>(vm)) {
jsCast<JSCallbackObject<JSNonFinalObject>*>(jsObject)->deletePrivateProperty(name);
return true;
}
#if JSC_OBJC_API_ENABLED
@ -698,55 +694,53 @@ bool JSObjectIsFunction(JSContextRef ctx, JSObjectRef object)
{
if (!object)
return false;
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
CallData callData;
JSCell* cell = toJS(object);
return cell->methodTable(vm)->getCallData(cell, callData) != CallType::None;
return cell->isCallable(vm);
}
JSValueRef JSObjectCallAsFunction(JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
if (!object)
return 0;
return nullptr;
JSObject* jsObject = toJS(object);
JSObject* jsThisObject = toJS(thisObject);
if (!jsThisObject)
jsThisObject = exec->globalThisValue();
jsThisObject = globalObject->globalThis();
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; i++)
argList.append(toJS(exec, arguments[i]));
argList.append(toJS(globalObject, arguments[i]));
if (UNLIKELY(argList.hasOverflowed())) {
auto throwScope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(exec, throwScope);
handleExceptionIfNeeded(scope, exec, exception);
return 0;
throwOutOfMemoryError(globalObject, throwScope);
handleExceptionIfNeeded(scope, ctx, exception);
return nullptr;
}
CallData callData;
CallType callType = jsObject->methodTable(vm)->getCallData(jsObject, callData);
if (callType == CallType::None)
return 0;
auto callData = getCallData(vm, jsObject);
if (callData.type == CallData::Type::None)
return nullptr;
JSValueRef result = toRef(exec, profiledCall(exec, ProfilingReason::API, jsObject, callType, callData, jsThisObject, argList));
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
JSValueRef result = toRef(globalObject, profiledCall(globalObject, ProfilingReason::API, jsObject, callData, jsThisObject, argList));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return result;
}
bool JSObjectIsConstructor(JSContextRef ctx, JSObjectRef object)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
if (!object)
return false;
@ -755,34 +749,33 @@ bool JSObjectIsConstructor(JSContextRef ctx, JSObjectRef object)
JSObjectRef JSObjectCallAsConstructor(JSContextRef ctx, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
if (!object)
return 0;
return nullptr;
JSObject* jsObject = toJS(object);
ConstructData constructData;
ConstructType constructType = jsObject->methodTable(vm)->getConstructData(jsObject, constructData);
if (constructType == ConstructType::None)
return 0;
auto constructData = getConstructData(vm, jsObject);
if (constructData.type == CallData::Type::None)
return nullptr;
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; i++)
argList.append(toJS(exec, arguments[i]));
argList.append(toJS(globalObject, arguments[i]));
if (UNLIKELY(argList.hasOverflowed())) {
auto throwScope = DECLARE_THROW_SCOPE(vm);
throwOutOfMemoryError(exec, throwScope);
handleExceptionIfNeeded(scope, exec, exception);
return 0;
throwOutOfMemoryError(globalObject, throwScope);
handleExceptionIfNeeded(scope, ctx, exception);
return nullptr;
}
JSObjectRef result = toRef(profiledConstruct(exec, ProfilingReason::API, jsObject, constructType, constructData, argList));
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
result = 0;
JSObjectRef result = toRef(profiledConstruct(globalObject, ProfilingReason::API, jsObject, constructData, argList));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
result = nullptr;
return result;
}
@ -805,17 +798,17 @@ JSPropertyNameArrayRef JSObjectCopyPropertyNames(JSContextRef ctx, JSObjectRef o
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
VM* vm = &exec->vm();
VM& vm = globalObject->vm();
JSObject* jsObject = toJS(object);
JSPropertyNameArrayRef propertyNames = new OpaqueJSPropertyNameArray(vm);
JSPropertyNameArrayRef propertyNames = new OpaqueJSPropertyNameArray(&vm);
PropertyNameArray array(vm, PropertyNameMode::Strings, PrivateSymbolMode::Exclude);
jsObject->methodTable(*vm)->getPropertyNames(jsObject, exec, array, EnumerationMode());
jsObject->getPropertyNames(globalObject, array, DontEnumPropertiesMode::Exclude);
size_t size = array.size();
propertyNames->array.reserveInitialCapacity(size);
@ -852,9 +845,9 @@ JSStringRef JSPropertyNameArrayGetNameAtIndex(JSPropertyNameArrayRef array, size
void JSPropertyNameAccumulatorAddName(JSPropertyNameAccumulatorRef array, JSStringRef propertyName)
{
PropertyNameArray* propertyNames = toJS(array);
VM* vm = propertyNames->vm();
VM& vm = propertyNames->vm();
JSLockHolder locker(vm);
propertyNames->add(propertyName->identifier(vm));
propertyNames->add(propertyName->identifier(&vm));
}
JSObjectRef JSObjectGetProxyTarget(JSObjectRef objectRef)
@ -862,7 +855,7 @@ JSObjectRef JSObjectGetProxyTarget(JSObjectRef objectRef)
JSObject* object = toJS(objectRef);
if (!object)
return nullptr;
VM& vm = *object->vm();
VM& vm = object->vm();
JSLockHolder locker(vm);
JSObject* result = nullptr;
if (JSProxy* proxy = jsDynamicCast<JSProxy*>(vm, object))
@ -877,6 +870,6 @@ JSGlobalContextRef JSObjectGetGlobalContext(JSObjectRef objectRef)
JSObject* object = toJS(objectRef);
if (!object)
return nullptr;
return reinterpret_cast<JSGlobalContextRef>(object->globalObject()->globalExec());
return reinterpret_cast<JSGlobalContextRef>(object->globalObject());
}

6
API/JSObjectRef.h
View File

@ -339,6 +339,8 @@ JSStaticValue StaticValueArray[] = {
Standard JavaScript practice calls for storing function objects in prototypes, so they can be shared. The default JSClass created by JSClassCreate follows this idiom, instantiating objects with a shared, automatically generating prototype containing the class's function objects. The kJSClassAttributeNoAutomaticPrototype attribute specifies that a JSClass should not automatically generate such a prototype. The resulting JSClass instantiates objects with the default object prototype, and gives each instance object its own copy of the class's function objects.
A NULL callback specifies that the default object callback should substitute, except in the case of hasProperty, where it specifies that getProperty should substitute.
It is not possible to use JS subclassing with objects created from a class definition that sets callAsConstructor by default. Subclassing is supported via the JSObjectMakeConstructor function, however.
*/
typedef struct {
int version; /* current (and only) version is 0 */
@ -426,7 +428,7 @@ JS_EXPORT JSObjectRef JSObjectMakeFunctionWithCallback(JSContextRef ctx, JSStrin
@param jsClass A JSClass that is the class your constructor will assign to the objects its constructs. jsClass will be used to set the constructor's .prototype property, and to evaluate 'instanceof' expressions. Pass NULL to use the default object class.
@param callAsConstructor A JSObjectCallAsConstructorCallback to invoke when your constructor is used in a 'new' expression. Pass NULL to use the default object constructor.
@result A JSObject that is a constructor. The object's prototype will be the default object prototype.
@discussion The default object constructor takes no arguments and constructs an object of class jsClass with no private data.
@discussion The default object constructor takes no arguments and constructs an object of class jsClass with no private data. If the constructor is inherited via JS subclassing and the value returned from callAsConstructor was created with jsClass, then the returned object will have it's prototype overridden to the derived class's prototype.
*/
JS_EXPORT JSObjectRef JSObjectMakeConstructor(JSContextRef ctx, JSClassRef jsClass, JSObjectCallAsConstructorCallback callAsConstructor);
@ -461,7 +463,7 @@ JS_EXPORT JSObjectRef JSObjectMakeDate(JSContextRef ctx, size_t argumentCount, c
@param argumentCount An integer count of the number of arguments in arguments.
@param arguments A JSValue array of arguments to pass to the Error Constructor. Pass NULL if argumentCount is 0.
@param exception A pointer to a JSValueRef in which to store an exception, if any. Pass NULL if you do not care to store an exception.
@result A JSObject that is a Error.
@result A JSObject that is an Error.
*/
JS_EXPORT JSObjectRef JSObjectMakeError(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) JSC_API_AVAILABLE(macos(10.6), ios(7.0));

40
API/JSRemoteInspectorServer.cpp Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (C) 2020 Sony Interactive Entertainment Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "JSRemoteInspectorServer.h"
#if ENABLE(REMOTE_INSPECTOR)
#include "RemoteInspectorServer.h"
uint16_t JSRemoteInspectorServerStart(const char* address, uint16_t port)
{
auto& server = Inspector::RemoteInspectorServer::singleton();
if (!server.start(address, port))
return 0;
return server.getPort().valueOr(0);
}
#endif // ENABLE(REMOTE_INSPECTOR)

42
API/JSRemoteInspectorServer.h Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright (C) 2020 Sony Interactive Entertainment Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef JSRemoteInspectorServer_h
#define JSRemoteInspectorServer_h
#include <JavaScriptCore/JSBase.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
JS_EXPORT uint16_t JSRemoteInspectorServerStart(const char* address, uint16_t port);
#ifdef __cplusplus
}
#endif
#endif /* JSRemoteInspectorServer_h */

15
API/JSRetainPtr.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2005-2018 Apple Inc. All rights reserved.
* Copyright (C) 2005-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -29,13 +29,16 @@
#pragma once
#include <JavaScriptCore/JSContextRef.h>
#include <JavaScriptCore/JSObjectRef.h>
#include <JavaScriptCore/JSStringRef.h>
#include <algorithm>
inline void JSRetain(JSStringRef string) { JSStringRetain(string); }
inline void JSRelease(JSStringRef string) { JSStringRelease(string); }
inline void JSRetain(JSClassRef context) { JSClassRetain(context); }
inline void JSRelease(JSClassRef context) { JSClassRelease(context); }
inline void JSRetain(JSGlobalContextRef context) { JSGlobalContextRetain(context); }
inline void JSRelease(JSGlobalContextRef context) { JSGlobalContextRelease(context); }
inline void JSRetain(JSStringRef string) { JSStringRetain(string); }
inline void JSRelease(JSStringRef string) { JSStringRelease(string); }
enum AdoptTag { Adopt };
@ -74,6 +77,7 @@ private:
T m_ptr { nullptr };
};
JSRetainPtr<JSClassRef> adopt(JSClassRef);
JSRetainPtr<JSStringRef> adopt(JSStringRef);
JSRetainPtr<JSGlobalContextRef> adopt(JSGlobalContextRef);
@ -82,6 +86,11 @@ template<typename T> inline JSRetainPtr<T>::JSRetainPtr(AdoptTag, T ptr)
{
}
inline JSRetainPtr<JSClassRef> adopt(JSClassRef o)
{
return JSRetainPtr<JSClassRef>(Adopt, o);
}
inline JSRetainPtr<JSStringRef> adopt(JSStringRef o)
{
return JSRetainPtr<JSStringRef>(Adopt, o);

5
API/JSScript.h
View File

@ -23,11 +23,6 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef DARLING_NONUNIFIED_BUILD
#include <JavaScriptCore/JSBase.h>
#include <JavaScriptCore/WebKitAvailability.h>
#endif
#import <JavaScriptCore/JSValue.h>
#if JSC_OBJC_API_ENABLED

103
API/JSScript.mm
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019 Apple Inc. All rights reserved.
* Copyright (C) 2019-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -40,12 +40,10 @@
#import <sys/stat.h>
#import <wtf/FileMetadata.h>
#import <wtf/FileSystem.h>
#import <wtf/SHA1.h>
#import <wtf/Scope.h>
#import <wtf/WeakObjCPtr.h>
#import <wtf/spi/darwin/DataVaultSPI.h>
#ifdef DARLING_NONUNIFIED_BUILD
#include "runtime/Completion.h"
#endif
#if JSC_OBJC_API_ENABLED
@ -73,7 +71,7 @@ static bool validateBytecodeCachePath(NSURL* cachePath, NSError** error)
URL cachePathURL([cachePath absoluteURL]);
if (!cachePathURL.isLocalFile()) {
createError([NSString stringWithFormat:@"Cache path `%@` is not a local file", static_cast<NSString *>(cachePathURL)], error);
createError([NSString stringWithFormat:@"Cache path `%@` is not a local file", static_cast<NSURL *>(cachePathURL)], error);
return false;
}
@ -129,11 +127,11 @@ static bool validateBytecodeCachePath(NSURL* cachePath, NSError** error)
URL filePathURL([filePath absoluteURL]);
if (!filePathURL.isLocalFile())
return createError([NSString stringWithFormat:@"File path %@ is not a local file", static_cast<NSString *>(filePathURL)], error);
return createError([NSString stringWithFormat:@"File path %@ is not a local file", static_cast<NSURL *>(filePathURL)], error);
bool success = false;
String systemPath = filePathURL.fileSystemPath();
FileSystem::MappedFileData fileData(systemPath, success);
FileSystem::MappedFileData fileData(systemPath, FileSystem::MappedFileMode::Shared, success);
if (!success)
return createError([NSString stringWithFormat:@"File at path %@ could not be mapped.", static_cast<NSString *>(systemPath)], error);
@ -156,30 +154,54 @@ static bool validateBytecodeCachePath(NSURL* cachePath, NSError** error)
if (!m_cachePath)
return;
int fd = open([m_cachePath path].UTF8String, O_RDONLY | O_EXLOCK | O_NONBLOCK, 0666);
if (fd == -1)
NSString *cachePathString = [m_cachePath path];
const char* cacheFilename = cachePathString.UTF8String;
auto fd = FileSystem::openAndLockFile(cacheFilename, FileSystem::FileOpenMode::Read, {FileSystem::FileLockMode::Exclusive, FileSystem::FileLockMode::Nonblocking});
if (!FileSystem::isHandleValid(fd))
return;
auto closeFD = makeScopeExit([&] {
close(fd);
FileSystem::unlockAndCloseFile(fd);
});
struct stat sb;
int res = fstat(fd, &sb);
size_t size = static_cast<size_t>(sb.st_size);
if (res || !size)
bool success;
FileSystem::MappedFileData mappedFile(fd, FileSystem::MappedFileMode::Private, success);
if (!success)
return;
void* buffer = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0);
const uint8_t* fileData = reinterpret_cast<const uint8_t*>(mappedFile.data());
unsigned fileTotalSize = mappedFile.size();
Ref<JSC::CachedBytecode> cachedBytecode = JSC::CachedBytecode::create(buffer, size);
// Ensure we at least have a SHA1::Digest to read.
if (fileTotalSize < sizeof(SHA1::Digest)) {
FileSystem::deleteFile(cacheFilename);
return;
}
JSC::VM& vm = [m_virtualMachine vm];
unsigned fileDataSize = fileTotalSize - sizeof(SHA1::Digest);
SHA1::Digest computedHash;
SHA1 sha1;
sha1.addBytes(fileData, fileDataSize);
sha1.computeHash(computedHash);
SHA1::Digest fileHash;
memcpy(&fileHash, fileData + fileDataSize, sizeof(SHA1::Digest));
if (computedHash != fileHash) {
FileSystem::deleteFile(cacheFilename);
return;
}
Ref<JSC::CachedBytecode> cachedBytecode = JSC::CachedBytecode::create(WTFMove(mappedFile));
JSC::VM& vm = *toJS([m_virtualMachine JSContextGroupRef]);
JSC::SourceCode sourceCode = [self sourceCode];
JSC::SourceCodeKey key = m_type == kJSScriptTypeProgram ? sourceCodeKeyForSerializedProgram(vm, sourceCode) : sourceCodeKeyForSerializedModule(vm, sourceCode);
if (isCachedBytecodeStillValid(vm, cachedBytecode.copyRef(), key, m_type == kJSScriptTypeProgram ? JSC::SourceCodeType::ProgramType : JSC::SourceCodeType::ModuleType))
m_cachedBytecode = WTFMove(cachedBytecode);
else
ftruncate(fd, 0);
FileSystem::truncateFile(fd, 0);
}
- (BOOL)cacheBytecodeWithError:(NSError **)error
@ -241,20 +263,22 @@ static bool validateBytecodeCachePath(NSURL* cachePath, NSError** error)
- (JSC::SourceCode)sourceCode
{
JSC::VM& vm = [m_virtualMachine vm];
JSC::VM& vm = *toJS([m_virtualMachine JSContextGroupRef]);
JSC::JSLockHolder locker(vm);
TextPosition startPosition { };
String url = String { [[self sourceURL] absoluteString] };
String filename = String { [[self sourceURL] absoluteString] };
URL url = URL({ }, filename);
auto type = m_type == kJSScriptTypeModule ? JSC::SourceProviderSourceType::Module : JSC::SourceProviderSourceType::Program;
Ref<JSScriptSourceProvider> sourceProvider = JSScriptSourceProvider::create(self, JSC::SourceOrigin(url), URL({ }, url), startPosition, type);
JSC::SourceOrigin origin(url);
Ref<JSScriptSourceProvider> sourceProvider = JSScriptSourceProvider::create(self, origin, WTFMove(filename), startPosition, type);
JSC::SourceCode sourceCode(WTFMove(sourceProvider), startPosition.m_line.oneBasedInt(), startPosition.m_column.oneBasedInt());
return sourceCode;
}
- (JSC::JSSourceCode*)jsSourceCode
{
JSC::VM& vm = [m_virtualMachine vm];
JSC::VM& vm = *toJS([m_virtualMachine JSContextGroupRef]);
JSC::JSLockHolder locker(vm);
JSC::JSSourceCode* jsSourceCode = JSC::JSSourceCode::create(vm, [self sourceCode]);
return jsSourceCode;
@ -272,33 +296,60 @@ static bool validateBytecodeCachePath(NSURL* cachePath, NSError** error)
return NO;
}
int fd = open([m_cachePath path].UTF8String, O_CREAT | O_RDWR | O_EXLOCK | O_NONBLOCK, 0666);
// We want to do the write as a transaction (i.e. we guarantee that it's all
// or nothing). So, we'll write to a temp file first, and rename the temp
// file to the cache file only after we've finished writing the whole thing.
NSString *cachePathString = [m_cachePath path];
const char* cacheFileName = cachePathString.UTF8String;
const char* tempFileName = [cachePathString stringByAppendingString:@".tmp"].UTF8String;
int fd = open(cacheFileName, O_CREAT | O_WRONLY | O_EXLOCK | O_NONBLOCK, 0600);
if (fd == -1) {
error = makeString("Could not open or lock the bytecode cache file. It's likely another VM or process is already using it. Error: ", strerror(errno));
return NO;
}
auto closeFD = makeScopeExit([&] {
close(fd);
});
int tempFD = open(tempFileName, O_CREAT | O_RDWR | O_EXLOCK | O_NONBLOCK, 0600);
if (tempFD == -1) {
error = makeString("Could not open or lock the bytecode cache temp file. Error: ", strerror(errno));
return NO;
}
auto closeTempFD = makeScopeExit([&] {
close(tempFD);
});
JSC::BytecodeCacheError cacheError;
JSC::SourceCode sourceCode = [self sourceCode];
JSC::VM& vm = *toJS([m_virtualMachine JSContextGroupRef]);
switch (m_type) {
case kJSScriptTypeModule:
m_cachedBytecode = JSC::generateModuleBytecode([m_virtualMachine vm], sourceCode, fd, cacheError);
m_cachedBytecode = JSC::generateModuleBytecode(vm, sourceCode, tempFD, cacheError);
break;
case kJSScriptTypeProgram:
m_cachedBytecode = JSC::generateProgramBytecode([m_virtualMachine vm], sourceCode, fd, cacheError);
m_cachedBytecode = JSC::generateProgramBytecode(vm, sourceCode, tempFD, cacheError);
break;
}
if (cacheError.isValid()) {
m_cachedBytecode = JSC::CachedBytecode::create();
ftruncate(fd, 0);
FileSystem::truncateFile(fd, 0);
error = makeString("Unable to generate bytecode for this JSScript because: ", cacheError.message());
return NO;
}
SHA1::Digest computedHash;
SHA1 sha1;
sha1.addBytes(m_cachedBytecode->data(), m_cachedBytecode->size());
sha1.computeHash(computedHash);
FileSystem::writeToFile(tempFD, reinterpret_cast<const char*>(&computedHash), sizeof(computedHash));
fsync(tempFD);
rename(tempFileName, cacheFileName);
return YES;
}

4
API/JSScriptInternal.h
View File

@ -23,14 +23,12 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#if JSC_OBJC_API_ENABLED
#import "JSScript.h"
#import "SourceCode.h"
#import <wtf/RefPtr.h>
#if JSC_OBJC_API_ENABLED
NS_ASSUME_NONNULL_BEGIN
namespace JSC {

54
API/JSScriptRef.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2012 Apple Inc. All rights reserved.
* Copyright (C) 2012-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -28,30 +28,28 @@
#include "APICast.h"
#include "Completion.h"
#include "Exception.h"
#include "JSBasePrivate.h"
#include "VM.h"
#include "JSGlobalObjectInlines.h"
#include "JSScriptRefPrivate.h"
#include "OpaqueJSString.h"
#include "JSCInlines.h"
#include "Parser.h"
#include "SourceCode.h"
#include "SourceProvider.h"
using namespace JSC;
struct OpaqueJSScript : public SourceProvider {
struct OpaqueJSScript final : public SourceProvider {
public:
static WTF::Ref<OpaqueJSScript> create(VM& vm, const SourceOrigin& sourceOrigin, URL&& url, int startingLineNumber, const String& source)
static WTF::Ref<OpaqueJSScript> create(VM& vm, const SourceOrigin& sourceOrigin, String filename, int startingLineNumber, const String& source)
{
return WTF::adoptRef(*new OpaqueJSScript(vm, sourceOrigin, WTFMove(url), startingLineNumber, source));
return WTF::adoptRef(*new OpaqueJSScript(vm, sourceOrigin, WTFMove(filename), startingLineNumber, source));
}
unsigned hash() const override
unsigned hash() const final
{
return m_source.get().hash();
}
StringView source() const override
StringView source() const final
{
return m_source.get();
}
@ -59,14 +57,14 @@ public:
VM& vm() const { return m_vm; }
private:
OpaqueJSScript(VM& vm, const SourceOrigin& sourceOrigin, URL&& url, int startingLineNumber, const String& source)
: SourceProvider(sourceOrigin, WTFMove(url), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()), SourceProviderSourceType::Program)
OpaqueJSScript(VM& vm, const SourceOrigin& sourceOrigin, String&& filename, int startingLineNumber, const String& source)
: SourceProvider(sourceOrigin, WTFMove(filename), TextPosition(OrdinalNumber::fromOneBasedInt(startingLineNumber), OrdinalNumber()), SourceProviderSourceType::Program)
, m_vm(vm)
, m_source(source.isNull() ? *StringImpl::empty() : *source.impl())
{
}
virtual ~OpaqueJSScript() { }
~OpaqueJSScript() final { }
VM& m_vm;
Ref<StringImpl> m_source;
@ -75,26 +73,26 @@ private:
static bool parseScript(VM& vm, const SourceCode& source, ParserError& error)
{
return !!JSC::parse<JSC::ProgramNode>(
&vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
vm, source, Identifier(), JSParserBuiltinMode::NotBuiltin,
JSParserStrictMode::NotStrict, JSParserScriptMode::Classic, SourceParseMode::ProgramMode, SuperBinding::NotNeeded,
error);
}
extern "C" {
JSScriptRef JSScriptCreateReferencingImmortalASCIIText(JSContextGroupRef contextGroup, JSStringRef url, int startingLineNumber, const char* source, size_t length, JSStringRef* errorMessage, int* errorLine)
JSScriptRef JSScriptCreateReferencingImmortalASCIIText(JSContextGroupRef contextGroup, JSStringRef urlString, int startingLineNumber, const char* source, size_t length, JSStringRef* errorMessage, int* errorLine)
{
auto& vm = *toJS(contextGroup);
JSLockHolder locker(&vm);
for (size_t i = 0; i < length; i++) {
if (!isASCII(source[i]))
return 0;
return nullptr;
}
startingLineNumber = std::max(1, startingLineNumber);
auto sourceURLString = url ? url->string() : String();
auto result = OpaqueJSScript::create(vm, SourceOrigin { sourceURLString }, URL({ }, sourceURLString), startingLineNumber, String(StringImpl::createFromLiteral(source, length)));
auto sourceURL = urlString ? URL({ }, urlString->string()) : URL();
auto result = OpaqueJSScript::create(vm, SourceOrigin { sourceURL }, sourceURL.string(), startingLineNumber, String(StringImpl::createFromLiteral(source, length)));
ParserError error;
if (!parseScript(vm, SourceCode(result.copyRef()), error)) {
@ -108,15 +106,15 @@ JSScriptRef JSScriptCreateReferencingImmortalASCIIText(JSContextGroupRef context
return &result.leakRef();
}
JSScriptRef JSScriptCreateFromString(JSContextGroupRef contextGroup, JSStringRef url, int startingLineNumber, JSStringRef source, JSStringRef* errorMessage, int* errorLine)
JSScriptRef JSScriptCreateFromString(JSContextGroupRef contextGroup, JSStringRef urlString, int startingLineNumber, JSStringRef source, JSStringRef* errorMessage, int* errorLine)
{
auto& vm = *toJS(contextGroup);
JSLockHolder locker(&vm);
startingLineNumber = std::max(1, startingLineNumber);
auto sourceURLString = url ? url->string() : String();
auto result = OpaqueJSScript::create(vm, SourceOrigin { sourceURLString }, URL({ }, sourceURLString), startingLineNumber, source->string());
auto sourceURL = urlString ? URL({ }, urlString->string()) : URL();
auto result = OpaqueJSScript::create(vm, SourceOrigin { sourceURL }, sourceURL.string(), startingLineNumber, source->string());
ParserError error;
if (!parseScript(vm, SourceCode(result.copyRef()), error)) {
@ -144,23 +142,23 @@ void JSScriptRelease(JSScriptRef script)
JSValueRef JSScriptEvaluate(JSContextRef context, JSScriptRef script, JSValueRef thisValueRef, JSValueRef* exception)
{
ExecState* exec = toJS(context);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(context);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
if (&script->vm() != &vm) {
RELEASE_ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
NakedPtr<Exception> internalException;
JSValue thisValue = thisValueRef ? toJS(exec, thisValueRef) : jsUndefined();
JSValue result = evaluate(exec, SourceCode(*script), thisValue, internalException);
JSValue thisValue = thisValueRef ? toJS(globalObject, thisValueRef) : jsUndefined();
JSValue result = evaluate(globalObject, SourceCode(*script), thisValue, internalException);
if (internalException) {
if (exception)
*exception = toRef(exec, internalException->value());
return 0;
*exception = toRef(globalObject, internalException->value());
return nullptr;
}
ASSERT(result);
return toRef(exec, result);
return toRef(globalObject, result);
}
}

13
API/JSScriptSourceProvider.h
View File

@ -23,18 +23,13 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef DARLING_NONUNIFIED_BUILD
#include <JavaScriptCore/JSBase.h>
#include <JavaScriptCore/WebKitAvailability.h>
#endif
#if JSC_OBJC_API_ENABLED
#import "SourceProvider.h"
@class JSScript;
class JSScriptSourceProvider : public JSC::SourceProvider {
class JSScriptSourceProvider final : public JSC::SourceProvider {
public:
template<typename... Args>
static Ref<JSScriptSourceProvider> create(JSScript *script, Args&&... args)
@ -42,9 +37,9 @@ public:
return adoptRef(*new JSScriptSourceProvider(script, std::forward<Args>(args)...));
}
unsigned hash() const override;
StringView source() const override;
RefPtr<JSC::CachedBytecode> cachedBytecode() const override;
unsigned hash() const final;
StringView source() const final;
RefPtr<JSC::CachedBytecode> cachedBytecode() const final;
private:
template<typename... Args>

6
API/JSStringRef.cpp
View File

@ -36,13 +36,13 @@ using namespace WTF::Unicode;
JSStringRef JSStringCreateWithCharacters(const JSChar* chars, size_t numChars)
{
initializeThreading();
JSC::initialize();
return &OpaqueJSString::create(reinterpret_cast<const UChar*>(chars), numChars).leakRef();
}
JSStringRef JSStringCreateWithUTF8CString(const char* string)
{
initializeThreading();
JSC::initialize();
if (string) {
size_t length = strlen(string);
Vector<UChar, 1024> buffer(length);
@ -61,7 +61,7 @@ JSStringRef JSStringCreateWithUTF8CString(const char* string)
JSStringRef JSStringCreateWithCharactersNoCopy(const JSChar* chars, size_t numChars)
{
initializeThreading();
JSC::initialize();
return OpaqueJSString::tryCreate(StringImpl::createWithoutCopying(reinterpret_cast<const UChar*>(chars), numChars)).leakRef();
}

2
API/JSStringRefCF.cpp
View File

@ -35,7 +35,7 @@
JSStringRef JSStringCreateWithCFString(CFStringRef string)
{
JSC::initializeThreading();
JSC::initialize();
// We cannot use CFIndex here since CFStringGetLength can return values larger than
// it can hold. (<rdar://problem/6806478>)

2
API/JSStringRefCF.h
View File

@ -26,8 +26,8 @@
#ifndef JSStringRefCF_h
#define JSStringRefCF_h
#include "JSBase.h"
#include <CoreFoundation/CoreFoundation.h>
#include <JavaScriptCore/JSBase.h>
#ifdef __cplusplus
extern "C" {

138
API/JSTypedArray.cpp
View File

@ -30,10 +30,7 @@
#include "APICast.h"
#include "APIUtils.h"
#include "ClassInfo.h"
#include "Error.h"
#include "JSArrayBufferViewInlines.h"
#include "JSCInlines.h"
#include "JSDataView.h"
#include "JSGenericTypedArrayViewInlines.h"
#include "JSTypedArrays.h"
#include "TypedArrayController.h"
@ -99,34 +96,33 @@ inline TypedArrayType toTypedArrayType(JSTypedArrayType type)
RELEASE_ASSERT_NOT_REACHED();
}
static JSObject* createTypedArray(ExecState* exec, JSTypedArrayType type, RefPtr<ArrayBuffer>&& buffer, size_t offset, size_t length)
static JSObject* createTypedArray(JSGlobalObject* globalObject, JSTypedArrayType type, RefPtr<ArrayBuffer>&& buffer, size_t offset, size_t length)
{
VM& vm = exec->vm();
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
if (!buffer) {
throwOutOfMemoryError(exec, scope);
throwOutOfMemoryError(globalObject, scope);
return nullptr;
}
switch (type) {
case kJSTypedArrayTypeInt8Array:
return JSInt8Array::create(exec, globalObject->typedArrayStructure(TypeInt8), WTFMove(buffer), offset, length);
return JSInt8Array::create(globalObject, globalObject->typedArrayStructure(TypeInt8), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeInt16Array:
return JSInt16Array::create(exec, globalObject->typedArrayStructure(TypeInt16), WTFMove(buffer), offset, length);
return JSInt16Array::create(globalObject, globalObject->typedArrayStructure(TypeInt16), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeInt32Array:
return JSInt32Array::create(exec, globalObject->typedArrayStructure(TypeInt32), WTFMove(buffer), offset, length);
return JSInt32Array::create(globalObject, globalObject->typedArrayStructure(TypeInt32), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeUint8Array:
return JSUint8Array::create(exec, globalObject->typedArrayStructure(TypeUint8), WTFMove(buffer), offset, length);
return JSUint8Array::create(globalObject, globalObject->typedArrayStructure(TypeUint8), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeUint8ClampedArray:
return JSUint8ClampedArray::create(exec, globalObject->typedArrayStructure(TypeUint8Clamped), WTFMove(buffer), offset, length);
return JSUint8ClampedArray::create(globalObject, globalObject->typedArrayStructure(TypeUint8Clamped), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeUint16Array:
return JSUint16Array::create(exec, globalObject->typedArrayStructure(TypeUint16), WTFMove(buffer), offset, length);
return JSUint16Array::create(globalObject, globalObject->typedArrayStructure(TypeUint16), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeUint32Array:
return JSUint32Array::create(exec, globalObject->typedArrayStructure(TypeUint32), WTFMove(buffer), offset, length);
return JSUint32Array::create(globalObject, globalObject->typedArrayStructure(TypeUint32), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeFloat32Array:
return JSFloat32Array::create(exec, globalObject->typedArrayStructure(TypeFloat32), WTFMove(buffer), offset, length);
return JSFloat32Array::create(globalObject, globalObject->typedArrayStructure(TypeFloat32), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeFloat64Array:
return JSFloat64Array::create(exec, globalObject->typedArrayStructure(TypeFloat64), WTFMove(buffer), offset, length);
return JSFloat64Array::create(globalObject, globalObject->typedArrayStructure(TypeFloat64), WTFMove(buffer), offset, length);
case kJSTypedArrayTypeArrayBuffer:
case kJSTypedArrayTypeNone:
RELEASE_ASSERT_NOT_REACHED();
@ -139,11 +135,11 @@ static JSObject* createTypedArray(ExecState* exec, JSTypedArrayType type, RefPtr
JSTypedArrayType JSValueGetTypedArrayType(JSContextRef ctx, JSValueRef valueRef, JSValueRef*)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSValue value = toJS(exec, valueRef);
JSValue value = toJS(globalObject, valueRef);
if (!value.isObject())
return kJSTypedArrayTypeNone;
JSObject* object = value.getObject();
@ -156,8 +152,8 @@ JSTypedArrayType JSValueGetTypedArrayType(JSContextRef ctx, JSValueRef valueRef,
JSObjectRef JSObjectMakeTypedArray(JSContextRef ctx, JSTypedArrayType arrayType, size_t length, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
@ -167,16 +163,16 @@ JSObjectRef JSObjectMakeTypedArray(JSContextRef ctx, JSTypedArrayType arrayType,
unsigned elementByteSize = elementSize(toTypedArrayType(arrayType));
auto buffer = ArrayBuffer::tryCreate(length, elementByteSize);
JSObject* result = createTypedArray(exec, arrayType, WTFMove(buffer), 0, length);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
JSObject* result = createTypedArray(globalObject, arrayType, WTFMove(buffer), 0, length);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(result);
}
JSObjectRef JSObjectMakeTypedArrayWithBytesNoCopy(JSContextRef ctx, JSTypedArrayType arrayType, void* bytes, size_t length, JSTypedArrayBytesDeallocator destructor, void* destructorContext, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
@ -185,20 +181,20 @@ JSObjectRef JSObjectMakeTypedArrayWithBytesNoCopy(JSContextRef ctx, JSTypedArray
unsigned elementByteSize = elementSize(toTypedArrayType(arrayType));
auto buffer = ArrayBuffer::createFromBytes(bytes, length, [=](void* p) {
auto buffer = ArrayBuffer::createFromBytes(bytes, length, createSharedTask<void(void*)>([=](void* p) {
if (destructor)
destructor(p, destructorContext);
});
JSObject* result = createTypedArray(exec, arrayType, WTFMove(buffer), 0, length / elementByteSize);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
}));
JSObject* result = createTypedArray(globalObject, arrayType, WTFMove(buffer), 0, length / elementByteSize);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(result);
}
JSObjectRef JSObjectMakeTypedArrayWithArrayBuffer(JSContextRef ctx, JSTypedArrayType arrayType, JSObjectRef jsBufferRef, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
@ -207,23 +203,23 @@ JSObjectRef JSObjectMakeTypedArrayWithArrayBuffer(JSContextRef ctx, JSTypedArray
JSArrayBuffer* jsBuffer = jsDynamicCast<JSArrayBuffer*>(vm, toJS(jsBufferRef));
if (!jsBuffer) {
setException(exec, exception, createTypeError(exec, "JSObjectMakeTypedArrayWithArrayBuffer expects buffer to be an Array Buffer object"));
setException(ctx, exception, createTypeError(globalObject, "JSObjectMakeTypedArrayWithArrayBuffer expects buffer to be an Array Buffer object"));
return nullptr;
}
RefPtr<ArrayBuffer> buffer = jsBuffer->impl();
unsigned elementByteSize = elementSize(toTypedArrayType(arrayType));
JSObject* result = createTypedArray(exec, arrayType, WTFMove(buffer), 0, buffer->byteLength() / elementByteSize);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
JSObject* result = createTypedArray(globalObject, arrayType, WTFMove(buffer), 0, buffer->byteLength() / elementByteSize);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(result);
}
JSObjectRef JSObjectMakeTypedArrayWithArrayBufferAndOffset(JSContextRef ctx, JSTypedArrayType arrayType, JSObjectRef jsBufferRef, size_t offset, size_t length, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
@ -232,35 +228,38 @@ JSObjectRef JSObjectMakeTypedArrayWithArrayBufferAndOffset(JSContextRef ctx, JST
JSArrayBuffer* jsBuffer = jsDynamicCast<JSArrayBuffer*>(vm, toJS(jsBufferRef));
if (!jsBuffer) {
setException(exec, exception, createTypeError(exec, "JSObjectMakeTypedArrayWithArrayBuffer expects buffer to be an Array Buffer object"));
setException(ctx, exception, createTypeError(globalObject, "JSObjectMakeTypedArrayWithArrayBuffer expects buffer to be an Array Buffer object"));
return nullptr;
}
JSObject* result = createTypedArray(exec, arrayType, jsBuffer->impl(), offset, length);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
JSObject* result = createTypedArray(globalObject, arrayType, jsBuffer->impl(), offset, length);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(result);
}
void* JSObjectGetTypedArrayBytesPtr(JSContextRef ctx, JSObjectRef objectRef, JSValueRef*)
void* JSObjectGetTypedArrayBytesPtr(JSContextRef ctx, JSObjectRef objectRef, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* object = toJS(objectRef);
if (JSArrayBufferView* typedArray = jsDynamicCast<JSArrayBufferView*>(vm, object)) {
ArrayBuffer* buffer = typedArray->possiblySharedBuffer();
buffer->pinAndLock();
return buffer->data();
if (ArrayBuffer* buffer = typedArray->possiblySharedBuffer()) {
buffer->pinAndLock();
return buffer->data();
}
setException(ctx, exception, createOutOfMemoryError(globalObject));
}
return nullptr;
}
size_t JSObjectGetTypedArrayLength(JSContextRef ctx, JSObjectRef objectRef, JSValueRef*)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSObject* object = toJS(objectRef);
if (JSArrayBufferView* typedArray = jsDynamicCast<JSArrayBufferView*>(vm, object))
@ -271,8 +270,8 @@ size_t JSObjectGetTypedArrayLength(JSContextRef ctx, JSObjectRef objectRef, JSVa
size_t JSObjectGetTypedArrayByteLength(JSContextRef ctx, JSObjectRef objectRef, JSValueRef*)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSObject* object = toJS(objectRef);
if (JSArrayBufferView* typedArray = jsDynamicCast<JSArrayBufferView*>(vm, object))
@ -283,8 +282,8 @@ size_t JSObjectGetTypedArrayByteLength(JSContextRef ctx, JSObjectRef objectRef,
size_t JSObjectGetTypedArrayByteOffset(JSContextRef ctx, JSObjectRef objectRef, JSValueRef*)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSObject* object = toJS(objectRef);
if (JSArrayBufferView* typedArray = jsDynamicCast<JSArrayBufferView*>(vm, object))
@ -293,33 +292,38 @@ size_t JSObjectGetTypedArrayByteOffset(JSContextRef ctx, JSObjectRef objectRef,
return 0;
}
JSObjectRef JSObjectGetTypedArrayBuffer(JSContextRef ctx, JSObjectRef objectRef, JSValueRef*)
JSObjectRef JSObjectGetTypedArrayBuffer(JSContextRef ctx, JSObjectRef objectRef, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* object = toJS(objectRef);
if (JSArrayBufferView* typedArray = jsDynamicCast<JSArrayBufferView*>(vm, object))
return toRef(vm.m_typedArrayController->toJS(exec, typedArray->globalObject(vm), typedArray->possiblySharedBuffer()));
if (JSArrayBufferView* typedArray = jsDynamicCast<JSArrayBufferView*>(vm, object)) {
if (ArrayBuffer* buffer = typedArray->possiblySharedBuffer())
return toRef(vm.m_typedArrayController->toJS(globalObject, typedArray->globalObject(vm), buffer));
setException(ctx, exception, createOutOfMemoryError(globalObject));
}
return nullptr;
}
JSObjectRef JSObjectMakeArrayBufferWithBytesNoCopy(JSContextRef ctx, void* bytes, size_t byteLength, JSTypedArrayBytesDeallocator bytesDeallocator, void* deallocatorContext, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
auto buffer = ArrayBuffer::createFromBytes(bytes, byteLength, [=](void* p) {
auto buffer = ArrayBuffer::createFromBytes(bytes, byteLength, createSharedTask<void(void*)>([=](void* p) {
if (bytesDeallocator)
bytesDeallocator(p, deallocatorContext);
});
}));
JSArrayBuffer* jsBuffer = JSArrayBuffer::create(vm, exec->lexicalGlobalObject()->arrayBufferStructure(ArrayBufferSharingMode::Default), WTFMove(buffer));
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
JSArrayBuffer* jsBuffer = JSArrayBuffer::create(vm, globalObject->arrayBufferStructure(ArrayBufferSharingMode::Default), WTFMove(buffer));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return toRef(jsBuffer);
@ -327,15 +331,15 @@ JSObjectRef JSObjectMakeArrayBufferWithBytesNoCopy(JSContextRef ctx, void* bytes
void* JSObjectGetArrayBufferBytesPtr(JSContextRef ctx, JSObjectRef objectRef, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* object = toJS(objectRef);
if (JSArrayBuffer* jsBuffer = jsDynamicCast<JSArrayBuffer*>(vm, object)) {
ArrayBuffer* buffer = jsBuffer->impl();
if (buffer->isWasmMemory()) {
setException(exec, exception, createTypeError(exec, "Cannot get the backing buffer for a WebAssembly.Memory"_s));
setException(ctx, exception, createTypeError(globalObject, "Cannot get the backing buffer for a WebAssembly.Memory"_s));
return nullptr;
}
@ -347,8 +351,8 @@ void* JSObjectGetArrayBufferBytesPtr(JSContextRef ctx, JSObjectRef objectRef, JS
size_t JSObjectGetArrayBufferByteLength(JSContextRef ctx, JSObjectRef objectRef, JSValueRef*)
{
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSObject* object = toJS(objectRef);
if (JSArrayBuffer* jsBuffer = jsDynamicCast<JSArrayBuffer*>(vm, object))

5
API/JSValue.h
View File

@ -26,11 +26,6 @@
#ifndef JSValue_h
#define JSValue_h
#ifdef DARLING_NONUNIFIED_BUILD
#include <JavaScriptCore/JSBase.h>
#include <JavaScriptCore/WebKitAvailability.h>
#endif
#if JSC_OBJC_API_ENABLED
#import <CoreGraphics/CGGeometry.h>

82
API/JSValue.mm
View File

@ -23,7 +23,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#import "config.h"
#import "APICast.h"
#import "DateInstance.h"
@ -36,11 +36,8 @@
#import "JSValueInternal.h"
#import "JSValuePrivate.h"
#import "JSWrapperMap.h"
#ifdef DARLING
#import "ObjCRuntimeExtras.h"
#else
#import "MarkedJSValueRefArray.h"
#import "ObjcRuntimeExtras.h"
#endif
#import "JSCInlines.h"
#import "JSCJSValue.h"
#import "Strong.h"
@ -49,7 +46,6 @@
#import <wtf/HashMap.h>
#import <wtf/HashSet.h>
#import <wtf/Lock.h>
#import <wtf/ObjCRuntimeExtras.h>
#import <wtf/Vector.h>
#import <wtf/text/WTFString.h>
#import <wtf/text/StringHash.h>
@ -402,37 +398,65 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
- (BOOL)isUndefined
{
#if !CPU(ADDRESS64)
return JSValueIsUndefined([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isUndefined();
#endif
}
- (BOOL)isNull
{
#if !CPU(ADDRESS64)
return JSValueIsNull([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isNull();
#endif
}
- (BOOL)isBoolean
{
#if !CPU(ADDRESS64)
return JSValueIsBoolean([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isBoolean();
#endif
}
- (BOOL)isNumber
{
#if !CPU(ADDRESS64)
return JSValueIsNumber([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isNumber();
#endif
}
- (BOOL)isString
{
#if !CPU(ADDRESS64)
return JSValueIsString([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isString();
#endif
}
- (BOOL)isObject
{
#if !CPU(ADDRESS64)
return JSValueIsObject([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isObject();
#endif
}
- (BOOL)isSymbol
{
#if !CPU(ADDRESS64)
return JSValueIsSymbol([_context JSGlobalContextRef], m_value);
#else
return toJS(m_value).isSymbol();
#endif
}
- (BOOL)isArray
@ -476,8 +500,12 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
- (JSValue *)callWithArguments:(NSArray *)argumentArray
{
JSC::JSGlobalObject* globalObject = toJS([_context JSGlobalContextRef]);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
NSUInteger argumentCount = [argumentArray count];
JSValueRef arguments[argumentCount];
JSC::MarkedJSValueRefArray arguments([_context JSGlobalContextRef], argumentCount);
for (unsigned i = 0; i < argumentCount; ++i)
arguments[i] = objectToValue(_context, [argumentArray objectAtIndex:i]);
@ -486,7 +514,7 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
if (exception)
return [_context valueFromNotifyException:exception];
JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, 0, argumentCount, arguments, &exception);
JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, 0, argumentCount, arguments.data(), &exception);
if (exception)
return [_context valueFromNotifyException:exception];
@ -495,8 +523,12 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
- (JSValue *)constructWithArguments:(NSArray *)argumentArray
{
JSC::JSGlobalObject* globalObject = toJS([_context JSGlobalContextRef]);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
NSUInteger argumentCount = [argumentArray count];
JSValueRef arguments[argumentCount];
JSC::MarkedJSValueRefArray arguments([_context JSGlobalContextRef], argumentCount);
for (unsigned i = 0; i < argumentCount; ++i)
arguments[i] = objectToValue(_context, [argumentArray objectAtIndex:i]);
@ -505,7 +537,7 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
if (exception)
return [_context valueFromNotifyException:exception];
JSObjectRef result = JSObjectCallAsConstructor([_context JSGlobalContextRef], object, argumentCount, arguments, &exception);
JSObjectRef result = JSObjectCallAsConstructor([_context JSGlobalContextRef], object, argumentCount, arguments.data(), &exception);
if (exception)
return [_context valueFromNotifyException:exception];
@ -514,8 +546,12 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
- (JSValue *)invokeMethod:(NSString *)method withArguments:(NSArray *)arguments
{
JSC::JSGlobalObject* globalObject = toJS([_context JSGlobalContextRef]);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
NSUInteger argumentCount = [arguments count];
JSValueRef argumentArray[argumentCount];
JSC::MarkedJSValueRefArray argumentArray([_context JSGlobalContextRef], argumentCount);
for (unsigned i = 0; i < argumentCount; ++i)
argumentArray[i] = objectToValue(_context, [arguments objectAtIndex:i]);
@ -533,7 +569,7 @@ inline Expected<Result, JSValueRef> performPropertyOperation(NSStringFunction st
if (exception)
return [_context valueFromNotifyException:exception];
JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, thisObject, argumentCount, argumentArray, &exception);
JSValueRef result = JSObjectCallAsFunction([_context JSGlobalContextRef], object, thisObject, argumentCount, argumentArray.data(), &exception);
if (exception)
return [_context valueFromNotifyException:exception];
@ -695,8 +731,8 @@ inline id JSContainerConvertor::convert(JSValueRef value)
void JSContainerConvertor::add(Task task)
{
JSC::ExecState* exec = toJS(m_context);
m_jsValues.append(JSC::Strong<JSC::Unknown>(exec->vm(), toJSForGC(exec, task.js)));
JSC::JSGlobalObject* globalObject = toJS(m_context);
m_jsValues.append(JSC::Strong<JSC::Unknown>(globalObject->vm(), toJSForGC(globalObject, task.js)));
m_objectMap.add(task.js, task.objc);
if (task.type != ContainerNone)
m_worklist.append(task);
@ -713,17 +749,17 @@ JSContainerConvertor::Task JSContainerConvertor::take()
#if ENABLE(REMOTE_INSPECTOR)
static void reportExceptionToInspector(JSGlobalContextRef context, JSC::JSValue exceptionValue)
{
JSC::ExecState* exec = toJS(context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(context);
JSC::VM& vm = globalObject->vm();
JSC::Exception* exception = JSC::Exception::create(vm, exceptionValue);
vm.vmEntryGlobalObject(exec)->inspectorController().reportAPIException(exec, exception);
globalObject->inspectorController().reportAPIException(globalObject, exception);
}
#endif
static JSContainerConvertor::Task valueToObjectWithoutCopy(JSGlobalContextRef context, JSValueRef value)
{
JSC::ExecState* exec = toJS(context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(context);
JSC::VM& vm = globalObject->vm();
if (!JSValueIsObject(context, value)) {
id primitive;
@ -733,7 +769,7 @@ static JSContainerConvertor::Task valueToObjectWithoutCopy(JSGlobalContextRef co
// 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)];
primitive = @(JSValueToNumber(context, value, 0));
} else if (JSValueIsString(context, value)) {
// Would be nice to unique strings, too.
auto jsstring = adoptRef(JSValueToStringCopy(context, value, 0));
@ -828,7 +864,7 @@ id valueToNumber(JSGlobalContextRef context, JSValueRef value, JSValueRef* excep
return JSValueToBoolean(context, value) ? @YES : @NO;
double result = JSValueToNumber(context, value, exception);
return [NSNumber numberWithDouble:*exception ? std::numeric_limits<double>::quiet_NaN() : result];
return @(*exception ? std::numeric_limits<double>::quiet_NaN() : result);
}
id valueToString(JSGlobalContextRef context, JSValueRef value, JSValueRef* exception)
@ -944,8 +980,8 @@ JSValueRef ObjcContainerConvertor::convert(id object)
void ObjcContainerConvertor::add(ObjcContainerConvertor::Task task)
{
JSC::ExecState* exec = toJS(m_context.JSGlobalContextRef);
m_jsValues.append(JSC::Strong<JSC::Unknown>(exec->vm(), toJSForGC(exec, task.js)));
JSC::JSGlobalObject* globalObject = toJS(m_context.JSGlobalContextRef);
m_jsValues.append(JSC::Strong<JSC::Unknown>(globalObject->vm(), toJSForGC(globalObject, task.js)));
m_objectMap.add(task.objc, task.js);
if (task.type != ContainerNone)
m_worklist.append(task);

317
API/JSValueRef.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006, 2007, 2016 Apple Inc. All rights reserved.
* Copyright (C) 2006-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -29,20 +29,13 @@
#include "APICast.h"
#include "APIUtils.h"
#include "DateInstance.h"
#include "Exception.h"
#include "JSAPIWrapperObject.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSCallbackObject.h"
#include "JSGlobalObject.h"
#include "JSONObject.h"
#include "JSObjectRefPrivate.h"
#include "JSString.h"
#include "LiteralParser.h"
#include "Protect.h"
#include <algorithm>
#include <wtf/Assertions.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>
#if PLATFORM(MAC)
@ -61,14 +54,17 @@ using namespace JSC;
ASSERT_NOT_REACHED();
return kJSTypeUndefined;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSValue jsValue = toJS(exec, value);
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
JSValue jsValue = toJS(globalObject, value);
#else
JSValue jsValue = toJS(value);
#endif
if (jsValue.isUndefined())
return kJSTypeUndefined;
if (jsValue.isNull())
if (!jsValue || jsValue.isNull())
return kJSTypeNull;
if (jsValue.isBoolean())
return kJSTypeBoolean;
@ -88,10 +84,13 @@ bool JSValueIsUndefined(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isUndefined();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isUndefined();
#else
return toJS(value).isUndefined();
#endif
}
bool JSValueIsNull(JSContextRef ctx, JSValueRef value)
@ -100,10 +99,14 @@ bool JSValueIsNull(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isNull();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isNull();
#else
return !value || toJS(value).isNull();
#endif
}
bool JSValueIsBoolean(JSContextRef ctx, JSValueRef value)
@ -112,10 +115,13 @@ bool JSValueIsBoolean(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isBoolean();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isBoolean();
#else
return toJS(value).isBoolean();
#endif
}
bool JSValueIsNumber(JSContextRef ctx, JSValueRef value)
@ -124,10 +130,13 @@ bool JSValueIsNumber(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isNumber();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isNumber();
#else
return toJS(value).isNumber();
#endif
}
bool JSValueIsString(JSContextRef ctx, JSValueRef value)
@ -136,10 +145,13 @@ bool JSValueIsString(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isString();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isString();
#else
return value && toJS(value).isString();
#endif
}
bool JSValueIsObject(JSContextRef ctx, JSValueRef value)
@ -148,10 +160,13 @@ bool JSValueIsObject(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isObject();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isObject();
#else
return value && toJS(value).isObject();
#endif
}
bool JSValueIsSymbol(JSContextRef ctx, JSValueRef value)
@ -160,10 +175,13 @@ bool JSValueIsSymbol(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toJS(exec, value).isSymbol();
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toJS(globalObject, value).isSymbol();
#else
return value && toJS(value).isSymbol();
#endif
}
bool JSValueIsArray(JSContextRef ctx, JSValueRef value)
@ -172,11 +190,11 @@ bool JSValueIsArray(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(globalObject);
return toJS(exec, value).inherits<JSArray>(vm);
return toJS(globalObject, value).inherits<JSArray>(vm);
}
bool JSValueIsDate(JSContextRef ctx, JSValueRef value)
@ -185,11 +203,11 @@ bool JSValueIsDate(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(globalObject);
return toJS(exec, value).inherits<DateInstance>(vm);
return toJS(globalObject, value).inherits<DateInstance>(vm);
}
bool JSValueIsObjectOfClass(JSContextRef ctx, JSValueRef value, JSClassRef jsClass)
@ -198,11 +216,11 @@ bool JSValueIsObjectOfClass(JSContextRef ctx, JSValueRef value, JSClassRef jsCla
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(globalObject);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
if (JSObject* o = jsValue.getObject()) {
if (o->inherits<JSProxy>(vm))
@ -210,8 +228,8 @@ bool JSValueIsObjectOfClass(JSContextRef ctx, JSValueRef value, JSClassRef jsCla
if (o->inherits<JSCallbackObject<JSGlobalObject>>(vm))
return jsCast<JSCallbackObject<JSGlobalObject>*>(o)->inherits(jsClass);
if (o->inherits<JSCallbackObject<JSDestructibleObject>>(vm))
return jsCast<JSCallbackObject<JSDestructibleObject>*>(o)->inherits(jsClass);
if (o->inherits<JSCallbackObject<JSNonFinalObject>>(vm))
return jsCast<JSCallbackObject<JSNonFinalObject>*>(o)->inherits(jsClass);
#if JSC_OBJC_API_ENABLED
if (o->inherits<JSCallbackObject<JSAPIWrapperObject>>(vm))
return jsCast<JSCallbackObject<JSAPIWrapperObject>*>(o)->inherits(jsClass);
@ -226,16 +244,17 @@ bool JSValueIsEqual(JSContextRef ctx, JSValueRef a, JSValueRef b, JSValueRef* ex
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue jsA = toJS(exec, a);
JSValue jsB = toJS(exec, b);
JSValue jsA = toJS(globalObject, a);
JSValue jsB = toJS(globalObject, b);
bool result = JSValue::equal(exec, jsA, jsB); // false if an exception is thrown
handleExceptionIfNeeded(scope, exec, exception);
bool result = JSValue::equal(globalObject, jsA, jsB); // false if an exception is thrown
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
return result;
}
@ -246,13 +265,13 @@ bool JSValueIsStrictEqual(JSContextRef ctx, JSValueRef a, JSValueRef b)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
JSValue jsA = toJS(exec, a);
JSValue jsB = toJS(exec, b);
JSValue jsA = toJS(globalObject, a);
JSValue jsB = toJS(globalObject, b);
return JSValue::strictEqual(exec, jsA, jsB);
return JSValue::strictEqual(globalObject, jsA, jsB);
}
bool JSValueIsInstanceOfConstructor(JSContextRef ctx, JSValueRef value, JSObjectRef constructor, JSValueRef* exception)
@ -261,18 +280,19 @@ bool JSValueIsInstanceOfConstructor(JSContextRef ctx, JSValueRef value, JSObject
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
JSObject* jsConstructor = toJS(constructor);
if (!jsConstructor->structure(vm)->typeInfo().implementsHasInstance())
return false;
bool result = jsConstructor->hasInstance(exec, jsValue); // false if an exception is thrown
handleExceptionIfNeeded(scope, exec, exception);
bool result = jsConstructor->hasInstance(globalObject, jsValue); // false if an exception is thrown
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return false;
return result;
}
@ -280,48 +300,60 @@ JSValueRef JSValueMakeUndefined(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toRef(exec, jsUndefined());
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toRef(globalObject, jsUndefined());
#else
return toRef(jsUndefined());
#endif
}
JSValueRef JSValueMakeNull(JSContextRef ctx)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toRef(exec, jsNull());
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toRef(globalObject, jsNull());
#else
return toRef(jsNull());
#endif
}
JSValueRef JSValueMakeBoolean(JSContextRef ctx, bool value)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toRef(exec, jsBoolean(value));
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toRef(globalObject, jsBoolean(value));
#else
return toRef(jsBoolean(value));
#endif
}
JSValueRef JSValueMakeNumber(JSContextRef ctx, double value)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
return toRef(exec, jsNumber(purifyNaN(value)));
#if !CPU(ADDRESS64)
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toRef(globalObject, jsNumber(purifyNaN(value)));
#else
return toRef(jsNumber(purifyNaN(value)));
#endif
}
JSValueRef JSValueMakeSymbol(JSContextRef ctx, JSStringRef description)
@ -330,62 +362,63 @@ JSValueRef JSValueMakeSymbol(JSContextRef ctx, JSStringRef description)
ASSERT_NOT_REACHED();
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(globalObject);
if (!description)
return toRef(exec, Symbol::create(vm));
return toRef(exec, Symbol::createWithDescription(vm, description->string()));
return toRef(globalObject, Symbol::create(vm));
return toRef(globalObject, Symbol::createWithDescription(vm, description->string()));
}
JSValueRef JSValueMakeString(JSContextRef ctx, JSStringRef string)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
return toRef(exec, jsString(exec, string ? string->string() : String()));
return toRef(globalObject, jsString(vm, string ? string->string() : String()));
}
JSValueRef JSValueMakeFromJSONString(JSContextRef ctx, JSStringRef string)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
String str = string->string();
unsigned length = str.length();
if (!length || str.is8Bit()) {
LiteralParser<LChar> parser(exec, str.characters8(), length, StrictJSON);
return toRef(exec, parser.tryLiteralParse());
LiteralParser<LChar> parser(globalObject, str.characters8(), length, StrictJSON);
return toRef(globalObject, parser.tryLiteralParse());
}
LiteralParser<UChar> parser(exec, str.characters16(), length, StrictJSON);
return toRef(exec, parser.tryLiteralParse());
LiteralParser<UChar> parser(globalObject, str.characters16(), length, StrictJSON);
return toRef(globalObject, parser.tryLiteralParse());
}
JSStringRef JSValueCreateJSONString(JSContextRef ctx, JSValueRef apiValue, unsigned indent, JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue value = toJS(exec, apiValue);
String result = JSONStringify(exec, value, indent);
JSValue value = toJS(globalObject, apiValue);
String result = JSONStringify(globalObject, value, indent);
if (exception)
*exception = 0;
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
return 0;
*exception = nullptr;
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
return nullptr;
return OpaqueJSString::tryCreate(result).leakRef();
}
@ -395,11 +428,11 @@ bool JSValueToBoolean(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return false;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
JSValue jsValue = toJS(exec, value);
return jsValue.toBoolean(exec);
JSValue jsValue = toJS(globalObject, value);
return jsValue.toBoolean(globalObject);
}
double JSValueToNumber(JSContextRef ctx, JSValueRef value, JSValueRef* exception)
@ -408,15 +441,15 @@ double JSValueToNumber(JSContextRef ctx, JSValueRef value, JSValueRef* exception
ASSERT_NOT_REACHED();
return PNaN;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
double number = jsValue.toNumber(exec);
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
double number = jsValue.toNumber(globalObject);
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
number = PNaN;
return number;
}
@ -425,17 +458,17 @@ JSStringRef JSValueToStringCopy(JSContextRef ctx, JSValueRef value, JSValueRef*
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
auto stringRef(OpaqueJSString::tryCreate(jsValue.toWTFString(exec)));
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
auto stringRef(OpaqueJSString::tryCreate(jsValue.toWTFString(globalObject)));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
stringRef = nullptr;
return stringRef.leakRef();
}
@ -444,18 +477,18 @@ JSObjectRef JSValueToObject(JSContextRef ctx, JSValueRef value, JSValueRef* exce
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSValue jsValue = toJS(exec, value);
JSValue jsValue = toJS(globalObject, value);
JSObjectRef objectRef = toRef(jsValue.toObject(exec));
if (handleExceptionIfNeeded(scope, exec, exception) == ExceptionStatus::DidThrow)
objectRef = 0;
JSObjectRef objectRef = toRef(jsValue.toObject(globalObject));
if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
objectRef = nullptr;
return objectRef;
}
@ -465,18 +498,18 @@ void JSValueProtect(JSContextRef ctx, JSValueRef value)
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
JSValue jsValue = toJSForGC(exec, value);
JSValue jsValue = toJSForGC(globalObject, value);
gcProtect(jsValue);
}
void JSValueUnprotect(JSContextRef ctx, JSValueRef value)
{
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
JSValue jsValue = toJSForGC(exec, value);
JSValue jsValue = toJSForGC(globalObject, value);
gcUnprotect(jsValue);
}

24
API/JSVirtualMachine.mm
View File

@ -23,7 +23,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#import "config.h"
#import "JavaScriptCore.h"
@ -40,6 +40,7 @@
#import <mutex>
#import <wtf/BlockPtr.h>
#import <wtf/Lock.h>
#import <wtf/RetainPtr.h>
static NSMapTable *globalWrapperCache = 0;
@ -69,13 +70,13 @@ static NSMapTable *wrapperCache()
+ (void)addWrapper:(JSVirtualMachine *)wrapper forJSContextGroupRef:(JSContextGroupRef)group
{
std::lock_guard<Lock> lock(wrapperCacheMutex);
auto locker = holdLock(wrapperCacheMutex);
NSMapInsert(wrapperCache(), group, (__bridge void*)wrapper);
}
+ (JSVirtualMachine *)wrapperForJSContextGroupRef:(JSContextGroupRef)group
{
std::lock_guard<Lock> lock(wrapperCacheMutex);
auto locker = holdLock(wrapperCacheMutex);
return (__bridge JSVirtualMachine *)NSMapGet(wrapperCache(), group);
}
@ -180,17 +181,17 @@ static id getInternalObjcObject(id object)
[self addExternalRememberedObject:owner];
auto externalDataMutexLocker = holdLock(m_externalDataMutex);
NSMapTable *ownedObjects = [m_externalObjectGraph objectForKey:owner];
RetainPtr<NSMapTable> ownedObjects = [m_externalObjectGraph objectForKey:owner];
if (!ownedObjects) {
NSPointerFunctionsOptions weakIDOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
NSPointerFunctionsOptions integerOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsIntegerPersonality;
ownedObjects = [[NSMapTable alloc] initWithKeyOptions:weakIDOptions valueOptions:integerOptions capacity:1];
ownedObjects = adoptNS([[NSMapTable alloc] initWithKeyOptions:weakIDOptions valueOptions:integerOptions capacity:1]);
[m_externalObjectGraph setObject:ownedObjects forKey:owner];
[m_externalObjectGraph setObject:ownedObjects.get() forKey:owner];
}
size_t count = reinterpret_cast<size_t>(NSMapGet(ownedObjects, (__bridge void*)object));
NSMapInsert(ownedObjects, (__bridge void*)object, reinterpret_cast<void*>(count + 1));
size_t count = reinterpret_cast<size_t>(NSMapGet(ownedObjects.get(), (__bridge void*)object));
NSMapInsert(ownedObjects.get(), (__bridge void*)object, reinterpret_cast<void*>(count + 1));
}
- (void)removeManagedReference:(id)object withOwner:(id)owner
@ -297,14 +298,15 @@ JSContextGroupRef getGroupFromVirtualMachine(JSVirtualMachine *virtualMachine)
#endif // ENABLE(DFG_JIT)
- (JSC::VM&)vm
- (JSContextGroupRef)JSContextGroupRef
{
return *toJS(m_group);
return m_group;
}
- (BOOL)isWebThreadAware
{
return [self vm].apiLock().isWebThreadAware();
JSC::VM* vm = toJS(m_group);
return vm->apiLock().isWebThreadAware();
}
+ (void)setCrashOnVMCreation:(BOOL)shouldCrash

4
API/JSVirtualMachineInternal.h
View File

@ -46,10 +46,10 @@ JSContextGroupRef getGroupFromVirtualMachine(JSVirtualMachine *);
- (JSContext *)contextForGlobalContextRef:(JSGlobalContextRef)globalContext;
- (void)addContext:(JSContext *)wrapper forGlobalContextRef:(JSGlobalContextRef)globalContext;
- (JSC::VM&)vm;
- (BOOL)isWebThreadAware;
@property (readonly) JSContextGroupRef JSContextGroupRef;
@end
#endif // defined(__OBJC__)

4
API/JSVirtualMachinePrivate.h
View File

@ -23,8 +23,8 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "JSExportMacros.h"
#include <JavaScriptCore/JavaScript.h>
#import "JSExportMacros.h"
#import <JavaScriptCore/JavaScript.h>
#if JSC_OBJC_API_ENABLED

25
API/JSWeakObjectMapRefPrivate.cpp
View File

@ -27,11 +27,8 @@
#include "JSWeakObjectMapRefPrivate.h"
#include "APICast.h"
#include "JSCJSValue.h"
#include "JSCallbackObject.h"
#include "JSWeakObjectMapRefInternal.h"
#include "JSCInlines.h"
#include "Weak.h"
#include "WeakGCMapInlines.h"
using namespace JSC;
@ -42,11 +39,11 @@ extern "C" {
JSWeakObjectMapRef JSWeakObjectMapCreate(JSContextRef context, void* privateData, JSWeakMapDestroyedCallback callback)
{
ExecState* exec = toJS(context);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(context);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto map = OpaqueJSWeakObjectMap::create(vm, privateData, callback);
exec->lexicalGlobalObject()->registerWeakMap(map.ptr());
globalObject->registerWeakMap(map.ptr());
return map.ptr();
}
@ -56,15 +53,15 @@ void JSWeakObjectMapSet(JSContextRef ctx, JSWeakObjectMapRef map, void* key, JSO
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(ctx);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
JSObject* obj = toJS(object);
if (!obj)
return;
ASSERT(obj->inherits<JSProxy>(vm)
|| obj->inherits<JSCallbackObject<JSGlobalObject>>(vm)
|| obj->inherits<JSCallbackObject<JSDestructibleObject>>(vm));
|| obj->inherits<JSCallbackObject<JSNonFinalObject>>(vm));
map->map().set(key, obj);
}
@ -72,10 +69,10 @@ JSObjectRef JSWeakObjectMapGet(JSContextRef ctx, JSWeakObjectMapRef map, void* k
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
return nullptr;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
return toRef(jsCast<JSObject*>(map->map().get(key)));
}
@ -85,8 +82,8 @@ void JSWeakObjectMapRemove(JSContextRef ctx, JSWeakObjectMapRef map, void* key)
ASSERT_NOT_REACHED();
return;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSGlobalObject* globalObject = toJS(ctx);
JSLockHolder locker(globalObject);
map->map().remove(key);
}

1
API/JSWeakPrivate.cpp
View File

@ -27,7 +27,6 @@
#include "JSWeakPrivate.h"
#include "APICast.h"
#include "JSCInlines.h"
#include "Weak.h"
#include <wtf/ThreadSafeRefCounted.h>

1
API/JSWeakValue.cpp
View File

@ -28,7 +28,6 @@
#include "JSWeakValue.h"
#include "JSCInlines.h"
#include "WeakHandleOwner.h"
namespace JSC {

72
API/JSWrapperMap.mm
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013-2015, 2017 Apple Inc. All rights reserved.
* Copyright (C) 2013-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -23,7 +23,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#import "config.h"
#import "JavaScriptCore.h"
#if JSC_OBJC_API_ENABLED
@ -35,26 +35,25 @@
#import "JSContextInternal.h"
#import "JSWrapperMap.h"
#import "ObjCCallbackFunction.h"
#ifdef DARLING
#import "ObjCRuntimeExtras.h"
#else
#import "ObjcRuntimeExtras.h"
#endif
#import "ObjectConstructor.h"
#import "WeakGCMap.h"
#import "WeakGCMapInlines.h"
#import <wtf/Vector.h>
#import <wtf/spi/darwin/dyldSPI.h>
#include <mach-o/dyld.h>
#if PLATFORM(COCOA)
#import <wtf/cocoa/RuntimeApplicationChecksCocoa.h>
#endif
#import <mach-o/dyld.h>
#if PLATFORM(APPLETV)
#else
static const int32_t firstJavaScriptCoreVersionWithInitConstructorSupport = 0x21A0400; // 538.4.0
static constexpr int32_t firstJavaScriptCoreVersionWithInitConstructorSupport = 0x21A0400; // 538.4.0
#if PLATFORM(IOS_FAMILY)
static const uint32_t firstSDKVersionWithInitConstructorSupport = DYLD_IOS_VERSION_10_0;
static constexpr uint32_t firstSDKVersionWithInitConstructorSupport = DYLD_IOS_VERSION_10_0;
#elif PLATFORM(MAC)
static const uint32_t firstSDKVersionWithInitConstructorSupport = 0xA0A00; // OSX 10.10.0
static constexpr uint32_t firstSDKVersionWithInitConstructorSupport = 0xA0A00; // OSX 10.10.0
#endif
#endif
@ -66,7 +65,7 @@ static const uint32_t firstSDKVersionWithInitConstructorSupport = 0xA0A00; // OS
@end
static const constexpr unsigned InitialBufferSize { 256 };
static constexpr unsigned InitialBufferSize { 256 };
// Default conversion of selectors to property names.
// All semicolons are removed, lowercase letters following a semicolon are capitalized.
@ -112,25 +111,25 @@ done:
static bool constructorHasInstance(JSContextRef ctx, JSObjectRef constructorRef, JSValueRef possibleInstance, JSValueRef*)
{
JSC::ExecState* exec = toJS(ctx);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(ctx);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
JSC::JSObject* constructor = toJS(constructorRef);
JSC::JSValue instance = toJS(exec, possibleInstance);
return JSC::JSObject::defaultHasInstance(exec, instance, constructor->get(exec, vm.propertyNames->prototype));
JSC::JSValue instance = toJS(globalObject, possibleInstance);
return JSC::JSObject::defaultHasInstance(globalObject, instance, constructor->get(globalObject, vm.propertyNames->prototype));
}
static JSC::JSObject* makeWrapper(JSContextRef ctx, JSClassRef jsClass, id wrappedObject)
{
JSC::ExecState* exec = toJS(ctx);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(ctx);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
ASSERT(jsClass);
JSC::JSCallbackObject<JSC::JSAPIWrapperObject>* object = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->objcWrapperObjectStructure(), jsClass, 0);
JSC::JSCallbackObject<JSC::JSAPIWrapperObject>* object = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(globalObject, globalObject->objcWrapperObjectStructure(), jsClass, 0);
object->setWrappedObject((__bridge void*)wrappedObject);
if (JSC::JSObject* prototype = jsClass->prototype(exec))
if (JSC::JSObject* prototype = jsClass->prototype(globalObject))
object->setPrototypeDirect(vm, prototype);
return object;
@ -187,26 +186,26 @@ inline void putNonEnumerable(JSContext *context, JSValue *base, NSString *proper
{
if (![base isObject])
return;
JSC::ExecState* exec = toJS([context JSGlobalContextRef]);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS([context JSGlobalContextRef]);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSC::JSObject* baseObject = JSC::asObject(toJS(exec, [base JSValueRef]));
JSC::JSObject* baseObject = JSC::asObject(toJS(globalObject, [base JSValueRef]));
auto name = OpaqueJSString::tryCreate(propertyName);
if (!name)
return;
JSC::PropertyDescriptor descriptor;
descriptor.setValue(toJS(exec, [value JSValueRef]));
descriptor.setValue(toJS(globalObject, [value JSValueRef]));
descriptor.setEnumerable(false);
descriptor.setConfigurable(true);
descriptor.setWritable(true);
bool shouldThrow = false;
baseObject->methodTable(vm)->defineOwnProperty(baseObject, exec, name->identifier(&vm), descriptor, shouldThrow);
baseObject->methodTable(vm)->defineOwnProperty(baseObject, globalObject, name->identifier(&vm), descriptor, shouldThrow);
JSValueRef exception = 0;
if (handleExceptionIfNeeded(scope, exec, &exception) == ExceptionStatus::DidThrow)
if (handleExceptionIfNeeded(scope, [context JSGlobalContextRef], &exception) == ExceptionStatus::DidThrow)
[context valueFromNotifyException:exception];
}
@ -272,7 +271,7 @@ static void copyMethodsToObject(JSContext *context, Class objcClass, Protocol *p
name = renameMap[name];
if (!name)
name = selectorToPropertyName(nameCStr);
auto exec = toJS([context JSGlobalContextRef]);
JSC::JSGlobalObject* globalObject = toJS([context JSGlobalContextRef]);
JSValue *existingMethod = object[name];
// ObjCCallbackFunction does a dynamic lookup for the
// selector before calling the method. In order to save
@ -281,7 +280,7 @@ static void copyMethodsToObject(JSContext *context, Class objcClass, Protocol *p
// to override normal builtins e.g. "toString" we check if
// the existing value on the prototype chain is an ObjC
// callback already.
if ([existingMethod isObject] && JSC::jsDynamicCast<JSC::ObjCCallbackFunction*>(exec->vm(), toJS(exec, [existingMethod JSValueRef])))
if ([existingMethod isObject] && JSC::jsDynamicCast<JSC::ObjCCallbackFunction*>(globalObject->vm(), toJS(globalObject, [existingMethod JSValueRef])))
return;
JSObjectRef method = objCCallbackFunctionForMethod(context, objcClass, protocol, isInstanceMethod, sel, types);
if (method)
@ -394,7 +393,7 @@ static void copyPrototypeProperties(JSContext *context, Class objcClass, Protoco
@interface JSObjCClassInfo : NSObject {
Class m_class;
bool m_block;
JSClassRef m_classRef;
NakedPtr<OpaqueJSClass> m_classRef;
JSC::Weak<JSC::JSObject> m_prototype;
JSC::Weak<JSC::JSObject> m_constructor;
JSC::Weak<JSC::Structure> m_structure;
@ -428,7 +427,7 @@ static void copyPrototypeProperties(JSContext *context, Class objcClass, Protoco
- (void)dealloc
{
JSClassRelease(m_classRef);
JSClassRelease(m_classRef.get());
[super dealloc];
}
@ -551,11 +550,11 @@ typedef std::pair<JSC::JSObject*, JSC::JSObject*> ConstructorPrototypePair;
JSC::Structure* structure = [self structureInContext:context];
JSC::ExecState* exec = toJS([context JSGlobalContextRef]);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS([context JSGlobalContextRef]);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto wrapper = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(exec, exec->lexicalGlobalObject(), structure, m_classRef, 0);
auto wrapper = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(globalObject, structure, m_classRef, 0);
wrapper->setWrappedObject((__bridge void*)object);
return wrapper;
}
@ -584,10 +583,9 @@ typedef std::pair<JSC::JSObject*, JSC::JSObject*> ConstructorPrototypePair;
if (structure)
return structure;
JSC::ExecState* exec = toJS([context JSGlobalContextRef]);
JSC::JSGlobalObject* globalObject = toJSGlobalObject([context JSGlobalContextRef]);
JSC::JSObject* prototype = [self prototypeInContext:context];
m_structure = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::createStructure(exec->vm(), globalObject, prototype);
m_structure = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::createStructure(globalObject->vm(), globalObject, prototype);
return m_structure.get();
}
@ -610,7 +608,7 @@ typedef std::pair<JSC::JSObject*, JSC::JSObject*> ConstructorPrototypePair;
NSPointerFunctionsOptions valueOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
m_cachedObjCWrappers = [[NSMapTable alloc] initWithKeyOptions:keyOptions valueOptions:valueOptions capacity:0];
m_cachedJSWrappers = std::make_unique<JSC::WeakGCMap<__unsafe_unretained id, JSC::JSObject>>(toJS(context)->vm());
m_cachedJSWrappers = makeUnique<JSC::WeakGCMap<__unsafe_unretained id, JSC::JSObject>>(toJS(context)->vm());
ASSERT(!toJSGlobalObject(context)->wrapperMap());
toJSGlobalObject(context)->setWrapperMap(self);
@ -725,7 +723,7 @@ bool supportsInitMethodConstructors()
// base our check on what SDK was used to build the application.
static uint32_t programSDKVersion = 0;
if (!programSDKVersion)
programSDKVersion = dyld_get_program_sdk_version();
programSDKVersion = applicationSDKVersion();
return programSDKVersion >= firstSDKVersionWithInitConstructorSupport;
#endif

10
API/JavaScriptCore.h
View File

@ -31,11 +31,11 @@
#if defined(__OBJC__) && JSC_OBJC_API_ENABLED
#import "JSContext.h"
#import "JSValue.h"
#import "JSManagedValue.h"
#import "JSVirtualMachine.h"
#import "JSExport.h"
#import <JavaScriptCore/JSContext.h>
#import <JavaScriptCore/JSValue.h>
#import <JavaScriptCore/JSManagedValue.h>
#import <JavaScriptCore/JSVirtualMachine.h>
#import <JavaScriptCore/JSExport.h>
#endif

57
jit/HostCallReturnValue.h → API/MarkedJSValueRefArray.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2012 Apple Inc. All rights reserved.
* Copyright (C) 2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -20,41 +20,46 @@
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "config.h"
#include "MarkedJSValueRefArray.h"
#include "JSCJSValue.h"
#if !ENABLE(C_LOOP)
#if CALLING_CONVENTION_IS_STDCALL
#define HOST_CALL_RETURN_VALUE_OPTION CDECL
#else
#define HOST_CALL_RETURN_VALUE_OPTION
#endif
namespace JSC {
extern "C" EncodedJSValue HOST_CALL_RETURN_VALUE_OPTION getHostCallReturnValue() REFERENCED_FROM_ASM WTF_INTERNAL;
#if COMPILER(GCC_COMPATIBLE)
// This is a public declaration only to convince CLANG not to elide it.
extern "C" EncodedJSValue HOST_CALL_RETURN_VALUE_OPTION getHostCallReturnValueWithExecState(ExecState*) REFERENCED_FROM_ASM WTF_INTERNAL;
inline void initializeHostCallReturnValue()
MarkedJSValueRefArray::MarkedJSValueRefArray(JSGlobalContextRef context, unsigned size)
: m_size(size)
{
getHostCallReturnValueWithExecState(0);
if (m_size > MarkedArgumentBuffer::inlineCapacity) {
m_buffer = BufferUniquePtr::create(m_size);
toJS(context)->vm().heap.addMarkedJSValueRefArray(this);
ASSERT(isOnList());
}
}
#else // COMPILER(GCC_COMPATIBLE)
MarkedJSValueRefArray::~MarkedJSValueRefArray()
{
if (isOnList())
remove();
}
inline void initializeHostCallReturnValue() { }
#endif // COMPILER(GCC_COMPATIBLE)
void MarkedJSValueRefArray::visitAggregate(SlotVisitor& visitor)
{
JSValueRef* buffer = data();
for (unsigned index = 0; index < m_size; ++index) {
JSValueRef value = buffer[index];
#if !CPU(ADDRESS64)
JSCell* jsCell = reinterpret_cast<JSCell*>(const_cast<OpaqueJSValue*>(value));
if (!jsCell)
continue;
visitor.appendUnbarriered(jsCell); // We should mark the wrapper itself to keep JSValueRef live.
#else
visitor.appendUnbarriered(bitwise_cast<JSValue>(value));
#endif
}
}
} // namespace JSC
#endif // !ENABLE(C_LOOP)

73
API/MarkedJSValueRefArray.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (C) 2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "APICast.h"
#include "ArgList.h"
#include <wtf/CagedUniquePtr.h>
#include <wtf/ForbidHeapAllocation.h>
#include <wtf/Noncopyable.h>
#include <wtf/Nonmovable.h>
namespace JSC {
class MarkedJSValueRefArray final : public BasicRawSentinelNode<MarkedJSValueRefArray> {
WTF_MAKE_NONCOPYABLE(MarkedJSValueRefArray);
WTF_MAKE_NONMOVABLE(MarkedJSValueRefArray);
WTF_FORBID_HEAP_ALLOCATION;
public:
using BufferUniquePtr = CagedUniquePtr<Gigacage::JSValue, JSValueRef>;
static constexpr size_t inlineCapacity = MarkedArgumentBuffer::inlineCapacity;
JS_EXPORT_PRIVATE MarkedJSValueRefArray(JSGlobalContextRef, unsigned);
JS_EXPORT_PRIVATE ~MarkedJSValueRefArray();
size_t size() const { return m_size; }
bool isEmpty() const { return !m_size; }
JSValueRef& operator[](unsigned index) { return data()[index]; }
const JSValueRef* data() const
{
return const_cast<MarkedJSValueRefArray*>(this)->data();
}
JSValueRef* data()
{
if (m_buffer)
return m_buffer.get(m_size);
return m_inlineBuffer;
}
void visitAggregate(SlotVisitor&);
private:
unsigned m_size;
JSValueRef m_inlineBuffer[inlineCapacity] { };
BufferUniquePtr m_buffer;
};
} // namespace JSC

1
API/ObjCCallbackFunction.h
View File

@ -55,6 +55,7 @@ public:
}
static ObjCCallbackFunction* create(VM&, JSGlobalObject*, const String& name, std::unique_ptr<ObjCCallbackFunctionImpl>);
static constexpr bool needsDestruction = true;
static void destroy(JSCell*);
static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)

195
API/ObjCCallbackFunction.mm
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013, 2016 Apple Inc. All rights reserved.
* Copyright (C) 2013-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -23,7 +23,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#import "config.h"
#import "JavaScriptCore.h"
#if JSC_OBJC_API_ENABLED
@ -37,12 +37,7 @@
#import "JSWrapperMap.h"
#import "JSValueInternal.h"
#import "ObjCCallbackFunction.h"
#ifdef DARLING
// ugh, Apple with their stupid case-insensitivity
#import "ObjCRuntimeExtras.h"
#else
#import "ObjcRuntimeExtras.h"
#endif
#import "StructureInlines.h"
#import <objc/runtime.h>
#import <wtf/RetainPtr.h>
@ -60,8 +55,8 @@ CallbackArgument::~CallbackArgument()
{
}
class CallbackArgumentBoolean : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
class CallbackArgumentBoolean final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) final
{
bool value = JSValueToBoolean([context JSGlobalContextRef], argument);
[invocation setArgument:&value atIndex:argumentNumber];
@ -69,40 +64,46 @@ class CallbackArgumentBoolean : public CallbackArgument {
};
template<typename T>
class CallbackArgumentInteger : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentInteger final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
T value = (T)JSC::toInt32(JSValueToNumber([context JSGlobalContextRef], argument, exception));
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
template<typename T>
class CallbackArgumentDouble : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentDouble final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
T value = (T)JSValueToNumber([context JSGlobalContextRef], argument, exception);
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentJSValue : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
class CallbackArgumentJSValue final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) final
{
JSValue *value = [JSValue valueWithJSValueRef:argument inContext:context];
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentId : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
class CallbackArgumentId final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) final
{
id value = valueToObject(context, argument);
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentOfClass : public CallbackArgument {
class CallbackArgumentOfClass final : public CallbackArgument {
public:
CallbackArgumentOfClass(Class cls)
: m_class(cls)
@ -110,8 +111,9 @@ public:
}
private:
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
JSGlobalContextRef contextRef = [context JSGlobalContextRef];
id object = tryUnwrapObjcObject(contextRef, argument);
@ -132,47 +134,62 @@ private:
RetainPtr<Class> m_class;
};
class CallbackArgumentNSNumber : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentNSNumber final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
id value = valueToNumber([context JSGlobalContextRef], argument, exception);
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentNSString : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentNSString final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
id value = valueToString([context JSGlobalContextRef], argument, exception);
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentNSDate : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentNSDate final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
id value = valueToDate([context JSGlobalContextRef], argument, exception);
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentNSArray : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentNSArray final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
id value = valueToArray([context JSGlobalContextRef], argument, exception);
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentNSDictionary : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) override
class CallbackArgumentNSDictionary final : public CallbackArgument {
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef* exception) final
{
ASSERT(exception && !*exception);
id value = valueToDictionary([context JSGlobalContextRef], argument, exception);
if (*exception)
return;
[invocation setArgument:&value atIndex:argumentNumber];
}
};
class CallbackArgumentStruct : public CallbackArgument {
class CallbackArgumentStruct final : public CallbackArgument {
public:
CallbackArgumentStruct(NSInvocation *conversionInvocation, const char* encodedType)
: m_conversionInvocation(conversionInvocation)
@ -181,7 +198,7 @@ public:
}
private:
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) override
void set(NSInvocation *invocation, NSInteger argumentNumber, JSContext *context, JSValueRef argument, JSValueRef*) final
{
JSValue *value = [JSValue valueWithJSValueRef:argument inContext:context];
[m_conversionInvocation invokeWithTarget:value];
@ -193,25 +210,25 @@ private:
StructBuffer m_buffer;
};
class ArgumentTypeDelegate {
class ArgumentTypeDelegate final {
public:
typedef std::unique_ptr<CallbackArgument> ResultType;
template<typename T>
static ResultType typeInteger()
{
return std::make_unique<CallbackArgumentInteger<T>>();
return makeUnique<CallbackArgumentInteger<T>>();
}
template<typename T>
static ResultType typeDouble()
{
return std::make_unique<CallbackArgumentDouble<T>>();
return makeUnique<CallbackArgumentDouble<T>>();
}
static ResultType typeBool()
{
return std::make_unique<CallbackArgumentBoolean>();
return makeUnique<CallbackArgumentBoolean>();
}
static ResultType typeVoid()
@ -222,7 +239,7 @@ public:
static ResultType typeId()
{
return std::make_unique<CallbackArgumentId>();
return makeUnique<CallbackArgumentId>();
}
static ResultType typeOfClass(const char* begin, const char* end)
@ -233,19 +250,19 @@ public:
return nullptr;
if (cls == [JSValue class])
return std::make_unique<CallbackArgumentJSValue>();
return makeUnique<CallbackArgumentJSValue>();
if (cls == [NSString class])
return std::make_unique<CallbackArgumentNSString>();
return makeUnique<CallbackArgumentNSString>();
if (cls == [NSNumber class])
return std::make_unique<CallbackArgumentNSNumber>();
return makeUnique<CallbackArgumentNSNumber>();
if (cls == [NSDate class])
return std::make_unique<CallbackArgumentNSDate>();
return makeUnique<CallbackArgumentNSDate>();
if (cls == [NSArray class])
return std::make_unique<CallbackArgumentNSArray>();
return makeUnique<CallbackArgumentNSArray>();
if (cls == [NSDictionary class])
return std::make_unique<CallbackArgumentNSDictionary>();
return makeUnique<CallbackArgumentNSDictionary>();
return std::make_unique<CallbackArgumentOfClass>(cls);
return makeUnique<CallbackArgumentOfClass>(cls);
}
static ResultType typeBlock(const char*, const char*)
@ -257,7 +274,7 @@ public:
{
StringRange copy(begin, end);
if (NSInvocation *invocation = valueToTypeInvocationFor(copy))
return std::make_unique<CallbackArgumentStruct>(invocation, copy);
return makeUnique<CallbackArgumentStruct>(invocation, copy);
return nullptr;
}
};
@ -272,15 +289,15 @@ public:
virtual JSValueRef get(NSInvocation *, JSContext *, JSValueRef*) = 0;
};
class CallbackResultVoid : public CallbackResult {
JSValueRef get(NSInvocation *, JSContext *context, JSValueRef*) override
class CallbackResultVoid final : public CallbackResult {
JSValueRef get(NSInvocation *, JSContext *context, JSValueRef*) final
{
return JSValueMakeUndefined([context JSGlobalContextRef]);
}
};
class CallbackResultId : public CallbackResult {
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
class CallbackResultId final : public CallbackResult {
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) final
{
id value;
[invocation getReturnValue:&value];
@ -289,8 +306,8 @@ class CallbackResultId : public CallbackResult {
};
template<typename T>
class CallbackResultNumeric : public CallbackResult {
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
class CallbackResultNumeric final : public CallbackResult {
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) final
{
T value;
[invocation getReturnValue:&value];
@ -298,8 +315,8 @@ class CallbackResultNumeric : public CallbackResult {
}
};
class CallbackResultBoolean : public CallbackResult {
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
class CallbackResultBoolean final : public CallbackResult {
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) final
{
bool value;
[invocation getReturnValue:&value];
@ -307,7 +324,7 @@ class CallbackResultBoolean : public CallbackResult {
}
};
class CallbackResultStruct : public CallbackResult {
class CallbackResultStruct final : public CallbackResult {
public:
CallbackResultStruct(NSInvocation *conversionInvocation, const char* encodedType)
: m_conversionInvocation(conversionInvocation)
@ -316,7 +333,7 @@ public:
}
private:
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) override
JSValueRef get(NSInvocation *invocation, JSContext *context, JSValueRef*) final
{
[invocation getReturnValue:m_buffer];
@ -333,52 +350,52 @@ private:
StructBuffer m_buffer;
};
class ResultTypeDelegate {
class ResultTypeDelegate final {
public:
typedef std::unique_ptr<CallbackResult> ResultType;
template<typename T>
static ResultType typeInteger()
{
return std::make_unique<CallbackResultNumeric<T>>();
return makeUnique<CallbackResultNumeric<T>>();
}
template<typename T>
static ResultType typeDouble()
{
return std::make_unique<CallbackResultNumeric<T>>();
return makeUnique<CallbackResultNumeric<T>>();
}
static ResultType typeBool()
{
return std::make_unique<CallbackResultBoolean>();
return makeUnique<CallbackResultBoolean>();
}
static ResultType typeVoid()
{
return std::make_unique<CallbackResultVoid>();
return makeUnique<CallbackResultVoid>();
}
static ResultType typeId()
{
return std::make_unique<CallbackResultId>();
return makeUnique<CallbackResultId>();
}
static ResultType typeOfClass(const char*, const char*)
{
return std::make_unique<CallbackResultId>();
return makeUnique<CallbackResultId>();
}
static ResultType typeBlock(const char*, const char*)
{
return std::make_unique<CallbackResultId>();
return makeUnique<CallbackResultId>();
}
static ResultType typeStruct(const char* begin, const char* end)
{
StringRange copy(begin, end);
if (NSInvocation *invocation = typeToValueInvocationFor(copy))
return std::make_unique<CallbackResultStruct>(invocation, copy);
return makeUnique<CallbackResultStruct>(invocation, copy);
return nullptr;
}
};
@ -392,7 +409,8 @@ enum CallbackType {
namespace JSC {
class ObjCCallbackFunctionImpl {
class ObjCCallbackFunctionImpl final {
WTF_MAKE_FAST_ALLOCATED;
public:
ObjCCallbackFunctionImpl(NSInvocation *invocation, CallbackType type, Class instanceClass, std::unique_ptr<CallbackArgument> arguments, std::unique_ptr<CallbackResult> result)
: m_type(type)
@ -451,6 +469,8 @@ private:
static JSValueRef objCCallbackFunctionCallAsFunction(JSContextRef callerContext, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ASSERT(exception && !*exception);
// Retake the API lock - we need this for a few reasons:
// (1) We don't want to support the C-API's confusing drops-locks-once policy - should only drop locks if we can do so recursively.
// (2) We're calling some JSC internals that require us to be on the 'inside' - e.g. createTypeError.
@ -459,11 +479,13 @@ static JSValueRef objCCallbackFunctionCallAsFunction(JSContextRef callerContext,
ObjCCallbackFunction* callback = static_cast<ObjCCallbackFunction*>(toJS(function));
ObjCCallbackFunctionImpl* impl = callback->impl();
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(callback->globalObject()->globalExec())];
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(callback->globalObject())];
if (impl->type() == CallbackInitMethod) {
JSGlobalContextRef contextRef = [context JSGlobalContextRef];
*exception = toRef(JSC::createTypeError(toJS(contextRef), "Cannot call a class constructor without |new|"_s));
if (*exception)
return nullptr;
return JSValueMakeUndefined(contextRef);
}
@ -476,16 +498,19 @@ static JSValueRef objCCallbackFunctionCallAsFunction(JSContextRef callerContext,
*exception = valueInternalValue(context.exception);
[context endCallbackWithData:&callbackData];
}
if (*exception)
return nullptr;
return result;
}
static JSObjectRef objCCallbackFunctionCallAsConstructor(JSContextRef callerContext, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ASSERT(exception && !*exception);
JSC::JSLockHolder locker(toJS(callerContext));
ObjCCallbackFunction* callback = static_cast<ObjCCallbackFunction*>(toJS(constructor));
ObjCCallbackFunctionImpl* impl = callback->impl();
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(toJS(callerContext)->lexicalGlobalObject()->globalExec())];
JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(toJS(callerContext))];
CallbackData callbackData;
JSValueRef result;
@ -496,22 +521,35 @@ static JSObjectRef objCCallbackFunctionCallAsConstructor(JSContextRef callerCont
*exception = valueInternalValue(context.exception);
[context endCallbackWithData:&callbackData];
}
JSGlobalContextRef contextRef = [context JSGlobalContextRef];
if (*exception)
return nullptr;
JSGlobalContextRef contextRef = [context JSGlobalContextRef];
if (!JSValueIsObject(contextRef, result)) {
*exception = toRef(JSC::createTypeError(toJS(contextRef), "Objective-C blocks called as constructors must return an object."_s));
return nullptr;
}
ASSERT(!*exception);
return const_cast<JSObjectRef>(result);
}
const JSC::ClassInfo ObjCCallbackFunction::s_info = { "CallbackFunction", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(ObjCCallbackFunction) };
static JSC_DECLARE_HOST_FUNCTION(callObjCCallbackFunction);
static JSC_DECLARE_HOST_FUNCTION(constructObjCCallbackFunction);
JSC_DEFINE_HOST_FUNCTION(callObjCCallbackFunction, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return APICallbackFunction::callImpl<ObjCCallbackFunction>(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructObjCCallbackFunction, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return APICallbackFunction::constructImpl<ObjCCallbackFunction>(globalObject, callFrame);
}
ObjCCallbackFunction::ObjCCallbackFunction(JSC::VM& vm, JSC::Structure* structure, JSObjectCallAsFunctionCallback functionCallback, JSObjectCallAsConstructorCallback constructCallback, std::unique_ptr<ObjCCallbackFunctionImpl> impl)
: Base(vm, structure, APICallbackFunction::call<ObjCCallbackFunction>, impl->isConstructible() ? APICallbackFunction::construct<ObjCCallbackFunction> : nullptr)
: Base(vm, structure, callObjCCallbackFunction, impl->isConstructible() ? constructObjCCallbackFunction : nullptr)
, m_functionCallback(functionCallback)
, m_constructCallback(constructCallback)
, m_impl(WTFMove(impl))
@ -522,7 +560,7 @@ ObjCCallbackFunction* ObjCCallbackFunction::create(JSC::VM& vm, JSC::JSGlobalObj
{
Structure* structure = globalObject->objcCallbackFunctionStructure();
ObjCCallbackFunction* function = new (NotNull, allocateCell<ObjCCallbackFunction>(vm.heap)) ObjCCallbackFunction(vm, structure, objCCallbackFunctionCallAsFunction, objCCallbackFunctionCallAsConstructor, WTFMove(impl));
function->finishCreation(vm, name);
function->finishCreation(vm, 0, name);
return function;
}
@ -544,6 +582,7 @@ String ObjCCallbackFunctionImpl::name()
JSValueRef ObjCCallbackFunctionImpl::call(JSContext *context, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ASSERT(exception && !*exception);
JSGlobalContextRef contextRef = [context JSGlobalContextRef];
id target;
@ -554,6 +593,8 @@ JSValueRef ObjCCallbackFunctionImpl::call(JSContext *context, JSObjectRef thisOb
target = [m_instanceClass alloc];
if (!target || ![target isKindOfClass:m_instanceClass.get()]) {
*exception = toRef(JSC::createTypeError(toJS(contextRef), "self type check failed for Objective-C instance method"_s));
if (*exception)
return nullptr;
return JSValueMakeUndefined(contextRef);
}
[m_invocation setTarget:target];
@ -564,6 +605,8 @@ JSValueRef ObjCCallbackFunctionImpl::call(JSContext *context, JSObjectRef thisOb
target = tryUnwrapObjcObject(contextRef, thisObject);
if (!target || ![target isKindOfClass:m_instanceClass.get()]) {
*exception = toRef(JSC::createTypeError(toJS(contextRef), "self type check failed for Objective-C instance method"_s));
if (*exception)
return nullptr;
return JSValueMakeUndefined(contextRef);
}
[m_invocation setTarget:target];
@ -582,13 +625,15 @@ JSValueRef ObjCCallbackFunctionImpl::call(JSContext *context, JSObjectRef thisOb
JSValueRef value = argumentNumber < argumentCount ? arguments[argumentNumber] : JSValueMakeUndefined(contextRef);
argument->set(m_invocation.get(), argumentNumber + firstArgument, context, value, exception);
if (*exception)
return JSValueMakeUndefined(contextRef);
return nullptr;
++argumentNumber;
}
[m_invocation invoke];
JSValueRef result = m_result->get(m_invocation.get(), context, exception);
if (*exception)
return nullptr;
// Balance our call to -alloc with a call to -autorelease. We have to do this after calling -init
// because init family methods are allowed to release the allocated object and return something
@ -663,12 +708,12 @@ static JSObjectRef objCCallbackFunctionForInvocation(JSContext *context, NSInvoc
++argumentCount;
}
JSC::ExecState* exec = toJS([context JSGlobalContextRef]);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS([context JSGlobalContextRef]);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto impl = std::make_unique<JSC::ObjCCallbackFunctionImpl>(invocation, type, instanceClass, WTFMove(arguments), WTFMove(result));
auto impl = makeUnique<JSC::ObjCCallbackFunctionImpl>(invocation, type, instanceClass, WTFMove(arguments), WTFMove(result));
const String& name = impl->name();
return toRef(JSC::ObjCCallbackFunction::create(vm, exec->lexicalGlobalObject(), name, WTFMove(impl)));
return toRef(JSC::ObjCCallbackFunction::create(vm, globalObject, name, WTFMove(impl)));
}
JSObjectRef objCCallbackFunctionForInit(JSContext *context, Class cls, Protocol *protocol, SEL sel, const char* types)

0
API/ObjCRuntimeExtras.h → API/ObjcRuntimeExtras.h
View File

8
API/OpaqueJSString.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2008 Apple Inc. All rights reserved.
* Copyright (C) 2008-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -26,10 +26,8 @@
#include "config.h"
#include "OpaqueJSString.h"
#include "CallFrame.h"
#include "Identifier.h"
#include "IdentifierInlines.h"
#include "JSGlobalObject.h"
#include <wtf/text/StringView.h>
using namespace JSC;
@ -78,9 +76,9 @@ Identifier OpaqueJSString::identifier(VM* vm) const
return Identifier(Identifier::EmptyIdentifier);
if (m_string.is8Bit())
return Identifier::fromString(vm, m_string.characters8(), m_string.length());
return Identifier::fromString(*vm, m_string.characters8(), m_string.length());
return Identifier::fromString(vm, m_string.characters16(), m_string.length());
return Identifier::fromString(*vm, m_string.characters16(), m_string.length());
}
const UChar* OpaqueJSString::characters()

37
API/WebKitAvailability.h
View File

@ -31,43 +31,6 @@
#include <AvailabilityMacros.h>
#include <CoreFoundation/CoreFoundation.h>
#if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
/* To support availability macros that mention newer OS X versions when building on older OS X versions,
we provide our own definitions of the underlying macros that the availability macros expand to. We're
free to expand the macros as no-ops since frameworks built on older OS X versions only ship bundled with
an application rather than as part of the system.
*/
#ifndef __NSi_10_10 // Building from trunk rather than SDK.
#define __NSi_10_10 introduced=10.0 // Use 10.0 to indicate that everything is available.
#endif
#ifndef __NSi_10_11 // Building from trunk rather than SDK.
#define __NSi_10_11 introduced=10.0 // Use 10.0 to indicate that everything is available.
#endif
#ifndef __NSi_10_12 // Building from trunk rather than SDK.
#define __NSi_10_12 introduced=10.0 // Use 10.0 to indicate that everything is available.
#endif
#ifndef __AVAILABILITY_INTERNAL__MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_9
#endif
#ifndef __AVAILABILITY_INTERNAL__MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_10_10
#endif
#ifndef AVAILABLE_MAC_OS_X_VERSION_10_9_AND_LATER
#define AVAILABLE_MAC_OS_X_VERSION_10_9_AND_LATER
#endif
#ifndef AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER
#define AVAILABLE_MAC_OS_X_VERSION_10_10_AND_LATER
#endif
#endif /* !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED < 101100 */
#if defined(BUILDING_GTK__)
#undef JSC_API_AVAILABLE
#define JSC_API_AVAILABLE(...)

69
API/glib/JSAPIWrapperGlobalObject.cpp
View File

@ -31,9 +31,9 @@
#include "Structure.h"
#include <wtf/NeverDestroyed.h>
class JSAPIWrapperGlobalObjectHandleOwner : public JSC::WeakHandleOwner {
class JSAPIWrapperGlobalObjectHandleOwner final : public JSC::WeakHandleOwner {
public:
void finalize(JSC::Handle<JSC::Unknown>, void*) override;
void finalize(JSC::Handle<JSC::Unknown>, void*) final;
};
static JSAPIWrapperGlobalObjectHandleOwner* jsAPIWrapperGlobalObjectHandleOwner()
@ -54,9 +54,50 @@ void JSAPIWrapperGlobalObjectHandleOwner::finalize(JSC::Handle<JSC::Unknown> han
namespace JSC {
template <> const ClassInfo JSCallbackObject<JSAPIWrapperGlobalObject>::s_info = { "JSAPIWrapperGlobalObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
static JSC_DECLARE_HOST_FUNCTION(callJSAPIWrapperGlobalObjectCallbackObject);
static JSC_DECLARE_HOST_FUNCTION(constructJSAPIWrapperGlobalObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(callbackGetterJSAPIWrapperGlobalObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(staticFunctionGetterJSAPIWrapperGlobalObjectCallbackObject);
template<> const bool JSCallbackObject<JSAPIWrapperGlobalObject>::needsDestruction = false;
template <> const ClassInfo JSCallbackObject<JSAPIWrapperGlobalObject>::s_info = { "JSAPIWrapperGlobalObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template<> const bool JSCallbackObject<JSAPIWrapperGlobalObject>::needsDestruction = true;
template <>
RawNativeFunction JSCallbackObject<JSAPIWrapperGlobalObject>::getCallFunction()
{
return callJSAPIWrapperGlobalObjectCallbackObject;
}
template <>
RawNativeFunction JSCallbackObject<JSAPIWrapperGlobalObject>::getConstructFunction()
{
return constructJSAPIWrapperGlobalObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSAPIWrapperGlobalObject>::getCallbackGetter()
{
return callbackGetterJSAPIWrapperGlobalObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSAPIWrapperGlobalObject>::getStaticFunctionGetter()
{
return staticFunctionGetterJSAPIWrapperGlobalObjectCallbackObject;
}
template <>
IsoSubspace* JSCallbackObject<JSAPIWrapperGlobalObject>::subspaceForImpl(VM& vm, SubspaceAccess mode)
{
switch (mode) {
case SubspaceAccess::OnMainThread:
return vm.callbackAPIWrapperGlobalObjectSpace<SubspaceAccess::OnMainThread>();
case SubspaceAccess::Concurrently:
return vm.callbackAPIWrapperGlobalObjectSpace<SubspaceAccess::Concurrently>();
}
RELEASE_ASSERT_NOT_REACHED();
return nullptr;
}
template <>
Structure* JSCallbackObject<JSAPIWrapperGlobalObject>::createStructure(VM& vm, JSGlobalObject*, JSValue proto)
@ -72,6 +113,26 @@ JSCallbackObject<JSAPIWrapperGlobalObject>* JSCallbackObject<JSAPIWrapperGlobalO
return callbackObject;
}
JSC_DEFINE_HOST_FUNCTION(callJSAPIWrapperGlobalObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSAPIWrapperGlobalObject>::callImpl(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructJSAPIWrapperGlobalObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSAPIWrapperGlobalObject>::constructImpl(globalObject, callFrame);
}
JSC_DEFINE_CUSTOM_GETTER(callbackGetterJSAPIWrapperGlobalObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSAPIWrapperGlobalObject>::callbackGetterImpl(globalObject, thisValue, propertyName);
}
JSC_DEFINE_CUSTOM_GETTER(staticFunctionGetterJSAPIWrapperGlobalObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSAPIWrapperGlobalObject>::staticFunctionGetterImpl(globalObject, thisValue, propertyName);
}
JSAPIWrapperGlobalObject::JSAPIWrapperGlobalObject(VM& vm, Structure* structure)
: Base(vm, structure)
{

5
API/glib/JSAPIWrapperGlobalObject.h
View File

@ -33,7 +33,10 @@ namespace JSC {
class JSAPIWrapperGlobalObject : public JSGlobalObject {
public:
typedef JSGlobalObject Base;
using Base = JSGlobalObject;
template<typename, SubspaceAccess>
static void subspaceFor(VM&) { RELEASE_ASSERT_NOT_REACHED(); }
void finishCreation(VM&);
static void visitChildren(JSCell*, JSC::SlotVisitor&);

69
API/glib/JSAPIWrapperObjectGLib.cpp
View File

@ -33,10 +33,10 @@
#include "Structure.h"
#include <wtf/NeverDestroyed.h>
class JSAPIWrapperObjectHandleOwner : public JSC::WeakHandleOwner {
class JSAPIWrapperObjectHandleOwner final : public JSC::WeakHandleOwner {
public:
void finalize(JSC::Handle<JSC::Unknown>, void*) override;
bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**) override;
void finalize(JSC::Handle<JSC::Unknown>, void*) final;
bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&, const char**) final;
};
static JSAPIWrapperObjectHandleOwner* jsAPIWrapperObjectHandleOwner()
@ -67,16 +67,77 @@ bool JSAPIWrapperObjectHandleOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::
namespace JSC {
template <> const ClassInfo JSCallbackObject<JSAPIWrapperObject>::s_info = { "JSAPIWrapperObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
static JSC_DECLARE_HOST_FUNCTION(callJSAPIWrapperObjectCallbackObject);
static JSC_DECLARE_HOST_FUNCTION(constructJSAPIWrapperObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(callbackGetterJSAPIWrapperObjectCallbackObject);
static JSC_DECLARE_CUSTOM_GETTER(staticFunctionGetterJSAPIWrapperObjectCallbackObject);
template <> const ClassInfo JSCallbackObject<JSAPIWrapperObject>::s_info = { "JSAPIWrapperObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCallbackObject) };
template<> const bool JSCallbackObject<JSAPIWrapperObject>::needsDestruction = true;
template <>
RawNativeFunction JSCallbackObject<JSAPIWrapperObject>::getCallFunction()
{
return callJSAPIWrapperObjectCallbackObject;
}
template <>
RawNativeFunction JSCallbackObject<JSAPIWrapperObject>::getConstructFunction()
{
return constructJSAPIWrapperObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSAPIWrapperObject>::getCallbackGetter()
{
return callbackGetterJSAPIWrapperObjectCallbackObject;
}
template <>
PropertySlot::GetValueFunc JSCallbackObject<JSAPIWrapperObject>::getStaticFunctionGetter()
{
return staticFunctionGetterJSAPIWrapperObjectCallbackObject;
}
template <>
IsoSubspace* JSCallbackObject<JSAPIWrapperObject>::subspaceForImpl(VM& vm, SubspaceAccess mode)
{
switch (mode) {
case SubspaceAccess::OnMainThread:
return vm.apiWrapperObjectSpace<SubspaceAccess::OnMainThread>();
case SubspaceAccess::Concurrently:
return vm.apiWrapperObjectSpace<SubspaceAccess::Concurrently>();
}
RELEASE_ASSERT_NOT_REACHED();
return nullptr;
}
template <>
Structure* JSCallbackObject<JSAPIWrapperObject>::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue proto)
{
return Structure::create(vm, globalObject, proto, TypeInfo(ObjectType, StructureFlags), &s_info);
}
JSC_DEFINE_HOST_FUNCTION(callJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSAPIWrapperObject>::callImpl(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return JSCallbackObject<JSAPIWrapperObject>::constructImpl(globalObject, callFrame);
}
JSC_DEFINE_CUSTOM_GETTER(callbackGetterJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSAPIWrapperObject>::callbackGetterImpl(globalObject, thisValue, propertyName);
}
JSC_DEFINE_CUSTOM_GETTER(staticFunctionGetterJSAPIWrapperObjectCallbackObject, (JSGlobalObject* globalObject, EncodedJSValue thisValue, PropertyName propertyName))
{
return JSCallbackObject<JSAPIWrapperObject>::staticFunctionGetterImpl(globalObject, thisValue, propertyName);
}
JSAPIWrapperObject::JSAPIWrapperObject(VM& vm, Structure* structure)
: Base(vm, structure)
{

28
API/glib/JSCCallbackFunction.cpp
View File

@ -29,7 +29,6 @@
#include "APICallbackFunction.h"
#include "APICast.h"
#include "IsoSubspacePerVM.h"
#include "JSCClassPrivate.h"
#include "JSCContextPrivate.h"
#include "JSDestructibleObjectHeapCellType.h"
@ -53,16 +52,29 @@ static JSObjectRef callAsConstructor(JSContextRef callerContext, JSObjectRef con
const ClassInfo JSCCallbackFunction::s_info = { "CallbackFunction", &InternalFunction::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCCallbackFunction) };
static JSC_DECLARE_HOST_FUNCTION(callJSCCallbackFunction);
static JSC_DECLARE_HOST_FUNCTION(constructJSCCallbackFunction);
JSC_DEFINE_HOST_FUNCTION(callJSCCallbackFunction, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return APICallbackFunction::callImpl<JSCCallbackFunction>(globalObject, callFrame);
}
JSC_DEFINE_HOST_FUNCTION(constructJSCCallbackFunction, (JSGlobalObject* globalObject, CallFrame* callFrame))
{
return APICallbackFunction::constructImpl<JSCCallbackFunction>(globalObject, callFrame);
}
JSCCallbackFunction* JSCCallbackFunction::create(VM& vm, JSGlobalObject* globalObject, const String& name, Type type, JSCClass* jscClass, GRefPtr<GClosure>&& closure, GType returnType, Optional<Vector<GType>>&& parameters)
{
Structure* structure = globalObject->glibCallbackFunctionStructure();
JSCCallbackFunction* function = new (NotNull, allocateCell<JSCCallbackFunction>(vm.heap)) JSCCallbackFunction(vm, structure, type, jscClass, WTFMove(closure), returnType, WTFMove(parameters));
function->finishCreation(vm, name);
function->finishCreation(vm, 0, name);
return function;
}
JSCCallbackFunction::JSCCallbackFunction(VM& vm, Structure* structure, Type type, JSCClass* jscClass, GRefPtr<GClosure>&& closure, GType returnType, Optional<Vector<GType>>&& parameters)
: InternalFunction(vm, structure, APICallbackFunction::call<JSCCallbackFunction>, type == Type::Constructor ? APICallbackFunction::construct<JSCCallbackFunction> : nullptr)
: InternalFunction(vm, structure, callJSCCallbackFunction, type == Type::Constructor ? constructJSCCallbackFunction : nullptr)
, m_functionCallback(callAsFunction)
, m_constructCallback(callAsConstructor)
, m_type(type)
@ -79,7 +91,7 @@ JSCCallbackFunction::JSCCallbackFunction(VM& vm, Structure* structure, Type type
JSValueRef JSCCallbackFunction::call(JSContextRef callerContext, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
JSLockHolder locker(toJS(callerContext));
auto context = jscContextGetOrCreate(toGlobalRef(globalObject()->globalExec()));
auto context = jscContextGetOrCreate(toGlobalRef(globalObject()));
auto* jsContext = jscContextGetJSContext(context.get());
if (m_type == Type::Constructor) {
@ -150,7 +162,7 @@ JSValueRef JSCCallbackFunction::call(JSContextRef callerContext, JSObjectRef thi
JSObjectRef JSCCallbackFunction::construct(JSContextRef callerContext, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
JSLockHolder locker(toJS(callerContext));
auto context = jscContextGetOrCreate(toGlobalRef(globalObject()->globalExec()));
auto context = jscContextGetOrCreate(toGlobalRef(globalObject()));
auto* jsContext = jscContextGetJSContext(context.get());
if (m_returnType == G_TYPE_NONE) {
@ -223,10 +235,4 @@ void JSCCallbackFunction::destroy(JSCell* cell)
static_cast<JSCCallbackFunction*>(cell)->JSCCallbackFunction::~JSCCallbackFunction();
}
IsoSubspace* JSCCallbackFunction::subspaceForImpl(VM& vm)
{
NeverDestroyed<IsoSubspacePerVM> perVM([] (VM& vm) -> IsoSubspacePerVM::SubspaceParameters { return ISO_SUBSPACE_PARAMETERS(vm.destructibleObjectHeapCellType.get(), JSCCallbackFunction); });
return &perVM.get().forVM(vm);
}
} // namespace JSC

9
API/glib/JSCCallbackFunction.h
View File

@ -35,15 +35,15 @@ typedef struct _JSCClass JSCClass;
namespace JSC {
class JSCCallbackFunction : public InternalFunction {
class JSCCallbackFunction final : public InternalFunction {
friend struct APICallbackFunction;
public:
typedef InternalFunction Base;
template<typename CellType, SubspaceAccess>
template<typename CellType, SubspaceAccess mode>
static IsoSubspace* subspaceFor(VM& vm)
{
return subspaceForImpl(vm);
return vm.jscCallbackFunctionSpace<mode>();
}
enum class Type {
@ -53,6 +53,7 @@ public:
};
static JSCCallbackFunction* create(VM&, JSGlobalObject*, const String& name, Type, JSCClass*, GRefPtr<GClosure>&&, GType, Optional<Vector<GType>>&&);
static constexpr bool needsDestruction = true;
static void destroy(JSCell*);
static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
@ -67,8 +68,6 @@ public:
JSObjectRef construct(JSContextRef, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception);
private:
static IsoSubspace* subspaceForImpl(VM&);
JSCCallbackFunction(VM&, Structure*, Type, JSCClass*, GRefPtr<GClosure>&&, GType, Optional<Vector<GType>>&&);
JSObjectCallAsFunctionCallback functionCallback() { return m_functionCallback; }

26
API/glib/JSCClass.cpp
View File

@ -110,10 +110,10 @@ private:
static bool isWrappedObject(JSC::JSObject* jsObject)
{
JSC::ExecState* exec = jsObject->globalObject()->globalExec();
JSC::JSGlobalObject* globalObject = jsObject->globalObject();
if (jsObject->isGlobalObject())
return jsObject->inherits<JSC::JSCallbackObject<JSC::JSAPIWrapperGlobalObject>>(exec->vm());
return jsObject->inherits<JSC::JSCallbackObject<JSC::JSAPIWrapperObject>>(exec->vm());
return jsObject->inherits<JSC::JSCallbackObject<JSC::JSAPIWrapperGlobalObject>>(globalObject->vm());
return jsObject->inherits<JSC::JSCallbackObject<JSC::JSAPIWrapperObject>>(globalObject->vm());
}
static JSClassRef wrappedObjectClass(JSC::JSObject* jsObject)
@ -128,13 +128,11 @@ static GRefPtr<JSCContext> jscContextForObject(JSC::JSObject* jsObject)
{
ASSERT(isWrappedObject(jsObject));
JSC::JSGlobalObject* globalObject = jsObject->globalObject();
JSC::ExecState* exec = globalObject->globalExec();
if (jsObject->isGlobalObject()) {
JSC::VM& vm = globalObject->vm();
if (auto* globalScopeExtension = vm.vmEntryGlobalObject(exec)->globalScopeExtension())
exec = JSC::JSScope::objectAtScope(globalScopeExtension)->globalObject()->globalExec();
if (auto* globalScopeExtension = globalObject->globalScopeExtension())
globalObject = JSC::JSScope::objectAtScope(globalScopeExtension)->globalObject();
}
return jscContextGetOrCreate(toGlobalRef(exec));
return jscContextGetOrCreate(toGlobalRef(globalObject));
}
static JSValueRef getProperty(JSContextRef callerContext, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
@ -558,10 +556,10 @@ static GRefPtr<JSCValue> jscClassCreateConstructor(JSCClass* jscClass, const cha
else
closure = adoptGRef(g_cclosure_new(callback, userData, reinterpret_cast<GClosureNotify>(reinterpret_cast<GCallback>(destroyNotify))));
JSCClassPrivate* priv = jscClass->priv;
JSC::ExecState* exec = toJS(priv->context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(priv->context);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto* functionObject = JSC::JSCCallbackFunction::create(vm, exec->lexicalGlobalObject(), String::fromUTF8(name),
auto* functionObject = JSC::JSCCallbackFunction::create(vm, globalObject, String::fromUTF8(name),
JSC::JSCCallbackFunction::Type::Constructor, jscClass, WTFMove(closure), returnType, WTFMove(parameters));
auto context = jscContextGetOrCreate(priv->context);
auto constructor = jscContextGetOrCreateValue(context.get(), toRef(functionObject));
@ -707,10 +705,10 @@ static void jscClassAddMethod(JSCClass* jscClass, const char* name, GCallback ca
{
JSCClassPrivate* priv = jscClass->priv;
GRefPtr<GClosure> closure = adoptGRef(g_cclosure_new(callback, userData, reinterpret_cast<GClosureNotify>(reinterpret_cast<GCallback>(destroyNotify))));
JSC::ExecState* exec = toJS(priv->context);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(priv->context);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto* functionObject = toRef(JSC::JSCCallbackFunction::create(vm, exec->lexicalGlobalObject(), String::fromUTF8(name),
auto* functionObject = toRef(JSC::JSCCallbackFunction::create(vm, globalObject, String::fromUTF8(name),
JSC::JSCCallbackFunction::Type::Method, jscClass, WTFMove(closure), returnType, WTFMove(parameters)));
auto context = jscContextGetOrCreate(priv->context);
auto method = jscContextGetOrCreateValue(context.get(), functionObject);

59
API/glib/JSCContext.cpp
View File

@ -107,7 +107,7 @@ static void jscContextSetVirtualMachine(JSCContext* context, GRefPtr<JSCVirtualM
priv->jsContext = JSRetainPtr<JSGlobalContextRef>(Adopt, JSGlobalContextCreateInGroup(jscVirtualMachineGetContextGroup(priv->vm.get()), nullptr));
auto* globalObject = toJSGlobalObject(priv->jsContext.get());
if (!globalObject->wrapperMap())
globalObject->setWrapperMap(std::make_unique<JSC::WrapperMap>(priv->jsContext.get()));
globalObject->setWrapperMap(makeUnique<JSC::WrapperMap>(priv->jsContext.get()));
jscVirtualMachineAddContext(priv->vm.get(), context);
} else if (priv->vm) {
ASSERT(priv->jsContext);
@ -271,6 +271,9 @@ void jscContextPopCallback(JSCContext* context, CallbackData&& data)
JSValueRef jscContextGArrayToJSArray(JSCContext* context, GPtrArray* gArray, JSValueRef* exception)
{
JSCContextPrivate* priv = context->priv;
JSC::JSGlobalObject* globalObject = toJS(priv->jsContext.get());
JSC::JSLockHolder locker(globalObject);
auto* jsArray = JSObjectMakeArray(priv->jsContext.get(), 0, nullptr, exception);
if (*exception)
return JSValueMakeUndefined(priv->jsContext.get());
@ -289,7 +292,7 @@ JSValueRef jscContextGArrayToJSArray(JSCContext* context, GPtrArray* gArray, JSV
else if (JSC_IS_VALUE(item))
JSObjectSetPropertyAtIndex(priv->jsContext.get(), jsArrayObject, i, jscValueGetJSValue(JSC_VALUE(item)), exception);
else
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), makeString("invalid item type in GPtrArray")));
*exception = toRef(JSC::createTypeError(globalObject, makeString("invalid item type in GPtrArray")));
if (*exception)
return JSValueMakeUndefined(priv->jsContext.get());
@ -301,11 +304,14 @@ JSValueRef jscContextGArrayToJSArray(JSCContext* context, GPtrArray* gArray, JSV
static GRefPtr<GPtrArray> jscContextJSArrayToGArray(JSCContext* context, JSValueRef jsArray, JSValueRef* exception)
{
JSCContextPrivate* priv = context->priv;
JSC::JSGlobalObject* globalObject = toJS(priv->jsContext.get());
JSC::JSLockHolder locker(globalObject);
if (JSValueIsNull(priv->jsContext.get(), jsArray))
return nullptr;
if (!JSValueIsArray(priv->jsContext.get(), jsArray)) {
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), makeString("invalid js type for GPtrArray")));
*exception = toRef(JSC::createTypeError(globalObject, makeString("invalid js type for GPtrArray")));
return nullptr;
}
@ -337,11 +343,14 @@ static GRefPtr<GPtrArray> jscContextJSArrayToGArray(JSCContext* context, JSValue
GUniquePtr<char*> jscContextJSArrayToGStrv(JSCContext* context, JSValueRef jsArray, JSValueRef* exception)
{
JSCContextPrivate* priv = context->priv;
JSC::JSGlobalObject* globalObject = toJS(priv->jsContext.get());
JSC::JSLockHolder locker(globalObject);
if (JSValueIsNull(priv->jsContext.get(), jsArray))
return nullptr;
if (!JSValueIsArray(priv->jsContext.get(), jsArray)) {
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), makeString("invalid js type for GStrv")));
*exception = toRef(JSC::createTypeError(globalObject, makeString("invalid js type for GStrv")));
return nullptr;
}
@ -366,7 +375,7 @@ GUniquePtr<char*> jscContextJSArrayToGStrv(JSCContext* context, JSValueRef jsArr
auto jsValueItem = jscContextGetOrCreateValue(context, jsItem);
if (!jsc_value_is_string(jsValueItem.get())) {
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), makeString("invalid js type for GStrv: item ", String::number(i), " is not a string")));
*exception = toRef(JSC::createTypeError(globalObject, makeString("invalid js type for GStrv: item ", String::number(i), " is not a string")));
return nullptr;
}
@ -379,6 +388,8 @@ GUniquePtr<char*> jscContextJSArrayToGStrv(JSCContext* context, JSValueRef jsArr
JSValueRef jscContextGValueToJSValue(JSCContext* context, const GValue* value, JSValueRef* exception)
{
JSCContextPrivate* priv = context->priv;
JSC::JSGlobalObject* globalObject = toJS(priv->jsContext.get());
JSC::JSLockHolder locker(globalObject);
switch (g_type_fundamental(G_VALUE_TYPE(value))) {
case G_TYPE_BOOLEAN:
@ -446,15 +457,17 @@ JSValueRef jscContextGValueToJSValue(JSCContext* context, const GValue* value, J
break;
}
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), makeString("unsupported type ", g_type_name(G_VALUE_TYPE(value)))));
*exception = toRef(JSC::createTypeError(globalObject, makeString("unsupported type ", g_type_name(G_VALUE_TYPE(value)))));
return JSValueMakeUndefined(priv->jsContext.get());
}
void jscContextJSValueToGValue(JSCContext* context, JSValueRef jsValue, GType type, GValue* value, JSValueRef* exception)
{
JSCContextPrivate* priv = context->priv;
g_value_init(value, type);
JSC::JSGlobalObject* globalObject = toJS(priv->jsContext.get());
JSC::JSLockHolder locker(globalObject);
g_value_init(value, type);
auto fundamentalType = g_type_fundamental(G_VALUE_TYPE(value));
switch (fundamentalType) {
case G_TYPE_INT:
@ -528,7 +541,7 @@ void jscContextJSValueToGValue(JSCContext* context, JSValueRef jsValue, GType ty
return;
}
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), "invalid pointer type"_s));
*exception = toRef(JSC::createTypeError(globalObject, "invalid pointer type"_s));
return;
}
}
@ -539,7 +552,7 @@ void jscContextJSValueToGValue(JSCContext* context, JSValueRef jsValue, GType ty
else if (G_IS_OBJECT(wrappedObject))
g_value_set_object(value, wrappedObject);
else
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), "wrapped object is not a GObject"_s));
*exception = toRef(JSC::createTypeError(globalObject, "wrapped object is not a GObject"_s));
break;
}
case G_TYPE_LONG:
@ -564,7 +577,7 @@ void jscContextJSValueToGValue(JSCContext* context, JSValueRef jsValue, GType ty
case G_TYPE_INTERFACE:
case G_TYPE_VARIANT:
default:
*exception = toRef(JSC::createTypeError(toJS(priv->jsContext.get()), makeString("unsupported type ", g_type_name(G_VALUE_TYPE(value)))));
*exception = toRef(JSC::createTypeError(globalObject, makeString("unsupported type ", g_type_name(G_VALUE_TYPE(value)))));
break;
}
}
@ -879,10 +892,10 @@ JSCValue* jsc_context_evaluate_in_object(JSCContext* context, const char* code,
JSRetainPtr<JSGlobalContextRef> objectContext(Adopt,
instance ? jscClassCreateContextWithJSWrapper(objectClass, context, instance) : JSGlobalContextCreateInGroup(jscVirtualMachineGetContextGroup(context->priv->vm.get()), nullptr));
JSC::ExecState* exec = toJS(objectContext.get());
JSC::VM& vm = exec->vm();
auto* jsObject = vm.vmEntryGlobalObject(exec);
jsObject->setGlobalScopeExtension(JSC::JSWithScope::create(vm, jsObject, jsObject->globalScope(), toJS(JSContextGetGlobalObject(context->priv->jsContext.get()))));
JSC::JSGlobalObject* globalObject = toJS(objectContext.get());
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(globalObject);
globalObject->setGlobalScopeExtension(JSC::JSWithScope::create(vm, globalObject, globalObject->globalScope(), toJS(JSContextGetGlobalObject(context->priv->jsContext.get()))));
JSValueRef exception = nullptr;
JSValueRef result = evaluateScriptInContext(objectContext.get(), String::fromUTF8(code, length < 0 ? strlen(code) : length), uri, lineNumber, &exception);
if (jscContextHandleExceptionIfNeeded(context, exception))
@ -939,22 +952,22 @@ JSCCheckSyntaxResult jsc_context_check_syntax(JSCContext* context, const char* c
lineNumber = std::max<unsigned>(1, lineNumber);
auto* jsContext = context->priv->jsContext.get();
JSC::ExecState* exec = toJS(jsContext);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
String sourceURLString = uri ? String::fromUTF8(uri) : String();
JSC::SourceCode source = JSC::makeSource(String::fromUTF8(code, length < 0 ? strlen(code) : length), JSC::SourceOrigin { sourceURLString },
URL({ }, sourceURLString), TextPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber()));
URL sourceURL = uri ? URL({ }, uri) : URL();
JSC::SourceCode source = JSC::makeSource(String::fromUTF8(code, length < 0 ? strlen(code) : length), JSC::SourceOrigin { sourceURL },
sourceURL.string() , TextPosition(OrdinalNumber::fromOneBasedInt(lineNumber), OrdinalNumber()));
bool success = false;
JSC::ParserError error;
switch (mode) {
case JSC_CHECK_SYNTAX_MODE_SCRIPT:
success = !!JSC::parse<JSC::ProgramNode>(&vm, source, JSC::Identifier(), JSC::JSParserBuiltinMode::NotBuiltin,
success = !!JSC::parse<JSC::ProgramNode>(vm, source, JSC::Identifier(), JSC::JSParserBuiltinMode::NotBuiltin,
JSC::JSParserStrictMode::NotStrict, JSC::JSParserScriptMode::Classic, JSC::SourceParseMode::ProgramMode, JSC::SuperBinding::NotNeeded, error);
break;
case JSC_CHECK_SYNTAX_MODE_MODULE:
success = !!JSC::parse<JSC::ModuleProgramNode>(&vm, source, JSC::Identifier(), JSC::JSParserBuiltinMode::NotBuiltin,
success = !!JSC::parse<JSC::ModuleProgramNode>(vm, source, JSC::Identifier(), JSC::JSParserBuiltinMode::NotBuiltin,
JSC::JSParserStrictMode::Strict, JSC::JSParserScriptMode::Module, JSC::SourceParseMode::ModuleAnalyzeMode, JSC::SuperBinding::NotNeeded, error);
break;
}
@ -994,8 +1007,8 @@ JSCCheckSyntaxResult jsc_context_check_syntax(JSCContext* context, const char* c
}
if (exception) {
auto* jsError = error.toErrorObject(exec->lexicalGlobalObject(), source);
*exception = jscExceptionCreate(context, toRef(exec, jsError)).leakRef();
auto* jsError = error.toErrorObject(globalObject, source);
*exception = jscExceptionCreate(context, toRef(globalObject, jsError)).leakRef();
}
return result;

6
API/glib/JSCContextPrivate.h
View File

@ -25,9 +25,9 @@
#include "JSContextRef.h"
#include <wtf/glib/GRefPtr.h>
GRefPtr<JSCContext> jscContextGetOrCreate(JSGlobalContextRef);
JSGlobalContextRef jscContextGetJSContext(JSCContext*);
GRefPtr<JSCValue> jscContextGetOrCreateValue(JSCContext*, JSValueRef);
JS_EXPORT_PRIVATE GRefPtr<JSCContext> jscContextGetOrCreate(JSGlobalContextRef);
JS_EXPORT_PRIVATE JSGlobalContextRef jscContextGetJSContext(JSCContext*);
JS_EXPORT_PRIVATE GRefPtr<JSCValue> jscContextGetOrCreateValue(JSCContext*, JSValueRef);
void jscContextValueDestroyed(JSCContext*, JSValueRef);
JSC::JSObject* jscContextGetJSWrapper(JSCContext*, gpointer);
JSC::JSObject* jscContextGetOrCreateJSWrapper(JSCContext*, JSClassRef, JSValueRef prototype = nullptr, gpointer = nullptr, GDestroyNotify = nullptr);

4
API/glib/JSCException.cpp
View File

@ -74,8 +74,8 @@ GRefPtr<JSCException> jscExceptionCreate(JSCContext* context, JSValueRef jsExcep
{
GRefPtr<JSCException> exception = adoptGRef(JSC_EXCEPTION(g_object_new(JSC_TYPE_EXCEPTION, nullptr)));
auto* jsContext = jscContextGetJSContext(context);
JSC::ExecState* exec = toJS(jsContext);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
exception->priv->jsException.set(vm, toJS(JSValueToObject(jsContext, jsException, nullptr)));
// The context has a strong reference to the exception, so we can't ref the context. We use a weak

32
API/glib/JSCOptions.cpp
View File

@ -31,7 +31,7 @@
* @title: JSCOptions
*
* JavaScript options allow changing the behavior of the JavaScript engine.
* They affect the way the engine works, so it's encouraged to set the options
* They affect the way the engine works, so the options must be set
* at the very beginning of the program execution, before any other JavaScript
* API call. Most of the options are only useful for testing and debugging.
* Only a few of them are documented; you can use the undocumented options at
@ -166,9 +166,9 @@ static void valueToGValue(GCLogging::Level value, GValue* gValue)
static gboolean jscOptionsSetValue(const char* option, const GValue* value)
{
#define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
#define SET_OPTION_VALUE(type_, name_, defaultValue_, availability_, description_) \
if (!g_strcmp0(#name_, option)) { \
type_ valueToSet; \
OptionsStorage::type_ valueToSet; \
if (!valueFromGValue(value, valueToSet)) \
return FALSE; \
Options::name_() = valueToSet; \
@ -176,24 +176,24 @@ static gboolean jscOptionsSetValue(const char* option, const GValue* value)
}
Options::initialize();
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
FOR_EACH_JSC_OPTION(SET_OPTION_VALUE)
#undef SET_OPTION_VALUE
return FALSE;
}
static gboolean jscOptionsGetValue(const char* option, GValue* value)
{
#define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
#define GET_OPTION_VALUE(type_, name_, defaultValue_, availability_, description_) \
if (!g_strcmp0(#name_, option)) { \
type_ valueToGet = Options::name_(); \
OptionsStorage::type_ valueToGet = Options::name_(); \
valueToGValue(valueToGet, value); \
return TRUE; \
}
Options::initialize();
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
FOR_EACH_JSC_OPTION(GET_OPTION_VALUE)
#undef GET_OPTION_VALUE
return FALSE;
}
@ -614,18 +614,18 @@ void jsc_options_foreach(JSCOptionsFunc function, gpointer userData)
{
g_return_if_fail(function);
#define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
#define VISIT_OPTION(type_, name_, defaultValue_, availability_, description_) \
if (Options::Availability::availability_ == Options::Availability::Normal \
|| Options::isAvailable(Options::name_##ID, Options::Availability::availability_)) { \
type_ defaultValue { }; \
OptionsStorage::type_ defaultValue { }; \
auto optionType = jscOptionsType(defaultValue); \
if (function (#name_, optionType, description_, userData)) \
return; \
}
Options::initialize();
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
FOR_EACH_JSC_OPTION(VISIT_OPTION)
#undef VISIT_OPTION
}
static gboolean setOptionEntry(const char* optionNameFull, const char* value, gpointer, GError** error)
@ -664,7 +664,7 @@ GOptionGroup* jsc_options_get_option_group(void)
g_option_group_set_translation_domain(group, GETTEXT_PACKAGE);
GArray* entries = g_array_new(TRUE, TRUE, sizeof(GOptionEntry));
#define FOR_EACH_OPTION(type_, name_, defaultValue_, availability_, description_) \
#define REGISTER_OPTION(type_, name_, defaultValue_, availability_, description_) \
if (Options::Availability::availability_ == Options::Availability::Normal \
|| Options::isAvailable(Options::name_##ID, Options::Availability::availability_)) { \
GUniquePtr<char> name(g_strdup_printf("jsc-%s", #name_)); \
@ -678,8 +678,8 @@ GOptionGroup* jsc_options_get_option_group(void)
}
Options::initialize();
JSC_OPTIONS(FOR_EACH_OPTION)
#undef FOR_EACH_OPTION
FOR_EACH_JSC_OPTION(REGISTER_OPTION)
#undef REGISTER_OPTION
g_option_group_add_entries(group, reinterpret_cast<GOptionEntry*>(entries->data));
return group;

134
API/glib/JSCValue.cpp
View File

@ -28,6 +28,7 @@
#include "JSCInlines.h"
#include "JSCValuePrivate.h"
#include "JSRetainPtr.h"
#include "LiteralParser.h"
#include "OpaqueJSString.h"
#include <gobject/gvaluecollector.h>
#include <wtf/glib/GRefPtr.h>
@ -472,8 +473,11 @@ JSCValue* jsc_value_new_array(JSCContext* context, GType firstItemType, ...)
{
g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);
JSValueRef exception = nullptr;
auto* jsContext = jscContextGetJSContext(context);
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::JSLockHolder locker(globalObject);
JSValueRef exception = nullptr;
auto* jsArray = JSObjectMakeArray(jsContext, 0, nullptr, &exception);
if (jscContextHandleExceptionIfNeeded(context, exception))
return nullptr;
@ -491,7 +495,7 @@ JSCValue* jsc_value_new_array(JSCContext* context, GType firstItemType, ...)
GUniqueOutPtr<char> error;
G_VALUE_COLLECT_INIT(&item, itemType, args, G_VALUE_NOCOPY_CONTENTS, &error.outPtr());
if (error) {
exception = toRef(JSC::createTypeError(toJS(jsContext), makeString("failed to collect array item: ", error.get())));
exception = toRef(JSC::createTypeError(globalObject, makeString("failed to collect array item: ", error.get())));
jscContextHandleExceptionIfNeeded(context, exception);
jsArray = nullptr;
break;
@ -878,6 +882,8 @@ static GRefPtr<JSCValue> jscValueCallFunction(JSCValue* value, JSObjectRef funct
{
JSCValuePrivate* priv = value->priv;
auto* jsContext = jscContextGetJSContext(priv->context.get());
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::JSLockHolder locker(globalObject);
JSValueRef exception = nullptr;
Vector<JSValueRef> arguments;
@ -887,7 +893,7 @@ static GRefPtr<JSCValue> jscValueCallFunction(JSCValue* value, JSObjectRef funct
GUniqueOutPtr<char> error;
G_VALUE_COLLECT_INIT(&parameter, parameterType, args, G_VALUE_NOCOPY_CONTENTS, &error.outPtr());
if (error) {
exception = toRef(JSC::createTypeError(toJS(jsContext), makeString("failed to collect function paramater: ", error.get())));
exception = toRef(JSC::createTypeError(globalObject, makeString("failed to collect function paramater: ", error.get())));
jscContextHandleExceptionIfNeeded(priv->context.get(), exception);
return adoptGRef(jsc_value_new_undefined(priv->context.get()));
}
@ -1004,7 +1010,7 @@ JSCValue* jsc_value_object_invoke_methodv(JSCValue* value, const char* name, uns
auto result = jsObjectCall(jsContext, function, JSC::JSCCallbackFunction::Type::Method, object, arguments, &exception);
if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))
jsc_value_new_undefined(priv->context.get());
return jsc_value_new_undefined(priv->context.get());
return jscContextGetOrCreateValue(priv->context.get(), result).leakRef();
}
@ -1039,15 +1045,15 @@ void jsc_value_object_define_property_data(JSCValue* value, const char* property
JSCValuePrivate* priv = value->priv;
auto* jsContext = jscContextGetJSContext(priv->context.get());
JSC::ExecState* exec = toJS(jsContext);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSC::JSValue jsValue = toJS(exec, priv->jsValue);
JSC::JSObject* object = jsValue.toObject(exec);
JSC::JSValue jsValue = toJS(globalObject, priv->jsValue);
JSC::JSObject* object = jsValue.toObject(globalObject);
JSValueRef exception = nullptr;
if (handleExceptionIfNeeded(scope, exec, &exception) == ExceptionStatus::DidThrow) {
if (handleExceptionIfNeeded(scope, jsContext, &exception) == ExceptionStatus::DidThrow) {
jscContextHandleExceptionIfNeeded(priv->context.get(), exception);
return;
}
@ -1057,12 +1063,12 @@ void jsc_value_object_define_property_data(JSCValue* value, const char* property
return;
JSC::PropertyDescriptor descriptor;
descriptor.setValue(toJS(exec, propertyValue->priv->jsValue));
descriptor.setValue(toJS(globalObject, propertyValue->priv->jsValue));
descriptor.setEnumerable(flags & JSC_VALUE_PROPERTY_ENUMERABLE);
descriptor.setConfigurable(flags & JSC_VALUE_PROPERTY_CONFIGURABLE);
descriptor.setWritable(flags & JSC_VALUE_PROPERTY_WRITABLE);
object->methodTable(vm)->defineOwnProperty(object, exec, name->identifier(&vm), descriptor, true);
if (handleExceptionIfNeeded(scope, exec, &exception) == ExceptionStatus::DidThrow) {
object->methodTable(vm)->defineOwnProperty(object, globalObject, name->identifier(&vm), descriptor, true);
if (handleExceptionIfNeeded(scope, jsContext, &exception) == ExceptionStatus::DidThrow) {
jscContextHandleExceptionIfNeeded(priv->context.get(), exception);
return;
}
@ -1099,15 +1105,15 @@ void jsc_value_object_define_property_accessor(JSCValue* value, const char* prop
JSCValuePrivate* priv = value->priv;
auto* jsContext = jscContextGetJSContext(priv->context.get());
JSC::ExecState* exec = toJS(jsContext);
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto scope = DECLARE_CATCH_SCOPE(vm);
JSC::JSValue jsValue = toJS(exec, priv->jsValue);
JSC::JSObject* object = jsValue.toObject(exec);
JSC::JSValue jsValue = toJS(globalObject, priv->jsValue);
JSC::JSObject* object = jsValue.toObject(globalObject);
JSValueRef exception = nullptr;
if (handleExceptionIfNeeded(scope, exec, &exception) == ExceptionStatus::DidThrow) {
if (handleExceptionIfNeeded(scope, jsContext, &exception) == ExceptionStatus::DidThrow) {
jscContextHandleExceptionIfNeeded(priv->context.get(), exception);
return;
}
@ -1121,18 +1127,18 @@ void jsc_value_object_define_property_accessor(JSCValue* value, const char* prop
descriptor.setConfigurable(flags & JSC_VALUE_PROPERTY_CONFIGURABLE);
if (getter) {
GRefPtr<GClosure> closure = adoptGRef(g_cclosure_new(getter, userData, reinterpret_cast<GClosureNotify>(reinterpret_cast<GCallback>(destroyNotify))));
auto function = JSC::JSCCallbackFunction::create(vm, exec->lexicalGlobalObject(), "get"_s,
auto function = JSC::JSCCallbackFunction::create(vm, globalObject, "get"_s,
JSC::JSCCallbackFunction::Type::Method, nullptr, WTFMove(closure), propertyType, Vector<GType> { });
descriptor.setGetter(function);
}
if (setter) {
GRefPtr<GClosure> closure = adoptGRef(g_cclosure_new(setter, userData, getter ? nullptr : reinterpret_cast<GClosureNotify>(reinterpret_cast<GCallback>(destroyNotify))));
auto function = JSC::JSCCallbackFunction::create(vm, exec->lexicalGlobalObject(), "set"_s,
auto function = JSC::JSCCallbackFunction::create(vm, globalObject, "set"_s,
JSC::JSCCallbackFunction::Type::Method, nullptr, WTFMove(closure), G_TYPE_NONE, Vector<GType> { propertyType });
descriptor.setSetter(function);
}
object->methodTable(vm)->defineOwnProperty(object, exec, name->identifier(&vm), descriptor, true);
if (handleExceptionIfNeeded(scope, exec, &exception) == ExceptionStatus::DidThrow) {
object->methodTable(vm)->defineOwnProperty(object, globalObject, name->identifier(&vm), descriptor, true);
if (handleExceptionIfNeeded(scope, jsContext, &exception) == ExceptionStatus::DidThrow) {
jscContextHandleExceptionIfNeeded(priv->context.get(), exception);
return;
}
@ -1147,10 +1153,10 @@ static GRefPtr<JSCValue> jscValueFunctionCreate(JSCContext* context, const char*
closure = adoptGRef(g_cclosure_new_swap(callback, userData, reinterpret_cast<GClosureNotify>(reinterpret_cast<GCallback>(destroyNotify))));
else
closure = adoptGRef(g_cclosure_new(callback, userData, reinterpret_cast<GClosureNotify>(reinterpret_cast<GCallback>(destroyNotify))));
JSC::ExecState* exec = toJS(jscContextGetJSContext(context));
JSC::VM& vm = exec->vm();
JSC::JSGlobalObject* globalObject = toJS(jscContextGetJSContext(context));
JSC::VM& vm = globalObject->vm();
JSC::JSLockHolder locker(vm);
auto* functionObject = toRef(JSC::JSCCallbackFunction::create(vm, exec->lexicalGlobalObject(), name ? String::fromUTF8(name) : "anonymous"_s,
auto* functionObject = toRef(JSC::JSCCallbackFunction::create(vm, globalObject, name ? String::fromUTF8(name) : "anonymous"_s,
JSC::JSCCallbackFunction::Type::Function, nullptr, WTFMove(closure), returnType, WTFMove(parameters)));
return jscContextGetOrCreateValue(context, functionObject);
}
@ -1441,3 +1447,83 @@ JSCValue* jsc_value_constructor_callv(JSCValue* value, unsigned parametersCount,
return jscContextGetOrCreateValue(priv->context.get(), result).leakRef();
}
/**
* jsc_value_new_from_json:
* @context: a #JSCContext
* @json: the JSON string to be parsed
*
* Create a new #JSCValue referencing a new value created by parsing @json.
*
* Returns: (transfer full): a #JSCValue.
*
* Since: 2.28
*/
JSCValue* jsc_value_new_from_json(JSCContext* context, const char* json)
{
g_return_val_if_fail(JSC_IS_CONTEXT(context), nullptr);
if (!json)
return jsc_value_new_null(context);
auto* jsContext = jscContextGetJSContext(context);
JSC::JSGlobalObject* globalObject = toJS(jsContext);
JSC::JSLockHolder locker(globalObject);
JSValueRef exception = nullptr;
JSC::JSValue jsValue;
String jsonString = String::fromUTF8(json);
if (jsonString.is8Bit()) {
JSC::LiteralParser<LChar> jsonParser(globalObject, jsonString.characters8(), jsonString.length(), JSC::StrictJSON);
jsValue = jsonParser.tryLiteralParse();
if (!jsValue)
exception = toRef(JSC::createSyntaxError(globalObject, jsonParser.getErrorMessage()));
} else {
JSC::LiteralParser<UChar> jsonParser(globalObject, jsonString.characters16(), jsonString.length(), JSC::StrictJSON);
jsValue = jsonParser.tryLiteralParse();
if (!jsValue)
exception = toRef(JSC::createSyntaxError(globalObject, jsonParser.getErrorMessage()));
}
if (exception) {
jscContextHandleExceptionIfNeeded(context, exception);
return nullptr;
}
return jsValue ? jscContextGetOrCreateValue(context, toRef(globalObject, jsValue)).leakRef() : nullptr;
}
/**
* jsc_value_to_json:
* @value: a #JSCValue
* @indent: The number of spaces to indent when nesting.
*
* Create a JSON string of @value serialization. If @indent is 0, the resulting JSON will
* not contain newlines. The size of the indent is clamped to 10 spaces.
*
* Returns: (transfer full): a null-terminated JSON string with serialization of @value
*
* Since: 2.28
*/
char* jsc_value_to_json(JSCValue* value, unsigned indent)
{
g_return_val_if_fail(JSC_IS_VALUE(value), nullptr);
JSCValuePrivate* priv = value->priv;
JSValueRef exception = nullptr;
JSRetainPtr<JSStringRef> jsJSON(Adopt, JSValueCreateJSONString(jscContextGetJSContext(priv->context.get()), priv->jsValue, indent, &exception));
if (jscContextHandleExceptionIfNeeded(priv->context.get(), exception))
return nullptr;
if (!jsJSON)
return nullptr;
size_t maxSize = JSStringGetMaximumUTF8CStringSize(jsJSON.get());
auto* json = static_cast<char*>(g_malloc(maxSize));
if (!JSStringGetUTF8CString(jsJSON.get(), json, maxSize)) {
g_free(json);
return nullptr;
}
return json;
}

8
API/glib/JSCValue.h
View File

@ -260,6 +260,14 @@ jsc_value_constructor_callv (JSCValue *value,
guint n_parameters,
JSCValue **parameters);
JSC_API JSCValue *
jsc_value_new_from_json (JSCContext *context,
const char *json);
JSC_API char *
jsc_value_to_json (JSCValue *value,
guint indent);
G_END_DECLS
#endif /* JSCValue_h */

2
API/glib/JSCValuePrivate.h
View File

@ -21,5 +21,5 @@
#include "JSCValue.h"
JSValueRef jscValueGetJSValue(JSCValue*);
JS_EXPORT_PRIVATE JSValueRef jscValueGetJSValue(JSCValue*);
JSCValue* jscValueCreate(JSCContext*, JSValueRef);

14
API/glib/JSCVirtualMachine.cpp
View File

@ -33,7 +33,7 @@
* @see_also: JSCContext
*
* JSCVirtualMachine represents a group of JSCContext<!-- -->s. It allows
* concurrent JavaScript exeution by creating a different instance of
* concurrent JavaScript execution by creating a different instance of
* JSCVirtualMachine in each thread.
*
* To create a group of JSCContext<!-- -->s pass the same JSCVirtualMachine
@ -51,20 +51,24 @@ static Lock wrapperCacheMutex;
static HashMap<JSContextGroupRef, JSCVirtualMachine*>& wrapperMap()
{
static NeverDestroyed<HashMap<JSContextGroupRef, JSCVirtualMachine*>> map;
return map;
static LazyNeverDestroyed<HashMap<JSContextGroupRef, JSCVirtualMachine*>> shared;
static std::once_flag onceKey;
std::call_once(onceKey, [&] {
shared.construct();
});
return shared;
}
static void addWrapper(JSContextGroupRef group, JSCVirtualMachine* vm)
{
std::lock_guard<Lock> lock(wrapperCacheMutex);
auto locker = holdLock(wrapperCacheMutex);
ASSERT(!wrapperMap().contains(group));
wrapperMap().set(group, vm);
}
static void removeWrapper(JSContextGroupRef group)
{
std::lock_guard<Lock> lock(wrapperCacheMutex);
auto locker = holdLock(wrapperCacheMutex);
ASSERT(wrapperMap().contains(group));
wrapperMap().remove(group);
}

17
API/glib/JSCWeakValue.cpp
View File

@ -70,9 +70,9 @@ static void jscWeakValueClear(JSCWeakValue* weakValue)
priv->weakValueRef.clear();
}
class JSCWeakValueHandleOwner : public JSC::WeakHandleOwner {
class JSCWeakValueHandleOwner final : public JSC::WeakHandleOwner {
public:
void finalize(JSC::Handle<JSC::Unknown>, void* context) override
void finalize(JSC::Handle<JSC::Unknown>, void* context) final
{
auto* weakValue = JSC_WEAK_VALUE(context);
jscWeakValueClear(weakValue);
@ -90,14 +90,13 @@ static void jscWeakValueInitialize(JSCWeakValue* weakValue, JSCValue* value)
{
JSCWeakValuePrivate* priv = weakValue->priv;
auto* jsContext = jscContextGetJSContext(jsc_value_get_context(value));
JSC::ExecState* exec = toJS(jsContext);
JSC::JSGlobalObject* globalObject = exec->lexicalGlobalObject();
JSC::JSGlobalObject* globalObject = toJS(jsContext);
auto& owner = weakValueHandleOwner();
JSC::Weak<JSC::JSGlobalObject> weak(globalObject, &owner, weakValue);
priv->globalObject.swap(weak);
priv->lock = &exec->vm().apiLock();
priv->lock = &globalObject->vm().apiLock();
JSC::JSValue jsValue = toJS(exec, jscValueGetJSValue(value));
JSC::JSValue jsValue = toJS(globalObject, jscValueGetJSValue(value));
if (jsValue.isObject())
priv->weakValueRef.setObject(JSC::jsCast<JSC::JSObject*>(jsValue.asCell()), owner, weakValue);
else if (jsValue.isString())
@ -206,7 +205,7 @@ JSCValue* jsc_weak_value_get_value(JSCWeakValue* weakValue)
else
value = priv->weakValueRef.object();
JSC::ExecState* exec = priv->globalObject->globalExec();
GRefPtr<JSCContext> context = jscContextGetOrCreate(toGlobalRef(exec));
return jscContextGetOrCreateValue(context.get(), toRef(exec, value)).leakRef();
JSC::JSGlobalObject* globalObject = priv->globalObject.get();
GRefPtr<JSCContext> context = jscContextGetOrCreate(toGlobalRef(globalObject));
return jscContextGetOrCreateValue(context.get(), toRef(globalObject, value)).leakRef();
}

17
API/glib/JSCWrapperMap.cpp
View File

@ -33,7 +33,7 @@
namespace JSC {
WrapperMap::WrapperMap(JSGlobalContextRef jsContext)
: m_cachedJSWrappers(std::make_unique<JSC::WeakGCMap<gpointer, JSC::JSObject>>(toJS(jsContext)->vm()))
: m_cachedJSWrappers(makeUnique<JSC::WeakGCMap<gpointer, JSC::JSObject>>(toJS(jsContext)->vm()))
{
}
@ -77,17 +77,17 @@ JSCClass* WrapperMap::registeredClass(JSClassRef jsClass) const
JSObject* WrapperMap::createJSWrappper(JSGlobalContextRef jsContext, JSClassRef jsClass, JSValueRef prototype, gpointer wrappedObject, GDestroyNotify destroyFunction)
{
ASSERT(toJSGlobalObject(jsContext)->wrapperMap() == this);
ExecState* exec = toJS(jsContext);
VM& vm = exec->vm();
JSGlobalObject* globalObject = toJS(jsContext);
VM& vm = globalObject->vm();
JSLockHolder locker(vm);
auto* object = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->glibWrapperObjectStructure(), jsClass, nullptr);
auto* object = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(globalObject, globalObject->glibWrapperObjectStructure(), jsClass, nullptr);
if (wrappedObject) {
object->setWrappedObject(new JSC::JSCGLibWrapperObject(wrappedObject, destroyFunction));
m_cachedJSWrappers->set(wrappedObject, object);
}
if (prototype)
JSObjectSetPrototype(jsContext, toRef(object), prototype);
else if (auto* jsPrototype = jsClass->prototype(exec))
else if (auto* jsPrototype = jsClass->prototype(globalObject))
object->setPrototypeDirect(vm, jsPrototype);
return object;
}
@ -101,15 +101,14 @@ JSGlobalContextRef WrapperMap::createContextWithJSWrappper(JSContextGroupRef jsG
globalObject->setWrappedObject(new JSC::JSCGLibWrapperObject(wrappedObject, destroyFunction));
m_cachedJSWrappers->set(wrappedObject, globalObject);
}
ExecState* exec = globalObject->globalExec();
if (prototype)
globalObject->resetPrototype(vm.get(), toJS(exec, prototype));
else if (auto jsPrototype = jsClass->prototype(exec))
globalObject->resetPrototype(vm.get(), toJS(globalObject, prototype));
else if (auto jsPrototype = jsClass->prototype(globalObject))
globalObject->resetPrototype(vm.get(), jsPrototype);
else
globalObject->resetPrototype(vm.get(), jsNull());
return JSGlobalContextRetain(toGlobalRef(exec));
return JSGlobalContextRetain(toGlobalRef(globalObject));
}
JSObject* WrapperMap::jsWrapper(gpointer wrappedObject) const

2
API/glib/docs/jsc-glib-4.0-sections.txt
View File

@ -113,6 +113,8 @@ jsc_value_function_callv
jsc_value_is_constructor
jsc_value_constructor_call
jsc_value_constructor_callv
jsc_value_new_from_json
jsc_value_to_json
<SUBSECTION Standard>
JSCValueClass

5
API/glib/docs/jsc-glib-docs.sgml
View File

@ -30,5 +30,10 @@
<xi:include href="xml/api-index-2.24.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-28" role="2.28">
<title>Index of new symbols in 2.28</title>
<xi:include href="xml/api-index-2.28.xml"><xi:fallback /></xi:include>
</index>
<xi:include href="xml/annotation-glossary.xml"><xi:fallback /></xi:include>
</book>

12
API/tests/CompareAndSwapTest.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2015 Apple Inc. All rights reserved.
* Copyright (C) 2015-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -40,11 +40,11 @@ public:
inline size_t numBits() const { return words * wordSize; }
private:
static const size_t Size = 4096*10;
static constexpr size_t Size = 4096*10;
static const unsigned wordSize = sizeof(uint8_t) * 8;
static const unsigned words = (Size + wordSize - 1) / wordSize;
static const uint8_t one = 1;
static constexpr unsigned wordSize = sizeof(uint8_t) * 8;
static constexpr unsigned words = (Size + wordSize - 1) / wordSize;
static constexpr uint8_t one = 1;
uint8_t bits[words];
};
@ -100,7 +100,7 @@ void testCompareAndSwap()
RefPtr<Thread> threads[numThreads];
Data data[numThreads];
WTF::initializeThreading();
WTF::initialize();
printf("Starting %d threads for CompareAndSwap test. Test should complete without hanging.\n", numThreads);
for (int i = 0; i < numThreads; i++) {

4
API/tests/CurrentThisInsideBlockGetterTest.mm
View File

@ -23,8 +23,8 @@
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "CurrentThisInsideBlockGetterTest.h"
#import "config.h"
#import "CurrentThisInsideBlockGetterTest.h"
#if JSC_OBJC_API_ENABLED

152
API/tests/ExecutionTimeLimitTest.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2015 Apple Inc. All rights reserved.
* Copyright (C) 2015-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -30,8 +30,6 @@
#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"
#include <wtf/Atomics.h>
#include <wtf/CPUTime.h>
#include <wtf/Condition.h>
#include <wtf/Lock.h>
@ -78,7 +76,7 @@ static bool extendTerminateCallback(JSContextRef ctx, void*)
extendTerminateCallbackCalled++;
if (extendTerminateCallbackCalled == 1) {
JSContextGroupRef contextGroup = JSContextGetGroup(ctx);
JSContextGroupSetExecutionTimeLimit(contextGroup, .200f, extendTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, .200f, extendTerminateCallback, nullptr);
return false;
}
return true;
@ -122,13 +120,14 @@ int testExecutionTimeLimit()
{ "LLINT", 0_ms, "--useConcurrentJIT=false --useLLInt=true --useJIT=false" },
{ "Baseline", 0_ms, "--useConcurrentJIT=false --useLLInt=true --useJIT=true --useDFGJIT=false" },
{ "DFG", 200_ms, "--useConcurrentJIT=false --useLLInt=true --useJIT=true --useDFGJIT=true --useFTLJIT=false" },
#if ENABLE(FTL_JIT)
{ "FTL", 500_ms, "--useConcurrentJIT=false --useLLInt=true --useJIT=true --useDFGJIT=true --useFTLJIT=true" },
#endif
};
bool failed = false;
JSC::initializeThreading();
Options::initialize(); // Ensure options is initialized first.
JSC::initialize();
for (auto tierOptions : tierOptionsList) {
StringBuilder savedOptionsBuilder;
@ -154,9 +153,13 @@ int testExecutionTimeLimit()
/* Test script on another thread: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, nullptr);
{
#if OS(LINUX) && (CPU(MIPS) || CPU(ARM_THUMB2))
Seconds timeAfterWatchdogShouldHaveFired = 500_ms + tierAdjustment;
#else
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
#endif
JSStringRef script = JSStringCreateWithUTF8CString("function foo() { while (true) { } } foo();");
exception = nullptr;
@ -188,16 +191,22 @@ int testExecutionTimeLimit()
/* Test script timeout: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, nullptr);
{
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("function foo() { var startTime = currentCPUTime(); while (true) { for (var i = 0; i < 1000; i++); if (currentCPUTime() - startTime > ");
scriptBuilder.appendFixedPrecisionNumber(timeAfterWatchdogShouldHaveFired.seconds());
scriptBuilder.appendLiteral(") break; } } foo();");
CString scriptText = makeString(
"function foo() {"
"var startTime = currentCPUTime();"
"while (true) {"
"for (var i = 0; i < 1000; i++);"
"if (currentCPUTime() - startTime > ", timeAfterWatchdogShouldHaveFired.seconds(), ") break;"
"}"
"}"
"foo();"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
shouldTerminateCallbackWasCalled = false;
auto startTime = CPUTime::forCurrentThread();
@ -225,23 +234,22 @@ int testExecutionTimeLimit()
/* Test script timeout with tail calls: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, nullptr);
{
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("var startTime = currentCPUTime();"
"function recurse(i) {"
"'use strict';"
"if (i % 1000 === 0) {"
"if (currentCPUTime() - startTime >");
scriptBuilder.appendFixedPrecisionNumber(timeAfterWatchdogShouldHaveFired.seconds());
scriptBuilder.appendLiteral(" ) { return; }");
scriptBuilder.appendLiteral(" }");
scriptBuilder.appendLiteral(" return recurse(i + 1); }");
scriptBuilder.appendLiteral("recurse(0);");
CString scriptText = makeString(
"var startTime = currentCPUTime();"
"function recurse(i) {"
"'use strict';"
"if (i % 1000 === 0) {"
"if (currentCPUTime() - startTime >", timeAfterWatchdogShouldHaveFired.seconds(), ") { return; }"
"}"
"return recurse(i + 1); }"
"recurse(0);"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
shouldTerminateCallbackWasCalled = false;
auto startTime = CPUTime::forCurrentThread();
@ -269,16 +277,24 @@ int testExecutionTimeLimit()
/* Test the script timeout's TerminatedExecutionException should NOT be catchable: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), shouldTerminateCallback, nullptr);
{
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("function foo() { var startTime = currentCPUTime(); try { while (true) { for (var i = 0; i < 1000; i++); if (currentCPUTime() - startTime > ");
scriptBuilder.appendFixedPrecisionNumber(timeAfterWatchdogShouldHaveFired.seconds());
scriptBuilder.appendLiteral(") break; } } catch(e) { } } foo();");
CString scriptText = makeString(
"function foo() {"
"var startTime = currentCPUTime();"
"try {"
"while (true) {"
"for (var i = 0; i < 1000; i++);"
"if (currentCPUTime() - startTime > ", timeAfterWatchdogShouldHaveFired.seconds(), ") break;"
"}"
"} catch(e) { }"
"}"
"foo();"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
shouldTerminateCallbackWasCalled = false;
@ -308,16 +324,22 @@ int testExecutionTimeLimit()
/* Test script timeout with no callback: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), 0, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), nullptr, nullptr);
{
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("function foo() { var startTime = currentCPUTime(); while (true) { for (var i = 0; i < 1000; i++); if (currentCPUTime() - startTime > ");
scriptBuilder.appendFixedPrecisionNumber(timeAfterWatchdogShouldHaveFired.seconds());
scriptBuilder.appendLiteral(") break; } } foo();");
CString scriptText = makeString(
"function foo() {"
"var startTime = currentCPUTime();"
"while (true) {"
"for (var i = 0; i < 1000; i++);"
"if (currentCPUTime() - startTime > ", timeAfterWatchdogShouldHaveFired.seconds(), ") break;"
"}"
"}"
"foo();"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
shouldTerminateCallbackWasCalled = false;
@ -347,16 +369,22 @@ int testExecutionTimeLimit()
/* Test script timeout cancellation: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), cancelTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), cancelTerminateCallback, nullptr);
{
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("function foo() { var startTime = currentCPUTime(); while (true) { for (var i = 0; i < 1000; i++); if (currentCPUTime() - startTime > ");
scriptBuilder.appendFixedPrecisionNumber(timeAfterWatchdogShouldHaveFired.seconds());
scriptBuilder.appendLiteral(") break; } } foo();");
CString scriptText = makeString(
"function foo() {"
"var startTime = currentCPUTime();"
"while (true) {"
"for (var i = 0; i < 1000; i++);"
"if (currentCPUTime() - startTime > ", timeAfterWatchdogShouldHaveFired.seconds(), ") break;"
"}"
"}"
"foo();"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
cancelTerminateCallbackWasCalled = false;
@ -384,18 +412,24 @@ int testExecutionTimeLimit()
/* Test script timeout extension: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), extendTerminateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), extendTerminateCallback, nullptr);
{
Seconds timeBeforeExtendedDeadline = 250_ms + tierAdjustment;
Seconds timeAfterExtendedDeadline = 600_ms + tierAdjustment;
Seconds maxBusyLoopTime = 750_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("function foo() { var startTime = currentCPUTime(); while (true) { for (var i = 0; i < 1000; i++); if (currentCPUTime() - startTime > ");
scriptBuilder.appendFixedPrecisionNumber(maxBusyLoopTime.seconds()); // in seconds.
scriptBuilder.appendLiteral(") break; } } foo();");
CString scriptText = makeString(
"function foo() {"
"var startTime = currentCPUTime();"
"while (true) {"
"for (var i = 0; i < 1000; i++);"
"if (currentCPUTime() - startTime > ", maxBusyLoopTime.seconds(), ") break;"
"}"
"}"
"foo();"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
extendTerminateCallbackCalled = 0;
@ -429,16 +463,22 @@ int testExecutionTimeLimit()
#if HAVE(MACH_EXCEPTIONS)
/* Test script timeout from dispatch queue: */
timeLimit = 100_ms + tierAdjustment;
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), dispatchTermitateCallback, 0);
JSContextGroupSetExecutionTimeLimit(contextGroup, timeLimit.seconds(), dispatchTermitateCallback, nullptr);
{
Seconds timeAfterWatchdogShouldHaveFired = 300_ms + tierAdjustment;
StringBuilder scriptBuilder;
scriptBuilder.appendLiteral("function foo() { var startTime = currentCPUTime(); while (true) { for (var i = 0; i < 1000; i++); if (currentCPUTime() - startTime > ");
scriptBuilder.appendFixedPrecisionNumber(timeAfterWatchdogShouldHaveFired.seconds());
scriptBuilder.appendLiteral(") break; } } foo();");
CString scriptText = makeString(
"function foo() {"
"var startTime = currentCPUTime();"
"while (true) {"
"for (var i = 0; i < 1000; i++);"
"if (currentCPUTime() - startTime > ", timeAfterWatchdogShouldHaveFired.seconds(), ") break;"
"}"
"}"
"foo();"
).utf8();
JSStringRef script = JSStringCreateWithUTF8CString(scriptBuilder.toString().utf8().data());
JSStringRef script = JSStringCreateWithUTF8CString(scriptText.data());
exception = nullptr;
dispatchTerminateCallbackCalled = false;

7
API/tests/FunctionOverridesTest.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 Apple Inc. All rights reserved.
* Copyright (C) 2016-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -28,10 +28,8 @@
#include "FunctionOverrides.h"
#include "InitializeThreading.h"
#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"
#include <string>
using JSC::Options;
@ -39,8 +37,7 @@ int testFunctionOverrides()
{
bool failed = false;
JSC::initializeThreading();
Options::initialize(); // Ensure options is initialized first.
JSC::initialize();
const char* oldFunctionOverrides = Options::functionOverrides();

2
API/tests/GlobalContextWithFinalizerTest.h
View File

@ -25,8 +25,6 @@
#pragma once
#include "JSContextRefPrivate.h"
#ifdef __cplusplus
extern "C" {
#endif

11
API/tests/JSONParseTest.cpp
View File

@ -43,14 +43,13 @@ int testJSONParse()
JSLockHolder locker(vm.get());
JSGlobalObject* globalObject = JSGlobalObject::create(*vm, JSGlobalObject::createStructure(*vm, jsNull()));
ExecState* exec = globalObject->globalExec();
JSValue v0 = JSONParse(exec, "");
JSValue v1 = JSONParse(exec, "#$%^");
JSValue v2 = JSONParse(exec, String());
JSValue v0 = JSONParse(globalObject, "");
JSValue v1 = JSONParse(globalObject, "#$%^");
JSValue v2 = JSONParse(globalObject, String());
UChar emptyUCharArray[1] = { '\0' };
JSValue v3 = JSONParse(exec, String(emptyUCharArray, 0));
JSValue v3 = JSONParse(globalObject, String(emptyUCharArray, 0));
JSValue v4;
JSValue v5 = JSONParse(exec, "123");
JSValue v5 = JSONParse(globalObject, "123");
failed = failed || (v0 != v1);
failed = failed || (v1 != v2);

13
API/tests/JSObjectGetProxyTargetTest.cpp
View File

@ -27,12 +27,10 @@
#include "JSObjectGetProxyTargetTest.h"
#include "APICast.h"
#include "InitializeThreading.h"
#include "JSCInlines.h"
#include "JSObjectRefPrivate.h"
#include "JSProxy.h"
#include "JavaScript.h"
#include "Options.h"
#include "ProxyObject.h"
using namespace JSC;
@ -51,12 +49,11 @@ int testJSObjectGetProxyTarget()
JSContextGroupRef group = JSContextGroupCreate();
JSGlobalContextRef context = JSGlobalContextCreateInGroup(group, nullptr);
ExecState* exec = toJS(context);
VM& vm = *toJS(group);
JSObjectRef globalObjectProxy = JSContextGetGlobalObject(context);
JSGlobalObject* globalObjectObject;
JSObjectRef globalObject;
JSObjectRef globalObjectRef;
JSProxy* jsProxyObject;
{
@ -64,7 +61,7 @@ int testJSObjectGetProxyTarget()
JSProxy* globalObjectProxyObject = jsCast<JSProxy*>(toJS(globalObjectProxy));
globalObjectObject = jsCast<JSGlobalObject*>(globalObjectProxyObject->target());
Structure* proxyStructure = JSProxy::createStructure(vm, globalObjectObject, globalObjectObject->objectPrototype(), PureForwardingProxyType);
globalObject = toRef(globalObjectObject);
globalObjectRef = toRef(jsCast<JSObject*>(globalObjectObject));
jsProxyObject = JSProxy::create(vm, proxyStructure);
}
@ -76,7 +73,7 @@ int testJSObjectGetProxyTarget()
JSLockHolder locker(vm);
Structure* emptyObjectStructure = JSFinalObject::createStructure(vm, globalObjectObject, globalObjectObject->objectPrototype(), 0);
JSObject* handler = JSFinalObject::create(vm, emptyObjectStructure);
proxyObjectObject = ProxyObject::create(exec, globalObjectObject, toJS(array), handler);
proxyObjectObject = ProxyObject::create(globalObjectObject, toJS(array), handler);
}
JSObjectRef jsProxy = toRef(jsProxyObject);
@ -91,11 +88,11 @@ int testJSObjectGetProxyTarget()
jsProxyObject->setTarget(vm, globalObjectObject);
}
test("proxy target of initialized JSProxy works", JSObjectGetProxyTarget(jsProxy) == globalObject);
test("proxy target of initialized JSProxy works", JSObjectGetProxyTarget(jsProxy) == globalObjectRef);
test("proxy target of ProxyObject works", JSObjectGetProxyTarget(proxyObject) == array);
test("proxy target of GlobalObject is the globalObject", JSObjectGetProxyTarget(globalObjectProxy) == globalObject);
test("proxy target of GlobalObject is the globalObject", JSObjectGetProxyTarget(globalObjectProxy) == globalObjectRef);
JSGlobalContextRelease(context);
JSContextGroupRelease(group);

12
API/tests/JSWrapperMapTests.mm
View File

@ -28,6 +28,7 @@
#import "APICast.h"
#import "HeapCellInlines.h"
#import "JSGlobalObjectInlines.h"
#import "JSValue.h"
#if JSC_OBJC_API_ENABLED
@ -55,15 +56,16 @@ extern "C" void checkResult(NSString *description, bool passed);
{
JSContext* context = [[JSContext alloc] init];
JSGlobalContextRef contextRef = JSGlobalContextRetain(context.JSGlobalContextRef);
JSC::ExecState* exec = toJS(contextRef);
JSC::JSGlobalObject* globalObject = toJS(contextRef);
JSC::VM& vm = globalObject->vm();
context[@"TestClass"] = [TestClass class];
JSValue* aWrapper = [context evaluateScript:@"new TestClass()"];
JSValue* bWrapper = [context evaluateScript:@"new TestClass()"];
JSC::JSValue aValue = toJS(exec, aWrapper.JSValueRef);
JSC::JSValue bValue = toJS(exec, bWrapper.JSValueRef);
JSC::Structure* aStructure = aValue.structureOrNull();
JSC::Structure* bStructure = bValue.structureOrNull();
JSC::JSValue aValue = toJS(globalObject, aWrapper.JSValueRef);
JSC::JSValue bValue = toJS(globalObject, bWrapper.JSValueRef);
JSC::Structure* aStructure = aValue.structureOrNull(vm);
JSC::Structure* bStructure = bValue.structureOrNull(vm);
checkResult(@"structure should not be null", !!aStructure);
checkResult(@"both wrappers should share the same structure", aStructure == bStructure);
}

4
API/tests/MultithreadedMultiVMExecutionTest.cpp
View File

@ -27,9 +27,7 @@
#include "MultithreadedMultiVMExecutionTest.h"
#include "InitializeThreading.h"
#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"
#include <mutex>
#include <string>
#include <thread>
@ -51,7 +49,7 @@ static std::vector<std::thread>& threadsList()
void startMultithreadedMultiVMExecutionTest()
{
WTF::initializeMainThread();
JSC::initializeThreading();
JSC::initialize();
#define CHECK(condition, message) do { \
if (!condition) { \

40
API/tests/PingPongStackOverflowTest.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2015 Apple Inc. All rights reserved.
* Copyright (C) 2015-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -27,7 +27,6 @@
#include "PingPongStackOverflowTest.h"
#include "InitializeThreading.h"
#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"
#include <wtf/text/StringBuilder.h>
@ -50,7 +49,7 @@ static bool PingPongStackOverflowObject_hasInstance(JSContextRef context, JSObje
int countAtEntry = nativeRecursionCount++;
JSValueRef result = 0;
JSValueRef result = nullptr;
if (nativeRecursionCount < 100) {
JSObjectRef function = JSValueToObject(context, hasInstance, exception);
result = JSObjectCallAsFunction(context, function, constructor, 1, &possibleValue, exception);
@ -65,7 +64,7 @@ static bool PingPongStackOverflowObject_hasInstance(JSContextRef context, JSObje
builder.appendLiteral(");");
JSStringRef script = JSStringCreateWithUTF8CString(builder.toString().utf8().data());
result = JSEvaluateScript(context, script, NULL, NULL, 1, exception);
result = JSEvaluateScript(context, script, nullptr, nullptr, 1, exception);
JSStringRelease(script);
}
@ -81,22 +80,22 @@ JSClassDefinition PingPongStackOverflowObject_definition = {
kJSClassAttributeNone,
"PingPongStackOverflowObject",
NULL,
nullptr,
NULL,
NULL,
nullptr,
nullptr,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
PingPongStackOverflowObject_hasInstance,
NULL,
nullptr,
};
static JSClassRef PingPongStackOverflowObject_class(JSContextRef context)
@ -117,8 +116,7 @@ int testPingPongStackOverflow()
{
bool failed = false;
JSC::initializeThreading();
Options::initialize(); // Ensure options is initialized first.
JSC::initialize();
auto origSoftReservedZoneSize = Options::softReservedZoneSize();
auto origReservedZoneSize = Options::reservedZoneSize();
@ -151,9 +149,9 @@ int testPingPongStackOverflow()
JSObjectRef globalObject = JSContextGetGlobalObject(context);
ASSERT(JSValueIsObject(context, globalObject));
JSObjectRef PingPongStackOverflowObject = JSObjectMake(context, PingPongStackOverflowObject_class(context), NULL);
JSObjectRef PingPongStackOverflowObject = JSObjectMake(context, PingPongStackOverflowObject_class(context), nullptr);
JSStringRef PingPongStackOverflowObjectString = JSStringCreateWithUTF8CString("PingPongStackOverflowObject");
JSObjectSetProperty(context, globalObject, PingPongStackOverflowObjectString, PingPongStackOverflowObject, kJSPropertyAttributeNone, NULL);
JSObjectSetProperty(context, globalObject, PingPongStackOverflowObjectString, PingPongStackOverflowObject, kJSPropertyAttributeNone, nullptr);
JSStringRelease(PingPongStackOverflowObjectString);
unsigned stackSize = 32 * KB;

4
API/tests/TypedArrayCTest.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2016 Apple Inc. All rights reserved.
* Copyright (C) 2016-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -40,7 +40,7 @@ static void freePtr(void* ptr, void*)
free(ptr);
}
static const unsigned numLengths = 3;
static constexpr unsigned numLengths = 3;
static const unsigned lengths[numLengths] =
{

3
API/tests/minidom.c
View File

@ -88,10 +88,11 @@ static JSValueRef print(JSContextRef context, JSObjectRef object, JSObjectRef th
if (argumentCount > 0) {
JSStringRef string = JSValueToStringCopy(context, arguments[0], exception);
size_t numChars = JSStringGetMaximumUTF8CStringSize(string);
char stringUTF8[numChars];
char* stringUTF8 = (char*)malloc(numChars);
JSStringGetUTF8CString(string, stringUTF8, numChars);
printf("%s\n", stringUTF8);
JSStringRelease(string);
free(stringUTF8);
}
return JSValueMakeUndefined(context);

22
API/tests/testapi.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2006-2017 Apple Inc. All rights reserved.
* Copyright (C) 2006-2020 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -23,7 +23,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define ASSERT_DISABLED 0
#define ASSERT_ENABLED 1
#include "config.h"
#if USE(CF)
@ -33,7 +33,6 @@
#endif
#include "JSBasePrivate.h"
#include "JSContextRefPrivate.h"
#include "JSHeapFinalizerPrivate.h"
#include "JSMarkingConstraintPrivate.h"
#include "JSObjectRefPrivate.h"
@ -77,6 +76,7 @@
void testObjectiveCAPI(const char*);
#endif
void configureJSCForTesting(void);
int testCAPIViaCpp(const char* filter);
bool assertTrue(bool value, const char* message);
@ -1017,12 +1017,14 @@ static JSValueRef functionGC(JSContextRef context, JSObjectRef function, JSObjec
static JSStaticValue globalObject_staticValues[] = {
{ "globalStaticValue", globalObject_get, globalObject_set, kJSPropertyAttributeNone },
{ "globalStaticValue2", globalObject_get, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum },
{ 0, 0, 0, 0 }
};
static JSStaticFunction globalObject_staticFunctions[] = {
{ "globalStaticFunction", globalObject_call, kJSPropertyAttributeNone },
{ "globalStaticFunction2", globalObject_call, kJSPropertyAttributeNone },
{ "globalStaticFunction3", globalObject_call, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum },
{ "gc", functionGC, kJSPropertyAttributeNone },
{ 0, 0, 0 }
};
@ -1387,9 +1389,12 @@ int main(int argc, char* argv[])
SetErrorMode(0);
#endif
configureJSCForTesting();
#if !OS(WINDOWS)
char resolvedPath[PATH_MAX];
realpath(argv[0], resolvedPath);
if (!realpath(argv[0], resolvedPath))
fprintf(stdout, "Could not get the absolute pathname for: %s\n", argv[0]);
char* newCWD = dirname(resolvedPath);
if (chdir(newCWD))
fprintf(stdout, "Could not chdir to: %s\n", newCWD);
@ -2098,7 +2103,6 @@ int main(int argc, char* argv[])
JSGlobalContextRelease(context);
}
failed |= testTypedArrayCAPI();
failed |= testExecutionTimeLimit();
failed |= testFunctionOverrides();
failed |= testGlobalContextWithFinalizer();
failed |= testPingPongStackOverflow();
@ -2154,6 +2158,14 @@ int main(int argc, char* argv[])
failed = finalizeMultithreadedMultiVMExecutionTest() || failed;
// Don't run this till after the MultithreadedMultiVMExecutionTest has finished.
// This is because testExecutionTimeLimit() modifies JIT options at runtime
// as part of its testing. This can wreak havoc on the rest of the system that
// expects the options to be frozen. Ideally, we'll find a way for testExecutionTimeLimit()
// to do its work without changing JIT options, but that is not easy to do.
// For now, we'll just run it here at the end as a workaround.
failed |= testExecutionTimeLimit();
if (failed) {
printf("FAIL: Some tests failed.\n");
return 1;

248
API/tests/testapi.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017 Apple Inc. All rights reserved.
* Copyright (C) 2017-2019 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -26,9 +26,9 @@
#include "config.h"
#include "APICast.h"
#include "JSCJSValueInlines.h"
#include "JSObject.h"
#include "JSGlobalObjectInlines.h"
#include "MarkedJSValueRefArray.h"
#include <JavaScriptCore/JSContextRefPrivate.h>
#include <JavaScriptCore/JSObjectRefPrivate.h>
#include <JavaScriptCore/JavaScript.h>
#include <wtf/DataLog.h>
@ -38,7 +38,9 @@
#include <wtf/Vector.h>
#include <wtf/text/StringCommon.h>
extern "C" void configureJSCForTesting();
extern "C" int testCAPIViaCpp(const char* filter);
extern "C" void JSSynchronousGarbageCollectForDebugging(JSContextRef);
class APIString {
WTF_MAKE_NONCOPYABLE(APIString);
@ -49,6 +51,11 @@ public:
{
}
APIString(const String& string)
: APIString(string.utf8().data())
{
}
~APIString()
{
JSStringRelease(m_string);
@ -70,9 +77,9 @@ public:
APIString print("print");
JSObjectRef printFunction = JSObjectMakeFunctionWithCallback(m_context, print, [] (JSContextRef ctx, JSObjectRef, JSObjectRef, size_t argumentCount, const JSValueRef arguments[], JSValueRef*) {
JSC::ExecState* exec = toJS(ctx);
JSC::JSGlobalObject* globalObject = toJS(ctx);
for (unsigned i = 0; i < argumentCount; i++)
dataLog(toJS(exec, arguments[i]));
dataLog(toJS(globalObject, arguments[i]));
dataLogLn();
return JSValueMakeUndefined(ctx);
});
@ -86,7 +93,7 @@ public:
}
operator JSGlobalContextRef() { return m_context; }
operator JSC::ExecState*() { return toJS(m_context); }
operator JSC::JSGlobalObject*() { return toJS(m_context); }
private:
JSGlobalContextRef m_context;
@ -137,6 +144,13 @@ public:
void symbolsDeletePropertyForKey();
void promiseResolveTrue();
void promiseRejectTrue();
void promiseUnhandledRejection();
void promiseUnhandledRejectionFromUnhandledRejectionCallback();
void promiseEarlyHandledRejections();
void topCallFrameAccess();
void markedJSValueArrayAndGC();
void classDefinitionWithJSSubclass();
void proxyReturnedWithJSSubclassing();
int failed() const { return m_failed; }
@ -156,6 +170,8 @@ private:
template<typename... ArgumentTypes>
bool functionReturnsTrue(const char* functionSource, ArgumentTypes... arguments);
bool scriptResultIs(ScriptResult, JSValueRef);
// Ways to make sets of interesting things.
APIVector<JSObjectRef> interestingObjects();
APIVector<JSValueRef> interestingKeys();
@ -198,6 +214,30 @@ TestAPI::ScriptResult TestAPI::callFunction(const char* functionSource, Argument
return Unexpected<JSValueRef>(exception);
}
#if COMPILER(MSVC)
template<>
TestAPI::ScriptResult TestAPI::callFunction(const char* functionSource)
{
JSValueRef function;
{
ScriptResult functionResult = evaluateScript(functionSource);
if (!functionResult)
return functionResult;
function = functionResult.value();
}
JSValueRef exception = nullptr;
if (JSObjectRef functionObject = JSValueToObject(context, function, &exception)) {
JSValueRef result = JSObjectCallAsFunction(context, functionObject, functionObject, 0, nullptr, &exception);
if (!exception)
return ScriptResult(result);
}
RELEASE_ASSERT(exception);
return Unexpected<JSValueRef>(exception);
}
#endif
template<typename... ArgumentTypes>
bool TestAPI::functionReturnsTrue(const char* functionSource, ArgumentTypes... arguments)
{
@ -208,6 +248,13 @@ bool TestAPI::functionReturnsTrue(const char* functionSource, ArgumentTypes... a
return JSValueIsStrictEqual(context, trueValue, result.value());
}
bool TestAPI::scriptResultIs(ScriptResult result, JSValueRef value)
{
if (!result)
return false;
return JSValueIsStrictEqual(context, result.value(), value);
}
template<typename... Strings>
bool TestAPI::check(bool condition, Strings... messages)
{
@ -454,7 +501,7 @@ void TestAPI::promiseResolveTrue()
auto trueValue = JSValueMakeBoolean(context, true);
JSObjectCallAsFunction(context, resolve, resolve, 1, &trueValue, &exception);
check(!exception, "No exception should be thrown resolve promise");
check(!exception, "No exception should be thrown resolving promise");
check(passedTrueCalled, "then response function should have been called.");
}
@ -479,7 +526,7 @@ void TestAPI::promiseRejectTrue()
APIString catchString("catch");
JSValueRef catchFunction = JSObjectGetProperty(context, promise, catchString, &exception);
check(!exception && catchFunction && JSValueIsObject(context, catchFunction), "Promise should have a then object property");
check(!exception && catchFunction && JSValueIsObject(context, catchFunction), "Promise should have a catch object property");
JSValueRef passedTrueFunction = JSObjectMakeFunctionWithCallback(context, trueString, passedTrue);
JSObjectCallAsFunction(context, const_cast<JSObjectRef>(catchFunction), promise, 1, &passedTrueFunction, &exception);
@ -487,8 +534,180 @@ void TestAPI::promiseRejectTrue()
auto trueValue = JSValueMakeBoolean(context, true);
JSObjectCallAsFunction(context, reject, reject, 1, &trueValue, &exception);
check(!exception, "No exception should be thrown resolve promise");
check(passedTrueCalled, "then response function should have been called.");
check(!exception, "No exception should be thrown rejecting promise");
check(passedTrueCalled, "catch response function should have been called.");
}
void TestAPI::promiseUnhandledRejection()
{
JSObjectRef reject = nullptr;
JSValueRef exception = nullptr;
static auto promise = JSObjectMakeDeferredPromise(context, nullptr, &reject, &exception);
check(!exception, "creating a (reject-only) deferred promise should not throw");
static auto reason = JSValueMakeString(context, APIString("reason"));
static TestAPI* tester = this;
static bool callbackCalled = false;
auto callback = [](JSContextRef ctx, JSObjectRef, JSObjectRef, size_t argumentCount, const JSValueRef arguments[], JSValueRef*) -> JSValueRef {
tester->check(argumentCount && JSValueIsStrictEqual(ctx, arguments[0], promise), "callback should receive rejected promise as first argument");
tester->check(argumentCount > 1 && JSValueIsStrictEqual(ctx, arguments[1], reason), "callback should receive rejection reason as second argument");
tester->check(argumentCount == 2, "callback should not receive a third argument");
callbackCalled = true;
return JSValueMakeUndefined(ctx);
};
auto callbackFunction = JSObjectMakeFunctionWithCallback(context, APIString("callback"), callback);
JSGlobalContextSetUnhandledRejectionCallback(context, callbackFunction, &exception);
check(!exception, "setting unhandled rejection callback should not throw");
JSObjectCallAsFunction(context, reject, reject, 1, &reason, &exception);
check(!exception && callbackCalled, "unhandled rejection callback should be called upon unhandled rejection");
}
void TestAPI::promiseUnhandledRejectionFromUnhandledRejectionCallback()
{
static JSObjectRef reject;
static JSValueRef exception = nullptr;
JSObjectMakeDeferredPromise(context, nullptr, &reject, &exception);
check(!exception, "creating a (reject-only) deferred promise should not throw");
static auto callbackCallCount = 0;
auto callback = [](JSContextRef ctx, JSObjectRef, JSObjectRef, size_t, const JSValueRef[], JSValueRef*) -> JSValueRef {
if (!callbackCallCount)
JSObjectCallAsFunction(ctx, reject, reject, 0, nullptr, &exception);
callbackCallCount++;
return JSValueMakeUndefined(ctx);
};
auto callbackFunction = JSObjectMakeFunctionWithCallback(context, APIString("callback"), callback);
JSGlobalContextSetUnhandledRejectionCallback(context, callbackFunction, &exception);
check(!exception, "setting unhandled rejection callback should not throw");
callFunction("(function () { Promise.reject(); })");
check(!exception && callbackCallCount == 2, "unhandled rejection from unhandled rejection callback should also trigger the callback");
}
void TestAPI::promiseEarlyHandledRejections()
{
JSValueRef exception = nullptr;
static bool callbackCalled = false;
auto callback = [](JSContextRef ctx, JSObjectRef, JSObjectRef, size_t, const JSValueRef[], JSValueRef*) -> JSValueRef {
callbackCalled = true;
return JSValueMakeUndefined(ctx);
};
auto callbackFunction = JSObjectMakeFunctionWithCallback(context, APIString("callback"), callback);
JSGlobalContextSetUnhandledRejectionCallback(context, callbackFunction, &exception);
check(!exception, "setting unhandled rejection callback should not throw");
callFunction("(function () { const p = Promise.reject(); p.catch(() => {}); })");
check(!callbackCalled, "unhandled rejection callback should not be called for synchronous early-handled rejection");
callFunction("(function () { const p = Promise.reject(); Promise.resolve().then(() => { p.catch(() => {}); }); })");
check(!callbackCalled, "unhandled rejection callback should not be called for asynchronous early-handled rejection");
}
void TestAPI::topCallFrameAccess()
{
{
JSObjectRef function = JSValueToObject(context, evaluateScript("(function () { })").value(), nullptr);
APIString argumentsString("arguments");
auto arguments = JSObjectGetProperty(context, function, argumentsString, nullptr);
check(JSValueIsNull(context, arguments), "vm.topCallFrame access from C++ world should use nullptr internally for arguments");
}
{
JSObjectRef arguments = JSValueToObject(context, evaluateScript("(function ok(v) { return ok.arguments; })(42)").value(), nullptr);
check(!JSValueIsNull(context, arguments), "vm.topCallFrame is materialized and we found the caller function's arguments");
}
{
JSObjectRef function = JSValueToObject(context, evaluateScript("(function () { })").value(), nullptr);
APIString callerString("caller");
auto caller = JSObjectGetProperty(context, function, callerString, nullptr);
check(JSValueIsNull(context, caller), "vm.topCallFrame access from C++ world should use nullptr internally for caller");
}
{
JSObjectRef caller = JSValueToObject(context, evaluateScript("(function () { return (function ok(v) { return ok.caller; })(42); })()").value(), nullptr);
check(!JSValueIsNull(context, caller), "vm.topCallFrame is materialized and we found the caller function's caller");
}
{
JSObjectRef caller = JSValueToObject(context, evaluateScript("(function ok(v) { return ok.caller; })(42)").value(), nullptr);
check(JSValueIsNull(context, caller), "vm.topCallFrame is materialized and we found the caller function's caller, but the caller is global code");
}
}
void TestAPI::markedJSValueArrayAndGC()
{
auto testMarkedJSValueArray = [&] (unsigned count) {
auto* globalObject = toJS(context);
JSC::JSLockHolder locker(globalObject->vm());
JSC::MarkedJSValueRefArray values(context, count);
for (unsigned index = 0; index < count; ++index) {
JSValueRef string = JSValueMakeString(context, APIString(makeString("Prefix", index)));
values[index] = string;
}
JSSynchronousGarbageCollectForDebugging(context);
bool ok = true;
for (unsigned index = 0; index < count; ++index) {
JSValueRef string = JSValueMakeString(context, APIString(makeString("Prefix", index)));
if (!JSValueIsStrictEqual(context, values[index], string))
ok = false;
}
check(ok, "Held JSString should be alive and correct.");
};
testMarkedJSValueArray(4);
testMarkedJSValueArray(1000);
}
void TestAPI::classDefinitionWithJSSubclass()
{
const static JSClassDefinition definition = kJSClassDefinitionEmpty;
static JSClassRef jsClass = JSClassCreate(&definition);
auto constructor = [] (JSContextRef ctx, JSObjectRef, size_t, const JSValueRef*, JSValueRef*) -> JSObjectRef {
return JSObjectMake(ctx, jsClass, nullptr);
};
JSObjectRef Superclass = JSObjectMakeConstructor(context, jsClass, constructor);
ScriptResult result = callFunction("(function (Superclass) { class Subclass extends Superclass { method() { return 'value'; } }; return new Subclass(); })", Superclass);
check(!!result, "creating a subclass should not throw.");
check(JSValueIsObject(context, result.value()), "result of construction should have been an object.");
JSObjectRef subclass = const_cast<JSObjectRef>(result.value());
check(JSObjectHasProperty(context, subclass, APIString("method")), "subclass should have derived classes functions.");
check(functionReturnsTrue("(function (subclass, Superclass) { return subclass instanceof Superclass; })", subclass, Superclass), "JS subclass should instanceof the Superclass");
JSClassRelease(jsClass);
}
void TestAPI::proxyReturnedWithJSSubclassing()
{
const static JSClassDefinition definition = kJSClassDefinitionEmpty;
static JSClassRef jsClass = JSClassCreate(&definition);
static TestAPI& test = *this;
auto constructor = [] (JSContextRef ctx, JSObjectRef, size_t, const JSValueRef*, JSValueRef*) -> JSObjectRef {
ScriptResult result = test.callFunction("(function (object) { return new Proxy(object, { getPrototypeOf: () => { globalThis.triggeredProxy = true; return object.__proto__; }}); })", JSObjectMake(ctx, jsClass, nullptr));
test.check(!!result, "creating a proxy should not throw");
test.check(JSValueIsObject(ctx, result.value()), "result of proxy creation should have been an object.");
return const_cast<JSObjectRef>(result.value());
};
JSObjectRef Superclass = JSObjectMakeConstructor(context, jsClass, constructor);
ScriptResult result = callFunction("(function (Superclass) { class Subclass extends Superclass { method() { return 'value'; } }; return new Subclass(); })", Superclass);
check(!!result, "creating a subclass should not throw.");
check(JSValueIsObject(context, result.value()), "result of construction should have been an object.");
JSObjectRef subclass = const_cast<JSObjectRef>(result.value());
check(scriptResultIs(evaluateScript("globalThis.triggeredProxy"), JSValueMakeUndefined(context)), "creating a subclass should not have triggered the proxy");
check(functionReturnsTrue("(function (subclass, Superclass) { return subclass.__proto__ == Superclass.prototype; })", subclass, Superclass), "proxy's prototype should match Superclass.prototype");
}
void configureJSCForTesting()
{
JSC::Config::configureForTesting();
}
#define RUN(test) do { \
@ -512,6 +731,7 @@ int testCAPIViaCpp(const char* filter)
return !filter || WTF::findIgnoringASCIICaseWithoutLength(testName, filter) != WTF::notFound;
};
RUN(topCallFrameAccess());
RUN(basicSymbol());
RUN(symbolsTypeof());
RUN(symbolsDescription());
@ -521,6 +741,12 @@ int testCAPIViaCpp(const char* filter)
RUN(symbolsDeletePropertyForKey());
RUN(promiseResolveTrue());
RUN(promiseRejectTrue());
RUN(promiseUnhandledRejection());
RUN(promiseUnhandledRejectionFromUnhandledRejectionCallback());
RUN(promiseEarlyHandledRejections());
RUN(markedJSValueArrayAndGC());
RUN(classDefinitionWithJSSubclass());
RUN(proxyReturnedWithJSSubclassing());
if (tasks.isEmpty()) {
dataLogLn("Filtered all tests: ERROR");

19
API/tests/testapi.mm
View File

@ -128,7 +128,7 @@ JSExportAs(testArgumentTypes,
}
- (void)callback:(JSValue *)function
{
[function callWithArguments:[NSArray arrayWithObject:[NSNumber numberWithInt:42]]];
[function callWithArguments:@[@(42)]];
}
- (void)bogusCallback:(void(^)(int))function
{
@ -199,7 +199,7 @@ bool testXYZTested = false;
return;
JSValue *function = [m_onclickHandler value];
[function callWithArguments:[NSArray array]];
[function callWithArguments:@[]];
}
@end
@ -1014,7 +1014,7 @@ static void testObjectiveCAPIMain()
@autoreleasepool {
JSContext *context = [[JSContext alloc] init];
JSValue *result = [context evaluateScript:@"String(console)"];
checkResult(@"String(console)", [result isEqualToObject:@"[object Console]"]);
checkResult(@"String(console)", [result isEqualToObject:@"[object console]"]);
result = [context evaluateScript:@"typeof console.log"];
checkResult(@"typeof console.log", [result isEqualToObject:@"function"]);
}
@ -1171,10 +1171,8 @@ static void testObjectiveCAPIMain()
JSContext *context = [[JSContext alloc] init];
context[@"handleTheDictionary"] = ^(NSDictionary *dict) {
NSDictionary *expectedDict = @{
@"foo" : [NSNumber numberWithInt:1],
@"bar" : @{
@"baz": [NSNumber numberWithInt:2]
}
@"foo": @(1),
@"bar": @{ @"baz": @(2) }
};
checkResult(@"recursively convert nested dictionaries", [dict isEqualToDictionary:expectedDict]);
};
@ -1340,7 +1338,7 @@ static void testObjectiveCAPIMain()
}
@autoreleasepool {
static const unsigned count = 100;
static constexpr unsigned count = 100;
NSMutableArray *array = [NSMutableArray arrayWithCapacity:count];
JSContext *context = [[JSContext alloc] init];
@autoreleasepool {
@ -2405,7 +2403,9 @@ static void testBytecodeCacheValidation()
testInvalidCacheURL([NSURL URLWithString:@""], @"Cache path `` is not a local file");
testInvalidCacheURL([NSURL URLWithString:@"file:///"], @"Cache path `/` already exists and is not a file");
testInvalidCacheURL([NSURL URLWithString:@"file:///a/b/c/d/e"], @"Cache directory `/a/b/c/d` is not a directory or does not exist");
#if USE(APPLE_INTERNAL_SDK)
testInvalidCacheURL([NSURL URLWithString:@"file:///private/tmp/file.cache"], @"Cache directory `/private/tmp` is not a data vault");
#endif
}
#if USE(APPLE_INTERNAL_SDK)
@ -2859,7 +2859,8 @@ void testObjectiveCAPI(const char* filter)
RUN(promiseCreateRejected());
RUN(parallelPromiseResolveTest());
testObjectiveCAPIMain();
if (!filter)
testObjectiveCAPIMain();
}
#else

Some files were not shown because too many files have changed in this diff Show More