static FLOPPY_CONSTRUCT(oric_dsk_construct)
{
struct FloppyCallbacks *callbacks;
struct oricdsk_tag *tag;
UINT8 header[mfm_disk_header_size];
floppy_image_read(floppy, header, 0, mfm_disk_header_size);
tag = (struct oricdsk_tag *) floppy_create_tag(floppy, sizeof(struct oricdsk_tag));
if (!tag)
return FLOPPY_ERROR_OUTOFMEMORY;
tag->heads = pick_integer_le(header, 8, 4);
tag->tracks = pick_integer_le(header, 12, 4);
tag->geometry = pick_integer_le(header, 16, 4);
tag->tracksize = TRACK_SIZE_MFM;
memset(tag->sector_data,0,sizeof(tag->sector_data));
callbacks = floppy_callbacks(floppy);
callbacks->read_sector = oric_read_sector;
callbacks->write_sector = oric_write_sector;
callbacks->read_indexed_sector = oric_read_indexed_sector;
callbacks->write_indexed_sector = oric_write_indexed_sector;
callbacks->get_sector_length = oric_get_sector_length;
callbacks->get_heads_per_disk = oric_get_heads_per_disk;
callbacks->get_tracks_per_disk = oric_get_tracks_per_disk;
callbacks->get_indexed_sector_info = oric_get_indexed_sector_info;
return FLOPPY_ERROR_SUCCESS;
}
/* return a directory entry for an index */
static imgtoolerr_t vzdos_get_dirent(imgtool_image *img, int index, vzdos_dirent *ent)
{
int ret, entry;
UINT8 buffer[DATA_SIZE + 2];
ret = vzdos_read_sector_data(img, 0, (int) index / 8, buffer);
if (ret) return (imgtoolerr_t)ret;
entry = ((index % 8) * sizeof(vzdos_dirent));
memcpy(ent, &buffer[entry], 10);
ent->start_track = pick_integer_le(&buffer[entry], 10, 1);
ent->start_sector = pick_integer_le(&buffer[entry], 11, 1);
ent->start_address = pick_integer_le(&buffer[entry], 12, 2);
ent->end_address = pick_integer_le(&buffer[entry], 14, 2);
if (ent->ftype == 0x00)
return IMGTOOLERR_FILENOTFOUND;
/* check values */
if (ent->start_track > 39)
return IMGTOOLERR_CORRUPTFILE;
if (ent->start_sector > 15)
return IMGTOOLERR_CORRUPTFILE;
return IMGTOOLERR_SUCCESS;
}
bool g64_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
UINT64 size = io_generic_size(io);
dynamic_buffer img(size);
io_generic_read(io, &img[0], 0, size);
if (img[POS_VERSION]) {
throw emu_fatalerror("g64_format: Unsupported version %u", img[POS_VERSION]);
}
int track_count = img[POS_TRACK_COUNT];
int head = 0;
for (int track = 0; track < track_count; track++)
{
int cylinder = track % TRACK_COUNT;
if (track == TRACK_COUNT)
head = 1;
UINT32 tpos = POS_TRACK_OFFSET + (track * 4);
UINT32 spos = tpos + (track_count * 4);
UINT32 dpos = pick_integer_le(&img[0], tpos, 4);
if (!dpos)
continue;
if (dpos > size)
throw emu_fatalerror("g64_format: Track %u offset %06x out of bounds", track, dpos);
UINT32 speed_zone = pick_integer_le(&img[0], spos, 4);
if (speed_zone > 3)
throw emu_fatalerror("g64_format: Unsupported variable speed zones on track %d", track);
UINT16 track_bytes = pick_integer_le(&img[0], dpos, 2);
int track_size = track_bytes * 8;
LOG_FORMATS("head %u track %u offs %u size %u cell %ld\n", head, cylinder, dpos, track_bytes, 200000000L/track_size);
generate_track_from_bitstream(cylinder, head, &img[dpos+2], track_size, image);
}
if (!head)
image->set_variant(floppy_image::SSSD);
else
image->set_variant(floppy_image::DSSD);
return true;
}
static imgtoolerr_t vzsnapshot_writefile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *sourcef, option_resolution *opts)
{
imgtoolerr_t ret;
int fnameopt;
vzdos_dirent entry;
UINT8 header[24];
/* get header infos from file */
stream_read(sourcef, header, sizeof(header));
/* prepare directory entry */
entry.ftype = header[21] == 0xF1 ? 'B' : 'T';
entry.delimitor = ':';
entry.start_address = pick_integer_le(header, 22, 2);
/* filename from header or directly? */
fnameopt = option_resolution_lookup_int(opts, 'F');
if (fnameopt == 0) {
memcpy(&entry.fname, &header[4], 8);
} else {
/* TODO: check for leading spaces and strip */
if (strlen(filename) > 8 || strlen(filename) < 1)
return IMGTOOLERR_BADFILENAME;
memcpy(&entry.fname, filename, strlen(filename) - 3);
}
/* write file to disk */
ret = vzdos_writefile(partition, 24, sourcef, &entry);
if (ret) return ret;
return IMGTOOLERR_SUCCESS;
}
SNAPSHOT_LOAD_MEMBER( vtech1_state, vtech1 )
{
address_space &space = m_maincpu->space(AS_PROGRAM);
UINT8 i, header[24];
UINT16 start, end, size;
char pgmname[18];
/* get the header */
image.fread( &header, sizeof(header));
for (i = 0; i < 16; i++) pgmname[i] = header[i+4];
pgmname[16] = '\0';
/* get start and end addresses */
start = pick_integer_le(header, 22, 2);
end = start + snapshot_size - sizeof(header);
size = end - start;
/* check if we have enough ram */
if (m_ram_size < size)
{
char message[256];
snprintf(message, ARRAY_LENGTH(message), "SNAPLOAD: %s\nInsufficient RAM - need %04X",pgmname,size);
image.seterror(IMAGE_ERROR_INVALIDIMAGE, message);
image.message("SNAPLOAD: %s\nInsufficient RAM - need %04X",pgmname,size);
return IMAGE_INIT_FAIL;
}
/* write it to ram */
image.fread( &m_ram_pointer[start - 0x7800], size);
/* patch variables depending on snapshot type */
switch (header[21])
{
case VZ_BASIC: /* 0xF0 */
space.write_byte(0x78a4, start % 256); /* start of basic program */
space.write_byte(0x78a5, start / 256);
space.write_byte(0x78f9, end % 256); /* end of basic program */
space.write_byte(0x78fa, end / 256);
space.write_byte(0x78fb, end % 256); /* start variable table */
space.write_byte(0x78fc, end / 256);
space.write_byte(0x78fd, end % 256); /* start free mem, end variable table */
space.write_byte(0x78fe, end / 256);
image.message(" %s (B)\nsize=%04X : start=%04X : end=%04X",pgmname,size,start,end);
break;
case VZ_MCODE: /* 0xF1 */
space.write_byte(0x788e, start % 256); /* usr subroutine address */
space.write_byte(0x788f, start / 256);
image.message(" %s (M)\nsize=%04X : start=%04X : end=%04X",pgmname,size,start,end);
m_maincpu->set_pc(start); /* start program */
break;
default:
image.seterror(IMAGE_ERROR_UNSUPPORTED, "Snapshot format not supported.");
image.message("Snapshot format not supported.");
return IMAGE_INIT_FAIL;
}
return IMAGE_INIT_PASS;
}
bool vic20_expansion_slot_device::call_load()
{
if (m_cart)
{
size_t size = 0;
if (software_entry() == NULL)
{
if (!mame_stricmp(filetype(), "20")) fread(m_cart->vic20_blk1_pointer(machine(), 0x2000), 0x2000);
else if (!mame_stricmp(filetype(), "40")) fread(m_cart->vic20_blk2_pointer(machine(), 0x2000), 0x2000);
else if (!mame_stricmp(filetype(), "60")) fread(m_cart->vic20_blk3_pointer(machine(), 0x2000), 0x2000);
else if (!mame_stricmp(filetype(), "70")) fread(m_cart->vic20_blk3_pointer(machine(), 0x2000) + 0x1000, 0x1000);
else if (!mame_stricmp(filetype(), "a0")) fread(m_cart->vic20_blk5_pointer(machine(), 0x2000), 0x2000);
else if (!mame_stricmp(filetype(), "b0")) fread(m_cart->vic20_blk5_pointer(machine(), 0x2000) + 0x1000, 0x1000);
else if (!mame_stricmp(filetype(), "crt"))
{
// read the header
UINT8 header[2];
fread(&header, 2);
UINT16 address = pick_integer_le(header, 0, 2);
if (LOG) logerror("Address %04x\n", address);
switch (address)
{
case 0x2000: fread(m_cart->vic20_blk1_pointer(machine(), 0x2000), 0x2000); break;
case 0x4000: fread(m_cart->vic20_blk2_pointer(machine(), 0x2000), 0x2000); break;
case 0x6000: fread(m_cart->vic20_blk3_pointer(machine(), 0x2000), 0x2000); break;
case 0x7000: fread(m_cart->vic20_blk3_pointer(machine(), 0x2000) + 0x1000, 0x1000); break;
case 0xa000: fread(m_cart->vic20_blk5_pointer(machine(), 0x2000), 0x2000); break;
case 0xb000: fread(m_cart->vic20_blk5_pointer(machine(), 0x2000) + 0x1000, 0x1000); break;
default: return IMAGE_INIT_FAIL;
}
}
}
else
{
size = get_software_region_length("blk1");
if (size) memcpy(m_cart->vic20_blk1_pointer(machine(), size), get_software_region("blk1"), size);
size = get_software_region_length("blk2");
if (size) memcpy(m_cart->vic20_blk2_pointer(machine(), size), get_software_region("blk2"), size);
size = get_software_region_length("blk3");
if (size) memcpy(m_cart->vic20_blk3_pointer(machine(), size), get_software_region("blk3"), size);
size = get_software_region_length("blk5");
if (size) memcpy(m_cart->vic20_blk5_pointer(machine(), size), get_software_region("blk5"), size);
size = get_software_region_length("ram");
if (size) memcpy(m_cart->vic20_ram_pointer(machine(), size), get_software_region("ram"), size);
size = get_software_region_length("nvram");
if (size) memcpy(m_cart->vic20_nvram_pointer(machine(), size), get_software_region("nvram"), size);
}
}
return IMAGE_INIT_PASS;
}
bool dsk_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
UINT8 header[100];
bool extendformat = FALSE;
io_generic_read(io, &header, 0, sizeof(header));
if ( memcmp( header, EXT_FORMAT_HEADER, 16 ) ==0) {
extendformat = TRUE;
}
int heads = header[0x31];
int skip = 1;
if (heads==1) {
skip = 2;
}
int tracks = header[0x30];
UINT64 track_offsets[84*2];
int cnt =0;
if (!extendformat) {
int tmp = 0x100;
for (int i=0; i<tracks * heads; i++)
{
track_offsets[cnt] = tmp;
tmp += pick_integer_le(header, 0x32, 2);
cnt += skip;
}
} else {
int tmp = 0x100;
for (int i=0; i<tracks * heads; i++)
{
track_offsets[cnt] = tmp;
tmp += header[0x34 + i] << 8;
cnt += skip;
}
}
int counter = 0;
for(int track=0; track < tracks; track++) {
for(int side=0; side < heads; side++) {
// read location of
track_header tr;
io_generic_read(io, &tr,track_offsets[(track<<1)+side],sizeof(tr));
//printf("%d,%d %d, %d\n",track,side,tr.track_number, tr.gap3_length);
//int sec_location = track_offsets[(track<<1)+side] + 0x100;
for(int j=0;j<tr.number_of_sector;j++)
{
sector_header sector;
io_generic_read(io, §or,track_offsets[(track<<1)+side]+sizeof(tr)+(sizeof(sector)*j),sizeof(sector));
//printf("sec %02x %08x\n",sector.sector_id,sec_location);
//sec_location += sector.data_lenght;
}
counter++;
}
}
return FALSE;
}
static imgtoolerr_t vzdos_diskimage_readfile(imgtool_partition *partition, const char *filename, const char *fork, imgtool_stream *destf)
{
imgtoolerr_t ret;
imgtool_image *image = imgtool_partition_image(partition);
int filesize, track, sector;
vzdos_dirent ent;
UINT8 buffer[DATA_SIZE + 2];
ret = vzdos_get_dirent_fname(image, filename, &ent);
if (ret) return ret;
filesize = ent.end_address - ent.start_address;
track = ent.start_track;
sector = ent.start_sector;
while (filesize > 0) {
int towrite;
ret = vzdos_read_sector_data(image, track, sector, buffer);
if (ret) return ret;
/* detect sectors pointing to themselfs */
if ((track == pick_integer_le(buffer, DATA_SIZE, 1)) && (sector == pick_integer_le(buffer, DATA_SIZE + 1, 1)))
return IMGTOOLERR_CORRUPTIMAGE;
/* load next track and sector values */
track = pick_integer_le(buffer, DATA_SIZE, 1);
sector = pick_integer_le(buffer, DATA_SIZE + 1, 1);
/* track 0 is invalid */
if ((track == 0) && (filesize > DATA_SIZE))
return IMGTOOLERR_CORRUPTIMAGE;
/* write either DATA_SIZE or the remaining bytes */
towrite = filesize > DATA_SIZE ? DATA_SIZE : filesize;
if (stream_write(destf, buffer, towrite) != towrite)
return IMGTOOLERR_WRITEERROR;
filesize -= DATA_SIZE;
}
return IMGTOOLERR_SUCCESS;
}
static FLOPPY_IDENTIFY(oric_dsk_identify)
{
UINT8 header[mfm_disk_header_size];
floppy_image_read(floppy, header, 0, mfm_disk_header_size);
if ( memcmp( header, MFM_ID, 8 ) ==0) {
int heads = pick_integer_le(header, 8, 4);
int tracks = pick_integer_le(header, 12, 4);
if (floppy_image_size(floppy)==((tracks*heads*TRACK_SIZE_MFM)+mfm_disk_header_size)) {
*vote = 100;
} else {
*vote = 0;
}
} else {
*vote = 0;
}
return FLOPPY_ERROR_SUCCESS;
}
bool g64_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
UINT64 size = io_generic_size(io);
UINT8 *img = global_alloc_array(UINT8, size);
io_generic_read(io, img, 0, size);
if (img[VERSION]) {
throw emu_fatalerror("g64_format: Unsupported version %u", img[VERSION]);
}
int track_count = img[TRACK_COUNT];
int head = 0;
for (int track = 0; track < track_count; track++)
{
offs_t track_offset = pick_integer_le(img, TRACK_OFFSET + (track * 4), 4);
if (!track_offset)
continue;
if (track_offset > size)
throw emu_fatalerror("g64_format: Track %u offset %06x out of bounds", track, track_offset);
offs_t speed_zone = pick_integer_le(img, SPEED_ZONE + (track * 4), 4);
if (speed_zone > 3)
throw emu_fatalerror("g64_format: Unsupported variable speed zones on track %d", track);
UINT16 track_bytes = pick_integer_le(img, track_offset, 2);
int track_size = track_bytes * 8;
LOG_FORMATS("track %u size %u cell %ld\n", track, track_size, 200000000L/track_size);
generate_track_from_bitstream(track, head, &img[track_offset+2], track_size, image);
}
global_free(img);
image->set_variant(floppy_image::SSSD);
return true;
}
QUICKLOAD_LOAD_MEMBER( atom_state, atom_atm )
{
/*
The format for the .ATM files is as follows:
Offset Size Description
------ -------- -----------------------------------------------------------
0000h 16 BYTEs ATOM filename (if less than 16 BYTEs, rest is 00h bytes)
0010h WORD Start address for load
0012h WORD Execution address
0014h WORD Size of data in BYTEs
0016h Size Data
*/
uint8_t header[0x16] = { 0 };
void *ptr;
image.fread(header, 0x16);
uint16_t start_address = pick_integer_le(header, 0x10, 2);
uint16_t run_address = pick_integer_le(header, 0x12, 2);
uint16_t size = pick_integer_le(header, 0x14, 2);
if (LOG)
{
header[16] = 0;
logerror("ATM filename: %s\n", header);
logerror("ATM start address: %04x\n", start_address);
logerror("ATM run address: %04x\n", run_address);
logerror("ATM size: %04x\n", size);
}
ptr = m_maincpu->space(AS_PROGRAM).get_write_ptr(start_address);
image.fread(ptr, size);
m_maincpu->set_pc(run_address);
return image_init_result::PASS;
}
// this only works for some of the files, nothing which tries to load
// more data from tape. todo: tapes which autorun after loading
SNAPSHOT_LOAD_MEMBER( mtx_state, mtx )
{
address_space &program = m_maincpu->space(AS_PROGRAM);
void *ptr;
UINT8 header[18];
// read header
image.fread(&header, sizeof(header));
// verify first byte
if (header[0] != 0xff)
{
image.seterror(IMAGE_ERROR_INVALIDIMAGE, NULL);
return IMAGE_INIT_FAIL;
}
// get tape name
char tape_name[16];
memcpy(&tape_name, &header[1], 15);
tape_name[15] = '\0';
image.message("Loading '%s'", tape_name);
// start of system variables area
UINT16 system_variables_base = pick_integer_le(header, 16, 2);
// write system variables
UINT16 system_variables_size = 0;
if (system_variables_base != 0)
{
ptr = program.get_write_ptr(system_variables_base);
system_variables_size = 0xfb4b - system_variables_base;
image.fread(ptr, system_variables_size);
}
// write actual image data
UINT16 data_size = snapshot_size - 18 - system_variables_size;
ptr = program.get_write_ptr(0x4000);
image.fread(ptr, 0x4000);
// if we cross the page boundary, get a new write pointer and write the rest
if (data_size > 0x4000)
{
ptr = program.get_write_ptr(0x8000);
image.fread(ptr, 0x4000);
}
logerror("snapshot name = '%s', system_size = 0x%04x, data_size = 0x%04x\n", tape_name, system_variables_size, data_size);
return IMAGE_INIT_PASS;
}
/* return the actual data of a sector */
static imgtoolerr_t vzdos_read_sector_data(imgtool_image *img, int track, int sector, UINT8 *data)
{
int ret, data_start;
UINT8 buffer[DATA_SIZE + 4]; /* data + checksum */
ret = vzdos_get_data_start(img, track, sector, &data_start);
if (ret) return (imgtoolerr_t)ret;
ret = floppy_read_sector(imgtool_floppy(img), 0, track, sector_order[sector], data_start, &buffer, sizeof(buffer));
if (ret) return (imgtoolerr_t)ret;
/* verify sector checksums */
if (pick_integer_le(buffer, DATA_SIZE + 2, 2) != chksum16(buffer, DATA_SIZE + 2))
return IMGTOOLERR_CORRUPTFILE;
memcpy(data, &buffer, DATA_SIZE + 2);
return IMGTOOLERR_SUCCESS;
}
static UINT32 g64_get_track_size(floppy_image_legacy *floppy, int head, int track)
{
// get track offset
UINT32 track_length = 0;
UINT64 track_offset;
floperr_t err = get_track_offset(floppy, head, track, &track_offset);
if (err)
return 0;
// read track length
if (track_offset > 0)
{
UINT8 size[2];
floppy_image_read(floppy, &size, track_offset, 2);
track_length = pick_integer_le(size, 0, 2);
}
return track_length;
}
bool g64_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
UINT64 size = io_generic_size(io);
UINT8 *img = global_alloc_array(UINT8, size);
io_generic_read(io, img, 0, size);
int version = img[0x08];
if (version)
throw emu_fatalerror("g64_format: Unsupported version %u", version);
int track_count = img[0x09];
int pos = 0x0c;
int track_offset[84*2];
for(int track = 0; track < track_count; track++) {
track_offset[track] = pick_integer_le(img, pos, 4);
pos += 4;
}
int speed_zone_offset[84*2];
for(int track = 0; track < track_count; track++) {
speed_zone_offset[track] = pick_integer_le(img, pos, 4);
pos += 4;
}
for(int track = 0; track < track_count; track++) {
int track_size = 0;
pos = track_offset[track];
if (pos > 0) {
track_size = pick_integer_le(img, pos, 2);
pos +=2;
if (speed_zone_offset[track] > 3)
throw emu_fatalerror("g64_format: Unsupported variable speed zones on track %d", track);
UINT32 cell_size = c1541_cell_size[speed_zone_offset[track]];
int total_size = 200000000/cell_size;
UINT32 *buffer = global_alloc_array_clear(UINT32, total_size);
int offset = 0;
for (int i=0; i<track_size; i++, pos++) {
for (int bit=7; bit>=0; bit--) {
bit_w(buffer, offset++, BIT(img[pos], bit), cell_size);
if (offset == total_size) break;
}
}
if (offset < total_size) {
// pad the remainder of the track with sync
int count = (total_size-offset);
for (int i=0; i<count; i++) {
bit_w(buffer, offset++, 1, cell_size);
}
}
int physical_track = track >= 84 ? track - 84 : track;
int head = track >= 84;
generate_track_from_levels(physical_track, head, buffer, total_size, 0, image);
global_free(buffer);
}
}
image->set_variant(floppy_image::SSSD);
return true;
}
static void read_g64_header(floppy_image_legacy *floppy, struct g64dsk_tag *tag, int head, UINT64 &pos)
{
UINT8 header[HEADER_LENGTH];
UINT64 start_pos = pos;
// read header
floppy_image_read(floppy, header, pos, HEADER_LENGTH);
// get version
tag->version = header[8];
if (!head) LOG_FORMATS("G64 version: %u\n", tag->version);
// get number of tracks
tag->tracks = header[9];
LOG_FORMATS("G64 side %u tracks: %u\n", head, tag->tracks);
// get track size
UINT16 track_size = (header[0xb] << 8) | header[0xa];
// get data offsets
pos = 0xc;
for (int i = 0; i < tag->tracks; i++)
{
tag->track_offset[head][i] = pick_integer_le(header, pos, 4);
if (tag->track_offset[head][i])
{
tag->track_offset[head][i] += start_pos;
}
pos += 4;
}
// get speed zone information
UINT32 track_offs = 0;
for (int i = 0; i < tag->tracks; i++)
{
tag->speed_zone_offset[head][i] = pick_integer_le(header, pos, 4);
if (tag->speed_zone_offset[head][i] >= 4)
{
tag->speed_zone_offset[head][i] += start_pos;
}
pos += 4;
tag->track_size[head][i] = g64_get_track_size(floppy, head, i);
if (tag->track_offset[head][i] != 0)
{
LOG_FORMATS("G64 side %u track %.1f offset %05x length %04x ", head, get_dos_track(i), tag->track_offset[head][i], tag->track_size[head][i]);
track_offs = tag->track_offset[head][i];
if (tag->speed_zone_offset[head][i] < 4) {
LOG_FORMATS("speed %u\n", tag->speed_zone_offset[head][i]);
} else {
LOG_FORMATS("speed offset %04x\n", tag->speed_zone_offset[head][i]);
}
}
}
pos = track_offs + 2 + track_size;
}
SNAPSHOT_LOAD_MEMBER( vtech1_state, vtech1 )
{
address_space &space = m_maincpu->space(AS_PROGRAM);
uint8_t header[24];
char pgmname[18];
// get the header
image.fread(&header, sizeof(header));
// get image name
for (int i = 0; i < 16; i++)
pgmname[i] = header[i+4];
pgmname[16] = '\0';
// get start and end addresses
uint16_t start = pick_integer_le(header, 22, 2);
uint16_t end = start + snapshot_size - sizeof(header);
uint16_t size = end - start;
// write it to ram
uint8_t *ptr = (uint8_t *)image.ptr() + sizeof(header);
for (uint16_t addr = start; addr <= end; addr++, ptr++)
{
uint8_t to_write = *ptr;
space.write_byte(addr, to_write);
// verify
if (space.read_byte(addr) != to_write)
{
image.seterror(IMAGE_ERROR_INVALIDIMAGE, "Insufficient RAM to load snapshot");
image.message("Insufficient RAM to load snapshot (%d bytes needed) [%s]", size, pgmname);
return image_init_result::FAIL;
}
}
// patch variables depending on snapshot type
switch (header[21])
{
case VZ_BASIC:
space.write_byte(0x78a4, start % 256); /* start of basic program */
space.write_byte(0x78a5, start / 256);
space.write_byte(0x78f9, end % 256); /* end of basic program */
space.write_byte(0x78fa, end / 256);
space.write_byte(0x78fb, end % 256); /* start variable table */
space.write_byte(0x78fc, end / 256);
space.write_byte(0x78fd, end % 256); /* start free mem, end variable table */
space.write_byte(0x78fe, end / 256);
image.message(" %s (B)\nsize=%04X : start=%04X : end=%04X", pgmname, size, start, end);
break;
case VZ_MCODE:
space.write_byte(0x788e, start % 256); /* usr subroutine address */
space.write_byte(0x788f, start / 256);
image.message(" %s (M)\nsize=%04X : start=%04X : end=%04X", pgmname, size, start, end);
m_maincpu->set_pc(start); /* start program */
break;
default:
image.seterror(IMAGE_ERROR_UNSUPPORTED, "Snapshot format not supported.");
image.message("Snapshot format not supported.");
return image_init_result::FAIL;
}
return image_init_result::PASS;
}
/* deletes directory entry, clears trackmap entries and sectors */
static imgtoolerr_t vzdos_diskimage_deletefile(imgtool_partition *partition, const char *fname)
{
imgtoolerr_t ret;
imgtool_image *img = imgtool_partition_image(partition);
int index, filesize, track, sector, next_track, next_sector;
vzdos_dirent entry, next_entry;
UINT8 buffer[DATA_SIZE + 2];
ret = vzdos_get_dirent_fname(img, fname, &entry);
if (ret) return ret;
ret = (imgtoolerr_t)floppy_read_sector(imgtool_floppy(img), 0, entry.start_track, sector_order[entry.start_sector], 24, &buffer, DATA_SIZE + 2);
if (ret) return ret;
filesize = entry.end_address - entry.start_address;
track = entry.start_track;
sector = entry.start_sector;
/* delete directory entry */
ret = vzdos_searchentry(img, fname, &index);
if (ret) return ret;
ret = vzdos_get_dirent(img, index + 1, &next_entry);
if (ret == IMGTOOLERR_FILENOTFOUND) {
/* we are the last directory entry, just delete it */
ret = vzdos_clear_dirent(img, index);
if (ret) return ret;
} else if (ret) {
/* an error occured */
return ret;
} else {
ret = vzdos_set_dirent(img, index++, next_entry);
if (ret) return ret;
while ((ret = vzdos_get_dirent(img, index + 1, &next_entry)) != IMGTOOLERR_FILENOTFOUND) {
if (ret) return ret;
ret = vzdos_set_dirent(img, index++, next_entry);
if (ret) return ret;
}
ret = vzdos_clear_dirent(img, index);
if (ret) return ret;
}
/* clear sectors and trackmap entries */
while (filesize > 0) {
filesize -= DATA_SIZE;
/* clear trackmap entry */
ret = vzdos_clear_trackmap(img, track, sector);
if (ret) return ret;
/* load next track and sector values */
next_track = pick_integer_le(buffer, DATA_SIZE, 1);
next_sector = pick_integer_le(buffer, DATA_SIZE + 1, 1);
/* overwrite sector with default values */
ret = vzdos_clear_sector(img, track, sector);
if (ret) return ret;
/* read next sector */
track = next_track;
sector = next_sector;
if (filesize > 0) {
ret = (imgtoolerr_t)floppy_read_sector(imgtool_floppy(img), 0, track, sector_order[sector], 24, &buffer, DATA_SIZE + 2);
if (ret) return ret;
}
}
return IMGTOOLERR_SUCCESS;
}
bool dsk_format::load(io_generic *io, UINT32 form_factor, floppy_image *image)
{
UINT8 header[0x100];
bool extendformat = FALSE;
UINT64 image_size = io_generic_size(io);
io_generic_read(io, &header, 0, sizeof(header));
if ( memcmp( header, EXT_FORMAT_HEADER, 16 ) ==0) {
extendformat = TRUE;
}
int heads = header[0x31];
int skip = 1;
if (heads==1) {
skip = 2;
}
int tracks = header[0x30];
UINT64 track_offsets[84*2];
int cnt =0;
if (!extendformat) {
int tmp = 0x100;
for (int i=0; i<tracks * heads; i++)
{
track_offsets[cnt] = tmp;
tmp += pick_integer_le(header, 0x32, 2);
cnt += skip;
}
} else {
int tmp = 0x100;
for (int i=0; i<tracks * heads; i++)
{
int length = header[0x34 + i] << 8;
if (length != 0)
{
track_offsets[cnt] = tmp;
tmp += length;
}
else
{
track_offsets[cnt] = image_size;
}
cnt += skip;
}
}
int counter = 0;
for(int track=0; track < tracks; track++) {
for(int side=0; side < heads; side++) {
if(track_offsets[(track<<1)+side] >= image_size)
continue;
track_header tr;
io_generic_read(io, &tr,track_offsets[(track<<1)+side],sizeof(tr));
desc_pc_sector sects[256];
UINT8 sect_data[65536];
int sdatapos = 0;
int pos = track_offsets[(track<<1)+side] + 0x100;
for(int j=0;j<tr.number_of_sector;j++) {
sector_header sector;
io_generic_read(io, §or,track_offsets[(track<<1)+side]+sizeof(tr)+(sizeof(sector)*j),sizeof(sector));
sects[j].track = sector.track;
sects[j].head = sector.side;
sects[j].sector = sector.sector_id;
sects[j].size = sector.sector_size_code;
if(extendformat)
sects[j].actual_size = sector.data_length;
else
sects[j].actual_size = 128 << tr.sector_size_code;
sects[j].deleted = sector.fdc_status_reg1 == 0xb2;
sects[j].bad_crc = sector.fdc_status_reg1 == 0xb5;
if(!sects[j].deleted) {
sects[j].data = sect_data + sdatapos;
io_generic_read(io, sects[j].data, pos, sects[j].actual_size);
sdatapos += sects[j].actual_size;
} else
sects[j].data = NULL;
if(extendformat)
pos += sector.data_length;
else
pos += 128 << tr.sector_size_code;
}
build_pc_track_mfm(track, side, image, 100000, tr.number_of_sector, sects, tr.gap3_length);
counter++;
}
}
return true;
}
