src/Memory.cpp

   1 /*
   2  *      avr-sim: An atmel AVR simulator
   3  *  Copyright (C) 2008  Tom Haber
   4  *
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "Memory.h"
  20 #include <memory.h>
  21 #include <fstream>
  22
  23 #include "Format.h"
  24 #include "AccessViolation.h"
  25
  26 namespace avr {
  27         Memory::Memory(unsigned int size) : siz(size) {
  28                 mem = new unsigned char[size];
  29         }
  30
  31         Memory::~Memory() {
  32                 delete [] mem;
  33         }
  34
  35         void Memory::write(unsigned int offset, unsigned char *block, unsigned int size /*= 1*/) {
  36                 if( offset + size > siz )
  37                         throw AccessViolation("Memory::write: writing too much to memory");
  38
  39                 memcpy( mem + offset, block, size );
  40         }
  41
  42         void Memory::fill(unsigned char val) {
  43                 memset( mem, val, siz );
  44         }
  45
  46         const unsigned char *Memory::read(unsigned int offset, unsigned int size /*= 1*/) const {
  47                 if( offset + size > siz )
  48                         throw AccessViolation("Memory::read: reads too far");
  49
  50                 return mem + offset;
  51         }
  52
  53         /**
  54          * Reads \e size bytes of raw data from memory starting at
  55          * offset \e offset. It returns a pointer to this data.
  56          *
  57          * \exception RuntimeException { When the data requested is
  58          *              not available, this exception is thrown }
  59          */
  60         byte Memory::readByte(unsigned int offset) const {
  61                 if( offset >= siz )
  62                         throw AccessViolation("Memory::read: reads too far");
  63
  64                 return mem[ offset ];
  65         }
  66
  67         word Memory::readWord(unsigned int offset) const {
  68                 if( offset >= siz )
  69                         throw AccessViolation("Memory::read: reads too far");
  70
  71                 return *((word *)(mem + offset));
  72         }
  73
  74         void Memory::dump(const char *fname) const {
  75                 std::ofstream fout( fname, std::ios::out | std::ios::binary );
  76                 if( ! fout.is_open() )
  77                         throw AccessViolation( util::format("Memory::dump: failed to open file: %s") % fname );
  78
  79                 fout.write( reinterpret_cast<const char *>(mem), siz );
  80         }
  81
  82 }