Previous

199869 Revisions

Next

r23831 Friday 21st June, 2013 at 10:26:41 UTC by Miodrag Milanović
extended large amount of devices with shortname and source file data (nw)

[src/emu]	sprite.h
[src/emu/cpu/psx]	dma.c irq.c mdec.c rcnt.c sio.c sio.h
[src/emu/sound]	2151intf.c 2203intf.c 2413intf.c 2608intf.c 2610intf.c 2610intf.h 2612intf.c 2612intf.h 262intf.c 3526intf.c 3812intf.c 8950intf.c aica.c asc.c astrocde.c awacs.c ay8910.c ay8910.h beep.c c140.c c352.c c6280.c cdda.c cdp1863.c cdp1864.c cdp1869.c cem3394.c digitalk.c discrete.c dmadac.c es5503.c es5506.c es5506.h es8712.c flt_rc.c flt_vol.c gaelco.c gaelco.h hc55516.c hc55516.h i5000.c ics2115.c iremga20.c k005289.c k007232.c k051649.c k053260.c k056800.c lmc1992.c mas3507d.c mos6560.c mos6560.h mos6581.c mos6581.h mos7360.c msm5205.c msm5205.h msm5232.c multipcm.c n63701x.c namco.c namco.h nes_apu.c nile.c okim6258.c okim6295.c okim6376.c okim9810.c pokey.c rf5c400.c rf5c68.c s14001a.c s2636.c saa1099.c samples.c scsp.c sn76477.c sn76496.c sn76496.h snkwave.c sp0250.c sp0256.c speaker.c spu.c st0016.c t6721a.c t6w28.c tc8830f.c tiaintf.c tms3615.c tms36xx.c tms5110.c tms5110.h tms5220.c tms5220.h upd7759.c upd7759.h vlm5030.c vrender0.c wave.c x1_010.c ymf271.c ymf278b.c ymz280b.c ymz770.c zsg2.c
[src/emu/video]	bufsprite.h
[src/mame/audio]	amiga.c beezer.c cps3.c decobsmt.c dsbz80.c exidy.c exidy.h exidy440.c flower.c geebee.c gomoku.c gridlee.c hyprolyb.c irem.c leland.c m72.c micro3d.c phoenix.c pleiads.c pleiads.h polepos.c redbaron.c segag80r.c segasnd.c seibu.c snes_snd.c snk6502.c taitosnd.c tiamc1.c timeplt.c trackfld.c tx1.c warpwarp.c wiping.c
[src/mame/drivers]	littlerb.c mjkjidai.c namcoic.c pinkiri8.c renegade.c
[src/mame/includes]	leland.h tx1.h
[src/mame/machine]	atari_vg.c bfm_bd1.c bfm_bda.c buggychl.c cd32.c cdi070.c cdicdic.c cdislave.c decocass_tape.c gaelco3d.c kaneko_calc3.c kaneko_hit.c kaneko_toybox.c maple-dc.c mathbox.c mega32x.c mega32x.h megacd.c megacd.h megacdcd.c n64.c naomig1.c nmk112.c ns11prot.c ns11prot.h segaic16.c taitoio.c ticket.c
[src/mame/video]	atarirle.c decbac06.c deckarn.c decmxc06.c deco16ic.c decocomn.c decospr.c gp9001.c kan_pand.c kaneko_grap2.c kaneko_spr.c kaneko_tmap.c konicdev.c mcd212.c powervr2.c ppu2c0x.c ppu2c0x.h scn2674.c segaic24.c seta001.c sknsspr.c st0020.c taitoic.c tia.c vrender0.c vsystem_spr.c vsystem_spr2.c

trunk/src/emu/sprite.h

r23830	r23831
114	114	protected:
115	115	// construction/destruction - only for subclasses
116	116	sprite_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, int dirty_granularity = 3)
117		: device_t(mconfig, type, name, tag, owner, 0),
	117	: device_t(mconfig, type, name, tag, owner, 0, "sprite", __FILE__),
118	118	m_xorigin(0),
119	119	m_yorigin(0),
120	120	m_spriteram(NULL),

trunk/src/emu/cpu/psx/rcnt.c

r23830	r23831
25	25	const device_type PSX_RCNT = &device_creator<psxrcnt_device>;
26	26
27	27	psxrcnt_device::psxrcnt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
28		device_t(mconfig, PSX_RCNT, "PSX RCNT", tag, owner, clock),
	28	device_t(mconfig, PSX_RCNT, "PSX RCNT", tag, owner, clock, "psxrcnt", __FILE__),
29	29	m_irq0_handler(*this),
30	30	m_irq1_handler(*this),
31	31	m_irq2_handler(*this)

trunk/src/emu/cpu/psx/mdec.c

r23830	r23831
29	29	const device_type PSX_MDEC = &device_creator<psxmdec_device>;
30	30
31	31	psxmdec_device::psxmdec_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
32		: device_t(mconfig, PSX_MDEC, "PSX MDEC", tag, owner, clock)
	32	: device_t(mconfig, PSX_MDEC, "PSX MDEC", tag, owner, clock, "psxmdec", __FILE__)
33	33	{
34	34	}
35	35

trunk/src/emu/cpu/psx/sio.c

r23830	r23831
26	26	const device_type PSX_SIO1 = &device_creator<psxsio1_device>;
27	27
28	28	psxsio0_device::psxsio0_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
29		psxsio_device(mconfig, PSX_SIO0, tag, owner, clock)
	29	psxsio_device(mconfig, PSX_SIO0, tag, owner, clock, "psxsio0", __FILE__)
30	30	{
31	31	}
32	32
33	33	psxsio1_device::psxsio1_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
34		psxsio_device(mconfig, PSX_SIO1, tag, owner, clock)
	34	psxsio_device(mconfig, PSX_SIO1, tag, owner, clock, "psxsio1", __FILE__)
35	35	{
36	36	}
37	37
38		psxsio_device::psxsio_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock) :
39		device_t(mconfig, type, "PSX SIO", tag, owner, clock),
	38	psxsio_device::psxsio_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source) :
	39	device_t(mconfig, type, "PSX SIO", tag, owner, clock, shortname, source),
40	40	m_irq_handler(*this)
41	41	{
42	42	}

trunk/src/emu/cpu/psx/irq.c

r23830	r23831
28	28	const device_type PSX_IRQ = &device_creator<psxirq_device>;
29	29
30	30	psxirq_device::psxirq_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
31		device_t(mconfig, PSX_IRQ, "PSX IRQ", tag, owner, clock),
	31	device_t(mconfig, PSX_IRQ, "PSX IRQ", tag, owner, clock, "psxirq", __FILE__),
32	32	m_irq_handler(*this)
33	33	{
34	34	}

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

r23830	r23831
38	38	class psxsio_device : public device_t
39	39	{
40	40	public:
41		psxsio_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock);
	41	psxsio_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
42	42
43	43	// static configuration helpers
44	44	template<class _Object> static devcb2_base &set_irq_handler(device_t &device, _Object object) { return downcast<psxsio_device &>(device).m_irq_handler.set_callback(object); }

trunk/src/emu/cpu/psx/dma.c

r23830	r23831
26	26	const device_type PSX_DMA = &device_creator<psxdma_device>;
27	27
28	28	psxdma_device::psxdma_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
29		device_t(mconfig, PSX_DMA, "PSX DMA", tag, owner, clock),
	29	device_t(mconfig, PSX_DMA, "PSX DMA", tag, owner, clock, "psxdma", __FILE__),
30	30	m_irq_handler(*this)
31	31	{
32	32	}

trunk/src/emu/video/bufsprite.h

r23830	r23831
83	83	public:
84	84	// construction
85	85	buffered_spriteram_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, UINT32 clock)
86		: device_t(mconfig, type, "Buffered Sprite RAM", tag, owner, clock),
	86	: device_t(mconfig, type, "Buffered Sprite RAM", tag, owner, clock, "buffered_spriteram", __FILE__),
87	87	m_spriteram(*owner, tag) { }
88	88
89	89	// getters

trunk/src/emu/sound/msm5205.c

r23830	r23831
56	56
57	57
58	58	msm5205_device::msm5205_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
59		: device_t(mconfig, MSM5205, "MSM5205", tag, owner, clock),
	59	: device_t(mconfig, MSM5205, "MSM5205", tag, owner, clock, "msm5205", __FILE__),
60	60	device_sound_interface(mconfig, *this)
61	61	{
62	62	}
63	63
64		msm5205_device::msm5205_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
65		: device_t(mconfig, type, name, tag, owner, clock),
	64	msm5205_device::msm5205_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	65	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
66	66	device_sound_interface(mconfig, *this)
67	67	{
68	68	}
69	69
70	70
71	71	msm6585_device::msm6585_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
72		: msm5205_device(mconfig, MSM6585, "MSM6585", tag, owner, clock)
	72	: msm5205_device(mconfig, MSM6585, "MSM6585", tag, owner, clock, "msm6585", __FILE__)
73	73	{
74	74	}
75	75

trunk/src/emu/sound/msm5205.h

r23830	r23831
36	36	{
37	37	public:
38	38	msm5205_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
39		msm5205_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	39	msm5205_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
40	40	~msm5205_device() {}
41	41
42	42	// reset signal should keep for 2cycle of VCLK

trunk/src/emu/sound/3812intf.c

r23830	r23831
152	152	const device_type YM3812 = &device_creator<ym3812_device>;
153	153
154	154	ym3812_device::ym3812_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
155		: device_t(mconfig, YM3812, "YM3812", tag, owner, clock),
	155	: device_t(mconfig, YM3812, "YM3812", tag, owner, clock, "ym3812", __FILE__),
156	156	device_sound_interface(mconfig, *this),
157	157	m_irq_handler(*this)
158	158	{

trunk/src/emu/sound/snkwave.c

r23830	r23831
20	20	//-------------------------------------------------
21	21
22	22	snkwave_device::snkwave_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
23		: device_t(mconfig, SNKWAVE, "SNK Wave", tag, owner, clock),
	23	: device_t(mconfig, SNKWAVE, "SNK Wave", tag, owner, clock, "snkwave", __FILE__),
24	24	device_sound_interface(mconfig, *this),
25	25	m_stream(NULL),
26	26	m_external_clock(0),

trunk/src/emu/sound/rf5c400.c

r23830	r23831
64	64	//-------------------------------------------------
65	65
66	66	rf5c400_device::rf5c400_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
67		: device_t(mconfig, RF5C400, "RF5C400", tag, owner, clock),
	67	: device_t(mconfig, RF5C400, "RF5C400", tag, owner, clock, "rf5c400", __FILE__),
68	68	device_sound_interface(mconfig, *this),
69	69	m_rom(NULL),
70	70	m_rom_length(0),

trunk/src/emu/sound/saa1099.c

r23830	r23831
132	132	//-------------------------------------------------
133	133
134	134	saa1099_device::saa1099_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
135		: device_t(mconfig, SAA1099, "SAA1099", tag, owner, clock),
	135	: device_t(mconfig, SAA1099, "SAA1099", tag, owner, clock, "saa1099", __FILE__),
136	136	device_sound_interface(mconfig, *this),
137	137	m_stream(NULL),
138	138	m_all_ch_enable(0),

trunk/src/emu/sound/cem3394.c

r23830	r23831
114	114	//-------------------------------------------------
115	115
116	116	cem3394_device::cem3394_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
117		: device_t(mconfig, CEM3394, "CEM3394", tag, owner, clock),
	117	: device_t(mconfig, CEM3394, "CEM3394", tag, owner, clock, "cem3394", __FILE__),
118	118	device_sound_interface(mconfig, *this),
119	119	m_external(NULL),
120	120	m_stream(NULL),

trunk/src/emu/sound/digitalk.c

r23830	r23831
262	262	const device_type DIGITALKER = &device_creator<digitalker_device>;
263	263
264	264	digitalker_device::digitalker_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
265		: device_t(mconfig, DIGITALKER, "Digitalker", tag, owner, clock),
	265	: device_t(mconfig, DIGITALKER, "Digitalker", tag, owner, clock, "digitalker", __FILE__),
266	266	device_sound_interface(mconfig, *this),
267	267	m_rom(NULL),
268	268	m_stream(NULL),

trunk/src/emu/sound/ymz770.c

r23830	r23831
19	19	//-------------------------------------------------
20	20
21	21	ymz770_device::ymz770_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
22		: device_t(mconfig, YMZ770, "Yamaha YMZ770", tag, owner, clock),
	22	: device_t(mconfig, YMZ770, "Yamaha YMZ770", tag, owner, clock, "ymz770", __FILE__),
23	23	device_sound_interface(mconfig, *this)
24	24	{
25	25	}

trunk/src/emu/sound/mos6560.c

r23830	r23831
686	686	AM_RANGE(0x000, 0x3ff) AM_RAM
687	687	ADDRESS_MAP_END
688	688
689		mos6560_device::mos6560_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant)
690		: device_t(mconfig, type, name, tag, owner, clock),
	689	mos6560_device::mos6560_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant, const char *shortname, const char *source)
	690	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
691	691	device_memory_interface(mconfig, *this),
692	692	device_sound_interface(mconfig, *this),
693	693	m_variant(variant),
r23830	r23831
699	699	}
700	700
701	701	mos6560_device::mos6560_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
702		: device_t(mconfig, MOS6560, "MOS6560", tag, owner, clock),
	702	: device_t(mconfig, MOS6560, "MOS6560", tag, owner, clock, "mos6560", __FILE__),
703	703	device_memory_interface(mconfig, *this),
704	704	device_sound_interface(mconfig, *this),
705	705	m_variant(TYPE_6560),
r23830	r23831
711	711	}
712	712
713	713	mos6561_device::mos6561_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
714		:mos6560_device(mconfig, MOS6561, "MOS6561", tag, owner, clock, TYPE_6561) { }
	714	:mos6560_device(mconfig, MOS6561, "MOS6561", tag, owner, clock, TYPE_6561, "mos6561", __FILE__) { }
715	715
716	716	mos656x_attack_ufo_device::mos656x_attack_ufo_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
717		:mos6560_device(mconfig, MOS656X_ATTACK_UFO, "MOS656X", tag, owner, clock, TYPE_ATTACK_UFO) { }
	717	:mos6560_device(mconfig, MOS656X_ATTACK_UFO, "MOS656X", tag, owner, clock, TYPE_ATTACK_UFO, "mos656x_attack_ufo", __FILE__) { }
718	718
719	719
720	720	//-------------------------------------------------

trunk/src/emu/sound/okim9810.c

r23830	r23831
76	76	//-------------------------------------------------
77	77
78	78	okim9810_device::okim9810_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
79		: device_t(mconfig, OKIM9810, "OKI9810", tag, owner, clock),
	79	: device_t(mconfig, OKIM9810, "OKI9810", tag, owner, clock, "okim9810", __FILE__),
80	80	device_sound_interface(mconfig, *this),
81	81	device_memory_interface(mconfig, *this),
82	82	m_space_config("samples", ENDIANNESS_BIG, 8, 24, 0, NULL, *ADDRESS_MAP_NAME(okim9810)),

trunk/src/emu/sound/mos6560.h

r23830	r23831
128	128	public device_sound_interface
129	129	{
130	130	public:
131		mos6560_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant);
	131	mos6560_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant, const char *shortname, const char *source);
132	132	mos6560_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
133	133
134	134	template<class _potx, class _poty> void set_callbacks(const char *screen_tag, _potx potx, _poty poty) {

trunk/src/emu/sound/i5000.c

r23830	r23831
22	22	const device_type I5000_SND = &device_creator<i5000snd_device>;
23	23
24	24	i5000snd_device::i5000snd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
25		: device_t(mconfig, I5000_SND, "I5000", tag, owner, clock),
	25	: device_t(mconfig, I5000_SND, "I5000", tag, owner, clock, "i5000snd", __FILE__),
26	26	device_sound_interface(mconfig, *this)
27	27	{
28	28	}

trunk/src/emu/sound/aica.c

r23830	r23831
1355	1355	const device_type AICA = &device_creator<aica_device>;
1356	1356
1357	1357	aica_device::aica_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1358		: device_t(mconfig, AICA, "AICA", tag, owner, clock),
	1358	: device_t(mconfig, AICA, "AICA", tag, owner, clock, "aica", __FILE__),
1359	1359	device_sound_interface(mconfig, *this)
1360	1360	{
1361	1361	m_token = global_alloc_clear(aica_state);

trunk/src/emu/sound/sn76496.c

r23830	r23831
125	125
126	126	sn76496_base_device::sn76496_base_device(const machine_config &mconfig, device_type type,  const char *name,
127	127	const char *tag, int feedbackmask, int noisetap1, int noisetap2, bool negate, bool stereo, int clockdivider, int freq0,
128		device_t *owner, UINT32 clock)
	128	device_t *owner, UINT32 clock, const char *shortname, const char *source)
129	129
130		: device_t(mconfig, type, name, tag, owner, clock),
	130	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
131	131	device_sound_interface(mconfig, *this),
132	132	m_feedback_mask(feedbackmask),
133	133	m_whitenoise_tap1(noisetap1),

trunk/src/emu/sound/wave.c

r23830	r23831
85	85	const device_type WAVE = &device_creator<wave_device>;
86	86
87	87	wave_device::wave_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
88		: device_t(mconfig, WAVE, "Cassette", tag, owner, clock),
	88	: device_t(mconfig, WAVE, "Cassette", tag, owner, clock, "wawe", __FILE__),
89	89	device_sound_interface(mconfig, *this)
90	90	{
91	91	}

trunk/src/emu/sound/astrocde.c

r23830	r23831
56	56	//-------------------------------------------------
57	57
58	58	astrocade_device::astrocade_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
59		: device_t(mconfig, ASTROCADE, "Astrocade", tag, owner, clock),
	59	: device_t(mconfig, ASTROCADE, "Astrocade", tag, owner, clock, "astrocade", __FILE__),
60	60	device_sound_interface(mconfig, *this),
61	61	m_stream(NULL),
62	62	m_master_count(0),

trunk/src/emu/sound/sn76496.h

r23830	r23831
25	25	public:
26	26	sn76496_base_device(const machine_config &mconfig, device_type type,  const char *name, const char *tag,
27	27	int feedbackmask, int noisetap1, int noisetap2, bool negate, bool stereo, int clockdivider, int freq0,
28		device_t *owner, UINT32 clock);
	28	device_t *owner, UINT32 clock, const char *shortname, const char *source);
29	29	DECLARE_READ_LINE_MEMBER( ready_r );
30	30	DECLARE_WRITE8_MEMBER( stereo_w );
31	31	void write(UINT8 data);
r23830	r23831
72	72	{
73	73	public:
74	74	sn76496_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
75		:  sn76496_base_device(mconfig, SN76496, "SN76496", tag, 0x10000, 0x04, 0x08, false, false, 8, true, owner, clock)
	75	:  sn76496_base_device(mconfig, SN76496, "SN76496", tag, 0x10000, 0x04, 0x08, false, false, 8, true, owner, clock, "sn76496", __FILE__)
76	76	{ }
77	77	};
78	78
r23830	r23831
81	81	{
82	82	public:
83	83	u8106_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
84		:  sn76496_base_device(mconfig, U8106, "U8106", tag, 0x4000, 0x01, 0x02, true, false, 8, true, owner, clock)
	84	:  sn76496_base_device(mconfig, U8106, "U8106", tag, 0x4000, 0x01, 0x02, true, false, 8, true, owner, clock, "u8106", __FILE__)
85	85	{ }
86	86	};
87	87
r23830	r23831
90	90	{
91	91	public:
92	92	y2404_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
93		:  sn76496_base_device(mconfig, Y2404, "Y2404", tag, 0x10000, 0x04, 0x08, false, false, 8, true, owner, clock)
	93	:  sn76496_base_device(mconfig, Y2404, "Y2404", tag, 0x10000, 0x04, 0x08, false, false, 8, true, owner, clock, "y2404", __FILE__)
94	94	{ }
95	95	};
96	96
r23830	r23831
99	99	{
100	100	public:
101	101	sn76489_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
102		:  sn76496_base_device(mconfig, SN76489, "SN76489", tag, 0x4000, 0x01, 0x02, true, false, 8, true, owner, clock)
	102	:  sn76496_base_device(mconfig, SN76489, "SN76489", tag, 0x4000, 0x01, 0x02, true, false, 8, true, owner, clock, "sn76489", __FILE__)
103	103	{ }
104	104	};
105	105
r23830	r23831
108	108	{
109	109	public:
110	110	sn76489a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
111		:  sn76496_base_device(mconfig, SN76489A, "SN76489A", tag, 0x10000, 0x04, 0x08, false, false, 8, true, owner, clock)
	111	:  sn76496_base_device(mconfig, SN76489A, "SN76489A", tag, 0x10000, 0x04, 0x08, false, false, 8, true, owner, clock, "sn76489a", __FILE__)
112	112	{ }
113	113	};
114	114
r23830	r23831
117	117	{
118	118	public:
119	119	sn76494_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
120		:  sn76496_base_device(mconfig, SN76494, "SN76494", tag, 0x10000, 0x04, 0x08, false, false, 1, true, owner, clock)
	120	:  sn76496_base_device(mconfig, SN76494, "SN76494", tag, 0x10000, 0x04, 0x08, false, false, 1, true, owner, clock, "sn76494", __FILE__)
121	121	{ }
122	122	};
123	123
r23830	r23831
126	126	{
127	127	public:
128	128	sn94624_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
129		:  sn76496_base_device(mconfig, SN94624, "SN94624", tag, 0x4000, 0x01, 0x02, true, false, 1, true, owner, clock)
	129	:  sn76496_base_device(mconfig, SN94624, "SN94624", tag, 0x4000, 0x01, 0x02, true, false, 1, true, owner, clock, "sn94624", __FILE__)
130	130	{ }
131	131	};
132	132
r23830	r23831
135	135	{
136	136	public:
137	137	ncr7496_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
138		:  sn76496_base_device(mconfig, NCR7496, "NCR7496", tag, 0x8000, 0x02, 0x20, false, false, 8, true, owner, clock)
	138	:  sn76496_base_device(mconfig, NCR7496, "NCR7496", tag, 0x8000, 0x02, 0x20, false, false, 8, true, owner, clock, "ncr7496", __FILE__)
139	139	{ }
140	140	};
141	141
r23830	r23831
144	144	{
145	145	public:
146	146	gamegear_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
147		:  sn76496_base_device(mconfig, GAMEGEAR, "Game Gear PSG", tag, 0x8000, 0x01, 0x08, true, true, 8, false, owner, clock)
	147	:  sn76496_base_device(mconfig, GAMEGEAR, "Game Gear PSG", tag, 0x8000, 0x01, 0x08, true, true, 8, false, owner, clock, "gamegear", __FILE__)
148	148	{ }
149	149	};
150	150
r23830	r23831
153	153	{
154	154	public:
155	155	segapsg_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
156		:  sn76496_base_device(mconfig, SEGAPSG, "SEGA VDP PSG", tag, 0x8000, 0x01, 0x08, true, false, 8, false, owner, clock)
	156	:  sn76496_base_device(mconfig, SEGAPSG, "SEGA VDP PSG", tag, 0x8000, 0x01, 0x08, true, false, 8, false, owner, clock, "segapsg", __FILE__)
157	157	{ }
158	158	};
159	159

trunk/src/emu/sound/pokey.c

r23830	r23831
181	181	//-------------------------------------------------
182	182
183	183	pokey_device::pokey_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
184		: device_t(mconfig, POKEY, "POKEY", tag, owner, clock),
	184	: device_t(mconfig, POKEY, "POKEY", tag, owner, clock, "pokey", __FILE__),
185	185	device_sound_interface(mconfig, *this),
186	186	device_execute_interface(mconfig, *this),
187	187	device_state_interface(mconfig, *this),

trunk/src/emu/sound/tiaintf.c

r23830	r23831
15	15	//-------------------------------------------------
16	16
17	17	tia_device::tia_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
18		: device_t(mconfig, TIA, "TIA", tag, owner, clock),
	18	: device_t(mconfig, TIA, "TIA", tag, owner, clock, "tia_sound", __FILE__),
19	19	device_sound_interface(mconfig, *this),
20	20	m_channel(NULL),
21	21	m_chip(NULL)

trunk/src/emu/sound/c6280.c

r23830	r23831
247	247	const device_type C6280 = &device_creator<c6280_device>;
248	248
249	249	c6280_device::c6280_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
250		: device_t(mconfig, C6280, "HuC6280", tag, owner, clock),
	250	: device_t(mconfig, C6280, "HuC6280", tag, owner, clock, "c6280", __FILE__),
251	251	device_sound_interface(mconfig, *this)
252	252	{
253	253	}

trunk/src/emu/sound/discrete.c

r23830	r23831
825	825	//-------------------------------------------------
826	826
827	827	discrete_device::discrete_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
828		: device_t(mconfig, type, name, tag, owner, clock),
	828	: device_t(mconfig, type, name, tag, owner, clock, "discrete", __FILE__),
829	829	m_intf(NULL),
830	830	m_sample_rate(0),
831	831	m_sample_time(0),

trunk/src/emu/sound/samples.c

r23830	r23831
75	75	//-------------------------------------------------
76	76
77	77	samples_device::samples_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
78		: device_t(mconfig, SAMPLES, "Samples", tag, owner, clock),
	78	: device_t(mconfig, SAMPLES, "Samples", tag, owner, clock, "samples", __FILE__),
79	79	device_sound_interface(mconfig, *this)
80	80	{
81	81	}

trunk/src/emu/sound/msm5232.c

r23830	r23831
853	853	const device_type MSM5232 = &device_creator<msm5232_device>;
854	854
855	855	msm5232_device::msm5232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
856		: device_t(mconfig, MSM5232, "MSM5232", tag, owner, clock),
	856	: device_t(mconfig, MSM5232, "MSM5232", tag, owner, clock, "msm5232", __FILE__),
857	857	device_sound_interface(mconfig, *this)
858	858	{
859	859	m_token = global_alloc_clear(msm5232_state);

trunk/src/emu/sound/scsp.c

r23830	r23831
1492	1492	const device_type SCSP = &device_creator<scsp_device>;
1493	1493
1494	1494	scsp_device::scsp_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1495		: device_t(mconfig, SCSP, "SCSP", tag, owner, clock),
	1495	: device_t(mconfig, SCSP, "SCSP", tag, owner, clock, "scsp", __FILE__),
1496	1496	device_sound_interface(mconfig, *this)
1497	1497	{
1498	1498	m_token = global_alloc_clear(scsp_state);

trunk/src/emu/sound/flt_rc.c

r23830	r23831
18	18	//-------------------------------------------------
19	19
20	20	filter_rc_device::filter_rc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
21		: device_t(mconfig, FILTER_RC, "RC Filter", tag, owner, clock),
	21	: device_t(mconfig, FILTER_RC, "RC Filter", tag, owner, clock, "filter_rc", __FILE__),
22	22	device_sound_interface(mconfig, *this),
23	23	m_stream(NULL),
24	24	m_k(0),

trunk/src/emu/sound/ics2115.c

r23830	r23831
22	22	}
23	23
24	24	ics2115_device::ics2115_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
25		: device_t(mconfig, ICS2115, "ICS2115", tag, owner, clock),
	25	: device_t(mconfig, ICS2115, "ICS2115", tag, owner, clock, "ics2115", __FILE__),
26	26	device_sound_interface(mconfig, *this),
27	27	m_irq_cb(NULL)
28	28	{

trunk/src/emu/sound/s14001a.c

r23830	r23831
636	636	const device_type S14001A = &device_creator<s14001a_device>;
637	637
638	638	s14001a_device::s14001a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
639		: device_t(mconfig, S14001A, "S14001A", tag, owner, clock),
	639	: device_t(mconfig, S14001A, "S14001A", tag, owner, clock, "s14001a", __FILE__),
640	640	device_sound_interface(mconfig, *this)
641	641	{
642	642	m_token = global_alloc_clear(S14001AChip);

trunk/src/emu/sound/2608intf.c

r23830	r23831
202	202	const device_type YM2608 = &device_creator<ym2608_device>;
203	203
204	204	ym2608_device::ym2608_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
205		: device_t(mconfig, YM2608, "YM2608", tag, owner, clock),
	205	: device_t(mconfig, YM2608, "YM2608", tag, owner, clock, "ym2608", __FILE__),
206	206	device_sound_interface(mconfig, *this),
207	207	m_irq_handler(*this),
208	208	m_ay8910_config(NULL)

trunk/src/emu/sound/zsg2.c

r23830	r23831
60	60	//-------------------------------------------------
61	61
62	62	zsg2_device::zsg2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
63		: device_t(mconfig, ZSG2, "ZSG-2", tag, owner, clock),
	63	: device_t(mconfig, ZSG2, "ZSG-2", tag, owner, clock, "zsg2", __FILE__),
64	64	device_sound_interface(mconfig, *this),
65	65	m_alow(0),
66	66	m_ahigh(0),

trunk/src/emu/sound/ymf278b.c

r23830	r23831
1002	1002	const device_type YMF278B = &device_creator<ymf278b_device>;
1003	1003
1004	1004	ymf278b_device::ymf278b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1005		: device_t(mconfig, YMF278B, "YMF278B", tag, owner, clock),
	1005	: device_t(mconfig, YMF278B, "YMF278B", tag, owner, clock, "ymf278b", __FILE__),
1006	1006	device_sound_interface(mconfig, *this),
1007	1007	m_irq_handler(*this)
1008	1008	{

trunk/src/emu/sound/flt_vol.c

r23830	r23831
10	10	//-------------------------------------------------
11	11
12	12	filter_volume_device::filter_volume_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
13		: device_t(mconfig, FILTER_VOLUME, "Volume Filter", tag, owner, clock),
	13	: device_t(mconfig, FILTER_VOLUME, "Volume Filter", tag, owner, clock, "filter_volume", __FILE__),
14	14	device_sound_interface(mconfig, *this),
15	15	m_stream(NULL),
16	16	m_gain(0)

trunk/src/emu/sound/2151intf.c

r23830	r23831
21	21	//-------------------------------------------------
22	22
23	23	ym2151_device::ym2151_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
24		: device_t(mconfig, YM2151, "YM2151", tag, owner, clock),
	24	: device_t(mconfig, YM2151, "YM2151", tag, owner, clock, "ym2151", __FILE__),
25	25	device_sound_interface(mconfig, *this),
26	26	m_irqhandler(*this),
27	27	m_portwritehandler(*this)

trunk/src/emu/sound/k053260.c

r23830	r23831
27	27	//-------------------------------------------------
28	28
29	29	k053260_device::k053260_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
30		: device_t(mconfig, K053260, "K053260", tag, owner, clock),
	30	: device_t(mconfig, K053260, "K053260", tag, owner, clock, "k053260", __FILE__),
31	31	device_sound_interface(mconfig, *this),
32	32	m_channel(NULL),
33	33	m_mode(0),

trunk/src/emu/sound/vrender0.c

r23830	r23831
82	82	//-------------------------------------------------
83	83
84	84	vrender0_device::vrender0_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
85		: device_t(mconfig, VRENDER0, "VRender0", tag, owner, clock),
	85	: device_t(mconfig, VRENDER0, "VRender0", tag, owner, clock, "vrender0", __FILE__),
86	86	device_sound_interface(mconfig, *this),
87	87	m_TexBase(NULL),
88	88	m_FBBase(NULL),

trunk/src/emu/sound/8950intf.c

r23830	r23831
203	203	const device_type Y8950 = &device_creator<y8950_device>;
204	204
205	205	y8950_device::y8950_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
206		: device_t(mconfig, Y8950, "Y8950", tag, owner, clock),
	206	: device_t(mconfig, Y8950, "Y8950", tag, owner, clock, "y8950", __FILE__),
207	207	device_sound_interface(mconfig, *this),
208	208	m_irq_handler(*this),
209	209	m_keyboard_read_handler(*this),

trunk/src/emu/sound/multipcm.c

r23830	r23831
675	675	const device_type MULTIPCM = &device_creator<multipcm_device>;
676	676
677	677	multipcm_device::multipcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
678		: device_t(mconfig, MULTIPCM, "Sega/Yamaha 315-5560", tag, owner, clock),
	678	: device_t(mconfig, MULTIPCM, "Sega/Yamaha 315-5560", tag, owner, clock, "multipcm", __FILE__),
679	679	device_sound_interface(mconfig, *this)
680	680	{
681	681	m_token = global_alloc_clear(MultiPCM);

trunk/src/emu/sound/awacs.c

r23830	r23831
23	23	//-------------------------------------------------
24	24
25	25	awacs_device::awacs_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
26		: device_t(mconfig, AWACS, "AWACS", tag, owner, clock),
	26	: device_t(mconfig, AWACS, "AWACS", tag, owner, clock, "awacs", __FILE__),
27	27	device_sound_interface(mconfig, *this)
28	28	{
29	29	}

trunk/src/emu/sound/asc.c

r23830	r23831
44	44	//-------------------------------------------------
45	45
46	46	asc_device::asc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
47		: device_t(mconfig, ASC, "ASC", tag, owner, clock),
	47	: device_t(mconfig, ASC, "ASC", tag, owner, clock, "asc", __FILE__),
48	48	device_sound_interface(mconfig, *this),
49	49	m_chip_type(0),
50	50	m_irq_cb(NULL)

trunk/src/emu/sound/2203intf.c

r23830	r23831
203	203	const device_type YM2203 = &device_creator<ym2203_device>;
204	204
205	205	ym2203_device::ym2203_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
206		: device_t(mconfig, YM2203, "YM2203", tag, owner, clock),
	206	: device_t(mconfig, YM2203, "YM2203", tag, owner, clock, "ym2203", __FILE__),
207	207	device_sound_interface(mconfig, *this),
208	208	m_irq_handler(*this),
209	209	m_ay8910_config(NULL)

trunk/src/emu/sound/k007232.c

r23830	r23831
146	146	const device_type K007232 = &device_creator<k007232_device>;
147	147
148	148	k007232_device::k007232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
149		: device_t(mconfig, K007232, "K007232", tag, owner, clock),
	149	: device_t(mconfig, K007232, "K007232", tag, owner, clock, "k007232", __FILE__),
150	150	device_sound_interface(mconfig, *this)
151	151	{
152	152

trunk/src/emu/sound/es5503.c

r23830	r23831
62	62	//-------------------------------------------------
63	63
64	64	es5503_device::es5503_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
65		: device_t(mconfig, ES5503, "Ensoniq ES5503", tag, owner, clock),
	65	: device_t(mconfig, ES5503, "Ensoniq ES5503", tag, owner, clock, "es5503", __FILE__),
66	66	device_sound_interface(mconfig, *this),
67	67	device_memory_interface(mconfig, *this),
68	68	m_space_config("es5503_samples", ENDIANNESS_LITTLE, 8, 17, 0, NULL, *ADDRESS_MAP_NAME(es5503)),

trunk/src/emu/sound/okim6258.c

r23830	r23831
45	45	//-------------------------------------------------
46	46
47	47	okim6258_device::okim6258_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
48		: device_t(mconfig, OKIM6258, "OKI6258", tag, owner, clock),
	48	: device_t(mconfig, OKIM6258, "OKI6258", tag, owner, clock, "okim6258", __FILE__),
49	49	device_sound_interface(mconfig, *this),
50	50	m_status(0),
51	51	m_master_clock(0),

trunk/src/emu/sound/nile.c

r23830	r23831
51	51	const device_type NILE = &device_creator<nile_device>;
52	52
53	53	nile_device::nile_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
54		: device_t(mconfig, NILE, "NiLe", tag, owner, clock),
	54	: device_t(mconfig, NILE, "NiLe", tag, owner, clock, "nile", __FILE__),
55	55	device_sound_interface(mconfig, *this),
56	56	m_stream(NULL),
57	57	m_sound_ram(NULL),

trunk/src/emu/sound/cdp1869.c

r23830	r23831
342	342	//-------------------------------------------------
343	343
344	344	cdp1869_device::cdp1869_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
345		: device_t(mconfig, CDP1869, "RCA CDP1869", tag, owner, clock),
	345	: device_t(mconfig, CDP1869, "RCA CDP1869", tag, owner, clock, "cdp1869", __FILE__),
346	346	device_sound_interface(mconfig, *this),
347	347	device_memory_interface(mconfig, *this),
348	348	m_stream(NULL),

trunk/src/emu/sound/sp0256.c

r23830	r23831
94	94	//**************************************************************************
95	95
96	96	sp0256_device::sp0256_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
97		: device_t(mconfig, SP0256, "SP0256", tag, owner, clock),
	97	: device_t(mconfig, SP0256, "SP0256", tag, owner, clock, "sp0256", __FILE__),
98	98	device_sound_interface(mconfig, *this)
99	99	{
100	100	}

trunk/src/emu/sound/hc55516.c

r23830	r23831
296	296	const device_type HC55516 = &device_creator<hc55516_device>;
297	297
298	298	hc55516_device::hc55516_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
299		: device_t(mconfig, HC55516, "HC-55516", tag, owner, clock),
	299	: device_t(mconfig, HC55516, "HC-55516", tag, owner, clock, "hc55516", __FILE__),
300	300	device_sound_interface(mconfig, *this)
301	301	{
302	302	m_token = global_alloc_clear(hc55516_state);
303	303	}
304		hc55516_device::hc55516_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
305		: device_t(mconfig, type, name, tag, owner, clock),
	304	hc55516_device::hc55516_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	305	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
306	306	device_sound_interface(mconfig, *this)
307	307	{
308	308	m_token = global_alloc_clear(hc55516_state);
r23830	r23831
350	350	const device_type MC3417 = &device_creator<mc3417_device>;
351	351
352	352	mc3417_device::mc3417_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
353		: hc55516_device(mconfig, MC3417, "MC3417", tag, owner, clock)
	353	: hc55516_device(mconfig, MC3417, "MC3417", tag, owner, clock, "mc3417", __FILE__)
354	354	{
355	355	}
356	356
r23830	r23831
377	377	const device_type MC3418 = &device_creator<mc3418_device>;
378	378
379	379	mc3418_device::mc3418_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
380		: hc55516_device(mconfig, MC3418, "MC3418", tag, owner, clock)
	380	: hc55516_device(mconfig, MC3418, "MC3418", tag, owner, clock, "mc3418", __FILE__)
381	381	{
382	382	}
383	383

trunk/src/emu/sound/hc55516.h

r23830	r23831
20	20	{
21	21	public:
22	22	hc55516_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
23		hc55516_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	23	hc55516_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
24	24	~hc55516_device() { global_free(m_token); }
25	25
26	26	// access to legacy token

trunk/src/emu/sound/iremga20.c

r23830	r23831
45	45	//-------------------------------------------------
46	46
47	47	iremga20_device::iremga20_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
48		: device_t(mconfig, IREMGA20, "Irem GA20", tag, owner, clock),
	48	: device_t(mconfig, IREMGA20, "Irem GA20", tag, owner, clock, "iremga20", __FILE__),
49	49	device_sound_interface(mconfig, *this),
50	50	m_rom(NULL),
51	51	m_rom_size(0),

trunk/src/emu/sound/tms5110.c

r23830	r23831
1362	1362	const device_type TMS5110 = &device_creator<tms5110_device>;
1363	1363
1364	1364	tms5110_device::tms5110_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1365		: device_t(mconfig, TMS5110, "TMS5110", tag, owner, clock),
	1365	: device_t(mconfig, TMS5110, "TMS5110", tag, owner, clock, "tms5110", __FILE__),
1366	1366	device_sound_interface(mconfig, *this)
1367	1367	{
1368	1368	}
1369	1369
1370		tms5110_device::tms5110_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
1371		: device_t(mconfig, type, name, tag, owner, clock),
	1370	tms5110_device::tms5110_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	1371	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
1372	1372	device_sound_interface(mconfig, *this)
1373	1373	{
1374	1374	}
r23830	r23831
1387	1387
1388	1388
1389	1389	tms5100_device::tms5100_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1390		: tms5110_device(mconfig, TMS5100, "TMS5100", tag, owner, clock)
	1390	: tms5110_device(mconfig, TMS5100, "TMS5100", tag, owner, clock, "tms5100", __FILE__)
1391	1391	{
1392	1392	}
1393	1393
r23830	r23831
1395	1395	const device_type TMS5110A = &device_creator<tms5110a_device>;
1396	1396
1397	1397	tms5110a_device::tms5110a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1398		: tms5110_device(mconfig, TMS5110A, "TMS5110A", tag, owner, clock)
	1398	: tms5110_device(mconfig, TMS5110A, "TMS5110A", tag, owner, clock, "tms5110a", __FILE__)
1399	1399	{
1400	1400	}
1401	1401
r23830	r23831
1403	1403	const device_type CD2801 = &device_creator<cd2801_device>;
1404	1404
1405	1405	cd2801_device::cd2801_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1406		: tms5110_device(mconfig, CD2801, "CD2801", tag, owner, clock)
	1406	: tms5110_device(mconfig, CD2801, "CD2801", tag, owner, clock, "cd2801", __FILE__)
1407	1407	{
1408	1408	}
1409	1409
r23830	r23831
1411	1411	const device_type TMC0281 = &device_creator<tmc0281_device>;
1412	1412
1413	1413	tmc0281_device::tmc0281_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1414		: tms5110_device(mconfig, TMC0281, "TMC0281", tag, owner, clock)
	1414	: tms5110_device(mconfig, TMC0281, "TMC0281", tag, owner, clock, "tmc0281", __FILE__)
1415	1415	{
1416	1416	}
1417	1417
r23830	r23831
1419	1419	const device_type CD2802 = &device_creator<cd2802_device>;
1420	1420
1421	1421	cd2802_device::cd2802_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1422		: tms5110_device(mconfig, CD2802, "CD2802", tag, owner, clock)
	1422	: tms5110_device(mconfig, CD2802, "CD2802", tag, owner, clock, "cd2802", __FILE__)
1423	1423	{
1424	1424	}
1425	1425
r23830	r23831
1427	1427	const device_type M58817 = &device_creator<m58817_device>;
1428	1428
1429	1429	m58817_device::m58817_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1430		: tms5110_device(mconfig, M58817, "M58817", tag, owner, clock)
	1430	: tms5110_device(mconfig, M58817, "M58817", tag, owner, clock, "m58817", __FILE__)
1431	1431	{
1432	1432	}
1433	1433
r23830	r23831
1435	1435	const device_type TMSPROM = &device_creator<tmsprom_device>;
1436	1436
1437	1437	tmsprom_device::tmsprom_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1438		: device_t(mconfig, TMSPROM, "TMSPROM", tag, owner, clock)
	1438	: device_t(mconfig, TMSPROM, "TMSPROM", tag, owner, clock, "tmsprom", __FILE__)
1439	1439	{
1440	1440	}
1441	1441

trunk/src/emu/sound/2612intf.c

r23830	r23831
149	149	const device_type YM2612 = &device_creator<ym2612_device>;
150	150
151	151	ym2612_device::ym2612_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
152		: device_t(mconfig, YM2612, "YM2612", tag, owner, clock),
	152	: device_t(mconfig, YM2612, "YM2612", tag, owner, clock, "ym2612", __FILE__),
153	153	device_sound_interface(mconfig, *this),
154	154	m_irq_handler(*this)
155	155	{
156	156	}
157	157
158		ym2612_device::ym2612_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
159		: device_t(mconfig, type, name, tag, owner, clock),
	158	ym2612_device::ym2612_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	159	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
160	160	device_sound_interface(mconfig, *this),
161	161	m_irq_handler(*this)
162	162	{
r23830	r23831
176	176	const device_type YM3438 = &device_creator<ym3438_device>;
177	177
178	178	ym3438_device::ym3438_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
179		: ym2612_device(mconfig, YM3438, "YM3438", tag, owner, clock)
	179	: ym2612_device(mconfig, YM3438, "YM3438", tag, owner, clock, "ym3438", __FILE__)
180	180	{
181	181	}

trunk/src/emu/sound/c352.c

r23830	r23831
36	36	//-------------------------------------------------
37	37
38	38	c352_device::c352_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
39		: device_t(mconfig, C352, "C352", tag, owner, clock),
	39	: device_t(mconfig, C352, "C352", tag, owner, clock, "c352", __FILE__),
40	40	device_sound_interface(mconfig, *this),
41	41	device_memory_interface(mconfig, *this),
42	42	m_space_config("samples", ENDIANNESS_LITTLE, 8, 24, 0, NULL, *ADDRESS_MAP_NAME(c352))

trunk/src/emu/sound/tms5110.h

r23830	r23831
45	45	{
46	46	public:
47	47	tms5110_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
48		tms5110_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	48	tms5110_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
49	49
50	50	DECLARE_WRITE8_MEMBER( ctl_w );
51	51	DECLARE_READ8_MEMBER( ctl_r );

trunk/src/emu/sound/3526intf.c

r23830	r23831
154	154	const device_type YM3526 = &device_creator<ym3526_device>;
155	155
156	156	ym3526_device::ym3526_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
157		: device_t(mconfig, YM3526, "YM3526", tag, owner, clock),
	157	: device_t(mconfig, YM3526, "YM3526", tag, owner, clock, "ym3526", __FILE__),
158	158	device_sound_interface(mconfig, *this),
159	159	m_irq_handler(*this)
160	160	{

trunk/src/emu/sound/2612intf.h

r23830	r23831
15	15	{
16	16	public:
17	17	ym2612_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
18		ym2612_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	18	ym2612_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
19	19
20	20	// static configuration helpers
21	21	template<class _Object> static devcb2_base &set_irq_handler(device_t &device, _Object object) { return downcast<ym2612_device &>(device).m_irq_handler.set_callback(object); }

trunk/src/emu/sound/k051649.c

r23830	r23831
42	42	//-------------------------------------------------
43	43
44	44	k051649_device::k051649_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
45		: device_t(mconfig, K051649, "K051649", tag, owner, clock),
	45	: device_t(mconfig, K051649, "K051649", tag, owner, clock, "k051649", __FILE__),
46	46	device_sound_interface(mconfig, *this),
47	47	m_stream(NULL),
48	48	m_mclock(0),

trunk/src/emu/sound/c140.c

r23830	r23831
85	85	//-------------------------------------------------
86	86
87	87	c140_device::c140_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
88		: device_t(mconfig, C140, "C140", tag, owner, clock),
	88	: device_t(mconfig, C140, "C140", tag, owner, clock, "c140", __FILE__),
89	89	device_sound_interface(mconfig, *this),
90	90	m_sample_rate(0),
91	91	m_stream(NULL),

trunk/src/emu/sound/ymz280b.c

r23830	r23831
941	941	const device_type YMZ280B = &device_creator<ymz280b_device>;
942	942
943	943	ymz280b_device::ymz280b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
944		: device_t(mconfig, YMZ280B, "YMZ280B", tag, owner, clock),
	944	: device_t(mconfig, YMZ280B, "YMZ280B", tag, owner, clock, "ymz280b", __FILE__),
945	945	device_sound_interface(mconfig, *this),
946	946	m_current_register(0),
947	947	m_status_register(0),

trunk/src/emu/sound/rf5c68.c

r23830	r23831
19	19	//-------------------------------------------------
20	20
21	21	rf5c68_device::rf5c68_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
22		: device_t(mconfig, RF5C68, "RF5C68", tag, owner, clock),
	22	: device_t(mconfig, RF5C68, "RF5C68", tag, owner, clock, "rf5c68", __FILE__),
23	23	device_sound_interface(mconfig, *this),
24	24	m_stream(NULL),
25	25	m_cbank(0),

trunk/src/emu/sound/k005289.c

r23830	r23831
44	44	//-------------------------------------------------
45	45
46	46	k005289_device::k005289_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
47		: device_t(mconfig, K005289, "K005289", tag, owner, clock),
	47	: device_t(mconfig, K005289, "K005289", tag, owner, clock, "k005289", __FILE__),
48	48	device_sound_interface(mconfig, *this),
49	49	m_sound_prom(NULL),
50	50	m_stream(NULL),

trunk/src/emu/sound/mos6581.c

r23830	r23831
38	38	//  mos6581_device - constructor
39	39	//-------------------------------------------------
40	40
41		mos6581_device::mos6581_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant)
42		: device_t(mconfig, type, name, tag, owner, clock),
	41	mos6581_device::mos6581_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant, const char *shortname, const char *source)
	42	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
43	43	device_sound_interface(mconfig, *this),
44	44	m_read_potx(*this),
45	45	m_read_poty(*this),
r23830	r23831
50	50	}
51	51
52	52	mos6581_device::mos6581_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
53		: device_t(mconfig, MOS6581, "MOS6581", tag, owner, clock),
	53	: device_t(mconfig, MOS6581, "MOS6581", tag, owner, clock, "mos6581", __FILE__),
54	54	device_sound_interface(mconfig, *this),
55	55	m_read_potx(*this),
56	56	m_read_poty(*this),
r23830	r23831
66	66	//-------------------------------------------------
67	67
68	68	mos8580_device::mos8580_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
69		: mos6581_device(mconfig, MOS8580, "MOS8580", tag, owner, clock, TYPE_8580)
	69	: mos6581_device(mconfig, MOS8580, "MOS8580", tag, owner, clock, TYPE_8580, "mos8580", __FILE__)
70	70	{
71	71	}
72	72

trunk/src/emu/sound/mos6581.h

r23830	r23831
54	54	public device_sound_interface
55	55	{
56	56	public:
57		mos6581_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant);
	57	mos6581_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 variant, const char *shortname, const char *source);
58	58	mos6581_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
59	59	~mos6581_device() { global_free(m_token); }
60	60

trunk/src/emu/sound/spu.c

r23830	r23831
954	954	//-------------------------------------------------
955	955
956	956	spu_device::spu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
957		device_t(mconfig, SPU, "SPU", tag, owner, clock),
	957	device_t(mconfig, SPU, "SPU", tag, owner, clock, "spu", __FILE__),
958	958	device_sound_interface(mconfig, *this),
959	959	m_irq_handler(*this),
960	960	dirty_flags(-1),

trunk/src/emu/sound/x1_010.c

r23830	r23831
286	286	const device_type X1_010 = &device_creator<x1_010_device>;
287	287
288	288	x1_010_device::x1_010_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
289		: device_t(mconfig, X1_010, "X1-010", tag, owner, clock),
	289	: device_t(mconfig, X1_010, "X1-010", tag, owner, clock, "x1_010", __FILE__),
290	290	device_sound_interface(mconfig, *this)
291	291	{
292	292	m_token = global_alloc_clear(x1_010_state);

trunk/src/emu/sound/k056800.c

r23830	r23831
13	13	const device_type K056800 = &device_creator<k056800_device>;
14	14
15	15	k056800_device::k056800_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
16		: device_t(mconfig, K056800, "Konami 056800 MIRAC", tag, owner, clock)
	16	: device_t(mconfig, K056800, "Konami 056800 MIRAC", tag, owner, clock, "k056800", __FILE__)
17	17	{
18	18	}
19	19

trunk/src/emu/sound/upd7759.c

r23830	r23831
788	788	const device_type UPD7759 = &device_creator<upd7759_device>;
789	789
790	790	upd7759_device::upd7759_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
791		: device_t(mconfig, UPD7759, "uPD7759", tag, owner, clock),
	791	: device_t(mconfig, UPD7759, "uPD7759", tag, owner, clock, "upd7759", __FILE__),
792	792	device_sound_interface(mconfig, *this)
793	793	{
794	794	m_token = global_alloc_clear(upd7759_state);
795	795	}
796		upd7759_device::upd7759_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
797		: device_t(mconfig, type, name, tag, owner, clock),
	796	upd7759_device::upd7759_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	797	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
798	798	device_sound_interface(mconfig, *this)
799	799	{
800	800	m_token = global_alloc_clear(upd7759_state);
r23830	r23831
842	842	const device_type UPD7756 = &device_creator<upd7756_device>;
843	843
844	844	upd7756_device::upd7756_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
845		: upd7759_device(mconfig, UPD7756, "uPD7756", tag, owner, clock)
	845	: upd7759_device(mconfig, UPD7756, "uPD7756", tag, owner, clock, "upd7756", __FILE__)
846	846	{
847	847	}
848	848

trunk/src/emu/sound/ymf271.c

r23830	r23831
1753	1753	const device_type YMF271 = &device_creator<ymf271_device>;
1754	1754
1755	1755	ymf271_device::ymf271_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1756		: device_t(mconfig, YMF271, "YMF271", tag, owner, clock),
	1756	: device_t(mconfig, YMF271, "YMF271", tag, owner, clock, "ymf271", __FILE__),
1757	1757	device_sound_interface(mconfig, *this),
1758	1758	m_timerA(0),
1759	1759	m_timerB(0),

trunk/src/emu/sound/n63701x.c

r23830	r23831
30	30	const device_type NAMCO_63701X = &device_creator<namco_63701x_device>;
31	31
32	32	namco_63701x_device::namco_63701x_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
33		: device_t(mconfig, NAMCO_63701X, "Namco 63701X", tag, owner, clock),
	33	: device_t(mconfig, NAMCO_63701X, "Namco 63701X", tag, owner, clock, "namco_63701x", __FILE__),
34	34	device_sound_interface(mconfig, *this),
35	35	m_stream(NULL),
36	36	m_rom(NULL)

trunk/src/emu/sound/cdp1863.c

r23830	r23831
48	48	//-------------------------------------------------
49	49
50	50	cdp1863_device::cdp1863_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
51		: device_t(mconfig, CDP1863, "CDP1863", tag, owner, clock),
	51	: device_t(mconfig, CDP1863, "CDP1863", tag, owner, clock, "cdp1863", __FILE__),
52	52	device_sound_interface(mconfig, *this),
53	53	m_stream(NULL),
54	54	m_clock1(clock),

trunk/src/emu/sound/upd7759.h

r23830	r23831
32	32	{
33	33	public:
34	34	upd7759_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
35		upd7759_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	35	upd7759_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
36	36	~upd7759_device() { global_free(m_token); }
37	37
38	38	// access to legacy token

trunk/src/emu/sound/sp0250.c

r23830	r23831
240	240	const device_type SP0250 = &device_creator<sp0250_device>;
241	241
242	242	sp0250_device::sp0250_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
243		: device_t(mconfig, SP0250, "SP0250", tag, owner, clock),
	243	: device_t(mconfig, SP0250, "SP0250", tag, owner, clock, "sp0250", __FILE__),
244	244	device_sound_interface(mconfig, *this)
245	245	{
246	246	m_token = global_alloc_clear(sp0250_state);

trunk/src/emu/sound/speaker.c

r23830	r23831
82	82	const device_type SPEAKER_SOUND = &device_creator<speaker_sound_device>;
83	83
84	84	speaker_sound_device::speaker_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
85		: device_t(mconfig, SPEAKER_SOUND, "Filtered 1-bit DAC", tag, owner, clock),
	85	: device_t(mconfig, SPEAKER_SOUND, "Filtered 1-bit DAC", tag, owner, clock, "speaker", __FILE__),
86	86	device_sound_interface(mconfig, *this)
87	87	{
88	88	}

trunk/src/emu/sound/cdda.c

r23830	r23831
252	252	const device_type CDDA = &device_creator<cdda_device>;
253	253
254	254	cdda_device::cdda_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
255		: device_t(mconfig, CDDA, "CD/DA", tag, owner, clock),
	255	: device_t(mconfig, CDDA, "CD/DA", tag, owner, clock, "cdda", __FILE__),
256	256	device_sound_interface(mconfig, *this)
257	257	{
258	258	}

trunk/src/emu/sound/ay8910.c

r23830	r23831
1052	1052	const device_type AY8910 = &device_creator<ay8910_device>;
1053	1053
1054	1054	ay8910_device::ay8910_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1055		: device_t(mconfig, AY8910, "AY-3-8910A", tag, owner, clock),
	1055	: device_t(mconfig, AY8910, "AY-3-8910A", tag, owner, clock, "ay8910", __FILE__),
1056	1056	device_sound_interface(mconfig, *this)
1057	1057	{
1058	1058	}
1059		ay8910_device::ay8910_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
1060		: device_t(mconfig, type, name, tag, owner, clock),
	1059	ay8910_device::ay8910_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	1060	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
1061	1061	device_sound_interface(mconfig, *this)
1062	1062	{
1063	1063	}
r23830	r23831
1087	1087	const device_type AY8912 = &device_creator<ay8912_device>;
1088	1088
1089	1089	ay8912_device::ay8912_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1090		: ay8910_device(mconfig, AY8912, "AY-3-8912A", tag, owner, clock)
	1090	: ay8910_device(mconfig, AY8912, "AY-3-8912A", tag, owner, clock, "ay8913", __FILE__)
1091	1091	{
1092	1092	}
1093	1093
r23830	r23831
1095	1095	const device_type AY8913 = &device_creator<ay8913_device>;
1096	1096
1097	1097	ay8913_device::ay8913_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1098		: ay8910_device(mconfig, AY8913, "AY-3-8913A", tag, owner, clock)
	1098	: ay8910_device(mconfig, AY8913, "AY-3-8913A", tag, owner, clock, "ay8913", __FILE__)
1099	1099	{
1100	1100	}
1101	1101
r23830	r23831
1103	1103	const device_type AY8914 = &device_creator<ay8914_device>;
1104	1104
1105	1105	ay8914_device::ay8914_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1106		: ay8910_device(mconfig, AY8914, "AY-3-8914", tag, owner, clock)
	1106	: ay8910_device(mconfig, AY8914, "AY-3-8914", tag, owner, clock, "ay8914", __FILE__)
1107	1107	{
1108	1108	}
1109	1109
r23830	r23831
1111	1111	const device_type AY8930 = &device_creator<ay8930_device>;
1112	1112
1113	1113	ay8930_device::ay8930_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1114		: ay8910_device(mconfig, AY8930, "AY8930", tag, owner, clock)
	1114	: ay8910_device(mconfig, AY8930, "AY8930", tag, owner, clock, "ay8930", __FILE__)
1115	1115	{
1116	1116	}
1117	1117
r23830	r23831
1119	1119	const device_type YM2149 = &device_creator<ym2149_device>;
1120	1120
1121	1121	ym2149_device::ym2149_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1122		: ay8910_device(mconfig, YM2149, "YM2149", tag, owner, clock)
	1122	: ay8910_device(mconfig, YM2149, "YM2149", tag, owner, clock, "ym2149", __FILE__)
1123	1123	{
1124	1124	}
1125		ym2149_device::ym2149_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
1126		: ay8910_device(mconfig, type, name, tag, owner, clock)
	1125	ym2149_device::ym2149_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	1126	: ay8910_device(mconfig, type, name, tag, owner, clock, shortname, source)
1127	1127	{
1128	1128	}
1129	1129
r23830	r23831
1131	1131	const device_type YM3439 = &device_creator<ym3439_device>;
1132	1132
1133	1133	ym3439_device::ym3439_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1134		: ym2149_device(mconfig, YM3439, "YM3439", tag, owner, clock)
	1134	: ym2149_device(mconfig, YM3439, "YM3439", tag, owner, clock, "ym3429", __FILE__)
1135	1135	{
1136	1136	}
1137	1137
r23830	r23831
1139	1139	const device_type YMZ284 = &device_creator<ymz284_device>;
1140	1140
1141	1141	ymz284_device::ymz284_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1142		: ym2149_device(mconfig, YMZ284, "YMZ284", tag, owner, clock)
	1142	: ym2149_device(mconfig, YMZ284, "YMZ284", tag, owner, clock, "ymz284", __FILE__)
1143	1143	{
1144	1144	}
1145	1145
r23830	r23831
1147	1147	const device_type YMZ294 = &device_creator<ymz294_device>;
1148	1148
1149	1149	ymz294_device::ymz294_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1150		: ym2149_device(mconfig, YMZ294, "YMZ294", tag, owner, clock)
	1150	: ym2149_device(mconfig, YMZ294, "YMZ294", tag, owner, clock, "ymz294", __FILE__)
1151	1151	{
1152	1152	}

trunk/src/emu/sound/tms36xx.c

r23830	r23831
322	322	//-------------------------------------------------
323	323
324	324	tms36xx_device::tms36xx_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
325		: device_t(mconfig, TMS36XX, "TMS36XX", tag, owner, clock),
	325	: device_t(mconfig, TMS36XX, "TMS36XX", tag, owner, clock, "tms36xx", __FILE__),
326	326	device_sound_interface(mconfig, *this),
327	327	m_subtype(NULL),
328	328	m_channel(NULL),

trunk/src/emu/sound/st0016.c

r23830	r23831
23	23	//-------------------------------------------------
24	24
25	25	st0016_device::st0016_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
26		: device_t(mconfig, ST0016, "ST0016", tag, owner, clock),
	26	: device_t(mconfig, ST0016, "ST0016", tag, owner, clock, "st0016", __FILE__),
27	27	device_sound_interface(mconfig, *this),
28	28	m_stream(NULL),
29	29	m_sound_ram(NULL)

trunk/src/emu/sound/ay8910.h

r23830	r23831
100	100	{
101	101	public:
102	102	ay8910_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
103		ay8910_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	103	ay8910_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
104	104
105	105	DECLARE_READ8_MEMBER( data_r );
106	106	DECLARE_WRITE8_MEMBER( address_w );
r23830	r23831
174	174	{
175	175	public:
176	176	ym2149_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
177		ym2149_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	177	ym2149_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
178	178	protected:
179	179	// device-level overrides
180	180	virtual void device_start();

trunk/src/emu/sound/2610intf.c

r23830	r23831
219	219	const device_type YM2610 = &device_creator<ym2610_device>;
220	220
221	221	ym2610_device::ym2610_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
222		: device_t(mconfig, YM2610, "YM2610", tag, owner, clock),
	222	: device_t(mconfig, YM2610, "YM2610", tag, owner, clock, "ym2610", __FILE__),
223	223	device_sound_interface(mconfig, *this),
224	224	m_irq_handler(*this)
225	225	{
226	226	}
227	227
228		ym2610_device::ym2610_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
229		: device_t(mconfig, type, name, tag, owner, clock),
	228	ym2610_device::ym2610_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	229	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
230	230	device_sound_interface(mconfig, *this),
231	231	m_irq_handler(*this)
232	232	{
r23830	r23831
245	245	const device_type YM2610B = &device_creator<ym2610b_device>;
246	246
247	247	ym2610b_device::ym2610b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
248		: ym2610_device(mconfig, YM2610B, "YM2610B", tag, owner, clock)
	248	: ym2610_device(mconfig, YM2610B, "YM2610B", tag, owner, clock, "ym2610b", __FILE__)
249	249	{
250	250	}

trunk/src/emu/sound/beep.c

r23830	r23831
30	30	//-------------------------------------------------
31	31
32	32	beep_device::beep_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
33		: device_t(mconfig, BEEP, "Beep", tag, owner, clock),
	33	: device_t(mconfig, BEEP, "Beep", tag, owner, clock, "beep", __FILE__),
34	34	device_sound_interface(mconfig, *this),
35	35	m_stream(NULL),
36	36	m_enable(0),

trunk/src/emu/sound/2610intf.h

r23830	r23831
16	16	{
17	17	public:
18	18	ym2610_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
19		ym2610_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	19	ym2610_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
20	20
21	21	// static configuration helpers
22	22	template<class _Object> static devcb2_base &set_irq_handler(device_t &device, _Object object) { return downcast<ym2610_device &>(device).m_irq_handler.set_callback(object); }

trunk/src/emu/sound/tms3615.c

r23830	r23831
20	20	//-------------------------------------------------
21	21
22	22	tms3615_device::tms3615_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
23		: device_t(mconfig, TMS3615, "TMS3615", tag, owner, clock),
	23	: device_t(mconfig, TMS3615, "TMS3615", tag, owner, clock, "tms3615", __FILE__),
24	24	device_sound_interface(mconfig, *this),
25	25	m_channel(0),
26	26	m_samplerate(0),

trunk/src/emu/sound/gaelco.c

r23830	r23831
55	55	const device_type GAELCO_GAE1 = &device_creator<gaelco_gae1_device>;
56	56
57	57	gaelco_gae1_device::gaelco_gae1_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
58		: device_t(mconfig, GAELCO_GAE1, "Gaelco GAE1", tag, owner, clock),
	58	: device_t(mconfig, GAELCO_GAE1, "Gaelco GAE1", tag, owner, clock, "gaelco_gae1", __FILE__),
59	59	device_sound_interface(mconfig, *this),
60	60	m_stream(NULL),
61	61	m_snd_data(NULL)
62	62	{
63	63	}
64	64
65		gaelco_gae1_device::gaelco_gae1_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
66		: device_t(mconfig, type, name, tag, owner, clock),
	65	gaelco_gae1_device::gaelco_gae1_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	66	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
67	67	device_sound_interface(mconfig, *this),
68	68	m_stream(NULL),
69	69	m_snd_data(NULL)
r23830	r23831
277	277	const device_type GAELCO_CG1V = &device_creator<gaelco_cg1v_device>;
278	278
279	279	gaelco_cg1v_device::gaelco_cg1v_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
280		: gaelco_gae1_device(mconfig, GAELCO_CG1V, "Gaelco CG1V", tag, owner, clock)
	280	: gaelco_gae1_device(mconfig, GAELCO_CG1V, "Gaelco CG1V", tag, owner, clock, "gaelco_cg1v", __FILE__)
281	281	{
282	282	}

trunk/src/emu/sound/gaelco.h

r23830	r23831
50	50	{
51	51	public:
52	52	gaelco_gae1_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
53		gaelco_gae1_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	53	gaelco_gae1_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
54	54	~gaelco_gae1_device() { }
55	55
56	56	protected:

trunk/src/emu/sound/dmadac.c

r23830	r23831
236	236	const device_type DMADAC = &device_creator<dmadac_sound_device>;
237	237
238	238	dmadac_sound_device::dmadac_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
239		: device_t(mconfig, DMADAC, "DMA-driven DAC", tag, owner, clock),
	239	: device_t(mconfig, DMADAC, "DMA-driven DAC", tag, owner, clock, "dmadac", __FILE__),
240	240	device_sound_interface(mconfig, *this)
241	241	{
242	242	m_token = global_alloc_clear(dmadac_state);

trunk/src/emu/sound/s2636.c

r23830	r23831
84	84	const device_type S2636_SOUND = &device_creator<s2636_sound_device>;
85	85
86	86	s2636_sound_device::s2636_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
87		: device_t(mconfig, S2636_SOUND, "S2636", tag, owner, clock),
	87	: device_t(mconfig, S2636_SOUND, "S2636", tag, owner, clock, "s2636", __FILE__),
88	88	device_sound_interface(mconfig, *this)
89	89	{
90	90	m_token = global_alloc_clear(s2636_sound);

trunk/src/emu/sound/okim6295.c

r23830	r23831
85	85	//-------------------------------------------------
86	86
87	87	okim6295_device::okim6295_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
88		: device_t(mconfig, OKIM6295, "OKI6295", tag, owner, clock),
	88	: device_t(mconfig, OKIM6295, "OKI6295", tag, owner, clock, "okim6295", __FILE__),
89	89	device_sound_interface(mconfig, *this),
90	90	device_memory_interface(mconfig, *this),
91	91	m_space_config("samples", ENDIANNESS_LITTLE, 8, 18, 0, NULL, *ADDRESS_MAP_NAME(okim6295)),

trunk/src/emu/sound/okim6376.c

r23830	r23831
619	619	const device_type OKIM6376 = &device_creator<okim6376_device>;
620	620
621	621	okim6376_device::okim6376_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
622		: device_t(mconfig, OKIM6376, "OKI6376", tag, owner, clock),
	622	: device_t(mconfig, OKIM6376, "OKI6376", tag, owner, clock, "okim6376", __FILE__),
623	623	device_sound_interface(mconfig, *this)
624	624	{
625	625	m_token = global_alloc_clear(okim6376_state);

trunk/src/emu/sound/es5506.c

r23830	r23831
2160	2160	const device_type ES5506 = &device_creator<es5506_device>;
2161	2161
2162	2162	es5506_device::es5506_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2163		: device_t(mconfig, ES5506, "ES5506", tag, owner, clock),
	2163	: device_t(mconfig, ES5506, "ES5506", tag, owner, clock, "es5506", __FILE__),
2164	2164	device_sound_interface(mconfig, *this)
2165	2165	{
2166	2166	m_token = global_alloc_clear(es5506_state);
2167	2167	}
2168	2168
2169		es5506_device::es5506_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
2170		: device_t(mconfig, type, name, tag, owner, clock),
	2169	es5506_device::es5506_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	2170	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
2171	2171	device_sound_interface(mconfig, *this)
2172	2172	{
2173	2173	m_token = global_alloc_clear(es5506_state);
r23830	r23831
2223	2223	const device_type ES5505 = &device_creator<es5505_device>;
2224	2224
2225	2225	es5505_device::es5505_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2226		: es5506_device(mconfig, ES5505, "ES5505", tag, owner, clock)
	2226	: es5506_device(mconfig, ES5505, "ES5505", tag, owner, clock, "es5505", __FILE__)
2227	2227	{
2228	2228	}
2229	2229

trunk/src/emu/sound/cdp1864.c

r23830	r23831
98	98	//-------------------------------------------------
99	99
100	100	cdp1864_device::cdp1864_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
101		: device_t(mconfig, CDP1864, "CDP1864", tag, owner, clock),
	101	: device_t(mconfig, CDP1864, "CDP1864", tag, owner, clock, "cdp1864", __FILE__),
102	102	device_sound_interface(mconfig, *this),
103	103	m_read_inlace(*this),
104	104	m_read_rdata(*this),

trunk/src/emu/sound/es5506.h

r23830	r23831
30	30	{
31	31	public:
32	32	es5506_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
33		es5506_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	33	es5506_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
34	34	~es5506_device() { global_free(m_token); }
35	35
36	36	// access to legacy token

trunk/src/emu/sound/2413intf.c

r23830	r23831
77	77	const device_type YM2413 = &device_creator<ym2413_device>;
78	78
79	79	ym2413_device::ym2413_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
80		: device_t(mconfig, YM2413, "YM2413", tag, owner, clock),
	80	: device_t(mconfig, YM2413, "YM2413", tag, owner, clock, "ym2413", __FILE__),
81	81	device_sound_interface(mconfig, *this)
82	82	{
83	83	}

trunk/src/emu/sound/t6w28.c

r23830	r23831
348	348	const device_type T6W28 = &device_creator<t6w28_device>;
349	349
350	350	t6w28_device::t6w28_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
351		: device_t(mconfig, T6W28, "T6W28", tag, owner, clock),
	351	: device_t(mconfig, T6W28, "T6W28", tag, owner, clock, "t6w28", __FILE__),
352	352	device_sound_interface(mconfig, *this)
353	353	{
354	354	}

trunk/src/emu/sound/namco.c

r23830	r23831
816	816	const device_type NAMCO = &device_creator<namco_device>;
817	817
818	818	namco_device::namco_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
819		: device_t(mconfig, NAMCO, "Namco", tag, owner, clock),
	819	: device_t(mconfig, NAMCO, "Namco", tag, owner, clock, "namco", __FILE__),
820	820	device_sound_interface(mconfig, *this)
821	821	{
822	822	m_token = global_alloc_clear(namco_sound);
823	823	}
824	824
825		namco_device::namco_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
826		: device_t(mconfig, type, name, tag, owner, clock),
	825	namco_device::namco_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	826	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
827	827	device_sound_interface(mconfig, *this)
828	828	{
829	829	m_token = global_alloc_clear(namco_sound);
r23830	r23831
862	862	const device_type NAMCO_15XX = &device_creator<namco_15xx_device>;
863	863
864	864	namco_15xx_device::namco_15xx_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
865		: namco_device(mconfig, NAMCO_15XX, "Namco 15XX", tag, owner, clock)
	865	: namco_device(mconfig, NAMCO_15XX, "Namco 15XX", tag, owner, clock, "namco_15xx", __FILE__)
866	866	{
867	867	}
868	868
869	869	const device_type NAMCO_CUS30 = &device_creator<namco_cus30_device>;
870	870
871	871	namco_cus30_device::namco_cus30_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
872		: namco_device(mconfig, NAMCO_CUS30, "Namco CUS30", tag, owner, clock)
	872	: namco_device(mconfig, NAMCO_CUS30, "Namco CUS30", tag, owner, clock, "namco_cus30", __FILE__)
873	873	{
874	874	}

trunk/src/emu/sound/sn76477.c

r23830	r23831
2469	2469	const device_type SN76477 = &device_creator<sn76477_device>;
2470	2470
2471	2471	sn76477_device::sn76477_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2472		: device_t(mconfig, SN76477, "SN76477", tag, owner, clock),
	2472	: device_t(mconfig, SN76477, "SN76477", tag, owner, clock, "sn76477", __FILE__),
2473	2473	device_sound_interface(mconfig, *this)
2474	2474	{
2475	2475	m_token = global_alloc_clear(sn76477_state);

trunk/src/emu/sound/namco.h

r23830	r23831
31	31	{
32	32	public:
33	33	namco_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
34		namco_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	34	namco_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
35	35	~namco_device() { global_free(m_token); }
36	36
37	37	// access to legacy token

trunk/src/emu/sound/vlm5030.c

r23830	r23831
690	690	const device_type VLM5030 = &device_creator<vlm5030_device>;
691	691
692	692	vlm5030_device::vlm5030_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
693		: device_t(mconfig, VLM5030, "VLM5030", tag, owner, clock),
	693	: device_t(mconfig, VLM5030, "VLM5030", tag, owner, clock, "vlm5030", __FILE__),
694	694	device_sound_interface(mconfig, *this)
695	695	{
696	696	m_token = global_alloc_clear(vlm5030_state);

trunk/src/emu/sound/tms5220.c

r23830	r23831
1826	1826	const device_type TMS5220C = &device_creator<tms5220c_device>;
1827	1827
1828	1828	tms5220c_device::tms5220c_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1829		: tms5220_device(mconfig, TMS5220C, "TMS5220C", tag, owner, clock)
	1829	: tms5220_device(mconfig, TMS5220C, "TMS5220C", tag, owner, clock, "tms5220c", __FILE__)
1830	1830	{
1831	1831	}
1832	1832
r23830	r23831
1834	1834	const device_type TMS5220 = &device_creator<tms5220_device>;
1835	1835
1836	1836	tms5220_device::tms5220_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1837		: device_t(mconfig, TMS5220, "TMS5220", tag, owner, clock),
	1837	: device_t(mconfig, TMS5220, "TMS5220", tag, owner, clock, "tms5220", __FILE__),
1838	1838	device_sound_interface(mconfig, *this),
1839	1839	m_irq_handler(*this),
1840	1840	m_readyq_handler(*this),
r23830	r23831
1842	1842	{
1843	1843	}
1844	1844
1845		tms5220_device::tms5220_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
1846		: device_t(mconfig, type, name, tag, owner, clock),
	1845	tms5220_device::tms5220_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	1846	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
1847	1847	device_sound_interface(mconfig, *this),
1848	1848	m_irq_handler(*this),
1849	1849	m_readyq_handler(*this),
r23830	r23831
1865	1865	const device_type TMC0285 = &device_creator<tmc0285_device>;
1866	1866
1867	1867	tmc0285_device::tmc0285_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1868		: tms5220_device(mconfig, TMC0285, "TMC0285", tag, owner, clock)
	1868	: tms5220_device(mconfig, TMC0285, "TMC0285", tag, owner, clock, "tmc0285", __FILE__)
1869	1869	{
1870	1870	}
1871	1871
r23830	r23831
1873	1873	const device_type TMS5200 = &device_creator<tms5200_device>;
1874	1874
1875	1875	tms5200_device::tms5200_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1876		: tms5220_device(mconfig, TMS5200, "TMS5200", tag, owner, clock)
	1876	: tms5220_device(mconfig, TMS5200, "TMS5200", tag, owner, clock, "tms5200", __FILE__)
1877	1877	{
1878	1878	}

trunk/src/emu/sound/mos7360.c

r23830	r23831
255	255	//-------------------------------------------------
256	256
257	257	mos7360_device::mos7360_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
258		: device_t(mconfig, MOS7360, "MOS7360", tag, owner, clock),
	258	: device_t(mconfig, MOS7360, "MOS7360", tag, owner, clock, "mos7360", __FILE__),
259	259	device_memory_interface(mconfig, *this),
260	260	device_sound_interface(mconfig, *this),
261	261	m_videoram_space_config("videoram", ENDIANNESS_LITTLE, 8, 16, 0, NULL, *ADDRESS_MAP_NAME(mos7360_videoram_map)),

trunk/src/emu/sound/tms5220.h

r23830	r23831
31	31	{
32	32	public:
33	33	tms5220_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
34		tms5220_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	34	tms5220_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
35	35
36	36	// static configuration helpers
37	37	template<class _Object> static devcb2_base &set_irq_handler(device_t &device, _Object object) { return downcast<tms5220_device &>(device).m_irq_handler.set_callback(object); }

trunk/src/emu/sound/t6721a.c

r23830	r23831
37	37	//-------------------------------------------------
38	38
39	39	t6721a_device::t6721a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
40		: device_t(mconfig, T6721A, "T6721A", tag, owner, clock),
	40	: device_t(mconfig, T6721A, "T6721A", tag, owner, clock, "t6721a", __FILE__),
41	41	device_sound_interface(mconfig, *this),
42	42	m_eos_handler(*this),
43	43	m_dtrd_handler(*this),

trunk/src/emu/sound/es8712.c

r23830	r23831
38	38	//-------------------------------------------------
39	39
40	40	es8712_device::es8712_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
41		: device_t(mconfig, ES8712, "ES8712", tag, owner, clock),
	41	: device_t(mconfig, ES8712, "ES8712", tag, owner, clock, "es8712", __FILE__),
42	42	device_sound_interface(mconfig, *this),
43	43	m_playing(0),
44	44	m_base_offset(0),

trunk/src/emu/sound/262intf.c

r23830	r23831
136	136	const device_type YMF262 = &device_creator<ymf262_device>;
137	137
138	138	ymf262_device::ymf262_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
139		: device_t(mconfig, YMF262, "YMF262", tag, owner, clock),
	139	: device_t(mconfig, YMF262, "YMF262", tag, owner, clock, "ymf262", __FILE__),
140	140	device_sound_interface(mconfig, *this),
141	141	m_irq_handler(*this)
142	142	{

trunk/src/emu/sound/nes_apu.c

r23830	r23831
769	769	const device_type NES = &device_creator<nesapu_device>;
770	770
771	771	nesapu_device::nesapu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
772		: device_t(mconfig, NES, "N2A03", tag, owner, clock),
	772	: device_t(mconfig, NES, "N2A03", tag, owner, clock, "nesapu", __FILE__),
773	773	device_sound_interface(mconfig, *this)
774	774	{
775	775	m_token = global_alloc_clear(nesapu_state);

trunk/src/emu/sound/tc8830f.c

r23830	r23831
23	23	const device_type TC8830F = &device_creator<tc8830f_device>;
24	24
25	25	tc8830f_device::tc8830f_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
26		: device_t(mconfig, TC8830F, "TC8830F", tag, owner, clock),
	26	: device_t(mconfig, TC8830F, "TC8830F", tag, owner, clock, "tc8830f", __FILE__),
27	27	device_sound_interface(mconfig, *this)
28	28	{
29	29	}

trunk/src/emu/sound/lmc1992.c

r23830	r23831
140	140	//-------------------------------------------------
141	141
142	142	lmc1992_device::lmc1992_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
143		: device_t(mconfig, LMC1992, "LMC1992", tag, owner, clock),
	143	: device_t(mconfig, LMC1992, "LMC1992", tag, owner, clock, "lmc1992", __FILE__),
144	144	device_sound_interface(mconfig, *this)
145	145	{
146	146	}

trunk/src/emu/sound/mas3507d.c

r23830	r23831
9	9	const device_type MAS3507D = &device_creator<mas3507d_device>;
10	10
11	11	mas3507d_device::mas3507d_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
12		: device_t(mconfig, MAS3507D, "MAS3507D", tag, owner, clock),
	12	: device_t(mconfig, MAS3507D, "MAS3507D", tag, owner, clock, "mas3507d", __FILE__),
13	13	device_sound_interface(mconfig, *this)
14	14	{
15	15	}

trunk/src/mame/drivers/namcoic.c

r23830	r23831
1309	1309	//-------------------------------------------------
1310	1310
1311	1311	namco_c45_road_device::namco_c45_road_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1312		: device_t(mconfig, NAMCO_C45_ROAD, "Namco C45 Road", tag, owner, clock),
	1312	: device_t(mconfig, NAMCO_C45_ROAD, "Namco C45 Road", tag, owner, clock, "namco_c45_road", __FILE__),
1313	1313	m_transparent_color(~0),
1314	1314	m_gfx(NULL),
1315	1315	m_tilemap(NULL)

trunk/src/mame/drivers/pinkiri8.c

r23830	r23831
125	125
126	126
127	127	janshi_vdp_device::janshi_vdp_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
128		: device_t(mconfig, JANSHIVDP, "JANSHIVDP", tag, owner, clock),
	128	: device_t(mconfig, JANSHIVDP, "JANSHIVDP", tag, owner, clock, "janshi_vdp", __FILE__),
129	129	device_memory_interface(mconfig, *this),
130	130	m_space_config("janshi_vdp", ENDIANNESS_LITTLE, 8,24, 0, NULL, *ADDRESS_MAP_NAME(janshi_vdp_map8))
131	131	{

trunk/src/mame/drivers/mjkjidai.c

r23830	r23831
103	103	const device_type MJKJIDAI = &device_creator<mjkjidai_adpcm_device>;
104	104
105	105	mjkjidai_adpcm_device::mjkjidai_adpcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
106		: device_t(mconfig, MJKJIDAI, "Custom ADPCM", tag, owner, clock),
	106	: device_t(mconfig, MJKJIDAI, "Custom ADPCM", tag, owner, clock, "mjkjidai_adpcm", __FILE__),
107	107	device_sound_interface(mconfig, *this)
108	108	{
109	109	m_token = global_alloc_clear(mjkjidai_adpcm_state);

trunk/src/mame/drivers/littlerb.c

r23830	r23831
285	285	const device_type LITTLERBVDP = &device_creator<littlerb_vdp_device>;
286	286
287	287	littlerb_vdp_device::littlerb_vdp_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
288		: device_t(mconfig, LITTLERBVDP, "LITTLERBVDP", tag, owner, clock),
	288	: device_t(mconfig, LITTLERBVDP, "LITTLERBVDP", tag, owner, clock, "littlerb_vdp", __FILE__),
289	289	device_memory_interface(mconfig, *this),
290	290	m_space_config("littlerb_vdp", ENDIANNESS_LITTLE, 16,32, 0, NULL, *ADDRESS_MAP_NAME(littlerb_vdp_map8))
291	291	{

trunk/src/mame/drivers/renegade.c

r23830	r23831
193	193	const device_type RENEGADE_ADPCM = &device_creator<renegade_adpcm_device>;
194	194
195	195	renegade_adpcm_device::renegade_adpcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
196		: device_t(mconfig, RENEGADE_ADPCM, "Renegade Custom ADPCM", tag, owner, clock),
	196	: device_t(mconfig, RENEGADE_ADPCM, "Renegade Custom ADPCM", tag, owner, clock, "renegade_adpcm", __FILE__),
197	197	device_sound_interface(mconfig, *this)
198	198	{
199	199	m_token = global_alloc_clear(renegade_adpcm_state);

trunk/src/mame/audio/snes_snd.c

r23830	r23831
154	154	const device_type SNES = &device_creator<snes_sound_device>;
155	155
156	156	snes_sound_device::snes_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
157		: device_t(mconfig, SNES, "SNES Custom DSP (SPC700)", tag, owner, clock),
	157	: device_t(mconfig, SNES, "SNES Custom DSP (SPC700)", tag, owner, clock, "snes_sound", __FILE__),
158	158	device_sound_interface(mconfig, *this)
159	159	{
160	160	}

trunk/src/mame/audio/timeplt.c

r23830	r23831
263	263	const device_type TIMEPLT_AUDIO = &device_creator<timeplt_audio_device>;
264	264
265	265	timeplt_audio_device::timeplt_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
266		: device_t(mconfig, TIMEPLT_AUDIO, "Time Pilot Audio", tag, owner, clock),
	266	: device_t(mconfig, TIMEPLT_AUDIO, "Time Pilot Audio", tag, owner, clock, "timeplt_audio", __FILE__),
267	267	device_sound_interface(mconfig, *this)
268	268	{
269	269	m_token = global_alloc_clear(timeplt_audio_state);

trunk/src/mame/audio/wiping.c

r23830	r23831
262	262	const device_type WIPING = &device_creator<wiping_sound_device>;
263	263
264	264	wiping_sound_device::wiping_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
265		: device_t(mconfig, WIPING, "Wiping Custom", tag, owner, clock),
	265	: device_t(mconfig, WIPING, "Wiping Custom", tag, owner, clock, "wiping_sound", __FILE__),
266	266	device_sound_interface(mconfig, *this)
267	267	{
268	268	m_token = global_alloc_clear(wiping_sound_state);

trunk/src/mame/audio/leland.c

r23830	r23831
573	573	const device_type LELAND = &device_creator<leland_sound_device>;
574	574
575	575	leland_sound_device::leland_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
576		: device_t(mconfig, LELAND, "Leland DAC", tag, owner, clock),
	576	: device_t(mconfig, LELAND, "Leland DAC", tag, owner, clock, "leland_dac", __FILE__),
577	577	device_sound_interface(mconfig, *this)
578	578	{
579	579	m_token = global_alloc_clear(leland_sound_state);
580	580	}
581	581
582		leland_sound_device::leland_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
583		: device_t(mconfig, type, name, tag, owner, clock),
	582	leland_sound_device::leland_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	583	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
584	584	device_sound_interface(mconfig, *this)
585	585	{
586	586	m_token = global_alloc_clear(leland_sound_state);
r23830	r23831
619	619	const device_type LELAND_80186 = &device_creator<leland_80186_sound_device>;
620	620
621	621	leland_80186_sound_device::leland_80186_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
622		: leland_sound_device(mconfig, LELAND_80186, "Leland 80186 DAC", tag, owner, clock)
	622	: leland_sound_device(mconfig, LELAND_80186, "Leland 80186 DAC", tag, owner, clock, "leland_80186_sound", __FILE__)
623	623	{
624	624	}
625	625
626		leland_80186_sound_device::leland_80186_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
627		: leland_sound_device(mconfig, type, name, tag, owner, clock)
	626	leland_80186_sound_device::leland_80186_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	627	: leland_sound_device(mconfig, type, name, tag, owner, clock, shortname, source)
628	628	{
629	629	}
630	630
r23830	r23831
671	671	const device_type REDLINE_80186 = &device_creator<redline_80186_sound_device>;
672	672
673	673	redline_80186_sound_device::redline_80186_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
674		: leland_80186_sound_device(mconfig, REDLINE_80186, "Redline Racer 80186 DAC", tag, owner, clock)
	674	: leland_80186_sound_device(mconfig, REDLINE_80186, "Redline Racer 80186 DAC", tag, owner, clock, "redline_80186_sound", __FILE__)
675	675	{
676	676	}
677	677

trunk/src/mame/audio/gomoku.c

r23830	r23831
26	26	//-------------------------------------------------
27	27
28	28	gomoku_sound_device::gomoku_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
29		: device_t(mconfig, GOMOKU, "Gomoku Custom", tag, owner, clock),
	29	: device_t(mconfig, GOMOKU, "Gomoku Custom", tag, owner, clock, "gomoku_sound", __FILE__),
30	30	device_sound_interface(mconfig, *this),
31	31	m_last_channel(NULL),
32	32	m_sound_rom(NULL),

trunk/src/mame/audio/warpwarp.c

r23830	r23831
17	17	const device_type WARPWARP = &device_creator<warpwarp_sound_device>;
18	18
19	19	warpwarp_sound_device::warpwarp_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
20		: device_t(mconfig, WARPWARP, "Warp Warp Custom", tag, owner, clock),
	20	: device_t(mconfig, WARPWARP, "Warp Warp Custom", tag, owner, clock, "warpwarp_sound", __FILE__),
21	21	device_sound_interface(mconfig, *this),
22	22	m_decay(NULL),
23	23	m_channel(NULL),

trunk/src/mame/audio/snk6502.c

r23830	r23831
1252	1252	const device_type SNK6502 = &device_creator<snk6502_sound_device>;
1253	1253
1254	1254	snk6502_sound_device::snk6502_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1255		: device_t(mconfig, SNK6502, "snk6502 Custom", tag, owner, clock),
	1255	: device_t(mconfig, SNK6502, "snk6502 Custom", tag, owner, clock, "snk6502_sound", __FILE__),
1256	1256	device_sound_interface(mconfig, *this)
1257	1257	{
1258	1258	m_token = global_alloc_clear(snk6502_sound_state);

trunk/src/mame/audio/cps3.c

r23830	r23831
20	20	//-------------------------------------------------
21	21
22	22	cps3_sound_device::cps3_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
23		: device_t(mconfig, CPS3, "CPS3 Custom", tag, owner, clock),
	23	: device_t(mconfig, CPS3, "CPS3 Custom", tag, owner, clock, "cps3_custom", __FILE__),
24	24	device_sound_interface(mconfig, *this),
25	25	m_stream(NULL),
26	26	m_key(0),

trunk/src/mame/audio/tiamc1.c

r23830	r23831
56	56	//-------------------------------------------------
57	57
58	58	tiamc1_sound_device::tiamc1_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
59		: device_t(mconfig, TIAMC1, "TIA-MC1 Custom", tag, owner, clock),
	59	: device_t(mconfig, TIAMC1, "TIA-MC1 Custom", tag, owner, clock, "tiamc1_sound", __FILE__),
60	60	device_sound_interface(mconfig, *this),
61	61	m_channel(NULL),
62	62	m_timer1_divider(0)

trunk/src/mame/audio/flower.c

r23830	r23831
22	22	const device_type FLOWER = &device_creator<flower_sound_device>;
23	23
24	24	flower_sound_device::flower_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
25		: device_t(mconfig, FLOWER, "Flower Custom Sound", tag, owner, clock),
	25	: device_t(mconfig, FLOWER, "Flower Custom Sound", tag, owner, clock, "flower_sound", __FILE__),
26	26	device_sound_interface(mconfig, *this)
27	27	{
28	28	}

trunk/src/mame/audio/dsbz80.c

r23830	r23831
61	61	//-------------------------------------------------
62	62
63	63	dsbz80_device::dsbz80_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
64		device_t(mconfig, DSBZ80, "Sega Z80-based Digital Sound Board", tag, owner, clock),
	64	device_t(mconfig, DSBZ80, "Sega Z80-based Digital Sound Board", tag, owner, clock, "dsbz80", __FILE__),
65	65	device_sound_interface(mconfig, *this),
66	66	m_ourcpu(*this, Z80_TAG)
67	67	{

trunk/src/mame/audio/pleiads.c

r23830	r23831
682	682	const device_type PLEIADS = &device_creator<pleiads_sound_device>;
683	683
684	684	pleiads_sound_device::pleiads_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
685		: device_t(mconfig, PLEIADS, "Pleiads Custom", tag, owner, clock),
	685	: device_t(mconfig, PLEIADS, "Pleiads Custom", tag, owner, clock, "pleiads_sound", __FILE__),
686	686	device_sound_interface(mconfig, *this)
687	687	{
688	688	m_token = global_alloc_clear(pleiads_sound_state);
689	689	}
690	690
691		pleiads_sound_device::pleiads_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
692		: device_t(mconfig, type, name, tag, owner, clock),
	691	pleiads_sound_device::pleiads_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	692	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
693	693	device_sound_interface(mconfig, *this)
694	694	{
695	695	m_token = global_alloc_clear(pleiads_sound_state);
r23830	r23831
728	728	const device_type NAUGHTYB = &device_creator<naughtyb_sound_device>;
729	729
730	730	naughtyb_sound_device::naughtyb_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
731		: pleiads_sound_device(mconfig, NAUGHTYB, "Naughty Boy Custom", tag, owner, clock)
	731	: pleiads_sound_device(mconfig, NAUGHTYB, "Naughty Boy Custom", tag, owner, clock, "naughtyb_sound", __FILE__)
732	732	{
733	733	}
734	734
r23830	r23831
765	765	const device_type POPFLAME = &device_creator<popflame_sound_device>;
766	766
767	767	popflame_sound_device::popflame_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
768		: pleiads_sound_device(mconfig, POPFLAME, "Pop Flamer Custom", tag, owner, clock)
	768	: pleiads_sound_device(mconfig, POPFLAME, "Pop Flamer Custom", tag, owner, clock, "popflame_sound", __FILE__)
769	769	{
770	770	}
771	771

trunk/src/mame/audio/taitosnd.c

r23830	r23831
29	29	//-------------------------------------------------
30	30
31	31	tc0140syt_device::tc0140syt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
32		: device_t(mconfig, TC0140SYT, "Taito TC0140SYT", tag, owner, clock),
	32	: device_t(mconfig, TC0140SYT, "Taito TC0140SYT", tag, owner, clock, "tc0140syt", __FILE__),
33	33	m_mainmode(0),
34	34	m_submode(0),
35	35	m_status(0),

trunk/src/mame/audio/pleiads.h

r23830	r23831
7	7	{
8	8	public:
9	9	pleiads_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
10		pleiads_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	10	pleiads_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
11	11	~pleiads_sound_device() { global_free(m_token); }
12	12
13	13	// access to legacy token

trunk/src/mame/audio/irem.c

r23830	r23831
488	488	const device_type IREM_AUDIO = &device_creator<irem_audio_device>;
489	489
490	490	irem_audio_device::irem_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
491		: device_t(mconfig, IREM_AUDIO, "Irem Audio", tag, owner, clock),
	491	: device_t(mconfig, IREM_AUDIO, "Irem Audio", tag, owner, clock, "irem_audio", __FILE__),
492	492	device_sound_interface(mconfig, *this)
493	493	{
494	494	m_token = global_alloc_clear(irem_audio_state);

trunk/src/mame/audio/segag80r.c

r23830	r23831
48	48	const device_type SEGA005 = &device_creator<sega005_sound_device>;
49	49
50	50	sega005_sound_device::sega005_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
51		: device_t(mconfig, SEGA005, "005 Custom", tag, owner, clock),
	51	: device_t(mconfig, SEGA005, "005 Custom", tag, owner, clock, "sega005_sound", __FILE__),
52	52	device_sound_interface(mconfig, *this)
53	53	{
54	54	}

trunk/src/mame/audio/polepos.c

r23830	r23831
50	50	//-------------------------------------------------
51	51
52	52	polepos_sound_device::polepos_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
53		: device_t(mconfig, POLEPOS, "Pole Position Custom", tag, owner, clock),
	53	: device_t(mconfig, POLEPOS, "Pole Position Custom", tag, owner, clock, "polepos_sound", __FILE__),
54	54	device_sound_interface(mconfig, *this),
55	55	m_current_position(0),
56	56	m_sample_msb(0),

trunk/src/mame/audio/micro3d.c

r23830	r23831
405	405	const device_type MICRO3D = &device_creator<micro3d_sound_device>;
406	406
407	407	micro3d_sound_device::micro3d_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
408		: device_t(mconfig, MICRO3D, "Microprose Custom", tag, owner, clock),
	408	: device_t(mconfig, MICRO3D, "Microprose Custom", tag, owner, clock, "micro3d_sound", __FILE__),
409	409	device_sound_interface(mconfig, *this)
410	410	{
411	411	m_token = global_alloc_clear(noise_state);

trunk/src/mame/audio/seibu.c

r23830	r23831
591	591	const device_type SEIBU_ADPCM = &device_creator<seibu_adpcm_device>;
592	592
593	593	seibu_adpcm_device::seibu_adpcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
594		: device_t(mconfig, SEIBU_ADPCM, "Seibu ADPCM", tag, owner, clock),
	594	: device_t(mconfig, SEIBU_ADPCM, "Seibu ADPCM", tag, owner, clock, "seibu_adpcm", __FILE__),
595	595	device_sound_interface(mconfig, *this)
596	596	{
597	597	m_token = global_alloc_clear(seibu_adpcm_state);

trunk/src/mame/audio/phoenix.c

r23830	r23831
573	573	const device_type PHOENIX = &device_creator<phoenix_sound_device>;
574	574
575	575	phoenix_sound_device::phoenix_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
576		: device_t(mconfig, PHOENIX, "Phoenix Custom", tag, owner, clock),
	576	: device_t(mconfig, PHOENIX, "Phoenix Custom", tag, owner, clock, "phoenix_sound", __FILE__),
577	577	device_sound_interface(mconfig, *this)
578	578	{
579	579	m_token = global_alloc_clear(phoenix_sound_state);

trunk/src/mame/audio/hyprolyb.c

r23830	r23831
138	138	const device_type HYPROLYB_ADPCM = &device_creator<hyprolyb_adpcm_device>;
139	139
140	140	hyprolyb_adpcm_device::hyprolyb_adpcm_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
141		: device_t(mconfig, HYPROLYB_ADPCM, "Hyper Olympics Audio", tag, owner, clock),
	141	: device_t(mconfig, HYPROLYB_ADPCM, "Hyper Olympics Audio", tag, owner, clock, "hyprolyb_adpcm", __FILE__),
142	142	device_sound_interface(mconfig, *this)
143	143	{
144	144	m_token = global_alloc_clear(hyprolyb_adpcm_state);

trunk/src/mame/audio/geebee.c

r23830	r23831
14	14	const device_type GEEBEE = &device_creator<geebee_sound_device>;
15	15
16	16	geebee_sound_device::geebee_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
17		: device_t(mconfig, GEEBEE, "Gee Bee Custom", tag, owner, clock),
	17	: device_t(mconfig, GEEBEE, "Gee Bee Custom", tag, owner, clock, "geebee_sound", __FILE__),
18	18	device_sound_interface(mconfig, *this),
19	19	m_decay(NULL),
20	20	m_channel(NULL),

trunk/src/mame/audio/beezer.c

r23830	r23831
397	397	const device_type BEEZER = &device_creator<beezer_sound_device>;
398	398
399	399	beezer_sound_device::beezer_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
400		: device_t(mconfig, BEEZER, "beezer SFX", tag, owner, clock),
	400	: device_t(mconfig, BEEZER, "beezer SFX", tag, owner, clock, "beezer_sound", __FILE__),
401	401	device_sound_interface(mconfig, *this)
402	402	{
403	403	m_token = global_alloc_clear(beezer_sound_state);

trunk/src/mame/audio/tx1.c

r23830	r23831
575	575	const device_type BUGGYBOY = &device_creator<buggyboy_sound_device>;
576	576
577	577	buggyboy_sound_device::buggyboy_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
578		: tx1_sound_device(mconfig, BUGGYBOY, "Buggy Boy Custom", tag, owner, clock)
	578	: tx1_sound_device(mconfig, BUGGYBOY, "Buggy Boy Custom", tag, owner, clock, "buggyboy_sound", __FILE__)
579	579	{
580	580	}
581	581
r23830	r23831
621	621	const device_type TX1 = &device_creator<tx1_sound_device>;
622	622
623	623	tx1_sound_device::tx1_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
624		: device_t(mconfig, TX1, "TX-1 Custom", tag, owner, clock),
	624	: device_t(mconfig, TX1, "TX-1 Custom", tag, owner, clock, "tx1_sound", __FILE__),
625	625	device_sound_interface(mconfig, *this)
626	626	{
627	627	m_token = global_alloc_clear(tx1_sound_state);
628	628	}
629	629
630		tx1_sound_device::tx1_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
631		: device_t(mconfig, type, name, tag, owner, clock),
	630	tx1_sound_device::tx1_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	631	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
632	632	device_sound_interface(mconfig, *this)
633	633	{
634	634	m_token = global_alloc_clear(tx1_sound_state);

trunk/src/mame/audio/exidy.c

r23830	r23831
421	421	const device_type EXIDY = &device_creator<exidy_sound_device>;
422	422
423	423	exidy_sound_device::exidy_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
424		: device_t(mconfig, EXIDY, "Exidy SFX", tag, owner, clock),
	424	: device_t(mconfig, EXIDY, "Exidy SFX", tag, owner, clock, "exidy_sfx", __FILE__),
425	425	device_sound_interface(mconfig, *this)
426	426	{
427	427	m_token = global_alloc_clear(exidy_sound_state);
428	428	}
429	429
430		exidy_sound_device::exidy_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
431		: device_t(mconfig, type, name, tag, owner, clock),
	430	exidy_sound_device::exidy_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	431	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
432	432	device_sound_interface(mconfig, *this)
433	433	{
434	434	m_token = global_alloc_clear(exidy_sound_state);
r23830	r23831
887	887	const device_type EXIDY_VENTURE = &device_creator<venture_sound_device>;
888	888
889	889	venture_sound_device::venture_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
890		: exidy_sound_device(mconfig, EXIDY_VENTURE, "Exidy SFX+PSG", tag, owner, clock)
	890	: exidy_sound_device(mconfig, EXIDY_VENTURE, "Exidy SFX+PSG", tag, owner, clock, "venture_sound", __FILE__)
891	891	{
892	892	}
893	893
r23830	r23831
1154	1154	const device_type EXIDY_VICTORY = &device_creator<victory_sound_device>;
1155	1155
1156	1156	victory_sound_device::victory_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1157		: exidy_sound_device(mconfig, EXIDY_VICTORY, "Exidy SFX+PSG+Speech", tag, owner, clock)
	1157	: exidy_sound_device(mconfig, EXIDY_VICTORY, "Exidy SFX+PSG+Speech", tag, owner, clock, "victory_sound", __FILE__)
1158	1158	{
1159	1159	}
1160	1160

trunk/src/mame/audio/segasnd.c

r23830	r23831
179	179	const device_type SEGASPEECH = &device_creator<speech_sound_device>;
180	180
181	181	speech_sound_device::speech_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
182		: device_t(mconfig, SEGASPEECH, "Sega Speech Sound Board", tag, owner, clock),
	182	: device_t(mconfig, SEGASPEECH, "Sega Speech Sound Board", tag, owner, clock, "sega_speech_sound", __FILE__),
183	183	device_sound_interface(mconfig, *this)
184	184	{
185	185	m_token = global_alloc_clear(speech_state);
r23830	r23831
882	882	const device_type SEGAUSB = &device_creator<usb_sound_device>;
883	883
884	884	usb_sound_device::usb_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
885		: device_t(mconfig, SEGAUSB, "Sega Universal Sound Board", tag, owner, clock),
	885	: device_t(mconfig, SEGAUSB, "Sega Universal Sound Board", tag, owner, clock, "usb_sound", __FILE__),
886	886	device_sound_interface(mconfig, *this)
887	887	{
888	888	m_token = global_alloc_clear(usb_state);

trunk/src/mame/audio/exidy.h

r23830	r23831
3	3	{
4	4	public:
5	5	exidy_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
6		exidy_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	6	exidy_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
7	7	~exidy_sound_device() { global_free(m_token); }
8	8
9	9	// access to legacy token

trunk/src/mame/audio/trackfld.c

r23830	r23831
163	163	const device_type TRACKFLD_AUDIO = &device_creator<trackfld_audio_device>;
164	164
165	165	trackfld_audio_device::trackfld_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
166		: device_t(mconfig, TRACKFLD_AUDIO, "Track And Field Audio", tag, owner, clock),
	166	: device_t(mconfig, TRACKFLD_AUDIO, "Track And Field Audio", tag, owner, clock, "trackfld_audio", __FILE__),
167	167	device_sound_interface(mconfig, *this)
168	168	{
169	169	m_token = global_alloc_clear(trackfld_audio_state);

trunk/src/mame/audio/redbaron.c

r23830	r23831
34	34	//-------------------------------------------------
35	35
36	36	redbaron_sound_device::redbaron_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
37		: device_t(mconfig, REDBARON, "Red Baron Custom", tag, owner, clock),
	37	: device_t(mconfig, REDBARON, "Red Baron Custom", tag, owner, clock, "redbaron_custom", __FILE__),
38	38	device_sound_interface(mconfig, *this),
39	39	m_vol_lookup(NULL),
40	40	m_channel(NULL),

trunk/src/mame/audio/decobsmt.c

r23830	r23831
77	77	//-------------------------------------------------
78	78
79	79	decobsmt_device::decobsmt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
80		device_t(mconfig, DECOBSMT, "Data East/Sega/Stern BSMT2000 Sound Board", tag, owner, clock),
	80	device_t(mconfig, DECOBSMT, "Data East/Sega/Stern BSMT2000 Sound Board", tag, owner, clock, "decobsmt", __FILE__),
81	81	m_ourcpu(*this, M6809_TAG),
82	82	m_bsmt(*this, BSMT_TAG)
83	83	{

trunk/src/mame/audio/m72.c

r23830	r23831
256	256	const device_type M72 = &device_creator<m72_audio_device>;
257	257
258	258	m72_audio_device::m72_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
259		: device_t(mconfig, M72, "M72 Custom", tag, owner, clock),
	259	: device_t(mconfig, M72, "M72 Custom", tag, owner, clock, "m72_audio", __FILE__),
260	260	device_sound_interface(mconfig, *this)
261	261	{
262	262	m_token = global_alloc_clear(m72_audio_state);

trunk/src/mame/audio/exidy440.c

r23830	r23831
992	992	const device_type EXIDY440 = &device_creator<exidy440_sound_device>;
993	993
994	994	exidy440_sound_device::exidy440_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
995		: device_t(mconfig, EXIDY440, "Exidy 440 CVSD", tag, owner, clock),
	995	: device_t(mconfig, EXIDY440, "Exidy 440 CVSD", tag, owner, clock, "exidy440_sound", __FILE__),
996	996	device_sound_interface(mconfig, *this)
997	997	{
998	998	m_token = global_alloc_clear(exidy440_audio_state);

trunk/src/mame/audio/gridlee.c

r23830	r23831
21	21	//-------------------------------------------------
22	22
23	23	gridlee_sound_device::gridlee_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
24		: device_t(mconfig, GRIDLEE, "Gridlee Custom", tag, owner, clock),
	24	: device_t(mconfig, GRIDLEE, "Gridlee Custom", tag, owner, clock, "gridlee_sound", __FILE__),
25	25	device_sound_interface(mconfig, *this),
26	26	m_tone_step(0),
27	27	m_tone_fraction(0),

trunk/src/mame/audio/amiga.c

r23830	r23831
280	280	const device_type AMIGA = &device_creator<amiga_sound_device>;
281	281
282	282	amiga_sound_device::amiga_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
283		: device_t(mconfig, AMIGA, "Amiga Paula", tag, owner, clock),
	283	: device_t(mconfig, AMIGA, "Amiga Paula", tag, owner, clock, "amiga_paula", __FILE__),
284	284	device_sound_interface(mconfig, *this)
285	285	{
286	286	m_token = global_alloc_clear(amiga_audio);

trunk/src/mame/machine/megacdcd.c

r23830	r23831
11	11	const device_type LC89510_TEMP = &device_creator<lc89510_temp_device>;
12	12
13	13	lc89510_temp_device::lc89510_temp_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
14		: device_t(mconfig, LC89510_TEMP, "lc89510_temp_device", tag, owner, clock)
	14	: device_t(mconfig, LC89510_TEMP, "lc89510_temp_device", tag, owner, clock, "lc89510_temp", __FILE__)
15	15	{
16	16	segacd_dma_callback =  segacd_dma_delegate(FUNC(lc89510_temp_device::Fake_CDC_Do_DMA), this);
17	17	type1_interrupt_callback =  interrupt_delegate(FUNC(lc89510_temp_device::dummy_interrupt_callback), this);

trunk/src/mame/machine/cd32.c

r23830	r23831
910	910	const device_type AKIKO = &device_creator<akiko_device>;
911	911
912	912	akiko_device::akiko_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
913		: device_t(mconfig, AKIKO, "Akiko", tag, owner, clock)
	913	: device_t(mconfig, AKIKO, "Akiko", tag, owner, clock, "akiko", __FILE__)
914	914	{
915	915	m_token = global_alloc_clear(akiko_state);
916	916	}

trunk/src/mame/machine/mathbox.c

r23830	r23831
38	38	const device_type MATHBOX = &device_creator<mathbox_device>;
39	39
40	40	mathbox_device::mathbox_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
41		: device_t(mconfig, MATHBOX, "MATHBOX", tag, owner, clock)
	41	: device_t(mconfig, MATHBOX, "MATHBOX", tag, owner, clock, "mathbox", __FILE__)
42	42	{
43	43	}
44	44

trunk/src/mame/machine/kaneko_calc3.c

r23830	r23831
28	28	const device_type KANEKO_CALC3 = &device_creator<kaneko_calc3_device>;
29	29
30	30	kaneko_calc3_device::kaneko_calc3_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
31		: device_t(mconfig, KANEKO_CALC3, "kaneko_calc3_device", tag, owner, clock)
	31	: device_t(mconfig, KANEKO_CALC3, "kaneko_calc3_device", tag, owner, clock, "kaneko_calc3", __FILE__)
32	32	{
33	33	memset(&m_calc3, 0, sizeof m_calc3);
34	34	}

trunk/src/mame/machine/bfm_bd1.c

r23830	r23831
100	100	};
101	101
102	102	bfm_bd1_t::bfm_bd1_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
103		: device_t(mconfig, BFM_BD1, "BFM BD1 VFD controller", tag, owner, clock),
	103	: device_t(mconfig, BFM_BD1, "BFM BD1 VFD controller", tag, owner, clock, "bfm_bd1", __FILE__),
104	104	m_port_val(0)
105	105	{
106	106	}

trunk/src/mame/machine/atari_vg.c

r23830	r23831
16	16	//-------------------------------------------------
17	17
18	18	atari_vg_earom_device::atari_vg_earom_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
19		: device_t(mconfig, ATARIVGEAROM, "ATARI VG EAROM", tag, owner, clock),
	19	: device_t(mconfig, ATARIVGEAROM, "ATARI VG EAROM", tag, owner, clock, "atari_vg_earom", __FILE__),
20	20	device_nvram_interface(mconfig, *this)
21	21	{
22	22	}

trunk/src/mame/machine/taitoio.c

r23830	r23831
55	55	const device_type TC0220IOC = &device_creator<tc0220ioc_device>;
56	56
57	57	tc0220ioc_device::tc0220ioc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
58		: device_t(mconfig, TC0220IOC, "Taito TC0220IOC", tag, owner, clock)
	58	: device_t(mconfig, TC0220IOC, "Taito TC0220IOC", tag, owner, clock, "tc0220ioc", __FILE__)
59	59	{
60	60	}
61	61
r23830	r23831
200	200	const device_type TC0510NIO = &device_creator<tc0510nio_device>;
201	201
202	202	tc0510nio_device::tc0510nio_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
203		: device_t(mconfig, TC0510NIO, "Taito TC0510NIO", tag, owner, clock)
	203	: device_t(mconfig, TC0510NIO, "Taito TC0510NIO", tag, owner, clock, "tc0510nio", __FILE__)
204	204	{
205	205	}
206	206
r23830	r23831
346	346	const device_type TC0640FIO = &device_creator<tc0640fio_device>;
347	347
348	348	tc0640fio_device::tc0640fio_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
349		: device_t(mconfig, TC0640FIO, "Taito TC0640FIO", tag, owner, clock)
	349	: device_t(mconfig, TC0640FIO, "Taito TC0640FIO", tag, owner, clock, "tc0640fio", __FILE__)
350	350	{
351	351	}
352	352

trunk/src/mame/machine/bfm_bda.c

r23830	r23831
82	82	};
83	83
84	84	bfm_bda_t::bfm_bda_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
85		: device_t(mconfig, BFM_BDA, "BFM BDA VFD controller", tag, owner, clock),
	85	: device_t(mconfig, BFM_BDA, "BFM BDA VFD controller", tag, owner, clock, "bfm_bda", __FILE__),
86	86	m_port_val(0)
87	87	{
88	88	}

trunk/src/mame/machine/cdi070.c

r23830	r23831
53	53	//-------------------------------------------------
54	54
55	55	cdi68070_device::cdi68070_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
56		: device_t(mconfig, MACHINE_CDI68070, "CDI68070", tag, owner, clock)
	56	: device_t(mconfig, MACHINE_CDI68070, "CDI68070", tag, owner, clock, "cdi68070", __FILE__)
57	57	{
58	58	}
59	59

trunk/src/mame/machine/mega32x.c

r23830	r23831
214	214	const device_type SEGA_32X_NTSC = &device_creator<sega_32x_ntsc_device>;
215	215	const device_type SEGA_32X_PAL = &device_creator<sega_32x_pal_device>;
216	216
217		sega_32x_device::sega_32x_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type)
218		: device_t(mconfig, type, "sega_32x_device", tag, owner, clock),
	217	sega_32x_device::sega_32x_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type, const char *shortname, const char *source)
	218	: device_t(mconfig, type, "sega_32x_device", tag, owner, clock, shortname, source),
219	219	m_master_cpu(*this, "32x_master_sh2"),
220	220	m_slave_cpu(*this, "32x_slave_sh2"),
221	221	m_lch_pwm(*this, "lch_pwm"),
r23830	r23831
224	224	}
225	225
226	226	sega_32x_ntsc_device::sega_32x_ntsc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
227		: sega_32x_device(mconfig, tag, owner, clock, SEGA_32X_NTSC)
	227	: sega_32x_device(mconfig, tag, owner, clock, SEGA_32X_NTSC, "sega_32x_ntsc", __FILE__)
228	228	{
229	229	}
230	230
231	231	sega_32x_pal_device::sega_32x_pal_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
232		: sega_32x_device(mconfig, tag, owner, clock, SEGA_32X_PAL)
	232	: sega_32x_device(mconfig, tag, owner, clock, SEGA_32X_PAL, "sega_32x_pal", __FILE__)
233	233	{
234	234	}
235	235

trunk/src/mame/machine/mega32x.h

r23830	r23831
25	25	class sega_32x_device : public device_t
26	26	{
27	27	public:
28		sega_32x_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type);
	28	sega_32x_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type, const char *shortname, const char *source);
29	29
30	30	required_device<cpu_device> m_master_cpu;
31	31	required_device<cpu_device> m_slave_cpu;

trunk/src/mame/machine/cdicdic.c

r23830	r23831
1161	1161	//-------------------------------------------------
1162	1162
1163	1163	cdicdic_device::cdicdic_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1164		: device_t(mconfig, MACHINE_CDICDIC, "CDICDIC", tag, owner, clock)
	1164	: device_t(mconfig, MACHINE_CDICDIC, "CDICDIC", tag, owner, clock, "cdicdic", __FILE__)
1165	1165	{
1166	1166	}
1167	1167

trunk/src/mame/machine/cdislave.c

r23830	r23831
417	417	//-------------------------------------------------
418	418
419	419	cdislave_device::cdislave_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
420		: device_t(mconfig, MACHINE_CDISLAVE, "CDISLAVE", tag, owner, clock)
	420	: device_t(mconfig, MACHINE_CDISLAVE, "CDISLAVE", tag, owner, clock, "cdislave", __FILE__)
421	421	{
422	422	}
423	423

trunk/src/mame/machine/decocass_tape.c

r23830	r23831
431	431	const device_type DECOCASS_TAPE = &device_creator<decocass_tape_device>;
432	432
433	433	decocass_tape_device::decocass_tape_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
434		: device_t(mconfig, DECOCASS_TAPE, "DECO Cassette Tape", tag, owner, clock)
	434	: device_t(mconfig, DECOCASS_TAPE, "DECO Cassette Tape", tag, owner, clock, "decocass_tape", __FILE__)
435	435	{
436	436	m_token = global_alloc_clear(tape_state);
437	437	}

trunk/src/mame/machine/n64.c

r23830	r23831
21	21
22	22
23	23	n64_periphs::n64_periphs(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
24		: device_t(mconfig, N64PERIPH, "N64 Periphal Chips", tag, owner, clock)
	24	: device_t(mconfig, N64PERIPH, "N64 Periphal Chips", tag, owner, clock, "n64_periphs", __FILE__)
25	25	, m_nvram_image(NULL)
26	26	{
27	27	}

trunk/src/mame/machine/naomig1.c

r23830	r23831
24	24	ADDRESS_MAP_END
25	25
26	26	naomi_g1_device::naomi_g1_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
27		: device_t(mconfig, type, name, tag, owner, clock),
	27	: device_t(mconfig, type, name, tag, owner, clock, "naomi_g1", __FILE__),
28	28	irq_cb(*this)
29	29	{
30	30	}

trunk/src/mame/machine/nmk112.c

r23830	r23831
18	18	const device_type NMK112 = &device_creator<nmk112_device>;
19	19
20	20	nmk112_device::nmk112_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
21		: device_t(mconfig, NMK112, "NMK 112", tag, owner, clock)
	21	: device_t(mconfig, NMK112, "NMK 112", tag, owner, clock, "nmk112", __FILE__)
22	22	{
23	23	}
24	24

trunk/src/mame/machine/gaelco3d.c

r23830	r23831
498	498	const device_type GAELCO_SERIAL = &device_creator<gaelco_serial_device>;
499	499
500	500	gaelco_serial_device::gaelco_serial_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
501		: device_t(mconfig, GAELCO_SERIAL, "gaelco_serial", tag, owner, clock)
	501	: device_t(mconfig, GAELCO_SERIAL, "gaelco_serial", tag, owner, clock, "gaelco_serial", __FILE__)
502	502	{
503	503	m_token = global_alloc_clear(gaelco_serial_state);
504	504	}

trunk/src/mame/machine/megacd.c

r23830	r23831
22	22	const device_type SEGA_SEGACD_JAPAN = &device_creator<sega_segacd_japan_device>;
23	23	const device_type SEGA_SEGACD_EUROPE = &device_creator<sega_segacd_europe_device>;
24	24
25		sega_segacd_device::sega_segacd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type)
26		: device_t(mconfig, type, "sega_segacd_device", tag, owner, clock),
	25	sega_segacd_device::sega_segacd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type, const char *shortname, const char *source)
	26	: device_t(mconfig, type, "sega_segacd_device", tag, owner, clock, shortname, source),
27	27	m_scdcpu(*this, "segacd_68k")
28	28	{
29	29	}
30	30
31	31	sega_segacd_us_device::sega_segacd_us_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
32		: sega_segacd_device(mconfig, tag, owner, clock, SEGA_SEGACD_US)
	32	: sega_segacd_device(mconfig, tag, owner, clock, SEGA_SEGACD_US, "sega_segacd_us", __FILE__)
33	33	{
34	34	}
35	35
36	36	sega_segacd_japan_device::sega_segacd_japan_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
37		: sega_segacd_device(mconfig, tag, owner, clock, SEGA_SEGACD_JAPAN)
	37	: sega_segacd_device(mconfig, tag, owner, clock, SEGA_SEGACD_JAPAN, "sega_segacd_japan", __FILE__)
38	38	{
39	39	}
40	40
41	41	sega_segacd_europe_device::sega_segacd_europe_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
42		: sega_segacd_device(mconfig, tag, owner, clock, SEGA_SEGACD_EUROPE)
	42	: sega_segacd_device(mconfig, tag, owner, clock, SEGA_SEGACD_EUROPE, "sega_segacd_europe", __FILE__)
43	43	{
44	44	}
45	45

trunk/src/mame/machine/megacd.h

r23830	r23831
198	198	class sega_segacd_device : public device_t
199	199	{
200	200	public:
201		sega_segacd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type);
	201	sega_segacd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type, const char *shortname, const char *source);
202	202
203	203	required_device<cpu_device> m_scdcpu;
204	204	lc89510_temp_device *lc89510_temp;

trunk/src/mame/machine/ns11prot.c

r23830	r23831
5	5
6	6	#include "ns11prot.h"
7	7
8		ns11_keycus_device::ns11_keycus_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock) :
9		device_t(mconfig, type, name, tag, owner, clock)
	8	ns11_keycus_device::ns11_keycus_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source) :
	9	device_t(mconfig, type, name, tag, owner, clock, shortname, source)
10	10	{
11	11	}
12	12
r23830	r23831
27	27	/* tekken 2 */
28	28
29	29	keycus_c406_device::keycus_c406_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
30		ns11_keycus_device(mconfig, KEYCUS_C406, "KEYCUS C406", tag, owner, clock)
	30	ns11_keycus_device(mconfig, KEYCUS_C406, "KEYCUS C406", tag, owner, clock, "keycus_c406", __FILE__)
31	31	{
32	32	}
33	33
r23830	r23831
67	67	/* soul edge */
68	68
69	69	keycus_c409_device::keycus_c409_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
70		ns11_keycus_device(mconfig, KEYCUS_C409, "KEYCUS C409", tag, owner, clock)
	70	ns11_keycus_device(mconfig, KEYCUS_C409, "KEYCUS C409", tag, owner, clock, "keycus_c409", __FILE__)
71	71	{
72	72	}
73	73
r23830	r23831
107	107	/* dunk mania */
108	108
109	109	keycus_c410_device::keycus_c410_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
110		ns11_keycus_device(mconfig, KEYCUS_C410, "KEYCUS C410", tag, owner, clock)
	110	ns11_keycus_device(mconfig, KEYCUS_C410, "KEYCUS C410", tag, owner, clock, "keycus_c410", __FILE__)
111	111	{
112	112	}
113	113
r23830	r23831
161	161	/* prime goal ex */
162	162
163	163	keycus_c411_device::keycus_c411_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
164		ns11_keycus_device(mconfig, KEYCUS_C411, "KEYCUS C411", tag, owner, clock)
	164	ns11_keycus_device(mconfig, KEYCUS_C411, "KEYCUS C411", tag, owner, clock, "keycus_c411", __FILE__)
165	165	{
166	166	}
167	167
r23830	r23831
217	217	/* xevious 3d/g */
218	218
219	219	keycus_c430_device::keycus_c430_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
220		ns11_keycus_device(mconfig, KEYCUS_C430, "KEYCUS C430", tag, owner, clock)
	220	ns11_keycus_device(mconfig, KEYCUS_C430, "KEYCUS C430", tag, owner, clock, "keycus_c430", __FILE__)
221	221	{
222	222	}
223	223
r23830	r23831
276	276	/* dancing eyes */
277	277
278	278	keycus_c431_device::keycus_c431_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
279		ns11_keycus_device(mconfig, KEYCUS_C431, "KEYCUS C431", tag, owner, clock)
	279	ns11_keycus_device(mconfig, KEYCUS_C431, "KEYCUS C431", tag, owner, clock, "keycus_c431", __FILE__)
280	280	{
281	281	}
282	282
r23830	r23831
334	334	/* pocket racer */
335	335
336	336	keycus_c432_device::keycus_c432_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
337		ns11_keycus_device(mconfig, KEYCUS_C432, "KEYCUS C432", tag, owner, clock)
	337	ns11_keycus_device(mconfig, KEYCUS_C432, "KEYCUS C432", tag, owner, clock, "keycus_c432", __FILE__)
338	338	{
339	339	}
340	340
r23830	r23831
394	394	/* star sweep */
395	395
396	396	keycus_c442_device::keycus_c442_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
397		ns11_keycus_device(mconfig, KEYCUS_C442, "KEYCUS C442", tag, owner, clock)
	397	ns11_keycus_device(mconfig, KEYCUS_C442, "KEYCUS C442", tag, owner, clock, "keycus_c442", __FILE__)
398	398	{
399	399	}
400	400
r23830	r23831
442	442	/* kosodate quiz my angel 3 / point blank 2 */
443	443
444	444	keycus_c443_device::keycus_c443_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
445		ns11_keycus_device(mconfig, KEYCUS_C443, "KEYCUS C443", tag, owner, clock)
	445	ns11_keycus_device(mconfig, KEYCUS_C443, "KEYCUS C443", tag, owner, clock, "keycus_c443", __FILE__)
446	446	{
447	447	}
448	448

trunk/src/mame/machine/ns11prot.h

r23830	r23831
8	8	class ns11_keycus_device : public device_t
9	9	{
10	10	protected:
11		ns11_keycus_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	11	ns11_keycus_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock,const char *shortname, const char *source);
12	12
13	13	virtual void device_start();
14	14	virtual void device_reset();

trunk/src/mame/machine/segaic16.c

r23830	r23831
202	202	//-------------------------------------------------
203	203
204	204	sega_315_5195_mapper_device::sega_315_5195_mapper_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
205		: device_t(mconfig, SEGA_315_5195_MEM_MAPPER, "Sega 315-5195 Memory Mapper", tag, owner, clock),
	205	: device_t(mconfig, SEGA_315_5195_MEM_MAPPER, "Sega 315-5195 Memory Mapper", tag, owner, clock, "sega_315_5195", __FILE__),
206	206	m_cputag(NULL),
207	207	m_cpu(NULL),
208	208	m_space(NULL),
r23830	r23831
742	742	//-------------------------------------------------
743	743
744	744	sega_315_5248_multiplier_device::sega_315_5248_multiplier_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
745		: device_t(mconfig, SEGA_315_5248_MULTIPLIER, "Sega 315-5248 Multiplier", tag, owner, clock)
	745	: device_t(mconfig, SEGA_315_5248_MULTIPLIER, "Sega 315-5248 Multiplier", tag, owner, clock, "sega_315_5248", __FILE__)
746	746	{
747	747	}
748	748
r23830	r23831
810	810	//-------------------------------------------------
811	811
812	812	sega_315_5249_divider_device::sega_315_5249_divider_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
813		: device_t(mconfig, SEGA_315_5248_MULTIPLIER, "Sega 315-5249 Divider", tag, owner, clock)
	813	: device_t(mconfig, SEGA_315_5248_MULTIPLIER, "Sega 315-5249 Divider", tag, owner, clock, "sega_315_5249", __FILE__)
814	814	{
815	815	}
816	816
r23830	r23831
955	955	//-------------------------------------------------
956	956
957	957	sega_315_5250_compare_timer_device::sega_315_5250_compare_timer_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
958		: device_t(mconfig, SEGA_315_5250_COMPARE_TIMER, "Sega 315-5250 Compare/Timer", tag, owner, clock)
	958	: device_t(mconfig, SEGA_315_5250_COMPARE_TIMER, "Sega 315-5250 Compare/Timer", tag, owner, clock, "sega_315_5250", __FILE__)
959	959	{
960	960	}
961	961

trunk/src/mame/machine/buggychl.c

r23830	r23831
237	237	const device_type BUGGYCHL_MCU = &device_creator<buggychl_mcu_device>;
238	238
239	239	buggychl_mcu_device::buggychl_mcu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
240		: device_t(mconfig, BUGGYCHL_MCU, "BuggyChl MCU", tag, owner, clock)
	240	: device_t(mconfig, BUGGYCHL_MCU, "BuggyChl MCU", tag, owner, clock, "buggychl_mcu", __FILE__)
241	241	{
242	242	m_token = global_alloc_clear(buggychl_mcu_state);
243	243	}

trunk/src/mame/machine/kaneko_hit.c

r23830	r23831
29	29	const device_type KANEKO_HIT = &device_creator<kaneko_hit_device>;
30	30
31	31	kaneko_hit_device::kaneko_hit_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
32		: device_t(mconfig, KANEKO_HIT, "kaneko_hit_device", tag, owner, clock)
	32	: device_t(mconfig, KANEKO_HIT, "kaneko_hit_device", tag, owner, clock, "kaneko_hit", __FILE__)
33	33	{
34	34	m_hittype = -1;
35	35	memset(&m_hit, 0, sizeof m_hit);

trunk/src/mame/machine/maple-dc.c

r23830	r23831
26	26	}
27	27
28	28	maple_dc_device::maple_dc_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
29		: device_t(mconfig, MAPLE_DC, "MAPLE_DC", tag, owner, clock)
	29	: device_t(mconfig, MAPLE_DC, "MAPLE_DC", tag, owner, clock, "maple_dc", __FILE__)
30	30	{
31	31	// Do not move that in device_start or there will be a race
32	32	// condition with the maple devices call to register_port.

trunk/src/mame/machine/ticket.c

r23830	r23831
68	68	//-------------------------------------------------
69	69
70	70	ticket_dispenser_device::ticket_dispenser_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
71		: device_t(mconfig, TICKET_DISPENSER, "Ticket Dispenser", tag, owner, clock),
	71	: device_t(mconfig, TICKET_DISPENSER, "Ticket Dispenser", tag, owner, clock, "ticket_dispenser", __FILE__),
72	72	m_motor_sense(TICKET_MOTOR_ACTIVE_LOW),
73	73	m_status_sense(TICKET_STATUS_ACTIVE_LOW),
74	74	m_period(attotime::from_msec(100)),

trunk/src/mame/machine/kaneko_toybox.c

r23830	r23831
52	52	const device_type KANEKO_TOYBOX = &device_creator<kaneko_toybox_device>;
53	53
54	54	kaneko_toybox_device::kaneko_toybox_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
55		: device_t(mconfig, KANEKO_TOYBOX, "kaneko_toybox_device", tag, owner, clock)
	55	: device_t(mconfig, KANEKO_TOYBOX, "kaneko_toybox_device", tag, owner, clock, "kaneko_toybox", __FILE__)
56	56	{
57	57	m_tabletype = TABLE_NORMAL;
58	58	m_gametype = GAME_NORMAL;

trunk/src/mame/includes/tx1.h

r23830	r23831
230	230	{
231	231	public:
232	232	tx1_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
233		tx1_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	233	tx1_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
234	234	~tx1_sound_device() { global_free(m_token); }
235	235
236	236	// access to legacy token

trunk/src/mame/includes/leland.h

r23830	r23831
203	203	{
204	204	public:
205	205	leland_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
206		leland_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	206	leland_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
207	207	~leland_sound_device() { global_free(m_token); }
208	208
209	209	// access to legacy token
r23830	r23831
226	226	{
227	227	public:
228	228	leland_80186_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
229		leland_80186_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	229	leland_80186_sound_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
230	230	protected:
231	231	// device-level overrides
232	232	virtual void device_config_complete();

trunk/src/mame/video/taitoic.c

r23830	r23831
549	549	const device_type PC080SN = &device_creator<pc080sn_device>;
550	550
551	551	pc080sn_device::pc080sn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
552		: device_t(mconfig, PC080SN, "Taito PC080SN", tag, owner, clock)
	552	: device_t(mconfig, PC080SN, "Taito PC080SN", tag, owner, clock, "pc080sn", __FILE__)
553	553	{
554	554	}
555	555
r23830	r23831
1005	1005	const device_type PC090OJ = &device_creator<pc090oj_device>;
1006	1006
1007	1007	pc090oj_device::pc090oj_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1008		: device_t(mconfig, PC090OJ, "Taito PC090OJ", tag, owner, clock)
	1008	: device_t(mconfig, PC090OJ, "Taito PC090OJ", tag, owner, clock, "pc090oj", __FILE__)
1009	1009	{
1010	1010	}
1011	1011
r23830	r23831
1176	1176	const device_type TC0080VCO = &device_creator<tc0080vco_device>;
1177	1177
1178	1178	tc0080vco_device::tc0080vco_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1179		: device_t(mconfig, TC0080VCO, "Taito TC0080VCO", tag, owner, clock)
	1179	: device_t(mconfig, TC0080VCO, "Taito TC0080VCO", tag, owner, clock, "tc0080vco", __FILE__)
1180	1180	{
1181	1181	}
1182	1182
r23830	r23831
1810	1810	const device_type TC0100SCN = &device_creator<tc0100scn_device>;
1811	1811
1812	1812	tc0100scn_device::tc0100scn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1813		: device_t(mconfig, TC0100SCN, "Taito TC0100SCN", tag, owner, clock)
	1813	: device_t(mconfig, TC0100SCN, "Taito TC0100SCN", tag, owner, clock, "tc0100scn", __FILE__)
1814	1814	{
1815	1815	}
1816	1816
r23830	r23831
2522	2522	const device_type TC0280GRD = &device_creator<tc0280grd_device>;
2523	2523
2524	2524	tc0280grd_device::tc0280grd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2525		: device_t(mconfig, TC0280GRD, "Taito TC0280GRD & TC0430GRW", tag, owner, clock)
	2525	: device_t(mconfig, TC0280GRD, "Taito TC0280GRD & TC0430GRW", tag, owner, clock, "tc0280grd", __FILE__)
2526	2526	{
2527	2527	m_token = global_alloc_clear(tc0280grd_state);
2528	2528	}
r23830	r23831
2643	2643	const device_type TC0360PRI = &device_creator<tc0360pri_device>;
2644	2644
2645	2645	tc0360pri_device::tc0360pri_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2646		: device_t(mconfig, TC0360PRI, "Taito TC0360PRI", tag, owner, clock)
	2646	: device_t(mconfig, TC0360PRI, "Taito TC0360PRI", tag, owner, clock, "tc0360pri", __FILE__)
2647	2647	{
2648	2648	m_token = global_alloc_clear(tc0360pri_state);
2649	2649	}
r23830	r23831
3527	3527	const device_type TC0480SCP = &device_creator<tc0480scp_device>;
3528	3528
3529	3529	tc0480scp_device::tc0480scp_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
3530		: device_t(mconfig, TC0480SCP, "Taito TC0480SCP", tag, owner, clock)
	3530	: device_t(mconfig, TC0480SCP, "Taito TC0480SCP", tag, owner, clock, "tc0480scp", __FILE__)
3531	3531	{
3532	3532	m_token = global_alloc_clear(tc0480scp_state);
3533	3533	}
r23830	r23831
4471	4471	const device_type TC0150ROD = &device_creator<tc0150rod_device>;
4472	4472
4473	4473	tc0150rod_device::tc0150rod_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
4474		: device_t(mconfig, TC0150ROD, "Taito TC0150ROD", tag, owner, clock)
	4474	: device_t(mconfig, TC0150ROD, "Taito TC0150ROD", tag, owner, clock, "tc0150rod", __FILE__)
4475	4475	{
4476	4476	m_token = global_alloc_clear(tc0150rod_state);
4477	4477	}
r23830	r23831
4698	4698	const device_type TC0110PCR = &device_creator<tc0110pcr_device>;
4699	4699
4700	4700	tc0110pcr_device::tc0110pcr_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
4701		: device_t(mconfig, TC0110PCR, "Taito TC0110PCR", tag, owner, clock)
	4701	: device_t(mconfig, TC0110PCR, "Taito TC0110PCR", tag, owner, clock, "tc0110pcr", __FILE__)
4702	4702	{
4703	4703	m_token = global_alloc_clear(tc0110pcr_state);
4704	4704	}
r23830	r23831
5043	5043	const device_type TC0180VCU = &device_creator<tc0180vcu_device>;
5044	5044
5045	5045	tc0180vcu_device::tc0180vcu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
5046		: device_t(mconfig, TC0180VCU, "Taito TC0180VCU", tag, owner, clock)
	5046	: device_t(mconfig, TC0180VCU, "Taito TC0180VCU", tag, owner, clock, "tc0180vcu", __FILE__)
5047	5047	{
5048	5048	m_token = global_alloc_clear(tc0180vcu_state);
5049	5049	}

trunk/src/mame/video/decospr.c

r23830	r23831
160	160	const device_type DECO_SPRITE = &device_creator<decospr_device>;
161	161
162	162	decospr_device::decospr_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
163		: device_t(mconfig, DECO_SPRITE, "decospr_device", tag, owner, clock),
	163	: device_t(mconfig, DECO_SPRITE, "decospr_device", tag, owner, clock, "decospr", __FILE__),
164	164	m_gfxregion(0),
165	165	m_pricallback(NULL),
166	166	m_colcallback(decospr_default_colour_callback),

trunk/src/mame/video/kaneko_grap2.c

r23830	r23831
15	15	const device_type KANEKO_GRAP2 = &device_creator<kaneko_grap2_device>;
16	16
17	17	kaneko_grap2_device::kaneko_grap2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
18		: device_t(mconfig, KANEKO_GRAP2, "kaneko_grap2_device", tag, owner, clock)
	18	: device_t(mconfig, KANEKO_GRAP2, "kaneko_grap2_device", tag, owner, clock, "kaneko_grap2", __FILE__)
19	19	{
20	20	m_chipnum = 0;
21	21	}

trunk/src/mame/video/deckarn.c

r23830	r23831
13	13	const device_type DECO_KARNOVSPRITES = &device_creator<deco_karnovsprites_device>;
14	14
15	15	deco_karnovsprites_device::deco_karnovsprites_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
16		: device_t(mconfig, DECO_KARNOVSPRITES, "karnovsprites_device", tag, owner, clock),
	16	: device_t(mconfig, DECO_KARNOVSPRITES, "karnovsprites_device", tag, owner, clock, "deco_karnovsprites", __FILE__),
17	17	m_gfxregion(0)
18	18	{
19	19	}

trunk/src/mame/video/powervr2.c

r23830	r23831
2982	2982	}
2983	2983
2984	2984	powervr2_device::powervr2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2985		: device_t(mconfig, POWERVR2, "PowerVR 2", tag, owner, clock),
	2985	: device_t(mconfig, POWERVR2, "PowerVR 2", tag, owner, clock, "powervr2", __FILE__),
2986	2986	irq_cb(*this)
2987	2987	{
2988	2988	}

trunk/src/mame/video/decbac06.c

r23830	r23831
74	74	const device_type DECO_BAC06 = &device_creator<deco_bac06_device>;
75	75
76	76	deco_bac06_device::deco_bac06_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
77		: device_t(mconfig, DECO_BAC06, "decbac06_device", tag, owner, clock),
	77	: device_t(mconfig, DECO_BAC06, "decbac06_device", tag, owner, clock, "deco_bac06", __FILE__),
78	78	m_gfxregion8x8(0),
79	79	m_gfxregion16x16(0),
80	80	m_wide(0)

trunk/src/mame/video/seta001.c

r23830	r23831
30	30	const device_type SETA001_SPRITE = &device_creator<seta001_device>;
31	31
32	32	seta001_device::seta001_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
33		: device_t(mconfig, SETA001_SPRITE, "seta001_device", tag, owner, clock)
	33	: device_t(mconfig, SETA001_SPRITE, "seta001_device", tag, owner, clock, "seta001", __FILE__)
34	34	{
35	35	}
36	36

trunk/src/mame/video/vsystem_spr.c

r23830	r23831
70	70	const device_type VSYSTEM_SPR = &device_creator<vsystem_spr_device>;
71	71
72	72	vsystem_spr_device::vsystem_spr_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
73		: device_t(mconfig, VSYSTEM_SPR, "vsystem_spr_device", tag, owner, clock)
	73	: device_t(mconfig, VSYSTEM_SPR, "vsystem_spr_device", tag, owner, clock, "vsystem_spr", __FILE__)
74	74	{
75	75	m_transpen = 15;
76	76	m_pal_base = 0;

trunk/src/mame/video/vsystem_spr2.c

r23830	r23831
28	28	const device_type VSYSTEM_SPR2 = &device_creator<vsystem_spr2_device>;
29	29
30	30	vsystem_spr2_device::vsystem_spr2_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
31		: device_t(mconfig, VSYSTEM_SPR2, "vsystem_spr2_device", tag, owner, clock)
	31	: device_t(mconfig, VSYSTEM_SPR2, "vsystem_spr2_device", tag, owner, clock, "vsystem_spr2", __FILE__)
32	32	{
33	33	m_newtilecb =  vsystem_tile2_indirection_delegate(FUNC(vsystem_spr2_device::tile_callback_noindirect), this);
34	34	m_pritype = 0; // hack until we have better handling

trunk/src/mame/video/gp9001.c

r23830	r23831
203	203	const device_type GP9001_VDP = &device_creator<gp9001vdp_device>;
204	204
205	205	gp9001vdp_device::gp9001vdp_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
206		: device_t(mconfig, GP9001_VDP, "GP9001_VDP", tag, owner, clock),
	206	: device_t(mconfig, GP9001_VDP, "GP9001_VDP", tag, owner, clock, "gp9001vdp", __FILE__),
207	207	device_memory_interface(mconfig, *this),
208	208	m_space_config("gp9001vdp", ENDIANNESS_BIG, 16,14, 0, NULL, *ADDRESS_MAP_NAME(gp9001vdp_map)),
209	209	m_gfxregion(0)

trunk/src/mame/video/mcd212.c

r23830	r23831
1509	1509	//-------------------------------------------------
1510	1510
1511	1511	mcd212_device::mcd212_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1512		: device_t(mconfig, MACHINE_MCD212, "MCD212", tag, owner, clock)
	1512	: device_t(mconfig, MACHINE_MCD212, "MCD212", tag, owner, clock, "mcd212", __FILE__)
1513	1513	{
1514	1514	}
1515	1515

trunk/src/mame/video/segaic24.c

r23830	r23831
22	22
23	23
24	24	segas24_tile::segas24_tile(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
25		: device_t(mconfig, S24TILE, "S24TILE", tag, owner, clock)
	25	: device_t(mconfig, S24TILE, "S24TILE", tag, owner, clock, "segas24_tile", __FILE__)
26	26	{
27	27	}
28	28
r23830	r23831
577	577
578	578
579	579	segas24_sprite::segas24_sprite(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
580		: device_t(mconfig, S24SPRITE, "S24SPRITE", tag, owner, clock)
	580	: device_t(mconfig, S24SPRITE, "S24SPRITE", tag, owner, clock, "segas24_sprite", __FILE__)
581	581	{
582	582	}
583	583
r23830	r23831
822	822
823	823
824	824	segas24_mixer::segas24_mixer(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
825		: device_t(mconfig, S24MIXER, "S24MIXER", tag, owner, clock)
	825	: device_t(mconfig, S24MIXER, "S24MIXER", tag, owner, clock, "segas24_mixer", __FILE__)
826	826	{
827	827	}
828	828

trunk/src/mame/video/st0020.c

r23830	r23831
13	13	const device_type ST0020_SPRITES = &device_creator<st0020_device>;
14	14
15	15	st0020_device::st0020_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
16		: device_t(mconfig, ST0020_SPRITES, "st0020_device", tag, owner, clock)
	16	: device_t(mconfig, ST0020_SPRITES, "st0020_device", tag, owner, clock, "st0020", __FILE__)
17	17	{
18	18	m_is_st0032 = 0;
19	19	m_is_jclub2 = 0;

trunk/src/mame/video/atarirle.c

r23830	r23831
370	370	const device_type ATARIRLE = &device_creator<atarirle_device>;
371	371
372	372	atarirle_device::atarirle_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
373		: device_t(mconfig, ATARIRLE, "Atari RLE", tag, owner, clock)
	373	: device_t(mconfig, ATARIRLE, "Atari RLE", tag, owner, clock, "atari_rle", __FILE__)
374	374	{
375	375	m_token = global_alloc_clear(atarirle_data);
376	376	}

trunk/src/mame/video/tia.c

r23830	r23831
170	170	//-------------------------------------------------
171	171
172	172	tia_video_device::tia_video_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
173		: device_t(mconfig, TIA_VIDEO, "TIA Video", tag, owner, clock)
	173	: device_t(mconfig, TIA_VIDEO, "TIA Video", tag, owner, clock, "tia_video", __FILE__)
174	174	{
175	175	}
176	176

trunk/src/mame/video/ppu2c0x.c

r23830	r23831
126	126	m_screen_tag = config->screen_tag;
127	127	}
128	128
129		ppu2c0x_device::ppu2c0x_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
130		: device_t(mconfig, type, name, tag, owner, clock),
	129	ppu2c0x_device::ppu2c0x_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source)
	130	: device_t(mconfig, type, name, tag, owner, clock, shortname, source),
131	131	device_memory_interface(mconfig, *this),
132	132	m_space_config("videoram", ENDIANNESS_LITTLE, 8, 17, 0, NULL, *ADDRESS_MAP_NAME(ppu2c0x)),
133	133	m_scanline(0),  // reset the scanline count
r23830	r23831
159	159
160	160
161	161	// NTSC NES
162		ppu2c02_device::ppu2c02_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C02, "2C02 PPU", tag, owner, clock)
	162	ppu2c02_device::ppu2c02_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C02, "2C02 PPU", tag, owner, clock, "ppu2c02", __FILE__)
163	163	{
164	164	}
165	165
166	166	// Playchoice 10
167		ppu2c03b_device::ppu2c03b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C03B, "2C03B PPU PPU", tag, owner, clock)
	167	ppu2c03b_device::ppu2c03b_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C03B, "2C03B PPU PPU", tag, owner, clock, "ppu2c03b", __FILE__)
168	168	{
169	169	}
170	170
171	171	// Vs. Unisystem
172		ppu2c04_device::ppu2c04_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C04, "2C04 PPU", tag, owner, clock)
	172	ppu2c04_device::ppu2c04_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C04, "2C04 PPU", tag, owner, clock, "ppu2c04", __FILE__)
173	173	{
174	174	}
175	175
176	176	// PAL NES
177		ppu2c07_device::ppu2c07_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C07, "2C07 PPU", tag, owner, clock)
	177	ppu2c07_device::ppu2c07_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C07, "2C07 PPU", tag, owner, clock, "ppu2c07", __FILE__)
178	178	{
179	179	m_scanlines_per_frame = PPU_PAL_SCANLINES_PER_FRAME;
180	180	}
181	181
182	182	// The PPU_2C05 variants have different protection value, set at DEVICE_START, but otherwise are all the same...
183	183	// Vs. Unisystem (Ninja Jajamaru Kun)
184		ppu2c05_01_device::ppu2c05_01_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_01, "2C05 PPU", tag, owner, clock)
	184	ppu2c05_01_device::ppu2c05_01_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_01, "2C05 PPU", tag, owner, clock, "ppu2c05_01", __FILE__)
185	185	{
186	186	m_security_value = 0x1b;    // game (jajamaru) doesn't seem to ever actually check it
187	187	}
188	188	// Vs. Unisystem (Mighty Bomb Jack)
189		ppu2c05_02_device::ppu2c05_02_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_02, "2C05 PPU", tag, owner, clock)
	189	ppu2c05_02_device::ppu2c05_02_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_02, "2C05 PPU", tag, owner, clock, "ppu2c05_02", __FILE__)
190	190	{
191	191	m_security_value = 0x3d;
192	192	}
193	193	// Vs. Unisystem (Gumshoe)
194		ppu2c05_03_device::ppu2c05_03_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_03, "2C05 PPU", tag, owner, clock)
	194	ppu2c05_03_device::ppu2c05_03_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_03, "2C05 PPU", tag, owner, clock, "ppu2c05_03", __FILE__)
195	195	{
196	196	m_security_value = 0x1c;
197	197	}
198	198	// Vs. Unisystem (Top Gun)
199		ppu2c05_04_device::ppu2c05_04_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_04, "2C05 PPU", tag, owner, clock)
	199	ppu2c05_04_device::ppu2c05_04_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : ppu2c0x_device(mconfig, PPU_2C05_04, "2C05 PPU", tag, owner, clock, "ppu2c05_04", __FILE__)
200	200	{
201	201	m_security_value = 0x1b;
202	202	}

trunk/src/mame/video/ppu2c0x.h

r23830	r23831
133	133	{
134	134	public:
135	135	// construction/destruction
136		ppu2c0x_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
	136	ppu2c0x_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
137	137
138	138	DECLARE_READ8_MEMBER( read );
139	139	DECLARE_WRITE8_MEMBER( write );

trunk/src/mame/video/deco16ic.c

r23830	r23831
899	899	const device_type DECO16IC = &device_creator<deco16ic_device>;
900	900
901	901	deco16ic_device::deco16ic_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
902		: device_t(mconfig, DECO16IC, "Data East IC 55 / 56 / 74 / 141", tag, owner, clock)
	902	: device_t(mconfig, DECO16IC, "Data East IC 55 / 56 / 74 / 141", tag, owner, clock, "deco16ic", __FILE__)
903	903	{
904	904	m_token = global_alloc_clear(deco16ic_state);
905	905	}

trunk/src/mame/video/decocomn.c

r23830	r23831
142	142	const device_type DECOCOMN = &device_creator<decocomn_device>;
143	143
144	144	decocomn_device::decocomn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
145		: device_t(mconfig, DECOCOMN, "Data East Common Video Functions", tag, owner, clock)
	145	: device_t(mconfig, DECOCOMN, "Data East Common Video Functions", tag, owner, clock, "decocomn", __FILE__)
146	146	{
147	147	m_token = global_alloc_clear(decocomn_state);
148	148	}

trunk/src/mame/video/vrender0.c

r23830	r23831
602	602	const device_type VIDEO_VRENDER0 = &device_creator<vr0video_device>;
603	603
604	604	vr0video_device::vr0video_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
605		: device_t(mconfig, VIDEO_VRENDER0, "VRender0", tag, owner, clock)
	605	: device_t(mconfig, VIDEO_VRENDER0, "VRender0", tag, owner, clock, "vr0video", __FILE__)
606	606	{
607	607	m_token = global_alloc_clear(vr0video_state);
608	608	}

trunk/src/mame/video/kaneko_spr.c

r23830	r23831
30	30	const device_type KANEKO_KC002_SPRITE = &device_creator<kaneko_kc002_sprite_device>;
31	31
32	32	kaneko16_sprite_device::kaneko16_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, device_type type)
33		: device_t(mconfig, type, "kaneko16_sprite_device", tag, owner, clock)
	33	: device_t(mconfig, type, "kaneko16_sprite_device", tag, owner, clock, "kaneko16_sprite", __FILE__)
34	34	{
35	35	m_keep_sprites = 0; // default disabled for games not using it
36	36

trunk/src/mame/video/sknsspr.c

r23830	r23831
20	20
21	21
22	22	sknsspr_device::sknsspr_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
23		: device_t(mconfig, SKNS_SPRITE, "sknsspr_device", tag, owner, clock)
	23	: device_t(mconfig, SKNS_SPRITE, "sknsspr_device", tag, owner, clock, "sknsspr", __FILE__)
24	24	{
25	25	}
26	26

trunk/src/mame/video/scn2674.c

r23830	r23831
34	34
35	35
36	36	scn2674_device::scn2674_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
37		: device_t(mconfig, SCN2674_VIDEO, "scn2674_device", tag, owner, clock),
	37	: device_t(mconfig, SCN2674_VIDEO, "scn2674_device", tag, owner, clock, "scn2674_device", __FILE__),
38	38	m_interrupt_callback(*this)
39	39	{
40	40	}

trunk/src/mame/video/decmxc06.c

r23830	r23831
48	48	const device_type DECO_MXC06 = &device_creator<deco_mxc06_device>;
49	49
50	50	deco_mxc06_device::deco_mxc06_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
51		: device_t(mconfig, DECO_MXC06, "decmxc06_device", tag, owner, clock),
	51	: device_t(mconfig, DECO_MXC06, "decmxc06_device", tag, owner, clock, "deco_mxc06", __FILE__),
52	52	m_gfxregion(0)
53	53	{
54	54	}

trunk/src/mame/video/kaneko_tmap.c

r23830	r23831
95	95	const device_type KANEKO_TMAP = &device_creator<kaneko_view2_tilemap_device>;
96	96
97	97	kaneko_view2_tilemap_device::kaneko_view2_tilemap_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
98		: device_t(mconfig, KANEKO_TMAP, "kaneko_view2_tilemap_device", tag, owner, clock)
	98	: device_t(mconfig, KANEKO_TMAP, "kaneko_view2_tilemap_device", tag, owner, clock, "kaneko_view2_tilemap", __FILE__)
99	99	{
100	100	m_invert_flip = 0;
101	101	}

trunk/src/mame/video/kan_pand.c

r23830	r23831
53	53	const device_type KANEKO_PANDORA = &device_creator<kaneko_pandora_device>;
54	54
55	55	kaneko_pandora_device::kaneko_pandora_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
56		: device_t(mconfig, KANEKO_PANDORA, "Kaneko Pandora - PX79C480FP-3", tag, owner, clock)
	56	: device_t(mconfig, KANEKO_PANDORA, "Kaneko Pandora - PX79C480FP-3", tag, owner, clock, "kaneko_pandora", __FILE__)
57	57	{
58	58	}
59	59

trunk/src/mame/video/konicdev.c

r23830	r23831
1578	1578	const device_type K007121 = &device_creator<k007121_device>;
1579	1579
1580	1580	k007121_device::k007121_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1581		: device_t(mconfig, K007121, "Konami 007121", tag, owner, clock)
	1581	: device_t(mconfig, K007121, "Konami 007121", tag, owner, clock, "k007121", __FILE__)
1582	1582	{
1583	1583	m_token = global_alloc_clear(k007121_state);
1584	1584	}
r23830	r23831
1851	1851	const device_type K007342 = &device_creator<k007342_device>;
1852	1852
1853	1853	k007342_device::k007342_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1854		: device_t(mconfig, K007342, "Konami 007342", tag, owner, clock)
	1854	: device_t(mconfig, K007342, "Konami 007342", tag, owner, clock, "k007342", __FILE__)
1855	1855	{
1856	1856	m_token = global_alloc_clear(k007342_state);
1857	1857	}
r23830	r23831
2184	2184	const device_type K007420 = &device_creator<k007420_device>;
2185	2185
2186	2186	k007420_device::k007420_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2187		: device_t(mconfig, K007420, "Konami 007420", tag, owner, clock)
	2187	: device_t(mconfig, K007420, "Konami 007420", tag, owner, clock, "k007420", __FILE__)
2188	2188	{
2189	2189	m_token = global_alloc_clear(k007420_state);
2190	2190	}
r23830	r23831
2755	2755	const device_type K052109 = &device_creator<k052109_device>;
2756	2756
2757	2757	k052109_device::k052109_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2758		: device_t(mconfig, K052109, "Konami 052109", tag, owner, clock)
	2758	: device_t(mconfig, K052109, "Konami 052109", tag, owner, clock, "k052109", __FILE__)
2759	2759	{
2760	2760	m_token = global_alloc_clear(k052109_state);
2761	2761	}
r23830	r23831
3425	3425	const device_type K051960 = &device_creator<k051960_device>;
3426	3426
3427	3427	k051960_device::k051960_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
3428		: device_t(mconfig, K051960, "Konami 051960", tag, owner, clock)
	3428	: device_t(mconfig, K051960, "Konami 051960", tag, owner, clock, "k051960", __FILE__)
3429	3429	{
3430	3430	m_token = global_alloc_clear(k051960_state);
3431	3431	}
r23830	r23831
4256	4256	const device_type K053244 = &device_creator<k05324x_device>;
4257	4257
4258	4258	k05324x_device::k05324x_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
4259		: device_t(mconfig, K053244, "Konami 053244 & 053245", tag, owner, clock)
	4259	: device_t(mconfig, K053244, "Konami 053244 & 053245", tag, owner, clock, "k05324x", __FILE__)
4260	4260	{
4261	4261	m_token = global_alloc_clear(k05324x_state);
4262	4262	}
r23830	r23831
5268	5268	const device_type K055673 = &device_creator<k055673_device>;
5269	5269
5270	5270	k055673_device::k055673_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
5271		: device_t(mconfig, K055673, "Konami 055673", tag, owner, clock)
	5271	: device_t(mconfig, K055673, "Konami 055673", tag, owner, clock, "k055673", __FILE__)
5272	5272	{
5273	5273	m_token = global_alloc_clear(k053247_state);
5274	5274	}
r23830	r23831
5304	5304	const device_type K053246 = &device_creator<k053247_device>;
5305	5305
5306	5306	k053247_device::k053247_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
5307		: device_t(mconfig, K053246, "Konami 053246 & 053247", tag, owner, clock)
	5307	: device_t(mconfig, K053246, "Konami 053246 & 053247", tag, owner, clock, "k053247", __FILE__)
5308	5308	{
5309	5309	m_token = global_alloc_clear(k053247_state);
5310	5310	}
r23830	r23831
5537	5537	const device_type K051316 = &device_creator<k051316_device>;
5538	5538
5539	5539	k051316_device::k051316_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
5540		: device_t(mconfig, K051316, "Konami 051316", tag, owner, clock)
	5540	: device_t(mconfig, K051316, "Konami 051316", tag, owner, clock, "k051316", __FILE__)
5541	5541	{
5542	5542	m_token = global_alloc_clear(k051316_state);
5543	5543	}
r23830	r23831
5910	5910	const device_type K053936 = &device_creator<k053936_device>;
5911	5911
5912	5912	k053936_device::k053936_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
5913		: device_t(mconfig, K053936, "Konami 053936", tag, owner, clock)
	5913	: device_t(mconfig, K053936, "Konami 053936", tag, owner, clock, "k053936", __FILE__)
5914	5914	{
5915	5915	m_token = global_alloc_clear(k053936_state);
5916	5916	}
r23830	r23831
6101	6101	const device_type K053251 = &device_creator<k053251_device>;
6102	6102
6103	6103	k053251_device::k053251_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
6104		: device_t(mconfig, K053251, "Konami 053251", tag, owner, clock)
	6104	: device_t(mconfig, K053251, "Konami 053251", tag, owner, clock, "k053251", __FILE__)
6105	6105	{
6106	6106	m_token = global_alloc_clear(k053251_state);
6107	6107	}
r23830	r23831
6246	6246	const device_type K054000 = &device_creator<k054000_device>;
6247	6247
6248	6248	k054000_device::k054000_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
6249		: device_t(mconfig, K054000, "Konami 054000", tag, owner, clock)
	6249	: device_t(mconfig, K054000, "Konami 054000", tag, owner, clock, "k054000", __FILE__)
6250	6250	{
6251	6251	m_token = global_alloc_clear(k054000_state);
6252	6252	}
r23830	r23831
6434	6434	const device_type K051733 = &device_creator<k051733_device>;
6435	6435
6436	6436	k051733_device::k051733_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
6437		: device_t(mconfig, K051733, "Konami 051733", tag, owner, clock)
	6437	: device_t(mconfig, K051733, "Konami 051733", tag, owner, clock, "k051733", __FILE__)
6438	6438	{
6439	6439	m_token = global_alloc_clear(k051733_state);
6440	6440	}
r23830	r23831
8181	8181	const device_type K056832 = &device_creator<k056832_device>;
8182	8182
8183	8183	k056832_device::k056832_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
8184		: device_t(mconfig, K056832, "Konami 056832", tag, owner, clock)
	8184	: device_t(mconfig, K056832, "Konami 056832", tag, owner, clock, "k056832", __FILE__)
8185	8185	{
8186	8186	m_token = global_alloc_clear(k056832_state);
8187	8187	}
r23830	r23831
8571	8571	const device_type K055555 = &device_creator<k055555_device>;
8572	8572
8573	8573	k055555_device::k055555_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
8574		: device_t(mconfig, K055555, "Konami 055555", tag, owner, clock)
	8574	: device_t(mconfig, K055555, "Konami 055555", tag, owner, clock, "k055555", __FILE__)
8575	8575	{
8576	8576	m_token = global_alloc_clear(k055555_state);
8577	8577	}
r23830	r23831
8909	8909	const device_type K054338 = &device_creator<k054338_device>;
8910	8910
8911	8911	k054338_device::k054338_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
8912		: device_t(mconfig, K054338, "Konami 054338", tag, owner, clock)
	8912	: device_t(mconfig, K054338, "Konami 054338", tag, owner, clock, "k054338", __FILE__)
8913	8913	{
8914	8914	m_token = global_alloc_clear(k054338_state);
8915	8915	}
r23830	r23831
9120	9120	const device_type K001006 = &device_creator<k001006_device>;
9121	9121
9122	9122	k001006_device::k001006_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
9123		: device_t(mconfig, K001006, "Konami 001006", tag, owner, clock)
	9123	: device_t(mconfig, K001006, "Konami 001006", tag, owner, clock, "k001006", __FILE__)
9124	9124	{
9125	9125	m_token = global_alloc_clear(k001006_state);
9126	9126	}
r23830	r23831
10082	10082	const device_type K001005 = &device_creator<k001005_device>;
10083	10083
10084	10084	k001005_device::k001005_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
10085		: device_t(mconfig, K001005, "Konami 001005", tag, owner, clock)
	10085	: device_t(mconfig, K001005, "Konami 001005", tag, owner, clock, "k001005", __FILE__)
10086	10086	{
10087	10087	m_token = global_alloc_clear(k001005_state);
10088	10088	}
r23830	r23831
10519	10519	const device_type K001604 = &device_creator<k001604_device>;
10520	10520
10521	10521	k001604_device::k001604_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
10522		: device_t(mconfig, K001604, "Konami 001604", tag, owner, clock)
	10522	: device_t(mconfig, K001604, "Konami 001604", tag, owner, clock, "k001604", __FILE__)
10523	10523	{
10524	10524	m_token = global_alloc_clear(k001604_state);
10525	10525	}
r23830	r23831
10809	10809	const device_type K037122 = &device_creator<k037122_device>;
10810	10810
10811	10811	k037122_device::k037122_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
10812		: device_t(mconfig, K037122, "Konami 0371222", tag, owner, clock)
	10812	: device_t(mconfig, K037122, "Konami 0371222", tag, owner, clock, "k037122", __FILE__)
10813	10813	{
10814	10814	m_token = global_alloc_clear(k037122_state);
10815	10815	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team