as_object.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_AS_OBJECT_H
#define GNASH_AS_OBJECT_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include "tu_config.h"

#include "string_table.h"
#include "ref_counted.h" // for inheritance  (to drop)
#include "GC.h" // for inheritance from GcResource (to complete)
#include "PropertyList.h"
#include "as_value.h" // for return of get_primitive_value
#include "smart_ptr.h"
#include "as_prop_flags.h" // for enum
#include "GnashException.h"
#include "event_id.h" // for event_id
#include <sstream>

#if defined(__GNUC__) && __GNUC__ > 2
#  include <cxxabi.h>
#endif

#include <cmath>
#include <utility> // for std::pair
#include <set>

// Forward declarations
namespace gnash {
        class as_function;
        class sprite_instance;
        class character;
        class as_environment;
        class VM;
        class Machine;
}

namespace gnash {

class asClass;
class asName;

//
class DSOEXPORT as_object
        :
#ifdef GNASH_USE_GC
        public GcResource
#else
        public ref_counted
#endif
{
        friend class asClass;
        friend class Machine;

        typedef std::set<std::pair<string_table::key, string_table::key> > propNameSet;
private:
        PropertyList _members;

        as_object& operator=(const as_object&)
        {
                abort();
                return *this;
        }

        //
        Property* findUpdatableProperty(string_table::key name, 
                string_table::key nsname = 0);

        Property* findProperty(string_table::key name, string_table::key nsname,
                as_object **owner = NULL);

public:

        VM& getVM() const {
                return _vm;
        }


        //
        void dump_members();

        //
        void dump_members(std::map<std::string, as_value>& to);

        as_object();

        as_object(as_object* proto);

        as_object(boost::intrusive_ptr<as_object> proto);

        //
        as_object(const as_object& other);
        
        virtual std::string get_text_value() const { return "[object Object]"; }

        virtual bool useCustomToString() const { return true; }

        //
        virtual double get_numeric_value() const {
                std::string txt = get_text_value();
                if ( ! txt.empty() ) return atof(txt.c_str());
                else return 0; 
        }

        //
        virtual as_value get_primitive_value() const
        {
                // Since as_value(const as_object*) doesn't exist
                // we have to cast the value to non-const, or
                // the as_value will result as beeing a BOOLEAN ! (?)
                return as_value(const_cast<as_object*>(this)); 
        }

        //
        virtual void set_member(string_table::key key, const as_value& val,
                string_table::key nsname = 0)
        {
                return set_member_default(key, val, nsname);
        }

        //
        std::pair<bool,bool> update_member(string_table::key key, const as_value& val,
                string_table::key nsname = 0);

        virtual bool on_event(const event_id& id );

        void reserveSlot(string_table::key name, string_table::key nsId,
                unsigned short slotId);

        //
        void init_member(const std::string& name, const as_value& val, 
                int flags=as_prop_flags::dontDelete|as_prop_flags::dontEnum, 
                string_table::key nsname = 0);

        //
        void init_member(string_table::key key, const as_value& val, 
                int flags=as_prop_flags::dontDelete|as_prop_flags::dontEnum,
                string_table::key nsname = 0, int slotId = -1);

        //
        void init_property(const std::string& key, as_function& getter,
                as_function& setter, int flags=as_prop_flags::dontDelete|as_prop_flags::dontEnum,
                string_table::key nsname = 0);

        //
        void init_property(string_table::key key, as_function& getter,
                as_function& setter, int flags=as_prop_flags::dontDelete|as_prop_flags::dontEnum,
                string_table::key nsname = 0);


        bool init_destructive_property(string_table::key key, as_function& getter,
                as_function& setter, int flags=as_prop_flags::dontEnum,
                string_table::key nsname = 0);

        //
        void init_readonly_property(const std::string& key, as_function& getter,
                        int flags=as_prop_flags::dontDelete|as_prop_flags::dontEnum,
                        string_table::key nsname = 0);

        //
        virtual bool get_member(string_table::key name, as_value* val,
                string_table::key nsname = 0)
        {
                return get_member_default(name, val, nsname);
        }

        //
        virtual as_object* get_path_element(string_table::key key);

        bool isQName() const { return false; /* TODO: Implement */ }
        bool isXML() const { return false; /* TODO */ }
        bool isDictionary() const { return false; /* TODO */ }

        as_object* get_super(); 

        as_function* get_constructor();

        //
        as_value getMember(string_table::key name, string_table::key nsname = 0);

        //
        as_value callMethod(string_table::key name);
        as_value callMethod(string_table::key name, const as_value& arg0);
        as_value callMethod(string_table::key name, const as_value& arg0, const as_value& arg1);
        as_value callMethod(string_table::key name, const as_value& arg0, const as_value& arg1, const as_value& arg2);
        as_value callMethod(string_table::key name, const as_value& arg0, const as_value& arg1, const as_value& arg2, const as_value& arg3);

        //
        std::pair<bool,bool> delProperty(string_table::key name, string_table::key nsname = 0);

        //
        Property* getOwnProperty(string_table::key name, string_table::key nsname = 0);

        Property *getByIndex(int index);

        int nextIndex(int index, as_object **owner = NULL);

        //
        bool set_member_flags(string_table::key name,
                        int setTrue, int setFalse=0, string_table::key nsname = 0);

        virtual sprite_instance* to_movie() { return NULL; }

        const sprite_instance* to_movie() const { return const_cast<as_object*>(this)->to_movie(); }

        virtual as_function* to_function() { return NULL; }

        virtual character* to_character() { return NULL; }

        const character* to_character() const { return const_cast<as_object*>(this)->to_character(); }

        //
        virtual bool isDateObject() { return false; }

        void add_interface(as_object* ctor);

        //
        bool instanceOf(as_function* ctor);

        //
        bool prototypeOf(as_object& instance);

        //
        void setPropFlags(as_value& props, int set_false, int set_true);

#ifdef USE_DEBUGGER
        PropertyList &get_properties() { return _members; };
#endif

        //
        void copyProperties(const as_object& o);

        void clearProperties()
        {
                _members.clear();
        }

        //
        void enumerateProperties(as_environment& env) const;

        //
        virtual void enumerateNonProperties(as_environment&) const
        {
        }

        //
        void enumerateProperties(std::map<std::string, std::string>& to);

        //
        void getURLEncodedVars(std::string& data);

        //
        template <class V>
        void visitPropertyValues(V& visitor) const
        {
                _members.visitValues(visitor, 
                        // Need const_cast due to getValue getting non-const ...
                        const_cast<as_object&>(*this));
        }


        //
        bool add_property(const std::string& key, as_function& getter,
                as_function& setter);

        //
        boost::intrusive_ptr<as_object> get_prototype();

        const boost::intrusive_ptr<as_object> get_prototype() const {
                // cast away constness
                return const_cast<as_object*>(this)->get_prototype();
        }

        //
        void set_prototype(boost::intrusive_ptr<as_object> proto, int flags=as_prop_flags::dontDelete|as_prop_flags::dontEnum);

        std::string asPropName(string_table::key name);
        

        static as_value tostring_method(const fn_call& fn);

        static as_value valueof_method(const fn_call& fn);

        
protected:

        //
        bool get_member_default(string_table::key name, as_value* val, 
                string_table::key nsname);

        //
        void set_member_default(string_table::key name, const as_value& val, 
                string_table::key nsname);

#ifdef GNASH_USE_GC
        //
        virtual void markReachableResources() const
        {
                markAsObjectReachable();
        }

        void markAsObjectReachable() const
        {
                _members.setReachable();
                //if ( m_prototype.get() ) m_prototype->setReachable();
        }
#endif // GNASH_USE_GC

        VM& _vm;

private:

        std::list<as_object*> mInterfaces;

        //boost::intrusive_ptr<as_object> m_prototype;

};

template <typename T>
boost::intrusive_ptr<T>
ensureType (boost::intrusive_ptr<as_object> obj)
{
        boost::intrusive_ptr<T> ret = boost::dynamic_pointer_cast<T>(obj);

        if (!ret) {
                std::string     target = typeid(T).name(),
                                source = typeid(*obj.get()).name();
#if defined(__GNUC__) && __GNUC__ > 2
                int status;
                char* target_unmangled = 
                        abi::__cxa_demangle (target.c_str(), NULL, NULL,
                                             &status);
                if (status == 0) {
                        target = target_unmangled;
                        free(target_unmangled);
                }

                char* source_unmangled =
                        abi::__cxa_demangle (source.c_str(), NULL, NULL,
                                             &status);

                if (status == 0) {
                        source = source_unmangled;
                        free(source_unmangled);
                }
#endif // __GNUC__ > 2

                std::string msg = "builtin method or gettersetter for " +
                        target + " called from " + source + " instance.";

                throw ActionException(msg);
        }
        return ret;
}



} // namespace gnash

#endif // GNASH_AS_OBJECT_H

---