hex-editor/src/source-memory.c

#include "source.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gint/defs/util.h>

static memory_region_t REGION_ROM = {
    .start    = 0x80000000,
    .end      = 0x82000000,
    .writable = false,
    .name     = "ROM",
};
static memory_region_t REGION_RAM = {
    .start    = 0x8c000000,
    .end      = 0x8c800000,
    .writable = true,
    .name     = "RAM",
};
static memory_region_t REGION_ILRAM = {
    .start    = 0xe5200000,
    .end      = 0xe5201000,
    .writable = true,
    .name     = "ILRAM",
};
static memory_region_t REGION_XYRAM = {
    .start    = 0xe500e000,
    .end      = 0xe5012000,
    .writable = true,
    .name     = "XRAM/YRAM",
};
static memory_region_t REGION_RS = {
    .start    = 0xfd800000,
    .end      = 0xfd800800,
    .writable = false,
    .name     = "RS",
};

memory_region_t *memory_all_regions[] = {
    &REGION_ROM,
    &REGION_RAM,
    &REGION_ILRAM,
    &REGION_XYRAM,
    &REGION_RS,
    NULL,
};

static ssize_t mr_read(void *_cookie, void *buf, off_t offset, size_t size)
{
    memory_region_t *mr = _cookie;
    int mr_size = mr->end - mr->start;

    if(offset < 0 || offset >= mr_size)
        return -1;
    size = min(size, mr_size - offset);

    memcpy(buf, (void *)mr->start + offset, size);
    return size;
}

static bool mr_write(void *_cookie, void *data, size_t data_size, off_t offset,
    size_t segment_size)
{
    memory_region_t *mr = _cookie;
    int mr_size = mr->end - mr->start;
    if(data_size != segment_size)
        return false;

    if(offset < 0 || offset >= mr_size)
        return -1;
    data_size = min(data_size, mr_size - offset);

    memcpy((void *)mr->start + offset, data, data_size);
    return true;
}

static size_t mr_size(void *_cookie)
{
    memory_region_t *mr = _cookie;
    return mr->end - mr->start;
}

static bool mr_dirty(void *_cookie)
{
    (void)_cookie;
    return false;
}

static bool mr_save(void *_cookie, char const *outfile)
{
    (void)_cookie;
    return (outfile == NULL);
}

static void mr_close(void *_cookie)
{
    (void)_cookie;
}

static source_intf_t mr_intf = {
    .name = "Memory",
    .close_on_return_to_menu = false,
    .read = mr_read,
    .write = mr_write,
    .size = mr_size,
    .dirty = mr_dirty,
    .save = mr_save,
    .close = mr_close,
};

source_t *source_memory_open(memory_region_t *region)
{
    char path[128];
    sprintf(path, "%s (%08X)", region->name, region->start);
    source_t *source = source_open(&mr_intf, region, path);
    if(!source)
        return NULL;

    source->cap = region->writable ? SOURCE_WRITE : 0;
    source->address_base = region->start;
    return source;
}