char* JIT_OPERATION operationNewArray(ExecState* exec, Structure* arrayStructure, void* buffer, size_t size)
{
VM* vm = &exec->vm();
NativeCallFrameTracer tracer(vm, exec);
return bitwise_cast<char*>(constructArray(exec, arrayStructure, static_cast<JSValue*>(buffer), size));
}
static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
{
switch (info.getType()) {
case WebGLGetInfo::kTypeBool:
return jsBoolean(info.getBool());
case WebGLGetInfo::kTypeBoolArray: {
MarkedArgumentBuffer list;
const auto& values = info.getBoolArray();
for (const auto& value : values)
list.append(jsBoolean(value));
return constructArray(exec, 0, globalObject, list);
}
case WebGLGetInfo::kTypeFloat:
return jsNumber(info.getFloat());
case WebGLGetInfo::kTypeInt:
return jsNumber(info.getInt());
case WebGLGetInfo::kTypeNull:
return jsNull();
case WebGLGetInfo::kTypeString:
return jsStringWithCache(exec, info.getString());
case WebGLGetInfo::kTypeUnsignedInt:
return jsNumber(info.getUnsignedInt());
case WebGLGetInfo::kTypeInt64:
return jsNumber(info.getInt64());
default:
notImplemented();
return jsUndefined();
}
}
EncodedJSValue DFG_OPERATION operationNewArray(ExecState* exec, void* start, size_t size)
{
JSGlobalData* globalData = &exec->globalData();
NativeCallFrameTracer tracer(globalData, exec);
return JSValue::encode(constructArray(exec, static_cast<JSValue*>(start), size));
}
JSValue JSInspectorFrontendHost::search(ExecState* exec, const ArgList& args)
{
if (args.size() < 2)
return jsUndefined();
Node* node = toNode(args.at(0));
if (!node)
return jsUndefined();
String target = args.at(1).toString(exec);
if (exec->hadException())
return jsUndefined();
MarkedArgumentBuffer result;
RefPtr<Range> searchRange(rangeOfContents(node));
ExceptionCode ec = 0;
do {
RefPtr<Range> resultRange(findPlainText(searchRange.get(), target, true, false));
if (resultRange->collapsed(ec))
break;
// A non-collapsed result range can in some funky whitespace cases still not
// advance the range's start position (4509328). Break to avoid infinite loop.
VisiblePosition newStart = endVisiblePosition(resultRange.get(), DOWNSTREAM);
if (newStart == startVisiblePosition(searchRange.get(), DOWNSTREAM))
break;
result.append(toJS(exec, resultRange.get()));
setStart(searchRange.get(), newStart);
} while (true);
return constructArray(exec, result);
}
static EncodedJSValue createIteratorResult(CallFrame* callFrame, ArrayIterationKind kind, size_t index, JSValue result, bool done)
{
if (done)
return JSValue::encode(callFrame->vm().iterationTerminator.get());
switch (kind & ~ArrayIterateSparseTag) {
case ArrayIterateKey:
return JSValue::encode(jsNumber(index));
case ArrayIterateValue:
return JSValue::encode(result);
case ArrayIterateKeyValue: {
MarkedArgumentBuffer args;
args.append(jsNumber(index));
args.append(result);
JSGlobalObject* globalObject = callFrame->callee()->globalObject();
return JSValue::encode(constructArray(callFrame, 0, globalObject, args));
}
default:
RELEASE_ASSERT_NOT_REACHED();
}
return JSValue::encode(JSValue());
}
bool JSMutationCallback::handleEvent(MutationRecordArray* mutations, WebKitMutationObserver* observer)
{
if (!canInvokeCallback())
return true;
RefPtr<JSMutationCallback> protect(this);
JSLock lock(SilenceAssertionsOnly);
ExecState* exec = m_data->globalObject()->globalExec();
MarkedArgumentBuffer mutationList;
for (size_t i = 0; i < mutations->size(); ++i)
mutationList.append(toJS(exec, m_data->globalObject(), mutations->at(i).get()));
JSValue jsObserver = toJS(exec, m_data->globalObject(), observer);
MarkedArgumentBuffer args;
args.append(constructArray(exec, m_data->globalObject(), mutationList));
args.append(jsObserver);
bool raisedException = false;
m_data->invokeCallback(jsObserver, args, &raisedException);
return !raisedException;
}
JSValue JSSetIterator::createPair(CallFrame* callFrame, JSValue key, JSValue value)
{
MarkedArgumentBuffer args;
args.append(key);
args.append(value);
JSGlobalObject* globalObject = callFrame->callee()->globalObject();
return constructArray(callFrame, 0, globalObject, args);
}
int * removeRequiredElement(int *arr, int n, std::stack<int> s0, std::stack<int> s1, std::stack<int> s2)
{
int size = n;
int sum = 0;
for (int i = 0; i < n; ++i)
sum = sum + arr[i];
if (sum % 3 == 0)
return arr;
else if (sum % 3 == 1)
{
if (!s1.empty())
{
s1.pop();
size--;
}
else if (!s2.empty())
{
// we need to pop two elements whose rem is 2
s2.pop();
size--;
if (!s2.empty())
{
s2.pop();
size--;
}
else
return NULL;
}
else
return NULL;
}
else // rem is 2
{
if (!s2.empty())
{
s2.pop();
size--;
}
else if (!s1.empty())
{
// pop two elements whose rem is 1
s1.pop();
size--;
if (!s1.empty())
{
s1.pop();
size--;
}
else
return NULL;
}
else
return NULL;
}
return constructArray(s0, s1, s2, size);
}
JSObject* constructArrayWithSizeQuirk(ExecState* exec, ArrayAllocationProfile* profile, JSGlobalObject* globalObject, JSValue length)
{
if (!length.isNumber())
return constructArray(exec, profile, globalObject, &length, 1);
uint32_t n = length.toUInt32(exec);
if (n != length.toNumber(exec))
return exec->vm().throwException(exec, createRangeError(exec, ASCIILiteral("Array size is not a small enough positive integer.")));
return constructEmptyArray(exec, profile, globalObject, n);
}
JSValue JSMessageEvent::ports(ExecState* exec) const
{
MessagePortArray* ports = static_cast<MessageEvent*>(impl())->ports();
if (!ports)
return constructEmptyArray(exec, globalObject());
MarkedArgumentBuffer list;
for (size_t i = 0; i < ports->size(); i++)
list.append(toJS(exec, globalObject(), (*ports)[i].get()));
return constructArray(exec, globalObject(), list);
}
JSValue JSWebGLRenderingContextBase::getSupportedExtensions(ExecState* exec)
{
WebGLRenderingContextBase& context = impl();
if (context.isContextLost())
return jsNull();
Vector<String> value = context.getSupportedExtensions();
MarkedArgumentBuffer list;
for (size_t ii = 0; ii < value.size(); ++ii)
list.append(jsStringWithCache(exec, value[ii]));
return constructArray(exec, 0, globalObject(), list);
}
JSValue JSCanvasRenderingContext2D::webkitLineDash(ExecState* exec) const
{
CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(impl());
const Vector<float>& dash = context->getLineDash();
MarkedArgumentBuffer list;
Vector<float>::const_iterator end = dash.end();
for (Vector<float>::const_iterator it = dash.begin(); it != end; ++it)
list.append(JSValue(*it));
return constructArray(exec, 0, globalObject(), list);
}
JSValue JSConsole::profiles(ExecState* exec) const
{
const ProfilesArray& profiles = impl()->profiles();
MarkedArgumentBuffer list;
ProfilesArray::const_iterator end = profiles.end();
for (ProfilesArray::const_iterator iter = profiles.begin(); iter != end; ++iter)
list.append(toJS(exec, iter->get()));
return constructArray(exec, list);
}
static inline JSObject* constructArrayWithSizeQuirk(ExecState* exec, const ArgList& args)
{
JSGlobalObject* globalObject = asInternalFunction(exec->callee())->globalObject();
// a single numeric argument denotes the array size (!)
if (args.size() == 1)
return constructArrayWithSizeQuirk(exec, 0, globalObject, args.at(0));
// otherwise the array is constructed with the arguments in it
return constructArray(exec, 0, globalObject, args);
}
JSValue JSWebGLRenderingContext::getSupportedExtensions(ExecState* exec)
{
WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
if (context->isContextLost())
return jsNull();
Vector<String> value = context->getSupportedExtensions();
MarkedArgumentBuffer list;
for (size_t ii = 0; ii < value.size(); ++ii)
list.append(jsString(exec, value[ii]));
return constructArray(exec, globalObject(), list);
}
static JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, const WebGLGetInfo& info)
{
switch (info.getType()) {
case WebGLGetInfo::kTypeBool:
return jsBoolean(info.getBool());
case WebGLGetInfo::kTypeBoolArray: {
MarkedArgumentBuffer list;
const Vector<bool>& value = info.getBoolArray();
for (size_t ii = 0; ii < value.size(); ++ii)
list.append(jsBoolean(value[ii]));
return constructArray(exec, 0, globalObject, list);
}
case WebGLGetInfo::kTypeFloat:
return jsNumber(info.getFloat());
case WebGLGetInfo::kTypeInt:
return jsNumber(info.getInt());
case WebGLGetInfo::kTypeNull:
return jsNull();
case WebGLGetInfo::kTypeString:
return jsStringWithCache(exec, info.getString());
case WebGLGetInfo::kTypeUnsignedInt:
return jsNumber(info.getUnsignedInt());
case WebGLGetInfo::kTypeWebGLBuffer:
return toJS(exec, globalObject, info.getWebGLBuffer());
case WebGLGetInfo::kTypeWebGLFloatArray:
return toJS(exec, globalObject, info.getWebGLFloatArray());
case WebGLGetInfo::kTypeWebGLFramebuffer:
return toJS(exec, globalObject, info.getWebGLFramebuffer());
case WebGLGetInfo::kTypeWebGLIntArray:
return toJS(exec, globalObject, info.getWebGLIntArray());
// FIXME: implement WebGLObjectArray
// case WebGLGetInfo::kTypeWebGLObjectArray:
case WebGLGetInfo::kTypeWebGLProgram:
return toJS(exec, globalObject, info.getWebGLProgram());
case WebGLGetInfo::kTypeWebGLRenderbuffer:
return toJS(exec, globalObject, info.getWebGLRenderbuffer());
case WebGLGetInfo::kTypeWebGLTexture:
return toJS(exec, globalObject, info.getWebGLTexture());
case WebGLGetInfo::kTypeWebGLUnsignedByteArray:
return toJS(exec, globalObject, info.getWebGLUnsignedByteArray());
case WebGLGetInfo::kTypeWebGLUnsignedIntArray:
return toJS(exec, globalObject, info.getWebGLUnsignedIntArray());
#if ENABLE(WEBGL2)
case WebGLGetInfo::kTypeWebGLVertexArrayObject:
return toJS(exec, globalObject, info.getWebGLVertexArrayObject());
#endif
case WebGLGetInfo::kTypeWebGLVertexArrayObjectOES:
return toJS(exec, globalObject, info.getWebGLVertexArrayObjectOES());
default:
notImplemented();
return jsUndefined();
}
}
JSValue JSInternals::userPreferredLanguages(ExecState* exec) const
{
Internals* imp = static_cast<Internals*>(impl());
const Vector<String> languages = imp->userPreferredLanguages();
if (languages.isEmpty())
return jsNull();
MarkedArgumentBuffer array;
Vector<String>::const_iterator end = languages.end();
for (Vector<String>::const_iterator it = languages.begin(); it != end; ++it)
array.append(jsString(exec, stringToUString(*it)));
return constructArray(exec, globalObject(), array);
}
JSValue JSC_HOST_CALL stringProtoFuncMatch(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
{
UString s = thisValue.toThisString(exec);
JSValue a0 = args.at(0);
UString u = s;
RefPtr<RegExp> reg;
RegExpObject* imp = 0;
if (a0.isObject(&RegExpObject::info))
reg = asRegExpObject(a0)->regExp();
else {
/*
* ECMA 15.5.4.12 String.prototype.search (regexp)
* If regexp is not an object whose [[Class]] property is "RegExp", it is
* replaced with the result of the expression new RegExp(regexp).
*/
reg = RegExp::create(&exec->globalData(), a0.toString(exec));
}
RegExpConstructor* regExpConstructor = exec->lexicalGlobalObject()->regExpConstructor();
int pos;
int matchLength;
regExpConstructor->performMatch(reg.get(), u, 0, pos, matchLength);
if (!(reg->global())) {
// case without 'g' flag is handled like RegExp.prototype.exec
if (pos < 0)
return jsNull();
return regExpConstructor->arrayOfMatches(exec);
}
// return array of matches
MarkedArgumentBuffer list;
int lastIndex = 0;
while (pos >= 0) {
list.append(jsSubstring(exec, u, pos, matchLength));
lastIndex = pos;
pos += matchLength == 0 ? 1 : matchLength;
regExpConstructor->performMatch(reg.get(), u, pos, pos, matchLength);
}
if (imp)
imp->setLastIndex(lastIndex);
if (list.isEmpty()) {
// if there are no matches at all, it's important to return
// Null instead of an empty array, because this matches
// other browsers and because Null is a false value.
return jsNull();
}
return constructArray(exec, list);
}
static inline JSObject* constructArrayWithSizeQuirk(ExecState* exec, const ArgList& args)
{
JSGlobalObject* globalObject = asInternalFunction(exec->callee())->globalObject();
// a single numeric argument denotes the array size (!)
if (args.size() == 1 && args.at(0).isNumber()) {
uint32_t n = args.at(0).toUInt32(exec);
if (n != args.at(0).toNumber(exec))
return throwError(exec, createRangeError(exec, "Array size is not a small enough positive integer."));
return constructEmptyArray(exec, globalObject, n);
}
// otherwise the array is constructed with the arguments in it
return constructArray(exec, globalObject, args);
}
JSValue* JSJavaScriptCallFrame::scopeChain(ExecState* exec) const
{
if (!impl()->scopeChain())
return jsNull();
const ScopeChainNode* scopeChain = impl()->scopeChain();
ScopeChainIterator iter = scopeChain->begin();
ScopeChainIterator end = scopeChain->end();
// we must always have something in the scope chain
ASSERT(iter != end);
ArgList list;
do {
list.append(*iter);
++iter;
} while (iter != end);
return constructArray(exec, list);
}
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);
}
JSValue JSWebGLRenderingContextBase::getAttachedShaders(ExecState* exec)
{
if (exec->argumentCount() < 1)
return exec->vm().throwException(exec, createNotEnoughArgumentsError(exec));
ExceptionCode ec = 0;
WebGLRenderingContextBase& context = impl();
WebGLProgram* program = JSWebGLProgram::toWrapped(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();
JSC::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);
}
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);
}
char* JIT_OPERATION operationNewArrayBuffer(ExecState* exec, Structure* arrayStructure, size_t start, size_t size)
{
VM& vm = exec->vm();
NativeCallFrameTracer tracer(&vm, exec);
return bitwise_cast<char*>(constructArray(exec, arrayStructure, exec->codeBlock()->constantBuffer(start), size));
}
EncodedJSValue DFG_OPERATION operationNewArray(ExecState* exec, void* start, size_t size)
{
return JSValue::encode(constructArray(exec, static_cast<JSValue*>(start), size));
}
EncodedJSValue DFG_OPERATION operationNewArray(ExecState* exec, void* start, size_t size)
{
ArgList argList(static_cast<Register*>(start), size);
return JSValue::encode(constructArray(exec, argList));
}
JSValue RegExpObject::matchGlobal(ExecState* exec, JSGlobalObject* globalObject, JSString* string)
{
RegExp* regExp = this->regExp();
ASSERT(regExp->global());
VM* vm = &globalObject->vm();
setLastIndex(exec, 0);
if (exec->hadException())
return jsUndefined();
String s = string->value(exec);
RegExpConstructor* regExpConstructor = globalObject->regExpConstructor();
MatchResult result = regExpConstructor->performMatch(*vm, regExp, string, s, 0);
// return array of matches
MarkedArgumentBuffer list;
// We defend ourselves from crazy.
const size_t maximumReasonableMatchSize = 1000000000;
if (regExp->unicode()) {
unsigned stringLength = s.length();
while (result) {
if (list.size() > maximumReasonableMatchSize) {
throwOutOfMemoryError(exec);
return jsUndefined();
}
size_t end = result.end;
size_t length = end - result.start;
list.append(jsSubstring(exec, s, result.start, length));
if (!length)
end = advanceStringUnicode(s, stringLength, end);
result = regExpConstructor->performMatch(*vm, regExp, string, s, end);
}
} else {
while (result) {
if (list.size() > maximumReasonableMatchSize) {
throwOutOfMemoryError(exec);
return jsUndefined();
}
size_t end = result.end;
size_t length = end - result.start;
list.append(jsSubstring(exec, s, result.start, length));
if (!length)
++end;
result = regExpConstructor->performMatch(*vm, regExp, string, s, end);
}
}
if (list.isEmpty()) {
// if there are no matches at all, it's important to return
// Null instead of an empty array, because this matches
// other browsers and because Null is a false value.
return jsNull();
}
return constructArray(exec, static_cast<ArrayAllocationProfile*>(0), list);
}
EncodedJSValue DFG_OPERATION operationNewArrayBuffer(ExecState* exec, size_t start, size_t size)
{
return JSValue::encode(constructArray(exec, exec->codeBlock()->constantBuffer(start), size));
}
