JSActivation* activation;

unsigned numParameters;

ptrdiff_t firstParameterIndex;

unsigned numArguments;

Register* registers;

OwnArrayPtr<Register> registerArray;

Register* extraArguments;

OwnArrayPtr<bool> deletedArguments;

Register extraArgumentsFixedBuffer[4];

JSFunction* callee;

bool overrodeLength : 1;

bool overrodeCallee : 1;

public:

enum NoParametersType { NoParameters };

Arguments(CallFrame*);

Arguments(CallFrame*, NoParametersType);

virtual ~Arguments();

static const ClassInfo info;

virtual void markChildren(MarkStack&);

void fillArgList(ExecState*, MarkedArgumentBuffer&);

uint32_t numProvidedArguments(ExecState* exec) const

{

if (UNLIKELY(d->overrodeLength))

return get(exec, exec->propertyNames().length).toUInt32(exec);

return d->numArguments;

}

void copyToRegisters(ExecState* exec, Register* buffer, uint32_t maxSize);

void copyRegisters();

bool isTornOff() const { return d->registerArray; }

void setActivation(JSActivation* activation)

{

d->activation = activation;

d->registers = &activation->registerAt(0);

}

static PassRefPtr<Structure> createStructure(JSValue prototype)

{

return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount);

}

protected:

static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesMarkChildren | OverridesGetPropertyNames | JSObject::StructureFlags;

private:

void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);

virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);

virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);

virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);

virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);

virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);

virtual void put(ExecState*, unsigned propertyName, JSValue, PutPropertySlot&);

virtual bool deleteProperty(ExecState*, const Identifier& propertyName);

virtual bool deleteProperty(ExecState*, unsigned propertyName);

virtual const ClassInfo* classInfo() const { return &info; }

void init(CallFrame*);

OwnPtr<ArgumentsData> d;

{

function = callFrame->callee();

int numParameters = function->jsExecutable()->parameterCount();

argc = callFrame->argumentCount();

if (argc <= numParameters)

argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters;

else

argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters - argc;

argc -= 1; // - 1 to skip "this"

firstParameterIndex = -RegisterFile::CallFrameHeaderSize - numParameters;

: JSObject(callFrame->lexicalGlobalObject()->argumentsStructure())

, d(new ArgumentsData)

{

JSFunction* callee;

ptrdiff_t firstParameterIndex;

Register* argv;

int numArguments;

getArgumentsData(callFrame, callee, firstParameterIndex, argv, numArguments);

d->numParameters = callee->jsExecutable()->parameterCount();

d->firstParameterIndex = firstParameterIndex;

d->numArguments = numArguments;

d->activation = 0;

d->registers = callFrame->registers();

Register* extraArguments;

if (d->numArguments <= d->numParameters)

extraArguments = 0;

else {

unsigned numExtraArguments = d->numArguments - d->numParameters;

if (numExtraArguments > sizeof(d->extraArgumentsFixedBuffer) / sizeof(Register))

extraArguments = new Register[numExtraArguments];

else

extraArguments = d->extraArgumentsFixedBuffer;

for (unsigned i = 0; i < numExtraArguments; ++i)

extraArguments[i] = argv[d->numParameters + i];

}

d->extraArguments = extraArguments;

d->callee = callee;

d->overrodeLength = false;

d->overrodeCallee = false;

: JSObject(callFrame->lexicalGlobalObject()->argumentsStructure())

, d(new ArgumentsData)

{

ASSERT(!callFrame->callee()->jsExecutable()->parameterCount());

unsigned numArguments = callFrame->argumentCount() - 1;

d->numParameters = 0;

d->numArguments = numArguments;

d->activation = 0;

Register* extraArguments;

if (numArguments > sizeof(d->extraArgumentsFixedBuffer) / sizeof(Register))

extraArguments = new Register[numArguments];

else

extraArguments = d->extraArgumentsFixedBuffer;

Register* argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numArguments - 1;

for (unsigned i = 0; i < numArguments; ++i)

extraArguments[i] = argv[i];

d->extraArguments = extraArguments;

d->callee = callFrame->callee();

d->overrodeLength = false;

d->overrodeCallee = false;

{

ASSERT(!isTornOff());

if (!d->numParameters)

return;

int registerOffset = d->numParameters + RegisterFile::CallFrameHeaderSize;

size_t registerArraySize = d->numParameters;

Register* registerArray = new Register[registerArraySize];

memcpy(registerArray, d->registers - registerOffset, registerArraySize * sizeof(Register));

d->registerArray.set(registerArray);

d->registers = registerArray + registerOffset;

{

ASSERT(!d()->registerArray);

size_t numParametersMinusThis = d()->functionExecutable->generatedBytecode().m_numParameters - 1;

size_t numVars = d()->functionExecutable->generatedBytecode().m_numVars;

size_t numLocals = numVars + numParametersMinusThis;

if (!numLocals)

return;

int registerOffset = numParametersMinusThis + RegisterFile::CallFrameHeaderSize;

size_t registerArraySize = numLocals + RegisterFile::CallFrameHeaderSize;

Register* registerArray = copyRegisterArray(d()->registers - registerOffset, registerArraySize);

setRegisters(registerArray + registerOffset, registerArray);

if (arguments && !arguments->isTornOff())

static_cast<Arguments*>(arguments)->setActivation(this);