floppy: Beginning of the support for preformatted floppy images.

What's missing:
- parameters (like the disk name when it exists)
- possibly a cleanup of ram_open and friends (but not sure of the appropriate direction in which to go)

scripts/src/formats.lua

@@ -69,6 +69,11 @@ project "formats"
 		MAME_DIR .. "src/lib/formats/dfi_dsk.cpp",
 		MAME_DIR .. "src/lib/formats/dfi_dsk.h",
 		MAME_DIR .. "src/lib/formats/fdi_dsk.cpp",
+
+		MAME_DIR .. "src/lib/formats/fsmgr.h",
+		MAME_DIR .. "src/lib/formats/fsmgr.cpp",
+		MAME_DIR .. "src/lib/formats/fs_unformatted.h",
+		MAME_DIR .. "src/lib/formats/fs_unformatted.cpp",
 	}
 
 --------------------------------------------------
@@ -1598,10 +1603,10 @@ end
 
 --------------------------------------------------
 --
---@src/lib/formats/rc759_dsk.h,FORMATS["RC759_DSK"] = true
+--@src/lib/formats/rc759_dsk.h,FORMATS["RC759"] = true
 --------------------------------------------------
 
-if opt_tool(FORMATS, "RC759_DSK") then
+if (FORMATS["APRIDISK"]~=null  or _OPTIONS["with-tools"]) then
 	files {
 		MAME_DIR.. "src/lib/formats/rc759_dsk.cpp",
 		MAME_DIR.. "src/lib/formats/rc759_dsk.h",
@@ -2052,4 +2057,16 @@ if opt_tool(FORMATS, "ZX81_P") then
 	}
 end
 
+--------------------------------------------------
+--
+--@src/lib/formats/fs_prodos.h,FORMATS["FS_PRODOS"] = true
+--------------------------------------------------
+
+if opt_tool(FORMATS, "FS_PRODOS") then
+	files {
+		MAME_DIR.. "src/lib/formats/fs_prodos.cpp",
+		MAME_DIR.. "src/lib/formats/fs_prodos.h",
+	}
+end
+
 end

scripts/target/mame/mess.lua

@@ -981,6 +981,7 @@ BUSES["X68K"] = true
 BUSES["Z29_KBD"] = true
 BUSES["Z88"] = true
 BUSES["ZORRO"] = true
+BUSES["THOMSON"] = true
 
 --------------------------------------------------
 -- specify used file formats
@@ -1111,7 +1112,7 @@ FORMATS["PPG_DSK"] = true
 FORMATS["PRIMOPTP"] = true
 FORMATS["PYLDIN_DSK"] = true
 FORMATS["QL_DSK"] = true
-FORMATS["RC759_DSK"] = true
+FORMATS["RC759"] = true
 FORMATS["RK_CAS"] = true
 FORMATS["RX50_DSK"] = true
 FORMATS["SC3000_BIT"] = true
@@ -1150,6 +1151,7 @@ FORMATS["X07_CAS"] = true
 FORMATS["X1_TAP"] = true
 FORMATS["XDF_DSK"] = true
 FORMATS["ZX81_P"] = true
+FORMATS["FS_PRODOS"] = true
 
 --------------------------------------------------
 -- this is the list of driver libraries that
@@ -3928,8 +3930,6 @@ files {
 	MAME_DIR .. "src/mame/drivers/thomson.cpp",
 	MAME_DIR .. "src/mame/includes/thomson.h",
 	MAME_DIR .. "src/mame/machine/thomson.cpp",
-	MAME_DIR .. "src/mame/machine/thomflop.cpp",
-	MAME_DIR .. "src/mame/machine/thomflop.h",
 	MAME_DIR .. "src/mame/video/thomson.cpp",
 }
 

src/devices/imagedev/floppy.cpp

@@ -20,6 +20,8 @@
 #include "formats/dsk_dsk.h"
 #include "formats/pc_dsk.h"
 
+#include "formats/fs_unformatted.h"
+
 #include "speaker.h"
 #include "formats/imageutl.h"
 #include "zippath.h"
@@ -139,6 +141,8 @@ format_registration::format_registration()
 {
 	add(FLOPPY_MFI_FORMAT); // Our generic format
 	add(FLOPPY_DFI_FORMAT); // Flux format, dying
+
+	add(FS_UNFORMATTED);
 }
 
 void format_registration::add_fm_containers()
@@ -170,6 +174,11 @@ void format_registration::add(floppy_format_type format)
 	m_formats.push_back(format);
 }
 
+void format_registration::add(filesystem_manager_type fs)
+{
+	m_fs.push_back(fs);
+}
+
 void floppy_image_device::default_fm_floppy_formats(format_registration &fr)
 {
 	fr.add_fm_containers();
@@ -299,11 +308,21 @@ void floppy_image_device::setup_led_cb(led_cb cb)
 	cur_led_cb = cb;
 }
 
-void floppy_image_device::set_formats(std::function<void (format_registration &fr)> formats)
+void floppy_image_device::fs_enum::add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description)
+{
+	m_fid->m_fs.emplace_back(fs_info(manager, type, image_size, name, key, description));
+}
+
+void floppy_image_device::fs_enum::add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description)
+{
+	m_fid->m_fs.emplace_back(fs_info(manager, name, key, description));
+}
+
+void floppy_image_device::register_formats()
 {
 	format_registration fr;
-	if(formats)
+	if(format_registration_cb)
-		formats(fr);
+		format_registration_cb(fr);
 
 	extension_list[0] = '\0';
 	fif_list = nullptr;
@@ -320,6 +339,19 @@ void floppy_image_device::set_formats(std::function<void (format_registration &f
 
 		image_specify_extension( extension_list, 256, fif->extensions() );
 	}
+
+	fs_enum fse(this);
+	for(filesystem_manager_type fmt : fr.m_fs)
+	{
+		auto ff = fmt();
+		ff->enumerate(fse, form_factor, variants);
+		m_fs_managers.push_back(std::unique_ptr<filesystem_manager_t>(ff));
+	}		
+}
+
+void floppy_image_device::set_formats(std::function<void (format_registration &fr)> formats)
+{
+	format_registration_cb = formats;
 }
 
 floppy_image_format_t *floppy_image_device::get_formats() const
@@ -400,6 +432,7 @@ void floppy_image_device::device_start()
 	phases = 0;
 
 	setup_characteristics();
+	register_formats();
 
 	if (m_make_sound) m_sound_out = subdevice<floppy_sound_device>(FLOPSND_TAG);
 
@@ -611,6 +644,87 @@ image_init_result floppy_image_device::call_create(int format_type, util::option
 	return image_init_result::PASS;
 }
 
+// Should that go into ioprocs?  Should ioprocs be turned into something C++?
+
+struct iofile_ram {
+	std::vector<u8> *data;
+	int64_t pos;
+};
+
+static void ram_closeproc(void *file)
+{
+	auto f = (iofile_ram *)file;
+	delete f;
+}
+
+static int ram_seekproc(void *file, int64_t offset, int whence)
+{
+	auto f = (iofile_ram *)file;
+	switch(whence) {
+	case SEEK_SET: f->pos = offset; break;
+	case SEEK_CUR: f->pos += offset; break;
+	case SEEK_END: f->pos = f->data->size() + offset; break;
+	}
+
+	f->pos = std::clamp(f->pos, int64_t(0), int64_t(f->data->size()));
+	return 0;
+}
+
+static size_t ram_readproc(void *file, void *buffer, size_t length)
+{
+	auto f = (iofile_ram *)file;
+	size_t l = std::min(length, f->data->size() - f->pos);
+	memcpy(buffer, f->data->data() + f->pos, l);
+	return l;
+}
+
+static size_t ram_writeproc(void *file, const void *buffer, size_t length)
+{
+	auto f = (iofile_ram *)file;
+	size_t l = std::min(length, f->data->size() - f->pos);
+	memcpy(f->data->data() + f->pos, buffer, l);
+	return l;
+}
+
+static uint64_t ram_filesizeproc(void *file)
+{
+	auto f = (iofile_ram *)file;
+	return f->data->size();
+}
+
+
+static const io_procs iop_ram = {
+	ram_closeproc,
+	ram_seekproc,
+	ram_readproc,
+	ram_writeproc,
+	ram_filesizeproc
+};
+
+static io_generic *ram_open(std::vector<u8> &data)
+{
+	iofile_ram *f = new iofile_ram;
+	f->data = &data;
+	f->pos = 0;
+	return new io_generic({ &iop_ram, f });
+}
+
+void floppy_image_device::init_fs(const fs_info *fs)
+{
+	if (fs->m_type)
+	{
+		std::vector<u8> img(fs->m_image_size);
+		fs->m_manager->floppy_instantiate(fs->m_key, img);
+		auto iog = ram_open(img);
+		auto source_format = fs->m_type();
+		source_format->load(iog, floppy_image::FF_UNKNOWN, variants, image.get());
+		delete source_format;
+		delete iog;
+
+	} else
+		fs->m_manager->floppy_instantiate_raw(fs->m_key, image.get());
+}
+
 /* write protect, active high
    phase 1 can force it to 1 for drive detection
    on the rare drives that actually use phases.
@@ -2293,7 +2407,7 @@ void teac_fd_30a::setup_characteristics()
 	sides = 1;
 	set_rpm(300);
 
-	variants.push_back(floppy_image::SSSD);
+	variants.push_back(floppy_image::SSDD);
 }
 
 //-------------------------------------------------

src/devices/imagedev/floppy.h

@@ -12,6 +12,7 @@
 #pragma once
 
 #include "formats/flopimg.h"
+#include "formats/fsmgr.h"
 #include "sound/samples.h"
 #include "softlist_dev.h"
 
@@ -26,12 +27,14 @@ public:
 	format_registration();
 
 	void add(floppy_format_type format);
+	void add(filesystem_manager_type fs);
 
 	void add_fm_containers();
 	void add_mfm_containers();
 	void add_pc_formats();
 
 	std::vector<floppy_format_type> m_formats;
+	std::vector<filesystem_manager_type> m_fs;
 };
 
 class floppy_image_device : public device_t,
@@ -45,15 +48,45 @@ public:
 	typedef delegate<void (floppy_image_device *, int)> wpt_cb;
 	typedef delegate<void (floppy_image_device *, int)> led_cb;
 
+	struct fs_info {
+		const filesystem_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, u32 key, const char *description) :
+			m_manager(manager),
+			m_type(type),
+			m_image_size(image_size),
+			m_name(name),
+			m_key(key),
+			m_description(description)
+		{}
+		
+		fs_info(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) :
+			m_manager(manager),
+			m_type(nullptr),
+			m_image_size(0),
+			m_name(name),
+			m_key(key),
+			m_description(description)
+		{}
+	};
+
 	// construction/destruction
 	virtual ~floppy_image_device();
 
 	void set_formats(std::function<void (format_registration &fr)> formats);
 	floppy_image_format_t *get_formats() const;
+	const std::vector<fs_info> &get_fs() const { return m_fs; }
 	floppy_image_format_t *get_load_format() const;
 	floppy_image_format_t *identify(std::string filename);
 	void set_rpm(float rpm);
 
+	void init_fs(const fs_info *fs);
+
 	// image-level overrides
 	virtual image_init_result call_load() override;
 	virtual void call_unload() override;
@@ -120,6 +153,14 @@ public:
 	void    enable_sound(bool doit) { m_make_sound = doit; }
 
 protected:
+	struct fs_enum : public filesystem_manager_t::floppy_enumerator {
+		floppy_image_device *m_fid;
+		fs_enum(floppy_image_device *fid) : filesystem_manager_t::floppy_enumerator(), m_fid(fid) {};
+		
+		virtual void add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) override;
+		virtual void add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) override;
+	};
+
 	floppy_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
 
 	// device-level overrides
@@ -137,12 +178,15 @@ protected:
 
 	void init_floppy_load(bool write_supported);
 
+	std::function<void (format_registration &fr)> format_registration_cb;
 	floppy_image_format_t *input_format;
 	floppy_image_format_t *output_format;
 	std::vector<uint32_t> variants;
 	std::unique_ptr<floppy_image> image;
 	char                  extension_list[256];
 	floppy_image_format_t *fif_list;
+	std::vector<fs_info>  m_fs;
+	std::vector<std::unique_ptr<filesystem_manager_t>> m_fs_managers;
 	emu_timer             *index_timer;
 
 	/* Physical characteristics, filled by setup_characteristics */
@@ -197,6 +241,8 @@ protected:
 	wpt_cb cur_wpt_cb;
 	led_cb cur_led_cb;
 
+	void register_formats();
+
 	void check_led();
 	uint32_t find_position(attotime &base, const attotime &when);
 	int find_index(uint32_t position, const std::vector<uint32_t> &buf) const;

src/devices/machine/applefdintf.cpp

@@ -6,6 +6,7 @@
 #include "formats/ap2_dsk.h"
 #include "formats/ap_dsk35.h"
 #include "formats/pc_dsk.h"
+#include "formats/fs_prodos.h"
 
 void applefdintf_device::formats_525_13(format_registration &fr)
 {
@@ -30,6 +31,8 @@ void applefdintf_device::formats_35(format_registration &fr)
 	fr.add(FLOPPY_WOZ_FORMAT);
 	fr.add(FLOPPY_APPLE_GCR_FORMAT);
 	fr.add(FLOPPY_APPLE_2MG_FORMAT);
+
+	fr.add(FS_PRODOS);
 }
 
 void applefdintf_device::floppies_525(device_slot_interface &device)

src/frontend/mame/ui/filecreate.cpp

@@ -291,4 +291,59 @@ void menu_select_format::handle()
 }
 
 
+/***************************************************************************
+SELECT FORMAT MENU
+***************************************************************************/
+
+//-------------------------------------------------
+//  ctor
+//-------------------------------------------------
+
+menu_select_floppy_init::menu_select_floppy_init(mame_ui_manager &mui, render_container &container, const std::vector<floppy_image_device::fs_info> &fs, int *result)
+	: menu(mui, container),
+	  m_fs(fs),
+	  m_result(result)
+	  
+{
+}
+
+
+//-------------------------------------------------
+//  dtor
+//-------------------------------------------------
+
+menu_select_floppy_init::~menu_select_floppy_init()
+{
+}
+
+
+//-------------------------------------------------
+//  populate
+//-------------------------------------------------
+
+void menu_select_floppy_init::populate(float &customtop, float &custombottom)
+{
+	item_append(_("Select initial contents"), FLAG_DISABLE, nullptr);
+	int id = 0;
+	for (const auto &fmt : m_fs)
+		item_append(fmt.m_description, fmt.m_name, 0, (void *)(uintptr_t)(id++));
+}
+
+
+//-------------------------------------------------
+//  handle
+//-------------------------------------------------
+
+void menu_select_floppy_init::handle()
+{
+	// process the menu
+	const event *event = process(0);
+	if (event != nullptr && event->iptkey == IPT_UI_SELECT)
+	{
+		*m_result = int(uintptr_t(event->itemref));
+		stack_pop();
+	}
+}
+
+
 } // namespace ui

src/frontend/mame/ui/filecreate.h

@@ -14,6 +14,7 @@
 #pragma once
 
 #include "ui/menu.h"
+#include "imagedev/floppy.h"
 
 class floppy_image_format_t;
 
@@ -77,6 +78,24 @@ private:
 	int *                       m_result;
 };
 
+// ======================> menu_select_floppy_init
+
+class menu_select_floppy_init : public menu
+{
+public:
+	menu_select_floppy_init(mame_ui_manager &mui, render_container &container,
+		const std::vector<floppy_image_device::fs_info> &fs, int *result);
+	virtual ~menu_select_floppy_init() override;
+
+private:
+	virtual void populate(float &customtop, float &custombottom) override;
+	virtual void handle() override;
+
+	// internal state
+	const std::vector<floppy_image_device::fs_info> &m_fs;
+	int *                                            m_result;
+};
+
 
 } // namespace ui
 

src/frontend/mame/ui/floppycntrl.cpp

@@ -26,6 +26,7 @@ menu_control_floppy_image::menu_control_floppy_image(mame_ui_manager &mui, rende
 	fd(dynamic_cast<floppy_image_device &>(image)),
 	input_format(nullptr),
 	output_format(nullptr),
+	create_fs(nullptr),
 	input_filename(),
 	output_filename()
 {
@@ -48,6 +49,8 @@ void menu_control_floppy_image::do_load_create()
 			machine().popmessage("Error: %s", fd.error());
 			return;
 		}
+		if (create_fs)
+			fd.init_fs(create_fs);
 	} else {
 		image_init_result err = fd.load(input_filename);
 		if ((err == image_init_result::PASS) && (output_filename.compare("") != 0))
@@ -122,8 +125,27 @@ void menu_control_floppy_image::handle()
 			m_state = START_FILE;
 			handle();
 		} else {
+			const auto &fs = fd.get_fs();
 			output_filename = util::zippath_combine(m_current_directory, m_current_file);
 			output_format = format_array[m_submenu_result.i];
+			if(fs.size() == 1) {
+				create_fs = &fs[0];
+				do_load_create();
+				stack_pop();
+			} else {
+				m_submenu_result.i = -1;
+				menu::stack_push<menu_select_floppy_init>(ui(), container(), fs, &m_submenu_result.i);
+				m_state = SELECT_INIT;
+			}
+		}
+		break;
+
+	case SELECT_INIT:
+		if(m_submenu_result.i == -1) {
+			m_state = START_FILE;
+			handle();
+		} else {
+			create_fs = &fd.get_fs()[m_submenu_result.i];
 			do_load_create();
 			stack_pop();
 		}

src/frontend/mame/ui/floppycntrl.h

@@ -27,11 +27,12 @@ public:
 	virtual ~menu_control_floppy_image() override;
 
 private:
-	enum { SELECT_FORMAT = LAST_ID, SELECT_MEDIA, SELECT_RW };
+	enum { SELECT_FORMAT = LAST_ID, SELECT_MEDIA, SELECT_INIT, SELECT_RW };
 
 	floppy_image_device &fd;
 	std::unique_ptr<floppy_image_format_t * []> format_array;
 	floppy_image_format_t *input_format, *output_format;
+	const floppy_image_device::fs_info *create_fs;
 	std::string input_filename, output_filename;
 
 	virtual void handle() override;

src/lib/formats/all.cpp

@@ -19,6 +19,7 @@
 #include "pc_dsk.h"
 #include "d88_dsk.h"
 #include "dfi_dsk.h"
+#include "fs_unformatted.h"
 
 #ifdef HAS_FORMATS_2D_DSK
 #include "2d_dsk.h"
@@ -664,9 +665,14 @@
 #include "zx81_p.h"
 #endif
 
+#ifdef HAS_FORMATS_FS_PRODOS
+#include "fs_prodos.h"
+#endif
+
 void mame_formats_full_list(mame_formats_enumerator &en)
 {
 	en.category("Generic");
+	en.add(FS_UNFORMATTED);
 	en.add(cassette_default_formats);
 #ifdef HAS_FORMATS_UEF_CAS
 	en.add(uef_cassette_formats); // uef_cas.h
@@ -689,6 +695,9 @@ void mame_formats_full_list(mame_formats_enumerator &en)
 #endif
 
 	en.category("Apple");
+#ifdef HAS_FORMATS_FS_PRODOS
+	en.add(FS_PRODOS);
+#endif
 #ifdef HAS_FORMATS_AP2_DSK
 	en.add(FLOPPY_A216S_FORMAT); // ap2_dsk.h
 	en.add(FLOPPY_RWTS18_FORMAT); // ap2_dsk.h

src/lib/formats/all.h

@@ -10,6 +10,7 @@
 
 #include "cassimg.h"
 #include "flopimg.h"
+#include "fsmgr.h"
 
 struct mame_formats_enumerator {
 	virtual ~mame_formats_enumerator() = default;
@@ -17,6 +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(filesystem_manager_type fs) = 0;
 };
 
 void mame_formats_full_list(mame_formats_enumerator &en);

src/lib/formats/fs_prodos.cpp

@@ -0,0 +1,76 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Creation of Apple ProDOS floppy images
+
+#include "emu.h"
+#include "fs_prodos.h"
+#include "ap_dsk35.h"
+
+const u8 fs_prodos::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,
+	0x48, 0x60, 0x85, 0x40, 0x85, 0x48, 0xa0, 0x5e, 0xb1, 0x48, 0x99, 0x94, 0x09, 0xc8, 0xc0, 0xeb,
+	0xd0, 0xf6, 0xa2, 0x06, 0xbc, 0x32, 0x09, 0xbd, 0x39, 0x09, 0x99, 0xf2, 0x09, 0xbd, 0x40, 0x09,
+	0x9d, 0x7f, 0x0a, 0xca, 0x10, 0xee, 0xa9, 0x09, 0x85, 0x49, 0xa9, 0x86, 0xa0, 0x00, 0xc9, 0xf9,
+	0xb0, 0x2f, 0x85, 0x48, 0x84, 0x60, 0x84, 0x4a, 0x84, 0x4c, 0x84, 0x4e, 0x84, 0x47, 0xc8, 0x84,
+	0x42, 0xc8, 0x84, 0x46, 0xa9, 0x0c, 0x85, 0x61, 0x85, 0x4b, 0x20, 0x27, 0x09, 0xb0, 0x66, 0xe6,
+	0x61, 0xe6, 0x61, 0xe6, 0x46, 0xa5, 0x46, 0xc9, 0x06, 0x90, 0xef, 0xad, 0x00, 0x0c, 0x0d, 0x01,
+	0x0c, 0xd0, 0x52, 0xa9, 0x04, 0xd0, 0x02, 0xa5, 0x4a, 0x18, 0x6d, 0x23, 0x0c, 0xa8, 0x90, 0x0d,
+	0xe6, 0x4b, 0xa5, 0x4b, 0x4a, 0xb0, 0x06, 0xc9, 0x0a, 0xf0, 0x71, 0xa0, 0x04, 0x84, 0x4a, 0xad,
+	0x20, 0x09, 0x29, 0x0f, 0xa8, 0xb1, 0x4a, 0xd9, 0x20, 0x09, 0xd0, 0xdb, 0x88, 0x10, 0xf6, 0xa0,
+	0x16, 0xb1, 0x4a, 0x4a, 0x6d, 0x1f, 0x09, 0x8d, 0x1f, 0x09, 0xa0, 0x11, 0xb1, 0x4a, 0x85, 0x46,
+	0xc8, 0xb1, 0x4a, 0x85, 0x47, 0xa9, 0x00, 0x85, 0x4a, 0xa0, 0x1e, 0x84, 0x4b, 0x84, 0x61, 0xc8,
+	0x84, 0x4d, 0x20, 0x27, 0x09, 0xb0, 0x35, 0xe6, 0x61, 0xe6, 0x61, 0xa4, 0x4e, 0xe6, 0x4e, 0xb1,
+	0x4a, 0x85, 0x46, 0xb1, 0x4c, 0x85, 0x47, 0x11, 0x4a, 0xd0, 0x18, 0xa2, 0x01, 0xa9, 0x00, 0xa8,
+	0x91, 0x60, 0xc8, 0xd0, 0xfb, 0xe6, 0x61, 0xea, 0xea, 0xca, 0x10, 0xf4, 0xce, 0x1f, 0x09, 0xf0,
+	0x07, 0xd0, 0xd8, 0xce, 0x1f, 0x09, 0xd0, 0xca, 0x58, 0x4c, 0x00, 0x20, 0x4c, 0x47, 0x09, 0x02,
+	0x26, 0x50, 0x52, 0x4f, 0x44, 0x4f, 0x53, 0xa5, 0x60, 0x85, 0x44, 0xa5, 0x61, 0x85, 0x45, 0x6c,
+	0x48, 0x00, 0x08, 0x1e, 0x24, 0x3f, 0x45, 0x47, 0x76, 0xf4, 0xd7, 0xd1, 0xb6, 0x4b, 0xb4, 0xac,
+	0xa6, 0x2b, 0x18, 0x60, 0x4c, 0xbc, 0x09, 0x20, 0x58, 0xfc, 0xa0, 0x14, 0xb9, 0x58, 0x09, 0x99,
+	0xb1, 0x05, 0x88, 0x10, 0xf7, 0x4c, 0x55, 0x09, 0xd5, 0xce, 0xc1, 0xc2, 0xcc, 0xc5, 0xa0, 0xd4,
+	0xcf, 0xa0, 0xcc, 0xcf, 0xc1, 0xc4, 0xa0, 0xd0, 0xd2, 0xcf, 0xc4, 0xcf, 0xd3, 0xa5, 0x53, 0x29,
+	0x03, 0x2a, 0x05, 0x2b, 0xaa, 0xbd, 0x80, 0xc0, 0xa9, 0x2c, 0xa2, 0x11, 0xca, 0xd0, 0xfd, 0xe9,
+	0x01, 0xd0, 0xf7, 0xa6, 0x2b, 0x60, 0xa5, 0x46, 0x29, 0x07, 0xc9, 0x04, 0x29, 0x03, 0x08, 0x0a,
+	0x28, 0x2a, 0x85, 0x3d, 0xa5, 0x47, 0x4a, 0xa5, 0x46, 0x6a, 0x4a, 0x4a, 0x85, 0x41, 0x0a, 0x85,
+	0x51, 0xa5, 0x45, 0x85, 0x27, 0xa6, 0x2b, 0xbd, 0x89, 0xc0, 0x20, 0xbc, 0x09, 0xe6, 0x27, 0xe6,
+	0x3d, 0xe6, 0x3d, 0xb0, 0x03, 0x20, 0xbc, 0x09, 0xbc, 0x88, 0xc0, 0x60, 0xa5, 0x40, 0x0a, 0x85,
+	0x53, 0xa9, 0x00, 0x85, 0x54, 0xa5, 0x53, 0x85, 0x50, 0x38, 0xe5, 0x51, 0xf0, 0x14, 0xb0, 0x04,
+	0xe6, 0x53, 0x90, 0x02, 0xc6, 0x53, 0x38, 0x20, 0x6d, 0x09, 0xa5, 0x50, 0x18, 0x20, 0x6f, 0x09,
+	0xd0, 0xe3, 0xa0, 0x7f, 0x84, 0x52, 0x08, 0x28, 0x38, 0xc6, 0x52, 0xf0, 0xce, 0x18, 0x08, 0x88,
+	0xf0, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+void fs_prodos::enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const
+{
+	bool all = form_factor == floppy_image::FF_UNKNOWN;
+
+	if(all || (form_factor == floppy_image::FF_35 && has_variant(variants, floppy_image::DSDD)))
+		fe.add(this, FLOPPY_APPLE_GCR_FORMAT, 819200, "prodos_800k", 800, "Apple ProDOS 800K");
+	if(all || (form_factor == floppy_image::FF_35 && has_variant(variants, floppy_image::SSDD)))
+		fe.add(this, FLOPPY_APPLE_GCR_FORMAT, 409600, "prodos_400k", 400, "Apple ProDOS 400K");
+}
+
+void fs_prodos::floppy_instantiate(u32 key, std::vector<u8> &image) const
+{
+	if(key == 800) {
+		copy(image, 0x000, boot, 512);
+		w8  (image, 0x402, 0x03);
+		w8  (image, 0x404, 0xf8);
+		wstr(image, 0x405, "UNTITLED");
+		w32b(image, 0x416, 0x642a250d);
+		w16b(image, 0x41a, 0x80ff);
+		w32b(image, 0x41c, 0x642a250d);
+		w32b(image, 0x420, 0x0500c327);
+		w32b(image, 0x424, 0x0d000006);
+		w32b(image, 0x428, 0x00400600);
+		w32b(image, 0x600, 0x02000400);
+		w32b(image, 0x800, 0x03000500);
+		w8  (image, 0xa00, 0x04);
+		w8  (image, 0xc00, 0x01);
+		fill(image, 0xc01, 0xff, 199);	
+	}
+}
+
+const filesystem_manager_type FS_PRODOS = &filesystem_manager_creator<fs_prodos>;;

src/lib/formats/fs_prodos.h

@@ -0,0 +1,26 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Creation of Apple ProDOS floppy images
+
+#ifndef MAME_FORMATS_FS_PRODOS_H
+#define MAME_FORMATS_FS_PRODOS_H
+
+#pragma once
+
+#include "fsmgr.h"
+
+class fs_prodos : public filesystem_manager_t {
+public:
+	fs_prodos() : filesystem_manager_t() {}
+
+	virtual void enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override;
+	virtual void floppy_instantiate(u32 key, std::vector<u8> &image) const override;
+
+private:
+	static const u8 boot[512];
+};
+
+extern const filesystem_manager_type FS_PRODOS;
+
+#endif

src/lib/formats/fs_unformatted.cpp

@@ -0,0 +1,99 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Creation of unformatted floppy images
+
+#include "emu.h"
+#include "fs_unformatted.h"
+
+void fs_unformatted::enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const
+{
+	bool all = form_factor == floppy_image::FF_UNKNOWN;
+	u32 best_8 =
+		form_factor == floppy_image::FF_8 ?
+		has_variant(variants, floppy_image::DSDD) ? FSI_8_DSDD :
+		has_variant(variants, floppy_image::DSSD) ? FSI_8_DSSD : FSI_8_SSSD
+		: FSI_NONE;
+
+	u32 best_525 =
+		form_factor == floppy_image::FF_525 ?
+		has_variant(variants, floppy_image::DSHD) ? FSI_525_DSHD :
+		has_variant(variants, floppy_image::DSQD) ? FSI_525_DSQD :
+		has_variant(variants, floppy_image::DSDD) ? FSI_525_DSDD :
+		has_variant(variants, floppy_image::SSQD) ? FSI_525_SSQD :
+		has_variant(variants, floppy_image::SSDD) ? FSI_525_SSDD : FSI_525_SSSD
+		: FSI_NONE;
+
+	u32 best_35 =
+		form_factor == floppy_image::FF_35 ?
+		has_variant(variants, floppy_image::DSDD) ? FSI_35_DSDD : FSI_35_SSDD
+		: FSI_NONE;
+
+	u32 best_3 =
+		form_factor == floppy_image::FF_3 ?
+		has_variant(variants, floppy_image::DSDD) ? FSI_3_DSDD : FSI_3_SSDD
+		: FSI_NONE;
+
+	if(all || best_8 == FSI_8_DSDD)
+		fe.add_raw(this, "u8dsdd", FSI_8_DSDD, "Unformatted 8\" double-sided double-density");
+	if(all || best_8 == FSI_8_DSSD)
+		fe.add_raw(this, "u8dssd", FSI_8_DSSD, "Unformatted 8\" double-sided single-density");
+	if(all || best_8 == FSI_8_SSSD)
+		fe.add_raw(this, "u8sssd", FSI_8_SSSD, "Unformatted 8\" single-sided single-density");
+
+	if(all || best_525 == FSI_525_DSHD)
+		fe.add_raw(this, "u525dshd", FSI_525_DSHD, "Unformatted 5\"25 double-sided high-density");
+	if(all || best_525 == FSI_525_DSQD)
+		fe.add_raw(this, "u525dsqd", FSI_525_DSQD, "Unformatted 5\"25 double-sided quad-density");
+	if(all || best_525 == FSI_525_DSDD)
+		fe.add_raw(this, "u525dsdd", FSI_525_DSDD, "Unformatted 5\"25 double-sided double-density");
+	if(all)
+		fe.add_raw(this, "u525dssd", FSI_525_DSSD, "Unformatted 5\"25 double-sided single-density");
+	if(all || best_525 == FSI_525_SSQD)
+		fe.add_raw(this, "u525ssqd", FSI_525_SSQD, "Unformatted 5\"25 single-sided quad-density");
+	if(all || best_525 == FSI_525_SSDD)
+		fe.add_raw(this, "u525ssdd", FSI_525_SSDD, "Unformatted 5\"25 single-sided double-density");
+	if(all || best_525 == FSI_525_SSSD)
+		fe.add_raw(this, "u525sssd", FSI_525_SSSD, "Unformatted 5\"25 single-sided single-density");
+
+	if(all || has_variant(variants, floppy_image::DSED))
+		fe.add_raw(this, "u35dsed", FSI_35_DSED, "Unformatted 3\"5 double-sided extra-density");
+	if(all || has_variant(variants, floppy_image::DSHD))
+		fe.add_raw(this, "u35dshd", FSI_35_DSHD, "Unformatted 3\"5 double-sided high-density");
+	if(all || best_35 == FSI_35_DSDD)
+		fe.add_raw(this, "u35dsdd", FSI_35_DSDD, "Unformatted 3\"5 double-sided double-density");
+	if(all || best_35 == FSI_35_SSDD)
+		fe.add_raw(this, "u35ssdd", FSI_35_SSDD, "Unformatted 3\"5 single-sided double-density");
+
+	if(all || best_3 == FSI_3_DSDD)
+		fe.add_raw(this, "u3dsdd", FSI_35_DSDD, "Unformatted 3\" double-sided double-density");
+	if(all || best_3 == FSI_3_SSDD)
+		fe.add_raw(this, "u3ssdd", FSI_35_SSDD, "Unformatted 3\" single-sided double-density");
+}
+
+void fs_unformatted::floppy_instantiate_raw(u32 key, floppy_image *image) const
+{
+	switch(key) {
+	case FSI_8_DSDD: image->set_form_variant(floppy_image::FF_8, floppy_image::DSDD); break;
+	case FSI_8_DSSD: image->set_form_variant(floppy_image::FF_8, floppy_image::DSSD); break;
+	case FSI_8_SSSD: image->set_form_variant(floppy_image::FF_8, floppy_image::SSSD); break;
+
+	case FSI_525_DSHD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSHD); break;
+	case FSI_525_DSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSQD); break;
+	case FSI_525_DSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSDD); break;
+	case FSI_525_DSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSSD); break;
+	case FSI_525_SSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSQD); break;
+	case FSI_525_SSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSDD); break;
+	case FSI_525_SSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD); break;
+
+	case FSI_35_DSED: image->set_form_variant(floppy_image::FF_35, floppy_image::DSED); break;
+	case FSI_35_DSHD: image->set_form_variant(floppy_image::FF_35, floppy_image::DSHD); break;
+	case FSI_35_DSDD: image->set_form_variant(floppy_image::FF_35, floppy_image::DSDD); break;
+	case FSI_35_SSDD: image->set_form_variant(floppy_image::FF_35, floppy_image::SSDD); break;
+
+	case FSI_3_DSDD: image->set_form_variant(floppy_image::FF_3, floppy_image::DSDD); break;
+	case FSI_3_SSDD: image->set_form_variant(floppy_image::FF_3, floppy_image::SSDD); break;
+	}
+}
+
+const filesystem_manager_type FS_UNFORMATTED = &filesystem_manager_creator<fs_unformatted>;

src/lib/formats/fs_unformatted.h

@@ -0,0 +1,48 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Creation of unformatted floppy images
+
+#ifndef MAME_FORMATS_FS_UNFORMATTED_H
+#define MAME_FORMATS_FS_UNFORMATTED_H
+
+#pragma once
+
+#include "fsmgr.h"
+
+class fs_unformatted : public filesystem_manager_t {
+public:
+	fs_unformatted() : filesystem_manager_t() {}
+
+	virtual void enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override;
+	virtual void floppy_instantiate_raw(u32 key, floppy_image *image) const override;
+
+private:
+	enum {
+		FSI_NONE,
+
+		FSI_8_SSSD,
+		FSI_8_DSSD,
+		FSI_8_DSDD,
+
+		FSI_525_SSSD,
+		FSI_525_SSDD,
+		FSI_525_SSQD,
+		FSI_525_DSSD,
+		FSI_525_DSDD,
+		FSI_525_DSQD,
+		FSI_525_DSHD,
+
+		FSI_35_SSDD,
+		FSI_35_DSDD,
+		FSI_35_DSHD,
+		FSI_35_DSED,
+
+		FSI_3_DSDD,
+		FSI_3_SSDD,
+	};
+};
+
+extern const filesystem_manager_type FS_UNFORMATTED;
+
+#endif

src/lib/formats/fsmgr.cpp

@@ -0,0 +1,81 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Filesystem management code for floppy and hd images
+
+// Currently limited to floppies and creation of preformatted images
+
+#include "emu.h"
+#include "fsmgr.h"
+
+void filesystem_manager_t::enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const
+{
+}
+
+void filesystem_manager_t::floppy_instantiate(u32 key, std::vector<u8> &image) const
+{
+	fprintf(stderr, "filesystem_manager_t::floppy_instantiate called while unsupported\n");
+	abort();
+}
+
+void filesystem_manager_t::floppy_instantiate_raw(u32 key, floppy_image *image) const
+{
+	fprintf(stderr, "filesystem_manager_t::floppy_instantiate_raw called while unsupported\n");
+	abort();
+}
+
+bool filesystem_manager_t::has_variant(const std::vector<uint32_t> &variants, uint32_t variant)
+{
+	for(uint32_t v : variants)
+		if(variant == v)
+			return true;
+	return false;
+}
+
+void filesystem_manager_t::copy(std::vector<u8> &image, u32 offset, const u8 *src, u32 size)
+{
+	memcpy(image.data() + offset, src, size);
+}
+
+void filesystem_manager_t::fill(std::vector<u8> &image, u32 offset, u8 data, u32 size)
+{
+	memset(image.data() + offset, data, size);
+}
+
+void filesystem_manager_t::wstr(std::vector<u8> &image, u32 offset, const char *str)
+{
+	memcpy(image.data() + offset, str, strlen(str)+1);
+}
+
+void filesystem_manager_t::w8(std::vector<u8> &image, u32 offset, u8 data)
+{
+	image[offset] = data;
+}
+
+void filesystem_manager_t::w16b(std::vector<u8> &image, u32 offset, u16 data)
+{
+	image[offset  ] = data >> 8;
+	image[offset+1] = data;
+}
+
+void filesystem_manager_t::w32b(std::vector<u8> &image, u32 offset, u32 data)
+{
+	image[offset  ] = data >> 24;
+	image[offset+1] = data >> 16;
+	image[offset+2] = data >> 8;
+	image[offset+3] = data;
+}
+
+void filesystem_manager_t::w16l(std::vector<u8> &image, u32 offset, u16 data)
+{
+	image[offset  ] = data;
+	image[offset+1] = data >> 8;
+}
+
+void filesystem_manager_t::w32l(std::vector<u8> &image, u32 offset, u32 data)
+{
+	image[offset  ] = data;
+	image[offset+1] = data >> 8;
+	image[offset+2] = data >> 16;
+	image[offset+3] = data >> 24;
+}

src/lib/formats/fsmgr.h

@@ -0,0 +1,57 @@
+// license:BSD-3-Clause
+// copyright-holders:Olivier Galibert
+
+// Filesystem management code for floppy and hd images
+
+// Currently limited to floppies and creation of preformatted images
+
+#ifndef MAME_FORMATS_FSMGR_H
+#define MAME_FORMATS_FSMGR_H
+
+#pragma once
+
+#include "flopimg.h"
+
+class filesystem_manager_t {
+public:
+	struct floppy_enumerator {
+		virtual ~floppy_enumerator() = default;
+
+		virtual void add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) = 0;
+		virtual void add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) = 0;
+	};
+
+	virtual void enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const;
+
+	// Floppy image initialization
+	virtual void floppy_instantiate(u32 key, std::vector<u8> &image) const;
+
+	// Floppy image initialization for add_raw
+	virtual void floppy_instantiate_raw(u32 key, floppy_image *image) const;
+	
+protected:
+	filesystem_manager_t() = default;
+
+	static bool has_variant(const std::vector<uint32_t> &variants, uint32_t variant);
+
+	static void copy(std::vector<u8> &image, u32 offset, const u8 *src, u32 size);
+	static void fill(std::vector<u8> &image, u32 offset, u8 data, u32 size);
+	static void wstr(std::vector<u8> &image, u32 offset, const char *str);
+	static void w8(std::vector<u8> &image, u32 offset, u8 data);
+	static void w16b(std::vector<u8> &image, u32 offset, u16 data);
+	static void w32b(std::vector<u8> &image, u32 offset, u32 data);
+	static void w16l(std::vector<u8> &image, u32 offset, u16 data);
+	static void w32l(std::vector<u8> &image, u32 offset, u32 data);
+};
+
+
+typedef filesystem_manager_t *(*filesystem_manager_type)();
+
+// this template function creates a stub which constructs a filesystem manager
+template<class _FormatClass>
+filesystem_manager_t *filesystem_manager_creator()
+{
+	return new _FormatClass();
+}
+
+#endif

src/mame/includes/mac.h

@@ -33,7 +33,7 @@
 #include "emupal.h"
 #include "screen.h"
 
-#define NEW_SWIM 0
+#define NEW_SWIM 1
 
 #define MAC_SCREEN_NAME "screen"
 #define MAC_539X_1_TAG "539x_1"

src/tools/floptool.cpp

@@ -22,16 +22,131 @@
 #include "corestr.h"
 #include "osdcomm.h"
 
+using u8  = uint8_t;
+using u16 = uint16_t;
+using u32 = uint32_t;
+
 #include "formats/all.h"
 
+struct fs_info {
+	const filesystem_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, u32 key, const char *description) :
+		m_manager(manager),
+		m_type(type),
+		m_image_size(image_size),
+		m_name(name),
+		m_key(key),
+		m_description(description)
+	{}
+
+	fs_info(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) :
+		m_manager(manager),
+		m_type(nullptr),
+		m_image_size(0),
+		m_name(name),
+		m_key(key),
+		m_description(description)
+	{}
+};
+
+struct iofile_ram {
+	std::vector<u8> *data;
+	int64_t pos;
+};
+
+static void ram_closeproc(void *file)
+{
+	auto f = (iofile_ram *)file;
+	delete f;
+}
+
+static int ram_seekproc(void *file, int64_t offset, int whence)
+{
+	auto f = (iofile_ram *)file;
+	switch(whence) {
+	case SEEK_SET: f->pos = offset; break;
+	case SEEK_CUR: f->pos += offset; break;
+	case SEEK_END: f->pos = f->data->size() + offset; break;
+	}
+
+	f->pos = std::clamp(f->pos, int64_t(0), int64_t(f->data->size()));
+	return 0;
+}
+
+static size_t ram_readproc(void *file, void *buffer, size_t length)
+{
+	auto f = (iofile_ram *)file;
+	size_t l = std::min(length, f->data->size() - f->pos);
+	memcpy(buffer, f->data->data() + f->pos, l);
+	return l;
+}
+
+static size_t ram_writeproc(void *file, const void *buffer, size_t length)
+{
+	auto f = (iofile_ram *)file;
+	size_t l = std::min(length, f->data->size() - f->pos);
+	memcpy(f->data->data() + f->pos, buffer, l);
+	return l;
+}
+
+static uint64_t ram_filesizeproc(void *file)
+{
+	auto f = (iofile_ram *)file;
+	return f->data->size();
+}
+
+
+static const io_procs iop_ram = {
+	ram_closeproc,
+	ram_seekproc,
+	ram_readproc,
+	ram_writeproc,
+	ram_filesizeproc
+};
+
+static io_generic *ram_open(std::vector<u8> &data)
+{
+	iofile_ram *f = new iofile_ram;
+	f->data = &data;
+	f->pos = 0;
+	return new io_generic({ &iop_ram, f });
+}
+	
 std::map<std::string, std::vector<floppy_image_format_t *>> formats_by_category;
 std::map<std::string, floppy_image_format_t *> formats_by_key;
 
+std::map<std::string, std::vector<fs_info>> fs_by_category;
+std::map<std::string, fs_info> fs_by_key;
+
+static std::vector<uint32_t> variants;
+
+struct enumerator;
+
+struct fs_enum : public filesystem_manager_t::floppy_enumerator {
+	enumerator *m_en;
+	fs_enum(enumerator *en) : filesystem_manager_t::floppy_enumerator(), m_en(en) {};
+
+	void reg(const fs_info &fsi) const;
+	virtual void add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) override;
+	virtual void add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) override;
+};
+
 struct enumerator : public mame_formats_enumerator {
+	fs_enum fse;
+
+	enumerator() : mame_formats_enumerator(), fse(this) {}
+
 	virtual ~enumerator() = default;
 	virtual void add(const cassette_image::Format *const *formats) {}
 
 	std::vector<floppy_image_format_t *> *cf = nullptr;
+	std::vector<fs_info> *cfs = nullptr;
 	virtual void category(const char *name) {
 		auto i = formats_by_category.find(name);
 		if(i != formats_by_category.end()) {
@@ -39,6 +154,7 @@ struct enumerator : public mame_formats_enumerator {
 			exit(1);
 		}
 		cf = &formats_by_category[name];
+		cfs = &fs_by_category[name];
 	}
 
 	virtual void add(floppy_format_type format) {
@@ -46,7 +162,7 @@ struct enumerator : public mame_formats_enumerator {
 		std::string key = f->name();
 		auto i = formats_by_key.find(key);
 		if(i != formats_by_key.end()) {
-			fprintf(stderr, "Collision on key %s between \"%s\" and \"%s\".\n",
+			fprintf(stderr, "Collision on format key %s between \"%s\" and \"%s\".\n",
 					key.c_str(),
 					i->second->description(),
 					f->description());
@@ -55,8 +171,40 @@ struct enumerator : public mame_formats_enumerator {
 		cf->push_back(f);
 		formats_by_key[key] = f;
 	}
+
+	virtual void add(filesystem_manager_type fs) {
+		auto ff = fs();
+		ff->enumerate(fse, floppy_image::FF_UNKNOWN, variants);
+	}		
 };
 
+void fs_enum::reg(const fs_info &fsi) const
+{
+	std::string key = fsi.m_name;
+	auto i = fs_by_key.find(key);
+	if(i != fs_by_key.end()) {
+		fprintf(stderr, "Collision on fs key %s between \"%s\" and \"%s\".\n",
+				key.c_str(),
+				i->second.m_description,
+				fsi.m_description);
+		exit(1);
+	}
+	m_en->cfs->push_back(fsi);
+	fs_by_key.emplace(key, fsi);
+}
+
+void fs_enum::add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description)
+{
+	fs_info fsi(manager, type, image_size, name, key, description);
+	reg(fsi);
+}
+
+void fs_enum::add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description)
+{
+	fs_info fsi(manager, name, key, description);
+	reg(fsi);
+}
+
 void CLIB_DECL ATTR_PRINTF(1,2) logerror(const char *format, ...)
 {
 	va_list arg;
@@ -65,7 +213,6 @@ void CLIB_DECL ATTR_PRINTF(1,2) logerror(const char *format, ...)
 	va_end(arg);
 }
 
-static std::vector<uint32_t> variants;
 
 static void init_formats()
 {
@@ -97,11 +244,21 @@ static floppy_image_format_t *find_format_by_identify(io_generic *image)
 	return best_fif;
 }
 
+static const fs_info *find_fs_by_name(const char *name)
+{
+	auto i = fs_by_key.find(name);
+	if(i == fs_by_key.end())
+		return nullptr;
+	return &i->second;
+}
+
+
 static void display_usage()
 {
 	fprintf(stderr, "Usage: \n");
 	fprintf(stderr, "       floptool.exe identify <inputfile> [<inputfile> ...]\n");
 	fprintf(stderr, "       floptool.exe convert [input_format|auto] output_format <inputfile> <outputfile>\n");
+	fprintf(stderr, "       floptool.exe create output_format filesystem <outputfile>\n");
 }
 
 static void display_formats()
@@ -112,6 +269,11 @@ static void display_formats()
 		if(sz > sk)
 			sk = sz;
 	}
+	for(const auto &e : fs_by_key) {
+		int sz = e.first.size();
+		if(sz > sk)
+			sk = sz;
+	}
 
 	fprintf(stderr, "Supported formats:\n\n");
 	for(const auto &e : formats_by_category)
@@ -120,6 +282,15 @@ static void display_formats()
 			for(floppy_image_format_t *fif : e.second)
 				fprintf(stderr, "  %-*s - %s [%s]\n", sk, fif->name(), fif->description(), fif->extensions());
 		}
+
+	fprintf(stderr, "\n\n");
+	fprintf(stderr, "Supported filesystems:\n\n");
+	for(const auto &e : fs_by_category)
+		if(!e.second.empty()) {
+			fprintf(stderr, "%s:\n", e.first.c_str());
+			for(const fs_info &fs : e.second)
+				fprintf(stderr, "  %-*s - %s\n", sk, fs.m_name, fs.m_description);
+		}
 }
 
 static void display_full_usage()
@@ -240,6 +411,63 @@ static int convert(int argc, char *argv[])
 	return 0;
 }
 
+static int create(int argc, char *argv[])
+{
+	if (argc!=5) {
+		fprintf(stderr, "Incorrect number of arguments.\n\n");
+		display_usage();
+		return 1;
+	}
+
+	auto dest_format = find_format_by_name(argv[2]);
+	if(!dest_format) {
+		fprintf(stderr, "Error: Format '%s' unknown\n", argv[3]);
+		return 1;
+	}
+
+	auto source_fs = find_fs_by_name(argv[3]);
+	if(!source_fs) {
+		fprintf(stderr, "Error: Filesystem '%s' unknown\n", argv[2]);
+		return 1;
+	}
+
+	floppy_image image(84, 2, floppy_image::FF_UNKNOWN);
+
+	if(source_fs->m_type) {
+		std::vector<u8> img(source_fs->m_image_size);
+		source_fs->m_manager->floppy_instantiate(source_fs->m_key, img);
+		auto iog = ram_open(img);
+		auto source_format = source_fs->m_type();
+		source_format->load(iog, floppy_image::FF_UNKNOWN, variants, &image);
+		delete source_format;
+		delete iog;
+
+	} else
+		source_fs->m_manager->floppy_instantiate_raw(source_fs->m_key, &image);
+
+	char msg[4096];
+	sprintf(msg, "Error opening %s for writing", argv[4]);
+	auto f = fopen(argv[4], "wb");
+	if (!f) {
+		perror(msg);
+		return 1;
+	}
+
+	io_generic dest_io;
+	dest_io.file = f;
+	dest_io.procs = &stdio_ioprocs_noclose;
+	dest_io.filler = 0xff;
+
+	if(!dest_format->save(&dest_io, variants, &image)) {
+		fprintf(stderr, "Error: writing output file as '%s' failed\n", dest_format->name());
+		return 1;
+	}
+
+	fclose((FILE *)dest_io.file);
+	
+	return 0;
+}
+
 int CLIB_DECL main(int argc, char *argv[])
 {
 	init_formats();
@@ -253,6 +481,8 @@ int CLIB_DECL main(int argc, char *argv[])
 		return identify(argc, argv);
 	else if (!core_stricmp("convert", argv[1]))
 		return convert(argc, argv);
+	else if (!core_stricmp("create", argv[1]))
+		return create(argc, argv);
 	else {
 		fprintf(stderr, "Unknown command '%s'\n\n", argv[1]);
 		display_usage();