SRecord.h

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

namespace Rose {
namespace BinaryAnalysis {

class SRecord {
public:
    enum Syntax {
        SREC_MOTOROLA,                                  
        SREC_INTEL,                                     
        SREC_UNKNOWN_SYNTAX                             
    };

    enum Type {
        // Motorola
        SREC_M_HEADER,                                  
        SREC_M_DATA16,                                  
        SREC_M_DATA24,                                  
        SREC_M_DATA32,                                  
        SREC_M_RESERVED,                                
        SREC_M_COUNT16,                                 
        SREC_M_COUNT24,                                 
        SREC_M_START32,                                 
        SREC_M_START24,                                 
        SREC_M_START16,                                 
        // Intel
        SREC_I_DATA,                                    
        SREC_I_END,                                     
        SREC_I_EXTENDED_SA,                             
        SREC_I_START_SA,                                
        SREC_I_EXTENDED_LA,                             
        SREC_I_START_LA,                                
        SREC_UNKNOWN_TYPE                               
    };

private:
    Type type_;
    rose_addr_t addr_;
    std::vector<uint8_t> data_;
    std::string error_;

    // Constructors, etc.
public:
    SRecord(): type_(SREC_UNKNOWN_TYPE), addr_(0) {}

    SRecord(Type type, rose_addr_t addr, const std::vector<uint8_t> data)
        : type_(type), addr_(addr), data_(data) {}
    SRecord(Type type, rose_addr_t addr, const uint8_t *buffer, size_t bufsz)
        : type_(type), addr_(addr), data_(buffer+0, buffer+bufsz) {}
    // High-level functions.
public:
    static SRecord parse(const std::string&);

    static std::vector<SRecord> parse(std::istream&);

    static AddressIntervalSet dataAddresses(const std::vector<SRecord>&);

    static AddressIntervalSet createSegments(const std::vector<SRecord>&, const MemoryMap::Ptr &map, rose_addr_t alignment,
                                             unsigned accessPermissions, const std::string &segmentName,
                                             MemoryMap::Clobber clobber);

    static Sawyer::Optional<rose_addr_t> load(const std::vector<SRecord>&, const MemoryMap::Ptr&);

    static Sawyer::Optional<rose_addr_t> load(const std::vector<SRecord>&, const MemoryMap::Ptr&, rose_addr_t alignment,
                                               unsigned accessPerms, const std::string &name, MemoryMap::Clobber);

    static std::vector<SRecord> create(const MemoryMap::Ptr&, Syntax, size_t bytesPerRecord=28, size_t preferredAddrSize=4);

    std::string toString() const;

    void print(std::ostream&) const;
    friend std::ostream& operator<<(std::ostream&, const SRecord&);
    // S-Record properties.
public:
    Syntax syntax() const;

    Type type() const { return type_; }
    SRecord& type(Type type) { type_ = type; return *this; }
    rose_addr_t address() const { return addr_; }
    SRecord& address(rose_addr_t addr) { addr_ = addr; return *this; }
    const std::vector<uint8_t>& data() const { return data_; }
    std::vector<uint8_t>& data() { return data_; }
    SRecord& data(const std::vector<uint8_t>& data) { data_ = data; return *this; }
    const std::string& error() const { return error_; }
    SRecord& error(const std::string &error) { error_ = error; return *this; }
    // Low-level functions.
public:
    class RunLengthEncoding {
        Sawyer::Optional<rose_addr_t> dataVa_, executionVa_;
        size_t nDataRecords_;
    public:
        RunLengthEncoding()
            : nDataRecords_(0) {}

        void insert(const SRecord&);

        Sawyer::Optional<rose_addr_t> dataAddress(const SRecord&) const;

        rose_addr_t baseDataAddress() const;

        Sawyer::Optional<rose_addr_t> executionAddress() const;

        size_t nDataRecords() const { return nDataRecords_; }
    };

    static SRecord parseMotorola(const std::string&);

    static SRecord parseIntel(const std::string&);

    static Sawyer::Optional<rose_addr_t> parseBigEndianInteger(const std::string&, size_t start, size_t nChars);

    static unsigned bigEndian(const std::vector<uint8_t> &data, size_t nBytes);

    static size_t addressNBytes(Type);

    static uint8_t checksum(Syntax, const std::string&, size_t start, size_t n);
};

} // namespace
} // namespace

#endif
#endif