int cli_info_listclones(core_options *options, const char *gamename)
{
int drvindex, count = 0;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex]; drvindex++)
{
const game_driver *clone_of = driver_get_clone(drivers[drvindex]);
/* if we are a clone, and either our name matches the gamename, or the clone's name matches, display us */
if (clone_of != NULL && (clone_of->flags & GAME_IS_BIOS_ROOT) == 0)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0 || mame_strwildcmp(gamename, clone_of->name) == 0)
{
/* print the header on the first one */
if (count == 0)
mame_printf_info("Name: Clone of:\n");
/* output the remaining information */
mame_printf_info("%-8s %-8s\n", drivers[drvindex]->name, clone_of->name);
count++;
}
}
/* return an error if none found */
return (count > 0) ? MAMERR_NONE : MAMERR_NO_SUCH_GAME;
}
static int open_rom_file(rom_load_data *romdata, const rom_entry *romp)
{
mame_file_error filerr = FILERR_NOT_FOUND;
const game_driver *drv;
++romdata->romsloaded;
/* update status display */
display_loading_rom_message(ROM_GETNAME(romp), romdata);
/* Attempt reading up the chain through the parents. It automatically also
attempts any kind of load by checksum supported by the archives. */
romdata->file = NULL;
for (drv = Machine->gamedrv; !romdata->file && drv; drv = driver_get_clone(drv))
if (drv->name && *drv->name)
{
UINT8 crcs[4];
char *fname;
fname = assemble_3_strings(drv->name, PATH_SEPARATOR, ROM_GETNAME(romp));
if (hash_data_extract_binary_checksum(ROM_GETHASHDATA(romp), HASH_CRC, crcs))
{
UINT32 crc = (crcs[0] << 24) | (crcs[1] << 16) | (crcs[2] << 8) | crcs[3];
filerr = mame_fopen_crc(SEARCHPATH_ROM, fname, crc, OPEN_FLAG_READ, &romdata->file);
}
else
filerr = mame_fopen(SEARCHPATH_ROM, fname, OPEN_FLAG_READ, &romdata->file);
free(fname);
}
/* return the result */
return (filerr == FILERR_NONE);
}
/* Print the MAME info record for a game */
static void print_game_info(FILE* out, const game_driver* game)
{
const char *start;
const game_driver *clone_of;
/* No action if not a game */
if (game->flags & NOT_A_DRIVER)
return;
fprintf(out, "\t<" XML_TOP);
fprintf(out, " name=\"%s\"", normalize_string(game->name) );
start = strrchr(game->source_file, '/');
if (!start)
start = strrchr(game->source_file, '\\');
if (!start)
start = game->source_file - 1;
fprintf(out, " sourcefile=\"%s\"", normalize_string(start + 1));
clone_of = driver_get_clone(game);
if (clone_of && !(clone_of->flags & NOT_A_DRIVER))
fprintf(out, " cloneof=\"%s\"", normalize_string(clone_of->name));
if (clone_of)
fprintf(out, " romof=\"%s\"", normalize_string(clone_of->name));
print_game_sampleof(out, game);
fprintf(out, ">\n");
if (game->description)
fprintf(out, "\t\t<description>%s</description>\n", normalize_string(game->description));
/* print the year only if is a number */
if (game->year && strspn(game->year,"0123456789")==strlen(game->year))
fprintf(out, "\t\t<year>%s</year>\n", normalize_string(game->year) );
if (game->manufacturer)
fprintf(out, "\t\t<manufacturer>%s</manufacturer>\n", normalize_string(game->manufacturer));
print_game_bios(out, game);
print_game_rom(out, game);
print_game_sample(out, game);
print_game_micro(out, game);
print_game_video(out, game);
print_game_sound(out, game);
print_game_input(out, game);
print_game_switch(out, game);
print_game_driver(out, game);
#ifdef MESS
print_game_device(out, game);
print_game_ramoptions(out, game);
#endif
fprintf(out, "\t</" XML_TOP ">\n");
}
chd_interface_file *audit_chd_open(const char *filename, const char *mode)
{
const game_driver *drv;
/* attempt reading up the chain through the parents */
for (drv = chd_gamedrv; drv != NULL; drv = driver_get_clone(drv))
{
void* file = mame_fopen(drv->name, filename, FILETYPE_IMAGE, 0);
if (file != NULL)
return file;
}
return NULL;
}
static int rom_used_by_parent(const game_driver *gamedrv, const rom_entry *romentry, const game_driver **parent)
{
const char *hash = ROM_GETHASHDATA(romentry);
const game_driver *drv;
/* iterate up the parent chain */
for (drv = driver_get_clone(gamedrv); drv != NULL; drv = driver_get_clone(drv))
{
const rom_entry *region;
const rom_entry *rom;
/* see if the parent has the same ROM or not */
for (region = rom_first_region(drv, NULL); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
if (hash_data_is_equal(ROM_GETHASHDATA(rom), hash, 0))
{
if (parent != NULL)
*parent = drv;
return TRUE;
}
}
return FALSE;
}
/* returns nonzero if romset is missing */
int audit_has_missing_roms (int game)
{
const game_driver *gamedrv = drivers[game];
const game_driver *clone_of = driver_get_clone(gamedrv);
if (clone_of != NULL)
{
audit_record *aud;
int count;
int i;
#if 1
int cloneRomsFound = 0;
int uniqueRomsFound = 0;
if ((count = audit_roms (game, &aud)) == 0)
return 1;
if (count == -1) return 0;
/* count number of roms found that are unique to clone */
for (i = 0; i < count; i++)
if (!audit_is_rom_used (clone_of, aud[i].exphash))
{
uniqueRomsFound++;
if (aud[i].status != AUD_ROM_NOT_FOUND)
cloneRomsFound++;
}
#else
int cloneRomsFound = 0;
if ((count = audit_roms (game, &aud)) == 0)
return 1;
if (count == -1) return 0;
/* count number of roms found that are unique to clone */
for (i = 0; i < count; i++)
if (aud[i].status != AUD_ROM_NOT_FOUND)
if (!audit_is_rom_used (clone_of, aud[i].exphash))
cloneRomsFound++;
#endif
return !cloneRomsFound;
}
else
return !mame_faccess (gamedrv->name, FILETYPE_ROM);
}
static chd_interface_file *audit_chd_open(const char *filename, const char *mode)
{
const game_driver *drv;
/* attempt reading up the chain through the parents */
for (drv = chd_gamedrv; drv != NULL; drv = driver_get_clone(drv))
{
mame_file_error filerr;
mame_file *file;
char *fname;
fname = assemble_3_strings(drv->name, PATH_SEPARATOR, filename);
filerr = mame_fopen(SEARCHPATH_IMAGE, fname, OPEN_FLAG_READ, &file);
free(fname);
if (filerr == FILERR_NONE)
return (chd_interface_file *)file;
}
return NULL;
}
chd_error open_disk_image(const game_driver *gamedrv, const rom_entry *romp, chd_file **image)
{
const game_driver *drv;
const rom_entry *region, *rom;
const char *fname;
chd_error err;
/* attempt to open the properly named file */
fname = assemble_2_strings(ROM_GETNAME(romp), ".chd");
err = chd_open(fname, CHD_OPEN_READ, NULL, image);
free((void *)fname);
/* if that worked, we're done */
if (err == CHDERR_NONE)
return err;
/* otherwise, look at our parents for a CHD with an identical checksum */
/* and try to open that */
for (drv = gamedrv; drv != NULL; drv = driver_get_clone(drv))
for (region = rom_first_region(drv); region != NULL; region = rom_next_region(region))
if (ROMREGION_ISDISKDATA(region))
for (rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom))
/* look for a differing name but with the same hash data */
if (strcmp(ROM_GETNAME(romp), ROM_GETNAME(rom)) != 0 &&
hash_data_is_equal(ROM_GETHASHDATA(romp), ROM_GETHASHDATA(rom), 0))
{
fname = assemble_2_strings(ROM_GETNAME(rom), ".chd");
err = chd_open(fname, CHD_OPEN_READ, NULL, image);
free((void *)fname);
/* if that worked, we're done */
if (err == CHDERR_NONE)
return err;
}
return err;
}
int cli_info_listbrothers(core_options *options, const char *gamename)
{
UINT8 *didit = global_alloc_array_clear(UINT8, driver_list_get_count(drivers));
int drvindex, count = 0;
astring filename;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex] != NULL; drvindex++)
if (!didit[drvindex] && mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
int matchindex;
didit[drvindex] = TRUE;
if (count > 0)
mame_printf_info("\n");
mame_printf_info("%s ... other drivers in %s:\n", drivers[drvindex]->name, core_filename_extract_base(&filename, drivers[drvindex]->source_file, FALSE)->cstr());
/* now iterate again over drivers, finding those with the same source file */
for (matchindex = 0; drivers[matchindex]; matchindex++)
if (matchindex != drvindex && strcmp(drivers[drvindex]->source_file, drivers[matchindex]->source_file) == 0)
{
const char *matchstring = (mame_strwildcmp(gamename, drivers[matchindex]->name) == 0) ? "-> " : " ";
const game_driver *clone_of = driver_get_clone(drivers[matchindex]);
if (clone_of != NULL && (clone_of->flags & GAME_IS_BIOS_ROOT) == 0)
mame_printf_info("%s%-16s [%s]\n", matchstring, drivers[matchindex]->name, clone_of->name);
else
mame_printf_info("%s%s\n", matchstring, drivers[matchindex]->name);
didit[matchindex] = TRUE;
}
count++;
}
/* return an error if none found */
global_free(didit);
return (count > 0) ? MAMERR_NONE : MAMERR_NO_SUCH_GAME;
}
static int config_load_xml(mame_file *file, int which_type)
{
xml_data_node *root, *confignode, *systemnode;
config_type *type;
const char *srcfile;
int version, count;
/* read the file */
root = xml_file_read(file, NULL);
if (!root)
goto error;
/* find the config node */
confignode = xml_get_sibling(root->child, "mameconfig");
if (!confignode)
goto error;
/* validate the config data version */
version = xml_get_attribute_int(confignode, "version", 0);
if (version != CONFIG_VERSION)
goto error;
/* strip off all the path crap from the source filename */
srcfile = strrchr(Machine->gamedrv->source_file, '/');
if (!srcfile)
srcfile = strrchr(Machine->gamedrv->source_file, '\\');
if (!srcfile)
srcfile = strrchr(Machine->gamedrv->source_file, ':');
if (!srcfile)
srcfile = Machine->gamedrv->source_file;
else
srcfile++;
/* loop over all system nodes in the file */
count = 0;
for (systemnode = xml_get_sibling(confignode->child, "system"); systemnode; systemnode = xml_get_sibling(systemnode->next, "system"))
{
/* look up the name of the system here; skip if none */
const char *name = xml_get_attribute_string(systemnode, "name", "");
/* based on the file type, determine whether we have a match */
switch (which_type)
{
case CONFIG_TYPE_GAME:
/* only match on the specific game name */
if (strcmp(name, Machine->gamedrv->name) != 0)
continue;
break;
case CONFIG_TYPE_DEFAULT:
/* only match on default */
if (strcmp(name, "default") != 0)
continue;
break;
case CONFIG_TYPE_CONTROLLER:
{
const game_driver *clone_of;
/* match on: default, game name, source file name, parent name, grandparent name */
if (strcmp(name, "default") != 0 &&
strcmp(name, Machine->gamedrv->name) != 0 &&
strcmp(name, srcfile) != 0 &&
((clone_of = driver_get_clone(Machine->gamedrv)) == NULL || strcmp(name, clone_of->name) != 0) &&
(clone_of == NULL || ((clone_of = driver_get_clone(clone_of)) == NULL) || strcmp(name, clone_of->name) != 0))
continue;
break;
}
}
/* log that we are processing this entry */
if (DEBUG_CONFIG)
mame_printf_debug("Entry: %s -- processing\n", name);
/* loop over all registrants and call their load function */
for (type = typelist; type; type = type->next)
(*type->load)(which_type, xml_get_sibling(systemnode->child, type->name));
count++;
}
/* error if this isn't a valid game match */
if (count == 0)
goto error;
/* free the parser */
xml_file_free(root);
return 1;
error:
if (root)
xml_file_free(root);
return 0;
}
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 print_game_info(FILE *out, const game_driver *game)
{
const input_port_config *portconfig;
const game_driver *clone_of;
machine_config *config;
const char *start;
/* no action if not a game */
if (game->flags & GAME_NO_STANDALONE)
return;
/* start tracking resources and allocate the machine and input configs */
config = machine_config_alloc(game->machine_config);
#ifdef MESS
/* temporary hook until MESS device transition is complete */
mess_devices_setup(NULL, config, game);
#endif /* MESS */
portconfig = input_port_config_alloc(game->ipt, NULL, 0);
/* print the header and the game name */
fprintf(out, "\t<" XML_TOP);
fprintf(out, " name=\"%s\"", xml_normalize_string(game->name) );
/* strip away any path information from the source_file and output it */
start = strrchr(game->source_file, '/');
if (start == NULL)
start = strrchr(game->source_file, '\\');
if (start == NULL)
start = game->source_file - 1;
fprintf(out, " sourcefile=\"%s\"", xml_normalize_string(start + 1));
/* append bios and runnable flags */
if (game->flags & GAME_IS_BIOS_ROOT)
fprintf(out, " isbios=\"yes\"");
if (game->flags & GAME_NO_STANDALONE)
fprintf(out, " runnable=\"no\"");
/* display clone information */
clone_of = driver_get_clone(game);
if (clone_of != NULL && !(clone_of->flags & GAME_IS_BIOS_ROOT))
fprintf(out, " cloneof=\"%s\"", xml_normalize_string(clone_of->name));
if (clone_of != NULL)
fprintf(out, " romof=\"%s\"", xml_normalize_string(clone_of->name));
/* display sample information and close the game tag */
print_game_sampleof(out, game, config);
fprintf(out, ">\n");
/* output game description */
if (game->description != NULL)
fprintf(out, "\t\t<description>%s</description>\n", xml_normalize_string(game->description));
/* print the year only if is a number */
if (game->year != NULL && strspn(game->year, "0123456789") == strlen(game->year))
fprintf(out, "\t\t<year>%s</year>\n", xml_normalize_string(game->year));
/* print the manufacturer information */
if (game->manufacturer != NULL)
fprintf(out, "\t\t<manufacturer>%s</manufacturer>\n", xml_normalize_string(game->manufacturer));
/* now print various additional information */
print_game_bios(out, game);
print_game_rom(out, game, config);
print_game_sample(out, game, config);
print_game_chips(out, game, config);
print_game_display(out, game, config);
print_game_sound(out, game, config);
print_game_input(out, game, portconfig);
print_game_switches(out, game, portconfig);
print_game_configs(out, game, portconfig);
#ifdef MESS
print_game_categories(out, game, portconfig);
#endif /* MESS */
print_game_adjusters(out, game, portconfig);
print_game_driver(out, game, config);
#ifdef MESS
print_game_device(out, game, config);
print_game_ramoptions(out, game, config);
#endif /* MESS */
/* close the topmost tag */
fprintf(out, "\t</" XML_TOP ">\n");
input_port_config_free(portconfig);
machine_config_free(config);
}
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 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);
}
}
/* Generic function for evaluating a romset. Some platforms may wish to
call audit_roms() instead and implement their own reporting (like MacMAME). */
int audit_verify_roms (int game, verify_printf_proc verify_printf)
{
audit_record *aud;
int count;
int archive_status = 0;
const game_driver *gamedrv = drivers[game];
const game_driver *clone_of = driver_get_clone(gamedrv);
if ((count = audit_roms (game, &aud)) == 0)
return NOTFOUND;
if (count == -1) return CORRECT;
#if 1
if (clone_of != NULL)
{
int i;
int cloneRomsFound = 0;
int uniqueRomsFound = 0;
/* count number of roms found that are unique to clone */
for (i = 0; i < count; i++)
if (!audit_is_rom_used (clone_of, aud[i].exphash))
{
uniqueRomsFound++;
if (aud[i].status != AUD_ROM_NOT_FOUND)
cloneRomsFound++;
}
#ifndef MESS
/* Different MESS systems can use the same ROMs */
if (uniqueRomsFound && !cloneRomsFound)
return CLONE_NOTFOUND;
#endif
}
#else
if (clone_of != NULL)
{
int i;
int cloneRomsFound = 0;
/* count number of roms found that are unique to clone */
for (i = 0; i < count; i++)
if (aud[i].status != AUD_ROM_NOT_FOUND)
if (!audit_is_rom_used (clone_of, aud[i].exphash))
cloneRomsFound++;
#ifndef MESS
/* Different MESS systems can use the same ROMs */
if (cloneRomsFound == 0)
return CLONE_NOTFOUND;
#endif
}
#endif
while (count--)
{
archive_status |= aud->status;
switch (aud->status)
{
case AUD_ROM_NOT_FOUND:
verify_printf ("%-8s: %-12s %7d bytes NOT FOUND\n",
drivers[game]->name, aud->rom, aud->explength);
verify_dump_hash_data(aud->exphash, NULL, verify_printf);
break;
case AUD_ROM_NOT_FOUND_PARENT:
verify_printf ("%-8s: %-12s %7d bytes NOT FOUND (shared with parent)\n",
drivers[game]->name, aud->rom, aud->explength);
verify_dump_hash_data(aud->exphash, NULL, verify_printf);
break;
case AUD_ROM_NOT_FOUND_BIOS:
verify_printf ("%-8s: %-12s %7d bytes NOT FOUND (BIOS)\n",
drivers[game]->name, aud->rom, aud->explength);
verify_dump_hash_data(aud->exphash, NULL, verify_printf);
break;
case AUD_OPTIONAL_ROM_NOT_FOUND:
verify_printf ("%-8s: %-12s %7d bytes NOT FOUND BUT OPTIONAL\n",
drivers[game]->name, aud->rom, aud->explength);
verify_dump_hash_data(aud->exphash, NULL, verify_printf);
break;
case AUD_NOT_AVAILABLE:
verify_printf ("%-8s: %-12s %7d bytes NOT FOUND - NO GOOD DUMP KNOWN\n",
drivers[game]->name, aud->rom, aud->explength);
break;
case AUD_ROM_NEED_DUMP:
verify_printf ("%-8s: %-12s %7d bytes FOUND BUT NO GOOD DUMP KNOWN\n",
drivers[game]->name, aud->rom, aud->explength);
break;
case AUD_BAD_CHECKSUM:
verify_printf ("%-8s: %-12s %7d bytes INCORRECT CHECKSUM:\n",
drivers[game]->name, aud->rom, aud->explength);
verify_dump_hash_data(aud->exphash, "EXPECTED: ", verify_printf);
verify_dump_hash_data(aud->hash, " FOUND: ", verify_printf);
break;
case AUD_ROM_NEED_REDUMP:
verify_printf ("%-8s: %-12s %7d bytes ROM NEEDS REDUMP\n",
drivers[game]->name, aud->rom, aud->explength);
break;
case AUD_MEM_ERROR:
verify_printf ("Out of memory reading ROM %s\n", aud->rom);
break;
case AUD_LENGTH_MISMATCH:
verify_printf ("%-8s: %-12s %7d bytes INCORRECT LENGTH: %8d\n",
drivers[game]->name, aud->rom, aud->explength, aud->length);
verify_dump_hash_data(aud->exphash, NULL, verify_printf);
break;
case AUD_ROM_GOOD:
#if 0 /* if you want a full accounting of roms */
verify_printf ("%-8s: %-12s %7d bytes ROM GOOD\n",
drivers[game]->name, aud->rom, aud->explength);
verify_dump_hash_data(aud->hash, NULL, verify_printf);
#endif
break;
case AUD_DISK_GOOD:
#if 0 /* if you want a full accounting of roms */
verify_printf ("%-8s: %-12s GOOD\n",
drivers[game]->name, aud->rom);
verify_dump_hash_data(aud->hash, NULL, verify_printf);
#endif
break;
case AUD_DISK_NOT_FOUND:
verify_printf ("%-8s: %-12s NOT FOUND\n",
drivers[game]->name, aud->rom);
verify_dump_hash_data(aud->exphash, NULL, verify_printf);
break;
case AUD_DISK_BAD_MD5:
verify_printf ("%-8s: %-12s INCORRECT CHECKSUM:\n",
drivers[game]->name, aud->rom);
verify_dump_hash_data(aud->exphash, "EXPECTED: ", verify_printf);
verify_dump_hash_data(aud->hash, " FOUND: ", verify_printf);
break;
case AUD_DISK_NOT_AVAILABLE:
verify_printf ("%-8s: %-12s NO GOOD DUMP KNOWN\n",
drivers[game]->name, aud->rom);
break;
case AUD_DISK_NEED_DUMP:
verify_printf ("%-8s: %-12s FOUND BUT NO GOOD DUMP KNOWN\n",
drivers[game]->name, aud->rom);
verify_dump_hash_data(aud->hash, NULL, verify_printf);
break;
}
aud++;
}
if (archive_status & (AUD_ROM_NOT_FOUND|AUD_ROM_NOT_FOUND_PARENT|AUD_ROM_NOT_FOUND_BIOS|AUD_BAD_CHECKSUM|AUD_MEM_ERROR|AUD_LENGTH_MISMATCH|AUD_DISK_NOT_FOUND|AUD_DISK_BAD_MD5))
return INCORRECT;
if (archive_status & (AUD_ROM_NEED_DUMP|AUD_ROM_NEED_REDUMP|AUD_NOT_AVAILABLE|AUD_DISK_NOT_AVAILABLE|AUD_DISK_NEED_DUMP))
return BEST_AVAILABLE;
if (archive_status & (AUD_OPTIONAL_ROM_NOT_FOUND))
return MISSING_OPTIONAL;
return CORRECT;
}
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");
}
}
}
int mess_validitychecks(void)
{
int i, j;
int error = 0;
iodevice_t devtype;
struct IODevice *devices;
const char *name;
input_port_entry *inputports = NULL;
extern int device_valididtychecks(void);
extern const char *mess_default_text[];
struct SystemConfigurationParamBlock cfg;
device_getinfo_handler handlers[64];
int count_overrides[sizeof(handlers) / sizeof(handlers[0])];
device_class devclass;
/* make sure that all of the UI_* strings are set for all devices */
for (devtype = 0; devtype < IO_COUNT; devtype++)
{
name = mess_default_text[UI_cartridge - IO_CARTSLOT - UI_last_mame_entry + devtype];
if (!name || !name[0])
{
printf("Device type %d does not have an associated UI string\n", devtype);
error = 1;
}
}
/* MESS specific driver validity checks */
for (i = 0; drivers[i]; i++)
{
devices = devices_allocate(drivers[i]);
/* make sure that there are no clones that reference nonexistant drivers */
if (driver_get_clone(drivers[i]))
{
if (drivers[i]->compatible_with && !(drivers[i]->compatible_with->flags & NOT_A_DRIVER))
{
printf("%s: both compatbile_with and clone_of are specified\n", drivers[i]->name);
error = 1;
}
for (j = 0; drivers[j]; j++)
{
if (driver_get_clone(drivers[i]) == drivers[j])
break;
}
if (!drivers[j])
{
printf("%s: is a clone of %s, which is not in drivers[]\n", drivers[i]->name, driver_get_clone(drivers[i])->name);
error = 1;
}
}
/* make sure that there are no clones that reference nonexistant drivers */
if (drivers[i]->compatible_with && !(drivers[i]->compatible_with->flags & NOT_A_DRIVER))
{
for (j = 0; drivers[j]; j++)
{
if (drivers[i]->compatible_with == drivers[j])
break;
}
if (!drivers[j])
{
printf("%s: is compatible with %s, which is not in drivers[]\n", drivers[i]->name, drivers[i]->compatible_with->name);
error = 1;
}
}
/* check devices */
if (drivers[i]->sysconfig_ctor)
{
memset(&cfg, 0, sizeof(cfg));
memset(handlers, 0, sizeof(handlers));
cfg.device_slotcount = sizeof(handlers) / sizeof(handlers[0]);
cfg.device_handlers = handlers;
cfg.device_countoverrides = count_overrides;
drivers[i]->sysconfig_ctor(&cfg);
for (j = 0; handlers[j]; j++)
{
devclass.gamedrv = drivers[i];
devclass.get_info = handlers[j];
if (validate_device(&devclass))
error = 1;
}
}
/* check system config */
ram_option_count(drivers[i]);
/* make sure that our input system likes this driver */
if (inputx_validitycheck(drivers[i], &inputports))
error = 1;
devices = NULL;
}
/* call other validity checks */
if (inputx_validitycheck(NULL, &inputports))
error = 1;
if (device_valididtychecks())
error = 1;
/* now that we are completed, re-expand the actual driver to compensate
* for the tms9928a hack */
if (Machine && Machine->gamedrv)
{
machine_config drv;
expand_machine_driver(Machine->gamedrv->drv, &drv);
}
return error;
}
static int info_verifyroms(core_options *options, const char *gamename)
{
int correct = 0;
int incorrect = 0;
int notfound = 0;
int drvindex;
/* iterate over drivers */
for (drvindex = 0; drivers[drvindex]; drvindex++)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
audit_record *audit;
int audit_records;
int res;
/* audit the ROMs in this set */
audit_records = audit_images(options, drivers[drvindex], AUDIT_VALIDATE_FAST, &audit);
res = audit_summary(drivers[drvindex], audit_records, audit, TRUE);
if (audit_records > 0)
free(audit);
/* if not found, count that and leave it at that */
if (res == NOTFOUND)
notfound++;
/* else display information about what we discovered */
else
{
const game_driver *clone_of;
/* output the name of the driver and its clone */
mame_printf_info("romset %s ", drivers[drvindex]->name);
clone_of = driver_get_clone(drivers[drvindex]);
if (clone_of != NULL)
mame_printf_info("[%s] ", clone_of->name);
/* switch off of the result */
switch (res)
{
case INCORRECT:
mame_printf_info("is bad\n");
incorrect++;
break;
case CORRECT:
mame_printf_info("is good\n");
correct++;
break;
case BEST_AVAILABLE:
mame_printf_info("is best available\n");
correct++;
break;
}
}
}
/* clear out any cached files */
zip_file_cache_clear();
/* if we didn't get anything at all, display a generic end message */
if (correct + incorrect == 0)
{
if (notfound > 0)
mame_printf_info("romset \"%s\" not found!\n", gamename);
else
mame_printf_info("romset \"%s\" not supported!\n", gamename);
return MAMERR_NO_SUCH_GAME;
}
/* otherwise, print a summary */
else
{
mame_printf_info("%d romsets found, %d were OK.\n", correct + incorrect, correct);
return (incorrect > 0) ? MAMERR_MISSING_FILES : MAMERR_NONE;
}
}
/* 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;
}