/*-------------------------------------------------
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);
}
}
void ui_menu_control_device_image::handle()
{
switch(state) {
case START_FILE: {
bool can_create = false;
if(image->is_creatable()) {
zippath_directory *directory = NULL;
file_error err = zippath_opendir(current_directory, &directory);
can_create = err == FILERR_NONE && !zippath_is_zip(directory);
if(directory)
zippath_closedir(directory);
}
submenu_result = -1;
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_file_selector(machine(), container, image, current_directory, current_file, true, image->image_interface()!=NULL, can_create, &submenu_result)));
state = SELECT_FILE;
break;
}
case START_SOFTLIST:
sld = 0;
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_software(machine(), container, image->image_interface(), &sld)));
state = SELECT_SOFTLIST;
break;
case START_OTHER_PART: {
submenu_result = -1;
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_software_parts(machine(), container, swi, swp->interface_, &swp, true, &submenu_result)));
state = SELECT_OTHER_PART;
break;
}
case SELECT_SOFTLIST:
if(!sld) {
ui_menu::stack_pop(machine());
break;
}
software_info_name = "";
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_software_list(machine(), container, sld, image->image_interface(), software_info_name)));
state = SELECT_PARTLIST;
break;
case SELECT_PARTLIST:
swl = software_list_open(machine().options(), sld->list_name(), false, NULL);
swi = software_list_find(swl, software_info_name, NULL);
if(swinfo_has_multiple_parts(swi, image->image_interface())) {
submenu_result = -1;
swp = 0;
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_software_parts(machine(), container, swi, image->image_interface(), &swp, false, &submenu_result)));
state = SELECT_ONE_PART;
} else {
swp = software_find_part(swi, NULL, NULL);
load_software_part();
software_list_close(swl);
ui_menu::stack_pop(machine());
}
break;
case SELECT_ONE_PART:
switch(submenu_result) {
case ui_menu_software_parts::T_ENTRY: {
load_software_part();
software_list_close(swl);
ui_menu::stack_pop(machine());
break;
}
case -1: // return to list
software_list_close(swl);
state = SELECT_SOFTLIST;
break;
}
break;
case SELECT_OTHER_PART:
switch(submenu_result) {
case ui_menu_software_parts::T_ENTRY: {
load_software_part();
break;
}
case ui_menu_software_parts::T_FMGR:
state = START_FILE;
handle();
break;
case -1: // return to system
ui_menu::stack_pop(machine());
break;
}
break;
case SELECT_FILE:
switch(submenu_result) {
case ui_menu_file_selector::R_EMPTY:
image->unload();
ui_menu::stack_pop(machine());
break;
case ui_menu_file_selector::R_FILE:
hook_load(current_file, false);
break;
case ui_menu_file_selector::R_CREATE:
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_file_create(machine(), container, image, current_directory, current_file)));
state = CREATE_FILE;
break;
case ui_menu_file_selector::R_SOFTLIST:
state = START_SOFTLIST;
handle();
break;
case -1: // return to system
ui_menu::stack_pop(machine());
break;
}
break;
case CREATE_FILE: {
bool can_create, need_confirm;
test_create(can_create, need_confirm);
if(can_create) {
if(need_confirm) {
ui_menu::stack_push(auto_alloc_clear(machine(), ui_menu_confirm_save_as(machine(), container, &create_confirmed)));
state = CREATE_CONFIRM;
} else {
state = DO_CREATE;
handle();
}
} else {
state = START_FILE;
handle();
}
break;
}
case CREATE_CONFIRM: {
state = create_confirmed ? DO_CREATE : START_FILE;
handle();
break;
}
case DO_CREATE: {
astring path;
zippath_combine(path, current_directory, current_file);
int err = image->create(path, 0, NULL);
if (err != 0)
popmessage("Error: %s", image->error());
ui_menu::stack_pop(machine());
break;
}
}
}
//-------------------------------------------------
// audit_software
//-------------------------------------------------
media_auditor::summary media_auditor::audit_software(const char *list_name, software_info *swinfo, const char *validation)
{
// start fresh
m_record_list.reset();
// store validation for later
m_validation = validation;
astring combinedpath(swinfo->shortname, ";", list_name, PATH_SEPARATOR, swinfo->shortname);
astring locationtag(list_name, "%", swinfo->shortname, "%");
if ( swinfo->parentname )
{
locationtag.cat(swinfo->parentname);
combinedpath.cat(";").cat(swinfo->parentname).cat(";").cat(list_name).cat(PATH_SEPARATOR).cat(swinfo->parentname);
}
m_searchpath = combinedpath;
int found = 0;
int required = 0;
// now iterate over software parts
for ( software_part *part = software_find_part( swinfo, NULL, NULL ); part != NULL; part = software_part_next( part ) )
{
// now iterate over regions
for ( const rom_entry *region = part->romdata; region; region = rom_next_region( region ) )
{
// now iterate over rom definitions
for (const rom_entry *rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
hash_collection hashes(ROM_GETHASHDATA(rom));
// count the number of files with hashes
if (!hashes.flag(hash_collection::FLAG_NO_DUMP) && !ROM_ISOPTIONAL(rom))
{
required++;
}
// 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, (const char *)locationtag);
}
// count the number of files that are found.
if (record != NULL && (record->status() == audit_record::STATUS_GOOD || record->status() == audit_record::STATUS_FOUND_INVALID))
{
found++;
}
}
}
}
if (found == 0 && required > 0)
{
m_record_list.reset();
return NOTFOUND;
}
// return a summary
return summarize(list_name);
}
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;
}
