void printromlist(const struct RomModule *romp,const char *basename)
{
const struct RomModule *region, *rom, *chunk;
char buf[512];
if (!romp) return;
#ifdef MESS
if (!strcmp(basename,"nes")) return;
#endif
printf("This is the list of the ROMs required for driver \"%s\".\n"
"Name Size Checksum\n",basename);
for (region = romp; region; region = rom_next_region(region))
{
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
const char *name = ROM_GETNAME(rom);
const char* hash = ROM_GETHASHDATA(rom);
int length = -1; /* default is for disks! */
if (ROMREGION_ISROMDATA(region))
{
length = 0;
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
length += ROM_GETLENGTH(chunk);
}
printf("%-12s ", name);
if (length >= 0)
printf("%7d",length);
else
printf(" ");
if (!hash_data_has_info(hash, HASH_INFO_NO_DUMP))
{
if (hash_data_has_info(hash, HASH_INFO_BAD_DUMP))
printf(" BAD");
hash_data_print(hash, 0, buf);
printf(" %s", buf);
}
else
printf(" NO GOOD DUMP KNOWN");
printf("\n");
}
}
}
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 );
}
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++;
}
}
/*-------------------------------------------------
softlist_match_roms - scan for a matching
software ROM by hash
-------------------------------------------------*/
static void softlist_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));
for (const device_config *dev = config->m_devicelist.first(SOFTWARE_LIST); dev != NULL; dev = dev->typenext())
{
software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(dev)->inline_config();
for ( int i = 0; i < DEVINFO_STR_SWLIST_MAX - DEVINFO_STR_SWLIST_0; i++ )
{
if ( swlist->list_name[i] )
{
software_list *list = software_list_open( options, swlist->list_name[i], FALSE, NULL );
for ( software_info *swinfo = software_list_find( list, "*", NULL ); swinfo != NULL; swinfo = software_list_find( list, "*", swinfo ) )
{
for ( software_part *part = software_find_part( swinfo, NULL, NULL ); part != NULL; part = software_part_next( part ) )
{
for ( const rom_entry *region = part->romdata; region != NULL; region = rom_next_region(region) )
{
for ( const rom_entry *rom = rom_first_file(region); rom != NULL; 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 %s:%s %s\n", baddump ? "(BAD) " : "", ROM_GETNAME(rom), swlist->list_name[i], swinfo->shortname, swinfo->longname);
(*found)++;
}
}
}
}
}
software_list_close( list );
}
}
}
global_free(config);
}
}
/* Identifies a rom from from this checksum */
static void match_roms(const struct GameDriver *driver,const char* hash,int *found)
{
const struct RomModule *region, *rom;
for (region = rom_first_region(driver); 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))
{
char baddump = hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_BAD_DUMP);
if (!silentident)
{
if (*found != 0)
fprintf(stdout_file, " ");
fprintf(stdout_file, "= %s%-12s %s\n",baddump ? "(BAD) " : "",ROM_GETNAME(rom),driver->description);
}
(*found)++;
}
}
}
}
static void match_roms(const char *hash, int length, int *found)
{
int drvindex;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex]; drvindex++)
{
const rom_entry *region, *rom;
/* iterate over regions and files within the region */
for (region = rom_first_region(drivers[drvindex]); 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 %s\n", baddump ? "(BAD) " : "", ROM_GETNAME(rom), drivers[drvindex]->description);
(*found)++;
}
}
}
int cli_info_listroms(core_options *options, const char *gamename)
{
int drvindex, count = 0;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex]; drvindex++)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
const rom_entry *region, *rom, *chunk;
/* 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 regions and then ROMs within the region */
for (region = drivers[drvindex]->rom; region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; 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 = 0;
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
length += ROM_GETLENGTH(chunk);
}
/* 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++;
}
return (count > 0) ? MAMERR_NONE : MAMERR_NO_SUCH_GAME;
}
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);
}
static void audit_one_disk(core_options *options, const rom_entry *rom, const game_driver *gamedrv, UINT32 validation, audit_record *record)
{
mame_file *source_file;
chd_file *source;
chd_error err;
/* fill in the record basics */
record->type = AUDIT_FILE_DISK;
record->name = ROM_GETNAME(rom);
record->exphash = ROM_GETHASHDATA(rom);
/* open the disk */
err = open_disk_image_options(options, gamedrv, rom, &source_file, &source);
/* if we failed, report the error */
if (err != CHDERR_NONE)
{
/* out of memory */
if (err == CHDERR_OUT_OF_MEMORY)
set_status(record, AUDIT_STATUS_ERROR, SUBSTATUS_ERROR);
/* not found but it's not good anyway */
else if (hash_data_has_info(record->exphash, HASH_INFO_NO_DUMP))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_NODUMP);
/* not found but optional */
else if (DISK_ISOPTIONAL(rom))
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND_OPTIONAL);
/* not found at all */
else
set_status(record, AUDIT_STATUS_NOT_FOUND, SUBSTATUS_NOT_FOUND);
}
/* if we succeeded, validate it */
else
{
static const UINT8 nullhash[HASH_BUF_SIZE] = { 0 };
chd_header header = *chd_get_header(source);
/* if there's an MD5 or SHA1 hash, add them to the output hash */
if (memcmp(nullhash, header.md5, sizeof(header.md5)) != 0)
hash_data_insert_binary_checksum(record->hash, HASH_MD5, header.md5);
if (memcmp(nullhash, header.sha1, sizeof(header.sha1)) != 0)
hash_data_insert_binary_checksum(record->hash, HASH_SHA1, header.sha1);
/* found but needs a dump */
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 good */
else
set_status(record, AUDIT_STATUS_GOOD, SUBSTATUS_GOOD);
chd_close(source);
mame_fclose(source_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);
}
}
/* Fills in an audit record for each rom in the romset. Sets 'audit' to
point to the list of audit records. Returns total number of roms
in the romset (same as number of audit records), 0 if romset missing. */
int audit_roms (int game, audit_record **audit)
{
const rom_entry *region, *rom, *chunk;
const char *name;
const game_driver *gamedrv;
const game_driver *clone_of;
int count = 0;
audit_record *aud;
int err;
if (!audit_records)
{
audit_records = (audit_record *)malloc (AUD_MAX_ROMS * sizeof (audit_record));
// Make sure the memory is cleared - it's needed by the hashing
// engine
memset(audit_records, 0, AUD_MAX_ROMS * sizeof(audit_record));
}
if (audit_records)
*audit = aud = audit_records;
else
return 0;
gamedrv = drivers[game];
clone_of = driver_get_clone(gamedrv);
if (!gamedrv->rom) return -1;
/* check for existence of romset */
if (!mame_faccess (gamedrv->name, FILETYPE_ROM))
{
/* if the game is a clone, check for parent */
if (clone_of == NULL || (clone_of->flags & NOT_A_DRIVER) ||
!mame_faccess(clone_of->name,FILETYPE_ROM))
return 0;
}
for (region = rom_first_region(gamedrv); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
if (ROMREGION_ISROMDATA(region))
{
const game_driver *drv;
name = ROM_GETNAME(rom);
strcpy (aud->rom, name);
aud->explength = 0;
aud->length = 0;
aud->exphash = ROM_GETHASHDATA(rom);
/* Copy into the variable we pass to the functions
to support load-by-checksum */
hash_data_copy(aud->hash, aud->exphash);
count++;
/* obtain hash checksums and length of ROM file */
drv = gamedrv;
do
{
err = mame_fchecksum(drv->name, name, &aud->length, aud->hash);
drv = driver_get_clone(drv);
} while (err && drv);
/* spin through ROM_CONTINUEs, totaling length */
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
aud->explength += ROM_GETLENGTH(chunk);
if (err)
{
if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
{
/* not found but it's not good anyway */
aud->status = AUD_NOT_AVAILABLE;
}
else if (ROM_ISOPTIONAL(rom))
{
/* optional ROM not found */
aud->status = AUD_OPTIONAL_ROM_NOT_FOUND;
}
else
{
/* not found */
aud->status = AUD_ROM_NOT_FOUND;
drv = clone_of;
/* If missing ROM is also present in a parent set, indicate that */
while (drv)
{
if (audit_is_rom_used (drv, aud->exphash))
{
if (drv->flags & NOT_A_DRIVER)
{
aud->status = AUD_ROM_NOT_FOUND_BIOS;
break;
}
else
aud->status = AUD_ROM_NOT_FOUND_PARENT;
}
// Walk up the inheritance list. If this ROM is a clone of a set which
// contains a BIOS that is missing, we can correctly mark it as
// such.
drv = driver_get_clone(drv);
}
}
}
/* all cases below assume the ROM was at least found */
else if (aud->explength != aud->length)
aud->status = AUD_LENGTH_MISMATCH;
else if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
aud->status = AUD_ROM_NEED_DUMP; /* new case - found but not known to be dumped */
else if (!hash_data_is_equal(aud->exphash, aud->hash, 0))
{
/* non-matching hash */
aud->status = AUD_BAD_CHECKSUM;
}
else
{
/* matching hash */
if (hash_data_has_info(aud->exphash, HASH_INFO_BAD_DUMP))
aud->status = AUD_ROM_NEED_REDUMP;
else
aud->status = AUD_ROM_GOOD;
}
aud++;
}
else if (ROMREGION_ISDISKDATA(region))
{
const UINT8 nullhash[HASH_BUF_SIZE] = { 0 };
void *source;
chd_header header;
name = ROM_GETNAME(rom);
strcpy (aud->rom, name);
aud->explength = 0;
aud->length = 0;
aud->exphash = ROM_GETHASHDATA(rom);
hash_data_clear(aud->hash);
count++;
chd_gamedrv = gamedrv;
chd_set_interface(&audit_chd_interface);
source = chd_open( name, 0, NULL );
if( source == NULL )
{
err = chd_get_last_error();
if( err == CHDERR_OUT_OF_MEMORY )
{
aud->status = AUD_MEM_ERROR;
}
else if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
{
/* not found but it's not good anyway */
aud->status = AUD_DISK_NOT_AVAILABLE;
}
else
{
/* not found */
aud->status = AUD_DISK_NOT_FOUND;
}
}
else
{
header = *chd_get_header(source);
if (memcmp(nullhash, header.md5, sizeof(header.md5)))
hash_data_insert_binary_checksum(aud->hash, HASH_MD5, header.md5);
if (memcmp(nullhash, header.sha1, sizeof(header.sha1)))
hash_data_insert_binary_checksum(aud->hash, HASH_SHA1, header.sha1);
if (hash_data_has_info(aud->exphash, HASH_INFO_NO_DUMP))
{
aud->status = AUD_DISK_NEED_DUMP;
}
else if (!hash_data_is_equal(aud->exphash, aud->hash, 0))
{
aud->status = AUD_DISK_BAD_MD5;
}
else
{
aud->status = AUD_DISK_GOOD;
}
chd_close( source );
}
aud++;
}
}
#ifdef MESS
if (!count)
return -1;
else
#endif
return count;
}
static void process_disk_entries(rom_load_data *romdata, const rom_entry *romp)
{
/* loop until we hit the end of this region */
while (!ROMENTRY_ISREGIONEND(romp))
{
/* handle files */
if (ROMENTRY_ISFILE(romp))
{
chd_file *source, *diff = NULL;
chd_header header;
char filename[1024];
char acthash[HASH_BUF_SIZE];
chd_error err;
/* make the filename of the source */
sprintf(filename, "%s.chd", ROM_GETNAME(romp));
/* first open the source drive */
debugload("Opening disk image: %s\n", filename);
err = open_disk_image(Machine->gamedrv, romp, &source);
if (err != CHDERR_NONE)
{
if (err == CHDERR_UNSUPPORTED_VERSION)
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s UNSUPPORTED CHD VERSION\n", filename);
else
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s NOT FOUND\n", filename);
/* if this is NO_DUMP, keep going, though the system may not be able to handle it */
if (hash_data_has_info(ROM_GETHASHDATA(romp), HASH_INFO_NO_DUMP))
romdata->warnings++;
else
romdata->errors++;
romp++;
continue;
}
/* get the header and extract the MD5/SHA1 */
header = *chd_get_header(source);
hash_data_clear(acthash);
hash_data_insert_binary_checksum(acthash, HASH_MD5, header.md5);
hash_data_insert_binary_checksum(acthash, HASH_SHA1, header.sha1);
/* verify the MD5 */
if (!hash_data_is_equal(ROM_GETHASHDATA(romp), acthash, 0))
{
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s WRONG CHECKSUMS:\n", filename);
dump_wrong_and_correct_checksums(romdata, ROM_GETHASHDATA(romp), acthash);
romdata->warnings++;
}
else if (hash_data_has_info(ROM_GETHASHDATA(romp), HASH_INFO_BAD_DUMP))
{
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s CHD NEEDS REDUMP\n", filename);
romdata->warnings++;
}
/* if not read-only, make the diff file */
if (!DISK_ISREADONLY(romp))
{
/* make the filename of the diff */
sprintf(filename, "%s.dif", ROM_GETNAME(romp));
/* try to open the diff */
debugload("Opening differencing image: %s\n", filename);
err = chd_open(filename, CHD_OPEN_READWRITE, source, &diff);
if (err != CHDERR_NONE)
{
/* didn't work; try creating it instead */
debugload("Creating differencing image: %s\n", filename);
err = chd_create(filename, 0, 0, CHDCOMPRESSION_NONE, source);
if (err != CHDERR_NONE)
{
if (err == CHDERR_UNSUPPORTED_VERSION)
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s UNSUPPORTED CHD VERSION\n", filename);
else
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s: CAN'T CREATE DIFF FILE\n", filename);
romdata->errors++;
romp++;
continue;
}
/* open the newly-created diff file */
debugload("Opening differencing image: %s\n", filename);
err = chd_open(filename, CHD_OPEN_READWRITE, source, &diff);
if (err != CHDERR_NONE)
{
if (err == CHDERR_UNSUPPORTED_VERSION)
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s UNSUPPORTED CHD VERSION\n", filename);
else
sprintf(&romdata->errorbuf[strlen(romdata->errorbuf)], "%s: CAN'T OPEN DIFF FILE\n", filename);
romdata->errors++;
romp++;
continue;
}
}
}
/* we're okay, set the handle */
debugload("Assigning to handle %d\n", DISK_GETINDEX(romp));
disk_handle[DISK_GETINDEX(romp)] = DISK_ISREADONLY(romp) ? source : diff;
romp++;
}
}
}
static void print_game_rom(FILE* out, const game_driver* game)
{
const rom_entry *region, *rom, *chunk;
const rom_entry *pregion, *prom, *fprom=NULL;
const game_driver *clone_of;
if (!game->rom)
return;
clone_of = driver_get_clone(game);
for (region = rom_first_region(game); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
int offset, length, in_parent, is_disk, is_bios, found_bios, i;
char name[100], bios_name[100];
strcpy(name,ROM_GETNAME(rom));
offset = ROM_GETOFFSET(rom);
is_disk = ROMREGION_ISDISKDATA(region);
is_bios = ROM_GETBIOSFLAGS(rom);
in_parent = 0;
length = 0;
for (chunk = rom_first_chunk(rom); chunk; chunk = rom_next_chunk(chunk))
length += ROM_GETLENGTH(chunk);
if (!ROM_NOGOODDUMP(rom) && clone_of)
{
fprom=NULL;
for (pregion = rom_first_region(clone_of); pregion; pregion = rom_next_region(pregion))
for (prom = rom_first_file(pregion); prom; prom = rom_next_file(prom))
if (hash_data_is_equal(ROM_GETHASHDATA(rom), ROM_GETHASHDATA(prom), 0))
{
if (!fprom || !strcmp(ROM_GETNAME(prom), name))
fprom=prom;
in_parent = 1;
}
}
found_bios = 0;
if(!is_disk && is_bios && game->bios)
{
const bios_entry *thisbios = game->bios;
/* Match against bios short names */
while(!found_bios && !BIOSENTRY_ISEND(thisbios) )
{
if((is_bios-1) == thisbios->value) /* Note '-1' */
{
strcpy(bios_name,thisbios->_name);
found_bios = 1;
}
thisbios++;
}
}
if (!is_disk)
fprintf(out, "\t\t<rom");
else
fprintf(out, "\t\t<disk");
if (*name)
fprintf(out, " name=\"%s\"", normalize_string(name));
if (in_parent)
fprintf(out, " merge=\"%s\"", normalize_string(ROM_GETNAME(fprom)));
if (!is_disk && found_bios)
fprintf(out, " bios=\"%s\"", normalize_string(bios_name));
if (!is_disk)
fprintf(out, " size=\"%d\"", length);
/* dump checksum information only if there is a known dump */
if (!hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_NO_DUMP))
{
for (i=0;i<HASH_NUM_FUNCTIONS;i++)
{
int func = 1<<i;
const char* func_name = hash_function_name(func);
char checksum[1000];
if (hash_data_extract_printable_checksum(ROM_GETHASHDATA(rom), func, checksum))
{
fprintf(out, " %s=\"%s\"", func_name, checksum);
}
}
}
switch (ROMREGION_GETTYPE(region))
{
case REGION_CPU1: fprintf(out, " region=\"cpu1\""); break;
case REGION_CPU2: fprintf(out, " region=\"cpu2\""); break;
case REGION_CPU3: fprintf(out, " region=\"cpu3\""); break;
case REGION_CPU4: fprintf(out, " region=\"cpu4\""); break;
case REGION_CPU5: fprintf(out, " region=\"cpu5\""); break;
case REGION_CPU6: fprintf(out, " region=\"cpu6\""); break;
case REGION_CPU7: fprintf(out, " region=\"cpu7\""); break;
case REGION_CPU8: fprintf(out, " region=\"cpu8\""); break;
case REGION_GFX1: fprintf(out, " region=\"gfx1\""); break;
case REGION_GFX2: fprintf(out, " region=\"gfx2\""); break;
case REGION_GFX3: fprintf(out, " region=\"gfx3\""); break;
case REGION_GFX4: fprintf(out, " region=\"gfx4\""); break;
case REGION_GFX5: fprintf(out, " region=\"gfx5\""); break;
case REGION_GFX6: fprintf(out, " region=\"gfx6\""); break;
case REGION_GFX7: fprintf(out, " region=\"gfx7\""); break;
case REGION_GFX8: fprintf(out, " region=\"gfx8\""); break;
case REGION_PROMS: fprintf(out, " region=\"proms\""); break;
case REGION_SOUND1: fprintf(out, " region=\"sound1\""); break;
case REGION_SOUND2: fprintf(out, " region=\"sound2\""); break;
case REGION_SOUND3: fprintf(out, " region=\"sound3\""); break;
case REGION_SOUND4: fprintf(out, " region=\"sound4\""); break;
case REGION_SOUND5: fprintf(out, " region=\"sound5\""); break;
case REGION_SOUND6: fprintf(out, " region=\"sound6\""); break;
case REGION_SOUND7: fprintf(out, " region=\"sound7\""); break;
case REGION_SOUND8: fprintf(out, " region=\"sound8\""); break;
case REGION_USER1: fprintf(out, " region=\"user1\""); break;
case REGION_USER2: fprintf(out, " region=\"user2\""); break;
case REGION_USER3: fprintf(out, " region=\"user3\""); break;
case REGION_USER4: fprintf(out, " region=\"user4\""); break;
case REGION_USER5: fprintf(out, " region=\"user5\""); break;
case REGION_USER6: fprintf(out, " region=\"user6\""); break;
case REGION_USER7: fprintf(out, " region=\"user7\""); break;
case REGION_USER8: fprintf(out, " region=\"user8\""); break;
case REGION_DISKS: fprintf(out, " region=\"disks\""); break;
default: fprintf(out, " region=\"0x%x\"", ROMREGION_GETTYPE(region));
}
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\"");
if (!is_disk)
{
if (ROMREGION_GETFLAGS(region) & ROMREGION_DISPOSE)
fprintf(out, " dispose=\"yes\"");
fprintf(out, " offset=\"%x\"", offset);
fprintf(out, "/>\n");
}
else
{
fprintf(out, " index=\"%x\"", DISK_GETINDEX(rom));
fprintf(out, "/>\n");
}
}
}
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 info_listsoftware(core_options *options, const char *gamename)
{
FILE *out = stdout;
int nr_lists = 0;
char ** lists = NULL;
int list_idx = 0;
/* First determine the maximum number of lists we might encounter */
for ( int drvindex = 0; drivers[drvindex] != NULL; drvindex++ )
{
if ( mame_strwildcmp( gamename, drivers[drvindex]->name ) == 0 )
{
/* allocate the machine config */
machine_config *config = global_alloc(machine_config(drivers[drvindex]->machine_config));
for (const device_config *dev = config->m_devicelist.first(SOFTWARE_LIST); dev != NULL; dev = dev->typenext())
{
software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(dev)->inline_config();
for ( int i = 0; i < DEVINFO_STR_SWLIST_MAX - DEVINFO_STR_SWLIST_0; i++ )
{
if ( swlist->list_name[i] && *swlist->list_name[i] && (swlist->list_type == SOFTWARE_LIST_ORIGINAL_SYSTEM))
nr_lists++;
}
}
/* free the machine config */
global_free(config);
}
}
lists = global_alloc_array( char *, nr_lists );
fprintf( out,
"<?xml version=\"1.0\"?>\n"
"<!DOCTYPE softwarelist [\n"
"<!ELEMENT softwarelists (softwarelist*)>\n"
"\t<!ELEMENT softwarelist (software+)>\n"
"\t\t<!ATTLIST softwarelist name CDATA #REQUIRED>\n"
"\t\t<!ATTLIST softwarelist description CDATA #IMPLIED>\n"
"\t\t<!ELEMENT software (description, year?, publisher, part*)>\n"
"\t\t\t<!ATTLIST software name CDATA #REQUIRED>\n"
"\t\t\t<!ATTLIST software cloneof CDATA #IMPLIED>\n"
"\t\t\t<!ATTLIST software supported (yes|partial|no) \"yes\">\n"
"\t\t\t<!ELEMENT description (#PCDATA)>\n"
"\t\t\t<!ELEMENT year (#PCDATA)>\n"
"\t\t\t<!ELEMENT publisher (#PCDATA)>\n"
"\t\t\t<!ELEMENT part (dataarea*)>\n"
"\t\t\t\t<!ATTLIST part name CDATA #REQUIRED>\n"
"\t\t\t\t<!ATTLIST part interface CDATA #REQUIRED>\n"
"\t\t\t\t<!ATTLIST part feature CDATA #IMPLIED>\n"
"\t\t\t\t<!ELEMENT dataarea (rom*)>\n"
"\t\t\t\t\t<!ATTLIST dataarea name CDATA #REQUIRED>\n"
"\t\t\t\t\t<!ATTLIST dataarea size CDATA #REQUIRED>\n"
"\t\t\t\t\t<!ATTLIST dataarea databits (8|16|32|64) \"8\">\n"
"\t\t\t\t\t<!ATTLIST dataarea endian (big|little) \"little\">\n"
"\t\t\t\t\t<!ELEMENT rom EMPTY>\n"
"\t\t\t\t\t\t<!ATTLIST rom name CDATA #IMPLIED>\n"
"\t\t\t\t\t\t<!ATTLIST rom size CDATA #REQUIRED>\n"
"\t\t\t\t\t\t<!ATTLIST rom crc CDATA #IMPLIED>\n"
"\t\t\t\t\t\t<!ATTLIST rom md5 CDATA #IMPLIED>\n"
"\t\t\t\t\t\t<!ATTLIST rom sha1 CDATA #IMPLIED>\n"
"\t\t\t\t\t\t<!ATTLIST rom offset CDATA #IMPLIED>\n"
"\t\t\t\t\t\t<!ATTLIST rom status (baddump|nodump|good) \"good\">\n"
"\t\t\t\t\t\t<!ATTLIST rom loadflag (load16_byte|load16_word|load16_word_swap|load32_byte|load32_word|load32_word_swap|load32_dword|load64_word|load64_word_swap|reload) #IMPLIED>\n"
"]>\n\n"
"<softwarelists>\n"
);
for ( int drvindex = 0; drivers[drvindex] != NULL; drvindex++ )
{
if ( mame_strwildcmp( gamename, drivers[drvindex]->name ) == 0 )
{
/* allocate the machine config */
machine_config *config = global_alloc(machine_config(drivers[drvindex]->machine_config));
for (const device_config *dev = config->m_devicelist.first(SOFTWARE_LIST); dev != NULL; dev = dev->typenext())
{
software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(dev)->inline_config();
for ( int i = 0; i < DEVINFO_STR_SWLIST_MAX - DEVINFO_STR_SWLIST_0; i++ )
{
if ( swlist->list_name[i] && *swlist->list_name[i] && (swlist->list_type == SOFTWARE_LIST_ORIGINAL_SYSTEM))
{
software_list *list = software_list_open( options, swlist->list_name[i], FALSE, NULL );
if ( list )
{
/* Verify if we have encountered this list before */
bool seen_before = false;
for ( int l = 0; l < list_idx && !seen_before; l++ )
{
if ( ! strcmp( swlist->list_name[i], lists[l] ) )
{
seen_before = true;
}
}
if ( ! seen_before )
{
lists[list_idx] = core_strdup( swlist->list_name[i] );
list_idx++;
fprintf(out, "\t<softwarelist name=\"%s\">\n", swlist->list_name[i] );
for ( software_info *swinfo = software_list_find( list, "*", NULL ); swinfo != NULL; swinfo = software_list_find( list, "*", swinfo ) )
{
fprintf( out, "\t\t<software name=\"%s\"", swinfo->shortname );
if ( swinfo->parentname != NULL )
fprintf( out, " cloneof=\"%s\"", swinfo->parentname );
if ( swinfo->supported == SOFTWARE_SUPPORTED_PARTIAL )
fprintf( out, " supported=\"partial\"" );
if ( swinfo->supported == SOFTWARE_SUPPORTED_NO )
fprintf( out, " supported=\"no\"" );
fprintf( out, ">\n" );
fprintf( out, "\t\t\t<description>%s</description>\n", xml_normalize_string(swinfo->longname) );
fprintf( out, "\t\t\t<year>%s</year>\n", xml_normalize_string( swinfo->year ) );
fprintf( out, "\t\t\t<publisher>%s</publisher>\n", xml_normalize_string( swinfo->publisher ) );
for ( software_part *part = software_find_part( swinfo, NULL, NULL ); part != NULL; part = software_part_next( part ) )
{
fprintf( out, "\t\t\t<part name=\"%s\"", part->name );
if ( part->interface_ )
fprintf( out, " interface=\"%s\"", part->interface_ );
// if ( part->feature )
// fprintf( out, " features=\"%s\"", part->feature );
fprintf( out, ">\n");
/* TODO: display rom region information */
for ( const rom_entry *region = part->romdata; region; region = rom_next_region( region ) )
{
fprintf( out, "\t\t\t\t<dataarea name=\"%s\" size=\"%x\">\n", ROMREGION_GETTAG(region), ROMREGION_GETLENGTH(region) );
for ( const rom_entry *rom = rom_first_file( region ); rom && !ROMENTRY_ISREGIONEND(rom); rom++ )
{
if ( ROMENTRY_ISFILE(rom) )
{
fprintf( out, "\t\t\t\t\t<rom name=\"%s\" size=\"%d\"", xml_normalize_string(ROM_GETNAME(rom)), 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);
}
fprintf( out, " offset=\"%x\"", ROM_GETOFFSET(rom) );
if ( hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_BAD_DUMP) )
fprintf( out, " status=\"baddump\"" );
if ( hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_NO_DUMP) )
fprintf( out, " status=\"nodump\"" );
fprintf( out, "/>\n" );
}
else if ( ROMENTRY_ISRELOAD(rom) )
{
fprintf( out, "\t\t\t\t\t<rom size=\"%d\" offset=\"%x\" loadflag=\"reload\" />\n", ROM_GETLENGTH(rom), ROM_GETOFFSET(rom) );
}
}
fprintf( out, "\t\t\t\t</dataarea>\n" );
}
fprintf( out, "\t\t\t</part>\n" );
}
fprintf( out, "\t\t</software>\n" );
}
fprintf(out, "\t</softwarelist>\n" );
}
software_list_close( list );
}
}
}
}
global_free(config);
}
}
fprintf( out, "</softwarelists>\n" );
global_free( lists );
return MAMERR_NONE;
}
