static int internal_floppy_device_load(mess_image *image, mame_file *file, int create_format, option_resolution *create_args)
{
floperr_t err;
struct mess_flopimg *flopimg;
const struct IODevice *dev;
const struct FloppyFormat *floppy_options;
int floppy_flags, i;
const char *extension;
/* look up instance data */
flopimg = get_flopimg(image);
/* figure out the floppy options */
dev = image_device(image);
floppy_options = device_get_info_ptr(&dev->devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
if (image_has_been_created(image))
{
/* creating an image */
assert(create_format >= 0);
err = floppy_create(file, &mess_ioprocs, &floppy_options[create_format], create_args, &flopimg->floppy);
if (err)
goto error;
}
else
{
/* opening an image */
floppy_flags = image_is_writable(image) ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
extension = image_filetype(image);
err = floppy_open_choices(file, &mess_ioprocs, extension, floppy_options, floppy_flags, &flopimg->floppy);
if (err)
goto error;
}
/* if we can get head and track counts, then set the geometry accordingly */
if (floppy_callbacks(flopimg->floppy)->get_heads_per_disk
&& floppy_callbacks(flopimg->floppy)->get_tracks_per_disk)
{
floppy_drive_set_geometry_absolute(image,
floppy_get_tracks_per_disk(flopimg->floppy),
floppy_get_heads_per_disk(flopimg->floppy));
}
return INIT_PASS;
error:
for (i = 0; i < sizeof(errmap) / sizeof(errmap[0]); i++)
{
if (err == errmap[i].ferr)
image_seterror(image, errmap[i].ierr, errmap[i].message);
}
return INIT_FAIL;
}
static int internal_floppy_device_load(device_image_interface *image, int create_format, option_resolution *create_args)
{
floperr_t err;
floppy_drive *flopimg;
const struct FloppyFormat *floppy_options;
int floppy_flags, i;
const char *extension;
/* look up instance data */
flopimg = get_safe_token( &image->device() );
/* figure out the floppy options */
floppy_options = ((floppy_interface*)image->device().static_config())->formats;
if (image->has_been_created())
{
/* creating an image */
assert(create_format >= 0);
err = floppy_create((void *) image, &image_ioprocs, &floppy_options[create_format], create_args, &flopimg->floppy);
if (err)
goto error;
}
else
{
/* opening an image */
floppy_flags = !image->is_readonly() ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
extension = image->filetype();
err = floppy_open_choices((void *) image, &image_ioprocs, extension, floppy_options, floppy_flags, &flopimg->floppy);
if (err)
goto error;
}
if (floppy_callbacks(flopimg->floppy)->get_heads_per_disk && floppy_callbacks(flopimg->floppy)->get_tracks_per_disk)
{
floppy_drive_set_geometry_absolute(&image->device(),
floppy_get_tracks_per_disk(flopimg->floppy),
floppy_get_heads_per_disk(flopimg->floppy));
}
/* disk changed */
flopimg->dskchg = CLEAR_LINE;
return IMAGE_INIT_PASS;
error:
for (i = 0; i < ARRAY_LENGTH(errmap); i++)
{
if (err == errmap[i].ferr)
image->seterror(errmap[i].ierr, errmap[i].message);
}
return IMAGE_INIT_FAIL;
}
image_init_result legacy_floppy_image_device::internal_floppy_device_load(bool is_create, int create_format, util::option_resolution *create_args)
{
floperr_t err;
const struct FloppyFormat *floppy_options;
int floppy_flags, i;
device_image_interface *image = nullptr;
interface(image); /* figure out the floppy options */
floppy_options = m_config->formats;
if (is_create)
{
/* creating an image */
assert(create_format >= 0);
err = floppy_create((void *) image, &image_ioprocs, &floppy_options[create_format], create_args, &m_floppy);
if (err)
goto error;
}
else
{
/* opening an image */
floppy_flags = !is_readonly() ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
err = floppy_open_choices((void *) image, &image_ioprocs, filetype(), floppy_options, floppy_flags, &m_floppy);
if (err)
goto error;
}
if (floppy_callbacks(m_floppy)->get_heads_per_disk && floppy_callbacks(m_floppy)->get_tracks_per_disk)
{
floppy_drive_set_geometry_absolute(floppy_get_tracks_per_disk(m_floppy),floppy_get_heads_per_disk(m_floppy));
}
/* disk changed */
m_dskchg = CLEAR_LINE;
// If we have one of our hacky load procs, call it
if (m_load_proc)
m_load_proc(*this, is_create);
return image_init_result::PASS;
error:
for (i = 0; i < ARRAY_LENGTH(errmap); i++)
{
if (err == errmap[i].ferr)
seterror(errmap[i].ierr, errmap[i].message);
}
return image_init_result::FAIL;
}
int legacy_floppy_image_device::internal_floppy_device_load(int create_format, util::option_resolution *create_args)
{
floperr_t err;
const struct FloppyFormat *floppy_options;
int floppy_flags, i;
const char *extension;
device_image_interface *image = nullptr;
interface(image); /* figure out the floppy options */
floppy_options = m_config->formats;
if (has_been_created())
{
/* creating an image */
assert(create_format >= 0);
err = floppy_create((void *) image, &image_ioprocs, &floppy_options[create_format], create_args, &m_floppy);
if (err)
goto error;
}
else
{
/* opening an image */
floppy_flags = !is_readonly() ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
extension = filetype();
err = floppy_open_choices((void *) image, &image_ioprocs, extension, floppy_options, floppy_flags, &m_floppy);
if (err)
goto error;
}
if (floppy_callbacks(m_floppy)->get_heads_per_disk && floppy_callbacks(m_floppy)->get_tracks_per_disk)
{
floppy_drive_set_geometry_absolute(floppy_get_tracks_per_disk(m_floppy),floppy_get_heads_per_disk(m_floppy));
}
/* disk changed */
m_dskchg = CLEAR_LINE;
return IMAGE_INIT_PASS;
error:
for (i = 0; i < ARRAY_LENGTH(errmap); i++)
{
if (err == errmap[i].ferr)
seterror(errmap[i].ierr, errmap[i].message);
}
return IMAGE_INIT_FAIL;
}
static imgtoolerr_t imgtool_floppy_create(imgtool_image *image, imgtool_stream *f, option_resolution *opts)
{
floperr_t ferr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
struct imgtool_floppy_image *fimg;
const imgtool_class *imgclass;
const struct FloppyFormat *format;
imgtoolerr_t (*create)(imgtool_image *, imgtool_stream *, option_resolution *);
imgtoolerr_t (*open)(imgtool_image *image, imgtool_stream *f);
fimg = (struct imgtool_floppy_image *) imgtool_image_extra_bytes(image);
imgclass = &imgtool_image_module(image)->imgclass;
format = (const struct FloppyFormat *) imgclass->derived_param;
create = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *, option_resolution *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_CREATE);
open = (imgtoolerr_t (*)(imgtool_image *, imgtool_stream *)) imgtool_get_info_ptr(imgclass, IMGTOOLINFO_PTR_FLOPPY_OPEN);
/* open up the floppy */
ferr = floppy_create(f, &imgtool_ioprocs, format, opts, &fimg->floppy);
if (ferr)
{
err = imgtool_floppy_error(ferr);
goto done;
}
/* do we have to do extra stuff when creating the image? */
if (create)
{
err = create(image, NULL, opts);
if (err)
goto done;
}
/* do we have to do extra stuff when opening the image? */
if (open)
{
err = open(image, NULL);
if (err)
goto done;
}
done:
return err;
}
static imgtoolerr_t imgtool_floppy_create(imgtool_image *image, imgtool_stream *f, option_resolution *opts)
{
floperr_t ferr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
const struct FloppyFormat *format;
const struct ImgtoolFloppyExtra *extra;
struct imgtool_floppy_image *fimg;
extra = get_extra(img_module(image));
format = extra->format;
fimg = (struct imgtool_floppy_image *) img_extrabytes(image);
/* open up the floppy */
ferr = floppy_create(f, &imgtool_ioprocs, format, opts, &fimg->floppy);
if (ferr)
{
err = imgtool_floppy_error(ferr);
goto done;
}
/* do we have to do extra stuff when creating the image? */
if (extra->create)
{
err = extra->create(image, NULL, opts);
if (err)
goto done;
}
/* do we have to do extra stuff when opening the image? */
if (extra->open)
{
err = extra->open(image, NULL);
if (err)
goto done;
}
done:
return err;
}
