as_environment.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_ENVIRONMENT_H
#define GNASH_AS_ENVIRONMENT_H

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

#include "as_value.h" // for composition (vector + frame_slot)
#include "StringPredicates.h" // for Variables 
#include "as_object.h"

#include <map> // for composition (Variables)
#include <string> // for frame_slot name
#include <vector>
#include <iostream> // for dump_stack inline

namespace gnash {

// Forward declarations
class character;
//class with_stack_entry;

class as_environment
{
public:

        //typedef std::vector<with_stack_entry> ScopeStack;
        typedef std::vector< boost::intrusive_ptr<as_object> > ScopeStack;

        std::vector<as_value>   m_stack;

        as_environment()
                :
                m_stack(),
                m_target(0),
                _original_target(0)
        {
        }

        character* get_target() { return m_target; }
        void set_target(character* target);

        character* get_original_target() { return _original_target; }

        // Reset target to its original value
        void reset_target() { m_target = _original_target; }


        void    push(const as_value& val)
        {
                m_stack.push_back(val);
        }


        as_value pop()
        {
                assert( ! m_stack.empty() );
                as_value result = m_stack.back();
                m_stack.pop_back();
                return result;
        }

        //
        as_value& top(size_t dist)
        {
                size_t ssize = m_stack.size();
                assert ( ssize > dist );
                return m_stack[ssize - 1 - dist];
        }

        //
        as_value& bottom(size_t index)
        {
                assert ( m_stack.size() > index );
                return m_stack[index];
        }

        void drop(size_t count)
        {
                size_t ssize = m_stack.size();
                assert ( ssize >= count );
                m_stack.resize(ssize - count);
        }

        //
        void padStack(size_t offset, size_t count);

        // FIXME: what if stack is empty ??
        // I'd obsolete this and convert calling code to use
        // stack_size() instead.
        int     get_top_index() const { return m_stack.size() - 1; }

        size_t stack_size() const { return m_stack.size(); }


        //
        as_value get_variable(const std::string& varname) const;

        //
        bool del_variable_raw(const std::string& varname,
                        const ScopeStack& scopeStack);

        //
        as_value get_variable(const std::string& varname,
                const ScopeStack& scopeStack, as_object** retTarget=NULL) const;

        //
        void set_variable(const std::string& path, const as_value& val);

        //
        void set_variable_raw(const std::string& var, const as_value& val);

        //
        void set_variable(const std::string& path, const as_value& val,
                const ScopeStack& scopeStack);

        //
        void set_local(const std::string& varname, const as_value& val);

        void add_local(const std::string& varname, const as_value& val);

        void    declare_local(const std::string& varname);

        //
        void add_local_registers(unsigned int register_count)
        {
                assert(!_localFrames.empty());
                return _localFrames.back().registers.resize(register_count);
        }

        //
        size_t num_local_registers() const
        {
                assert(!_localFrames.empty());
                return _localFrames.back().registers.size();
        }

        //
        as_value& local_register(boost::uint8_t n)
        {
                assert(!_localFrames.empty());
                return _localFrames.back().registers[n];
        }

        void set_local_register(boost::uint8_t n, as_value &val)
        {
                if ( ! _localFrames.empty() )
                {
                        Registers& registers = _localFrames.back().registers;
                        if ( n < registers.size() )
                        {
                                registers[n] = val;
                        }
                }
        }

        as_value& global_register(unsigned int n)
        {
                assert(n<4);
                return m_global_register[n];
        }

        void set_global_register(boost::uint8_t n, as_value &val) {
            if (n <= 4) {
                m_global_register[n] = val;
            }
        }

#ifdef GNASH_USE_GC
        //
        void markReachableResources() const;
#endif

        //
        character* find_target(const std::string& path) const;

        //
        as_object* find_object(const std::string& path, const ScopeStack* scopeStack=NULL) const;

        void dump_stack(std::ostream& out=std::cerr)
        {
                out << "Stack: ";
                for (unsigned int i=0, n=m_stack.size(); i<n; i++)
                {
                        if (i) out << " | ";
                        out << '"' << m_stack[i] << '"';
                }
                out << std::endl;
        }

        //
        void dump_local_registers(std::ostream& out=std::cerr) const;

        void dump_global_registers(std::ostream& out=std::cerr) const;

        void dump_local_variables(std::ostream& out=std::cerr) const;

        //
        int get_version() const;

        static bool parse_path(const std::string& var_path, std::string& path,
                        std::string& var);

        //
        bool parse_path(const std::string& var_path, as_object** target, as_value& val);

        typedef std::map<std::string, as_value, StringNoCaseLessThen> Variables;

        //typedef std::vector<frame_slot>       LocalVars;
        typedef boost::intrusive_ptr<as_object> LocalVars;

        typedef std::vector<as_value> Registers;

        struct CallFrame
        {
                CallFrame(as_function* funcPtr);

                CallFrame(const CallFrame& other) : locals(other.locals),
                        registers(other.registers), func(other.func)
                {}

                LocalVars locals;

                Registers registers;

                as_function* func;

#ifdef GNASH_USE_GC
                //
                void markReachableResources() const;
#endif // GNASH_USE_GC
        };

        class FrameGuard
        {
        public:
                FrameGuard(as_function* func)
                { as_environment::pushCallFrame(func); }
                ~FrameGuard() { as_environment::popCallFrame(); }
        };

        //
        CallFrame& topCallFrame()
        {
                assert(!_localFrames.empty());
                return _localFrames.back();
        }

        size_t callStackDepth()
        {
                return _localFrames.size();
        }

private:

        static const short unsigned int numGlobalRegisters = 4;

        typedef std::vector<CallFrame> CallStack;
                
        static CallStack _localFrames;

        as_value m_global_register[numGlobalRegisters];

        character* m_target;

        character* _original_target;

        //
        static void pushCallFrame(as_function* func);

        //
        static void popCallFrame();
        
        //
        as_value get_variable_raw(const std::string& varname) const;

        void set_variable_raw(const std::string& path, const as_value& val,
                const ScopeStack& scopeStack);

        as_value get_variable_raw(const std::string& varname,
                const ScopeStack& scopeStack, as_object** retTarget=NULL) const;


        //
        bool findLocal(const std::string& varname, as_value& ret, as_object** retTarget=NULL);

        bool findLocal(const std::string& varname, as_value& ret, as_object** retTarget=NULL) const
        {
                return const_cast<as_environment*>(this)->findLocal(varname, ret, retTarget);
        }

        //
        static bool findLocal(LocalVars& locals, const std::string& name, as_value& ret);

        //
        bool delLocal(const std::string& varname);

        //
        static bool delLocal(LocalVars& locals, const std::string& varname);

        //
        bool setLocal(const std::string& varname, const as_value& val);

        //
        static bool setLocal(LocalVars& locals, const std::string& varname, const as_value& val);

};


} // end namespace gnash


#endif // GNASH_AS_ENVIRONMENT_H


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

---