Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-22 08:22:15 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Changed fs::manager_t::enumerate_f() to simplify logic within file system drivers (#10106)

Browse Source 
* Changed fs::manager_t::enumerate_f() to simplify logic within file system drivers

enumerate_f() used to contain quite a bit of boilerplate logic to determine whether a particular floppy type should be added.  This change attempts to move this logic outside the file system drivers to simplify the drivers.

The riskiest part of this change is unformatted_image::enumerate_f().  I attempted to replicate the logic that was previously determining with unformatted image types to use, but the logic is tricky and it isn't clear to me that replicating the logic is the correct action - I may be cargo culting.

* Fix to floppy_image_device::fs_enum::add_raw()

* Updating FS_FAT to reflect this PR

* On the advise of Sarayan, I moved the filtering to the fs::manager_t::fs_enum base class.  This is actually a less intrusive change than what I originally had because it keeps the unformatted raw image handling closer to what we had previously.

Some misgivings about these changes:
1. We now have fs::manager_t::fs_enum::add() being a thin call that invokes a protected method called fs::manager_t::fs_enum::add_format().  Better ideas for names are welcome.
2. It feels odd that we've removed the need to do filtering from the various FS modules, but the unformatted module has to ask the fs_enum() for its internal variables for filtering to perform the same logic.  This seems to be the least worst option

Feedback is welcome
This commit is contained in:
npwoods 2022-09-19 02:33:50 -04:00 committed by GitHub
parent e1e30896f5
commit 5499683a23
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 77 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/devices/imagedev/floppy.cpp
View File

@ -318,7 +318,13 @@ void floppy_image_device::setup_led_cb(led_cb cb)
cur_led_cb = cb;
}
void floppy_image_device::fs_enum::add(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description)
floppy_image_device::fs_enum::fs_enum(floppy_image_device *fid)
: fs::manager_t::floppy_enumerator(fid->form_factor, fid->variants)
, m_fid(fid)
{
}
void floppy_image_device::fs_enum::add_format(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description)
{
m_fid->m_fs.emplace_back(fs_info(m_manager, &type, image_size, name, description));
}
@ -346,7 +352,7 @@ void floppy_image_device::register_formats()
for(const fs::manager_t *fmt : fr.m_fs)
{
fse.m_manager = fmt;
fmt->enumerate_f(fse, form_factor, variants);
fmt->enumerate_f(fse);
m_fs_managers.push_back(fmt);
}
}

5
src/devices/imagedev/floppy.h
View File

@ -157,10 +157,11 @@ protected:
floppy_image_device *m_fid;
const fs::manager_t *m_manager;
fs_enum(floppy_image_device *fid) : fs::manager_t::floppy_enumerator(), m_fid(fid) {}
fs_enum(floppy_image_device *fid);
virtual void add(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description) override;
virtual void add_raw(const char *name, u32 key, const char *description) override;
protected:
virtual void add_format(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description) override;
};
floppy_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);

9
src/lib/formats/fs_cbmdos.cpp
View File

@ -109,13 +109,10 @@ const char *fs::cbmdos_image::description() const
// enumerate_f
//-------------------------------------------------
void fs::cbmdos_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void fs::cbmdos_image::enumerate_f(floppy_enumerator &fe) const
{
if (has(form_factor, variants, floppy_image::FF_525, floppy_image::SSSD))
{
fe.add(FLOPPY_D64_FORMAT, 174848, "d64_cbmdos_35", "D64 CBMDOS single-sided 35 tracks");
fe.add(FLOPPY_D64_FORMAT, 192256, "d64_cbmdos_40", "D64 CBMDOS single-sided 40 tracks");
}
fe.add(FLOPPY_D64_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 174848, "d64_cbmdos_35", "D64 CBMDOS single-sided 35 tracks");
fe.add(FLOPPY_D64_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 192256, "d64_cbmdos_40", "D64 CBMDOS single-sided 40 tracks");
}

2
src/lib/formats/fs_cbmdos.h
View File

@ -27,7 +27,7 @@ namespace fs {
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

9
src/lib/formats/fs_coco_os9.cpp
View File

@ -155,13 +155,10 @@ const char *coco_os9_image::description() const
// enumerate_f
//-------------------------------------------------
void coco_os9_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void coco_os9_image::enumerate_f(floppy_enumerator &fe) const
{
if (has(form_factor, variants, floppy_image::FF_525, floppy_image::SSDD))
{
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, 161280, "coco_rawdsk_os9_35", "CoCo Raw Disk OS-9 single-sided 35 tracks");
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, 184320, "coco_rawdsk_os9_40", "CoCo Raw Disk OS-9 single-sided 40 tracks");
}
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 161280, "coco_rawdsk_os9_35", "CoCo Raw Disk OS-9 single-sided 35 tracks");
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 184320, "coco_rawdsk_os9_40", "CoCo Raw Disk OS-9 single-sided 40 tracks");
}

2
src/lib/formats/fs_coco_os9.h
View File

@ -28,7 +28,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

9
src/lib/formats/fs_coco_rsdos.cpp
View File

@ -105,13 +105,10 @@ const char *coco_rsdos_image::description() const
// enumerate_f
//-------------------------------------------------
void coco_rsdos_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void coco_rsdos_image::enumerate_f(floppy_enumerator &fe) const
{
if (has(form_factor, variants, floppy_image::FF_525, floppy_image::SSDD))
{
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, 161280, "coco_rawdsk_rsdos_35", "CoCo Raw Disk RS-DOS single-sided 35 tracks");
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, 184320, "coco_rawdsk_rsdos_40", "CoCo Raw Disk RS-DOS single-sided 40 tracks");
}
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 161280, "coco_rawdsk_rsdos_35", "CoCo Raw Disk RS-DOS single-sided 35 tracks");
fe.add(FLOPPY_COCO_RAWDSK_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 184320, "coco_rawdsk_rsdos_40", "CoCo Raw Disk RS-DOS single-sided 40 tracks");
}

2
src/lib/formats/fs_coco_rsdos.h
View File

@ -26,7 +26,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

14
src/lib/formats/fs_fat.cpp
View File

@ -804,16 +804,12 @@ const char *fs::pc_fat_image::description() const
// pc_fat_image::enumerate_f
//-------------------------------------------------
void pc_fat_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void pc_fat_image::enumerate_f(floppy_enumerator &fe) const
{
if (has(form_factor, variants, floppy_image::FF_35, floppy_image::DSSD))
fe.add(FLOPPY_PC_FORMAT, 368640, "pc_fat_dssd", "PC FAT 3.5\" dual-sided single density");
if (has(form_factor, variants, floppy_image::FF_35, floppy_image::DSDD))
fe.add(FLOPPY_PC_FORMAT, 737280, "pc_fat_dsdd", "PC FAT 3.5\" dual-sided double density");
if (has(form_factor, variants, floppy_image::FF_35, floppy_image::DSHD))
fe.add(FLOPPY_PC_FORMAT, 1474560, "pc_fat_dshd", "PC FAT 3.5\" dual-sided high density");
if (has(form_factor, variants, floppy_image::FF_35, floppy_image::DSED))
fe.add(FLOPPY_PC_FORMAT, 2949120, "pc_fat_dsed", "PC FAT 3.5\" dual-sided extra density");
fe.add(FLOPPY_PC_FORMAT, floppy_image::FF_35, floppy_image::DSSD, 368640, "pc_fat_dssd", "PC FAT 3.5\" dual-sided single density");
fe.add(FLOPPY_PC_FORMAT, floppy_image::FF_35, floppy_image::DSDD, 737280, "pc_fat_dsdd", "PC FAT 3.5\" dual-sided double density");
fe.add(FLOPPY_PC_FORMAT, floppy_image::FF_35, floppy_image::DSHD, 1474560, "pc_fat_dshd", "PC FAT 3.5\" dual-sided high density");
fe.add(FLOPPY_PC_FORMAT, floppy_image::FF_35, floppy_image::DSED, 2949120, "pc_fat_dsed", "PC FAT 3.5\" dual-sided extra density");
}

2
src/lib/formats/fs_fat.h
View File

@ -48,7 +48,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
};

8
src/lib/formats/fs_oric_jasmin.cpp
View File

@ -100,12 +100,10 @@ const char *oric_jasmin_image::description() const
return "Oric Jasmin";
}
void oric_jasmin_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void oric_jasmin_image::enumerate_f(floppy_enumerator &fe) const
{
if(has(form_factor, variants, floppy_image::FF_3, floppy_image::DSDD))
fe.add(FLOPPY_ORIC_JASMIN_FORMAT, 356864, "oric_jasmin_ds", "Oric Jasmin dual-sided");
if(has(form_factor, variants, floppy_image::FF_3, floppy_image::SSDD))
fe.add(FLOPPY_ORIC_JASMIN_FORMAT, 178432, "oric_jasmin_ss", "Oric Jasmin single-sided");
fe.add(FLOPPY_ORIC_JASMIN_FORMAT, floppy_image::FF_3, floppy_image::DSDD, 356864, "oric_jasmin_ds", "Oric Jasmin dual-sided");
fe.add(FLOPPY_ORIC_JASMIN_FORMAT, floppy_image::FF_3, floppy_image::SSDD, 178432, "oric_jasmin_ss", "Oric Jasmin single-sided");
}
std::unique_ptr<filesystem_t> oric_jasmin_image::mount(fsblk_t &blockdev) const

2
src/lib/formats/fs_oric_jasmin.h
View File

@ -19,7 +19,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

8
src/lib/formats/fs_prodos.cpp
View File

@ -86,12 +86,10 @@ const u8 prodos_impl::boot[512] = {
0xf0, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
void prodos_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void prodos_image::enumerate_f(floppy_enumerator &fe) const
{
if(has(form_factor, variants, floppy_image::FF_35, floppy_image::DSDD))
fe.add(FLOPPY_APPLE_GCR_FORMAT, 819200, "prodos_800k", "Apple ProDOS 800K");
if(has(form_factor, variants, floppy_image::FF_35, floppy_image::SSDD))
fe.add(FLOPPY_APPLE_GCR_FORMAT, 409600, "prodos_400k", "Apple ProDOS 400K");
fe.add(FLOPPY_APPLE_GCR_FORMAT, floppy_image::FF_35, floppy_image::DSDD, 819200, "prodos_800k", "Apple ProDOS 800K");
fe.add(FLOPPY_APPLE_GCR_FORMAT, floppy_image::FF_35, floppy_image::SSDD, 409600, "prodos_400k", "Apple ProDOS 400K");
}
std::unique_ptr<filesystem_t> prodos_image::mount(fsblk_t &blockdev) const

2
src/lib/formats/fs_prodos.h
View File

@ -19,7 +19,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

5
src/lib/formats/fs_unformatted.cpp
View File

@ -19,8 +19,11 @@ const char *unformatted_image::description() const
return "Unformatted floppy image";
}
void unformatted_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void unformatted_image::enumerate_f(floppy_enumerator &fe) const
{
u32 form_factor = fe.form_factor();
const std::vector<u32> &variants = fe.variants();
bool all = form_factor == floppy_image::FF_UNKNOWN;
u32 best_8 =
form_factor == floppy_image::FF_8 ?

2
src/lib/formats/fs_unformatted.h
View File

@ -45,7 +45,7 @@ public:
static void format(u32 key, floppy_image *image);
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

5
src/lib/formats/fs_vtech.cpp
View File

@ -69,10 +69,9 @@ const char *vtech_image::description() const
return "VTech (Laser 200/300)";
}
void vtech_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void vtech_image::enumerate_f(floppy_enumerator &fe) const
{
if(has(form_factor, variants, floppy_image::FF_525, floppy_image::SSSD))
fe.add(FLOPPY_VTECH_BIN_FORMAT, 163840, "vtech", "VTech");
fe.add(FLOPPY_VTECH_BIN_FORMAT, floppy_image::FF_525, floppy_image::SSSD, 163840, "vtech", "VTech");
}
std::unique_ptr<filesystem_t> vtech_image::mount(fsblk_t &blockdev) const

2
src/lib/formats/fs_vtech.h
View File

@ -19,7 +19,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override;
virtual void enumerate_f(floppy_enumerator &fe) const override;
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override;
virtual bool can_format() const override;

13
src/lib/formats/fsmgr.cpp
View File

@ -48,7 +48,7 @@ bool refcounted_inner::unref_weak()
void manager_t::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const
void manager_t::enumerate_f(floppy_enumerator &fe) const
{
}
@ -428,5 +428,16 @@ err_t filesystem_t::format(const meta_data &meta)
return ERR_UNSUPPORTED;
}
manager_t::floppy_enumerator::floppy_enumerator(u32 form_factor, const std::vector<u32> &variants)
: m_form_factor(form_factor)
, m_variants(variants)
{
}
void manager_t::floppy_enumerator::add(const floppy_image_format_t &type, u32 form_factor, u32 variant, u32 image_size, const char *name, const char *description)
{
if (has(m_form_factor, m_variants, form_factor, variant))
add_format(type, image_size, name, description);
}
} // namespace fs

21
src/lib/formats/fsmgr.h
View File

@ -288,10 +288,21 @@ class unformatted_floppy_creator;
class manager_t {
public:
struct floppy_enumerator {
floppy_enumerator(u32 form_factor, const std::vector<u32> &variants);
virtual ~floppy_enumerator() = default;
virtual void add(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description) = 0;
void add(const floppy_image_format_t &type, u32 form_factor, u32 variant, u32 image_size, const char *name, const char *description);
virtual void add_raw(const char *name, u32 key, const char *description) = 0;
u32 form_factor() const { return m_form_factor; }
const std::vector<u32> &variants() const { return m_variants; }
protected:
virtual void add_format(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description) = 0;
private:
u32 m_form_factor;
const std::vector<u32> & m_variants;
};
struct hd_enumerator {
@ -312,7 +323,7 @@ public:
virtual const char *name() const = 0;
virtual const char *description() const = 0;
virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const;
virtual void enumerate_f(floppy_enumerator &fe) const;
virtual void enumerate_h(hd_enumerator &he) const;
virtual void enumerate_c(cdrom_enumerator &ce) const;
@ -331,11 +342,11 @@ public:
// Create a filesystem object from a block device
virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const = 0;
protected:
manager_t() = default;
static bool has(u32 form_factor, const std::vector<u32> &variants, u32 ff, u32 variant);
static bool has_variant(const std::vector<u32> &variants, u32 variant);
protected:
manager_t() = default;
};
} // namespace fs

9
src/tools/image_handler.cpp
View File

@ -42,10 +42,9 @@ namespace {
struct fs_enum : public fs::manager_t::floppy_enumerator {
filesystem_format *m_format;
fs_enum(filesystem_format *format, const std::vector<u32> &variants) : fs::manager_t::floppy_enumerator(floppy_image::FF_UNKNOWN, variants), m_format(format) {}
fs_enum(filesystem_format *format) : m_format(format) {}
virtual void add(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description) override {
virtual void add_format(const floppy_image_format_t &type, u32 image_size, const char *name, const char *description) override {
m_format->m_floppy = true;
m_format->m_floppy_create.emplace_back(std::make_unique<floppy_create_info>(m_format->m_manager, &type, image_size, name, description));
}
@ -65,8 +64,8 @@ void formats_table::init()
mame_formats_full_list(en);
for(auto &f : filesystem_formats) {
fs_enum fen(f.get());
f->m_manager->enumerate_f(fen, floppy_image::FF_UNKNOWN, variants);
fs_enum fen(f.get(), variants);
f->m_manager->enumerate_f(fen);
}
for(auto &f : floppy_format_infos) {