action_buffer.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_ACTION_BUFFER_H
#define GNASH_ACTION_BUFFER_H

#include <string>
#include <vector> 
#include <map> 
#include <boost/noncopyable.hpp>
#include <cstdint>

#include "GnashException.h"
#include "ConstantPool.h"
#include "log.h"

// Forward declarations
namespace gnash {
        class as_value;
        class movie_definition;
        class SWFStream; // for read signature
}

namespace gnash {

//
//
class action_buffer : boost::noncopyable
{
public:

        action_buffer(const movie_definition& md);

        //
        void read(SWFStream& in, unsigned long endPos);

        size_t size() const { return m_buffer.size(); }

        std::uint8_t operator[] (size_t off) const
        {
                if (off >= m_buffer.size()) {
                    throw ActionParserException (_("Attempt to read outside "
                                    "action buffer"));
                }
                return m_buffer[off];
        }

        std::string disasm(size_t pc) const;

        //
        const char* read_string(size_t pc) const
        {
                assert(pc <= m_buffer.size() );
        if (pc == m_buffer.size())
        {
            throw ActionParserException(_("Asked to read string when only "
                "1 byte remains in the buffer"));
        }
                return reinterpret_cast<const char*>(&m_buffer[pc]);
        }

        const unsigned char* getFramePointer(size_t pc) const
        {
                assert (pc < m_buffer.size());
                return &m_buffer.at(pc);
        }

        //
        std::int16_t read_int16(size_t pc) const
        {
            if (pc + 1 >= m_buffer.size()) {
                throw ActionParserException(_("Attempt to read outside action buffer limits"));
            }
                std::int16_t ret = (m_buffer[pc] | (m_buffer[pc + 1] << 8));
                return ret;
        }

        std::uint16_t read_uint16(size_t pc) const
        {
                return static_cast<std::uint16_t>(read_int16(pc));
        }

        //
        std::int32_t read_int32(size_t pc) const
        {
                if (pc + 3 >= m_buffer.size()) {
                throw ActionParserException(_("Attempt to read outside action buffer limits"));
            }
            
                std::int32_t    val = m_buffer[pc]
                      | (m_buffer[pc + 1] << 8)
                      | (m_buffer[pc + 2] << 16)
                      | (m_buffer[pc + 3] << 24);
                return val;
        }

        //
        float read_float_little(size_t pc) const;

        //
        double read_double_wacky(size_t pc) const;

        const char* dictionary_get(size_t n) const
        {
        if ( _pools.empty() ) return nullptr;

        // We'll query the last inserted one for now (highest PC)
        const ConstantPool& pool = _pools.rbegin()->second;

        if ( n < pool.size() ) return pool[n];

        else return nullptr;
        }

        //
        const ConstantPool& readConstantPool(size_t start_pc, size_t stop_pc) const;

        const std::string& getDefinitionURL() const;

        int getDefinitionVersion() const;

    const movie_definition& getMovieDefinition() const {
        return _src;
    }

private:

        std::vector<std::uint8_t> m_buffer;

        typedef std::map<size_t, ConstantPool> PoolsMap;
        mutable PoolsMap _pools;

        //
        const movie_definition& _src;
};


}       // end namespace gnash


#endif // GNASH_ACTION_BUFFER_H


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