bool as_value::abstract_equality_comparison( const as_value & first, const as_value & second )
{
if (first.type_of() == second.type_of())
{
if( first.is_undefined() ) return true;
if( first.is_null() ) return true;
if( first.is_number() )
{
double first_number = first.to_number();
double second_number = second.to_number();
if( first_number == get_nan() || second_number == get_nan() )
{
return false;
}
return first_number == second_number;
}
else if( first.is_string() )
{
return first.to_tu_string() == second.to_tu_string();
}
else if( first.is_bool() )
{
return first.to_bool() == second.to_bool();
}
//13.Return true if x and y refer to the same object or if they refer to objects joined to each other (see
//13.1.2). Otherwise, return false.
// TODO: treat joined object
return first.to_object() == second.to_object();
}
else
{
if( first.is_null() && second.is_undefined() ) return true;
if( second.is_null() && first.is_undefined() ) return true;
if( ( first.is_number() && second.is_string() )
|| (second.is_number() && first.is_string() ) )
{
return first.to_number() == second.to_number();
}
if( first.is_bool() || second.is_bool() ) return first.to_number() == second.to_number();
// TODO:20.If Type(x) is either String or Number and Type(y) is Object,
//return the result of the comparison x == ToPrimitive(y).
//21.If Type(x) is Object and Type(y) is either String or Number,
//return the result of the comparison ToPrimitive(x) == y.
return false;
}
}
bool
Class::addValue(string_table::key name, Namespace *ns,
std::uint32_t slotId, Class *type, as_value& val, bool isconst,
bool isstatic)
{
Global_as* g = VM::get().getGlobal();
if (val.is_object()) {
val.to_object(*g)->set_member(NSV::INTERNAL_TYPE, type->getName());
}
string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
int flags = PropFlags::dontDelete;
if (isconst)
flags |= PropFlags::readOnly;
if (isstatic)
flags |= PropFlags::staticProp;
const ObjectURI uri(name, nsname);
if (slotId == 0) {
_prototype->init_member(uri, val, flags);
}
else {
_prototype->init_member(uri, val, flags, slotId);
}
return true;
}
bool as_value::operator==(const as_value& v) const
// Return true if operands are equal.
{
// types don't match
if (m_type != PROPERTY && v.m_type != PROPERTY && m_type != v.m_type)
{
if ((is_undefined() && v.is_null()) || (is_null() && v.is_undefined()))
{
return true;
}
return false;
}
switch (m_type)
{
case UNDEFINED:
return v.m_type == UNDEFINED;
case STRING:
return m_string == v.to_tu_string();
case NUMBER:
return m_number == v.to_number();
case BOOLEAN:
return m_bool == v.to_bool();
case OBJECT:
return m_object.get() == v.to_object();
case PROPERTY:
{
as_value prop;
get_property(&prop);
return prop == v;
}
default:
assert(0);
return false;
}
}
bool as_transform::set_member(const tu_stringi& name, const as_value& val)
{
as_transform_member member = get_transform_member( name );
switch (member)
{
case colorTransform:
{
m_color_transform = cast_to<as_color_transform>( val.to_object() );
m_movie->set_cxform( m_color_transform->m_color_transform );
return true;
}
case concatenatedColorTransform:
{
//read-only
return true;
}
case matrix:
{
assert( false && "todo" );
return true;
}
case concatenatedMatrix:
{
//read-only
return true;
}
case pixelBounds:
{
assert( false && "todo" );
return true;
}
default:
break;
};
return as_object::set_member( name, val );
}
as_property::as_property(const as_value& getter, const as_value& setter)
{
m_getter = cast_to<as_function>(getter.to_object());
m_setter = cast_to<as_function>(setter.to_object());
}
void as_environment::set_register ( int reg, const as_value &val )
{
IF_VERBOSE_ACTION ( log_msg ( "-------------- set_register(%d): %s at %p\n",
reg, val.to_string(), val.to_object() ) );
*local_register_ptr ( reg ) = val;
}