Memory.cpp

   1 #include "Memory.h"
   2 #include <memory.h>
   3 #include <fstream>
   4
   5 #include "Format.h"
   6 #include "AccessViolation.h"
   7
   8 namespace avr {
   9         Memory::Memory(unsigned int size) : siz(size) {
  10                 mem = new unsigned char[size];
  11         }
  12
  13         Memory::~Memory() {
  14                 delete [] mem;
  15         }
  16
  17         void Memory::write(unsigned int offset, unsigned char *block, unsigned int size /*= 1*/) {
  18                 if( offset + size > siz )
  19                         throw AccessViolation("Memory::write: writing too much to memory");
  20
  21                 memcpy( mem + offset, block, size );
  22         }
  23
  24         void Memory::fill(unsigned char val) {
  25                 memset( mem, val, siz );
  26         }
  27
  28         const unsigned char *Memory::read(unsigned int offset, unsigned int size /*= 1*/) const {
  29                 if( offset + size > siz )
  30                         throw AccessViolation("Memory::read: reads too far");
  31
  32                 return mem + offset;
  33         }
  34
  35         /**
  36          * Reads \e size bytes of raw data from memory starting at
  37          * offset \e offset. It returns a pointer to this data.
  38          *
  39          * \exception RuntimeException { When the data requested is
  40          *              not available, this exception is thrown }
  41          */
  42         byte Memory::readByte(unsigned int offset) const {
  43                 if( offset >= siz )
  44                         throw AccessViolation("Memory::read: reads too far");
  45
  46                 return mem[ offset ];
  47         }
  48
  49         word Memory::readWord(unsigned int offset) const {
  50                 if( offset >= siz )
  51                         throw AccessViolation("Memory::read: reads too far");
  52
  53                 return *((word *)(mem + offset));
  54         }
  55
  56         void Memory::dump(const char *fname) const {
  57                 std::ofstream fout( fname, std::ios::out | std::ios::binary );
  58                 if( ! fout.is_open() )
  59                         throw AccessViolation( util::format("Memory::dump: failed to open file: %s") % fname );
  60
  61                 fout.write( reinterpret_cast<const char *>(mem), siz );
  62         }
  63
  64 }