String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
{
ASSERT(m_customResolver);
JSLock lock(SilenceAssertionsOnly);
ExecState* exec = m_globalObject->globalExec();
JSValue function = m_customResolver->get(exec, Identifier(exec, "lookupNamespaceURI"));
CallData callData;
CallType callType = getCallData(function, callData);
if (callType == CallTypeNone) {
callType = m_customResolver->getCallData(callData);
if (callType == CallTypeNone) {
// FIXME: Pass actual line number and source URL.
m_globalObject->impl()->console()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, "XPathNSResolver does not have a lookupNamespaceURI method.", 0, String());
return String();
}
function = m_customResolver;
}
RefPtr<JSCustomXPathNSResolver> selfProtector(this);
MarkedArgumentBuffer args;
args.append(jsString(exec, prefix));
m_globalObject->globalData().timeoutChecker.start();
JSValue retval = JSC::call(exec, function, callType, callData, m_customResolver, args);
m_globalObject->globalData().timeoutChecker.stop();
String result;
if (exec->hadException())
reportCurrentException(exec);
else {
if (!retval.isUndefinedOrNull())
result = ustringToString(retval.toString(exec));
}
Document::updateStyleForAllDocuments();
return result;
}
bool NPJSObject::invoke(ExecState* exec, JSGlobalObject* globalObject, JSValue function, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
{
CallData callData;
CallType callType = getCallData(function, callData);
if (callType == CallTypeNone)
return false;
// Convert the passed in arguments.
MarkedArgumentBuffer argumentList;
for (uint32_t i = 0; i < argumentCount; ++i)
argumentList.append(m_objectMap->convertNPVariantToJSValue(exec, globalObject, arguments[i]));
JSValue value = JSC::call(exec, function, callType, callData, m_jsObject->methodTable()->toThisObject(m_jsObject.get(), exec), argumentList);
// Convert and return the result of the function call.
m_objectMap->convertJSValueToNPVariant(exec, value, *result);
exec->clearException();
return true;
}
JSPromise* ReadableJSStream::invoke(ExecState& state, const char* propertyName, JSValue parameter)
{
JSValue function = getPropertyFromObject(state, *m_source.get(), propertyName);
if (state.hadException())
return nullptr;
if (!function.isFunction()) {
if (!function.isUndefined())
throwVMError(&state, createTypeError(&state, ASCIILiteral("ReadableStream trying to call a property that is not callable")));
return nullptr;
}
MarkedArgumentBuffer arguments;
arguments.append(parameter);
JSPromise* promise = jsDynamicCast<JSPromise*>(callFunction(state, function, m_source.get(), arguments));
ASSERT(!(promise && state.hadException()));
return promise;
}
void Arguments::fillArgList(ExecState* exec, MarkedArgumentBuffer& args)
{
if (UNLIKELY(d->overrodeLength)) {
unsigned length = get(exec, exec->propertyNames().length).toUInt32(exec);
for (unsigned i = 0; i < length; i++)
args.append(get(exec, i));
return;
}
if (LIKELY(!d->deletedArguments)) {
if (LIKELY(!d->numParameters)) {
args.initialize(d->extraArguments, d->numArguments);
return;
}
if (d->numParameters == d->numArguments) {
args.initialize(&d->registers[d->firstParameterIndex], d->numArguments);
return;
}
unsigned parametersLength = min(d->numParameters, d->numArguments);
unsigned i = 0;
for (; i < parametersLength; ++i)
args.append(d->registers[d->firstParameterIndex + i].get());
for (; i < d->numArguments; ++i)
args.append(d->extraArguments[i - d->numParameters].get());
return;
}
unsigned parametersLength = min(d->numParameters, d->numArguments);
unsigned i = 0;
for (; i < parametersLength; ++i) {
if (!d->deletedArguments[i])
args.append(d->registers[d->firstParameterIndex + i].get());
else
args.append(get(exec, i));
}
for (; i < d->numArguments; ++i) {
if (!d->deletedArguments[i])
args.append(d->extraArguments[i - d->numParameters].get());
else
args.append(get(exec, i));
}
}
JSValue JSJavaScriptCallFrame::scopeChain(ExecState* exec) const
{
if (!impl()->scopeChain())
return jsNull();
ScopeChainNode* scopeChain = impl()->scopeChain();
ScopeChainIterator iter = scopeChain->begin();
ScopeChainIterator end = scopeChain->end();
// we must always have something in the scope chain
ASSERT(iter != end);
MarkedArgumentBuffer list;
do {
list.append(iter->get());
++iter;
} while (iter != end);
return constructArray(exec, globalObject(), list);
}
bool callSetter(ExecState* exec, JSValue base, JSValue getterSetter, JSValue value, ECMAMode ecmaMode)
{
GetterSetter* getterSetterObj = jsCast<GetterSetter*>(getterSetter);
if (getterSetterObj->isSetterNull()) {
if (ecmaMode == StrictMode)
throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
return false;
}
JSObject* setter = getterSetterObj->setter();
MarkedArgumentBuffer args;
args.append(value);
CallData callData;
CallType callType = setter->methodTable(exec->vm())->getCallData(setter, callData);
call(exec, setter, callType, callData, base, args);
return true;
}
bool JSTestCallbackFunction::callbackWithArrayParam(RefPtr<Float32Array> arrayParam)
{
if (!canInvokeCallback())
return true;
Ref<JSTestCallbackFunction> protectedThis(*this);
JSLockHolder lock(m_data->globalObject()->vm());
ExecState* state = m_data->globalObject()->globalExec();
MarkedArgumentBuffer args;
args.append(toJS(state, m_data->globalObject(), arrayParam));
NakedPtr<Exception> returnedException;
UNUSED_PARAM(state);
m_data->invokeCallback(args, JSCallbackData::CallbackType::Function, Identifier(), returnedException);
if (returnedException)
reportException(state, returnedException);
return !returnedException;
}
JSObjectRef JSObjectMakeRegExp(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
exec->globalData().heap.registerThread();
JSLock lock(exec);
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
JSObject* result = constructRegExp(exec, argList);
if (exec->hadException()) {
if (exception)
*exception = toRef(exec, exec->exception());
exec->clearException();
result = 0;
}
return toRef(result);
}
short JSNodeFilterCondition::acceptNode(JSC::ExecState* exec, Node* filterNode) const
{
JSLock lock(SilenceAssertionsOnly);
if (!m_filter)
return NodeFilter::FILTER_ACCEPT;
// Exec is null if we've been called from a non-JavaScript language and the document
// is no longer able to run JavaScript (e.g., it's disconnected from its frame).
if (!exec)
return NodeFilter::FILTER_REJECT;
JSValue filter = m_filter.get();
CallData callData;
CallType callType = getCallData(filter, callData);
if (callType == CallTypeNone) {
filter = filter.get(exec, Identifier(exec, "acceptNode"));
callType = getCallData(filter, callData);
if (callType == CallTypeNone) {
throwError(exec, createTypeError(exec, "NodeFilter object does not have an acceptNode function"));
return NodeFilter::FILTER_REJECT;
}
}
MarkedArgumentBuffer args;
// FIXME: The node should have the prototype chain that came from its document, not
// whatever prototype chain might be on the window this filter came from. Bug 27662
args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), filterNode));
if (exec->hadException())
return NodeFilter::FILTER_REJECT;
JSValue result = JSMainThreadExecState::call(exec, filter, callType, callData, m_filter.get(), args);
if (exec->hadException())
return NodeFilter::FILTER_REJECT;
int intResult = result.toInt32(exec);
if (exec->hadException())
return NodeFilter::FILTER_REJECT;
return intResult;
}
JSValue JSInjectedScriptHost::evaluate(ExecState* exec)
{
JSValue expression = exec->argument(0);
if (!expression.isString())
return throwError(exec, createError(exec, "String argument expected."));
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
JSFunction* evalFunction = globalObject->evalFunction();
CallData callData;
CallType callType = evalFunction->methodTable()->getCallData(evalFunction, callData);
if (callType == CallTypeNone)
return jsUndefined();
MarkedArgumentBuffer args;
args.append(expression);
bool wasEvalEnabled = globalObject->evalEnabled();
globalObject->setEvalEnabled(true);
JSValue result = JSC::call(exec, evalFunction, callType, callData, exec->globalThisValue(), args);
globalObject->setEvalEnabled(wasEvalEnabled);
return result;
}
bool JSDatabaseCallback::handleEvent(ScriptExecutionContext* context, DatabaseSync* database)
{
ASSERT(m_data);
ASSERT(context);
RefPtr<JSDatabaseCallback> protect(this);
JSLock lock(SilenceAssertionsOnly);
JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(context, m_isolatedWorld.get());
if (!globalObject)
return true;
ExecState* exec = globalObject->globalExec();
MarkedArgumentBuffer args;
args.append(toJS(exec, database));
bool raisedException = false;
m_data->invokeCallback(args, &raisedException);
return !raisedException;
}
void ReadableStream::lock()
{
auto& state = *m_globalObject->globalExec();
VM& vm = state.vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
auto* constructor = JSC::asObject(m_globalObject->get(&state, clientData.builtinNames().ReadableStreamDefaultReaderPrivateName()));
ConstructData constructData;
ConstructType constructType = constructor->methodTable(vm)->getConstructData(constructor, constructData);
ASSERT(constructType != ConstructType::None);
MarkedArgumentBuffer args;
args.append(readableStream());
ASSERT(!args.hasOverflowed());
JSC::construct(&state, constructor, constructType, constructData, args);
scope.assertNoException();
}
static EncodedJSValue JSC_HOST_CALL callPlugin(ExecState* exec)
{
JSHTMLElement* element = jsCast<JSHTMLElement*>(exec->callee());
// Get the plug-in script object.
JSObject* scriptObject = pluginScriptObject(exec, element);
ASSERT(scriptObject);
size_t argumentCount = exec->argumentCount();
MarkedArgumentBuffer argumentList;
for (size_t i = 0; i < argumentCount; i++)
argumentList.append(exec->argument(i));
CallData callData;
CallType callType = getCallData(scriptObject, callData);
ASSERT(callType == CallTypeHost);
// Call the object.
JSValue result = call(exec, scriptObject, callType, callData, exec->hostThisValue(), argumentList);
return JSValue::encode(result);
}
String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
{
ASSERT(m_customResolver);
JSLockHolder lock(JSDOMWindowBase::commonVM());
ExecState* exec = m_globalObject->globalExec();
JSValue function = m_customResolver->get(exec, Identifier::fromString(exec, "lookupNamespaceURI"));
CallData callData;
CallType callType = getCallData(function, callData);
if (callType == CallTypeNone) {
callType = m_customResolver->methodTable()->getCallData(m_customResolver.get(), callData);
if (callType == CallTypeNone) {
// FIXME: <http://webkit.org/b/114312> JSCustomXPathNSResolver::lookupNamespaceURI Console Message should include Line, Column, and SourceURL
if (PageConsoleClient* console = m_globalObject->impl().console())
console->addMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("XPathNSResolver does not have a lookupNamespaceURI method."));
return String();
}
function = m_customResolver.get();
}
Ref<JSCustomXPathNSResolver> selfProtector(*this);
MarkedArgumentBuffer args;
args.append(jsStringWithCache(exec, prefix));
NakedPtr<Exception> exception;
JSValue retval = JSMainThreadExecState::call(exec, function, callType, callData, m_customResolver.get(), args, exception);
String result;
if (exception)
reportException(exec, exception);
else {
if (!retval.isUndefinedOrNull())
result = retval.toString(exec)->value(exec);
}
return result;
}
String JSCustomXPathNSResolver::lookupNamespaceURI(const String& prefix)
{
ASSERT(m_customResolver);
JSLockHolder lock(commonVM());
ExecState* exec = m_globalObject->globalExec();
JSValue function = m_customResolver->get(exec, Identifier::fromString(exec, "lookupNamespaceURI"));
CallData callData;
CallType callType = getCallData(function, callData);
if (callType == CallType::None) {
callType = m_customResolver->methodTable()->getCallData(m_customResolver.get(), callData);
if (callType == CallType::None) {
if (PageConsoleClient* console = m_globalObject->wrapped().console())
console->addMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("XPathNSResolver does not have a lookupNamespaceURI method."));
return String();
}
function = m_customResolver.get();
}
Ref<JSCustomXPathNSResolver> protectedThis(*this);
MarkedArgumentBuffer args;
args.append(jsStringWithCache(exec, prefix));
NakedPtr<JSC::Exception> exception;
JSValue retval = JSMainThreadExecState::call(exec, function, callType, callData, m_customResolver.get(), args, exception);
String result;
if (exception)
reportException(exec, exception);
else {
if (!retval.isUndefinedOrNull())
result = retval.toWTFString(exec);
}
return result;
}
void WebDebugListenerImpl::sourceParsedFunctions(ExecState* execState, intptr_t sourceId, JSC::ParserArenaData<DeclarationStacks::FunctionStack>* funcStack)
{
if (m_listener && !m_inDebug) {
m_inDebug = true;
MarkedArgumentBuffer funcList;
ArgList empty;
Identifier functionName (execState, "functionName");
Identifier firstLine (execState, "firstLine");
Identifier lastLine (execState, "lastLine");
for(size_t i=0, l=funcStack->data.size(); i<l; i++) {
FunctionBodyNode *funcBody = funcStack->data[i];
ASSERT(funcBody);
if (!funcBody) continue;
JSObject* funcObj = JSC::constructEmptyObject(execState);
JSC::PutPropertySlot slot;
funcObj->put(execState, functionName, jsString( execState, funcBody->ident().ustring() ), slot );
funcObj->put(execState, firstLine, jsNumber ( execState, funcBody->firstLine() ), slot );
funcObj->put(execState, lastLine, jsNumber ( execState, funcBody->lastLine() ), slot);
funcList.append(funcObj);
}
JSObject* functions = JSC::constructArray(execState, funcList);
WebScriptProxyVariant* functionsVariant = WebCore::ApolloScriptBridging::getApolloVariantForJSValue(execState, functions);
m_listener->m_pVTable->sourceParsedFunctions(m_listener, sourceId, functionsVariant);
m_inDebug = false;
}
}
JSValue JSWebGLRenderingContext::getAttachedShaders(ExecState* exec)
{
if (exec->argumentCount() < 1)
return exec->vm().throwException(exec, createNotEnoughArgumentsError(exec));
ExceptionCode ec = 0;
WebGLRenderingContext& context = impl();
WebGLProgram* program = toWebGLProgram(exec->uncheckedArgument(0));
if (!program && !exec->uncheckedArgument(0).isUndefinedOrNull())
return throwTypeError(exec);
Vector<RefPtr<WebGLShader>> shaders;
bool succeed = context.getAttachedShaders(program, shaders, ec);
if (ec) {
setDOMException(exec, ec);
return jsNull();
}
if (!succeed)
return jsNull();
MarkedArgumentBuffer list;
for (size_t ii = 0; ii < shaders.size(); ++ii)
list.append(toJS(exec, globalObject(), shaders[ii].get()));
return constructArray(exec, 0, globalObject(), list);
}
void JSCustomPositionCallback::handleEvent(Geoposition* geoposition)
{
#if ENABLE(GEOLOCATION)
ASSERT(m_callback);
ASSERT(m_globalObject);
ExecState* exec = m_globalObject->globalExec();
JSC::JSLock lock(SilenceAssertionsOnly);
JSValue function = m_callback->get(exec, Identifier(exec, "handleEvent"));
CallData callData;
CallType callType = function.getCallData(callData);
if (callType == CallTypeNone) {
callType = m_callback->getCallData(callData);
if (callType == CallTypeNone) {
// FIXME: Should an exception be thrown here?
return;
}
function = m_callback;
}
RefPtr<JSCustomPositionCallback> protect(this);
MarkedArgumentBuffer args;
args.append(toJS(exec, deprecatedGlobalObjectForPrototype(exec), geoposition));
m_globalObject->globalData()->timeoutChecker.start();
call(exec, function, callType, callData, m_callback, args);
m_globalObject->globalData()->timeoutChecker.stop();
if (exec->hadException())
reportCurrentException(exec);
Document::updateStyleForAllDocuments();
#endif
}
JSObjectRef JSObjectMakeRegExp(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
}
ExecState* exec = toJS(ctx);
APIEntryShim entryShim(exec);
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
JSObject* result = constructRegExp(exec, exec->lexicalGlobalObject(), argList);
if (exec->hadException()) {
if (exception)
*exception = toRef(exec, exec->exception());
exec->clearException();
result = 0;
}
return toRef(result);
}
double ReadableJSStream::retrieveChunkSize(ExecState& state, JSValue chunk)
{
if (!m_sizeFunction)
return 1;
MarkedArgumentBuffer arguments;
arguments.append(chunk);
JSValue sizeValue = callFunction(state, m_sizeFunction.get(), jsUndefined(), arguments);
if (state.hadException())
return 0;
double size = sizeValue.toNumber(&state);
if (state.hadException())
return 0;
if (!std::isfinite(size) || size < 0) {
throwVMError(&state, createRangeError(&state, ASCIILiteral("Incorrect double value")));
return 0;
}
return size;
}
JSValue iteratorNext(ExecState* exec, JSValue iterator, JSValue value)
{
JSValue nextFunction = iterator.get(exec, exec->vm().propertyNames->next);
if (exec->hadException())
return jsUndefined();
CallData nextFunctionCallData;
CallType nextFunctionCallType = getCallData(nextFunction, nextFunctionCallData);
if (nextFunctionCallType == CallType::None)
return throwTypeError(exec);
MarkedArgumentBuffer nextFunctionArguments;
if (!value.isEmpty())
nextFunctionArguments.append(value);
JSValue result = call(exec, nextFunction, nextFunctionCallType, nextFunctionCallData, iterator, nextFunctionArguments);
if (exec->hadException())
return jsUndefined();
if (!result.isObject())
return throwTypeError(exec, ASCIILiteral("Iterator result interface is not an object."));
return result;
}
bool NPJSObject::invoke(ExecState* exec, JSGlobalObject* globalObject, JSValue function, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
{
VM& vm = exec->vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
CallData callData;
CallType callType = getCallData(function, callData);
if (callType == CallType::None)
return false;
// Convert the passed in arguments.
MarkedArgumentBuffer argumentList;
for (uint32_t i = 0; i < argumentCount; ++i)
argumentList.append(m_objectMap->convertNPVariantToJSValue(exec, globalObject, arguments[i]));
JSValue value = JSC::call(exec, function, callType, callData, m_jsObject.get(), argumentList);
// Convert and return the result of the function call.
m_objectMap->convertJSValueToNPVariant(exec, value, *result);
scope.clearException();
return true;
}
Ref<ReadableStream> ReadableStream::create(JSC::ExecState& execState, RefPtr<ReadableStreamSource>&& source)
{
VM& vm = execState.vm();
auto scope = DECLARE_CATCH_SCOPE(vm);
auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(execState.lexicalGlobalObject());
auto* constructor = JSC::asObject(globalObject.get(&execState, clientData.builtinNames().ReadableStreamPrivateName()));
ConstructData constructData;
ConstructType constructType = constructor->methodTable(vm)->getConstructData(constructor, constructData);
ASSERT(constructType != ConstructType::None);
MarkedArgumentBuffer args;
args.append(source ? toJSNewlyCreated(&execState, &globalObject, source.releaseNonNull()) : JSC::jsUndefined());
ASSERT(!args.hasOverflowed());
auto newReadableStream = jsDynamicCast<JSReadableStream*>(vm, JSC::construct(&execState, constructor, constructType, constructData, args));
scope.assertNoException();
return create(globalObject, *newReadableStream);
}
static EncodedJSValue JSC_HOST_CALL constructPromise(ExecState* exec)
{
if (!exec->argumentCount())
return throwVMError(exec, createTypeError(exec, "Expected at least one argument"));
JSValue function = exec->argument(0);
CallData callData;
CallType callType = getCallData(function, callData);
if (callType == CallTypeNone)
return throwVMError(exec, createTypeError(exec, "Expected function as as first argument"));
JSGlobalObject* globalObject = asInternalFunction(exec->callee())->globalObject();
// 1. Let promise be a new promise.
JSPromise* promise = JSPromise::createWithResolver(exec->vm(), globalObject);
// 2. Let resolver be promise's associated resolver.
JSPromiseResolver* resolver = promise->resolver();
// 3. Set init's callback this value to promise.
// 4. Invoke init with resolver passed as parameter.
MarkedArgumentBuffer initArguments;
initArguments.append(resolver);
call(exec, function, callType, callData, promise, initArguments);
// 5. If init threw an exception, catch it, and then, if resolver's resolved flag
// is unset, run resolver's reject with the thrown exception as argument.
if (exec->hadException()) {
JSValue exception = exec->exception();
exec->clearException();
resolver->rejectIfNotResolved(exec, exception);
}
return JSValue::encode(promise);
}
void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSValue thisValue)
{
ASSERT(m_function);
JSLock lock(SilenceAssertionsOnly);
CallData callData;
CallType callType = m_function.get().getCallData(callData);
if (callType == CallTypeNone)
return;
ExecState* exec = globalObject->globalExec();
MarkedArgumentBuffer args;
size_t size = m_args.size();
for (size_t i = 0; i < size; ++i)
args.append(m_args[i]);
globalObject->globalData()->timeoutChecker.start();
call(exec, m_function, callType, callData, thisValue, args);
globalObject->globalData()->timeoutChecker.stop();
if (exec->hadException())
reportCurrentException(exec);
}
JSObjectRef JSObjectCallAsConstructor(JSContextRef ctx, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
APIEntryShim entryShim(exec);
JSObject* jsObject = toJS(object);
ConstructData constructData;
ConstructType constructType = jsObject->methodTable()->getConstructData(jsObject, constructData);
if (constructType == ConstructTypeNone)
return 0;
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; i++)
argList.append(toJS(exec, arguments[i]));
JSObjectRef result = toRef(construct(exec, jsObject, constructType, constructData, argList));
if (exec->hadException()) {
if (exception)
*exception = toRef(exec, exec->exception());
exec->clearException();
result = 0;
}
return result;
}
JSObjectRef JSObjectMakeArray(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
APIEntryShim entryShim(exec);
JSObject* result;
if (argumentCount) {
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
result = constructArray(exec, argList);
} else
result = constructEmptyArray(exec);
if (exec->hadException()) {
if (exception)
*exception = toRef(exec, exec->exception());
exec->clearException();
result = 0;
}
return toRef(result);
}
JSValue JSWebGLRenderingContext::getAttachedShaders(ExecState* exec)
{
if (exec->argumentCount() < 1)
return throwSyntaxError(exec);
ExceptionCode ec = 0;
WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
if (exec->argumentCount() > 0 && !exec->argument(0).isUndefinedOrNull() && !exec->argument(0).inherits(&JSWebGLProgram::s_info))
return throwTypeError(exec);
WebGLProgram* program = toWebGLProgram(exec->argument(0));
if (exec->hadException())
return jsUndefined();
Vector<WebGLShader*> shaders;
bool succeed = context->getAttachedShaders(program, shaders, ec);
if (ec) {
setDOMException(exec, ec);
return jsUndefined();
}
if (!succeed)
return jsUndefined();
MarkedArgumentBuffer list;
for (size_t ii = 0; ii < shaders.size(); ++ii)
list.append(toJS(exec, globalObject(), shaders[ii]));
return constructArray(exec, list);
}
JSObjectRef JSObjectMakeArray(JSContextRef ctx, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (!ctx) {
ASSERT_NOT_REACHED();
return 0;
}
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
JSObject* result;
if (argumentCount) {
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; ++i)
argList.append(toJS(exec, arguments[i]));
result = constructArray(exec, static_cast<ArrayAllocationProfile*>(0), argList);
} else
result = constructEmptyArray(exec, 0);
if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
result = 0;
return toRef(result);
}
JSObjectRef JSObjectCallAsConstructor(JSContextRef ctx, JSObjectRef object, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
JSLockHolder locker(exec);
if (!object)
return 0;
JSObject* jsObject = toJS(object);
ConstructData constructData;
ConstructType constructType = jsObject->methodTable()->getConstructData(jsObject, constructData);
if (constructType == ConstructTypeNone)
return 0;
MarkedArgumentBuffer argList;
for (size_t i = 0; i < argumentCount; i++)
argList.append(toJS(exec, arguments[i]));
JSObjectRef result = toRef(profiledConstruct(exec, ProfilingReason::API, jsObject, constructType, constructData, argList));
if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
result = 0;
return result;
}
