summaryrefslogtreecommitdiffstatshomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/devices/bus/oricext/jasmin.cpp2
-rw-r--r--src/devices/bus/vtech/memexp/floppy.cpp2
-rw-r--r--src/devices/imagedev/floppy.cpp12
-rw-r--r--src/devices/imagedev/floppy.h18
-rw-r--r--src/devices/machine/applefdintf.cpp2
-rw-r--r--src/frontend/mame/ui/floppycntrl.cpp2
-rw-r--r--src/lib/formats/all.cpp8
-rw-r--r--src/lib/formats/all.h2
-rw-r--r--src/lib/formats/fs_oric_jasmin.cpp328
-rw-r--r--src/lib/formats/fs_oric_jasmin.h82
-rw-r--r--src/lib/formats/fs_prodos.cpp228
-rw-r--r--src/lib/formats/fs_prodos.h66
-rw-r--r--src/lib/formats/fs_unformatted.cpp26
-rw-r--r--src/lib/formats/fs_unformatted.h14
-rw-r--r--src/lib/formats/fs_vtech.cpp194
-rw-r--r--src/lib/formats/fs_vtech.h60
-rw-r--r--src/lib/formats/fsblk_vec.cpp15
-rw-r--r--src/lib/formats/fsblk_vec.h22
-rw-r--r--src/lib/formats/fsmeta.cpp40
-rw-r--r--src/lib/formats/fsmeta.h84
-rw-r--r--src/lib/formats/fsmgr.cpp176
-rw-r--r--src/lib/formats/fsmgr.h269
-rw-r--r--src/tools/floptool.cpp42
-rw-r--r--src/tools/image_handler.cpp16
-rw-r--r--src/tools/image_handler.h18
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;
};