fn_call.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_FN_CALL_H
#define GNASH_FN_CALL_H

#include <string>
#include <vector>
#include <cassert> 
#include <ostream>
#include <algorithm>

#include "utility.h" // for typeName
#include "as_object.h"
#include "as_value.h"
#include "VM.h"
#include "GnashException.h"
#include "as_environment.h"


// Forward declarations
namespace gnash {
    class movie_definition;
}

namespace gnash {

//
//
//
//
template<typename T>
class FunctionArgs
{
public:

    typedef typename std::vector<T>::size_type size_type;
    typedef std::vector<T> container_type;
    typedef T value_type;

    FunctionArgs() = default;
    FunctionArgs(FunctionArgs&& other) = default;

    FunctionArgs(const FunctionArgs& other) = default;

    FunctionArgs& operator+=(T t) {
        _v.push_back(std::move(t));
        return *this;
    }

    FunctionArgs& operator,(T t) {
        _v.push_back(std::move(t));
        return *this;
    }

    template <typename U>
    FunctionArgs& operator,(U&& u) {
        _v.emplace_back(std::forward<U>(u));
        return *this;
    }

    template <typename U>
    FunctionArgs& operator+=(U&& u) {
        _v.emplace_back(std::forward<U>(u));
        return *this;
    }

    //
    void setReachable() const {
        std::for_each(_v.begin(), _v.end(),
                      std::mem_fun_ref(&as_value::setReachable));
    }

    void swap(std::vector<T>& to) {
        std::swap(_v, to);
    }

    size_type size() const {
        return _v.size();
    }

private:
    std::vector<T> _v;
};


class fn_call
{
public:

    typedef FunctionArgs<as_value> Args;

    //
    fn_call(as_object* this_in, const as_environment& env_in,
            Args& args, as_object* sup = nullptr, bool isNew = false)
        :
        this_ptr(this_in),
        super(sup),
        nargs(args.size()),
        callerDef(nullptr),
        _env(env_in),
        _new(isNew)
    {
        args.swap(_args);
    }
    
    fn_call(as_object* this_in, const as_environment& env_in)
        :
        this_ptr(this_in),
        super(nullptr),
        nargs(0),
        callerDef(nullptr),
        _env(env_in),
        _new(false)
        {
        }
    
    fn_call(const fn_call& fn)
        :
        this_ptr(fn.this_ptr),
        super(fn.super),
        nargs(fn.nargs),
        callerDef(fn.callerDef),
        _env(fn._env),
        _args(fn._args),
        _new(false)
        {
        }
    
    as_object* this_ptr;
    
    //
    as_object* super;
    
    Args::size_type nargs;
    
    const movie_definition* callerDef;
    
    VM& getVM() const {
        return _env.getVM();
    }
    
    bool isInstantiation() const {
        return _new;
        }
    
    const Args::value_type& arg(unsigned int n) const {
        assert(n < nargs);
        return _args[n]; 
        }
    
    const Args::container_type& getArgs() const {
        return _args;
    }
    
    void drop_bottom() {
        assert(!_args.empty());
        _args.erase(_args.begin());
        --nargs;
        }
    
    const as_environment& env() const {
        return _env;
        }
    
    void dump_args(std::ostream& os) const {
        for (size_t i = 0; i < nargs; ++i) {
            if (i) os << ", ";
            os << arg(i);
        }
        }
    
    void resetArgs() {
        nargs = 0;
        _args.clear();
        }
    
    void pushArg(const Args::value_type& arg) {
        ++nargs;
        _args.push_back(arg);
        }
    
private:

    const as_environment& _env;
    
    Args::container_type _args;
    
    bool _new;
    
};


//
template<typename T>
struct ThisIsNative
{
    typedef T value_type;
    value_type* operator()(const as_object* o) const {
        return dynamic_cast<value_type*>(o->relay());
    }
};

//
template<typename T = DisplayObject>
struct IsDisplayObject
{
    typedef T value_type;
    value_type* operator()(const as_object* o) const {
        if (!o) return nullptr;
        return dynamic_cast<T*>(o->displayObject());
    }
};

struct ValidThis
{
    typedef as_object value_type;
    value_type* operator()(as_object* o) const {
        return o;
    }
};

//
//
//
template<typename T>
typename T::value_type*
ensure(const fn_call& fn)
{
    as_object* obj = fn.this_ptr;
    if (!obj) throw ActionTypeError();
    
    typename T::value_type* ret = T()(obj);
    
    if (!ret) {
        std::string target = typeName(ret);
        std::string source = typeName(obj);

        std::string msg = "Function requiring " + target + " as 'this' "
            "called from " + source + " instance.";

        throw ActionTypeError(msg);
    }
    return ret;
}

inline string_table&
getStringTable(const fn_call& fn)
{
    return fn.getVM().getStringTable();
}

inline movie_root&
getRoot(const fn_call& fn)
{
    return fn.getVM().getRoot();
}

inline int
getSWFVersion(const fn_call& fn)
{
    return fn.getVM().getSWFVersion();
}

inline VM&
getVM(const fn_call& fn)
{
    return fn.getVM();
}

inline Global_as&
getGlobal(const fn_call& fn)
{
    return *fn.getVM().getGlobal();
}

} // namespace gnash


#endif 


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