diff options
25 files changed, 894 insertions, 834 deletions
diff --git a/src/devices/bus/oricext/jasmin.cpp b/src/devices/bus/oricext/jasmin.cpp index a7188667b09..a50ab9d742d 100644 --- a/src/devices/bus/oricext/jasmin.cpp +++ b/src/devices/bus/oricext/jasmin.cpp @@ -18,7 +18,7 @@ void oric_jasmin_device::floppy_formats(format_registration &fr) fr.add(FLOPPY_ORIC_DSK_FORMAT); fr.add(FLOPPY_ORIC_JASMIN_FORMAT); - fr.add(FS_ORIC_JASMIN); + fr.add(fs::ORIC_JASMIN); } static void jasmin_floppies(device_slot_interface &device) diff --git a/src/devices/bus/vtech/memexp/floppy.cpp b/src/devices/bus/vtech/memexp/floppy.cpp index 47970b9a142..4e641947aaf 100644 --- a/src/devices/bus/vtech/memexp/floppy.cpp +++ b/src/devices/bus/vtech/memexp/floppy.cpp @@ -71,7 +71,7 @@ void vtech_floppy_controller_device::floppy_formats(format_registration &fr) { fr.add(FLOPPY_VTECH_BIN_FORMAT); fr.add(FLOPPY_VTECH_DSK_FORMAT); - fr.add(FS_VTECH); + fr.add(fs::VTECH); } void vtech_floppy_controller_device::device_add_mconfig(machine_config &config) diff --git a/src/devices/imagedev/floppy.cpp b/src/devices/imagedev/floppy.cpp index 00d4b77ecd3..0d8d75b9279 100644 --- a/src/devices/imagedev/floppy.cpp +++ b/src/devices/imagedev/floppy.cpp @@ -155,7 +155,7 @@ format_registration::format_registration() add(FLOPPY_MFI_FORMAT); // Our generic format add(FLOPPY_DFI_FORMAT); // Flux format, dying - add(FS_UNFORMATTED); + add(fs::UNFORMATTED); } void format_registration::add_fm_containers() @@ -188,7 +188,7 @@ void format_registration::add(floppy_format_type format) m_formats.push_back(format); } -void format_registration::add(const filesystem_manager_t &fs) +void format_registration::add(const fs::manager_t &fs) { m_fs.push_back(&fs); } @@ -352,7 +352,7 @@ void floppy_image_device::register_formats() } fs_enum fse(this); - for(const filesystem_manager_t *fmt : fr.m_fs) + for(const fs::manager_t *fmt : fr.m_fs) { fse.m_manager = fmt; fmt->enumerate_f(fse, form_factor, variants); @@ -829,12 +829,12 @@ image_init_result floppy_image_device::call_create(int format_type, util::option return image_init_result::PASS; } -void floppy_image_device::init_fs(const fs_info *fs, const fs_meta_data &meta) +void floppy_image_device::init_fs(const fs_info *fs, const fs::meta_data &meta) { assert(image); if (fs->m_type) { std::vector<u8> img(fs->m_image_size); - fsblk_vec_t blockdev(img); + fs::fsblk_vec_t blockdev(img); auto cfs = fs->m_manager->mount(blockdev); cfs->format(meta); @@ -843,7 +843,7 @@ void floppy_image_device::init_fs(const fs_info *fs, const fs_meta_data &meta) source_format->load(*io, floppy_image::FF_UNKNOWN, variants, image.get()); delete source_format; } else { - fs_unformatted::format(fs->m_key, image.get()); + fs::unformatted_image::format(fs->m_key, image.get()); } } diff --git a/src/devices/imagedev/floppy.h b/src/devices/imagedev/floppy.h index ac27e35741e..fe878bf6d2d 100644 --- a/src/devices/imagedev/floppy.h +++ b/src/devices/imagedev/floppy.h @@ -28,14 +28,14 @@ public: format_registration(); void add(floppy_format_type format); - void add(const filesystem_manager_t &fs); + void add(const fs::manager_t &fs); void add_fm_containers(); void add_mfm_containers(); void add_pc_formats(); std::vector<floppy_format_type> m_formats; - std::vector<const filesystem_manager_t *> m_fs; + std::vector<const fs::manager_t *> m_fs; }; class floppy_image_device : public device_t, @@ -50,14 +50,14 @@ public: typedef delegate<void (floppy_image_device *, int)> led_cb; struct fs_info { - const filesystem_manager_t *m_manager; + const fs::manager_t *m_manager; floppy_format_type m_type; u32 m_image_size; const char *m_name; u32 m_key; const char *m_description; - fs_info(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, const char *description) : + fs_info(const fs::manager_t *manager, floppy_format_type type, u32 image_size, const char *name, const char *description) : m_manager(manager), m_type(type), m_image_size(image_size), @@ -87,7 +87,7 @@ public: floppy_image_format_t *identify(std::string filename); void set_rpm(float rpm); - void init_fs(const fs_info *fs, const fs_meta_data &meta); + void init_fs(const fs_info *fs, const fs::meta_data &meta); // image-level overrides virtual image_init_result call_load() override; @@ -156,11 +156,11 @@ public: void enable_sound(bool doit) { m_make_sound = doit; } protected: - struct fs_enum : public filesystem_manager_t::floppy_enumerator { + struct fs_enum : public fs::manager_t::floppy_enumerator { floppy_image_device *m_fid; - const filesystem_manager_t *m_manager; + const fs::manager_t *m_manager; - fs_enum(floppy_image_device *fid) : filesystem_manager_t::floppy_enumerator(), m_fid(fid) {}; + fs_enum(floppy_image_device *fid) : fs::manager_t::floppy_enumerator(), m_fid(fid) {}; virtual void add(floppy_format_type type, u32 image_size, const char *name, const char *description) override; virtual void add_raw(const char *name, u32 key, const char *description) override; @@ -191,7 +191,7 @@ protected: char extension_list[256]; std::vector<floppy_image_format_t *> fif_list; std::vector<fs_info> m_create_fs, m_io_fs; - std::vector<const filesystem_manager_t *> m_fs_managers; + std::vector<const fs::manager_t *> m_fs_managers; emu_timer *index_timer; /* Physical characteristics, filled by setup_characteristics */ diff --git a/src/devices/machine/applefdintf.cpp b/src/devices/machine/applefdintf.cpp index d81f77562d3..e20364b4983 100644 --- a/src/devices/machine/applefdintf.cpp +++ b/src/devices/machine/applefdintf.cpp @@ -32,7 +32,7 @@ void applefdintf_device::formats_35(format_registration &fr) fr.add(FLOPPY_APPLE_GCR_FORMAT); fr.add(FLOPPY_APPLE_2MG_FORMAT); - fr.add(FS_PRODOS); + fr.add(fs::PRODOS); } void applefdintf_device::floppies_525(device_slot_interface &device) diff --git a/src/frontend/mame/ui/floppycntrl.cpp b/src/frontend/mame/ui/floppycntrl.cpp index ee7740c76d1..d9d6d421b81 100644 --- a/src/frontend/mame/ui/floppycntrl.cpp +++ b/src/frontend/mame/ui/floppycntrl.cpp @@ -48,7 +48,7 @@ void menu_control_floppy_image::do_load_create() // HACK: ensure the floppy_image structure is created since device_image_interface may not otherwise do so during "init phase" err = fd.finish_load(); if (err == image_init_result::PASS) { - fs_meta_data meta; + fs::meta_data meta; fd.init_fs(create_fs, meta); } } diff --git a/src/lib/formats/all.cpp b/src/lib/formats/all.cpp index d9e7839828d..7be97cec4f7 100644 --- a/src/lib/formats/all.cpp +++ b/src/lib/formats/all.cpp @@ -687,7 +687,7 @@ void mame_formats_full_list(mame_formats_enumerator &en) { en.category("Generic"); - en.add(FS_UNFORMATTED); + en.add(fs::UNFORMATTED); en.add(cassette_default_formats); #ifdef HAS_FORMATS_UEF_CAS en.add(uef_cassette_formats); // uef_cas.h @@ -711,7 +711,7 @@ void mame_formats_full_list(mame_formats_enumerator &en) en.category("Apple"); #ifdef HAS_FORMATS_FS_PRODOS - en.add(FS_PRODOS); + en.add(fs::PRODOS); #endif #ifdef HAS_FORMATS_AP2_DSK en.add(FLOPPY_A216S_FORMAT); // ap2_dsk.h @@ -1144,7 +1144,7 @@ void mame_formats_full_list(mame_formats_enumerator &en) en.add(FLOPPY_ORIC_JASMIN_FORMAT); // oric_dsk.h #endif #ifdef HAS_FORMATS_FS_ORIC_JASMIN - en.add(FS_ORIC_JASMIN); // fs_oric_jasmin.h + en.add(fs::ORIC_JASMIN); // fs_oric_jasmin.h #endif en.category("Atari"); @@ -1391,7 +1391,7 @@ void mame_formats_full_list(mame_formats_enumerator &en) en.add(FLOPPY_VTECH_DSK_FORMAT); // vt_dsk.h #endif #ifdef HAS_FORMATS_FS_VTECH - en.add(FS_VTECH); // fs_vtech.h + en.add(fs::VTECH); // fs_vtech.h #endif en.category("Canon"); diff --git a/src/lib/formats/all.h b/src/lib/formats/all.h index 1284bf9f509..bf797bda5eb 100644 --- a/src/lib/formats/all.h +++ b/src/lib/formats/all.h @@ -18,7 +18,7 @@ struct mame_formats_enumerator { virtual void category(const char *name) = 0; virtual void add(const cassette_image::Format *const *formats) = 0; virtual void add(floppy_format_type format) = 0; - virtual void add(const filesystem_manager_t &fs) = 0; + virtual void add(const fs::manager_t &fs) = 0; }; void mame_formats_full_list(mame_formats_enumerator &en); diff --git a/src/lib/formats/fs_oric_jasmin.cpp b/src/lib/formats/fs_oric_jasmin.cpp index 189eb761115..624d9631ccb 100644 --- a/src/lib/formats/fs_oric_jasmin.cpp +++ b/src/lib/formats/fs_oric_jasmin.cpp @@ -8,7 +8,9 @@ #include <stdexcept> -const fs_oric_jasmin FS_ORIC_JASMIN; +namespace fs { + +const oric_jasmin_image ORIC_JASMIN; // Floppy only, format is 41 tracks, 1/2 heads, 17 sectors. // Filesystem has no subdirectories. @@ -42,17 +44,17 @@ const fs_oric_jasmin FS_ORIC_JASMIN; // offset 04-05: length of the file in bytes on the first sector, ffff otherwise // offset 06+ : reference to data sectors, (ff, ff) when done -const char *fs_oric_jasmin::name() const +const char *oric_jasmin_image::name() const { return "oric_jasmin"; } -const char *fs_oric_jasmin::description() const +const char *oric_jasmin_image::description() const { return "Oric Jasmin"; } -void fs_oric_jasmin::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const +void oric_jasmin_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) 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"); @@ -60,52 +62,52 @@ void fs_oric_jasmin::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, co fe.add(FLOPPY_ORIC_JASMIN_FORMAT, 178432, "oric_jasmin_ss", "Oric Jasmin single-sided"); } -std::unique_ptr<filesystem_t> fs_oric_jasmin::mount(fsblk_t &blockdev) const +std::unique_ptr<filesystem_t> oric_jasmin_image::mount(fsblk_t &blockdev) const { return std::make_unique<impl>(blockdev); } -bool fs_oric_jasmin::can_format() const +bool oric_jasmin_image::can_format() const { return true; } -bool fs_oric_jasmin::can_read() const +bool oric_jasmin_image::can_read() const { return true; } -bool fs_oric_jasmin::can_write() const +bool oric_jasmin_image::can_write() const { return true; } -bool fs_oric_jasmin::has_rsrc() const +bool oric_jasmin_image::has_rsrc() const { return false; } -std::vector<fs_meta_description> fs_oric_jasmin::volume_meta_description() const +std::vector<meta_description> oric_jasmin_image::volume_meta_description() const { - std::vector<fs_meta_description> res; - res.emplace_back(fs_meta_description(fs_meta_name::name, fs_meta_type::string, "UNTITLED", false, [](const fs_meta &m) { return m.as_string().size() <= 8; }, "Volume name, up to 8 characters")); + std::vector<meta_description> res; + res.emplace_back(meta_description(meta_name::name, meta_type::string, "UNTITLED", false, [](const meta_value &m) { return m.as_string().size() <= 8; }, "Volume name, up to 8 characters")); return res; } -fs_meta_data fs_oric_jasmin::impl::metadata() +meta_data oric_jasmin_image::impl::metadata() { - fs_meta_data res; + meta_data res; auto bdir = m_blockdev.get(20*17); int len = 8; while(len > 0 && bdir.rodata()[0xf8 + len - 1] == ' ') len--; - res.set(fs_meta_name::name, bdir.rstr(0xf8, len)); + res.set(meta_name::name, bdir.rstr(0xf8, len)); return res; } -bool fs_oric_jasmin::validate_filename(std::string name) +bool oric_jasmin_image::validate_filename(std::string name) { auto pos = name.find('.'); if(pos != std::string::npos) @@ -114,30 +116,30 @@ bool fs_oric_jasmin::validate_filename(std::string name) return name.size() > 0 && name.size() <= 8; } -std::vector<fs_meta_description> fs_oric_jasmin::file_meta_description() const +std::vector<meta_description> oric_jasmin_image::file_meta_description() const { - std::vector<fs_meta_description> res; - res.emplace_back(fs_meta_description(fs_meta_name::name, fs_meta_type::string, "", false, [](const fs_meta &m) { return validate_filename(m.as_string()); }, "File name, 8.3")); - res.emplace_back(fs_meta_description(fs_meta_name::loading_address, fs_meta_type::number, 0x501, false, [](const fs_meta &m) { return m.as_number() < 0x10000; }, "Loading address of the file")); - res.emplace_back(fs_meta_description(fs_meta_name::length, fs_meta_type::number, 0, true, nullptr, "Size of the file in bytes")); - res.emplace_back(fs_meta_description(fs_meta_name::size_in_blocks, fs_meta_type::number, 0, true, nullptr, "Number of blocks used by the file")); - res.emplace_back(fs_meta_description(fs_meta_name::locked, fs_meta_type::flag, false, false, nullptr, "File locked")); - res.emplace_back(fs_meta_description(fs_meta_name::sequential, fs_meta_type::flag, true, false, nullptr, "File sequential")); + std::vector<meta_description> res; + res.emplace_back(meta_description(meta_name::name, meta_type::string, "", false, [](const meta_value &m) { return validate_filename(m.as_string()); }, "File name, 8.3")); + res.emplace_back(meta_description(meta_name::loading_address, meta_type::number, 0x501, false, [](const meta_value &m) { return m.as_number() < 0x10000; }, "Loading address of the file")); + res.emplace_back(meta_description(meta_name::length, meta_type::number, 0, true, nullptr, "Size of the file in bytes")); + res.emplace_back(meta_description(meta_name::size_in_blocks, meta_type::number, 0, true, nullptr, "Number of blocks used by the file")); + res.emplace_back(meta_description(meta_name::locked, meta_type::flag, false, false, nullptr, "File locked")); + res.emplace_back(meta_description(meta_name::sequential, meta_type::flag, true, false, nullptr, "File sequential")); return res; } -void fs_oric_jasmin::impl::format(const fs_meta_data &meta) +void oric_jasmin_image::impl::format(const meta_data &meta) { - std::string volume_name = meta.get_string(fs_meta_name::name, "UNTITLED"); - uint32_t blocks = m_blockdev.block_count(); + std::string volume_name = meta.get_string(meta_name::name, "UNTITLED"); + u32 blocks = m_blockdev.block_count(); m_blockdev.fill(0x6c); - uint32_t bblk = 20*17; + u32 bblk = 20*17; auto fmap = m_blockdev.get(bblk); - uint32_t off = 0; - for(uint32_t blk = 0; blk != blocks; blk += 17) { + u32 off = 0; + for(u32 blk = 0; blk != blocks; blk += 17) { if(blk == bblk) fmap.w24l(off, 0x07fff); else @@ -145,7 +147,7 @@ void fs_oric_jasmin::impl::format(const fs_meta_data &meta) off += 3; } - for(uint32_t blk = blocks; blk != 17*42*2; blk += 17) { + for(u32 blk = blocks; blk != 17*42*2; blk += 17) { fmap.w24l(off, 0x800000); off += 3; } @@ -161,14 +163,14 @@ void fs_oric_jasmin::impl::format(const fs_meta_data &meta) bdir.w16l(2, 0x0000); } -fs_oric_jasmin::impl::impl(fsblk_t &blockdev) : filesystem_t(blockdev, 256), m_root(true) +oric_jasmin_image::impl::impl(fsblk_t &blockdev) : filesystem_t(blockdev, 256), m_root(true) { } -bool fs_oric_jasmin::impl::ref_valid(uint16_t ref) +bool oric_jasmin_image::impl::ref_valid(u16 ref) { - uint8_t track = ref >> 8; - uint8_t sector = ref & 0xff; + u8 track = ref >> 8; + u8 sector = ref & 0xff; if(sector < 1 || sector > 17) return false; if(track >= m_blockdev.block_count()/17) @@ -176,21 +178,21 @@ bool fs_oric_jasmin::impl::ref_valid(uint16_t ref) return true; } -uint32_t fs_oric_jasmin::impl::cs_to_block(uint16_t ref) +u32 oric_jasmin_image::impl::cs_to_block(u16 ref) { - uint8_t track = ref >> 8; - uint8_t sector = ref & 0xff; + u8 track = ref >> 8; + u8 sector = ref & 0xff; return track * 17 + sector - 1; } -uint16_t fs_oric_jasmin::impl::block_to_cs(uint32_t block) +u16 oric_jasmin_image::impl::block_to_cs(u32 block) { - uint8_t track = block / 17; - uint8_t sector = (block % 17) + 1; + u8 track = block / 17; + u8 sector = (block % 17) + 1; return (track << 8) | sector; } -std::string fs_oric_jasmin::impl::read_file_name(const uint8_t *p) +std::string oric_jasmin_image::impl::read_file_name(const u8 *p) { int main_len; for(main_len = 8; main_len > 0; main_len--) @@ -209,49 +211,49 @@ std::string fs_oric_jasmin::impl::read_file_name(const uint8_t *p) } -filesystem_t::dir_t fs_oric_jasmin::impl::root() +filesystem_t::dir_t oric_jasmin_image::impl::root() { if(!m_root) m_root = new root_dir(*this); return m_root.strong(); } -void fs_oric_jasmin::impl::drop_root_ref() +void oric_jasmin_image::impl::drop_root_ref() { m_root = nullptr; } -void fs_oric_jasmin::impl::root_dir::drop_weak_references() +void oric_jasmin_image::impl::root_dir::drop_weak_references() { m_fs.drop_root_ref(); } -fs_meta_data fs_oric_jasmin::impl::root_dir::metadata() +meta_data oric_jasmin_image::impl::root_dir::metadata() { - return fs_meta_data(); + return meta_data(); } -std::vector<fs_dir_entry> fs_oric_jasmin::impl::root_dir::contents() +std::vector<dir_entry> oric_jasmin_image::impl::root_dir::contents() { - std::vector<fs_dir_entry> res; + std::vector<dir_entry> res; auto bdir = m_fs.m_blockdev.get(20*17+1); - uint64_t id = 0; + u64 id = 0; for(;;) { - for(uint32_t i = 0; i != 14; i ++) { - uint32_t off = 4 + i*18; - uint16_t ref = bdir.r16b(off); + for(u32 i = 0; i != 14; i ++) { + u32 off = 4 + i*18; + u16 ref = bdir.r16b(off); std::string fname = read_file_name(bdir.rodata()+off+3); bool system = ref == 0 && id == 0 && bdir.r32b(off+0xb) == 0x2e535953; if(system) - res.emplace_back(fs_dir_entry(fname, fs_dir_entry_type::system_file, 0)); + res.emplace_back(dir_entry(fname, dir_entry_type::system_file, 0)); else if(m_fs.ref_valid(ref)) - res.emplace_back(fs_dir_entry(fname, fs_dir_entry_type::file, id)); + res.emplace_back(dir_entry(fname, dir_entry_type::file, id)); id++; } - uint16_t ref = bdir.r16b(2); + u16 ref = bdir.r16b(2); if(!ref || !m_fs.ref_valid(ref)) break; bdir = m_fs.m_blockdev.get(cs_to_block(ref)); @@ -259,24 +261,24 @@ std::vector<fs_dir_entry> fs_oric_jasmin::impl::root_dir::contents() return res; } -std::pair<fsblk_t::block_t, uint32_t> fs_oric_jasmin::impl::root_dir::get_dir_block(uint64_t key) +std::pair<fsblk_t::block_t, u32> oric_jasmin_image::impl::root_dir::get_dir_block(u64 key) { auto bdir = m_fs.m_blockdev.get(20*17+1); while(key >= 14) { - uint16_t ref = bdir.r16b(2); + u16 ref = bdir.r16b(2); if(!ref || !m_fs.ref_valid(ref)) throw std::invalid_argument("Incorrect file key"); bdir = m_fs.m_blockdev.get(cs_to_block(ref)); key -= 14; } - return std::pair<fsblk_t::block_t, uint32_t>(bdir, 4 + key * 18); + return std::pair<fsblk_t::block_t, u32>(bdir, 4 + key * 18); } -filesystem_t::file_t fs_oric_jasmin::impl::root_dir::file_get(uint64_t key) +filesystem_t::file_t oric_jasmin_image::impl::root_dir::file_get(u64 key) { - uint64_t rkey = key; + u64 rkey = key; auto [bdir, off] = get_dir_block(rkey); - uint16_t ref = bdir.r16b(off); + u16 ref = bdir.r16b(off); bool system = ref == 0 && key == 0 && bdir.r32b(off+0xb) == 0x2e535953; if(system) return file_t(new system_file(m_fs, this, bdir.rodata() + off, key)); @@ -286,19 +288,19 @@ filesystem_t::file_t fs_oric_jasmin::impl::root_dir::file_get(uint64_t key) return file_t(new file(m_fs, this, bdir.rodata() + off, key)); } -void fs_oric_jasmin::impl::root_dir::update_file(uint16_t key, const uint8_t *entry) +void oric_jasmin_image::impl::root_dir::update_file(u16 key, const u8 *entry) { - uint64_t rkey = key; + u64 rkey = key; auto [bdir, off] = get_dir_block(rkey); bdir.copy(off, entry, 18); } -filesystem_t::dir_t fs_oric_jasmin::impl::root_dir::dir_get(uint64_t key) +filesystem_t::dir_t oric_jasmin_image::impl::root_dir::dir_get(u64 key) { throw std::logic_error("Directories not supported"); } -std::string fs_oric_jasmin::impl::file_name_prepare(std::string fname) +std::string oric_jasmin_image::impl::file_name_prepare(std::string fname) { std::string nname; size_t i; @@ -318,45 +320,45 @@ std::string fs_oric_jasmin::impl::file_name_prepare(std::string fname) return nname; } -fs_oric_jasmin::impl::file::file(impl &fs, root_dir *dir, const uint8_t *entry, uint16_t key) : m_fs(fs), m_dir(dir), m_key(key) +oric_jasmin_image::impl::file::file(impl &fs, root_dir *dir, const u8 *entry, u16 key) : m_fs(fs), m_dir(dir), m_key(key) { memcpy(m_entry, entry, 18); } -void fs_oric_jasmin::impl::file::drop_weak_references() +void oric_jasmin_image::impl::file::drop_weak_references() { } -fs_meta_data fs_oric_jasmin::impl::file::metadata() +meta_data oric_jasmin_image::impl::file::metadata() { - fs_meta_data res; + meta_data res; - res.set(fs_meta_name::name, read_file_name(m_entry + 3)); - res.set(fs_meta_name::locked, m_entry[2] == 'L'); - res.set(fs_meta_name::sequential, m_entry[0xf] == 'S'); - res.set(fs_meta_name::size_in_blocks, r16l(m_entry + 0x10)); + res.set(meta_name::name, read_file_name(m_entry + 3)); + res.set(meta_name::locked, m_entry[2] == 'L'); + res.set(meta_name::sequential, m_entry[0xf] == 'S'); + res.set(meta_name::size_in_blocks, r16l(m_entry + 0x10)); - uint16_t ref = r16b(m_entry); + u16 ref = r16b(m_entry); auto dblk = m_fs.m_blockdev.get(cs_to_block(ref)); - res.set(fs_meta_name::loading_address, dblk.r16l(2)); - res.set(fs_meta_name::length, dblk.r16l(4)); + res.set(meta_name::loading_address, dblk.r16l(2)); + res.set(meta_name::length, dblk.r16l(4)); return res; } -std::vector<uint8_t> fs_oric_jasmin::impl::file::read_all() +std::vector<u8> oric_jasmin_image::impl::file::read_all() { - std::vector<uint8_t> data; - uint16_t ref = r16b(m_entry); + std::vector<u8> data; + u16 ref = r16b(m_entry); auto iblk = m_fs.m_blockdev.get(cs_to_block(ref)); - uint32_t length = iblk.r16l(4); + u32 length = iblk.r16l(4); while(m_fs.ref_valid(ref)) { - for(uint32_t pos = 6; pos != 256 && data.size() < length; pos += 2) { - uint16_t dref = iblk.r16b(pos); + for(u32 pos = 6; pos != 256 && data.size() < length; pos += 2) { + u16 dref = iblk.r16b(pos); if(!m_fs.ref_valid(dref)) goto done; auto dblk = m_fs.m_blockdev.get(cs_to_block(dref)); - uint32_t dpos = data.size(); + u32 dpos = data.size(); data.resize(dpos + 256); memcpy(data.data() + dpos, dblk.rodata(), 256); if(data.size() >= length) @@ -372,55 +374,55 @@ std::vector<uint8_t> fs_oric_jasmin::impl::file::read_all() return data; } -fs_oric_jasmin::impl::system_file::system_file(impl &fs, root_dir *dir, const uint8_t *entry, uint16_t key) : m_fs(fs), m_dir(dir), m_key(key) +oric_jasmin_image::impl::system_file::system_file(impl &fs, root_dir *dir, const u8 *entry, u16 key) : m_fs(fs), m_dir(dir), m_key(key) { memcpy(m_entry, entry, 18); } -void fs_oric_jasmin::impl::system_file::drop_weak_references() +void oric_jasmin_image::impl::system_file::drop_weak_references() { } -fs_meta_data fs_oric_jasmin::impl::system_file::metadata() +meta_data oric_jasmin_image::impl::system_file::metadata() { - fs_meta_data res; + meta_data res; - res.set(fs_meta_name::name, read_file_name(m_entry + 3)); - res.set(fs_meta_name::locked, m_entry[2] == 'L'); - res.set(fs_meta_name::sequential, m_entry[0xf] == 'S'); - res.set(fs_meta_name::size_in_blocks, r16l(m_entry + 0x10)); - res.set(fs_meta_name::length, 0x3e00); + res.set(meta_name::name, read_file_name(m_entry + 3)); + res.set(meta_name::locked, m_entry[2] == 'L'); + res.set(meta_name::sequential, m_entry[0xf] == 'S'); + res.set(meta_name::size_in_blocks, r16l(m_entry + 0x10)); + res.set(meta_name::length, 0x3e00); return res; } -std::vector<uint8_t> fs_oric_jasmin::impl::system_file::read_all() +std::vector<u8> oric_jasmin_image::impl::system_file::read_all() { - std::vector<uint8_t> data(0x3e00); - for(uint32_t i = 0; i != 62; i++) { + std::vector<u8> data(0x3e00); + for(u32 i = 0; i != 62; i++) { auto dblk = m_fs.m_blockdev.get(i); memcpy(data.data() + 256 * i, dblk.rodata(), 256); } return data; } -fs_oric_jasmin::impl::file_t fs_oric_jasmin::impl::root_dir::file_create(const fs_meta_data &info) +oric_jasmin_image::impl::file_t oric_jasmin_image::impl::root_dir::file_create(const meta_data &info) { // One block of sector list, one block of data - uint32_t nb = 2; + u32 nb = 2; // Find the key for the next entry, increase nb if needed auto bdir = m_fs.m_blockdev.get(20*17+1); - uint64_t id = 0; + u64 id = 0; for(;;) { - for(uint32_t i = 0; i != 14; i ++) { - uint32_t off = 4 + i*18; - uint16_t ref = bdir.r16b(off); + for(u32 i = 0; i != 14; i ++) { + u32 off = 4 + i*18; + u16 ref = bdir.r16b(off); if(!m_fs.ref_valid(ref)) goto found; id++; } - uint16_t ref = bdir.r16b(2); + u16 ref = bdir.r16b(2); if(!ref || !m_fs.ref_valid(ref)) { nb ++; break; @@ -434,7 +436,7 @@ fs_oric_jasmin::impl::file_t fs_oric_jasmin::impl::root_dir::file_create(const f auto sblk = m_fs.m_blockdev.get(cs_to_block(block[0])); sblk.w16b(0, 0xff00); // Next sector - sblk.w16l(2, info.get_number(fs_meta_name::loading_address, 0x500)); + sblk.w16l(2, info.get_number(meta_name::loading_address, 0x500)); sblk.w16l(4, 0); // Length sblk.w16b(6, block[1]); // Data block @@ -446,11 +448,11 @@ fs_oric_jasmin::impl::file_t fs_oric_jasmin::impl::root_dir::file_create(const f bdir.w16l(2, 0xff00); // No next directory sector } - uint32_t off = 4 + (id % 14) * 18; + u32 off = 4 + (id % 14) * 18; bdir.w16b(off+0x00, block[0]); // First (and only) sector in the sector list - bdir.w8 (off+0x02, info.get_flag(fs_meta_name::locked, false) ? 'L' : 'U'); - bdir.wstr(off+0x03, file_name_prepare(info.get_string(fs_meta_name::name, ""))); - bdir.w8 (off+0x0f, info.get_flag(fs_meta_name::sequential, true) ? 'S' : 'D'); + bdir.w8 (off+0x02, info.get_flag(meta_name::locked, false) ? 'L' : 'U'); + bdir.wstr(off+0x03, file_name_prepare(info.get_string(meta_name::name, ""))); + bdir.w8 (off+0x0f, info.get_flag(meta_name::sequential, true) ? 'S' : 'D'); bdir.w16l(off+0x10, 2); // 2 sectors for an empty file return file_t(new file(m_fs, this, bdir.rodata() + off, id)); @@ -458,15 +460,15 @@ fs_oric_jasmin::impl::file_t fs_oric_jasmin::impl::root_dir::file_create(const f -void fs_oric_jasmin::impl::root_dir::file_delete(uint64_t key) +void oric_jasmin_image::impl::root_dir::file_delete(u64 key) { } -void fs_oric_jasmin::impl::file::replace(const std::vector<uint8_t> &data) +void oric_jasmin_image::impl::file::replace(const std::vector<u8> &data) { - uint32_t cur_ns = r16l(m_entry + 0x10); + u32 cur_ns = r16l(m_entry + 0x10); // Data sectors first - uint32_t need_ns = (data.size() + 255) / 256; + u32 need_ns = (data.size() + 255) / 256; if(need_ns == 0) need_ns = 1; // Add the sector list sectors, 125 entries/sector @@ -476,22 +478,22 @@ void fs_oric_jasmin::impl::file::replace(const std::vector<uint8_t> &data) if(cur_ns < need_ns && m_fs.free_block_count() < need_ns - cur_ns) return; - uint16_t load_address = 0; - std::vector<uint16_t> tofree; - uint16_t iref = r16b(m_entry); - for(uint32_t i=0; i < cur_ns; i += 125+1) { + u16 load_address = 0; + std::vector<u16> tofree; + u16 iref = r16b(m_entry); + for(u32 i=0; i < cur_ns; i += 125+1) { auto iblk = m_fs.m_blockdev.get(cs_to_block(iref)); if(!i) load_address = iblk.r16l(2); tofree.push_back(iref); - for(uint32_t j=0; j != 125 && i+j+1 != cur_ns; j++) + for(u32 j=0; j != 125 && i+j+1 != cur_ns; j++) tofree.push_back(iblk.r16b(6+2*j)); iref = iblk.r16b(2); } m_fs.free_blocks(tofree); - std::vector<uint16_t> blocks = m_fs.allocate_blocks(need_ns); - for(uint32_t i=0; i < need_ns; i += 125+1) { + std::vector<u16> blocks = m_fs.allocate_blocks(need_ns); + for(u32 i=0; i < need_ns; i += 125+1) { auto iblk = m_fs.m_blockdev.get(cs_to_block(blocks[i])); iblk.fill(0xff); if(!i) { @@ -503,9 +505,9 @@ void fs_oric_jasmin::impl::file::replace(const std::vector<uint8_t> &data) else iblk.w16b(0, 0xff00); - for(uint32_t j=0; j != 125 && i+j+1 != need_ns; j++) { - uint32_t dpos = 256 * (j + i/126*125); - uint32_t size = data.size() - dpos; + for(u32 j=0; j != 125 && i+j+1 != need_ns; j++) { + u32 dpos = 256 * (j + i/126*125); + u32 size = data.size() - dpos; iblk.w16b(6+j*2, blocks[i+j+1]); auto dblk = m_fs.m_blockdev.get(cs_to_block(blocks[i+j+1])); if(size >= 256) @@ -521,66 +523,66 @@ void fs_oric_jasmin::impl::file::replace(const std::vector<uint8_t> &data) m_dir->update_file(m_key, m_entry); } -void fs_oric_jasmin::impl::root_dir::metadata_change(const fs_meta_data &info) +void oric_jasmin_image::impl::root_dir::metadata_change(const meta_data &info) { } -void fs_oric_jasmin::impl::metadata_change(const fs_meta_data &info) +void oric_jasmin_image::impl::metadata_change(const meta_data &info) { - if(info.has(fs_meta_name::name)) { - std::string volume_name = info.get_string(fs_meta_name::name); + if(info.has(meta_name::name)) { + std::string volume_name = info.get_string(meta_name::name); volume_name.resize(8, ' '); m_blockdev.get(20*17).wstr(0xf8, volume_name); } } -void fs_oric_jasmin::impl::file::metadata_change(const fs_meta_data &info) +void oric_jasmin_image::impl::file::metadata_change(const meta_data &info) { - if(info.has(fs_meta_name::locked)) - w8 (m_entry+0x02, info.get_flag(fs_meta_name::locked) ? 'L' : 'U'); - if(info.has(fs_meta_name::name)) - wstr(m_entry+0x03, file_name_prepare(info.get_string(fs_meta_name::name))); - if(info.has(fs_meta_name::sequential)) - w8 (m_entry+0x0f, info.get_flag(fs_meta_name::sequential) ? 'D' : 'S'); - if(info.has(fs_meta_name::loading_address)) - m_fs.m_blockdev.get(cs_to_block(r16b(m_entry))).w16l(2, info.get_number(fs_meta_name::loading_address)); + if(info.has(meta_name::locked)) + w8 (m_entry+0x02, info.get_flag(meta_name::locked) ? 'L' : 'U'); + if(info.has(meta_name::name)) + wstr(m_entry+0x03, file_name_prepare(info.get_string(meta_name::name))); + if(info.has(meta_name::sequential)) + w8 (m_entry+0x0f, info.get_flag(meta_name::sequential) ? 'D' : 'S'); + if(info.has(meta_name::loading_address)) + m_fs.m_blockdev.get(cs_to_block(r16b(m_entry))).w16l(2, info.get_number(meta_name::loading_address)); m_dir->update_file(m_key, m_entry); } -void fs_oric_jasmin::impl::system_file::replace(const std::vector<uint8_t> &data) +void oric_jasmin_image::impl::system_file::replace(const std::vector<u8> &data) { if(data.size() != 0x3e00) return; - for(uint32_t i=0; i != 0x3e; i++) + for(u32 i=0; i != 0x3e; i++) m_fs.m_blockdev.get(i).copy(0, data.data() + i * 256, 256); } -void fs_oric_jasmin::impl::system_file::metadata_change(const fs_meta_data &info) +void oric_jasmin_image::impl::system_file::metadata_change(const meta_data &info) { - if(info.has(fs_meta_name::locked)) - w8 (m_entry+0x02, info.get_flag(fs_meta_name::locked) ? 'L' : 'U'); - if(info.has(fs_meta_name::name)) - wstr(m_entry+0x03, file_name_prepare(info.get_string(fs_meta_name::name))); - if(info.has(fs_meta_name::sequential)) - w8 (m_entry+0x0f, info.get_flag(fs_meta_name::sequential) ? 'S' : 'D'); - if(info.has(fs_meta_name::loading_address)) - m_fs.m_blockdev.get(cs_to_block(r16b(m_entry))).w16l(2, info.get_number(fs_meta_name::loading_address)); + if(info.has(meta_name::locked)) + w8 (m_entry+0x02, info.get_flag(meta_name::locked) ? 'L' : 'U'); + if(info.has(meta_name::name)) + wstr(m_entry+0x03, file_name_prepare(info.get_string(meta_name::name))); + if(info.has(meta_name::sequential)) + w8 (m_entry+0x0f, info.get_flag(meta_name::sequential) ? 'S' : 'D'); + if(info.has(meta_name::loading_address)) + m_fs.m_blockdev.get(cs_to_block(r16b(m_entry))).w16l(2, info.get_number(meta_name::loading_address)); m_dir->update_file(m_key, m_entry); } -std::vector<uint16_t> fs_oric_jasmin::impl::allocate_blocks(uint32_t count) +std::vector<u16> oric_jasmin_image::impl::allocate_blocks(u32 count) { - std::vector<uint16_t> blocks; + std::vector<u16> blocks; if(free_block_count() < count) return blocks; auto fmap = m_blockdev.get(20*17); - uint32_t nf = 0; - for(uint32_t track = 0; track != 2*41 && nf != count; track++) { - uint32_t map = fmap.r24l(track*3); + u32 nf = 0; + for(u32 track = 0; track != 2*41 && nf != count; track++) { + u32 map = fmap.r24l(track*3); if(map != 0x800000) { - for(uint32_t sect = 1; sect <= 17 && nf != count; sect++) + for(u32 sect = 1; sect <= 17 && nf != count; sect++) if(map & (0x20000 >> sect)) { blocks.push_back((track << 8) | sect); map &= ~(0x20000 >> sect); @@ -594,13 +596,13 @@ std::vector<uint16_t> fs_oric_jasmin::impl::allocate_blocks(uint32_t count) return blocks; } -void fs_oric_jasmin::impl::free_blocks(const std::vector<uint16_t> &blocks) +void oric_jasmin_image::impl::free_blocks(const std::vector<u16> &blocks) { auto fmap = m_blockdev.get(20*17); - for(uint16_t ref : blocks) { - uint32_t track = ref >> 8; - uint32_t sect = ref & 0xff; - uint32_t map = fmap.r24l(track*3); + for(u16 ref : blocks) { + u32 track = ref >> 8; + u32 sect = ref & 0xff; + u32 map = fmap.r24l(track*3); if(map == 0x800000) map = 0; map |= 0x20000 >> sect; @@ -608,17 +610,19 @@ void fs_oric_jasmin::impl::free_blocks(const std::vector<uint16_t> &blocks) } } -uint32_t fs_oric_jasmin::impl::free_block_count() +u32 oric_jasmin_image::impl::free_block_count() { auto fmap = m_blockdev.get(20*17); - uint32_t nf = 0; - for(uint32_t track = 0; track != 2*41; track++) { - uint32_t map = fmap.r24l(track*3); + u32 nf = 0; + for(u32 track = 0; track != 2*41; track++) { + u32 map = fmap.r24l(track*3); if(map != 0x800000) { - for(uint32_t sect = 1; sect <= 17; sect++) + for(u32 sect = 1; sect <= 17; sect++) if(map & (0x20000 >> sect)) nf++; } } return nf; } + +} // namespace fs diff --git a/src/lib/formats/fs_oric_jasmin.h b/src/lib/formats/fs_oric_jasmin.h index 4566e9ab301..70ac34bab47 100644 --- a/src/lib/formats/fs_oric_jasmin.h +++ b/src/lib/formats/fs_oric_jasmin.h @@ -10,7 +10,9 @@ #include "fsmgr.h" -class fs_oric_jasmin : public filesystem_manager_t { +namespace fs { + +class oric_jasmin_image : public manager_t { public: class impl : public filesystem_t { public: @@ -21,78 +23,78 @@ public: virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; - virtual std::vector<fs_dir_entry> contents() override; - virtual file_t file_get(uint64_t key) override; - virtual dir_t dir_get(uint64_t key) override; - virtual file_t file_create(const fs_meta_data &info) override; - virtual void file_delete(uint64_t key) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; + virtual std::vector<dir_entry> contents() override; + virtual file_t file_get(u64 key) override; + virtual dir_t dir_get(u64 key) override; + virtual file_t file_create(const meta_data &info) override; + virtual void file_delete(u64 key) override; - void update_file(uint16_t key, const uint8_t *entry); + void update_file(u16 key, const u8 *entry); private: impl &m_fs; - std::pair<fsblk_t::block_t, uint32_t> get_dir_block(uint64_t key); + std::pair<fsblk_t::block_t, u32> get_dir_block(u64 key); }; class file : public ifile_t { public: - file(impl &fs, root_dir *dir, const uint8_t *entry, uint16_t key); + file(impl &fs, root_dir *dir, const u8 *entry, u16 key); virtual ~file() = default; virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; - virtual std::vector<uint8_t> read_all() override; - virtual void replace(const std::vector<uint8_t> &data) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; + virtual std::vector<u8> read_all() override; + virtual void replace(const std::vector<u8> &data) override; private: impl &m_fs; root_dir *m_dir; - uint16_t m_key; - uint8_t m_entry[18]; + u16 m_key; + u8 m_entry[18]; }; class system_file : public ifile_t { public: - system_file(impl &fs, root_dir *dir, const uint8_t *entry, uint16_t key); + system_file(impl &fs, root_dir *dir, const u8 *entry, u16 key); virtual ~system_file() = default; virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; - virtual std::vector<uint8_t> read_all() override; - virtual void replace(const std::vector<uint8_t> &data) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; + virtual std::vector<u8> read_all() override; + virtual void replace(const std::vector<u8> &data) override; private: impl &m_fs; root_dir *m_dir; - uint16_t m_key; - uint8_t m_entry[18]; + u16 m_key; + u8 m_entry[18]; }; impl(fsblk_t &blockdev); virtual ~impl() = default; - virtual void format(const fs_meta_data &meta) override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; + virtual void format(const meta_data &meta) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; virtual dir_t root() override; - static uint32_t cs_to_block(uint16_t ref); - static uint16_t block_to_cs(uint32_t block); + static u32 cs_to_block(u16 ref); + static u16 block_to_cs(u32 block); - bool ref_valid(uint16_t ref); - static std::string read_file_name(const uint8_t *p); + bool ref_valid(u16 ref); + static std::string read_file_name(const u8 *p); void drop_root_ref(); - std::vector<uint16_t> allocate_blocks(uint32_t count); - void free_blocks(const std::vector<uint16_t> &blocks); - uint32_t free_block_count(); + std::vector<u16> allocate_blocks(u32 count); + void free_blocks(const std::vector<u16> &blocks); + u32 free_block_count(); static std::string file_name_prepare(std::string name); @@ -100,12 +102,12 @@ public: dir_t m_root; }; - fs_oric_jasmin() : filesystem_manager_t() {} + oric_jasmin_image() : manager_t() {} virtual const char *name() const override; virtual const char *description() const override; - virtual void enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override; + virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override; virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override; virtual bool can_format() const override; @@ -113,12 +115,14 @@ public: virtual bool can_write() const override; virtual bool has_rsrc() const override; - virtual std::vector<fs_meta_description> volume_meta_description() const override; - virtual std::vector<fs_meta_description> file_meta_description() const override; + virtual std::vector<meta_description> volume_meta_description() const override; + virtual std::vector<meta_description> file_meta_description() const override; static bool validate_filename(std::string name); }; -extern const fs_oric_jasmin FS_ORIC_JASMIN; +extern const oric_jasmin_image ORIC_JASMIN; + +} // namespace fs #endif diff --git a/src/lib/formats/fs_prodos.cpp b/src/lib/formats/fs_prodos.cpp index 56b624633a9..6abf335307f 100644 --- a/src/lib/formats/fs_prodos.cpp +++ b/src/lib/formats/fs_prodos.cpp @@ -11,19 +11,21 @@ #include <stdexcept> -const fs_prodos FS_PRODOS; +namespace fs { -const char *fs_prodos::name() const +const prodos_image PRODOS; + +const char *prodos_image::name() const { return "prodos"; } -const char *fs_prodos::description() const +const char *prodos_image::description() const { return "Apple ProDOS"; } -const uint8_t fs_prodos::impl::boot[512] = { +const u8 prodos_image::impl::boot[512] = { 0x01, 0x38, 0xb0, 0x03, 0x4c, 0x1c, 0x09, 0x78, 0x86, 0x43, 0xc9, 0x03, 0x08, 0x8a, 0x29, 0x70, 0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x85, 0x49, 0xa0, 0xff, 0x84, 0x48, 0x28, 0xc8, 0xb1, 0x48, 0xd0, 0x3a, 0xb0, 0x0e, 0xa9, 0x03, 0x8d, 0x00, 0x08, 0xe6, 0x3d, 0xa5, 0x49, 0x48, 0xa9, 0x5b, @@ -58,7 +60,7 @@ const uint8_t fs_prodos::impl::boot[512] = { 0xf0, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; -void fs_prodos::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const +void prodos_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) 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"); @@ -66,81 +68,81 @@ void fs_prodos::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const s fe.add(FLOPPY_APPLE_GCR_FORMAT, 409600, "prodos_400k", "Apple ProDOS 400K"); } -std::unique_ptr<filesystem_t> fs_prodos::mount(fsblk_t &blockdev) const +std::unique_ptr<filesystem_t> prodos_image::mount(fsblk_t &blockdev) const { return std::make_unique<impl>(blockdev); } -bool fs_prodos::can_format() const +bool prodos_image::can_format() const { return true; } -bool fs_prodos::can_read() const +bool prodos_image::can_read() const { return true; } -bool fs_prodos::can_write() const +bool prodos_image::can_write() const { return false; } -bool fs_prodos::has_rsrc() const +bool prodos_image::has_rsrc() const { return true; } -char fs_prodos::directory_separator() const +char prodos_image::directory_separator() const { return '/'; } -std::vector<fs_meta_description> fs_prodos::volume_meta_description() const +std::vector<meta_description> prodos_image::volume_meta_description() const { - std::vector<fs_meta_description> res; - res.emplace_back(fs_meta_description(fs_meta_name::name, fs_meta_type::string, "UNTITLED", false, [](const fs_meta &m) { return m.as_string().size() <= 15; }, "Volume name, up to 15 characters")); - res.emplace_back(fs_meta_description(fs_meta_name::os_version, fs_meta_type::number, 5, false, [](const fs_meta &m) { return m.as_number() <= 255; }, "Creator OS version")); - res.emplace_back(fs_meta_description(fs_meta_name::os_minimum_version, fs_meta_type::number, 5, false, [](const fs_meta &m) { return m.as_number() <= 255; }, "Minimum OS version")); + std::vector<meta_description> res; + res.emplace_back(meta_description(meta_name::name, meta_type::string, "UNTITLED", false, [](const meta_value &m) { return m.as_string().size() <= 15; }, "Volume name, up to 15 characters")); + res.emplace_back(meta_description(meta_name::os_version, meta_type::number, 5, false, [](const meta_value &m) { return m.as_number() <= 255; }, "Creator OS version")); + res.emplace_back(meta_description(meta_name::os_minimum_version, meta_type::number, 5, false, [](const meta_value &m) { return m.as_number() <= 255; }, "Minimum OS version")); auto now = util::arbitrary_datetime::now(); - res.emplace_back(fs_meta_description(fs_meta_name::creation_date, fs_meta_type::date, now, false, nullptr, "Creation time")); - res.emplace_back(fs_meta_description(fs_meta_name::modification_date, fs_meta_type::date, now, false, nullptr, "Modification time")); + res.emplace_back(meta_description(meta_name::creation_date, meta_type::date, now, false, nullptr, "Creation time")); + res.emplace_back(meta_description(meta_name::modification_date, meta_type::date, now, false, nullptr, "Modification time")); return res; } -std::vector<fs_meta_description> fs_prodos::file_meta_description() const +std::vector<meta_description> prodos_image::file_meta_description() const { - std::vector<fs_meta_description> res; - res.emplace_back(fs_meta_description(fs_meta_name::name, fs_meta_type::string, "Empty file", false, [](const fs_meta &m) { return m.as_string().size() <= 15; }, "File name, up to 15 characters")); - res.emplace_back(fs_meta_description(fs_meta_name::length, fs_meta_type::number, 0, true, nullptr, "Size of the file in bytes")); - res.emplace_back(fs_meta_description(fs_meta_name::rsrc_length, fs_meta_type::number, 0, true, nullptr, "Size of the resource fork in bytes")); - res.emplace_back(fs_meta_description(fs_meta_name::os_version, fs_meta_type::number, 5, false, [](const fs_meta &m) { return m.as_number() <= 255; }, "Creator OS version")); - res.emplace_back(fs_meta_description(fs_meta_name::os_minimum_version, fs_meta_type::number, 5, false, [](const fs_meta &m) { return m.as_number() <= 255; }, "Minimum OS version")); + std::vector<meta_description> res; + res.emplace_back(meta_description(meta_name::name, meta_type::string, "Empty file", false, [](const meta_value &m) { return m.as_string().size() <= 15; }, "File name, up to 15 characters")); + res.emplace_back(meta_description(meta_name::length, meta_type::number, 0, true, nullptr, "Size of the file in bytes")); + res.emplace_back(meta_description(meta_name::rsrc_length, meta_type::number, 0, true, nullptr, "Size of the resource fork in bytes")); + res.emplace_back(meta_description(meta_name::os_version, meta_type::number, 5, false, [](const meta_value &m) { return m.as_number() <= 255; }, "Creator OS version")); + res.emplace_back(meta_description(meta_name::os_minimum_version, meta_type::number, 5, false, [](const meta_value &m) { return m.as_number() <= 255; }, "Minimum OS version")); auto now = util::arbitrary_datetime::now(); - res.emplace_back(fs_meta_description(fs_meta_name::creation_date, fs_meta_type::date, now, false, nullptr, "Creation time")); - res.emplace_back(fs_meta_description(fs_meta_name::modification_date, fs_meta_type::date, now, false, nullptr, "Modification time")); + res.emplace_back(meta_description(meta_name::creation_date, meta_type::date, now, false, nullptr, "Creation time")); + res.emplace_back(meta_description(meta_name::modification_date, meta_type::date, now, false, nullptr, "Modification time")); return res; } -std::vector<fs_meta_description> fs_prodos::directory_meta_description() const +std::vector<meta_description> prodos_image::directory_meta_description() const { - std::vector<fs_meta_description> res; - res.emplace_back(fs_meta_description(fs_meta_name::name, fs_meta_type::string, "Empty directory", false, [](const fs_meta &m) { return m.as_string().size() <= 15; }, "Directory name, up to 15 characters")); - res.emplace_back(fs_meta_description(fs_meta_name::os_version, fs_meta_type::number, 5, false, [](const fs_meta &m) { return m.as_number() <= 255; }, "Creator OS version")); - res.emplace_back(fs_meta_description(fs_meta_name::os_minimum_version, fs_meta_type::number, 5, false, [](const fs_meta &m) { return m.as_number() <= 255; }, "Minimum OS version")); + std::vector<meta_description> res; + res.emplace_back(meta_description(meta_name::name, meta_type::string, "Empty directory", false, [](const meta_value &m) { return m.as_string().size() <= 15; }, "Directory name, up to 15 characters")); + res.emplace_back(meta_description(meta_name::os_version, meta_type::number, 5, false, [](const meta_value &m) { return m.as_number() <= 255; }, "Creator OS version")); + res.emplace_back(meta_description(meta_name::os_minimum_version, meta_type::number, 5, false, [](const meta_value &m) { return m.as_number() <= 255; }, "Minimum OS version")); auto now = util::arbitrary_datetime::now(); - res.emplace_back(fs_meta_description(fs_meta_name::creation_date, fs_meta_type::date, now, false, nullptr, "Creation time")); - res.emplace_back(fs_meta_description(fs_meta_name::modification_date, fs_meta_type::date, now, false, nullptr, "Modification time")); + res.emplace_back(meta_description(meta_name::creation_date, meta_type::date, now, false, nullptr, "Creation time")); + res.emplace_back(meta_description(meta_name::modification_date, meta_type::date, now, false, nullptr, "Modification time")); return res; } -void fs_prodos::impl::format(const fs_meta_data &meta) +void prodos_image::impl::format(const meta_data &meta) { - std::string volume_name = meta.get_string(fs_meta_name::name, "UNTITLED"); - uint32_t blocks = m_blockdev.block_count(); + std::string volume_name = meta.get_string(meta_name::name, "UNTITLED"); + u32 blocks = m_blockdev.block_count(); // Maximum usable partition size = 32M - 512 bytes (65535 blocks) if(blocks >= 0x10000) @@ -177,20 +179,20 @@ void fs_prodos::impl::format(const fs_meta_data &meta) kblk4.w16l(0x00, 0x0004); // Backwards block pointer of the fourth volume block kblk4.w16l(0x02, 0x0000); // Forwards block pointer of the fourth volume block (null) - uint32_t fmap_block_count = (blocks + 4095) / 4096; - uint32_t first_free_block = 6 + fmap_block_count; + u32 fmap_block_count = (blocks + 4095) / 4096; + u32 first_free_block = 6 + fmap_block_count; // Mark blocks from first_free_block to blocks-1 (the last one) as free - for(uint32_t i = 0; i != fmap_block_count; i++) { + for(u32 i = 0; i != fmap_block_count; i++) { auto fmap = m_blockdev.get(6 + i); - uint8_t *fdata = fmap.data(); - uint32_t start = i ? 0 : first_free_block; - uint32_t end = i != fmap_block_count - 1 ? 4095 : (blocks - 1) & 4095; + u8 *fdata = fmap.data(); + u32 start = i ? 0 : first_free_block; + u32 end = i != fmap_block_count - 1 ? 4095 : (blocks - 1) & 4095; end += 1; - uint32_t sb = start >> 3; - uint32_t si = start & 7; - uint32_t eb = end >> 3; - uint32_t ei = end & 7; + u32 sb = start >> 3; + u32 si = start & 7; + u32 eb = end >> 3; + u32 ei = end & 7; if(sb == eb) fdata[sb] = (0xff >> si) & ~(0xff >> ei); else { @@ -203,11 +205,11 @@ void fs_prodos::impl::format(const fs_meta_data &meta) } } -fs_prodos::impl::impl(fsblk_t &blockdev) : filesystem_t(blockdev, 512), m_root(true) +prodos_image::impl::impl(fsblk_t &blockdev) : filesystem_t(blockdev, 512), m_root(true) { } -util::arbitrary_datetime fs_prodos::impl::prodos_to_dt(uint32_t date) +util::arbitrary_datetime prodos_image::impl::prodos_to_dt(u32 date) { util::arbitrary_datetime dt; dt.second = 0; @@ -222,60 +224,60 @@ util::arbitrary_datetime fs_prodos::impl::prodos_to_dt(uint32_t date) return dt; } -fs_meta_data fs_prodos::impl::metadata() +meta_data prodos_image::impl::metadata() { - fs_meta_data res; + meta_data res; auto bdir = m_blockdev.get(2); int len = bdir.r8(0x04) & 0xf; - res.set(fs_meta_name::name, bdir.rstr(0x05, len)); - res.set(fs_meta_name::os_version, bdir.r8(0x20)); - res.set(fs_meta_name::os_minimum_version, bdir.r8(0x21)); - res.set(fs_meta_name::creation_date, prodos_to_dt(bdir.r32l(0x1c))); - res.set(fs_meta_name::modification_date, prodos_to_dt(bdir.r32l(0x16))); + res.set(meta_name::name, bdir.rstr(0x05, len)); + res.set(meta_name::os_version, bdir.r8(0x20)); + res.set(meta_name::os_minimum_version, bdir.r8(0x21)); + res.set(meta_name::creation_date, prodos_to_dt(bdir.r32l(0x1c))); + res.set(meta_name::modification_date, prodos_to_dt(bdir.r32l(0x16))); return res; } -filesystem_t::dir_t fs_prodos::impl::root() +filesystem_t::dir_t prodos_image::impl::root() { if(!m_root) m_root = new root_dir(*this, 2); return m_root.strong(); } -void fs_prodos::impl::drop_root_ref() +void prodos_image::impl::drop_root_ref() { m_root = nullptr; } -void fs_prodos::impl::root_dir::drop_weak_references() +void prodos_image::impl::root_dir::drop_weak_references() { if(m_base_block == 2) m_fs.drop_root_ref(); } -fs_meta_data fs_prodos::impl::root_dir::metadata() +meta_data prodos_image::impl::root_dir::metadata() { - return fs_meta_data(); + return meta_data(); } -std::vector<fs_dir_entry> fs_prodos::impl::root_dir::contents() +std::vector<dir_entry> prodos_image::impl::root_dir::contents() { - std::vector<fs_dir_entry> res; + std::vector<dir_entry> res; - uint16_t block = m_base_block; - uint32_t off = 39 + 4; - uint32_t id = 1; + u16 block = m_base_block; + u32 off = 39 + 4; + u32 id = 1; do { auto blk = m_fs.m_blockdev.get(block); while(off < 511) { - uint8_t type = blk.r8(off); + u8 type = blk.r8(off); auto name = blk.rstr(off+1, type & 0xf); type >>= 4; if(type == 0xd) - res.emplace_back(fs_dir_entry(name, fs_dir_entry_type::dir, id)); + res.emplace_back(dir_entry(name, dir_entry_type::dir, id)); else if(type != 0) - res.emplace_back(fs_dir_entry(name, fs_dir_entry_type::file, id)); + res.emplace_back(dir_entry(name, dir_entry_type::file, id)); off += 39; id ++; } @@ -288,13 +290,13 @@ std::vector<fs_dir_entry> fs_prodos::impl::root_dir::contents() } -std::pair<fsblk_t::block_t, const uint8_t *> fs_prodos::impl::root_dir::get_entry_ro(uint64_t key) +std::pair<fsblk_t::block_t, const u8 *> prodos_image::impl::root_dir::get_entry_ro(u64 key) { - std::pair<fsblk_t::block_t, const uint8_t *> res; + std::pair<fsblk_t::block_t, const u8 *> res; res.first = m_fs.m_blockdev.get(m_base_block); while(key >= 13) { key -= 13; - uint16_t block = res.first.r16l(2); + u16 block = res.first.r16l(2); if(!block || block >= m_fs.m_blockdev.block_count()) { res.first = nullptr; res.second = nullptr; @@ -306,13 +308,13 @@ std::pair<fsblk_t::block_t, const uint8_t *> fs_prodos::impl::root_dir::get_entr return res; } -std::pair<fsblk_t::block_t, uint8_t *> fs_prodos::impl::root_dir::get_entry(uint64_t key) +std::pair<fsblk_t::block_t, u8 *> prodos_image::impl::root_dir::get_entry(u64 key) { - std::pair<fsblk_t::block_t, uint8_t *> res; + std::pair<fsblk_t::block_t, u8 *> res; res.first = m_fs.m_blockdev.get(m_base_block); while(key > 13) { key -= 13; - uint16_t block = res.first.r16l(2); + u16 block = res.first.r16l(2); if(!block || block >= m_fs.m_blockdev.block_count()) { res.first = nullptr; res.second = nullptr; @@ -324,87 +326,87 @@ std::pair<fsblk_t::block_t, uint8_t *> fs_prodos::impl::root_dir::get_entry(uint return res; } -filesystem_t::file_t fs_prodos::impl::root_dir::file_get(uint64_t key) +filesystem_t::file_t prodos_image::impl::root_dir::file_get(u64 key) { auto [blk, entry] = get_entry_ro(key); if(!blk) throw std::out_of_range("Out-of-range key on file_get"); - uint8_t type = entry[0] >> 4; + u8 type = entry[0] >> 4; if(type == 0 || type == 4 || type > 5) throw std::runtime_error(util::string_format("Unhandled file type %x", type)); return new file(m_fs, entry, key, this); } -filesystem_t::dir_t fs_prodos::impl::root_dir::dir_get(uint64_t key) +filesystem_t::dir_t prodos_image::impl::root_dir::dir_get(u64 key) { auto [blk, entry] = get_entry_ro(key); if(!blk) throw std::out_of_range("Out-of-range key on dir_get"); - uint8_t type = entry[0] >> 4; + u8 type = entry[0] >> 4; if(type != 0xd) throw std::runtime_error(util::string_format("Unhandled directory type %x", type)); return new dir(m_fs, entry, r16l(entry+0x11), key, this); } -fs_prodos::impl::dir::dir(impl &fs, const uint8_t *entry, uint16_t base_block, uint16_t key, root_dir *parent_dir) : root_dir(fs, base_block), m_parent_dir(parent_dir), m_key(key) +prodos_image::impl::dir::dir(impl &fs, const u8 *entry, u16 base_block, u16 key, root_dir *parent_dir) : root_dir(fs, base_block), m_parent_dir(parent_dir), m_key(key) { memcpy(m_entry, entry, 39); (void)m_key; (void)m_parent_dir; } -fs_prodos::impl::file::file(impl &fs, const uint8_t *entry, uint16_t key, root_dir *parent_dir) : m_fs(fs), m_parent_dir(parent_dir), m_key(key) +prodos_image::impl::file::file(impl &fs, const u8 *entry, u16 key, root_dir *parent_dir) : m_fs(fs), m_parent_dir(parent_dir), m_key(key) { memcpy(m_entry, entry, 39); (void)m_key; (void)m_parent_dir; } -void fs_prodos::impl::file::drop_weak_references() +void prodos_image::impl::file::drop_weak_references() { } -fs_meta_data fs_prodos::impl::file::metadata() +meta_data prodos_image::impl::file::metadata() { - fs_meta_data res; - uint8_t type = r8(m_entry); + meta_data res; + u8 type = r8(m_entry); std::string name = rstr(m_entry+1, type & 0xf); type >>= 4; - res.set(fs_meta_name::name, name); + res.set(meta_name::name, name); if(type == 5) { auto rootblk = m_fs.m_blockdev.get(r16l(m_entry+0x11)); - res.set(fs_meta_name::length, rootblk.r24l(0x005)); - res.set(fs_meta_name::rsrc_length, rootblk.r24l(0x105)); + res.set(meta_name::length, rootblk.r24l(0x005)); + res.set(meta_name::rsrc_length, rootblk.r24l(0x105)); } else if(type >= 1 && type <= 3) - res.set(fs_meta_name::length, r24l(m_entry + 0x15)); + res.set(meta_name::length, r24l(m_entry + 0x15)); else - throw std::runtime_error(util::string_format("fs_prodos::impl::file::metadata: Unhandled file type %d", type)); + throw std::runtime_error(util::string_format("prodos_image::impl::file::metadata: Unhandled file type %d", type)); return res; } -fs_meta_data fs_prodos::impl::dir::metadata() +meta_data prodos_image::impl::dir::metadata() { - fs_meta_data res; - uint8_t type = r8(m_entry); + meta_data res; + u8 type = r8(m_entry); std::string name = rstr(m_entry+1, type & 0xf); - res.set(fs_meta_name::name, name); + res.set(meta_name::name, name); return res; } -std::vector<uint8_t> fs_prodos::impl::file::any_read_all(uint8_t type, uint16_t block, uint32_t length) +std::vector<u8> prodos_image::impl::file::any_read_all(u8 type, u16 block, u32 length) { - std::vector<uint8_t> data((length + 511) & ~511); - uint32_t nb = data.size()/512; + std::vector<u8> data((length + 511) & ~511); + u32 nb = data.size()/512; if(!nb) return data; - uint8_t *dst = data.data(); - uint8_t *end = dst + data.size(); + u8 *dst = data.data(); + u8 *end = dst + data.size(); switch(type) { case 1: memcpy(dst, m_fs.m_blockdev.get(block).rodata(), 512); @@ -413,8 +415,8 @@ std::vector<uint8_t> fs_prodos::impl::file::any_read_all(uint8_t type, uint16_t case 2: { auto iblk = m_fs.m_blockdev.get(block); - for(uint32_t i=0; i != 256 && dst != end; i++) { - uint16_t blk = iblk.r8(i) | (iblk.r8(i | 0x100) << 8); + for(u32 i=0; i != 256 && dst != end; i++) { + u16 blk = iblk.r8(i) | (iblk.r8(i | 0x100) << 8); memcpy(dst, m_fs.m_blockdev.get(blk).rodata(), 512); dst += 512; } @@ -423,11 +425,11 @@ std::vector<uint8_t> fs_prodos::impl::file::any_read_all(uint8_t type, uint16_t case 3: { auto mblk = m_fs.m_blockdev.get(block); - for(uint32_t j=0; dst != end; j += 256) { - uint32_t idx = j/256; + for(u32 j=0; dst != end; j += 256) { + u32 idx = j/256; auto iblk = m_fs.m_blockdev.get(mblk.r8(idx) | (mblk.r8(idx | 0x100) << 8)); - for(uint32_t i=0; i != 256 && dst != end; i++) { - uint16_t blk = iblk.r8(i) | (iblk.r8(i | 0x100) << 8); + for(u32 i=0; i != 256 && dst != end; i++) { + u16 blk = iblk.r8(i) | (iblk.r8(i | 0x100) << 8); memcpy(dst, m_fs.m_blockdev.get(blk).rodata(), 512); dst += 512; } @@ -436,16 +438,16 @@ std::vector<uint8_t> fs_prodos::impl::file::any_read_all(uint8_t type, uint16_t } default: - throw std::runtime_error(util::string_format("fs_prodos::impl::file::get_file_blocks: unknown file type %d", type)); + throw std::runtime_error(util::string_format("prodos_image::impl::file::get_file_blocks: unknown file type %d", type)); } data.resize(length); return data; } -std::vector<uint8_t> fs_prodos::impl::file::read_all() +std::vector<u8> prodos_image::impl::file::read_all() { - uint8_t type = r8(m_entry) >> 4; + u8 type = r8(m_entry) >> 4; if(type >= 1 && type <= 3) return any_read_all(type, r16l(m_entry+0x11), r24l(m_entry + 0x15)); @@ -454,17 +456,19 @@ std::vector<uint8_t> fs_prodos::impl::file::read_all() return any_read_all(kblk.r8(0x000), kblk.r16l(0x001), kblk.r24l(0x005)); } else - throw std::runtime_error(util::string_format("fs_prodos::impl::file::read_all: Unhandled file type %d", type)); + throw std::runtime_error(util::string_format("prodos_image::impl::file::read_all: Unhandled file type %d", type)); } -std::vector<uint8_t> fs_prodos::impl::file::rsrc_read_all() +std::vector<u8> prodos_image::impl::file::rsrc_read_all() { - uint8_t type = r8(m_entry) >> 4; + u8 type = r8(m_entry) >> 4; if(type == 5) { auto kblk = m_fs.m_blockdev.get(r16l(m_entry+0x11)); return any_read_all(kblk.r8(0x100), kblk.r16l(0x101), kblk.r24l(0x105)); } else - throw std::runtime_error(util::string_format("fs_prodos::impl::file::rsrc_blocks: Unhandled file type %d", type)); + throw std::runtime_error(util::string_format("prodos_image::impl::file::rsrc_blocks: Unhandled file type %d", type)); } + +} // namespace fs diff --git a/src/lib/formats/fs_prodos.h b/src/lib/formats/fs_prodos.h index da0857514c2..f4c53be48cf 100644 --- a/src/lib/formats/fs_prodos.h +++ b/src/lib/formats/fs_prodos.h @@ -10,88 +10,90 @@ #include "fsmgr.h" -class fs_prodos : public filesystem_manager_t { +namespace fs { + +class prodos_image : public manager_t { public: class impl : public filesystem_t { public: class root_dir : public idir_t { public: - root_dir(impl &fs, uint16_t base_block) : m_fs(fs), m_base_block(base_block) { } + root_dir(impl &fs, u16 base_block) : m_fs(fs), m_base_block(base_block) { } virtual ~root_dir() = default; virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual std::vector<fs_dir_entry> contents() override; - virtual file_t file_get(uint64_t key) override; - virtual dir_t dir_get(uint64_t key) override; + virtual meta_data metadata() override; + virtual std::vector<dir_entry> contents() override; + virtual file_t file_get(u64 key) override; + virtual dir_t dir_get(u64 key) override; protected: impl &m_fs; - uint16_t m_base_block; + u16 m_base_block; - std::pair<fsblk_t::block_t, const uint8_t *> get_entry_ro(uint64_t key); - std::pair<fsblk_t::block_t, uint8_t *> get_entry(uint64_t key); + std::pair<fsblk_t::block_t, const u8 *> get_entry_ro(u64 key); + std::pair<fsblk_t::block_t, u8 *> get_entry(u64 key); }; class dir : public root_dir { public: - dir(impl &fs, const uint8_t *entry, uint16_t base_block, uint16_t key, root_dir *parent_dir); + dir(impl &fs, const u8 *entry, u16 base_block, u16 key, root_dir *parent_dir); virtual ~dir() = default; - virtual fs_meta_data metadata() override; + virtual meta_data metadata() override; protected: root_dir *m_parent_dir; - uint16_t m_key; - uint8_t m_entry[39]; + u16 m_key; + u8 m_entry[39]; }; class file : public ifile_t { public: - file(impl &fs, const uint8_t *entry, uint16_t key, root_dir *parent_dir); + file(impl &fs, const u8 *entry, u16 key, root_dir *parent_dir); virtual ~file() = default; virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual std::vector<uint8_t> read_all() override; - virtual std::vector<uint8_t> rsrc_read_all() override; + virtual meta_data metadata() override; + virtual std::vector<u8> read_all() override; + virtual std::vector<u8> rsrc_read_all() override; private: impl &m_fs; root_dir *m_parent_dir; - uint16_t m_key; - uint8_t m_entry[39]; + u16 m_key; + u8 m_entry[39]; - std::vector<uint8_t> any_read_all(uint8_t type, uint16_t block, uint32_t length); + std::vector<u8> any_read_all(u8 type, u16 block, u32 length); }; impl(fsblk_t &blockdev); virtual ~impl() = default; - virtual void format(const fs_meta_data &meta) override; + virtual void format(const meta_data &meta) override; - virtual fs_meta_data metadata() override; + virtual meta_data metadata() override; virtual dir_t root() override; void drop_root_ref(); - static util::arbitrary_datetime prodos_to_dt(uint32_t date); - std::vector<fs_dir_entry> contents(uint16_t block); + static util::arbitrary_datetime prodos_to_dt(u32 date); + std::vector<dir_entry> contents(u16 block); private: - static const uint8_t boot[512]; + static const u8 boot[512]; dir_t m_root; }; - fs_prodos() : filesystem_manager_t() {} + prodos_image() : manager_t() {} virtual const char *name() const override; virtual const char *description() const override; - virtual void enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override; + virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override; virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override; virtual bool can_format() const override; @@ -100,11 +102,13 @@ public: virtual bool has_rsrc() const override; virtual char directory_separator() const override; - virtual std::vector<fs_meta_description> volume_meta_description() const override; - virtual std::vector<fs_meta_description> file_meta_description() const override; - virtual std::vector<fs_meta_description> directory_meta_description() const override; + virtual std::vector<meta_description> volume_meta_description() const override; + virtual std::vector<meta_description> file_meta_description() const override; + virtual std::vector<meta_description> directory_meta_description() const override; }; -extern const fs_prodos FS_PRODOS; +extern const prodos_image PRODOS; + +} // namespace fs #endif diff --git a/src/lib/formats/fs_unformatted.cpp b/src/lib/formats/fs_unformatted.cpp index ce68a5e344f..df0bbccecd4 100644 --- a/src/lib/formats/fs_unformatted.cpp +++ b/src/lib/formats/fs_unformatted.cpp @@ -5,22 +5,22 @@ #include "fs_unformatted.h" -const fs_unformatted FS_UNFORMATTED; +namespace fs { -const char *fs_unformatted::name() const +const unformatted_image UNFORMATTED; + +const char *unformatted_image::name() const { return "unformatted"; } -const char *fs_unformatted::description() const +const char *unformatted_image::description() const { return "Unformatted floppy image"; } -void fs_unformatted::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const +void unformatted_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const { - using u32 = std::uint32_t; - bool all = form_factor == floppy_image::FF_UNKNOWN; u32 best_8 = form_factor == floppy_image::FF_8 ? @@ -84,7 +84,7 @@ void fs_unformatted::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, co fe.add_raw("u3ssdd", FSI_35_SSDD, "Unformatted 3\" single-sided double-density"); } -void fs_unformatted::format(uint32_t key, floppy_image *image) +void unformatted_image::format(u32 key, floppy_image *image) { switch(key) { case FSI_8_DSDD: image->set_form_variant(floppy_image::FF_8, floppy_image::DSDD); break; @@ -109,27 +109,29 @@ void fs_unformatted::format(uint32_t key, floppy_image *image) } } -std::unique_ptr<filesystem_t> fs_unformatted::mount(fsblk_t &blockdev) const +std::unique_ptr<filesystem_t> unformatted_image::mount(fsblk_t &blockdev) const { return nullptr; } -bool fs_unformatted::can_format() const +bool unformatted_image::can_format() const { return false; } -bool fs_unformatted::can_read() const +bool unformatted_image::can_read() const { return false; } -bool fs_unformatted::can_write() const +bool unformatted_image::can_write() const { return false; } -bool fs_unformatted::has_rsrc() const +bool unformatted_image::has_rsrc() const { return false; } + +} // namespace fs diff --git a/src/lib/formats/fs_unformatted.h b/src/lib/formats/fs_unformatted.h index c73ef1d8583..8186ac1cdac 100644 --- a/src/lib/formats/fs_unformatted.h +++ b/src/lib/formats/fs_unformatted.h @@ -10,7 +10,9 @@ #include "fsmgr.h" -class fs_unformatted : public filesystem_manager_t { +namespace fs { + +class unformatted_image : public manager_t { public: enum { FSI_NONE, @@ -36,14 +38,14 @@ public: FSI_3_SSDD, }; - fs_unformatted() : filesystem_manager_t() {} + unformatted_image() : manager_t() {} virtual const char *name() const override; virtual const char *description() const override; - static void format(uint32_t key, floppy_image *image); + static void format(u32 key, floppy_image *image); - virtual void enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override; + virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override; virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override; virtual bool can_format() const override; @@ -52,6 +54,8 @@ public: virtual bool has_rsrc() const override; }; -extern const fs_unformatted FS_UNFORMATTED; +extern const unformatted_image UNFORMATTED; + +} // namespace fs #endif diff --git a/src/lib/formats/fs_vtech.cpp b/src/lib/formats/fs_vtech.cpp index b68b69a9599..8c6a4e94f82 100644 --- a/src/lib/formats/fs_vtech.cpp +++ b/src/lib/formats/fs_vtech.cpp @@ -8,7 +8,9 @@ #include <stdexcept> -const fs_vtech FS_VTECH; +namespace fs { + +const vtech_image VTECH; // Floppy only, format is 40 tracks, 1 head, 16 sectors numbered 0-15, 256 bytes/sector. // Filesystem has no subdirectories. @@ -25,124 +27,124 @@ const fs_vtech FS_VTECH; // Files are stored with 126 bytes/sector, and bytes 126 and 127 are // track/sector of the next file data sector. -const char *fs_vtech::name() const +const char *vtech_image::name() const { return "vtech"; } -const char *fs_vtech::description() const +const char *vtech_image::description() const { return "VTech (Laser 200/300)"; } -void fs_vtech::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const +void vtech_image::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const { if(has(form_factor, variants, floppy_image::FF_525, floppy_image::SSSD)) fe.add(FLOPPY_VTECH_BIN_FORMAT, 163840, "vtech", "VTech"); } -std::unique_ptr<filesystem_t> fs_vtech::mount(fsblk_t &blockdev) const +std::unique_ptr<filesystem_t> vtech_image::mount(fsblk_t &blockdev) const { return std::make_unique<impl>(blockdev); } -bool fs_vtech::can_format() const +bool vtech_image::can_format() const { return true; } -bool fs_vtech::can_read() const +bool vtech_image::can_read() const { return true; } -bool fs_vtech::can_write() const +bool vtech_image::can_write() const { return true; } -bool fs_vtech::has_rsrc() const +bool vtech_image::has_rsrc() const { return false; } -std::vector<fs_meta_description> fs_vtech::volume_meta_description() const +std::vector<meta_description> vtech_image::volume_meta_description() const { - std::vector<fs_meta_description> res; + std::vector<meta_description> res; return res; } -fs_meta_data fs_vtech::impl::metadata() +meta_data vtech_image::impl::metadata() { - fs_meta_data res; + meta_data res; return res; } -std::vector<fs_meta_description> fs_vtech::file_meta_description() const +std::vector<meta_description> vtech_image::file_meta_description() const { - std::vector<fs_meta_description> res; - res.emplace_back(fs_meta_description(fs_meta_name::name, fs_meta_type::string, "", false, [](const fs_meta &m) { return m.as_string().size() <= 8; }, "File name, 8 chars")); - res.emplace_back(fs_meta_description(fs_meta_name::loading_address, fs_meta_type::number, 0x7ae9, false, [](const fs_meta &m) { return m.as_number() < 0x10000; }, "Loading address of the file")); - res.emplace_back(fs_meta_description(fs_meta_name::length, fs_meta_type::number, 0, true, nullptr, "Size of the file in bytes")); - res.emplace_back(fs_meta_description(fs_meta_name::basic, fs_meta_type::flag, true, true, nullptr, "Basic file")); + std::vector<meta_description> res; + res.emplace_back(meta_description(meta_name::name, meta_type::string, "", false, [](const meta_value &m) { return m.as_string().size() <= 8; }, "File name, 8 chars")); + res.emplace_back(meta_description(meta_name::loading_address, meta_type::number, 0x7ae9, false, [](const meta_value &m) { return m.as_number() < 0x10000; }, "Loading address of the file")); + res.emplace_back(meta_description(meta_name::length, meta_type::number, 0, true, nullptr, "Size of the file in bytes")); + res.emplace_back(meta_description(meta_name::basic, meta_type::flag, true, true, nullptr, "Basic file")); return res; } -void fs_vtech::impl::format(const fs_meta_data &meta) +void vtech_image::impl::format(const meta_data &meta) { m_blockdev.fill(0); } -fs_vtech::impl::impl(fsblk_t &blockdev) : filesystem_t(blockdev, 128), m_root(true) +vtech_image::impl::impl(fsblk_t &blockdev) : filesystem_t(blockdev, 128), m_root(true) { } -filesystem_t::dir_t fs_vtech::impl::root() +filesystem_t::dir_t vtech_image::impl::root() { if(!m_root) m_root = new root_dir(*this); return m_root.strong(); } -void fs_vtech::impl::drop_root_ref() +void vtech_image::impl::drop_root_ref() { m_root = nullptr; } -void fs_vtech::impl::root_dir::drop_weak_references() +void vtech_image::impl::root_dir::drop_weak_references() { m_fs.drop_root_ref(); } -fs_meta_data fs_vtech::impl::root_dir::metadata() +meta_data vtech_image::impl::root_dir::metadata() { - return fs_meta_data(); + return meta_data(); } -std::vector<fs_dir_entry> fs_vtech::impl::root_dir::contents() +std::vector<dir_entry> vtech_image::impl::root_dir::contents() { - std::vector<fs_dir_entry> res; + std::vector<dir_entry> res; - uint64_t id = 0; + u64 id = 0; for(int sect = 0; sect != 14; sect++) { auto bdir = m_fs.m_blockdev.get(sect); - for(uint32_t i = 0; i != 8; i ++) { - uint32_t off = i*16; - uint8_t type = bdir.r8(off); + for(u32 i = 0; i != 8; i ++) { + u32 off = i*16; + u8 type = bdir.r8(off); if(type != 'T' && type != 'B') continue; if(bdir.r8(off+1) != ':') continue; std::string fname = trim_end_spaces(bdir.rstr(off+2, 8)); - res.emplace_back(fs_dir_entry(fname, fs_dir_entry_type::file, id)); + res.emplace_back(dir_entry(fname, dir_entry_type::file, id)); id++; } } return res; } -filesystem_t::file_t fs_vtech::impl::root_dir::file_get(uint64_t key) +filesystem_t::file_t vtech_image::impl::root_dir::file_get(u64 key) { if(key >= 15*8) throw std::out_of_range("Key out of range"); @@ -152,46 +154,46 @@ filesystem_t::file_t fs_vtech::impl::root_dir::file_get(uint64_t key) return file_t(new file(m_fs, this, bdir.rodata() + off, key)); } -void fs_vtech::impl::root_dir::update_file(uint16_t key, const uint8_t *entry) +void vtech_image::impl::root_dir::update_file(u16 key, const u8 *entry) { auto bdir = m_fs.m_blockdev.get(key >> 3); int off = (key & 7) << 4; bdir.copy(off, entry, 16); } -filesystem_t::dir_t fs_vtech::impl::root_dir::dir_get(uint64_t key) +filesystem_t::dir_t vtech_image::impl::root_dir::dir_get(u64 key) { throw std::logic_error("Directories not supported"); } -fs_vtech::impl::file::file(impl &fs, root_dir *dir, const uint8_t *entry, uint16_t key) : m_fs(fs), m_dir(dir), m_key(key) +vtech_image::impl::file::file(impl &fs, root_dir *dir, const u8 *entry, u16 key) : m_fs(fs), m_dir(dir), m_key(key) { memcpy(m_entry, entry, 16); } -void fs_vtech::impl::file::drop_weak_references() +void vtech_image::impl::file::drop_weak_references() { } -fs_meta_data fs_vtech::impl::file::metadata() +meta_data vtech_image::impl::file::metadata() { - fs_meta_data res; + meta_data res; - res.set(fs_meta_name::name, trim_end_spaces(rstr(m_entry+2, 8))); - res.set(fs_meta_name::basic, m_entry[0] == 'T'); - res.set(fs_meta_name::loading_address, r16l(m_entry + 0xc)); - res.set(fs_meta_name::length, ((r16l(m_entry + 0xe) - r16l(m_entry + 0xc) + 1) & 0xffff)); + res.set(meta_name::name, trim_end_spaces(rstr(m_entry+2, 8))); + res.set(meta_name::basic, m_entry[0] == 'T'); + res.set(meta_name::loading_address, r16l(m_entry + 0xc)); + res.set(meta_name::length, ((r16l(m_entry + 0xe) - r16l(m_entry + 0xc) + 1) & 0xffff)); return res; } -std::vector<uint8_t> fs_vtech::impl::file::read_all() +std::vector<u8> vtech_image::impl::file::read_all() { - uint8_t track = m_entry[0xa]; - uint8_t sector = m_entry[0xb]; + u8 track = m_entry[0xa]; + u8 sector = m_entry[0xb]; int len = ((r16l(m_entry + 0xe) - r16l(m_entry + 0xc)) & 0xffff) + 1; - std::vector<uint8_t> data(len, 0); + std::vector<u8> data(len, 0); int pos = 0; while(pos < len) { if(track >= 40 || sector >= 16) @@ -208,25 +210,25 @@ std::vector<uint8_t> fs_vtech::impl::file::read_all() return data; } -fs_vtech::impl::file_t fs_vtech::impl::root_dir::file_create(const fs_meta_data &info) +vtech_image::impl::file_t vtech_image::impl::root_dir::file_create(const meta_data &info) { // Find the key for the next unused entry for(int sect = 0; sect != 14; sect++) { auto bdir = m_fs.m_blockdev.get(sect); - uint64_t id = 0; - for(uint32_t i = 0; i != 16; i ++) { - uint32_t off = i*16; - uint8_t type = bdir.r8(off); + u64 id = 0; + for(u32 i = 0; i != 16; i ++) { + u32 off = i*16; + u8 type = bdir.r8(off); if(type != 'T' && type != 'B') { - std::string fname = info.get_string(fs_meta_name::name, ""); + std::string fname = info.get_string(meta_name::name, ""); fname.resize(8, ' '); - bdir.w8 (off+0x0, info.get_flag(fs_meta_name::basic, true) ? 'T' : 'B'); + bdir.w8 (off+0x0, info.get_flag(meta_name::basic, true) ? 'T' : 'B'); bdir.w8 (off+0x1, ':'); bdir.wstr(off+0x2, fname); bdir.w8 (off+0xa, 0x00); bdir.w8 (off+0xb, 0x00); - bdir.w16l(off+0xc, info.get_number(fs_meta_name::loading_address, 0x7ae9)); + bdir.w16l(off+0xc, info.get_number(meta_name::loading_address, 0x7ae9)); bdir.w16l(off+0xe, bdir.r16l(off+0xc) - 1); // Size 0 initially return file_t(new file(m_fs, this, bdir.rodata() + off, id)); } @@ -236,27 +238,27 @@ fs_vtech::impl::file_t fs_vtech::impl::root_dir::file_create(const fs_meta_data return nullptr; } -void fs_vtech::impl::root_dir::file_delete(uint64_t key) +void vtech_image::impl::root_dir::file_delete(u64 key) { } -void fs_vtech::impl::file::replace(const std::vector<uint8_t> &data) +void vtech_image::impl::file::replace(const std::vector<u8> &data) { - uint32_t cur_len = ((r16l(m_entry + 0xe) - r16l(m_entry + 0xc) + 1) & 0xffff); - uint32_t new_len = data.size(); + u32 cur_len = ((r16l(m_entry + 0xe) - r16l(m_entry + 0xc) + 1) & 0xffff); + u32 new_len = data.size(); if(new_len > 65535) new_len = 65535; - uint32_t cur_ns = (cur_len + 125)/126; - uint32_t need_ns = (new_len + 125) / 126; + u32 cur_ns = (cur_len + 125)/126; + u32 need_ns = (new_len + 125) / 126; // Enough space? if(cur_ns < need_ns && m_fs.free_block_count() < need_ns - cur_ns) return; - uint8_t track = m_entry[0xa]; - uint8_t sector = m_entry[0xb]; - std::vector<std::pair<uint8_t, uint8_t>> tofree; - for(uint32_t i = 0; i != cur_ns; i++) { + u8 track = m_entry[0xa]; + u8 sector = m_entry[0xb]; + std::vector<std::pair<u8, u8>> tofree; + for(u32 i = 0; i != cur_ns; i++) { tofree.emplace_back(std::make_pair(track, sector)); auto dblk = m_fs.m_blockdev.get(track*16 + sector); track = dblk.r8(126); @@ -265,10 +267,10 @@ void fs_vtech::impl::file::replace(const std::vector<uint8_t> &data) m_fs.free_blocks(tofree); - std::vector<std::pair<uint8_t, uint8_t>> blocks = m_fs.allocate_blocks(need_ns); - for(uint32_t i=0; i != need_ns; i ++) { + std::vector<std::pair<u8, u8>> blocks = m_fs.allocate_blocks(need_ns); + for(u32 i=0; i != need_ns; i ++) { auto dblk = m_fs.m_blockdev.get(blocks[i].first * 16 + blocks[i].second); - uint32_t len = new_len - i*126; + u32 len = new_len - i*126; if(len > 126) len = 126; else if(len < 126) @@ -281,7 +283,7 @@ void fs_vtech::impl::file::replace(const std::vector<uint8_t> &data) dblk.w16l(126, 0); } - uint16_t end_address = (r16l(m_entry + 0xc) + data.size() - 1) & 0xffff; + u16 end_address = (r16l(m_entry + 0xc) + data.size() - 1) & 0xffff; w16l(m_entry + 0xe, end_address); if(need_ns) { w8(m_entry + 0xa, blocks[0].first); @@ -292,43 +294,43 @@ void fs_vtech::impl::file::replace(const std::vector<uint8_t> &data) m_dir->update_file(m_key, m_entry); } -void fs_vtech::impl::root_dir::metadata_change(const fs_meta_data &info) +void vtech_image::impl::root_dir::metadata_change(const meta_data &info) { } -void fs_vtech::impl::metadata_change(const fs_meta_data &info) +void vtech_image::impl::metadata_change(const meta_data &info) { } -void fs_vtech::impl::file::metadata_change(const fs_meta_data &info) +void vtech_image::impl::file::metadata_change(const meta_data &info) { - if(info.has(fs_meta_name::basic)) - w8 (m_entry+0x0, info.get_flag(fs_meta_name::basic) ? 'T' : 'B'); - if(info.has(fs_meta_name::name)) { - std::string name = info.get_string(fs_meta_name::name); + if(info.has(meta_name::basic)) + w8 (m_entry+0x0, info.get_flag(meta_name::basic) ? 'T' : 'B'); + if(info.has(meta_name::name)) { + std::string name = info.get_string(meta_name::name); name.resize(8, ' '); wstr(m_entry+0x2, name); } - if(info.has(fs_meta_name::loading_address)) { - uint16_t new_loading = info.get_number(fs_meta_name::loading_address); - uint16_t new_end = r16l(m_entry + 0xe) - r16l(m_entry + 0xc) + new_loading; + if(info.has(meta_name::loading_address)) { + u16 new_loading = info.get_number(meta_name::loading_address); + u16 new_end = r16l(m_entry + 0xe) - r16l(m_entry + 0xc) + new_loading; w16l(m_entry + 0xc, new_loading); w16l(m_entry + 0xe, new_end); } m_dir->update_file(m_key, m_entry); } -std::vector<std::pair<uint8_t, uint8_t>> fs_vtech::impl::allocate_blocks(uint32_t count) +std::vector<std::pair<u8, u8>> vtech_image::impl::allocate_blocks(u32 count) { - std::vector<std::pair<uint8_t, uint8_t>> blocks; + std::vector<std::pair<u8, u8>> blocks; if(free_block_count() < count) return blocks; auto fmap = m_blockdev.get(15); - for(uint8_t track = 1; track != 40; track++) - for(uint8_t sector = 0; sector != 16; sector++) { - uint32_t off = (track-1)*2 + (sector / 8); - uint32_t bit = 1 << (sector & 7); + for(u8 track = 1; track != 40; track++) + for(u8 sector = 0; sector != 16; sector++) { + u32 off = (track-1)*2 + (sector / 8); + u32 bit = 1 << (sector & 7); if(!(fmap.r8(off) & bit)) { fmap.w8(off, fmap.r8(off) | bit); blocks.emplace_back(std::make_pair(track, sector)); @@ -339,24 +341,24 @@ std::vector<std::pair<uint8_t, uint8_t>> fs_vtech::impl::allocate_blocks(uint32_ abort(); } -void fs_vtech::impl::free_blocks(const std::vector<std::pair<uint8_t, uint8_t>> &blocks) +void vtech_image::impl::free_blocks(const std::vector<std::pair<u8, u8>> &blocks) { auto fmap = m_blockdev.get(15); for(auto ref : blocks) { - uint8_t track = ref.first; - uint8_t sector = ref.second; - uint32_t off = (track-1)*2 + (sector / 8); - uint32_t bit = 1 << (sector & 7); + u8 track = ref.first; + u8 sector = ref.second; + u32 off = (track-1)*2 + (sector / 8); + u32 bit = 1 << (sector & 7); fmap.w8(off, fmap.r8(off) & ~bit); } } -uint32_t fs_vtech::impl::free_block_count() +u32 vtech_image::impl::free_block_count() { auto fmap = m_blockdev.get(15); - uint32_t nf = 0; - for(uint32_t off = 0; off != (40-1)*2; off++) { - uint8_t m = fmap.r8(off); + u32 nf = 0; + for(u32 off = 0; off != (40-1)*2; off++) { + u8 m = fmap.r8(off); // Count 1 bits; m = ((m & 0xaa) >> 1) | (m & 0x55); m = ((m & 0xcc) >> 2) | (m & 0x33); @@ -365,3 +367,5 @@ uint32_t fs_vtech::impl::free_block_count() } return nf; } + +} // namespace fs diff --git a/src/lib/formats/fs_vtech.h b/src/lib/formats/fs_vtech.h index d4f27b1c472..16afee02cad 100644 --- a/src/lib/formats/fs_vtech.h +++ b/src/lib/formats/fs_vtech.h @@ -10,7 +10,9 @@ #include "fsmgr.h" -class fs_vtech : public filesystem_manager_t { +namespace fs { + +class vtech_image : public manager_t { public: class impl : public filesystem_t { public: @@ -21,65 +23,65 @@ public: virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; - virtual std::vector<fs_dir_entry> contents() override; - virtual file_t file_get(uint64_t key) override; - virtual dir_t dir_get(uint64_t key) override; - virtual file_t file_create(const fs_meta_data &info) override; - virtual void file_delete(uint64_t key) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; + virtual std::vector<dir_entry> contents() override; + virtual file_t file_get(u64 key) override; + virtual dir_t dir_get(u64 key) override; + virtual file_t file_create(const meta_data &info) override; + virtual void file_delete(u64 key) override; - void update_file(uint16_t key, const uint8_t *entry); + void update_file(u16 key, const u8 *entry); private: impl &m_fs; - std::pair<fsblk_t::block_t, uint32_t> get_dir_block(uint64_t key); + std::pair<fsblk_t::block_t, u32> get_dir_block(u64 key); }; class file : public ifile_t { public: - file(impl &fs, root_dir *dir, const uint8_t *entry, uint16_t key); + file(impl &fs, root_dir *dir, const u8 *entry, u16 key); virtual ~file() = default; virtual void drop_weak_references() override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; - virtual std::vector<uint8_t> read_all() override; - virtual void replace(const std::vector<uint8_t> &data) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; + virtual std::vector<u8> read_all() override; + virtual void replace(const std::vector<u8> &data) override; private: impl &m_fs; root_dir *m_dir; - uint16_t m_key; - uint8_t m_entry[18]; + u16 m_key; + u8 m_entry[18]; }; impl(fsblk_t &blockdev); virtual ~impl() = default; - virtual void format(const fs_meta_data &meta) override; - virtual fs_meta_data metadata() override; - virtual void metadata_change(const fs_meta_data &info) override; + virtual void format(const meta_data &meta) override; + virtual meta_data metadata() override; + virtual void metadata_change(const meta_data &info) override; virtual dir_t root() override; void drop_root_ref(); - std::vector<std::pair<uint8_t, uint8_t>> allocate_blocks(uint32_t count); - void free_blocks(const std::vector<std::pair<uint8_t, uint8_t>> &blocks); - uint32_t free_block_count(); + std::vector<std::pair<u8, u8>> allocate_blocks(u32 count); + void free_blocks(const std::vector<std::pair<u8, u8>> &blocks); + u32 free_block_count(); private: dir_t m_root; }; - fs_vtech() : filesystem_manager_t() {} + vtech_image() : manager_t() {} virtual const char *name() const override; virtual const char *description() const override; - virtual void enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override; + virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const override; virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const override; virtual bool can_format() const override; @@ -87,10 +89,12 @@ public: virtual bool can_write() const override; virtual bool has_rsrc() const override; - virtual std::vector<fs_meta_description> volume_meta_description() const override; - virtual std::vector<fs_meta_description> file_meta_description() const override; + virtual std::vector<meta_description> volume_meta_description() const override; + virtual std::vector<meta_description> file_meta_description() const override; }; -extern const fs_vtech FS_VTECH; +extern const vtech_image VTECH; + +} // namespace fs #endif diff --git a/src/lib/formats/fsblk_vec.cpp b/src/lib/formats/fsblk_vec.cpp index ff66b2b20ed..e80cad8c51c 100644 --- a/src/lib/formats/fsblk_vec.cpp +++ b/src/lib/formats/fsblk_vec.cpp @@ -1,7 +1,7 @@ // license:BSD-3-Clause // copyright-holders:Olivier Galibert -// Block device on vector<uint8_t> +// Block device on vector<u8> #include "fsblk_vec.h" @@ -10,12 +10,14 @@ #include <algorithm> #include <stdexcept> -const uint8_t *fsblk_vec_t::blk_t::rodata() +namespace fs { + +const u8 *fsblk_vec_t::blk_t::rodata() { return m_data; } -uint8_t *fsblk_vec_t::blk_t::data() +u8 *fsblk_vec_t::blk_t::data() { return m_data; } @@ -24,20 +26,21 @@ void fsblk_vec_t::blk_t::drop_weak_references() { } -uint32_t fsblk_vec_t::block_count() const +u32 fsblk_vec_t::block_count() const { return m_data.size() / m_block_size; } -fsblk_t::block_t fsblk_vec_t::get(uint32_t id) +fsblk_t::block_t fsblk_vec_t::get(u32 id) { if(id >= block_count()) throw std::out_of_range(util::string_format("Block number overflow: requiring block %d on device of size %d (%d bytes, block size %d)", id, block_count(), m_data.size(), m_block_size)); return block_t(new blk_t(m_data.data() + m_block_size*id, m_block_size)); } -void fsblk_vec_t::fill(uint8_t data) +void fsblk_vec_t::fill(u8 data) { std::fill(m_data.begin(), m_data.end(), data); } +} // namespace fs diff --git a/src/lib/formats/fsblk_vec.h b/src/lib/formats/fsblk_vec.h index b663d673855..e18a66da782 100644 --- a/src/lib/formats/fsblk_vec.h +++ b/src/lib/formats/fsblk_vec.h @@ -5,29 +5,33 @@ #include "fsmgr.h" +namespace fs { + class fsblk_vec_t : public fsblk_t { private: class blk_t : public iblock_t { public: - blk_t(uint8_t *data, uint32_t size) : iblock_t(size), m_data(data) {} + blk_t(u8 *data, u32 size) : iblock_t(size), m_data(data) {} virtual ~blk_t() = default; - virtual const uint8_t *rodata() override; - virtual uint8_t *data() override; + virtual const u8 *rodata() override; + virtual u8 *data() override; virtual void drop_weak_references() override; private: - uint8_t *m_data; + u8 *m_data; }; public: - fsblk_vec_t(std::vector<uint8_t> &data) : m_data(data) {} + fsblk_vec_t(std::vector<u8> &data) : m_data(data) {} virtual ~fsblk_vec_t() = default; - virtual uint32_t block_count() const override; - virtual block_t get(uint32_t id) override; - virtual void fill(uint8_t data) override; + virtual u32 block_count() const override; + virtual block_t get(u32 id) override; + virtual void fill(u8 data) override; private: - std::vector<uint8_t> &m_data; + std::vector<u8> &m_data; }; + +} // namespace fs diff --git a/src/lib/formats/fsmeta.cpp b/src/lib/formats/fsmeta.cpp index 4f76485a5f8..c5675d67a04 100644 --- a/src/lib/formats/fsmeta.cpp +++ b/src/lib/formats/fsmeta.cpp @@ -7,32 +7,34 @@ #include "strformat.h" -const char *fs_meta_data::entry_name(fs_meta_name name) +namespace fs { + +const char *meta_data::entry_name(meta_name name) { switch(name) { - case fs_meta_name::basic: return "basic"; - case fs_meta_name::creation_date: return "creation_date"; - case fs_meta_name::length: return "length"; - case fs_meta_name::loading_address: return "loading_address"; - case fs_meta_name::locked: return "locked"; - case fs_meta_name::modification_date: return "modification_date"; - case fs_meta_name::name: return "name"; - case fs_meta_name::os_minimum_version: return "os_minimum_version"; - case fs_meta_name::os_version: return "os_version"; - case fs_meta_name::rsrc_length: return "rsrc_length"; - case fs_meta_name::sequential: return "sequential"; - case fs_meta_name::size_in_blocks: return "size_in_blocks"; + case meta_name::basic: return "basic"; + case meta_name::creation_date: return "creation_date"; + case meta_name::length: return "length"; + case meta_name::loading_address: return "loading_address"; + case meta_name::locked: return "locked"; + case meta_name::modification_date: return "modification_date"; + case meta_name::name: return "name"; + case meta_name::os_minimum_version: return "os_minimum_version"; + case meta_name::os_version: return "os_version"; + case meta_name::rsrc_length: return "rsrc_length"; + case meta_name::sequential: return "sequential"; + case meta_name::size_in_blocks: return "size_in_blocks"; } return ""; } -std::string fs_meta::to_string(fs_meta_type type, const fs_meta &m) +std::string meta_value::to_string(meta_type type, const meta_value &m) { switch(type) { - case fs_meta_type::string: return m.as_string(); - case fs_meta_type::number: return util::string_format("0x%x", m.as_number()); - case fs_meta_type::flag: return m.as_flag() ? "t" : "f"; - case fs_meta_type::date: { + case meta_type::string: return m.as_string(); + case meta_type::number: return util::string_format("0x%x", m.as_number()); + case meta_type::flag: return m.as_flag() ? "t" : "f"; + case meta_type::date: { auto dt = m.as_date(); return util::string_format("%04d-%02d-%02d %02d:%02d:%02d", dt.year, dt.month, dt.day_of_month, @@ -41,3 +43,5 @@ std::string fs_meta::to_string(fs_meta_type type, const fs_meta &m) } return std::string(""); } + +} // namespace fs diff --git a/src/lib/formats/fsmeta.h b/src/lib/formats/fsmeta.h index 9edede6c36a..dad70d86b6d 100644 --- a/src/lib/formats/fsmeta.h +++ b/src/lib/formats/fsmeta.h @@ -16,7 +16,9 @@ #include <unordered_map> #include <variant> -enum class fs_meta_name { +namespace fs { + +enum class meta_name { basic, creation_date, length, @@ -31,26 +33,26 @@ enum class fs_meta_name { size_in_blocks, }; -enum class fs_meta_type { +enum class meta_type { date, flag, number, string, }; -class fs_meta { +class meta_value { public: - static std::string to_string(fs_meta_type type, const fs_meta &m); - static fs_meta from_string(fs_meta_type type, std::string value); - - fs_meta() { value = false; } - fs_meta(std::string str) { value = str; } - fs_meta(bool b) { value = b; } - fs_meta(int32_t num) { value = uint64_t(num); } - fs_meta(uint32_t num) { value = uint64_t(num); } - fs_meta(int64_t num) { value = uint64_t(num); } - fs_meta(uint64_t num) { value = num; } - fs_meta(util::arbitrary_datetime dt) { value = dt; } + static std::string to_string(meta_type type, const meta_value &m); + static meta_value from_string(meta_type type, std::string value); + + meta_value() { value = false; } + meta_value(std::string str) { value = str; } + meta_value(bool b) { value = b; } + meta_value(int32_t num) { value = uint64_t(num); } + meta_value(uint32_t num) { value = uint64_t(num); } + meta_value(int64_t num) { value = uint64_t(num); } + meta_value(uint64_t num) { value = num; } + meta_value(util::arbitrary_datetime dt) { value = dt; } util::arbitrary_datetime as_date() const { return *std::get_if<util::arbitrary_datetime>(&value); } bool as_flag() const { return *std::get_if<bool>(&value); } @@ -61,47 +63,49 @@ private: std::variant<std::string, uint64_t, bool, util::arbitrary_datetime> value; }; -class fs_meta_data { +class meta_data { public: - std::unordered_map<fs_meta_name, fs_meta> meta; + std::unordered_map<meta_name, meta_value> meta; - static const char *entry_name(fs_meta_name name); + static const char *entry_name(meta_name name); - bool has(fs_meta_name name) const { return meta.find(name) != meta.end(); } + bool has(meta_name name) const { return meta.find(name) != meta.end(); } bool empty() const { return meta.empty(); } - void set(fs_meta_name name, const fs_meta &val) { meta[name] = val; } - void set(fs_meta_name name, std::string str) { set(name, fs_meta(str)); } - void set(fs_meta_name name, bool b) { set(name, fs_meta(b)); } - void set(fs_meta_name name, int32_t num) { set(name, fs_meta(num)); } - void set(fs_meta_name name, uint32_t num) { set(name, fs_meta(num)); } - void set(fs_meta_name name, int64_t num) { set(name, fs_meta(num)); } - void set(fs_meta_name name, uint64_t num) { set(name, fs_meta(num)); } - void set(fs_meta_name name, util::arbitrary_datetime dt) { set(name, fs_meta(dt)); } - void set_now(fs_meta_name name) { set(name, fs_meta(util::arbitrary_datetime::now())); } - - fs_meta get(fs_meta_name name) const { auto i = meta.find(name); assert(i != meta.end()); return i->second; } - util::arbitrary_datetime get_date(fs_meta_name name, util::arbitrary_datetime def = util::arbitrary_datetime::now()) const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_date(); } - bool get_flag(fs_meta_name name, bool def = false) const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_flag(); } - uint64_t get_number(fs_meta_name name, uint64_t def = 0) const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_number(); } - std::string get_string(fs_meta_name name, std::string def = "") const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_string(); } + void set(meta_name name, const meta_value &val) { meta[name] = val; } + void set(meta_name name, std::string str) { set(name, meta_value(str)); } + void set(meta_name name, bool b) { set(name, meta_value(b)); } + void set(meta_name name, int32_t num) { set(name, meta_value(num)); } + void set(meta_name name, uint32_t num) { set(name, meta_value(num)); } + void set(meta_name name, int64_t num) { set(name, meta_value(num)); } + void set(meta_name name, uint64_t num) { set(name, meta_value(num)); } + void set(meta_name name, util::arbitrary_datetime dt) { set(name, meta_value(dt)); } + void set_now(meta_name name) { set(name, meta_value(util::arbitrary_datetime::now())); } + + meta_value get(meta_name name) const { auto i = meta.find(name); assert(i != meta.end()); return i->second; } + util::arbitrary_datetime get_date(meta_name name, util::arbitrary_datetime def = util::arbitrary_datetime::now()) const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_date(); } + bool get_flag(meta_name name, bool def = false) const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_flag(); } + uint64_t get_number(meta_name name, uint64_t def = 0) const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_number(); } + std::string get_string(meta_name name, std::string def = "") const { auto i = meta.find(name); if(i == meta.end()) return def; else return i->second.as_string(); } }; -struct fs_meta_description { - fs_meta_name m_name; - fs_meta_type m_type; - fs_meta m_default; +struct meta_description { + meta_name m_name; + meta_type m_type; + meta_value m_default; bool m_ro; - std::function<void (const fs_meta &)> m_validator; + std::function<void (const meta_value &)> m_validator; const char *m_tooltip; - fs_meta_description(fs_meta_name name, fs_meta_type type, int def, bool ro, std::function<void (fs_meta)> validator, const char *tooltip) : + meta_description(meta_name name, meta_type type, int def, bool ro, std::function<void (meta_value)> validator, const char *tooltip) : m_name(name), m_type(type), m_default(uint64_t(def)), m_ro(ro), m_validator(validator), m_tooltip(tooltip) {} - template<typename T> fs_meta_description(fs_meta_name name, fs_meta_type type, T def, bool ro, std::function<void (fs_meta)> validator, const char *tooltip) : + template<typename T> meta_description(meta_name name, meta_type type, T def, bool ro, std::function<void (meta_value)> validator, const char *tooltip) : m_name(name), m_type(type), m_default(def), m_ro(ro), m_validator(validator), m_tooltip(tooltip) {} }; +} // namespace fs + #endif // MAME_FORMATS_FSMETA_H diff --git a/src/lib/formats/fsmgr.cpp b/src/lib/formats/fsmgr.cpp index 1fe13037418..185c08fa503 100644 --- a/src/lib/formats/fsmgr.cpp +++ b/src/lib/formats/fsmgr.cpp @@ -11,17 +11,19 @@ #include <stdexcept> -void fs_refcounted_inner::ref() +namespace fs { + +void refcounted_inner::ref() { m_ref ++; } -void fs_refcounted_inner::ref_weak() +void refcounted_inner::ref_weak() { m_weak_ref ++; } -bool fs_refcounted_inner::unref() +bool refcounted_inner::unref() { m_ref --; if(m_ref == 0) { @@ -34,7 +36,7 @@ bool fs_refcounted_inner::unref() return false; } -bool fs_refcounted_inner::unref_weak() +bool refcounted_inner::unref_weak() { m_weak_ref --; if(m_weak_ref == 0 && m_ref == 0) { @@ -46,62 +48,62 @@ bool fs_refcounted_inner::unref_weak() -void filesystem_manager_t::enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const +void manager_t::enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const { } -void filesystem_manager_t::enumerate_h(hd_enumerator &he) const +void manager_t::enumerate_h(hd_enumerator &he) const { } -void filesystem_manager_t::enumerate_c(cdrom_enumerator &ce) const +void manager_t::enumerate_c(cdrom_enumerator &ce) const { } -bool filesystem_manager_t::has_variant(const std::vector<uint32_t> &variants, uint32_t variant) +bool manager_t::has_variant(const std::vector<u32> &variants, u32 variant) { - for(uint32_t v : variants) + for(u32 v : variants) if(variant == v) return true; return false; } -bool filesystem_manager_t::has(uint32_t form_factor, const std::vector<uint32_t> &variants, uint32_t ff, uint32_t variant) +bool manager_t::has(u32 form_factor, const std::vector<u32> &variants, u32 ff, u32 variant) { if(form_factor == floppy_image::FF_UNKNOWN) return true; if(form_factor != ff) return false; - for(uint32_t v : variants) + for(u32 v : variants) if(variant == v) return true; return false; } -std::vector<fs_meta_description> filesystem_manager_t::volume_meta_description() const +std::vector<meta_description> manager_t::volume_meta_description() const { - std::vector<fs_meta_description> res; + std::vector<meta_description> res; return res; } -std::vector<fs_meta_description> filesystem_manager_t::file_meta_description() const +std::vector<meta_description> manager_t::file_meta_description() const { - std::vector<fs_meta_description> res; + std::vector<meta_description> res; return res; } -std::vector<fs_meta_description> filesystem_manager_t::directory_meta_description() const +std::vector<meta_description> manager_t::directory_meta_description() const { - std::vector<fs_meta_description> res; + std::vector<meta_description> res; return res; } -char filesystem_manager_t::directory_separator() const +char manager_t::directory_separator() const { return 0; // Subdirectories not supported by default } -void filesystem_t::format(const fs_meta_data &meta) +void filesystem_t::format(const meta_data &meta) { throw std::logic_error("format called on a filesystem not supporting it"); } @@ -111,193 +113,193 @@ filesystem_t::dir_t filesystem_t::root() throw std::logic_error("root called on a filesystem not supporting it"); } -fs_meta_data filesystem_t::metadata() +meta_data filesystem_t::metadata() { throw std::logic_error("filesystem_t::metadata called on a filesystem not supporting it"); } -void fsblk_t::set_block_size(uint32_t block_size) +void fsblk_t::set_block_size(u32 block_size) { m_block_size = block_size; } -uint8_t *fsblk_t::iblock_t::offset(const char *function, uint32_t off, uint32_t size) +u8 *fsblk_t::iblock_t::offset(const char *function, u32 off, u32 size) { if(off + size > m_size) throw std::out_of_range(util::string_format("block_t::%s out-of-block access, offset=%d, size=%d, block size=%d", function, off, size, m_size)); return data() + off; } -const uint8_t *fsblk_t::iblock_t::rooffset(const char *function, uint32_t off, uint32_t size) +const u8 *fsblk_t::iblock_t::rooffset(const char *function, u32 off, u32 size) { if(off + size > m_size) throw std::out_of_range(util::string_format("block_t::%s out-of-block read access, offset=%d, size=%d, block size=%d\n", function, off, size, m_size)); return rodata() + off; } -void fsblk_t::block_t::copy(uint32_t offset, const uint8_t *src, uint32_t size) +void fsblk_t::block_t::copy(u32 offset, const u8 *src, u32 size) { - uint8_t *blk = m_object->offset("copy", offset, size); + u8 *blk = m_object->offset("copy", offset, size); memcpy(blk, src, size); } -void fsblk_t::block_t::fill(uint32_t offset, uint8_t data, uint32_t size) +void fsblk_t::block_t::fill(u32 offset, u8 data, u32 size) { - uint8_t *blk = m_object->offset("fill", offset, size); + u8 *blk = m_object->offset("fill", offset, size); memset(blk, data, size); } -void fsblk_t::block_t::fill(uint8_t data) +void fsblk_t::block_t::fill(u8 data) { - uint8_t *blk = m_object->data(); + u8 *blk = m_object->data(); memset(blk, data, m_object->size()); } -void fsblk_t::block_t::wstr(uint32_t offset, const std::string &str) +void fsblk_t::block_t::wstr(u32 offset, const std::string &str) { - uint8_t *blk = m_object->offset("wstr", offset, str.size()); + u8 *blk = m_object->offset("wstr", offset, str.size()); memcpy(blk, str.data(), str.size()); } -void fsblk_t::block_t::w8(uint32_t offset, uint8_t data) +void fsblk_t::block_t::w8(u32 offset, u8 data) { - uint8_t *blk = m_object->offset("w8", offset, 1); + u8 *blk = m_object->offset("w8", offset, 1); blk[0] = data; } -void fsblk_t::block_t::w16b(uint32_t offset, uint16_t data) +void fsblk_t::block_t::w16b(u32 offset, u16 data) { - uint8_t *blk = m_object->offset("w16b", offset, 2); + u8 *blk = m_object->offset("w16b", offset, 2); blk[0] = data >> 8; blk[1] = data; } -void fsblk_t::block_t::w24b(uint32_t offset, uint32_t data) +void fsblk_t::block_t::w24b(u32 offset, u32 data) { - uint8_t *blk = m_object->offset("w24b", offset, 3); + u8 *blk = m_object->offset("w24b", offset, 3); blk[0] = data >> 16; blk[1] = data >> 8; blk[2] = data; } -void fsblk_t::block_t::w32b(uint32_t offset, uint32_t data) +void fsblk_t::block_t::w32b(u32 offset, u32 data) { - uint8_t *blk = m_object->offset("w32b", offset, 4); + u8 *blk = m_object->offset("w32b", offset, 4); blk[0] = data >> 24; blk[1] = data >> 16; blk[2] = data >> 8; blk[3] = data; } -void fsblk_t::block_t::w16l(uint32_t offset, uint16_t data) +void fsblk_t::block_t::w16l(u32 offset, u16 data) { - uint8_t *blk = m_object->offset("w16l", offset, 2); + u8 *blk = m_object->offset("w16l", offset, 2); blk[0] = data; blk[1] = data >> 8; } -void fsblk_t::block_t::w24l(uint32_t offset, uint32_t data) +void fsblk_t::block_t::w24l(u32 offset, u32 data) { - uint8_t *blk = m_object->offset("w24l", offset, 3); + u8 *blk = m_object->offset("w24l", offset, 3); blk[0] = data; blk[1] = data >> 8; blk[2] = data >> 16; } -void fsblk_t::block_t::w32l(uint32_t offset, uint32_t data) +void fsblk_t::block_t::w32l(u32 offset, u32 data) { - uint8_t *blk = m_object->offset("w32l", offset, 4); + u8 *blk = m_object->offset("w32l", offset, 4); blk[0] = data; blk[1] = data >> 8; blk[2] = data >> 16; blk[3] = data >> 24; } -std::string fsblk_t::block_t::rstr(uint32_t offset, uint32_t size) +std::string fsblk_t::block_t::rstr(u32 offset, u32 size) { - const uint8_t *d = m_object->rooffset("rstr", offset, size); + const u8 *d = m_object->rooffset("rstr", offset, size); return std::string(d, d + size); } -uint8_t fsblk_t::block_t::r8(uint32_t offset) +u8 fsblk_t::block_t::r8(u32 offset) { - const uint8_t *blk = m_object->offset("r8", offset, 1); + const u8 *blk = m_object->offset("r8", offset, 1); return blk[0]; } -uint16_t fsblk_t::block_t::r16b(uint32_t offset) +u16 fsblk_t::block_t::r16b(u32 offset) { - const uint8_t *blk = m_object->offset("r16b", offset, 2); + const u8 *blk = m_object->offset("r16b", offset, 2); return (blk[0] << 8) | blk[1]; } -uint32_t fsblk_t::block_t::r24b(uint32_t offset) +u32 fsblk_t::block_t::r24b(u32 offset) { - const uint8_t *blk = m_object->offset("r24b", offset, 3); + const u8 *blk = m_object->offset("r24b", offset, 3); return (blk[0] << 16) | (blk[1] << 8) | blk[2]; } -uint32_t fsblk_t::block_t::r32b(uint32_t offset) +u32 fsblk_t::block_t::r32b(u32 offset) { - const uint8_t *blk = m_object->offset("r32b", offset, 4); + const u8 *blk = m_object->offset("r32b", offset, 4); return (blk[0] << 24) | (blk[1] << 16) | (blk[2] << 8) | blk[3]; } -uint16_t fsblk_t::block_t::r16l(uint32_t offset) +u16 fsblk_t::block_t::r16l(u32 offset) { - const uint8_t *blk = m_object->offset("r16l", offset, 2); + const u8 *blk = m_object->offset("r16l", offset, 2); return blk[0] | (blk[1] << 8); } -uint32_t fsblk_t::block_t::r24l(uint32_t offset) +u32 fsblk_t::block_t::r24l(u32 offset) { - const uint8_t *blk = m_object->offset("r24l", offset, 3); + const u8 *blk = m_object->offset("r24l", offset, 3); return blk[0] | (blk[1] << 8) | (blk[2] << 16); } -uint32_t fsblk_t::block_t::r32l(uint32_t offset) +u32 fsblk_t::block_t::r32l(u32 offset) { - const uint8_t *blk = m_object->offset("r32l", offset, 4); + const u8 *blk = m_object->offset("r32l", offset, 4); return blk[0] | (blk[1] << 8) | (blk[2] << 16) | (blk[3] << 24); } -void filesystem_t::copy(uint8_t *p, const uint8_t *src, uint32_t size) +void filesystem_t::copy(u8 *p, const u8 *src, u32 size) { memcpy(p, src, size); } -void filesystem_t::fill(uint8_t *p, uint8_t data, uint32_t size) +void filesystem_t::fill(u8 *p, u8 data, u32 size) { memset(p, data, size); } -void filesystem_t::wstr(uint8_t *p, const std::string &str) +void filesystem_t::wstr(u8 *p, const std::string &str) { memcpy(p, str.data(), str.size()); } -void filesystem_t::w8(uint8_t *p, uint8_t data) +void filesystem_t::w8(u8 *p, u8 data) { p[0] = data; } -void filesystem_t::w16b(uint8_t *p, uint16_t data) +void filesystem_t::w16b(u8 *p, u16 data) { p[0] = data >> 8; p[1] = data; } -void filesystem_t::w24b(uint8_t *p, uint32_t data) +void filesystem_t::w24b(u8 *p, u32 data) { p[0] = data >> 16; p[1] = data >> 8; p[2] = data; } -void filesystem_t::w32b(uint8_t *p, uint32_t data) +void filesystem_t::w32b(u8 *p, u32 data) { p[0] = data >> 24; p[1] = data >> 16; @@ -305,20 +307,20 @@ void filesystem_t::w32b(uint8_t *p, uint32_t data) p[3] = data; } -void filesystem_t::w16l(uint8_t *p, uint16_t data) +void filesystem_t::w16l(u8 *p, u16 data) { p[0] = data; p[1] = data >> 8; } -void filesystem_t::w24l(uint8_t *p, uint32_t data) +void filesystem_t::w24l(u8 *p, u32 data) { p[0] = data; p[1] = data >> 8; p[2] = data >> 16; } -void filesystem_t::w32l(uint8_t *p, uint32_t data) +void filesystem_t::w32l(u8 *p, u32 data) { p[0] = data; p[1] = data >> 8; @@ -326,42 +328,42 @@ void filesystem_t::w32l(uint8_t *p, uint32_t data) p[3] = data >> 24; } -std::string filesystem_t::rstr(const uint8_t *p, uint32_t size) +std::string filesystem_t::rstr(const u8 *p, u32 size) { return std::string(p, p + size); } -uint8_t filesystem_t::r8(const uint8_t *p) +u8 filesystem_t::r8(const u8 *p) { return p[0]; } -uint16_t filesystem_t::r16b(const uint8_t *p) +u16 filesystem_t::r16b(const u8 *p) { return (p[0] << 8) | p[1]; } -uint32_t filesystem_t::r24b(const uint8_t *p) +u32 filesystem_t::r24b(const u8 *p) { return (p[0] << 16) | (p[1] << 8) | p[2]; } -uint32_t filesystem_t::r32b(const uint8_t *p) +u32 filesystem_t::r32b(const u8 *p) { return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; } -uint16_t filesystem_t::r16l(const uint8_t *p) +u16 filesystem_t::r16l(const u8 *p) { return p[0] | (p[1] << 8); } -uint32_t filesystem_t::r24l(const uint8_t *p) +u32 filesystem_t::r24l(const u8 *p) { return p[0] | (p[1] << 8) | (p[2] << 16); } -uint32_t filesystem_t::r32l(const uint8_t *p) +u32 filesystem_t::r32l(const u8 *p) { return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); } @@ -372,7 +374,7 @@ std::string filesystem_t::trim_end_spaces(const std::string &str) return str.substr(0, (std::string::npos != i) ? (i + 1) : 0); } -filesystem_t::file_t filesystem_t::idir_t::file_create(const fs_meta_data &info) +filesystem_t::file_t filesystem_t::idir_t::file_create(const meta_data &info) { throw std::logic_error("file_create called on a filesystem not supporting write"); } @@ -383,32 +385,34 @@ void filesystem_t::idir_t::file_delete(uint64_t key) } -void filesystem_t::ifile_t::replace(const std::vector<uint8_t> &data) +void filesystem_t::ifile_t::replace(const std::vector<u8> &data) { throw std::logic_error("replace called on a filesystem not supporting write"); } -void filesystem_t::ifile_t::rsrc_replace(const std::vector<uint8_t> &data) +void filesystem_t::ifile_t::rsrc_replace(const std::vector<u8> &data) { throw std::logic_error("rsrc_replace called on a filesystem not supporting write or resource forks"); } -void filesystem_t::ifile_t::metadata_change(const fs_meta_data &info) +void filesystem_t::ifile_t::metadata_change(const meta_data &info) { throw std::logic_error("metadata_change called on a filesystem not supporting write"); } -void filesystem_t::idir_t::metadata_change(const fs_meta_data &info) +void filesystem_t::idir_t::metadata_change(const meta_data &info) { throw std::logic_error("metadata_change called on a filesystem not supporting write"); } -void filesystem_t::metadata_change(const fs_meta_data &info) +void filesystem_t::metadata_change(const meta_data &info) { throw std::logic_error("metadata_change called on a filesystem not supporting write"); } -std::vector<uint8_t> filesystem_t::ifile_t::rsrc_read_all() +std::vector<u8> filesystem_t::ifile_t::rsrc_read_all() { throw std::logic_error("rsrc_read_all called on a filesystem without resource forks"); } + +} // namespace fs diff --git a/src/lib/formats/fsmgr.h b/src/lib/formats/fsmgr.h index 6c70d4806a0..37ddaac2265 100644 --- a/src/lib/formats/fsmgr.h +++ b/src/lib/formats/fsmgr.h @@ -11,30 +11,37 @@ #include "flopimg.h" #include "fsmeta.h" -template<typename T> class fs_refcounted_outer { +namespace fs { + +using u8 = uint8_t; +using u16 = uint16_t; +using u32 = uint32_t; +using u64 = uint64_t; + +template<typename T> class refcounted_outer { public: - fs_refcounted_outer(bool weak) : m_object(nullptr), m_is_weak_ref(weak) {} - fs_refcounted_outer(T *object, bool weak) : m_object(object), m_is_weak_ref(weak) { + refcounted_outer(bool weak) : m_object(nullptr), m_is_weak_ref(weak) {} + refcounted_outer(T *object, bool weak) : m_object(object), m_is_weak_ref(weak) { ref(); } - fs_refcounted_outer(const fs_refcounted_outer &cref) { + refcounted_outer(const refcounted_outer &cref) { m_object = cref.m_object; m_is_weak_ref = cref.m_is_weak_ref; ref(); } - fs_refcounted_outer(fs_refcounted_outer &&cref) { + refcounted_outer(refcounted_outer &&cref) { m_object = cref.m_object; m_is_weak_ref = cref.m_is_weak_ref; cref.m_object = nullptr; } - ~fs_refcounted_outer() { + ~refcounted_outer() { unref(); } - fs_refcounted_outer<T> &operator =(T *dir) { + refcounted_outer<T> &operator =(T *dir) { if(m_object != dir) { unref(); m_object = dir; @@ -43,7 +50,7 @@ public: return *this; } - fs_refcounted_outer<T> &operator =(const fs_refcounted_outer<T> &cref) { + refcounted_outer<T> &operator =(const refcounted_outer<T> &cref) { if(m_object != cref.m_object) { unref(); m_object = cref.m_object; @@ -52,7 +59,7 @@ public: return *this; } - fs_refcounted_outer<T> &operator =(fs_refcounted_outer<T> &&cref) { + refcounted_outer<T> &operator =(refcounted_outer<T> &&cref) { if(m_object != cref.m_object) { unref(); m_object = cref.m_object; @@ -92,10 +99,10 @@ private: }; -class fs_refcounted_inner { +class refcounted_inner { public: - fs_refcounted_inner() : m_ref(0), m_weak_ref(0) {} - virtual ~fs_refcounted_inner() = default; + refcounted_inner() : m_ref(0), m_weak_ref(0) {} + virtual ~refcounted_inner() = default; void ref(); void ref_weak(); @@ -105,87 +112,87 @@ public: virtual void drop_weak_references() = 0; public: - uint32_t m_ref, m_weak_ref; + u32 m_ref, m_weak_ref; }; -enum class fs_dir_entry_type { +enum class dir_entry_type { dir, file, system_file, }; -struct fs_dir_entry { +struct dir_entry { std::string m_name; - fs_dir_entry_type m_type; - uint64_t m_key; + dir_entry_type m_type; + u64 m_key; - fs_dir_entry(const std::string &name, fs_dir_entry_type type, uint64_t key) : m_name(name), m_type(type), m_key(key) {} + dir_entry(const std::string &name, dir_entry_type type, u64 key) : m_name(name), m_type(type), m_key(key) {} }; class fsblk_t { protected: - class iblock_t : public fs_refcounted_inner { + class iblock_t : public refcounted_inner { public: - iblock_t(uint32_t size) : fs_refcounted_inner(), m_size(size) {} + iblock_t(u32 size) : refcounted_inner(), m_size(size) {} virtual ~iblock_t() = default; - uint32_t size() const { return m_size; } + u32 size() const { return m_size; } - virtual const uint8_t *rodata() = 0; - virtual uint8_t *data() = 0; - uint8_t *offset(const char *function, uint32_t off, uint32_t size); - const uint8_t *rooffset(const char *function, uint32_t off, uint32_t size); + virtual const u8 *rodata() = 0; + virtual u8 *data() = 0; + u8 *offset(const char *function, u32 off, u32 size); + const u8 *rooffset(const char *function, u32 off, u32 size); protected: - uint32_t m_size; + u32 m_size; }; public: - class block_t : public fs_refcounted_outer<iblock_t> { + class block_t : public refcounted_outer<iblock_t> { public: - block_t(bool weak = false) : fs_refcounted_outer<iblock_t>(weak) {} - block_t(iblock_t *block, bool weak = true) : fs_refcounted_outer(block, weak) {} + block_t(bool weak = false) : refcounted_outer<iblock_t>(weak) {} + block_t(iblock_t *block, bool weak = true) : refcounted_outer(block, weak) {} virtual ~block_t() = default; block_t strong() { return block_t(m_object, false); } block_t weak() { return block_t(m_object, true); } - const uint8_t *rodata() { return m_object->rodata(); } - uint8_t *data() { return m_object->data(); } - - void copy(uint32_t offset, const uint8_t *src, uint32_t size); - void fill( uint8_t data); - void fill(uint32_t offset, uint8_t data, uint32_t size); - void wstr(uint32_t offset, const std::string &str); - void w8( uint32_t offset, uint8_t data); - void w16b(uint32_t offset, uint16_t data); - void w24b(uint32_t offset, uint32_t data); - void w32b(uint32_t offset, uint32_t data); - void w16l(uint32_t offset, uint16_t data); - void w24l(uint32_t offset, uint32_t data); - void w32l(uint32_t offset, uint32_t data); - - std::string rstr(uint32_t offset, uint32_t size); - uint8_t r8( uint32_t offset); - uint16_t r16b(uint32_t offset); - uint32_t r24b(uint32_t offset); - uint32_t r32b(uint32_t offset); - uint16_t r16l(uint32_t offset); - uint32_t r24l(uint32_t offset); - uint32_t r32l(uint32_t offset); + const u8 *rodata() { return m_object->rodata(); } + u8 *data() { return m_object->data(); } + + void copy(u32 offset, const u8 *src, u32 size); + void fill( u8 data); + void fill(u32 offset, u8 data, u32 size); + void wstr(u32 offset, const std::string &str); + void w8( u32 offset, u8 data); + void w16b(u32 offset, u16 data); + void w24b(u32 offset, u32 data); + void w32b(u32 offset, u32 data); + void w16l(u32 offset, u16 data); + void w24l(u32 offset, u32 data); + void w32l(u32 offset, u32 data); + + std::string rstr(u32 offset, u32 size); + u8 r8( u32 offset); + u16 r16b(u32 offset); + u32 r24b(u32 offset); + u32 r32b(u32 offset); + u16 r16l(u32 offset); + u32 r24l(u32 offset); + u32 r32l(u32 offset); }; fsblk_t() : m_block_size(0) {} virtual ~fsblk_t() = default; - virtual void set_block_size(uint32_t block_size); - virtual uint32_t block_count() const = 0; - virtual block_t get(uint32_t id) = 0; - virtual void fill(uint8_t data) = 0; + virtual void set_block_size(u32 block_size); + virtual u32 block_count() const = 0; + virtual block_t get(u32 id) = 0; + virtual void fill(u8 data) = 0; protected: - uint32_t m_block_size; + u32 m_block_size; }; @@ -195,99 +202,99 @@ public: class file_t; protected: - class idir_t : public fs_refcounted_inner { + class idir_t : public refcounted_inner { public: - idir_t() : fs_refcounted_inner() {} + idir_t() : refcounted_inner() {} virtual ~idir_t() = default; - virtual fs_meta_data metadata() = 0; - virtual void metadata_change(const fs_meta_data &info); - virtual std::vector<fs_dir_entry> contents() = 0; - virtual file_t file_get(uint64_t key) = 0; - virtual dir_t dir_get(uint64_t key) = 0; - virtual file_t file_create(const fs_meta_data &info); - virtual void file_delete(uint64_t key); + virtual meta_data metadata() = 0; + virtual void metadata_change(const meta_data &info); + virtual std::vector<dir_entry> contents() = 0; + virtual file_t file_get(u64 key) = 0; + virtual dir_t dir_get(u64 key) = 0; + virtual file_t file_create(const meta_data &info); + virtual void file_delete(u64 key); }; - class ifile_t : public fs_refcounted_inner { + class ifile_t : public refcounted_inner { public: - ifile_t() : fs_refcounted_inner() {} + ifile_t() : refcounted_inner() {} virtual ~ifile_t() = default; - virtual fs_meta_data metadata() = 0; - virtual void metadata_change(const fs_meta_data &info); - virtual std::vector<uint8_t> read_all() = 0; - virtual void replace(const std::vector<uint8_t> &data); - virtual std::vector<uint8_t> rsrc_read_all(); - virtual void rsrc_replace(const std::vector<uint8_t> &data); + virtual meta_data metadata() = 0; + virtual void metadata_change(const meta_data &info); + virtual std::vector<u8> read_all() = 0; + virtual void replace(const std::vector<u8> &data); + virtual std::vector<u8> rsrc_read_all(); + virtual void rsrc_replace(const std::vector<u8> &data); }; public: - class dir_t : public fs_refcounted_outer<idir_t> { + class dir_t : public refcounted_outer<idir_t> { public: - dir_t(bool weak = false) : fs_refcounted_outer<idir_t>(weak) {} - dir_t(idir_t *dir, bool weak = true) : fs_refcounted_outer(dir, weak) {} + dir_t(bool weak = false) : refcounted_outer<idir_t>(weak) {} + dir_t(idir_t *dir, bool weak = true) : refcounted_outer(dir, weak) {} virtual ~dir_t() = default; dir_t strong() { return dir_t(m_object, false); } dir_t weak() { return dir_t(m_object, true); } - fs_meta_data metadata() { return m_object->metadata(); } - void metadata_change(const fs_meta_data &info) { m_object->metadata_change(info); } - std::vector<fs_dir_entry> contents() { return m_object->contents(); } - file_t file_get(uint64_t key) { return m_object->file_get(key); } - dir_t dir_get(uint64_t key) { return m_object->dir_get(key); } - file_t file_create(const fs_meta_data &info) { return m_object->file_create(info); } - void file_delete(uint64_t key) { m_object->file_delete(key); } + meta_data metadata() { return m_object->metadata(); } + void metadata_change(const meta_data &info) { m_object->metadata_change(info); } + std::vector<dir_entry> contents() { return m_object->contents(); } + file_t file_get(u64 key) { return m_object->file_get(key); } + dir_t dir_get(u64 key) { return m_object->dir_get(key); } + file_t file_create(const meta_data &info) { return m_object->file_create(info); } + void file_delete(u64 key) { m_object->file_delete(key); } }; - class file_t : public fs_refcounted_outer<ifile_t> { + class file_t : public refcounted_outer<ifile_t> { public: - file_t(bool weak = false) : fs_refcounted_outer<ifile_t>(weak) {} - file_t(ifile_t *file, bool weak = true) : fs_refcounted_outer(file, weak) {} + file_t(bool weak = false) : refcounted_outer<ifile_t>(weak) {} + file_t(ifile_t *file, bool weak = true) : refcounted_outer(file, weak) {} virtual ~file_t() = default; file_t strong() { return file_t(m_object, false); } file_t weak() { return file_t(m_object, true); } - fs_meta_data metadata() { return m_object->metadata(); } - void metadata_change(const fs_meta_data &info) { m_object->metadata_change(info); } - std::vector<uint8_t> read_all() { return m_object->read_all(); } - void replace(const std::vector<uint8_t> &data) { m_object->replace(data); } - std::vector<uint8_t> rsrc_read_all() { return m_object->rsrc_read_all(); } - void rsrc_replace(const std::vector<uint8_t> &data) { m_object->rsrc_replace(data); } + meta_data metadata() { return m_object->metadata(); } + void metadata_change(const meta_data &info) { m_object->metadata_change(info); } + std::vector<u8> read_all() { return m_object->read_all(); } + void replace(const std::vector<u8> &data) { m_object->replace(data); } + std::vector<u8> rsrc_read_all() { return m_object->rsrc_read_all(); } + void rsrc_replace(const std::vector<u8> &data) { m_object->rsrc_replace(data); } }; - filesystem_t(fsblk_t &blockdev, uint32_t size) : m_blockdev(blockdev) { + filesystem_t(fsblk_t &blockdev, u32 size) : m_blockdev(blockdev) { m_blockdev.set_block_size(size); } virtual ~filesystem_t() = default; virtual dir_t root(); - virtual void format(const fs_meta_data &meta); - virtual fs_meta_data metadata(); - virtual void metadata_change(const fs_meta_data &info); - - static void copy(uint8_t *p, const uint8_t *src, uint32_t size); - static void fill(uint8_t *p, uint8_t data, uint32_t size); - static void wstr(uint8_t *p, const std::string &str); - static void w8( uint8_t *p, uint8_t data); - static void w16b(uint8_t *p, uint16_t data); - static void w24b(uint8_t *p, uint32_t data); - static void w32b(uint8_t *p, uint32_t data); - static void w16l(uint8_t *p, uint16_t data); - static void w24l(uint8_t *p, uint32_t data); - static void w32l(uint8_t *p, uint32_t data); - - static std::string rstr(const uint8_t *p, uint32_t size); - static uint8_t r8( const uint8_t *p); - static uint16_t r16b(const uint8_t *p); - static uint32_t r24b(const uint8_t *p); - static uint32_t r32b(const uint8_t *p); - static uint16_t r16l(const uint8_t *p); - static uint32_t r24l(const uint8_t *p); - static uint32_t r32l(const uint8_t *p); + virtual void format(const meta_data &meta); + virtual meta_data metadata(); + virtual void metadata_change(const meta_data &info); + + static void copy(u8 *p, const u8 *src, u32 size); + static void fill(u8 *p, u8 data, u32 size); + static void wstr(u8 *p, const std::string &str); + static void w8( u8 *p, u8 data); + static void w16b(u8 *p, u16 data); + static void w24b(u8 *p, u32 data); + static void w32b(u8 *p, u32 data); + static void w16l(u8 *p, u16 data); + static void w24l(u8 *p, u32 data); + static void w32l(u8 *p, u32 data); + + static std::string rstr(const u8 *p, u32 size); + static u8 r8( const u8 *p); + static u16 r16b(const u8 *p); + static u32 r24b(const u8 *p); + static u32 r32b(const u8 *p); + static u16 r16l(const u8 *p); + static u32 r24l(const u8 *p); + static u32 r32l(const u8 *p); static std::string trim_end_spaces(const std::string &str); @@ -297,34 +304,34 @@ protected: class unformatted_floppy_creator; -class filesystem_manager_t { +class manager_t { public: struct floppy_enumerator { virtual ~floppy_enumerator() = default; - virtual void add(floppy_format_type type, uint32_t image_size, const char *name, const char *description) = 0; - virtual void add_raw(const char *name, uint32_t key, const char *description) = 0; + virtual void add(floppy_format_type type, u32 image_size, const char *name, const char *description) = 0; + virtual void add_raw(const char *name, u32 key, const char *description) = 0; }; struct hd_enumerator { virtual ~hd_enumerator() = default; - virtual void add(const filesystem_manager_t *manager, const char *name, const char *description) = 0; + virtual void add(const manager_t *manager, const char *name, const char *description) = 0; }; struct cdrom_enumerator { virtual ~cdrom_enumerator() = default; - virtual void add(const filesystem_manager_t *manager, const char *name, const char *description) = 0; + virtual void add(const manager_t *manager, const char *name, const char *description) = 0; }; - virtual ~filesystem_manager_t() = default; + virtual ~manager_t() = default; virtual const char *name() const = 0; virtual const char *description() const = 0; - virtual void enumerate_f(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const; + virtual void enumerate_f(floppy_enumerator &fe, u32 form_factor, const std::vector<u32> &variants) const; virtual void enumerate_h(hd_enumerator &he) const; virtual void enumerate_c(cdrom_enumerator &ce) const; @@ -336,18 +343,20 @@ public: bool has_subdirectories() const { return directory_separator() != 0; } - virtual std::vector<fs_meta_description> volume_meta_description() const; - virtual std::vector<fs_meta_description> file_meta_description() const; - virtual std::vector<fs_meta_description> directory_meta_description() const; + virtual std::vector<meta_description> volume_meta_description() const; + virtual std::vector<meta_description> file_meta_description() const; + virtual std::vector<meta_description> directory_meta_description() const; // Create a filesystem object from a block device virtual std::unique_ptr<filesystem_t> mount(fsblk_t &blockdev) const = 0; protected: - filesystem_manager_t() = default; + manager_t() = default; - static bool has(uint32_t form_factor, const std::vector<uint32_t> &variants, uint32_t ff, uint32_t variant); - static bool has_variant(const std::vector<uint32_t> &variants, uint32_t variant); + 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); }; +} // namespace fs + #endif diff --git a/src/tools/floptool.cpp b/src/tools/floptool.cpp index 7be0560bae9..b69c3fe1881 100644 --- a/src/tools/floptool.cpp +++ b/src/tools/floptool.cpp @@ -243,7 +243,7 @@ static int flopcreate(int argc, char *argv[]) return 1; } - fs_meta_data meta; + fs::meta_data meta; image_handler ih; ih.set_on_disk_path(argv[4]); @@ -251,7 +251,7 @@ static int flopcreate(int argc, char *argv[]) return ih.floppy_save(dest_format); } -static void dir_scan(u32 depth, filesystem_t::dir_t dir, std::vector<std::vector<std::string>> &entries, const std::unordered_map<fs_meta_name, size_t> &nmap, size_t nc, const std::vector<fs_meta_description> &dmetad, const std::vector<fs_meta_description> &fmetad) +static void dir_scan(u32 depth, fs::filesystem_t::dir_t dir, std::vector<std::vector<std::string>> &entries, const std::unordered_map<fs::meta_name, size_t> &nmap, size_t nc, const std::vector<fs::meta_description> &dmetad, const std::vector<fs::meta_description> &fmetad) { std::string head; for(u32 i = 0; i != depth; i++) @@ -262,14 +262,14 @@ static void dir_scan(u32 depth, filesystem_t::dir_t dir, std::vector<std::vector entries.resize(id+1); entries[id].resize(nc); switch(c.m_type) { - case fs_dir_entry_type::dir: { + case fs::dir_entry_type::dir: { auto subdir = dir.dir_get(c.m_key); auto meta = subdir.metadata(); for(const auto &m : dmetad) { if(!meta.has(m.m_name)) continue; size_t slot = nmap.find(m.m_name)->second; - std::string val = fs_meta::to_string(m.m_type, meta.get(m.m_name)); + std::string val = fs::meta_value::to_string(m.m_type, meta.get(m.m_name)); if(slot == 0) val = head + "dir " + val; entries[id][slot] = val; @@ -277,17 +277,17 @@ static void dir_scan(u32 depth, filesystem_t::dir_t dir, std::vector<std::vector dir_scan(depth+1, subdir, entries, nmap, nc, dmetad, fmetad); break; } - case fs_dir_entry_type::file: - case fs_dir_entry_type::system_file: { + case fs::dir_entry_type::file: + case fs::dir_entry_type::system_file: { auto file = dir.file_get(c.m_key); auto meta = file.metadata(); for(const auto &m : fmetad) { if(!meta.has(m.m_name)) continue; size_t slot = nmap.find(m.m_name)->second; - std::string val = fs_meta::to_string(m.m_type, meta.get(m.m_name)); + std::string val = fs::meta_value::to_string(m.m_type, meta.get(m.m_name)); if(slot == 0) - val = head + (c.m_type == fs_dir_entry_type::system_file ? "sys " : "file ") + val; + val = head + (c.m_type == fs::dir_entry_type::system_file ? "sys " : "file ") + val; entries[id][slot] = val; } break; @@ -307,20 +307,20 @@ static int generic_dir(image_handler &ih) if(!vmeta.empty()) { std::string vinf = "Volume:"; for(const auto &e : vmetad) - vinf += util::string_format(" %s=%s", fs_meta_data::entry_name(e.m_name), fs_meta::to_string(e.m_type, vmeta.get(e.m_name))); + vinf += util::string_format(" %s=%s", fs::meta_data::entry_name(e.m_name), fs::meta_value::to_string(e.m_type, vmeta.get(e.m_name))); printf("%s\n\n", vinf.c_str()); } - std::vector<fs_meta_name> names; - names.push_back(fs_meta_name::name); + std::vector<fs::meta_name> names; + names.push_back(fs::meta_name::name); for(const auto &e : fmetad) - if(e.m_name != fs_meta_name::name) + if(e.m_name != fs::meta_name::name) names.push_back(e.m_name); for(const auto &e : dmetad) if(std::find(names.begin(), names.end(), e.m_name) == names.end()) names.push_back(e.m_name); - std::unordered_map<fs_meta_name, size_t> nmap; + std::unordered_map<fs::meta_name, size_t> nmap; for(size_t i = 0; i != names.size(); i++) nmap[names[i]] = i; @@ -328,8 +328,8 @@ static int generic_dir(image_handler &ih) std::vector<std::vector<std::string>> entries; entries.resize(1); - for(fs_meta_name n : names) - entries[0].push_back(fs_meta_data::entry_name(n)); + for(fs::meta_name n : names) + entries[0].push_back(fs::meta_data::entry_name(n)); dir_scan(0, root, entries, nmap, names.size(), dmetad, fmetad); @@ -440,7 +440,7 @@ static int generic_read(image_handler &ih, const char *srcpath, const char *dstp fprintf(stderr, "Error: directory %s%c%s not found\n", apath.c_str(), fsm->directory_separator(), path[i].c_str()); return 1; } - if(c[j].m_type != fs_dir_entry_type::dir) { + if(c[j].m_type != fs::dir_entry_type::dir) { fprintf(stderr, "Error: %s%c%s is not a directory\n", apath.c_str(), fsm->directory_separator(), path[i].c_str()); return 1; } @@ -460,14 +460,14 @@ static int generic_read(image_handler &ih, const char *srcpath, const char *dstp auto file = dir.file_get(c[j].m_key); auto meta = file.metadata(); - if(!meta.has(fs_meta_name::length)) { + if(!meta.has(fs::meta_name::length)) { fprintf(stderr, "Error: %s%c%s is not a readable file\n", apath.c_str(), fsm->directory_separator(), path.back().c_str()); return 1; } image_handler::fsave(dstpath, file.read_all()); - bool has_rsrc = fsm->has_rsrc() && meta.has(fs_meta_name::rsrc_length); + bool has_rsrc = fsm->has_rsrc() && meta.has(fs::meta_name::rsrc_length); if(has_rsrc) image_handler::fsave_rsrc(image_handler::path_make_rsrc(dstpath), file.rsrc_read_all()); @@ -565,7 +565,7 @@ static int generic_write(image_handler &ih, const char *srcpath, const char *dst fprintf(stderr, "Error: directory %s%c%s not found\n", apath.c_str(), fsm->directory_separator(), path[i].c_str()); return 1; } - if(c[j].m_type != fs_dir_entry_type::dir) { + if(c[j].m_type != fs::dir_entry_type::dir) { fprintf(stderr, "Error: %s%c%s is not a directory\n", apath.c_str(), fsm->directory_separator(), path[i].c_str()); return 1; } @@ -574,8 +574,8 @@ static int generic_write(image_handler &ih, const char *srcpath, const char *dst } - fs_meta_data meta; - meta.set(fs_meta_name::name, path.back()); + fs::meta_data meta; + meta.set(fs::meta_name::name, path.back()); auto file = dir.file_create(meta); auto filedata = image_handler::fload(srcpath); diff --git a/src/tools/image_handler.cpp b/src/tools/image_handler.cpp index 03ebfb0b847..2bc9e70814b 100644 --- a/src/tools/image_handler.cpp +++ b/src/tools/image_handler.cpp @@ -35,12 +35,12 @@ namespace { m_table->floppy_format_infos.emplace_back(std::make_unique<floppy_format_info>(format(), m_category)); } - virtual void add(const filesystem_manager_t &fs) { + virtual void add(const fs::manager_t &fs) { m_table->filesystem_formats.emplace_back(std::make_unique<filesystem_format>(&fs, m_category)); } }; - struct fs_enum : public filesystem_manager_t::floppy_enumerator { + struct fs_enum : public fs::manager_t::floppy_enumerator { filesystem_format *m_format; fs_enum(filesystem_format *format) : m_format(format) {} @@ -162,6 +162,7 @@ std::vector<u8> image_handler::fload_rsrc(std::string path) auto filedata = fload(path); const u8 *head = filedata.data(); + using fs::filesystem_t; if(filesystem_t::r32b(head+0x00) == 0x00051607 && filesystem_t::r32b(head+0x04) == 0x00020000) { u16 nent = filesystem_t::r16b(head+0x18); @@ -198,6 +199,7 @@ void image_handler::fsave_rsrc(std::string path, const std::vector<u8> &data) { u8 head[0x2a]; + using fs::filesystem_t; filesystem_t::w32b(head+0x00, 0x00051607); // Magic filesystem_t::w32b(head+0x04, 0x00020000); // Version filesystem_t::fill(head+0x08, 0, 16); // Filler @@ -281,12 +283,12 @@ bool image_handler::floppy_save(const floppy_format_info *format) return !format->m_format->save(*io, variants, &m_floppy_image); } -void image_handler::floppy_create(const floppy_create_info *format, fs_meta_data meta) +void image_handler::floppy_create(const floppy_create_info *format, fs::meta_data meta) { if(format->m_type) { std::vector<uint32_t> variants; std::vector<u8> img(format->m_image_size); - fsblk_vec_t blockdev(img); + fs::fsblk_vec_t blockdev(img); auto fs = format->m_manager->mount(blockdev); fs->format(meta); @@ -295,7 +297,7 @@ void image_handler::floppy_create(const floppy_create_info *format, fs_meta_data source_format->load(*io, floppy_image::FF_UNKNOWN, variants, &m_floppy_image); delete source_format; } else { - fs_unformatted::format(format->m_key, &m_floppy_image); + fs::unformatted_image::format(format->m_key, &m_floppy_image); } } @@ -321,7 +323,7 @@ bool image_handler::floppy_mount_fs(const filesystem_format *format) return true; success: - m_fsblk.reset(new fsblk_vec_t(m_sector_image)); + m_fsblk.reset(new fs::fsblk_vec_t(m_sector_image)); m_fsm = format->m_manager; m_fs = m_fsm->mount(*m_fsblk); return false; @@ -332,7 +334,7 @@ bool image_handler::hd_mount_fs(const filesystem_format *format) // Should use the chd mechanisms, one thing at a time... m_sector_image = fload(m_on_disk_path); - m_fsblk.reset(new fsblk_vec_t(m_sector_image)); + m_fsblk.reset(new fs::fsblk_vec_t(m_sector_image)); m_fsm = format->m_manager; m_fs = m_fsm->mount(*m_fsblk); return false; diff --git a/src/tools/image_handler.h b/src/tools/image_handler.h index e56f1af872d..fec66602a43 100644 --- a/src/tools/image_handler.h +++ b/src/tools/image_handler.h @@ -29,7 +29,7 @@ struct floppy_format_info { }; struct floppy_create_info { - const filesystem_manager_t *m_manager; + const fs::manager_t *m_manager; floppy_format_type m_type; u32 m_image_size; @@ -37,7 +37,7 @@ struct floppy_create_info { const char *m_name; const char *m_description; - floppy_create_info(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, const char *description) : + floppy_create_info(const fs::manager_t *manager, floppy_format_type type, u32 image_size, const char *name, const char *description) : m_manager(manager), m_type(type), m_image_size(image_size), m_key(0), m_name(name), m_description(description) { } @@ -47,12 +47,12 @@ struct floppy_create_info { }; struct filesystem_format { - const filesystem_manager_t *m_manager; + const fs::manager_t *m_manager; std::vector<std::unique_ptr<floppy_create_info>> m_floppy_create; std::string m_category; bool m_floppy, m_floppy_raw, m_hd, m_cd; - filesystem_format(const filesystem_manager_t *manager, std::string category) : m_manager(manager), m_category(category), m_floppy(false), m_floppy_raw(false), m_hd(false), m_cd(false) {} + filesystem_format(const fs::manager_t *manager, std::string category) : m_manager(manager), m_category(category), m_floppy(false), m_floppy_raw(false), m_hd(false), m_cd(false) {} }; struct formats_table { @@ -85,12 +85,12 @@ public: bool floppy_load(const floppy_format_info *format); bool floppy_save(const floppy_format_info *format); - void floppy_create(const floppy_create_info *format, fs_meta_data meta); + void floppy_create(const floppy_create_info *format, fs::meta_data meta); bool floppy_mount_fs(const filesystem_format *format); bool hd_mount_fs(const filesystem_format *format); void fs_to_floppy(); - std::pair<const filesystem_manager_t *, filesystem_t *> get_fs() const { return std::make_pair(m_fsm, m_fs.get()); } + std::pair<const fs::manager_t *, fs::filesystem_t *> get_fs() const { return std::make_pair(m_fsm, m_fs.get()); } std::vector<std::string> path_split(std::string path) const; @@ -108,9 +108,9 @@ private: floppy_format_type m_floppy_fs_converter; std::vector<u8> m_sector_image; - std::unique_ptr<fsblk_t> m_fsblk; - const filesystem_manager_t *m_fsm; - std::unique_ptr<filesystem_t> m_fs; + std::unique_ptr<fs::fsblk_t> m_fsblk; + const fs::manager_t *m_fsm; + std::unique_ptr<fs::filesystem_t> m_fs; }; |