MemoryState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryState_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryState_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>

#include <boost/enable_shared_from_this.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/shared_ptr.hpp>

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {

//                                      Memory State

class MemoryState: public boost::enable_shared_from_this<MemoryState> {
public:
    typedef MemoryStatePtr Ptr;

private:
    SValuePtr addrProtoval_;                            
    SValuePtr valProtoval_;                             
    ByteOrder::Endianness byteOrder_;                   
    MergerPtr merger_;
    bool byteRestricted_;                               // are cell values all exactly one byte wide?

    // Serialization
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(addrProtoval_);
        s & BOOST_SERIALIZATION_NVP(valProtoval_);
        s & BOOST_SERIALIZATION_NVP(byteOrder_);
        //s & merger_ -- not saved
        s & BOOST_SERIALIZATION_NVP(byteRestricted_);
    }
#endif


    // Real constructors
protected:
    MemoryState();                                      // for serialization
    MemoryState(const SValuePtr &addrProtoval, const SValuePtr &valProtoval);
    MemoryState(const MemoryStatePtr &other);

public:
    virtual ~MemoryState();

    // Static allocating constructors. None needed since this class is abstract

    // Virtual constructors
public:
    virtual MemoryStatePtr create(const SValuePtr &addrProtoval, const SValuePtr &valProtoval) const = 0;

    virtual MemoryStatePtr clone() const = 0;

    // Dynamic pointer casts.  No-op since this is the base class.
public:
    static MemoryStatePtr promote(const MemoryStatePtr&);

    // Methods first declared at this level of the class hierarchy
public:
    MergerPtr merger() const;
    void merger(const MergerPtr&);
    SValuePtr get_addr_protoval() const;

    SValuePtr get_val_protoval() const;

    virtual void clear() = 0;

    bool byteRestricted() const;
    void byteRestricted(bool);
    ByteOrder::Endianness get_byteOrder() const;
    void set_byteOrder(ByteOrder::Endianness);
    virtual bool merge(const MemoryStatePtr &other, RiscOperators *addrOps, RiscOperators *valOps) = 0;

    virtual SValuePtr readMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) = 0;

    virtual SValuePtr peekMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) = 0;

    virtual void writeMemory(const SValuePtr &addr, const SValuePtr &value,
                             RiscOperators *addrOps, RiscOperators *valOps) = 0;


    virtual void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const = 0;

    void print(std::ostream&, const std::string prefix = "") const;
    virtual void print(std::ostream&, Formatter&) const = 0;
    class WithFormatter {
        MemoryStatePtr obj;
        Formatter &fmt;
    public:
        ~WithFormatter();
        WithFormatter() = delete;
        WithFormatter(const MemoryStatePtr&, Formatter&);
        void print(std::ostream&) const;
    };

    WithFormatter with_format(Formatter&);
    WithFormatter operator+(Formatter&);
    WithFormatter operator+(const std::string &linePrefix);
};

std::ostream& operator<<(std::ostream&, const MemoryState&);
std::ostream& operator<<(std::ostream&, const MemoryState::WithFormatter&);

} // namespace
} // namespace
} // namespace
} // namespace

BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryState);

#endif
#endif