bool device_image_interface::load_internal(const char *path, bool is_create, int create_format, option_resolution *create_args, bool just_load)
{
UINT32 open_plan[4];
int i;
bool softload = FALSE;
m_from_swlist = FALSE;
// if the path contains no period, we are using softlists, so we won't create an image
astring pathstr(path);
bool filename_has_period = (pathstr.rchr(0, '.') != -1) ? TRUE : FALSE;
/* first unload the image */
unload();
/* clear any possible error messages */
clear_error();
/* we are now loading */
m_is_loading = TRUE;
/* record the filename */
m_err = set_image_filename(path);
if (m_err)
goto done;
/* Check if there's a software list defined for this device and use that if we're not creating an image */
if (!filename_has_period && !just_load)
{
softload = load_software_part( device().machine().options(), this, path, &m_software_info_ptr, &m_software_part_ptr, &m_full_software_name, &m_software_list_name );
// if we had launched from softlist with a specified part, e.g. "shortname:part"
// we would have recorded the wrong name, so record it again based on software_info
if (m_software_info_ptr && m_full_software_name)
m_err = set_image_filename(m_full_software_name);
m_from_swlist = TRUE;
}
if (is_create || filename_has_period)
{
/* determine open plan */
determine_open_plan(is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !m_file && open_plan[i]; i++)
{
/* open the file */
m_err = load_image_by_path(open_plan[i], path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
/* Copy some image information when we have been loaded through a software list */
if ( m_software_info_ptr )
{
m_longname = m_software_info_ptr->longname;
m_manufacturer = m_software_info_ptr->publisher;
m_year = m_software_info_ptr->year;
//m_playable = m_software_info_ptr->supported;
}
/* did we fail to find the file? */
if (!is_loaded() && !softload)
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* call device load or create */
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
m_err = (image_error_t)finish_load();
if (m_err)
goto done;
}
/* success! */
done:
if (just_load) {
if(m_err) clear();
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
if (m_err!=0) {
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
popmessage("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
else
mame_printf_error("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if (device().machine().time() > attotime::zero && is_reset_on_load())
device().machine().schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
mame_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
bool legacy_image_device_base::load_internal(const char *path, bool is_create, int create_format, option_resolution *create_args)
{
image_error_t err;
UINT32 open_plan[4];
int i;
bool softload = FALSE;
/* first unload the image */
unload();
/* clear any possible error messages */
clear_error();
/* we are now loading */
m_is_loading = TRUE;
/* record the filename */
err = set_image_filename(path);
if (err)
goto done;
/* Check if there's a software list defined for this device and use that if we're not creating an image */
softload = load_software_part( this, path, &m_software_info_ptr, &m_software_part_ptr, &m_full_software_name );
if (is_create || (!softload && m_software_info_ptr==NULL))
{
/* determine open plan */
determine_open_plan(is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !m_file && open_plan[i]; i++)
{
/* open the file */
err = load_image_by_path(open_plan[i], path);
if (err && (err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
/* Copy some image information when we have been loaded through a software list */
if ( m_software_info_ptr )
{
m_longname = m_software_info_ptr->longname;
m_manufacturer = m_software_info_ptr->publisher;
m_year = m_software_info_ptr->year;
//m_playable = m_software_info_ptr->supported;
}
/* did we fail to find the file? */
if (!is_loaded() && !softload)
{
err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* call device load or create */
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
err = (image_error_t)finish_load();
if (err)
goto done;
}
/* success! */
done:
if (m_err) {
if (!m_init_phase)
{
if (machine->phase() == MACHINE_PHASE_RUNNING)
popmessage("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
else
mame_printf_error("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if ((attotime_compare(timer_get_time(device().machine), attotime_zero) > 0) && m_image_config.is_reset_on_load())
device().machine->schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (machine->phase() == MACHINE_PHASE_RUNNING)
popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
mame_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
bool device_image_interface::load_internal(const char *path, bool is_create, int create_format, util::option_resolution *create_args, bool just_load)
{
UINT32 open_plan[4];
int i;
bool softload = FALSE;
m_from_swlist = FALSE;
// if the path contains no period, we are using softlists, so we won't create an image
std::string pathstr(path);
bool filename_has_period = (pathstr.find_last_of('.') != -1) ? TRUE : FALSE;
// first unload the image
unload();
// clear any possible error messages
clear_error();
// we are now loading
m_is_loading = TRUE;
// record the filename
m_err = set_image_filename(path);
if (m_err)
goto done;
if (core_opens_image_file())
{
// Check if there's a software list defined for this device and use that if we're not creating an image
if (!filename_has_period && !just_load)
{
softload = load_software_part(path, m_software_part_ptr);
if (softload)
{
m_software_info_ptr = &m_software_part_ptr->info();
m_software_list_name.assign(m_software_info_ptr->list().list_name());
m_full_software_name.assign(m_software_part_ptr->info().shortname());
// if we had launched from softlist with a specified part, e.g. "shortname:part"
// we would have recorded the wrong name, so record it again based on software_info
if (m_software_info_ptr && !m_full_software_name.empty())
m_err = set_image_filename(m_full_software_name.c_str());
// check if image should be read-only
const char *read_only = get_feature("read_only");
if (read_only && !strcmp(read_only, "true")) {
make_readonly();
}
m_from_swlist = TRUE;
}
}
if (is_create || filename_has_period)
{
// determine open plan
determine_open_plan(is_create, open_plan);
// attempt to open the file in various ways
for (i = 0; !m_file && open_plan[i]; i++)
{
// open the file
m_err = load_image_by_path(open_plan[i], path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
// Copy some image information when we have been loaded through a software list
if ( m_software_info_ptr )
{
// sanitize
if (m_software_info_ptr->longname().empty() || m_software_info_ptr->publisher().empty() || m_software_info_ptr->year().empty())
fatalerror("Each entry in an XML list must have all of the following fields: description, publisher, year!\n");
// store
m_longname = m_software_info_ptr->longname();
m_manufacturer = m_software_info_ptr->publisher();
m_year = m_software_info_ptr->year();
//m_playable = m_software_info_ptr->supported();
}
// did we fail to find the file?
if (!is_loaded() && !softload)
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
}
// call device load or create
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
m_err = (image_error_t)finish_load();
if (m_err)
goto done;
}
// success!
done:
if (just_load) {
if(m_err) clear();
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
if (m_err!=0) {
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
else
osd_printf_error("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if (device().machine().time() > attotime::zero && is_reset_on_load())
device().machine().schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
osd_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
image_init_result device_image_interface::load_internal(const std::string &path, bool is_create, int create_format, util::option_resolution *create_args, bool just_load)
{
// first unload the image
unload();
// clear any possible error messages
clear_error();
// we are now loading
m_is_loading = true;
// record the filename
set_image_filename(path);
if (core_opens_image_file())
{
// determine open plan
std::vector<UINT32> open_plan = determine_open_plan(is_create);
// attempt to open the file in various ways
for (auto iter = open_plan.cbegin(); !m_file && iter != open_plan.cend(); iter++)
{
// open the file
m_err = load_image_by_path(*iter, path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
// did we fail to find the file?
if (!is_loaded())
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
}
// call device load or create
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==false) {
m_err = (finish_load() == image_init_result::PASS) ? IMAGE_ERROR_SUCCESS : IMAGE_ERROR_INTERNAL;
if (m_err)
goto done;
}
// success!
done:
if (just_load) {
if (m_err) clear();
return m_err ? image_init_result::FAIL : image_init_result::PASS;
}
if (m_err!=0) {
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
else
osd_printf_error("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path.c_str(), error());
}
clear();
}
else {
// do we need to reset the CPU? only schedule it if load/create is successful
if (!schedule_postload_hard_reset_if_needed())
{
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
device().popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
osd_printf_info("Image '%s' was successfully %s.\n", path.c_str(), is_create ? "created" : "loaded");
}
}
}
return m_err ? image_init_result::FAIL : image_init_result::PASS;
}
static int image_load_internal(mess_image *image, const char *path,
int is_create, int create_format, option_resolution *create_args)
{
image_error_t err;
const char *software_path;
char *software_path_list = NULL;
const void *buffer;
const game_driver *gamedrv;
UINT32 open_plan[4];
int i;
/* sanity checks */
assert_always(image, "image_load(): image is NULL");
assert_always(path, "image_load(): path is NULL");
/* we are now loading */
image->is_loading = 1;
/* first unload the image */
image_unload(image);
/* record the filename */
image->err = set_image_filename(image, path, NULL);
if (image->err)
goto done;
/* tell the OSD layer that this is changing */
osd_image_load_status_changed(image, 0);
/* do we need to reset the CPU? */
if ((timer_get_time() > 0) && image->dev->reset_on_load)
mame_schedule_soft_reset(Machine);
/* determine open plan */
determine_open_plan(image, is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !image->file && open_plan[i]; i++)
{
software_path = software_path_list;
do
{
gamedrv = Machine->gamedrv;
while(!is_loaded(image) && gamedrv)
{
/* open the file */
image->err = load_image_by_path(image, software_path, gamedrv, open_plan[i], path);
if (image->err && (image->err != IMAGE_ERROR_FILENOTFOUND))
goto done;
/* move on to the next driver */
gamedrv = mess_next_compatible_driver(gamedrv);
}
/* move on to the next entry in the software path; if we can */
if (software_path)
software_path += strlen(software_path) + 1;
}
while(!is_loaded(image) && software_path && *software_path);
}
/* did we fail to find the file? */
if (!is_loaded(image))
{
image->err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* if applicable, call device verify */
if (image->dev->imgverify && !image_has_been_created(image))
{
/* access the memory */
buffer = image_ptr(image);
if (!buffer)
{
image->err = IMAGE_ERROR_OUTOFMEMORY;
goto done;
}
/* verify the file */
err = image->dev->imgverify(buffer, (size_t) image->length);
if (err)
{
image->err = IMAGE_ERROR_INVALIDIMAGE;
goto done;
}
}
/* call device load or create */
if (image_has_been_created(image) && image->dev->create)
{
err = image->dev->create(image, create_format, create_args);
if (err)
{
if (!image->err)
image->err = IMAGE_ERROR_UNSPECIFIED;
goto done;
}
}
else if (image->dev->load)
{
/* using device load */
err = image->dev->load(image);
if (err)
{
if (!image->err)
image->err = IMAGE_ERROR_UNSPECIFIED;
goto done;
}
}
/* success! */
done:
if (software_path_list)
free(software_path_list);
if (image->err)
image_clear(image);
image->is_loading = 1;
return image->err ? INIT_FAIL : INIT_PASS;
}