void media_identifier::digest_data(std::vector<file_info> &info, char const *name, void const *data, std::uint64_t length)
{
util::hash_collection hashes;
// if this is a '.jed' file, process it into raw bits first
if (core_filename_ends_with(name, ".jed"))
{
jed_data jed;
if (JEDERR_NONE == jed_parse(data, length, &jed))
{
try
{
// now determine the new data length and allocate temporary memory for it
std::vector<uint8_t> tempjed(jedbin_output(&jed, nullptr, 0));
jedbin_output(&jed, &tempjed[0], tempjed.size());
hashes.compute(&tempjed[0], tempjed.size(), util::hash_collection::HASH_TYPES_CRC_SHA1);
info.emplace_back(name, tempjed.size(), std::move(hashes), file_flavour::JED);
m_total++;
return;
}
catch (...)
{
}
}
}
hashes.compute(reinterpret_cast<std::uint8_t const *>(data), length, util::hash_collection::HASH_TYPES_CRC_SHA1);
info.emplace_back(name, length, std::move(hashes), file_flavour::RAW);
m_total++;
}
static void identify_data(const char *name, const UINT8 *data, int length, romident_status *status)
{
char hash[HASH_BUF_SIZE];
UINT8 *tempjed = NULL;
astring *basename;
int found = 0;
jed_data jed;
/* if this is a '.jed' file, process it into raw bits first */
if (core_filename_ends_with(name, ".jed") && jed_parse(data, length, &jed) == JEDERR_NONE)
{
/* now determine the new data length and allocate temporary memory for it */
length = jedbin_output(&jed, NULL, 0);
tempjed = malloc(length);
if (tempjed == NULL)
return;
/* create a binary output of the JED data and use that instead */
jedbin_output(&jed, tempjed, length);
data = tempjed;
}
/* compute the hash of the data */
hash_data_clear(hash);
hash_compute(hash, data, length, HASH_SHA1 | HASH_CRC);
/* output the name */
status->total++;
basename = core_filename_extract_base(astring_alloc(), name, FALSE);
mame_printf_info("%-20s", astring_c(basename));
astring_free(basename);
/* see if we can find a match in the ROMs */
match_roms(hash, length, &found);
/* if we didn't find it, try to guess what it might be */
if (found == 0)
{
/* if not a power of 2, assume it is a non-ROM file */
if ((length & (length - 1)) != 0)
{
mame_printf_info("NOT A ROM\n");
status->nonroms++;
}
/* otherwise, it's just not a match */
else
mame_printf_info("NO MATCH\n");
}
/* if we did find it, count it as a match */
else
status->matches++;
/* free any temporary JED data */
if (tempjed != NULL)
free(tempjed);
}
static void romident(const char *filename, romident_status *status)
{
osd_directory *directory;
/* reset the status */
memset(status, 0, sizeof(*status));
/* first try to open as a directory */
directory = osd_opendir(filename);
if (directory != NULL)
{
const osd_directory_entry *entry;
/* iterate over all files in the directory */
while ((entry = osd_readdir(directory)) != NULL)
if (entry->type == ENTTYPE_FILE)
{
astring *curfile = astring_assemble_3(astring_alloc(), filename, PATH_SEPARATOR, entry->name);
identify_file(astring_c(curfile), status);
astring_free(curfile);
}
osd_closedir(directory);
}
/* if that failed, and the filename ends with .zip, identify as a ZIP file */
else if (core_filename_ends_with(filename, ".zip"))
{
/* first attempt to examine it as a valid ZIP file */
zip_file *zip = NULL;
zip_error ziperr = zip_file_open(filename, &zip);
if (ziperr == ZIPERR_NONE && zip != NULL)
{
const zip_file_header *entry;
/* loop over entries in the ZIP, skipping empty files and directories */
for (entry = zip_file_first_file(zip); entry; entry = zip_file_next_file(zip))
if (entry->uncompressed_length != 0)
{
UINT8 *data = (UINT8 *)malloc(entry->uncompressed_length);
if (data != NULL)
{
/* decompress data into RAM and identify it */
ziperr = zip_file_decompress(zip, data, entry->uncompressed_length);
if (ziperr == ZIPERR_NONE)
identify_data(entry->filename, data, entry->uncompressed_length, status);
free(data);
}
}
/* close up */
zip_file_close(zip);
}
}
/* otherwise, identify as a raw file */
else
identify_file(filename, status);
}
inifile_manager::inifile_manager(ui_options &options)
: m_options(options)
, m_ini_index()
{
// scan directories and create index
file_enumerator path(m_options.categoryini_path());
for (osd::directory::entry const *dir = path.next(); dir; dir = path.next())
{
std::string name(dir->name);
if (core_filename_ends_with(name, ".ini"))
{
emu_file file(m_options.categoryini_path(), OPEN_FLAG_READ);
if (file.open(name) == osd_file::error::NONE)
{
init_category(std::move(name), file);
file.close();
}
}
}
std::stable_sort(m_ini_index.begin(), m_ini_index.end(), [] (auto const &x, auto const &y) { return 0 > core_stricmp(x.first.c_str(), y.first.c_str()); });
}
static int recurse_dir(int srcrootlen, int dstrootlen, std::string &srcdir, std::string &dstdir, std::string &tempheader, std::string &tempfooter)
{
static const osd::directory::entry::entry_type typelist[] = { osd::directory::entry::entry_type::DIR, osd::directory::entry::entry_type::FILE };
// extract a normalized subpath
std::string srcdir_subpath;
normalized_subpath(srcdir_subpath, srcdir, srcrootlen + 1);
// create an index file
std::string indexname;
indexname = string_format("%s%c%s", dstdir.c_str(), PATH_SEPARATOR[0], "index.html");
util::core_file::ptr indexfile = create_file_and_output_header(indexname, tempheader, srcdir_subpath);
// output the directory navigation
indexfile->printf("<h3>Viewing Directory: ");
output_path_as_links(*indexfile, srcdir_subpath, true, false);
indexfile->printf("</h3>");
// iterate first over directories, then over files
int result = 0;
for (int entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++)
{
auto entry_type = typelist[entindex];
// open the directory and iterate through it
auto dir = osd::directory::open(srcdir.c_str());
if (dir == nullptr)
{
result = 1;
break;
}
// build up the list of files
const osd::directory::entry *entry;
int found = 0;
list_entry *list = nullptr;
while ((entry = dir->read()) != nullptr)
if (entry->type == entry_type && entry->name[0] != '.')
{
auto lentry = new list_entry;
lentry->name.assign(entry->name);
lentry->next = list;
list = lentry;
found++;
}
// close the directory
dir.reset();
// skip if nothing found
if (found == 0)
continue;
// allocate memory for sorting
auto listarray = new list_entry *[found];
found = 0;
for (list_entry *curlist = list; curlist != nullptr; curlist = curlist->next)
listarray[found++] = curlist;
// sort the list
qsort(listarray, found, sizeof(listarray[0]), compare_list_entries);
// rebuild the list
list = nullptr;
while (--found >= 0)
{
listarray[found]->next = list;
list = listarray[found];
}
delete[] listarray;
// iterate through each file
for (list_entry *curlist = list; curlist != nullptr && result == 0; curlist = curlist->next)
{
// add a header
if (curlist == list)
indexfile->printf("\t<h2>%s</h2>\n\t<ul>\n", (entry_type == osd::directory::entry::entry_type::DIR) ? "Directories" : "Files");
// build the source filename
std::string srcfile;
srcfile = string_format("%s%c%s", srcdir.c_str(), PATH_SEPARATOR[0], curlist->name.c_str());
// if we have a file, output it
std::string dstfile;
if (entry_type == osd::directory::entry::entry_type::FILE)
{
// make sure we care, first
file_type type = FILE_TYPE_INVALID;
for (auto & elem : extension_lookup)
if (core_filename_ends_with(curlist->name, elem.extension))
{
type = elem.type;
break;
}
// if we got a valid file, process it
if (type != FILE_TYPE_INVALID)
{
dstfile = string_format("%s%c%s.html", dstdir.c_str(), PATH_SEPARATOR[0], curlist->name.c_str());
if (indexfile != nullptr)
indexfile->printf("\t<li><a href=\"%s.html\">%s</a></li>\n", curlist->name.c_str(), curlist->name.c_str());
result = output_file(type, srcrootlen, dstrootlen, srcfile, dstfile, srcdir.compare(dstdir) == 0, tempheader, tempfooter);
}
}
// if we have a directory, recurse
else
{
dstfile = string_format("%s%c%s", dstdir.c_str(), PATH_SEPARATOR[0], curlist->name.c_str());
if (indexfile != nullptr)
indexfile->printf("\t<li><a href=\"%s/index.html\">%s/</a></li>\n", curlist->name.c_str(), curlist->name.c_str());
result = recurse_dir(srcrootlen, dstrootlen, srcfile, dstfile, tempheader, tempfooter);
}
}
// close the list if we found some stuff
if (list != nullptr)
indexfile->printf("\t</ul>\n");
// free all the allocated entries
while (list != nullptr)
{
list_entry *next = list->next;
delete list;
list = next;
}
}
if (indexfile != nullptr)
output_footer_and_close_file(std::move(indexfile), tempfooter, srcdir_subpath);
return result;
}
static int recurse_dir(int srcrootlen, int dstrootlen, astring &srcdir, astring &dstdir, astring &tempheader, astring &tempfooter)
{
static const osd_dir_entry_type typelist[] = { ENTTYPE_DIR, ENTTYPE_FILE };
// extract a normalized subpath
astring srcdir_subpath;
normalized_subpath(srcdir_subpath, srcdir, srcrootlen + 1);
// create an index file
astring indexname;
indexname.printf("%s%c%s", dstdir.cstr(), PATH_SEPARATOR[0], "index.html");
core_file *indexfile = create_file_and_output_header(indexname, tempheader, srcdir_subpath);
// output the directory navigation
core_fprintf(indexfile, "<h3>Viewing Directory: ");
output_path_as_links(indexfile, srcdir_subpath, true, false);
core_fprintf(indexfile, "</h3>");
// iterate first over directories, then over files
int result = 0;
for (int entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++)
{
osd_dir_entry_type entry_type = typelist[entindex];
// open the directory and iterate through it
osd_directory *dir = osd_opendir(srcdir);
if (dir == NULL)
{
result = 1;
break;
}
// build up the list of files
const osd_directory_entry *entry;
int found = 0;
list_entry *list = NULL;
while ((entry = osd_readdir(dir)) != NULL)
if (entry->type == entry_type && entry->name[0] != '.')
{
list_entry *lentry = new list_entry;
lentry->name.cpy(entry->name);
lentry->next = list;
list = lentry;
found++;
}
// close the directory
osd_closedir(dir);
// skip if nothing found
if (found == 0)
continue;
// allocate memory for sorting
list_entry **listarray = new list_entry *[found];
found = 0;
for (list_entry *curlist = list; curlist != NULL; curlist = curlist->next)
listarray[found++] = curlist;
// sort the list
qsort(listarray, found, sizeof(listarray[0]), compare_list_entries);
// rebuild the list
list = NULL;
while (--found >= 0)
{
listarray[found]->next = list;
list = listarray[found];
}
delete[] listarray;
// iterate through each file
for (list_entry *curlist = list; curlist != NULL && result == 0; curlist = curlist->next)
{
// add a header
if (curlist == list)
core_fprintf(indexfile, "\t<h2>%s</h2>\n\t<ul>\n", (entry_type == ENTTYPE_DIR) ? "Directories" : "Files");
// build the source filename
astring srcfile;
srcfile.printf("%s%c%s", srcdir.cstr(), PATH_SEPARATOR[0], curlist->name.cstr());
// if we have a file, output it
astring dstfile;
if (entry_type == ENTTYPE_FILE)
{
// make sure we care, first
file_type type = FILE_TYPE_INVALID;
for (int extnum = 0; extnum < ARRAY_LENGTH(extension_lookup); extnum++)
if (core_filename_ends_with(curlist->name, extension_lookup[extnum].extension))
{
type = extension_lookup[extnum].type;
break;
}
// if we got a valid file, process it
if (type != FILE_TYPE_INVALID)
{
dstfile.printf("%s%c%s.html", dstdir.cstr(), PATH_SEPARATOR[0], curlist->name.cstr());
if (indexfile != NULL)
core_fprintf(indexfile, "\t<li><a href=\"%s.html\">%s</a></li>\n", curlist->name.cstr(), curlist->name.cstr());
result = output_file(type, srcrootlen, dstrootlen, srcfile, dstfile, srcdir == dstdir, tempheader, tempfooter);
}
}
// if we have a directory, recurse
else
{
dstfile.printf("%s%c%s", dstdir.cstr(), PATH_SEPARATOR[0], curlist->name.cstr());
if (indexfile != NULL)
core_fprintf(indexfile, "\t<li><a href=\"%s/index.html\">%s/</a></li>\n", curlist->name.cstr(), curlist->name.cstr());
result = recurse_dir(srcrootlen, dstrootlen, srcfile, dstfile, tempheader, tempfooter);
}
}
// close the list if we found some stuff
if (list != NULL)
core_fprintf(indexfile, "\t</ul>\n");
// free all the allocated entries
while (list != NULL)
{
list_entry *next = list->next;
delete list;
list = next;
}
}
if (indexfile != NULL)
output_footer_and_close_file(indexfile, tempfooter, srcdir_subpath);
return result;
}
static int recurse_dir(int srcrootlen, astring &srcdir)
{
static const osd_dir_entry_type typelist[] = { ENTTYPE_DIR, ENTTYPE_FILE };
int result = 0;
// iterate first over directories, then over files
for (int entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++)
{
osd_dir_entry_type entry_type = typelist[entindex];
// open the directory and iterate through it
osd_directory *dir = osd_opendir(srcdir);
if (dir == NULL)
{
result = 1;
goto error;
}
// build up the list of files
const osd_directory_entry *entry;
list_entry *list = NULL;
int found = 0;
while ((entry = osd_readdir(dir)) != NULL)
if (entry->type == entry_type && entry->name[0] != '.')
{
list_entry *lentry = new list_entry;
lentry->name.cpy(entry->name);
lentry->next = list;
list = lentry;
found++;
}
// close the directory
osd_closedir(dir);
// skip if nothing found
if (found == 0)
continue;
// allocate memory for sorting
list_entry **listarray = new list_entry *[found];
found = 0;
for (list_entry *curlist = list; curlist != NULL; curlist = curlist->next)
listarray[found++] = curlist;
// sort the list
qsort(listarray, found, sizeof(listarray[0]), compare_list_entries);
// rebuild the list
list = NULL;
while (--found >= 0)
{
listarray[found]->next = list;
list = listarray[found];
}
delete[] listarray;
// iterate through each file
for (list_entry *curlist = list; curlist != NULL && result == 0; curlist = curlist->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%c%s", srcdir.cstr(), PATH_SEPARATOR[0], curlist->name.cstr());
// if we have a file, output it
if (entry_type == ENTTYPE_FILE)
{
// make sure we care, first
if (core_filename_ends_with(curlist->name, ".c"))
{
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcrootlen, srcfile);
recurse_dependencies(file, depend_map);
// convert the target from source to object (makes assumptions about rules)
astring target(file.name);
target.replace(0, "src/", "$(OBJ)/");
target.replace(0, ".c", ".o");
printf("\n%s : \\\n", target.cstr());
// iterate over the hashed dependencies and output them as well
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
printf("\t%s \\\n", entry->tag().cstr());
}
}
// if we have a directory, recurse
else
result = recurse_dir(srcrootlen, srcfile);
}
// free all the allocated entries
while (list != NULL)
{
list_entry *next = list->next;
delete list;
list = next;
}
}
error:
return result;
}
static int recurse_dir(int srcrootlen, const astring *srcdir)
{
static const osd_dir_entry_type typelist[] = { ENTTYPE_DIR, ENTTYPE_FILE };
int result = 0;
int entindex;
/* iterate first over directories, then over files */
for (entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++)
{
osd_dir_entry_type entry_type = typelist[entindex];
const osd_directory_entry *entry;
list_entry **listarray = NULL;
list_entry *list = NULL;
list_entry *curlist;
osd_directory *dir;
int found = 0;
/* open the directory and iterate through it */
dir = osd_opendir(astring_c(srcdir));
if (dir == NULL)
{
result = 1;
goto error;
}
/* build up the list of files */
while ((entry = osd_readdir(dir)) != NULL)
if (entry->type == entry_type && entry->name[0] != '.')
{
list_entry *lentry = (list_entry *)malloc(sizeof(*lentry));
lentry->name = astring_dupc(entry->name);
lentry->next = list;
list = lentry;
found++;
}
/* close the directory */
osd_closedir(dir);
/* skip if nothing found */
if (found == 0)
continue;
/* allocate memory for sorting */
listarray = (list_entry **)malloc(sizeof(list_entry *) * found);
found = 0;
for (curlist = list; curlist != NULL; curlist = curlist->next)
listarray[found++] = curlist;
/* sort the list */
qsort(listarray, found, sizeof(listarray[0]), compare_list_entries);
/* rebuild the list */
list = NULL;
while (--found >= 0)
{
listarray[found]->next = list;
list = listarray[found];
}
free(listarray);
/* iterate through each file */
for (curlist = list; curlist != NULL && result == 0; curlist = curlist->next)
{
astring *srcfile;
/* build the source filename */
srcfile = astring_alloc();
astring_printf(srcfile, "%s%c%s", astring_c(srcdir), PATH_SEPARATOR[0], astring_c(curlist->name));
/* if we have a file, output it */
if (entry_type == ENTTYPE_FILE)
{
/* make sure we care, first */
if (core_filename_ends_with(astring_c(curlist->name), ".c"))
{
tagmap *depend_map = tagmap_alloc();
tagmap_entry *map_entry;
file_entry *file;
astring *target;
int taghash;
/* find dependencies */
file = compute_dependencies(srcrootlen, srcfile);
recurse_dependencies(file, depend_map);
/* convert the target from source to object (makes assumptions about rules) */
target = astring_dup(file->name);
astring_replacec(target, 0, "src/", "$(OBJ)/");
astring_replacec(target, 0, ".c", ".o");
printf("\n%s : \\\n", astring_c(target));
/* iterate over the hashed dependencies and output them as well */
for (taghash = 0; taghash < TAGMAP_HASH_SIZE; taghash++)
for (map_entry = depend_map->table[taghash]; map_entry != NULL; map_entry = map_entry->next)
printf("\t%s \\\n", astring_c((astring *)map_entry->object));
astring_free(target);
tagmap_free(depend_map);
}
}
/* if we have a directory, recurse */
else
result = recurse_dir(srcrootlen, srcfile);
/* free memory for the names */
astring_free(srcfile);
}
/* free all the allocated entries */
while (list != NULL)
{
list_entry *next = list->next;
astring_free((astring *)list->name);
free(list);
list = next;
}
}
error:
return result;
}
static int recurse_dir(int srcrootlen, int dstrootlen, const astring *srcdir, const astring *dstdir)
{
static const osd_dir_entry_type typelist[] = { ENTTYPE_DIR, ENTTYPE_FILE };
const astring *srcdir_subpath;
core_file *indexfile = NULL;
astring *indexname;
int result = 0;
int entindex;
/* extract a normalized subpath */
srcdir_subpath = normalized_subpath(srcdir, srcrootlen + 1);
if (srcdir_subpath == NULL)
return 1;
/* create an index file */
indexname = astring_alloc();
astring_printf(indexname, "%s%c%s", astring_c(dstdir), PATH_SEPARATOR[0], "index.html");
indexfile = create_file_and_output_header(indexname, "MAME Source Code", astring_c(srcdir_subpath));
astring_free(indexname);
/* output the directory navigation */
core_fprintf(indexfile, "<h3>Viewing Directory: ");
output_path_as_links(indexfile, srcdir_subpath, TRUE, FALSE);
core_fprintf(indexfile, "</h3>");
astring_free((astring *)srcdir_subpath);
/* iterate first over directories, then over files */
for (entindex = 0; entindex < ARRAY_LENGTH(typelist) && result == 0; entindex++)
{
osd_dir_entry_type entry_type = typelist[entindex];
const osd_directory_entry *entry;
list_entry *list = NULL;
list_entry **listarray;
list_entry *curlist;
osd_directory *dir;
int found = 0;
/* open the directory and iterate through it */
dir = osd_opendir(astring_c(srcdir));
if (dir == NULL)
{
result = 1;
goto error;
}
/* build up the list of files */
while ((entry = osd_readdir(dir)) != NULL)
if (entry->type == entry_type && entry->name[0] != '.')
{
list_entry *lentry = malloc(sizeof(*lentry));
lentry->name = astring_dupc(entry->name);
lentry->next = list;
list = lentry;
found++;
}
/* close the directory */
osd_closedir(dir);
/* skip if nothing found */
if (found == 0)
continue;
/* allocate memory for sorting */
listarray = malloc(sizeof(list_entry *) * found);
found = 0;
for (curlist = list; curlist != NULL; curlist = curlist->next)
listarray[found++] = curlist;
/* sort the list */
qsort(listarray, found, sizeof(listarray[0]), compare_list_entries);
/* rebuild the list */
list = NULL;
while (--found >= 0)
{
listarray[found]->next = list;
list = listarray[found];
}
/* iterate through each file */
for (curlist = list; curlist != NULL && result == 0; curlist = curlist->next)
{
astring *srcfile, *dstfile;
/* add a header */
if (curlist == list)
core_fprintf(indexfile, "\t<h2>%s</h2>\n\t<ul>\n", (entry_type == ENTTYPE_DIR) ? "Directories" : "Files");
/* build the source filename */
srcfile = astring_alloc();
astring_printf(srcfile, "%s%c%s", astring_c(srcdir), PATH_SEPARATOR[0], astring_c(curlist->name));
/* if we have a file, output it */
dstfile = astring_alloc();
if (entry_type == ENTTYPE_FILE)
{
file_type type = FILE_TYPE_INVALID;
int extnum;
/* make sure we care, first */
for (extnum = 0; extnum < ARRAY_LENGTH(extension_lookup); extnum++)
if (core_filename_ends_with(astring_c(curlist->name), extension_lookup[extnum].extension))
{
type = extension_lookup[extnum].type;
break;
}
/* if we got a valid file, process it */
if (type != FILE_TYPE_INVALID)
{
astring_printf(dstfile, "%s%c%s.html", astring_c(dstdir), PATH_SEPARATOR[0], astring_c(curlist->name));
if (indexfile != NULL)
core_fprintf(indexfile, "\t<li><a href=\"%s.html\">%s</a></li>\n", astring_c(curlist->name), astring_c(curlist->name));
result = output_file(type, srcrootlen, dstrootlen, srcfile, dstfile, astring_cmp(srcdir, dstdir) == 0);
}
}
/* if we have a directory, recurse */
else
{
astring_printf(dstfile, "%s%c%s", astring_c(dstdir), PATH_SEPARATOR[0], astring_c(curlist->name));
if (indexfile != NULL)
core_fprintf(indexfile, "\t<li><a href=\"%s/index.html\">%s/</a></li>\n", astring_c(curlist->name), astring_c(curlist->name));
result = recurse_dir(srcrootlen, dstrootlen, srcfile, dstfile);
}
/* free memory for the names */
astring_free(srcfile);
astring_free(dstfile);
}
/* close the list if we found some stuff */
if (list != NULL)
core_fprintf(indexfile, "\t</ul>\n");
/* free all the allocated entries */
while (list != NULL)
{
list_entry *next = list->next;
astring_free((astring *)list->name);
free(list);
list = next;
}
}
error:
if (indexfile != NULL)
output_footer_and_close_file(indexfile);
return result;
}
void media_identifier::digest_file(std::vector<file_info> &info, char const *path)
{
// CHD files need to be parsed and their hashes extracted from the header
if (core_filename_ends_with(path, ".chd"))
{
// attempt to open as a CHD; fail if not
chd_file chd;
chd_error const err = chd.open(path);
m_total++;
if (err != CHDERR_NONE)
{
osd_printf_info("%-20sNOT A CHD\n", core_filename_extract_base(path).c_str());
m_nonroms++;
}
else if (!chd.compressed())
{
osd_printf_info("%-20sis a writeable CHD\n", core_filename_extract_base(path).c_str());
}
else
{
// otherwise, get the hash collection for this CHD
util::hash_collection hashes;
if (chd.sha1() != util::sha1_t::null)
hashes.add_sha1(chd.sha1());
info.emplace_back(path, chd.logical_bytes(), std::move(hashes), file_flavour::CHD);
}
}
else
{
// if this is a '.jed' file, process it into raw bits first
if (core_filename_ends_with(path, ".jed"))
{
// load the file and process if it opens and has a valid length
uint32_t length;
void *data;
if (osd_file::error::NONE == util::core_file::load(path, &data, length))
{
jed_data jed;
if (JEDERR_NONE == jed_parse(data, length, &jed))
{
try
{
// now determine the new data length and allocate temporary memory for it
std::vector<uint8_t> tempjed(jedbin_output(&jed, nullptr, 0));
jedbin_output(&jed, &tempjed[0], tempjed.size());
util::hash_collection hashes;
hashes.compute(&tempjed[0], tempjed.size(), util::hash_collection::HASH_TYPES_CRC_SHA1);
info.emplace_back(path, tempjed.size(), std::move(hashes), file_flavour::JED);
free(data);
m_total++;
return;
}
catch (...)
{
}
}
free(data);
}
}
// load the file and process if it opens and has a valid length
util::core_file::ptr file;
if ((osd_file::error::NONE == util::core_file::open(path, OPEN_FLAG_READ, file)) && file)
{
util::hash_collection hashes;
hashes.begin(util::hash_collection::HASH_TYPES_CRC_SHA1);
std::uint8_t buf[1024];
for (std::uint64_t remaining = file->size(); remaining; )
{
std::uint32_t const block = std::min<std::uint64_t>(remaining, sizeof(buf));
if (file->read(buf, block) < block)
{
osd_printf_error("%s: error reading file\n", path);
return;
}
remaining -= block;
hashes.buffer(buf, block);
}
hashes.end();
info.emplace_back(path, file->size(), std::move(hashes), file_flavour::RAW);
m_total++;
}
else
{
osd_printf_error("%s: error opening file\n", path);
}
}
}
void media_identifier::collect_files(std::vector<file_info> &info, char const *path)
{
// first try to open as a directory
osd::directory::ptr const directory = osd::directory::open(path);
if (directory)
{
// iterate over all files in the directory
for (osd::directory::entry const *entry = directory->read(); entry; entry = directory->read())
{
if (entry->type == osd::directory::entry::entry_type::FILE)
{
std::string const curfile = std::string(path).append(PATH_SEPARATOR).append(entry->name);
collect_files(info, curfile.c_str());
}
}
}
else if (core_filename_ends_with(path, ".7z") || core_filename_ends_with(path, ".zip"))
{
// first attempt to examine it as a valid zip/7z file
util::archive_file::ptr archive;
util::archive_file::error err;
if (core_filename_ends_with(path, ".7z"))
err = util::archive_file::open_7z(path, archive);
else
err = util::archive_file::open_zip(path, archive);
if ((util::archive_file::error::NONE == err) && archive)
{
std::vector<std::uint8_t> data;
// loop over entries in the .7z, skipping empty files and directories
for (int i = archive->first_file(); i >= 0; i = archive->next_file())
{
std::uint64_t const length(archive->current_uncompressed_length());
if (!archive->current_is_directory() && length)
{
std::string const curfile = std::string(path).append(PATH_SEPARATOR).append(archive->current_name());
if (std::uint32_t(length) == length)
{
// decompress data into RAM and identify it
try
{
data.resize(std::size_t(length));
err = archive->decompress(&data[0], std::uint32_t(length));
if (util::archive_file::error::NONE == err)
digest_data(info, curfile.c_str(), &data[0], length);
else
osd_printf_error("%s: error decompressing file\n", curfile.c_str());
}
catch (...)
{
// resizing the buffer could cause a bad_alloc if archive contains large files
osd_printf_error("%s: error decompressing file\n", curfile.c_str());
}
data.clear();
}
else
{
osd_printf_error("%s: file too large to decompress into memory\n", curfile.c_str());
}
}
}
}
else
{
osd_printf_error("%s: error opening archive\n", path);
}
// clear out any cached files
util::archive_file::cache_clear();
}
else
{
// otherwise, identify as a raw file
digest_file(info, path);
}
}
static int recurse_dir(astring &srcdir)
{
int result = 0;
// iterate through each file
for (librarylist_entry *lib = librarylist; lib != NULL; lib = lib->next)
{
for (list_entry *src = lib->sourcefiles; src != NULL; src = src->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%s.c", srcdir.cstr(), src->name.cstr());
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcfile);
recurse_dependencies(file, depend_map);
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
{
astring t(entry->tag());
if (core_filename_ends_with(t, ".h"))
{
char *foundfile = include_map.find(t);
if (foundfile != NULL) {
printf("%s\n", foundfile);
// we add things just once when needed
include_map.remove(t);
}
}
}
}
}
// iterate through each file
for (librarylist_entry *lib = librarylist; lib != NULL; lib = lib->next)
{
// convert the target from source to object (makes assumptions about rules)
astring target("$(OBJ)/target/",lib->name.cstr());
target.cat(".a");
printf("\n%s : \\\n", target.cstr());
for (list_entry *src = lib->sourcefiles; src != NULL; src = src->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%s.c", srcdir.cstr(), src->name.cstr());
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcfile);
recurse_dependencies(file, depend_map);
// iterate over the hashed dependencies and output them as well
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
{
astring t(entry->tag());
t.replace(0, "src/", "$(OBJ)/");
t.replace(0, ".c", ".o");
if (core_filename_ends_with(t, ".o"))
{
printf("\t%s \\\n", t.cstr());
}
}
}
printf("\n");
for (list_entry *src = lib->sourcefiles; src != NULL; src = src->next)
{
astring srcfile;
// build the source filename
srcfile.printf("%s%s.c", srcdir.cstr(), src->name.cstr());
dependency_map depend_map;
// find dependencies
file_entry &file = compute_dependencies(srcfile);
recurse_dependencies(file, depend_map);
for (dependency_map::entry_t *entry = depend_map.first(); entry != NULL; entry = depend_map.next(entry))
{
astring t(entry->tag());
if (core_filename_ends_with(t, ".lay"))
{
astring target2(file.name);
target2.replace(0, "src/", "$(OBJ)/");
target2.replace(0, ".c", ".o");
t.replace(0, "src/", "$(OBJ)/");
t.replace(0, ".lay", ".lh");
printf("%s: %s\n", target2.cstr(), t.cstr());
}
if (core_filename_ends_with(t, ".inc"))
{
astring target2(file.name);
target2.replace(0, "src/", "$(OBJ)/");
target2.replace(0, ".c", ".o");
printf("%s: %s\n", target2.cstr(), t.cstr());
}
}
}
}
return result;
}
static void identify_file(core_options *options, const char *name, romident_status *status)
{
file_error filerr;
osd_file *file;
UINT64 length;
if (core_filename_ends_with(name, ".chd"))
{
chd_file *chd;
chd_error err;
astring basename;
int found = 0;
core_filename_extract_base(&basename, name, FALSE);
mame_printf_info("%-20s", basename.cstr());
status->total++;
err = chd_open(name, CHD_OPEN_READ, NULL, &chd);
if (err != CHDERR_NONE)
{
mame_printf_info("NOT A CHD\n");
status->nonroms++;
}
else
{
chd_header header;
header = *chd_get_header(chd);
if (header.flags & CHDFLAGS_IS_WRITEABLE)
{
mame_printf_info("is a writable CHD\n");
}
else
{
static const UINT8 nullhash[HASH_BUF_SIZE] = { 0 };
char hash[HASH_BUF_SIZE]; /* actual hash information */
hash_data_clear(hash);
/* 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(hash, HASH_MD5, header.md5);
if (memcmp(nullhash, header.sha1, sizeof(header.sha1)) != 0)
hash_data_insert_binary_checksum(hash, HASH_SHA1, header.sha1);
length = header.logicalbytes;
match_roms(options, hash, length, &found);
if (found == 0)
{
mame_printf_info("NO MATCH\n");
}
/* if we did find it, count it as a match */
else
status->matches++;
}
chd_close(chd);
}
}
else
{
/* open for read and process if it opens and has a valid length */
filerr = osd_open(name, OPEN_FLAG_READ, &file, &length);
if (filerr == FILERR_NONE && length > 0 && (UINT32)length == length)
{
UINT8 *data = global_alloc_array(UINT8, length);
if (data != NULL)
{
UINT32 bytes;
/* read file data into RAM and identify it */
filerr = osd_read(file, data, 0, length, &bytes);
if (filerr == FILERR_NONE)
identify_data(options, name, data, bytes, status);
global_free(data);
}
osd_close(file);
}
}
}
