Remote Access Control

hexfile.cpp

Go to the documentation of this file.

// This file has been prepared for Doxygen automatic documentation generation.
#include "hexfile.h"
#include <iomanip>
#include <stdexcept>



#define HEXDATARECORDTYPE ( (byte) 0x00 )
#define HEXEOFRECORDTYPE ( (byte) 0x01 )



void HEXRecord::Add( byte data )
{
        if( data > 255 ) {
                throw std::runtime_error( "Data larger than 255" );
        }

        m_data.push_back( data );
}



void HEXRecord::Add( std::vector< byte > data )
{
        for( size_t idx = 0; idx < data.size(); ++idx ) {
                Add( data.at( idx ) );
        }
}



void HEXRecord::Print( std::ostream & os ) const
{
        if( GetByteCount() > 255 ) {
                throw std::runtime_error( "HEX record have more than 255 data bytes" );
        }

        if( m_address > 65535 ) {
                throw std::runtime_error( "HEX record base address exceeds 16 bits" );
        }

        if( m_address + GetByteCount() > 65536 ) {
                throw std::runtime_error( "HEX record data crosses segment boundary" );
        }

        byte checksum = 0;
        checksum += GetByteCount(); // First byte in record.
        checksum += m_address & 0xff; // Second byte in record.
        checksum += (m_address >> 8) & 0xff; // Third byte in record.
        checksum += HEXDATARECORDTYPE; // Fourth byte in record.

        os << ":" << std::setfill('0') << std::hex
                << std::setw(2) << GetByteCount()
                << std::setw(2) << ((m_address >> 8) & 0xff)
                << std::setw(2) << (m_address & 0xff)
                << std::setw(2) << HEXDATARECORDTYPE;

        for( size_t idx = 0; idx < GetByteCount(); ++idx ) {
                byte data = m_data.at( idx );
                os << std::setw(2) << data;
                checksum += data;
        }

        os << std::setw(2) << ((-checksum) & 0xff) // 2's complement of total sum.
                << std::endl;
}



HEXRecord & operator<<( HEXRecord & record, byte data )
{
        record.Add( data );
        return record;
}



HEXRecord & operator<<( HEXRecord & record, std::vector< byte > data )
{
        record.Add( data );
        return record;
}



std::ostream & operator<<( std::ostream & os, const HEXRecord & record )
{
        record.Print( os );
        return os;
}



void HEXFile::Print( std::ostream & os ) const
{
        for( size_t idx = 0; idx < m_records.size(); ++idx ) {
                os << m_records.at( idx );
        }
        os << ":00000001ff" << std::endl;
}



HEXFile & operator<<( HEXFile & file, const HEXRecord & record )
{
        file.Add( record );
        return file;
}



std::ostream & operator<<( std::ostream & os, const HEXFile & file )
{
        file.Print( os );
        return os;
}