static void vc20_prg_open(mess_image *img, mame_file *fp)
{
const char *name;
int i;
prg.length = mame_fsize (fp);
if ((prg.prg = (UINT8 *) malloc (prg.length)) == NULL)
{
logerror("tape %s could not be loaded\n", image_filename(img));
return;
}
mame_fread (fp, prg.prg, prg.length);
logerror("tape %s loaded\n", image_filename(img));
name = image_filename(img);
for (i = 0; name[i] != 0; i++)
prg.name[i] = toupper (name[i]);
for (; i < 16; i++)
prg.name[i] = ' ';
prg.img = img;
prg.stateblock = 0;
prg.stateheader = 0;
prg.statebyte = 0;
prg.statebit = 0;
tape.type = TAPE_PRG;
tape.on = 1;
prg.state = 2;
prg.pos = 0;
prg.timer = prg.prg_timer;
}
static int run_hash(mame_file *file,
void (*partialhash)(char *, const unsigned char *, unsigned long, unsigned int),
char *dest, unsigned int hash_functions)
{
UINT32 size;
UINT8 *buf = NULL;
*dest = '\0';
size = (UINT32) mame_fsize(file);
buf = (UINT8 *) malloc(size);
if (!buf)
return FALSE;
/* read the file */
mame_fseek(file, 0, SEEK_SET);
mame_fread(file, buf, size);
if (partialhash)
partialhash(dest, buf, size, hash_functions);
else
hash_compute(dest, buf, size, hash_functions);
/* cleanup */
if (buf)
free(buf);
mame_fseek(file, 0, SEEK_SET);
return TRUE;
}
/* load image */
static int kc_load(mame_file *file, unsigned char **ptr)
{
if (file)
{
int datasize;
unsigned char *data;
/* get file size */
datasize = mame_fsize(file);
if (datasize!=0)
{
/* malloc memory for this data */
data = malloc(datasize);
if (data!=NULL)
{
/* read whole file */
mame_fread(file, data, datasize);
*ptr = data;
logerror("File loaded!\r\n");
/* ok! */
return 1;
}
}
}
return 0;
}
static void verify_length_and_hash(struct rom_load_data *romdata, const char *name, UINT32 explength, const char* hash)
{
UINT32 actlength;
const char* acthash;
/* we've already complained if there is no file */
if (!romdata->file)
return;
/* get the length and CRC from the file */
actlength = mame_fsize(romdata->file);
acthash = mame_fhash(romdata->file);
/* verify length */
if (explength != actlength)
{
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s WRONG LENGTH (expected: %08x found: %08x)\n", name, explength, actlength);
romdata->warnings++;
}
/* If there is no good dump known, write it */
if (hash_data_has_info(hash, HASH_INFO_NO_DUMP))
{
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s NO GOOD DUMP KNOWN\n", name);
romdata->warnings++;
}
/* verify checksums */
else if (!hash_data_is_equal(hash, acthash, 0))
{
/* otherwise, it's just bad */
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s WRONG CHECKSUMS:\n", name);
dump_wrong_and_correct_checksums(romdata, hash, acthash);
romdata->warnings++;
}
/* If it matches, but it is actually a bad dump, write it */
else if (hash_data_has_info(hash, HASH_INFO_BAD_DUMP))
{
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%-12s ROM NEEDS REDUMP\n",name);
romdata->warnings++;
}
}
/* open an d64 image */
static DEVICE_LOAD(cbm_drive)
{
int size;
int id = image_index_in_device(image);
cbm_drive[id].drive = 0;
cbm_drive[id].image = NULL;
size = mame_fsize(file);
cbm_drive[id].image = (UINT8*) image_malloc(image, size);
if (!cbm_drive[id].image)
return INIT_FAIL;
if (size != mame_fread (file, cbm_drive[id].image, size))
return INIT_FAIL;
cbm_drive[id].drive = D64_IMAGE;
return 0;
}
int state_save_load_begin(mame_file *file)
{
TRACE(logerror("Beginning load\n"));
/* read the file into memory */
ss_dump_size = mame_fsize(file);
ss_dump_array = malloc(ss_dump_size);
ss_dump_file = file;
mame_fread(ss_dump_file, ss_dump_array, ss_dump_size);
/* verify the header and report an error if it doesn't match */
if (validate_header(ss_dump_array, NULL, get_signature(), popmessage, "Error: "))
{
free(ss_dump_array);
return 1;
}
/* compute the total size and offset of all the entries */
compute_size_and_offsets();
return 0;
}
static UINT64 mame_fsize_thunk(void *file)
{
return mame_fsize((mame_file *) file);
}
static void audit_one_rom(core_options *options, const rom_entry *rom, const char *regiontag, const game_driver *gamedrv, UINT32 validation, audit_record *record)
{
const game_driver *drv;
UINT32 crc = 0;
UINT8 crcs[4];
int has_crc;
/* fill in the record basics */
record->type = AUDIT_FILE_ROM;
record->name = ROM_GETNAME(rom);
record->exphash = ROM_GETHASHDATA(rom);
record->length = 0;
record->explength = rom_file_size(rom);
/* see if we have a CRC and extract it if so */
has_crc = hash_data_extract_binary_checksum(record->exphash, HASH_CRC, crcs);
if (has_crc)
crc = (crcs[0] << 24) | (crcs[1] << 16) | (crcs[2] << 8) | crcs[3];
/* find the file and checksum it, getting the file length along the way */
for (drv = gamedrv; drv != NULL; drv = driver_get_clone(drv))
{
file_error filerr;
mame_file *file;
/* open the file if we can */
astring fname(drv->name, PATH_SEPARATOR, ROM_GETNAME(rom));
if (has_crc)
filerr = mame_fopen_crc_options(options, libretro_content_directory, fname, crc, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file);
else
filerr = mame_fopen_options(options, libretro_content_directory, fname, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file);
/* if we got it, extract the hash and length */
if (filerr == FILERR_NONE)
{
hash_data_copy(record->hash, mame_fhash(file, validation));
record->length = (UINT32)mame_fsize(file);
mame_fclose(file);
break;
}
}
/* if not found, check the region as a backup */
if (record->length == 0 && regiontag != NULL)
{
file_error filerr;
mame_file *file;
/* open the file if we can */
astring fname(regiontag, PATH_SEPARATOR, ROM_GETNAME(rom));
if (has_crc)
filerr = mame_fopen_crc_options(options, libretro_content_directory, fname, crc, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file);
else
filerr = mame_fopen_options(options, libretro_content_directory, fname, OPEN_FLAG_READ | OPEN_FLAG_NO_PRELOAD, &file);
/* if we got it, extract the hash and length */
if (filerr == FILERR_NONE)
{
hash_data_copy(record->hash, mame_fhash(file, validation));
record->length = (UINT32)mame_fsize(file);
mame_fclose(file);
}
}
/* if we failed to find the file, set the appropriate status */
if (record->length == 0)
{
const game_driver *parent;
/* no good dump */
if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_NODUMP);
/* optional ROM */
else if (ROM_ISOPTIONAL(rom))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_OPTIONAL);
/* not found and used by parent */
else if (rom_used_by_parent(gamedrv, rom, &parent))
set_status(record, AUDIT_STATUS_NOT_FOUND, (parent->flags & GAME_IS_BIOS_ROOT) ? SUBSTATUS_NOT_FOUND_BIOS : SUBSTATUS_NOT_FOUND_PARENT);
/* just plain old not found */
else
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND);
}
/* if we did find the file, do additional verification */
else
{
/* length mismatch */
if (record->explength != record->length)
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_WRONG_LENGTH);
/* found but needs a dump */
else if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_FOUND_NODUMP);
/* incorrect hash */
else if (!hash_data_is_equal(record->exphash, record->hash, 0))
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_BAD_CHECKSUM);
/* correct hash but needs a redump */
else if (hash_data_has_info(record->exphash, HASH_INFO_BAD_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD_NEEDS_REDUMP);
/* just plain old good */
else
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD);
}
}
static UINT64 mess_chd_length(chd_interface_file *file)
{
return mame_fsize((mame_file *)file);
}
UINT64 audit_chd_length(chd_interface_file *file)
{
return mame_fsize((mame_file *)file);
}
/* check a mfm_disk image is valid */
int mfm_disk_id(int id)
{
mame_file *file;
int result = 0;
/* open file and determine image geometry */
file = image_fopen(IO_FLOPPY, id, FILETYPE_IMAGE, OSD_FOPEN_READ);
if (file)
{
unsigned char header[mfm_disk_header_size];
unsigned long FileLength;
/* get length of file */
FileLength = mame_fsize(file);
if (FileLength!=0)
{
/* load header */
if (mame_fread(file, header, mfm_disk_header_size))
{
/* check for text ident */
if (memcmp(header, MFM_ID, 8)==0)
{
unsigned long NumTracks;
unsigned long TrackSize;
unsigned long NumSides;
unsigned long Density;
NumTracks = mfm_get_long(&header[12]);
NumSides = mfm_get_long(&header[16]);
Density = mfm_get_long(&header[8]);
switch (Density)
{
default:
case MFM_DISK_DENSITY_MFM_LO:
{
TrackSize = TrackSizeMFMLo;
}
break;
}
/* size must be long enough to contain the data */
if (FileLength>=((NumTracks*NumSides*TrackSize)+mfm_disk_header_size))
{
logerror("mfm disk id succeeded!\n");
result = 1;
}
}
}
}
mame_fclose(file);
}
return result;
}
ROM_END
static int device_load_arcadia_cart(mess_image *image, mame_file *file)
{
UINT8 *rom = memory_region(REGION_CPU1);
int size;
memset(rom, 0, 0x8000);
size = mame_fsize(file);
if (size > memory_region_length(REGION_CPU1))
size = memory_region_length(REGION_CPU1);
if (mame_fread(file, rom, size) != size)
return INIT_FAIL;
if (size > 0x1000)
memmove(rom + 0x2000, rom + 0x1000, size - 0x1000);
if (size > 0x2000)
memmove(rom + 0x4000, rom + 0x3000, size - 0x2000);
#if 1
/* golf cartridge support */
/* 4kbyte at 0x0000 */
/* 2kbyte at 0x4000 */
if (size<=0x2000) memcpy (rom+0x4000, rom+0x2000, 0x1000);
#else
/* this is a testpatch for the golf cartridge
so it could be burned in a arcadia 2001 cartridge
activate it and use debugger to save patched version */
/* not enough yet (some pointers stored as data?) */
struct { UINT16 address; UINT8 old; UINT8 neu; }
patch[]= {
{ 0x0077,0x40,0x20 },
{ 0x011e,0x40,0x20 },
{ 0x0348,0x40,0x20 },
{ 0x03be,0x40,0x20 },
{ 0x04ce,0x40,0x20 },
{ 0x04da,0x40,0x20 },
{ 0x0562,0x42,0x22 },
{ 0x0617,0x40,0x20 },
{ 0x0822,0x40,0x20 },
{ 0x095e,0x42,0x22 },
{ 0x09d3,0x42,0x22 },
{ 0x0bb0,0x42,0x22 },
{ 0x0efb,0x40,0x20 },
{ 0x0ec1,0x43,0x23 },
{ 0x0f00,0x40,0x20 },
{ 0x0f12,0x40,0x20 },
{ 0x0ff5,0x43,0x23 },
{ 0x0ff7,0x41,0x21 },
{ 0x0ff9,0x40,0x20 },
{ 0x0ffb,0x41,0x21 },
{ 0x20ec,0x42,0x22 }
};
for (int i=0; i<ARRAY_LENGTH(patch); i++) {
assert(rom[patch[i].address]==patch[i].old);
rom[patch[i].address]=patch[i].neu;
}
#endif
return INIT_PASS;
}
static int audit_one_rom(const rom_entry *rom, const game_driver *gamedrv, UINT32 validation, audit_record *record)
{
const game_driver *drv;
const rom_entry *chunk;
UINT32 crc = 0;
UINT8 crcs[4];
int has_crc;
/* fill in the record basics */
record->type = AUDIT_FILE_ROM;
record->name = ROM_GETNAME(rom);
record->exphash = ROM_GETHASHDATA(rom);
/* compute the expected length by summing the chunks */
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
record->explength += ROM_GETLENGTH(chunk);
/* see if we have a CRC and extract it if so */
has_crc = hash_data_extract_binary_checksum(record->exphash, HASH_CRC, crcs);
if (has_crc)
crc = (crcs[0] << 24) | (crcs[1] << 16) | (crcs[2] << 8) | crcs[3];
/* find the file and checksum it, getting the file length along the way */
for (drv = gamedrv; drv != NULL; drv = driver_get_clone(drv))
{
mame_file_error filerr;
mame_file *file;
char *fname;
/* open the file if we can */
fname = assemble_3_strings(drv->name, PATH_SEPARATOR, ROM_GETNAME(rom));
if (has_crc)
filerr = mame_fopen_crc(SEARCHPATH_ROM, fname, crc, OPEN_FLAG_READ, &file);
else
filerr = mame_fopen(SEARCHPATH_ROM, fname, OPEN_FLAG_READ, &file);
free(fname);
/* if we got it, extract the hash and length */
if (filerr == FILERR_NONE)
{
hash_data_copy(record->hash, mame_fhash(file, validation));
record->length = (UINT32)mame_fsize(file);
mame_fclose(file);
break;
}
}
/* if we failed to find the file, set the appropriate status */
if (drv == NULL)
{
const game_driver *parent;
/* no good dump */
if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_NODUMP);
/* optional ROM */
else if (ROM_ISOPTIONAL(rom))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_OPTIONAL);
/* not found and used by parent */
else if (rom_used_by_parent(gamedrv, rom, &parent))
set_status(record, AUDIT_STATUS_NOT_FOUND, (parent->flags & NOT_A_DRIVER) ? SUBSTATUS_NOT_FOUND_BIOS : SUBSTATUS_NOT_FOUND_PARENT);
/* just plain old not found */
else
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND);
}
/* if we did find the file, do additional verification */
else
{
/* length mismatch */
if (record->explength != record->length)
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_WRONG_LENGTH);
/* found but needs a dump */
else if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_FOUND_NODUMP);
/* incorrect hash */
else if (!hash_data_is_equal(record->exphash, record->hash, 0))
set_status(record, AUDIT_STATUS_FOUND_INVALID, SUBSTATUS_FOUND_BAD_CHECKSUM);
/* correct hash but needs a redump */
else if (hash_data_has_info(record->exphash, HASH_INFO_BAD_DUMP))
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD_NEEDS_REDUMP);
/* just plain old good */
else
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD);
}
/* return TRUE if we found anything at all */
return (drv != NULL);
}
static int image_load_internal(mess_image *img, const char *name, int is_create, int create_format, option_resolution *create_args)
{
const struct IODevice *dev;
const char *s;
char *newname;
int err = INIT_PASS;
mame_file *file = NULL;
UINT8 *buffer = NULL;
UINT64 size;
unsigned int readable, writeable, creatable;
/* unload if we are loaded */
if (img->status & IMAGE_STATUS_ISLOADED)
image_unload(img);
/* clear out the error */
image_clear_error(img);
/* if we are attempting to "load" NULL, then exit at this point */
if (!name)
return INIT_PASS;
dev = image_device(img);
assert(dev);
img->status |= IMAGE_STATUS_ISLOADING;
if (name && *name)
{
newname = image_strdup(img, name);
if (!newname)
{
err = IMAGE_ERROR_OUTOFMEMORY;
goto error;
}
}
else
newname = NULL;
img->name = newname;
img->dir = NULL;
osd_image_load_status_changed(img, 0);
/* do we need to reset the CPU? */
if ((timer_get_time() > 0) && dev->reset_on_load)
machine_reset();
/* prepare to open the file */
img->created = 0;
img->writeable = 0;
file = NULL;
if (dev->getdispositions)
{
dev->getdispositions(dev, image_index_in_device(img), &readable, &writeable, &creatable);
}
else
{
readable = dev->readable;
writeable = dev->writeable;
creatable = dev->creatable;
}
/* is this a ZIP file? */
s = strrchr(img->name, '.');
if (s && !mame_stricmp(s, ".ZIP"))
{
/* ZIP files are writeable */
writeable = 0;
creatable = 0;
}
if (readable && !writeable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ);
}
else if (!readable && writeable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_WRITE);
img->writeable = file ? 1 : 0;
}
else if (readable && writeable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW);
img->writeable = file ? 1 : 0;
if (!file)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ);
if (!file && creatable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW_CREATE);
img->writeable = file ? 1 : 0;
img->created = file ? 1 : 0;
}
}
}
/* did this attempt succeed? */
if (!file)
{
img->err = IMAGE_ERROR_FILENOTFOUND;
goto error;
}
/* if applicable, call device verify */
if (dev->imgverify && !image_has_been_created(img))
{
size = mame_fsize(file);
buffer = malloc(size);
if (!buffer)
{
img->err = IMAGE_ERROR_OUTOFMEMORY;
goto error;
}
if (mame_fread(file, buffer, (UINT32) size) != size)
{
img->err = IMAGE_ERROR_INVALIDIMAGE;
goto error;
}
err = dev->imgverify(buffer, size);
if (err)
{
img->err = IMAGE_ERROR_INVALIDIMAGE;
goto error;
}
mame_fseek(file, 0, SEEK_SET);
free(buffer);
buffer = NULL;
}
/* call device load or create */
if (image_has_been_created(img) && dev->create)
{
err = dev->create(img, file, create_format, create_args);
if (err)
{
if (!img->err)
img->err = IMAGE_ERROR_UNSPECIFIED;
goto error;
}
}
else if (dev->load)
{
/* using device load */
err = dev->load(img, file);
if (err)
{
if (!img->err)
img->err = IMAGE_ERROR_UNSPECIFIED;
goto error;
}
}
img->status &= ~IMAGE_STATUS_ISLOADING;
img->status |= IMAGE_STATUS_ISLOADED;
return INIT_PASS;
error:
if (file)
mame_fclose(file);
if (buffer)
free(buffer);
if (img)
{
img->fp = NULL;
img->name = NULL;
img->status &= ~IMAGE_STATUS_ISLOADING|IMAGE_STATUS_ISLOADED;
}
osd_image_load_status_changed(img, 0);
return INIT_FAIL;
}
static mame_file *image_fopen_custom(mess_image *img, int filetype, int read_or_write)
{
const char *sysname;
char *lpExt;
const game_driver *gamedrv = Machine->gamedrv;
assert(img);
if (!img->name)
return NULL;
if (img->fp)
{
/* If already open, we won't open the file again until it is closed. */
return NULL;
}
do
{
sysname = gamedrv->name;
logerror("image_fopen: trying %s for system %s\n", img->name, sysname);
img->fp = mame_fopen(sysname, img->name, filetype, read_or_write);
if (img->fp && (read_or_write == OSD_FOPEN_READ))
{
lpExt = strrchr( img->name, '.' );
if (lpExt && (mame_stricmp( lpExt, ".ZIP" ) == 0))
{
int pathindex;
int pathcount = osd_get_path_count(filetype);
zip_file *zipfile;
zip_entry *zipentry;
char *newname;
char *name;
char *zipname;
const char *ext;
const struct IODevice *dev;
mame_fclose( img->fp );
img->fp = NULL;
dev = image_device(img);
assert(dev);
newname = NULL;
zipname = image_malloc( img, strlen( sysname ) + 1 + strlen( img->name ) + 1 );
if( osd_is_absolute_path( img->name ) )
{
strcpy( zipname, img->name );
}
else
{
strcpy( zipname, sysname );
strcat( zipname, osd_path_separator() );
strcat( zipname, img->name );
}
for (pathindex = 0; pathindex < pathcount; pathindex++)
{
zipfile = openzip(filetype, pathindex, zipname);
if (zipfile)
{
zipentry = readzip(zipfile);
while( zipentry )
{
/* mess doesn't support paths in zip files */
name = osd_basename( zipentry->name );
lpExt = strrchr(name, '.');
if (lpExt)
{
lpExt++;
ext = dev->file_extensions;
while(*ext)
{
if( mame_stricmp( lpExt, ext ) == 0 )
{
if( newname )
{
image_freeptr( img, newname );
}
newname = image_malloc(img, strlen(img->name) + 1 + strlen(name) + 1);
if (!newname)
return NULL;
strcpy(newname, img->name);
strcat(newname, osd_path_separator());
strcat(newname, name);
}
ext += strlen(ext) + 1;
}
}
zipentry = readzip(zipfile);
}
closezip(zipfile);
}
if( !newname )
{
return NULL;
}
img->fp = mame_fopen(sysname, newname, filetype, read_or_write);
if (img->fp)
{
image_freeptr(img, img->name);
img->name = newname;
break;
}
}
image_freeptr( img, zipname );
}
}
gamedrv = mess_next_compatible_driver(gamedrv);
}
while(!img->fp && gamedrv);
if (img->fp)
{
logerror("image_fopen: found image %s for system %s\n", img->name, sysname);
img->length = mame_fsize(img->fp);
img->hash = NULL;
}
return img->fp;
}
static int load_cartridge(const rom_entry *romrgn, const rom_entry *roment, mame_file *file)
{
UINT32 region, flags;
offs_t offset, length, read_length, pos = 0, len;
UINT8 *ptr;
UINT8 clear_val;
int type, datawidth, littleendian, i, j;
region = ROMREGION_GETTYPE(romrgn);
offset = ROM_GETOFFSET(roment);
length = ROM_GETLENGTH(roment);
flags = ROM_GETFLAGS(roment);
ptr = ((UINT8 *) memory_region(region)) + offset;
if (file)
{
/* must this be full size */
if (flags & ROM_FULLSIZE)
{
if (mame_fsize(file) != length)
return INIT_FAIL;
}
/* read the ROM */
pos = read_length = mame_fread(file, ptr, length);
/* do we need to mirror the ROM? */
if (flags & ROM_MIRROR)
{
while(pos < length)
{
len = MIN(read_length, length - pos);
memcpy(ptr + pos, ptr, len);
pos += len;
}
}
/* postprocess this region */
type = ROMREGION_GETTYPE(romrgn);
littleendian = ROMREGION_ISLITTLEENDIAN(romrgn);
datawidth = ROMREGION_GETWIDTH(romrgn) / 8;
/* if the region is inverted, do that now */
if (type >= REGION_CPU1 && type < REGION_CPU1 + MAX_CPU)
{
int cputype = Machine->drv->cpu[type - REGION_CPU1].cpu_type;
if (cputype != 0)
{
datawidth = cputype_databus_width(cputype, ADDRESS_SPACE_PROGRAM) / 8;
littleendian = (cputype_endianness(cputype) == CPU_IS_LE);
}
}
/* swap the endianness if we need to */
#ifdef LSB_FIRST
if (datawidth > 1 && !littleendian)
#else
if (datawidth > 1 && littleendian)
#endif
{
for (i = 0; i < length; i += datawidth)
{
UINT8 temp[8];
memcpy(temp, &ptr[i], datawidth);
for (j = datawidth - 1; j >= 0; j--)
ptr[i + j] = temp[datawidth - 1 - j];
}
}
}
/* clear out anything that remains */
if (!(flags & ROM_NOCLEAR))
{
clear_val = (flags & ROM_FILL_FF) ? 0xFF : 0x00;
memset(ptr + pos, clear_val, length - pos);
}
return INIT_PASS;
}
