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

#include <string>
#include <stack>
#include <vector>
#include <boost/noncopyable.hpp>

#include "as_environment.h" 
#include "SWF.h"
#include "action_buffer.h"

// Forward declarations
namespace gnash {
        class as_value;
        class 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.
                TRY_END // Finished with finally
        };

    TryBlock(size_t cur_off, size_t try_size, size_t catch_size,
                size_t finally_size, std::string catchName)
                :
                _catchOffset(cur_off + try_size),
                _finallyOffset(cur_off + try_size + catch_size),
                _afterTriedOffset(cur_off + try_size + catch_size + finally_size),
                _savedEndOffset(0),
                _hasName(true),
                _name(std::move(catchName)),
                _registerIndex(0),
                _tryState(TryBlock::TRY_TRY),
                _lastThrow()
        {}

        TryBlock(size_t cur_off, size_t try_size, size_t catch_size,
                size_t finally_size, std::uint8_t register_index)
                :
                _catchOffset(cur_off + try_size),
                _finallyOffset(cur_off + try_size + catch_size),
                _afterTriedOffset(cur_off + try_size + catch_size + finally_size),
                _savedEndOffset(0),
                _hasName(false),
                _name(),
                _registerIndex(register_index),
                _tryState(TryBlock::TRY_TRY),
                _lastThrow()
        {}

private:
        size_t _catchOffset;
        size_t _finallyOffset;
        size_t _afterTriedOffset;
        size_t _savedEndOffset;
        bool _hasName;
        std::string _name;
        unsigned int _registerIndex;
        tryState _tryState;
        as_value _lastThrow;
};

class With
{
public: 

        With(as_object* obj, size_t end)
                :
                _object(obj),
                _block_end_pc(end)
        {
        }

        size_t end_pc() const {
                return _block_end_pc;
        }

        as_object* object() const {
                return _object;
        }

private:
        as_object* _object;
        size_t _block_end_pc;
};

class ActionExec : boost::noncopyable
{

    typedef as_environment::ScopeStack ScopeStack;

public:

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

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

        void pushTryBlock(TryBlock t);

        void pushReturn(const as_value& t);

        //
        const action_buffer& code;

        as_environment& env;

        as_value* retval;

        bool isFunction() const { return _func != nullptr; }

        as_object* getThisPointer();

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

        //
        bool pushWith(const With& entry);

        //
        void skip_actions(size_t offset);

        //
        bool delVariable(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_object** target = nullptr);

        //
        as_object* getTarget();

        void operator()();

    // TODO: cut down these accessors.
    bool atActionTag(SWF::ActionType t) { return code[pc] == t; }
        
        size_t getCurrentPC() const { return pc; }
        
        void skipRemainingBuffer() { next_pc = stop_pc; }
        
        void adjustNextPC(int offset);
        
        size_t getNextPC() const { return next_pc; }
        
        void setNextPC(size_t pc) { next_pc = pc; }
        
        size_t getStopPC() const { return stop_pc; }
        
private: 

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

    //
    //
    bool processExceptions(TryBlock& t);

        //
        void cleanupAfterRun();

        std::vector<With> _withStack;

        ScopeStack _scopeStack;

        const Function* _func;

        as_object* _this_ptr;

        size_t _initialStackSize;

        DisplayObject* _originalTarget;

        int _origExecSWFVersion;

        std::stack<TryBlock> _tryList;

        bool _returning;

        bool _abortOnUnload;

        size_t pc;

        size_t next_pc;

        size_t stop_pc;

};

} // namespace gnash

#endif // GNASH_ACTIONEXEC_H

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