ActionExec.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_ACTIONEXEC_H
#define GNASH_ACTIONEXEC_H

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

#include "with_stack_entry.h"
#include "as_environment.h" // for ensureStack
#include "smart_ptr.h"

#include <vector>

// Forward declarations
namespace gnash {
        class action_buffer;
        class as_value;
        class swf_function;
        class ActionExec;
}

namespace gnash {

class tryBlock
{
public:
        friend class ActionExec;

        enum tryState
        {
                TRY_TRY, // In a try block.
                TRY_CATCH, // In a catch block.
                TRY_FINALLY // In a finally block.
        };

    tryBlock(size_t cur_off, size_t try_size, size_t catch_size,
                size_t finally_size, std::string catchName, int stack_depth)
                : mCatchOffset(cur_off + try_size),
                mFinallyOffset(cur_off + try_size + catch_size),
                mAfterTriedOffset(cur_off + try_size + catch_size + finally_size),
                mNamed(true), mName(catchName), mReg(), mState(tryBlock::TRY_TRY),
                mThrownFromCatch(), mStackDepth(stack_depth)
        {}

        tryBlock(size_t cur_off, size_t try_size, size_t catch_size,
                size_t finally_size, boost::uint8_t register_index, int stack_depth)
                : mCatchOffset(cur_off + try_size),
                mFinallyOffset(cur_off + try_size + catch_size),
                mAfterTriedOffset(cur_off + try_size + catch_size + finally_size),
                mNamed(false), mName(), mReg(register_index),
                mState(tryBlock::TRY_TRY), mThrownFromCatch(),
                mStackDepth(stack_depth)
        {}

private:
        size_t mCatchOffset;
        size_t mFinallyOffset;
        size_t mAfterTriedOffset;
        size_t mSavedEndOffset;
        bool mNamed;
        std::string mName;
        boost::uint8_t mReg;
        tryState mState;
        as_value mThrownFromCatch;
        boost::uint32_t mStackDepth;
};

class ActionExec {

private: 

        //
        void dumpActions(size_t start, size_t end, std::ostream& os);

        // 
        const std::vector<with_stack_entry>& getWithStack() const
        {
                return with_stack;
        }


        //
        void cleanupAfterRun(bool expectInconsistencies=false);

        std::vector<with_stack_entry> with_stack;

        typedef as_environment::ScopeStack ScopeStack;

        ScopeStack _scopeStack;

        //
        size_t _with_stack_limit;

        int _function_var;

        const swf_function* _func;

        boost::intrusive_ptr<as_object> _this_ptr;

        size_t _initial_stack_size;

        size_t _initialCallStackDepth;

        character* _original_target;

        std::list<tryBlock> mTryList;

        bool mReturning;

        //
        void fixStackUnderrun(size_t required);

        bool _abortOnUnload;

        boost::uint32_t getScriptTimeout();

public:

        //
        void ensureStack(size_t required)
        {
                // The stack_size() < _initial_stack_size case should
                // be handled this by stack smashing checks
                assert( env.stack_size() >= _initial_stack_size );

                size_t slots_left = env.stack_size() - _initial_stack_size;
                if ( slots_left < required )
                {
                        fixStackUnderrun(required);
                }
        }

        void pushTryBlock(tryBlock& t);

        void pushReturn(const as_value& t);

        //
        const action_buffer& code;

        //
        size_t pc;

        //
        size_t stop_pc;

        size_t next_pc;

        as_environment& env;

        as_value* retval;

        //
        ActionExec(const action_buffer& abuf, as_environment& newEnv, bool abortOnUnloaded=true);

        //
        ActionExec(const swf_function& func, as_environment& newEnv, as_value* nRetVal, as_object* this_ptr);

        bool isFunction2() { return _function_var==2; }

        bool isFunction() { return _function_var!=0; }

        as_object* getThisPointer();

        //
        const ScopeStack& getScopeStack() const
        {
                return _scopeStack;
        }

        //
        size_t getWithStackLimit() const 
        {
                return _with_stack_limit;
        }

        //
        bool pushWithEntry(const with_stack_entry& entry);

        //
        void skip_actions(size_t offset);

        //
        bool delVariable(const std::string& name);

        //
        bool delObjectMember(as_object& obj, const std::string& name);

        //
        void setVariable(const std::string& name, const as_value& val);

        //
        void setLocalVariable(const std::string& name, const as_value& val);

        //
        as_value getVariable(const std::string& name);

        //
        as_value getVariable(const std::string& name, as_object** target);

        //
        void setObjectMember(as_object& obj, const std::string& name, const as_value& val);

        //
        bool getObjectMember(as_object& obj, const std::string& name, as_value& val);

        //
        as_object* getTarget();

        void operator() ();
};

} // namespace gnash

#endif // GNASH_ACTIONEXEC_H

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

---