232 lines
7.2 KiB
C++
232 lines
7.2 KiB
C++
/* ***** BEGIN LICENSE BLOCK *****
|
||
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
||
*
|
||
* The contents of this file are subject to the Mozilla Public License Version
|
||
* 1.1 (the "License"); you may not use this file except in compliance with
|
||
* the License. You may obtain a copy of the License at
|
||
* http://www.mozilla.org/MPL/
|
||
*
|
||
* Software distributed under the License is distributed on an "AS IS" basis,
|
||
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
||
* for the specific language governing rights and limitations under the
|
||
* License.
|
||
*
|
||
* The Original Code is [Open Source Virtual Machine.].
|
||
*
|
||
* The Initial Developer of the Original Code is
|
||
* Adobe System Incorporated.
|
||
* Portions created by the Initial Developer are Copyright (C) 2004-2006
|
||
* the Initial Developer. All Rights Reserved.
|
||
*
|
||
* Contributor(s):
|
||
* Adobe AS3 Team
|
||
*
|
||
* Alternatively, the contents of this file may be used under the terms of
|
||
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
||
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
||
* in which case the provisions of the GPL or the LGPL are applicable instead
|
||
* of those above. If you wish to allow use of your version of this file only
|
||
* under the terms of either the GPL or the LGPL, and not to allow others to
|
||
* use your version of this file under the terms of the MPL, indicate your
|
||
* decision by deleting the provisions above and replace them with the notice
|
||
* and other provisions required by the GPL or the LGPL. If you do not delete
|
||
* the provisions above, a recipient may use your version of this file under
|
||
* the terms of any one of the MPL, the GPL or the LGPL.
|
||
*
|
||
* ***** END LICENSE BLOCK ***** */
|
||
|
||
|
||
#include "avmplus.h"
|
||
|
||
namespace avmplus
|
||
{
|
||
BEGIN_NATIVE_MAP(ObjectClass)
|
||
NATIVE_METHOD(Object_private__hasOwnProperty, ObjectClass::objectHasOwnProperty)
|
||
NATIVE_METHOD(Object_private__propertyIsEnumerable, ObjectClass::objectPropertyIsEnumerable)
|
||
NATIVE_METHOD(Object_protected__setPropertyIsEnumerable, ObjectClass::objectSetPropertyIsEnumerable)
|
||
NATIVE_METHOD(Object_private__isPrototypeOf, ObjectClass::objectIsPrototypeOf)
|
||
NATIVE_METHOD(Object_private__toString, ObjectClass::objectToString)
|
||
END_NATIVE_MAP()
|
||
|
||
ObjectClass::ObjectClass(VTable* cvtable)
|
||
: ClassClosure(cvtable)
|
||
{
|
||
toplevel()->objectClass = this;
|
||
|
||
// patch Object's instance vtable scope, since we created it earlier for
|
||
// bootstrapping
|
||
//ivtable()->scope = cvtable->scope;
|
||
|
||
AvmAssert(traits()->sizeofInstance == sizeof(ObjectClass));
|
||
// it is correct call construct() when this.prototype == null
|
||
prototype = construct();
|
||
}
|
||
|
||
void ObjectClass::initPrototype()
|
||
{
|
||
// patch global.__proto__ = Object.prototype
|
||
Toplevel* toplevel = this->toplevel();
|
||
toplevel->setDelegate( prototype ); // global.__proto__ = Object.prototype
|
||
this->setDelegate( toplevel->classClass->prototype ); // Object.__proto__ = Class.prototype
|
||
}
|
||
|
||
ScriptObject* ObjectClass::construct()
|
||
{
|
||
return (ScriptObject*) core()->newObject(ivtable(), prototype);
|
||
}
|
||
|
||
// this = argv[0]
|
||
// arg1 = argv[1]
|
||
// argN = argv[argc]
|
||
Atom ObjectClass::call(int argc, Atom* argv)
|
||
{
|
||
// see E-262 15.2.1
|
||
if (argc == 0 || AvmCore::isNullOrUndefined(argv[1]))
|
||
return construct(argc, argv);
|
||
else
|
||
return argv[1];
|
||
}
|
||
|
||
// this = argv[0] (ignored)
|
||
// arg1 = argv[1]
|
||
// argN = argv[argc]
|
||
Atom ObjectClass::construct(int argc, Atom* argv)
|
||
{
|
||
switch (argc)
|
||
{
|
||
default:
|
||
// TODO throw exception if argc > 1 (see E4 semantics)
|
||
case 1: {
|
||
Atom o = argv[1];
|
||
if (!AvmCore::isNullOrUndefined(o))
|
||
return o;
|
||
// else fall through
|
||
}
|
||
case 0:
|
||
return construct()->atom();
|
||
}
|
||
}
|
||
|
||
/**
|
||
15.2.4.5 Object.prototype.hasOwnProperty (V)
|
||
When the hasOwnProperty method is called with argument V, the following steps are taken:
|
||
1. Let O be this object.
|
||
2. Call ToString(V).
|
||
3. If O doesnt have a property with the name given by Result(2), return false.
|
||
4. Return true.
|
||
NOTE Unlike [[HasProperty]] (section 8.6.2.4), this method does not consider objects in the prototype chain.
|
||
*/
|
||
bool ObjectClass::objectHasOwnProperty(Atom thisAtom, Stringp name)
|
||
{
|
||
AvmCore* core = this->core();
|
||
name = name ? core->internString(name) : (Stringp)core->knull;
|
||
|
||
switch (thisAtom&7)
|
||
{
|
||
case kObjectType:
|
||
{
|
||
// ISSUE should this look in traits and dynamic vars, or just dynamic vars.
|
||
ScriptObject* obj = AvmCore::atomToScriptObject(thisAtom);
|
||
return obj->traits()->findBinding(name, core->publicNamespace) != BIND_NONE ||
|
||
obj->hasStringProperty(name);
|
||
}
|
||
case kNamespaceType:
|
||
case kStringType:
|
||
case kBooleanType:
|
||
case kDoubleType:
|
||
case kIntegerType:
|
||
return toplevel()->toTraits(thisAtom)->findBinding(name, core->publicNamespace) != BIND_NONE;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
bool ObjectClass::objectPropertyIsEnumerable(Atom thisAtom, Stringp name)
|
||
{
|
||
AvmCore* core = this->core();
|
||
name = name ? core->internString(name) : (Stringp)core->knull;
|
||
|
||
if ((thisAtom&7) == kObjectType)
|
||
{
|
||
ScriptObject* obj = AvmCore::atomToScriptObject(thisAtom);
|
||
return obj->getStringPropertyIsEnumerable(name);
|
||
}
|
||
else if ((thisAtom&7) == kNamespaceType)
|
||
{
|
||
// Special case:
|
||
// E4X 13.2.5.1, 13.2.5.2 specifies that prefix and uri
|
||
// are not DontEnum.
|
||
return name == core->kuri || name == core->kprefix;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
void ObjectClass::objectSetPropertyIsEnumerable(Atom thisAtom, Stringp name, bool enumerable)
|
||
{
|
||
AvmCore* core = this->core();
|
||
name = name ? core->internString(name) : (Stringp)core->knull;
|
||
|
||
if ((thisAtom&7) == kObjectType)
|
||
{
|
||
ScriptObject* obj = AvmCore::atomToScriptObject(thisAtom);
|
||
obj->setStringPropertyIsEnumerable(name, enumerable);
|
||
}
|
||
else
|
||
{
|
||
// cannot create properties on a sealed object.
|
||
Multiname multiname(core->publicNamespace, name);
|
||
toplevel()->throwReferenceError(kWriteSealedError, &multiname, traits());
|
||
}
|
||
}
|
||
|
||
/**
|
||
15.2.4.6 Object.prototype.isPrototypeOf (V)
|
||
When the isPrototypeOf method is called with argument V, the following steps are taken:
|
||
1. Let O be this object.
|
||
2. If V is not an object, return false.
|
||
3. Let V be the value of the [[Prototype]] property of V.
|
||
4. if V is null, return false
|
||
5. If O and V refer to the same object or if they refer to objects joined to each other (section 13.1.2), return true.
|
||
6. Go to step 3.
|
||
*/
|
||
bool ObjectClass::objectIsPrototypeOf(Atom thisAtom, Atom V)
|
||
{
|
||
// ECMA-262 Section 15.2.4.6
|
||
if (AvmCore::isNullOrUndefined(V))
|
||
return false;
|
||
|
||
ScriptObject* o = toplevel()->toPrototype(V);
|
||
for (; o != NULL; o = o->getDelegate())
|
||
{
|
||
if (o->atom() == thisAtom)
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Object.prototype.toString()
|
||
*/
|
||
Stringp ObjectClass::objectToString(Atom thisAtom)
|
||
{
|
||
AvmCore* core = this->core();
|
||
|
||
if (core->istype(thisAtom, CLASS_TYPE))
|
||
{
|
||
ClassClosure *cc = (ClassClosure *)AvmCore::atomToScriptObject(thisAtom);
|
||
Traits* t = cc->ivtable()->traits;
|
||
Stringp s = core->concatStrings(core->newString("[class "), t->name);
|
||
return core->concatStrings(s, core->newString("]"));
|
||
}
|
||
else
|
||
{
|
||
Traits* t = toplevel()->toTraits(thisAtom);
|
||
Stringp s = core->concatStrings(core->newString("[object "), t->name);
|
||
return core->concatStrings(s, core->newString("]"));
|
||
}
|
||
}
|
||
}
|