dmcallis
65a0592776
Source code drop for the Actionscript virtual machine in the Adobe Flash Player for December 2013
1641 lines
60 KiB
C++
1641 lines
60 KiB
C++
/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
|
|
/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
#include "avmplus.h"
|
|
|
|
namespace avmplus
|
|
{
|
|
|
|
void MethodEnv::argcError(int32_t argc)
|
|
{
|
|
MethodSignaturep ms = get_ms();
|
|
AvmAssert(!ms->argcOk(argc));
|
|
toplevel()->argumentErrorClass()->throwError(kWrongArgumentCountError,
|
|
core()->toErrorString(method),
|
|
core()->toErrorString(ms->requiredParamCount()),
|
|
core()->toErrorString(argc));
|
|
}
|
|
|
|
MethodEnv::MethodEnv(MethodInfo* method, ScopeChain* scope) :
|
|
method(method),
|
|
_scope(scope),
|
|
activationOrMCTable(0)
|
|
{
|
|
AvmAssert(method != NULL);
|
|
core()->exec->init(this);
|
|
|
|
if (method->declaringTraits() != this->vtable()->traits)
|
|
{
|
|
#ifdef AVMPLUS_VERBOSE
|
|
core()->console << "ERROR " << method->getMethodName() << " " << method->declaringTraits() << " " << this->vtable()->traits << "\n";
|
|
#endif
|
|
AvmAssertMsg(0, "(method->declaringTraits != vtable->traits)");
|
|
toplevel()->throwVerifyError(kCorruptABCError);
|
|
}
|
|
|
|
// activation info used to be created here, but is now created lazily
|
|
}
|
|
|
|
#ifdef DEBUGGER
|
|
void MethodEnv::debugEnter( const uint8_t* frame_sst,
|
|
CallStackNode* callstack,
|
|
FramePtr framep,
|
|
volatile intptr_t *eip)
|
|
{
|
|
AvmAssert(this != 0);
|
|
AvmAssert(callstack != 0);
|
|
callstack->init(this, framep, frame_sst, eip);
|
|
debugEnterInner();
|
|
}
|
|
|
|
void MethodEnv::debugEnterInner()
|
|
{
|
|
AvmAssert(this != 0);
|
|
AvmCore* core = this->core();
|
|
|
|
Sampler* s = core->get_sampler();
|
|
|
|
// this shouldn't ever be called unless there's a debugger
|
|
AvmAssert(core->debugger() != NULL);
|
|
Debugger* debugger = core->debugger();
|
|
if (debugger)
|
|
debugger->_debugMethod(this);
|
|
|
|
if (s)
|
|
s->sampleCheck();
|
|
|
|
// method_id can legitimately be -1 for activations, but we don't care about those here,
|
|
// so just ignore them.
|
|
const int32_t method_id = this->method->method_id();
|
|
if (method_id >= 0)
|
|
{
|
|
this->abcEnv()->invocationCount(method_id) += 1; // returns a reference, so this works
|
|
}
|
|
}
|
|
|
|
void MethodEnv::debugExit(CallStackNode* callstack)
|
|
{
|
|
AvmAssert(this != 0);
|
|
AvmAssert(callstack != 0);
|
|
AvmCore* core = this->core();
|
|
|
|
Sampler* s = core->get_sampler();
|
|
if (s != 0)
|
|
{
|
|
// do this before popping the stack, so that the time slice
|
|
// gets attributed to the function that is exiting
|
|
s->sampleCheck();
|
|
}
|
|
|
|
core->callStack = callstack->next();
|
|
|
|
// trigger a faked "line number changed" since we exited the function and are now back on the old line (well, almost)
|
|
if (core->callStack && core->callStack->linenum() > 0)
|
|
{
|
|
int32_t line = core->callStack->linenum();
|
|
core->callStack->set_linenum(-1);
|
|
Debugger* debugger = core->debugger();
|
|
if (debugger)
|
|
debugger->debugLine(line);
|
|
}
|
|
}
|
|
|
|
uint64_t MethodEnv::invocationCount() const
|
|
{
|
|
const int32_t method_id = this->method->method_id();
|
|
if (method_id < 0) return 0;
|
|
return this->abcEnv()->invocationCount(method_id);
|
|
}
|
|
#endif // DEBUGGER
|
|
|
|
void FASTCALL MethodEnv::nullcheckfail(Atom atom)
|
|
{
|
|
AvmAssert(AvmCore::isNullOrUndefined(atom));
|
|
|
|
// TypeError in ECMA
|
|
Toplevel* toplevel = this->toplevel();
|
|
GCRef<TypeErrorClass> error = toplevel->typeErrorClass();
|
|
if( error ){
|
|
error->throwError(
|
|
(atom == undefinedAtom) ? kConvertUndefinedToObjectError :
|
|
kConvertNullToObjectError);
|
|
} else {
|
|
toplevel->throwVerifyError(kCorruptABCError);
|
|
}
|
|
}
|
|
|
|
ArrayObject* MethodEnv::createRest(Atom* argv, int32_t argc)
|
|
{
|
|
// create arguments Array using argv[param_count..argc]
|
|
MethodSignaturep ms = get_ms();
|
|
const int32_t param_count = ms->param_count();
|
|
Atom* extra = argv + param_count + 1;
|
|
const int32_t extra_count = argc > param_count ? argc - param_count : 0;
|
|
return toplevel()->arrayClass()->newarray(extra, extra_count);
|
|
}
|
|
|
|
#if defined VMCFG_NANOJIT || defined VMCFG_AOT
|
|
|
|
Atom MethodEnv::getpropertyHelper(Atom obj, /* not const */ Multiname *multi, VTable *vtable, Atom index)
|
|
{
|
|
if (atomIsIntptr(index) && atomCanBeInt32(index))
|
|
{
|
|
return getpropertylate_i(obj, (int32_t)atomGetIntptr(index));
|
|
}
|
|
|
|
if (atomKind(index) == kDoubleType)
|
|
{
|
|
return getpropertylate_d(obj, AvmCore::atomToDouble(index));
|
|
}
|
|
|
|
if (AvmCore::isObject(index))
|
|
{
|
|
ScriptObject* i = AvmCore::atomToScriptObject(index);
|
|
if (i->traits() == core()->traits.qName_itraits)
|
|
{
|
|
QNameObject* qname = (QNameObject*) i;
|
|
qname->getMultiname(*multi);
|
|
}
|
|
else if(!multi->isRtns() && AvmCore::isDictionary(obj))
|
|
{
|
|
return AvmCore::atomToScriptObject(obj)->getAtomProperty(index);
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core()->intern(index));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core()->intern(index));
|
|
}
|
|
|
|
return toplevel()->getproperty(obj, multi, vtable);
|
|
}
|
|
|
|
void MethodEnv::initpropertyHelper(Atom obj, /* not const */ Multiname *multi, Atom value, VTable *vtable, Atom index)
|
|
{
|
|
if (atomIsIntptr(index) && atomCanBeInt32(index))
|
|
{
|
|
setpropertylate_i(obj, (int32_t)atomGetIntptr(index), value);
|
|
return;
|
|
}
|
|
|
|
if (atomKind(index) == kDoubleType)
|
|
{
|
|
setpropertylate_d(obj, AvmCore::atomToDouble(index), value);
|
|
return;
|
|
}
|
|
|
|
if (AvmCore::isObject(index))
|
|
{
|
|
ScriptObject* i = AvmCore::atomToScriptObject(index);
|
|
if (i->traits() == core()->traits.qName_itraits)
|
|
{
|
|
QNameObject* qname = (QNameObject*) i;
|
|
qname->getMultiname(*multi);
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core()->intern(index));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core()->intern(index));
|
|
}
|
|
|
|
initproperty(obj, multi, value, vtable);
|
|
}
|
|
|
|
void MethodEnv::setpropertyHelper(Atom obj, /* not const */ Multiname *multi, Atom value, VTable *vtable, Atom index)
|
|
{
|
|
// the positive-integer case is inlined into setprop_index in jit-calls.h,
|
|
// this handles the negative case
|
|
if (atomIsIntptr(index) && atomCanBeInt32(index))
|
|
{
|
|
setpropertylate_i(obj, (int32_t)atomGetIntptr(index), value);
|
|
return;
|
|
}
|
|
|
|
if (atomKind(index) == kDoubleType)
|
|
{
|
|
setpropertylate_d(obj, AvmCore::atomToDouble(index), value);
|
|
return;
|
|
}
|
|
|
|
if (AvmCore::isObject(index))
|
|
{
|
|
ScriptObject* i = AvmCore::atomToScriptObject(index);
|
|
if (i->traits() == core()->traits.qName_itraits)
|
|
{
|
|
QNameObject* qname = (QNameObject*) i;
|
|
qname->getMultiname(*multi);
|
|
}
|
|
else if(!multi->isRtns() && AvmCore::isDictionary(obj))
|
|
{
|
|
AvmCore::atomToScriptObject(obj)->setAtomProperty(index, value);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core()->intern(index));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core()->intern(index));
|
|
}
|
|
|
|
toplevel()->setproperty(obj, multi, value, vtable);
|
|
}
|
|
|
|
Atom MethodEnv::delpropertyHelper(Atom obj, /* not const */ Multiname *multi, Atom index)
|
|
{
|
|
AvmCore* core = this->core();
|
|
|
|
if (AvmCore::isObject(obj) && AvmCore::isObject(index))
|
|
{
|
|
if (AvmCore::isXMLList(index) )
|
|
{
|
|
// Error according to E4X spec, section 11.3.1
|
|
toplevel()->throwTypeError(kDeleteTypeError, core->toErrorString(toplevel()->toTraits(index)));
|
|
}
|
|
ScriptObject* i = AvmCore::atomToScriptObject(index);
|
|
if (i->traits() == core->traits.qName_itraits)
|
|
{
|
|
QNameObject* qname = (QNameObject*) i;
|
|
qname->getMultiname(*multi);
|
|
}
|
|
else if(!multi->isRtns() && AvmCore::isDictionary(obj))
|
|
{
|
|
bool res = AvmCore::atomToScriptObject(obj)->deleteAtomProperty(index);
|
|
return res ? trueAtom : falseAtom;
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core->intern(index));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
multi->setName(core->intern(index));
|
|
}
|
|
|
|
return delproperty(obj, multi);
|
|
}
|
|
|
|
void MethodEnv::initMultinameLateForDelete(Multiname& name, Atom index)
|
|
{
|
|
AvmCore *core = this->core();
|
|
|
|
if (AvmCore::isObject(index))
|
|
{
|
|
if (AvmCore::isXMLList(index))
|
|
{
|
|
// Error according to E4X spec, section 11.3.1
|
|
toplevel()->throwTypeError(kDeleteTypeError, core->toErrorString(toplevel()->toTraits(index)));
|
|
}
|
|
|
|
ScriptObject* i = AvmCore::atomToScriptObject(index);
|
|
if (i->traits() == core->traits.qName_itraits)
|
|
{
|
|
QNameObject* qname = (QNameObject*) i;
|
|
bool attr = name.isAttr();
|
|
qname->getMultiname(name);
|
|
if (attr)
|
|
name.setAttr(attr);
|
|
return;
|
|
}
|
|
}
|
|
|
|
name.setName(core->intern(index));
|
|
}
|
|
#endif
|
|
|
|
ScriptObject* MethodEnv::newcatch(Traits* traits)
|
|
{
|
|
AvmCore* core = this->core();
|
|
Toplevel* toplevel = this->toplevel();
|
|
if (traits == core->traits.object_itraits)
|
|
{
|
|
// don't need temporary vtable. this is a scope for a finally clause
|
|
// todo: asc shouldn't even call OP_newcatch in a finally clause
|
|
return toplevel->objectClass->construct();
|
|
}
|
|
else
|
|
{
|
|
VTable* vt = core->newVTable(traits, NULL, toplevel);
|
|
ScopeChain* catchScope = this->scope()->cloneWithNewVTable(core->GetGC(), vt, this->abcEnv());
|
|
vt->resolveSignatures(catchScope);
|
|
return core->newObject(vt, NULL);
|
|
}
|
|
}
|
|
|
|
#ifdef VMCFG_NANOJIT
|
|
ArrayObject* MethodEnv::createArgumentsHelper(int argc, uint32_t *ap)
|
|
{
|
|
// create arguments using argv[1..argc].
|
|
// Even tho E3 says create an Object, E4 says create an Array so thats what we will do.
|
|
AvmAssert(argc >= 0);
|
|
MMgc::GC::AllocaAutoPtr _atomv;
|
|
Atom* atomv = (Atom*) avmStackAllocArray(core(), _atomv, (argc+1), sizeof(Atom));
|
|
method->getMethodSignature()->boxArgs(core(), argc, ap, atomv);
|
|
return createArguments(atomv, argc);
|
|
}
|
|
|
|
ArrayObject* MethodEnv::createRestHelper(int argc, uint32_t *ap)
|
|
{
|
|
// create rest Array using argv[param_count..argc]
|
|
MethodSignaturep ms = get_ms();
|
|
const int rest_offset = ms->rest_offset();
|
|
union {
|
|
char* extra_8;
|
|
Atom* extra;
|
|
};
|
|
extra_8 = (char*)ap + rest_offset;
|
|
const int param_count = ms->param_count();
|
|
const int extra_count = argc > param_count ? argc - param_count : 0;
|
|
return toplevel()->arrayClass()->newarray(extra, extra_count);
|
|
}
|
|
#endif // VMCFG_NANOJIT
|
|
|
|
// Keep in sync with related methods. See comments at Toplevel::getproperty.
|
|
/*bool*/ int32_t MethodEnv::haspropertylate_u(Atom obj, uint32_t index) const
|
|
{
|
|
#ifdef VMCFG_FLOAT
|
|
if (AvmCore::isFloat4(obj))
|
|
{
|
|
// See FIXME in Toplevel::getproperty() - do not absorb non-integer values outside
|
|
// the range [0,2^32-2], but let them pass through to the prototype lookup.
|
|
if (index != 4294967295U)
|
|
return int32_t(index <= 3);
|
|
}
|
|
#endif
|
|
// Primitive types are not dynamic, so we can go directly
|
|
// to their __proto__ object.
|
|
ScriptObject *o = (atomKind(obj) == kObjectType) ?
|
|
AvmCore::atomToScriptObject(obj) :
|
|
this->toplevel()->toPrototype(obj);
|
|
bool present = o->hasUintProperty(index);
|
|
return (int32_t)present;
|
|
}
|
|
|
|
// Keep in sync with related methods. See comments at Toplevel::getproperty.
|
|
/*bool*/ int32_t MethodEnv::haspropertylate_i(Atom obj, int32_t index) const
|
|
{
|
|
#ifdef VMCFG_FLOAT
|
|
if (AvmCore::isFloat4(obj))
|
|
{
|
|
// See FIXME in Toplevel::getproperty() - do not absorb non-integer values outside
|
|
// the range [0,2^32-2], but let them pass through to the prototype lookup.
|
|
if (index >= 0)
|
|
return int32_t(index <= 3);
|
|
}
|
|
#endif
|
|
// Primitive types are not dynamic, so we can go directly
|
|
// to their __proto__ object.
|
|
ScriptObject *o = (atomKind(obj) == kObjectType) ?
|
|
AvmCore::atomToScriptObject(obj) :
|
|
this->toplevel()->toPrototype(obj);
|
|
bool present;
|
|
if (index >= 0) {
|
|
present = o->hasUintProperty((uint32_t)index);
|
|
} else {
|
|
Atom interned = this->core()->internInt(index)->atom();
|
|
present = o->hasAtomProperty(interned);
|
|
}
|
|
return (int32_t)present;
|
|
}
|
|
|
|
// Numeric property name. Except for float4, no fixed bindings have numeric names.
|
|
// Keep in sync with related methods. See comments at Toplevel::getproperty.
|
|
Atom MethodEnv::getpropertylate_i(Atom obj, int32_t index) const
|
|
{
|
|
if (atomKind(obj) == kObjectType)
|
|
{
|
|
if (index >= 0)
|
|
{
|
|
// Try dynamic lookup on instance. Even if the traits are sealed,
|
|
// we might need to search the prototype chain.
|
|
return AvmCore::atomToScriptObject(obj)->getUintProperty(index);
|
|
}
|
|
else
|
|
{
|
|
// Negative - we must intern the integer.
|
|
return AvmCore::atomToScriptObject(obj)->getAtomProperty(this->core()->internInt(index)->atom());
|
|
}
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if (AvmCore::isFloat4(obj))
|
|
{
|
|
if (index >= 0 && index <= 3){
|
|
float4_t f4 = AvmCore::atomToFloat4(obj);
|
|
float* pf4 = reinterpret_cast<float*>(&f4);
|
|
return core()->floatToAtom(pf4[index]);
|
|
}
|
|
// See FIXME in Toplevel::getproperty() - do not absorb non-integer values outside
|
|
// the range [0,2^32-2], but let them pass through to the prototype lookup.
|
|
if (index >= 0)
|
|
toplevel()->throwRangeError(kOutOfRangeError, this->core()->internInt(index));
|
|
}
|
|
#endif
|
|
// *No* else clause
|
|
{
|
|
// Primitive types are not dynamic, so we can go directly
|
|
// to their __proto__ object.
|
|
AvmCore* core = this->core();
|
|
Toplevel *toplevel = this->toplevel();
|
|
ScriptObject *protoObject = toplevel->toPrototype(obj);
|
|
return protoObject->ScriptObject::getStringPropertyFromProtoChain(core->internInt(index), protoObject, toplevel->toTraits(obj));
|
|
}
|
|
}
|
|
|
|
// Numeric property name. Except for float4, no fixed bindings have numeric names.
|
|
// Keep in sync with related methods. See comments at Toplevel::getproperty.
|
|
Atom MethodEnv::getpropertylate_u(Atom obj, uint32_t index) const
|
|
{
|
|
if (atomKind(obj) == kObjectType)
|
|
{
|
|
// Try dynamic lookup on instance. Even if the traits are sealed,
|
|
// we might need to search the prototype chain.
|
|
return AvmCore::atomToScriptObject(obj)->getUintProperty(index);
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if (AvmCore::isFloat4(obj))
|
|
{
|
|
if (index <= 3)
|
|
{
|
|
float4_t f4 = AvmCore::atomToFloat4(obj);
|
|
float* pf4 = reinterpret_cast<float*>(&f4);
|
|
return core()->floatToAtom(pf4[index]);
|
|
}
|
|
// See FIXME in Toplevel::getproperty() - do not absorb non-integer values outside
|
|
// the range [0,2^32-2], but let them pass through to the prototype lookup.
|
|
if (index != 4294967295U)
|
|
toplevel()->throwRangeError(kOutOfRangeError, this->core()->internInt(index));
|
|
}
|
|
#endif
|
|
// *No* else clause
|
|
{
|
|
// Primitive types are not dynamic, so we can go directly
|
|
// to their __proto__ object.
|
|
AvmCore* core = this->core();
|
|
Toplevel *toplevel = this->toplevel();
|
|
ScriptObject *protoObject = toplevel->toPrototype(obj);
|
|
return protoObject->ScriptObject::getStringPropertyFromProtoChain(core->internUint32(index), protoObject, toplevel->toTraits(obj));
|
|
}
|
|
}
|
|
|
|
// Numeric property name. Except for float4, no fixed bindings have numeric names.
|
|
// Keep in sync with related methods. See comments at Toplevel::getproperty.
|
|
Atom MethodEnv::getpropertylate_d(Atom obj, double index) const
|
|
{
|
|
if (atomKind(obj) == kObjectType)
|
|
{
|
|
// Use signed conversion, as it is faster on most platforms.
|
|
int32_t index_i = int32_t(index);
|
|
if (double(index_i) == index && index_i >= 0)
|
|
{
|
|
// Try dynamic lookup on instance. Even if the traits are sealed,
|
|
// we might need to search the prototype chain.
|
|
return AvmCore::atomToScriptObject(obj)->getUintProperty(uint32_t(index_i));
|
|
}
|
|
else
|
|
{
|
|
// Negative, fractional, or out of range, so we must intern the double.
|
|
// Sufficiently large non-negative numbers will also take this slower path,
|
|
// but we know an exception will be thrown (Vector) or a dense representation
|
|
// will not be used (Array, others).
|
|
return AvmCore::atomToScriptObject(obj)->getAtomProperty(this->core()->internDouble(index)->atom());
|
|
}
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if (AvmCore::isFloat4(obj))
|
|
{
|
|
float4_t f4 = AvmCore::atomToFloat4(obj);
|
|
float* pf4 = reinterpret_cast<float*>(&f4);
|
|
if (index == 0.0) return core()->floatToAtom(pf4[0]);
|
|
if (index == 1.0) return core()->floatToAtom(pf4[1]);
|
|
if (index == 2.0) return core()->floatToAtom(pf4[2]);
|
|
if (index == 3.0) return core()->floatToAtom(pf4[3]);
|
|
// See FIXME in Toplevel::getproperty() - do not absorb non-integer values outside
|
|
// the range [0,2^32-2], but let them pass through to the prototype lookup.
|
|
if (index >= 0.0 && index <= 4294967294.0) {
|
|
uint32_t u = uint32_t(index);
|
|
if (double(u) == index)
|
|
toplevel()->throwRangeError(kOutOfRangeError, this->core()->internDouble(index));
|
|
}
|
|
}
|
|
#endif
|
|
// *No* else clause
|
|
{
|
|
// Primitive types are not dynamic, so we can go directly
|
|
// to their __proto__ object.
|
|
AvmCore* core = this->core();
|
|
Toplevel *toplevel = this->toplevel();
|
|
ScriptObject *protoObject = toplevel->toPrototype(obj);
|
|
return protoObject->ScriptObject::getStringPropertyFromProtoChain(core->internDouble(index), protoObject, toplevel->toTraits(obj));
|
|
}
|
|
}
|
|
|
|
ScriptObject* MethodEnv::finddef(const Multiname* multiname) const
|
|
{
|
|
// getting toplevel() is slightly more expensive than it used to be (more indirection)...
|
|
// so only extract in the (rare) event of an exception
|
|
|
|
AbcEnv* abcEnv = this->abcEnv();
|
|
AvmCore* core = abcEnv->core();
|
|
ScriptEnv* script = core->domainMgr()->findScriptEnvInAbcEnvByMultiname(abcEnv, *multiname);
|
|
if (script == (ScriptEnv*)BIND_AMBIGUOUS)
|
|
this->toplevel()->throwReferenceError(kAmbiguousBindingError, multiname);
|
|
|
|
if (script == (ScriptEnv*)BIND_NONE)
|
|
this->toplevel()->throwReferenceError(kUndefinedVarError, multiname);
|
|
|
|
ScriptObject* global = script->global;
|
|
if (!global)
|
|
{
|
|
global = script->initGlobal();
|
|
script->coerceEnter(global->atom());
|
|
}
|
|
return global;
|
|
}
|
|
|
|
/*static*/ ScopeChain* ScriptEnv::createScriptScope(const ScopeTypeChain* stc, VTable* _vtable, AbcEnv* _abcEnv)
|
|
{
|
|
AvmCore* core = _vtable->core();
|
|
// NOTE the namespace here is the default xml namespaces. we use the caller's public
|
|
return ScopeChain::create(core->GetGC(), _vtable, _abcEnv, stc, NULL, core->findPublicNamespace());
|
|
}
|
|
|
|
ScriptObject* ScriptEnv::initGlobal()
|
|
{
|
|
AvmAssert(this->global == NULL);
|
|
// object not defined yet. define it by running the script that exports it
|
|
this->vtable()->resolveSignatures(this->scope());
|
|
// resolving the vtable also resolves the traits, if necessary
|
|
ObjectClass* const objectClass = this->toplevel()->objectClass;
|
|
ScriptObject* const delegate = objectClass ? objectClass->prototypePtr() : NULL;
|
|
global = this->core()->newObject(this->vtable(), delegate);
|
|
return global;
|
|
}
|
|
|
|
ScriptObject* MethodEnv::op_newobject(Atom* sp, int argc) const
|
|
{
|
|
// pre-size the hashtable since we know how many vars are coming
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
VTable* object_ivtable = toplevel->objectClass->ivtable();
|
|
|
|
ScriptObject* o = ScriptObject::create(core->GetGC(), object_ivtable, toplevel->objectClass->prototypePtr(), argc);
|
|
|
|
for (; argc-- > 0; sp -= 2)
|
|
{
|
|
Atom name = sp[-1];
|
|
// verifier has stated this is a String, but we may see nullStringAtom
|
|
if (!AvmCore::isString(name))
|
|
toplevel->throwTypeError(kConvertNullToObjectError);
|
|
|
|
name = core->internString(name)->atom();
|
|
o->setAtomProperty(name, sp[0]);
|
|
}
|
|
return o;
|
|
}
|
|
|
|
|
|
|
|
Atom MethodEnv::nextname(Atom objAtom, int index) const
|
|
{
|
|
// Handle special case inputs;
|
|
// bad index returns null,
|
|
// null object throws error.
|
|
if (index <= 0)
|
|
{
|
|
return nullStringAtom;
|
|
}
|
|
|
|
if (AvmCore::isNullOrUndefined(objAtom))
|
|
{
|
|
toplevel()->throwTypeError(
|
|
(objAtom == undefinedAtom) ? kConvertUndefinedToObjectError :
|
|
kConvertNullToObjectError);
|
|
}
|
|
|
|
switch (atomKind(objAtom))
|
|
{
|
|
case kObjectType:
|
|
return AvmCore::atomToScriptObject(objAtom)->nextName(index);
|
|
case kNamespaceType:
|
|
return AvmCore::atomToNamespace(objAtom)->nextName(this->core(), index);
|
|
#ifdef VMCFG_FLOAT
|
|
case kSpecialBibopType:
|
|
if (AvmCore::isFloat4(objAtom) && index <= 4)
|
|
return atomFromIntptrValue(index-1);
|
|
// Else fall through
|
|
#endif // VMCFG_FLOAT
|
|
default:
|
|
ScriptObject* proto = toplevel()->toPrototype(objAtom); // cn: types like Number are sealed, but their prototype could have dynamic properties
|
|
return proto ? proto->nextName(index) : undefinedAtom;
|
|
}
|
|
}
|
|
|
|
Atom MethodEnv::nextvalue(Atom objAtom, int index) const
|
|
{
|
|
// Handle special case inputs;
|
|
// bad index returns undefined,
|
|
// null object throws error.
|
|
if (index <= 0)
|
|
{
|
|
return undefinedAtom;
|
|
}
|
|
|
|
if (AvmCore::isNullOrUndefined(objAtom))
|
|
{
|
|
toplevel()->throwTypeError(
|
|
(objAtom == undefinedAtom) ? kConvertUndefinedToObjectError :
|
|
kConvertNullToObjectError);
|
|
}
|
|
|
|
switch (atomKind(objAtom))
|
|
{
|
|
case kObjectType:
|
|
return AvmCore::atomToScriptObject(objAtom)->nextValue(index);
|
|
case kNamespaceType:
|
|
return AvmCore::atomToNamespace(objAtom)->nextValue(index);
|
|
case kSpecialBibopType:
|
|
#ifdef VMCFG_FLOAT
|
|
if (AvmCore::isFloat4(objAtom) && index <= 4)
|
|
{
|
|
float* f4p = (float*)atomPtr(objAtom);
|
|
return toplevel()->core()->floatToAtom( f4p[index-1] );
|
|
}
|
|
// Else fall through
|
|
#endif
|
|
default:
|
|
ScriptObject* proto = toplevel()->toPrototype(objAtom);
|
|
return (proto ? proto->nextValue(index) : undefinedAtom);
|
|
}
|
|
}
|
|
|
|
int MethodEnv::hasnext(Atom objAtom, int index) const
|
|
{
|
|
if (index < 0)
|
|
return 0;
|
|
|
|
if (!AvmCore::isNullOrUndefined(objAtom))
|
|
{
|
|
switch (atomKind(objAtom))
|
|
{
|
|
case kObjectType:
|
|
return AvmCore::atomToScriptObject(objAtom)->nextNameIndex(index);
|
|
case kNamespaceType:
|
|
return AvmCore::atomToNamespace(objAtom)->nextNameIndex(index);
|
|
#ifdef VMCFG_FLOAT
|
|
case kSpecialBibopType:
|
|
if (AvmCore::isFloat4(objAtom) && index <= 3)
|
|
return index + 1;
|
|
// Else fall through
|
|
#endif // VMCFG_FLOAT
|
|
default:
|
|
ScriptObject* proto = toplevel()->toPrototype(objAtom);
|
|
int nextIndex = ( proto ? proto->nextNameIndex(index) : 0);
|
|
return nextIndex;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int32_t MethodEnv::hasnextproto(Atom& objAtom, int& index) const
|
|
{
|
|
if (index < 0)
|
|
return 0;
|
|
|
|
ScriptObject *delegate = NULL;
|
|
|
|
if (!AvmCore::isNullOrUndefined(objAtom))
|
|
{
|
|
switch (atomKind(objAtom))
|
|
{
|
|
case kObjectType:
|
|
{
|
|
ScriptObject *object = AvmCore::atomToScriptObject(objAtom);
|
|
delegate = object->getDelegate();
|
|
index = object->nextNameIndex(index);
|
|
}
|
|
break;
|
|
case kNamespaceType:
|
|
{
|
|
index = AvmCore::atomToNamespace(objAtom)->nextNameIndex(index);
|
|
delegate = toplevel()->namespaceClass()->prototypePtr();
|
|
}
|
|
break;
|
|
#ifdef VMCFG_FLOAT
|
|
case kSpecialBibopType:
|
|
if (AvmCore::isFloat4(objAtom) && index <= 3)
|
|
{
|
|
index++;
|
|
return 1; // I.e. "true"; but hasnextproto() traditionally returns int
|
|
}
|
|
// Else fall through
|
|
#endif // VMCFG_FLOAT
|
|
default:
|
|
{
|
|
ScriptObject* proto = toplevel()->toPrototype(objAtom);
|
|
delegate = proto ? proto->getDelegate() : NULL;
|
|
index = ( proto ? proto->nextNameIndex(index) : 0);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
index = 0;
|
|
}
|
|
|
|
while (index == 0 && delegate != NULL)
|
|
{
|
|
// Advance to next object on prototype chain
|
|
ScriptObject *object = delegate;
|
|
objAtom = object->atom();
|
|
delegate = object->getDelegate();
|
|
index = object->nextNameIndex(index);
|
|
}
|
|
|
|
if (index == 0)
|
|
{
|
|
// If we're done, set object local to null
|
|
objAtom = nullObjectAtom;
|
|
}
|
|
|
|
return index != 0;
|
|
}
|
|
|
|
// see 13.2 creating function objects
|
|
ClassClosure* MethodEnv::newfunction(MethodInfo *function, Atom* scopes) const
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
FunctionClass* functionClass = toplevel->_functionClass; // can't use functionClass(), might not be inited yet
|
|
VTable* fvtable = functionClass->ivtable();
|
|
VTable* object_ivtable = toplevel->objectClass->ivtable();
|
|
|
|
AvmAssert(fvtable->ivtable == NULL || fvtable->ivtable == object_ivtable);
|
|
fvtable->ivtable = object_ivtable;
|
|
AvmAssert(fvtable->linked);
|
|
|
|
const ScopeTypeChain* fstc = function->declaringScope();
|
|
// functions should never have 'extra' scopes
|
|
AvmAssert(fstc->size == fstc->fullsize);
|
|
|
|
MMgc::GC* gc = core->GetGC();
|
|
ScopeChain* outer = scope();
|
|
ScopeChain* fscope = ScopeChain::create(gc, fvtable, abcEnv(), fstc, outer, core->dxns());
|
|
for (int i=outer->getSize(), n=fscope->getSize(); i < n; i++)
|
|
{
|
|
fscope->setScope(gc, i, *scopes++);
|
|
}
|
|
|
|
FunctionEnv* fenv = FunctionEnv::create(gc, function, fscope);
|
|
FunctionObject* c = FunctionObject::create(gc, fvtable, fenv);
|
|
c->setDelegate(functionClass->prototypePtr());
|
|
|
|
c->createVanillaPrototype();
|
|
c->prototypePtr()->setStringProperty(core->kconstructor, c->atom());
|
|
c->prototypePtr()->setStringPropertyIsEnumerable(core->kconstructor, false);
|
|
|
|
fenv->closure = c;
|
|
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* given a classInfo, create a new ClassClosure object and return it on the stack.
|
|
*/
|
|
|
|
ClassClosure* MethodEnv::newclass(Traits* ctraits,
|
|
ClassClosure *base,
|
|
ScopeChain* outer,
|
|
Atom* scopes) const
|
|
{
|
|
AvmCore* core = this->core();
|
|
// adds clarity to what is usually just global$init()
|
|
SAMPLE_FRAME("[newclass]", core);
|
|
|
|
MMgc::GC* gc = core->GetGC();
|
|
Toplevel* toplevel = this->toplevel();
|
|
|
|
Traits* itraits = ctraits->itraits;
|
|
const BuiltinType bt = Traits::getBuiltinType(itraits);
|
|
if (bt == BUILTIN_object)
|
|
return toplevel->objectClass;
|
|
if (bt == BUILTIN_class)
|
|
return toplevel->_classClass;
|
|
|
|
AbcEnv* abcEnv = this->abcEnv();
|
|
|
|
// finish resolving the base class
|
|
if (!base && itraits->base)
|
|
{
|
|
// class has a base but no base object was provided
|
|
GCRef<TypeErrorClass> error = toplevel->typeErrorClass();
|
|
if (error)
|
|
error->throwError(kConvertNullToObjectError);
|
|
else
|
|
toplevel->throwTypeError(kCorruptABCError);
|
|
}
|
|
|
|
// have to use local variables for CodeWarrior
|
|
Traits* baseIvtableTraits = base ? base->ivtable()->traits : 0;
|
|
Traits* itraitsBase = itraits->base;
|
|
// make sure the traits of the base vtable matches the base traits
|
|
if (!((base == NULL && itraits->base == NULL) || (base != NULL && itraitsBase == baseIvtableTraits)))
|
|
{
|
|
GCRef<VerifyErrorClass> error = toplevel->verifyErrorClass();
|
|
if (error)
|
|
error->throwError(kInvalidBaseClassError);
|
|
else
|
|
toplevel->throwTypeError(kCorruptABCError);
|
|
}
|
|
|
|
VTable* ivtable = core->newVTable(itraits, base ? base->ivtable() : NULL, toplevel);
|
|
|
|
VTable* class_ivtable = toplevel->_classClass->ivtable();
|
|
VTable* cvtable = core->newVTable(ctraits, class_ivtable, toplevel);
|
|
|
|
// class scopechain = [..., class]
|
|
AvmAssert(ctraits->init != NULL);
|
|
ScopeChain* cscope = ScopeChain::create(gc, cvtable, abcEnv, ctraits->init->declaringScope(), outer, core->dxns());
|
|
int i = outer->getSize();
|
|
for (int n=cscope->getSize(); i < n; i++)
|
|
{
|
|
cscope->setScope(gc, i, *scopes++);
|
|
}
|
|
|
|
AvmAssert(itraits->init != NULL);
|
|
ScopeChain* iscope = ScopeChain::create(gc, ivtable, abcEnv, itraits->init->declaringScope(), cscope, core->dxns());
|
|
ivtable->resolveSignatures(iscope);
|
|
|
|
cvtable->ivtable = ivtable;
|
|
cvtable->resolveSignatures(cscope);
|
|
|
|
CreateClassClosureProc createClassClosure = cvtable->traits->getCreateClassClosureProc();
|
|
AvmAssert(createClassClosure != NULL);
|
|
ClassClosure* cc = (*createClassClosure)(cvtable);
|
|
|
|
if (cc->prototypePtr())
|
|
{
|
|
// C.prototype.__proto__ = Base.prototype
|
|
if (base != NULL)
|
|
cc->prototypePtr()->setDelegate(base->prototypePtr());
|
|
|
|
// C.prototype.constructor = C {DontEnum}
|
|
cc->initPrototypeConstructor();
|
|
}
|
|
|
|
AvmAssert(i == iscope->getSize()-1);
|
|
iscope->setScope(gc, i, cc->atom());
|
|
|
|
AvmAssert(toplevel->_classClass != NULL);
|
|
cc->setDelegate(toplevel->_classClass->prototypePtr());
|
|
|
|
cvtable->init->coerceEnter(cc->atom()); // ignore result
|
|
|
|
return cc;
|
|
}
|
|
|
|
void MethodEnv::initproperty(Atom obj, const Multiname* multiname, Atom value, VTable* vtable) const
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
|
|
Traitsp declarer = NULL;
|
|
Binding b = toplevel->getBindingAndDeclarer(vtable->traits, *multiname, declarer);
|
|
|
|
if (AvmCore::bindingKind(b) == BKIND_CONST)
|
|
{
|
|
if (this->method != declarer->init)
|
|
toplevel->throwReferenceError(kConstWriteError, multiname, vtable->traits);
|
|
|
|
b = AvmCore::makeSlotBinding(AvmCore::bindingToSlotId(b), BKIND_VAR);
|
|
}
|
|
toplevel->setproperty_b(obj, multiname, value, vtable, b);
|
|
}
|
|
|
|
void MethodEnv::setpropertylate_i(Atom obj, int32_t index, Atom value) const
|
|
{
|
|
if (AvmCore::isObject(obj))
|
|
{
|
|
ScriptObject* o = AvmCore::atomToScriptObject(obj);
|
|
if (index >= 0)
|
|
{
|
|
o->setUintProperty(index, value);
|
|
}
|
|
else
|
|
{
|
|
// negative index - we must intern the integer
|
|
o->setAtomProperty(this->core()->internInt(index)->atom(), value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// obj represents a primitive Number, Boolean, int, or String, and primitives
|
|
// are sealed and final. Cannot add dynamic vars to them.
|
|
|
|
// throw a ReferenceError exception Property not found and could not be created.
|
|
Multiname tempname(core()->getPublicNamespace(method->pool()), core()->internInt(index));
|
|
toplevel()->throwReferenceError(kWriteSealedError, &tempname, toplevel()->toTraits(obj));
|
|
}
|
|
}
|
|
|
|
void MethodEnv::setpropertylate_u(Atom obj, uint32_t index, Atom value) const
|
|
{
|
|
if (AvmCore::isObject(obj))
|
|
{
|
|
AvmCore::atomToScriptObject(obj)->setUintProperty(index, value);
|
|
}
|
|
else
|
|
{
|
|
// obj represents a primitive Number, Boolean, int, or String, and primitives
|
|
// are sealed and final. Cannot add dynamic vars to them.
|
|
|
|
// throw a ReferenceError exception Property not found and could not be created.
|
|
Multiname tempname(core()->getPublicNamespace(method->pool()), core()->internUint32(index));
|
|
toplevel()->throwReferenceError(kWriteSealedError, &tempname, toplevel()->toTraits(obj));
|
|
}
|
|
}
|
|
|
|
void MethodEnv::setpropertylate_d(Atom obj, double index, Atom value) const
|
|
{
|
|
if (AvmCore::isObject(obj))
|
|
{
|
|
ScriptObject* o = AvmCore::atomToScriptObject(obj);
|
|
|
|
// Use signed conversion, as it is faster on most platforms.
|
|
// We do not allocate objects large enough for an integral value
|
|
// that will not fit an int32 to index a vector or dense array,
|
|
// thus we'd have to use a string property name anyway in the
|
|
// cases where this conversion fails.
|
|
int32_t index_i = int32_t(index);
|
|
if (double(index_i) == index && index_i >= 0)
|
|
{
|
|
o->setUintProperty(uint32_t(index_i), value);
|
|
return;
|
|
}
|
|
|
|
// On the face of it, it should be sufficient to fall back to using
|
|
// setAtomProperty() here. Unfortunately, due to former differences
|
|
// in the way that setUintProperty() and setAtomProperty() handled
|
|
// out-of-range indices, a RangeError might have been thrown where
|
|
// setAtomProperty() would have thrown a ReferenceError. We have to
|
|
// preserve the distinct code paths so that the SWF10 compatibility
|
|
// logic can distinguish these cases.
|
|
|
|
// Try unsigned conversion.
|
|
uint32_t index_u = uint32_t(index);
|
|
if (double(index_u) == index)
|
|
{
|
|
o->setUintProperty(index_u, value);
|
|
return;
|
|
}
|
|
|
|
// Negative, fractional, or out of range, so we must intern the double.
|
|
// Sufficiently large non-negative numbers will also take this slower path,
|
|
// but we know an exception will be thrown (Vector) or a dense representation
|
|
// will not be used (Array, others).
|
|
o->setAtomProperty(this->core()->internDouble(index)->atom(), value);
|
|
}
|
|
else
|
|
{
|
|
// obj represents a primitive Number, Boolean, int, or String, and primitives
|
|
// are sealed and final. Cannot add dynamic vars to them.
|
|
|
|
// throw a ReferenceError exception Property not found and could not be created.
|
|
Multiname tempname(core()->getPublicNamespace(method->pool()), core()->internDouble(index));
|
|
toplevel()->throwReferenceError(kWriteSealedError, &tempname, toplevel()->toTraits(obj));
|
|
}
|
|
}
|
|
|
|
#ifdef VMCFG_FLOAT
|
|
void MethodEnv::setpropertylate_f(Atom obj, float index_f, Atom value) const
|
|
{
|
|
if (AvmCore::isObject(obj))
|
|
{
|
|
ScriptObject* o = AvmCore::atomToScriptObject(obj);
|
|
|
|
// Use signed conversion, as it is faster on most platforms.
|
|
// We do not allocate objects large enough for an integral value
|
|
// that will not fit an int32 to index a vector or dense array,
|
|
// thus we'd have to use a string property name anyway in the
|
|
// cases where this conversion fails.
|
|
int32_t index_i = int32_t(index_f);
|
|
if (float(index_i) == index_f && index_i >= 0)
|
|
{
|
|
o->setUintProperty(uint32_t(index_i), value);
|
|
return;
|
|
}
|
|
|
|
// No need to worry about SWF10 compatibility (like setpropertylate_d does)
|
|
|
|
// Negative, fractional, or out of range, so we must intern the float.
|
|
// Sufficiently large non-negative numbers will also take this slower path,
|
|
// but we know an exception will be thrown (Vector) or a dense representation
|
|
// will not be used (Array, others).
|
|
o->setAtomProperty(this->core()->internFloat(index_f)->atom(), value);
|
|
}
|
|
else
|
|
{
|
|
// obj represents a primitive Number, Boolean, int, float or String, and primitives
|
|
// are sealed and final. Cannot add dynamic vars to them.
|
|
|
|
// throw a ReferenceError exception Property not found and could not be created.
|
|
Multiname tempname(core()->getPublicNamespace(method->pool()), core()->internFloat(index_f));
|
|
toplevel()->throwReferenceError(kWriteSealedError, &tempname, toplevel()->toTraits(obj));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
Atom MethodEnv::callsuper(const Multiname* multiname, int argc, Atom* atomv) const
|
|
{
|
|
VTable* base = this->vtable()->base;
|
|
Toplevel* toplevel = this->toplevel();
|
|
Binding b = toplevel->getBinding(base->traits, multiname);
|
|
switch (AvmCore::bindingKind(b))
|
|
{
|
|
default:
|
|
toplevel->throwReferenceError(kCallNotFoundError, multiname, base->traits);
|
|
|
|
case BKIND_METHOD:
|
|
{
|
|
MethodEnv* superenv = base->methods[AvmCore::bindingToMethodId(b)];
|
|
return superenv->coerceEnter(argc, atomv);
|
|
}
|
|
case BKIND_VAR:
|
|
case BKIND_CONST:
|
|
{
|
|
uint32_t slot = AvmCore::bindingToSlotId(b);
|
|
ScriptObject* function = AvmCore::atomToScriptObject(atomv[0])->getSlotObject(slot);
|
|
return op_call(this, function, argc, atomv);
|
|
}
|
|
case BKIND_SET:
|
|
{
|
|
// read on write-only property
|
|
toplevel->throwReferenceError(kWriteOnlyError, multiname, base->traits);
|
|
}
|
|
case BKIND_GET:
|
|
case BKIND_GETSET:
|
|
{
|
|
// Invoke the getter
|
|
int m = AvmCore::bindingToGetterId(b);
|
|
MethodEnv *f = base->methods[m];
|
|
Atom method = f->coerceEnter(atomv[0]);
|
|
return avmplus::op_call(this, method, argc, atomv);
|
|
}
|
|
}
|
|
}
|
|
|
|
Atom MethodEnv::delproperty(Atom obj, const Multiname* multiname) const
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
Traits* traits = toplevel->toTraits(obj); // includes null check
|
|
if (AvmCore::isObject(obj))
|
|
{
|
|
Binding b = toplevel->getBinding(traits, multiname);
|
|
if (b == BIND_NONE)
|
|
{
|
|
bool b = AvmCore::atomToScriptObject(obj)->deleteMultinameProperty(multiname);
|
|
return b ? trueAtom : falseAtom;
|
|
}
|
|
else if (AvmCore::isMethodBinding(b))
|
|
{
|
|
if (AvmCore::isXMLorXMLList(obj) && multiname->containsAnyPublicNamespace())
|
|
{
|
|
// dynamic props should hide declared methods on delete
|
|
ScriptObject* so = AvmCore::atomToScriptObject(obj);
|
|
bool b = so->deleteMultinameProperty(multiname);
|
|
return b ? trueAtom : falseAtom;
|
|
}
|
|
}
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if (AvmCore::isFloat4(obj))
|
|
{
|
|
// See FIXME in Toplevel::getproperty() for an explanation of this logic.
|
|
if (multiname->isValidDynamicName())
|
|
{
|
|
uint32_t index;
|
|
if (AvmCore::getIndexFromAtom(multiname->getName()->atom(), &index))
|
|
{
|
|
if (index <= 3)
|
|
return falseAtom;
|
|
return trueAtom;
|
|
}
|
|
}
|
|
toplevel->throwReferenceError(kDeleteSealedError, multiname, traits);
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
toplevel->throwReferenceError(kDeleteSealedError, multiname, traits);
|
|
}
|
|
|
|
return falseAtom;
|
|
}
|
|
|
|
Atom MethodEnv::getsuper(Atom obj, const Multiname* multiname) const
|
|
{
|
|
VTable* vtable = this->vtable()->base;
|
|
Toplevel* toplevel = this->toplevel();
|
|
Binding b = toplevel->getBinding(vtable->traits, multiname);
|
|
switch (AvmCore::bindingKind(b))
|
|
{
|
|
default:
|
|
toplevel->throwReferenceError(kReadSealedError, multiname, vtable->traits);
|
|
|
|
case BKIND_METHOD:
|
|
{
|
|
// extracting a virtual method
|
|
MethodEnv *m = vtable->methods[AvmCore::bindingToMethodId(b)];
|
|
return toplevel->methodClosureClass()->create(m, obj)->atom();
|
|
}
|
|
|
|
case BKIND_VAR:
|
|
case BKIND_CONST:
|
|
return AvmCore::atomToScriptObject(obj)->getSlotAtom(AvmCore::bindingToSlotId(b));
|
|
|
|
case BKIND_SET:
|
|
{
|
|
// read on write-only property
|
|
toplevel->throwReferenceError(kWriteOnlyError, multiname, vtable->traits);
|
|
}
|
|
case BKIND_GET:
|
|
case BKIND_GETSET:
|
|
{
|
|
// Invoke the getter
|
|
int m = AvmCore::bindingToGetterId(b);
|
|
MethodEnv *f = vtable->methods[m];
|
|
return f->coerceEnter(obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void MethodEnv::setsuper(Atom obj, const Multiname* multiname, Atom value) const
|
|
{
|
|
VTable* vtable = this->vtable()->base;
|
|
Toplevel* toplevel = this->toplevel();
|
|
Binding b = toplevel->getBinding(vtable->traits, multiname);
|
|
switch (AvmCore::bindingKind(b))
|
|
{
|
|
default:
|
|
toplevel->throwReferenceError(kWriteSealedError, multiname, vtable->traits);
|
|
|
|
case BKIND_CONST:
|
|
toplevel->throwReferenceError(kConstWriteError, multiname, vtable->traits);
|
|
|
|
case BKIND_METHOD:
|
|
toplevel->throwReferenceError(kCannotAssignToMethodError, multiname, vtable->traits);
|
|
|
|
case BKIND_GET:
|
|
toplevel->throwReferenceError(kConstWriteError, multiname, vtable->traits);
|
|
|
|
case BKIND_VAR:
|
|
// @todo, this does a redundant coercion -- no harm done, just slightly more work than necessary
|
|
AvmCore::atomToScriptObject(obj)->coerceAndSetSlotAtom(AvmCore::bindingToSlotId(b), value);
|
|
return;
|
|
|
|
case BKIND_SET:
|
|
case BKIND_GETSET:
|
|
{
|
|
// Invoke the setter
|
|
uint32_t m = AvmCore::bindingToSetterId(b);
|
|
AvmAssert(m < vtable->traits->getTraitsBindings()->methodCount);
|
|
MethodEnv* method = vtable->methods[m];
|
|
Atom atomv_out[2] = { obj, value };
|
|
// coerce value to proper type, then call enter
|
|
method->coerceEnter(1, atomv_out);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Atom MethodEnv::findWithProperty(Atom atom, const Multiname* multiname)
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
if (atomKind(atom)==kObjectType)
|
|
{
|
|
// usually scope objects are ScriptObject's
|
|
|
|
ScriptObject* o = AvmCore::atomToScriptObject(atom);
|
|
|
|
// search the delegate chain for a value. we must look at
|
|
// traits at each step along the way in case we have class
|
|
// instances on the scope chain
|
|
do
|
|
{
|
|
// ISSUE it is incorrect to return a reference to an object on the prototype
|
|
// chain, we should only return the scopechain object; the next operation
|
|
// could be a setproperty, and we don't want to mutate prototype objects this way.
|
|
|
|
// look at the traits first, stop if found.
|
|
Binding b = toplevel->getBinding(o->traits(), multiname);
|
|
if (b != BIND_NONE)
|
|
return atom;
|
|
if (o->hasMultinameProperty(multiname))
|
|
return atom;
|
|
}
|
|
while ((o = o->getDelegate()) != NULL);
|
|
}
|
|
else
|
|
{
|
|
// primitive value on scope chain!
|
|
|
|
// first iteration looks at traits only since primitive values don't have
|
|
// dynamic variables
|
|
|
|
Binding b = toplevel->getBinding(toplevel->toTraits(atom), multiname);
|
|
if (b != BIND_NONE)
|
|
return atom;
|
|
|
|
// then we continue starting at the prototype for this primitive type
|
|
ScriptObject* o = toplevel->toPrototype(atom);
|
|
do
|
|
{
|
|
Binding b = toplevel->getBinding(o->traits(), multiname);
|
|
if (b != BIND_NONE)
|
|
return atom;
|
|
if (o->hasMultinameProperty(multiname))
|
|
return atom;
|
|
}
|
|
while ((o = o->getDelegate()) != NULL);
|
|
}
|
|
|
|
return nullObjectAtom;
|
|
}
|
|
|
|
/**
|
|
* return the object on the scope chain that owns the given property.
|
|
* if no object has that property, return scope[0]. we search each
|
|
* delegate chain but only return objects that are on the scope chain.
|
|
* this way, find+get and find+set are both correct. find+set should
|
|
* not mutate a prototype object.
|
|
*/
|
|
Atom MethodEnv::findproperty(ScopeChain* outer,
|
|
Atom* scopes,
|
|
int extraScopes,
|
|
const Multiname* multiname,
|
|
bool strict,
|
|
Atom* withBase)
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
|
|
// look in each with frame in the current stack frame
|
|
Atom* scopep = &scopes[extraScopes-1];
|
|
if (withBase)
|
|
{
|
|
for (; scopep >= withBase; scopep--)
|
|
{
|
|
Atom result = findWithProperty(*scopep, multiname);
|
|
if (!AvmCore::isNull(result))
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we're in global$init (outer_depth==0), don't check "this" scope just yet.
|
|
int outer_depth = outer->getSize();
|
|
for (; scopep > scopes; scopep--)
|
|
{
|
|
Atom a = *scopep;
|
|
Traits* t = toplevel->toTraits(a);
|
|
Binding b = toplevel->getBinding(t, multiname);
|
|
if (b != BIND_NONE)
|
|
return a;
|
|
}
|
|
|
|
const ScopeTypeChain* outerTraits = outer->scopeTraits();
|
|
|
|
if (outer_depth > 0 && scopep >= scopes)
|
|
{
|
|
// consider "this" scope now, but constrain it to the declaringTraits of
|
|
// the current method (verifier ensures this is safe)
|
|
Atom a = *scopep;
|
|
Traits *t;
|
|
if (outerTraits->fullsize > outerTraits->size)
|
|
{
|
|
// scope traits has extra constraint for "this" scope, see OP_newclass in verifier
|
|
t = outerTraits->getScopeTraitsAt(outerTraits->size);
|
|
}
|
|
else
|
|
{
|
|
// "this" scope type is the runtime type
|
|
t = toplevel->toTraits(a);
|
|
}
|
|
|
|
Binding b = toplevel->getBinding(t, multiname);
|
|
if (b != BIND_NONE)
|
|
return a;
|
|
}
|
|
|
|
// now search outer scopes
|
|
for (int i=outer_depth-1; i > 0; i--)
|
|
{
|
|
if (outerTraits->getScopeIsWithAt(i))
|
|
{
|
|
Atom result = findWithProperty(outer->getScope(i), multiname);
|
|
if (!AvmCore::isNull(result))
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
// only look at the properties on the captured (verify time) type, not the actual type,
|
|
// of the outer scope object.
|
|
Atom a = outer->getScope(i);
|
|
Traits* t = outerTraits->getScopeTraitsAt(i);
|
|
Binding b = toplevel->getBinding(t, multiname);
|
|
if (b != BIND_NONE)
|
|
return a;
|
|
}
|
|
}
|
|
|
|
// No imported definitions or global scope can have attributes. (Using filter
|
|
// operator with non existent attribute will get here.
|
|
if (multiname->isAttr())
|
|
{
|
|
if (strict)
|
|
toplevel->throwReferenceError(kUndefinedVarError, multiname);
|
|
return undefinedAtom;
|
|
}
|
|
|
|
// now we have searched all the scopes, except global
|
|
{
|
|
Atom global = outer->getSize() > 0 ? outer->getScope(0) : *scopes;
|
|
Atom obj = findglobalproperty(global, multiname);
|
|
if (AvmCore::isNullOrUndefined(obj)) {
|
|
if (strict)
|
|
toplevel->throwReferenceError(kUndefinedVarError, multiname);
|
|
obj = global;
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
}
|
|
|
|
Atom MethodEnv::findglobalproperty(Atom target_global, const Multiname* multiname)
|
|
{
|
|
// wildcards used here always fail later on, so just check now.
|
|
if (multiname->isAnyName() || multiname->isAnyNamespace())
|
|
return nullObjectAtom;
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
|
|
// look for imported definition (similar logic to OP_finddef). This will
|
|
// find definitions in this script and in other scripts.
|
|
AbcEnv* abcEnv = this->abcEnv();
|
|
AvmCore* core = abcEnv->core();
|
|
ScriptEnv* script = core->domainMgr()->findScriptEnvInAbcEnvByMultiname(abcEnv, *multiname);
|
|
if (script != (ScriptEnv*)BIND_NONE)
|
|
{
|
|
if (script == (ScriptEnv*)BIND_AMBIGUOUS)
|
|
toplevel->throwReferenceError(kAmbiguousBindingError, multiname);
|
|
|
|
ScriptObject* global = script->global;
|
|
if (global == NULL)
|
|
{
|
|
global = script->initGlobal();
|
|
script->coerceEnter(script->global->atom());
|
|
}
|
|
return global->atom();
|
|
}
|
|
|
|
// no imported definition found. look for dynamic props
|
|
// on the global object
|
|
|
|
// search the delegate chain for a value. The delegate
|
|
// chain for the global object will only contain vanilla
|
|
// objects (Object.prototype) so we can skip traits
|
|
|
|
ScriptObject* o = AvmCore::isObject(target_global) ?
|
|
AvmCore::atomToScriptObject(target_global) :
|
|
toplevel->toPrototype(target_global);
|
|
do
|
|
{
|
|
if (o->hasMultinameProperty(multiname))
|
|
return target_global;
|
|
}
|
|
while ((o = o->getDelegate()) != NULL);
|
|
|
|
return nullObjectAtom;
|
|
}
|
|
|
|
Namespace* MethodEnv::internRtns(Atom nsAtom)
|
|
{
|
|
if ((atomKind(nsAtom) != kNamespaceType) || AvmCore::isNull(nsAtom))
|
|
toplevel()->throwTypeError(kIllegalNamespaceError);
|
|
return core()->internNamespace(AvmCore::atomToNamespace(nsAtom));
|
|
}
|
|
|
|
ArrayObject* MethodEnv::createArguments(Atom *atomv, int argc)
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
ArrayObject *arguments = toplevel->arrayClass()->newarray(atomv+1,argc);
|
|
ScriptObject *closure;
|
|
if (method->needClosure())
|
|
{
|
|
closure = toplevel->methodClosureClass()->create(this, atomv[0]);
|
|
}
|
|
else
|
|
{
|
|
closure = ((FunctionEnv*)this)->closure;
|
|
}
|
|
arguments->setStringProperty(core()->kcallee, closure->atom());
|
|
arguments->setStringPropertyIsEnumerable(core()->kcallee, false);
|
|
return arguments;
|
|
}
|
|
|
|
Atom MethodEnv::getdescendants(Atom obj, const Multiname* multiname)
|
|
{
|
|
if (AvmCore::isObject (obj))
|
|
{
|
|
return core()->atomToScriptObject(obj)->getDescendants (multiname);
|
|
}
|
|
else
|
|
{
|
|
// Rhino simply returns undefined for other Atom types
|
|
// SpiderMonkey throws TypeError. We're doing TypeError.
|
|
toplevel()->throwTypeError(kDescendentsError, core()->toErrorString(toplevel()->toTraits(obj)));
|
|
return undefinedAtom; // not reached
|
|
}
|
|
}
|
|
|
|
void MethodEnv::checkfilter(Atom obj)
|
|
{
|
|
if ( !AvmCore::isXMLorXMLList(obj) )
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
toplevel->throwTypeError(kFilterError, core()->toErrorString(toplevel->toTraits(obj)));
|
|
}
|
|
}
|
|
|
|
VTable* MethodEnv::buildActivationVTable()
|
|
{
|
|
const ScopeTypeChain* activationScopeTraits = method->activationScope();
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
|
|
// This can happen when the ABC has MethodInfo data but not MethodBody data
|
|
if (!activationScopeTraits)
|
|
{
|
|
toplevel->throwVerifyError(kCorruptABCError);
|
|
}
|
|
|
|
Traits* activationTraits = activationScopeTraits->traits();
|
|
AvmAssert(activationTraits != NULL);
|
|
|
|
AvmCore* core = this->core();
|
|
|
|
// Bugzilla 671413 (note below is from Steven Johnson):
|
|
// This is quite possibly the ugliest hack I've ever inserted into Tamarin.
|
|
// The problem: at the ABC level, activation objects can be coerced into plain Objects,
|
|
// but they aren't plain Objects (they are distinct types). If a call to one of Object's
|
|
// methods (e.g. AS3::hasOwnProperty) is early bound to this, we'll attempt to call
|
|
// a method using a non-existent MethodEnv on the activation object's VTable -- crashamundo.
|
|
// The *proper* fix is (arguably) to smarten Verifier to ensure that activation objects
|
|
// can't be coerced, or leaked into a different structure/function that might coerce them,
|
|
// but that's tricky to do and a Quick Fix is needed for Wasabi. Hence, the pragmatic approach:
|
|
// artificially graft the MethodEnvs from Object onto each activation VTable, so that if
|
|
// such a dubious call happens, it quietly calls the proper Object method. (Arguably, a better
|
|
// approach would be to call a method that throws a VerifyError, but since this is intended
|
|
// as a temporary fix for fuzzed/malformed ABC in the first place, I don't think it's worth
|
|
// the extra effort.)
|
|
MMgc::GC* gc = core->GetGC();
|
|
VTable* object_ivtable = toplevel->objectClass->ivtable();
|
|
Traits* object_itraits = object_ivtable->traits;
|
|
uint32_t const object_method_count = object_itraits->getTraitsBindings()->methodCount;
|
|
AvmAssert(object_method_count > 0);
|
|
|
|
// activations shouldn't ever have methods.
|
|
uint32_t const activation_method_count = activationTraits->getTraitsBindings()->methodCount;
|
|
AvmAssert(activation_method_count == 0);
|
|
if (activation_method_count > 0)
|
|
toplevel->throwVerifyError(kCorruptABCError);
|
|
|
|
size_t const extraSize = sizeof(MethodEnv*) * (object_method_count-1);
|
|
VTable* activation = new (gc, MMgc::kExact, extraSize) VTable(activationTraits, NULL, toplevel);
|
|
|
|
ScopeChain* activationScope = this->scope()->cloneWithNewVTable(core->GetGC(), activation, this->abcEnv(), activationScopeTraits);
|
|
activation->resolveSignatures(activationScope);
|
|
|
|
// Bugzilla 671413
|
|
for (uint32_t i = 0; i < object_method_count; i++)
|
|
WB(gc, activation, &activation->methods[i], object_ivtable->methods[i]);
|
|
|
|
return activation;
|
|
}
|
|
|
|
VTable* MethodEnv::getActivationVTable()
|
|
{
|
|
if (!method->needActivation())
|
|
return NULL;
|
|
|
|
VTable* activation;
|
|
const int type = getType();
|
|
if (!activationOrMCTable)
|
|
{
|
|
activation = buildActivationVTable();
|
|
setActivationOrMCTable(activation, kActivation);
|
|
}
|
|
else if (type == kMethodTable)
|
|
{
|
|
activation = buildActivationVTable();
|
|
ActivationMethodTablePair *amtp = new (core()->GetGC()) ActivationMethodTablePair(activation, getMethodClosureTable());
|
|
setActivationOrMCTable(amtp, kActivationMethodTablePair);
|
|
}
|
|
else if (type == kActivationMethodTablePair)
|
|
{
|
|
activation = getPair()->activation;
|
|
}
|
|
else
|
|
{
|
|
activation = (VTable*)(activationOrMCTable&~7);
|
|
}
|
|
AvmAssert(activation != NULL);
|
|
return activation;
|
|
}
|
|
|
|
ScriptObject *MethodEnv::newUninitializedActivation()
|
|
{
|
|
VTable *vtable = getActivationVTable();
|
|
AvmCore *core = this->core();
|
|
MMgc::GC *gc = core->GetGC();
|
|
SAMPLE_FRAME("[activation-object]", core);
|
|
ScriptObject* obj = ScriptObject::create(gc, vtable, 0/*delegate*/);
|
|
AvmAssert(obj->getDelegate() == NULL); // activation objects must not have a prototype pointer.
|
|
return obj;
|
|
}
|
|
|
|
ScriptObject *MethodEnv::newActivation()
|
|
{
|
|
ScriptObject* obj = newUninitializedActivation();
|
|
MethodEnv *init = obj->vtable->init;
|
|
if (init)
|
|
init->coerceEnter(obj->atom());
|
|
AvmAssert(obj->getDelegate() == NULL); // activation objects must not have a prototype pointer.
|
|
return obj;
|
|
}
|
|
|
|
WeakKeyHashtable *MethodEnv::getMethodClosureTable()
|
|
{
|
|
int type = getType();
|
|
if(!activationOrMCTable)
|
|
{
|
|
WeakKeyHashtable *wkh = WeakKeyHashtable::create(core()->GetGC());
|
|
setActivationOrMCTable(wkh, kMethodTable);
|
|
return wkh;
|
|
}
|
|
else if(type == kActivation)
|
|
{
|
|
WeakKeyHashtable *wkh = WeakKeyHashtable::create(core()->GetGC());
|
|
ActivationMethodTablePair *amtp = new (core()->GetGC()) ActivationMethodTablePair(getActivationVTable(), wkh);
|
|
setActivationOrMCTable(amtp, kActivationMethodTablePair);
|
|
return wkh;
|
|
}
|
|
else if(type == kActivationMethodTablePair)
|
|
{
|
|
return getPair()->methodTable;
|
|
}
|
|
return (WeakKeyHashtable*)(activationOrMCTable&~7);
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
void FASTCALL check_unbox(MethodEnv* env, bool u)
|
|
{
|
|
AvmAssert((env->method->unboxThis() != 0) == u);
|
|
}
|
|
#endif
|
|
|
|
#ifdef DEBUGGER
|
|
ArrayObject* MethodEnv::getLexicalScopes()
|
|
{
|
|
if(_scope->getSize() == 0)
|
|
return NULL;
|
|
|
|
ArrayObject *scopes = toplevel()->arrayClass()->newArray(_scope->getSize());
|
|
|
|
for(int i=_scope->getSize()-1, j=0; i >= 0; i--, j++) {
|
|
Atom scope = _scope->getScope(i);
|
|
scopes->setUintProperty(j, scope);
|
|
}
|
|
|
|
return scopes;
|
|
}
|
|
#endif
|
|
}
|