floppy.cpp: Update class variables to current naming convention. (#11851)

src/devices/bus/thomson/cd90_015.cpp

@@ -61,13 +61,13 @@ ud90_070_device::ud90_070_device(const machine_config &mconfig, const char *tag,
 
 void ud90_070_device::setup_characteristics()
 {
-	form_factor = floppy_image::FF_525;
-	tracks = 40;
-	sides = 1;
-	has_trk00_sensor = false;
+	m_form_factor = floppy_image::FF_525;
+	m_tracks = 40;
+	m_sides = 1;
+	m_has_trk00_sensor = false;
 	set_rpm(300);
 
-	variants.push_back(floppy_image::SSSD);
+	m_variants.push_back(floppy_image::SSSD);
 }
 
 void cd90_015_device::floppy_drives(device_slot_interface &device)

src/devices/imagedev/floppy.h

@@ -103,7 +103,7 @@ public:
 	virtual bool is_writeable() const noexcept override { return true; }
 	virtual bool is_creatable() const noexcept override { return true; }
 	virtual bool is_reset_on_load() const noexcept override { return false; }
-	virtual const char *file_extensions() const noexcept override { return extension_list; }
+	virtual const char *file_extensions() const noexcept override { return m_extension_list; }
 	virtual const char *image_type_name() const noexcept override { return "floppydisk"; }
 	virtual const char *image_brief_type_name() const noexcept override { return "flop"; }
 	void setup_write(const floppy_image_format_t *output_format);
@@ -116,8 +116,8 @@ public:
 	void setup_led_cb(led_cb cb);
 
 	std::vector<uint32_t> &get_buffer();
-	int get_cyl() const { return cyl; }
-	bool on_track() const { return !subcyl; }
+	int get_cyl() const { return m_cyl; }
+	bool on_track() const { return !m_subcyl; }
 
 	virtual void mon_w(int state);
 	bool ready_r();
@@ -126,28 +126,28 @@ public:
 	virtual void tfsel_w(int state) { }    // 35SEL line for Apple Sony drives
 
 	virtual bool wpt_r(); // Mac sony drives using this for various reporting
-	int dskchg_r() { return dskchg; }
-	bool trk00_r() { return (has_trk00_sensor ? (cyl != 0) : 1); }
-	int idx_r() { return idx; }
-	int mon_r() { return mon; }
-	bool ss_r() { return ss; }
+	int dskchg_r() { return m_dskchg; }
+	bool trk00_r() { return (m_has_trk00_sensor ? (m_cyl != 0) : 1); }
+	int idx_r() { return m_idx; }
+	int mon_r() { return m_mon; }
+	bool ss_r() { return m_ss; }
 	bool twosid_r();
 
 	virtual bool writing_disabled() const;
 
 	virtual void seek_phase_w(int phases);
 	void stp_w(int state);
-	void dir_w(int state) { dir = state; }
-	void ss_w(int state) { actual_ss = state; if (sides > 1) ss = state; }
+	void dir_w(int state) { m_dir = state; }
+	void ss_w(int state) { m_actual_ss = state; if (m_sides > 1) m_ss = state; }
 	void inuse_w(int state) { }
-	void dskchg_w(int state) { if (dskchg_writable) dskchg = state; }
-	void ds_w(int state) { ds = state; check_led(); }
+	void dskchg_w(int state) { if (m_dskchg_writable) m_dskchg = state; }
+	void ds_w(int state) { m_ds = state; check_led(); }
 
 	attotime time_next_index();
 	attotime get_next_transition(const attotime &from_when);
 	void write_flux(const attotime &start, const attotime &end, int transition_count, const attotime *transitions);
 	void set_write_splice(const attotime &when);
-	int get_sides() { return sides; }
+	int get_sides() { return m_sides; }
 	uint32_t get_form_factor() const;
 	uint32_t get_variant() const;
 
@@ -179,68 +179,68 @@ protected:
 
 	void init_floppy_load(bool write_supported);
 
-	std::function<void (format_registration &fr)> format_registration_cb;
-	const floppy_image_format_t *input_format;
-	const floppy_image_format_t *output_format;
-	std::vector<uint32_t> variants;
-	std::unique_ptr<floppy_image> image;
-	char                  extension_list[256];
-	std::vector<const floppy_image_format_t *> fif_list;
+	std::function<void (format_registration &fr)> m_format_registration_cb;
+	const floppy_image_format_t *m_input_format;
+	const floppy_image_format_t *m_output_format;
+	std::vector<uint32_t> m_variants;
+	std::unique_ptr<floppy_image> m_image;
+	char                  m_extension_list[256];
+	std::vector<const floppy_image_format_t *> m_fif_list;
 	std::vector<fs_info>  m_fs;
 	std::vector<const fs::manager_t *> m_fs_managers;
-	emu_timer             *index_timer;
+	emu_timer             *m_index_timer;
 
 	/* Physical characteristics, filled by setup_characteristics */
-	int tracks; /* addressable tracks */
-	int sides;  /* number of heads */
-	uint32_t form_factor; /* 3"5, 5"25, etc */
-	bool motor_always_on;
-	bool dskchg_writable;
-	bool has_trk00_sensor;
+	int m_tracks; /* addressable tracks */
+	int m_sides;  /* number of heads */
+	uint32_t m_form_factor; /* 3"5, 5"25, etc */
+	bool m_motor_always_on;
+	bool m_dskchg_writable;
+	bool m_has_trk00_sensor;
 
-	int drive_index;
+	int m_drive_index;
 
 	/* state of input lines */
-	int dir;  /* direction */
-	int stp;  /* step */
-	int wtg;  /* write gate */
-	int mon;  /* motor on */
-	int ss, actual_ss; /* side select (forced to 0 if single-sided drive / actual value) */
-	int ds; /* drive select */
+	int m_dir;  /* direction */
+	int m_stp;  /* step */
+	int m_wtg;  /* write gate */
+	int m_mon;  /* motor on */
+	int m_ss, m_actual_ss; /* side select (forced to 0 if single-sided drive / actual value) */
+	int m_ds; /* drive select */
 
-	int phases; /* phases lines, when they exist */
+	int m_phases; /* phases lines, when they exist */
 
 	/* state of output lines */
-	int idx;  /* index pulse */
-	int wpt;  /* write protect */
-	int rdy;  /* ready */
-	int dskchg;     /* disk changed */
-	bool ready;
+	int m_idx;  /* index pulse */
+	int m_wpt;  /* write protect */
+	int m_rdy;  /* ready */
+	int m_dskchg;     /* disk changed */
+	bool m_ready;
 
 	/* rotation per minute => gives index pulse frequency */
-	float rpm;
+	float m_rpm;
 	/* angular speed, where a full circle is 2e8 */
-	double angular_speed;
+	double m_angular_speed;
 
-	attotime revolution_start_time, rev_time;
-	uint32_t revolution_count;
-	int cyl, subcyl;
+	attotime m_revolution_start_time, m_rev_time;
+	uint32_t m_revolution_count;
+	int m_cyl, m_subcyl;
 	/* Current floppy zone cache */
-	attotime cache_start_time, cache_end_time, cache_weak_start;
-	attotime amplifier_freakout_time;
-	int cache_index;
-	u32 cache_entry;
-	bool cache_weak;
+	attotime m_cache_start_time, m_cache_end_time, m_cache_weak_start;
+	attotime m_amplifier_freakout_time;
+	int m_cache_index;
+	u32 m_cache_entry;
+	bool m_cache_weak;
 
-	bool image_dirty, track_dirty;
-	int ready_counter;
+	bool m_image_dirty, m_track_dirty;
+	int m_ready_counter;
 
-	load_cb cur_load_cb;
-	unload_cb cur_unload_cb;
-	index_pulse_cb cur_index_pulse_cb;
-	ready_cb cur_ready_cb;
-	wpt_cb cur_wpt_cb;
-	led_cb cur_led_cb;
+	load_cb m_cur_load_cb;
+	unload_cb m_cur_unload_cb;
+	index_pulse_cb m_cur_index_pulse_cb;
+	ready_cb m_cur_ready_cb;
+	wpt_cb m_cur_wpt_cb;
+	led_cb m_cur_led_cb;
 
 
 	// Temporary structure storing a write span