as_value.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

/* $Id: as__value_8h-source.html,v 1.3 2008/03/07 02:36:49 bjacques Exp $ */

#ifndef GNASH_AS_VALUE_H
#define GNASH_AS_VALUE_H

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

#include "tu_config.h"
#include "smart_ptr.h"

#include <cmath>
#include <limits>
#include <string>
#include <boost/variant.hpp>
#include <ostream> // for inlined output operator

#include "string_table.h"

namespace gnash {

class as_object;
class fn_call;
class as_function;
class sprite_instance;
class character;
class asNamespace;
class asName;

#ifndef HAVE_ISFINITE
# ifndef isfinite 
#  define isfinite finite
# endif 
#endif 

#ifndef NAN
#       define NAN (std::numeric_limits<double>::quiet_NaN())
#endif

#ifndef INFINITY
#       define INFINITY (std::numeric_limits<double>::infinity())
#endif


#ifndef isnan
# define isnan(x) \
(sizeof (x) == sizeof (long double) ? isnan_ld (x) \
: sizeof (x) == sizeof (double) ? isnan_d (x) \
: isnan_f (x))
static inline int isnan_f  (float       x) { return x != x; }
static inline int isnan_d  (double      x) { return x != x; }
static inline int isnan_ld (long double x) { return x != x; }
#endif
          
#ifndef isinf
# define isinf(x) \
(sizeof (x) == sizeof (long double) ? isinf_ld (x) \
: sizeof (x) == sizeof (double) ? isinf_d (x) \
: isinf_f (x))
        static inline int isinf_f  (float       x) { return isnan (x - x); }
        static inline int isinf_d  (double      x) { return isnan (x - x); }
        static inline int isinf_ld (long double x) { return isnan (x - x); }
#endif

//#define PROPNAME(x) ( VM::get().getSWFVersion() < 7 ? boost::to_lower_copy(std::string(x)) : (x) )
#define PROPNAME(x) ( x )

enum primitive_types
{
        PTYPE_STRING,
        PTYPE_NUMBER,
        PTYPE_BOOLEAN
};

//
class DSOEXPORT as_value
{
public:
        enum type
        {
                // Always make the exception type one greater than the normal type.
                
                UNDEFINED,
                UNDEFINED_EXCEPT,

                NULLTYPE,
                NULLTYPE_EXCEPT,

                BOOLEAN,
                BOOLEAN_EXCEPT,

                STRING,
                STRING_EXCEPT,

                NUMBER, 
                NUMBER_EXCEPT,

                OBJECT,
                OBJECT_EXCEPT,

                AS_FUNCTION,
                AS_FUNCTION_EXCEPT,

                MOVIECLIP,
                MOVIECLIP_EXCEPT
        };

        as_value();

        as_value(const as_value& v);

        as_value(const char* str);

        as_value(const std::string& str);

        as_value(bool val);

        as_value(int val);

        as_value(unsigned int val);

        as_value(float val);

        as_value(double val);

        as_value(long val);
        
        as_value(unsigned long val);

        as_value(asNamespace &) {}

        //
        as_value(as_object* obj);

        as_value(boost::intrusive_ptr<as_object> obj);

        as_value(as_function* func);

        ~as_value();

        //
        static std::string doubleToString(double val, int radix=10);

        //
        void    drop_refs() {}

        const char* typeOf() const;

        primitive_types ptype() const;

        // Chad: Document
        bool conforms_to(string_table::key name);

        bool is_function() const
        {
                return m_type == AS_FUNCTION;
        }

        bool is_as_function() const
        {
                return m_type == AS_FUNCTION;
        }

        //
        bool is_string() const
        {
                return m_type == STRING;
        }

        //
        bool is_number() const
        {
                return m_type == NUMBER;
        }

        bool is_object() const
        {
                return m_type == OBJECT || m_type == AS_FUNCTION || m_type == MOVIECLIP;
        }

        bool is_sprite() const
        {
                return m_type == MOVIECLIP;
        }

        //
        std::string to_string() const;

        std::string to_debug_string() const;

        //
        std::string to_string_versioned(int version) const;

        //
        double  to_number() const;

        //
        boost::int32_t  to_int() const;

        //
        template <typename T>
        T to_number () const
        {
                return static_cast<T>(to_number());
        }

        //
        bool    to_bool() const;

        //
        bool    to_bool_v7() const;

        //
        bool    to_bool_v6() const;

        //
        bool    to_bool_v5() const;

        //
        boost::intrusive_ptr<as_object> to_object() const;

        //
        sprite_instance* to_sprite(bool skipRebinding=false) const;

        //
        character* to_character(bool skipRebinding=false) const;

        as_function*    to_as_function() const;

        //
        as_value to_primitive() const;

        //
        as_value to_primitive(type hint) const;

        //
        void    convert_to_number();

        void    convert_to_string();
    
        void    convert_to_boolean();
    
        //
        void    convert_to_string_versioned(int version);

        // These set_*()'s are more type-safe; should be used
        // in preference to generic overloaded set().  You are
        // more likely to get a warning/error if misused.

        void    set_string(const std::string& str);

        void    set_std_string(const std::string& str)
        {
                set_string(str);
        }

        void    set_string(const char* str)
        {
                set_string(std::string(str));
        }

        void    set_double(double val);

        void    set_bool(bool val);

        void    set_sprite(sprite_instance& sp);

        void    set_character(character& sp);

        void    set_int(int val) { set_double(val); }

        void    set_nan() { set_double(NAN); }

        //
        void    set_as_object(as_object* obj);

        void    set_as_object(boost::intrusive_ptr<as_object> obj);

        void    set_as_function(as_function* func);

        void    set_undefined();

        void set_null();

        //
        bool operator==(const as_value& v) const
        {
                return strictly_equals(v);
        }

        //
        bool operator!=(const as_value& v) const {
                return ! ( *this  == v );
        }

        void    operator=(const as_value& v);

        bool    is_undefined() const { return (m_type == UNDEFINED); }

        bool    is_null() const { return (m_type == NULLTYPE); }

        bool    is_bool() const { return (m_type == BOOLEAN); }

        bool    is_exception() const
        { return (m_type == UNDEFINED_EXCEPT || m_type == NULLTYPE_EXCEPT
                || m_type == BOOLEAN_EXCEPT || m_type == NUMBER_EXCEPT
                || m_type == OBJECT_EXCEPT || m_type == AS_FUNCTION_EXCEPT
                || m_type == MOVIECLIP_EXCEPT || m_type == STRING_EXCEPT);
        }

        // Flag or unflag an as_value as an exception -- this gets flagged
        // when an as_value is 'thrown'.
        void    flag_exception() 
        { if (!is_exception()) m_type = (type) ((int) m_type + 1); }
        void    unflag_exception()
        { if (is_exception()) m_type = (type) ((int) m_type - 1); }

        //
        bool strictly_equals(const as_value& v) const;

        //
        bool equals(const as_value& v) const;

        void    string_concat(const std::string& str);

        //
        void setReachable() const;

private:

        //
        class CharacterProxy {

                mutable character* _ptr;

                mutable std::string _tgt;

                static character* find_character_by_target(const std::string& target);

                void checkDangling() const;

        public:

                CharacterProxy(character* sp)
                        :
                        _ptr(sp)
                {
                        checkDangling();
                }

                //
                CharacterProxy(const CharacterProxy& sp)
                {
                        sp.checkDangling();
                        _ptr=sp._ptr;
                        if ( ! _ptr ) _tgt=sp._tgt;
                }

                //
                CharacterProxy& operator=(const CharacterProxy& sp)
                {
                        sp.checkDangling();
                        _ptr=sp._ptr;
                        if ( ! _ptr ) _tgt=sp._tgt;
                        return *this;
                }

                //
                character* get(bool skipRebinding=false) const
                {
                        if ( skipRebinding ) return _ptr;

                        checkDangling(); // set _ptr to NULL and _tgt to original target if destroyed
                        if ( _ptr ) return _ptr;
                        else return find_character_by_target(_tgt);
                }

                std::string getTarget() const;

                //
                bool isDangling() const
                {
                        checkDangling();
                        return !_ptr;
                }

                bool operator==(const CharacterProxy& sp) const
                {
                        return get() == sp.get();
                }

                //
                void setReachable() const;
        };

        //
        bool equalsSameType(const as_value& v) const;

        // TODO: make private. The rationale is that callers of this functions
        //       should use is_WHAT() instead, or changes in the available
        //       primitive value types will require modifications in all callers.
        //       This happened when adding MOVIECLIP.
        //
        type    get_type() const { return m_type; }

        type    m_type;

        typedef sprite_instance* SpritePtr;
        typedef character* CharacterPtr;
        typedef boost::intrusive_ptr<as_function> AsFunPtr;
        typedef boost::intrusive_ptr<as_object> AsObjPtr;

        boost::variant<  
                         boost::blank,  // UNDEFINED or NULL
                         double,        // NUMBER
                         bool,          // BOOLEAN
                         AsObjPtr,      // OBJECT,
//                        AsFuncPtr,    // AS_FUNCTION
                         CharacterProxy,        // MOVIECLIP
                         std::string    // STRING 
                      > _value;


        AsFunPtr getFun() const;

        AsObjPtr getObj() const;

        //
        SpritePtr getSprite(bool skipRebinding=false) const;

        //
        CharacterPtr getCharacter(bool skipRebinding=false) const;

        //
        CharacterProxy getCharacterProxy() const;

        double getNum() const
        {
                assert(m_type == NUMBER);
                return boost::get<double>(_value);
        }

        bool getBool() const
        {
                assert(m_type == BOOLEAN);
                return boost::get<bool>(_value);
        }

        const std::string& getStr() const
        {
                assert(m_type == STRING);
                return boost::get<std::string>(_value);
        }

};

typedef as_value (*as_c_function_ptr)(const fn_call& fn);

inline std::ostream& operator<< (std::ostream& os, const as_value& v) {
        return os << v.to_debug_string();
}

} // namespace gnash

#endif // GNASH_AS_VALUE_H

// Local Variables:
// mode: C++
// indent-tabs-mode: t
// End:

---