int cli_info_listcrc(core_options *options, const char *gamename)
{
int drvindex, count = 0;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex] != NULL; drvindex++)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
machine_config *config = global_alloc(machine_config(drivers[drvindex]->machine_config));
const rom_entry *region, *rom;
const rom_source *source;
/* iterate over sources, regions, and then ROMs within the region */
for (source = rom_first_source(drivers[drvindex], config); source != NULL; source = rom_next_source(drivers[drvindex], config, source))
for (region = rom_first_region(drivers[drvindex], source); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
char hashbuf[HASH_BUF_SIZE];
/* if we have a CRC, display it */
if (hash_data_extract_printable_checksum(ROM_GETHASHDATA(rom), HASH_CRC, hashbuf))
mame_printf_info("%s %-12s %s\n", hashbuf, ROM_GETNAME(rom), drivers[drvindex]->description);
}
count++;
global_free(config);
}
/* return an error if none found */
return (count > 0) ? MAMERR_NONE : MAMERR_NO_SUCH_GAME;
}
static int process_cartridge(device_image_interface *image, process_mode mode)
{
const rom_source *source;
const rom_entry *romrgn, *roment;
int result = 0;
for (source = rom_first_source(image->device().machine().config()); source != NULL; source = rom_next_source(*source))
{
for (romrgn = rom_first_region(*source); romrgn != NULL; romrgn = rom_next_region(romrgn))
{
roment = romrgn + 1;
while(!ROMENTRY_ISREGIONEND(roment))
{
if (ROMENTRY_GETTYPE(roment) == ROMENTRYTYPE_CARTRIDGE)
{
if (strcmp(roment->_hashdata,image->device().tag())==0)
{
result |= load_cartridge(image, romrgn, roment, mode);
/* if loading failed in any cart region, stop loading */
if (result)
return result;
}
}
roment++;
}
}
}
return IMAGE_INIT_PASS;
}
static void match_roms(core_options *options, const char *hash, int length, int *found)
{
int drvindex;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex] != NULL; drvindex++)
{
machine_config *config = global_alloc(machine_config(drivers[drvindex]->machine_config));
const rom_entry *region, *rom;
const rom_source *source;
/* iterate over sources, regions and files within the region */
for (source = rom_first_source(drivers[drvindex], config); source != NULL; source = rom_next_source(drivers[drvindex], config, source))
for (region = rom_first_region(drivers[drvindex], source); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
if (hash_data_is_equal(hash, ROM_GETHASHDATA(rom), 0))
{
int baddump = hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_BAD_DUMP);
/* output information about the match */
if (*found != 0)
mame_printf_info(" ");
mame_printf_info("= %s%-20s %-10s %s\n", baddump ? "(BAD) " : "", ROM_GETNAME(rom), drivers[drvindex]->name, drivers[drvindex]->description);
(*found)++;
}
global_free(config);
}
softlist_match_roms( options, hash, length, found );
}
void info_xml_creator::output_device_roms()
{
int cnt=0;
for (const rom_source *source = rom_first_source(m_drivlist.config()); source != NULL; source = rom_next_source(*source))
{
if (cnt!=0) {
fprintf(m_output, "\t\t<device_ref name=\"%s\"/>\n", xml_normalize_string(source->shortname()));
for(int i=0;i<m_device_count;i++) {
if (source->type() == *s_devices_sorted[i]) m_device_used[i] = 1;
}
}
cnt++;
}
}
int media_auditor::also_used_by_parent(const hash_collection &romhashes)
{
// iterate up the parent chain
for (int drvindex = m_enumerator.find(m_enumerator.driver().parent); drvindex != -1; drvindex = m_enumerator.find(m_enumerator.driver(drvindex).parent))
// see if the parent has the same ROM or not
for (const rom_source *source = rom_first_source(m_enumerator.config(drvindex)); source != NULL; source = rom_next_source(*source))
for (const rom_entry *region = rom_first_region(*source); region; region = rom_next_region(region))
for (const rom_entry *rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
hash_collection hashes(ROM_GETHASHDATA(rom));
if (!hashes.flag(hash_collection::FLAG_NO_DUMP) && hashes == romhashes)
return drvindex;
}
// nope, return -1
return -1;
}
const char *info_xml_creator::get_merge_name(const hash_collection &romhashes)
{
const char *merge_name = NULL;
// walk the parent chain
for (int clone_of = m_drivlist.find(m_drivlist.driver().parent); clone_of != -1; clone_of = m_drivlist.find(m_drivlist.driver(clone_of).parent))
// look in the parent's ROMs
for (const rom_source *psource = rom_first_source(m_drivlist.config(clone_of,m_lookup_options)); psource != NULL; psource = rom_next_source(*psource))
for (const rom_entry *pregion = rom_first_region(*psource); pregion != NULL; pregion = rom_next_region(pregion))
for (const rom_entry *prom = rom_first_file(pregion); prom != NULL; prom = rom_next_file(prom))
{
hash_collection phashes(ROM_GETHASHDATA(prom));
if (!phashes.flag(hash_collection::FLAG_NO_DUMP) && romhashes == phashes)
{
// stop when we find a match
merge_name = ROM_GETNAME(prom);
break;
}
}
return merge_name;
}
media_auditor::summary media_auditor::audit_media(const char *validation)
{
// start fresh
m_record_list.reset();
// store validation for later
m_validation = validation;
// temporary hack until romload is update: get the driver path and support it for
// all searches
const char *driverpath = m_enumerator.config().devicelist().find("root")->searchpath();
// iterate over ROM sources and regions
int found = 0;
int required = 0;
int sharedFound = 0;
int sharedRequired = 0;
for (const rom_source *source = rom_first_source(m_enumerator.config()); source != NULL; source = rom_next_source(*source))
{
// determine the search path for this source and iterate through the regions
m_searchpath = source->searchpath();
// also determine if this is the driver's specific ROMs or not
bool source_is_gamedrv = (dynamic_cast<const driver_device *>(source) != NULL);
// now iterate over regions and ROMs within
for (const rom_entry *region = rom_first_region(*source); region != NULL; region = rom_next_region(region))
{
// temporary hack: add the driver path & region name
astring combinedpath(source->searchpath(), ";", driverpath);
if(ROMREGION_ISLOADBYNAME(region))
{
combinedpath=combinedpath.cat(";");
combinedpath=combinedpath.cat(ROMREGION_GETTAG(region));
}
m_searchpath = combinedpath;
for (const rom_entry *rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
hash_collection hashes(ROM_GETHASHDATA(rom));
bool shared = also_used_by_parent(hashes) >= 0;
// if a dump exists, then at least one entry is required
if (!hashes.flag(hash_collection::FLAG_NO_DUMP))
{
required++;
if (shared)
{
sharedRequired++;
}
}
// audit a file
audit_record *record = NULL;
if (ROMREGION_ISROMDATA(region))
record = audit_one_rom(rom);
// audit a disk
else if (ROMREGION_ISDISKDATA(region))
record = audit_one_disk(rom);
// skip if no record
if (record == NULL)
continue;
// if we got a record back,
if (record->status() != audit_record::STATUS_NOT_FOUND && source_is_gamedrv)
{
found++;
if (shared)
{
sharedFound++;
}
}
}
}
}
// if we found nothing unique to this set & the set needs roms that aren't in the parent or the parent isn't found either, then we don't have the set at all
if (found == sharedFound && required > 0 && (required != sharedRequired || sharedFound == 0))
m_record_list.reset();
// return a summary
return summarize();
}
static void print_game_rom(FILE *out, const game_driver *game, const machine_config *config)
{
const game_driver *clone_of = driver_get_clone(game);
int rom_type;
machine_config *pconfig = (clone_of != NULL) ? machine_config_alloc(clone_of->machine_config) : NULL;
/* iterate over 3 different ROM "types": BIOS, ROMs, DISKs */
for (rom_type = 0; rom_type < 3; rom_type++)
{
const rom_source *source;
const rom_entry *region;
/* iterate over ROM sources: first the game, then any devices */
for (source = rom_first_source(game, config); source != NULL; source = rom_next_source(game, config, source))
for (region = rom_first_region(game, source); region != NULL; region = rom_next_region(region))
{
int is_disk = ROMREGION_ISDISKDATA(region);
const rom_entry *rom;
/* disk regions only work for disks */
if ((is_disk && rom_type != 2) || (!is_disk && rom_type == 2))
continue;
/* iterate through ROM entries */
for (rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
{
int is_bios = ROM_GETBIOSFLAGS(rom);
const char *name = ROM_GETNAME(rom);
int offset = ROM_GETOFFSET(rom);
const rom_entry *parent_rom = NULL;
char bios_name[100];
/* BIOS ROMs only apply to bioses */
if ((is_bios && rom_type != 0) || (!is_bios && rom_type == 0))
continue;
/* if we have a valid ROM and we are a clone, see if we can find the parent ROM */
if (!ROM_NOGOODDUMP(rom) && clone_of != NULL)
{
const rom_source *psource;
const rom_entry *pregion, *prom;
/* scan the clone_of ROM for a matching ROM entry */
for (psource = rom_first_source(clone_of, pconfig); psource != NULL; psource = rom_next_source(clone_of, pconfig, psource))
for (pregion = rom_first_region(clone_of, psource); pregion != NULL; pregion = rom_next_region(pregion))
for (prom = rom_first_file(pregion); prom != NULL; prom = rom_next_file(prom))
if (hash_data_is_equal(ROM_GETHASHDATA(rom), ROM_GETHASHDATA(prom), 0))
{
parent_rom = prom;
break;
}
}
/* scan for a BIOS name */
bios_name[0] = 0;
if (!is_disk && is_bios)
{
const rom_entry *brom;
/* scan backwards through the ROM entries */
for (brom = rom - 1; brom != game->rom; brom--)
if (ROMENTRY_ISSYSTEM_BIOS(brom))
{
strcpy(bios_name, ROM_GETNAME(brom));
break;
}
}
/* opening tag */
if (!is_disk)
fprintf(out, "\t\t<rom");
else
fprintf(out, "\t\t<disk");
/* add name, merge, bios, and size tags */
if (name != NULL && name[0] != 0)
fprintf(out, " name=\"%s\"", xml_normalize_string(name));
if (parent_rom != NULL)
fprintf(out, " merge=\"%s\"", xml_normalize_string(ROM_GETNAME(parent_rom)));
if (bios_name[0] != 0)
fprintf(out, " bios=\"%s\"", xml_normalize_string(bios_name));
if (!is_disk)
fprintf(out, " size=\"%d\"", rom_file_size(rom));
/* dump checksum information only if there is a known dump */
if (!hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_NO_DUMP))
{
char checksum[HASH_BUF_SIZE];
int hashtype;
/* iterate over hash function types and print out their values */
for (hashtype = 0; hashtype < HASH_NUM_FUNCTIONS; hashtype++)
if (hash_data_extract_printable_checksum(ROM_GETHASHDATA(rom), 1 << hashtype, checksum))
fprintf(out, " %s=\"%s\"", hash_function_name(1 << hashtype), checksum);
}
/* append a region name */
fprintf(out, " region=\"%s\"", ROMREGION_GETTAG(region));
/* add nodump/baddump flags */
if (hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_NO_DUMP))
fprintf(out, " status=\"nodump\"");
if (hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_BAD_DUMP))
fprintf(out, " status=\"baddump\"");
/* for non-disk entries, print offset */
if (!is_disk)
fprintf(out, " offset=\"%x\"", offset);
/* for disk entries, add the disk index */
else
fprintf(out, " index=\"%x\"", DISK_GETINDEX(rom));
/* add optional flag */
if ((!is_disk && ROM_ISOPTIONAL(rom)) || (is_disk && DISK_ISOPTIONAL(rom)))
fprintf(out, " optional=\"yes\"");
fprintf(out, "/>\n");
}
}
}
if (pconfig != NULL)
machine_config_free(pconfig);
}
int audit_images(core_options *options, const game_driver *gamedrv, UINT32 validation, audit_record **audit)
{
machine_config *config = global_alloc(machine_config(gamedrv->machine_config));
const rom_entry *region, *rom;
const rom_source *source;
audit_record *record;
int anyfound = FALSE;
int anyrequired = FALSE;
int allshared = TRUE;
int records;
/* determine the number of records we will generate */
records = 0;
for (source = rom_first_source(gamedrv, config); source != NULL; source = rom_next_source(gamedrv, config, source))
{
int source_is_gamedrv = rom_source_is_gamedrv(gamedrv, source);
for (region = rom_first_region(gamedrv, source); region != NULL; region = rom_next_region(region))
for (rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
if (ROMREGION_ISROMDATA(region) || ROMREGION_ISDISKDATA(region))
{
if (source_is_gamedrv && !ROM_ISOPTIONAL(rom) && !ROM_NOGOODDUMP(rom))
{
anyrequired = TRUE;
if (allshared && !rom_used_by_parent(gamedrv, rom, NULL))
allshared = FALSE;
}
records++;
}
}
if (records > 0)
{
/* allocate memory for the records */
*audit = global_alloc_array_clear(audit_record, records);
record = *audit;
/* iterate over ROM sources and regions */
for (source = rom_first_source(gamedrv, config); source != NULL; source = rom_next_source(gamedrv, config, source))
{
int source_is_gamedrv = rom_source_is_gamedrv(gamedrv, source);
for (region = rom_first_region(gamedrv, source); region != NULL; region = rom_next_region(region))
{
const char *regiontag = ROMREGION_ISLOADBYNAME(region) ? ROM_GETNAME(region) : NULL;
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
/* audit a file */
if (ROMREGION_ISROMDATA(region))
{
audit_one_rom(options, rom, regiontag, gamedrv, validation, record);
}
/* audit a disk */
else if (ROMREGION_ISDISKDATA(region))
{
audit_one_disk(options, rom, gamedrv, validation, record);
}
else
{
continue;
}
if (source_is_gamedrv && record->status != AUDIT_STATUS_NOT_FOUND && (allshared || !rom_used_by_parent(gamedrv, rom, NULL)))
anyfound = TRUE;
record++;
}
}
}
}
/* if we found nothing, we don't have the set at all */
if (!anyfound && anyrequired)
{
global_free(*audit);
*audit = NULL;
records = 0;
}
global_free(config);
return records;
}
bool device_memory_interface::interface_validity_check(emu_options &options, const game_driver &driver) const
{
bool detected_overlap = DETECT_OVERLAPPING_MEMORY ? false : true;
bool error = false;
// loop over all address spaces
for (address_spacenum spacenum = AS_0; spacenum < ADDRESS_SPACES; spacenum++)
{
const address_space_config *spaceconfig = space_config(spacenum);
if (spaceconfig != NULL)
{
int datawidth = spaceconfig->m_databus_width;
int alignunit = datawidth / 8;
// construct the maps
::address_map *map = global_alloc(::address_map(device(), spacenum));
// if this is an empty map, just skip it
if (map->m_entrylist.first() == NULL)
{
global_free(map);
continue;
}
// validate the global map parameters
if (map->m_spacenum != spacenum)
{
mame_printf_error("%s: %s device '%s' space %d has address space %d handlers!\n", driver.source_file, driver.name, device().tag(), spacenum, map->m_spacenum);
error = true;
}
if (map->m_databits != datawidth)
{
mame_printf_error("%s: %s device '%s' uses wrong memory handlers for %s space! (width = %d, memory = %08x)\n", driver.source_file, driver.name, device().tag(), spaceconfig->m_name, datawidth, map->m_databits);
error = true;
}
// loop over entries and look for errors
for (address_map_entry *entry = map->m_entrylist.first(); entry != NULL; entry = entry->next())
{
UINT32 bytestart = spaceconfig->addr2byte(entry->m_addrstart);
UINT32 byteend = spaceconfig->addr2byte_end(entry->m_addrend);
// look for overlapping entries
if (!detected_overlap)
{
address_map_entry *scan;
for (scan = map->m_entrylist.first(); scan != entry; scan = scan->next())
if (entry->m_addrstart <= scan->m_addrend && entry->m_addrend >= scan->m_addrstart &&
((entry->m_read.m_type != AMH_NONE && scan->m_read.m_type != AMH_NONE) ||
(entry->m_write.m_type != AMH_NONE && scan->m_write.m_type != AMH_NONE)))
{
mame_printf_warning("%s: %s '%s' %s space has overlapping memory (%X-%X,%d,%d) vs (%X-%X,%d,%d)\n", driver.source_file, driver.name, device().tag(), spaceconfig->m_name, entry->m_addrstart, entry->m_addrend, entry->m_read.m_type, entry->m_write.m_type, scan->m_addrstart, scan->m_addrend, scan->m_read.m_type, scan->m_write.m_type);
detected_overlap = true;
break;
}
}
// look for inverted start/end pairs
if (byteend < bytestart)
{
mame_printf_error("%s: %s wrong %s memory read handler start = %08x > end = %08x\n", driver.source_file, driver.name, spaceconfig->m_name, entry->m_addrstart, entry->m_addrend);
error = true;
}
// look for misaligned entries
if ((bytestart & (alignunit - 1)) != 0 || (byteend & (alignunit - 1)) != (alignunit - 1))
{
mame_printf_error("%s: %s wrong %s memory read handler start = %08x, end = %08x ALIGN = %d\n", driver.source_file, driver.name, spaceconfig->m_name, entry->m_addrstart, entry->m_addrend, alignunit);
error = true;
}
// if this is a program space, auto-assign implicit ROM entries
if (entry->m_read.m_type == AMH_ROM && entry->m_region == NULL)
{
entry->m_region = device().tag();
entry->m_rgnoffs = entry->m_addrstart;
}
// if this entry references a memory region, validate it
if (entry->m_region != NULL && entry->m_share == 0)
{
// look for the region
bool found = false;
for (const rom_source *source = rom_first_source(device().mconfig()); source != NULL && !found; source = rom_next_source(*source))
for (const rom_entry *romp = rom_first_region(*source); !ROMENTRY_ISEND(romp) && !found; romp++)
{
const char *regiontag_c = ROMREGION_GETTAG(romp);
if (regiontag_c != NULL)
{
astring fulltag;
astring regiontag;
// a leading : on a region name indicates an absolute region, so fix up accordingly
if (entry->m_region[0] == ':')
{
regiontag = &entry->m_region[1];
}
else
{
if (strchr(entry->m_region,':')) {
regiontag = entry->m_region;
} else {
device().siblingtag(regiontag, entry->m_region);
}
}
rom_region_name(fulltag, &driver, source, romp);
if (fulltag.cmp(regiontag) == 0)
{
// verify the address range is within the region's bounds
offs_t length = ROMREGION_GETLENGTH(romp);
if (entry->m_rgnoffs + (byteend - bytestart + 1) > length)
{
mame_printf_error("%s: %s device '%s' %s space memory map entry %X-%X extends beyond region '%s' size (%X)\n", driver.source_file, driver.name, device().tag(), spaceconfig->m_name, entry->m_addrstart, entry->m_addrend, entry->m_region, length);
error = true;
}
found = true;
}
}
}
// error if not found
if (!found)
{
mame_printf_error("%s: %s device '%s' %s space memory map entry %X-%X references non-existant region '%s'\n", driver.source_file, driver.name, device().tag(), spaceconfig->m_name, entry->m_addrstart, entry->m_addrend, entry->m_region);
error = true;
}
}
// make sure all devices exist
if ((entry->m_read.m_type == AMH_LEGACY_DEVICE_HANDLER && entry->m_read.m_tag != NULL && device().mconfig().devicelist().find(entry->m_read.m_tag) == NULL) ||
(entry->m_write.m_type == AMH_LEGACY_DEVICE_HANDLER && entry->m_write.m_tag != NULL && device().mconfig().devicelist().find(entry->m_write.m_tag) == NULL))
{
mame_printf_error("%s: %s device '%s' %s space memory map entry references nonexistant device '%s'\n", driver.source_file, driver.name, device().tag(), spaceconfig->m_name, entry->m_write.m_tag);
error = true;
}
// make sure ports exist
// if ((entry->m_read.m_type == AMH_PORT && entry->m_read.m_tag != NULL && portlist.find(entry->m_read.m_tag) == NULL) ||
// (entry->m_write.m_type == AMH_PORT && entry->m_write.m_tag != NULL && portlist.find(entry->m_write.m_tag) == NULL))
// {
// mame_printf_error("%s: %s device '%s' %s space memory map entry references nonexistant port tag '%s'\n", driver.source_file, driver.name, device().tag(), spaceconfig->m_name, entry->m_read.tag);
// error = true;
// }
// validate bank and share tags
if (entry->m_read.m_type == AMH_BANK && !validate_tag(driver, "bank", entry->m_read.m_tag))
error = true ;
if (entry->m_write.m_type == AMH_BANK && !validate_tag(driver, "bank", entry->m_write.m_tag))
error = true;
if (entry->m_share != NULL && !validate_tag(driver, "share", entry->m_share))
error = true;
}
// release the address map
global_free(map);
}
}
return error;
}
void info_xml_creator::output_rom()
{
// iterate over 3 different ROM "types": BIOS, ROMs, DISKs
for (int rom_type = 0; rom_type < 3; rom_type++)
{
// iterate over ROM sources: first the game, then any devices
for (const rom_source *source = rom_first_source(m_drivlist.config()); source != NULL; source = rom_next_source(*source))
for (const rom_entry *region = rom_first_region(*source); region != NULL; region = rom_next_region(region))
{
bool is_disk = ROMREGION_ISDISKDATA(region);
// disk regions only work for disks
if ((is_disk && rom_type != 2) || (!is_disk && rom_type == 2))
continue;
// iterate through ROM entries
for (const rom_entry *rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
{
bool is_bios = ROM_GETBIOSFLAGS(rom);
const char *name = ROM_GETNAME(rom);
int offset = ROM_GETOFFSET(rom);
const char *merge_name = NULL;
char bios_name[100];
// BIOS ROMs only apply to bioses
if ((is_bios && rom_type != 0) || (!is_bios && rom_type == 0))
continue;
// if we have a valid ROM and we are a clone, see if we can find the parent ROM
hash_collection hashes(ROM_GETHASHDATA(rom));
if (!hashes.flag(hash_collection::FLAG_NO_DUMP))
merge_name = get_merge_name(hashes);
// scan for a BIOS name
bios_name[0] = 0;
if (!is_disk && is_bios)
{
// scan backwards through the ROM entries
for (const rom_entry *brom = rom - 1; brom != m_drivlist.driver().rom; brom--)
if (ROMENTRY_ISSYSTEM_BIOS(brom))
{
strcpy(bios_name, ROM_GETNAME(brom));
break;
}
}
// opening tag
if (!is_disk)
fprintf(m_output, "\t\t<rom");
else
fprintf(m_output, "\t\t<disk");
// add name, merge, bios, and size tags */
if (name != NULL && name[0] != 0)
fprintf(m_output, " name=\"%s\"", xml_normalize_string(name));
if (merge_name != NULL)
fprintf(m_output, " merge=\"%s\"", xml_normalize_string(merge_name));
if (bios_name[0] != 0)
fprintf(m_output, " bios=\"%s\"", xml_normalize_string(bios_name));
if (!is_disk)
fprintf(m_output, " size=\"%d\"", rom_file_size(rom));
// dump checksum information only if there is a known dump
if (!hashes.flag(hash_collection::FLAG_NO_DUMP))
{
// iterate over hash function types and print m_output their values
astring tempstr;
for (hash_base *hash = hashes.first(); hash != NULL; hash = hash->next())
fprintf(m_output, " %s=\"%s\"", hash->name(), hash->string(tempstr));
}
// append a region name
fprintf(m_output, " region=\"%s\"", ROMREGION_GETTAG(region));
// add nodump/baddump flags
if (hashes.flag(hash_collection::FLAG_NO_DUMP))
fprintf(m_output, " status=\"nodump\"");
if (hashes.flag(hash_collection::FLAG_BAD_DUMP))
fprintf(m_output, " status=\"baddump\"");
// for non-disk entries, print offset
if (!is_disk)
fprintf(m_output, " offset=\"%x\"", offset);
// for disk entries, add the disk index
else
{
fprintf(m_output, " index=\"%x\"", DISK_GETINDEX(rom));
fprintf(m_output, " writeable=\"%s\"", DISK_ISREADONLY(rom) ? "no" : "yes");
}
// add optional flag
if ((!is_disk && ROM_ISOPTIONAL(rom)) || (is_disk && DISK_ISOPTIONAL(rom)))
fprintf(m_output, " optional=\"yes\"");
fprintf(m_output, "/>\n");
}
}
}
}
void info_xml_creator::output_one()
{
// no action if not a game
const game_driver &driver = m_drivlist.driver();
if (driver.flags & GAME_NO_STANDALONE)
return;
// allocate input ports
machine_config &config = m_drivlist.config();
ioport_list portlist;
astring errors;
device_iterator iter(config.root_device());
for (device_t *device = iter.first(); device != NULL; device = iter.next())
input_port_list_init(*device, portlist, errors);
// print the header and the game name
fprintf(m_output, "\t<%s",emulator_info::get_xml_top());
fprintf(m_output, " name=\"%s\"", xml_normalize_string(driver.name));
// strip away any path information from the source_file and output it
const char *start = strrchr(driver.source_file, '/');
if (start == NULL)
start = strrchr(driver.source_file, '\\');
if (start == NULL)
start = driver.source_file - 1;
fprintf(m_output, " sourcefile=\"%s\"", xml_normalize_string(start + 1));
// append bios and runnable flags
if (driver.flags & GAME_IS_BIOS_ROOT)
fprintf(m_output, " isbios=\"yes\"");
if (driver.flags & GAME_NO_STANDALONE)
fprintf(m_output, " runnable=\"no\"");
if (driver.flags & GAME_MECHANICAL)
fprintf(m_output, " ismechanical=\"yes\"");
// display clone information
int clone_of = m_drivlist.find(driver.parent);
if (clone_of != -1 && !(m_drivlist.driver(clone_of).flags & GAME_IS_BIOS_ROOT))
fprintf(m_output, " cloneof=\"%s\"", xml_normalize_string(m_drivlist.driver(clone_of).name));
if (clone_of != -1)
fprintf(m_output, " romof=\"%s\"", xml_normalize_string(m_drivlist.driver(clone_of).name));
// display sample information and close the game tag
output_sampleof();
fprintf(m_output, ">\n");
// output game description
if (driver.description != NULL)
fprintf(m_output, "\t\t<description>%s</description>\n", xml_normalize_string(driver.description));
// print the year only if is a number or another allowed character (? or +)
if (driver.year != NULL && strspn(driver.year, "0123456789?+") == strlen(driver.year))
fprintf(m_output, "\t\t<year>%s</year>\n", xml_normalize_string(driver.year));
// print the manufacturer information
if (driver.manufacturer != NULL)
fprintf(m_output, "\t\t<manufacturer>%s</manufacturer>\n", xml_normalize_string(driver.manufacturer));
// now print various additional information
output_bios();
output_rom(rom_first_source(m_drivlist.config()));
output_device_roms();
output_sample();
output_chips();
output_display();
output_sound();
output_input(portlist);
output_switches(portlist, IPT_DIPSWITCH, "dipswitch", "dipvalue");
output_switches(portlist, IPT_CONFIG, "configuration", "confsetting");
output_adjusters(portlist);
output_driver();
output_images();
output_slots();
output_software_list();
output_ramoptions();
// close the topmost tag
fprintf(m_output, "\t</%s>\n",emulator_info::get_xml_top());
}
static struct DriversInfo* GetDriversInfo(int driver_index)
{
if (drivers_info == NULL)
{
int ndriver;
drivers_info = (DriversInfo*)malloc(sizeof(struct DriversInfo) * driver_list_get_count(drivers));
for (ndriver = 0; ndriver < driver_list_get_count(drivers); ndriver++)
{
const game_driver *gamedrv = drivers[ndriver];
struct DriversInfo *gameinfo = &drivers_info[ndriver];
const rom_entry *region, *rom;
windows_options pCurrentOpts;
load_options(pCurrentOpts, OPTIONS_GLOBAL, driver_index);
machine_config config(*gamedrv,pCurrentOpts);
const rom_source *source;
int num_speakers;
gameinfo->isClone = (GetParentRomSetIndex(gamedrv) != -1);
gameinfo->isBroken = ((gamedrv->flags & GAME_NOT_WORKING) != 0);
gameinfo->supportsSaveState = ((gamedrv->flags & GAME_SUPPORTS_SAVE) != 0);
gameinfo->isHarddisk = FALSE;
gameinfo->isVertical = (gamedrv->flags & ORIENTATION_SWAP_XY) ? TRUE : FALSE;
for (source = rom_first_source(config); source != NULL; source = rom_next_source(*source))
{
for (region = rom_first_region(*source); region; region = rom_next_region(region))
{
if (ROMREGION_ISDISKDATA(region))
gameinfo->isHarddisk = TRUE;
}
}
gameinfo->hasOptionalBIOS = FALSE;
if (gamedrv->rom != NULL)
{
for (rom = gamedrv->rom; !ROMENTRY_ISEND(rom); rom++)
{
if (ROMENTRY_ISSYSTEM_BIOS(rom))
{
gameinfo->hasOptionalBIOS = TRUE;
break;
}
}
}
num_speakers = numberOfSpeakers(&config);
gameinfo->isStereo = (num_speakers > 1);
gameinfo->screenCount = numberOfScreens(&config);
gameinfo->isVector = isDriverVector(&config); // ((drv.video_attributes & VIDEO_TYPE_VECTOR) != 0);
gameinfo->usesRoms = FALSE;
for (source = rom_first_source(config); source != NULL; source = rom_next_source(*source))
{
for (region = rom_first_region(*source); region; region = rom_next_region(region))
{
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
gameinfo->usesRoms = TRUE;
break;
}
}
}
gameinfo->usesSamples = FALSE;
{
const device_config_sound_interface *sound = NULL;
const char * const * samplenames = NULL;
for (bool gotone = config.m_devicelist.first(sound); gotone; gotone = sound->next(sound)) {
if (sound->devconfig().type() == SAMPLES)
{
const samples_interface *intf = (const samples_interface *)sound->devconfig().static_config();
samplenames = intf->samplenames;
if (samplenames != 0 && samplenames[0] != 0)
{
gameinfo->usesSamples = TRUE;
break;
}
}
}
}
gameinfo->usesTrackball = FALSE;
gameinfo->usesLightGun = FALSE;
if (gamedrv->ipt != NULL)
{
const input_port_config *port;
ioport_list portlist;
input_port_list_init(portlist, gamedrv->ipt, NULL, 0, FALSE, NULL);
for (device_config *cfg = config.m_devicelist.first(); cfg != NULL; cfg = cfg->next())
{
if (cfg->input_ports()!=NULL) {
input_port_list_init(portlist, cfg->input_ports(), NULL, 0, FALSE, cfg);
}
}
for (port = portlist.first(); port != NULL; port = port->next())
{
const input_field_config *field;
for (field = port->fieldlist; field != NULL; field = field->next)
{
UINT32 type;
type = field->type;
if (type == IPT_END)
break;
if (type == IPT_DIAL || type == IPT_PADDLE ||
type == IPT_TRACKBALL_X || type == IPT_TRACKBALL_Y ||
type == IPT_AD_STICK_X || type == IPT_AD_STICK_Y)
gameinfo->usesTrackball = TRUE;
if (type == IPT_LIGHTGUN_X || type == IPT_LIGHTGUN_Y)
gameinfo->usesLightGun = TRUE;
if (type == IPT_MOUSE_X || type == IPT_MOUSE_Y)
gameinfo->usesMouse = TRUE;
}
}
}
}
}
return &drivers_info[driver_index];
}
static struct DriversInfo* GetDriversInfo(int driver_index)
{
if (drivers_info == NULL)
{
int ndriver;
drivers_info = (DriversInfo*)malloc(sizeof(struct DriversInfo) * GetNumGames());
for (ndriver = 0; ndriver < GetNumGames(); ndriver++)
{
const game_driver *gamedrv = drivers[ndriver];
struct DriversInfo *gameinfo = &drivers_info[ndriver];
const rom_entry *region, *rom;
machine_config *config;
const rom_source *source;
int num_speakers;
/* Allocate machine config */
config = global_alloc(machine_config(gamedrv->machine_config));
gameinfo->isClone = (GetParentRomSetIndex(gamedrv) != -1);
gameinfo->isBroken = ((gamedrv->flags & GAME_NOT_WORKING) != 0);
gameinfo->supportsSaveState = ((gamedrv->flags & GAME_SUPPORTS_SAVE) != 0);
gameinfo->isHarddisk = FALSE;
gameinfo->isVertical = (gamedrv->flags & ORIENTATION_SWAP_XY) ? TRUE : FALSE;
for (source = rom_first_source(gamedrv, config); source != NULL; source = rom_next_source(gamedrv, config, source))
{
for (region = rom_first_region(gamedrv, source); region; region = rom_next_region(region))
{
if (ROMREGION_ISDISKDATA(region))
gameinfo->isHarddisk = TRUE;
}
}
gameinfo->hasOptionalBIOS = FALSE;
if (gamedrv->rom != NULL)
{
for (rom = gamedrv->rom; !ROMENTRY_ISEND(rom); rom++)
{
if (ROMENTRY_ISSYSTEM_BIOS(rom))
{
gameinfo->hasOptionalBIOS = TRUE;
break;
}
}
}
num_speakers = numberOfSpeakers(config);
gameinfo->isStereo = (num_speakers > 1);
gameinfo->screenCount = numberOfScreens(config);
gameinfo->isVector = isDriverVector(config); // ((drv.video_attributes & VIDEO_TYPE_VECTOR) != 0);
gameinfo->usesRoms = FALSE;
for (source = rom_first_source(gamedrv, config); source != NULL; source = rom_next_source(gamedrv, config, source))
{
for (region = rom_first_region(gamedrv, source); region; region = rom_next_region(region))
{
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
gameinfo->usesRoms = TRUE;
break;
}
}
}
gameinfo->usesSamples = FALSE;
{
const device_config_sound_interface *sound;
const char * const * samplenames = NULL;
for (bool gotone = config->m_devicelist.first(sound); gotone; gotone = sound->next(sound)) {
if (sound->devconfig().type() == SOUND_SAMPLES)
{
const samples_interface *intf = (const samples_interface *)sound->devconfig().static_config();
samplenames = intf->samplenames;
if (samplenames != 0 && samplenames[0] != 0)
{
gameinfo->usesSamples = TRUE;
break;
}
}
}
}
gameinfo->numPlayers = 0;
gameinfo->numButtons = 0;
memset(gameinfo->usesController, 0, sizeof gameinfo->usesController);
gameinfo->parentIndex = -1;
if (gameinfo->isClone)
{
int i;
for (i = 0; i < GetNumGames(); i++)
{
if (GetParentRomSetIndex(gamedrv) == i)
{
gameinfo->parentIndex = i;
break;
}
}
}
gameinfo->biosIndex = -1;
if (DriverIsBios(ndriver))
gameinfo->biosIndex = ndriver;
else if (gameinfo->hasOptionalBIOS)
{
int parentIndex;
if (gameinfo->isClone)
parentIndex = gameinfo->parentIndex;
else
parentIndex = ndriver;
while (1)
{
parentIndex = GetGameNameIndex(drivers[parentIndex]->parent);
if (parentIndex == -1)
{
dprintf("bios for %s is not found", drivers[ndriver]->name);
break;
}
if (DriverIsBios(parentIndex))
{
gameinfo->biosIndex = parentIndex;
break;
}
}
}
/* Free the structure */
global_free(config);
gameinfo->usesTrackball = FALSE;
gameinfo->usesLightGun = FALSE;
if (gamedrv->ipt != NULL)
{
const input_port_config *port;
ioport_list portlist;
input_port_list_init(portlist, gamedrv->ipt, NULL, 0, FALSE);
for (port = portlist.first(); port != NULL; port = port->next())
{
const input_field_config *field;
for (field = port->fieldlist; field != NULL; field = field->next)
{
UINT32 type;
type = field->type;
if (type == IPT_END)
break;
if (type == IPT_DIAL || type == IPT_PADDLE ||
type == IPT_TRACKBALL_X || type == IPT_TRACKBALL_Y ||
type == IPT_AD_STICK_X || type == IPT_AD_STICK_Y)
gameinfo->usesTrackball = TRUE;
if (type == IPT_LIGHTGUN_X || type == IPT_LIGHTGUN_Y)
gameinfo->usesLightGun = TRUE;
if (type == IPT_MOUSE_X || type == IPT_MOUSE_Y)
gameinfo->usesMouse = TRUE;
}
}
}
}
UpdateController();
}
return &drivers_info[driver_index];
}
int cli_info_listroms(core_options *options, const char *gamename)
{
int drvindex, count = 0;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex] != NULL; drvindex++)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
machine_config *config = global_alloc(machine_config(drivers[drvindex]->machine_config));
const rom_entry *region, *rom;
const rom_source *source;
/* print the header */
if (count > 0)
mame_printf_info("\n");
mame_printf_info("This is the list of the ROMs required for driver \"%s\".\n"
"Name Size Checksum\n", drivers[drvindex]->name);
/* iterate over sources, regions and then ROMs within the region */
for (source = rom_first_source(drivers[drvindex], config); source != NULL; source = rom_next_source(drivers[drvindex], config, source))
for (region = rom_first_region(drivers[drvindex], source); region != NULL; region = rom_next_region(region))
for (rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
{
const char *name = ROM_GETNAME(rom);
const char *hash = ROM_GETHASHDATA(rom);
char hashbuf[HASH_BUF_SIZE];
int length = -1;
/* accumulate the total length of all chunks */
if (ROMREGION_ISROMDATA(region))
length = rom_file_size(rom);
/* start with the name */
mame_printf_info("%-12s ", name);
/* output the length next */
if (length >= 0)
mame_printf_info("%7d", length);
else
mame_printf_info(" ");
/* output the hash data */
if (!hash_data_has_info(hash, HASH_INFO_NO_DUMP))
{
if (hash_data_has_info(hash, HASH_INFO_BAD_DUMP))
mame_printf_info(" BAD");
hash_data_print(hash, 0, hashbuf);
mame_printf_info(" %s", hashbuf);
}
else
mame_printf_info(" NO GOOD DUMP KNOWN");
/* end with a CR */
mame_printf_info("\n");
}
count++;
global_free(config);
}
return (count > 0) ? MAMERR_NONE : MAMERR_NO_SUCH_GAME;
}
static struct DriversInfo* GetDriversInfo(int driver_index)
{
if (drivers_info == NULL)
{
UINT16 ndriver;
drivers_info = (DriversInfo*)malloc(sizeof(struct DriversInfo) * GetNumGames());
for (ndriver = 0; ndriver < GetNumGames(); ndriver++)
{
const game_driver *gamedrv = &driver_list::driver(ndriver);
struct DriversInfo *gameinfo = &drivers_info[ndriver];
const rom_entry *region, *rom;
machine_config config(*gamedrv, MameUIGlobal());
const rom_source *source;
int num_speakers;
gameinfo->isClone = (GetParentRomSetIndex(gamedrv) != -1);
gameinfo->isBroken = ((gamedrv->flags & GAME_NOT_WORKING) != 0);
gameinfo->supportsSaveState = ((gamedrv->flags & GAME_SUPPORTS_SAVE) != 0);
gameinfo->isHarddisk = FALSE;
gameinfo->isVertical = (gamedrv->flags & ORIENTATION_SWAP_XY) ? TRUE : FALSE;
for (source = rom_first_source(config); source != NULL; source = rom_next_source(*source))
for (region = rom_first_region(*source); region; region = rom_next_region(region))
if (ROMREGION_ISDISKDATA(region))
gameinfo->isHarddisk = TRUE;
gameinfo->hasOptionalBIOS = FALSE;
if (gamedrv->rom != NULL)
for (rom = gamedrv->rom; !ROMENTRY_ISEND(rom); rom++)
if (ROMENTRY_ISSYSTEM_BIOS(rom))
{
gameinfo->hasOptionalBIOS = TRUE;
break;
}
num_speakers = numberOfSpeakers(&config);
gameinfo->isStereo = (num_speakers > 1);
gameinfo->screenCount = numberOfScreens(&config);
gameinfo->isVector = isDriverVector(&config); // ((drv.video_attributes & VIDEO_TYPE_VECTOR) != 0);
gameinfo->usesRoms = FALSE;
for (source = rom_first_source(config); source != NULL; source = rom_next_source(*source))
for (region = rom_first_region(*source); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
gameinfo->usesRoms = TRUE;
break;
}
gameinfo->usesSamples = FALSE;
samples_device_iterator iter(config.root_device());
if (iter.first() != NULL)
gameinfo->usesSamples = TRUE;
gameinfo->numPlayers = 0;
gameinfo->numButtons = 0;
memset(gameinfo->usesController, 0, sizeof gameinfo->usesController);
gameinfo->parentIndex = -1;
if (gameinfo->isClone)
{
int i;
for (i = 0; i < GetNumGames(); i++)
{
if (GetParentRomSetIndex(gamedrv) == i)
{
gameinfo->parentIndex = i;
break;
}
}
}
gameinfo->biosIndex = -1;
if (DriverIsBios(ndriver))
gameinfo->biosIndex = ndriver;
else if (gameinfo->hasOptionalBIOS)
{
int parentIndex;
if (gameinfo->isClone)
parentIndex = gameinfo->parentIndex;
else
parentIndex = ndriver;
while (1)
{
parentIndex = GetGameNameIndex(driver_list::driver(parentIndex).parent);
if (parentIndex == -1)
{
dprintf("bios for %s is not found", driver_list::driver(ndriver).name);
break;
}
if (DriverIsBios(parentIndex))
{
gameinfo->biosIndex = parentIndex;
break;
}
}
}
gameinfo->usesTrackball = FALSE;
gameinfo->usesLightGun = FALSE;
if (gamedrv->ipt != NULL)
{
input_port_config *port;
ioport_list portlist;
astring errors;
device_iterator iter(config.root_device());
for (device_t *device = iter.first(); device != NULL; device = iter.next())
if (device->input_ports()!=NULL)
input_port_list_init(*device, portlist, errors);
for (port = portlist.first(); port != NULL; port = port->next())
{
const input_field_config *field;
for (field = port->first_field(); field != NULL; field = field->next())
{
UINT32 type;
type = field->type;
if (type == IPT_END)
break;
if (type == IPT_DIAL || type == IPT_PADDLE ||
type == IPT_TRACKBALL_X || type == IPT_TRACKBALL_Y ||
type == IPT_AD_STICK_X || type == IPT_AD_STICK_Y)
gameinfo->usesTrackball = TRUE;
if (type == IPT_LIGHTGUN_X || type == IPT_LIGHTGUN_Y)
gameinfo->usesLightGun = TRUE;
if (type == IPT_MOUSE_X || type == IPT_MOUSE_Y)
gameinfo->usesMouse = TRUE;
}
}
}
}
UpdateController();
}
return &drivers_info[driver_index];
}