static void process_region_list(romload_private *romdata)
{
astring regiontag;
/* loop until we hit the end */
device_iterator deviter(romdata->machine().root_device());
for (device_t *device = deviter.first(); device != NULL; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != NULL; region = rom_next_region(region))
{
UINT32 regionlength = ROMREGION_GETLENGTH(region);
rom_region_name(regiontag, *device, region);
LOG(("Processing region \"%s\" (length=%X)\n", regiontag.cstr(), regionlength));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
if (ROMREGION_ISROMDATA(region))
{
/* if this is a device region, override with the device width and endianness */
UINT8 width = ROMREGION_GETWIDTH(region) / 8;
endianness_t endianness = ROMREGION_ISBIGENDIAN(region) ? ENDIANNESS_BIG : ENDIANNESS_LITTLE;
if (romdata->machine().device(regiontag) != NULL)
normalize_flags_for_device(romdata->machine(), regiontag, width, endianness);
/* remember the base and length */
romdata->region = romdata->machine().memory().region_alloc(regiontag, regionlength, width, endianness);
LOG(("Allocated %X bytes @ %p\n", romdata->region->bytes(), romdata->region->base()));
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata->region->base(), ROMREGION_GETERASEVAL(region), romdata->region->bytes());
/* or if it's sufficiently small (<= 4MB) */
else if (romdata->region->bytes() <= 0x400000)
memset(romdata->region->base(), 0, romdata->region->bytes());
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata->machine(), romdata->region->base(), romdata->region->bytes());
#endif
/* now process the entries in the region */
process_rom_entries(romdata, device->shortname(), region, region + 1, device, FALSE);
}
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(romdata, regiontag, region, region + 1, NULL);
}
/* now go back and post-process all the regions */
for (device_t *device = deviter.first(); device != NULL; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != NULL; region = rom_next_region(region))
{
rom_region_name(regiontag, *device, region);
region_post_process(romdata, regiontag, ROMREGION_ISINVERTED(region));
}
}
void load_software_part_region(device_t &device, software_list_device &swlist, const char *swname, const rom_entry *start_region)
{
astring locationtag(swlist.list_name()), breakstr("%");
romload_private *romdata = device.machine().romload_data;
const rom_entry *region;
astring regiontag;
romdata->errorstring.reset();
romdata->softwarningstring.reset();
romdata->romstotal = 0;
romdata->romstotalsize = 0;
romdata->romsloadedsize = 0;
software_info *swinfo = swlist.find(swname);
if (swinfo != NULL)
{
UINT32 supported = swinfo->supported();
if (supported == SOFTWARE_SUPPORTED_PARTIAL)
{
romdata->errorstring.catprintf("WARNING: support for software %s (in list %s) is only partial\n", swname, swlist.list_name());
romdata->softwarningstring.catprintf("Support for software %s (in list %s) is only partial\n", swname, swlist.list_name());
}
if (supported == SOFTWARE_SUPPORTED_NO)
{
romdata->errorstring.catprintf("WARNING: support for software %s (in list %s) is only preliminary\n", swname, swlist.list_name());
romdata->softwarningstring.catprintf("Support for software %s (in list %s) is only preliminary\n", swname, swlist.list_name());
}
// attempt reading up the chain through the parents and create a locationtag astring in the format
// " swlist % clonename % parentname "
// open_rom_file contains the code to split the elements and to create paths to load from
locationtag.cat(breakstr);
while (swinfo != NULL)
{
locationtag.cat(swinfo->shortname()).cat(breakstr);
const char *parentname = swinfo->parentname();
swinfo = (parentname != NULL) ? swlist.find(parentname) : NULL;
}
// strip the final '%'
locationtag.del(locationtag.len() - 1, 1);
}
/* loop until we hit the end */
for (region = start_region; region != NULL; region = rom_next_region(region))
{
UINT32 regionlength = ROMREGION_GETLENGTH(region);
device.subtag(regiontag, ROMREGION_GETTAG(region));
LOG(("Processing region \"%s\" (length=%X)\n", regiontag.cstr(), regionlength));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
/* if this is a device region, override with the device width and endianness */
endianness_t endianness = ROMREGION_ISBIGENDIAN(region) ? ENDIANNESS_BIG : ENDIANNESS_LITTLE;
UINT8 width = ROMREGION_GETWIDTH(region) / 8;
memory_region *memregion = romdata->machine().root_device().memregion(regiontag);
if (memregion != NULL)
{
if (romdata->machine().device(regiontag) != NULL)
normalize_flags_for_device(romdata->machine(), regiontag, width, endianness);
/* clear old region (todo: should be moved to an image unload function) */
romdata->machine().memory().region_free(memregion->name());
}
/* remember the base and length */
romdata->region = romdata->machine().memory().region_alloc(regiontag, regionlength, width, endianness);
LOG(("Allocated %X bytes @ %p\n", romdata->region->bytes(), romdata->region->base()));
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata->region->base(), ROMREGION_GETERASEVAL(region), romdata->region->bytes());
/* or if it's sufficiently small (<= 4MB) */
else if (romdata->region->bytes() <= 0x400000)
memset(romdata->region->base(), 0, romdata->region->bytes());
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata->machine(), romdata->region->base(), romdata->region->bytes());
#endif
/* update total number of roms */
for (const rom_entry *rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
{
romdata->romstotal++;
romdata->romstotalsize += rom_file_size(rom);
}
/* now process the entries in the region */
if (ROMREGION_ISROMDATA(region))
process_rom_entries(romdata, locationtag, region, region + 1, &device, TRUE);
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(romdata, core_strdup(regiontag.cstr()), region, region + 1, locationtag);
}
/* now go back and post-process all the regions */
for (region = start_region; region != NULL; region = rom_next_region(region))
{
device.subtag(regiontag, ROMREGION_GETTAG(region));
region_post_process(romdata, regiontag.cstr(), ROMREGION_ISINVERTED(region));
}
/* display the results and exit */
display_rom_load_results(romdata, TRUE);
}
int rom_load(const struct RomModule *romp)
{
const struct RomModule *regionlist[REGION_MAX];
const struct RomModule *region;
static struct rom_load_data romdata;
int regnum;
/* reset the region list */
for (regnum = 0;regnum < REGION_MAX;regnum++)
regionlist[regnum] = NULL;
/* reset the romdata struct */
memset(&romdata, 0, sizeof(romdata));
romdata.romstotal = count_roms(romp);
/* reset the disk list */
memset(disk_handle, 0, sizeof(disk_handle));
/* determine the correct biosset to load based on options.bios string */
system_bios = determine_bios_rom(Machine->gamedrv->bios);
/* loop until we hit the end */
for (region = romp, regnum = 0; region; region = rom_next_region(region), regnum++)
{
int regiontype = ROMREGION_GETTYPE(region);
debugload("Processing region %02X (length=%X)\n", regiontype, ROMREGION_GETLENGTH(region));
/* the first entry must be a region */
if (!ROMENTRY_ISREGION(region))
{
printf("Error: missing ROM_REGION header\n");
return 1;
}
/* if sound is disabled and it's a sound-only region, skip it */
if (Machine->sample_rate == 0 && ROMREGION_ISSOUNDONLY(region))
continue;
/* allocate memory for the region */
if (new_memory_region(regiontype, ROMREGION_GETLENGTH(region), ROMREGION_GETFLAGS(region)))
{
printf("Error: unable to allocate memory for region %d\n", regiontype);
return 1;
}
/* remember the base and length */
romdata.regionlength = memory_region_length(regiontype);
romdata.regionbase = memory_region(regiontype);
debugload("Allocated %X bytes @ %08X\n", romdata.regionlength, (int)romdata.regionbase);
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata.regionbase, ROMREGION_GETERASEVAL(region), romdata.regionlength);
/* or if it's sufficiently small (<= 4MB) */
else if (romdata.regionlength <= 0x400000)
memset(romdata.regionbase, 0, romdata.regionlength);
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata.regionbase, romdata.regionlength);
#endif
/* now process the entries in the region */
if (ROMREGION_ISROMDATA(region))
{
if (!process_rom_entries(&romdata, region + 1))
return 1;
}
else if (ROMREGION_ISDISKDATA(region))
{
if (!process_disk_entries(&romdata, region + 1))
return 1;
}
/* add this region to the list */
if (regiontype < REGION_MAX)
regionlist[regiontype] = region;
}
/* post-process the regions */
for (regnum = 0; regnum < REGION_MAX; regnum++)
if (regionlist[regnum])
{
debugload("Post-processing region %02X\n", regnum);
romdata.regionlength = memory_region_length(regnum);
romdata.regionbase = memory_region(regnum);
region_post_process(&romdata, regionlist[regnum]);
}
/* display the results and exit */
return display_rom_load_results(&romdata);
}
void rom_load_manager::process_region_list()
{
std::string regiontag;
/* loop until we hit the end */
device_iterator deviter(machine().root_device());
for (device_t *device = deviter.first(); device != nullptr; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != nullptr; region = rom_next_region(region))
{
UINT32 regionlength = ROMREGION_GETLENGTH(region);
regiontag = rom_region_name(*device, region);
LOG(("Processing region \"%s\" (length=%X)\n", regiontag.c_str(), regionlength));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
if (ROMREGION_ISROMDATA(region))
{
/* if this is a device region, override with the device width and endianness */
UINT8 width = ROMREGION_GETWIDTH(region) / 8;
endianness_t endianness = ROMREGION_ISBIGENDIAN(region) ? ENDIANNESS_BIG : ENDIANNESS_LITTLE;
if (machine().device(regiontag.c_str()) != nullptr)
normalize_flags_for_device(machine(), regiontag.c_str(), width, endianness);
/* remember the base and length */
m_region = machine().memory().region_alloc(regiontag.c_str(), regionlength, width, endianness);
LOG(("Allocated %X bytes @ %p\n", m_region->bytes(), m_region->base()));
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(m_region->base(), ROMREGION_GETERASEVAL(region), m_region->bytes());
/* or if it's sufficiently small (<= 4MB) */
else if (m_region->bytes() <= 0x400000)
memset(m_region->base(), 0, m_region->bytes());
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(m_region->base(), m_region->bytes());
#endif
/* now process the entries in the region */
process_rom_entries(device->shortname().c_str(), region, region + 1, device, FALSE);
}
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(regiontag.c_str(), region, region + 1, nullptr);
}
/* now go back and post-process all the regions */
for (device_t *device = deviter.first(); device != nullptr; device = deviter.next())
for (const rom_entry *region = rom_first_region(*device); region != nullptr; region = rom_next_region(region))
{
regiontag = rom_region_name(*device, region);
region_post_process(regiontag.c_str(), ROMREGION_ISINVERTED(region));
}
/* and finally register all per-game parameters */
for (device_t *device = deviter.first(); device != nullptr; device = deviter.next())
for (const rom_entry *param = rom_first_parameter(*device); param != nullptr; param = rom_next_parameter(param))
{
regiontag = rom_parameter_name(*device, param);
machine().parameters().add(regiontag, rom_parameter_value(param));
}
}
void rom_init(running_machine *machine, const rom_entry *romp)
{
const rom_entry *regionlist[REGION_MAX];
const rom_entry *region;
static rom_load_data romdata;
int regnum;
/* if no roms, bail */
if (romp == NULL)
return;
/* make sure we get called back on the way out */
add_exit_callback(machine, rom_exit);
/* reset the region list */
memset((void *)regionlist, 0, sizeof(regionlist));
/* reset the romdata struct */
memset(&romdata, 0, sizeof(romdata));
romdata.romstotal = count_roms(romp);
/* reset the disk list */
memset(disk_handle, 0, sizeof(disk_handle));
/* determine the correct biosset to load based on options.bios string */
system_bios = determine_bios_rom(Machine->gamedrv->bios);
/* loop until we hit the end */
for (region = romp, regnum = 0; region; region = rom_next_region(region), regnum++)
{
int regiontype = ROMREGION_GETTYPE(region);
debugload("Processing region %02X (length=%X)\n", regiontype, ROMREGION_GETLENGTH(region));
/* the first entry must be a region */
assert(ROMENTRY_ISREGION(region));
/* remember the base and length */
romdata.regionbase = new_memory_region(machine, regiontype, ROMREGION_GETLENGTH(region), ROMREGION_GETFLAGS(region));
romdata.regionlength = ROMREGION_GETLENGTH(region);
debugload("Allocated %X bytes @ %08X\n", romdata.regionlength, (int)romdata.regionbase);
/* clear the region if it's requested */
if (ROMREGION_ISERASE(region))
memset(romdata.regionbase, ROMREGION_GETERASEVAL(region), romdata.regionlength);
/* or if it's sufficiently small (<= 4MB) */
else if (romdata.regionlength <= 0x400000)
memset(romdata.regionbase, 0, romdata.regionlength);
#ifdef MAME_DEBUG
/* if we're debugging, fill region with random data to catch errors */
else
fill_random(romdata.regionbase, romdata.regionlength);
#endif
/* now process the entries in the region */
if (ROMREGION_ISROMDATA(region))
process_rom_entries(&romdata, region + 1);
else if (ROMREGION_ISDISKDATA(region))
process_disk_entries(&romdata, region + 1);
/* add this region to the list */
if (regiontype < REGION_MAX)
regionlist[regiontype] = region;
}
/* post-process the regions */
for (regnum = 0; regnum < REGION_MAX; regnum++)
if (regionlist[regnum])
{
debugload("Post-processing region %02X\n", regnum);
romdata.regionlength = memory_region_length(regnum);
romdata.regionbase = memory_region(regnum);
region_post_process(&romdata, regionlist[regnum]);
}
/* display the results and exit */
total_rom_load_warnings = romdata.warnings;
display_rom_load_results(&romdata);
}
