Previous

199869 Revisions

Next

r20930 Monday 11th February, 2013 at 08:38:01 UTC by Oliver Stöneberg
added missing virtual to device-level overrides (nw)

[src/emu/cpu/psx]	psx.h
[src/emu/machine]	tms9901.h tms9902.h
[src/emu/sound]	bsmt2000.h ics2115.h qs1000.h sn76496.h tms5220.h votrax.h
[src/emu/video]	k053250.h
[src/mame/machine]	jvs13551.h k573cass.h zndip.h znsec.h
[src/mess/includes]	next.h pc4.h
[src/mess/machine]	at29040a.h isa_ibm_mfc.h kc_rom.h nextkbd.h psxcport.h smc92x4.h teleprinter.h
[src/mess/machine/ti99]	bwg.h datamux.h evpc.h genboard.h grom.h gromport.h handset.h hfdc.h horizon.h hsgpl.h joyport.h mapper8.h mecmouse.h memex.h myarcmem.h p_code.h peribox.h samsmem.h spchsyn.h speech8.h ti32kmem.h ti99_hd.h ti_fdc.h ti_rs232.h tn_ide.h tn_usbsm.h videowrp.h
[src/mess/video]	hd44780.h

trunk/src/mame/machine/jvs13551.h

r20929	r20930
26	26	public:
27	27	sega_837_13551(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
28	28	static void static_set_port_tag(device_t &device, int port, const char *tag);
29		ioport_constructor device_input_ports() const;
30	29
31	30	DECLARE_WRITE_LINE_MEMBER(jvs13551_coin_1_w);
32	31	DECLARE_WRITE_LINE_MEMBER(jvs13551_coin_2_w);
r20929	r20930
36	35	// device-level overrides
37	36	virtual void device_start();
38	37	virtual void device_reset();
	38	virtual ioport_constructor device_input_ports() const;
39	39
40	40	// JVS device overrides
41	41	virtual const char *device_id();

trunk/src/mame/machine/zndip.h

r20929	r20930
20	20	void select(int select);
21	21
22	22	protected:
23		void device_start();
	23	virtual void device_start();
24	24	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
25	25
26	26	private:

trunk/src/mame/machine/znsec.h

r20929	r20930
18	18	void select(int select);
19	19
20	20	protected:
21		void device_start();
	21	virtual void device_start();
22	22
23	23	private:
24	24	virtual void data_in( int data, int mask );

trunk/src/mame/machine/k573cass.h

r20929	r20930
13	13	konami573cassette_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
14	14
15	15	protected:
16		void device_start();
	16	virtual void device_start();
17	17
18	18	private:
19	19	virtual void data_in( int data, int mask );

trunk/src/emu/machine/tms9901.h

r20929	r20930
71	71	private:
72	72	static const device_timer_id DECREMENTER = 0;
73	73
74		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	74	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
75	75	void timer_reload(void);
76	76	void field_interrupts(void);
77	77
78		void device_start(void);
79		void device_stop(void);
80		void device_reset(void);
	78	virtual void device_start(void);
	79	virtual void device_stop(void);
	80	virtual void device_reset(void);
81	81
82	82	/* interrupt registers */
83	83	// mask:  bit #n is set if pin #n is supported as an interrupt pin,

trunk/src/emu/machine/tms9902.h

r20929	r20930
71	71	DECLARE_WRITE8_MEMBER( cruwrite );
72	72
73	73	protected:
74		void    device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
75		void    device_start();
76		void    device_reset();
77		void    device_stop();
	74	virtual void    device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	75	virtual void    device_start();
	76	virtual void    device_reset();
	77	virtual void    device_stop();
78	78
79	79	private:
80	80	void    field_interrupts();

trunk/src/emu/video/k053250.h

r20929	r20930
29	29	void draw( bitmap_rgb32 &bitmap, const rectangle &cliprect, int colorbase, int flags, int priority );
30	30
31	31	protected:
32		void device_start();
33		void device_reset();
	32	virtual void device_start();
	33	virtual void device_reset();
34	34
35	35	private:
36	36	UINT8 regs[8];

trunk/src/emu/cpu/psx/psx.h

r20929	r20930
172	172	virtual void device_start();
173	173	virtual void device_reset();
174	174	virtual void device_post_load();
175		machine_config_constructor device_mconfig_additions() const;
	175	virtual machine_config_constructor device_mconfig_additions() const;
176	176
177	177	// device_execute_interface overrides
178	178	virtual UINT32 execute_min_cycles() const { return 1; }

trunk/src/emu/sound/ics2115.h

r20929	r20930
114	114	virtual void device_reset();
115	115
116	116	// internal callbacks
117		void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	117	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
118	118
119	119	// internal state
120	120	void (*m_irq_cb)(device_t *device, int state);

trunk/src/emu/sound/votrax.h

r20929	r20930
86	86
87	87	protected:
88	88	// device-level overrides
89		const rom_entry *device_rom_region() const;
	89	virtual const rom_entry *device_rom_region() const;
90	90	virtual void device_start();
91	91	virtual void device_reset();
92	92	virtual void device_clock_changed();

trunk/src/emu/sound/tms5220.h

r20929	r20930
137	137	{
138	138	public:
139	139	tms52xx_device(const machine_config &mconfig, device_type type,  const char *name, const char *tag, const struct tms5100_coeffs* coeffs, const int var, device_t *owner, UINT32 clock);
140		void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
141		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	140	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	141	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
142	142
143	143	DECLARE_WRITE_LINE_MEMBER( rsq_w );
144	144	DECLARE_WRITE_LINE_MEMBER( wsq_w );
r20929	r20930
150	150	double time_to_ready();
151	151
152	152	protected:
153		void device_start();
154		void device_reset();
	153	virtual void device_start();
	154	virtual void device_reset();
155	155
156	156	private:
157	157	// Methods

trunk/src/emu/sound/bsmt2000.h

r20929	r20930
84	84
85	85	protected:
86	86	// device-level overrides
87		const rom_entry *device_rom_region() const;
88		machine_config_constructor device_mconfig_additions() const;
	87	virtual const rom_entry *device_rom_region() const;
	88	virtual machine_config_constructor device_mconfig_additions() const;
89	89	virtual void device_start();
90	90	virtual void device_reset();
91	91	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);

trunk/src/emu/sound/qs1000.h

r20929	r20930
69	69
70	70	protected:
71	71	// device-level overrides
72		const rom_entry *device_rom_region() const;
73		machine_config_constructor device_mconfig_additions() const;
	72	virtual const rom_entry *device_rom_region() const;
	73	virtual machine_config_constructor device_mconfig_additions() const;
74	74	virtual void device_config_complete();
75	75	virtual void device_start();
76	76	virtual void device_reset();

trunk/src/emu/sound/sn76496.h

r20929	r20930
32	32	DECLARE_WRITE8_MEMBER( write );
33	33
34	34	protected:
35		void    device_start();
36		void    sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
	35	virtual void    device_start();
	36	virtual void    sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
37	37
38	38	private:
39	39	inline bool     in_noise_mode();

trunk/src/mess/machine/isa_ibm_mfc.h

r20929	r20930
67	67	virtual void                    device_reset();
68	68	virtual void                    device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
69	69
70		const rom_entry*                device_rom_region() const;
	70	virtual const rom_entry*        device_rom_region() const;
71	71
72	72	private:
73	73	void                            set_pc_interrupt(int src, int state);

trunk/src/mess/machine/teleprinter.h

r20929	r20930
33	33	protected:
34	34	virtual void term_write(UINT8 data);
35	35	virtual void device_reset();
36		machine_config_constructor device_mconfig_additions() const;
	36	virtual machine_config_constructor device_mconfig_additions() const;
37	37	private:
38	38	void scroll_line();
39	39	void write_char(UINT8 data);

trunk/src/mess/machine/smc92x4.h

r20929	r20930
91	91	void reset();
92	92
93	93	protected:
94		void device_start(void);
95		void device_reset(void);
	94	virtual void device_start(void);
	95	virtual void device_reset(void);
96	96
97	97	private:
98	98	devcb_resolved_write_line   m_out_intrq;    // INT line
r20929	r20930
121	121	void    timed_sector_write_request();
122	122	void    timed_track_request();
123	123	void    timed_seek_request();
124		void    device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	124	virtual void    device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
125	125	UINT8   cylinder_to_ident(int cylinder);
126	126	int     ident_to_cylinder(UINT8 ident);
127	127	void    update_id_regs(chrn_id_hd id);

trunk/src/mess/machine/kc_rom.h

r20929	r20930
22	22	kc_8k_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
23	23
24	24	// optional information overrides
25		const rom_entry *device_rom_region() const;
26	25
27	26	protected:
28	27	// device-level overrides
29	28	virtual void device_start();
30	29	virtual void device_reset();
31	30	virtual void device_config_complete() { m_shortname = "kc_8k"; }
32
	31	virtual const rom_entry *device_rom_region() const;
	32
33	33	// kcexp_interface overrides
34	34	virtual UINT8 module_id_r() { return 0xfb; }
35	35	virtual void control_w(UINT8 data);

trunk/src/mess/machine/at29040a.h

r20929	r20930
50	50	DECLARE_WRITE8_MEMBER( write );
51	51
52	52	protected:
53		void device_start(void);
54		void device_reset(void);
55		void device_stop(void);
56		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	53	virtual void device_start(void);
	54	virtual void device_reset(void);
	55	virtual void device_stop(void);
	56	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
57	57
58	58	void nvram_default();
59	59	void nvram_read(emu_file &file);

trunk/src/mess/machine/ti99/grom.h

r20929	r20930
89	89	// CPU into wait state mode. A timer is set to raise READY again.
90	90	void clear_ready();
91	91
92		void device_start(void);
93		void device_reset(void);
94		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	92	virtual void device_start(void);
	93	virtual void device_reset(void);
	94	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
95	95	};
96	96
97	97

trunk/src/mess/machine/ti99/joyport.h

r20929	r20930
44	44	: device_t(mconfig, type, name, tag, owner, clock) { }
45	45
46	46	protected:
47		void device_config_complete();
	47	virtual void device_config_complete();
48	48	joyport_device* m_joyport;
49	49
50	50	private:
r20929	r20930
64	64	void    set_interrupt(int state);
65	65
66	66	protected:
67		void device_start() { };
68		void device_config_complete();
	67	virtual void device_start() { };
	68	virtual void device_config_complete();
69	69
70	70	private:
71	71	devcb_resolved_write_line   m_interrupt;

trunk/src/mess/machine/ti99/ti99_hd.h

r20929	r20930
50	50	int     get_track_length();
51	51
52	52	protected:
53		void    device_start();
54		void    device_reset();
55		machine_config_constructor device_mconfig_additions() const;
	53	virtual void    device_start();
	54	virtual void    device_reset();
	55	virtual machine_config_constructor device_mconfig_additions() const;
56	56
57	57	private:
58	58	int     find_block(const UINT8 *buffer, int start, int stop, UINT8 byte, size_t number);
r20929	r20930
73	73	public:
74	74	ide_harddisk_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
75	75	protected:
76		void    device_start() { };
77		void    device_reset() { };
78		machine_config_constructor device_mconfig_additions() const;
	76	virtual void    device_start() { };
	77	virtual void    device_reset() { };
	78	virtual machine_config_constructor device_mconfig_additions() const;
79	79	};
80	80
81	81	#define MCFG_MFMHD_3_DRIVES_ADD()           \

trunk/src/mess/machine/ti99/gromport.h

r20929	r20930
39	39	void    cartridge_inserted();
40	40
41	41	protected:
42		void device_start();
43		void device_reset();
44		void device_config_complete();
45		ioport_constructor device_input_ports() const;
	42	virtual void device_start();
	43	virtual void device_reset();
	44	virtual void device_config_complete();
	45	virtual ioport_constructor device_input_ports() const;
46	46
47	47	private:
48	48	ti99_cartridge_connector_device*    m_connector;
r20929	r20930
78	78	void    set_slot(int i);
79	79
80	80	protected:
81		void device_start() { };
82		void device_config_complete();
83		machine_config_constructor device_mconfig_additions() const;
84		const rom_entry* device_rom_region() const;
	81	virtual void device_start() { };
	82	virtual void device_config_complete();
	83	virtual machine_config_constructor device_mconfig_additions() const;
	84	virtual const rom_entry* device_rom_region() const;
85	85
86	86	// Image handling: implementation of methods which are abstract in the parent
87	87	bool call_load();
r20929	r20930
150	150	void cruwrite(offs_t offset, UINT8 data);
151	151
152	152	protected:
153		void device_start() { };
154		void device_reset();
155		machine_config_constructor device_mconfig_additions() const;
156		void device_config_complete();
	153	virtual void device_start() { };
	154	virtual void device_reset();
	155	virtual machine_config_constructor device_mconfig_additions() const;
	156	virtual void device_config_complete();
157	157
158	158	private:
159	159	ti99_cartridge_device *m_cartridge;
r20929	r20930
182	182	void remove(int index);
183	183
184	184	protected:
185		void device_start();
186		void device_reset();
187		machine_config_constructor device_mconfig_additions() const;
188		ioport_constructor device_input_ports() const;
	185	virtual void device_start();
	186	virtual void device_reset();
	187	virtual machine_config_constructor device_mconfig_additions() const;
	188	virtual ioport_constructor device_input_ports() const;
189	189
190	190	private:
191	191	int     m_active_slot;
r20929	r20930
217	217	DECLARE_INPUT_CHANGED_MEMBER( gk_changed );
218	218
219	219	protected:
220		void device_start();
221		void device_reset();
	220	virtual void device_start();
	221	virtual void device_reset();
222	222
223		machine_config_constructor device_mconfig_additions() const;
224		const rom_entry* device_rom_region() const;
225		ioport_constructor device_input_ports() const;
	223	virtual machine_config_constructor device_mconfig_additions() const;
	224	virtual const rom_entry* device_rom_region() const;
	225	virtual ioport_constructor device_input_ports() const;
226	226
227	227	// device_nvram_interface
228	228	void nvram_default();

trunk/src/mess/machine/ti99/hsgpl.h

r20929	r20930
32	32	void    cruwrite(offs_t offset, UINT8 data);
33	33
34	34	protected:
35		void device_start(void);
36		void device_reset(void);
37		void device_stop(void);
38		void device_config_complete(void);
39		ioport_constructor device_input_ports() const;
	35	virtual void device_start(void);
	36	virtual void device_reset(void);
	37	virtual void device_stop(void);
	38	virtual void device_config_complete(void);
	39	virtual ioport_constructor device_input_ports() const;
40	40
41		machine_config_constructor device_mconfig_additions() const;
	41	virtual machine_config_constructor device_mconfig_additions() const;
42	42
43	43	private:
44	44	at29040a_device* m_dsr_eeprom;

trunk/src/mess/machine/ti99/genboard.h

r20929	r20930
29	29	line_state  left_button();  // left button is not connected to the V9938 but to a TMS9901 pin
30	30
31	31	protected:
32		void device_start();
33		void device_reset();
34		ioport_constructor device_input_ports() const;
	32	virtual void device_start();
	33	virtual void device_reset();
	34	virtual ioport_constructor device_input_ports() const;
35	35
36	36	private:
37	37	v9938_device*   m_v9938;
r20929	r20930
68	68	UINT8 get_recent_key();
69	69
70	70	protected:
71		void                        device_start();
72		void                        device_reset();
73		void                        device_config_complete();
74		ioport_constructor          device_input_ports() const;
	71	virtual void                        device_start();
	72	virtual void                        device_reset();
	73	virtual void                        device_config_complete();
	74	virtual ioport_constructor          device_input_ports() const;
75	75	devcb_resolved_write_line   m_interrupt;    // Keyboard interrupt to console
76		void                        device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	76	virtual void                        device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
77	77
78	78	private:
79	79	void    post_in_key_queue(int keycode);
r20929	r20930
140	140	void clock_in(int state);
141	141
142	142	protected:
143		void    device_start();
144		void    device_reset();
	143	virtual void    device_start();
	144	virtual void    device_reset();
145	145
146	146	private:
147	147	// GROM simulation

trunk/src/mess/machine/ti99/ti_fdc.h

r20929	r20930
32	32	void cruwrite(offs_t offset, UINT8 value);
33	33
34	34	protected:
35		void device_start(void);
36		void device_reset(void);
37		const rom_entry *device_rom_region() const;
38		machine_config_constructor device_mconfig_additions() const;
39
	35	virtual void device_start(void);
	36	virtual void device_reset(void);
	37	virtual const rom_entry *device_rom_region() const;
	38	virtual machine_config_constructor device_mconfig_additions() const;
	39	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	40
40	41	private:
41	42	void handle_hold(void);
42	43	void set_all_geometries(floppy_type_t type);
43	44	void set_geometry(device_t *drive, floppy_type_t type);
44		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
45	45
46	46
47	47	// Holds the status of the DRQ and IRQ lines.

trunk/src/mess/machine/ti99/p_code.h

r20929	r20930
32	32	DECLARE_INPUT_CHANGED_MEMBER( switch_changed );
33	33
34	34	protected:
35		void device_start();
36		void device_reset();
37		void device_config_complete();
38		const rom_entry *device_rom_region() const;
39		machine_config_constructor device_mconfig_additions() const;
40		ioport_constructor device_input_ports() const;
	35	virtual void device_start();
	36	virtual void device_reset();
	37	virtual void device_config_complete();
	38	virtual const rom_entry *device_rom_region() const;
	39	virtual machine_config_constructor device_mconfig_additions() const;
	40	virtual ioport_constructor device_input_ports() const;
41	41
42	42	private:
43	43	ti99_grom_device*   m_grom[8];

trunk/src/mess/machine/ti99/tn_usbsm.h

r20929	r20930
30	30	void    cruwrite(offs_t offset, UINT8 value);
31	31
32	32	protected:
33		void device_start(void);
34		void device_reset(void);
35		const rom_entry *device_rom_region() const;
36		machine_config_constructor device_mconfig_additions() const;
37		ioport_constructor device_input_ports() const;
	33	virtual void device_start(void);
	34	virtual void device_reset(void);
	35	virtual const rom_entry *device_rom_region() const;
	36	virtual machine_config_constructor device_mconfig_additions() const;
	37	virtual ioport_constructor device_input_ports() const;
38	38
39	39	private:
40	40	UINT16      usbsm_mem_16_r(offs_t offset);

trunk/src/mess/machine/ti99/ti32kmem.h

r20929	r20930
27	27	void cruwrite(offs_t offset, UINT8 value);
28	28
29	29	protected:
30		void device_start();
31		const rom_entry *device_rom_region() const;
	30	virtual void device_start();
	31	virtual const rom_entry *device_rom_region() const;
32	32	private:
33	33	UINT8*  m_ram_ptr;
34	34	};

trunk/src/mess/machine/ti99/evpc.h

r20929	r20930
40	40	void    cruwrite(offs_t offset, UINT8 data);
41	41
42	42	protected:
43		void device_start(void);
44		void device_reset(void);
45		void device_stop(void);
	43	virtual void device_start(void);
	44	virtual void device_reset(void);
	45	virtual void device_stop(void);
46	46
47		const rom_entry *device_rom_region() const;
48		ioport_constructor device_input_ports() const;
	47	virtual const rom_entry *device_rom_region() const;
	48	virtual ioport_constructor device_input_ports() const;
49	49
50	50	void nvram_default();
51	51	void nvram_read(emu_file &file);

trunk/src/mess/machine/ti99/videowrp.h

r20929	r20930
62	62	void    reset_vdp(int state) { m_v9938->reset_line(state); }
63	63
64	64	protected:
65		void            device_start(void);
	65	virtual void    device_start(void);
66	66	v9938_device    *m_v9938;
67	67	};
68	68
r20929	r20930
97	97	DECLARE_WRITE_LINE_MEMBER( sound_ready );   // connect to console READY
98	98
99	99	protected:
100		void device_start(void);
	100	virtual void device_start(void);
101	101	virtual machine_config_constructor device_mconfig_additions() const =0;
102	102
103	103	private:
r20929	r20930
115	115	: ti_sound_system_device(mconfig, TISOUND_94624, tag, "Onboard sound (SN94624)", owner, clock) { }
116	116
117	117	protected:
118		machine_config_constructor device_mconfig_additions() const;
	118	virtual machine_config_constructor device_mconfig_additions() const;
119	119	};
120	120
121	121	/*
r20929	r20930
128	128	: ti_sound_system_device(mconfig, TISOUND_76496, tag, "Onboard sound (SN76496)", owner, clock) { }
129	129
130	130	protected:
131		machine_config_constructor device_mconfig_additions() const;
	131	virtual machine_config_constructor device_mconfig_additions() const;
132	132	};
133	133
134	134

trunk/src/mess/machine/ti99/speech8.h

r20929	r20930
47	47	int             m_select_value;
48	48
49	49	protected:
50		void            device_start();
51		void            device_reset(void);
52		const rom_entry *device_rom_region() const;
53		machine_config_constructor device_mconfig_additions() const;
	50	virtual void    device_start();
	51	virtual void    device_reset(void);
	52	virtual const rom_entry *device_rom_region() const;
	53	virtual machine_config_constructor device_mconfig_additions() const;
54	54
55	55	private:
56	56	tms5220n_device *m_vsp;

trunk/src/mess/machine/ti99/samsmem.h

r20929	r20930
30	30	void cruwrite(offs_t offset, UINT8 data);
31	31
32	32	protected:
33		void device_start(void);
34		void device_reset(void);
35		const rom_entry *device_rom_region(void) const;
	33	virtual void device_start(void);
	34	virtual void device_reset(void);
	35	virtual const rom_entry *device_rom_region(void) const;
36	36
37	37	private:
38	38	UINT8*  m_ram;

trunk/src/mess/machine/ti99/tn_ide.h

r20929	r20930
36	36	DECLARE_WRITE_LINE_MEMBER(ide_interrupt_callback);
37	37
38	38	protected:
39		void device_start(void);
40		void device_reset(void);
41		const rom_entry *device_rom_region() const;
42		machine_config_constructor device_mconfig_additions() const;
43		ioport_constructor device_input_ports() const;
	39	virtual void device_start(void);
	40	virtual void device_reset(void);
	41	virtual const rom_entry *device_rom_region() const;
	42	virtual machine_config_constructor device_mconfig_additions() const;
	43	virtual ioport_constructor device_input_ports() const;
44	44
45	45	private:
46	46	rtc65271_device*    m_rtc;

trunk/src/mess/machine/ti99/datamux.h

r20929	r20930
78	78	virtual void device_start(void);
79	79	virtual void device_stop(void);
80	80	virtual void device_reset(void);
81		ioport_constructor device_input_ports() const;
	81	virtual ioport_constructor device_input_ports() const;
82	82
83	83	private:
84	84	// Ready line to the CPU

trunk/src/mess/machine/ti99/hfdc.h

r20929	r20930
41	41	DECLARE_WRITE8_MEMBER( write_buffer );
42	42
43	43	protected:
44		void device_start(void);
45		void device_reset(void);
46		const rom_entry *device_rom_region() const;
47		machine_config_constructor device_mconfig_additions() const;
48		ioport_constructor device_input_ports() const;
49		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	44	virtual void device_start(void);
	45	virtual void device_reset(void);
	46	virtual const rom_entry *device_rom_region() const;
	47	virtual machine_config_constructor device_mconfig_additions() const;
	48	virtual ioport_constructor device_input_ports() const;
	49	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
50	50
51	51
52	52	private:

trunk/src/mess/machine/ti99/ti_rs232.h

r20929	r20930
47	47	DECLARE_WRITE_LINE_MEMBER( senila );
48	48
49	49	protected:
50		void device_start(void);
51		void device_reset(void);
52		const rom_entry *device_rom_region(void) const;
53		machine_config_constructor device_mconfig_additions() const;
54		ioport_constructor device_input_ports() const;
	50	virtual void device_start(void);
	51	virtual void device_reset(void);
	52	virtual const rom_entry *device_rom_region(void) const;
	53	virtual machine_config_constructor device_mconfig_additions() const;
	54	virtual ioport_constructor device_input_ports() const;
55	55
56	56	private:
57	57	void        incoming_dtr(int uartind, line_state value);
r20929	r20930
119	119	const option_guide *create_option_guide() const { return NULL; }
120	120
121	121	protected:
122		void    device_start(void);
	122	virtual void    device_start(void);
123	123	bool    call_load();
124	124	void    call_unload();
125		void    device_config_complete();
	125	virtual void    device_config_complete();
126	126
127	127	private:
128	128	int get_index_from_tagname();
r20929	r20930
147	147	const option_guide *create_option_guide() const { return NULL; }
148	148
149	149	protected:
150		void    device_start(void);
	150	virtual void    device_start(void);
151	151	bool    call_load();
152	152	void    call_unload();
153		void    device_config_complete();
	153	virtual void    device_config_complete();
154	154	};
155	155
156	156	#endif

trunk/src/mess/machine/ti99/peribox.h

r20929	r20930
64	64	void set_genmod(bool set);
65	65
66	66	protected:
67		void device_start(void);
68		void device_config_complete(void);
	67	virtual void device_start(void);
	68	virtual void device_config_complete(void);
69	69
70	70	virtual machine_config_constructor device_mconfig_additions() const;
71	71
r20929	r20930
103	103	peribox_ev_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
104	104
105	105	protected:
106		machine_config_constructor device_mconfig_additions() const;
	106	virtual machine_config_constructor device_mconfig_additions() const;
107	107	};
108	108
109	109	/*
r20929	r20930
115	115	peribox_sg_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
116	116
117	117	protected:
118		machine_config_constructor device_mconfig_additions() const;
	118	virtual machine_config_constructor device_mconfig_additions() const;
119	119	};
120	120
121	121	/*
r20929	r20930
127	127	peribox_gen_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
128	128
129	129	protected:
130		machine_config_constructor device_mconfig_additions() const;
	130	virtual machine_config_constructor device_mconfig_additions() const;
131	131	};
132	132
133	133	/*****************************************************************************
r20929	r20930
159	159	device_t*   get_drive(const char* name);
160	160
161	161	protected:
162		void device_start(void);
163		void device_config_complete(void);
	162	virtual void device_start(void);
	163	virtual void device_config_complete(void);
164	164
165	165	private:
166	166	int get_index_from_tagname();

trunk/src/mess/machine/ti99/myarcmem.h

r20929	r20930
28	28	void cruwrite(offs_t offset, UINT8 data);
29	29
30	30	protected:
31		void device_start(void);
32		void device_reset(void);
33		const rom_entry *device_rom_region(void) const;
34		ioport_constructor device_input_ports() const;
	31	virtual void device_start(void);
	32	virtual void device_reset(void);
	33	virtual const rom_entry *device_rom_region(void) const;
	34	virtual ioport_constructor device_input_ports() const;
35	35
36	36	private:
37	37	int     get_base(int offset);

trunk/src/mess/machine/ti99/memex.h

r20929	r20930
28	28	void cruwrite(offs_t offset, UINT8 value)  { };
29	29
30	30	protected:
31		void device_start();
32		void device_reset();
33		ioport_constructor device_input_ports() const;
34		const rom_entry *device_rom_region() const;
	31	virtual void device_start();
	32	virtual void device_reset();
	33	virtual ioport_constructor device_input_ports() const;
	34	virtual const rom_entry *device_rom_region() const;
35	35
36	36	private:
37	37	bool    access_enabled(offs_t offset);

trunk/src/mess/machine/ti99/mapper8.h

r20929	r20930
113	113	void clock_in(int state);
114	114
115	115	protected:
116		void device_start(void);
117		void device_reset(void);
	116	virtual void device_start(void);
	117	virtual void device_reset(void);
118	118
119	119	private:
120	120	bool search_logically_addressed_r(address_space& space, offs_t offset, UINT8 *value, UINT8 mem_mask );

trunk/src/mess/machine/ti99/mecmouse.h

r20929	r20930
26	26	void  write_dev(UINT8 data);
27	27
28	28	protected:
29		void device_start(void);
30		void device_reset(void);
31		ioport_constructor device_input_ports() const;
32
	29	virtual void device_start(void);
	30	virtual void device_reset(void);
	31	virtual ioport_constructor device_input_ports() const;
	32	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	33
33	34	private:
34	35	int     m_last_select;
35	36	bool    m_read_y_axis;
r20929	r20930
39	40	int     m_y_buf;
40	41	int     m_last_mx;
41	42	int     m_last_my;
42		void    device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
43	43
44	44	emu_timer   *m_poll_timer;
45	45	};

trunk/src/mess/machine/ti99/bwg.h

r20929	r20930
31	31	void cruwrite(offs_t offset, UINT8 value);
32	32
33	33	protected:
34		void device_start(void);
35		void device_reset(void);
36		const rom_entry *device_rom_region() const;
37		machine_config_constructor device_mconfig_additions() const;
38		ioport_constructor device_input_ports() const;
	34	virtual void device_start(void);
	35	virtual void device_reset(void);
	36	virtual const rom_entry *device_rom_region() const;
	37	virtual machine_config_constructor device_mconfig_additions() const;
	38	virtual ioport_constructor device_input_ports() const;
39	39
40	40	private:
41	41	void handle_hold(void);
42	42	void set_all_geometries(floppy_type_t type);
43	43	void set_geometry(device_t *drive, floppy_type_t type);
44		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	44	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
45	45
46	46	// Holds the status of the DRQ and IRQ lines.
47	47	bool            m_DRQ, m_IRQ;

trunk/src/mess/machine/ti99/handset.h

r20929	r20930
31	31	void  write_dev(UINT8 data);
32	32
33	33	protected:
34		void device_start(void);
35		void device_reset(void);
36		ioport_constructor device_input_ports() const;
	34	virtual void device_start(void);
	35	virtual void device_reset(void);
	36	virtual ioport_constructor device_input_ports() const;
37	37
38		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	38	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
39	39
40	40	private:
41	41	void do_task();
r20929	r20930
71	71	public:
72	72	ti99_twin_joystick(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
73	73	DECLARE_READ8_MEMBER( read );
74		void device_start(void);
	74	virtual void device_start(void);
75	75
76	76	UINT8 read_dev();
77	77	void  write_dev(UINT8 data);
78	78
79	79	protected:
80		ioport_constructor device_input_ports() const;
	80	virtual ioport_constructor device_input_ports() const;
81	81
82	82	private:
83	83	// Which joystick is selected?

trunk/src/mess/machine/ti99/spchsyn.h

r20929	r20930
34	34	DECLARE_WRITE8_MEMBER( spchrom_read_and_branch );
35	35
36	36	protected:
37		void            device_start();
38		void            device_reset(void);
39		const rom_entry *device_rom_region() const;
40		machine_config_constructor device_mconfig_additions() const;
41		void            device_config_complete();
	37	virtual void            device_start();
	38	virtual void            device_reset(void);
	39	virtual const rom_entry *device_rom_region() const;
	40	virtual machine_config_constructor device_mconfig_additions() const;
	41	virtual void            device_config_complete();
42	42
43	43	private:
44	44	tmc0285n_device *m_vsp;

trunk/src/mess/machine/ti99/horizon.h

r20929	r20930
31	31	DECLARE_INPUT_CHANGED_MEMBER( ks_changed );
32	32
33	33	protected:
34		void device_start();
35		void device_reset();
	34	virtual void device_start();
	35	virtual void device_reset();
36	36
37		const rom_entry *device_rom_region() const;
38		ioport_constructor device_input_ports() const;
	37	virtual const rom_entry *device_rom_region() const;
	38	virtual ioport_constructor device_input_ports() const;
39	39
40	40	void nvram_default();
41	41	void nvram_read(emu_file &file);

trunk/src/mess/machine/psxcport.h

r20929	r20930
85	85	void ack();
86	86
87	87	protected:
88		void device_start();
	88	virtual void device_start();
89	89
90	90	private:
91	91	virtual void data_in(int data, int mask);

trunk/src/mess/machine/nextkbd.h

r20929	r20930
13	13	void setup(line_cb_t int_change_cb, line_cb_t _int_power_cb, line_cb_t _int_nmi_cb);
14	14
15	15	DECLARE_ADDRESS_MAP(amap, 32);
16		ioport_constructor device_input_ports() const;
17	16
18	17	DECLARE_READ32_MEMBER(ctrl_r);
19	18	DECLARE_READ32_MEMBER(ctrl2_r);
r20929	r20930
31	30	virtual void device_start();
32	31	virtual void device_reset();
33	32	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	33	virtual ioport_constructor device_input_ports() const;
34	34
35	35	private:
36	36	enum { FLAG_INT = 0x800000, FLAG_DATA = 0x400000, FLAG_RESET = 0x000200 };

trunk/src/mess/includes/pc4.h

r20929	r20930
34	34	//LCD controller
35	35	void update_ac(void);
36	36	void set_busy_flag(UINT16 usec);
37		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	37	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
38	38
39	39	DECLARE_WRITE8_MEMBER(lcd_control_w);
40	40	DECLARE_READ8_MEMBER(lcd_control_r);

trunk/src/mess/includes/next.h

r20929	r20930
156	156	virtual void machine_start();
157	157	virtual void machine_reset();
158	158
159		void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	159	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
160	160	void timer_start();
161	161	void timer_update();
162	162

trunk/src/mess/video/hd44780.h

r20929	r20930
59	59	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
60	60
61	61	// optional information overrides
62		const rom_entry *device_rom_region() const;
	62	virtual const rom_entry *device_rom_region() const;
63	63
64	64	// charset
65	65	enum

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team