as_value.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   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_VALUE_H
#define GNASH_AS_VALUE_H

#include "dsodefs.h"
#include "CharacterProxy.h"

#include <limits>
#include <string>
#include <boost/variant.hpp>
#include <iosfwd> // for inlined output operator
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/cstdint.hpp>

#include "utility.h" // UNUSED

// Forward declarations
namespace gnash {
    class VM;
        class as_object;
        class Global_as;
        class fn_call;
        class as_function;
        class MovieClip;
        class DisplayObject;
    namespace amf {
        class Writer;
    }
}

namespace gnash {


// NaN constant for use in as_value implementation
static const double NaN = std::numeric_limits<double>::quiet_NaN();

// The following template works just like its C counterpart, with added
// type safety (i.e., they will only compile for floating point arguments).
template <typename T>
inline bool
isNaN(const T& num, typename boost::enable_if<boost::is_floating_point<T> >::
        type* dummy = 0)
{
        UNUSED(dummy);
        return num != num;
}

template <typename T>
inline bool
isInf(const T& num)
{
        return isNaN(num - num);
}


enum primitive_types
{
        PTYPE_STRING,
        PTYPE_NUMBER,
        PTYPE_BOOLEAN
};

//
//
//
//
//
//
class as_value
{

public:

    // The exception type should always be one greater than the normal type.
    enum AsType
    {
        UNDEFINED,
        UNDEFINED_EXCEPT,
        NULLTYPE,
        NULLTYPE_EXCEPT,
        BOOLEAN,
        BOOLEAN_EXCEPT,
        STRING,
        STRING_EXCEPT,
        NUMBER, 
        NUMBER_EXCEPT,
        OBJECT,
        OBJECT_EXCEPT,
        DISPLAYOBJECT,
        DISPLAYOBJECT_EXCEPT
    };
    
    DSOEXPORT as_value()
        :
        _type(UNDEFINED),
        _value(boost::blank())
    {
    }
    
    DSOEXPORT as_value(const as_value& v)
        :
        _type(v._type),
        _value(v._value)
    {
    }

    ~as_value() {}
    
    DSOEXPORT as_value(const char* str)
        :
        _type(STRING),
        _value(std::string(str))
    {}

    DSOEXPORT as_value(const std::string& str)
        :
        _type(STRING),
        _value(std::string(str))
    {}
    
    template <typename T>
    as_value(T val, typename boost::enable_if<boost::is_same<bool, T> >::type*
             dummy = 0)
        :
        _type(BOOLEAN),
        _value(val)
        {
        UNUSED(dummy);
        }
    
    as_value(double num)
        :
        _type(NUMBER),
        _value(num)
    {}
    
    as_value(as_object* obj)
        :
        _type(UNDEFINED)
    {
        set_as_object(obj);
    }
    
    DSOEXPORT as_value& operator=(const as_value& v)
    {
        _type = v._type;
        _value = v._value;
        return *this;
    }

    friend std::ostream& operator<<(std::ostream& o, const as_value&);
    
    const char* typeOf() const;
    
    bool is_function() const;
    
    bool is_string() const {
        return _type == STRING;
    }
    
    bool is_number() const {
        return _type == NUMBER;
    }
    
    //
    bool is_object() const {
        return _type == OBJECT || _type == DISPLAYOBJECT;
    }
    
    bool is_sprite() const {
        return _type == DISPLAYOBJECT;
    }
    
    //
    //
    std::string to_string(int version = 7) const;
    
    //
    double to_number(int version) const;
    
    //
    bool to_bool(int version) const;
    
    //
    //
    //
    as_object* to_object(VM& vm) const;

    //
    as_object* get_object() const;
    
    //
    //
    MovieClip* toMovieClip(bool skipRebinding = false) const;
    
    //
    //
    DisplayObject* toDisplayObject(bool skipRebinding = false) const;

    //
    as_function* to_function() const;
    
    AsType defaultPrimitive(int version) const;
    
    //
    //
    as_value to_primitive(AsType hint) const;
    
    void set_string(const std::string& str);
    
    void set_double(double val);
    
    void set_bool(bool val);

    void set_as_object(as_object* obj);
    
    void set_undefined();
    
    void set_null();
    
    bool is_undefined() const {
        return (_type == UNDEFINED);
    }
    
    bool is_null() const {
        return (_type == NULLTYPE);
    }
    
    bool is_bool() const {
        return (_type == BOOLEAN);
    }
    
    bool is_exception() const {
        return (_type == UNDEFINED_EXCEPT || _type == NULLTYPE_EXCEPT
                || _type == BOOLEAN_EXCEPT || _type == NUMBER_EXCEPT
                || _type == OBJECT_EXCEPT || _type == DISPLAYOBJECT_EXCEPT
                || _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()) {
            _type = static_cast<AsType>(static_cast<int>(_type) + 1);
        }
    }
    
    void unflag_exception() {
        if (is_exception()) {
            _type = static_cast<AsType>(static_cast<int>(_type) - 1);
        }
    }
    
    //
    bool strictly_equals(const as_value& v) const;
    
    //
    bool equals(const as_value& v, int version) const;
    
    //
    void setReachable() const;
    
    //
    bool writeAMF0(amf::Writer& w) const;

private:

    //
    typedef boost::variant<boost::blank,
                           double,
                           bool,
                           as_object*,
                           CharacterProxy,
                           std::string>
    AsValueType;
    
    bool operator==(const as_value& v) const;
    
    bool operator!=(const as_value& v) const;
    
    //
    bool equalsSameType(const as_value& v) const;
    
    AsType _type;
    
    AsValueType _value;
    
    //
    as_object* getObj() const;
    
    //
    DisplayObject* getCharacter(bool skipRebinding = false) const;

    //
    CharacterProxy getCharacterProxy() const;

    //
    double getNum() const {
        assert(_type == NUMBER);
        return boost::get<double>(_value);
    }
    
    //
    bool getBool() const {
        assert(_type == BOOLEAN);
        return boost::get<bool>(_value);
    }

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

std::ostream& operator<<(std::ostream& os, const as_value& v);

//
// Printing formats:
//
// If _val > 1, Print up to 15 significant digits, then switch
// to scientific notation, rounding at the last place and
// omitting trailing zeroes.
// For values < 1, print up to 4 leading zeroes after the
// decimal point, then switch to scientific notation with up
// to 15 significant digits, rounding with no trailing zeroes
// If the value is negative, just add a '-' to the start; this
// does not affect the precision of the printed value.
//
// This almost corresponds to iomanip's std::setprecision(15)
// format, except that iomanip switches to scientific notation
// at e-05 not e-06, and always prints at least two digits for the exponent.
std::string doubleToString(double val, int radix = 10);

//
bool parseNonDecimalInt(const std::string& s, double& d, bool whole = true);

inline void
setNaN(as_value& v) {
    v.set_double(NaN);
}

} // namespace gnash

#endif // GNASH_AS_VALUE_H

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