Subversion Repositories igor

#include <stdio.h>
#include <stdlib.h>
#include <err.h>
#include <string.h>
#include <errno.h>
 
#include "memory.h"
 
#include "types.h"
#include "regs.h"
#include "io.h"
#include "object.h"
 
static reg_t *memorybuf;
static unsigned int memorysize;
static char *memoryused;
int verify_written_memory;
 
int
memory_init(unsigned int memsz, char *memfile)
{
	printf("Allocating memory: 0x%X\n", memsz);
	memorybuf = calloc(memsz, sizeof(reg_t));
	if (memorybuf == NULL)
		return 0;
	memorysize = memsz;
	reg_set(REG_SP, memorysize);
	if (memfile != NULL)
		memory_load_from_file(memfile);
	memoryused = malloc(memsz);
	if (memoryused == NULL)
		err(1, "malloc(memoryused)");
	memset(memoryused, '\0', memsz);
 
	return 1;
}
 
void
memory_load_from_file(char *memfile)
{
	int i;
	FILE *f = fopen(memfile, "r");
	if (f == NULL)
		errx(1, "could not open memory file %s: %s",
		     memfile, strerror(errno));
 
	i = object_read(memorybuf, memorysize, f);
 
	if (ferror(f)) {
		err(1, "error reading memory file %s", memfile);
	}
 
	printf("0x%X memory objects read from %s\n",
	       i, memfile);
 
	fclose(f);
}
 
void
memory_write_to_file(char *memfile)
{
	memory_write_part_to_file(memfile, 0, memorysize);
}
 
void
memory_write_part_to_file(char *memfile, int start, int length)
{
	FILE *f = fopen(memfile, "w");
	if (f == NULL)
		errx(1, "could not open memory file %s for writing: %s",
		     memfile, strerror(errno));
 
	if (object_write(&memorybuf[start], length, f) < length)
		err(1, "error writing memory file %s", memfile);
 
	fclose(f);
}
 
 
void
memory_set(unsigned int pos, reg_t value)
{
	if ((pos & IO_AREA_MASK) == IO_AREA_MASK) {
		io_memory_set(pos & ~IO_AREA_MASK, value);
		return;
	}
	if (pos < 0 || pos >= memorysize)
		errx(1, "Trying to store outside of memory region: 0x%X", pos);
	memorybuf[pos] = value;
	memoryused[pos] = 1;
}
 
reg_t
memory_get(unsigned int pos)
{
	if ((pos & IO_AREA_MASK) == IO_AREA_MASK) {
		return io_memory_get(pos & ~IO_AREA_MASK);
	}
	if (pos < 0 || pos >= memorysize)
		errx(1, "Trying to load outside of memory region: 0x%X", pos);
	if (memoryused[pos] == 0 && verify_written_memory == 1)
		warnx("Reading from unwritten memory position: 0x%X", pos);
 
	return memorybuf[pos];
}
 
int
memory_size(void)
{
	return memorysize;
}