int argumentCount = static_cast<int>(args.size());
Vector<JSValueRef, 16> arguments(argumentCount);
for (int i = 0; i < argumentCount; i++)
- arguments[i] = toRef(args[i]);
+ arguments[i] = toRef(args.at(exec, i));
JSLock::DropAllLocks dropAllLocks(exec);
return toJS(callback(ctx, constructorRef, argumentCount, arguments.data(), toRef(exec->exceptionSlot())));
int argumentCount = static_cast<int>(args.size());
Vector<JSValueRef, 16> arguments(argumentCount);
for (int i = 0; i < argumentCount; i++)
- arguments[i] = toRef(args[i]);
+ arguments[i] = toRef(args.at(exec, i));
JSLock::DropAllLocks dropAllLocks(exec);
return toJS(static_cast<JSCallbackFunction*>(functionObject)->m_callback(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), toRef(exec->exceptionSlot())));
int argumentCount = static_cast<int>(args.size());
Vector<JSValueRef, 16> arguments(argumentCount);
for (int i = 0; i < argumentCount; i++)
- arguments[i] = toRef(args[i]);
+ arguments[i] = toRef(args.at(exec, i));
JSLock::DropAllLocks dropAllLocks(exec);
return toJS(callAsConstructor(execRef, constructorRef, argumentCount, arguments.data(), toRef(exec->exceptionSlot())));
}
int argumentCount = static_cast<int>(args.size());
Vector<JSValueRef, 16> arguments(argumentCount);
for (int i = 0; i < argumentCount; i++)
- arguments[i] = toRef(args[i]);
+ arguments[i] = toRef(args.at(exec, i));
JSLock::DropAllLocks dropAllLocks(exec);
return toJS(callAsFunction(execRef, functionRef, thisObjRef, argumentCount, arguments.data(), toRef(exec->exceptionSlot())));
}
+2008-07-22 Geoffrey Garen <ggaren@apple.com>
+
+ Reviewed by Oliver Hunt and Sam Weinig.
+
+ Next step toward putting doubles in registers: Prepare the Register class
+ and its clients for registers that don't contain JSValue*s.
+
+ This means a few things:
+
+ 1. Register::jsValue() clients, including ArgList clients, must now supply
+ an ExecState* when accessing an entry in an ArgList, in case the entry
+ will need to create a JSValue* on the fly.
+
+ 2. Register clients that definitely don't want to create a JSValue* on
+ the fly now use different APIs: getJSValue() for clients that know
+ the register contains a JSValue*, and v() for clients who just want a
+ void*.
+
+ 3. I had to change some headers around in order to resolve dependency
+ problems created by using a Register in the ArgList header.
+
+ SunSpider reports no change.
+
2008-07-22 Gavin Barraclough <barraclough@apple.com>
Reviewed by Alexey Proskuryakov.
return result;
}
-static UString valueToSourceString(ExecState* exec, const Register& val)
+static UString valueToSourceString(ExecState* exec, JSValue* val)
{
- if (val.isString()) {
+ if (val->isString()) {
UString result("\"");
- result += escapeQuotes(val.toString(exec)) + "\"";
+ result += escapeQuotes(val->toString(exec)) + "\"";
return result;
}
- return val.toString(exec);
+ return val->toString(exec);
}
static CString registerName(int r)
return (UString("tr") + UString::from(r)).UTF8String();
}
-static CString constantName(ExecState* exec, int k, const Register& value)
+static CString constantName(ExecState* exec, int k, JSValue* value)
{
return (valueToSourceString(exec, value) + "(@k" + UString::from(k) + ")").UTF8String();
}
printf("\nConstants:\n");
size_t i = 0;
do {
- printf(" k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, registers[i]).ascii());
+ printf(" k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, registers[i].jsValue(exec)).ascii());
++i;
} while (i < registers.size());
}
case op_load: {
int r0 = (++it)->u.operand;
int k0 = (++it)->u.operand;
- printf("[%4d] load\t\t %s, %s\t\t\n", location, registerName(r0).c_str(), constantName(exec, k0, registers[k0]).c_str());
+ printf("[%4d] load\t\t %s, %s\t\t\n", location, registerName(r0).c_str(), constantName(exec, k0, registers[k0].jsValue(exec)).c_str());
break;
}
case op_new_object: {
int r0 = (++it)->u.operand;
int errorType = (++it)->u.operand;
int k0 = (++it)->u.operand;
- printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, registers[k0]).c_str());
+ printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, registers[k0].jsValue(exec)).c_str());
break;
}
case op_jsr: {
callFrame[RegisterFile::ArgumentCount] = argc; // original argument count (for the sake of the "arguments" object)
callFrame[RegisterFile::CalledAsConstructor] = calledAsConstructor;
callFrame[RegisterFile::Callee] = function;
- callFrame[RegisterFile::OptionalCalleeActivation] = static_cast<intptr_t>(0);
+ callFrame[RegisterFile::OptionalCalleeActivation] = nullJSValue;
}
ALWAYS_INLINE Register* slideRegisterWindowForCall(ExecState* exec, CodeBlock* newCodeBlock, RegisterFile* registerFile, Register* registerBase, Register* r, int argv, int argc, JSValue*& exceptionValue)
if (argc < 2)
return jsUndefined();
- JSValue* program = r[argv + 1].jsValue();
+ JSValue* program = r[argv + 1].jsValue(exec);
if (!program->isString())
return program;
it = registerFile->lastGlobal();
end = it + registerFile->numGlobals();
while (it != end) {
- printf("[global var] | %10p | %10p \n", it, (*it).jsValue());
+ printf("[global var] | %10p | %10p \n", it, (*it).v());
++it;
}
printf("----------------------------------------------------\n");
}
it = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
- printf("[CallerCodeBlock] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[ReturnVPC] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[CallerScopeChain] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[CallerRegisterOffset] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[ReturnValueRegister] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[ArgumentStartRegister] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[ArgumentCount] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[CalledAsConstructor] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[Callee] | %10p | %10p \n", it, (*it).jsValue()); ++it;
- printf("[OptionalCalleeActivation] | %10p | %10p \n", it, (*it).jsValue()); ++it;
+ printf("[CallerCodeBlock] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[ReturnVPC] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[CallerScopeChain] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[CallerRegisterOffset] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[ReturnValueRegister] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[ArgumentStartRegister] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[ArgumentCount] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[CalledAsConstructor] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[Callee] | %10p | %10p \n", it, (*it).v()); ++it;
+ printf("[OptionalCalleeActivation] | %10p | %10p \n", it, (*it).v()); ++it;
printf("----------------------------------------------------\n");
- printf("[this] | %10p | %10p \n", it, (*it).jsValue()); ++it;
+ printf("[this] | %10p | %10p \n", it, (*it).v()); ++it;
end = it + max(codeBlock->numParameters - 1, 0); // - 1 to skip "this"
if (it != end) {
do {
- printf("[param] | %10p | %10p \n", it, (*it).jsValue());
+ printf("[param] | %10p | %10p \n", it, (*it).v());
++it;
} while (it != end);
}
end = it + codeBlock->numVars;
if (it != end) {
do {
- printf("[var] | %10p | %10p \n", it, (*it).jsValue());
+ printf("[var] | %10p | %10p \n", it, (*it).v());
++it;
} while (it != end);
printf("----------------------------------------------------\n");
end = it + codeBlock->numTemporaries;
if (it != end) {
do {
- printf("[temp] | %10p | %10p \n", it, (*it).jsValue());
+ printf("[temp] | %10p | %10p \n", it, (*it).v());
++it;
} while (it != end);
}
if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
- if (callFrame[RegisterFile::Callee].jsValue())
+ if (callFrame[RegisterFile::Callee].jsValue(exec))
debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->lastLine());
else
debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->lastLine());
}
if (Profiler* profiler = *Profiler::enabledProfilerReference()) {
- if (callFrame[RegisterFile::Callee].jsValue())
- profiler->didExecute(exec, static_cast<JSObject*>(callFrame[RegisterFile::Callee].jsValue()));
+ if (callFrame[RegisterFile::Callee].jsValue(exec))
+ profiler->didExecute(exec, static_cast<JSObject*>(callFrame[RegisterFile::Callee].jsValue(exec)));
else
profiler->didExecute(exec, codeBlock->ownerNode->sourceURL(), codeBlock->ownerNode->lineNo());
}
scopeChain->deref();
// If this call frame created an activation, tear it off.
- if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue())) {
+ if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue(exec))) {
ASSERT(activation->isActivationObject());
activation->copyRegisters();
}
as a boolean in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
else {
result as a boolean in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
else {
result as a boolean in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
else
puts the result as a boolean in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
else
a boolean in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
JSValue* result = jsBoolean(jsLess(exec, src1, src2));
VM_CHECK_EXCEPTION();
r[dst] = result;
puts the result as a boolean in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
JSValue* result = jsBoolean(jsLessEq(exec, src1, src2));
VM_CHECK_EXCEPTION();
r[dst] = result;
back in register srcDst.
*/
int srcDst = (++vPC)->u.operand;
- JSValue* v = r[srcDst].jsValue();
+ JSValue* v = r[srcDst].jsValue(exec);
if (JSImmediate::canDoFastAdditiveOperations(v))
r[srcDst] = JSImmediate::incImmediateNumber(v);
else {
back in register srcDst.
*/
int srcDst = (++vPC)->u.operand;
- JSValue* v = r[srcDst].jsValue();
+ JSValue* v = r[srcDst].jsValue(exec);
if (JSImmediate::canDoFastAdditiveOperations(v))
r[srcDst] = JSImmediate::decImmediateNumber(v);
else {
*/
int dst = (++vPC)->u.operand;
int srcDst = (++vPC)->u.operand;
- JSValue* v = r[srcDst].jsValue();
+ JSValue* v = r[srcDst].jsValue(exec);
if (JSImmediate::canDoFastAdditiveOperations(v)) {
r[dst] = v;
r[srcDst] = JSImmediate::incImmediateNumber(v);
} else {
- JSValue* number = r[srcDst].jsValue()->toJSNumber(exec);
+ JSValue* number = r[srcDst].jsValue(exec)->toJSNumber(exec);
VM_CHECK_EXCEPTION();
r[dst] = number;
r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() + 1);
*/
int dst = (++vPC)->u.operand;
int srcDst = (++vPC)->u.operand;
- JSValue* v = r[srcDst].jsValue();
+ JSValue* v = r[srcDst].jsValue(exec);
if (JSImmediate::canDoFastAdditiveOperations(v)) {
r[dst] = v;
r[srcDst] = JSImmediate::decImmediateNumber(v);
} else {
- JSValue* number = r[srcDst].jsValue()->toJSNumber(exec);
+ JSValue* number = r[srcDst].jsValue(exec)->toJSNumber(exec);
VM_CHECK_EXCEPTION();
r[dst] = number;
r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() - 1);
*/
int dst = (++vPC)->u.operand;
int src = (++vPC)->u.operand;
- JSValue* result = r[src].jsValue()->toJSNumber(exec);
+ JSValue* result = r[src].jsValue(exec)->toJSNumber(exec);
VM_CHECK_EXCEPTION();
r[dst] = result;
*/
int dst = (++vPC)->u.operand;
int src = (++vPC)->u.operand;
- JSValue* result = jsNumber(exec, -r[src].jsValue()->toNumber(exec));
+ JSValue* result = jsNumber(exec, -r[src].jsValue(exec)->toNumber(exec));
VM_CHECK_EXCEPTION();
r[dst] = result;
numeric add, depending on the types of the operands.)
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
r[dst] = JSImmediate::addImmediateNumbers(src1, src2);
else {
numbers), and puts the product in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
JSValue* result = jsNumber(exec, src1->toNumber(exec) * src2->toNumber(exec));
VM_CHECK_EXCEPTION();
r[dst] = result;
int dst = (++vPC)->u.operand;
int dividend = (++vPC)->u.operand;
int divisor = (++vPC)->u.operand;
- JSValue* result = jsNumber(exec, r[dividend].jsValue()->toNumber(exec) / r[divisor].jsValue()->toNumber(exec));
+ JSValue* result = jsNumber(exec, r[dividend].jsValue(exec)->toNumber(exec) / r[divisor].jsValue(exec)->toNumber(exec));
VM_CHECK_EXCEPTION();
r[dst] = result;
++vPC;
int dst = (++vPC)->u.operand;
int dividend = (++vPC)->u.operand;
int divisor = (++vPC)->u.operand;
- double d = r[dividend].jsValue()->toNumber(exec);
- JSValue* result = jsNumber(exec, fmod(d, r[divisor].jsValue()->toNumber(exec)));
+ double d = r[dividend].jsValue(exec)->toNumber(exec);
+ JSValue* result = jsNumber(exec, fmod(d, r[divisor].jsValue(exec)->toNumber(exec)));
VM_CHECK_EXCEPTION();
r[dst] = result;
++vPC;
register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
r[dst] = JSImmediate::subImmediateNumbers(src1, src2);
else {
in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* val = r[(++vPC)->u.operand].jsValue();
- JSValue* shift = r[(++vPC)->u.operand].jsValue();
+ JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(val, shift))
r[dst] = jsNumber(exec, JSImmediate::getTruncatedInt32(val) << (JSImmediate::toTruncatedUInt32(shift) & 0x1f));
else {
uint32), and puts the result in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* val = r[(++vPC)->u.operand].jsValue();
- JSValue* shift = r[(++vPC)->u.operand].jsValue();
+ JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(val, shift))
r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
else {
uint32), and puts the result in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* val = r[(++vPC)->u.operand].jsValue();
- JSValue* shift = r[(++vPC)->u.operand].jsValue();
+ JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
else {
in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = JSImmediate::andImmediateNumbers(src1, src2);
else {
in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
else {
result in register dst.
*/
int dst = (++vPC)->u.operand;
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
if (JSImmediate::areBothImmediateNumbers(src1, src2))
r[dst] = JSImmediate::orImmediateNumbers(src1, src2);
else {
*/
int dst = (++vPC)->u.operand;
int src = (++vPC)->u.operand;
- JSValue* result = jsNumber(exec, ~r[src].jsValue()->toInt32(exec));
+ JSValue* result = jsNumber(exec, ~r[src].jsValue(exec)->toInt32(exec));
VM_CHECK_EXCEPTION();
r[dst] = result;
*/
int dst = (++vPC)->u.operand;
int src = (++vPC)->u.operand;
- JSValue* result = jsBoolean(!r[src].jsValue()->toBoolean(exec));
+ JSValue* result = jsBoolean(!r[src].jsValue(exec)->toBoolean(exec));
VM_CHECK_EXCEPTION();
r[dst] = result;
int value = (++vPC)->u.operand;
int base = (++vPC)->u.operand;
- JSValue* baseVal = r[base].jsValue();
+ JSValue* baseVal = r[base].jsValue(exec);
if (isNotObject(exec, true, codeBlock, vPC, baseVal, exceptionValue))
goto vm_throw;
JSObject* baseObj = static_cast<JSObject*>(baseVal);
- r[dst] = jsBoolean(baseObj->implementsHasInstance() ? baseObj->hasInstance(exec, r[value].jsValue()) : false);
+ r[dst] = jsBoolean(baseObj->implementsHasInstance() ? baseObj->hasInstance(exec, r[value].jsValue(exec)) : false);
++vPC;
NEXT_OPCODE;
*/
int dst = (++vPC)->u.operand;
int src = (++vPC)->u.operand;
- r[dst] = jsTypeStringForValue(exec, r[src].jsValue());
+ r[dst] = jsTypeStringForValue(exec, r[src].jsValue(exec));
++vPC;
NEXT_OPCODE;
int property = (++vPC)->u.operand;
int base = (++vPC)->u.operand;
- JSValue* baseVal = r[base].jsValue();
+ JSValue* baseVal = r[base].jsValue(exec);
if (isNotObject(exec, false, codeBlock, vPC, baseVal, exceptionValue))
goto vm_throw;
JSObject* baseObj = static_cast<JSObject*>(baseVal);
- JSValue* propName = r[property].jsValue();
+ JSValue* propName = r[property].jsValue(exec);
uint32_t i;
if (propName->getUInt32(i))
ASSERT((*iter)->isVariableObject());
JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
- scope->registerAt(index) = r[value].jsValue();
+ scope->registerAt(index) = r[value].jsValue(exec);
++vPC;
NEXT_OPCODE;
}
int property = (++vPC)->u.operand;
Identifier& ident = codeBlock->identifiers[property];
- JSValue *result = r[base].jsValue()->get(exec, ident);
+ JSValue *result = r[base].jsValue(exec)->get(exec, ident);
VM_CHECK_EXCEPTION();
r[dst] = result;
++vPC;
int value = (++vPC)->u.operand;
Identifier& ident = codeBlock->identifiers[property];
- r[base].jsValue()->put(exec, ident, r[value].jsValue());
+ r[base].jsValue(exec)->put(exec, ident, r[value].jsValue(exec));
VM_CHECK_EXCEPTION();
++vPC;
int base = (++vPC)->u.operand;
int property = (++vPC)->u.operand;
- JSObject* baseObj = r[base].jsValue()->toObject(exec);
+ JSObject* baseObj = r[base].jsValue(exec)->toObject(exec);
Identifier& ident = codeBlock->identifiers[property];
JSValue* result = jsBoolean(baseObj->deleteProperty(exec, ident));
int base = (++vPC)->u.operand;
int property = (++vPC)->u.operand;
- JSValue* baseValue = r[base].jsValue();
- JSValue* subscript = r[property].jsValue();
+ JSValue* baseValue = r[base].jsValue(exec);
+ JSValue* subscript = r[property].jsValue(exec);
JSValue* result;
unsigned i;
int property = (++vPC)->u.operand;
int value = (++vPC)->u.operand;
- JSValue* baseValue = r[base].jsValue();
- JSValue* subscript = r[property].jsValue();
+ JSValue* baseValue = r[base].jsValue(exec);
+ JSValue* subscript = r[property].jsValue(exec);
unsigned i;
if (isJSArray(baseValue)) {
JSArray* jsArray = static_cast<JSArray*>(baseValue);
if (jsArray->canSetIndex(i))
- jsArray->setIndex(i, r[value].jsValue());
+ jsArray->setIndex(i, r[value].jsValue(exec));
else
- jsArray->JSArray::put(exec, i, r[value].jsValue());
+ jsArray->JSArray::put(exec, i, r[value].jsValue(exec));
} else
- baseValue->put(exec, i, r[value].jsValue());
+ baseValue->put(exec, i, r[value].jsValue(exec));
} else {
Identifier property(exec, subscript->toString(exec));
if (!exec->hadException()) // Don't put to an object if toString threw an exception.
- baseValue->put(exec, property, r[value].jsValue());
+ baseValue->put(exec, property, r[value].jsValue(exec));
}
VM_CHECK_EXCEPTION();
int base = (++vPC)->u.operand;
int property = (++vPC)->u.operand;
- JSObject* baseObj = r[base].jsValue()->toObject(exec); // may throw
+ JSObject* baseObj = r[base].jsValue(exec)->toObject(exec); // may throw
- JSValue* subscript = r[property].jsValue();
+ JSValue* subscript = r[property].jsValue(exec);
JSValue* result;
uint32_t i;
if (subscript->getUInt32(i))
unsigned property = (++vPC)->u.operand;
int value = (++vPC)->u.operand;
- r[base].jsValue()->put(exec, property, r[value].jsValue());
+ r[base].jsValue(exec)->put(exec, property, r[value].jsValue(exec));
++vPC;
NEXT_OPCODE;
*/
int cond = (++vPC)->u.operand;
int target = (++vPC)->u.operand;
- if (r[cond].jsValue()->toBoolean(exec)) {
+ if (r[cond].jsValue(exec)->toBoolean(exec)) {
vPC += target;
CHECK_FOR_TIMEOUT();
NEXT_OPCODE;
*/
int cond = (++vPC)->u.operand;
int target = (++vPC)->u.operand;
- if (r[cond].jsValue()->toBoolean(exec)) {
+ if (r[cond].jsValue(exec)->toBoolean(exec)) {
vPC += target;
NEXT_OPCODE;
}
*/
int cond = (++vPC)->u.operand;
int target = (++vPC)->u.operand;
- if (!r[cond].jsValue()->toBoolean(exec)) {
+ if (!r[cond].jsValue(exec)->toBoolean(exec)) {
vPC += target;
NEXT_OPCODE;
}
Additionally this loop instruction may terminate JS execution is
the JS timeout is reached.
*/
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
int target = (++vPC)->u.operand;
bool result = jsLess(exec, src1, src2);
target from the current instruction, if and only if the
result of the comparison is true.
*/
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
int target = (++vPC)->u.operand;
bool result = jsLess(exec, src1, src2);
target from the current instruction, if and only if the
result of the comparison is false.
*/
- JSValue* src1 = r[(++vPC)->u.operand].jsValue();
- JSValue* src2 = r[(++vPC)->u.operand].jsValue();
+ JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+ JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
int target = (++vPC)->u.operand;
bool result = jsLess(exec, src1, src2);
int firstArg = (++vPC)->u.operand;
int argCount = (++vPC)->u.operand;
- JSValue* funcVal = r[func].jsValue();
- JSValue* baseVal = r[thisVal].jsValue();
+ JSValue* funcVal = r[func].jsValue(exec);
+ JSValue* baseVal = r[thisVal].jsValue(exec);
if (baseVal == scopeChain->globalObject() && funcVal == scopeChain->globalObject()->evalFunction()) {
- JSObject* thisObject = static_cast<JSObject*>(r[codeBlock->thisRegister].jsValue());
+ JSObject* thisObject = static_cast<JSObject*>(r[codeBlock->thisRegister].jsValue(exec));
JSValue* result = callEval(exec, thisObject, scopeChain, registerFile, r, firstArg, argCount, exceptionValue);
if (exceptionValue)
goto vm_throw;
int firstArg = (++vPC)->u.operand;
int argCount = (++vPC)->u.operand;
- JSValue* v = r[func].jsValue();
+ JSValue* v = r[func].jsValue(exec);
CallData callData;
CallType callType = v->getCallData(callData);
FunctionBodyNode* functionBodyNode = callData.js.functionBody;
CodeBlock* newCodeBlock = &functionBodyNode->byteCode(callDataScopeChain);
- r[firstArg] = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue();
+ r[firstArg] = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue(exec);
Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
initializeCallFrame(callFrame, codeBlock, vPC, scopeChain, r, dst, firstArg, argCount, 0, v);
if (*enabledProfilerReference)
(*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
- JSValue* thisValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue();
+ JSValue* thisValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue(exec);
ArgList args(r + firstArg + 1, argCount - 1);
JSValue* returnValue = callData.native.function(exec, static_cast<JSObject*>(v), thisValue, args);
int result = (++vPC)->u.operand;
Register* callFrame = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
- if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue())) {
+ if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue(exec))) {
ASSERT(!codeBlock->needsFullScopeChain || scopeChain->object == activation);
ASSERT(activation->isActivationObject());
activation->copyRegisters();
}
if (*enabledProfilerReference)
- (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(callFrame[RegisterFile::Callee].jsValue()));
+ (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(callFrame[RegisterFile::Callee].jsValue(exec)));
if (codeBlock->needsFullScopeChain)
scopeChain->deref();
- JSValue* returnValue = r[result].jsValue();
+ JSValue* returnValue = r[result].jsValue(exec);
if (callFrame[RegisterFile::CalledAsConstructor].i() && !returnValue->isObject()) {
- JSValue* thisObject = callFrame[RegisterFile::CallFrameHeaderSize].jsValue();
+ JSValue* thisObject = callFrame[RegisterFile::CallFrameHeaderSize].jsValue(exec);
returnValue = thisObject;
}
int firstArg = (++vPC)->u.operand;
int argCount = (++vPC)->u.operand;
- JSValue* constrVal = r[constr].jsValue();
+ JSValue* constrVal = r[constr].jsValue(exec);
ConstructData constructData;
ConstructType constructType = constrVal->getConstructData(constructData);
of the current scope chain.
*/
int scope = (++vPC)->u.operand;
- JSValue* v = r[scope].jsValue();
+ JSValue* v = r[scope].jsValue(exec);
JSObject* o = v->toObject(exec);
VM_CHECK_EXCEPTION();
int dst = (++vPC)->u.operand;
int base = (++vPC)->u.operand;
- r[dst] = JSPropertyNameIterator::create(exec, r[base].jsValue());
+ r[dst] = JSPropertyNameIterator::create(exec, r[base].jsValue(exec));
++vPC;
NEXT_OPCODE;
}
*/
int ex = (++vPC)->u.operand;
- exceptionValue = r[ex].jsValue();
+ exceptionValue = r[ex].jsValue(exec);
handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r, true);
if (!handlerVPC) {
int type = (++vPC)->u.operand;
int message = (++vPC)->u.operand;
- r[dst] = Error::create(exec, (ErrorType)type, k[message].toString(exec), codeBlock->lineNumberForVPC(vPC), codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
+ r[dst] = Error::create(exec, (ErrorType)type, k[message].jsValue(exec)->toString(exec), codeBlock->lineNumberForVPC(vPC), codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
++vPC;
NEXT_OPCODE;
scopeChain->deref();
}
int result = (++vPC)->u.operand;
- return r[result].jsValue();
+ return r[result].jsValue(exec);
}
BEGIN_OPCODE(op_put_getter) {
/* put_getter base(r) property(id) function(r)
int property = (++vPC)->u.operand;
int function = (++vPC)->u.operand;
- ASSERT(r[base].jsValue()->isObject());
- JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue());
+ ASSERT(r[base].jsValue(exec)->isObject());
+ JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue(exec));
Identifier& ident = codeBlock->identifiers[property];
- ASSERT(r[function].jsValue()->isObject());
- baseObj->defineGetter(exec, ident, static_cast<JSObject*>(r[function].jsValue()));
+ ASSERT(r[function].jsValue(exec)->isObject());
+ baseObj->defineGetter(exec, ident, static_cast<JSObject*>(r[function].jsValue(exec)));
++vPC;
NEXT_OPCODE;
int property = (++vPC)->u.operand;
int function = (++vPC)->u.operand;
- ASSERT(r[base].jsValue()->isObject());
- JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue());
+ ASSERT(r[base].jsValue(exec)->isObject());
+ JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue(exec));
Identifier& ident = codeBlock->identifiers[property];
- ASSERT(r[function].jsValue()->isObject());
- baseObj->defineSetter(exec, ident, static_cast<JSObject*>(r[function].jsValue()));
+ ASSERT(r[function].jsValue(exec)->isObject());
+ baseObj->defineSetter(exec, ident, static_cast<JSObject*>(r[function].jsValue(exec)));
++vPC;
NEXT_OPCODE;
if (!callFrame)
return jsNull();
- JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue());
+ JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue(exec));
if (!activation) {
CodeBlock* codeBlock = &function->m_body->generatedByteCode();
activation = new (exec) JSActivation(function->m_body, callFrame + RegisterFile::CallFrameHeaderSize + codeBlock->numLocals);
return jsNull();
Register* callerCallFrame = callFrame[RegisterFile::CallerRegisters].r() - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
- if (JSValue* caller = callerCallFrame[RegisterFile::Callee].jsValue())
+ if (JSValue* caller = callerCallFrame[RegisterFile::Callee].jsValue(exec))
return caller;
return jsNull();
callFrame = exec->m_callFrame;
}
- if (callFrame[RegisterFile::Callee].jsValue() == function)
+ if (callFrame[RegisterFile::Callee].jsValue(exec) == function)
return callFrame;
CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].codeBlock();
void Machine::getArgumentsData(Register* callFrame, JSFunction*& function, Register*& argv, int& argc)
{
- function = static_cast<JSFunction*>(callFrame[RegisterFile::Callee].jsValue());
+ function = static_cast<JSFunction*>(callFrame[RegisterFile::Callee].getJSValue());
ASSERT(function->inherits(&JSFunction::info));
argv = callFrame[RegisterFile::CallerRegisters].r() + callFrame[RegisterFile::ArgumentStartRegister].i() + 1; // + 1 to skip "this"
class JSValue;
class ScopeChainNode;
struct Instruction;
+
+ static JSValue* const nullJSValue = 0;
class Register {
public:
Register();
Register(JSValue*);
- JSValue* jsValue() const;
+ JSValue* jsValue(ExecState*) const;
+ JSValue* getJSValue() const;
bool marked() const;
void mark();
- bool isString() const;
-
- uint32_t toUInt32(ExecState*) const;
- UString toString(ExecState*) const;
-
-
private:
friend class Machine;
Register* r() const;
Instruction* vPC() const;
JSPropertyNameIterator* jsPropertyNameIterator() const;
+ void* v() const;
union {
private:
ScopeChainNode* scopeChain;
JSPropertyNameIterator* jsPropertyNameIterator;
Register* r;
+ void* v;
intptr_t i;
} u;
ALWAYS_INLINE Register::Register()
{
#ifndef NDEBUG
- *this = static_cast<intptr_t>(0);
+ *this = nullJSValue;
#endif
}
u.jsValue = v;
}
+ // This function is scaffolding for legacy clients. It will eventually go away.
+ ALWAYS_INLINE JSValue* Register::jsValue(ExecState*) const
+ {
+ // Once registers hold doubles, this function will allocate a JSValue*
+ // if the register doesn't hold one already.
+ ASSERT(m_type == JSValueType);
+ return u.jsValue;
+ }
+
+ ALWAYS_INLINE JSValue* Register::getJSValue() const
+ {
+ ASSERT(m_type == JSValueType);
+ return u.jsValue;
+ }
+
+ ALWAYS_INLINE bool Register::marked() const
+ {
+ return getJSValue()->marked();
+ }
+
+ ALWAYS_INLINE void Register::mark()
+ {
+ getJSValue()->mark();
+ }
+
+ // Machine functions
+
ALWAYS_INLINE Register::Register(CodeBlock* codeBlock)
{
#ifndef NDEBUG
u.i = i;
}
- ALWAYS_INLINE JSValue* Register::jsValue() const
- {
- ASSERT(m_type == JSValueType || !i());
- return u.jsValue;
- }
-
ALWAYS_INLINE CodeBlock* Register::codeBlock() const
{
ASSERT(m_type == CodeBlockType);
return u.jsPropertyNameIterator;
}
- ALWAYS_INLINE bool Register::marked() const
- {
- return jsValue()->marked();
- }
-
- ALWAYS_INLINE void Register::mark()
- {
- jsValue()->mark();
- }
-
- ALWAYS_INLINE bool Register::isString() const
- {
- return jsValue()->isString();
- }
-
- ALWAYS_INLINE uint32_t Register::toUInt32(ExecState* exec) const
- {
- return jsValue()->toUInt32(exec);
- }
-
- ALWAYS_INLINE UString Register::toString(ExecState* exec) const
+ ALWAYS_INLINE void* Register::v() const
{
- return jsValue()->toString(exec);
+ return u.v;
}
} // namespace KJS
size_t size() const { return m_size; }
bool isEmpty() const { return !m_size; }
- JSValue* at(size_t i) const
+ JSValue* at(ExecState* exec, size_t i) const
{
if (i < m_size)
- return m_buffer[i].jsValue();
+ return m_buffer[i].jsValue(exec);
return jsUndefined();
}
- JSValue* operator[](int i) const { return at(i); }
-
void clear()
{
m_vector.clear();
private:
// Prohibits new / delete, which would break GC.
- void* operator new(size_t);
+ friend class JSGlobalData;
+
+ void* ArgList::operator new(size_t size)
+ {
+ return fastMalloc(size);
+ }
void operator delete(void*);
void* operator new[](size_t);
for (ArgList::const_iterator it = args.begin(); it != end; ++it, ++i) {
Identifier name = Identifier::from(exec, i);
if (!m_indexToNameMap.isMapped(name))
- putDirect(name, (*it).jsValue(), DontEnum);
+ putDirect(name, (*it).jsValue(exec), DontEnum);
}
}
static JSObject* constructArrayWithSizeQuirk(ExecState* exec, const ArgList& args)
{
// a single numeric argument denotes the array size (!)
- if (args.size() == 1 && args[0]->isNumber()) {
- uint32_t n = args[0]->toUInt32(exec);
- if (n != args[0]->toNumber(exec))
+ if (args.size() == 1 && args.at(exec, 0)->isNumber()) {
+ uint32_t n = args.at(exec, 0)->toUInt32(exec);
+ if (n != args.at(exec, 0)->toNumber(exec))
return throwError(exec, RangeError, "Array size is not a small enough positive integer.");
return new (exec) JSArray(exec->lexicalGlobalObject()->arrayPrototype(), n);
}
// otherwise the array is constructed with the arguments in it
- return new (exec) JSArray(exec->lexicalGlobalObject()->arrayPrototype(), args);
+ return new (exec) JSArray(exec, exec->lexicalGlobalObject()->arrayPrototype(), args);
}
static JSObject* constructWithArrayConstructor(ExecState* exec, JSObject*, const ArgList& args)
return jsString(exec, UString(0, 0)); // return an empty string, avoding infinite recursion.
UChar comma = ',';
- UString separator = args[0]->isUndefined() ? UString(&comma, 1) : args[0]->toString(exec);
+ UString separator = args.at(exec, 0)->isUndefined() ? UString(&comma, 1) : args.at(exec, 0)->toString(exec);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
for (unsigned k = 0; k < length; k++) {
}
if (it == end)
break;
- curArg = (*it).jsValue();
+ curArg = (*it).jsValue(exec);
++it;
}
arr->setLength(n);
JSObject* thisObj = thisValue->toThisObject(exec);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
for (unsigned n = 0; n < args.size(); n++)
- thisObj->put(exec, length + n, args[n]);
+ thisObj->put(exec, length + n, args.at(exec, n));
length += args.size();
thisObj->put(exec, exec->propertyNames().length, jsNumber(exec, length));
return jsNumber(exec, length);
// We return a new array
JSArray* resObj = constructEmptyArray(exec);
JSValue* result = resObj;
- double begin = args[0]->toInteger(exec);
+ double begin = args.at(exec, 0)->toInteger(exec);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
if (begin >= 0) {
if (begin > length)
begin = 0;
}
double end;
- if (args[1]->isUndefined())
+ if (args.at(exec, 1)->isUndefined())
end = length;
else {
- end = args[1]->toInteger(exec);
+ end = args.at(exec, 1)->toInteger(exec);
if (end < 0) {
end += length;
if (end < 0)
{
JSObject* thisObj = thisValue->toThisObject(exec);
- JSValue* function = args[0];
+ JSValue* function = args.at(exec, 0);
CallData callData;
CallType callType = function->getCallData(callData);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
if (!args.size())
return jsUndefined();
- int begin = args[0]->toUInt32(exec);
+ int begin = args.at(exec, 0)->toUInt32(exec);
if (begin < 0)
begin = std::max<int>(begin + length, 0);
else
unsigned deleteCount;
if (args.size() > 1)
- deleteCount = std::min<int>(std::max<int>(args[1]->toUInt32(exec), 0), length - begin);
+ deleteCount = std::min<int>(std::max<int>(args.at(exec, 1)->toUInt32(exec), 0), length - begin);
else
deleteCount = length - begin;
}
}
for (unsigned k = 0; k < additionalArgs; ++k)
- thisObj->put(exec, k + begin, args[k + 2]);
+ thisObj->put(exec, k + begin, args.at(exec, k + 2));
thisObj->put(exec, exec->propertyNames().length, jsNumber(exec, length - deleteCount + additionalArgs));
return result;
}
}
for (unsigned k = 0; k < nrArgs; ++k)
- thisObj->put(exec, k, args[k]);
+ thisObj->put(exec, k, args.at(exec, k));
JSValue* result = jsNumber(exec, length + nrArgs);
thisObj->put(exec, exec->propertyNames().length, result);
return result;
{
JSObject* thisObj = thisValue->toThisObject(exec);
- JSValue* function = args[0];
+ JSValue* function = args.at(exec, 0);
CallData callData;
CallType callType = function->getCallData(callData);
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->globalThisValue() : args[1]->toObject(exec);
+ JSObject* applyThis = args.at(exec, 1)->isUndefinedOrNull() ? exec->globalThisValue() : args.at(exec, 1)->toObject(exec);
JSArray* resultArray = constructEmptyArray(exec);
unsigned filterIndex = 0;
{
JSObject* thisObj = thisValue->toThisObject(exec);
- JSValue* function = args[0];
+ JSValue* function = args.at(exec, 0);
CallData callData;
CallType callType = function->getCallData(callData);
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->globalThisValue() : args[1]->toObject(exec);
+ JSObject* applyThis = args.at(exec, 1)->isUndefinedOrNull() ? exec->globalThisValue() : args.at(exec, 1)->toObject(exec);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
{
JSObject* thisObj = thisValue->toThisObject(exec);
- JSValue* function = args[0];
+ JSValue* function = args.at(exec, 0);
CallData callData;
CallType callType = function->getCallData(callData);
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->globalThisValue() : args[1]->toObject(exec);
+ JSObject* applyThis = args.at(exec, 1)->isUndefinedOrNull() ? exec->globalThisValue() : args.at(exec, 1)->toObject(exec);
JSValue* result = jsBoolean(true);
{
JSObject* thisObj = thisValue->toThisObject(exec);
- JSValue* function = args[0];
+ JSValue* function = args.at(exec, 0);
CallData callData;
CallType callType = function->getCallData(callData);
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->globalThisValue() : args[1]->toObject(exec);
+ JSObject* applyThis = args.at(exec, 1)->isUndefinedOrNull() ? exec->globalThisValue() : args.at(exec, 1)->toObject(exec);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
for (unsigned k = 0; k < length && !exec->hadException(); ++k) {
{
JSObject* thisObj = thisValue->toThisObject(exec);
- JSValue* function = args[0];
+ JSValue* function = args.at(exec, 0);
CallData callData;
CallType callType = function->getCallData(callData);
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->globalThisValue() : args[1]->toObject(exec);
+ JSObject* applyThis = args.at(exec, 1)->isUndefinedOrNull() ? exec->globalThisValue() : args.at(exec, 1)->toObject(exec);
JSValue* result = jsBoolean(false);
JSObject* thisObj = thisValue->toThisObject(exec);
unsigned index = 0;
- double d = args[1]->toInteger(exec);
+ double d = args.at(exec, 1)->toInteger(exec);
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
if (d < 0)
d += length;
index = static_cast<unsigned>(d);
}
- JSValue* searchElement = args[0];
+ JSValue* searchElement = args.at(exec, 0);
for (; index < length; ++index) {
JSValue* e = getProperty(exec, thisObj, index);
if (!e)
unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec);
int index = length - 1;
- double d = args[1]->toIntegerPreserveNaN(exec);
+ double d = args.at(exec, 1)->toIntegerPreserveNaN(exec);
if (d < 0) {
d += length;
if (d < length)
index = static_cast<int>(d);
- JSValue* searchElement = args[0];
+ JSValue* searchElement = args.at(exec, 0);
for (; index >= 0; --index) {
JSValue* e = getProperty(exec, thisObj, index);
if (!e)
JSObject* constructBoolean(ExecState* exec, const ArgList& args)
{
BooleanObject* obj = new (exec) BooleanObject(exec->lexicalGlobalObject()->booleanPrototype());
- obj->setInternalValue(jsBoolean(args[0]->toBoolean(exec)));
+ obj->setInternalValue(jsBoolean(args.at(exec, 0)->toBoolean(exec)));
return obj;
}
// ECMA 15.6.1
static JSValue* callBooleanConstructor(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsBoolean(args[0]->toBoolean(exec));
+ return jsBoolean(args.at(exec, 0)->toBoolean(exec));
}
CallType BooleanConstructor::getCallData(CallData& callData)
if (numArgs == 0) // new Date() ECMA 15.9.3.3
value = getCurrentUTCTime();
else if (numArgs == 1) {
- if (args[0]->isObject(&DateInstance::info))
- value = static_cast<DateInstance*>(args[0])->internalNumber();
+ if (args.at(exec, 0)->isObject(&DateInstance::info))
+ value = static_cast<DateInstance*>(args.at(exec, 0))->internalNumber();
else {
- JSValue* primitive = args[0]->toPrimitive(exec);
+ JSValue* primitive = args.at(exec, 0)->toPrimitive(exec);
if (primitive->isString())
value = parseDate(primitive->getString());
else
value = primitive->toNumber(exec);
}
} else {
- if (isnan(args[0]->toNumber(exec))
- || isnan(args[1]->toNumber(exec))
- || (numArgs >= 3 && isnan(args[2]->toNumber(exec)))
- || (numArgs >= 4 && isnan(args[3]->toNumber(exec)))
- || (numArgs >= 5 && isnan(args[4]->toNumber(exec)))
- || (numArgs >= 6 && isnan(args[5]->toNumber(exec)))
- || (numArgs >= 7 && isnan(args[6]->toNumber(exec))))
+ if (isnan(args.at(exec, 0)->toNumber(exec))
+ || isnan(args.at(exec, 1)->toNumber(exec))
+ || (numArgs >= 3 && isnan(args.at(exec, 2)->toNumber(exec)))
+ || (numArgs >= 4 && isnan(args.at(exec, 3)->toNumber(exec)))
+ || (numArgs >= 5 && isnan(args.at(exec, 4)->toNumber(exec)))
+ || (numArgs >= 6 && isnan(args.at(exec, 5)->toNumber(exec)))
+ || (numArgs >= 7 && isnan(args.at(exec, 6)->toNumber(exec))))
value = NaN;
else {
GregorianDateTime t;
- int year = args[0]->toInt32(exec);
+ int year = args.at(exec, 0)->toInt32(exec);
t.year = (year >= 0 && year <= 99) ? year : year - 1900;
- t.month = args[1]->toInt32(exec);
- t.monthDay = (numArgs >= 3) ? args[2]->toInt32(exec) : 1;
- t.hour = args[3]->toInt32(exec);
- t.minute = args[4]->toInt32(exec);
- t.second = args[5]->toInt32(exec);
+ t.month = args.at(exec, 1)->toInt32(exec);
+ t.monthDay = (numArgs >= 3) ? args.at(exec, 2)->toInt32(exec) : 1;
+ t.hour = args.at(exec, 3)->toInt32(exec);
+ t.minute = args.at(exec, 4)->toInt32(exec);
+ t.second = args.at(exec, 5)->toInt32(exec);
t.isDST = -1;
- double ms = (numArgs >= 7) ? args[6]->toNumber(exec) : 0;
+ double ms = (numArgs >= 7) ? args.at(exec, 6)->toNumber(exec) : 0;
value = gregorianDateTimeToMS(t, ms, false);
}
}
static JSValue* dateParse(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, parseDate(args[0]->toString(exec)));
+ return jsNumber(exec, parseDate(args.at(exec, 0)->toString(exec)));
}
static JSValue* dateNow(ExecState* exec, JSObject*, JSValue*, const ArgList&)
static JSValue* dateUTC(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
int n = args.size();
- if (isnan(args[0]->toNumber(exec))
- || isnan(args[1]->toNumber(exec))
- || (n >= 3 && isnan(args[2]->toNumber(exec)))
- || (n >= 4 && isnan(args[3]->toNumber(exec)))
- || (n >= 5 && isnan(args[4]->toNumber(exec)))
- || (n >= 6 && isnan(args[5]->toNumber(exec)))
- || (n >= 7 && isnan(args[6]->toNumber(exec))))
+ if (isnan(args.at(exec, 0)->toNumber(exec))
+ || isnan(args.at(exec, 1)->toNumber(exec))
+ || (n >= 3 && isnan(args.at(exec, 2)->toNumber(exec)))
+ || (n >= 4 && isnan(args.at(exec, 3)->toNumber(exec)))
+ || (n >= 5 && isnan(args.at(exec, 4)->toNumber(exec)))
+ || (n >= 6 && isnan(args.at(exec, 5)->toNumber(exec)))
+ || (n >= 7 && isnan(args.at(exec, 6)->toNumber(exec))))
return jsNaN(exec);
GregorianDateTime t;
- int year = args[0]->toInt32(exec);
+ int year = args.at(exec, 0)->toInt32(exec);
t.year = (year >= 0 && year <= 99) ? year : year - 1900;
- t.month = args[1]->toInt32(exec);
- t.monthDay = (n >= 3) ? args[2]->toInt32(exec) : 1;
- t.hour = args[3]->toInt32(exec);
- t.minute = args[4]->toInt32(exec);
- t.second = args[5]->toInt32(exec);
- double ms = (n >= 7) ? args[6]->toNumber(exec) : 0;
+ t.month = args.at(exec, 1)->toInt32(exec);
+ t.monthDay = (n >= 3) ? args.at(exec, 2)->toInt32(exec) : 1;
+ t.hour = args.at(exec, 3)->toInt32(exec);
+ t.minute = args.at(exec, 4)->toInt32(exec);
+ t.second = args.at(exec, 5)->toInt32(exec);
+ double ms = (n >= 7) ? args.at(exec, 6)->toNumber(exec) : 0;
return jsNumber(exec, gregorianDateTimeToMS(t, ms, true));
}
bool useCustomFormat = false;
UString customFormatString;
- UString arg0String = args[0]->toString(exec);
- if (arg0String == "custom" && !args[1]->isUndefined()) {
+ UString arg0String = args.at(exec, 0)->toString(exec);
+ if (arg0String == "custom" && !args.at(exec, 1)->isUndefined()) {
useCustomFormat = true;
- customFormatString = args[1]->toString(exec);
- } else if (includeDate && includeTime && !args[1]->isUndefined()) {
+ customFormatString = args.at(exec, 1)->toString(exec);
+ } else if (includeDate && includeTime && !args.at(exec, 1)->isUndefined()) {
dateStyle = styleFromArgString(arg0String, dateStyle);
- timeStyle = styleFromArgString(args[1]->toString(exec), timeStyle);
- } else if (includeDate && !args[0]->isUndefined())
+ timeStyle = styleFromArgString(args.at(exec, 1)->toString(exec), timeStyle);
+ } else if (includeDate && !args.at(exec, 0)->isUndefined())
dateStyle = styleFromArgString(arg0String, dateStyle);
- else if (includeTime && !args[0]->isUndefined())
+ else if (includeTime && !args.at(exec, 0)->isUndefined())
timeStyle = styleFromArgString(arg0String, timeStyle);
CFLocaleRef locale = CFLocaleCopyCurrent();
// hours
if (maxArgs >= 4 && idx < numArgs) {
t->hour = 0;
- milliseconds += args[idx++]->toInt32(exec, ok) * msPerHour;
+ milliseconds += args.at(exec, idx++)->toInt32(exec, ok) * msPerHour;
}
// minutes
if (maxArgs >= 3 && idx < numArgs && ok) {
t->minute = 0;
- milliseconds += args[idx++]->toInt32(exec, ok) * msPerMinute;
+ milliseconds += args.at(exec, idx++)->toInt32(exec, ok) * msPerMinute;
}
// seconds
if (maxArgs >= 2 && idx < numArgs && ok) {
t->second = 0;
- milliseconds += args[idx++]->toInt32(exec, ok) * msPerSecond;
+ milliseconds += args.at(exec, idx++)->toInt32(exec, ok) * msPerSecond;
}
if (!ok)
// milliseconds
if (idx < numArgs) {
- double millis = args[idx]->toNumber(exec);
+ double millis = args.at(exec, idx)->toNumber(exec);
ok = isfinite(millis);
milliseconds += millis;
} else
// years
if (maxArgs >= 3 && idx < numArgs)
- t->year = args[idx++]->toInt32(exec, ok) - 1900;
+ t->year = args.at(exec, idx++)->toInt32(exec, ok) - 1900;
// months
if (maxArgs >= 2 && idx < numArgs && ok)
- t->month = args[idx++]->toInt32(exec, ok);
+ t->month = args.at(exec, idx++)->toInt32(exec, ok);
// days
if (idx < numArgs && ok) {
t->monthDay = 0;
- *ms += args[idx]->toInt32(exec, ok) * msPerDay;
+ *ms += args.at(exec, idx)->toInt32(exec, ok) * msPerDay;
}
return ok;
DateInstance* thisDateObj = static_cast<DateInstance*>(thisValue);
- double milli = timeClip(args[0]->toNumber(exec));
+ double milli = timeClip(args.at(exec, 0)->toNumber(exec));
JSValue* result = jsNumber(exec, milli);
thisDateObj->setInternalValue(result);
return result;
}
bool ok = true;
- int32_t year = args[0]->toInt32(exec, ok);
+ int32_t year = args.at(exec, 0)->toInt32(exec, ok);
if (!ok) {
JSValue* result = jsNaN(exec);
thisDateObj->setInternalValue(result);
if (!m_codeBlock)
return 0;
- JSFunction* function = static_cast<JSFunction*>(callFrame()[RegisterFile::Callee].jsValue());
+ JSFunction* function = static_cast<JSFunction*>(callFrame()[RegisterFile::Callee].getJSValue());
if (!function)
return 0;
return &function->functionName().ustring();
DebuggerCallFrame::Type DebuggerCallFrame::type() const
{
- if (callFrame()[RegisterFile::Callee].jsValue())
+ if (callFrame()[RegisterFile::Callee].getJSValue())
return FunctionType;
return ProgramType;
if (!m_codeBlock)
return 0;
- return static_cast<JSObject*>(m_registers[m_codeBlock->thisRegister].jsValue());
+ return static_cast<JSObject*>(m_registers[m_codeBlock->thisRegister].getJSValue());
}
JSValue* DebuggerCallFrame::evaluate(const UString& script, JSValue*& exception) const
static ErrorInstance* constructError(ExecState* exec, const ArgList& args)
{
ErrorInstance* obj = new (exec) ErrorInstance(exec->lexicalGlobalObject()->errorPrototype());
- if (!args[0]->isUndefined())
- obj->putDirect(exec->propertyNames().message, jsString(exec, args[0]->toString(exec)));
+ if (!args.at(exec, 0)->isUndefined())
+ obj->putDirect(exec->propertyNames().message, jsString(exec, args.at(exec, 0)->toString(exec)));
return obj;
}
class EvalNode;
class FunctionBodyNode;
class JSFunction;
+ class JSValue;
class GlobalFuncImp;
class Interpreter;
class JSGlobalObject;
IdentifierTable* identifierTable() { return m_globalData->identifierTable; }
const CommonIdentifiers& propertyNames() const { return *m_globalData->propertyNames; }
- const ArgList& emptyList() const { return m_globalData->emptyList; }
+ const ArgList& emptyList() const { return *m_globalData->emptyList; }
Lexer* lexer() { return m_globalData->lexer; }
Parser* parser() { return m_globalData->parser; }
Machine* machine() const { return m_globalData->machine; }
if (argsSize == 0)
body = "";
else if (argsSize == 1)
- body = args[0]->toString(exec);
+ body = args.at(exec, 0)->toString(exec);
else {
- p = args[0]->toString(exec);
+ p = args.at(exec, 0)->toString(exec);
for (int k = 1; k < argsSize - 1; k++)
- p += "," + args[k]->toString(exec);
- body = args[argsSize - 1]->toString(exec);
+ p += "," + args.at(exec, k)->toString(exec);
+ body = args.at(exec, argsSize - 1)->toString(exec);
}
// parse the source code
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSValue* thisArg = args[0];
- JSValue* argArray = args[1];
+ JSValue* thisArg = args.at(exec, 0);
+ JSValue* argArray = args.at(exec, 1);
JSValue* applyThis;
if (thisArg->isUndefinedOrNull())
if (callType == CallTypeNone)
return throwError(exec, TypeError);
- JSValue* thisArg = args[0];
+ JSValue* thisArg = args.at(exec, 0);
JSObject* callThis;
if (thisArg->isUndefinedOrNull())
checkConsistency();
}
-JSArray::JSArray(JSObject* prototype, const ArgList& list)
+JSArray::JSArray(ExecState* exec, JSObject* prototype, const ArgList& list)
: JSObject(prototype)
{
unsigned length = list.size();
size_t i = 0;
ArgList::const_iterator end = list.end();
for (ArgList::const_iterator it = list.begin(); it != end; ++it, ++i)
- storage->m_vector[i] = (*it).jsValue();
+ storage->m_vector[i] = (*it).jsValue(exec);
m_storage = storage;
{
ArgList values;
values.append(singleItemValue);
- return new (exec) JSArray(exec->lexicalGlobalObject()->arrayPrototype(), values);
+ return new (exec) JSArray(exec, exec->lexicalGlobalObject()->arrayPrototype(), values);
}
JSArray* constructArray(ExecState* exec, const ArgList& values)
{
- return new (exec) JSArray(exec->lexicalGlobalObject()->arrayPrototype(), values);
+ return new (exec) JSArray(exec, exec->lexicalGlobalObject()->arrayPrototype(), values);
}
} // namespace KJS
class JSArray : public JSObject {
public:
JSArray(JSValue* prototype, unsigned initialLength);
- JSArray(JSObject* prototype, const ArgList& initialValues);
+ JSArray(ExecState* exec, JSObject* prototype, const ArgList& initialValues);
virtual ~JSArray();
virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
extern const HashTable regExpConstructorTable;
extern const HashTable stringTable;
-
JSGlobalData::JSGlobalData(bool isShared)
: machine(new Machine)
, heap(new Heap(this))
#endif
, identifierTable(createIdentifierTable())
, propertyNames(new CommonIdentifiers(this))
+ , emptyList(new ArgList)
, newParserObjects(0)
, parserObjectExtraRefCounts(0)
, lexer(new Lexer(this))
#ifndef JSGlobalData_h
#define JSGlobalData_h
-#include "ArgList.h"
#include <wtf/Forward.h>
#include <wtf/HashCountedSet.h>
#include <wtf/HashSet.h>
namespace KJS {
+ class ArgList;
class CommonIdentifiers;
class Heap;
class IdentifierTable;
IdentifierTable* identifierTable;
CommonIdentifiers* propertyNames;
- const ArgList emptyList; // Lists are supposed to be allocated on the stack to have their elements properly marked, which is not the case here - but this list has nothing to mark.
+ const ArgList* emptyList; // Lists are supposed to be allocated on the stack to have their elements properly marked, which is not the case here - but this list has nothing to mark.
HashSet<ParserRefCounted*>* newParserObjects;
HashCountedSet<ParserRefCounted*>* parserObjectExtraRefCounts;
static JSValue* encode(ExecState* exec, const ArgList& args, const char* doNotEscape)
{
- UString str = args[0]->toString(exec);
+ UString str = args.at(exec, 0)->toString(exec);
CString cstr = str.UTF8String(true);
if (!cstr.c_str())
return throwError(exec, URIError, "String contained an illegal UTF-16 sequence.");
static JSValue* decode(ExecState* exec, const ArgList& args, const char* doNotUnescape, bool strict)
{
UString result = "";
- UString str = args[0]->toString(exec);
+ UString str = args.at(exec, 0)->toString(exec);
int k = 0;
int len = str.size();
const UChar* d = str.data();
if (!globalObject || globalObject->evalFunction() != function)
return throwError(exec, EvalError, "The \"this\" value passed to eval must be the global object from which eval originated");
- JSValue* x = args[0];
+ JSValue* x = args.at(exec, 0);
if (!x->isString())
return x;
JSValue* globalFuncParseInt(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, parseInt(args[0]->toString(exec), args[1]->toInt32(exec)));
+ return jsNumber(exec, parseInt(args.at(exec, 0)->toString(exec), args.at(exec, 1)->toInt32(exec)));
}
JSValue* globalFuncParseFloat(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, parseFloat(args[0]->toString(exec)));
+ return jsNumber(exec, parseFloat(args.at(exec, 0)->toString(exec)));
}
JSValue* globalFuncIsNaN(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsBoolean(isnan(args[0]->toNumber(exec)));
+ return jsBoolean(isnan(args.at(exec, 0)->toNumber(exec)));
}
JSValue* globalFuncIsFinite(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- double n = args[0]->toNumber(exec);
+ double n = args.at(exec, 0)->toNumber(exec);
return jsBoolean(!isnan(n) && !isinf(n));
}
UString result = "";
UString s;
- UString str = args[0]->toString(exec);
+ UString str = args.at(exec, 0)->toString(exec);
const UChar* c = str.data();
for (int k = 0; k < str.size(); k++, c++) {
int u = c[0];
JSValue* globalFuncUnescape(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
UString result = "";
- UString str = args[0]->toString(exec);
+ UString str = args.at(exec, 0)->toString(exec);
int k = 0;
int len = str.size();
while (k < len) {
JSValue* globalFuncKJSPrint(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
CStringBuffer string;
- args[0]->toString(exec).getCString(string);
+ args.at(exec, 0)->toString(exec).getCString(string);
puts(string.data());
return jsUndefined();
}
#ifndef JSNumberCell_h
#define JSNumberCell_h
-#include "CallData.h"
-#include "ConstructData.h"
#include "ExecState.h"
#include "JSCell.h"
#include "JSImmediate.h"
namespace KJS {
- class ExecState;
class Identifier;
class JSCell;
class JSObject;
JSValue* mathProtoFuncAbs(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- double arg = args[0]->toNumber(exec);
+ double arg = args.at(exec, 0)->toNumber(exec);
return signbit(arg) ? jsNumber(exec, -arg) : jsNumber(exec, arg);
}
JSValue* mathProtoFuncACos(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, acos(args[0]->toNumber(exec)));
+ return jsNumber(exec, acos(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncASin(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, asin(args[0]->toNumber(exec)));
+ return jsNumber(exec, asin(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncATan(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, atan(args[0]->toNumber(exec)));
+ return jsNumber(exec, atan(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncATan2(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, atan2(args[0]->toNumber(exec), args[1]->toNumber(exec)));
+ return jsNumber(exec, atan2(args.at(exec, 0)->toNumber(exec), args.at(exec, 1)->toNumber(exec)));
}
JSValue* mathProtoFuncCeil(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- double arg = args[0]->toNumber(exec);
+ double arg = args.at(exec, 0)->toNumber(exec);
if (signbit(arg) && arg > -1.0)
return jsNumber(exec, -0.0);
return jsNumber(exec, ceil(arg));
JSValue* mathProtoFuncCos(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, cos(args[0]->toNumber(exec)));
+ return jsNumber(exec, cos(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncExp(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, exp(args[0]->toNumber(exec)));
+ return jsNumber(exec, exp(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncFloor(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- double arg = args[0]->toNumber(exec);
+ double arg = args.at(exec, 0)->toNumber(exec);
if (signbit(arg) && arg == 0.0)
return jsNumber(exec, -0.0);
return jsNumber(exec, floor(arg));
JSValue* mathProtoFuncLog(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, log(args[0]->toNumber(exec)));
+ return jsNumber(exec, log(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncMax(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
unsigned argsCount = args.size();
double result = -Inf;
for (unsigned k = 0; k < argsCount; ++k) {
- double val = args[k]->toNumber(exec);
+ double val = args.at(exec, k)->toNumber(exec);
if (isnan(val)) {
result = NaN;
break;
unsigned argsCount = args.size();
double result = +Inf;
for (unsigned k = 0; k < argsCount; ++k) {
- double val = args[k]->toNumber(exec);
+ double val = args.at(exec, k)->toNumber(exec);
if (isnan(val)) {
result = NaN;
break;
{
// ECMA 15.8.2.1.13
- double arg = args[0]->toNumber(exec);
- double arg2 = args[1]->toNumber(exec);
+ double arg = args.at(exec, 0)->toNumber(exec);
+ double arg2 = args.at(exec, 1)->toNumber(exec);
if (isnan(arg2))
return jsNaN(exec);
JSValue* mathProtoFuncRound(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- double arg = args[0]->toNumber(exec);
+ double arg = args.at(exec, 0)->toNumber(exec);
if (signbit(arg) && arg >= -0.5)
return jsNumber(exec, -0.0);
return jsNumber(exec, floor(arg + 0.5));
JSValue* mathProtoFuncSin(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, sin(args[0]->toNumber(exec)));
+ return jsNumber(exec, sin(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncSqrt(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, sqrt(args[0]->toNumber(exec)));
+ return jsNumber(exec, sqrt(args.at(exec, 0)->toNumber(exec)));
}
JSValue* mathProtoFuncTan(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, tan(args[0]->toNumber(exec)));
+ return jsNumber(exec, tan(args.at(exec, 0)->toNumber(exec)));
}
} // namespace KJS
ErrorInstance* NativeErrorConstructor::construct(ExecState* exec, const ArgList& args)
{
ErrorInstance* object = new (exec) ErrorInstance(m_proto);
- if (!args[0]->isUndefined())
- object->putDirect(exec->propertyNames().message, jsString(exec, args[0]->toString(exec)));
+ if (!args.at(exec, 0)->isUndefined())
+ object->putDirect(exec->propertyNames().message, jsString(exec, args.at(exec, 0)->toString(exec)));
return object;
}
static JSObject* constructWithNumberConstructor(ExecState* exec, JSObject*, const ArgList& args)
{
NumberObject* obj = new (exec) NumberObject(exec->lexicalGlobalObject()->numberPrototype());
- double n = args.isEmpty() ? 0 : args[0]->toNumber(exec);
+ double n = args.isEmpty() ? 0 : args.at(exec, 0)->toNumber(exec);
obj->setInternalValue(jsNumber(exec, n));
return obj;
}
// ECMA 15.7.2
static JSValue* callNumberConstructor(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- return jsNumber(exec, args.isEmpty() ? 0 : args[0]->toNumber(exec));
+ return jsNumber(exec, args.isEmpty() ? 0 : args.at(exec, 0)->toNumber(exec));
}
CallType NumberConstructor::getCallData(CallData& callData)
if (!v)
return throwError(exec, TypeError);
- double radixAsDouble = args[0]->toInteger(exec); // nan -> 0
- if (radixAsDouble == 10 || args[0]->isUndefined())
+ double radixAsDouble = args.at(exec, 0)->toInteger(exec); // nan -> 0
+ if (radixAsDouble == 10 || args.at(exec, 0)->isUndefined())
return jsString(exec, v->toString(exec));
if (radixAsDouble < 2 || radixAsDouble > 36)
if (!v)
return throwError(exec, TypeError);
- JSValue* fractionDigits = args[0];
+ JSValue* fractionDigits = args.at(exec, 0);
double df = fractionDigits->toInteger(exec);
if (!(df >= 0 && df <= 20))
return throwError(exec, RangeError, "toFixed() digits argument must be between 0 and 20");
if (isnan(x) || isinf(x))
return jsString(exec, UString::from(x));
- JSValue* fractionalDigitsValue = args[0];
+ JSValue* fractionalDigitsValue = args.at(exec, 0);
double df = fractionalDigitsValue->toInteger(exec);
if (!(df >= 0 && df <= 20))
return throwError(exec, RangeError, "toExponential() argument must between 0 and 20");
if (!v)
return throwError(exec, TypeError);
- double doublePrecision = args[0]->toIntegerPreserveNaN(exec);
+ double doublePrecision = args.at(exec, 0)->toIntegerPreserveNaN(exec);
double x = v->uncheckedGetNumber();
- if (args[0]->isUndefined() || isnan(x) || isinf(x))
+ if (args.at(exec, 0)->isUndefined() || isnan(x) || isinf(x))
return jsString(exec, v->toString(exec));
UString s;
// ECMA 15.2.2
static ALWAYS_INLINE JSObject* constructObject(ExecState* exec, const ArgList& args)
{
- JSValue* arg = args[0];
+ JSValue* arg = args.at(exec, 0);
if (arg->isUndefinedOrNull())
return new (exec) JSObject(exec->lexicalGlobalObject()->objectPrototype());
return arg->toObject(exec);
JSValue* objectProtoFuncHasOwnProperty(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
- return jsBoolean(thisValue->toThisObject(exec)->hasOwnProperty(exec, Identifier(exec, args[0]->toString(exec))));
+ return jsBoolean(thisValue->toThisObject(exec)->hasOwnProperty(exec, Identifier(exec, args.at(exec, 0)->toString(exec))));
}
JSValue* objectProtoFuncIsPrototypeOf(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
JSObject* thisObj = thisValue->toThisObject(exec);
- if (!args[0]->isObject())
+ if (!args.at(exec, 0)->isObject())
return jsBoolean(false);
- JSValue* v = static_cast<JSObject*>(args[0])->prototype();
+ JSValue* v = static_cast<JSObject*>(args.at(exec, 0))->prototype();
while (true) {
if (!v->isObject())
JSValue* objectProtoFuncDefineGetter(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
CallData callData;
- if (args[1]->getCallData(callData) == CallTypeNone)
+ if (args.at(exec, 1)->getCallData(callData) == CallTypeNone)
return throwError(exec, SyntaxError, "invalid getter usage");
- thisValue->toThisObject(exec)->defineGetter(exec, Identifier(exec, args[0]->toString(exec)), static_cast<JSObject*>(args[1]));
+ thisValue->toThisObject(exec)->defineGetter(exec, Identifier(exec, args.at(exec, 0)->toString(exec)), static_cast<JSObject*>(args.at(exec, 1)));
return jsUndefined();
}
JSValue* objectProtoFuncDefineSetter(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
CallData callData;
- if (args[1]->getCallData(callData) == CallTypeNone)
+ if (args.at(exec, 1)->getCallData(callData) == CallTypeNone)
return throwError(exec, SyntaxError, "invalid setter usage");
- thisValue->toThisObject(exec)->defineSetter(exec, Identifier(exec, args[0]->toString(exec)), static_cast<JSObject*>(args[1]));
+ thisValue->toThisObject(exec)->defineSetter(exec, Identifier(exec, args.at(exec, 0)->toString(exec)), static_cast<JSObject*>(args.at(exec, 1)));
return jsUndefined();
}
JSValue* objectProtoFuncLookupGetter(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
- return thisValue->toThisObject(exec)->lookupGetter(exec, Identifier(exec, args[0]->toString(exec)));
+ return thisValue->toThisObject(exec)->lookupGetter(exec, Identifier(exec, args.at(exec, 0)->toString(exec)));
}
JSValue* objectProtoFuncLookupSetter(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
- return thisValue->toThisObject(exec)->lookupSetter(exec, Identifier(exec, args[0]->toString(exec)));
+ return thisValue->toThisObject(exec)->lookupSetter(exec, Identifier(exec, args.at(exec, 0)->toString(exec)));
}
JSValue* objectProtoFuncPropertyIsEnumerable(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
- return jsBoolean(thisValue->toThisObject(exec)->propertyIsEnumerable(exec, Identifier(exec, args[0]->toString(exec))));
+ return jsBoolean(thisValue->toThisObject(exec)->propertyIsEnumerable(exec, Identifier(exec, args.at(exec, 0)->toString(exec))));
}
JSValue* objectProtoFuncToLocaleString(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&)
if (m_getValue == KJS_VALUE_SLOT_MARKER)
return *m_data.valueSlot;
if (m_getValue == KJS_REGISTER_SLOT_MARKER)
- return (*m_data.registerSlot).jsValue();
+ return (*m_data.registerSlot).jsValue(exec);
ASSERT(m_getValue != KJS_NUMERIC_PROPERTY_NAME_SLOT_MARKER);
return m_getValue(exec, propertyName, *this);
}
if (m_getValue == KJS_NUMERIC_PROPERTY_NAME_SLOT_MARKER)
return m_data.numericFunc(exec, propertyName, *this);
if (m_getValue == KJS_REGISTER_SLOT_MARKER)
- return (*m_data.registerSlot).jsValue();
+ return (*m_data.registerSlot).jsValue(exec);
return m_getValue(exec, Identifier::from(exec, propertyName), *this);
}
// ECMA 15.10.4
static JSObject* constructRegExp(ExecState* exec, const ArgList& args)
{
- JSValue* arg0 = args[0];
- JSValue* arg1 = args[1];
+ JSValue* arg0 = args.at(exec, 0);
+ JSValue* arg1 = args.at(exec, 1);
if (arg0->isObject(&RegExpObject::info)) {
if (!arg1->isUndefined())
UString input;
if (!args.isEmpty())
- input = args[0]->toString(exec);
+ input = args.at(exec, 0)->toString(exec);
else {
input = regExpObj->input();
if (input.isNull()) {
return throwError(exec, TypeError);
RefPtr<RegExp> regExp;
- JSValue* arg0 = args[0];
- JSValue* arg1 = args[1];
+ JSValue* arg0 = args.at(exec, 0);
+ JSValue* arg1 = args.at(exec, 1);
if (arg0->isObject(&RegExpObject::info)) {
if (!arg1->isUndefined())
if (i != 0)
putchar(' ');
- printf("%s", args[i]->toString(exec).UTF8String().c_str());
+ printf("%s", args.at(exec, i)->toString(exec).UTF8String().c_str());
}
putchar('\n');
JSValue* functionDebug(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- fprintf(stderr, "--> %s\n", args[0]->toString(exec).UTF8String().c_str());
+ fprintf(stderr, "--> %s\n", args.at(exec, 0)->toString(exec).UTF8String().c_str());
return jsUndefined();
}
JSValue* functionRun(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
StopWatch stopWatch;
- UString fileName = args[0]->toString(exec);
+ UString fileName = args.at(exec, 0)->toString(exec);
Vector<char> script;
if (!fillBufferWithContentsOfFile(fileName, script))
return throwError(exec, GeneralError, "Could not open file.");
JSValue* functionLoad(ExecState* exec, JSObject*, JSValue*, const ArgList& args)
{
- UString fileName = args[0]->toString(exec);
+ UString fileName = args.at(exec, 0)->toString(exec);
Vector<char> script;
if (!fillBufferWithContentsOfFile(fileName, script))
return throwError(exec, GeneralError, "Could not open file.");
UChar* p = buf;
ArgList::const_iterator end = args.end();
for (ArgList::const_iterator it = args.begin(); it != end; ++it)
- *p++ = static_cast<UChar>((*it).toUInt32(exec));
+ *p++ = static_cast<UChar>((*it).jsValue(exec)->toUInt32(exec));
s = UString(buf, args.size(), false);
} else
s = "";
JSObject* prototype = exec->lexicalGlobalObject()->stringPrototype();
if (args.isEmpty())
return new (exec) StringObject(exec, prototype);
- return new (exec) StringObject(exec, prototype, args[0]->toString(exec));
+ return new (exec) StringObject(exec, prototype, args.at(exec, 0)->toString(exec));
}
ConstructType StringConstructor::getConstructData(ConstructData& constructData)
{
if (args.isEmpty())
return jsString(exec, "");
- return jsString(exec, args[0]->toString(exec));
+ return jsString(exec, args.at(exec, 0)->toString(exec));
}
CallType StringConstructor::getCallData(CallData& callData)
JSString* sourceVal = thisValue->toThisJSString(exec);
const UString& source = sourceVal->value();
- JSValue* pattern = args[0];
+ JSValue* pattern = args.at(exec, 0);
- JSValue* replacement = args[1];
+ JSValue* replacement = args.at(exec, 1);
UString replacementString;
CallData callData;
CallType callType = replacement->getCallData(callData);
int len = s.size();
UString u;
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
double dpos = a0->toInteger(exec);
if (dpos >= 0 && dpos < len)
u = s.substr(static_cast<int>(dpos), 1);
JSValue* result = 0;
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
double dpos = a0->toInteger(exec);
if (dpos >= 0 && dpos < len)
result = jsNumber(exec, s[static_cast<int>(dpos)]);
ArgList::const_iterator end = args.end();
for (ArgList::const_iterator it = args.begin(); it != end; ++it)
- s += (*it).toString(exec);
+ s += (*it).jsValue(exec)->toString(exec);
return jsString(exec, s);
}
UString s = thisValue->toThisString(exec);
int len = s.size();
- JSValue* a0 = args[0];
- JSValue* a1 = args[1];
+ JSValue* a0 = args.at(exec, 0);
+ JSValue* a1 = args.at(exec, 1);
UString u2 = a0->toString(exec);
double dpos = a1->toInteger(exec);
if (dpos < 0)
UString s = thisValue->toThisString(exec);
int len = s.size();
- JSValue* a0 = args[0];
- JSValue* a1 = args[1];
+ JSValue* a0 = args.at(exec, 0);
+ JSValue* a1 = args.at(exec, 1);
UString u2 = a0->toString(exec);
double dpos = a1->toIntegerPreserveNaN(exec);
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
UString u = s;
RefPtr<RegExp> reg;
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
UString u = s;
RefPtr<RegExp> reg;
UString s = thisValue->toThisString(exec);
int len = s.size();
- JSValue* a0 = args[0];
- JSValue* a1 = args[1];
+ JSValue* a0 = args.at(exec, 0);
+ JSValue* a1 = args.at(exec, 1);
// The arg processing is very much like ArrayProtoFunc::Slice
double start = a0->toInteger(exec);
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
- JSValue* a1 = args[1];
+ JSValue* a0 = args.at(exec, 0);
+ JSValue* a1 = args.at(exec, 1);
JSObject* res = constructEmptyArray(exec);
JSValue* result = res;
UString s = thisValue->toThisString(exec);
int len = s.size();
- JSValue* a0 = args[0];
- JSValue* a1 = args[1];
+ JSValue* a0 = args.at(exec, 0);
+ JSValue* a1 = args.at(exec, 1);
double start = a0->toInteger(exec);
double length = a1->isUndefined() ? len : a1->toInteger(exec);
UString s = thisValue->toThisString(exec);
int len = s.size();
- JSValue* a0 = args[0];
- JSValue* a1 = args[1];
+ JSValue* a0 = args.at(exec, 0);
+ JSValue* a1 = args.at(exec, 1);
double start = a0->toNumber(exec);
double end = a1->toNumber(exec);
return jsNumber(exec, 0);
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
return jsNumber(exec, localeCompare(s, a0->toString(exec)));
}
JSValue* stringProtoFuncFontcolor(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
return jsString(exec, "<font color=\"" + a0->toString(exec) + "\">" + s + "</font>");
}
JSValue* stringProtoFuncFontsize(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
return jsString(exec, "<font size=\"" + a0->toString(exec) + "\">" + s + "</font>");
}
JSValue* stringProtoFuncAnchor(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
return jsString(exec, "<a name=\"" + a0->toString(exec) + "\">" + s + "</a>");
}
JSValue* stringProtoFuncLink(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
UString s = thisValue->toThisString(exec);
- JSValue* a0 = args[0];
+ JSValue* a0 = args.at(exec, 0);
return jsString(exec, "<a href=\"" + a0->toString(exec) + "\">" + s + "</a>");
}
+2008-07-22 Geoffrey Garen <ggaren@apple.com>
+
+ Reviewed by Oliver Hunt and Sam Weinig.
+
+ Next step toward putting doubles in registers: Prepare the Register class
+ and its clients for registers that don't contain JSValue*s.
+
2008-07-21 Mark Rowe <mrowe@apple.com>
Reviewed by Sam Weinig.
CFMutableArrayRef jsArgs = CFArrayCreateMutable(0, 0, &arrayCallBacks);
if (jsArgs) {
for (CFIndex i = 0; i < argCount; i++) {
- JSUserObject* jsArg = KJSValueToJSObject(args[i], exec);
+ JSUserObject* jsArg = KJSValueToJSObject(args.at(exec, i), exec);
CFArrayAppendValue(jsArgs, (void*)jsArg);
jsArg->Release();
}
+2008-07-22 Geoffrey Garen <ggaren@apple.com>
+
+ Reviewed by Oliver Hunt and Sam Weinig.
+
+ Next step toward putting doubles in registers: Prepare the Register class
+ and its clients for registers that don't contain JSValue*s.
+
2008-07-22 Sam Weinig <sam@webkit.org>
Reviewed by Mark Rowe.
RefPtr<HTMLAudioElement> audio = new HTMLAudioElement(static_cast<JSAudioConstructor*>(constructor)->document());
if (args.size() > 0) {
- audio->setSrc(args[0]->toString(exec));
+ audio->setSrc(args.at(exec, 0)->toString(exec));
audio->scheduleLoad();
}
return static_cast<JSObject*>(toJS(exec, audio.release()));
// 5 args = c, m, y, k, a
switch (args.size()) {
case 1:
- if (args[0]->isString())
- context->setFillColor(static_cast<JSString*>(args[0])->value());
+ if (args.at(exec, 0)->isString())
+ context->setFillColor(static_cast<JSString*>(args.at(exec, 0))->value());
else
- context->setFillColor(args[0]->toFloat(exec));
+ context->setFillColor(args.at(exec, 0)->toFloat(exec));
break;
case 2:
- if (args[0]->isString())
- context->setFillColor(static_cast<JSString*>(args[0])->value(), args[1]->toFloat(exec));
+ if (args.at(exec, 0)->isString())
+ context->setFillColor(static_cast<JSString*>(args.at(exec, 0))->value(), args.at(exec, 1)->toFloat(exec));
else
- context->setFillColor(args[0]->toFloat(exec), args[1]->toFloat(exec));
+ context->setFillColor(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec));
break;
case 4:
- context->setFillColor(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec));
+ context->setFillColor(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec));
break;
case 5:
- context->setFillColor(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec), args[4]->toFloat(exec));
+ context->setFillColor(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec));
break;
default:
return throwError(exec, SyntaxError);
// 5 args = c, m, y, k, a
switch (args.size()) {
case 1:
- if (args[0]->isString())
- context->setStrokeColor(static_cast<JSString*>(args[0])->value());
+ if (args.at(exec, 0)->isString())
+ context->setStrokeColor(static_cast<JSString*>(args.at(exec, 0))->value());
else
- context->setStrokeColor(args[0]->toFloat(exec));
+ context->setStrokeColor(args.at(exec, 0)->toFloat(exec));
break;
case 2:
- if (args[0]->isString())
- context->setStrokeColor(static_cast<JSString*>(args[0])->value(), args[1]->toFloat(exec));
+ if (args.at(exec, 0)->isString())
+ context->setStrokeColor(static_cast<JSString*>(args.at(exec, 0))->value(), args.at(exec, 1)->toFloat(exec));
else
- context->setStrokeColor(args[0]->toFloat(exec), args[1]->toFloat(exec));
+ context->setStrokeColor(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec));
break;
case 4:
- context->setStrokeColor(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec));
+ context->setStrokeColor(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec));
break;
case 5:
- context->setStrokeColor(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec), args[4]->toFloat(exec));
+ context->setStrokeColor(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec));
break;
default:
return throwError(exec, SyntaxError);
CanvasRenderingContext2D* context = impl();
if (args.size() <= 4)
- context->strokeRect(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec));
+ context->strokeRect(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec));
else
- context->strokeRect(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec), args[4]->toFloat(exec));
+ context->strokeRect(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec));
return jsUndefined();
}
// drawImage(img, sx, sy, sw, sh, dx, dy, dw, dh)
// Composite operation is specified with globalCompositeOperation.
// The img parameter can be a <img> or <canvas> element.
- JSValue* value = args[0];
+ JSValue* value = args.at(exec, 0);
if (!value->isObject())
return throwError(exec, TypeError);
JSObject* o = static_cast<JSObject*>(value);
ExceptionCode ec = 0;
if (o->inherits(&JSHTMLImageElement::s_info)) {
- HTMLImageElement* imgElt = static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(args[0])->impl());
+ HTMLImageElement* imgElt = static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(args.at(exec, 0))->impl());
switch (args.size()) {
case 3:
- context->drawImage(imgElt, args[1]->toFloat(exec), args[2]->toFloat(exec));
+ context->drawImage(imgElt, args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec));
break;
case 5:
- context->drawImage(imgElt, args[1]->toFloat(exec), args[2]->toFloat(exec),
- args[3]->toFloat(exec), args[4]->toFloat(exec), ec);
+ context->drawImage(imgElt, args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec),
+ args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec), ec);
setDOMException(exec, ec);
break;
case 9:
- context->drawImage(imgElt, FloatRect(args[1]->toFloat(exec), args[2]->toFloat(exec),
- args[3]->toFloat(exec), args[4]->toFloat(exec)),
- FloatRect(args[5]->toFloat(exec), args[6]->toFloat(exec),
- args[7]->toFloat(exec), args[8]->toFloat(exec)), ec);
+ context->drawImage(imgElt, FloatRect(args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec),
+ args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec)),
+ FloatRect(args.at(exec, 5)->toFloat(exec), args.at(exec, 6)->toFloat(exec),
+ args.at(exec, 7)->toFloat(exec), args.at(exec, 8)->toFloat(exec)), ec);
setDOMException(exec, ec);
break;
default:
return throwError(exec, SyntaxError);
}
} else if (o->inherits(&JSHTMLCanvasElement::s_info)) {
- HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(args[0])->impl());
+ HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(args.at(exec, 0))->impl());
switch (args.size()) {
case 3:
- context->drawImage(canvas, args[1]->toFloat(exec), args[2]->toFloat(exec));
+ context->drawImage(canvas, args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec));
break;
case 5:
- context->drawImage(canvas, args[1]->toFloat(exec), args[2]->toFloat(exec),
- args[3]->toFloat(exec), args[4]->toFloat(exec), ec);
+ context->drawImage(canvas, args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec),
+ args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec), ec);
setDOMException(exec, ec);
break;
case 9:
- context->drawImage(canvas, FloatRect(args[1]->toFloat(exec), args[2]->toFloat(exec),
- args[3]->toFloat(exec), args[4]->toFloat(exec)),
- FloatRect(args[5]->toFloat(exec), args[6]->toFloat(exec),
- args[7]->toFloat(exec), args[8]->toFloat(exec)), ec);
+ context->drawImage(canvas, FloatRect(args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec),
+ args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec)),
+ FloatRect(args.at(exec, 5)->toFloat(exec), args.at(exec, 6)->toFloat(exec),
+ args.at(exec, 7)->toFloat(exec), args.at(exec, 8)->toFloat(exec)), ec);
setDOMException(exec, ec);
break;
default:
{
CanvasRenderingContext2D* context = impl();
- JSValue* value = args[0];
+ JSValue* value = args.at(exec, 0);
if (!value->isObject())
return throwError(exec, TypeError);
JSObject* o = static_cast<JSObject*>(value);
if (!o->inherits(&JSHTMLImageElement::s_info))
return throwError(exec, TypeError);
- context->drawImageFromRect(static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(args[0])->impl()),
- args[1]->toFloat(exec), args[2]->toFloat(exec),
- args[3]->toFloat(exec), args[4]->toFloat(exec),
- args[5]->toFloat(exec), args[6]->toFloat(exec),
- args[7]->toFloat(exec), args[8]->toFloat(exec),
- args[9]->toString(exec));
+ context->drawImageFromRect(static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(args.at(exec, 0))->impl()),
+ args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec),
+ args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec),
+ args.at(exec, 5)->toFloat(exec), args.at(exec, 6)->toFloat(exec),
+ args.at(exec, 7)->toFloat(exec), args.at(exec, 8)->toFloat(exec),
+ args.at(exec, 9)->toString(exec));
return jsUndefined();
}
switch (args.size()) {
case 3:
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec));
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec));
break;
case 4:
- if (args[3]->isString())
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), static_cast<JSString*>(args[3])->value());
+ if (args.at(exec, 3)->isString())
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), static_cast<JSString*>(args.at(exec, 3))->value());
else
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec));
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec));
break;
case 5:
- if (args[3]->isString())
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), static_cast<JSString*>(args[3])->value(),
- args[4]->toFloat(exec));
+ if (args.at(exec, 3)->isString())
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), static_cast<JSString*>(args.at(exec, 3))->value(),
+ args.at(exec, 4)->toFloat(exec));
else
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec),
- args[4]->toFloat(exec));
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec),
+ args.at(exec, 4)->toFloat(exec));
break;
case 7:
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec),
- args[4]->toFloat(exec), args[5]->toFloat(exec),
- args[6]->toFloat(exec));
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec),
+ args.at(exec, 4)->toFloat(exec), args.at(exec, 5)->toFloat(exec),
+ args.at(exec, 6)->toFloat(exec));
break;
case 8:
- context->setShadow(args[0]->toFloat(exec), args[1]->toFloat(exec),
- args[2]->toFloat(exec), args[3]->toFloat(exec),
- args[4]->toFloat(exec), args[5]->toFloat(exec),
- args[6]->toFloat(exec), args[7]->toFloat(exec));
+ context->setShadow(args.at(exec, 0)->toFloat(exec), args.at(exec, 1)->toFloat(exec),
+ args.at(exec, 2)->toFloat(exec), args.at(exec, 3)->toFloat(exec),
+ args.at(exec, 4)->toFloat(exec), args.at(exec, 5)->toFloat(exec),
+ args.at(exec, 6)->toFloat(exec), args.at(exec, 7)->toFloat(exec));
break;
default:
return throwError(exec, SyntaxError);
{
CanvasRenderingContext2D* context = impl();
- JSValue* value = args[0];
+ JSValue* value = args.at(exec, 0);
if (!value->isObject())
return throwError(exec, TypeError);
JSObject* o = static_cast<JSObject*>(value);
if (o->inherits(&JSHTMLImageElement::s_info)) {
ExceptionCode ec;
JSValue* pattern = toJS(exec,
- context->createPattern(static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(args[0])->impl()),
- valueToStringWithNullCheck(exec, args[1]), ec).get());
+ context->createPattern(static_cast<HTMLImageElement*>(static_cast<JSHTMLElement*>(args.at(exec, 0))->impl()),
+ valueToStringWithNullCheck(exec, args.at(exec, 1)), ec).get());
setDOMException(exec, ec);
return pattern;
}
if (o->inherits(&JSHTMLCanvasElement::s_info)) {
ExceptionCode ec;
JSValue* pattern = toJS(exec,
- context->createPattern(static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(args[0])->impl()),
- valueToStringWithNullCheck(exec, args[1]), ec).get());
+ context->createPattern(static_cast<HTMLCanvasElement*>(static_cast<JSHTMLElement*>(args.at(exec, 0))->impl()),
+ valueToStringWithNullCheck(exec, args.at(exec, 1)), ec).get());
setDOMException(exec, ec);
return pattern;
}
ExceptionCode ec = 0;
if (args.size() >= 7)
- context->putImageData(toImageData(args[0]), args[1]->toFloat(exec), args[2]->toFloat(exec),
- args[3]->toFloat(exec), args[4]->toFloat(exec), args[5]->toFloat(exec), args[6]->toFloat(exec), ec);
+ context->putImageData(toImageData(args.at(exec, 0)), args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec),
+ args.at(exec, 3)->toFloat(exec), args.at(exec, 4)->toFloat(exec), args.at(exec, 5)->toFloat(exec), args.at(exec, 6)->toFloat(exec), ec);
else
- context->putImageData(toImageData(args[0]), args[1]->toFloat(exec), args[2]->toFloat(exec), ec);
+ context->putImageData(toImageData(args.at(exec, 0)), args.at(exec, 1)->toFloat(exec), args.at(exec, 2)->toFloat(exec), ec);
setDOMException(exec, ec);
return jsUndefined();
}
if (args.size() == 1) {
- clipboard->clearData(args[0]->toString(exec));
+ clipboard->clearData(args.at(exec, 0)->toString(exec));
return jsUndefined();
}
Clipboard* clipboard = impl();
bool success;
- String result = clipboard->getData(args[0]->toString(exec), success);
+ String result = clipboard->getData(args.at(exec, 0)->toString(exec), success);
if (!success)
return jsUndefined();
if (args.size() != 2)
return throwError(exec, SyntaxError, "setData: Invalid number of arguments");
- return jsBoolean(clipboard->setData(args[0]->toString(exec), args[1]->toString(exec)));
+ return jsBoolean(clipboard->setData(args.at(exec, 0)->toString(exec), args.at(exec, 1)->toString(exec)));
}
JSValue* JSClipboard::setDragImage(ExecState* exec, const ArgList& args)
if (args.size() != 3)
return throwError(exec, SyntaxError, "setDragImage: Invalid number of arguments");
- int x = args[1]->toInt32(exec);
- int y = args[2]->toInt32(exec);
+ int x = args.at(exec, 1)->toInt32(exec);
+ int y = args.at(exec, 2)->toInt32(exec);
// See if they passed us a node
- Node* node = toNode(args[0]);
+ Node* node = toNode(args.at(exec, 0));
if (!node)
return throwError(exec, TypeError);
ArgList messageParameters;
arguments.getSlice(1, messageParameters);
- impl()->assertCondition(arguments[0]->toBoolean(exec), exec, messageParameters);
+ impl()->assertCondition(arguments.at(exec, 0)->toBoolean(exec), exec, messageParameters);
return jsUndefined();
}
Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame();
if (!frame)
return jsUndefined();
- const KURL& url = frame->loader()->completeURL(args[0]->toString(exec));
+ const KURL& url = frame->loader()->completeURL(args.at(exec, 0)->toString(exec));
ExceptionCode ec = 0;
impl()->add(url, ec);
Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame();
if (!frame)
return jsUndefined();
- const KURL& url = frame->loader()->completeURL(args[0]->toString(exec));
+ const KURL& url = frame->loader()->completeURL(args.at(exec, 0)->toString(exec));
ExceptionCode ec = 0;
impl()->remove(url, ec);
Frame* frame = impl()->frame();
if (!frame)
return jsUndefined();
- RefPtr<JSUnprotectedEventListener> listener = toJSDOMWindow(frame)->findOrCreateJSUnprotectedEventListener(exec, args[1], true);
+ RefPtr<JSUnprotectedEventListener> listener = toJSDOMWindow(frame)->findOrCreateJSUnprotectedEventListener(exec, args.at(exec, 1), true);
if (!listener)
return jsUndefined();
- impl()->addEventListener(args[0]->toString(exec), listener.release(), args[2]->toBoolean(exec));
+ impl()->addEventListener(args.at(exec, 0)->toString(exec), listener.release(), args.at(exec, 2)->toBoolean(exec));
return jsUndefined();
}
Frame* frame = impl()->frame();
if (!frame)
return jsUndefined();
- JSUnprotectedEventListener* listener = toJSDOMWindow(frame)->findJSUnprotectedEventListener(exec, args[1], true);
+ JSUnprotectedEventListener* listener = toJSDOMWindow(frame)->findJSUnprotectedEventListener(exec, args.at(exec, 1), true);
if (!listener)
return jsUndefined();
- impl()->removeEventListener(args[0]->toString(exec), listener, args[2]->toBoolean(exec));
+ impl()->removeEventListener(args.at(exec, 0)->toString(exec), listener, args.at(exec, 2)->toBoolean(exec));
return jsUndefined();
}
{
ExceptionCode ec = 0;
- bool result = impl()->dispatchEvent(toEvent(args[0]), ec);
+ bool result = impl()->dispatchEvent(toEvent(args.at(exec, 0)), ec);
setDOMException(exec, ec);
return jsBoolean(result);
}
if (args.size() < 1)
return throwError(exec, SyntaxError, "Not enough arguments");
- JSValue* v = args[0];
+ JSValue* v = args.at(exec, 0);
if (v->isNull())
return jsString(exec);
if (args.size() < 1)
return throwError(exec, SyntaxError, "Not enough arguments");
- JSValue* v = args[0];
+ JSValue* v = args.at(exec, 0);
if (v->isNull())
return jsString(exec);
Page* page = frame->page();
- String urlString = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- AtomicString frameName = args[1]->isUndefinedOrNull() ? "_blank" : AtomicString(args[1]->toString(exec));
+ String urlString = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ AtomicString frameName = args.at(exec, 1)->isUndefinedOrNull() ? "_blank" : AtomicString(args.at(exec, 1)->toString(exec));
// Because FrameTree::find() returns true for empty strings, we must check for empty framenames.
// Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker.
}
// In the case of a named frame or a new window, we'll use the createWindow() helper
- WindowFeatures windowFeatures(valueToStringWithUndefinedOrNullCheck(exec, args[2]));
+ WindowFeatures windowFeatures(valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 2)));
FloatRect windowRect(windowFeatures.x, windowFeatures.y, windowFeatures.width, windowFeatures.height);
DOMWindow::adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), windowRect, windowRect);
if (!window->allowsAccessFrom(exec))
return jsUndefined();
- JSValue* v = args[0];
- int delay = args[1]->toInt32(exec);
+ JSValue* v = args.at(exec, 0);
+ int delay = args.at(exec, 1)->toInt32(exec);
if (v->isString())
return jsNumber(exec, window->installTimeout(static_cast<JSString*>(v)->value(), delay, timeout));
CallData callData;
return jsUndefined();
ArgList argsTail;
args.getSlice(2, argsTail);
- return jsNumber(exec, window->installTimeout(v, argsTail, delay, timeout));
+ return jsNumber(exec, window->installTimeout(exec, v, argsTail, delay, timeout));
}
JSValue* windowProtoFuncClearTimeoutOrInterval(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
if (!window->allowsAccessFrom(exec))
return jsUndefined();
- window->clearTimeout(args[0]->toInt32(exec));
+ window->clearTimeout(args.at(exec, 0)->toInt32(exec));
return jsUndefined();
}
if (!frame)
return jsUndefined();
- if (RefPtr<JSEventListener> listener = window->findOrCreateJSEventListener(exec, args[1])) {
+ if (RefPtr<JSEventListener> listener = window->findOrCreateJSEventListener(exec, args.at(exec, 1))) {
if (Document* doc = frame->document())
- doc->addWindowEventListener(AtomicString(args[0]->toString(exec)), listener.release(), args[2]->toBoolean(exec));
+ doc->addWindowEventListener(AtomicString(args.at(exec, 0)->toString(exec)), listener.release(), args.at(exec, 2)->toBoolean(exec));
}
return jsUndefined();
if (!frame)
return jsUndefined();
- if (JSEventListener* listener = window->findJSEventListener(args[1])) {
+ if (JSEventListener* listener = window->findJSEventListener(args.at(exec, 1))) {
if (Document* doc = frame->document())
- doc->removeWindowEventListener(AtomicString(args[0]->toString(exec)), listener, args[2]->toBoolean(exec));
+ doc->removeWindowEventListener(AtomicString(args.at(exec, 0)->toString(exec)), listener, args.at(exec, 2)->toBoolean(exec));
}
return jsUndefined();
if (!frame)
return jsUndefined();
- return showModalDialog(exec, frame, valueToStringWithUndefinedOrNullCheck(exec, args[0]), args[1], valueToStringWithUndefinedOrNullCheck(exec, args[2]));
+ return showModalDialog(exec, frame, valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0)), args.at(exec, 1), valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 2)));
}
JSValue* windowProtoFuncNotImplemented(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&)
return installTimeout(new ScheduledAction(handler), t, singleShot);
}
-int JSDOMWindowBase::installTimeout(JSValue* func, const ArgList& args, int t, bool singleShot)
+int JSDOMWindowBase::installTimeout(ExecState* exec, JSValue* func, const ArgList& args, int t, bool singleShot)
{
- return installTimeout(new ScheduledAction(func, args), t, singleShot);
+ return installTimeout(new ScheduledAction(exec, func, args), t, singleShot);
}
PausedTimeouts* JSDOMWindowBase::pauseTimeouts()
virtual void put(KJS::ExecState*, const KJS::Identifier& propertyName, KJS::JSValue*);
int installTimeout(const KJS::UString& handler, int t, bool singleShot);
- int installTimeout(KJS::JSValue* function, const KJS::ArgList& args, int t, bool singleShot);
+ int installTimeout(KJS::ExecState*, KJS::JSValue* function, const KJS::ArgList& args, int t, bool singleShot);
void clearTimeout(int timerId, bool delAction = true);
PausedTimeouts* pauseTimeouts();
void resumeTimeouts(PausedTimeouts*);
DOMWindow* window = impl();
DOMWindow* source = asJSDOMWindow(exec->dynamicGlobalObject())->impl();
- String message = args[0]->toString(exec);
+ String message = args.at(exec, 0)->toString(exec);
if (exec->hadException())
return jsUndefined();
- String targetOrigin = valueToStringWithUndefinedOrNullCheck(exec, args[1]);
+ String targetOrigin = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 1));
if (exec->hadException())
return jsUndefined();
JSValue* JSDatabase::changeVersion(ExecState* exec, const ArgList& args)
{
- String oldVersion = args[0]->toString(exec);
- String newVersion = args[1]->toString(exec);
+ String oldVersion = args.at(exec, 0)->toString(exec);
+ String newVersion = args.at(exec, 1)->toString(exec);
Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame();
if (!frame)
return jsUndefined();
JSObject *object;
- if (!(object = args[2]->getObject())) {
+ if (!(object = args.at(exec, 2)->getObject())) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame));
RefPtr<SQLTransactionErrorCallback> errorCallback;
- if (!args[3]->isNull()) {
- if (!(object = args[3]->getObject())) {
+ if (!args.at(exec, 3)->isNull()) {
+ if (!(object = args.at(exec, 3)->getObject())) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
}
RefPtr<VoidCallback> successCallback;
- if (!args[4]->isNull()) {
- successCallback = toVoidCallback(exec, args[4]);
+ if (!args.at(exec, 4)->isNull()) {
+ successCallback = toVoidCallback(exec, args.at(exec, 4));
if (!successCallback) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
{
JSObject* object;
- if (!(object = args[0]->getObject())) {
+ if (!(object = args.at(exec, 0)->getObject())) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame));
RefPtr<SQLTransactionErrorCallback> errorCallback;
- if (args.size() > 1 && !args[1]->isNull()) {
- if (!(object = args[1]->getObject())) {
+ if (args.size() > 1 && !args.at(exec, 1)->isNull()) {
+ if (!(object = args.at(exec, 1)->getObject())) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
}
RefPtr<VoidCallback> successCallback;
- if (args.size() > 2 && !args[2]->isNull()) {
- successCallback = toVoidCallback(exec, args[2]);
+ if (args.size() > 2 && !args.at(exec, 2)->isNull()) {
+ successCallback = toVoidCallback(exec, args.at(exec, 2));
if (!successCallback) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
{
Document* imp = impl();
ExceptionCode ec = 0;
- const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- RefPtr<NSResolver> resolver = args[1]->isUndefinedOrNull() ? 0 : toNSResolver(args[1]);
+ const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ RefPtr<NSResolver> resolver = args.at(exec, 1)->isUndefinedOrNull() ? 0 : toNSResolver(args.at(exec, 1));
RefPtr<Element> element = imp->querySelector(selectors, resolver.get(), ec, exec);
if (exec->hadException())
{
Document* imp = impl();
ExceptionCode ec = 0;
- const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- RefPtr<NSResolver> resolver = args[1]->isUndefinedOrNull() ? 0 : toNSResolver(args[1]);
+ const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ RefPtr<NSResolver> resolver = args.at(exec, 1)->isUndefinedOrNull() ? 0 : toNSResolver(args.at(exec, 1));
RefPtr<NodeList> nodeList = imp->querySelectorAll(selectors, resolver.get(), ec, exec);
if (exec->hadException())
{
DocumentFragment* imp = static_cast<DocumentFragment*>(impl());
ExceptionCode ec = 0;
- const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- RefPtr<NSResolver> resolver = args[1]->isUndefinedOrNull() ? 0 : toNSResolver(args[1]);
+ const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ RefPtr<NSResolver> resolver = args.at(exec, 1)->isUndefinedOrNull() ? 0 : toNSResolver(args.at(exec, 1));
RefPtr<Element> element = imp->querySelector(selectors, resolver.get(), ec, exec);
if (exec->hadException())
{
DocumentFragment* imp = static_cast<DocumentFragment*>(impl());
ExceptionCode ec = 0;
- const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- RefPtr<NSResolver> resolver = args[1]->isUndefinedOrNull() ? 0 : toNSResolver(args[1]);
+ const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ RefPtr<NSResolver> resolver = args.at(exec, 1)->isUndefinedOrNull() ? 0 : toNSResolver(args.at(exec, 1));
RefPtr<NodeList> nodeList = imp->querySelectorAll(selectors, resolver.get(), ec, exec);
if (exec->hadException())
JSValue* JSElement::setAttribute(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- AtomicString name = args[0]->toString(exec);
- AtomicString value = args[1]->toString(exec);
+ AtomicString name = args.at(exec, 0)->toString(exec);
+ AtomicString value = args.at(exec, 1)->toString(exec);
Element* imp = impl();
if (!allowSettingSrcToJavascriptURL(exec, imp, name, value))
JSValue* JSElement::setAttributeNode(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- Attr* newAttr = toAttr(args[0]);
+ Attr* newAttr = toAttr(args.at(exec, 0));
if (!newAttr) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSElement::setAttributeNS(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- AtomicString namespaceURI = valueToStringWithNullCheck(exec, args[0]);
- AtomicString qualifiedName = args[1]->toString(exec);
- AtomicString value = args[2]->toString(exec);
+ AtomicString namespaceURI = valueToStringWithNullCheck(exec, args.at(exec, 0));
+ AtomicString qualifiedName = args.at(exec, 1)->toString(exec);
+ AtomicString value = args.at(exec, 2)->toString(exec);
Element* imp = impl();
if (!allowSettingSrcToJavascriptURL(exec, imp, qualifiedName, value))
JSValue* JSElement::setAttributeNodeNS(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- Attr* newAttr = toAttr(args[0]);
+ Attr* newAttr = toAttr(args.at(exec, 0));
if (!newAttr) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
{
Element* imp = impl();
ExceptionCode ec = 0;
- const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- RefPtr<NSResolver> resolver = args[1]->isUndefinedOrNull() ? 0 : toNSResolver(args[1]);
+ const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ RefPtr<NSResolver> resolver = args.at(exec, 1)->isUndefinedOrNull() ? 0 : toNSResolver(args.at(exec, 1));
RefPtr<Element> element = imp->querySelector(selectors, resolver.get(), ec, exec);
if (exec->hadException())
{
Element* imp = impl();
ExceptionCode ec = 0;
- const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
- RefPtr<NSResolver> resolver = args[1]->isUndefinedOrNull() ? 0 : toNSResolver(args[1]);
+ const UString& selectors = valueToStringWithUndefinedOrNullCheck(exec, args.at(exec, 0));
+ RefPtr<NSResolver> resolver = args.at(exec, 1)->isUndefinedOrNull() ? 0 : toNSResolver(args.at(exec, 1));
RefPtr<NodeList> nodeList = imp->querySelectorAll(selectors, resolver.get(), ec, exec);
if (exec->hadException())
if (!frame)
return jsUndefined();
- if (RefPtr<JSEventListener> listener = toJSDOMWindow(frame)->findOrCreateJSEventListener(exec, args[1]))
- eventTarget->addEventListener(args[0]->toString(exec), listener.release(), args[2]->toBoolean(exec));
+ if (RefPtr<JSEventListener> listener = toJSDOMWindow(frame)->findOrCreateJSEventListener(exec, args.at(exec, 1)))
+ eventTarget->addEventListener(args.at(exec, 0)->toString(exec), listener.release(), args.at(exec, 2)->toBoolean(exec));
return jsUndefined();
}
if (!frame)
return jsUndefined();
- if (JSEventListener* listener = toJSDOMWindow(frame)->findJSEventListener(args[1]))
- eventTarget->removeEventListener(args[0]->toString(exec), listener, args[2]->toBoolean(exec));
+ if (JSEventListener* listener = toJSDOMWindow(frame)->findJSEventListener(args.at(exec, 1)))
+ eventTarget->removeEventListener(args.at(exec, 0)->toString(exec), listener, args.at(exec, 2)->toBoolean(exec));
return jsUndefined();
}
return throwError(exec, TypeError);
DOMExceptionTranslator exception(exec);
- return jsBoolean(eventTarget->dispatchEvent(toEvent(args[0]), exception));
+ return jsBoolean(eventTarget->dispatchEvent(toEvent(args.at(exec, 0)), exception));
}
const AtomicString& eventNameForPropertyToken(int token)
if (args.size() == 1) {
// Support for document.all(<index>) etc.
bool ok;
- UString string = args[0]->toString(exec);
+ UString string = args.at(exec, 0)->toString(exec);
unsigned index = string.toUInt32(&ok, false);
if (ok)
return toJS(exec, collection->item(index));
// The second arg, if set, is the index of the item we want
bool ok;
- UString string = args[0]->toString(exec);
- unsigned index = args[1]->toString(exec).toUInt32(&ok, false);
+ UString string = args.at(exec, 0)->toString(exec);
+ unsigned index = args.at(exec, 1)->toString(exec).toUInt32(&ok, false);
if (ok) {
String pstr = string;
Node* node = collection->namedItem(pstr);
JSValue* JSHTMLCollection::item(ExecState* exec, const ArgList& args)
{
bool ok;
- uint32_t index = args[0]->toString(exec).toUInt32(&ok, false);
+ uint32_t index = args.at(exec, 0)->toString(exec).toUInt32(&ok, false);
if (ok)
return toJS(exec, impl()->item(index));
- return getNamedItems(exec, impl(), Identifier(exec, args[0]->toString(exec)));
+ return getNamedItems(exec, impl(), Identifier(exec, args.at(exec, 0)->toString(exec)));
}
JSValue* JSHTMLCollection::namedItem(ExecState* exec, const ArgList& args)
{
- return getNamedItems(exec, impl(), Identifier(exec, args[0]->toString(exec)));
+ return getNamedItems(exec, impl(), Identifier(exec, args.at(exec, 0)->toString(exec)));
}
JSValue* toJS(ExecState* exec, HTMLCollection* collection)
unsigned size = args.size();
if (size == 1)
- return args[0]->toString(exec);
+ return args.at(exec, 0)->toString(exec);
Vector<UChar> result;
for (unsigned i = 0; i < size; ++i)
- append(result, args[i]->toString(exec));
+ append(result, args.at(exec, i)->toString(exec));
return String::adopt(result);
}
JSValue* jsHTMLInputElementBaseFunctionSetSelectionRange(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
HTMLInputElement& input = *static_cast<HTMLInputElement*>(static_cast<JSHTMLInputElementBase*>(thisValue)->impl());
- input.setSelectionRange(args[0]->toInt32(exec), args[1]->toInt32(exec));
+ input.setSelectionRange(args.at(exec, 0)->toInt32(exec), args.at(exec, 1)->toInt32(exec));
return jsUndefined();
}
RefPtr<Text> text;
if (ec == 0)
text = document->createTextNode("");
- if (ec == 0 && !args[0]->isUndefined())
- text->setData(args[0]->toString(exec), ec);
+ if (ec == 0 && !args.at(exec, 0)->isUndefined())
+ text->setData(args.at(exec, 0)->toString(exec), ec);
if (ec == 0)
element->appendChild(text.release(), ec);
- if (ec == 0 && !args[1]->isUndefined())
- element->setValue(args[1]->toString(exec));
+ if (ec == 0 && !args.at(exec, 1)->isUndefined())
+ element->setValue(args.at(exec, 1)->toString(exec));
if (ec == 0)
- element->setDefaultSelected(args[2]->toBoolean(exec));
+ element->setDefaultSelected(args.at(exec, 2)->toBoolean(exec));
if (ec == 0)
- element->setSelected(args[3]->toBoolean(exec));
+ element->setSelected(args.at(exec, 3)->toBoolean(exec));
if (ec) {
setDOMException(exec, ec);
JSValue* JSHTMLOptionsCollection::add(ExecState* exec, const ArgList& args)
{
HTMLOptionsCollection* imp = static_cast<HTMLOptionsCollection*>(impl());
- HTMLOptionElement* option = toHTMLOptionElement(args[0]);
+ HTMLOptionElement* option = toHTMLOptionElement(args.at(exec, 0));
ExceptionCode ec = 0;
if (args.size() < 2)
imp->add(option, ec);
else {
bool ok;
- int index = args[1]->toInt32(exec, ok);
+ int index = args.at(exec, 1)->toInt32(exec, ok);
if (exec->hadException())
return jsUndefined();
if (!ok)
HTMLSelectElement& select = *static_cast<HTMLSelectElement*>(impl());
// we support both options index and options objects
- HTMLElement* element = toHTMLElement(args[0]);
+ HTMLElement* element = toHTMLElement(args.at(exec, 0));
if (element && element->hasTagName(optionTag))
select.remove(static_cast<HTMLOptionElement*>(element)->index());
else
- select.remove(args[0]->toInt32(exec));
+ select.remove(args.at(exec, 0)->toInt32(exec));
return jsUndefined();
}
int height = 0;
if (args.size() > 0) {
widthSet = true;
- width = args[0]->toInt32(exec);
+ width = args.at(exec, 0)->toInt32(exec);
}
if (args.size() > 1) {
heightSet = true;
- height = args[1]->toInt32(exec);
+ height = args.at(exec, 1)->toInt32(exec);
}
Document* document = static_cast<JSImageConstructor*>(constructor)->document();
JSValue* JSJavaScriptCallFrame::evaluate(ExecState* exec, const ArgList& args)
{
JSValue* exception = 0;
- JSValue* result = impl()->evaluate(args[0]->toString(exec), exception);
+ JSValue* result = impl()->evaluate(args.at(exec, 0)->toString(exec), exception);
if (exception)
exec->setException(exception);
if (!activeFrame->loader()->shouldAllowNavigation(frame))
return jsUndefined();
- navigateIfAllowed(exec, frame, activeFrame->loader()->completeURL(args[0]->toString(exec)), true);
+ navigateIfAllowed(exec, frame, activeFrame->loader()->completeURL(args.at(exec, 0)->toString(exec)), true);
return jsUndefined();
}
return jsUndefined();
// We want a new history item if this JS was called via a user gesture
- navigateIfAllowed(exec, frame, activeFrame->loader()->completeURL(args[0]->toString(exec)), false);
+ navigateIfAllowed(exec, frame, activeFrame->loader()->completeURL(args.at(exec, 0)->toString(exec)), false);
return jsUndefined();
}
JSValue* JSNode::insertBefore(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- bool ok = impl()->insertBefore(toNode(args[0]), toNode(args[1]), ec, true);
+ bool ok = impl()->insertBefore(toNode(args.at(exec, 0)), toNode(args.at(exec, 1)), ec, true);
setDOMException(exec, ec);
if (ok)
- return args[0];
+ return args.at(exec, 0);
return jsNull();
}
JSValue* JSNode::replaceChild(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- bool ok = impl()->replaceChild(toNode(args[0]), toNode(args[1]), ec, true);
+ bool ok = impl()->replaceChild(toNode(args.at(exec, 0)), toNode(args.at(exec, 1)), ec, true);
setDOMException(exec, ec);
if (ok)
- return args[1];
+ return args.at(exec, 1);
return jsNull();
}
JSValue* JSNode::removeChild(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- bool ok = impl()->removeChild(toNode(args[0]), ec);
+ bool ok = impl()->removeChild(toNode(args.at(exec, 0)), ec);
setDOMException(exec, ec);
if (ok)
- return args[0];
+ return args.at(exec, 0);
return jsNull();
}
JSValue* JSNode::appendChild(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- bool ok = impl()->appendChild(toNode(args[0]), ec, true);
+ bool ok = impl()->appendChild(toNode(args.at(exec, 0)), ec, true);
setDOMException(exec, ec);
if (ok)
- return args[0];
+ return args.at(exec, 0);
return jsNull();
}
JSValue* JSNodeFilter::acceptNode(ExecState* exec, const ArgList& args)
{
- return jsNumber(exec, impl()->acceptNode(exec, toNode(args[0])));
+ return jsNumber(exec, impl()->acceptNode(exec, toNode(args.at(exec, 0))));
}
PassRefPtr<NodeFilter> toNodeFilter(JSValue* value)
static JSValue* callNodeList(ExecState* exec, JSObject* function, JSValue*, const ArgList& args)
{
bool ok;
- unsigned index = args[0]->toString(exec).toUInt32(&ok);
+ unsigned index = args.at(exec, 0)->toString(exec).toUInt32(&ok);
if (!ok)
return jsUndefined();
return toJS(exec, static_cast<JSNodeList*>(function)->impl()->item(index));
ArgList preparedArgs;
for (size_t i = 0; i < args.size(); ++i)
- preparedArgs.append(wrapper->prepareIncomingValue(exec, args[i]));
+ preparedArgs.append(wrapper->prepareIncomingValue(exec, args.at(exec, i)));
// FIXME: Would be nice to find a way to reuse the result of m_unwrappedObject->getConstructData
// from when we called it in JSQuarantinedObjectWrapper::getConstructData.
ArgList preparedArgs;
for (size_t i = 0; i < args.size(); ++i)
- preparedArgs.append(wrapper->prepareIncomingValue(exec, args[i]));
+ preparedArgs.append(wrapper->prepareIncomingValue(exec, args.at(exec, i)));
// FIXME: Would be nice to find a way to reuse the result of m_unwrappedObject->getCallData
// from when we called it in JSQuarantinedObjectWrapper::getCallData.
JSValue* JSSQLResultSetRowList::item(ExecState* exec, const ArgList& args)
{
bool indexOk;
- int index = args[0]->toInt32(exec, indexOk);
+ int index = args.at(exec, 0)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSSQLTransaction::executeSql(ExecState* exec, const ArgList& args)
{
- String sqlStatement = args[0]->toString(exec);
+ String sqlStatement = args.at(exec, 0)->toString(exec);
if (exec->hadException())
return jsUndefined();
// Now assemble the list of SQL arguments
Vector<SQLValue> sqlValues;
- if (!args[1]->isUndefinedOrNull()) {
- JSObject* object = args[1]->getObject();
+ if (!args.at(exec, 1)->isUndefinedOrNull()) {
+ JSObject* object = args.at(exec, 1)->getObject();
if (!object) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
RefPtr<SQLStatementCallback> callback;
- if (!args[2]->isUndefinedOrNull()) {
- JSObject* object = args[2]->getObject();
+ if (!args.at(exec, 2)->isUndefinedOrNull()) {
+ JSObject* object = args.at(exec, 2)->getObject();
if (!object) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
RefPtr<SQLStatementErrorCallback> errorCallback;
- if (!args[3]->isUndefinedOrNull()) {
- JSObject* object = args[3]->getObject();
+ if (!args.at(exec, 3)->isUndefinedOrNull()) {
+ JSObject* object = args.at(exec, 3)->getObject();
if (!object) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSSVGPODTypeWrapper<SVGLength>* wrapper = impl();
SVGLength imp(*wrapper);
- imp.convertToSpecifiedUnits(args[0]->toInt32(exec), context());
+ imp.convertToSpecifiedUnits(args.at(exec, 0)->toInt32(exec), context());
wrapper->commitChange(imp, context());
return jsUndefined();
{
AffineTransform imp(*impl());
- AffineTransform secondMatrix = toSVGMatrix(args[0]);
+ AffineTransform secondMatrix = toSVGMatrix(args.at(exec, 0));
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.multiply(secondMatrix)).get(), m_context.get());
}
{
AffineTransform imp(*impl());
- float x = args[0]->toFloat(exec);
- float y = args[1]->toFloat(exec);
+ float x = args.at(exec, 0)->toFloat(exec);
+ float y = args.at(exec, 1)->toFloat(exec);
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.translate(x, y)).get(), m_context.get());
}
{
AffineTransform imp(*impl());
- float scaleFactor = args[0]->toFloat(exec);
+ float scaleFactor = args.at(exec, 0)->toFloat(exec);
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.scale(scaleFactor)).get(), m_context.get());
}
{
AffineTransform imp(*impl());
- float scaleFactorX = args[0]->toFloat(exec);
- float scaleFactorY = args[1]->toFloat(exec);
+ float scaleFactorX = args.at(exec, 0)->toFloat(exec);
+ float scaleFactorY = args.at(exec, 1)->toFloat(exec);
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.scaleNonUniform(scaleFactorX, scaleFactorY)).get(), m_context.get());
}
{
AffineTransform imp(*impl());
- float angle = args[0]->toFloat(exec);
+ float angle = args.at(exec, 0)->toFloat(exec);
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.rotate(angle)).get(), m_context.get());
}
{
AffineTransform imp(*impl());
- float x = args[0]->toFloat(exec);
- float y = args[1]->toFloat(exec);
+ float x = args.at(exec, 0)->toFloat(exec);
+ float y = args.at(exec, 1)->toFloat(exec);
KJS::JSValue* result = toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.rotateFromVector(x, y)).get(), m_context.get());
{
AffineTransform imp(*impl());
- float angle = args[0]->toFloat(exec);
+ float angle = args.at(exec, 0)->toFloat(exec);
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.skewX(angle)).get(), m_context.get());
}
{
AffineTransform imp(*impl());
- float angle = args[0]->toFloat(exec);
+ float angle = args.at(exec, 0)->toFloat(exec);
return toJS(exec, JSSVGStaticPODTypeWrapper<AffineTransform>::create(imp.skewY(angle)).get(), m_context.get());
}
JSValue* JSSVGPathSegList::initialize(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- SVGPathSeg* newItem = toSVGPathSeg(args[0]);
+ SVGPathSeg* newItem = toSVGPathSeg(args.at(exec, 0));
SVGPathSegList* imp = static_cast<SVGPathSegList*>(impl());
ExceptionCode ec = 0;
bool indexOk;
- unsigned index = args[0]->toInt32(exec, indexOk);
+ unsigned index = args.at(exec, 0)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSSVGPathSegList::insertItemBefore(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- SVGPathSeg* newItem = toSVGPathSeg(args[0]);
+ SVGPathSeg* newItem = toSVGPathSeg(args.at(exec, 0));
bool indexOk;
- unsigned index = args[1]->toInt32(exec, indexOk);
+ unsigned index = args.at(exec, 1)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSSVGPathSegList::replaceItem(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- SVGPathSeg* newItem = toSVGPathSeg(args[0]);
+ SVGPathSeg* newItem = toSVGPathSeg(args.at(exec, 0));
bool indexOk;
- unsigned index = args[1]->toInt32(exec, indexOk);
+ unsigned index = args.at(exec, 1)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
bool indexOk;
- unsigned index = args[0]->toInt32(exec, indexOk);
+ unsigned index = args.at(exec, 0)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSSVGPathSegList::appendItem(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- SVGPathSeg* newItem = toSVGPathSeg(args[0]);
+ SVGPathSeg* newItem = toSVGPathSeg(args.at(exec, 0));
SVGPathSegList* imp = static_cast<SVGPathSegList*>(impl());
ExceptionCode ec = 0;
SVGPointListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->initialize(PODListItem::copy(toSVGPoint(args[0])), ec));
+ listImp->initialize(PODListItem::copy(toSVGPoint(args.at(exec, 0))), ec));
}
JSValue* JSSVGPointList::getItem(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[0]->toUInt32(exec, indexOk);
+ unsigned index = args.at(exec, 0)->toUInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSSVGPointList::insertItemBefore(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[1]->toUInt32(exec, indexOk);
+ unsigned index = args.at(exec, 1)->toUInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
SVGPointListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->insertItemBefore(PODListItem::copy(toSVGPoint(args[0])), index, ec));
+ listImp->insertItemBefore(PODListItem::copy(toSVGPoint(args.at(exec, 0))), index, ec));
}
JSValue* JSSVGPointList::replaceItem(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[1]->toInt32(exec, indexOk);
+ unsigned index = args.at(exec, 1)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
SVGPointListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->replaceItem(PODListItem::copy(toSVGPoint(args[0])), index, ec));
+ listImp->replaceItem(PODListItem::copy(toSVGPoint(args.at(exec, 0))), index, ec));
}
JSValue* JSSVGPointList::removeItem(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[0]->toInt32(exec, indexOk);
+ unsigned index = args.at(exec, 0)->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
SVGPointListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->appendItem(PODListItem::copy(toSVGPoint(args[0])), ec));
+ listImp->appendItem(PODListItem::copy(toSVGPoint(args.at(exec, 0))), ec));
}
}
ExceptionCode ec = 0;
SVGTransformListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->initialize(PODListItem::copy(toSVGTransform(args[0])), ec));
+ listImp->initialize(PODListItem::copy(toSVGTransform(args.at(exec, 0))), ec));
}
JSValue* JSSVGTransformList::getItem(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[0]->toUInt32(exec, indexOk);
+ unsigned index = args.at(exec, 0)->toUInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
JSValue* JSSVGTransformList::insertItemBefore(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[1]->toUInt32(exec, indexOk);
+ unsigned index = args.at(exec, 1)->toUInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
SVGTransformListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->insertItemBefore(PODListItem::copy(toSVGTransform(args[0])), index, ec));
+ listImp->insertItemBefore(PODListItem::copy(toSVGTransform(args.at(exec, 0))), index, ec));
}
JSValue* JSSVGTransformList::replaceItem(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[1]->toUInt32(exec, indexOk);
+ unsigned index = args.at(exec, 1)->toUInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
SVGTransformListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->replaceItem(PODListItem::copy(toSVGTransform(args[0])), index, ec));
+ listImp->replaceItem(PODListItem::copy(toSVGTransform(args.at(exec, 0))), index, ec));
}
JSValue* JSSVGTransformList::removeItem(ExecState* exec, const ArgList& args)
{
bool indexOk;
- unsigned index = args[0]->toUInt32(exec, indexOk);
+ unsigned index = args.at(exec, 0)->toUInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
ExceptionCode ec = 0;
SVGTransformListBase* listImp = impl();
return finishSetter(exec, ec, context(), impl(),
- listImp->appendItem(PODListItem::copy(toSVGTransform(args[0])), ec));
+ listImp->appendItem(PODListItem::copy(toSVGTransform(args.at(exec, 0))), ec));
}
}
Frame* frame = asJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame();
if (!frame)
return jsUndefined();
- const KURL& url = frame->loader()->completeURL(args[1]->toString(exec));
+ const KURL& url = frame->loader()->completeURL(args.at(exec, 1)->toString(exec));
ExceptionCode ec = 0;
- String method = args[0]->toString(exec);
+ String method = args.at(exec, 0)->toString(exec);
bool async = true;
if (args.size() >= 3)
- async = args[2]->toBoolean(exec);
+ async = args.at(exec, 2)->toBoolean(exec);
- if (args.size() >= 4 && !args[3]->isUndefined()) {
- String user = valueToStringWithNullCheck(exec, args[3]);
+ if (args.size() >= 4 && !args.at(exec, 3)->isUndefined()) {
+ String user = valueToStringWithNullCheck(exec, args.at(exec, 3));
- if (args.size() >= 5 && !args[4]->isUndefined()) {
- String password = valueToStringWithNullCheck(exec, args[4]);
+ if (args.size() >= 5 && !args.at(exec, 4)->isUndefined()) {
+ String password = valueToStringWithNullCheck(exec, args.at(exec, 4));
impl()->open(method, url, async, user, password, ec);
} else
impl()->open(method, url, async, user, ec);
return throwError(exec, SyntaxError, "Not enough arguments");
ExceptionCode ec = 0;
- impl()->setRequestHeader(args[0]->toString(exec), args[1]->toString(exec), ec);
+ impl()->setRequestHeader(args.at(exec, 0)->toString(exec), args.at(exec, 1)->toString(exec), ec);
setDOMException(exec, ec);
return jsUndefined();
}
if (args.isEmpty())
impl()->send(ec);
else {
- JSValue* val = args[0];
+ JSValue* val = args.at(exec, 0);
if (val->isUndefinedOrNull())
impl()->send(ec);
else if (val->isObject(&JSDocument::s_info))
return throwError(exec, SyntaxError, "Not enough arguments");
ExceptionCode ec = 0;
- JSValue* header = jsStringOrNull(exec, impl()->getResponseHeader(args[0]->toString(exec), ec));
+ JSValue* header = jsStringOrNull(exec, impl()->getResponseHeader(args.at(exec, 0)->toString(exec), ec));
setDOMException(exec, ec);
return header;
}
if (args.size() < 1)
return throwError(exec, SyntaxError, "Not enough arguments");
- impl()->overrideMimeType(args[0]->toString(exec));
+ impl()->overrideMimeType(args.at(exec, 0)->toString(exec));
return jsUndefined();
}
Frame* frame = document->frame();
if (!frame)
return jsUndefined();
- RefPtr<JSUnprotectedEventListener> listener = toJSDOMWindow(frame)->findOrCreateJSUnprotectedEventListener(exec, args[1], true);
+ RefPtr<JSUnprotectedEventListener> listener = toJSDOMWindow(frame)->findOrCreateJSUnprotectedEventListener(exec, args.at(exec, 1), true);
if (!listener)
return jsUndefined();
- impl()->addEventListener(args[0]->toString(exec), listener.release(), args[2]->toBoolean(exec));
+ impl()->addEventListener(args.at(exec, 0)->toString(exec), listener.release(), args.at(exec, 2)->toBoolean(exec));
return jsUndefined();
}
Frame* frame = document->frame();
if (!frame)
return jsUndefined();
- JSUnprotectedEventListener* listener = toJSDOMWindow(frame)->findJSUnprotectedEventListener(exec, args[1], true);
+ JSUnprotectedEventListener* listener = toJSDOMWindow(frame)->findJSUnprotectedEventListener(exec, args.at(exec, 1), true);
if (!listener)
return jsUndefined();
- impl()->removeEventListener(args[0]->toString(exec), listener, args[2]->toBoolean(exec));
+ impl()->removeEventListener(args.at(exec, 0)->toString(exec), listener, args.at(exec, 2)->toBoolean(exec));
return jsUndefined();
}
JSValue* JSXMLHttpRequest::dispatchEvent(ExecState* exec, const ArgList& args)
{
ExceptionCode ec = 0;
- bool result = impl()->dispatchEvent(toEvent(args[0]), ec);
+ bool result = impl()->dispatchEvent(toEvent(args.at(exec, 0)), ec);
setDOMException(exec, ec);
return jsBoolean(result);
}
JSValue* JSXSLTProcessor::importStylesheet(ExecState* exec, const ArgList& args)
{
- JSValue* nodeVal = args[0];
+ JSValue* nodeVal = args.at(exec, 0);
if (nodeVal->isObject(&JSNode::s_info)) {
JSNode* node = static_cast<JSNode*>(nodeVal);
impl()->importStylesheet(node->impl());
JSValue* JSXSLTProcessor::transformToFragment(ExecState* exec, const ArgList& args)
{
- JSValue* nodeVal = args[0];
- JSValue* docVal = args[1];
+ JSValue* nodeVal = args.at(exec, 0);
+ JSValue* docVal = args.at(exec, 1);
if (nodeVal->isObject(&JSNode::s_info) && docVal->isObject(&JSDocument::s_info)) {
WebCore::Node* node = static_cast<JSNode*>(nodeVal)->impl();
Document* doc = static_cast<Document*>(static_cast<JSDocument*>(docVal)->impl());
JSValue* JSXSLTProcessor::transformToDocument(ExecState* exec, const ArgList& args)
{
- JSValue* nodeVal = args[0];
+ JSValue* nodeVal = args.at(exec, 0);
if (nodeVal->isObject(&JSNode::s_info)) {
JSNode* node = static_cast<JSNode*>(nodeVal);
RefPtr<Document> resultDocument = impl()->transformToDocument(node->impl());
JSValue* JSXSLTProcessor::setParameter(ExecState* exec, const ArgList& args)
{
- if (args[1]->isUndefinedOrNull() || args[2]->isUndefinedOrNull())
+ if (args.at(exec, 1)->isUndefinedOrNull() || args.at(exec, 2)->isUndefinedOrNull())
return jsUndefined(); // Throw exception?
- String namespaceURI = args[0]->toString(exec);
- String localName = args[1]->toString(exec);
- String value = args[2]->toString(exec);
+ String namespaceURI = args.at(exec, 0)->toString(exec);
+ String localName = args.at(exec, 1)->toString(exec);
+ String value = args.at(exec, 2)->toString(exec);
impl()->setParameter(namespaceURI, localName, value);
return jsUndefined();
}
JSValue* JSXSLTProcessor::getParameter(ExecState* exec, const ArgList& args)
{
- if (args[1]->isUndefinedOrNull())
+ if (args.at(exec, 1)->isUndefinedOrNull())
return jsUndefined();
- String namespaceURI = args[0]->toString(exec);
- String localName = args[1]->toString(exec);
+ String namespaceURI = args.at(exec, 0)->toString(exec);
+ String localName = args.at(exec, 1)->toString(exec);
String value = impl()->getParameter(namespaceURI, localName);
return jsStringOrUndefined(exec, value);
}
JSValue* JSXSLTProcessor::removeParameter(ExecState* exec, const ArgList& args)
{
- if (args[1]->isUndefinedOrNull())
+ if (args.at(exec, 1)->isUndefinedOrNull())
return jsUndefined();
- String namespaceURI = args[0]->toString(exec);
- String localName = args[1]->toString(exec);
+ String namespaceURI = args.at(exec, 0)->toString(exec);
+ String localName = args.at(exec, 1)->toString(exec);
impl()->removeParameter(namespaceURI, localName);
return jsUndefined();
}
namespace WebCore {
-ScheduledAction::ScheduledAction(JSValue* function, const ArgList& args)
+ScheduledAction::ScheduledAction(ExecState* exec, JSValue* function, const ArgList& args)
: m_function(function)
{
ArgList::const_iterator end = args.end();
for (ArgList::const_iterator it = args.begin(); it != end; ++it)
- m_args.append((*it).jsValue());
+ m_args.append((*it).jsValue(exec));
}
-
void ScheduledAction::execute(JSDOMWindowShell* windowShell)
{
RefPtr<Frame> frame = windowShell->window()->impl()->frame();
*/
class ScheduledAction {
public:
- ScheduledAction(KJS::JSValue* function, const KJS::ArgList&);
+ ScheduledAction(KJS::ExecState* exec, KJS::JSValue* function, const KJS::ArgList&);
ScheduledAction(const String& code)
: m_code(code)
{
if ($parameter->type eq "XPathNSResolver") {
push(@implContent, " RefPtr<XPathNSResolver> customResolver;\n");
- push(@implContent, " XPathNSResolver* resolver = toXPathNSResolver(args[$paramIndex]);\n");
+ push(@implContent, " XPathNSResolver* resolver = toXPathNSResolver(args.at(exec, $paramIndex));\n");
push(@implContent, " if (!resolver) {\n");
- push(@implContent, " customResolver = JSCustomXPathNSResolver::create(exec, args[$paramIndex]);\n");
+ push(@implContent, " customResolver = JSCustomXPathNSResolver::create(exec, args.at(exec, $paramIndex));\n");
push(@implContent, " if (exec->hadException())\n");
push(@implContent, " return jsUndefined();\n");
push(@implContent, " resolver = customResolver.get();\n");
push(@implContent, " }\n");
} else {
- push(@implContent, " " . GetNativeTypeFromSignature($parameter) . " $name = " . JSValueToNative($parameter, "args[$paramIndex]") . ";\n");
+ push(@implContent, " " . GetNativeTypeFromSignature($parameter) . " $name = " . JSValueToNative($parameter, "args.at(exec, $paramIndex)") . ";\n");
# If a parameter is "an index" and it's negative it should throw an INDEX_SIZE_ERR exception.
# But this needs to be done in the bindings, because the type is unsigned and the fact that it
#include "c_utility.h"
#include "npruntime_impl.h"
#include "runtime_root.h"
+#include <kjs/ArgList.h>
#include <kjs/ExecState.h>
#include <kjs/JSLock.h>
#include <kjs/JSNumberCell.h>
unsigned i;
for (i = 0; i < count; i++)
- convertValueToNPVariant(exec, args.at(i), &cArgs[i]);
+ convertValueToNPVariant(exec, args.at(exec, i), &cArgs[i]);
// Invoke the 'C' method.
NPVariant resultVariant;
unsigned i;
for (i = 0; i < count; i++)
- convertValueToNPVariant(exec, args.at(i), &cArgs[i]);
+ convertValueToNPVariant(exec, args.at(exec, i), &cArgs[i]);
// Invoke the 'C' method.
NPVariant resultVariant;
#include "jni_utility.h"
#include "runtime_object.h"
#include "runtime_root.h"
+#include <kjs/ArgList.h>
#include <kjs/Error.h>
#include <kjs/JSLock.h>
for (i = 0; i < count; i++) {
JavaParameter* aParameter = jMethod->parameterAt(i);
- jArgs[i] = convertValueToJValue (exec, args.at(i), aParameter->getJNIType(), aParameter->type());
- JS_LOG("arg[%d] = %s\n", i, args.at(i)->toString(exec).ascii());
+ jArgs[i] = convertValueToJValue (exec, args.at(exec, i), aParameter->getJNIType(), aParameter->type());
+ JS_LOG("arg[%d] = %s\n", i, args.at(exec, i)->toString(exec).ascii());
}
jvalue result;
NSMutableArray* objcArgs = [NSMutableArray array];
int count = args.size();
for (int i = 0; i < count; i++) {
- ObjcValue value = convertValueToObjcValue(exec, args.at(i), ObjcObjectType);
+ ObjcValue value = convertValueToObjcValue(exec, args.at(exec, i), ObjcObjectType);
[objcArgs addObject:value.objectValue];
}
[invocation setArgument:&objcArgs atIndex:3];
// types.
ASSERT(objcValueType != ObjcInvalidType && objcValueType != ObjcVoidType);
- ObjcValue value = convertValueToObjcValue(exec, args.at(i-2), objcValueType);
+ ObjcValue value = convertValueToObjcValue(exec, args.at(exec, i-2), objcValueType);
switch (objcValueType) {
case ObjcObjectType:
NSMutableArray* objcArgs = [NSMutableArray array];
unsigned count = args.size();
for (unsigned i = 0; i < count; i++) {
- ObjcValue value = convertValueToObjcValue(exec, args.at(i), ObjcObjectType);
+ ObjcValue value = convertValueToObjcValue(exec, args.at(exec, i), ObjcObjectType);
[objcArgs addObject:value.objectValue];
}
[invocation setArgument:&objcArgs atIndex:2];
printf(" %s\n", message.utf8().data());
}
-static void printToStandardOut(MessageLevel level, ExecState* exec, const ArgList& arguments, const KURL& url)
+static void printToStandardOut(MessageLevel level, ExecState* exec, const ArgList& args, const KURL& url)
{
if (!Interpreter::shouldPrintExceptions())
return;
printSourceURLAndLine(url.prettyURL(), 0);
printMessageSourceAndLevelPrefix(JSMessageSource, level);
- for (size_t i = 0; i < arguments.size(); ++i) {
- UString argAsString = arguments[i]->toString(exec);
+ for (size_t i = 0; i < args.size(); ++i) {
+ UString argAsString = args.at(exec, i)->toString(exec);
printf(" %s", argAsString.UTF8String().c_str());
}
printToStandardOut(source, level, message, sourceURL, lineNumber);
}
-void Console::debug(ExecState* exec, const ArgList& arguments)
+void Console::debug(ExecState* exec, const ArgList& args)
{
// In Firebug, console.debug has the same behavior as console.log. So we'll do the same.
- log(exec, arguments);
+ log(exec, args);
}
-void Console::error(ExecState* exec, const ArgList& arguments)
+void Console::error(ExecState* exec, const ArgList& args)
{
- if (arguments.isEmpty())
+ if (args.isEmpty())
return;
if (!m_frame)
if (!page)
return;
- String message = arguments[0]->toString(exec);
+ String message = args.at(exec, 0)->toString(exec);
const KURL& url = m_frame->loader()->url();
String prettyURL = url.prettyURL();
page->chrome()->client()->addMessageToConsole(message, 0, prettyURL);
- page->inspectorController()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, exec, arguments, 0, url.string());
+ page->inspectorController()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, exec, args, 0, url.string());
- printToStandardOut(ErrorMessageLevel, exec, arguments, url);
+ printToStandardOut(ErrorMessageLevel, exec, args, url);
}
-void Console::info(ExecState* exec, const ArgList& arguments)
+void Console::info(ExecState* exec, const ArgList& args)
{
- if (arguments.isEmpty())
+ if (args.isEmpty())
return;
if (!m_frame)
if (!page)
return;
- String message = arguments[0]->toString(exec);
+ String message = args.at(exec, 0)->toString(exec);
const KURL& url = m_frame->loader()->url();
String prettyURL = url.prettyURL();
page->chrome()->client()->addMessageToConsole(message, 0, prettyURL);
- page->inspectorController()->addMessageToConsole(JSMessageSource, LogMessageLevel, exec, arguments, 0, url.string());
+ page->inspectorController()->addMessageToConsole(JSMessageSource, LogMessageLevel, exec, args, 0, url.string());
- printToStandardOut(LogMessageLevel, exec, arguments, url);
+ printToStandardOut(LogMessageLevel, exec, args, url);
}
-void Console::log(ExecState* exec, const ArgList& arguments)
+void Console::log(ExecState* exec, const ArgList& args)
{
- if (arguments.isEmpty())
+ if (args.isEmpty())
return;
if (!m_frame)
if (!page)
return;
- String message = arguments[0]->toString(exec);
+ String message = args.at(exec, 0)->toString(exec);
const KURL& url = m_frame->loader()->url();
String prettyURL = url.prettyURL();
page->chrome()->client()->addMessageToConsole(message, 0, prettyURL);
- page->inspectorController()->addMessageToConsole(JSMessageSource, LogMessageLevel, exec, arguments, 0, url.string());
+ page->inspectorController()->addMessageToConsole(JSMessageSource, LogMessageLevel, exec, args, 0, url.string());
- printToStandardOut(LogMessageLevel, exec, arguments, url);
+ printToStandardOut(LogMessageLevel, exec, args, url);
}
-void Console::assertCondition(bool condition, ExecState* exec, const ArgList& arguments)
+void Console::assertCondition(bool condition, ExecState* exec, const ArgList& args)
{
if (condition)
return;
const KURL& url = m_frame->loader()->url();
// FIXME: <https://bugs.webkit.org/show_bug.cgi?id=19135> It would be nice to prefix assertion failures with a message like "Assertion failed: ".
- // FIXME: <https://bugs.webkit.org/show_bug.cgi?id=19136> We should print a message even when arguments.isEmpty() is true.
+ // FIXME: <https://bugs.webkit.org/show_bug.cgi?id=19136> We should print a message even when args.isEmpty() is true.
- page->inspectorController()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, exec, arguments, 0, url.string());
+ page->inspectorController()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, exec, args, 0, url.string());
- printToStandardOut(ErrorMessageLevel, exec, arguments, url);
+ printToStandardOut(ErrorMessageLevel, exec, args, url);
}
-void Console::profile(ExecState* exec, const ArgList& arguments)
+void Console::profile(ExecState* exec, const ArgList& args)
{
- UString title = arguments[0]->toString(exec);
+ UString title = args.at(exec, 0)->toString(exec);
Profiler::profiler()->startProfiling(exec, title, this);
}
-void Console::profileEnd(ExecState* exec, const ArgList& arguments)
+void Console::profileEnd(ExecState* exec, const ArgList& args)
{
UString title;
- if (arguments.size() >= 1)
- title = arguments[0]->toString(exec);
+ if (args.size() >= 1)
+ title = args.at(exec, 0)->toString(exec);
Profiler::profiler()->stopProfiling(exec, title);
}
page->inspectorController()->addProfile(prpProfile);
}
-void Console::warn(ExecState* exec, const ArgList& arguments)
+void Console::warn(ExecState* exec, const ArgList& args)
{
- if (arguments.isEmpty())
+ if (args.isEmpty())
return;
if (!m_frame)
if (!page)
return;
- String message = arguments[0]->toString(exec);
+ String message = args.at(exec, 0)->toString(exec);
const KURL& url = m_frame->loader()->url();
String prettyURL = url.prettyURL();
page->chrome()->client()->addMessageToConsole(message, 0, prettyURL);
- page->inspectorController()->addMessageToConsole(JSMessageSource, WarningMessageLevel, exec, arguments, 0, url.string());
+ page->inspectorController()->addMessageToConsole(JSMessageSource, WarningMessageLevel, exec, args, 0, url.string());
- printToStandardOut(WarningMessageLevel, exec, arguments, url);
+ printToStandardOut(WarningMessageLevel, exec, args, url);
}
void Console::reportException(ExecState* exec, JSValue* exception)
{
JSLock lock(false);
for (unsigned i = 0; i < args.size(); ++i)
- wrappedArguments[i] = JSInspectedObjectWrapper::wrap(exec, args[i]);
+ wrappedArguments[i] = JSInspectedObjectWrapper::wrap(exec, args.at(exec, i));
}
MessageSource source;
git://git.webkit.org / WebKit-https.git / commitdiff