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

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


#include "gnash.h"
#include "types.h"

//#include <cwchar>
#include <boost/cstdint.hpp> // for boost::uint8_t
#include <vector> // for composition

#include "smart_ptr.h"

// Forward declarations
namespace gnash {
        class as_environment;
        class as_value;
        class movie_definition;
}


namespace gnash {

class ActionExec;

//
//
class action_buffer
{
public:
        friend class ActionExec;

        action_buffer(const movie_definition& md);

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

        bool is_null() const
        {
                return m_buffer.size() < 1 || m_buffer[0] == 0;
        }

        // kept for backward compatibility, should drop and see
        // what breaks.
        size_t get_length() const { return size(); }

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

        boost::uint8_t operator[] (size_t off) const
        {
                assert(off < m_buffer.size() );
                return m_buffer[off];
        }

        std::string disasm(size_t pc) const;

        //
        const char* read_string(size_t pc) const
        {
                //assert(pc < m_buffer.size() );
                return (const char*)(&m_buffer[pc]);
        }

        boost::uint32_t read_V32(size_t pc, boost::uint8_t& length) const
        {
                boost::uint32_t res = m_buffer[pc];
                if (!(res & 0x00000080))
                {
                        length = 1;
                        return res;
                }
                res = res & 0x0000007F | m_buffer[pc + 1] << 7;
                if (!(res & 0x00004000))
                {
                        length = 2;
                        return res;
                }
                res = res & 0x00003FFF | m_buffer[pc + 2] << 14;
                if (!(res & 0x00200000))
                {
                        length = 3;
                        return res;
                }
                res = res & 0x001FFFFF | m_buffer[pc + 3] << 21;
                if (!(res & 0x10000000))
                {
                        length = 4;
                        return res;
                }
                res = res & 0x0FFFFFFF | m_buffer[pc + 4] << 28;
                length = 5;
                return res;
        }

        const unsigned char* getFramePointer(size_t pc) const
        {
                return reinterpret_cast<const unsigned char*>(&m_buffer[pc]);
        }

        const unsigned char* getCodeStart()
        {
                return reinterpret_cast<const unsigned char*>(&m_buffer);
        }

        const unsigned char* get_buffer(size_t pc) const
        {
                //assert(pc < m_buffer.size() );
                return (const unsigned char*)(&m_buffer[pc]);
        }

        //
        boost::int16_t read_int16(size_t pc) const
        {
                boost::int16_t ret = m_buffer[pc] | (m_buffer[pc + 1] << 8);
                return ret;
        }

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

        //
        boost::int32_t read_int32(size_t pc) const
        {
                boost::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;

        size_t dictionary_size() const
        {
                return m_dictionary.size();
        }

        const char* dictionary_get(size_t n) const
        {
                return m_dictionary[n];
        }

        //
        void process_decl_dict(size_t start_pc, size_t stop_pc) const;

        const std::string& getDefinitionURL() const;

private:

        // Don't put these as values in std::vector<>!  They contain
        // internal pointers and cannot be moved or copied.
        // If you need to keep an array of them, keep pointers
        // to new'd instances.
        action_buffer(const action_buffer& a) : _src(a._src) { abort(); }

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

        mutable std::vector<const char*> m_dictionary;

        mutable int m_decl_dict_processed_at;

        //
        const movie_definition& _src;
};


}       // end namespace gnash


#endif // GNASH_ACTION_BUFFER_H


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

---