自学教程：C++ DECLARE_THROW_SCOPE函数代码示例

static std::error_code getDomainList(ExecState& exec, const JSObject* arrayObject, Vector<String>& vector){    VM& vm = exec.vm();    auto scope = DECLARE_THROW_SCOPE(vm);    ASSERT(vector.isEmpty());    if (!arrayObject || !isJSArray(arrayObject))        return ContentExtensionError::JSONInvalidDomainList;    const JSArray* array = jsCast<const JSArray*>(arrayObject);        unsigned length = array->length();    for (unsigned i = 0; i < length; ++i) {        const JSValue value = array->getIndex(&exec, i);        if (scope.exception() || !value.isString())            return ContentExtensionError::JSONInvalidDomainList;                // Domains should be punycode encoded lower case.        const String& domain = jsCast<JSString*>(value)->value(&exec);        if (domain.isEmpty())            return ContentExtensionError::JSONInvalidDomainList;        if (!containsOnlyASCIIWithNoUppercase(domain))            return ContentExtensionError::JSONDomainNotLowerCaseASCII;        vector.append(domain);    }    return { };}

bool JSLocation::getOwnPropertySlotDelegate(ExecState* exec, PropertyName propertyName, PropertySlot& slot){    VM& vm = exec->vm();    auto scope = DECLARE_THROW_SCOPE(vm);    Frame* frame = wrapped().frame();    if (!frame) {        slot.setUndefined();        return true;    }    // When accessing Location cross-domain, functions are always the native built-in ones.    // See JSDOMWindow::getOwnPropertySlotDelegate for additional details.    // Our custom code is only needed to implement the Window cross-domain scheme, so if access is    // allowed, return false so the normal lookup will take place.    String message;    if (shouldAllowAccessToFrame(exec, frame, message))        return false;    // We only allow access to Location.replace() cross origin.    // Make it read-only / non-configurable to prevent writes via defineProperty.    if (propertyName == exec->propertyNames().replace) {        slot.setCustom(this, ReadOnly | DontDelete | DontEnum, nonCachingStaticFunctionGetter<jsLocationInstanceFunctionReplace, 1>);        return true;    }    throwSecurityError(*exec, scope, message);    slot.setUndefined();    return true;}

JSValue IntlNumberFormat::formatNumber(ExecState& state, double number){    VM& vm = state.vm();    auto scope = DECLARE_THROW_SCOPE(vm);    // 11.3.4 FormatNumber abstract operation (ECMA-402 2.0)    if (!m_initializedNumberFormat)        return throwTypeError(&state, scope, "Intl.NumberFormat.prototype.format called on value that's not an object initialized as a NumberFormat"_s);    // Map negative zero to positive zero.    if (!number)        number = 0.0;    UErrorCode status = U_ZERO_ERROR;    Vector<UChar, 32> buffer(32);    auto length = unum_formatDouble(m_numberFormat.get(), number, buffer.data(), buffer.size(), nullptr, &status);    if (status == U_BUFFER_OVERFLOW_ERROR) {        buffer.grow(length);        status = U_ZERO_ERROR;        unum_formatDouble(m_numberFormat.get(), number, buffer.data(), length, nullptr, &status);    }    if (U_FAILURE(status))        return throwException(&state, scope, createError(&state, "Failed to format a number."_s));    return jsString(&state, String(buffer.data(), length));}

bool JSDOMWindow::preventExtensions(JSObject*, ExecState* exec){    auto scope = DECLARE_THROW_SCOPE(exec->vm());    throwTypeError(exec, scope, ASCIILiteral("Cannot prevent extensions on this object"));    return false;}

static EncodedJSValue JSC_HOST_CALL constructWeakSet(ExecState* exec){    VM& vm = exec->vm();    auto scope = DECLARE_THROW_SCOPE(vm);    JSGlobalObject* globalObject = asInternalFunction(exec->jsCallee())->globalObject();    Structure* weakSetStructure = InternalFunction::createSubclassStructure(exec, exec->newTarget(), globalObject->weakSetStructure());    RETURN_IF_EXCEPTION(scope, encodedJSValue());    JSWeakSet* weakSet = JSWeakSet::create(exec, weakSetStructure);    JSValue iterable = exec->argument(0);    if (iterable.isUndefinedOrNull())        return JSValue::encode(weakSet);    JSValue adderFunction = weakSet->JSObject::get(exec, vm.propertyNames->add);    RETURN_IF_EXCEPTION(scope, encodedJSValue());    CallData adderFunctionCallData;    CallType adderFunctionCallType = getCallData(adderFunction, adderFunctionCallData);    if (adderFunctionCallType == CallType::None)        return JSValue::encode(throwTypeError(exec, scope));    scope.release();    forEachInIterable(exec, iterable, [&](VM&, ExecState* exec, JSValue nextValue) {        MarkedArgumentBuffer arguments;        arguments.append(nextValue);        call(exec, adderFunction, adderFunctionCallType, adderFunctionCallData, weakSet, arguments);    });    return JSValue::encode(weakSet);}

static void exportKey(ExecState& state, CryptoKeyFormat keyFormat, const CryptoKey& key, CryptoAlgorithm::VectorCallback callback, CryptoAlgorithm::VoidCallback failureCallback){    VM& vm = state.vm();    auto scope = DECLARE_THROW_SCOPE(vm);    if (!key.extractable()) {        throwTypeError(&state, scope, ASCIILiteral("Key is not extractable"));        return;    }    switch (keyFormat) {    case CryptoKeyFormat::Raw: {        Vector<uint8_t> result;        if (CryptoKeySerializationRaw::serialize(key, result))            callback(result);        else            failureCallback();        break;    }    case CryptoKeyFormat::JWK: {        String result = JSCryptoKeySerializationJWK::serialize(&state, key);        RETURN_IF_EXCEPTION(scope, void());        CString utf8String = result.utf8(StrictConversion);        Vector<uint8_t> resultBuffer;        resultBuffer.append(utf8String.data(), utf8String.length());        callback(resultBuffer);        break;    }    default:        throwTypeError(&state, scope, ASCIILiteral("Unsupported key format for export"));        break;    }}

JSValue Database::toJS(ExecState* exec) const{    VM& vm = exec->vm();    auto scope = DECLARE_THROW_SCOPE(vm);    JSObject* result = constructEmptyObject(exec);        JSArray* bytecodes = constructEmptyArray(exec, 0);    RETURN_IF_EXCEPTION(scope, JSValue());    for (unsigned i = 0; i < m_bytecodes.size(); ++i)        bytecodes->putDirectIndex(exec, i, m_bytecodes[i].toJS(exec));    result->putDirect(vm, exec->propertyNames().bytecodes, bytecodes);        JSArray* compilations = constructEmptyArray(exec, 0);    RETURN_IF_EXCEPTION(scope, JSValue());    for (unsigned i = 0; i < m_compilations.size(); ++i)        compilations->putDirectIndex(exec, i, m_compilations[i]->toJS(exec));    result->putDirect(vm, exec->propertyNames().compilations, compilations);        JSArray* events = constructEmptyArray(exec, 0);    RETURN_IF_EXCEPTION(scope, JSValue());    for (unsigned i = 0; i < m_events.size(); ++i)        events->putDirectIndex(exec, i, m_events[i].toJS(exec));    result->putDirect(vm, exec->propertyNames().events, events);        return result;}

EncodedJSValue JSC_HOST_CALL webAssemblyModuleCustomSections(ExecState* exec){    VM& vm = exec->vm();    auto* globalObject = exec->lexicalGlobalObject();    auto throwScope = DECLARE_THROW_SCOPE(vm);    JSWebAssemblyModule* module = jsDynamicCast<JSWebAssemblyModule*>(vm, exec->argument(0));    if (!module)        return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, "WebAssembly.Module.customSections called with non WebAssembly.Module argument"_s)));    const String sectionNameString = exec->argument(1).getString(exec);    RETURN_IF_EXCEPTION(throwScope, { });    JSArray* result = constructEmptyArray(exec, nullptr, globalObject);    RETURN_IF_EXCEPTION(throwScope, { });    const auto& customSections = module->moduleInformation().customSections;    for (const Wasm::CustomSection& section : customSections) {        if (String::fromUTF8(section.name) == sectionNameString) {            auto buffer = ArrayBuffer::tryCreate(section.payload.data(), section.payload.size());            if (!buffer)                return JSValue::encode(throwException(exec, throwScope, createOutOfMemoryError(exec)));            result->push(exec, JSArrayBuffer::create(vm, globalObject->arrayBufferStructure(ArrayBufferSharingMode::Default), WTFMove(buffer)));            RETURN_IF_EXCEPTION(throwScope, { });        }    }    return JSValue::encode(result);}

EncodedJSValue JSC_HOST_CALL webAssemblyModuleImports(ExecState* exec){    VM& vm = exec->vm();    auto* globalObject = exec->lexicalGlobalObject();    auto throwScope = DECLARE_THROW_SCOPE(vm);    JSWebAssemblyModule* module = jsDynamicCast<JSWebAssemblyModule*>(vm, exec->argument(0));    if (!module)        return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, "WebAssembly.Module.imports called with non WebAssembly.Module argument"_s)));    JSArray* result = constructEmptyArray(exec, nullptr, globalObject);    RETURN_IF_EXCEPTION(throwScope, { });    const auto& imports = module->moduleInformation().imports;    if (imports.size()) {        Identifier module = Identifier::fromString(exec, "module");        Identifier name = Identifier::fromString(exec, "name");        Identifier kind = Identifier::fromString(exec, "kind");        for (const Wasm::Import& imp : imports) {            JSObject* obj = constructEmptyObject(exec);            RETURN_IF_EXCEPTION(throwScope, { });            obj->putDirect(vm, module, jsString(exec, String::fromUTF8(imp.module)));            obj->putDirect(vm, name, jsString(exec, String::fromUTF8(imp.field)));            obj->putDirect(vm, kind, jsString(exec, String(makeString(imp.kind))));            result->push(exec, obj);            RETURN_IF_EXCEPTION(throwScope, { });        }    }    return JSValue::encode(result);}

EncodedJSValue JSC_HOST_CALL constructJSWorker(ExecState& exec){    VM& vm = exec.vm();    auto scope = DECLARE_THROW_SCOPE(vm);    DOMConstructorObject* jsConstructor = jsCast<DOMConstructorObject*>(exec.callee());    if (!exec.argumentCount())        return throwVMError(&exec, scope, createNotEnoughArgumentsError(&exec));    String scriptURL = exec.uncheckedArgument(0).toWTFString(&exec);    if (exec.hadException())        return JSValue::encode(JSValue());    // See section 4.8.2 step 14 of WebWorkers for why this is the lexicalGlobalObject.    DOMWindow& window = asJSDOMWindow(exec.lexicalGlobalObject())->wrapped();    ExceptionCode ec = 0;    ASSERT(window.document());    RefPtr<Worker> worker = Worker::create(*window.document(), scriptURL, ec);    if (ec) {        setDOMException(&exec, ec);        return JSValue::encode(JSValue());    }    return JSValue::encode(toJSNewlyCreated(&exec, jsConstructor->globalObject(), WTFMove(worker)));}

JSValue ScriptFunctionCall::call(bool& hadException){    JSObject* thisObject = m_thisObject.jsObject();    VM& vm = m_exec->vm();    JSLockHolder lock(vm);    auto scope = DECLARE_THROW_SCOPE(vm);    JSValue function = thisObject->get(m_exec, Identifier::fromString(m_exec, m_name));    if (UNLIKELY(scope.exception())) {        hadException = true;        return { };    }    CallData callData;    CallType callType = getCallData(function, callData);    if (callType == CallType::None)        return { };    JSValue result;    NakedPtr<Exception> exception;    if (m_callHandler)        result = m_callHandler(m_exec, function, callType, callData, thisObject, m_arguments, exception);    else        result = JSC::call(m_exec, function, callType, callData, thisObject, m_arguments, exception);    if (exception) {        // Do not treat a terminated execution exception as having an exception. Just treat it as an empty result.        hadException = !isTerminatedExecutionException(exception);        return { };    }    return result;}

static EncodedJSValue JSC_HOST_CALL constructArrayBuffer(ExecState* exec){    VM& vm = exec->vm();    auto scope = DECLARE_THROW_SCOPE(vm);    JSArrayBufferConstructor* constructor =        jsCast<JSArrayBufferConstructor*>(exec->jsCallee());        unsigned length;    if (exec->argumentCount()) {        length = exec->uncheckedArgument(0).toIndex(exec, "length");        RETURN_IF_EXCEPTION(scope, encodedJSValue());    } else {        // Although the documentation doesn't say so, it is in fact correct to say        // "new ArrayBuffer()". The result is the same as allocating an array buffer        // with a zero length.        length = 0;    }        auto buffer = ArrayBuffer::tryCreate(length, 1);    if (!buffer)        return JSValue::encode(throwOutOfMemoryError(exec, scope));        if (constructor->sharingMode() == ArrayBufferSharingMode::Shared)        buffer->makeShared();        ASSERT(constructor->sharingMode() == buffer->sharingMode());        Structure* arrayBufferStructure = InternalFunction::createSubclassStructure(exec, exec->newTarget(), constructor->globalObject()->arrayBufferStructure(constructor->sharingMode()));    RETURN_IF_EXCEPTION(scope, encodedJSValue());    JSArrayBuffer* result = JSArrayBuffer::create(vm, arrayBufferStructure, WTFMove(buffer));        return JSValue::encode(result);}

static std::error_code getTypeFlags(ExecState& exec, const JSValue& typeValue, ResourceFlags& flags, uint16_t (*stringToType)(const String&)){    VM& vm = exec.vm();    auto scope = DECLARE_THROW_SCOPE(vm);    if (!typeValue.isObject())        return { };    const JSObject* object = typeValue.toObject(&exec);    ASSERT(!scope.exception());    if (!isJSArray(object))        return ContentExtensionError::JSONInvalidTriggerFlagsArray;    const JSArray* array = jsCast<const JSArray*>(object);        unsigned length = array->length();    for (unsigned i = 0; i < length; ++i) {        const JSValue value = array->getIndex(&exec, i);        if (scope.exception() || !value)            return ContentExtensionError::JSONInvalidObjectInTriggerFlagsArray;                String name = value.toWTFString(&exec);        uint16_t type = stringToType(name);        if (!type)            return ContentExtensionError::JSONInvalidStringInTriggerFlagsArray;        flags |= type;    }    return { };}

// HTMLAllCollections are strange objects, they support both get and call.static EncodedJSValue JSC_HOST_CALL callHTMLAllCollection(ExecState* exec){    VM& vm = exec->vm();    auto scope = DECLARE_THROW_SCOPE(vm);    if (exec->argumentCount() < 1)        return JSValue::encode(jsUndefined());    // Do not use thisObj here. It can be the JSHTMLDocument, in the document.forms(i) case.    JSHTMLAllCollection* jsCollection = jsCast<JSHTMLAllCollection*>(exec->callee());    HTMLAllCollection& collection = jsCollection->wrapped();    // Also, do we need the TypeError test here ?    if (exec->argumentCount() == 1) {        // Support for document.all(<index>) etc.        String string = exec->argument(0).toString(exec)->value(exec);        RETURN_IF_EXCEPTION(scope, encodedJSValue());        if (Optional<uint32_t> index = parseIndex(*string.impl()))            return JSValue::encode(toJS(exec, jsCollection->globalObject(), collection.item(index.value())));        // Support for document.images('<name>') etc.        return JSValue::encode(namedItems(*exec, jsCollection, Identifier::fromString(exec, string)));    }    // The second arg, if set, is the index of the item we want    String string = exec->argument(0).toString(exec)->value(exec);    RETURN_IF_EXCEPTION(scope, encodedJSValue());    if (Optional<uint32_t> index = parseIndex(*exec->argument(1).toWTFString(exec).impl())) {        if (auto* item = collection.namedItemWithIndex(string, index.value()))            return JSValue::encode(toJS(exec, jsCollection->globalObject(), *item));    }    return JSValue::encode(jsUndefined());}

JSValue JSWebKitSubtleCrypto::digest(ExecState& state){    VM& vm = state.vm();    auto scope = DECLARE_THROW_SCOPE(vm);    if (state.argumentCount() < 2)        return throwException(&state, scope, createNotEnoughArgumentsError(&state));    auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(0));    RETURN_IF_EXCEPTION(scope, { });    auto parameters = JSCryptoAlgorithmDictionary::createParametersForDigest(state, scope, algorithm->identifier(), state.uncheckedArgument(0));    RETURN_IF_EXCEPTION(scope, { });    auto data = cryptoOperationDataFromJSValue(state, scope, state.uncheckedArgument(1));    RETURN_IF_EXCEPTION(scope, { });    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());    auto promise = wrapper->promise();    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());    };    auto failureCallback = [wrapper]() mutable {        wrapper->reject(); // FIXME: This should reject with an Exception.    };    auto result = algorithm->digest(*parameters, data, WTFMove(successCallback), WTFMove(failureCallback));    if (result.hasException()) {        propagateException(state, scope, result.releaseException());        return { };    }    return promise;}

EncodedJSValue JSC_HOST_CALL IntlCollatorPrototypeGetterCompare(ExecState* state){    VM& vm = state->vm();    auto scope = DECLARE_THROW_SCOPE(vm);    // 10.3.3 Intl.Collator.prototype.compare (ECMA-402 2.0)    // 1. Let collator be this Collator object.    IntlCollator* collator = jsDynamicCast<IntlCollator*>(state->thisValue());    if (!collator)        return JSValue::encode(throwTypeError(state, scope, ASCIILiteral("Intl.Collator.prototype.compare called on value that's not an object initialized as a Collator")));    JSBoundFunction* boundCompare = collator->boundCompare();    // 2. If collator.[[boundCompare]] is undefined,    if (!boundCompare) {        JSGlobalObject* globalObject = collator->globalObject();        // a. Let F be a new built-in function object as defined in 11.3.4.        // b. The value of F’s length property is 2.        JSFunction* targetObject = JSFunction::create(vm, globalObject, 2, ASCIILiteral("compare"), IntlCollatorFuncCompare, NoIntrinsic);        // c. Let bc be BoundFunctionCreate(F, 
C++ DECLARE_WAITQUEUE函数代码示例
C++ DECLARE_COMPLETION_ONSTACK函数代码示例